16 #define SWIG_name_d "plplot_octave" 17 #define SWIG_name plplot_octave 19 #define SWIG_global_name "cvar" 20 #define SWIG_op_prefix "op_" 25 template<
typename T>
class SwigValueWrapper {
26 struct SwigMovePointer {
28 SwigMovePointer(T *p) : ptr(p) { }
29 ~SwigMovePointer() {
delete ptr; }
30 SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0;
delete oldptr; ptr = rhs.ptr; rhs.ptr = 0;
return *
this; }
32 SwigValueWrapper& operator=(
const SwigValueWrapper<T>& rhs);
33 SwigValueWrapper(
const SwigValueWrapper<T>& rhs);
35 SwigValueWrapper() : pointer(0) { }
36 SwigValueWrapper& operator=(
const T& t) { SwigMovePointer tmp(
new T(t)); pointer = tmp;
return *
this; }
37 operator T&()
const {
return *pointer.ptr; }
38 T *operator&() {
return pointer.ptr; }
41 template <
typename T> T SwigValueInit() {
52 #ifndef SWIGTEMPLATEDISAMBIGUATOR 53 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) 54 # define SWIGTEMPLATEDISAMBIGUATOR template 55 # elif defined(__HP_aCC) 58 # define SWIGTEMPLATEDISAMBIGUATOR template 60 # define SWIGTEMPLATEDISAMBIGUATOR 66 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) 67 # define SWIGINLINE inline 75 # if defined(__GNUC__) 76 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) 77 # define SWIGUNUSED __attribute__ ((__unused__)) 82 # define SWIGUNUSED __attribute__ ((__unused__)) 88 #ifndef SWIG_MSC_UNSUPPRESS_4505 89 # if defined(_MSC_VER) 90 # pragma warning(disable : 4505) 94 #ifndef SWIGUNUSEDPARM 96 # define SWIGUNUSEDPARM(p) 98 # define SWIGUNUSEDPARM(p) p SWIGUNUSED 104 # define SWIGINTERN static SWIGUNUSED 108 #ifndef SWIGINTERNINLINE 109 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE 113 #if defined(__GNUC__) 114 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) 115 # ifndef GCC_HASCLASSVISIBILITY 116 # define GCC_HASCLASSVISIBILITY 122 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) 123 # if defined(STATIC_LINKED) 126 # define SWIGEXPORT __declspec(dllexport) 129 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) 130 # define SWIGEXPORT __attribute__ ((visibility("default"))) 139 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) 140 # define SWIGSTDCALL __stdcall 147 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) 148 # define _CRT_SECURE_NO_DEPRECATE 152 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) 153 # define _SCL_SECURE_NO_DEPRECATE 157 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) 158 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 166 #ifdef __INTEL_COMPILER 167 # pragma warning disable 592 175 #include <octave/oct.h> 176 #include <octave/version.h> 180 #define SWIG_OCTAVE_PREREQ(major, minor, patch) \ 181 ( (OCTAVE_MAJOR_VERSION<<16) + (OCTAVE_MINOR_VERSION<<8) + (OCTAVE_PATCH_VERSION + 0) >= ((major)<<16) + ((minor)<<8) + (patch) ) 184 #if !defined(OCTAVE_MAJOR_VERSION) 186 # if !defined(OCTAVE_API_VERSION_NUMBER) 190 # include <octave/ov.h> 191 # if defined(octave_ov_h) 192 # define OCTAVE_MAJOR_VERSION 3 193 # define OCTAVE_MINOR_VERSION 8 194 # define OCTAVE_PATCH_VERSION 0 198 # define ComplexLU __ignore 199 # include <octave/CmplxLU.h> 201 # if defined(octave_Complex_LU_h) 204 # define OCTAVE_MAJOR_VERSION 3 205 # define OCTAVE_MINOR_VERSION 1 206 # define OCTAVE_PATCH_VERSION 99 211 # define OCTAVE_MAJOR_VERSION 3 212 # define OCTAVE_MINOR_VERSION 2 213 # define OCTAVE_PATCH_VERSION 0 215 # endif // defined(octave_Complex_LU_h) 217 # endif // defined(octave_ov_h) 221 # elif OCTAVE_API_VERSION_NUMBER >= 48 222 # define OCTAVE_MAJOR_VERSION 3 223 # define OCTAVE_MINOR_VERSION 6 224 # define OCTAVE_PATCH_VERSION 0 226 # elif OCTAVE_API_VERSION_NUMBER >= 45 227 # define OCTAVE_MAJOR_VERSION 3 228 # define OCTAVE_MINOR_VERSION 4 229 # define OCTAVE_PATCH_VERSION 1 231 # elif OCTAVE_API_VERSION_NUMBER >= 42 232 # define OCTAVE_MAJOR_VERSION 3 233 # define OCTAVE_MINOR_VERSION 3 234 # define OCTAVE_PATCH_VERSION 54 236 # elif OCTAVE_API_VERSION_NUMBER >= 41 237 # define OCTAVE_MAJOR_VERSION 3 238 # define OCTAVE_MINOR_VERSION 3 239 # define OCTAVE_PATCH_VERSION 53 241 # elif OCTAVE_API_VERSION_NUMBER >= 40 242 # define OCTAVE_MAJOR_VERSION 3 243 # define OCTAVE_MINOR_VERSION 3 244 # define OCTAVE_PATCH_VERSION 52 246 # elif OCTAVE_API_VERSION_NUMBER >= 39 247 # define OCTAVE_MAJOR_VERSION 3 248 # define OCTAVE_MINOR_VERSION 3 249 # define OCTAVE_PATCH_VERSION 51 251 # else // OCTAVE_API_VERSION_NUMBER == 38 252 # define OCTAVE_MAJOR_VERSION 3 253 # define OCTAVE_MINOR_VERSION 3 254 # define OCTAVE_PATCH_VERSION 50 256 # endif // !defined(OCTAVE_API_VERSION_NUMBER) 258 #endif // !defined(OCTAVE_MAJOR_VERSION) 260 #include <octave/Cell.h> 261 #include <octave/dynamic-ld.h> 262 #include <octave/oct-env.h> 263 #include <octave/oct-map.h> 264 #include <octave/ov-scalar.h> 265 #include <octave/ov-fcn-handle.h> 266 #include <octave/parse.h> 267 #if SWIG_OCTAVE_PREREQ(4,2,0) 268 #include <octave/interpreter.h> 270 #include <octave/toplev.h> 272 #include <octave/unwind-prot.h> 273 #if SWIG_OCTAVE_PREREQ(4,2,0) 274 #include <octave/call-stack.h> 287 #define SWIG_RUNTIME_VERSION "4" 290 #ifdef SWIG_TYPE_TABLE 291 # define SWIG_QUOTE_STRING(x) #x 292 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) 293 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) 295 # define SWIG_TYPE_TABLE_NAME 308 # define SWIGRUNTIME SWIGINTERN 311 #ifndef SWIGRUNTIMEINLINE 312 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE 316 #ifndef SWIG_BUFFER_SIZE 317 # define SWIG_BUFFER_SIZE 1024 321 #define SWIG_POINTER_DISOWN 0x1 322 #define SWIG_CAST_NEW_MEMORY 0x2 325 #define SWIG_POINTER_OWN 0x1 408 #define SWIG_ERROR (-1) 409 #define SWIG_IsOK(r) (r >= 0) 410 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) 413 #define SWIG_CASTRANKLIMIT (1 << 8) 415 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) 417 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) 419 #define SWIG_BADOBJ (SWIG_ERROR) 420 #define SWIG_OLDOBJ (SWIG_OK) 421 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) 422 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) 424 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) 425 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) 426 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) 427 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) 428 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) 429 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) 432 #if defined(SWIG_CASTRANK_MODE) 433 # ifndef SWIG_TypeRank 434 # define SWIG_TypeRank unsigned long 436 # ifndef SWIG_MAXCASTRANK 437 # define SWIG_MAXCASTRANK (2) 439 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) 440 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) 445 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
448 # define SWIG_AddCast(r) (r) 449 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) 459 typedef void *(*swig_converter_func)(
void *,
int *);
501 const char *f2,
const char *l2) {
502 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
503 while ((*f1 ==
' ') && (f1 != l1)) ++f1;
504 while ((*f2 ==
' ') && (f2 != l2)) ++f2;
505 if (*f1 != *f2)
return (*f1 > *f2) ? 1 : -1;
507 return (
int)((l1 - f1) - (l2 - f2));
517 const char* te = tb + strlen(tb);
519 while (equiv != 0 && *ne) {
520 for (nb = ne; *ne; ++ne) {
521 if (*ne ==
'|')
break;
546 if (strcmp(iter->
type->
name, c) == 0) {
547 if (iter == ty->
cast)
573 if (iter->
type == from) {
574 if (iter == ty->
cast)
606 if (!ty || !ty->
dcast)
return ty;
607 while (ty && (ty->
dcast)) {
608 ty = (*ty->
dcast)(ptr);
632 if (!type)
return NULL;
633 if (type->
str != NULL) {
634 const char *last_name = type->
str;
636 for (s = type->
str; *s; s++)
637 if (*s ==
'|') last_name = s+1;
685 size_t r = iter->
size - 1;
688 size_t i = (l + r) >> 1;
689 const char *iname = iter->
types[i]->
name;
691 int compare = strcmp(name, iname);
693 return iter->
types[i];
694 }
else if (compare < 0) {
700 }
else if (compare > 0) {
709 }
while (iter != end);
736 for (; i < iter->
size; ++i) {
738 return iter->
types[i];
741 }
while (iter != end);
753 static const char hex[17] =
"0123456789abcdef";
754 const unsigned char *u = (
unsigned char *) ptr;
755 const unsigned char *eu = u + sz;
756 for (; u != eu; ++u) {
757 unsigned char uu = *u;
758 *(c++) = hex[(uu & 0xf0) >> 4];
759 *(c++) = hex[uu & 0xf];
769 unsigned char *u = (
unsigned char *) ptr;
770 const unsigned char *eu = u + sz;
771 for (; u != eu; ++u) {
774 if ((d >=
'0') && (d <=
'9'))
775 uu = (
unsigned char)((d -
'0') << 4);
776 else if ((d >=
'a') && (d <=
'f'))
777 uu = (
unsigned char)((d - (
'a'-10)) << 4);
781 if ((d >=
'0') && (d <=
'9'))
782 uu |= (
unsigned char)(d -
'0');
783 else if ((d >=
'a') && (d <=
'f'))
784 uu |= (
unsigned char)(d - (
'a'-10));
798 if ((2*
sizeof(
void *) + 2) > bsz)
return 0;
801 if (strlen(name) + 1 > (bsz - (r - buff)))
return 0;
809 if (strcmp(c,
"NULL") == 0) {
822 size_t lname = (name ? strlen(name) : 0);
823 if ((2*sz + 2 + lname) > bsz)
return 0;
827 strncpy(r,name,lname+1);
837 if (strcmp(c,
"NULL") == 0) {
852 #define SWIG_UnknownError -1 853 #define SWIG_IOError -2 854 #define SWIG_RuntimeError -3 855 #define SWIG_IndexError -4 856 #define SWIG_TypeError -5 857 #define SWIG_DivisionByZero -6 858 #define SWIG_OverflowError -7 859 #define SWIG_SyntaxError -8 860 #define SWIG_ValueError -9 861 #define SWIG_SystemError -10 862 #define SWIG_AttributeError -11 863 #define SWIG_MemoryError -12 864 #define SWIG_NullReferenceError -13 868 #if !SWIG_OCTAVE_PREREQ(3,2,0) 869 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc) 871 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc) 875 if (num_args > max_args && !varargs)
876 error(
"function %s takes at most %i arguments", func_name, max_args);
877 else if (num_args < min_args)
878 error(
"function %s requires at least %i arguments", func_name, min_args);
892 return "SWIG_MemoryError";
894 return "SWIG_IOError";
896 return "SWIG_RuntimeError";
898 return "SWIG_IndexError";
900 return "SWIG_TypeError";
902 return "SWIG_DivisionByZero";
904 return "SWIG_OverflowError";
906 return "SWIG_SyntaxError";
908 return "SWIG_ValueError";
910 return "SWIG_SystemError";
912 return "SWIG_AttributeError";
914 return "SWIG unknown error";
920 r +=
" (" + type.string_value() +
")";
922 return octave_value(r);
925 #define SWIG_fail goto fail 927 #define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0) 928 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags) 929 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own) 930 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags) 931 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags) 932 #define swig_owntype int 934 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty) 935 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type) 937 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0) 938 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0) 940 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty) 941 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type) 943 #define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata) 944 #define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer); 945 #define SWIG_MODULE_CLIENTDATA_TYPE void* 947 #define Octave_Error_Occurred() 0 948 #define SWIG_Octave_AddErrorMsg(msg) {;} 954 #define SWIG_POINTER_EXCEPTION 0 955 #define SWIG_arg_fail(arg) 0 963 typedef octave_value_list(*
octave_func) (
const octave_value_list &, int);
968 #ifdef SWIG_DIRECTORS 972 typedef std::map < void *, Director * > rtdir_map;
989 #ifdef SWIG_DIRECTORS 990 SWIGRUNTIME void swig_acquire_ownership(
void *vptr);
991 SWIGRUNTIME void swig_acquire_ownership_array(
void *vptr);
992 SWIGRUNTIME void swig_acquire_ownership_obj(
void *vptr,
int own);
1021 #if SWIG_OCTAVE_PREREQ(4,4,0) 1024 #define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(new octave_swig_bound_func(func, args)) 1025 class octave_swig_bound_func :
public octave_function {
1028 octave_swig_bound_func(
void) : octave_function(), method(0), first_args()
1031 octave_swig_bound_func(octave_function* _method, octave_value_list _first_args)
1032 : octave_function(
"",
""), method(_method), first_args(_first_args)
1035 octave_swig_bound_func(
const octave_swig_bound_func& f) =
delete;
1037 octave_swig_bound_func& operator= (
const octave_swig_bound_func& f) =
delete;
1039 ~octave_swig_bound_func(
void) =
default;
1041 bool is_function(
void)
const {
return true; }
1043 octave_function* function_value(
bool =
false) {
return this; }
1045 octave_value_list call(octave::tree_evaluator& tw,
int nargout = 0,
const octave_value_list& args = octave_value_list()) {
1046 octave_value_list all_args;
1047 all_args.append(first_args);
1048 all_args.append(args);
1049 return method->call(tw, nargout, all_args);
1052 octave_value subsref(
const std::string &ops,
const std::list < octave_value_list > &idx) {
1053 octave_value_list ovl = subsref(ops, idx, 1);
1054 return ovl.length() ? ovl(0) : octave_value();
1057 octave_value_list subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout) {
1058 assert(ops.size() > 0);
1059 assert(ops.size() == idx.size());
1061 error(
"invalid function call");
1062 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1063 return call(tw, nargout, *idx.begin());
1068 octave_function* method;
1069 octave_value_list first_args;
1071 std::set<std::string> dispatch_classes;
1075 DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
1079 #define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(func) 1114 if (m->name == name)
1125 if ((m = find_member(c->
base[j], name)))
1132 member_map::iterator it = members.find(name);
1133 if (it != members.end())
1136 for (
unsigned int j = 0; j < types.size(); ++j)
1137 if ((m = find_member(types[j].first, name)))
1138 return &members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
1139 if (!insert_if_not_found)
1141 return &members[
name];
1146 for (
unsigned int j = 0; j < types.size(); ++j) {
1147 assert(types[j].first->clientdata);
1149 if (cj->
name == name)
1150 return types[j].first;
1167 if (cj->
name == name)
1175 if (out.find(m->name) == out.end())
1176 out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1190 load_members(cj,out);
1196 for (
unsigned int j = 0; j < types.size(); ++j)
1197 if (types[j].first->clientdata)
1201 octave_value_list
member_invoke(member_value_pair *m,
const octave_value_list &args,
int nargout) {
1202 if (m->second.is_defined())
1203 return m->second.subsref(
"(", std::list < octave_value_list > (1, args), nargout);
1204 else if (m->first && m->first->method)
1205 return m->first->method(args, nargout);
1206 error(
"member not defined or not invocable");
1207 return octave_value_list();
1212 member_value_pair *m = nc_this->
find_member(symbol,
false);
1213 if (!m || m->first->is_static() || m->first->is_global())
1215 octave_value_list args;
1217 octave_value_list argout(nc_this->
member_invoke(m, args, 1));
1218 if (argout.length() < 1)
1226 member_value_pair *m = nc_this->
find_member(symbol,
false);
1227 if (!m || m->first->is_static() || m->first->is_global())
1229 octave_value_list args;
1231 args.append(make_value_hack(rhs));
1232 octave_value_list argout(nc_this->
member_invoke(m, args, 1));
1233 if (argout.length() < 1)
1241 member_value_pair *m = nc_this->
find_member(symbol,
false);
1242 if (!m || m->first->is_static() || m->first->is_global())
1244 octave_value_list args;
1247 octave_value_list argout(nc_this->
member_invoke(m, args, 1));
1248 if (argout.length() >= 1)
1253 octave_value_list
member_deref(member_value_pair *m,
const octave_value_list &args) {
1254 if (m->second.is_defined()) {
1255 if (m->second.is_function() || m->second.is_function_handle()) {
1260 }
else if (m->first) {
1261 if (m->first->get_method)
1262 return m->first->get_method(args, 1);
1263 else if (m->first->method)
1266 error(
"undefined member");
1267 return octave_value_list();
1272 return octave_value((octave_base_value *) &x);
1280 bool _always_static =
false)
1281 : module(0), construct_type(_ptr ? 0 : _type), own(_own),
1282 always_static(_always_static) {
1284 types.push_back(std::make_pair(_type, _ptr));
1285 #ifdef SWIG_DIRECTORS 1287 Swig::Director *d = Swig::get_rtdir(_ptr);
1289 Swig::swig_director_set_self(d,
this);
1297 for (
unsigned int j = 0; j < types.size(); ++j) {
1298 if (!types[j].first || !types[j].first->clientdata)
1301 if (c->
destructor && !types[j].second.destroyed && types[j].second.ptr) {
1306 #ifdef SWIG_DIRECTORS 1307 for (
unsigned int j = 0; j < types.size(); ++j)
1308 Swig::erase_rtdir(types[j].second.ptr);
1314 if (!dispatch_unary_op(
"__dims__", out))
1315 return dim_vector(1,1);
1318 #if SWIG_OCTAVE_PREREQ(4,4,0) 1321 if (out.is_cell()) {
1323 const Cell & c=out.cell_value();
1324 int ndim = c.rows();
1325 if (ndim==1 && c.columns()!=1) ndim = c.columns();
1328 d.resize(ndim < 2 ? 2 : ndim);
1332 for (
int k=0;k<ndim;k++) {
1333 const octave_value& obj = c(k);
1334 d.elem(k) = obj.int_value();
1337 if (error_state)
return dim_vector(1,1);
1340 #if SWIG_OCTAVE_PREREQ(4,4,0) 1341 }
else if (out.is_matrix_type() || out.isnumeric() ) {
1343 }
else if (out.is_matrix_type() || out.is_numeric_type() ) {
1345 if (out.rows()==1 || out.columns()==1) {
1346 Array<int> a = out.int_vector_value();
1347 if (error_state)
return dim_vector(1,1);
1349 d.resize(a.numel() < 2 ? 2 : a.numel());
1351 for (
int k=0;k<a.numel();k++) {
1356 return dim_vector(1,1);
1359 return dim_vector(1,1);
1380 return (
long) types[0].second.ptr;
1385 if (!types[0].first->clientdata)
1395 for (
unsigned int j = 0; j < types.size(); ++j) {
1398 if (types[j].first->clientdata) {
1402 ret += types[j].first->name;
1409 for (
unsigned int j = 0; j < rhs.
types.size(); ++j) {
1410 assert(!rhs.
types[j].second.destroyed);
1411 #ifdef SWIG_DIRECTORS 1412 Swig::Director *d = Swig::get_rtdir(rhs.
types[j].second.ptr);
1414 Swig::swig_director_set_self(d,
this);
1417 types.insert(types.end(), rhs.
types.begin(), rhs.
types.end());
1419 #if SWIG_OCTAVE_PREREQ(4,4,0) 1437 if (!type && types.size()) {
1439 *vptr = types[0].second.ptr;
1442 for (
unsigned int j = 0; j < types.size(); ++j)
1443 if (type == types[j].first) {
1445 *vptr = types[j].second.ptr;
1448 for (
unsigned int j = 0; j < types.size(); ++j) {
1471 #ifdef SWIG_DIRECTORS 1472 void director_destroyed(Swig::Director *d) {
1474 for (
unsigned int j = 0; j < types.size(); ++j) {
1475 Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1477 types[j].second.destroyed =
true;
1490 members[
name] = std::make_pair(m, octave_value());
1514 octave_value_list ovl = subsref(ops, idx, 1);
1515 return ovl.length()? ovl(0) : octave_value();
1518 virtual octave_value_list
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout) {
1519 assert(ops.size() > 0);
1520 assert(ops.size() == idx.size());
1522 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1524 octave_value_list sub_ovl;
1527 if (ops[skip] ==
'(' && construct_type) {
1531 error(
"cannot create instance");
1532 return octave_value_list();
1534 octave_value_list args;
1537 args.append(*idx_it++);
1542 else if (ops[skip] ==
'.') {
1546 octave_value_list subname_ovl(*idx_it++);
1548 assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1549 subname = subname_ovl(0).string_value();
1552 if (!next_base || skip >= (
int) ops.size() || ops[skip] !=
'.')
1557 member_value_pair tmp, *m = &tmp;
1558 if (!base || !(m->first = find_member(base, subname)))
1559 m = find_member(subname,
false);
1561 error(
"member not found");
1562 return octave_value_list();
1565 octave_value_list args;
1566 if (!always_static &&
1567 (!m->first || (!m->first->is_static() && !m->first->is_global())))
1568 args.append(as_value());
1569 if (skip < (
int) ops.size() && ops[skip] ==
'(' &&
1570 ((m->first && m->first->method) || m->second.is_function() ||
1571 m->second.is_function_handle())) {
1572 args.append(*idx_it++);
1574 sub_ovl = member_invoke(m, args, nargout);
1576 sub_ovl = member_deref(m, args);
1581 if (ops[skip] ==
'(' || ops[skip] ==
'{') {
1582 const char *op_name = ops[skip] ==
'(' ?
"__paren__" :
"__brace__";
1583 octave_value_list args;
1584 args.append(*idx_it++);
1586 if (!dispatch_index_op(op_name, args, sub_ovl)) {
1587 error(
"error evaluating index operator");
1588 return octave_value_list();
1591 error(
"unsupported subsref");
1592 return octave_value_list();
1596 if (skip >= (
int) ops.size())
1598 if (sub_ovl.length() < 1) {
1599 error(
"bad subs ref");
1600 return octave_value_list();
1602 return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1605 octave_value
subsasgn(
const std::string &ops,
const std::list < octave_value_list > &idx,
const octave_value &rhs) {
1606 assert(ops.size() > 0);
1607 assert(ops.size() == idx.size());
1609 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1612 if (ops.size() > 1) {
1613 std::list < octave_value_list >::const_iterator last = idx.end();
1615 std::list < octave_value_list > next_idx(idx.begin(), last);
1616 octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
1617 next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1620 else if (ops[skip] ==
'(' || ops[skip] ==
'{') {
1621 const char *op_name = ops[skip] ==
'(' ?
"__paren_asgn__" :
"__brace_asgn__";
1622 member_value_pair *m = find_member(op_name,
false);
1624 octave_value_list args;
1625 args.append(as_value());
1626 args.append(*idx_it);
1628 member_invoke(m, args, 1);
1630 error(
"%s member not found", op_name);
1633 else if (ops[skip] ==
'.') {
1634 octave_value_list subname_ovl(*idx_it++);
1636 assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1637 std::string subname = subname_ovl(0).string_value();
1639 member_value_pair *m = find_member(subname,
true);
1640 if (!m->first || !m->first->set_method) {
1643 }
else if (m->first->set_method) {
1644 octave_value_list args;
1645 if (!m->first->is_static() && !m->first->is_global())
1646 args.append(as_value());
1648 m->first->set_method(args, 1);
1650 error(
"member not assignable");
1652 error(
"unsupported subsasgn");
1668 if (!dispatch_unary_op(
"__str__", ret)) {
1669 error(
"__str__ method not defined");
1672 if (!ret.is_string()) {
1673 error(
"__str__ method did not return a string");
1676 return ret.string_value();
1681 if (!dispatch_unary_op(
"__float__", ret)) {
1682 error(
"__float__ method not defined");
1684 return ret.scalar_value();
1687 #if SWIG_OCTAVE_PREREQ(4,2,0) 1688 virtual octave_value as_double(
void)
const {
1690 if (!dispatch_unary_op(
"__float__", ret)) {
1691 error(
"__float__ method not defined");
1693 return ret.as_double();
1696 virtual octave_value as_single(
void)
const {
1698 if (!dispatch_unary_op(
"__float__", ret)) {
1699 error(
"__float__ method not defined");
1701 return ret.as_single();
1705 #if SWIG_OCTAVE_PREREQ(3,8,0) 1706 virtual octave_value map(octave_base_value::unary_mapper_t umap)
const {
1709 if (!dispatch_unary_op(opname, ret)) {
1711 return octave_value();
1717 #if SWIG_OCTAVE_PREREQ(3,3,52) 1718 virtual octave_map map_value()
const {
1719 return octave_map();
1723 return Octave_map();
1731 string_vector keys(tmp.size());
1733 for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1734 keys(k++) = it->first;
1752 oct_mach_info::float_format fmt) {
1756 #if defined (HAVE_HDF5) 1757 # if SWIG_OCTAVE_PREREQ(4,0,0) 1759 save_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool save_as_floats) {
1764 load_hdf5 (octave_hdf5_id loc_id,
const char *name,
bool have_h5giterate_bug) {
1769 save_hdf5 (hid_t loc_id,
const char *name,
bool save_as_floats) {
1774 load_hdf5 (hid_t loc_id,
const char *name,
bool have_h5giterate_bug) {
1780 virtual octave_value
convert_to_str(
bool pad =
false,
bool force =
false,
char type =
'"')
const {
1781 return string_value();
1785 return string_value();
1792 octave_function *fcn = is_valid_function(symbol,
std::string(),
false);
1795 #if SWIG_OCTAVE_PREREQ(4,4,0) 1796 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1797 octave_value_list retval = fcn->call(tw, 1, args);
1798 if (retval.length() == 1)
1801 ret = fcn->do_multi_index_op(1, args)(0);
1814 octave_value_list args;
1815 args.append(make_value_hack(x));
1816 if (dispatch_global_op(symbol, args, ret))
1819 error(
"could not dispatch unary operator");
1820 return octave_value();
1823 static octave_value
dispatch_binary_op(
const octave_base_value &lhs,
const octave_base_value &rhs,
const char *op_name) {
1831 if (strlen(op_name) == 2 && (op_name[1] ==
't' || op_name[1] ==
'e')) {
1842 octave_value_list args;
1843 args.append(make_value_hack(lhs));
1844 args.append(make_value_hack(rhs));
1852 if (dispatch_global_op(symbol, args, ret))
1861 if (dispatch_global_op(symbol, args, ret))
1870 if (dispatch_global_op(symbol, args, ret))
1873 error(
"could not dispatch binary operator");
1874 return octave_value();
1877 #if SWIG_OCTAVE_PREREQ(4,0,0) 1878 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
1880 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
1884 os << string_value();
1892 os <<
"{"; newline(os);
1893 increment_indent_level();
1894 for (
unsigned int j = 0; j < types.size(); ++j) {
1896 if (types[j].first->clientdata) {
1898 os << c->
name <<
", ptr = " << types[j].second.ptr; newline(os);
1900 os << types[j].first->name <<
", ptr = " << types[j].second.ptr; newline(os);
1903 for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
1905 if (it->second.first) {
1906 const char *objtype = it->second.first->method ?
"method" :
"variable";
1907 const char *modifier = (it->second.first->flags &1) ?
"static " : (it->second.first->flags &2) ?
"global " :
"";
1908 os << it->second.first->name <<
" (" << modifier << objtype <<
")"; newline(os);
1909 assert(it->second.first->name == it->first);
1911 os << it->first; newline(os);
1914 decrement_indent_level();
1916 os <<
"}"; newline(os);
1939 {
if (ptr) ptr->
decref(); }
1951 {
return ptr->
dims(); }
1957 {
return ptr->
is_map(); }
1960 {
return ptr->
subsref(ops, idx); }
1962 virtual octave_value_list
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout)
1963 {
return ptr->
subsref(ops, idx, nargout); }
1965 octave_value
subsasgn(
const std::string &ops,
const std::list < octave_value_list > &idx,
const octave_value &rhs)
1966 {
return ptr->
subsasgn(ops, idx, rhs); }
1980 #if SWIG_OCTAVE_PREREQ(4,2,0) 1981 virtual octave_value as_double(
void)
const 1982 {
return ptr->as_double(); }
1984 virtual octave_value as_single(
void)
const 1985 {
return ptr->as_single(); }
1988 #if SWIG_OCTAVE_PREREQ(3,8,0) 1989 virtual octave_value map(octave_base_value::unary_mapper_t umap)
const 1990 {
return ptr->map(umap); }
1993 #if SWIG_OCTAVE_PREREQ(3,3,52) 1994 virtual octave_map map_value()
const 2014 oct_mach_info::float_format fmt)
2017 #if defined (HAVE_HDF5) 2018 # if SWIG_OCTAVE_PREREQ(4,0,0) 2020 save_hdf5 (octave_hdf5_id loc_id,
const char *name,
bool save_as_floats)
2021 {
return ptr->save_hdf5(loc_id, name, save_as_floats); }
2024 load_hdf5 (octave_hdf5_id loc_id,
const char *name,
bool have_h5giterate_bug)
2025 {
return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2028 save_hdf5 (hid_t loc_id,
const char *name,
bool save_as_floats)
2029 {
return ptr->save_hdf5(loc_id, name, save_as_floats); }
2032 load_hdf5 (hid_t loc_id,
const char *name,
bool have_h5giterate_bug)
2033 {
return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2037 virtual octave_value
convert_to_str(
bool pad =
false,
bool force =
false,
char type =
'"')
const 2043 #if SWIG_OCTAVE_PREREQ(4,0,0) 2044 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
2046 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
2048 {
return ptr->
print(os, pr_as_read_syntax); }
2051 return octave_base_value::type_conv_info (default_numeric_conversion_function,
2052 octave_scalar::static_type_id ());
2061 #if !SWIG_OCTAVE_PREREQ(4,0,0) 2066 #if !SWIG_OCTAVE_PREREQ(4,0,0) 2077 : type(_type), buf((const char*)_buf, (const char*)_buf + _buf_len) {
2081 if (outtype && outtype != type)
2083 assert(sz <= buf.size());
2084 std::copy(buf.begin(), buf.begin()+sz, (
char*)ptr);
2100 #if SWIG_OCTAVE_PREREQ(4,0,0) 2101 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
2103 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
2107 os <<
"swig packed type: name = " << (type ? type->
name :
std::string()) <<
", len = " << buf.size(); newline(os);
2124 oct_mach_info::float_format fmt) {
2128 #if defined (HAVE_HDF5) 2129 # if SWIG_OCTAVE_PREREQ(4,0,0) 2131 save_hdf5 (octave_hdf5_id loc_id,
const char *name,
bool save_as_floats) {
2136 load_hdf5 (octave_hdf5_id loc_id,
const char *name,
bool have_h5giterate_bug) {
2141 save_hdf5 (hid_t loc_id,
const char *name,
bool save_as_floats) {
2146 load_hdf5 (hid_t loc_id,
const char *name,
bool have_h5giterate_bug) {
2153 #if !SWIG_OCTAVE_PREREQ(4,0,0) 2158 #if !SWIG_OCTAVE_PREREQ(4,0,0) 2164 error(
"attempt to set immutable member variable");
2165 return octave_value_list();
2173 :ovl(_ovl), j(_j) { }
2175 operator octave_value()
const {
2198 && ov.rows() == 1 && ov.columns() == 1)
2199 ov = ov.cell_value()(0);
2204 if (ov.type_id() != octave_swig_ref::static_type_id())
2213 #define swig_unary_op(name) \ 2214 SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \ 2215 return octave_swig_type::dispatch_unary_op(x,#name); \ 2217 #define swig_binary_op(name) \ 2218 SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \ 2219 return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \ 2221 #if SWIG_OCTAVE_PREREQ(4,4,0) 2222 #define swigreg_unary_op(name) \ 2223 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \ 2224 typeinfo.register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name); 2226 #define swigreg_unary_op(name) \ 2227 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \ 2228 octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name); 2230 #if SWIG_OCTAVE_PREREQ(4,4,0) 2231 #define swigreg_binary_op(name) \ 2232 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \ 2233 typeinfo.register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name); 2235 #define swigreg_binary_op(name) \ 2236 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \ 2237 octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name); 2254 #if !SWIG_OCTAVE_PREREQ(4,2,0) 2272 #if SWIG_OCTAVE_PREREQ(4,4,0) 2273 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2284 #if SWIG_OCTAVE_PREREQ(4,4,0) 2285 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2293 #if !SWIG_OCTAVE_PREREQ(4,2,0) 2317 for (
int j = 0; j < tid; ++j) {
2326 #ifdef SWIG_DIRECTORS 2327 Swig::Director *d = Swig::get_rtdir(ptr);
2328 if (d && Swig::swig_director_get_self(d))
2329 return Swig::swig_director_get_self(d)->as_value();
2341 && ov.rows() == 1 && ov.columns() == 1)
2342 ov = ov.cell_value()(0);
2343 if (!ov.is_defined() ||
2344 (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2349 if (ov.type_id() != octave_swig_ref::static_type_id())
2353 return ost->
cast(ptr, type, own, flags);
2361 if (!ov.is_defined())
2363 if (ov.type_id() != octave_swig_packed::static_type_id())
2370 module_ns->
assign(name, ov);
2374 #if SWIG_OCTAVE_PREREQ(4,4,0) 2375 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2376 return symtab.global_varval(name);
2378 return get_global_value(name,
true);
2383 #if SWIG_OCTAVE_PREREQ(4,4,0) 2384 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2385 symtab.global_assign(name, value);
2387 set_global_value(name, value);
2392 #if SWIG_OCTAVE_PREREQ(4,4,0) 2393 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2394 octave::symbol_scope symscope = octave::interpreter::the_interpreter()->get_current_scope();
2395 symscope.assign(name, symtab.global_varval(name));
2396 symscope.mark_global(name);
2398 #if !SWIG_OCTAVE_PREREQ(3,2,0) 2399 link_to_global_variable(curr_sym_tab->lookup(name,
true));
2401 #if !SWIG_OCTAVE_PREREQ(3,8,0) 2402 symbol_table::varref(name);
2404 symbol_table::mark_global(name);
2411 if (!ov.is_defined() ||
2412 ov.type_id() != octave_swig_packed::static_type_id())
2428 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 2430 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 2436 #define SWIGTYPE_p_PLGraphicsIn swig_types[0] 2437 #define SWIGTYPE_p_char swig_types[1] 2438 #define SWIGTYPE_p_double swig_types[2] 2439 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3] 2440 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4] 2441 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5] 2442 #define SWIGTYPE_p_int swig_types[6] 2443 #define SWIGTYPE_p_p_char swig_types[7] 2444 #define SWIGTYPE_p_unsigned_int swig_types[8] 2447 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) 2448 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) 2453 #define SWIGVERSION 0x030012 2454 #define SWIG_VERSION SWIGVERSION 2457 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 2458 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 2461 #include <stdexcept> 2471 #ifdef OCTAVE_EXPORT 2472 #if defined ( __GNUC__ ) && __GNUC__ > 3 2473 #undef OCTAVE_EXPORT 2474 #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) ) 2492 inline int max(
int a,
int b )
2494 return a >= b ? a : b;
2496 inline int min(
int a,
int b )
2498 return a >= b ? a : b;
2512 return max( o_obj.rows(), 1 ) *
max( o_obj.columns(), 1 );
2524 if (
max( o_obj.columns(), 1 ) > 1 )
2529 else if (
max( o_obj.rows(), 1 ) > 1 )
2539 _dim(
const octave_value &o_obj,
int dim_idx )
2542 return max( o_obj.rows(), 0 );
2546 else if ( dim_idx == 1 )
2547 return max( o_obj.columns(), 0 );
2560 template <
class FLOAT>
2564 while ( n_el-- > 0 )
2565 *out_arr++ = (FLOAT) ( *in_arr++ );
2571 template void _cvt_double_to(
unsigned long *,
double *,
unsigned );
2573 template void _cvt_double_to(
unsigned short *,
double *,
unsigned );
2584 template <
class FLOAT>
2588 while ( n_el-- > 0 )
2589 *d_arr++ = double(*arr++);
2595 template void _cvt_to_double(
unsigned long *,
double *,
unsigned );
2597 template void _cvt_to_double(
unsigned short *,
double *,
unsigned );
2620 octave_value_list functionArguments;
2621 octave_value_list retval;
2628 for ( i = 0; i < n; i++ )
2634 functionArguments( 0 ) = xin;
2635 functionArguments( 1 ) = yin;
2637 if ( fcnMapForm != NULL )
2638 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 2639 retval = octave::feval( fcnMapForm, functionArguments, 1 );
2641 retval = feval( fcnMapForm, functionArguments, 1 );
2644 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 2645 retval = octave::feval( nameMapForm, functionArguments, 1 );
2647 retval = feval( nameMapForm, functionArguments, 1 );
2650 if ( retval.length() >= 2 )
2652 xout = retval( 0 ).matrix_value();
2653 yout = retval( 1 ).matrix_value();
2655 for ( i = 0; i < n; i++ )
2657 x[i] = xout( i, 0 );
2658 y[i] = yout( i, 0 );
2670 octave_value_list functionArguments;
2671 octave_value_list retval;
2673 Matrix inAxis( 1, 1 );
2674 Matrix inValue( 1, 1 );
2675 inAxis( 0, 0 ) = axis;
2676 inValue( 0, 0 ) =
value;
2678 functionArguments( 0 ) = inAxis;
2679 functionArguments( 1 ) = inValue;
2681 if ( fcnLabelFunc != NULL )
2682 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 2683 retval = octave::feval( fcnLabelFunc, functionArguments, 1 );
2685 retval = feval( fcnLabelFunc, functionArguments, 1 );
2688 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 2689 retval = octave::feval( nameLabelFunc, functionArguments, 1 );
2691 retval = feval( nameLabelFunc, functionArguments, 1 );
2694 strncpy( label, retval( 0 ).string_value().c_str(), length );
2704 octave_value_list functionArguments;
2705 octave_value_list retval;
2715 functionArguments( 0 ) = xin;
2716 functionArguments( 1 ) = yin;
2718 if ( fcnCoordTrans != NULL )
2719 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 2720 retval = octave::feval( fcnCoordTrans, functionArguments, 1 );
2722 retval = feval( fcnCoordTrans, functionArguments, 1 );
2725 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 2726 retval = octave::feval( nameCoordTrans, functionArguments, 1 );
2728 retval = feval( nameCoordTrans, functionArguments, 1 );
2731 if ( retval.length() >= 2 )
2733 xout = retval( 0 ).matrix_value();
2734 yout = retval( 1 ).matrix_value();
2745 printf(
"nlegend =%d\n", nlegend );
2746 for ( i = 0; i < nlegend; i++ )
2748 printf(
"opt_array[%d] =%d\n", i, opt_array[i] );
2749 printf(
"strlen(text[%d]) =%d\n", i, (
int) strlen( text[i] ) );
2750 printf(
"text[%d] =%s\n", i, text[i] );
2756 #if !defined(SWIG_NO_LLONG_MAX) 2757 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) 2758 # define LLONG_MAX __LONG_LONG_MAX__ 2759 # define LLONG_MIN (-LLONG_MAX - 1LL) 2760 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) 2767 if (!ov.is_scalar_type())
2769 if (ov.is_complex_scalar())
2771 if (ov.is_double_type()||ov.is_single_type()) {
2772 double v=ov.double_value();
2777 *val = ov.long_value();
2788 if ((v < INT_MIN || v > INT_MAX)) {
2791 if (val) *val =
static_cast< int >(v);
2798 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 )
2806 *pX = gin.
pX; *pY = gin.
pY; *dX = gin.
dX; *dY = gin.
dY; *wX = gin.
wX; *wY = gin.
wY;
2820 && ov.rows() == 1 && ov.columns() == 1)
2821 ov = ov.cell_value()(0);
2822 if (!ov.is_string())
2826 size_t len=str.size();
2827 char* cstr=(
char*)str.c_str();
2829 *cptr =
reinterpret_cast< char*
>(memcpy(
new char[len + 1], cstr,
sizeof(
char)*(len + 1)));
2844 return octave_value(value);
2857 return octave_value(value);
2866 gin.
dX = x_in; gin.
dY = y_in;
2868 *x = gin.
wX; *y = gin.
wY;
2875 if (!ov.is_scalar_type())
2877 if (ov.is_complex_scalar())
2880 *val = ov.double_value();
2888 PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
2889 PLFLT xlpos, PLFLT ylpos,
2891 PLINT colbox, PLINT collab,
2892 const PLINT *colline,
const PLINT *styline,
2893 const char *legline1,
const char *legline2,
const char *legline3,
const char *legline4,
2894 const char *labx,
const char *laby,
const char *labtop )
2896 const char *legline[4];
2897 legline[0] = legline1; legline[1] = legline2;
2898 legline[2] = legline3; legline[3] = legline4;
2899 c_plstripc(
id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
2900 xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
2901 labx, laby, labtop );
2919 *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
2920 *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
2925 #define f2c( f, ff, nx, ny ) \ 2927 ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \ 2928 for ( int i = 0; i < nx; i++ ) { \ 2929 ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \ 2930 for ( int j = 0; j < ny; j++ ) \ 2931 *( ff[i] + j ) = *( f + nx * j + i );} 2935 void my_plcont(
const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2936 PLINT ly,
const PLFLT *clevel, PLINT nlevel, PLFLT *tr )
2938 f2c( f, ff, nx, ny );
2939 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
xform, tr );
2944 void my_plcont0(
const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2945 PLINT ly,
const PLFLT *clevel, PLINT nlevel )
2947 f2c( f, ff, nx, ny );
2948 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr0, NULL );
2953 void my_plcont1(
const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2954 PLINT ly,
const PLFLT *clevel, PLINT nlevel,
const PLFLT *xg,
const PLFLT *yg )
2957 grid1.
nx = nx; grid1.
ny = ny;
2958 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
2959 f2c( f, ff, nx, ny );
2960 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr1, &grid1 );
2964 void my_plcont2(
const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2965 PLINT ly,
const PLFLT *clevel, PLINT nlevel,
const PLFLT *xg,
const PLFLT *yg )
2968 f2c( xg, xgg, nx, ny );
2969 f2c( yg, ygg, nx, ny );
2970 grid2.
nx = nx; grid2.
ny = ny;
2971 grid2.
xg = xgg; grid2.
yg = ygg;
2972 f2c( f, ff, nx, ny );
2973 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
2978 void my_plcont2p(
const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2979 PLINT ly,
const PLFLT *clevel, PLINT nlevel,
const PLFLT *xg,
const PLFLT *yg )
2982 f2c( xg, xgg, nx, ny );
2983 f2c( yg, ygg, nx, ny );
2984 grid2.
nx = nx; grid2.
ny = ny;
2985 grid2.
xg = xgg; grid2.
yg = ygg;
2986 f2c( f, ff, nx, ny );
2987 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
2992 const PLFLT *xg,
int nptsx,
const PLFLT *yg,
int nptsy,
2993 PLFLT *zg,
int type, PLFLT data )
2995 f2c( zg, zgg, nptsx, nptsy );
2996 plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
2997 for (
int i = 0; i < nptsx; i++ )
2998 for (
int j = 0; j < nptsy; j++ )
2999 *( zg + nptsx * j + i ) = zgg[i][j];
3005 void my_plmesh(
const PLFLT *x,
const PLFLT *y,
const PLFLT *z, PLINT nx, PLINT ny, PLINT opt )
3007 f2c( z, zz, nx, ny );
3008 c_plmesh( x, y, (
const PLFLT **) zz, nx, ny, opt );
3013 void my_plmeshc(
const PLFLT *x,
const PLFLT *y,
const PLFLT *z, PLINT nx, PLINT ny, PLINT opt,
const PLFLT *clevel, PLINT nlevel )
3015 f2c( z, zz, nx, ny );
3016 c_plmeshc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3021 void my_plot3d(
const PLFLT *x,
const PLFLT *y,
const PLFLT *z,
3022 PLINT nx, PLINT ny, PLINT opt, PLINT side )
3024 f2c( z, zz, nx, ny );
3025 c_plot3d( x, y, (
const PLFLT **) zz, nx, ny, opt, side );
3030 PLINT nx, PLINT ny, PLINT opt,
3031 const PLFLT *clevel, PLINT nlevel )
3033 f2c( z, zz, nx, ny );
3034 c_plot3dc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3039 PLINT nx, PLINT ny, PLINT opt,
3040 const PLFLT * clevel, PLINT nlevel,
3041 PLINT indexxmin, PLINT indexxmax,
const PLINT * indexymin,
const PLINT * indexymax )
3043 f2c( z, zz, nx, ny );
3044 c_plot3dcl( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3045 indexxmin, indexxmax, indexymin, indexymax );
3050 PLINT nx, PLINT ny, PLINT opt,
const PLFLT *clevel, PLINT nlevel )
3052 f2c( z, zz, nx, ny );
3053 c_plsurf3d( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3057 PLINT nx, PLINT ny, PLINT opt,
const PLFLT * clevel, PLINT nlevel,
3058 PLINT indexxmin, PLINT indexxmax,
const PLINT * indexymin,
const PLINT * indexymax )
3060 f2c( z, zz, nx, ny );
3061 c_plsurf3dl( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3062 indexxmin, indexxmax, indexymin, indexymax );
3072 void my_plshade(
const PLFLT *a, PLINT nx, PLINT ny,
const PLFLT *defined,
3073 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3074 PLFLT shade_min, PLFLT shade_max,
3075 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3076 PLINT min_color, PLINT min_width,
3077 PLINT max_color, PLINT max_width,
3078 PLINT rectangular, PLFLT *tr )
3080 f2c( a, aa, nx, ny );
3081 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3082 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3083 min_color, min_width, max_color, max_width,
3088 void my_plshade1(
const PLFLT *a, PLINT nx, PLINT ny,
const char *defined,
3089 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3090 PLFLT shade_min, PLFLT shade_max,
3091 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3092 PLINT min_color, PLINT min_width,
3093 PLINT max_color, PLINT max_width,
3094 PLINT rectangular,
const PLFLT *xg,
const PLFLT *yg )
3097 grid1.
nx = nx; grid1.
ny = ny;
3098 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
3099 f2c( a, aa, nx, ny );
3100 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3101 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3102 min_color, min_width, max_color, max_width,
3107 void my_plshade2(
const PLFLT *a, PLINT nx, PLINT ny,
const char *defined,
3108 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3109 PLFLT shade_min, PLFLT shade_max,
3110 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3111 PLINT min_color, PLINT min_width,
3112 PLINT max_color, PLINT max_width,
3113 PLINT rectangular,
const PLFLT *xg,
const PLFLT *yg )
3116 f2c( xg, xgg, nx, ny );
3117 f2c( yg, ygg, nx, ny );
3118 grid2.
nx = nx; grid2.
ny = ny;
3119 grid2.
xg = xgg; grid2.
yg = ygg;
3120 f2c( a, aa, nx, ny );
3121 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3122 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3123 min_color, min_width, max_color, max_width,
3130 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3131 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3132 PLINT cont_color, PLINT cont_width,
3135 f2c( a, aa, nx, ny );
3136 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3137 clevel, nlevel, fill_width, cont_color, cont_width,
3138 plfill, rectangular, NULL, NULL );
3142 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3143 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3144 PLINT cont_color, PLINT cont_width,
3145 PLINT rectangular, PLFLT *tr )
3147 f2c( a, aa, nx, ny );
3148 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3149 clevel, nlevel, fill_width, cont_color, cont_width,
3154 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3155 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3156 PLINT cont_color, PLINT cont_width,
3157 PLINT rectangular,
const PLFLT *xg,
const PLFLT *yg )
3160 grid1.
nx = nx; grid1.
ny = ny;
3161 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
3163 f2c( a, aa, nx, ny );
3164 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3165 clevel, nlevel, fill_width, cont_color, cont_width,
3170 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3171 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3172 PLINT cont_color, PLINT cont_width,
3173 PLINT rectangular,
const PLFLT *xg,
const PLFLT *yg )
3176 f2c( xg, xgg, nx, ny );
3177 f2c( yg, ygg, nx, ny );
3178 grid2.
nx = nx; grid2.
ny = ny;
3179 grid2.
xg = xgg; grid2.
yg = ygg;
3180 f2c( a, aa, nx, ny );
3181 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3182 clevel, nlevel, fill_width, cont_color, cont_width,
3190 void my_plvect(
const PLFLT *u,
const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr )
3192 f2c( u, uu, nx, ny );
3193 f2c( v, vv, nx, ny );
3194 c_plvect( (
const PLFLT **) uu, (
const PLFLT **) vv, nx, ny, scale,
xform, tr );
3198 void my_plvect1(
const PLFLT *u,
const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale,
const PLFLT *xg,
const PLFLT *yg )
3201 grid1.
nx = nx; grid1.
ny = ny;
3202 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
3203 f2c( u, uu, nx, ny );
3204 f2c( v, vv, nx, ny );
3205 c_plvect( (
const PLFLT **) uu, (
const PLFLT **) vv, nx, ny, scale,
pltr1, &grid1 );
3209 void my_plvect2(
const PLFLT *u,
const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale,
const PLFLT *xg,
const PLFLT *yg )
3212 f2c( xg, xgg, nx, ny );
3213 f2c( yg, ygg, nx, ny );
3214 grid2.
nx = nx; grid2.
ny = ny;
3215 grid2.
xg = xgg; grid2.
yg = ygg;
3216 f2c( u, uu, nx, ny );
3217 f2c( v, vv, nx, ny );
3218 c_plvect( (
const PLFLT **) uu, (
const PLFLT **) vv, nx, ny, scale,
pltr2, &grid2 );
3224 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3225 PLFLT zmin, PLFLT zmax,
3226 PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
3228 f2c( a, aa, nx, ny );
3229 plimage( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
3235 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3236 PLFLT zmin, PLFLT zmax,
3237 PLFLT valuemin, PLFLT valuemax )
3239 f2c( a, aa, nx, ny );
3240 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
3244 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3245 PLFLT zmin, PLFLT zmax,
3246 PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
3248 f2c( a, aa, nx, ny );
3249 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
xform, tr );
3254 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3255 PLFLT zmin, PLFLT zmax,
3256 PLFLT valuemin, PLFLT valuemax,
const PLFLT *xg,
const PLFLT *yg )
3259 grid1.
nx = nx + 1; grid1.
ny = ny + 1;
3260 grid1.
xg = (PLFLT *) xg; grid1.
yg = (PLFLT *) yg;
3261 f2c( a, aa, nx, ny );
3262 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr1, &grid1 );
3267 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3268 PLFLT zmin, PLFLT zmax,
3269 PLFLT valuemin, PLFLT valuemax,
const PLFLT *xg,
const PLFLT *yg )
3272 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
3273 f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
3274 grid2.
nx = nx + 1; grid2.
ny = ny + 1;
3275 grid2.
xg = xgg; grid2.
yg = ygg;
3276 f2c( a, aa, nx, ny );
3277 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr2, &grid2 );
3283 PLINT opt, PLINT position, PLFLT x, PLFLT y,
3284 PLFLT x_length, PLFLT y_length,
3285 PLINT bg_color, PLINT bb_color, PLINT bb_style,
3286 PLFLT low_cap_color, PLFLT high_cap_color,
3287 PLINT cont_color, PLFLT cont_width,
3288 PLINT n_labels,
const PLINT *label_opts,
const char **label,
3289 PLINT n_axes,
const char ** axis_opts,
3290 const PLFLT *ticks,
const PLINT *sub_ticks,
3291 const PLINT *n_values,
const PLFLT *a )
3296 for ( i = 0; i < nx; i++ )
3297 if ( n_values[i] > ny )
3299 f2c( a, aa, nx, ny );
3301 opt, position, x, y,
3303 bg_color, bb_color, bb_style,
3304 low_cap_color, high_cap_color,
3305 cont_color, cont_width,
3306 n_labels, label_opts, label,
3316 if (!ov.is_scalar_type())
3318 if (ov.is_complex_scalar())
3320 if (ov.is_double_type()||ov.is_single_type()) {
3321 double v=ov.double_value();
3327 if (ov.is_int8_type()||ov.is_int16_type()||
3328 ov.is_int32_type()) {
3329 long v=ov.long_value();
3333 if (ov.is_int64_type()) {
3334 long long v=ov.int64_scalar_value().value();
3339 *val = ov.ulong_value();
3350 if ((v > UINT_MAX)) {
3353 if (val) *val =
static_cast< unsigned int >(v);
3362 return octave_value(value);
3376 char* cptr = 0;
size_t csize = 0;
int alloc =
SWIG_OLDOBJ;
3380 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3381 if (csize <= size) {
3383 if (csize) memcpy(val, cptr, csize*
sizeof(
char));
3384 if (csize < size) memset(val + csize, 0, (size - csize)*
sizeof(
char));
3401 static int init = 0;
3422 for (p = s; maxlen-- && *p; p++)
3436 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3437 if (val) *val =
static_cast< char >(v);
3447 Specify viewport in absolute coordinates\n\ 3451 Alternate routine to plvpor for setting up the viewport. This routine\n\ 3452 should be used only if the viewport is required to have a definite\n\ 3453 size in millimeters. The routine plgspa is useful for finding out the\n\ 3454 size of the current subpage.\n\ 3456 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\ 3458 This function is used in example 10.\n\ 3464 plsvpa(xmin, xmax, ymin, ymax)\n\ 3468 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\ 3469 viewport from the left-hand edge of the subpage in millimeters.\n\ 3471 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\ 3472 viewport from the left-hand edge of the subpage in millimeters.\n\ 3474 ymin (PLFLT, input) : The distance of the bottom edge of the\n\ 3475 viewport from the bottom edge of the subpage in millimeters.\n\ 3477 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\ 3478 from the bottom edge of the subpage in millimeters.\n\ 3481 Write text relative to viewport boundaries in 3D plots\n\ 3485 Writes text at a specified position relative to the viewport\n\ 3486 boundaries. Text may be written inside or outside the viewport, but\n\ 3487 is clipped at the subpage boundaries. The reference point of a string\n\ 3488 lies along a line passing through the string at half the height of a\n\ 3489 capital letter. The position of the reference point along this line\n\ 3490 is determined by just, and the position of the reference point\n\ 3491 relative to the viewport is set by disp and pos.\n\ 3493 Redacted form: plmtex3(side, disp, pos, just, text)\n\ 3495 This function is used in example 28.\n\ 3501 plmtex3(side, disp, pos, just, text)\n\ 3505 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\ 3506 the side of the viewport along which the text is to be written.\n\ 3507 The string should contain one or more of the following characters:\n\ 3508 [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\ 3509 only label the X axis, not both the X and Y axes. x: Label the X\n\ 3511 y: Label the Y axis.\n\ 3512 z: Label the Z axis.\n\ 3513 p: Label the primary axis. For Z this is the leftmost Z axis.\n\ 3514 For X it is the axis that starts at y-min. For Y it is the\n\ 3515 axis that starts at x-min.\n\ 3516 s: Label the secondary axis.\n\ 3517 v: Draw the text perpendicular to the axis.\n\ 3520 disp (PLFLT, input) : Position of the reference point of string,\n\ 3521 measured outwards from the specified viewport edge in units of the\n\ 3522 current character height. Use negative disp to write within the\n\ 3525 pos (PLFLT, input) : Position of the reference point of string\n\ 3526 along the specified edge, expressed as a fraction of the length of\n\ 3529 just (PLFLT, input) : Specifies the position of the string relative\n\ 3530 to its reference point. If just=0. , the reference point is at\n\ 3531 the left and if just=1. , it is at the right of the string. Other\n\ 3532 values of just give intermediate justifications.\n\ 3534 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\ 3538 Set semitransparent cmap1 RGBA colors.\n\ 3542 Set semitransparent cmap1 colors (see the PLplot documentation) using\n\ 3543 RGBA vector values. This function also sets the number of cmap1\n\ 3544 colors. N.B. Continuous cmap1 colors are indexed with a\n\ 3545 floating-point index in the range from 0.0-1.0 which is linearly\n\ 3546 transformed (e.g., by plcol1) to an integer index of these RGBA\n\ 3547 vectors in the range from 0 to\n\ 3548 ncol1-1. So in order for this continuous color model to work\n\ 3549 properly, it is the responsibility of the user of plscmap1 to insure\n\ 3550 that these RGBA vectors are continuous functions of their integer\n\ 3553 Redacted form: plscmap1a(r, g, b, alpha)\n\ 3555 This function is used in example 31.\n\ 3561 plscmap1a(r, g, b, alpha, ncol1)\n\ 3565 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\ 3566 8-bit integers in the range from 0-255) the degree of red in the\n\ 3567 color as a continuous function of the integer index of the vector.\n\ 3569 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\ 3570 8-bit integers in the range from 0-255) the degree of green in the\n\ 3571 color as a continuous function of the integer index of the vector.\n\ 3573 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\ 3574 8-bit integers in the range from 0-255) the degree of blue in the\n\ 3575 color as a continuous function of the integer index of the vector.\n\ 3577 alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\ 3578 values in the range from 0.0-1.0 where 0.0 corresponds to\n\ 3579 completely transparent and 1.0 corresponds to completely opaque)\n\ 3580 the alpha transparency of the color as a continuous function of\n\ 3581 the integer index of the vector.\n\ 3583 ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\ 3587 Select standard viewport\n\ 3591 Selects the largest viewport within the subpage that leaves a standard\n\ 3592 margin (left-hand margin of eight character heights, and a margin\n\ 3593 around the other three sides of five character heights).\n\ 3595 Redacted form: plvsta()\n\ 3597 This function is used in examples 1, 12, 14, 17, 25, and 29.\n\ 3606 Switch to graphics screen\n\ 3610 Sets an interactive device to graphics mode, used in conjunction with\n\ 3611 pltext to allow graphics and text to be interspersed. On a device\n\ 3612 which supports separate text and graphics windows, this command causes\n\ 3613 control to be switched to the graphics window. If already in graphics\n\ 3614 mode, this command is ignored. It is also ignored on devices which\n\ 3615 only support a single window or use a different method for shifting\n\ 3616 focus. See also pltext.\n\ 3618 Redacted form: plgra()\n\ 3620 This function is used in example 1.\n\ 3629 Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\ 3633 Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\ 3634 (see the PLplot documentation) index. Overwrites the previous color\n\ 3635 value for the given index and, thus, does not result in any additional\n\ 3636 allocation of space for colors.\n\ 3638 This function is used in example 30.\n\ 3644 plscol0a(icol0, r, g, b, alpha)\n\ 3648 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\ 3649 number of colors (which is set by default, by plscmap0n, or even\n\ 3652 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\ 3653 degree of red in the color.\n\ 3655 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\ 3656 degree of green in the color.\n\ 3658 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\ 3659 degree of blue in the color.\n\ 3661 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\ 3665 Set y axis parameters\n\ 3669 Identical to plsxax, except that arguments are flags for y axis. See\n\ 3670 the description of plsxax for more detail.\n\ 3672 Redacted form: plsyax(digmax, digits)\n\ 3674 This function is used in examples 1, 14, and 31.\n\ 3680 plsyax(digmax, digits)\n\ 3684 digmax (PLINT, input) : Variable to set the maximum number of\n\ 3685 digits for the y axis. If nonzero, the printed label will be\n\ 3686 switched to a floating-point representation when the number of\n\ 3687 digits exceeds digmax.\n\ 3689 digits (PLINT, input) : Field digits value. Currently, changing\n\ 3690 its value here has no effect since it is set only by plbox or\n\ 3691 plbox3. However, the user may obtain its value after a call to\n\ 3692 either of these functions by calling plgyax.\n\ 3695 Returns 8-bit RGB values for given color index from cmap0\n\ 3699 Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\ 3700 PLplot documentation). Values are negative if an invalid color id is\n\ 3703 Redacted form: plgcol0(icol0, r, g, b)\n\ 3705 This function is used in example 2.\n\ 3711 plgcol0(icol0, r, g, b)\n\ 3715 icol0 (PLINT, input) : Index of desired cmap0 color.\n\ 3717 r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\ 3720 g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\ 3723 b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\ 3727 Set seed for internal random number generator.\n\ 3731 Set the seed for the internal random number generator. See plrandd for\n\ 3734 Redacted form: plseed(seed)\n\ 3736 This function is used in example 21.\n\ 3746 seed (unsigned int, input) : Seed for random number generator.\n\ 3749 Magnitude colored plot surface with contour for z[x][y] with y index limits\n\ 3753 When the implementation is completed this variant of plot3dc (see that\n\ 3754 function\'s documentation for more details) should be suitable for the\n\ 3755 case where the area of the x, y coordinate grid where z is defined can\n\ 3756 be non-rectangular. The implementation is incomplete so the last 4\n\ 3757 parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\ 3758 indexymax; are currently ignored and the functionality is otherwise\n\ 3759 identical to that of plot3dc.\n\ 3761 Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\ 3762 indexymin, indexymax)\n\ 3765 This function is not used in any example.\n\ 3771 plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\ 3775 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\ 3776 which the function is evaluated.\n\ 3778 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\ 3779 which the function is evaluated.\n\ 3781 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\ 3782 plot. Should have dimensions of\n\ 3786 nx (PLINT, input) : Number of x values at which the function is\n\ 3789 ny (PLINT, input) : Number of y values at which the function is\n\ 3792 opt (PLINT, input) : Determines the way in which the surface is\n\ 3793 represented. To specify more than one option just add the options,\n\ 3794 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\ 3795 showing z as a function of x for each value of y[j] .\n\ 3796 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\ 3797 for each value of x[i] .\n\ 3798 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\ 3799 at which function is defined.\n\ 3800 opt=MAG_COLOR : Each line in the mesh is colored according to\n\ 3801 the z value being plotted. The color is used from the current\n\ 3803 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\ 3807 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\ 3808 the borders of the plotted function.\n\ 3811 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\ 3814 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\ 3816 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\ 3817 corresponds to the first x index where z is defined.\n\ 3819 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\ 3820 which corresponds (by convention) to one more than the last x\n\ 3821 index value where z is defined.\n\ 3823 indexymin (PLINT_VECTOR, input) : A vector containing y index\n\ 3824 values which all must be ≥ 0. These values are the first y index\n\ 3825 where z is defined for a particular x index in the range from\n\ 3826 indexxmin to indexxmax - 1. The dimension of indexymin is\n\ 3829 indexymax (PLINT_VECTOR, input) : A vector containing y index\n\ 3830 values which all must be ≤ ny. These values correspond (by\n\ 3831 convention) to one more than the last y index where z is defined\n\ 3832 for a particular x index in the range from indexxmin to indexxmax\n\ 3833 - 1. The dimension of indexymax is indexxmax.\n\ 3836 Get output file name\n\ 3840 Gets the current output file name, if applicable.\n\ 3842 Redacted form: plgfnam(fnam)\n\ 3844 This function is used in example 31.\n\ 3854 fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\ 3855 (with preallocated length of 80 characters or more) containing the\n\ 3863 Specify the window, i.e., the world coordinates of the edges of the\n\ 3866 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\ 3868 This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\ 3875 plwind(xmin, xmax, ymin, ymax)\n\ 3879 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\ 3882 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\ 3885 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\ 3888 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\ 3892 Set cmap1 colors using a piece-wise linear relationship\n\ 3896 Set cmap1 colors using a piece-wise linear relationship between the\n\ 3897 cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\ 3898 (see the PLplot documentation). May be called at any time.\n\ 3900 The idea here is to specify a number of control points that define the\n\ 3901 mapping between input cmap1 intensity indices and HLS or RGB. Between\n\ 3902 these points, linear interpolation is used which gives a smooth\n\ 3903 variation of color with intensity index. Any number of control points\n\ 3904 may be specified, located at arbitrary positions, although typically 2\n\ 3905 - 4 are enough. Another way of stating this is that we are traversing\n\ 3906 a given number of lines through HLS or RGB space as we move through\n\ 3907 cmap1 intensity indices. The control points at the minimum and\n\ 3908 maximum position (0 and 1) must always be specified. By adding more\n\ 3909 control points you can get more variation. One good technique for\n\ 3910 plotting functions that vary about some expected average is to use an\n\ 3911 additional 2 control points in the center (position ~= 0.5) that are\n\ 3912 the same lightness as the background (typically white for paper\n\ 3913 output, black for crt), and same hue as the boundary control points.\n\ 3914 This allows the highs and lows to be very easily distinguished.\n\ 3916 Each control point must specify the cmap1 intensity index and the\n\ 3917 associated three coordinates in HLS or RGB space. The first point\n\ 3918 must correspond to position = 0, and the last to position = 1.\n\ 3920 If RGB colors are provided then the interpolation takes place in RGB\n\ 3921 space and is trivial. However if HLS colors are provided then, because\n\ 3922 of the circular nature of the color wheel for the hue coordinate, the\n\ 3923 interpolation could be performed in either direction around the color\n\ 3924 wheel. The default behaviour is for the hue to be linearly\n\ 3925 interpolated ignoring this circular property of hue. So for example,\n\ 3926 the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\ 3927 green and cyan. If instead you wish to interpolate the other way\n\ 3928 around the color wheel you have two options. You may provide hues\n\ 3929 outside the range [0, 360), so by using a hue of -120 for blue or 360\n\ 3930 for red the interpolation will proceed via magenta. Alternatively you\n\ 3931 can utilise the alt_hue_path variable to reverse the direction of\n\ 3932 interpolation if you need to provide hues within the [0-360) range.\n\ 3934 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\ 3935 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\ 3936 -120]falsegreen-yellow-red-magenta-blue[240\n\ 3937 480]falseblue-magenta-red-yellow-green[120\n\ 3938 240]truegreen-yellow-red-magenta-blue[240\n\ 3939 120]trueblue-magenta-red-yellow-green\n\ 3941 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\ 3942 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\ 3943 1]magnitudeHLSsaturation[0, 1]magnitude\n\ 3945 Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\ 3948 This function is used in examples 8, 11, 12, 15, 20, and 21.\n\ 3954 plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\ 3958 itype (PLBOOL, input) : true: RGB, false: HLS.\n\ 3960 npts (PLINT, input) : number of control points\n\ 3962 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\ 3963 intensity index (0.0-1.0) in ascending order for each control\n\ 3966 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\ 3967 coordinate (H or R) for each control point.\n\ 3969 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\ 3970 coordinate (L or G) for each control point.\n\ 3972 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\ 3973 coordinate (S or B) for each control point.\n\ 3975 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\ 3976 npts - 1 elements), each containing either true to use the reversed\n\ 3977 HLS interpolation or false to use the regular HLS interpolation.\n\ 3978 (alt_hue_path[i] refers to the interpolation interval between the\n\ 3979 i and i + 1 control points). This parameter is not used for RGB\n\ 3984 Set the pause (on end-of-page) status\n\ 3988 Set the pause (on end-of-page) status.\n\ 3990 Redacted form: plspause(pause)\n\ 3992 This function is in examples 14,20.\n\ 4002 pause (PLBOOL, input) : If pause is true there will be a pause on\n\ 4003 end-of-page for those drivers which support this. Otherwise there\n\ 4007 Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\ 4011 Routine for creating a discrete plot legend with a plotted filled box,\n\ 4012 line, and/or line of symbols for each annotated legend entry. (See\n\ 4013 plcolorbar for similar functionality for creating continuous color\n\ 4014 bars.) The arguments of pllegend provide control over the location\n\ 4015 and size of the legend as well as the location and characteristics of\n\ 4016 the elements (most of which are optional) within that legend. The\n\ 4017 resulting legend is clipped at the boundaries of the current subpage.\n\ 4018 (N.B. the adopted coordinate system used for some of the parameters is\n\ 4019 defined in the documentation of the position parameter.)\n\ 4021 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\ 4022 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\ 4023 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\ 4024 test_justification, text_colors, text, box_colors, box_patterns,\n\ 4025 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\ 4026 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\ 4028 This function is used in examples 4, 26, and 33.\n\ 4034 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\ 4038 p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\ 4039 legend width in adopted coordinates. This quantity is calculated\n\ 4040 from plot_width, text_offset, ncolumn (possibly modified inside\n\ 4041 the routine depending on nlegend and nrow), and the length\n\ 4042 (calculated internally) of the longest text string.\n\ 4044 p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\ 4045 legend height in adopted coordinates. This quantity is calculated\n\ 4046 from text_scale, text_spacing, and nrow (possibly modified inside\n\ 4047 the routine depending on nlegend and nrow).\n\ 4049 opt (PLINT, input) : opt contains bits controlling the overall\n\ 4050 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\ 4051 on the left of the legend and the plotted area on the right.\n\ 4052 Otherwise, put the text area on the right of the legend and the\n\ 4053 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\ 4054 plot a (semitransparent) background for the legend. If the\n\ 4055 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\ 4056 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\ 4057 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\ 4058 plot the resulting array of legend entries in row-major order.\n\ 4059 Otherwise, plot the legend entries in column-major order.\n\ 4061 position (PLINT, input) : position contains bits which control the\n\ 4062 overall position of the legend and the definition of the adopted\n\ 4063 coordinates used for positions just like what is done for the\n\ 4064 position argument for plcolorbar. However, note that the defaults\n\ 4065 for the position bits (see below) are different than the\n\ 4066 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\ 4067 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\ 4068 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\ 4069 the 16 possible standard positions (the 4 corners and centers of\n\ 4070 the 4 sides for both the inside and outside cases) of the legend\n\ 4071 relative to the adopted coordinate system. The corner positions\n\ 4072 are specified by the appropriate combination of two of the\n\ 4073 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\ 4074 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\ 4075 value of one of those bits. The adopted coordinates are\n\ 4076 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\ 4077 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\ 4078 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\ 4079 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\ 4080 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\ 4081 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\ 4082 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\ 4083 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\ 4085 x (PLFLT, input) : X offset of the legend position in adopted\n\ 4086 coordinates from the specified standard position of the legend.\n\ 4087 For positive x, the direction of motion away from the standard\n\ 4088 position is inward/outward from the standard corner positions or\n\ 4089 standard left or right positions if the\n\ 4090 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\ 4091 For the standard top or bottom positions, the direction of motion\n\ 4092 is toward positive X.\n\ 4094 y (PLFLT, input) : Y offset of the legend position in adopted\n\ 4095 coordinates from the specified standard position of the legend.\n\ 4096 For positive y, the direction of motion away from the standard\n\ 4097 position is inward/outward from the standard corner positions or\n\ 4098 standard top or bottom positions if the\n\ 4099 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\ 4100 the standard left or right positions, the direction of motion is\n\ 4101 toward positive Y.\n\ 4103 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\ 4104 of the plot area (where the colored boxes, lines, and/or lines of\n\ 4105 symbols are drawn) of the legend.\n\ 4107 bg_color (PLINT, input) : The cmap0 color of the background for the\n\ 4108 legend (PL_LEGEND_BACKGROUND).\n\ 4110 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\ 4111 for the legend (PL_LEGEND_BOUNDING_BOX).\n\ 4113 bb_style (PLINT, input) : The pllsty style number for the\n\ 4114 bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\ 4116 nrow (PLINT, input) : The number of rows in the matrix used to\n\ 4118 nlegend legend entries. For internal transformations of\n\ 4119 nrow, see further remarks under\n\ 4122 ncolumn (PLINT, input) : The number of columns in the matrix used\n\ 4124 nlegend legend entries. For internal transformations of\n\ 4125 ncolumn, see further remarks under\n\ 4128 nlegend (PLINT, input) : Number of legend entries. The above\n\ 4130 ncolumn values are transformed internally to be consistent with\n\ 4131 nlegend. If either\n\ 4133 ncolumn is non-positive it is replaced by 1. If the resulting product\n\ 4136 ncolumn is less than\n\ 4137 nlegend, the smaller of the two (or\n\ 4140 ncolumn) is increased so the product is >=\n\ 4141 nlegend. Thus, for example, the common\n\ 4143 ncolumn = 0 case is transformed internally to\n\ 4146 ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\ 4149 opt_array (PLINT_VECTOR, input) : A vector of\n\ 4150 nlegend values of options to control each individual plotted area\n\ 4151 corresponding to a legend entry. If the\n\ 4152 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\ 4154 PL_LEGEND_COLOR_BOX,\n\ 4155 PL_LEGEND_LINE, and/or\n\ 4156 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\ 4157 entry is plotted with a colored box; a line; and/or a line of\n\ 4160 text_offset (PLFLT, input) : Offset of the text area from the plot\n\ 4161 area in units of character width.\n\ 4163 text_scale (PLFLT, input) : Character height scale for text\n\ 4166 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\ 4167 character height from one legend entry to the next.\n\ 4169 text_justification (PLFLT, input) : Justification parameter used\n\ 4170 for text justification. The most common values of\n\ 4171 text_justification are 0., 0.5, or 1. corresponding to a text that\n\ 4172 is left justified, centred, or right justified within the text\n\ 4173 area, but other values are allowed as well.\n\ 4175 text_colors (PLINT_VECTOR, input) : A vector containing\n\ 4176 nlegend cmap0 text colors.\n\ 4178 text (PLCHAR_MATRIX, input) : A vector of\n\ 4179 nlegend UTF-8 character strings containing the legend annotations.\n\ 4181 box_colors (PLINT_VECTOR, input) : A vector containing\n\ 4182 nlegend cmap0 colors for the discrete colored boxes (\n\ 4183 PL_LEGEND_COLOR_BOX).\n\ 4185 box_patterns (PLINT_VECTOR, input) : A vector containing\n\ 4186 nlegend patterns (plpsty indices) for the discrete colored boxes (\n\ 4187 PL_LEGEND_COLOR_BOX).\n\ 4189 box_scales (PLFLT_VECTOR, input) : A vector containing\n\ 4190 nlegend scales (units of fraction of character height) for the height\n\ 4191 of the discrete colored boxes (\n\ 4192 PL_LEGEND_COLOR_BOX).\n\ 4194 box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\ 4195 nlegend line widths for the patterns specified by box_patterns (\n\ 4196 PL_LEGEND_COLOR_BOX).\n\ 4198 line_colors (PLINT_VECTOR, input) : A vector containing\n\ 4199 nlegend cmap0 line colors (\n\ 4202 line_styles (PLINT_VECTOR, input) : A vector containing\n\ 4203 nlegend line styles (plsty indices) (\n\ 4206 line_widths (PLFLT_VECTOR, input) : A vector containing\n\ 4207 nlegend line widths (\n\ 4210 symbol_colors (PLINT_VECTOR, input) : A vector containing\n\ 4211 nlegend cmap0 symbol colors (\n\ 4212 PL_LEGEND_SYMBOL).\n\ 4214 symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\ 4215 nlegend scale values for the symbol height (\n\ 4216 PL_LEGEND_SYMBOL).\n\ 4218 symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\ 4219 nlegend numbers of symbols to be drawn across the width of the plotted\n\ 4221 PL_LEGEND_SYMBOL).\n\ 4223 symbols (PLCHAR_MATRIX, input) : A vector of\n\ 4224 nlegend UTF-8 character strings containing the legend symbols. (\n\ 4225 PL_LEGEND_SYMBOL).\n\ 4228 Set number of colors in cmap1\n\ 4232 Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\ 4233 values if this is the first allocation (see the PLplot documentation).\n\ 4235 Redacted form: plscmap1n(ncol1)\n\ 4237 This function is used in examples 8, 11, 20, and 21.\n\ 4247 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\ 4248 the cmap1 palette. If this number is zero or less, then the value\n\ 4249 from the previous call to plscmap1n is used and if there is no\n\ 4250 previous call, then a default value is used.\n\ 4253 Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\ 4257 Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\ 4258 (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\ 4259 Values are negative if an invalid color id is given.\n\ 4261 Redacted form: plgcola(r, g, b)\n\ 4263 This function is used in example 30.\n\ 4269 plgcol0a(icol0, r, g, b, alpha)\n\ 4273 icol0 (PLINT, input) : Index of desired cmap0 color.\n\ 4275 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\ 4276 in the range from 0 to 255.\n\ 4278 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\ 4279 in the range from 0 to 255.\n\ 4281 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\ 4282 in the range from 0 to 255.\n\ 4284 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\ 4285 transparency in the range from (0.0-1.0).\n\ 4288 Replays contents of plot buffer to current device/file\n\ 4292 Replays contents of plot buffer to current device/file.\n\ 4294 Redacted form: plreplot()\n\ 4296 This function is used in example 1,20.\n\ 4305 Simple routine to write labels\n\ 4309 Routine for writing simple labels. Use plmtex for more complex labels.\n\ 4311 Redacted form: pllab(xlabel, ylabel, tlabel)\n\ 4313 This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\ 4319 pllab(xlabel, ylabel, tlabel)\n\ 4323 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\ 4324 the label for the x axis.\n\ 4326 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\ 4327 the label for the y axis.\n\ 4329 tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\ 4330 the title of the plot.\n\ 4333 Set parameters that define current device-space window\n\ 4337 Set relative margin width, aspect ratio, and relative justification\n\ 4338 that define current device-space window. If you want to just use the\n\ 4339 previous value for any of these, just pass in the magic value\n\ 4340 PL_NOTSET. It is unlikely that one should ever need to change the\n\ 4341 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\ 4342 called the default values of mar, jx, and jy are all 0. aspect is set\n\ 4343 to a device-specific value.\n\ 4345 Redacted form: plsdidev(mar, aspect, jx, jy)\n\ 4347 This function is used in example 31.\n\ 4353 plsdidev(mar, aspect, jx, jy)\n\ 4357 mar (PLFLT, input) : Relative margin width.\n\ 4359 aspect (PLFLT, input) : Aspect ratio.\n\ 4361 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\ 4362 the range -0.5 to 0.5.\n\ 4364 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\ 4365 the range -0.5 to 0.5.\n\ 4372 Begins a new page. For a file driver, the output file is opened if\n\ 4373 necessary. Advancing the page via pleop and plbop is useful when a\n\ 4374 page break is desired at a particular point when plotting to subpages.\n\ 4375 Another use for pleop and plbop is when plotting pages to different\n\ 4376 files, since you can manually set the file name by calling plsfnam\n\ 4377 after the call to pleop. (In fact some drivers may only support a\n\ 4378 single page per file, making this a necessity.) One way to handle\n\ 4379 this case automatically is to page advance via pladv, but enable\n\ 4380 familying (see plsfam) with a small limit on the file size so that a\n\ 4381 new family member file will be created on each page break.\n\ 4383 Redacted form: plbop()\n\ 4385 This function is used in examples 2 and 20.\n\ 4394 Set cmap0 colors by 8-bit RGB values\n\ 4398 Set cmap0 colors using 8-bit RGB values (see the PLplot\n\ 4399 documentation). This sets the entire color map -- only as many colors\n\ 4400 as specified will be allocated.\n\ 4402 Redacted form: plscmap0(r, g, b)\n\ 4404 This function is used in examples 2 and 24.\n\ 4410 plscmap0(r, g, b, ncol0)\n\ 4414 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\ 4415 integers (0-255) representing the degree of red in the color.\n\ 4417 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\ 4418 integers (0-255) representing the degree of green in the color.\n\ 4420 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\ 4421 integers (0-255) representing the degree of blue in the color.\n\ 4423 ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\ 4426 Set the number of subpages in x and y\n\ 4430 Set the number of subpages in x and y.\n\ 4432 Redacted form: plssub(nx, ny)\n\ 4434 This function is examples 1,2,14,21,25,27.\n\ 4444 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\ 4445 of window columns).\n\ 4447 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\ 4451 Set a global coordinate transform function\n\ 4455 This function can be used to define a coordinate transformation which\n\ 4456 affects all elements drawn within the current plot window. The\n\ 4457 coordinate_transform callback function is similar to that provided for\n\ 4458 the plmap and plmeridians functions. The coordinate_transform_data\n\ 4459 parameter may be used to pass extra data to coordinate_transform.\n\ 4461 Redacted form: General: plstransform(coordinate_transform,\n\ 4462 coordinate_transform_data)\n\ 4465 This function is used in examples 19 and 22.\n\ 4471 plstransform(coordinate_transform, coordinate_transform_data)\n\ 4475 coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\ 4476 function that defines the transformation from the input (x, y)\n\ 4477 world coordinates to new PLplot world coordinates. If\n\ 4478 coordinate_transform is not supplied (e.g., is set to NULL in the C\n\ 4479 case), then no transform is applied.\n\ 4481 coordinate_transform_data (PLPointer, input) : Optional extra data\n\ 4483 coordinate_transform.\n\ 4486 Set opaque RGB cmap1 colors values\n\ 4490 Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\ 4491 vector values. This function also sets the number of cmap1 colors.\n\ 4492 N.B. Continuous cmap1 colors are indexed with a floating-point index\n\ 4493 in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\ 4494 plcol1) to an integer index of these RGB vectors in the range from 0\n\ 4496 ncol1-1. So in order for this continuous color model to work\n\ 4497 properly, it is the responsibility of the user of plscmap1 to insure\n\ 4498 that these RGB vectors are continuous functions of their integer\n\ 4501 Redacted form: plscmap1(r, g, b)\n\ 4503 This function is used in example 31.\n\ 4509 plscmap1(r, g, b, ncol1)\n\ 4513 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\ 4514 8-bit integers in the range from 0-255) the degree of red in the\n\ 4515 color as a continuous function of the integer index of the vector.\n\ 4517 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\ 4518 8-bit integers in the range from 0-255) the degree of green in the\n\ 4519 color as a continuous function of the integer index of the vector.\n\ 4521 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\ 4522 8-bit integers in the range from 0-255) the degree of blue in the\n\ 4523 color as a continuous function of the integer index of the vector.\n\ 4525 ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\ 4528 Configure the transformation between continuous and broken-down time for the current stream\n\ 4532 Configure the transformation between continuous and broken-down time\n\ 4533 for the current stream. This transformation is used by both plbtime\n\ 4536 Redacted form: General: plconfigtime(scale, offset1, offset2,\n\ 4537 ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\ 4540 This function is used in example 29.\n\ 4546 plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\ 4550 scale (PLFLT, input) : The number of days per continuous time unit.\n\ 4551 As a special case, if\n\ 4552 scale is 0., then all other arguments are ignored, and the result (the\n\ 4553 default used by PLplot) is the equivalent of a call to\n\ 4554 plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\ 4555 That is, for this special case broken-down time is calculated with\n\ 4556 the proleptic Gregorian calendar with no leap seconds inserted,\n\ 4557 and the continuous time is defined as the number of seconds since\n\ 4558 the Unix epoch of 1970-01-01T00:00:00Z.\n\ 4560 offset1 (PLFLT, input) : If\n\ 4561 ifbtime_offset is true, the parameters\n\ 4563 offset2 are completely ignored. Otherwise, the sum of these parameters\n\ 4564 (with units in days) specify the epoch of the continuous time\n\ 4565 relative to the MJD epoch corresponding to the Gregorian calendar\n\ 4566 date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\ 4567 are used to specify the origin to allow users (by specifying\n\ 4568 offset1 as an integer that can be exactly represented by a\n\ 4569 floating-point variable and specifying\n\ 4570 offset2 as a number in the range from 0. to 1) the chance to minimize\n\ 4571 the numerical errors of the continuous time representation.\n\ 4573 offset2 (PLFLT, input) : See documentation of\n\ 4576 ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\ 4577 transformation. If the 0x1 bit is set, then the proleptic Julian\n\ 4578 calendar is used for broken-down time rather than the proleptic\n\ 4579 Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\ 4580 have been historically used to define UTC are inserted into the\n\ 4581 broken-down time. Other possibilities for additional control bits\n\ 4582 for ccontrol exist such as making the historical time corrections\n\ 4583 in the broken-down time corresponding to ET (ephemeris time) or\n\ 4584 making the (slightly non-constant) corrections from international\n\ 4585 atomic time (TAI) to what astronomers define as terrestrial time\n\ 4586 (TT). But those additional possibilities have not been\n\ 4587 implemented yet in the qsastime library (one of the PLplot utility\n\ 4590 ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\ 4591 epoch of the continuous time scale is specified by the user. If\n\ 4592 ifbtime_offset is false, then\n\ 4594 offset2 are used to specify the epoch, and the following broken-down\n\ 4595 time parameters are completely ignored. If\n\ 4596 ifbtime_offset is true, then\n\ 4598 offset2 are completely ignored, and the following broken-down time\n\ 4599 parameters are used to specify the epoch.\n\ 4601 year (PLINT, input) : Year of epoch.\n\ 4603 month (PLINT, input) : Month of epoch in range from 0 (January) to\n\ 4606 day (PLINT, input) : Day of epoch in range from 1 to 31.\n\ 4608 hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\ 4610 min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\ 4612 sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\ 4615 Set length of minor ticks\n\ 4619 This sets up the length of the minor ticks and the length of the\n\ 4620 terminals on error bars. The actual length is the product of the\n\ 4621 default length and a scaling factor as for character height.\n\ 4623 Redacted form: plsmin(def, scale)\n\ 4625 This function is used in example 29.\n\ 4631 plsmin(def, scale)\n\ 4635 def (PLFLT, input) : The default length of a minor tick in\n\ 4636 millimeters, should be set to zero if the default length is to\n\ 4637 remain unchanged.\n\ 4639 scale (PLFLT, input) : Scale factor to be applied to default to get\n\ 4640 actual tick length.\n\ 4643 Set character size\n\ 4647 This sets up the size of all subsequent characters drawn. The actual\n\ 4648 height of a character is the product of the default character size and\n\ 4649 a scaling factor.\n\ 4651 Redacted form: plschr(def, scale)\n\ 4653 This function is used in examples 2, 13, 23, and 24.\n\ 4659 plschr(def, scale)\n\ 4663 def (PLFLT, input) : The default height of a character in\n\ 4664 millimeters, should be set to zero if the default height is to\n\ 4665 remain unchanged. For rasterized drivers the dx and dy values\n\ 4666 specified in plspage are used to convert from mm to pixels (note\n\ 4667 the different unit systems used). This dpi aware scaling is not\n\ 4668 implemented for all drivers yet.\n\ 4670 scale (PLFLT, input) : Scale factor to be applied to default to get\n\ 4671 actual character height.\n\ 4674 Initialize PLplot\n\ 4678 Initializing the plotting package. The program prompts for the device\n\ 4679 keyword or number of the desired output device. Hitting a RETURN in\n\ 4680 response to the prompt is the same as selecting the first device.\n\ 4681 plinit will issue no prompt if either the device was specified\n\ 4682 previously (via command line flag, the plsetopt function, or the\n\ 4683 plsdev function), or if only one device is enabled when PLplot is\n\ 4684 installed. If subpages have been specified, the output device is\n\ 4685 divided into nx by ny subpages, each of which may be used\n\ 4686 independently. If plinit is called again during a program, the\n\ 4687 previously opened file will be closed. The subroutine pladv is used\n\ 4688 to advance from one subpage to the next.\n\ 4690 Redacted form: plinit()\n\ 4692 This function is used in all of the examples.\n\ 4701 Draw a box with axes, etc\n\ 4705 Draws a box around the currently defined viewport, and labels it with\n\ 4706 world coordinate values appropriate to the window. Thus plbox should\n\ 4707 only be called after defining both viewport and window. The ascii\n\ 4708 character strings xopt and yopt specify how the box should be drawn as\n\ 4709 described below. If ticks and/or subticks are to be drawn for a\n\ 4710 particular axis, the tick intervals and number of subintervals may be\n\ 4711 specified explicitly, or they may be defaulted by setting the\n\ 4712 appropriate arguments to zero.\n\ 4714 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\ 4717 This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\ 4724 plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\ 4728 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\ 4729 options for the x axis. The string can include any combination of\n\ 4730 the following letters (upper or lower case) in any order: a: Draws\n\ 4731 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\ 4733 b: Draws bottom (X) or left (Y) edge of frame.\n\ 4734 c: Draws top (X) or right (Y) edge of frame.\n\ 4735 d: Plot labels as date / time. Values are assumed to be\n\ 4736 seconds since the epoch (as used by gmtime).\n\ 4737 f: Always use fixed point numeric labels.\n\ 4738 g: Draws a grid at the major tick interval.\n\ 4739 h: Draws a grid at the minor tick interval.\n\ 4740 i: Inverts tick marks, so they are drawn outwards, rather than\n\ 4742 l: Labels axis logarithmically. This only affects the labels,\n\ 4743 not the data, and so it is necessary to compute the logarithms\n\ 4744 of data points before passing them to any of the drawing\n\ 4746 m: Writes numeric labels at major tick intervals in the\n\ 4747 unconventional location (above box for X, right of box for Y).\n\ 4748 n: Writes numeric labels at major tick intervals in the\n\ 4749 conventional location (below box for X, left of box for Y).\n\ 4750 o: Use custom labelling function to generate axis label text.\n\ 4751 The custom labelling function can be defined with the\n\ 4752 plslabelfunc command.\n\ 4753 s: Enables subticks between major ticks, only valid if t is\n\ 4755 t: Draws major ticks.\n\ 4756 u: Exactly like \"b\" except don\'t draw edge line.\n\ 4757 w: Exactly like \"c\" except don\'t draw edge line.\n\ 4758 x: Exactly like \"t\" (including the side effect of the\n\ 4759 numerical labels for the major ticks) except exclude drawing\n\ 4760 the major and minor tick marks.\n\ 4763 xtick (PLFLT, input) : World coordinate interval between major\n\ 4764 ticks on the x axis. If it is set to zero, PLplot automatically\n\ 4765 generates a suitable tick interval.\n\ 4767 nxsub (PLINT, input) : Number of subintervals between major x axis\n\ 4768 ticks for minor ticks. If it is set to zero, PLplot automatically\n\ 4769 generates a suitable minor tick interval.\n\ 4771 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\ 4772 options for the y axis. The string can include any combination of\n\ 4773 the letters defined above for xopt, and in addition may contain:\n\ 4774 v: Write numeric labels for the y axis parallel to the base of the\n\ 4775 graph, rather than parallel to the axis.\n\ 4778 ytick (PLFLT, input) : World coordinate interval between major\n\ 4779 ticks on the y axis. If it is set to zero, PLplot automatically\n\ 4780 generates a suitable tick interval.\n\ 4782 nysub (PLINT, input) : Number of subintervals between major y axis\n\ 4783 ticks for minor ticks. If it is set to zero, PLplot automatically\n\ 4784 generates a suitable minor tick interval.\n\ 4787 Get parameters that define current device-space window\n\ 4791 Get relative margin width, aspect ratio, and relative justification\n\ 4792 that define current device-space window. If plsdidev has not been\n\ 4793 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\ 4794 p_jy will all be 0.\n\ 4796 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\ 4798 This function is used in example 31.\n\ 4804 plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\ 4808 p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\ 4811 p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\ 4814 p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\ 4815 justification in x.\n\ 4817 p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\ 4818 justification in y.\n\ 4821 Plot a glyph at the specified points\n\ 4825 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\ 4826 because many[!] more glyphs are accessible with plstring.) The glyph\n\ 4827 is specified with a PLplot user string. Note that the user string is\n\ 4828 not actually limited to one glyph so it is possible (but not normally\n\ 4829 useful) to plot more than one glyph at the specified points with this\n\ 4830 function. As with plmtex and plptex, the user string can contain FCI\n\ 4831 escapes to determine the font, UTF-8 code to determine the glyph or\n\ 4832 else PLplot escapes for Hershey or unicode text to determine the\n\ 4835 Redacted form: plstring(x, y, string)\n\ 4837 This function is used in examples 4, 21 and 26.\n\ 4843 plstring(n, x, y, string)\n\ 4847 n (PLINT, input) : Number of points in the x and y vectors.\n\ 4849 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\ 4852 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\ 4855 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\ 4856 the glyph(s) to be plotted at each of the n points.\n\ 4859 Plot all or a subset of Shapefile data using strings or points in world coordinates\n\ 4863 As per plmapline, however the items are plotted as strings or points\n\ 4864 in the same way as plstring.\n\ 4866 Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\ 4867 maxy, plotentries)\n\ 4869 This function is not used in any examples.\n\ 4875 plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\ 4879 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\ 4880 transform the coordinates given in the shapefile into a plot\n\ 4881 coordinate system. By using this transform, we can change from a\n\ 4882 longitude, latitude coordinate to a polar stereographic project,\n\ 4883 for example. Initially, x[0]..[n-1] are the longitudes and\n\ 4884 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\ 4885 mapform(), x[] and y[] should be replaced by the corresponding\n\ 4886 plot coordinates. If no transform is desired, mapform can be\n\ 4887 replaced by NULL.\n\ 4889 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\ 4890 the file name of a set of Shapefile files without the file\n\ 4893 string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\ 4896 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\ 4897 be in the same units as used by the Shapefile. You could use a\n\ 4898 very large negative number to plot everything, but you can improve\n\ 4899 performance by limiting the area drawn. The units must match those\n\ 4900 of the Shapefile projection, which may be for example longitude or\n\ 4901 distance. The value of minx must be less than the value of maxx.\n\ 4903 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\ 4904 use a very large number to plot everything, but you can improve\n\ 4905 performance by limiting the area drawn.\n\ 4907 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\ 4908 be in the same units as used by the Shapefile. You could use a\n\ 4909 very large negative number to plot everything, but you can improve\n\ 4910 performance by limiting the area drawn. The units must match those\n\ 4911 of the Shapefile projection, which may be for example latitude or\n\ 4912 distance. The value of miny must be less than the value of maxy.\n\ 4914 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\ 4915 use a very large number to plot everything, but you can improve\n\ 4916 performance by limiting the area drawn.\n\ 4918 plotentries (PLINT_VECTOR, input) : A vector containing the\n\ 4919 zero-based indices of the Shapefile elements which will be drawn.\n\ 4921 plotentries to NULL will plot all elements of the Shapefile.\n\ 4923 nplotentries (PLINT, input) : The number of items in\n\ 4924 plotentries. Ignored if\n\ 4925 plotentries is NULL.\n\ 4928 Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\ 4932 Sets up plotter environment for simple graphs by calling pladv and\n\ 4933 setting up viewport and window to sensible default values. plenv0\n\ 4934 leaves a standard margin (left-hand margin of eight character heights,\n\ 4935 and a margin around the other three sides of five character heights)\n\ 4936 around most graphs for axis labels and a title. When these defaults\n\ 4937 are not suitable, use the individual routines plvpas, plvpor, or\n\ 4938 plvasp for setting up the viewport, plwind for defining the window,\n\ 4939 and plbox for drawing the box.\n\ 4941 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\ 4943 This function is used in example 21.\n\ 4949 plenv0(xmin, xmax, ymin, ymax, just, axis)\n\ 4953 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\ 4954 world coordinates).\n\ 4956 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\ 4957 world coordinates).\n\ 4959 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\ 4962 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\ 4965 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\ 4966 scales will not be set, the user must set up the scale before\n\ 4967 calling plenv0 using plsvpa, plvasp or other.\n\ 4968 0: the x and y axes are scaled independently to use as much of\n\ 4969 the screen as possible.\n\ 4970 1: the scales of the x and y axes are made equal.\n\ 4971 2: the axis of the x and y axes are made equal, and the plot\n\ 4972 box will be square.\n\ 4975 axis (PLINT, input) : Controls drawing of the box around the plot:\n\ 4976 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\ 4977 -1: draw box only.\n\ 4978 0: draw box, ticks, and numeric tick labels.\n\ 4979 1: also draw coordinate axes at x=0 and y=0.\n\ 4980 2: also draw a grid at major tick positions in both\n\ 4982 3: also draw a grid at minor tick positions in both\n\ 4984 10: same as 0 except logarithmic x tick marks. (The x data\n\ 4985 have to be converted to logarithms separately.)\n\ 4986 11: same as 1 except logarithmic x tick marks. (The x data\n\ 4987 have to be converted to logarithms separately.)\n\ 4988 12: same as 2 except logarithmic x tick marks. (The x data\n\ 4989 have to be converted to logarithms separately.)\n\ 4990 13: same as 3 except logarithmic x tick marks. (The x data\n\ 4991 have to be converted to logarithms separately.)\n\ 4992 20: same as 0 except logarithmic y tick marks. (The y data\n\ 4993 have to be converted to logarithms separately.)\n\ 4994 21: same as 1 except logarithmic y tick marks. (The y data\n\ 4995 have to be converted to logarithms separately.)\n\ 4996 22: same as 2 except logarithmic y tick marks. (The y data\n\ 4997 have to be converted to logarithms separately.)\n\ 4998 23: same as 3 except logarithmic y tick marks. (The y data\n\ 4999 have to be converted to logarithms separately.)\n\ 5000 30: same as 0 except logarithmic x and y tick marks. (The x\n\ 5001 and y data have to be converted to logarithms separately.)\n\ 5002 31: same as 1 except logarithmic x and y tick marks. (The x\n\ 5003 and y data have to be converted to logarithms separately.)\n\ 5004 32: same as 2 except logarithmic x and y tick marks. (The x\n\ 5005 and y data have to be converted to logarithms separately.)\n\ 5006 33: same as 3 except logarithmic x and y tick marks. (The x\n\ 5007 and y data have to be converted to logarithms separately.)\n\ 5008 40: same as 0 except date / time x labels.\n\ 5009 41: same as 1 except date / time x labels.\n\ 5010 42: same as 2 except date / time x labels.\n\ 5011 43: same as 3 except date / time x labels.\n\ 5012 50: same as 0 except date / time y labels.\n\ 5013 51: same as 1 except date / time y labels.\n\ 5014 52: same as 2 except date / time y labels.\n\ 5015 53: same as 3 except date / time y labels.\n\ 5016 60: same as 0 except date / time x and y labels.\n\ 5017 61: same as 1 except date / time x and y labels.\n\ 5018 62: same as 2 except date / time x and y labels.\n\ 5019 63: same as 3 except date / time x and y labels.\n\ 5020 70: same as 0 except custom x and y labels.\n\ 5021 71: same as 1 except custom x and y labels.\n\ 5022 72: same as 2 except custom x and y labels.\n\ 5023 73: same as 3 except custom x and y labels.\n\ 5026 Configure the transformations required for projecting a 3D surface on a 2D window\n\ 5030 Configure the transformations required for projecting a 3D surface on\n\ 5031 an existing 2D window. Those transformations (see the PLplot\n\ 5032 documentation) are done to a rectangular cuboid enclosing the 3D\n\ 5033 surface which has its limits expressed in 3D world coordinates and\n\ 5034 also normalized 3D coordinates (used for interpreting the altitude and\n\ 5035 azimuth of the viewing angle). The transformations consist of the\n\ 5036 linear transform from 3D world coordinates to normalized 3D\n\ 5037 coordinates, and the 3D rotation of normalized coordinates required to\n\ 5038 align the pole of the new 3D coordinate system with the viewing\n\ 5039 direction specified by altitude and azimuth so that x and y of the\n\ 5040 surface elements in that transformed coordinate system are the\n\ 5041 projection of the 3D surface with given viewing direction on the 2D\n\ 5044 The enclosing rectangular cuboid for the surface plot is defined by\n\ 5045 xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\ 5046 mapped into the same rectangular cuboid with normalized 3D coordinate\n\ 5047 sizes of basex by basey by height so that xmin maps to -\n\ 5048 basex/2, xmax maps to basex/2, ymin maps to -\n\ 5049 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\ 5050 The resulting rectangular cuboid in normalized coordinates is then\n\ 5051 viewed by an observer at altitude alt and azimuth az. This routine\n\ 5052 must be called before plbox3 or any of the 3D surface plotting\n\ 5053 routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\ 5054 plsurf3dl or plfill3.\n\ 5056 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\ 5057 zmin, zmax, alt, az)\n\ 5059 This function is examples 8, 11, 18, and 21.\n\ 5065 plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\ 5069 basex (PLFLT, input) : The normalized x coordinate size of the\n\ 5070 rectangular cuboid.\n\ 5072 basey (PLFLT, input) : The normalized y coordinate size of the\n\ 5073 rectangular cuboid.\n\ 5075 height (PLFLT, input) : The normalized z coordinate size of the\n\ 5076 rectangular cuboid.\n\ 5078 xmin (PLFLT, input) : The minimum x world coordinate of the\n\ 5079 rectangular cuboid.\n\ 5081 xmax (PLFLT, input) : The maximum x world coordinate of the\n\ 5082 rectangular cuboid.\n\ 5084 ymin (PLFLT, input) : The minimum y world coordinate of the\n\ 5085 rectangular cuboid.\n\ 5087 ymax (PLFLT, input) : The maximum y world coordinate of the\n\ 5088 rectangular cuboid.\n\ 5090 zmin (PLFLT, input) : The minimum z world coordinate of the\n\ 5091 rectangular cuboid.\n\ 5093 zmax (PLFLT, input) : The maximum z world coordinate of the\n\ 5094 rectangular cuboid.\n\ 5096 alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\ 5097 plane of the rectangular cuboid in normalized coordinates.\n\ 5099 az (PLFLT, input) : The viewing azimuth in degrees of the\n\ 5100 rectangular cuboid in normalized coordinates. When az=0, the\n\ 5101 observer is looking face onto the zx plane of the rectangular\n\ 5102 cuboid in normalized coordinates, and as az is increased, the\n\ 5103 observer moves clockwise around that cuboid when viewed from above\n\ 5107 Draw filled polygon\n\ 5111 Fills the polygon defined by the n points (\n\ 5113 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\ 5114 style is a solid fill. The routine will automatically close the\n\ 5115 polygon between the last and first vertices. If multiple closed\n\ 5116 polygons are passed in x and y then plfill will fill in between them.\n\ 5118 Redacted form: plfill(x,y)\n\ 5120 This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\ 5130 n (PLINT, input) : Number of vertices in polygon.\n\ 5132 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\ 5135 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\ 5139 Magnitude colored plot surface with contour\n\ 5143 Aside from dropping the\n\ 5144 side functionality this is a more powerful form of plot3d: the surface\n\ 5145 mesh can be colored accordingly to the current z value being plotted,\n\ 5146 a contour plot can be drawn at the base XY plane, and a curtain can be\n\ 5147 drawn between the plotted function border and the base XY plane. The\n\ 5148 arguments are identical to those of plmeshc. The only difference\n\ 5149 between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\ 5150 the surface, while plot3dc only draws the surface as viewed from the\n\ 5153 Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\ 5156 This function is used in example 21.\n\ 5162 plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\ 5166 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\ 5167 which the function is evaluated.\n\ 5169 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\ 5170 which the function is evaluated.\n\ 5172 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\ 5173 plot. Should have dimensions of\n\ 5177 nx (PLINT, input) : Number of x values at which function is\n\ 5180 ny (PLINT, input) : Number of y values at which function is\n\ 5183 opt (PLINT, input) : Determines the way in which the surface is\n\ 5184 represented. To specify more than one option just add the options,\n\ 5185 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\ 5186 showing z as a function of x for each value of y[j] .\n\ 5187 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\ 5188 for each value of x[i] .\n\ 5189 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\ 5190 at which function is defined.\n\ 5191 opt=MAG_COLOR : Each line in the mesh is colored according to\n\ 5192 the z value being plotted. The color is used from the current\n\ 5194 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\ 5198 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\ 5199 the borders of the plotted function.\n\ 5202 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\ 5205 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\ 5208 Write text relative to viewport boundaries\n\ 5212 Writes text at a specified position relative to the viewport\n\ 5213 boundaries. Text may be written inside or outside the viewport, but\n\ 5214 is clipped at the subpage boundaries. The reference point of a string\n\ 5215 lies along a line passing through the string at half the height of a\n\ 5216 capital letter. The position of the reference point along this line\n\ 5217 is determined by just, and the position of the reference point\n\ 5218 relative to the viewport is set by disp and pos.\n\ 5220 Redacted form: General: plmtex(side, disp, pos, just, text)\n\ 5223 This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\ 5230 plmtex(side, disp, pos, just, text)\n\ 5234 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\ 5235 the side of the viewport along which the text is to be written.\n\ 5236 The string must be one of: b: Bottom of viewport, text written\n\ 5237 parallel to edge.\n\ 5238 bv: Bottom of viewport, text written at right angles to edge.\n\ 5239 l: Left of viewport, text written parallel to edge.\n\ 5240 lv: Left of viewport, text written at right angles to edge.\n\ 5241 r: Right of viewport, text written parallel to edge.\n\ 5242 rv: Right of viewport, text written at right angles to edge.\n\ 5243 t: Top of viewport, text written parallel to edge.\n\ 5244 tv: Top of viewport, text written at right angles to edge.\n\ 5247 disp (PLFLT, input) : Position of the reference point of string,\n\ 5248 measured outwards from the specified viewport edge in units of the\n\ 5249 current character height. Use negative disp to write within the\n\ 5252 pos (PLFLT, input) : Position of the reference point of string\n\ 5253 along the specified edge, expressed as a fraction of the length of\n\ 5256 just (PLFLT, input) : Specifies the position of the string relative\n\ 5257 to its reference point. If just=0. , the reference point is at\n\ 5258 the left and if just=1. , it is at the right of the string. Other\n\ 5259 values of just give intermediate justifications.\n\ 5261 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\ 5265 Set arrow style for vector plots\n\ 5269 Set the style for the arrow used by plvect to plot vectors.\n\ 5271 Redacted form: plsvect(arrowx, arrowy, fill)\n\ 5273 This function is used in example 22.\n\ 5279 plsvect(arrowx, arrowy, npts, fill)\n\ 5283 arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\ 5284 the x and y points which make up the arrow. The arrow is plotted\n\ 5285 by joining these points to form a polygon. The scaling assumes\n\ 5286 that the x and y points in the arrow lie in the range -0.5 <= x,y\n\ 5287 <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\ 5288 will be reset to its default.\n\ 5290 npts (PLINT, input) : Number of points in the vectors arrowx and\n\ 5293 fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\ 5294 fill is false then the arrow is open.\n\ 5297 Get family file parameters\n\ 5301 Gets information about current family file, if familying is enabled.\n\ 5302 See the PLplot documentation for more information.\n\ 5304 Redacted form: plgfam(p_fam, p_num, p_bmax)\n\ 5306 This function is used in examples 14 and 31.\n\ 5312 plgfam(p_fam, p_num, p_bmax)\n\ 5316 p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\ 5317 family flag value. If nonzero, familying is enabled for the\n\ 5320 p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\ 5321 family file number.\n\ 5323 p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\ 5324 file size (in bytes) for a family file.\n\ 5327 Random number generator returning a real random number in the range [0,1]\n\ 5331 Random number generator returning a real random number in the range\n\ 5332 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\ 5333 / compilers provide their own random number generator, and so this is\n\ 5334 provided purely for convenience and to give a consistent random number\n\ 5335 generator across all languages supported by PLplot. This is\n\ 5336 particularly useful for comparing results from the test suite of\n\ 5339 Redacted form: plrandd()\n\ 5341 This function is used in examples 17 and 21.\n\ 5354 Draws a contour plot of the data in f[\n\ 5356 ny], using the nlevel contour levels specified by clevel. Only the\n\ 5357 region of the matrix from kx to lx and from ky to ly is plotted out\n\ 5358 where all these index ranges are interpreted as one-based for\n\ 5359 historical reasons. A transformation routine pointed to by pltr with\n\ 5360 a generic pointer pltr_data for additional data required by the\n\ 5361 transformation routine is used to map indices within the matrix to the\n\ 5362 world coordinates.\n\ 5364 Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\ 5365 where (see above discussion) the pltr, pltr_data callback arguments\n\ 5366 are sometimes replaced by a tr vector with 6 elements; xg and yg\n\ 5367 vectors; or xg and yg matrices.\n\ 5369 This function is used in examples 9, 14, 16, and 22.\n\ 5375 plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\ 5379 f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\ 5381 nx, ny (PLINT, input) : The dimensions of the matrix f.\n\ 5383 kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\ 5384 kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\ 5385 zero-based for historical backwards-compatibility reasons.\n\ 5387 ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\ 5388 ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\ 5389 zero-based for historical backwards-compatibility reasons.\n\ 5391 clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\ 5392 which to draw contours.\n\ 5394 nlevel (PLINT, input) : Number of contour levels to draw.\n\ 5396 pltr (PLTRANSFORM_callback, input) : A callback function that\n\ 5397 defines the transformation between the zero-based indices of the\n\ 5398 matrix f and the world coordinates.For the C case, transformation\n\ 5399 functions are provided in the PLplot library: pltr0 for the\n\ 5400 identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\ 5401 respectively defined by vectors and matrices. In addition, C\n\ 5402 callback routines for the transformation can be supplied by the\n\ 5403 user such as the mypltr function in examples/c/x09c.c which\n\ 5404 provides a general linear transformation between index coordinates\n\ 5405 and world coordinates.For languages other than C you should\n\ 5406 consult the PLplot documentation for the details concerning how\n\ 5407 PLTRANSFORM_callback arguments are interfaced. However, in\n\ 5408 general, a particular pattern of callback-associated arguments\n\ 5409 such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\ 5410 yg matrices are respectively interfaced to a linear-transformation\n\ 5411 routine similar to the above mypltr function; pltr1; and pltr2.\n\ 5412 Furthermore, some of our more sophisticated bindings (see, e.g.,\n\ 5413 the PLplot documentation) support native language callbacks for\n\ 5414 handling index to world-coordinate transformations. Examples of\n\ 5415 these various approaches are given in examples/<language>x09*,\n\ 5416 examples/<language>x16*, examples/<language>x20*,\n\ 5417 examples/<language>x21*, and examples/<language>x22*, for all our\n\ 5418 supported languages.\n\ 5420 pltr_data (PLPointer, input) : Extra parameter to help pass\n\ 5421 information to pltr0, pltr1, pltr2, or whatever callback routine\n\ 5422 that is externally supplied.\n\ 5429 This sets up the line style for all lines subsequently drawn. A line\n\ 5430 consists of segments in which the pen is alternately down and up. The\n\ 5431 lengths of these segments are passed in the vectors mark and space\n\ 5432 respectively. The number of mark-space pairs is specified by nms. In\n\ 5433 order to return the line style to the default continuous line, plstyl\n\ 5434 should be called with nms =0 .(see also pllsty)\n\ 5436 Redacted form: plstyl(mark, space)\n\ 5438 This function is used in examples 1, 9, and 14.\n\ 5444 plstyl(nms, mark, space)\n\ 5448 nms (PLINT, input) : The number of mark and space elements in a\n\ 5449 line. Thus a simple broken line can be obtained by setting nms=1\n\ 5450 . A continuous line is specified by setting nms=0 .\n\ 5452 mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\ 5453 segments during which the pen is down, measured in micrometers.\n\ 5455 space (PLINT_VECTOR, input) : A vector containing the lengths of\n\ 5456 the segments during which the pen is up, measured in micrometers.\n\ 5459 Set the cmap0 palette using the specified cmap0*.pal format file\n\ 5463 Set the cmap0 palette using the specified cmap0*.pal format file.\n\ 5465 Redacted form: plspal0(filename)\n\ 5467 This function is in example 16.\n\ 5473 plspal0(filename)\n\ 5477 filename (PLCHAR_VECTOR, input) : An ascii character string\n\ 5478 containing the name of the cmap0*.pal file. If this string is\n\ 5479 empty, use the default cmap0*.pal file.\n\ 5482 Set the cmap1 palette using the specified cmap1*.pal format file\n\ 5486 Set the cmap1 palette using the specified cmap1*.pal format file.\n\ 5488 Redacted form: plspal1(filename, interpolate)\n\ 5490 This function is used in example 16.\n\ 5496 plspal1(filename, interpolate)\n\ 5500 filename (PLCHAR_VECTOR, input) : An ascii character string\n\ 5501 containing the name of the cmap1*.pal file. If this string is\n\ 5502 empty, use the default cmap1*.pal file.\n\ 5504 interpolate (PLBOOL, input) : If this parameter is true, the\n\ 5505 columns containing the intensity index, r, g, b, alpha and\n\ 5506 alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\ 5507 palette with a call to plscmap1la. (The cmap1*.pal header contains\n\ 5508 a flag which controls whether the r, g, b data sent to plscmap1la\n\ 5509 are interpreted as HLS or RGB.) If this parameter is false, the\n\ 5510 intensity index and alt_hue_path columns are ignored and the r, g,\n\ 5511 b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\ 5512 are used instead to set the cmap1 palette directly with a call to\n\ 5516 Set current output stream\n\ 5520 Sets the number of the current output stream. The stream number\n\ 5521 defaults to 0 unless changed by this routine. The first use of this\n\ 5522 routine must be followed by a call initializing PLplot (e.g. plstar).\n\ 5524 Redacted form: plsstrm(strm)\n\ 5526 This function is examples 1,14,20.\n\ 5536 strm (PLINT, input) : The current stream number.\n\ 5539 Specify viewport using normalized subpage coordinates\n\ 5543 Device-independent routine for setting up the viewport. This defines\n\ 5544 the viewport in terms of normalized subpage coordinates which run from\n\ 5545 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\ 5546 current subpage. Use the alternate routine plsvpa in order to create\n\ 5547 a viewport of a definite size.\n\ 5549 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\ 5551 This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\ 5552 24, 26, 27, and 31.\n\ 5558 plvpor(xmin, xmax, ymin, ymax)\n\ 5562 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\ 5563 left-hand edge of the viewport.\n\ 5565 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\ 5566 right-hand edge of the viewport.\n\ 5568 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\ 5569 bottom edge of the viewport.\n\ 5571 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\ 5572 edge of the viewport.\n\ 5575 Write text inside the viewport\n\ 5579 Writes text at a specified position and inclination within the\n\ 5580 viewport. Text is clipped at the viewport boundaries. The reference\n\ 5581 point of a string lies along a line passing through the string at half\n\ 5582 the height of a capital letter. The position of the reference point\n\ 5583 along this line is determined by just, the reference point is placed\n\ 5584 at world coordinates (\n\ 5586 y) within the viewport. The inclination of the string is specified\n\ 5587 in terms of differences of world coordinates making it easy to write\n\ 5588 text parallel to a line in a graph.\n\ 5590 Redacted form: plptex(x, y, dx, dy, just, text)\n\ 5592 This function is used in example 2-4,10,12-14,20,23,24,26.\n\ 5598 plptex(x, y, dx, dy, just, text)\n\ 5602 x (PLFLT, input) : x coordinate of reference point of string.\n\ 5604 y (PLFLT, input) : y coordinate of reference point of string.\n\ 5606 dx (PLFLT, input) : Together with dy, this specifies the\n\ 5607 inclination of the string. The baseline of the string is parallel\n\ 5608 to a line joining (\n\ 5616 dy (PLFLT, input) : Together with dx, this specifies the\n\ 5617 inclination of the string.\n\ 5619 just (PLFLT, input) : Specifies the position of the string relative\n\ 5620 to its reference point. If just=0. , the reference point is at\n\ 5621 the left and if just=1. , it is at the right of the string. Other\n\ 5622 values of just give intermediate justifications.\n\ 5624 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\ 5628 Set z axis parameters\n\ 5632 Identical to plsxax, except that arguments are flags for z axis. See\n\ 5633 the description of plsxax for more detail.\n\ 5635 Redacted form: plszax(digmax, digits)\n\ 5637 This function is used in example 31.\n\ 5643 plszax(digmax, digits)\n\ 5647 digmax (PLINT, input) : Variable to set the maximum number of\n\ 5648 digits for the z axis. If nonzero, the printed label will be\n\ 5649 switched to a floating-point representation when the number of\n\ 5650 digits exceeds digmax.\n\ 5652 digits (PLINT, input) : Field digits value. Currently, changing\n\ 5653 its value here has no effect since it is set only by plbox or\n\ 5654 plbox3. However, the user may obtain its value after a call to\n\ 5655 either of these functions by calling plgzax.\n\ 5658 Plot shaded 3-d surface plot for z[x][y] with y index limits\n\ 5662 This variant of plsurf3d (see that function\'s documentation for more\n\ 5663 details) should be suitable for the case where the area of the x, y\n\ 5664 coordinate grid where z is defined can be non-rectangular. The limits\n\ 5665 of that grid are provided by the parameters indexxmin, indexxmax,\n\ 5666 indexymin, and indexymax.\n\ 5668 Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\ 5671 This function is used in example 8.\n\ 5677 plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\ 5681 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\ 5682 which the function is evaluated.\n\ 5684 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\ 5685 which the function is evaluated.\n\ 5687 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\ 5688 plot. Should have dimensions of\n\ 5692 nx (PLINT, input) : Number of x values at which function is\n\ 5695 ny (PLINT, input) : Number of y values at which function is\n\ 5698 opt (PLINT, input) : Determines the way in which the surface is\n\ 5699 represented. To specify more than one option just add the options,\n\ 5700 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\ 5701 connecting points at which function is defined.\n\ 5702 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\ 5706 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\ 5710 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\ 5711 the borders of the plotted function.\n\ 5712 opt=MAG_COLOR : the surface is colored according to the value\n\ 5713 of Z; if MAG_COLOR is not used, then the surface is colored\n\ 5714 according to the intensity of the reflected light in the\n\ 5715 surface from a light source whose position is set using\n\ 5719 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\ 5722 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\ 5724 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\ 5725 corresponds to the first x index where z is defined.\n\ 5727 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\ 5728 which corresponds (by convention) to one more than the last x\n\ 5729 index value where z is defined.\n\ 5731 indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\ 5732 values which all must be ≥ 0. These values are the first y index\n\ 5733 where z is defined for a particular x index in the range from\n\ 5734 indexxmin to indexxmax - 1. The dimension of indexymin is\n\ 5737 indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\ 5738 values which all must be ≤ ny. These values correspond (by\n\ 5739 convention) to one more than the last y index where z is defined\n\ 5740 for a particular x index in the range from indexxmin to indexxmax\n\ 5741 - 1. The dimension of indexymax is indexxmax.\n\ 5748 Sets the font used for subsequent text and symbols. For devices that\n\ 5749 still use Hershey fonts this routine has no effect unless the Hershey\n\ 5750 fonts with extended character set are loaded (see plfontld). For\n\ 5751 unicode-aware devices that use system fonts instead of Hershey fonts,\n\ 5752 this routine calls the plsfci routine with argument set up\n\ 5753 appropriately for the various cases below. However, this method of\n\ 5754 specifying the font for unicode-aware devices is deprecated, and the\n\ 5755 much more flexible method of calling plsfont directly is recommended\n\ 5756 instead (where plsfont provides a user-friendly interface to plsfci),\n\ 5758 Redacted form: plfont(ifont)\n\ 5760 This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\ 5770 ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\ 5771 (simplest and fastest)\n\ 5777 Get the cmap1 argument range for continuous color plots\n\ 5781 Get the cmap1 argument range for continuous color plots. (Use\n\ 5782 plscmap1_range to set the cmap1 argument range.)\n\ 5784 Redacted form: plgcmap1_range(min_color, max_color)\n\ 5786 This function is currently not used in any example.\n\ 5792 plgcmap1_range(min_color, max_color)\n\ 5796 min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\ 5797 minimum cmap1 argument.\n\ 5799 max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\ 5800 maximum cmap1 argument.\n\ 5803 Set the cmap1 argument range for continuous color plots\n\ 5807 Set the cmap1 argument range for continuous color plots that\n\ 5808 corresponds to the range of data values. The maximum range\n\ 5809 corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\ 5810 the cmap1 argument range that is specified with this routine, the\n\ 5811 smaller the subset of the cmap1 color palette that is used to\n\ 5812 represent the continuous data being plotted. If\n\ 5813 min_color is greater than\n\ 5815 max_color is greater than 1.0 or\n\ 5816 min_color is less than 0.0 then no change is made to the cmap1\n\ 5817 argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\ 5819 Redacted form: plscmap1_range(min_color, max_color)\n\ 5821 This function is currently used in example 33.\n\ 5827 plscmap1_range(min_color, max_color)\n\ 5831 min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\ 5832 than 0.0, then 0.0 is used instead.\n\ 5834 max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\ 5835 than 1.0, then 1.0 is used instead.\n\ 5838 Draw a circular or elliptical arc\n\ 5842 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\ 5843 semiminor axis b, starting at angle1 and ending at angle2.\n\ 5845 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\ 5849 This function is used in examples 3 and 27.\n\ 5855 plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\ 5859 x (PLFLT, input) : X coordinate of arc center.\n\ 5861 y (PLFLT, input) : Y coordinate of arc center.\n\ 5863 a (PLFLT, input) : Length of the semimajor axis of the arc.\n\ 5865 b (PLFLT, input) : Length of the semiminor axis of the arc.\n\ 5867 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\ 5870 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\ 5873 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\ 5876 fill (PLBOOL, input) : Draw a filled arc.\n\ 5879 Plot 3-d surface plot\n\ 5883 Plots a three-dimensional surface plot within the environment set up\n\ 5884 by plw3d. The surface is defined by the matrix z[\n\ 5886 ny] , the point z[i][j] being the value of the function at (\n\ 5888 y[j]). Note that the points in vectors x and y do not need to be\n\ 5889 equally spaced, but must be stored in ascending order. The parameter\n\ 5890 opt controls the way in which the surface is displayed. For further\n\ 5891 details see the PLplot documentation. The only difference between\n\ 5892 plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\ 5893 while plot3d only draws the surface as viewed from the top.\n\ 5895 Redacted form: plot3d(x, y, z, opt, side)\n\ 5897 This function is used in examples 11 and 21.\n\ 5903 plot3d(x, y, z, nx, ny, opt, side)\n\ 5907 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\ 5908 which the function is evaluated.\n\ 5910 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\ 5911 which the function is evaluated.\n\ 5913 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\ 5914 plot. Should have dimensions of\n\ 5918 nx (PLINT, input) : Number of x values at which function is\n\ 5921 ny (PLINT, input) : Number of y values at which function is\n\ 5924 opt (PLINT, input) : Determines the way in which the surface is\n\ 5925 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\ 5926 function of x for each value of y[j] .\n\ 5927 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\ 5928 for each value of x[i] .\n\ 5929 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\ 5930 at which function is defined.\n\ 5933 side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\ 5934 should be draw on the figure. If side is true sides are drawn,\n\ 5935 otherwise no sides are drawn.\n\ 5938 Set area line fill pattern\n\ 5942 Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\ 5943 The pattern consists of 1 or 2 sets of parallel lines with specified\n\ 5944 inclinations and spacings. The arguments to this routine are the\n\ 5945 number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\ 5946 elements) specifying the inclinations in tenths of a degree and the\n\ 5947 spacing in micrometers. (See also plpsty)\n\ 5949 Redacted form: General: plpat(inc, del)\n\ 5952 This function is used in example 15.\n\ 5958 plpat(nlin, inc, del)\n\ 5962 nlin (PLINT, input) : Number of sets of lines making up the\n\ 5963 pattern, either 1 or 2.\n\ 5965 inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\ 5966 inclination in tenths of a degree. (Should be between -900 and\n\ 5969 del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\ 5970 spacing in micrometers between the lines making up the pattern.\n\ 5973 Get x axis parameters\n\ 5977 Returns current values of the p_digmax and p_digits flags for the x\n\ 5978 axis. p_digits is updated after the plot is drawn, so this routine\n\ 5979 should only be called after the call to plbox (or plbox3) is complete.\n\ 5980 See the PLplot documentation for more information.\n\ 5982 Redacted form: plgxax(p_digmax, p_digits)\n\ 5984 This function is used in example 31.\n\ 5990 plgxax(p_digmax, p_digits)\n\ 5994 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\ 5995 number of digits for the x axis. If nonzero, the printed label\n\ 5996 has been switched to a floating-point representation when the\n\ 5997 number of digits exceeds this value.\n\ 5999 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\ 6000 number of digits for the numeric labels (x axis) from the last\n\ 6004 Draw filled polygon in 3D\n\ 6008 Fills the 3D polygon defined by the n points in the x, y, and z\n\ 6009 vectors using the pattern defined by plpsty or plpat. The routine\n\ 6010 will automatically close the polygon between the last and first\n\ 6011 vertices. If multiple closed polygons are passed in x, y, and z then\n\ 6012 plfill3 will fill in between them.\n\ 6014 Redacted form: General: plfill3(x, y, z)\n\ 6017 This function is used in example 15.\n\ 6023 plfill3(n, x, y, z)\n\ 6027 n (PLINT, input) : Number of vertices in polygon.\n\ 6029 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\ 6032 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\ 6035 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\ 6043 Sets the color index for cmap0 (see the PLplot documentation).\n\ 6045 Redacted form: plcol0(icol0)\n\ 6047 This function is used in examples 1-9, 11-16, 18-27, and 29.\n\ 6057 icol0 (PLINT, input) : Integer representing the color. The\n\ 6058 defaults at present are (these may change):\n\ 6059 0 black (default background)\n\ 6060 1 red (default foreground)\n\ 6076 Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\ 6077 change an individual color in the cmap0 color palette.\n\ 6080 Draw text at points defined by Shapefile data in world coordinates\n\ 6084 As per plmapline, however the items are plotted as text in the same\n\ 6087 Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\ 6088 miny, maxy, plotentry)\n\ 6090 This function is used in example 19.\n\ 6096 plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\ 6100 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\ 6101 transform the coordinates given in the shapefile into a plot\n\ 6102 coordinate system. By using this transform, we can change from a\n\ 6103 longitude, latitude coordinate to a polar stereographic project,\n\ 6104 for example. Initially, x[0]..[n-1] are the longitudes and\n\ 6105 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\ 6106 mapform(), x[] and y[] should be replaced by the corresponding\n\ 6107 plot coordinates. If no transform is desired, mapform can be\n\ 6108 replaced by NULL.\n\ 6110 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\ 6111 the file name of a set of Shapefile files without the file\n\ 6114 dx (PLFLT, input) : Used to define the slope of the texts which is\n\ 6117 dy (PLFLT, input) : Used to define the slope of the texts which is\n\ 6120 just (PLFLT, input) : Set the justification of the text. The value\n\ 6121 given will be the fraction of the distance along the string that\n\ 6122 sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\ 6123 centralized text and 1.0 gives right aligned text.\n\ 6125 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\ 6127 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\ 6128 be in the same units as used by the Shapefile. You could use a\n\ 6129 very large negative number to plot everything, but you can improve\n\ 6130 performance by limiting the area drawn. The units must match those\n\ 6131 of the Shapefile projection, which may be for example longitude or\n\ 6132 distance. The value of minx must be less than the value of maxx.\n\ 6134 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\ 6135 use a very large number to plot everything, but you can improve\n\ 6136 performance by limiting the area drawn.\n\ 6138 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\ 6139 be in the same units as used by the Shapefile. You could use a\n\ 6140 very large negative number to plot everything, but you can improve\n\ 6141 performance by limiting the area drawn. The units must match those\n\ 6142 of the Shapefile projection, which may be for example latitude or\n\ 6143 distance. The value of miny must be less than the value of maxy.\n\ 6145 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\ 6146 use a very large number to plot everything, but you can improve\n\ 6147 performance by limiting the area drawn.\n\ 6149 plotentry (PLINT, input) : An integer indicating which text string\n\ 6150 of the Shapefile (zero indexed) will be drawn.\n\ 6153 Draw a line between two points\n\ 6157 Joins the point (\n\ 6163 Redacted form: pljoin(x1,y1,x2,y2)\n\ 6165 This function is used in examples 3 and 14.\n\ 6171 pljoin(x1, y1, x2, y2)\n\ 6175 x1 (PLFLT, input) : x coordinate of first point.\n\ 6177 y1 (PLFLT, input) : y coordinate of first point.\n\ 6179 x2 (PLFLT, input) : x coordinate of second point.\n\ 6181 y2 (PLFLT, input) : y coordinate of second point.\n\ 6188 Sets the color for cmap1 (see the PLplot documentation).\n\ 6190 Redacted form: plcol1(col1)\n\ 6192 This function is used in examples 12 and 21.\n\ 6202 col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\ 6203 is mapped to color using the continuous cmap1 palette which by\n\ 6204 default ranges from blue to the background color to red. The\n\ 6205 cmap1 palette can also be straightforwardly changed by the user\n\ 6206 with plscmap1 or plscmap1l.\n\ 6213 Set integer plot orientation parameter. This function is identical to\n\ 6214 plsdiori except for the type of the argument, and should be used in\n\ 6215 the same way. See the documentation of plsdiori for details.\n\ 6217 Redacted form: plsori(ori)\n\ 6219 This function is used in example 3.\n\ 6229 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\ 6230 portrait, etc.) The value is multiplied by 90 degrees to get the\n\ 6234 Calculate continuous time from broken-down time for the current stream\n\ 6238 Calculate continuous time, ctime, from broken-down time for the\n\ 6239 current stream. The broken-down\n\ 6240 time is specified by the following parameters: year, month, day, hour,\n\ 6241 min, and sec. This function is the inverse of plbtime.\n\ 6243 The PLplot definition of broken-down time is a calendar time that\n\ 6244 completely ignores all time zone offsets, i.e., it is the user\'s\n\ 6245 responsibility to apply those offsets (if so desired) before using the\n\ 6246 PLplot time API. By default broken-down time is defined using the\n\ 6247 proleptic Gregorian calendar without the insertion of leap seconds and\n\ 6248 continuous time is defined as the number of seconds since the Unix\n\ 6249 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\ 6250 broken-down and continuous time are possible, see plconfigtime which\n\ 6251 specifies that transformation for the current stream.\n\ 6253 Redacted form: General: plctime(year, month, day, hour, min, sec,\n\ 6257 This function is used in example 29.\n\ 6263 plctime(year, month, day, hour, min, sec, ctime)\n\ 6267 year (PLINT, input) : Input year.\n\ 6269 month (PLINT, input) : Input month in range from 0 (January) to 11\n\ 6272 day (PLINT, input) : Input day in range from 1 to 31.\n\ 6274 hour (PLINT, input) : Input hour in range from 0 to 23\n\ 6276 min (PLINT, input) : Input minute in range from 0 to 59.\n\ 6278 sec (PLFLT, input) : Input second in range from 0. to 60.\n\ 6280 ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\ 6281 time calculated from the broken-down time specified by the\n\ 6282 previous parameters.\n\ 6285 Plot continental outline or shapefile data in world coordinates\n\ 6289 Plots continental outlines or shapefile data in world coordinates. A\n\ 6290 demonstration of how to use this function to create different\n\ 6291 projections can be found in examples/c/x19c. PLplot is provided with\n\ 6292 basic coastal outlines and USA state borders. To use the map\n\ 6293 functionality PLplot must be compiled with the shapelib library.\n\ 6294 Shapefiles have become a popular standard for geographical data and\n\ 6295 data in this format can be easily found from a number of online\n\ 6296 sources. Shapefile data is actually provided as three or more files\n\ 6297 with the same filename, but different extensions. The .shp and .shx\n\ 6298 files are required for plotting Shapefile data with PLplot.\n\ 6300 PLplot currently supports the point, multipoint, polyline and polygon\n\ 6301 objects within shapefiles. However holes in polygons are not\n\ 6302 supported. When plmap is used the type of object is derived from the\n\ 6303 shapefile, if you wish to override the type then use one of the other\n\ 6304 plmap variants. The built in maps have line data only.\n\ 6306 Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\ 6308 This function is used in example 19.\n\ 6314 plmap(mapform, name, minx, maxx, miny, maxy)\n\ 6318 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\ 6319 transform the original map data coordinates to a new coordinate\n\ 6320 system. The PLplot-supplied map data is provided as latitudes and\n\ 6321 longitudes; other Shapefile data may be provided in other\n\ 6322 coordinate systems as can be found in their .prj plain text files.\n\ 6323 For example, by using this transform we can change from a\n\ 6324 longitude, latitude coordinate to a polar stereographic\n\ 6325 projection. Initially, x[0]..[n-1] are the original x coordinates\n\ 6326 (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\ 6327 corresponding y coordinates (latitudes for the PLplot supplied\n\ 6328 data). After the call to mapform(), x[] and y[] should be\n\ 6329 replaced by the corresponding plot coordinates. If no transform is\n\ 6330 desired, mapform can be replaced by NULL.\n\ 6332 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\ 6333 the type of map plotted. This is either one of the PLplot built-in\n\ 6334 maps or the file name of a set of Shapefile files without the file\n\ 6335 extensions. For the PLplot built-in maps the possible values are:\n\ 6336 \"globe\" -- continental outlines\n\ 6337 \"usa\" -- USA and state boundaries\n\ 6338 \"cglobe\" -- continental outlines and countries\n\ 6339 \"usaglobe\" -- USA, state boundaries and continental outlines\n\ 6342 minx (PLFLT, input) : The minimum x value of map elements to be\n\ 6343 drawn. The units must match the shapefile (built in maps are\n\ 6344 degrees lat/lon). Objects in the file which do not encroach on the\n\ 6345 box defined by minx, maxx, miny, maxy will not be rendered. But\n\ 6346 note this is simply an optimisation, not a clipping so for objects\n\ 6347 with some points inside the box and some points outside the box\n\ 6348 all the points will be rendered. These parameters also define\n\ 6349 latitude and longitude wrapping for shapefiles using these units.\n\ 6350 Longitude points will be wrapped by integer multiples of 360\n\ 6351 degrees to place them in the box. This allows the same data to be\n\ 6352 used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\ 6353 you plot from -180-540 you will get two cycles of data drawn. The\n\ 6354 value of minx must be less than the value of maxx. Passing in a\n\ 6355 nan, max/-max floating point number or +/-infinity will case the\n\ 6356 bounding box from the shapefile to be used.\n\ 6358 maxx (PLFLT, input) : The maximum x value of map elements to be\n\ 6359 drawn - see minx.\n\ 6361 miny (PLFLT, input) : The minimum y value of map elements to be\n\ 6362 drawn - see minx.\n\ 6364 maxy (PLFLT, input) : The maximum y value of map elements to be\n\ 6365 drawn - see minx.\n\ 6368 Calculate broken-down time from continuous time for the current stream\n\ 6372 Calculate broken-down time; year, month, day, hour, min, sec; from\n\ 6373 continuous time, ctime for the current stream. This function is the\n\ 6374 inverse of plctime.\n\ 6376 The PLplot definition of broken-down time is a calendar time that\n\ 6377 completely ignores all time zone offsets, i.e., it is the user\'s\n\ 6378 responsibility to apply those offsets (if so desired) before using the\n\ 6379 PLplot time API. By default broken-down time is defined using the\n\ 6380 proleptic Gregorian calendar without the insertion of leap seconds and\n\ 6381 continuous time is defined as the number of seconds since the Unix\n\ 6382 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\ 6383 broken-down and continuous time are possible, see plconfigtime.\n\ 6385 Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\ 6389 This function is used in example 29.\n\ 6395 plbtime(year, month, day, hour, min, sec, ctime)\n\ 6399 year (PLINT_NC_SCALAR, output) : Returned value of years with\n\ 6400 positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\ 6401 non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\ 6404 month (PLINT_NC_SCALAR, output) : Returned value of month within\n\ 6405 the year in the range from 0 (January) to 11 (December).\n\ 6407 day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\ 6408 month in the range from 1 to 31.\n\ 6410 hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\ 6411 day in the range from 0 to 23.\n\ 6413 min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\ 6414 hour in the range from 0 to 59\n\ 6416 sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\ 6417 minute in range from 0. to 60.\n\ 6419 ctime (PLFLT, input) : Continuous time from which the broken-down\n\ 6420 time is calculated.\n\ 6423 Get current stream number\n\ 6427 Gets the number of the current output stream. See also plsstrm.\n\ 6429 Redacted form: plgstrm(p_strm)\n\ 6431 This function is used in example 1,20.\n\ 6441 p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\ 6445 Draw a line in 3 space\n\ 6449 Draws line in 3 space defined by n points in x, y, and z. You must\n\ 6450 first set up the viewport, the 2d viewing window (in world\n\ 6451 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\ 6454 Redacted form: plline3(x, y, z)\n\ 6456 This function is used in example 18.\n\ 6462 plline3(n, x, y, z)\n\ 6466 n (PLINT, input) : Number of points defining line.\n\ 6468 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\ 6471 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\ 6474 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\ 6478 Load Hershey fonts\n\ 6482 Loads the Hershey fonts used for text and symbols. This routine may\n\ 6483 be called before or after initializing PLplot. If not explicitly\n\ 6484 called before PLplot initialization, then by default that\n\ 6485 initialization loads Hershey fonts with the extended character set.\n\ 6486 This routine only has a practical effect for devices that still use\n\ 6487 Hershey fonts (as opposed to modern devices that use unicode-aware\n\ 6488 system fonts instead of Hershey fonts).\n\ 6490 Redacted form: plfontld(fnt)\n\ 6492 This function is used in examples 1 and 7.\n\ 6502 fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\ 6503 A zero value specifies Hershey fonts with the standard character\n\ 6504 set and a non-zero value (the default assumed if plfontld is never\n\ 6505 called) specifies Hershey fonts with the extended character set.\n\ 6508 Set any command-line option\n\ 6512 Set any command-line option internally from a program before it\n\ 6513 invokes plinit. opt is the name of the command-line option and optarg\n\ 6514 is the corresponding command-line option argument.\n\ 6516 This function returns 0 on success.\n\ 6518 Redacted form: plsetopt(opt, optarg)\n\ 6520 This function is used in example 14.\n\ 6526 PLINT plsetopt(opt, optarg)\n\ 6530 opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\ 6531 the command-line option.\n\ 6533 optarg (PLCHAR_VECTOR, input) : An ascii character string\n\ 6534 containing the argument of the command-line option.\n\ 6537 Plot all or a subset of Shapefile data using lines in world coordinates\n\ 6541 Plot all or a subset of Shapefile data using lines in world\n\ 6542 coordinates. Our 19th standard example demonstrates how to use this\n\ 6543 function. This function plots data from a Shapefile using lines as in\n\ 6544 plmap, however it also has the option of also only drawing specified\n\ 6545 elements from the Shapefile. The vector of indices of the required\n\ 6546 elements are passed as a function argument. The Shapefile data should\n\ 6547 include a metadata file (extension.dbf) listing all items within the\n\ 6548 Shapefile. This file can be opened by most popular spreadsheet\n\ 6549 programs and can be used to decide which indices to pass to this\n\ 6552 Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\ 6555 This function is used in example 19.\n\ 6561 plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\ 6565 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\ 6566 transform the coordinates given in the shapefile into a plot\n\ 6567 coordinate system. By using this transform, we can change from a\n\ 6568 longitude, latitude coordinate to a polar stereographic project,\n\ 6569 for example. Initially, x[0]..[n-1] are the longitudes and\n\ 6570 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\ 6571 mapform(), x[] and y[] should be replaced by the corresponding\n\ 6572 plot coordinates. If no transform is desired, mapform can be\n\ 6573 replaced by NULL.\n\ 6575 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\ 6576 the file name of a set of Shapefile files without the file\n\ 6579 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\ 6580 be in the same units as used by the Shapefile. You could use a\n\ 6581 very large negative number to plot everything, but you can improve\n\ 6582 performance by limiting the area drawn. The units must match those\n\ 6583 of the Shapefile projection, which may be for example longitude or\n\ 6584 distance. The value of minx must be less than the value of maxx.\n\ 6586 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\ 6587 use a very large number to plot everything, but you can improve\n\ 6588 performance by limiting the area drawn.\n\ 6590 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\ 6591 be in the same units as used by the Shapefile. You could use a\n\ 6592 very large negative number to plot everything, but you can improve\n\ 6593 performance by limiting the area drawn. The units must match those\n\ 6594 of the Shapefile projection, which may be for example latitude or\n\ 6595 distance. The value of miny must be less than the value of maxy.\n\ 6597 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\ 6598 use a very large number to plot everything, but you can improve\n\ 6599 performance by limiting the area drawn.\n\ 6601 plotentries (PLINT_VECTOR, input) : A vector containing the\n\ 6602 zero-based indices of the Shapefile elements which will be drawn.\n\ 6604 plotentries to NULL will plot all elements of the Shapefile.\n\ 6606 nplotentries (PLINT, input) : The number of items in\n\ 6607 plotentries. Ignored if\n\ 6608 plotentries is NULL.\n\ 6611 Used to globally turn color output on/off\n\ 6615 Used to globally turn color output on/off for those drivers/devices\n\ 6618 Redacted form: plscolor(color)\n\ 6620 This function is used in example 31.\n\ 6630 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\ 6631 turned off. If non-zero, color is turned on.\n\ 6634 Wait for graphics input event and translate to world coordinates.\n\ 6638 Wait for graphics input event and translate to world coordinates.\n\ 6639 Returns 0 if no translation to world coordinates is possible.\n\ 6641 This function returns 1 on success and 0 if no translation to world\n\ 6642 coordinates is possible.\n\ 6644 Redacted form: plGetCursor(gin)\n\ 6646 This function is used in examples 1 and 20.\n\ 6652 PLINT plGetCursor(gin)\n\ 6656 gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\ 6657 which will contain the output. The structure is not allocated by\n\ 6658 the routine and must exist before the function is called.\n\ 6661 Get the current device (keyword) name\n\ 6665 Get the current device (keyword) name. Note: you must have allocated\n\ 6666 space for this (80 characters is safe).\n\ 6668 Redacted form: plgdev(p_dev)\n\ 6670 This function is used in example 14.\n\ 6680 p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\ 6681 (with preallocated length of 80 characters or more) containing the\n\ 6682 device (keyword) name.\n\ 6685 Add a point to a strip chart\n\ 6689 Add a point to a given pen of a given strip chart. There is no need\n\ 6690 for all pens to have the same number of points or to be equally\n\ 6691 sampled in the x coordinate. Allocates memory and rescales as\n\ 6694 Redacted form: plstripa(id, pen, x, y)\n\ 6696 This function is used in example 17.\n\ 6702 plstripa(id, pen, x, y)\n\ 6706 id (PLINT, input) : Identification number of the strip chart (set\n\ 6709 pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\ 6711 x (PLFLT, input) : X coordinate of point to plot.\n\ 6713 y (PLFLT, input) : Y coordinate of point to plot.\n\ 6716 Create a 4-pen strip chart\n\ 6720 Create a 4-pen strip chart, to be used afterwards by plstripa\n\ 6722 Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\ 6723 ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\ 6724 styline, legline, labx, laby, labz)\n\ 6727 This function is used in example 17.\n\ 6733 plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\ 6737 id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\ 6738 number of the strip chart to use on plstripa and plstripd.\n\ 6740 xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\ 6741 the x-axis specification as in plbox.\n\ 6743 yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\ 6744 the y-axis specification as in plbox.\n\ 6746 xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\ 6747 change as data are added.\n\ 6749 xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\ 6750 change as data are added.\n\ 6752 xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\ 6753 is multiplied by the factor (1 +\n\ 6756 ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\ 6757 change as data are added.\n\ 6759 ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\ 6760 change as data are added.\n\ 6762 xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\ 6764 ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\ 6766 y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\ 6767 true, otherwise not.\n\ 6769 acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\ 6770 otherwise slide display.\n\ 6772 colbox (PLINT, input) : Plot box color index (cmap0).\n\ 6774 collab (PLINT, input) : Legend color index (cmap0).\n\ 6776 colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\ 6777 indices for the 4 pens.\n\ 6779 styline (PLINT_VECTOR, input) : A vector containing the line style\n\ 6780 indices for the 4 pens.\n\ 6782 legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\ 6783 strings containing legends for the 4 pens.\n\ 6785 labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\ 6786 the label for the x axis.\n\ 6788 laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\ 6789 the label for the y axis.\n\ 6791 labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\ 6795 Deletes and releases memory used by a strip chart\n\ 6799 Deletes and releases memory used by a strip chart.\n\ 6801 Redacted form: plstripd(id)\n\ 6803 This function is used in example 17.\n\ 6813 id (PLINT, input) : Identification number of strip chart to delete.\n\ 6816 Specify viewport using coordinates and aspect ratio\n\ 6820 Device-independent routine for setting up the viewport. The viewport\n\ 6821 is chosen to be the largest with the given aspect ratio that fits\n\ 6822 within the specified region (in terms of normalized subpage\n\ 6823 coordinates). This routine is functionally equivalent to plvpor when\n\ 6824 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\ 6825 routine reserves no extra space at the edges for labels.\n\ 6827 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\ 6829 This function is used in example 9.\n\ 6835 plvpas(xmin, xmax, ymin, ymax, aspect)\n\ 6839 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\ 6840 left-hand edge of the viewport.\n\ 6842 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\ 6843 right-hand edge of the viewport.\n\ 6845 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\ 6846 bottom edge of the viewport.\n\ 6848 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\ 6849 edge of the viewport.\n\ 6851 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\ 6855 Assign a function to use for generating custom axis labels\n\ 6859 This function allows a user to provide their own function to provide\n\ 6860 axis label text. The user function is given the numeric value for a\n\ 6861 point on an axis and returns a string label to correspond with that\n\ 6862 value. Custom axis labels can be enabled by passing appropriate\n\ 6863 arguments to plenv, plbox, plbox3 and similar functions.\n\ 6865 This function is used in example 19.\n\ 6871 plslabelfunc(label_func, label_data)\n\ 6875 label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\ 6876 label function. In order to reset to the default labelling, set\n\ 6877 this to NULL. The labelling function parameters are, in order:\n\ 6878 axis: This indicates which axis a label is being requested for.\n\ 6879 The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\ 6881 value: This is the value along the axis which is being labelled.\n\ 6883 label_text: The string representation of the label value.\n\ 6885 length: The maximum length in characters allowed for label_text.\n\ 6888 label_data (PLPointer, input) : This parameter may be used to pass\n\ 6889 data to the label_func function.\n\ 6892 Set length of major ticks\n\ 6896 This sets up the length of the major ticks. The actual length is the\n\ 6897 product of the default length and a scaling factor as for character\n\ 6900 Redacted form: plsmaj(def, scale)\n\ 6902 This function is used in example 29.\n\ 6908 plsmaj(def, scale)\n\ 6912 def (PLFLT, input) : The default length of a major tick in\n\ 6913 millimeters, should be set to zero if the default length is to\n\ 6914 remain unchanged.\n\ 6916 scale (PLFLT, input) : Scale factor to be applied to default to get\n\ 6917 actual tick length.\n\ 6920 Get the current library version number\n\ 6924 Get the current library version number. Note: you must have allocated\n\ 6925 space for this (80 characters is safe).\n\ 6927 Redacted form: plgver(p_ver)\n\ 6929 This function is used in example 1.\n\ 6939 p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\ 6940 (with preallocated length of 80 characters or more) containing the\n\ 6941 PLplot version number.\n\ 6944 Set format of numerical label for contours\n\ 6948 Set format of numerical label for contours.\n\ 6950 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\ 6952 This function is used example 9.\n\ 6958 pl_setcontlabelformat(lexp, sigdig)\n\ 6962 lexp (PLINT, input) : If the contour numerical label is greater\n\ 6963 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\ 6964 format is used. Default value of lexp is 4.\n\ 6966 sigdig (PLINT, input) : Number of significant digits. Default\n\ 6970 Parse command-line arguments\n\ 6974 Parse command-line arguments.\n\ 6976 plparseopts removes all recognized flags (decreasing argc\n\ 6977 accordingly), so that invalid input may be readily detected. It can\n\ 6978 also be used to process user command line flags. The user can merge\n\ 6979 an option table of type PLOptionTable into the internal option table\n\ 6980 info structure using plMergeOpts. Or, the user can specify that ONLY\n\ 6981 the external table(s) be parsed by calling plClearOpts before\n\ 6984 The default action taken by plparseopts is as follows:\n\ 6985 Returns with an error if an unrecognized option or badly formed\n\ 6986 option-value pair are encountered.\n\ 6987 Returns immediately (return code 0) when the first non-option command\n\ 6988 line argument is found.\n\ 6989 Returns with the return code of the option handler, if one was called.\n\ 6991 Deletes command line arguments from argv list as they are found, and\n\ 6992 decrements argc accordingly.\n\ 6993 Does not show \"invisible\" options in usage or help messages.\n\ 6994 Assumes the program name is contained in argv[0].\n\ 6996 These behaviors may be controlled through the\n\ 6999 Redacted form: General: plparseopts(argv, mode)\n\ 7002 This function is used in all of the examples.\n\ 7008 PLINT plparseopts(p_argc, argv, mode)\n\ 7012 p_argc (int *, input/output) : Number of arguments.\n\ 7014 argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\ 7015 strings containing *p_argc command-line arguments.\n\ 7017 mode (PLINT, input) : Parsing mode with the following\n\ 7018 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\ 7019 and all error messages enabled, including program exit when an\n\ 7020 error occurs. Anything on the command line that isn\'t recognized\n\ 7021 as a valid option or option argument is flagged as an error.\n\ 7022 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\ 7024 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\ 7026 PL_PARSE_SHOWALL (8) -- Show invisible options\n\ 7027 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\ 7028 pointer to the program name.\n\ 7029 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\ 7030 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\ 7031 unrecognized arguments.\n\ 7038 Initializing the plotting package. The program prompts for the device\n\ 7039 keyword or number of the desired output device. Hitting a RETURN in\n\ 7040 response to the prompt is the same as selecting the first device. If\n\ 7041 only one device is enabled when PLplot is installed, plstar will issue\n\ 7042 no prompt. The output device is divided into nx by ny subpages, each\n\ 7043 of which may be used independently. The subroutine pladv is used to\n\ 7044 advance from one subpage to the next.\n\ 7046 Redacted form: plstar(nx, ny)\n\ 7048 This function is used in example 1.\n\ 7058 nx (PLINT, input) : Number of subpages to divide output page in the\n\ 7061 ny (PLINT, input) : Number of subpages to divide output page in the\n\ 7065 Get FCI (font characterization integer)\n\ 7069 Gets information about the current font using the FCI approach. See\n\ 7070 the PLplot documentation for more information.\n\ 7072 Redacted form: plgfci(p_fci)\n\ 7074 This function is used in example 23.\n\ 7084 p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\ 7088 Set family file parameters\n\ 7092 Sets variables dealing with output file familying. Does nothing if\n\ 7093 familying not supported by the driver. This routine, if used, must be\n\ 7094 called before initializing PLplot. See the PLplot documentation for\n\ 7095 more information.\n\ 7097 Redacted form: plsfam(fam, num, bmax)\n\ 7099 This function is used in examples 14 and 31.\n\ 7105 plsfam(fam, num, bmax)\n\ 7109 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\ 7112 num (PLINT, input) : Current family file number.\n\ 7114 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\ 7118 Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\ 7122 This is a variant of plscmap1l that supports alpha channel\n\ 7123 transparency. It sets cmap1 colors using a piece-wise linear\n\ 7124 relationship between cmap1 intensity index (0.0-1.0) and position in\n\ 7125 HLS or RGB color space (see the PLplot documentation) with alpha\n\ 7126 transparency value (0.0-1.0). It may be called at any time.\n\ 7128 Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\ 7129 alpha, alt_hue_path)\n\ 7131 This function is used in example 30.\n\ 7137 plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\ 7141 itype (PLBOOL, input) : true: RGB, false: HLS.\n\ 7143 npts (PLINT, input) : number of control points.\n\ 7145 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\ 7146 intensity index (0.0-1.0) in ascending order for each control\n\ 7149 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\ 7150 coordinate (H or R) for each control point.\n\ 7152 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\ 7153 coordinate (L or G) for each control point.\n\ 7155 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\ 7156 coordinate (S or B) for each control point.\n\ 7158 alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\ 7159 transparency value (0.0-1.0) for each control point.\n\ 7161 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\ 7162 npts - 1 elements) containing the alternative interpolation method\n\ 7163 Boolean value for each control point interval. (alt_hue_path[i]\n\ 7164 refers to the interpolation interval between the i and i + 1\n\ 7168 Set page parameters\n\ 7172 Sets the page configuration (optional). If an individual parameter is\n\ 7173 zero then that parameter value is not updated. Not all parameters are\n\ 7174 recognized by all drivers and the interpretation is device-dependent.\n\ 7175 The X-window driver uses the length and offset parameters to determine\n\ 7176 the window size and location. The length and offset values are\n\ 7177 expressed in units that are specific to the current driver. For\n\ 7178 instance: screen drivers will usually interpret them as number of\n\ 7179 pixels, whereas printer drivers will usually use mm.\n\ 7181 This routine, if used, must be called before initializing PLplot. It\n\ 7182 may be called at later times for interactive drivers to change only\n\ 7183 the dpi for subsequent redraws which you can force via a call to\n\ 7184 plreplot. If this function is not called then the page size defaults\n\ 7185 to landscape A4 for drivers which use real world page sizes and 744\n\ 7186 pixels wide by 538 pixels high for raster drivers. The default value\n\ 7187 for dx and dy is 90 pixels per inch for raster drivers.\n\ 7191 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\ 7193 This function is used in examples 14 and 31.\n\ 7199 plspage(xp, yp, xleng, yleng, xoff, yoff)\n\ 7203 xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\ 7204 by raster drivers, ignored by drivers which use \"real world\" units\n\ 7207 yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\ 7208 by raster drivers, ignored by drivers which use \"real world\" units\n\ 7211 xleng (PLINT, input) : Page length, x.\n\ 7213 yleng (PLINT, input) : Page length, y.\n\ 7215 xoff (PLINT, input) : Page offset, x.\n\ 7217 yoff (PLINT, input) : Page offset, y.\n\ 7220 Set precision in numeric labels\n\ 7224 Sets the number of places after the decimal point in numeric labels.\n\ 7226 Redacted form: plprec(setp, prec)\n\ 7228 This function is used in example 29.\n\ 7234 plprec(setp, prec)\n\ 7238 setp (PLINT, input) : If setp is equal to 0 then PLplot\n\ 7239 automatically determines the number of places to use after the\n\ 7240 decimal point in numeric labels (like those used to label axes).\n\ 7241 If setp is 1 then prec sets the number of places.\n\ 7243 prec (PLINT, input) : The number of characters to draw after the\n\ 7244 decimal point in numeric labels.\n\ 7247 Copy state parameters from the reference stream to the current stream\n\ 7251 Copies state parameters from the reference stream to the current\n\ 7252 stream. Tell driver interface to map device coordinates unless flags\n\ 7255 This function is used for making save files of selected plots (e.g.\n\ 7256 from the TK driver). After initializing, you can get a copy of the\n\ 7257 current plot to the specified device by switching to this stream and\n\ 7258 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\ 7259 appropriate. The plot buffer must have previously been enabled (done\n\ 7260 automatically by some display drivers, such as X).\n\ 7262 Redacted form: plcpstrm(iplsr, flags)\n\ 7264 This function is used in example 1,20.\n\ 7270 plcpstrm(iplsr, flags)\n\ 7274 iplsr (PLINT, input) : Number of reference stream.\n\ 7276 flags (PLBOOL, input) : If flags is set to true the device\n\ 7277 coordinates are not copied from the reference to current stream.\n\ 7280 Plot a glyph at the specified points\n\ 7284 Plot a glyph at the specified points. (This function is largely\n\ 7285 superseded by plstring which gives access to many[!] more glyphs.)\n\ 7286 code=-1 means try to just draw a point. Right now it\'s just a move\n\ 7287 and a draw at the same place. Not ideal, since a sufficiently\n\ 7288 intelligent output device may optimize it away, or there may be faster\n\ 7289 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\ 7290 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\ 7291 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\ 7292 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\ 7293 code <= 127 the corresponding printable ASCII character is plotted.\n\ 7295 Redacted form: plpoin(x, y, code)\n\ 7297 This function is used in examples 1, 6, 14, and 29.\n\ 7303 plpoin(n, x, y, code)\n\ 7307 n (PLINT, input) : Number of points in the x and y vectors.\n\ 7309 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\ 7312 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\ 7315 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\ 7316 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\ 7317 each of the n points.\n\ 7320 Enter or leave xor mode\n\ 7324 Enter (when mode is true) or leave (when mode is false) xor mode for\n\ 7325 those drivers (e.g., the xwin driver) that support it. Enables\n\ 7326 erasing plots by drawing twice the same line, symbol, etc. If driver\n\ 7327 is not capable of xor operation it returns a status of false.\n\ 7329 Redacted form: plxormod(mode, status)\n\ 7331 This function is used in examples 1 and 20.\n\ 7337 plxormod(mode, status)\n\ 7341 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\ 7342 is false means leave xor mode.\n\ 7344 status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\ 7345 modestatus of true (false) means driver is capable (incapable) of\n\ 7349 Get viewport limits in normalized device coordinates\n\ 7353 Get viewport limits in normalized device coordinates.\n\ 7355 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\ 7358 This function is used in example 31.\n\ 7364 plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\ 7368 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\ 7369 viewport limit of the normalized device coordinate in x.\n\ 7371 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\ 7372 viewport limit of the normalized device coordinate in x.\n\ 7374 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\ 7375 viewport limit of the normalized device coordinate in y.\n\ 7377 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\ 7378 viewport limit of the normalized device coordinate in y.\n\ 7381 Plot surface mesh\n\ 7385 Plots a surface mesh within the environment set up by plw3d. The\n\ 7386 surface is defined by the matrix z[\n\ 7388 ny] , the point z[i][j] being the value of the function at (\n\ 7390 y[j]). Note that the points in vectors x and y do not need to be\n\ 7391 equally spaced, but must be stored in ascending order. The parameter\n\ 7392 opt controls the way in which the surface is displayed. For further\n\ 7393 details see the PLplot documentation.\n\ 7395 Redacted form: plmesh(x, y, z, opt)\n\ 7397 This function is used in example 11.\n\ 7403 plmesh(x, y, z, nx, ny, opt)\n\ 7407 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\ 7408 which the function is evaluated.\n\ 7410 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\ 7411 which the function is evaluated.\n\ 7413 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\ 7414 plot. Should have dimensions of\n\ 7418 nx (PLINT, input) : Number of x values at which function has been\n\ 7421 ny (PLINT, input) : Number of y values at which function has been\n\ 7424 opt (PLINT, input) : Determines the way in which the surface is\n\ 7425 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\ 7426 function of x for each value of y[j] .\n\ 7427 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\ 7428 for each value of x[i] .\n\ 7429 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\ 7430 at which function is defined.\n\ 7433 Magnitude colored plot surface mesh with contour\n\ 7437 A more powerful form of plmesh: the surface mesh can be colored\n\ 7438 accordingly to the current z value being plotted, a contour plot can\n\ 7439 be drawn at the base XY plane, and a curtain can be drawn between the\n\ 7440 plotted function border and the base XY plane.\n\ 7442 Redacted form: plmeshc(x, y, z, opt, clevel)\n\ 7444 This function is used in example 11.\n\ 7450 plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\ 7454 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\ 7455 which the function is evaluated.\n\ 7457 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\ 7458 which the function is evaluated.\n\ 7460 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\ 7461 plot. Should have dimensions of\n\ 7465 nx (PLINT, input) : Number of x values at which function is\n\ 7468 ny (PLINT, input) : Number of y values at which function is\n\ 7471 opt (PLINT, input) : Determines the way in which the surface is\n\ 7472 represented. To specify more than one option just add the options,\n\ 7473 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\ 7474 showing z as a function of x for each value of y[j] .\n\ 7475 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\ 7476 for each value of x[i] .\n\ 7477 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\ 7478 at which function is defined.\n\ 7479 opt=MAG_COLOR : Each line in the mesh is colored according to\n\ 7480 the z value being plotted. The color is used from the current\n\ 7482 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\ 7486 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\ 7487 the borders of the plotted function.\n\ 7490 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\ 7493 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\ 7496 End plotting session for current stream\n\ 7500 Ends a plotting session for the current output stream only. See\n\ 7501 plsstrm for more info.\n\ 7503 Redacted form: plend1()\n\ 7505 This function is used in examples 1 and 20.\n\ 7514 Get y axis parameters\n\ 7518 Identical to plgxax, except that arguments are flags for y axis. See\n\ 7519 the description of plgxax for more detail.\n\ 7521 Redacted form: plgyax(p_digmax, p_digits)\n\ 7523 This function is used in example 31.\n\ 7529 plgyax(p_digmax, p_digits)\n\ 7533 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\ 7534 number of digits for the y axis. If nonzero, the printed label\n\ 7535 has been switched to a floating-point representation when the\n\ 7536 number of digits exceeds this value.\n\ 7538 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\ 7539 number of digits for the numeric labels (y axis) from the last\n\ 7543 Set plot orientation\n\ 7547 Set plot orientation parameter which is multiplied by 90 degrees to\n\ 7548 obtain the angle of rotation. Note, arbitrary rotation parameters\n\ 7549 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\ 7550 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\ 7551 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\ 7552 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\ 7553 not called the default value of rot is 0.\n\ 7555 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\ 7556 probably want to change the aspect ratio to a value suitable for the\n\ 7557 plot orientation using a call to plsdidev or the command-line options\n\ 7558 -a or -freeaspect. For more documentation of those options see the\n\ 7559 PLplot documentation. Such command-line options can be set internally\n\ 7560 using plsetopt or set directly using the command line and parsed using\n\ 7561 a call to plparseopts.\n\ 7563 Redacted form: plsdiori(rot)\n\ 7565 This function is not used in any examples.\n\ 7575 rot (PLFLT, input) : Plot orientation parameter.\n\ 7578 Plot a histogram from unbinned data\n\ 7582 Plots a histogram from n data points stored in the data vector. This\n\ 7583 routine bins the data into nbin bins equally spaced between datmin and\n\ 7584 datmax, and calls plbin to draw the resulting histogram. Parameter\n\ 7585 opt allows, among other things, the histogram either to be plotted in\n\ 7586 an existing window or causes plhist to call plenv with suitable limits\n\ 7587 before plotting the histogram.\n\ 7589 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\ 7591 This function is used in example 5.\n\ 7597 plhist(n, data, datmin, datmax, nbin, opt)\n\ 7601 n (PLINT, input) : Number of data points.\n\ 7603 data (PLFLT_VECTOR, input) : A vector containing the values of the\n\ 7606 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\ 7608 datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\ 7610 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\ 7611 divide the interval xmin to xmax.\n\ 7613 opt (PLINT, input) : Is a combination of several flags:\n\ 7614 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\ 7615 the histogram data, the outer bins are expanded to fill up the\n\ 7616 entire x-axis, data outside the given extremes are assigned to the\n\ 7617 outer bins and bins of zero height are simply drawn.\n\ 7618 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\ 7619 to fit the histogram data, without this flag, plenv is called\n\ 7620 to set the world coordinates.\n\ 7621 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\ 7622 extremes are not taken into account. This option should\n\ 7623 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\ 7624 properly present the data.\n\ 7625 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\ 7626 size as the ones inside.\n\ 7627 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\ 7628 (there is a gap for such bins).\n\ 7631 End plotting session\n\ 7635 Ends a plotting session, tidies up all the output files, switches\n\ 7636 interactive devices back into text mode and frees up any memory that\n\ 7637 was allocated. Must be called before end of program.\n\ 7639 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\ 7640 wait state after a call to plend or other functions which trigger the\n\ 7641 end of a plot page. To avoid this, use the plspause function.\n\ 7643 Redacted form: plend()\n\ 7645 This function is used in all of the examples.\n\ 7654 Plot shaded 3-d surface plot\n\ 7658 Plots a three-dimensional shaded surface plot within the environment\n\ 7659 set up by plw3d. The surface is defined by the two-dimensional matrix\n\ 7662 ny], the point z[i][j] being the value of the function at (\n\ 7664 y[j]). Note that the points in vectors x and y do not need to be\n\ 7665 equally spaced, but must be stored in ascending order. For further\n\ 7666 details see the PLplot documentation.\n\ 7668 Redacted form: plsurf3d(x, y, z, opt, clevel)\n\ 7670 This function is not used in any examples.\n\ 7676 plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\ 7680 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\ 7681 which the function is evaluated.\n\ 7683 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\ 7684 which the function is evaluated.\n\ 7686 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\ 7687 plot. Should have dimensions of\n\ 7691 nx (PLINT, input) : Number of x values at which function is\n\ 7694 ny (PLINT, input) : Number of y values at which function is\n\ 7697 opt (PLINT, input) : Determines the way in which the surface is\n\ 7698 represented. To specify more than one option just add the options,\n\ 7699 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\ 7700 connecting points at which function is defined.\n\ 7701 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\ 7705 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\ 7709 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\ 7710 the borders of the plotted function.\n\ 7711 opt=MAG_COLOR : the surface is colored according to the value\n\ 7712 of Z; if MAG_COLOR is not used, then the surface is colored\n\ 7713 according to the intensity of the reflected light in the\n\ 7714 surface from a light source whose position is set using\n\ 7718 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\ 7721 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\ 7724 Set device-compression level\n\ 7728 Set device-compression level. Only used for drivers that provide\n\ 7729 compression. This function, if used, should be invoked before a call\n\ 7732 Redacted form: plscompression(compression)\n\ 7734 This function is used in example 31.\n\ 7740 plscompression(compression)\n\ 7744 compression (PLINT, input) : The desired compression level. This is\n\ 7745 a device-dependent value. Currently only the jpeg and png devices\n\ 7746 use these values. For jpeg value is the jpeg quality which should\n\ 7747 normally be in the range 0-95. Higher values denote higher quality\n\ 7748 and hence larger image sizes. For png values are in the range -1\n\ 7749 to 99. Values of 0-9 are taken as the compression level for zlib.\n\ 7750 A value of -1 denotes the default zlib compression level. Values\n\ 7751 in the range 10-99 are divided by 10 and then used as the zlib\n\ 7752 compression level. Higher compression levels correspond to greater\n\ 7753 compression and small file sizes at the expense of more\n\ 7757 Get the current device-compression setting\n\ 7761 Get the current device-compression setting. This parameter is only\n\ 7762 used for drivers that provide compression.\n\ 7764 Redacted form: plgcompression(compression)\n\ 7766 This function is used in example 31.\n\ 7772 plgcompression(compression)\n\ 7776 compression (PLINT_NC_SCALAR, output) : Returned value of the\n\ 7777 compression setting for the current device.\n\ 7780 Advance the (sub-)page\n\ 7784 Advances to the next subpage if sub=0, performing a page advance if\n\ 7785 there are no remaining subpages on the current page. If subpages\n\ 7786 aren\'t being used, pladv(0) will always advance the page. If page>0,\n\ 7787 PLplot switches to the specified subpage. Note that this allows you\n\ 7788 to overwrite a plot on the specified subpage; if this is not what you\n\ 7789 intended, use pleop followed by plbop to first advance the page. This\n\ 7790 routine is called automatically (with page=0) by plenv, but if plenv\n\ 7791 is not used, pladv must be called after initializing PLplot but before\n\ 7792 defining the viewport.\n\ 7794 Redacted form: pladv(page)\n\ 7796 This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\ 7807 page (PLINT, input) : Specifies the subpage number (starting from 1\n\ 7808 in the top left corner and increasing along the rows) to which to\n\ 7809 advance. Set to zero to advance to the next subpage (or to the\n\ 7810 next page if subpages are not being used).\n\ 7813 Set parameters of contour labelling other than format of numerical label\n\ 7817 Set parameters of contour labelling other than those handled by\n\ 7818 pl_setcontlabelformat.\n\ 7820 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\ 7822 This function is used in example 9.\n\ 7828 pl_setcontlabelparam(offset, size, spacing, active)\n\ 7832 offset (PLFLT, input) : Offset of label from contour line (if set\n\ 7833 to 0.0, labels are printed on the lines). Default value is 0.006.\n\ 7835 size (PLFLT, input) : Font height for contour labels (normalized).\n\ 7836 Default value is 0.3.\n\ 7838 spacing (PLFLT, input) : Spacing parameter for contour labels.\n\ 7839 Default value is 0.1.\n\ 7841 active (PLINT, input) : Activate labels. Set to 1 if you want\n\ 7842 contour labels on. Default is off (0).\n\ 7845 Set family, style and weight of the current font\n\ 7849 Sets the current font. See the PLplot documentation for more\n\ 7850 information on font selection.\n\ 7852 Redacted form: plsfont(family, style, weight)\n\ 7854 This function is used in example 23.\n\ 7860 plsfont(family, style, weight)\n\ 7864 family (PLINT, input) : Font family to select for the current font.\n\ 7865 The available values are given by the PL_FCI_* constants in\n\ 7866 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\ 7867 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\ 7868 signifies that the font family should not be altered.\n\ 7870 style (PLINT, input) : Font style to select for the current font.\n\ 7871 The available values are given by the PL_FCI_* constants in\n\ 7872 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\ 7873 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\ 7874 should not be altered.\n\ 7876 weight (PLINT, input) : Font weight to select for the current font.\n\ 7877 The available values are given by the PL_FCI_* constants in\n\ 7878 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\ 7879 negative value signifies that the font weight should not be\n\ 7883 Sets the 3D position of the light source\n\ 7887 Sets the 3D position of the light source for use with plsurf3d and\n\ 7890 Redacted form: pllightsource(x, y, z)\n\ 7892 This function is used in example 8.\n\ 7898 pllightsource(x, y, z)\n\ 7902 x (PLFLT, input) : X-coordinate of the light source.\n\ 7904 y (PLFLT, input) : Y-coordinate of the light source.\n\ 7906 z (PLFLT, input) : Z-coordinate of the light source.\n\ 7913 Draws line defined by n points in x and y.\n\ 7915 Redacted form: plline(x, y)\n\ 7917 This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\ 7928 n (PLINT, input) : Number of points defining line.\n\ 7930 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\ 7933 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\ 7941 Sets the pen width.\n\ 7943 Redacted form: plwidth(width)\n\ 7945 This function is used in examples 1 and 2.\n\ 7955 width (PLFLT, input) : The desired pen width. If width is negative\n\ 7956 or the same as the previous value no action is taken. width = 0.\n\ 7957 should be interpreted as as the minimum valid pen width for the\n\ 7958 device. The interpretation of positive width values is also\n\ 7959 device dependent.\n\ 7962 Draw linear gradient inside polygon\n\ 7966 Draw a linear gradient using cmap1 inside the polygon defined by the n\n\ 7969 y[i]). Interpretation of the polygon is the same as for plfill. The\n\ 7970 polygon coordinates and the gradient angle are all expressed in world\n\ 7971 coordinates. The angle from the x axis for both the rotated\n\ 7972 coordinate system and the gradient vector is specified by angle. The\n\ 7973 magnitude of the gradient vector is the difference between the maximum\n\ 7974 and minimum values of x for the vertices in the rotated coordinate\n\ 7975 system. The origin of the gradient vector can be interpreted as being\n\ 7976 anywhere on the line corresponding to the minimum x value for the\n\ 7977 vertices in the rotated coordinate system. The distance along the\n\ 7978 gradient vector is linearly transformed to the independent variable of\n\ 7979 color map 1 which ranges from 0. at the tail of the gradient vector to\n\ 7980 1. at the head of the gradient vector. What is drawn is the RGBA\n\ 7981 color corresponding to the independent variable of cmap1. For more\n\ 7982 information about cmap1 (see the PLplot documentation).\n\ 7984 Redacted form: plgradient(x,y,angle)\n\ 7986 This function is used in examples 25 and 30.\n\ 7992 plgradient(n, x, y, angle)\n\ 7996 n (PLINT, input) : Number of vertices in polygon.\n\ 7998 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\ 8001 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\ 8004 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\ 8008 Flushes the output stream\n\ 8012 Flushes the output stream. Use sparingly, if at all.\n\ 8014 Redacted form: plflush()\n\ 8016 This function is used in examples 1 and 14.\n\ 8025 Get plot orientation\n\ 8029 Get plot orientation parameter which is multiplied by 90 degrees to\n\ 8030 obtain the angle of rotation. Note, arbitrary rotation parameters\n\ 8031 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\ 8032 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\ 8033 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\ 8034 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\ 8035 not been called the default value pointed to by p_rot will be 0.\n\ 8037 Redacted form: plgdiori(p_rot)\n\ 8039 This function is not used in any examples.\n\ 8049 p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\ 8053 Set x axis parameters\n\ 8057 Sets values of the digmax and digits flags for the x axis. See the\n\ 8058 PLplot documentation for more information.\n\ 8060 Redacted form: plsxax(digmax, digits)\n\ 8062 This function is used in example 31.\n\ 8068 plsxax(digmax, digits)\n\ 8072 digmax (PLINT, input) : Variable to set the maximum number of\n\ 8073 digits for the x axis. If nonzero, the printed label will be\n\ 8074 switched to a floating-point representation when the number of\n\ 8075 digits exceeds digmax.\n\ 8077 digits (PLINT, input) : Field digits value. Currently, changing\n\ 8078 its value here has no effect since it is set only by plbox or\n\ 8079 plbox3. However, the user may obtain its value after a call to\n\ 8080 either of these functions by calling plgxax.\n\ 8083 Get viewport limits in world coordinates\n\ 8087 Get viewport limits in world coordinates.\n\ 8089 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\ 8092 This function is used in example 31.\n\ 8098 plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\ 8102 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\ 8103 viewport limit of the world coordinate in x.\n\ 8105 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\ 8106 viewport limit of the world coordinate in x.\n\ 8108 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\ 8109 viewport limit of the world coordinate in y.\n\ 8111 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\ 8112 viewport limit of the world coordinate in y.\n\ 8115 Shade regions on the basis of value\n\ 8119 Shade regions on the basis of value. This is the high-level routine\n\ 8120 for making continuous color shaded plots with cmap1 while plshade\n\ 8121 should be used to plot individual shaded regions using either cmap0 or\n\ 8122 cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\ 8123 our supported languages.\n\ 8125 Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\ 8126 clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\ 8130 This function is used in examples 16, 21, and 22.\n\ 8136 plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\ 8140 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\ 8141 plot. Should have dimensions of\n\ 8145 nx (PLINT, input) : First dimension of matrix \"a\".\n\ 8147 ny (PLINT, input) : Second dimension of matrix \"a\".\n\ 8149 defined (PLDEFINED_callback, input) : Callback function specifying\n\ 8150 the region that should be plotted in the shade plot. This\n\ 8151 function accepts x and y coordinates as input arguments and must\n\ 8152 return 1 if the point is to be included in the shade plot and 0\n\ 8153 otherwise. If you want to plot the entire shade plot (the usual\n\ 8154 case), this argument should be set to NULL.\n\ 8156 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\ 8157 pltr below for how these arguments are used (only for the special case\n\ 8158 when the callback function\n\ 8159 pltr is not supplied).\n\ 8161 clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\ 8162 corresponding to the edges of each shaded region that will be\n\ 8163 plotted by this function. To work properly the levels should be\n\ 8166 nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\ 8167 of shade edge values in clevel).\n\ 8169 fill_width (PLFLT, input) : Defines the line width used by the fill\n\ 8172 cont_color (PLINT, input) : Defines cmap0 pen color used for\n\ 8173 contours defining edges of shaded regions. The pen color is only\n\ 8174 temporary set for the contour drawing. Set this value to zero or\n\ 8175 less if no shade edge contours are wanted.\n\ 8177 cont_width (PLFLT, input) : Defines line width used for contours\n\ 8178 defining edges of shaded regions. This value may not be honored\n\ 8179 by all drivers. The pen width is only temporary set for the\n\ 8180 contour drawing. Set this value to zero or less if no shade edge\n\ 8181 contours are wanted.\n\ 8183 fill (PLFILL_callback, input) : Callback routine used to fill the\n\ 8184 region. Use plfill for this purpose.\n\ 8186 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\ 8187 map to rectangles after coordinate transformation with pltrl.\n\ 8188 Otherwise, set rectangular to false. If rectangular is set to\n\ 8189 true, plshade tries to save time by filling large rectangles.\n\ 8190 This optimization fails if the coordinate transformation distorts\n\ 8191 the shape of rectangles. For example a plot in polar coordinates\n\ 8192 has to have rectangular set to false.\n\ 8194 pltr (PLTRANSFORM_callback, input) : A callback function that\n\ 8195 defines the transformation between the zero-based indices of the\n\ 8196 matrix a and world coordinates. If\n\ 8197 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\ 8198 indices of a are mapped to the range\n\ 8200 xmax and the y indices of a are mapped to the range\n\ 8202 ymax.For the C case, transformation functions are provided in the\n\ 8203 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\ 8204 pltr2 for arbitrary mappings respectively defined by vectors and\n\ 8205 matrices. In addition, C callback routines for the transformation\n\ 8206 can be supplied by the user such as the mypltr function in\n\ 8207 examples/c/x09c.c which provides a general linear transformation\n\ 8208 between index coordinates and world coordinates.For languages\n\ 8209 other than C you should consult the PLplot documentation for the\n\ 8210 details concerning how PLTRANSFORM_callback arguments are\n\ 8211 interfaced. However, in general, a particular pattern of\n\ 8212 callback-associated arguments such as a tr vector with 6 elements;\n\ 8213 xg and yg vectors; or xg and yg matrices are respectively\n\ 8214 interfaced to a linear-transformation routine similar to the above\n\ 8215 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\ 8216 sophisticated bindings (see, e.g., the PLplot documentation)\n\ 8217 support native language callbacks for handling index to\n\ 8218 world-coordinate transformations. Examples of these various\n\ 8219 approaches are given in examples/<language>x09*,\n\ 8220 examples/<language>x16*, examples/<language>x20*,\n\ 8221 examples/<language>x21*, and examples/<language>x22*, for all our\n\ 8222 supported languages.\n\ 8224 pltr_data (PLPointer, input) : Extra parameter to help pass\n\ 8225 information to pltr0, pltr1, pltr2, or whatever routine that is\n\ 8226 externally supplied.\n\ 8229 Plot color bar for image, shade or gradient plots\n\ 8233 Routine for creating a continuous color bar for image, shade, or\n\ 8234 gradient plots. (See pllegend for similar functionality for creating\n\ 8235 legends with discrete elements). The arguments of plcolorbar provide\n\ 8236 control over the location and size of the color bar as well as the\n\ 8237 location and characteristics of the elements (most of which are\n\ 8238 optional) within that color bar. The resulting color bar is clipped\n\ 8239 at the boundaries of the current subpage. (N.B. the adopted coordinate\n\ 8240 system used for some of the parameters is defined in the documentation\n\ 8241 of the position parameter.)\n\ 8243 Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\ 8244 position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\ 8245 low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\ 8246 labels, axis_opts, ticks, sub_ticks, values)\n\ 8248 This function is used in examples 16 and 33.\n\ 8254 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\ 8258 p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\ 8259 labelled and decorated color bar width in adopted coordinates.\n\ 8261 p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\ 8262 labelled and decorated color bar height in adopted coordinates.\n\ 8264 opt (PLINT, input) : opt contains bits controlling the overall\n\ 8265 color bar. The orientation (direction of the maximum value) of\n\ 8266 the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\ 8267 PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\ 8268 specified, the default orientation is toward the top if the\n\ 8269 colorbar is placed on the left or right of the viewport or toward\n\ 8270 the right if the colorbar is placed on the top or bottom of the\n\ 8271 viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\ 8272 (semitransparent) background for the color bar. If the\n\ 8273 PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\ 8274 color bar. The type of color bar must be specified with one of\n\ 8275 PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\ 8276 more than one of those bits is set only the first one in the above\n\ 8277 list is honored. The position of the (optional) label/title can be\n\ 8278 specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\ 8279 PL_LABEL_BOTTOM. If no label position bit is set then no label\n\ 8280 will be drawn. If more than one of this list of bits is specified,\n\ 8281 only the first one on the list is honored. End-caps for the color\n\ 8282 bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\ 8283 If a particular color bar cap option is not specified then no cap\n\ 8284 will be drawn for that end. As a special case for\n\ 8285 PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\ 8286 specified. If this option is provided then any tick marks and tick\n\ 8287 labels will be placed at the breaks between shaded segments. TODO:\n\ 8288 This should be expanded to support custom placement of tick marks\n\ 8289 and tick labels at custom value locations for any color bar type.\n\ 8291 position (PLINT, input) : position contains bits which control the\n\ 8292 overall position of the color bar and the definition of the\n\ 8293 adopted coordinates used for positions just like what is done for\n\ 8294 the position argument for pllegend. However, note that the\n\ 8295 defaults for the position bits (see below) are different than the\n\ 8296 pllegend case. The combination of the PL_POSITION_LEFT,\n\ 8297 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\ 8298 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\ 8299 the 16 possible standard positions (the 4 corners and centers of\n\ 8300 the 4 sides for both the inside and outside cases) of the color\n\ 8301 bar relative to the adopted coordinate system. The corner\n\ 8302 positions are specified by the appropriate combination of two of\n\ 8303 the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\ 8304 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\ 8305 value of one of those bits. The adopted coordinates are\n\ 8306 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\ 8307 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\ 8308 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\ 8309 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\ 8310 then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\ 8311 PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\ 8312 PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\ 8313 PL_POSITION_VIEWPORT.\n\ 8315 x (PLFLT, input) : X offset of the color bar position in adopted\n\ 8316 coordinates from the specified standard position of the color bar.\n\ 8317 For positive x, the direction of motion away from the standard\n\ 8318 position is inward/outward from the standard corner positions or\n\ 8319 standard left or right positions if the\n\ 8320 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\ 8321 For the standard top or bottom positions, the direction of motion\n\ 8322 is toward positive X.\n\ 8324 y (PLFLT, input) : Y offset of the color bar position in adopted\n\ 8325 coordinates from the specified standard position of the color bar.\n\ 8326 For positive y, the direction of motion away from the standard\n\ 8327 position is inward/outward from the standard corner positions or\n\ 8328 standard top or bottom positions if the\n\ 8329 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\ 8330 For the standard left or right positions, the direction of motion\n\ 8331 is toward positive Y.\n\ 8333 x_length (PLFLT, input) : Length of the body of the color bar in\n\ 8334 the X direction in adopted coordinates.\n\ 8336 y_length (PLFLT, input) : Length of the body of the color bar in\n\ 8337 the Y direction in adopted coordinates.\n\ 8339 bg_color (PLINT, input) : The cmap0 color of the background for the\n\ 8340 color bar (PL_COLORBAR_BACKGROUND).\n\ 8342 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\ 8343 for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\ 8345 bb_style (PLINT, input) : The pllsty style number for the\n\ 8346 bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\ 8348 low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\ 8349 bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\ 8351 high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\ 8352 color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\ 8354 cont_color (PLINT, input) : The cmap0 contour color for\n\ 8355 PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\ 8356 it will be interpreted according to the design of plshades.\n\ 8358 cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\ 8359 plots. This is passed directly to plshades, so it will be\n\ 8360 interpreted according to the design of plshades.\n\ 8362 n_labels (PLINT, input) : Number of labels to place around the\n\ 8365 label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\ 8368 labels (PLCHAR_MATRIX, input) : A vector of\n\ 8369 n_labels UTF-8 character strings containing the labels for the color\n\ 8370 bar. Ignored if no label position is specified with one of the\n\ 8371 PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\ 8372 PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\ 8373 corresponding label_opts field.\n\ 8375 n_axes (PLINT, input) : Number of axis definitions provided. This\n\ 8376 value must be greater than 0. It is typically 1 (numerical axis\n\ 8377 labels are provided for one of the long edges of the color bar),\n\ 8378 but it can be larger if multiple numerical axis labels for the\n\ 8379 long edges of the color bar are desired.\n\ 8381 axis_opts (PLCHAR_MATRIX, input) : A vector of\n\ 8382 n_axes ascii character strings containing options (interpreted as for\n\ 8383 plbox) for the color bar\'s axis definitions.\n\ 8385 ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\ 8386 spacing of the major tick marks (interpreted as for plbox) for the\n\ 8387 color bar\'s axis definitions.\n\ 8389 sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\ 8390 number of subticks (interpreted as for plbox) for the color bar\'s\n\ 8391 axis definitions.\n\ 8393 n_values (PLINT_VECTOR, input) : A vector containing the number of\n\ 8394 elements in each of the n_axes rows of the values matrix.\n\ 8396 values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\ 8397 values for the data range represented by the color bar. For a row\n\ 8398 index of i_axis (where 0 < i_axis < n_axes), the number of\n\ 8399 elements in the row is specified by n_values[i_axis]. For\n\ 8400 PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\ 8401 is 2, and the corresponding row elements of the values matrix are\n\ 8402 the minimum and maximum value represented by the colorbar. For\n\ 8403 PL_COLORBAR_SHADE, the number and values of the elements of a row\n\ 8404 of the values matrix is interpreted the same as the nlevel and\n\ 8405 clevel arguments of plshades.\n\ 8408 Get current subpage parameters\n\ 8412 Gets the size of the current subpage in millimeters measured from the\n\ 8413 bottom left hand corner of the output device page or screen. Can be\n\ 8414 used in conjunction with plsvpa for setting the size of a viewport in\n\ 8415 absolute coordinates (millimeters).\n\ 8417 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\ 8419 This function is used in example 23.\n\ 8425 plgspa(xmin, xmax, ymin, ymax)\n\ 8429 xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\ 8430 the left hand edge of the subpage in millimeters.\n\ 8432 xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\ 8433 the right hand edge of the subpage in millimeters.\n\ 8435 ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\ 8436 the bottom edge of the subpage in millimeters.\n\ 8438 ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\ 8439 the top edge of the subpage in millimeters.\n\ 8442 Shade individual region on the basis of value\n\ 8446 Shade individual region on the basis of value. Use plshades if you\n\ 8447 want to shade a number of contiguous regions using continuous colors.\n\ 8448 In particular the edge contours are treated properly in plshades. If\n\ 8449 you attempt to do contiguous regions with plshade the contours at the\n\ 8450 edge of the shade are partially obliterated by subsequent plots of\n\ 8451 contiguous shaded regions.\n\ 8453 Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\ 8454 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\ 8455 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\ 8458 This function is used in example 15.\n\ 8464 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\ 8468 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\ 8469 plot. Should have dimensions of\n\ 8473 nx (PLINT, input) : First dimension of the matrix \"a\".\n\ 8475 ny (PLINT, input) : Second dimension of the matrix \"a\".\n\ 8477 defined (PLDEFINED_callback, input) : Callback function specifying\n\ 8478 the region that should be plotted in the shade plot. This\n\ 8479 function accepts x and y coordinates as input arguments and must\n\ 8480 return 1 if the point is to be included in the shade plot and 0\n\ 8481 otherwise. If you want to plot the entire shade plot (the usual\n\ 8482 case), this argument should be set to NULL.\n\ 8484 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\ 8485 pltr below for how these arguments are used (only for the special case\n\ 8486 when the callback function\n\ 8487 pltr is not supplied).\n\ 8489 shade_min (PLFLT, input) : Defines the lower end of the interval to\n\ 8490 be shaded. If shade_max <= shade_min, plshade does nothing.\n\ 8492 shade_max (PLFLT, input) : Defines the upper end of the interval to\n\ 8493 be shaded. If shade_max <= shade_min, plshade does nothing.\n\ 8495 sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\ 8496 sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\ 8497 then sh_color is interpreted as a cmap1 argument in the range\n\ 8500 sh_color (PLFLT, input) : Defines color map index with integer\n\ 8501 value if cmap0 or value in range (0.0-1.0) if cmap1.\n\ 8503 sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\ 8505 min_color (PLINT, input) : Defines pen color, width used by the\n\ 8506 boundary of shaded region. The min values are used for the\n\ 8507 shade_min boundary, and the max values are used on the shade_max\n\ 8508 boundary. Set color and width to zero for no plotted boundaries.\n\ 8510 min_width (PLFLT, input) : Defines pen color, width used by the\n\ 8511 boundary of shaded region. The min values are used for the\n\ 8512 shade_min boundary, and the max values are used on the shade_max\n\ 8513 boundary. Set color and width to zero for no plotted boundaries.\n\ 8515 max_color (PLINT, input) : Defines pen color, width used by the\n\ 8516 boundary of shaded region. The min values are used for the\n\ 8517 shade_min boundary, and the max values are used on the shade_max\n\ 8518 boundary. Set color and width to zero for no plotted boundaries.\n\ 8520 max_width (PLFLT, input) : Defines pen color, width used by the\n\ 8521 boundary of shaded region. The min values are used for the\n\ 8522 shade_min boundary, and the max values are used on the shade_max\n\ 8523 boundary. Set color and width to zero for no plotted boundaries.\n\ 8525 fill (PLFILL_callback, input) : Routine used to fill the region.\n\ 8526 Use plfill. Future version of PLplot may have other fill\n\ 8529 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\ 8530 map to rectangles after coordinate transformation with pltrl.\n\ 8531 Otherwise, set rectangular to false. If rectangular is set to\n\ 8532 true, plshade tries to save time by filling large rectangles.\n\ 8533 This optimization fails if the coordinate transformation distorts\n\ 8534 the shape of rectangles. For example a plot in polar coordinates\n\ 8535 has to have rectangular set to false.\n\ 8537 pltr (PLTRANSFORM_callback, input) : A callback function that\n\ 8538 defines the transformation between the zero-based indices of the\n\ 8539 matrix a and world coordinates. If\n\ 8540 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\ 8541 indices of a are mapped to the range\n\ 8543 xmax and the y indices of a are mapped to the range\n\ 8545 ymax.For the C case, transformation functions are provided in the\n\ 8546 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\ 8547 pltr2 for arbitrary mappings respectively defined by vectors and\n\ 8548 matrices. In addition, C callback routines for the transformation\n\ 8549 can be supplied by the user such as the mypltr function in\n\ 8550 examples/c/x09c.c which provides a general linear transformation\n\ 8551 between index coordinates and world coordinates.For languages\n\ 8552 other than C you should consult the PLplot documentation for the\n\ 8553 details concerning how PLTRANSFORM_callback arguments are\n\ 8554 interfaced. However, in general, a particular pattern of\n\ 8555 callback-associated arguments such as a tr vector with 6 elements;\n\ 8556 xg and yg vectors; or xg and yg matrices are respectively\n\ 8557 interfaced to a linear-transformation routine similar to the above\n\ 8558 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\ 8559 sophisticated bindings (see, e.g., the PLplot documentation)\n\ 8560 support native language callbacks for handling index to\n\ 8561 world-coordinate transformations. Examples of these various\n\ 8562 approaches are given in examples/<language>x09*,\n\ 8563 examples/<language>x16*, examples/<language>x20*,\n\ 8564 examples/<language>x21*, and examples/<language>x22*, for all our\n\ 8565 supported languages.\n\ 8567 pltr_data (PLPointer, input) : Extra parameter to help pass\n\ 8568 information to pltr0, pltr1, pltr2, or whatever routine that is\n\ 8569 externally supplied.\n\ 8572 Calculate world coordinates and corresponding window index from relative device coordinates\n\ 8576 Calculate world coordinates, wx and wy, and corresponding window index\n\ 8577 from relative device coordinates, rx and ry.\n\ 8579 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\ 8582 This function is used in example 31.\n\ 8588 plcalc_world(rx, ry, wx, wy, window)\n\ 8592 rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\ 8593 the x coordinate.\n\ 8595 ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\ 8596 the y coordinate.\n\ 8598 wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\ 8599 coordinate corresponding to the relative device coordinates rx and\n\ 8602 wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\ 8603 coordinate corresponding to the relative device coordinates rx and\n\ 8606 window (PLINT_NC_SCALAR, output) : Returned value of the last\n\ 8607 defined window index that corresponds to the input relative device\n\ 8608 coordinates (and the returned world coordinates). To give some\n\ 8609 background on the window index, for each page the initial window\n\ 8610 index is set to zero, and each time plwind is called within the\n\ 8611 page, world and device coordinates are stored for the window and\n\ 8612 the window index is incremented. Thus, for a simple page layout\n\ 8613 with non-overlapping viewports and one window per viewport, window\n\ 8614 corresponds to the viewport index (in the order which the\n\ 8615 viewport/windows were created) of the only viewport/window\n\ 8616 corresponding to rx and ry. However, for more complicated layouts\n\ 8617 with potentially overlapping viewports and possibly more than one\n\ 8618 window (set of world coordinates) per viewport, window and the\n\ 8619 corresponding output world coordinates corresponds to the last\n\ 8620 window created that fulfills the criterion that the relative\n\ 8621 device coordinates are inside it. Finally, in all cases where the\n\ 8622 input relative device coordinates are not inside any\n\ 8623 viewport/window, then the returned value of the last defined\n\ 8624 window index is set to -1.\n\ 8627 Draw a box with axes, etc, in 3-d\n\ 8631 Draws axes, numeric and text labels for a three-dimensional surface\n\ 8632 plot. For a more complete description of three-dimensional plotting\n\ 8633 see the PLplot documentation.\n\ 8635 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\ 8636 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\ 8639 This function is used in examples 8, 11, 18, and 21.\n\ 8645 plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\ 8649 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\ 8650 options for the x axis. The string can include any combination of\n\ 8651 the following letters (upper or lower case) in any order: b: Draws\n\ 8652 axis at base, at height z=\n\ 8653 zmin where zmin is defined by call to plw3d. This character must be\n\ 8654 specified in order to use any of the other options.\n\ 8655 d: Plot labels as date / time. Values are assumed to be\n\ 8656 seconds since the epoch (as used by gmtime).\n\ 8657 f: Always use fixed point numeric labels.\n\ 8658 i: Inverts tick marks, so they are drawn downwards, rather\n\ 8660 l: Labels axis logarithmically. This only affects the labels,\n\ 8661 not the data, and so it is necessary to compute the logarithms\n\ 8662 of data points before passing them to any of the drawing\n\ 8664 n: Writes numeric labels at major tick intervals.\n\ 8665 o: Use custom labelling function to generate axis label text.\n\ 8666 The custom labelling function can be defined with the\n\ 8667 plslabelfunc command.\n\ 8668 s: Enables subticks between major ticks, only valid if t is\n\ 8670 t: Draws major ticks.\n\ 8671 u: If this is specified, the text label for the axis is\n\ 8672 written under the axis.\n\ 8675 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\ 8676 the text label for the x axis. It is only drawn if u is in the\n\ 8679 xtick (PLFLT, input) : World coordinate interval between major\n\ 8680 ticks on the x axis. If it is set to zero, PLplot automatically\n\ 8681 generates a suitable tick interval.\n\ 8683 nxsub (PLINT, input) : Number of subintervals between major x axis\n\ 8684 ticks for minor ticks. If it is set to zero, PLplot automatically\n\ 8685 generates a suitable minor tick interval.\n\ 8687 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\ 8688 options for the y axis. The string is interpreted in the same way\n\ 8691 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\ 8692 the text label for the y axis. It is only drawn if u is in the\n\ 8695 ytick (PLFLT, input) : World coordinate interval between major\n\ 8696 ticks on the y axis. If it is set to zero, PLplot automatically\n\ 8697 generates a suitable tick interval.\n\ 8699 nysub (PLINT, input) : Number of subintervals between major y axis\n\ 8700 ticks for minor ticks. If it is set to zero, PLplot automatically\n\ 8701 generates a suitable minor tick interval.\n\ 8703 zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\ 8704 options for the z axis. The string can include any combination of\n\ 8705 the following letters (upper or lower case) in any order: b: Draws\n\ 8706 z axis to the left of the surface plot.\n\ 8707 c: Draws z axis to the right of the surface plot.\n\ 8708 d: Draws grid lines parallel to the x-y plane behind the\n\ 8709 figure. These lines are not drawn until after plot3d or\n\ 8710 plmesh are called because of the need for hidden line removal.\n\ 8711 e: Plot labels as date / time. Values are assumed to be\n\ 8712 seconds since the epoch (as used by gmtime). Note this\n\ 8713 suboption is interpreted the same as the d suboption for xopt\n\ 8714 and yopt, but it has to be identified as e for zopt since d\n\ 8715 has already been used for the different purpose above.\n\ 8716 f: Always use fixed point numeric labels.\n\ 8717 i: Inverts tick marks, so they are drawn away from the center.\n\ 8718 l: Labels axis logarithmically. This only affects the labels,\n\ 8719 not the data, and so it is necessary to compute the logarithms\n\ 8720 of data points before passing them to any of the drawing\n\ 8722 m: Writes numeric labels at major tick intervals on the\n\ 8723 right-hand z axis.\n\ 8724 n: Writes numeric labels at major tick intervals on the\n\ 8725 left-hand z axis.\n\ 8726 o: Use custom labelling function to generate axis label text.\n\ 8727 The custom labelling function can be defined with the\n\ 8728 plslabelfunc command.\n\ 8729 s: Enables subticks between major ticks, only valid if t is\n\ 8731 t: Draws major ticks.\n\ 8732 u: If this is specified, the text label is written beside the\n\ 8734 v: If this is specified, the text label is written beside the\n\ 8738 zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\ 8739 the text label for the z axis. It is only drawn if u or v are in\n\ 8742 ztick (PLFLT, input) : World coordinate interval between major\n\ 8743 ticks on the z axis. If it is set to zero, PLplot automatically\n\ 8744 generates a suitable tick interval.\n\ 8746 nzsub (PLINT, input) : Number of subintervals between major z axis\n\ 8747 ticks for minor ticks. If it is set to zero, PLplot automatically\n\ 8748 generates a suitable minor tick interval.\n\ 8751 Get character default height and current (scaled) height\n\ 8755 Get character default height and current (scaled) height.\n\ 8757 Redacted form: plgchr(p_def, p_ht)\n\ 8759 This function is used in example 23.\n\ 8765 plgchr(p_def, p_ht)\n\ 8769 p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\ 8770 character height (mm).\n\ 8772 p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\ 8773 character height (mm).\n\ 8776 Set the escape character for text strings\n\ 8780 Set the escape character for text strings. From C (in contrast to\n\ 8781 Fortran, see plsescfortran) you pass esc as a character. Only selected\n\ 8782 characters are allowed to prevent the user from shooting himself in\n\ 8783 the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\ 8784 use of backslash as a character escape). Here are the allowed escape\n\ 8785 characters and their corresponding decimal ASCII values: !, ASCII 33\n\ 8796 Redacted form: General: plsesc(esc)\n\ 8799 This function is used in example 29.\n\ 8809 esc (char, input) : Escape character.\n\ 8812 Draw a line between two points, accounting for coordinate transforms\n\ 8816 Joins the point (\n\ 8820 y2) . If a global coordinate transform is defined then the line is\n\ 8821 broken in to n segments to approximate the path. If no transform is\n\ 8822 defined then this simply acts like a call to pljoin.\n\ 8824 Redacted form: plpath(n,x1,y1,x2,y2)\n\ 8826 This function is used in example 22.\n\ 8832 plpath(n, x1, y1, x2, y2)\n\ 8836 n (PLINT, input) : number of points to use to approximate the path.\n\ 8838 x1 (PLFLT, input) : x coordinate of first point.\n\ 8840 y1 (PLFLT, input) : y coordinate of first point.\n\ 8842 x2 (PLFLT, input) : x coordinate of second point.\n\ 8844 y2 (PLFLT, input) : y coordinate of second point.\n\ 8847 Set up standard window and draw box\n\ 8851 Sets up plotter environment for simple graphs by calling pladv and\n\ 8852 setting up viewport and window to sensible default values. plenv\n\ 8853 leaves a standard margin (left-hand margin of eight character heights,\n\ 8854 and a margin around the other three sides of five character heights)\n\ 8855 around most graphs for axis labels and a title. When these defaults\n\ 8856 are not suitable, use the individual routines plvpas, plvpor, or\n\ 8857 plvasp for setting up the viewport, plwind for defining the window,\n\ 8858 and plbox for drawing the box.\n\ 8860 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\ 8862 This function is used in example 1,3,9,13,14,19-22,29.\n\ 8868 plenv(xmin, xmax, ymin, ymax, just, axis)\n\ 8872 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\ 8873 world coordinates).\n\ 8875 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\ 8876 world coordinates).\n\ 8878 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\ 8881 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\ 8884 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\ 8885 scales will not be set, the user must set up the scale before\n\ 8886 calling plenv using plsvpa, plvasp or other.\n\ 8887 0: the x and y axes are scaled independently to use as much of\n\ 8888 the screen as possible.\n\ 8889 1: the scales of the x and y axes are made equal.\n\ 8890 2: the axis of the x and y axes are made equal, and the plot\n\ 8891 box will be square.\n\ 8894 axis (PLINT, input) : Controls drawing of the box around the plot:\n\ 8895 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\ 8896 -1: draw box only.\n\ 8897 0: draw box, ticks, and numeric tick labels.\n\ 8898 1: also draw coordinate axes at x=0 and y=0.\n\ 8899 2: also draw a grid at major tick positions in both\n\ 8901 3: also draw a grid at minor tick positions in both\n\ 8903 10: same as 0 except logarithmic x tick marks. (The x data\n\ 8904 have to be converted to logarithms separately.)\n\ 8905 11: same as 1 except logarithmic x tick marks. (The x data\n\ 8906 have to be converted to logarithms separately.)\n\ 8907 12: same as 2 except logarithmic x tick marks. (The x data\n\ 8908 have to be converted to logarithms separately.)\n\ 8909 13: same as 3 except logarithmic x tick marks. (The x data\n\ 8910 have to be converted to logarithms separately.)\n\ 8911 20: same as 0 except logarithmic y tick marks. (The y data\n\ 8912 have to be converted to logarithms separately.)\n\ 8913 21: same as 1 except logarithmic y tick marks. (The y data\n\ 8914 have to be converted to logarithms separately.)\n\ 8915 22: same as 2 except logarithmic y tick marks. (The y data\n\ 8916 have to be converted to logarithms separately.)\n\ 8917 23: same as 3 except logarithmic y tick marks. (The y data\n\ 8918 have to be converted to logarithms separately.)\n\ 8919 30: same as 0 except logarithmic x and y tick marks. (The x\n\ 8920 and y data have to be converted to logarithms separately.)\n\ 8921 31: same as 1 except logarithmic x and y tick marks. (The x\n\ 8922 and y data have to be converted to logarithms separately.)\n\ 8923 32: same as 2 except logarithmic x and y tick marks. (The x\n\ 8924 and y data have to be converted to logarithms separately.)\n\ 8925 33: same as 3 except logarithmic x and y tick marks. (The x\n\ 8926 and y data have to be converted to logarithms separately.)\n\ 8927 40: same as 0 except date / time x labels.\n\ 8928 41: same as 1 except date / time x labels.\n\ 8929 42: same as 2 except date / time x labels.\n\ 8930 43: same as 3 except date / time x labels.\n\ 8931 50: same as 0 except date / time y labels.\n\ 8932 51: same as 1 except date / time y labels.\n\ 8933 52: same as 2 except date / time y labels.\n\ 8934 53: same as 3 except date / time y labels.\n\ 8935 60: same as 0 except date / time x and y labels.\n\ 8936 61: same as 1 except date / time x and y labels.\n\ 8937 62: same as 2 except date / time x and y labels.\n\ 8938 63: same as 3 except date / time x and y labels.\n\ 8939 70: same as 0 except custom x and y labels.\n\ 8940 71: same as 1 except custom x and y labels.\n\ 8941 72: same as 2 except custom x and y labels.\n\ 8942 73: same as 3 except custom x and y labels.\n\ 8945 Grid data from irregularly sampled data\n\ 8949 Real world data is frequently irregularly sampled, but PLplot 3D plots\n\ 8950 require data organized as a grid, i.e., with x sample point values\n\ 8951 independent of y coordinate and vice versa. This function takes\n\ 8952 irregularly sampled data from the x[npts], y[npts], and z[npts]\n\ 8953 vectors; reads the desired grid location from the input vectors\n\ 8954 xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\ 8955 grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\ 8956 interpolate the data to the grid is specified with the argument type\n\ 8957 which can have one parameter specified in argument data.\n\ 8959 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\ 8960 Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\ 8963 This function is used in example 21.\n\ 8969 plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\ 8973 x (PLFLT_VECTOR, input) : The input x vector.\n\ 8975 y (PLFLT_VECTOR, input) : The input y vector.\n\ 8977 z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\ 8978 y[i], z[i] represents one data sample coordinate.\n\ 8980 npts (PLINT, input) : The number of data samples in the x, y and z\n\ 8983 xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\ 8984 in the x direction. Usually xg has nptsx equally spaced values\n\ 8985 from the minimum to the maximum values of the x input vector.\n\ 8987 nptsx (PLINT, input) : The number of points in the xg vector.\n\ 8989 yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\ 8990 in the y direction. Similar to the xg parameter.\n\ 8992 nptsy (PLINT, input) : The number of points in the yg vector.\n\ 8994 zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\ 8995 where data lies in the grid specified by xg and yg. Therefore the\n\ 8996 zg matrix must be dimensioned\n\ 9000 type (PLINT, input) : The type of grid interpolation algorithm to\n\ 9001 use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\ 9002 GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\ 9003 GRID_NNI: Natural Neighbors Interpolation\n\ 9004 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\ 9005 GRID_NNLI: Nearest Neighbors Linear Interpolation\n\ 9006 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\ 9008 For details of the algorithms read the source file plgridd.c.\n\ 9010 data (PLFLT, input) : Some gridding algorithms require extra data,\n\ 9011 which can be specified through this argument. Currently, for\n\ 9012 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\ 9013 use, the lower the value, the noisier (more local) the\n\ 9014 approximation is.\n\ 9015 GRID_NNLI, data specifies what a thin triangle is, in the\n\ 9016 range [1. .. 2.]. High values enable the usage of very thin\n\ 9017 triangles for interpolation, possibly resulting in error in\n\ 9018 the approximation.\n\ 9019 GRID_NNI, only weights greater than data will be accepted. If\n\ 9020 0, all weights will be accepted.\n\ 9023 Clear current (sub)page\n\ 9027 Clears the current page, effectively erasing everything that have been\n\ 9028 drawn. This command only works with interactive drivers; if the\n\ 9029 driver does not support this, the page is filled with the background\n\ 9030 color in use. If the current page is divided into subpages, only the\n\ 9031 current subpage is erased. The nth subpage can be selected with\n\ 9034 Redacted form: General: plclear()\n\ 9037 This function is not used in any examples.\n\ 9046 Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\ 9050 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\ 9051 and PLFLT alpha transparency value. This sets the entire color map --\n\ 9052 only as many colors as specified will be allocated.\n\ 9054 Redacted form: plscmap0a(r, g, b, alpha)\n\ 9056 This function is used in examples 30.\n\ 9062 plscmap0a(r, g, b, alpha, ncol0)\n\ 9066 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\ 9067 integers (0-255) representing the degree of red in the color.\n\ 9069 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\ 9070 integers (0-255) representing the degree of green in the color.\n\ 9072 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\ 9073 integers (0-255) representing the degree of blue in the color.\n\ 9075 alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\ 9076 representing the alpha transparency of the color.\n\ 9078 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\ 9082 Set 8-bit RGB values for given cmap0 color index\n\ 9086 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\ 9087 index. Overwrites the previous color value for the given index and,\n\ 9088 thus, does not result in any additional allocation of space for\n\ 9091 Redacted form: plscol0(icol0, r, g, b)\n\ 9093 This function is used in any example 31.\n\ 9099 plscol0(icol0, r, g, b)\n\ 9103 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\ 9104 number of colors (which is set by default, by plscmap0n, or even\n\ 9107 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\ 9108 degree of red in the color.\n\ 9110 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\ 9111 degree of green in the color.\n\ 9113 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\ 9114 degree of blue in the color.\n\ 9117 Set up transformation from metafile coordinates\n\ 9121 Set up transformation from metafile coordinates. The size of the plot\n\ 9122 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\ 9123 general-purpose facility just yet (not sure why the user would need\n\ 9126 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\ 9129 This function is not used in any examples.\n\ 9135 plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\ 9139 dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\ 9141 dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\ 9143 dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\ 9145 dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\ 9147 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\ 9149 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\ 9152 Creates a new stream and makes it the default\n\ 9156 Creates a new stream and makes it the default. Differs from using\n\ 9157 plsstrm, in that a free stream number is found, and returned.\n\ 9158 Unfortunately, I have to start at stream 1 and work upward, since\n\ 9159 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\ 9160 that no initial, library-opening call is required. So stream 0 must\n\ 9161 be preallocated, and there is no simple way of determining whether it\n\ 9162 is already in use or not.\n\ 9164 Redacted form: plmkstrm(p_strm)\n\ 9166 This function is used in examples 1 and 20.\n\ 9176 p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\ 9177 number of the created stream.\n\ 9180 Get page parameters\n\ 9184 Gets the current page configuration. The length and offset values are\n\ 9185 expressed in units that are specific to the current driver. For\n\ 9186 instance: screen drivers will usually interpret them as number of\n\ 9187 pixels, whereas printer drivers will usually use mm.\n\ 9189 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\ 9191 This function is used in examples 14 and 31.\n\ 9197 plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\ 9201 p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\ 9202 pixels/inch (DPI) in x.\n\ 9204 p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\ 9205 pixels/inch (DPI) in y.\n\ 9207 p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\ 9210 p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\ 9213 p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\ 9216 p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\ 9220 Set format for date / time labels\n\ 9224 Sets the format for date / time labels. To enable date / time format\n\ 9225 labels see the options to plbox, plbox3, and plenv.\n\ 9227 Redacted form: pltimefmt(fmt)\n\ 9229 This function is used in example 29.\n\ 9239 fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\ 9240 interpreted similarly to the format specifier of typical system\n\ 9241 strftime routines except that PLplot ignores locale and also\n\ 9242 supplies some useful extensions in the context of plotting. All\n\ 9243 text in the string is printed as-is other than conversion\n\ 9244 specifications which take the form of a \'%\' character followed by\n\ 9245 further conversion specification character. The conversion\n\ 9246 specifications which are similar to those provided by system\n\ 9247 strftime routines are the following: %a: The abbreviated (English)\n\ 9249 %A: The full (English) weekday name.\n\ 9250 %b: The abbreviated (English) month name.\n\ 9251 %B: The full (English) month name.\n\ 9252 %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\ 9253 %C: The century number (year/100) as a 2-digit integer.\n\ 9254 %d: The day of the month as a decimal number (range 01 to 31).\n\ 9255 %D: Equivalent to %m/%d/%y (non-ISO).\n\ 9256 %e: Like %d, but a leading zero is replaced by a space.\n\ 9257 %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\ 9258 %h: Equivalent to %b.\n\ 9259 %H: The hour as a decimal number using a 24-hour clock (range\n\ 9261 %I: The hour as a decimal number using a 12-hour clock (range\n\ 9263 %j: The day of the year as a decimal number (range 001 to\n\ 9265 %k: The hour (24-hour clock) as a decimal number (range 0 to\n\ 9266 23); single digits are preceded by a blank. (See also %H.)\n\ 9267 %l: The hour (12-hour clock) as a decimal number (range 1 to\n\ 9268 12); single digits are preceded by a blank. (See also %I.)\n\ 9269 %m: The month as a decimal number (range 01 to 12).\n\ 9270 %M: The minute as a decimal number (range 00 to 59).\n\ 9271 %n: A newline character.\n\ 9272 %p: Either \"AM\" or \"PM\" according to the given time value.\n\ 9273 Noon is treated as \"PM\" and midnight as \"AM\".\n\ 9274 %r: Equivalent to %I:%M:%S %p.\n\ 9275 %R: The time in 24-hour notation (%H:%M). For a version\n\ 9276 including the seconds, see %T below.\n\ 9277 %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\ 9279 %S: The second as a decimal number (range 00 to 60). (The\n\ 9280 range is up to 60 to allow for occasional leap seconds.)\n\ 9281 %t: A tab character.\n\ 9282 %T: The time in 24-hour notation (%H:%M:%S).\n\ 9283 %u: The day of the week as a decimal, range 1 to 7, Monday\n\ 9284 being 1. See also %w.\n\ 9285 %U: The week number of the current year as a decimal number,\n\ 9286 range 00 to 53, starting with the first Sunday as the first\n\ 9287 day of week 01. See also %V and %W.\n\ 9288 %v: Equivalent to %e-%b-%Y.\n\ 9289 %V: The ISO 8601 week number of the current year as a decimal\n\ 9290 number, range 01 to 53, where week 1 is the first week that\n\ 9291 has at least 4 days in the new year. See also %U and %W.\n\ 9292 %w: The day of the week as a decimal, range 0 to 6, Sunday\n\ 9293 being 0. See also %u.\n\ 9294 %W: The week number of the current year as a decimal number,\n\ 9295 range 00 to 53, starting with the first Monday as the first\n\ 9297 %x: Equivalent to %a %b %d %Y.\n\ 9298 %X: Equivalent to %T.\n\ 9299 %y: The year as a decimal number without a century (range 00\n\ 9301 %Y: The year as a decimal number including a century.\n\ 9302 %z: The UTC time-zone string = \"+0000\".\n\ 9303 %Z: The UTC time-zone abbreviation = \"UTC\".\n\ 9304 %+: The UTC date and time in default format of the Unix date\n\ 9305 command which is equivalent to %a %b %d %T %Z %Y.\n\ 9306 %%: A literal \"%\" character.\n\ 9307 The conversion specifications which are extensions to those normally\n\ 9308 provided by system strftime routines are the following: %(0-9):\n\ 9309 The fractional part of the seconds field (including leading\n\ 9310 decimal point) to the specified accuracy. Thus %S%3 would give\n\ 9311 seconds to millisecond accuracy (00.000).\n\ 9312 %.: The fractional part of the seconds field (including\n\ 9313 leading decimal point) to the maximum available accuracy. Thus\n\ 9314 %S%. would give seconds with fractional part up to 9 decimal\n\ 9315 places if available.\n\ 9318 Specify viewport using aspect ratio only\n\ 9322 Selects the largest viewport with the given aspect ratio within the\n\ 9323 subpage that leaves a standard margin (left-hand margin of eight\n\ 9324 character heights, and a margin around the other three sides of five\n\ 9325 character heights).\n\ 9327 Redacted form: plvasp(aspect)\n\ 9329 This function is used in example 13.\n\ 9339 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\ 9340 axis of resulting viewport.\n\ 9343 Set output file name\n\ 9347 Sets the current output file name, if applicable. If the file name\n\ 9348 has not been specified and is required by the driver, the user will be\n\ 9349 prompted for it. If using the X-windows output driver, this sets the\n\ 9350 display name. This routine, if used, must be called before\n\ 9351 initializing PLplot.\n\ 9353 Redacted form: plsfnam(fnam)\n\ 9355 This function is used in examples 1 and 20.\n\ 9365 fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\ 9373 Draws a plot of vector data contained in the matrices (\n\ 9379 ny]) . The scaling factor for the vectors is given by scale. A\n\ 9380 transformation routine pointed to by pltr with a pointer pltr_data for\n\ 9381 additional data required by the transformation routine to map indices\n\ 9382 within the matrices to the world coordinates. The style of the vector\n\ 9383 arrow may be set using plsvect.\n\ 9385 Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\ 9386 discussion) the pltr, pltr_data callback arguments are sometimes\n\ 9387 replaced by a tr vector with 6 elements, or xg and yg array arguments\n\ 9388 with either one or two dimensions.\n\ 9390 This function is used in example 22.\n\ 9396 plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\ 9400 u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\ 9401 and y components of the vector data to be plotted.\n\ 9403 nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\ 9405 scale (PLFLT, input) : Parameter to control the scaling factor of\n\ 9406 the vectors for plotting. If scale = 0 then the scaling factor is\n\ 9407 automatically calculated for the data. If scale < 0 then the\n\ 9408 scaling factor is automatically calculated for the data and then\n\ 9410 scale. If scale > 0 then the scaling factor is set to scale.\n\ 9412 pltr (PLTRANSFORM_callback, input) : A callback function that\n\ 9413 defines the transformation between the zero-based indices of the\n\ 9414 matrices u and v and world coordinates.For the C case,\n\ 9415 transformation functions are provided in the PLplot library: pltr0\n\ 9416 for the identity mapping, and pltr1 and pltr2 for arbitrary\n\ 9417 mappings respectively defined by vectors and matrices. In\n\ 9418 addition, C callback routines for the transformation can be\n\ 9419 supplied by the user such as the mypltr function in\n\ 9420 examples/c/x09c.c which provides a general linear transformation\n\ 9421 between index coordinates and world coordinates.For languages\n\ 9422 other than C you should consult the PLplot documentation for the\n\ 9423 details concerning how PLTRANSFORM_callback arguments are\n\ 9424 interfaced. However, in general, a particular pattern of\n\ 9425 callback-associated arguments such as a tr vector with 6 elements;\n\ 9426 xg and yg vectors; or xg and yg matrices are respectively\n\ 9427 interfaced to a linear-transformation routine similar to the above\n\ 9428 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\ 9429 sophisticated bindings (see, e.g., the PLplot documentation)\n\ 9430 support native language callbacks for handling index to\n\ 9431 world-coordinate transformations. Examples of these various\n\ 9432 approaches are given in examples/<language>x09*,\n\ 9433 examples/<language>x16*, examples/<language>x20*,\n\ 9434 examples/<language>x21*, and examples/<language>x22*, for all our\n\ 9435 supported languages.\n\ 9437 pltr_data (PLPointer, input) : Extra parameter to help pass\n\ 9438 information to pltr0, pltr1, pltr2, or whatever callback routine\n\ 9439 that is externally supplied.\n\ 9442 Set parameters that define current plot-space window\n\ 9446 Set relative minima and maxima that define the current plot-space\n\ 9447 window. If plsdiplt is not called the default values of xmin, ymin,\n\ 9448 xmax, and ymax are 0., 0., 1., and 1.\n\ 9450 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\ 9452 This function is used in example 31.\n\ 9458 plsdiplt(xmin, ymin, xmax, ymax)\n\ 9462 xmin (PLFLT, input) : Relative minimum in x.\n\ 9464 ymin (PLFLT, input) : Relative minimum in y.\n\ 9466 xmax (PLFLT, input) : Relative maximum in x.\n\ 9468 ymax (PLFLT, input) : Relative maximum in y.\n\ 9471 Select line style\n\ 9475 This sets the line style according to one of eight predefined patterns\n\ 9476 (also see plstyl).\n\ 9478 Redacted form: pllsty(lin)\n\ 9480 This function is used in examples 9, 12, 22, and 25.\n\ 9490 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\ 9491 a continuous line, line style 2 is a line with short dashes and\n\ 9492 gaps, line style 3 is a line with long dashes and gaps, line style\n\ 9493 4 has long dashes and short gaps and so on.\n\ 9496 Plot a glyph at the specified points\n\ 9500 Plot a glyph at the specified points. (This function is largely\n\ 9501 superseded by plstring which gives access to many[!] more glyphs.)\n\ 9503 Redacted form: plsym(x, y, code)\n\ 9505 This function is used in example 7.\n\ 9511 plsym(n, x, y, code)\n\ 9515 n (PLINT, input) : Number of points in the x and y vectors.\n\ 9517 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\ 9520 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\ 9523 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\ 9524 to be plotted at each of the n points.\n\ 9527 Set the device (keyword) name\n\ 9531 Set the device (keyword) name.\n\ 9533 Redacted form: plsdev(devname)\n\ 9535 This function is used in examples 1, 14, and 20.\n\ 9545 devname (PLCHAR_VECTOR, input) : An ascii character string\n\ 9546 containing the device name keyword of the required output device.\n\ 9548 devname is NULL or if the first character of the string is a ``?\'\',\n\ 9549 the normal (prompted) start up is used.\n\ 9552 Set the background color by 8-bit RGB value\n\ 9556 Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\ 9557 the PLplot documentation).\n\ 9559 Redacted form: plscolbg(r, g, b)\n\ 9561 This function is used in examples 15 and 31.\n\ 9567 plscolbg(r, g, b)\n\ 9571 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\ 9572 degree of red in the color.\n\ 9574 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\ 9575 degree of green in the color.\n\ 9577 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\ 9578 degree of blue in the color.\n\ 9581 Set parameters incrementally (zoom mode) that define current plot-space window\n\ 9585 Set relative minima and maxima incrementally (zoom mode) that define\n\ 9586 the current plot-space window. This function has the same effect as\n\ 9587 plsdiplt if that function has not been previously called. Otherwise,\n\ 9588 this function implements zoom mode using the transformation min_used =\n\ 9589 old_min + old_length*min and max_used = old_min + old_length*max for\n\ 9590 each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\ 9591 repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\ 9593 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\ 9595 This function is used in example 31.\n\ 9601 plsdiplz(xmin, ymin, xmax, ymax)\n\ 9605 xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\ 9607 ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\ 9609 xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\ 9611 ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\ 9614 Advance to the next family file on the next new page\n\ 9618 Advance to the next family file on the next new page.\n\ 9620 Redacted form: plfamadv()\n\ 9622 This function is not used in any examples.\n\ 9631 Set number of colors in cmap0\n\ 9635 Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\ 9636 (or reallocate) cmap0, and fill with default values for those colors\n\ 9637 not previously allocated. The first 16 default colors are given in\n\ 9638 the plcol0 documentation. For larger indices the default color is\n\ 9641 The drivers are not guaranteed to support more than 16 colors.\n\ 9643 Redacted form: plscmap0n(ncol0)\n\ 9645 This function is used in examples 15, 16, and 24.\n\ 9655 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\ 9656 the cmap0 palette. If this number is zero or less, then the value\n\ 9657 from the previous call to plscmap0n is used and if there is no\n\ 9658 previous call, then a default value is used.\n\ 9661 Plot latitude and longitude lines\n\ 9665 Displays latitude and longitude on the current plot. The lines are\n\ 9666 plotted in the current color and line style.\n\ 9668 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\ 9671 This function is used in example 19.\n\ 9677 plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\ 9681 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\ 9682 transform the coordinate longitudes and latitudes to a plot\n\ 9683 coordinate system. By using this transform, we can change from a\n\ 9684 longitude, latitude coordinate to a polar stereographic project,\n\ 9685 for example. Initially, x[0]..[n-1] are the longitudes and\n\ 9686 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\ 9687 mapform(), x[] and y[] should be replaced by the corresponding\n\ 9688 plot coordinates. If no transform is desired, mapform can be\n\ 9689 replaced by NULL.\n\ 9691 dlong (PLFLT, input) : The interval in degrees at which the\n\ 9692 longitude lines are to be plotted.\n\ 9694 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\ 9695 lines are to be plotted.\n\ 9697 minlong (PLFLT, input) : The value of the longitude on the left\n\ 9698 side of the plot. The value of minlong must be less than the value\n\ 9699 of maxlong, and the quantity maxlong-minlong must be less than or\n\ 9702 maxlong (PLFLT, input) : The value of the longitude on the right\n\ 9703 side of the plot.\n\ 9705 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\ 9706 background. One can always use -90.0 as the boundary outside the\n\ 9707 plot window will be automatically eliminated. However, the\n\ 9708 program will be faster if one can reduce the size of the\n\ 9709 background plotted.\n\ 9711 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\ 9712 background. One can always use 90.0 as the boundary outside the\n\ 9713 plot window will be automatically eliminated.\n\ 9716 Convert RGB color to HLS\n\ 9720 Convert RGB color coordinates to HLS\n\ 9722 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\ 9725 This function is used in example 2.\n\ 9731 plrgbhls(r, g, b, p_h, p_l, p_s)\n\ 9735 r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\ 9737 g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\ 9739 b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\ 9741 p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\ 9742 degrees (0.0-360.0) on the color cylinder.\n\ 9744 p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\ 9745 expressed as a fraction (0.0-1.0) of the axis of the color\n\ 9748 p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\ 9749 expressed as a fraction (0.0-1.0) of the radius of the color\n\ 9753 Plot a glyph at the specified 3D points\n\ 9757 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\ 9758 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\ 9759 this function similar to what is done for plline3. The glyph is\n\ 9760 specified with a PLplot user string. Note that the user string is not\n\ 9761 actually limited to one glyph so it is possible (but not normally\n\ 9762 useful) to plot more than one glyph at the specified points with this\n\ 9763 function. As with plmtex and plptex, the user string can contain FCI\n\ 9764 escapes to determine the font, UTF-8 code to determine the glyph or\n\ 9765 else PLplot escapes for Hershey or unicode text to determine the\n\ 9768 Redacted form: plstring3(x, y, z, string)\n\ 9770 This function is used in example 18.\n\ 9776 plstring3(n, x, y, z, string)\n\ 9780 n (PLINT, input) : Number of points in the x, y, and z vectors.\n\ 9782 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\ 9785 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\ 9788 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\ 9791 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\ 9792 the glyph(s) to be plotted at each of the n points. points.\n\ 9795 Switch to text screen\n\ 9799 Sets an interactive device to text mode, used in conjunction with\n\ 9800 plgra to allow graphics and text to be interspersed. On a device\n\ 9801 which supports separate text and graphics windows, this command causes\n\ 9802 control to be switched to the text window. This can be useful for\n\ 9803 printing diagnostic messages or getting user input, which would\n\ 9804 otherwise interfere with the plots. The program must switch back to\n\ 9805 the graphics window before issuing plot commands, as the text (or\n\ 9806 console) device will probably become quite confused otherwise. If\n\ 9807 already in text mode, this command is ignored. It is also ignored on\n\ 9808 devices which only support a single window or use a different method\n\ 9809 for shifting focus (see also plgra).\n\ 9811 Redacted form: pltext()\n\ 9813 This function is used in example 1.\n\ 9822 Get parameters that define current plot-space window\n\ 9826 Get relative minima and maxima that define current plot-space window.\n\ 9827 If plsdiplt has not been called the default values pointed to by\n\ 9828 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\ 9830 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\ 9832 This function is used in example 31.\n\ 9838 plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\ 9842 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\ 9845 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\ 9848 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\ 9851 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\ 9855 Get the (current) run level\n\ 9859 Get the (current) run level. Valid settings are: 0, uninitialized\n\ 9861 2, viewport defined\n\ 9862 3, world coordinates defined\n\ 9865 Redacted form: plglevel(p_level)\n\ 9867 This function is used in example 31.\n\ 9873 plglevel(p_level)\n\ 9877 p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\ 9881 Plot a histogram from binned data\n\ 9885 Plots a histogram consisting of nbin bins. The value associated with\n\ 9886 the i\'th bin is placed in x[i], and the number of points in the bin is\n\ 9887 placed in y[i]. For proper operation, the values in x[i] must form a\n\ 9888 strictly increasing sequence. By default, x[i] is the left-hand edge\n\ 9889 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\ 9890 placed midway between the values in the x vector. Also see plhist for\n\ 9891 drawing histograms from unbinned data.\n\ 9893 Redacted form: General: plbin(x, y, opt)\n\ 9894 Python: plbin(nbin, x, y, opt)\n\ 9897 This function is not used in any examples.\n\ 9903 plbin(nbin, x, y, opt)\n\ 9907 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\ 9910 x (PLFLT_VECTOR, input) : A vector containing values associated\n\ 9911 with bins. These must form a strictly increasing sequence.\n\ 9913 y (PLFLT_VECTOR, input) : A vector containing a number which is\n\ 9914 proportional to the number of points in each bin. This is a PLFLT\n\ 9915 (instead of PLINT) vector so as to allow histograms of\n\ 9916 probabilities, etc.\n\ 9918 opt (PLINT, input) : Is a combination of several flags:\n\ 9919 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\ 9920 outer bins are expanded to fill up the entire x-axis and bins of\n\ 9921 zero height are simply drawn.\n\ 9922 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\ 9923 between the x values. If the values in x are equally spaced,\n\ 9924 the values are the center values of the bins.\n\ 9925 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\ 9926 size as the ones inside.\n\ 9927 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\ 9928 (there is a gap for such bins).\n\ 9931 Plot a 2D matrix using cmap1\n\ 9935 Plot a 2D matrix using cmap1.\n\ 9937 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\ 9938 zmax, valuemin, valuemax, pltr, pltr_data)\n\ 9941 This function is used in example 20.\n\ 9947 plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\ 9951 idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\ 9952 plot. Should have dimensions of\n\ 9956 nx, ny (PLINT, input) : Dimensions of idata\n\ 9958 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\ 9959 pltr below for how these arguments are used (only for the special case\n\ 9960 when the callback function\n\ 9961 pltr is not supplied).\n\ 9963 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\ 9964 (inclusive) will be plotted.\n\ 9966 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\ 9967 values to use for value to color mappings. A datum equal to or\n\ 9968 less than valuemin will be plotted with color 0.0, while a datum\n\ 9969 equal to or greater than valuemax will be plotted with color 1.0.\n\ 9970 Data between valuemin and valuemax map linearly to colors in the\n\ 9973 pltr (PLTRANSFORM_callback, input) : A callback function that\n\ 9974 defines the transformation between the zero-based indices of the\n\ 9975 matrix idata and world coordinates. If\n\ 9976 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\ 9977 indices of idata are mapped to the range\n\ 9979 xmax and the y indices of idata are mapped to the range\n\ 9981 ymax.For the C case, transformation functions are provided in the\n\ 9982 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\ 9983 pltr2 for arbitrary mappings respectively defined by vectors and\n\ 9984 matrices. In addition, C callback routines for the transformation\n\ 9985 can be supplied by the user such as the mypltr function in\n\ 9986 examples/c/x09c.c which provides a general linear transformation\n\ 9987 between index coordinates and world coordinates.For languages\n\ 9988 other than C you should consult the PLplot documentation for the\n\ 9989 details concerning how PLTRANSFORM_callback arguments are\n\ 9990 interfaced. However, in general, a particular pattern of\n\ 9991 callback-associated arguments such as a tr vector with 6 elements;\n\ 9992 xg and yg vectors; or xg and yg matrices are respectively\n\ 9993 interfaced to a linear-transformation routine similar to the above\n\ 9994 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\ 9995 sophisticated bindings (see, e.g., the PLplot documentation)\n\ 9996 support native language callbacks for handling index to\n\ 9997 world-coordinate transformations. Examples of these various\n\ 9998 approaches are given in examples/<language>x09*,\n\ 9999 examples/<language>x16*, examples/<language>x20*,\n\ 10000 examples/<language>x21*, and examples/<language>x22*, for all our\n\ 10001 supported languages.\n\ 10003 pltr_data (PLPointer, input) : Extra parameter to help pass\n\ 10004 information to pltr0, pltr1, pltr2, or whatever routine is\n\ 10005 externally supplied.\n\ 10008 Get family, style and weight of the current font\n\ 10012 Gets information about current font. See the PLplot documentation for\n\ 10013 more information on font selection.\n\ 10015 Redacted form: plgfont(p_family, p_style, p_weight)\n\ 10017 This function is used in example 23.\n\ 10023 plgfont(p_family, p_style, p_weight)\n\ 10027 p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\ 10028 font family. The available values are given by the PL_FCI_*\n\ 10029 constants in plplot.h. Current options are PL_FCI_SANS,\n\ 10030 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\ 10031 p_family is NULL then the font family is not returned.\n\ 10033 p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\ 10034 font style. The available values are given by the PL_FCI_*\n\ 10035 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\ 10036 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\ 10037 style is not returned.\n\ 10039 p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\ 10040 font weight. The available values are given by the PL_FCI_*\n\ 10041 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\ 10042 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\ 10046 Get z axis parameters\n\ 10050 Identical to plgxax, except that arguments are flags for z axis. See\n\ 10051 the description of plgxax for more detail.\n\ 10053 Redacted form: plgzax(p_digmax, p_digits)\n\ 10055 This function is used in example 31.\n\ 10061 plgzax(p_digmax, p_digits)\n\ 10065 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\ 10066 number of digits for the z axis. If nonzero, the printed label\n\ 10067 has been switched to a floating-point representation when the\n\ 10068 number of digits exceeds this value.\n\ 10070 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\ 10071 number of digits for the numeric labels (z axis) from the last\n\ 10075 Write text inside the viewport of a 3D plot\n\ 10079 Writes text at a specified position and inclination and with a\n\ 10080 specified shear within the viewport. Text is clipped at the viewport\n\ 10081 boundaries. The reference point of a string lies along a line passing\n\ 10082 through the string at half the height of a capital letter. The\n\ 10083 position of the reference point along this line is determined by just,\n\ 10084 and the reference point is placed at world coordinates (\n\ 10087 wz) within the viewport. The inclination and shear of the string is\n\ 10088 specified in terms of differences of world coordinates making it easy\n\ 10089 to write text parallel to a line in a graph.\n\ 10091 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\ 10093 This function is used in example 28.\n\ 10099 plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\ 10103 wx (PLFLT, input) : x world coordinate of reference point of\n\ 10106 wy (PLFLT, input) : y world coordinate of reference point of\n\ 10109 wz (PLFLT, input) : z world coordinate of reference point of\n\ 10112 dx (PLFLT, input) : Together with dy and\n\ 10113 dz , this specifies the inclination of the string. The baseline of\n\ 10114 the string is parallel to a line joining (\n\ 10125 dy (PLFLT, input) : Together with dx and\n\ 10126 dz, this specifies the inclination of the string.\n\ 10128 dz (PLFLT, input) : Together with dx and\n\ 10129 dy, this specifies the inclination of the string.\n\ 10131 sx (PLFLT, input) : Together with sy and\n\ 10132 sz , this specifies the shear of the string. The string is sheared so\n\ 10133 that the characters are vertically parallel to a line joining (\n\ 10144 sz = 0.) then the text is not sheared.\n\ 10146 sy (PLFLT, input) : Together with sx and\n\ 10147 sz, this specifies shear of the string.\n\ 10149 sz (PLFLT, input) : Together with sx and\n\ 10150 sy, this specifies shear of the string.\n\ 10152 just (PLFLT, input) : Specifies the position of the string relative\n\ 10153 to its reference point. If just=0. , the reference point is at\n\ 10154 the left and if just=1. , it is at the right of the string. Other\n\ 10155 values of just give intermediate justifications.\n\ 10157 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\ 10161 Draw a box with axes, etc. with arbitrary origin\n\ 10165 Draws a box around the currently defined viewport with arbitrary\n\ 10166 world-coordinate origin specified by x0 and y0 and labels it with\n\ 10167 world coordinate values appropriate to the window. Thus plaxes should\n\ 10168 only be called after defining both viewport and window. The ascii\n\ 10169 character strings xopt and yopt specify how the box should be drawn as\n\ 10170 described below. If ticks and/or subticks are to be drawn for a\n\ 10171 particular axis, the tick intervals and number of subintervals may be\n\ 10172 specified explicitly, or they may be defaulted by setting the\n\ 10173 appropriate arguments to zero.\n\ 10175 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\ 10179 This function is not used in any examples.\n\ 10185 plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\ 10189 x0 (PLFLT, input) : World X coordinate of origin.\n\ 10191 y0 (PLFLT, input) : World Y coordinate of origin.\n\ 10193 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\ 10194 options for the x axis. The string can include any combination of\n\ 10195 the following letters (upper or lower case) in any order: a: Draws\n\ 10196 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\ 10198 b: Draws bottom (X) or left (Y) edge of frame.\n\ 10199 c: Draws top (X) or right (Y) edge of frame.\n\ 10200 d: Plot labels as date / time. Values are assumed to be\n\ 10201 seconds since the epoch (as used by gmtime).\n\ 10202 f: Always use fixed point numeric labels.\n\ 10203 g: Draws a grid at the major tick interval.\n\ 10204 h: Draws a grid at the minor tick interval.\n\ 10205 i: Inverts tick marks, so they are drawn outwards, rather than\n\ 10207 l: Labels axis logarithmically. This only affects the labels,\n\ 10208 not the data, and so it is necessary to compute the logarithms\n\ 10209 of data points before passing them to any of the drawing\n\ 10211 m: Writes numeric labels at major tick intervals in the\n\ 10212 unconventional location (above box for X, right of box for Y).\n\ 10213 n: Writes numeric labels at major tick intervals in the\n\ 10214 conventional location (below box for X, left of box for Y).\n\ 10215 o: Use custom labelling function to generate axis label text.\n\ 10216 The custom labelling function can be defined with the\n\ 10217 plslabelfunc command.\n\ 10218 s: Enables subticks between major ticks, only valid if t is\n\ 10220 t: Draws major ticks.\n\ 10221 u: Exactly like \"b\" except don\'t draw edge line.\n\ 10222 w: Exactly like \"c\" except don\'t draw edge line.\n\ 10223 x: Exactly like \"t\" (including the side effect of the\n\ 10224 numerical labels for the major ticks) except exclude drawing\n\ 10225 the major and minor tick marks.\n\ 10228 xtick (PLFLT, input) : World coordinate interval between major\n\ 10229 ticks on the x axis. If it is set to zero, PLplot automatically\n\ 10230 generates a suitable tick interval.\n\ 10232 nxsub (PLINT, input) : Number of subintervals between major x axis\n\ 10233 ticks for minor ticks. If it is set to zero, PLplot automatically\n\ 10234 generates a suitable minor tick interval.\n\ 10236 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\ 10237 options for the y axis. The string can include any combination of\n\ 10238 the letters defined above for xopt, and in addition may contain:\n\ 10239 v: Write numeric labels for the y axis parallel to the base of the\n\ 10240 graph, rather than parallel to the axis.\n\ 10243 ytick (PLFLT, input) : World coordinate interval between major\n\ 10244 ticks on the y axis. If it is set to zero, PLplot automatically\n\ 10245 generates a suitable tick interval.\n\ 10247 nysub (PLINT, input) : Number of subintervals between major y axis\n\ 10248 ticks for minor ticks. If it is set to zero, PLplot automatically\n\ 10249 generates a suitable minor tick interval.\n\ 10252 Returns the background color (cmap0[0]) by 8-bit RGB value\n\ 10256 Returns the background color (cmap0[0]) by 8-bit RGB value.\n\ 10258 Redacted form: plgcolbg(r, g, b)\n\ 10260 This function is used in example 31.\n\ 10266 plgcolbg(r, g, b)\n\ 10270 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\ 10271 in the range from 0 to 255.\n\ 10273 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\ 10274 in the range from 0 to 255.\n\ 10276 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\ 10277 in the range from 0 to 255.\n\ 10280 Plot a glyph at the specified 3D points\n\ 10284 Plot a glyph at the specified 3D points. (This function is largely\n\ 10285 superseded by plstring3 which gives access to many[!] more glyphs.)\n\ 10286 Set up the call to this function similar to what is done for plline3.\n\ 10287 code=-1 means try to just draw a point. Right now it\'s just a move\n\ 10288 and a draw at the same place. Not ideal, since a sufficiently\n\ 10289 intelligent output device may optimize it away, or there may be faster\n\ 10290 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\ 10291 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\ 10292 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\ 10293 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\ 10294 code <= 127 the corresponding printable ASCII character is plotted.\n\ 10296 Redacted form: plpoin3(x, y, z, code)\n\ 10298 This function is not used in any example.\n\ 10304 plpoin3(n, x, y, z, code)\n\ 10308 n (PLINT, input) : Number of points in the x and y vectors.\n\ 10310 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\ 10313 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\ 10316 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\ 10319 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\ 10320 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\ 10321 each of the n points.\n\ 10324 Draw a polygon in 3 space\n\ 10328 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\ 10329 like plline3, but differs from that function in that plpoly3 attempts\n\ 10330 to determine if the polygon is viewable depending on the order of the\n\ 10331 points within the vector and the value of ifcc. If the back of\n\ 10332 polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\ 10333 you want, then use plline3 instead.\n\ 10335 The points are assumed to be in a plane, and the directionality of the\n\ 10336 plane is determined from the first three points. Additional points do\n\ 10337 not have to lie on the plane defined by the first three, but if they\n\ 10338 do not, then the determination of visibility obviously can\'t be 100%\n\ 10339 accurate... So if you\'re 3 space polygons are too far from planar,\n\ 10340 consider breaking them into smaller polygons. 3 points define a plane\n\ 10343 Bugs: If one of the first two segments is of zero length, or if they\n\ 10344 are co-linear, the calculation of visibility has a 50/50 chance of\n\ 10345 being correct. Avoid such situations :-). See x18c.c for an example\n\ 10346 of this problem. (Search for 20.1).\n\ 10348 Redacted form: plpoly3(x, y, z, code)\n\ 10350 This function is used in example 18.\n\ 10356 plpoly3(n, x, y, z, draw, ifcc)\n\ 10360 n (PLINT, input) : Number of points defining line.\n\ 10362 x (PLFLT_VECTOR, input) : A vector containing\n\ 10363 n x coordinates of points.\n\ 10365 y (PLFLT_VECTOR, input) : A vector containing\n\ 10366 n y coordinates of points.\n\ 10368 z (PLFLT_VECTOR, input) : A vector containing\n\ 10369 n z coordinates of points.\n\ 10371 draw (PLBOOL_VECTOR, input) : A vector containing\n\ 10372 n-1 Boolean values which control drawing the segments of the polygon.\n\ 10373 If draw[i] is true, then the polygon segment from index [i] to\n\ 10374 [i+1] is drawn, otherwise, not.\n\ 10376 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\ 10377 polygon is determined by assuming the points are laid out in a\n\ 10378 counter-clockwise order. Otherwise, the directionality of the\n\ 10379 polygon is determined by assuming the points are laid out in a\n\ 10380 clockwise order.\n\ 10383 Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\ 10387 Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\ 10388 PLFLT alpha transparency value (see the PLplot documentation).\n\ 10390 This function is used in example 31.\n\ 10396 plscolbga(r, g, b, alpha)\n\ 10400 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\ 10401 degree of red in the color.\n\ 10403 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\ 10404 degree of green in the color.\n\ 10406 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\ 10407 degree of blue in the color.\n\ 10409 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\ 10413 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\ 10417 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\ 10418 alpha transparency value.\n\ 10420 This function is used in example 31.\n\ 10426 plgcolbga(r, g, b, alpha)\n\ 10430 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\ 10431 in the range from 0 to 255.\n\ 10433 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\ 10434 in the range from 0 to 255.\n\ 10436 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\ 10437 in the range from 0 to 255.\n\ 10439 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\ 10440 transparency in the range (0.0-1.0).\n\ 10443 Draw error bars in x direction\n\ 10447 Draws a set of n error bars in x direction, the i\'th error bar\n\ 10448 extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\ 10449 of the error bars are of length equal to the minor tick length\n\ 10450 (settable using plsmin).\n\ 10452 Redacted form: General: plerrx(xmin, ymax, y)\n\ 10455 This function is used in example 29.\n\ 10461 plerrx(n, xmin, xmax, y)\n\ 10465 n (PLINT, input) : Number of error bars to draw.\n\ 10467 xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\ 10468 of the left-hand endpoints of the error bars.\n\ 10470 xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\ 10471 of the right-hand endpoints of the error bars.\n\ 10473 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\ 10477 Eject current page\n\ 10481 Clears the graphics screen of an interactive device, or ejects a page\n\ 10482 on a plotter. See plbop for more information.\n\ 10484 Redacted form: pleop()\n\ 10486 This function is used in example 2,14.\n\ 10495 Convert HLS color to RGB\n\ 10499 Convert HLS color coordinates to RGB.\n\ 10501 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\ 10504 This function is used in example 2.\n\ 10510 plhlsrgb(h, l, s, p_r, p_g, p_b)\n\ 10514 h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\ 10517 l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\ 10518 the axis of the color cylinder.\n\ 10520 s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\ 10521 the radius of the color cylinder.\n\ 10523 p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\ 10524 (0.0-1.0) of the color.\n\ 10526 p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\ 10527 intensity (0.0-1.0) of the color.\n\ 10529 p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\ 10530 intensity (0.0-1.0) of the color.\n\ 10533 Plot all or a subset of Shapefile data, filling the polygons\n\ 10537 As per plmapline, however the items are filled in the same way as\n\ 10540 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\ 10543 This function is used in example 19.\n\ 10549 plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\ 10553 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\ 10554 transform the coordinates given in the shapefile into a plot\n\ 10555 coordinate system. By using this transform, we can change from a\n\ 10556 longitude, latitude coordinate to a polar stereographic project,\n\ 10557 for example. Initially, x[0]..[n-1] are the longitudes and\n\ 10558 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\ 10559 mapform(), x[] and y[] should be replaced by the corresponding\n\ 10560 plot coordinates. If no transform is desired, mapform can be\n\ 10561 replaced by NULL.\n\ 10563 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\ 10564 the file name of a set of Shapefile files without the file\n\ 10567 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\ 10568 be in the same units as used by the Shapefile. You could use a\n\ 10569 very large negative number to plot everything, but you can improve\n\ 10570 performance by limiting the area drawn. The units must match those\n\ 10571 of the Shapefile projection, which may be for example longitude or\n\ 10572 distance. The value of minx must be less than the value of maxx.\n\ 10574 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\ 10575 use a very large number to plot everything, but you can improve\n\ 10576 performance by limiting the area drawn.\n\ 10578 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\ 10579 be in the same units as used by the Shapefile. You could use a\n\ 10580 very large negative number to plot everything, but you can improve\n\ 10581 performance by limiting the area drawn. The units must match those\n\ 10582 of the Shapefile projection, which may be for example latitude or\n\ 10583 distance. The value of miny must be less than the value of maxy.\n\ 10585 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\ 10586 use a very large number to plot everything, but you can improve\n\ 10587 performance by limiting the area drawn.\n\ 10589 plotentries (PLINT_VECTOR, input) : A vector containing the\n\ 10590 zero-based indices of the Shapefile elements which will be drawn.\n\ 10592 plotentries to NULL will plot all elements of the Shapefile.\n\ 10594 nplotentries (PLINT, input) : The number of items in\n\ 10595 plotentries. Ignored if\n\ 10596 plotentries is NULL.\n\ 10599 Draw error bars in the y direction\n\ 10603 Draws a set of n error bars in the y direction, the i\'th error bar\n\ 10604 extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\ 10605 of the error bars are of length equal to the minor tick length\n\ 10606 (settable using plsmin).\n\ 10608 Redacted form: General: plerry(x, ymin, ymax)\n\ 10611 This function is used in example 29.\n\ 10617 plerry(n, x, ymin, ymax)\n\ 10621 n (PLINT, input) : Number of error bars to draw.\n\ 10623 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\ 10626 ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\ 10627 of the lower endpoints of the error bars.\n\ 10629 ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\ 10630 of the upper endpoints of the error bars.\n\ 10633 Set FCI (font characterization integer)\n\ 10637 Sets font characteristics to be used at the start of the next string\n\ 10638 using the FCI approach. See the PLplot documentation for more\n\ 10639 information. Note, plsfont (which calls plsfci internally) provides a\n\ 10640 more user-friendly API for setting the font characterisitics.\n\ 10642 Redacted form: General: plsfci(fci)\n\ 10645 This function is used in example 23.\n\ 10655 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\ 10659 Select area fill pattern\n\ 10664 patt is zero or less use either a hardware solid fill if the drivers\n\ 10665 have that capability (virtually all do) or fall back to a software\n\ 10666 emulation of a solid fill using the eighth area line fill pattern. If\n\ 10668 patt <= 8, then select one of eight predefined area line fill patterns\n\ 10669 to use (see plpat if you desire other patterns).\n\ 10671 Redacted form: plpsty(patt)\n\ 10673 This function is used in examples 12, 13, 15, 16, and 25.\n\ 10683 patt (PLINT, input) : The desired pattern index. If\n\ 10684 patt is zero or less, then a solid fill is (normally, see qualifiers\n\ 10685 above) used. For\n\ 10686 patt in the range from 1 to 8 and assuming the driver has not supplied\n\ 10687 line fill capability itself (most deliberately do not so that line\n\ 10688 fill patterns look identical for those drivers), the patterns\n\ 10689 consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\ 10690 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\ 10691 lines at -30 degrees, (7) both vertical and horizontal lines, and\n\ 10692 (8) lines at both 45 degrees and -45 degrees.\n\ 10699 This sets up the size of all subsequent symbols drawn by plpoin and\n\ 10700 plsym. The actual height of a symbol is the product of the default\n\ 10701 symbol size and a scaling factor as for the character height.\n\ 10703 Redacted form: plssym(def, scale)\n\ 10705 This function is used in example 29.\n\ 10711 plssym(def, scale)\n\ 10715 def (PLFLT, input) : The default height of a symbol in millimeters,\n\ 10716 should be set to zero if the default height is to remain\n\ 10719 scale (PLFLT, input) : Scale factor to be applied to default to get\n\ 10720 actual symbol height.\n\ 10727 Alternative to plstar for initializing the plotting package. The\n\ 10728 device name keyword for the desired output device must be supplied as\n\ 10729 an argument. These keywords are the same as those printed out by\n\ 10730 plstar. If the requested device is not available, or if the input\n\ 10731 string is empty or begins with ``?\'\', the prompted start up of plstar\n\ 10732 is used. This routine also divides the output device page into nx by\n\ 10733 ny subpages, each of which may be used independently. The subroutine\n\ 10734 pladv is used to advance from one subpage to the next.\n\ 10736 Redacted form: General: plstart(devname, nx, ny)\n\ 10739 This function is not used in any examples.\n\ 10745 plstart(devname, nx, ny)\n\ 10749 devname (PLCHAR_VECTOR, input) : An ascii character string\n\ 10750 containing the device name keyword of the required output device.\n\ 10752 devname is NULL or if the first character of the string is a ``?\'\',\n\ 10753 the normal (prompted) start up is used.\n\ 10755 nx (PLINT, input) : Number of subpages to divide output page in the\n\ 10758 ny (PLINT, input) : Number of subpages to divide output page in the\n\ 10764 PLINT *arg2 = (PLINT *) 0 ;
10765 char **arg3 = (
char **) 0 ;
10767 octave_value_list _out;
10768 octave_value_list *_outp=&_out;
10769 octave_value _outv;
10775 if (
_n_dims( args(0) ) > 1 )
10779 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
10780 arg2 =
new PLINT[
Alen];
10781 temp1 = args(0).matrix_value();
10785 charMatrix temp_matrix;
10789 size_t max_length = 0, non_blank_length;
10791 if (
_n_dims( args(1) ) > 2 )
10793 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
10795 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 10796 if ( !args(1).isempty() )
10798 if ( !args(1).is_empty() )
10801 if (
_dim( args(1), 0 ) != Alen )
10803 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
10805 arg3 =
new char*[
Alen];
10806 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 10807 ifcell = args(1).iscell();
10809 ifcell = args(1).is_cell();
10813 temp_cell = args(1).cell_value();
10817 temp_matrix = args(1).char_matrix_value();
10819 max_length =
_dim( args(1), 1 ) + 1;
10822 for ( i = 0; i <
Alen; i++ )
10829 if ( temp_cell.elem( i ).is_string() )
10831 str = temp_cell.elem( i ).string_value();
10833 max_length = str.size() + 1;
10834 tmp_cstring = (
char *) str.c_str();
10844 tmp_cstring = (
char *)
"";
10849 str = temp_matrix.row_as_string( i );
10850 tmp_cstring = (
char *) str.c_str();
10852 arg3[i] =
new char[max_length];
10853 strncpy( arg3[i], tmp_cstring, max_length - 1 );
10854 arg3[i][max_length - 1] =
'\0';
10869 non_blank_length = max_length - 2;
10870 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
'\0' )
10872 non_blank_length--;
10874 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
' ' )
10876 non_blank_length--;
10878 arg3[i][non_blank_length + 1] =
'\0';
10887 testppchar(arg1,(
int const *)arg2,(
char const **)arg3);
10888 _outv = octave_value();
10895 if ( arg3 != NULL )
10897 for ( i = 0; i <
Alen; i++ )
10911 if ( arg3 != NULL )
10913 for ( i = 0; i <
Alen; i++ )
10920 return octave_value_list();
10925 int *arg1 = (
int *) 0 ;
10926 int *arg2 = (
int *) 0 ;
10927 int *arg3 = (
int *) 0 ;
10928 char *arg4 = (
char *) 0 ;
10929 int *arg5 = (
int *) 0 ;
10930 int *arg6 = (
int *) 0 ;
10931 PLFLT *arg7 = (PLFLT *) 0 ;
10932 PLFLT *arg8 = (PLFLT *) 0 ;
10933 PLFLT *arg9 = (PLFLT *) 0 ;
10934 PLFLT *arg10 = (PLFLT *) 0 ;
10935 int *arg11 = (
int *) 0 ;
10942 char local_string4[80] ;
10957 size_t local_string_length4 ;
10958 charMatrix local_charMatrix4 ;
10959 octave_value_list retval4 ;
10960 octave_value_list _out;
10961 octave_value_list *_outp=&_out;
10962 octave_value _outv;
10969 arg4 = local_string4;
10981 result = (int)
my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11003 local_string_length4 = strlen( local_string4 );
11004 local_charMatrix4 = charMatrix( 1, local_string_length4 );
11005 local_charMatrix4.insert( local_string4, 0, 0 );
11006 retval4( 0 ) = octave_value( local_charMatrix4 );
11053 return octave_value_list();
11058 PLFLT *arg1 = (PLFLT *) 0 ;
11059 PLFLT *arg2 = (PLFLT *) 0 ;
11070 octave_value_list _out;
11071 octave_value_list *_outp=&_out;
11072 octave_value _outv;
11084 arg3 =
static_cast< PLFLT
>(val3);
11089 arg4 =
static_cast< PLFLT
>(val4);
11107 return octave_value_list();
11112 PLINT *arg1 = (PLINT *) 0 ;
11113 char *arg2 = (
char *) 0 ;
11114 char *arg3 = (
char *) 0 ;
11126 PLINT *arg15 = (PLINT *) 0 ;
11127 PLINT *arg16 = (PLINT *) 0 ;
11128 char *arg17 = (
char *) 0 ;
11129 char *arg18 = (
char *) 0 ;
11130 char *arg19 = (
char *) 0 ;
11131 char *arg20 = (
char *) 0 ;
11132 char *arg21 = (
char *) 0 ;
11133 char *arg22 = (
char *) 0 ;
11134 char *arg23 = (
char *) 0 ;
11188 octave_value_list _out;
11189 octave_value_list *_outp=&_out;
11190 octave_value _outv;
11200 arg2 =
reinterpret_cast< char *
>(buf2);
11205 arg3 =
reinterpret_cast< char *
>(buf3);
11210 arg4 =
static_cast< PLFLT
>(val4);
11215 arg5 =
static_cast< PLFLT
>(val5);
11220 arg6 =
static_cast< PLFLT
>(val6);
11225 arg7 =
static_cast< PLFLT
>(val7);
11230 arg8 =
static_cast< PLFLT
>(val8);
11235 arg9 =
static_cast< PLFLT
>(val9);
11240 arg10 =
static_cast< PLFLT
>(val10);
11245 arg11 =
static_cast< PLBOOL >(val11);
11250 arg12 =
static_cast< PLBOOL >(val12);
11255 arg13 =
static_cast< PLINT
>(val13);
11260 arg14 =
static_cast< PLINT
>(val14);
11262 if (
_n_dims( args(13) ) > 1 )
11266 Alen = (
PLINT) (
_dim( args(13), 0 ) );
11267 temp15 = args(13).matrix_value();
11268 arg15 =
new PLINT[
Alen];
11272 if (
_n_dims( args(14) ) > 1 )
11276 if (
_dim( args(14), 0 ) != Alen )
11280 temp16 = args(14).matrix_value();
11281 arg16 =
new PLINT[
Alen];
11288 arg17 =
reinterpret_cast< char *
>(buf17);
11293 arg18 =
reinterpret_cast< char *
>(buf18);
11298 arg19 =
reinterpret_cast< char *
>(buf19);
11303 arg20 =
reinterpret_cast< char *
>(buf20);
11308 arg21 =
reinterpret_cast< char *
>(buf21);
11313 arg22 =
reinterpret_cast< char *
>(buf22);
11318 arg23 =
reinterpret_cast< char *
>(buf23);
11319 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);
11320 _outv = octave_value();
11360 return octave_value_list();
11365 PLFLT *arg1 = (PLFLT *) 0 ;
11372 PLFLT *arg8 = (PLFLT *) 0 ;
11374 PLFLT *arg10 = (PLFLT *) 0 ;
11386 octave_value_list _out;
11387 octave_value_list *_outp=&_out;
11388 octave_value _outv;
11394 if (
_n_dims( args(0) ) > 2 )
11396 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11398 temp1 = args(0).matrix_value();
11399 arg1 = &temp1( 0, 0 );
11400 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11407 arg4 =
static_cast< PLINT
>(val4);
11412 arg5 =
static_cast< PLINT
>(val5);
11417 arg6 =
static_cast< PLINT
>(val6);
11422 arg7 =
static_cast< PLINT
>(val7);
11424 if (
_n_dims( args(5) ) > 1 )
11428 temp8 = args(5).matrix_value();
11429 arg8 = &temp8( 0, 0 );
11430 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
11433 if (
_n_dims( args(6) ) > 1 )
11437 if (
_dim( args(6), 0 ) != 6 )
11441 temp10 = args(6).matrix_value();
11442 arg10 = &temp10( 0, 0 );
11444 my_plcont((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10);
11445 _outv = octave_value();
11467 return octave_value_list();
11472 PLFLT *arg1 = (PLFLT *) 0 ;
11479 PLFLT *arg8 = (PLFLT *) 0 ;
11491 octave_value_list _out;
11492 octave_value_list *_outp=&_out;
11493 octave_value _outv;
11499 if (
_n_dims( args(0) ) > 2 )
11501 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11503 temp1 = args(0).matrix_value();
11504 arg1 = &temp1( 0, 0 );
11505 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11512 arg4 =
static_cast< PLINT
>(val4);
11517 arg5 =
static_cast< PLINT
>(val5);
11522 arg6 =
static_cast< PLINT
>(val6);
11527 arg7 =
static_cast< PLINT
>(val7);
11529 if (
_n_dims( args(5) ) > 1 )
11533 temp8 = args(5).matrix_value();
11534 arg8 = &temp8( 0, 0 );
11535 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
11537 my_plcont0((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9);
11538 _outv = octave_value();
11554 return octave_value_list();
11559 PLFLT *arg1 = (PLFLT *) 0 ;
11566 PLFLT *arg8 = (PLFLT *) 0 ;
11568 PLFLT *arg10 = (PLFLT *) 0 ;
11569 PLFLT *arg11 = (PLFLT *) 0 ;
11582 octave_value_list _out;
11583 octave_value_list *_outp=&_out;
11584 octave_value _outv;
11590 if (
_n_dims( args(0) ) > 2 )
11592 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11594 temp1 = args(0).matrix_value();
11595 arg1 = &temp1( 0, 0 );
11596 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11603 arg4 =
static_cast< PLINT
>(val4);
11608 arg5 =
static_cast< PLINT
>(val5);
11613 arg6 =
static_cast< PLINT
>(val6);
11618 arg7 =
static_cast< PLINT
>(val7);
11620 if (
_n_dims( args(5) ) > 1 )
11624 temp8 = args(5).matrix_value();
11625 arg8 = &temp8( 0, 0 );
11626 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
11629 if (
_n_dims( args(6) ) > 1 )
11633 if (
_dim( args(6), 0 ) != Xlen )
11637 temp10 = args(6).matrix_value();
11638 arg10 = &temp10( 0, 0 );
11641 if (
_n_dims( args(7) ) > 1 )
11649 temp11 = args(7).matrix_value();
11650 arg11 = &temp11( 0, 0 );
11652 my_plcont1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11653 _outv = octave_value();
11681 return octave_value_list();
11686 PLFLT *arg1 = (PLFLT *) 0 ;
11693 PLFLT *arg8 = (PLFLT *) 0 ;
11695 PLFLT *arg10 = (PLFLT *) 0 ;
11696 PLFLT *arg11 = (PLFLT *) 0 ;
11709 octave_value_list _out;
11710 octave_value_list *_outp=&_out;
11711 octave_value _outv;
11717 if (
_n_dims( args(0) ) > 2 )
11719 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11721 temp1 = args(0).matrix_value();
11722 arg1 = &temp1( 0, 0 );
11723 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11730 arg4 =
static_cast< PLINT
>(val4);
11735 arg5 =
static_cast< PLINT
>(val5);
11740 arg6 =
static_cast< PLINT
>(val6);
11745 arg7 =
static_cast< PLINT
>(val7);
11747 if (
_n_dims( args(5) ) > 1 )
11751 temp8 = args(5).matrix_value();
11752 arg8 = &temp8( 0, 0 );
11753 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
11756 if (
_n_dims( args(6) ) > 2 )
11758 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11760 if (
_dim( args(6), 0 ) != Xlen )
11762 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11766 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11768 temp10 = args(6).matrix_value();
11769 arg10 = &temp10( 0, 0 );
11772 if (
_n_dims( args(7) ) > 2 )
11774 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11776 if (
_dim( args(7), 0 ) != Xlen )
11778 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11782 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11784 temp11 = args(7).matrix_value();
11785 arg11 = &temp11( 0, 0 );
11787 my_plcont2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11788 _outv = octave_value();
11816 return octave_value_list();
11821 PLFLT *arg1 = (PLFLT *) 0 ;
11828 PLFLT *arg8 = (PLFLT *) 0 ;
11830 PLFLT *arg10 = (PLFLT *) 0 ;
11831 PLFLT *arg11 = (PLFLT *) 0 ;
11844 octave_value_list _out;
11845 octave_value_list *_outp=&_out;
11846 octave_value _outv;
11852 if (
_n_dims( args(0) ) > 2 )
11854 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11856 temp1 = args(0).matrix_value();
11857 arg1 = &temp1( 0, 0 );
11858 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
11865 arg4 =
static_cast< PLINT
>(val4);
11870 arg5 =
static_cast< PLINT
>(val5);
11875 arg6 =
static_cast< PLINT
>(val6);
11880 arg7 =
static_cast< PLINT
>(val7);
11882 if (
_n_dims( args(5) ) > 1 )
11886 temp8 = args(5).matrix_value();
11887 arg8 = &temp8( 0, 0 );
11888 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
11891 if (
_n_dims( args(6) ) > 2 )
11893 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11895 if (
_dim( args(6), 0 ) != Xlen )
11897 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11901 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11903 temp10 = args(6).matrix_value();
11904 arg10 = &temp10( 0, 0 );
11907 if (
_n_dims( args(7) ) > 2 )
11909 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11911 if (
_dim( args(7), 0 ) != Xlen )
11913 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11917 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11919 temp11 = args(7).matrix_value();
11920 arg11 = &temp11( 0, 0 );
11922 my_plcont2p((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11923 _outv = octave_value();
11951 return octave_value_list();
11956 PLFLT *arg1 = (PLFLT *) 0 ;
11957 PLFLT *arg2 = (PLFLT *) 0 ;
11958 PLFLT *arg3 = (PLFLT *) 0 ;
11960 PLFLT *arg5 = (PLFLT *) 0 ;
11962 PLFLT *arg7 = (PLFLT *) 0 ;
11964 PLFLT *arg9 = (PLFLT *) 0 ;
11972 octave_value_list retval7 ;
11977 octave_value_list _out;
11978 octave_value_list *_outp=&_out;
11979 octave_value _outv;
11985 if (
_n_dims( args(0) ) > 1 )
11990 temp1 = args(0).matrix_value();
11991 arg1 = &temp1( 0, 0 );
11994 if (
_n_dims( args(1) ) > 1 )
11998 if (
_dim( args(1), 0 ) != Alen )
12002 temp2 = args(1).matrix_value();
12003 arg2 = &temp2( 0, 0 );
12006 if (
_n_dims( args(2) ) > 1 )
12010 if (
_dim( args(2), 0 ) != Alen )
12014 temp3 = args(2).matrix_value();
12015 arg3 = &temp3( 0, 0 );
12019 if (
_n_dims( args(3) ) > 1 )
12023 temp5 = args(3).matrix_value();
12024 arg5 = &temp5( 0, 0 );
12025 arg6 = Xlen = (
PLINT) (
_dim( args(3), 0 ) );
12028 if (
_n_dims( args(4) ) > 1 )
12032 temp7 = args(4).matrix_value();
12033 arg7 = &temp7( 0, 0 );
12035 retval7( 0 ) = octave_value( Matrix( Xlen,
Ylen ) );
12036 arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
12042 arg10 =
static_cast< PLINT
>(val10);
12047 arg11 =
static_cast< PLFLT
>(val11);
12048 my_plgriddata((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,(
double const *)arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,arg11);
12049 _outv = octave_value();
12086 return octave_value_list();
12091 PLFLT *arg1 = (PLFLT *) 0 ;
12092 PLFLT *arg2 = (PLFLT *) 0 ;
12093 PLFLT *arg3 = (PLFLT *) 0 ;
12102 octave_value_list _out;
12103 octave_value_list *_outp=&_out;
12104 octave_value _outv;
12110 if (
_n_dims( args(0) ) > 1 )
12114 temp1 = args(0).matrix_value();
12115 arg1 = &temp1( 0, 0 );
12119 if (
_n_dims( args(1) ) > 1 )
12123 temp2 = args(1).matrix_value();
12124 arg2 = &temp2( 0, 0 );
12128 if (
_n_dims( args(2) ) > 2 )
12130 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12132 if (
_dim( args(2), 0 ) != Xlen )
12134 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12138 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12140 temp3 = args(2).matrix_value();
12141 arg3 = &temp3( 0, 0 );
12149 arg6 =
static_cast< PLINT
>(val6);
12150 my_plmesh((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6);
12151 _outv = octave_value();
12173 return octave_value_list();
12178 PLFLT *arg1 = (PLFLT *) 0 ;
12179 PLFLT *arg2 = (PLFLT *) 0 ;
12180 PLFLT *arg3 = (PLFLT *) 0 ;
12184 PLFLT *arg7 = (PLFLT *) 0 ;
12192 octave_value_list _out;
12193 octave_value_list *_outp=&_out;
12194 octave_value _outv;
12200 if (
_n_dims( args(0) ) > 1 )
12204 temp1 = args(0).matrix_value();
12205 arg1 = &temp1( 0, 0 );
12209 if (
_n_dims( args(1) ) > 1 )
12213 temp2 = args(1).matrix_value();
12214 arg2 = &temp2( 0, 0 );
12218 if (
_n_dims( args(2) ) > 2 )
12220 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12222 if (
_dim( args(2), 0 ) != Xlen )
12224 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12228 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12230 temp3 = args(2).matrix_value();
12231 arg3 = &temp3( 0, 0 );
12239 arg6 =
static_cast< PLINT
>(val6);
12241 if (
_n_dims( args(4) ) > 1 )
12245 temp7 = args(4).matrix_value();
12246 arg7 = &temp7( 0, 0 );
12247 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
12249 my_plmeshc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12250 _outv = octave_value();
12278 return octave_value_list();
12283 PLFLT *arg1 = (PLFLT *) 0 ;
12284 PLFLT *arg2 = (PLFLT *) 0 ;
12285 PLFLT *arg3 = (PLFLT *) 0 ;
12297 octave_value_list _out;
12298 octave_value_list *_outp=&_out;
12299 octave_value _outv;
12305 if (
_n_dims( args(0) ) > 1 )
12309 temp1 = args(0).matrix_value();
12310 arg1 = &temp1( 0, 0 );
12314 if (
_n_dims( args(1) ) > 1 )
12318 temp2 = args(1).matrix_value();
12319 arg2 = &temp2( 0, 0 );
12323 if (
_n_dims( args(2) ) > 2 )
12325 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12327 if (
_dim( args(2), 0 ) != Xlen )
12329 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12333 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12335 temp3 = args(2).matrix_value();
12336 arg3 = &temp3( 0, 0 );
12344 arg6 =
static_cast< PLINT
>(val6);
12349 arg7 =
static_cast< PLBOOL >(val7);
12350 my_plot3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,arg7);
12351 _outv = octave_value();
12373 return octave_value_list();
12378 PLFLT *arg1 = (PLFLT *) 0 ;
12379 PLFLT *arg2 = (PLFLT *) 0 ;
12380 PLFLT *arg3 = (PLFLT *) 0 ;
12384 PLFLT *arg7 = (PLFLT *) 0 ;
12392 octave_value_list _out;
12393 octave_value_list *_outp=&_out;
12394 octave_value _outv;
12400 if (
_n_dims( args(0) ) > 1 )
12404 temp1 = args(0).matrix_value();
12405 arg1 = &temp1( 0, 0 );
12409 if (
_n_dims( args(1) ) > 1 )
12413 temp2 = args(1).matrix_value();
12414 arg2 = &temp2( 0, 0 );
12418 if (
_n_dims( args(2) ) > 2 )
12420 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12422 if (
_dim( args(2), 0 ) != Xlen )
12424 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12428 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12430 temp3 = args(2).matrix_value();
12431 arg3 = &temp3( 0, 0 );
12439 arg6 =
static_cast< PLINT
>(val6);
12441 if (
_n_dims( args(4) ) > 1 )
12445 temp7 = args(4).matrix_value();
12446 arg7 = &temp7( 0, 0 );
12447 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
12449 my_plot3dc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12450 _outv = octave_value();
12478 return octave_value_list();
12483 PLFLT *arg1 = (PLFLT *) 0 ;
12484 PLFLT *arg2 = (PLFLT *) 0 ;
12485 PLFLT *arg3 = (PLFLT *) 0 ;
12489 PLFLT *arg7 = (PLFLT *) 0 ;
12493 PLINT *arg11 = (PLINT *) 0 ;
12494 PLINT *arg12 = (PLINT *) 0 ;
12505 octave_value_list _out;
12506 octave_value_list *_outp=&_out;
12507 octave_value _outv;
12513 if (
_n_dims( args(0) ) > 1 )
12517 temp1 = args(0).matrix_value();
12518 arg1 = &temp1( 0, 0 );
12522 if (
_n_dims( args(1) ) > 1 )
12526 temp2 = args(1).matrix_value();
12527 arg2 = &temp2( 0, 0 );
12531 if (
_n_dims( args(2) ) > 2 )
12533 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12535 if (
_dim( args(2), 0 ) != Xlen )
12537 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12541 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12543 temp3 = args(2).matrix_value();
12544 arg3 = &temp3( 0, 0 );
12552 arg6 =
static_cast< PLINT
>(val6);
12554 if (
_n_dims( args(4) ) > 1 )
12558 temp7 = args(4).matrix_value();
12559 arg7 = &temp7( 0, 0 );
12560 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
12566 arg9 =
static_cast< PLINT
>(val9);
12568 if (
_n_dims( args(6) ) > 1 )
12572 arg10 = Alen = (
PLINT) (
_dim( args(6), 0 ) );
12573 arg11 =
new PLINT[
Alen];
12574 temp10 = args(6).matrix_value();
12578 if (
_n_dims( args(7) ) > 1 )
12582 if (
_dim( args(7), 0 ) != Alen )
12586 temp12 = args(7).matrix_value();
12587 arg12 =
new PLINT[
Alen];
12590 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);
12591 _outv = octave_value();
12631 return octave_value_list();
12636 PLFLT *arg1 = (PLFLT *) 0 ;
12637 PLFLT *arg2 = (PLFLT *) 0 ;
12638 PLFLT *arg3 = (PLFLT *) 0 ;
12642 PLFLT *arg7 = (PLFLT *) 0 ;
12650 octave_value_list _out;
12651 octave_value_list *_outp=&_out;
12652 octave_value _outv;
12658 if (
_n_dims( args(0) ) > 1 )
12662 temp1 = args(0).matrix_value();
12663 arg1 = &temp1( 0, 0 );
12667 if (
_n_dims( args(1) ) > 1 )
12671 temp2 = args(1).matrix_value();
12672 arg2 = &temp2( 0, 0 );
12676 if (
_n_dims( args(2) ) > 2 )
12678 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12680 if (
_dim( args(2), 0 ) != Xlen )
12682 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12686 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12688 temp3 = args(2).matrix_value();
12689 arg3 = &temp3( 0, 0 );
12697 arg6 =
static_cast< PLINT
>(val6);
12699 if (
_n_dims( args(4) ) > 1 )
12703 temp7 = args(4).matrix_value();
12704 arg7 = &temp7( 0, 0 );
12705 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
12707 my_plsurf3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12708 _outv = octave_value();
12736 return octave_value_list();
12741 PLFLT *arg1 = (PLFLT *) 0 ;
12742 PLFLT *arg2 = (PLFLT *) 0 ;
12743 PLFLT *arg3 = (PLFLT *) 0 ;
12747 PLFLT *arg7 = (PLFLT *) 0 ;
12751 PLINT *arg11 = (PLINT *) 0 ;
12752 PLINT *arg12 = (PLINT *) 0 ;
12763 octave_value_list _out;
12764 octave_value_list *_outp=&_out;
12765 octave_value _outv;
12771 if (
_n_dims( args(0) ) > 1 )
12775 temp1 = args(0).matrix_value();
12776 arg1 = &temp1( 0, 0 );
12780 if (
_n_dims( args(1) ) > 1 )
12784 temp2 = args(1).matrix_value();
12785 arg2 = &temp2( 0, 0 );
12789 if (
_n_dims( args(2) ) > 2 )
12791 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12793 if (
_dim( args(2), 0 ) != Xlen )
12795 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12799 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12801 temp3 = args(2).matrix_value();
12802 arg3 = &temp3( 0, 0 );
12810 arg6 =
static_cast< PLINT
>(val6);
12812 if (
_n_dims( args(4) ) > 1 )
12816 temp7 = args(4).matrix_value();
12817 arg7 = &temp7( 0, 0 );
12818 arg8 = Alen = (
PLINT) (
_dim( args(4), 0 ) );
12824 arg9 =
static_cast< PLINT
>(val9);
12826 if (
_n_dims( args(6) ) > 1 )
12830 arg10 = Alen = (
PLINT) (
_dim( args(6), 0 ) );
12831 arg11 =
new PLINT[
Alen];
12832 temp10 = args(6).matrix_value();
12836 if (
_n_dims( args(7) ) > 1 )
12840 if (
_dim( args(7), 0 ) != Alen )
12844 temp12 = args(7).matrix_value();
12845 arg12 =
new PLINT[
Alen];
12848 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);
12849 _outv = octave_value();
12889 return octave_value_list();
12894 PLFLT *arg1 = (PLFLT *) 0 ;
12897 PLFLT *arg4 = (PLFLT *) 0 ;
12912 PLFLT *arg19 = (PLFLT *) 0 ;
12944 octave_value_list _out;
12945 octave_value_list *_outp=&_out;
12946 octave_value _outv;
12952 if (
_n_dims( args(0) ) > 2 )
12954 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12956 temp1 = args(0).matrix_value();
12957 arg1 = &temp1( 0, 0 );
12958 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
12962 if (
_n_dims( args(1) ) > 1 )
12967 temp4 = args(1).matrix_value();
12968 arg4 = &temp4( 0, 0 );
12974 arg5 =
static_cast< PLFLT
>(val5);
12979 arg6 =
static_cast< PLFLT
>(val6);
12984 arg7 =
static_cast< PLFLT
>(val7);
12989 arg8 =
static_cast< PLFLT
>(val8);
12994 arg9 =
static_cast< PLFLT
>(val9);
12999 arg10 =
static_cast< PLFLT
>(val10);
13004 arg11 =
static_cast< PLINT
>(val11);
13009 arg12 =
static_cast< PLFLT
>(val12);
13014 arg13 =
static_cast< PLINT
>(val13);
13019 arg14 =
static_cast< PLINT
>(val14);
13024 arg15 =
static_cast< PLINT
>(val15);
13029 arg16 =
static_cast< PLINT
>(val16);
13034 arg17 =
static_cast< PLINT
>(val17);
13039 arg18 =
static_cast< PLBOOL >(val18);
13041 if (
_n_dims( args(16) ) > 1 )
13045 if (
_dim( args(16), 0 ) != 6 )
13049 temp19 = args(16).matrix_value();
13050 arg19 = &temp19( 0, 0 );
13052 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);
13053 _outv = octave_value();
13075 return octave_value_list();
13080 PLFLT *arg1 = (PLFLT *) 0 ;
13083 char *arg4 = (
char *) 0 ;
13098 PLFLT *arg19 = (PLFLT *) 0 ;
13099 PLFLT *arg20 = (PLFLT *) 0 ;
13134 octave_value_list _out;
13135 octave_value_list *_outp=&_out;
13136 octave_value _outv;
13142 if (
_n_dims( args(0) ) > 2 )
13144 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13146 temp1 = args(0).matrix_value();
13147 arg1 = &temp1( 0, 0 );
13148 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13155 arg4 =
reinterpret_cast< char *
>(buf4);
13160 arg5 =
static_cast< PLFLT
>(val5);
13165 arg6 =
static_cast< PLFLT
>(val6);
13170 arg7 =
static_cast< PLFLT
>(val7);
13175 arg8 =
static_cast< PLFLT
>(val8);
13180 arg9 =
static_cast< PLFLT
>(val9);
13185 arg10 =
static_cast< PLFLT
>(val10);
13190 arg11 =
static_cast< PLINT
>(val11);
13195 arg12 =
static_cast< PLFLT
>(val12);
13200 arg13 =
static_cast< PLINT
>(val13);
13205 arg14 =
static_cast< PLINT
>(val14);
13210 arg15 =
static_cast< PLINT
>(val15);
13215 arg16 =
static_cast< PLINT
>(val16);
13220 arg17 =
static_cast< PLINT
>(val17);
13225 arg18 =
static_cast< PLBOOL >(val18);
13227 if (
_n_dims( args(16) ) > 1 )
13231 if (
_dim( args(16), 0 ) != Xlen )
13235 temp19 = args(16).matrix_value();
13236 arg19 = &temp19( 0, 0 );
13239 if (
_n_dims( args(17) ) > 1 )
13243 if (
_dim( args(17), 0 ) !=
Ylen )
13247 temp20 = args(17).matrix_value();
13248 arg20 = &temp20( 0, 0 );
13250 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);
13251 _outv = octave_value();
13275 return octave_value_list();
13280 PLFLT *arg1 = (PLFLT *) 0 ;
13283 char *arg4 = (
char *) 0 ;
13298 PLFLT *arg19 = (PLFLT *) 0 ;
13299 PLFLT *arg20 = (PLFLT *) 0 ;
13334 octave_value_list _out;
13335 octave_value_list *_outp=&_out;
13336 octave_value _outv;
13342 if (
_n_dims( args(0) ) > 2 )
13344 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13346 temp1 = args(0).matrix_value();
13347 arg1 = &temp1( 0, 0 );
13348 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13355 arg4 =
reinterpret_cast< char *
>(buf4);
13360 arg5 =
static_cast< PLFLT
>(val5);
13365 arg6 =
static_cast< PLFLT
>(val6);
13370 arg7 =
static_cast< PLFLT
>(val7);
13375 arg8 =
static_cast< PLFLT
>(val8);
13380 arg9 =
static_cast< PLFLT
>(val9);
13385 arg10 =
static_cast< PLFLT
>(val10);
13390 arg11 =
static_cast< PLINT
>(val11);
13395 arg12 =
static_cast< PLFLT
>(val12);
13400 arg13 =
static_cast< PLINT
>(val13);
13405 arg14 =
static_cast< PLINT
>(val14);
13410 arg15 =
static_cast< PLINT
>(val15);
13415 arg16 =
static_cast< PLINT
>(val16);
13420 arg17 =
static_cast< PLINT
>(val17);
13425 arg18 =
static_cast< PLBOOL >(val18);
13427 if (
_n_dims( args(16) ) > 2 )
13429 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13431 temp19 = args(16).matrix_value();
13432 arg19 = &temp19( 0, 0 );
13433 Xlen = (
PLINT) (
_dim( args(16), 0 ) );
13437 if (
_n_dims( args(17) ) > 2 )
13439 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13441 temp20 = args(17).matrix_value();
13442 arg20 = &temp20( 0, 0 );
13443 Xlen = (
PLINT) (
_dim( args(17), 0 ) );
13446 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);
13447 _outv = octave_value();
13471 return octave_value_list();
13476 PLFLT *arg1 = (PLFLT *) 0 ;
13483 PLFLT *arg8 = (PLFLT *) 0 ;
13507 octave_value_list _out;
13508 octave_value_list *_outp=&_out;
13509 octave_value _outv;
13515 if (
_n_dims( args(0) ) > 2 )
13517 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13519 temp1 = args(0).matrix_value();
13520 arg1 = &temp1( 0, 0 );
13521 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13528 arg4 =
static_cast< PLFLT
>(val4);
13533 arg5 =
static_cast< PLFLT
>(val5);
13538 arg6 =
static_cast< PLFLT
>(val6);
13543 arg7 =
static_cast< PLFLT
>(val7);
13545 if (
_n_dims( args(5) ) > 1 )
13549 temp8 = args(5).matrix_value();
13550 arg8 = &temp8( 0, 0 );
13551 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
13557 arg10 =
static_cast< PLINT
>(val10);
13562 arg11 =
static_cast< PLINT
>(val11);
13567 arg12 =
static_cast< PLINT
>(val12);
13572 arg13 =
static_cast< PLBOOL >(val13);
13573 my_plshades((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13);
13574 _outv = octave_value();
13590 return octave_value_list();
13595 PLFLT *arg1 = (PLFLT *) 0 ;
13602 PLFLT *arg8 = (PLFLT *) 0 ;
13608 PLFLT *arg14 = (PLFLT *) 0 ;
13628 octave_value_list _out;
13629 octave_value_list *_outp=&_out;
13630 octave_value _outv;
13636 if (
_n_dims( args(0) ) > 2 )
13638 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13640 temp1 = args(0).matrix_value();
13641 arg1 = &temp1( 0, 0 );
13642 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13649 arg4 =
static_cast< PLFLT
>(val4);
13654 arg5 =
static_cast< PLFLT
>(val5);
13659 arg6 =
static_cast< PLFLT
>(val6);
13664 arg7 =
static_cast< PLFLT
>(val7);
13666 if (
_n_dims( args(5) ) > 1 )
13670 temp8 = args(5).matrix_value();
13671 arg8 = &temp8( 0, 0 );
13672 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
13678 arg10 =
static_cast< PLINT
>(val10);
13683 arg11 =
static_cast< PLINT
>(val11);
13688 arg12 =
static_cast< PLINT
>(val12);
13693 arg13 =
static_cast< PLBOOL >(val13);
13695 if (
_n_dims( args(10) ) > 1 )
13699 if (
_dim( args(10), 0 ) != 6 )
13703 temp14 = args(10).matrix_value();
13704 arg14 = &temp14( 0, 0 );
13706 my_plshadesx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
13707 _outv = octave_value();
13729 return octave_value_list();
13734 PLFLT *arg1 = (PLFLT *) 0 ;
13741 PLFLT *arg8 = (PLFLT *) 0 ;
13747 PLFLT *arg14 = (PLFLT *) 0 ;
13748 PLFLT *arg15 = (PLFLT *) 0 ;
13769 octave_value_list _out;
13770 octave_value_list *_outp=&_out;
13771 octave_value _outv;
13777 if (
_n_dims( args(0) ) > 2 )
13779 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13781 temp1 = args(0).matrix_value();
13782 arg1 = &temp1( 0, 0 );
13783 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13790 arg4 =
static_cast< PLFLT
>(val4);
13795 arg5 =
static_cast< PLFLT
>(val5);
13800 arg6 =
static_cast< PLFLT
>(val6);
13805 arg7 =
static_cast< PLFLT
>(val7);
13807 if (
_n_dims( args(5) ) > 1 )
13811 temp8 = args(5).matrix_value();
13812 arg8 = &temp8( 0, 0 );
13813 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
13819 arg10 =
static_cast< PLINT
>(val10);
13824 arg11 =
static_cast< PLINT
>(val11);
13829 arg12 =
static_cast< PLINT
>(val12);
13834 arg13 =
static_cast< PLBOOL >(val13);
13836 if (
_n_dims( args(10) ) > 1 )
13840 if (
_dim( args(10), 0 ) != Xlen )
13844 temp14 = args(10).matrix_value();
13845 arg14 = &temp14( 0, 0 );
13848 if (
_n_dims( args(11) ) > 1 )
13852 if (
_dim( args(11), 0 ) !=
Ylen )
13856 temp15 = args(11).matrix_value();
13857 arg15 = &temp15( 0, 0 );
13859 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);
13860 _outv = octave_value();
13888 return octave_value_list();
13893 PLFLT *arg1 = (PLFLT *) 0 ;
13900 PLFLT *arg8 = (PLFLT *) 0 ;
13906 PLFLT *arg14 = (PLFLT *) 0 ;
13907 PLFLT *arg15 = (PLFLT *) 0 ;
13928 octave_value_list _out;
13929 octave_value_list *_outp=&_out;
13930 octave_value _outv;
13936 if (
_n_dims( args(0) ) > 2 )
13938 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13940 temp1 = args(0).matrix_value();
13941 arg1 = &temp1( 0, 0 );
13942 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
13949 arg4 =
static_cast< PLFLT
>(val4);
13954 arg5 =
static_cast< PLFLT
>(val5);
13959 arg6 =
static_cast< PLFLT
>(val6);
13964 arg7 =
static_cast< PLFLT
>(val7);
13966 if (
_n_dims( args(5) ) > 1 )
13970 temp8 = args(5).matrix_value();
13971 arg8 = &temp8( 0, 0 );
13972 arg9 = Alen = (
PLINT) (
_dim( args(5), 0 ) );
13978 arg10 =
static_cast< PLINT
>(val10);
13983 arg11 =
static_cast< PLINT
>(val11);
13988 arg12 =
static_cast< PLINT
>(val12);
13993 arg13 =
static_cast< PLBOOL >(val13);
13995 if (
_n_dims( args(10) ) > 2 )
13997 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13999 temp14 = args(10).matrix_value();
14000 arg14 = &temp14( 0, 0 );
14001 Xlen = (
PLINT) (
_dim( args(10), 0 ) );
14005 if (
_n_dims( args(11) ) > 2 )
14007 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14009 temp15 = args(11).matrix_value();
14010 arg15 = &temp15( 0, 0 );
14011 Xlen = (
PLINT) (
_dim( args(11), 0 ) );
14014 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);
14015 _outv = octave_value();
14043 return octave_value_list();
14048 PLFLT *arg1 = (PLFLT *) 0 ;
14049 PLFLT *arg2 = (PLFLT *) 0 ;
14053 PLFLT *arg6 = (PLFLT *) 0 ;
14059 octave_value_list _out;
14060 octave_value_list *_outp=&_out;
14061 octave_value _outv;
14067 if (
_n_dims( args(0) ) > 2 )
14069 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14071 temp1 = args(0).matrix_value();
14072 arg1 = &temp1( 0, 0 );
14077 if (
_n_dims( args(1) ) > 2 )
14079 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14081 if (
_dim( args(1), 0 ) != Xlen )
14083 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14087 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14089 temp2 = args(1).matrix_value();
14090 arg2 = &temp2( 0, 0 );
14098 arg5 =
static_cast< PLFLT
>(val5);
14100 if (
_n_dims( args(3) ) > 1 )
14104 if (
_dim( args(3), 0 ) != 6 )
14108 temp6 = args(3).matrix_value();
14109 arg6 = &temp6( 0, 0 );
14111 my_plvect((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
14112 _outv = octave_value();
14134 return octave_value_list();
14139 PLFLT *arg1 = (PLFLT *) 0 ;
14140 PLFLT *arg2 = (PLFLT *) 0 ;
14144 PLFLT *arg6 = (PLFLT *) 0 ;
14145 PLFLT *arg7 = (PLFLT *) 0 ;
14152 octave_value_list _out;
14153 octave_value_list *_outp=&_out;
14154 octave_value _outv;
14160 if (
_n_dims( args(0) ) > 2 )
14162 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14164 temp1 = args(0).matrix_value();
14165 arg1 = &temp1( 0, 0 );
14170 if (
_n_dims( args(1) ) > 2 )
14172 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14174 if (
_dim( args(1), 0 ) != Xlen )
14176 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14180 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14182 temp2 = args(1).matrix_value();
14183 arg2 = &temp2( 0, 0 );
14191 arg5 =
static_cast< PLFLT
>(val5);
14193 if (
_n_dims( args(3) ) > 1 )
14197 if (
_dim( args(3), 0 ) != Xlen )
14201 temp6 = args(3).matrix_value();
14202 arg6 = &temp6( 0, 0 );
14205 if (
_n_dims( args(4) ) > 1 )
14213 temp7 = args(4).matrix_value();
14214 arg7 = &temp7( 0, 0 );
14216 my_plvect1((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14217 _outv = octave_value();
14245 return octave_value_list();
14250 PLFLT *arg1 = (PLFLT *) 0 ;
14251 PLFLT *arg2 = (PLFLT *) 0 ;
14255 PLFLT *arg6 = (PLFLT *) 0 ;
14256 PLFLT *arg7 = (PLFLT *) 0 ;
14263 octave_value_list _out;
14264 octave_value_list *_outp=&_out;
14265 octave_value _outv;
14271 if (
_n_dims( args(0) ) > 2 )
14273 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14275 temp1 = args(0).matrix_value();
14276 arg1 = &temp1( 0, 0 );
14281 if (
_n_dims( args(1) ) > 2 )
14283 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14285 if (
_dim( args(1), 0 ) != Xlen )
14287 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14291 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14293 temp2 = args(1).matrix_value();
14294 arg2 = &temp2( 0, 0 );
14302 arg5 =
static_cast< PLFLT
>(val5);
14304 if (
_n_dims( args(3) ) > 2 )
14306 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14308 temp6 = args(3).matrix_value();
14309 arg6 = &temp6( 0, 0 );
14314 if (
_n_dims( args(4) ) > 2 )
14316 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14318 temp7 = args(4).matrix_value();
14319 arg7 = &temp7( 0, 0 );
14323 my_plvect2((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14324 _outv = octave_value();
14352 return octave_value_list();
14357 PLFLT *arg1 = (PLFLT *) 0 ;
14391 octave_value_list _out;
14392 octave_value_list *_outp=&_out;
14393 octave_value _outv;
14399 if (
_n_dims( args(0) ) > 2 )
14401 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14403 temp1 = args(0).matrix_value();
14404 arg1 = &temp1( 0, 0 );
14405 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
14412 arg4 =
static_cast< PLFLT
>(val4);
14417 arg5 =
static_cast< PLFLT
>(val5);
14422 arg6 =
static_cast< PLFLT
>(val6);
14427 arg7 =
static_cast< PLFLT
>(val7);
14432 arg8 =
static_cast< PLFLT
>(val8);
14437 arg9 =
static_cast< PLFLT
>(val9);
14442 arg10 =
static_cast< PLFLT
>(val10);
14447 arg11 =
static_cast< PLFLT
>(val11);
14452 arg12 =
static_cast< PLFLT
>(val12);
14457 arg13 =
static_cast< PLFLT
>(val13);
14458 my_plimage((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14459 _outv = octave_value();
14469 return octave_value_list();
14474 PLFLT *arg1 = (PLFLT *) 0 ;
14502 octave_value_list _out;
14503 octave_value_list *_outp=&_out;
14504 octave_value _outv;
14510 if (
_n_dims( args(0) ) > 2 )
14512 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14514 temp1 = args(0).matrix_value();
14515 arg1 = &temp1( 0, 0 );
14516 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
14523 arg4 =
static_cast< PLFLT
>(val4);
14528 arg5 =
static_cast< PLFLT
>(val5);
14533 arg6 =
static_cast< PLFLT
>(val6);
14538 arg7 =
static_cast< PLFLT
>(val7);
14543 arg8 =
static_cast< PLFLT
>(val8);
14548 arg9 =
static_cast< PLFLT
>(val9);
14553 arg10 =
static_cast< PLFLT
>(val10);
14558 arg11 =
static_cast< PLFLT
>(val11);
14559 my_plimagefr((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
14560 _outv = octave_value();
14570 return octave_value_list();
14575 PLFLT *arg1 = (PLFLT *) 0 ;
14586 PLFLT *arg12 = (PLFLT *) 0 ;
14605 octave_value_list _out;
14606 octave_value_list *_outp=&_out;
14607 octave_value _outv;
14613 if (
_n_dims( args(0) ) > 2 )
14615 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14617 temp1 = args(0).matrix_value();
14618 arg1 = &temp1( 0, 0 );
14619 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
14626 arg4 =
static_cast< PLFLT
>(val4);
14631 arg5 =
static_cast< PLFLT
>(val5);
14636 arg6 =
static_cast< PLFLT
>(val6);
14641 arg7 =
static_cast< PLFLT
>(val7);
14646 arg8 =
static_cast< PLFLT
>(val8);
14651 arg9 =
static_cast< PLFLT
>(val9);
14656 arg10 =
static_cast< PLFLT
>(val10);
14661 arg11 =
static_cast< PLFLT
>(val11);
14663 if (
_n_dims( args(9) ) > 1 )
14667 if (
_dim( args(9), 0 ) != 6 )
14671 temp12 = args(9).matrix_value();
14672 arg12 = &temp12( 0, 0 );
14674 my_plimagefrx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14675 _outv = octave_value();
14691 return octave_value_list();
14696 PLFLT *arg1 = (PLFLT *) 0 ;
14707 PLFLT *arg12 = (PLFLT *) 0 ;
14708 PLFLT *arg13 = (PLFLT *) 0 ;
14728 octave_value_list _out;
14729 octave_value_list *_outp=&_out;
14730 octave_value _outv;
14736 if (
_n_dims( args(0) ) > 2 )
14738 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14740 temp1 = args(0).matrix_value();
14741 arg1 = &temp1( 0, 0 );
14742 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
14749 arg4 =
static_cast< PLFLT
>(val4);
14754 arg5 =
static_cast< PLFLT
>(val5);
14759 arg6 =
static_cast< PLFLT
>(val6);
14764 arg7 =
static_cast< PLFLT
>(val7);
14769 arg8 =
static_cast< PLFLT
>(val8);
14774 arg9 =
static_cast< PLFLT
>(val9);
14779 arg10 =
static_cast< PLFLT
>(val10);
14784 arg11 =
static_cast< PLFLT
>(val11);
14786 if (
_n_dims( args(9) ) > 1 )
14790 if (
_dim( args(9), 0 ) != Xlen )
14794 temp12 = args(9).matrix_value();
14795 arg12 = &temp12( 0, 0 );
14798 if (
_n_dims( args(10) ) > 1 )
14802 if (
_dim( args(10), 0 ) !=
Ylen )
14806 temp13 = args(10).matrix_value();
14807 arg13 = &temp13( 0, 0 );
14809 my_plimagefr1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
14810 _outv = octave_value();
14832 return octave_value_list();
14837 PLFLT *arg1 = (PLFLT *) 0 ;
14848 PLFLT *arg12 = (PLFLT *) 0 ;
14849 PLFLT *arg13 = (PLFLT *) 0 ;
14869 octave_value_list _out;
14870 octave_value_list *_outp=&_out;
14871 octave_value _outv;
14877 if (
_n_dims( args(0) ) > 2 )
14879 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14881 temp1 = args(0).matrix_value();
14882 arg1 = &temp1( 0, 0 );
14883 arg2 = Xlen = (
PLINT) (
_dim( args(0), 0 ) );
14890 arg4 =
static_cast< PLFLT
>(val4);
14895 arg5 =
static_cast< PLFLT
>(val5);
14900 arg6 =
static_cast< PLFLT
>(val6);
14905 arg7 =
static_cast< PLFLT
>(val7);
14910 arg8 =
static_cast< PLFLT
>(val8);
14915 arg9 =
static_cast< PLFLT
>(val9);
14920 arg10 =
static_cast< PLFLT
>(val10);
14925 arg11 =
static_cast< PLFLT
>(val11);
14927 if (
_n_dims( args(9) ) > 2 )
14929 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14931 temp12 = args(9).matrix_value();
14932 arg12 = &temp12( 0, 0 );
14937 if (
_n_dims( args(10) ) > 2 )
14939 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14941 temp13 = args(10).matrix_value();
14942 arg13 = &temp13( 0, 0 );
14943 Xlen = (
PLINT) (
_dim( args(10), 0 ) );
14946 my_plimagefr2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
14947 _outv = octave_value();
14969 return octave_value_list();
14974 PLFLT *arg1 = (PLFLT *) 0 ;
14975 PLFLT *arg2 = (PLFLT *) 0 ;
14990 PLINT *arg17 = (PLINT *) 0 ;
14991 char **arg18 = (
char **) 0 ;
14993 char **arg20 = (
char **) 0 ;
14994 PLFLT *arg21 = (PLFLT *) 0 ;
14995 PLINT *arg22 = (PLINT *) 0 ;
14996 PLINT *arg23 = (PLINT *) 0 ;
14997 PLFLT *arg24 = (PLFLT *) 0 ;
15033 octave_value_list _out;
15034 octave_value_list *_outp=&_out;
15035 octave_value _outv;
15046 arg3 =
static_cast< PLINT
>(val3);
15051 arg4 =
static_cast< PLINT
>(val4);
15056 arg5 =
static_cast< PLFLT
>(val5);
15061 arg6 =
static_cast< PLFLT
>(val6);
15066 arg7 =
static_cast< PLFLT
>(val7);
15071 arg8 =
static_cast< PLFLT
>(val8);
15076 arg9 =
static_cast< PLINT
>(val9);
15081 arg10 =
static_cast< PLINT
>(val10);
15086 arg11 =
static_cast< PLINT
>(val11);
15091 arg12 =
static_cast< PLFLT
>(val12);
15096 arg13 =
static_cast< PLFLT
>(val13);
15101 arg14 =
static_cast< PLINT
>(val14);
15106 arg15 =
static_cast< PLFLT
>(val15);
15108 if (
_n_dims( args(13) ) > 1 )
15112 arg16 = Alen = (
PLINT) (
_dim( args(13), 0 ) );
15113 arg17 =
new PLINT[
Alen];
15114 temp16 = args(13).matrix_value();
15118 charMatrix temp_matrix;
15122 size_t max_length = 0, non_blank_length;
15124 if (
_n_dims( args(14) ) > 2 )
15126 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
15128 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 15129 if ( !args(14).isempty() )
15131 if ( !args(14).is_empty() )
15134 if (
_dim( args(14), 0 ) != Alen )
15136 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
15138 arg18 =
new char*[
Alen];
15139 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 15140 ifcell = args(14).iscell();
15142 ifcell = args(14).is_cell();
15146 temp_cell = args(14).cell_value();
15150 temp_matrix = args(14).char_matrix_value();
15152 max_length =
_dim( args(14), 1 ) + 1;
15155 for ( i = 0; i <
Alen; i++ )
15162 if ( temp_cell.elem( i ).is_string() )
15164 str = temp_cell.elem( i ).string_value();
15166 max_length = str.size() + 1;
15167 tmp_cstring = (
char *) str.c_str();
15177 tmp_cstring = (
char *)
"";
15182 str = temp_matrix.row_as_string( i );
15183 tmp_cstring = (
char *) str.c_str();
15185 arg18[i] =
new char[max_length];
15186 strncpy( arg18[i], tmp_cstring, max_length - 1 );
15187 arg18[i][max_length - 1] =
'\0';
15202 non_blank_length = max_length - 2;
15203 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
'\0' )
15205 non_blank_length--;
15207 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
' ' )
15209 non_blank_length--;
15211 arg18[i][non_blank_length + 1] =
'\0';
15221 charMatrix temp_matrix;
15225 size_t max_length = 0, non_blank_length;
15227 if (
_n_dims( args(15) ) > 2 )
15229 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
15231 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 15232 if ( !args(15).isempty() )
15234 if ( !args(15).is_empty() )
15237 Alen =
_dim( args(15), 0 );
15239 arg20 =
new char*[
Alen];
15240 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 15241 ifcell = args(15).iscell();
15243 ifcell = args(15).is_cell();
15247 temp_cell = args(15).cell_value();
15251 temp_matrix = args(15).char_matrix_value();
15253 max_length =
_dim( args(15), 1 ) + 1;
15256 for ( i = 0; i <
Alen; i++ )
15263 if ( temp_cell.elem( i ).is_string() )
15265 str = temp_cell.elem( i ).string_value();
15267 max_length = str.size() + 1;
15268 tmp_cstring = (
char *) str.c_str();
15278 tmp_cstring = (
char *)
"";
15283 str = temp_matrix.row_as_string( i );
15284 tmp_cstring = (
char *) str.c_str();
15286 arg20[i] =
new char[max_length];
15287 strncpy( arg20[i], tmp_cstring, max_length - 1 );
15288 arg20[i][max_length - 1] =
'\0';
15303 non_blank_length = max_length - 2;
15304 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
15306 non_blank_length--;
15308 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
15310 non_blank_length--;
15312 arg20[i][non_blank_length + 1] =
'\0';
15323 if (
_n_dims( args(16) ) > 1 )
15327 if (
_dim( args(16), 0 ) != Alen )
15331 temp21 = args(16).matrix_value();
15332 arg21 = &temp21( 0, 0 );
15335 if (
_n_dims( args(17) ) > 1 )
15339 if (
_dim( args(17), 0 ) != Alen )
15343 temp22 = args(17).matrix_value();
15344 arg22 =
new PLINT[
Alen];
15349 if (
_n_dims( args(18) ) > 1 )
15353 if (
_dim( args(18), 0 ) != Alen )
15358 temp23 = args(18).matrix_value();
15359 arg23 =
new PLINT[
Alen];
15362 for ( i = 0; i <
Xlen; i++ )
15363 if ( arg23[i] >
Ylen )
15367 if (
_n_dims( args(19) ) > 2 )
15369 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15371 if (
_dim( args(19), 0 ) != Xlen )
15373 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
15375 if (
_dim( args(19), 1 ) !=
Ylen )
15377 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
15379 temp24 = args(19).matrix_value();
15380 arg24 = &temp24( 0, 0 );
15382 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);
15383 _outv = octave_value();
15402 if ( arg18 != NULL )
15404 for ( i = 0; i <
Alen; i++ )
15413 if ( arg20 != NULL )
15415 for ( i = 0; i <
Alen; i++ )
15441 if ( arg18 != NULL )
15443 for ( i = 0; i <
Alen; i++ )
15452 if ( arg20 != NULL )
15454 for ( i = 0; i <
Alen; i++ )
15473 return octave_value_list();
15484 octave_value_list _out;
15485 octave_value_list *_outp=&_out;
15486 octave_value _outv;
15500 arg2 =
static_cast< int >(val2);
15501 if (arg1) (arg1)->type = arg2;
15502 _outv = octave_value();
15506 return octave_value_list();
15514 octave_value_list _out;
15515 octave_value_list *_outp=&_out;
15516 octave_value _outv;
15527 result = (int) ((arg1)->type);
15532 return octave_value_list();
15538 unsigned int arg2 ;
15541 unsigned int val2 ;
15543 octave_value_list _out;
15544 octave_value_list *_outp=&_out;
15545 octave_value _outv;
15559 arg2 =
static_cast< unsigned int >(val2);
15560 if (arg1) (arg1)->state = arg2;
15561 _outv = octave_value();
15565 return octave_value_list();
15573 octave_value_list _out;
15574 octave_value_list *_outp=&_out;
15575 octave_value _outv;
15576 unsigned int result;
15586 result = (
unsigned int) ((arg1)->state);
15591 return octave_value_list();
15597 unsigned int arg2 ;
15600 unsigned int val2 ;
15602 octave_value_list _out;
15603 octave_value_list *_outp=&_out;
15604 octave_value _outv;
15618 arg2 =
static_cast< unsigned int >(val2);
15619 if (arg1) (arg1)->keysym = arg2;
15620 _outv = octave_value();
15624 return octave_value_list();
15632 octave_value_list _out;
15633 octave_value_list *_outp=&_out;
15634 octave_value _outv;
15635 unsigned int result;
15645 result = (
unsigned int) ((arg1)->keysym);
15650 return octave_value_list();
15656 unsigned int arg2 ;
15659 unsigned int val2 ;
15661 octave_value_list _out;
15662 octave_value_list *_outp=&_out;
15663 octave_value _outv;
15677 arg2 =
static_cast< unsigned int >(val2);
15678 if (arg1) (arg1)->button = arg2;
15679 _outv = octave_value();
15683 return octave_value_list();
15691 octave_value_list _out;
15692 octave_value_list *_outp=&_out;
15693 octave_value _outv;
15694 unsigned int result;
15704 result = (
unsigned int) ((arg1)->button);
15709 return octave_value_list();
15720 octave_value_list _out;
15721 octave_value_list *_outp=&_out;
15722 octave_value _outv;
15736 arg2 =
static_cast< PLINT
>(val2);
15737 if (arg1) (arg1)->subwindow = arg2;
15738 _outv = octave_value();
15742 return octave_value_list();
15750 octave_value_list _out;
15751 octave_value_list *_outp=&_out;
15752 octave_value _outv;
15763 result = (
PLINT) ((arg1)->subwindow);
15768 return octave_value_list();
15779 octave_value_list _out;
15780 octave_value_list *_outp=&_out;
15781 octave_value _outv;
15795 arg2 =
reinterpret_cast< char *
>(temp2);
15796 if (arg2) memcpy(arg1->
string,arg2,16*
sizeof(
char));
15797 else memset(arg1->
string,0,16*
sizeof(
char));
15798 _outv = octave_value();
15802 return octave_value_list();
15810 octave_value_list _out;
15811 octave_value_list *_outp=&_out;
15812 octave_value _outv;
15823 result = (
char *)(
char *) ((arg1)->
string);
15834 return octave_value_list();
15845 octave_value_list _out;
15846 octave_value_list *_outp=&_out;
15847 octave_value _outv;
15861 arg2 =
static_cast< int >(val2);
15862 if (arg1) (arg1)->pX = arg2;
15863 _outv = octave_value();
15867 return octave_value_list();
15875 octave_value_list _out;
15876 octave_value_list *_outp=&_out;
15877 octave_value _outv;
15888 result = (int) ((arg1)->pX);
15893 return octave_value_list();
15904 octave_value_list _out;
15905 octave_value_list *_outp=&_out;
15906 octave_value _outv;
15920 arg2 =
static_cast< int >(val2);
15921 if (arg1) (arg1)->pY = arg2;
15922 _outv = octave_value();
15926 return octave_value_list();
15934 octave_value_list _out;
15935 octave_value_list *_outp=&_out;
15936 octave_value _outv;
15947 result = (int) ((arg1)->pY);
15952 return octave_value_list();
15963 octave_value_list _out;
15964 octave_value_list *_outp=&_out;
15965 octave_value _outv;
15979 arg2 =
static_cast< PLFLT
>(val2);
15980 if (arg1) (arg1)->dX = arg2;
15981 _outv = octave_value();
15985 return octave_value_list();
15993 octave_value_list _out;
15994 octave_value_list *_outp=&_out;
15995 octave_value _outv;
16006 result = (
PLFLT) ((arg1)->dX);
16011 return octave_value_list();
16022 octave_value_list _out;
16023 octave_value_list *_outp=&_out;
16024 octave_value _outv;
16038 arg2 =
static_cast< PLFLT
>(val2);
16039 if (arg1) (arg1)->dY = arg2;
16040 _outv = octave_value();
16044 return octave_value_list();
16052 octave_value_list _out;
16053 octave_value_list *_outp=&_out;
16054 octave_value _outv;
16065 result = (
PLFLT) ((arg1)->dY);
16070 return octave_value_list();
16081 octave_value_list _out;
16082 octave_value_list *_outp=&_out;
16083 octave_value _outv;
16097 arg2 =
static_cast< PLFLT
>(val2);
16098 if (arg1) (arg1)->wX = arg2;
16099 _outv = octave_value();
16103 return octave_value_list();
16111 octave_value_list _out;
16112 octave_value_list *_outp=&_out;
16113 octave_value _outv;
16124 result = (
PLFLT) ((arg1)->wX);
16129 return octave_value_list();
16140 octave_value_list _out;
16141 octave_value_list *_outp=&_out;
16142 octave_value _outv;
16156 arg2 =
static_cast< PLFLT
>(val2);
16157 if (arg1) (arg1)->wY = arg2;
16158 _outv = octave_value();
16162 return octave_value_list();
16170 octave_value_list _out;
16171 octave_value_list *_outp=&_out;
16172 octave_value _outv;
16183 result = (
PLFLT) ((arg1)->wY);
16188 return octave_value_list();
16193 octave_value_list _out;
16194 octave_value_list *_outp=&_out;
16195 octave_value _outv;
16206 return octave_value_list();
16214 octave_value_list _out;
16215 octave_value_list *_outp=&_out;
16216 octave_value _outv;
16227 _outv = octave_value();
16231 return octave_value_list();
16261 octave_value_list _out;
16262 octave_value_list *_outp=&_out;
16263 octave_value _outv;
16272 arg1 =
static_cast< PLINT
>(val1);
16277 arg2 =
static_cast< PLINT
>(val2);
16279 _outv = octave_value();
16283 return octave_value_list();
16300 octave_value_list _out;
16301 octave_value_list *_outp=&_out;
16302 octave_value _outv;
16311 arg1 =
static_cast< PLFLT
>(val1);
16316 arg2 =
static_cast< PLFLT
>(val2);
16321 arg3 =
static_cast< PLFLT
>(val3);
16326 arg4 =
static_cast< PLINT
>(val4);
16328 _outv = octave_value();
16332 return octave_value_list();
16340 octave_value_list _out;
16341 octave_value_list *_outp=&_out;
16342 octave_value _outv;
16351 arg1 =
static_cast< PLINT
>(val1);
16353 _outv = octave_value();
16357 return octave_value_list();
16386 octave_value_list _out;
16387 octave_value_list *_outp=&_out;
16388 octave_value _outv;
16397 arg1 =
static_cast< PLFLT
>(val1);
16402 arg2 =
static_cast< PLFLT
>(val2);
16407 arg3 =
static_cast< PLFLT
>(val3);
16412 arg4 =
static_cast< PLFLT
>(val4);
16417 arg5 =
static_cast< PLFLT
>(val5);
16422 arg6 =
static_cast< PLFLT
>(val6);
16427 arg7 =
static_cast< PLFLT
>(val7);
16432 arg8 =
static_cast< PLBOOL >(val8);
16433 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
16434 _outv = octave_value();
16438 return octave_value_list();
16445 char *arg3 = (
char *) 0 ;
16448 char *arg6 = (
char *) 0 ;
16469 octave_value_list _out;
16470 octave_value_list *_outp=&_out;
16471 octave_value _outv;
16480 arg1 =
static_cast< PLFLT
>(val1);
16485 arg2 =
static_cast< PLFLT
>(val2);
16490 arg3 =
reinterpret_cast< char *
>(buf3);
16495 arg4 =
static_cast< PLFLT
>(val4);
16500 arg5 =
static_cast< PLINT
>(val5);
16505 arg6 =
reinterpret_cast< char *
>(buf6);
16510 arg7 =
static_cast< PLFLT
>(val7);
16515 arg8 =
static_cast< PLINT
>(val8);
16516 plaxes(arg1,arg2,(
char const *)arg3,arg4,arg5,(
char const *)arg6,arg7,arg8);
16517 _outv = octave_value();
16525 return octave_value_list();
16531 PLFLT *arg2 = (PLFLT *) 0 ;
16532 PLFLT *arg3 = (PLFLT *) 0 ;
16538 octave_value_list _out;
16539 octave_value_list *_outp=&_out;
16540 octave_value _outv;
16546 if (
_n_dims( args(0) ) > 1 )
16550 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
16551 temp1 = args(0).matrix_value();
16552 arg2 = &temp1( 0, 0 );
16555 if (
_n_dims( args(1) ) > 1 )
16559 if (
_dim( args(1), 0 ) != Alen )
16563 temp3 = args(1).matrix_value();
16564 arg3 = &temp3( 0, 0 );
16570 arg4 =
static_cast< PLINT
>(val4);
16571 plbin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
16572 _outv = octave_value();
16588 return octave_value_list();
16593 PLINT *arg1 = (PLINT *) 0 ;
16594 PLINT *arg2 = (PLINT *) 0 ;
16595 PLINT *arg3 = (PLINT *) 0 ;
16596 PLINT *arg4 = (PLINT *) 0 ;
16597 PLINT *arg5 = (PLINT *) 0 ;
16598 PLFLT *arg6 = (PLFLT *) 0 ;
16614 octave_value_list _out;
16615 octave_value_list *_outp=&_out;
16616 octave_value _outv;
16631 arg7 =
static_cast< PLFLT
>(val7);
16632 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
16633 _outv = octave_value();
16673 return octave_value_list();
16678 octave_value_list _out;
16679 octave_value_list *_outp=&_out;
16680 octave_value _outv;
16686 _outv = octave_value();
16690 return octave_value_list();
16695 char *arg1 = (
char *) 0 ;
16698 char *arg4 = (
char *) 0 ;
16715 octave_value_list _out;
16716 octave_value_list *_outp=&_out;
16717 octave_value _outv;
16726 arg1 =
reinterpret_cast< char *
>(buf1);
16731 arg2 =
static_cast< PLFLT
>(val2);
16736 arg3 =
static_cast< PLINT
>(val3);
16741 arg4 =
reinterpret_cast< char *
>(buf4);
16746 arg5 =
static_cast< PLFLT
>(val5);
16751 arg6 =
static_cast< PLINT
>(val6);
16752 plbox((
char const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6);
16753 _outv = octave_value();
16761 return octave_value_list();
16766 char *arg1 = (
char *) 0 ;
16767 char *arg2 = (
char *) 0 ;
16770 char *arg5 = (
char *) 0 ;
16771 char *arg6 = (
char *) 0 ;
16774 char *arg9 = (
char *) 0 ;
16775 char *arg10 = (
char *) 0 ;
16808 octave_value_list _out;
16809 octave_value_list *_outp=&_out;
16810 octave_value _outv;
16819 arg1 =
reinterpret_cast< char *
>(buf1);
16824 arg2 =
reinterpret_cast< char *
>(buf2);
16829 arg3 =
static_cast< PLFLT
>(val3);
16834 arg4 =
static_cast< PLINT
>(val4);
16839 arg5 =
reinterpret_cast< char *
>(buf5);
16844 arg6 =
reinterpret_cast< char *
>(buf6);
16849 arg7 =
static_cast< PLFLT
>(val7);
16854 arg8 =
static_cast< PLINT
>(val8);
16859 arg9 =
reinterpret_cast< char *
>(buf9);
16864 arg10 =
reinterpret_cast< char *
>(buf10);
16869 arg11 =
static_cast< PLFLT
>(val11);
16874 arg12 =
static_cast< PLINT
>(val12);
16875 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);
16876 _outv = octave_value();
16892 return octave_value_list();
16899 PLFLT *arg3 = (PLFLT *) 0 ;
16900 PLFLT *arg4 = (PLFLT *) 0 ;
16901 PLINT *arg5 = (PLINT *) 0 ;
16912 octave_value_list _out;
16913 octave_value_list *_outp=&_out;
16914 octave_value _outv;
16926 arg1 =
static_cast< PLFLT
>(val1);
16931 arg2 =
static_cast< PLFLT
>(val2);
16933 _outv = octave_value();
16955 return octave_value_list();
16960 octave_value_list _out;
16961 octave_value_list *_outp=&_out;
16962 octave_value _outv;
16968 _outv = octave_value();
16972 return octave_value_list();
16980 octave_value_list _out;
16981 octave_value_list *_outp=&_out;
16982 octave_value _outv;
16991 arg1 =
static_cast< PLINT
>(val1);
16993 _outv = octave_value();
16997 return octave_value_list();
17005 octave_value_list _out;
17006 octave_value_list *_outp=&_out;
17007 octave_value _outv;
17016 arg1 =
static_cast< PLFLT
>(val1);
17018 _outv = octave_value();
17022 return octave_value_list();
17060 octave_value_list _out;
17061 octave_value_list *_outp=&_out;
17062 octave_value _outv;
17071 arg1 =
static_cast< PLFLT
>(val1);
17076 arg2 =
static_cast< PLFLT
>(val2);
17081 arg3 =
static_cast< PLFLT
>(val3);
17086 arg4 =
static_cast< PLINT
>(val4);
17091 arg5 =
static_cast< PLBOOL >(val5);
17096 arg6 =
static_cast< PLINT
>(val6);
17101 arg7 =
static_cast< PLINT
>(val7);
17106 arg8 =
static_cast< PLINT
>(val8);
17111 arg9 =
static_cast< PLINT
>(val9);
17116 arg10 =
static_cast< PLINT
>(val10);
17121 arg11 =
static_cast< PLFLT
>(val11);
17122 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
17123 _outv = octave_value();
17127 return octave_value_list();
17138 PLFLT *arg7 = (PLFLT *) 0 ;
17153 octave_value_list _out;
17154 octave_value_list *_outp=&_out;
17155 octave_value _outv;
17165 arg1 =
static_cast< PLINT
>(val1);
17170 arg2 =
static_cast< PLINT
>(val2);
17175 arg3 =
static_cast< PLINT
>(val3);
17180 arg4 =
static_cast< PLINT
>(val4);
17185 arg5 =
static_cast< PLINT
>(val5);
17190 arg6 =
static_cast< PLFLT
>(val6);
17191 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17192 _outv = octave_value();
17202 return octave_value_list();
17213 octave_value_list _out;
17214 octave_value_list *_outp=&_out;
17215 octave_value _outv;
17224 arg1 =
static_cast< PLINT
>(val1);
17229 arg2 =
static_cast< PLBOOL >(val2);
17231 _outv = octave_value();
17235 return octave_value_list();
17240 octave_value_list _out;
17241 octave_value_list *_outp=&_out;
17242 octave_value _outv;
17248 _outv = octave_value();
17252 return octave_value_list();
17257 octave_value_list _out;
17258 octave_value_list *_outp=&_out;
17259 octave_value _outv;
17265 _outv = octave_value();
17269 return octave_value_list();
17292 octave_value_list _out;
17293 octave_value_list *_outp=&_out;
17294 octave_value _outv;
17303 arg1 =
static_cast< PLFLT
>(val1);
17308 arg2 =
static_cast< PLFLT
>(val2);
17313 arg3 =
static_cast< PLFLT
>(val3);
17318 arg4 =
static_cast< PLFLT
>(val4);
17323 arg5 =
static_cast< PLINT
>(val5);
17328 arg6 =
static_cast< PLINT
>(val6);
17329 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
17330 _outv = octave_value();
17334 return octave_value_list();
17357 octave_value_list _out;
17358 octave_value_list *_outp=&_out;
17359 octave_value _outv;
17368 arg1 =
static_cast< PLFLT
>(val1);
17373 arg2 =
static_cast< PLFLT
>(val2);
17378 arg3 =
static_cast< PLFLT
>(val3);
17383 arg4 =
static_cast< PLFLT
>(val4);
17388 arg5 =
static_cast< PLINT
>(val5);
17393 arg6 =
static_cast< PLINT
>(val6);
17394 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
17395 _outv = octave_value();
17399 return octave_value_list();
17404 octave_value_list _out;
17405 octave_value_list *_outp=&_out;
17406 octave_value _outv;
17412 _outv = octave_value();
17416 return octave_value_list();
17422 PLFLT *arg2 = (PLFLT *) 0 ;
17423 PLFLT *arg3 = (PLFLT *) 0 ;
17424 PLFLT *arg4 = (PLFLT *) 0 ;
17428 octave_value_list _out;
17429 octave_value_list *_outp=&_out;
17430 octave_value _outv;
17436 if (
_n_dims( args(0) ) > 1 )
17440 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
17441 temp1 = args(0).matrix_value();
17442 arg2 = &temp1( 0, 0 );
17445 if (
_n_dims( args(1) ) > 1 )
17449 if (
_dim( args(1), 0 ) != Alen )
17453 temp3 = args(1).matrix_value();
17454 arg3 = &temp3( 0, 0 );
17457 if (
_n_dims( args(2) ) > 1 )
17461 if (
_dim( args(2), 0 ) != Alen )
17465 temp4 = args(2).matrix_value();
17466 arg4 = &temp4( 0, 0 );
17468 plerrx(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
17469 _outv = octave_value();
17491 return octave_value_list();
17497 PLFLT *arg2 = (PLFLT *) 0 ;
17498 PLFLT *arg3 = (PLFLT *) 0 ;
17499 PLFLT *arg4 = (PLFLT *) 0 ;
17503 octave_value_list _out;
17504 octave_value_list *_outp=&_out;
17505 octave_value _outv;
17511 if (
_n_dims( args(0) ) > 1 )
17515 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
17516 temp1 = args(0).matrix_value();
17517 arg2 = &temp1( 0, 0 );
17520 if (
_n_dims( args(1) ) > 1 )
17524 if (
_dim( args(1), 0 ) != Alen )
17528 temp3 = args(1).matrix_value();
17529 arg3 = &temp3( 0, 0 );
17532 if (
_n_dims( args(2) ) > 1 )
17536 if (
_dim( args(2), 0 ) != Alen )
17540 temp4 = args(2).matrix_value();
17541 arg4 = &temp4( 0, 0 );
17543 plerry(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
17544 _outv = octave_value();
17566 return octave_value_list();
17571 octave_value_list _out;
17572 octave_value_list *_outp=&_out;
17573 octave_value _outv;
17579 _outv = octave_value();
17583 return octave_value_list();
17589 PLFLT *arg2 = (PLFLT *) 0 ;
17590 PLFLT *arg3 = (PLFLT *) 0 ;
17593 octave_value_list _out;
17594 octave_value_list *_outp=&_out;
17595 octave_value _outv;
17601 if (
_n_dims( args(0) ) > 1 )
17605 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
17606 temp1 = args(0).matrix_value();
17607 arg2 = &temp1( 0, 0 );
17610 if (
_n_dims( args(1) ) > 1 )
17614 if (
_dim( args(1), 0 ) != Alen )
17618 temp3 = args(1).matrix_value();
17619 arg3 = &temp3( 0, 0 );
17621 plfill(arg1,(
double const *)arg2,(
double const *)arg3);
17622 _outv = octave_value();
17638 return octave_value_list();
17644 PLFLT *arg2 = (PLFLT *) 0 ;
17645 PLFLT *arg3 = (PLFLT *) 0 ;
17646 PLFLT *arg4 = (PLFLT *) 0 ;
17650 octave_value_list _out;
17651 octave_value_list *_outp=&_out;
17652 octave_value _outv;
17658 if (
_n_dims( args(0) ) > 1 )
17662 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
17663 temp1 = args(0).matrix_value();
17664 arg2 = &temp1( 0, 0 );
17667 if (
_n_dims( args(1) ) > 1 )
17671 if (
_dim( args(1), 0 ) != Alen )
17675 temp3 = args(1).matrix_value();
17676 arg3 = &temp3( 0, 0 );
17679 if (
_n_dims( args(2) ) > 1 )
17683 if (
_dim( args(2), 0 ) != Alen )
17687 temp4 = args(2).matrix_value();
17688 arg4 = &temp4( 0, 0 );
17690 plfill3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
17691 _outv = octave_value();
17713 return octave_value_list();
17719 PLFLT *arg2 = (PLFLT *) 0 ;
17720 PLFLT *arg3 = (PLFLT *) 0 ;
17726 octave_value_list _out;
17727 octave_value_list *_outp=&_out;
17728 octave_value _outv;
17734 if (
_n_dims( args(0) ) > 1 )
17738 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
17739 temp1 = args(0).matrix_value();
17740 arg2 = &temp1( 0, 0 );
17743 if (
_n_dims( args(1) ) > 1 )
17747 if (
_dim( args(1), 0 ) != Alen )
17751 temp3 = args(1).matrix_value();
17752 arg3 = &temp3( 0, 0 );
17758 arg4 =
static_cast< PLFLT
>(val4);
17759 plgradient(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
17760 _outv = octave_value();
17776 return octave_value_list();
17781 octave_value_list _out;
17782 octave_value_list *_outp=&_out;
17783 octave_value _outv;
17789 _outv = octave_value();
17793 return octave_value_list();
17801 octave_value_list _out;
17802 octave_value_list *_outp=&_out;
17803 octave_value _outv;
17812 arg1 =
static_cast< PLINT
>(val1);
17814 _outv = octave_value();
17818 return octave_value_list();
17826 octave_value_list _out;
17827 octave_value_list *_outp=&_out;
17828 octave_value _outv;
17837 arg1 =
static_cast< PLINT
>(val1);
17839 _outv = octave_value();
17843 return octave_value_list();
17848 PLFLT *arg1 = (PLFLT *) 0 ;
17849 PLFLT *arg2 = (PLFLT *) 0 ;
17854 octave_value_list _out;
17855 octave_value_list *_outp=&_out;
17856 octave_value _outv;
17864 _outv = octave_value();
17880 return octave_value_list();
17886 PLINT *arg2 = (PLINT *) 0 ;
17887 PLINT *arg3 = (PLINT *) 0 ;
17888 PLINT *arg4 = (PLINT *) 0 ;
17897 octave_value_list _out;
17898 octave_value_list *_outp=&_out;
17899 octave_value _outv;
17911 arg1 =
static_cast< PLINT
>(val1);
17912 plgcol0(arg1,arg2,arg3,arg4);
17913 _outv = octave_value();
17935 return octave_value_list();
17941 PLINT *arg2 = (PLINT *) 0 ;
17942 PLINT *arg3 = (PLINT *) 0 ;
17943 PLINT *arg4 = (PLINT *) 0 ;
17944 PLFLT *arg5 = (PLFLT *) 0 ;
17955 octave_value_list _out;
17956 octave_value_list *_outp=&_out;
17957 octave_value _outv;
17970 arg1 =
static_cast< PLINT
>(val1);
17971 plgcol0a(arg1,arg2,arg3,arg4,arg5);
17972 _outv = octave_value();
18000 return octave_value_list();
18005 PLINT *arg1 = (PLINT *) 0 ;
18006 PLINT *arg2 = (PLINT *) 0 ;
18007 PLINT *arg3 = (PLINT *) 0 ;
18014 octave_value_list _out;
18015 octave_value_list *_outp=&_out;
18016 octave_value _outv;
18025 _outv = octave_value();
18047 return octave_value_list();
18052 PLINT *arg1 = (PLINT *) 0 ;
18053 PLINT *arg2 = (PLINT *) 0 ;
18054 PLINT *arg3 = (PLINT *) 0 ;
18055 PLFLT *arg4 = (PLFLT *) 0 ;
18064 octave_value_list _out;
18065 octave_value_list *_outp=&_out;
18066 octave_value _outv;
18076 _outv = octave_value();
18104 return octave_value_list();
18109 PLINT *arg1 = (PLINT *) 0 ;
18112 octave_value_list _out;
18113 octave_value_list *_outp=&_out;
18114 octave_value _outv;
18121 _outv = octave_value();
18131 return octave_value_list();
18136 char *arg1 = (
char *) 0 ;
18137 char local_string1[80] ;
18138 size_t local_string_length1 ;
18139 charMatrix local_charMatrix1 ;
18140 octave_value_list retval1 ;
18141 octave_value_list _out;
18142 octave_value_list *_outp=&_out;
18143 octave_value _outv;
18146 arg1 = local_string1;
18152 _outv = octave_value();
18155 local_string_length1 = strlen( local_string1 );
18156 local_charMatrix1 = charMatrix( 1, local_string_length1 );
18157 local_charMatrix1.insert( local_string1, 0, 0 );
18158 retval1( 0 ) = octave_value( local_charMatrix1 );
18163 return octave_value_list();
18168 PLFLT *arg1 = (PLFLT *) 0 ;
18169 PLFLT *arg2 = (PLFLT *) 0 ;
18170 PLFLT *arg3 = (PLFLT *) 0 ;
18171 PLFLT *arg4 = (PLFLT *) 0 ;
18180 octave_value_list _out;
18181 octave_value_list *_outp=&_out;
18182 octave_value _outv;
18192 _outv = octave_value();
18220 return octave_value_list();
18225 PLFLT *arg1 = (PLFLT *) 0 ;
18228 octave_value_list _out;
18229 octave_value_list *_outp=&_out;
18230 octave_value _outv;
18237 _outv = octave_value();
18247 return octave_value_list();
18252 PLFLT *arg1 = (PLFLT *) 0 ;
18253 PLFLT *arg2 = (PLFLT *) 0 ;
18254 PLFLT *arg3 = (PLFLT *) 0 ;
18255 PLFLT *arg4 = (PLFLT *) 0 ;
18264 octave_value_list _out;
18265 octave_value_list *_outp=&_out;
18266 octave_value _outv;
18276 _outv = octave_value();
18304 return octave_value_list();
18309 PLINT *arg1 = (PLINT *) 0 ;
18310 PLINT *arg2 = (PLINT *) 0 ;
18311 PLINT *arg3 = (PLINT *) 0 ;
18318 octave_value_list _out;
18319 octave_value_list *_outp=&_out;
18320 octave_value _outv;
18329 _outv = octave_value();
18351 return octave_value_list();
18359 octave_value_list _out;
18360 octave_value_list *_outp=&_out;
18361 octave_value _outv;
18368 _outv = octave_value();
18378 return octave_value_list();
18383 char *arg1 = (
char *) 0 ;
18384 char local_string1[80] ;
18385 size_t local_string_length1 ;
18386 charMatrix local_charMatrix1 ;
18387 octave_value_list retval1 ;
18388 octave_value_list _out;
18389 octave_value_list *_outp=&_out;
18390 octave_value _outv;
18393 arg1 = local_string1;
18399 _outv = octave_value();
18402 local_string_length1 = strlen( local_string1 );
18403 local_charMatrix1 = charMatrix( 1, local_string_length1 );
18404 local_charMatrix1.insert( local_string1, 0, 0 );
18405 retval1( 0 ) = octave_value( local_charMatrix1 );
18410 return octave_value_list();
18415 PLINT *arg1 = (PLINT *) 0 ;
18416 PLINT *arg2 = (PLINT *) 0 ;
18417 PLINT *arg3 = (PLINT *) 0 ;
18424 octave_value_list _out;
18425 octave_value_list *_outp=&_out;
18426 octave_value _outv;
18435 _outv = octave_value();
18457 return octave_value_list();
18462 PLINT *arg1 = (PLINT *) 0 ;
18465 octave_value_list _out;
18466 octave_value_list *_outp=&_out;
18467 octave_value _outv;
18474 _outv = octave_value();
18484 return octave_value_list();
18489 PLFLT *arg1 = (PLFLT *) 0 ;
18490 PLFLT *arg2 = (PLFLT *) 0 ;
18491 PLINT *arg3 = (PLINT *) 0 ;
18492 PLINT *arg4 = (PLINT *) 0 ;
18493 PLINT *arg5 = (PLINT *) 0 ;
18494 PLINT *arg6 = (PLINT *) 0 ;
18507 octave_value_list _out;
18508 octave_value_list *_outp=&_out;
18509 octave_value _outv;
18520 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
18521 _outv = octave_value();
18561 return octave_value_list();
18566 octave_value_list _out;
18567 octave_value_list *_outp=&_out;
18568 octave_value _outv;
18574 _outv = octave_value();
18578 return octave_value_list();
18583 PLFLT *arg1 = (PLFLT *) 0 ;
18584 PLFLT *arg2 = (PLFLT *) 0 ;
18585 PLFLT *arg3 = (PLFLT *) 0 ;
18586 PLFLT *arg4 = (PLFLT *) 0 ;
18595 octave_value_list _out;
18596 octave_value_list *_outp=&_out;
18597 octave_value _outv;
18606 plgspa(arg1,arg2,arg3,arg4);
18607 _outv = octave_value();
18635 return octave_value_list();
18640 PLINT *arg1 = (PLINT *) 0 ;
18643 octave_value_list _out;
18644 octave_value_list *_outp=&_out;
18645 octave_value _outv;
18652 _outv = octave_value();
18662 return octave_value_list();
18667 char *arg1 = (
char *) 0 ;
18668 char local_string1[80] ;
18669 size_t local_string_length1 ;
18670 charMatrix local_charMatrix1 ;
18671 octave_value_list retval1 ;
18672 octave_value_list _out;
18673 octave_value_list *_outp=&_out;
18674 octave_value _outv;
18677 arg1 = local_string1;
18683 _outv = octave_value();
18686 local_string_length1 = strlen( local_string1 );
18687 local_charMatrix1 = charMatrix( 1, local_string_length1 );
18688 local_charMatrix1.insert( local_string1, 0, 0 );
18689 retval1( 0 ) = octave_value( local_charMatrix1 );
18694 return octave_value_list();
18699 PLFLT *arg1 = (PLFLT *) 0 ;
18700 PLFLT *arg2 = (PLFLT *) 0 ;
18701 PLFLT *arg3 = (PLFLT *) 0 ;
18702 PLFLT *arg4 = (PLFLT *) 0 ;
18711 octave_value_list _out;
18712 octave_value_list *_outp=&_out;
18713 octave_value _outv;
18722 plgvpd(arg1,arg2,arg3,arg4);
18723 _outv = octave_value();
18751 return octave_value_list();
18756 PLFLT *arg1 = (PLFLT *) 0 ;
18757 PLFLT *arg2 = (PLFLT *) 0 ;
18758 PLFLT *arg3 = (PLFLT *) 0 ;
18759 PLFLT *arg4 = (PLFLT *) 0 ;
18768 octave_value_list _out;
18769 octave_value_list *_outp=&_out;
18770 octave_value _outv;
18779 plgvpw(arg1,arg2,arg3,arg4);
18780 _outv = octave_value();
18808 return octave_value_list();
18813 PLINT *arg1 = (PLINT *) 0 ;
18814 PLINT *arg2 = (PLINT *) 0 ;
18819 octave_value_list _out;
18820 octave_value_list *_outp=&_out;
18821 octave_value _outv;
18829 _outv = octave_value();
18845 return octave_value_list();
18850 PLINT *arg1 = (PLINT *) 0 ;
18851 PLINT *arg2 = (PLINT *) 0 ;
18856 octave_value_list _out;
18857 octave_value_list *_outp=&_out;
18858 octave_value _outv;
18866 _outv = octave_value();
18882 return octave_value_list();
18887 PLINT *arg1 = (PLINT *) 0 ;
18888 PLINT *arg2 = (PLINT *) 0 ;
18893 octave_value_list _out;
18894 octave_value_list *_outp=&_out;
18895 octave_value _outv;
18903 _outv = octave_value();
18919 return octave_value_list();
18925 PLFLT *arg2 = (PLFLT *) 0 ;
18939 octave_value_list _out;
18940 octave_value_list *_outp=&_out;
18941 octave_value _outv;
18947 if (
_n_dims( args(0) ) > 1 )
18951 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
18952 temp1 = args(0).matrix_value();
18953 arg2 = &temp1( 0, 0 );
18959 arg3 =
static_cast< PLFLT
>(val3);
18964 arg4 =
static_cast< PLFLT
>(val4);
18969 arg5 =
static_cast< PLINT
>(val5);
18974 arg6 =
static_cast< PLINT
>(val6);
18975 plhist(arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
18976 _outv = octave_value();
18986 return octave_value_list();
18994 PLFLT *arg4 = (PLFLT *) 0 ;
18995 PLFLT *arg5 = (PLFLT *) 0 ;
18996 PLFLT *arg6 = (PLFLT *) 0 ;
19009 octave_value_list _out;
19010 octave_value_list *_outp=&_out;
19011 octave_value _outv;
19023 arg1 =
static_cast< PLFLT
>(val1);
19028 arg2 =
static_cast< PLFLT
>(val2);
19033 arg3 =
static_cast< PLFLT
>(val3);
19034 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
19035 _outv = octave_value();
19057 return octave_value_list();
19062 octave_value_list _out;
19063 octave_value_list *_outp=&_out;
19064 octave_value _outv;
19070 _outv = octave_value();
19074 return octave_value_list();
19091 octave_value_list _out;
19092 octave_value_list *_outp=&_out;
19093 octave_value _outv;
19102 arg1 =
static_cast< PLFLT
>(val1);
19107 arg2 =
static_cast< PLFLT
>(val2);
19112 arg3 =
static_cast< PLFLT
>(val3);
19117 arg4 =
static_cast< PLFLT
>(val4);
19118 pljoin(arg1,arg2,arg3,arg4);
19119 _outv = octave_value();
19123 return octave_value_list();
19128 char *arg1 = (
char *) 0 ;
19129 char *arg2 = (
char *) 0 ;
19130 char *arg3 = (
char *) 0 ;
19140 octave_value_list _out;
19141 octave_value_list *_outp=&_out;
19142 octave_value _outv;
19151 arg1 =
reinterpret_cast< char *
>(buf1);
19156 arg2 =
reinterpret_cast< char *
>(buf2);
19161 arg3 =
reinterpret_cast< char *
>(buf3);
19162 pllab((
char const *)arg1,(
char const *)arg2,(
char const *)arg3);
19163 _outv = octave_value();
19173 return octave_value_list();
19178 PLFLT *arg1 = (PLFLT *) 0 ;
19179 PLFLT *arg2 = (PLFLT *) 0 ;
19191 PLINT *arg14 = (PLINT *) 0 ;
19196 PLINT *arg19 = (PLINT *) 0 ;
19197 char **arg20 = (
char **) 0 ;
19198 PLINT *arg21 = (PLINT *) 0 ;
19199 PLINT *arg22 = (PLINT *) 0 ;
19200 PLFLT *arg23 = (PLFLT *) 0 ;
19201 PLFLT *arg24 = (PLFLT *) 0 ;
19202 PLINT *arg25 = (PLINT *) 0 ;
19203 PLINT *arg26 = (PLINT *) 0 ;
19204 PLFLT *arg27 = (PLFLT *) 0 ;
19205 PLINT *arg28 = (PLINT *) 0 ;
19206 PLFLT *arg29 = (PLFLT *) 0 ;
19207 PLINT *arg30 = (PLINT *) 0 ;
19208 char **arg31 = (
char **) 0 ;
19253 octave_value_list _out;
19254 octave_value_list *_outp=&_out;
19255 octave_value _outv;
19266 arg3 =
static_cast< PLINT
>(val3);
19271 arg4 =
static_cast< PLINT
>(val4);
19276 arg5 =
static_cast< PLFLT
>(val5);
19281 arg6 =
static_cast< PLFLT
>(val6);
19286 arg7 =
static_cast< PLFLT
>(val7);
19291 arg8 =
static_cast< PLINT
>(val8);
19296 arg9 =
static_cast< PLINT
>(val9);
19301 arg10 =
static_cast< PLINT
>(val10);
19306 arg11 =
static_cast< PLINT
>(val11);
19311 arg12 =
static_cast< PLINT
>(val12);
19313 if (
_n_dims( args(10) ) > 1 )
19317 arg13 = Alen = (
PLINT) (
_dim( args(10), 0 ) );
19318 arg14 =
new PLINT[
Alen];
19319 temp13 = args(10).matrix_value();
19326 arg15 =
static_cast< PLFLT
>(val15);
19331 arg16 =
static_cast< PLFLT
>(val16);
19336 arg17 =
static_cast< PLFLT
>(val17);
19341 arg18 =
static_cast< PLFLT
>(val18);
19343 if (
_n_dims( args(15) ) > 1 )
19347 if (
_dim( args(15), 0 ) != Alen )
19351 temp19 = args(15).matrix_value();
19352 arg19 =
new PLINT[
Alen];
19356 charMatrix temp_matrix;
19360 size_t max_length = 0, non_blank_length;
19362 if (
_n_dims( args(16) ) > 2 )
19364 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
19366 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 19367 if ( !args(16).isempty() )
19369 if ( !args(16).is_empty() )
19372 if (
_dim( args(16), 0 ) != Alen )
19374 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
19376 arg20 =
new char*[
Alen];
19377 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 19378 ifcell = args(16).iscell();
19380 ifcell = args(16).is_cell();
19384 temp_cell = args(16).cell_value();
19388 temp_matrix = args(16).char_matrix_value();
19390 max_length =
_dim( args(16), 1 ) + 1;
19393 for ( i = 0; i <
Alen; i++ )
19400 if ( temp_cell.elem( i ).is_string() )
19402 str = temp_cell.elem( i ).string_value();
19404 max_length = str.size() + 1;
19405 tmp_cstring = (
char *) str.c_str();
19415 tmp_cstring = (
char *)
"";
19420 str = temp_matrix.row_as_string( i );
19421 tmp_cstring = (
char *) str.c_str();
19423 arg20[i] =
new char[max_length];
19424 strncpy( arg20[i], tmp_cstring, max_length - 1 );
19425 arg20[i][max_length - 1] =
'\0';
19440 non_blank_length = max_length - 2;
19441 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
19443 non_blank_length--;
19445 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
19447 non_blank_length--;
19449 arg20[i][non_blank_length + 1] =
'\0';
19459 if (
_n_dims( args(17) ) > 1 )
19463 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 19464 if ( !args(17).isempty() )
19466 if ( !args(17).is_empty() )
19469 if (
_dim( args(17), 0 ) != Alen )
19473 temp21 = args(17).matrix_value();
19474 arg21 =
new PLINT[
Alen];
19483 if (
_n_dims( args(18) ) > 1 )
19487 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 19488 if ( !args(18).isempty() )
19490 if ( !args(18).is_empty() )
19493 if (
_dim( args(18), 0 ) != Alen )
19497 temp22 = args(18).matrix_value();
19498 arg22 =
new PLINT[
Alen];
19507 if (
_n_dims( args(19) ) > 1 )
19511 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 19512 if ( !args(19).isempty() )
19514 if ( !args(19).is_empty() )
19517 if (
_dim( args(19), 0 ) != Alen )
19521 temp23 = args(19).matrix_value();
19522 arg23 = &temp23( 0, 0 );
19530 if (
_n_dims( args(20) ) > 1 )
19534 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 19535 if ( !args(20).isempty() )
19537 if ( !args(20).is_empty() )
19540 if (
_dim( args(20), 0 ) != Alen )
19544 temp24 = args(20).matrix_value();
19545 arg24 = &temp24( 0, 0 );
19553 if (
_n_dims( args(21) ) > 1 )
19557 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 19558 if ( !args(21).isempty() )
19560 if ( !args(21).is_empty() )
19563 if (
_dim( args(21), 0 ) != Alen )
19567 temp25 = args(21).matrix_value();
19568 arg25 =
new PLINT[
Alen];
19577 if (
_n_dims( args(22) ) > 1 )
19581 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 19582 if ( !args(22).isempty() )
19584 if ( !args(22).is_empty() )
19587 if (
_dim( args(22), 0 ) != Alen )
19591 temp26 = args(22).matrix_value();
19592 arg26 =
new PLINT[
Alen];
19601 if (
_n_dims( args(23) ) > 1 )
19605 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 19606 if ( !args(23).isempty() )
19608 if ( !args(23).is_empty() )
19611 if (
_dim( args(23), 0 ) != Alen )
19615 temp27 = args(23).matrix_value();
19616 arg27 = &temp27( 0, 0 );
19624 if (
_n_dims( args(24) ) > 1 )
19628 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 19629 if ( !args(24).isempty() )
19631 if ( !args(24).is_empty() )
19634 if (
_dim( args(24), 0 ) != Alen )
19638 temp28 = args(24).matrix_value();
19639 arg28 =
new PLINT[
Alen];
19648 if (
_n_dims( args(25) ) > 1 )
19652 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 19653 if ( !args(25).isempty() )
19655 if ( !args(25).is_empty() )
19658 if (
_dim( args(25), 0 ) != Alen )
19662 temp29 = args(25).matrix_value();
19663 arg29 = &temp29( 0, 0 );
19671 if (
_n_dims( args(26) ) > 1 )
19675 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 19676 if ( !args(26).isempty() )
19678 if ( !args(26).is_empty() )
19681 if (
_dim( args(26), 0 ) != Alen )
19685 temp30 = args(26).matrix_value();
19686 arg30 =
new PLINT[
Alen];
19695 charMatrix temp_matrix;
19699 size_t max_length = 0, non_blank_length;
19701 if (
_n_dims( args(27) ) > 2 )
19703 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
19705 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 19706 if ( !args(27).isempty() )
19708 if ( !args(27).is_empty() )
19711 if (
_dim( args(27), 0 ) != Alen )
19713 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
19715 arg31 =
new char*[
Alen];
19716 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 19717 ifcell = args(27).iscell();
19719 ifcell = args(27).is_cell();
19723 temp_cell = args(27).cell_value();
19727 temp_matrix = args(27).char_matrix_value();
19729 max_length =
_dim( args(27), 1 ) + 1;
19732 for ( i = 0; i <
Alen; i++ )
19739 if ( temp_cell.elem( i ).is_string() )
19741 str = temp_cell.elem( i ).string_value();
19743 max_length = str.size() + 1;
19744 tmp_cstring = (
char *) str.c_str();
19754 tmp_cstring = (
char *)
"";
19759 str = temp_matrix.row_as_string( i );
19760 tmp_cstring = (
char *) str.c_str();
19762 arg31[i] =
new char[max_length];
19763 strncpy( arg31[i], tmp_cstring, max_length - 1 );
19764 arg31[i][max_length - 1] =
'\0';
19779 non_blank_length = max_length - 2;
19780 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
'\0' )
19782 non_blank_length--;
19784 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
' ' )
19786 non_blank_length--;
19788 arg31[i][non_blank_length + 1] =
'\0';
19797 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);
19798 _outv = octave_value();
19820 if ( arg20 != NULL )
19822 for ( i = 0; i <
Alen; i++ )
19830 if ( arg21 != NULL )
19834 if ( arg22 != NULL )
19844 if ( arg25 != NULL )
19848 if ( arg26 != NULL )
19855 if ( arg28 != NULL )
19862 if ( arg30 != NULL )
19867 if ( arg31 != NULL )
19869 for ( i = 0; i <
Alen; i++ )
19886 if ( arg20 != NULL )
19888 for ( i = 0; i <
Alen; i++ )
19896 if ( arg21 != NULL )
19900 if ( arg22 != NULL )
19910 if ( arg25 != NULL )
19914 if ( arg26 != NULL )
19921 if ( arg28 != NULL )
19928 if ( arg30 != NULL )
19933 if ( arg31 != NULL )
19935 for ( i = 0; i <
Alen; i++ )
19942 return octave_value_list();
19956 octave_value_list _out;
19957 octave_value_list *_outp=&_out;
19958 octave_value _outv;
19967 arg1 =
static_cast< PLFLT
>(val1);
19972 arg2 =
static_cast< PLFLT
>(val2);
19977 arg3 =
static_cast< PLFLT
>(val3);
19979 _outv = octave_value();
19983 return octave_value_list();
19989 PLFLT *arg2 = (PLFLT *) 0 ;
19990 PLFLT *arg3 = (PLFLT *) 0 ;
19993 octave_value_list _out;
19994 octave_value_list *_outp=&_out;
19995 octave_value _outv;
20001 if (
_n_dims( args(0) ) > 1 )
20005 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
20006 temp1 = args(0).matrix_value();
20007 arg2 = &temp1( 0, 0 );
20010 if (
_n_dims( args(1) ) > 1 )
20014 if (
_dim( args(1), 0 ) != Alen )
20018 temp3 = args(1).matrix_value();
20019 arg3 = &temp3( 0, 0 );
20021 plline(arg1,(
double const *)arg2,(
double const *)arg3);
20022 _outv = octave_value();
20038 return octave_value_list();
20044 PLFLT *arg2 = (PLFLT *) 0 ;
20045 PLFLT *arg3 = (PLFLT *) 0 ;
20046 PLFLT *arg4 = (PLFLT *) 0 ;
20050 octave_value_list _out;
20051 octave_value_list *_outp=&_out;
20052 octave_value _outv;
20058 if (
_n_dims( args(0) ) > 1 )
20062 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
20063 temp1 = args(0).matrix_value();
20064 arg2 = &temp1( 0, 0 );
20067 if (
_n_dims( args(1) ) > 1 )
20071 if (
_dim( args(1), 0 ) != Alen )
20075 temp3 = args(1).matrix_value();
20076 arg3 = &temp3( 0, 0 );
20079 if (
_n_dims( args(2) ) > 1 )
20083 if (
_dim( args(2), 0 ) != Alen )
20087 temp4 = args(2).matrix_value();
20088 arg4 = &temp4( 0, 0 );
20090 plline3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
20091 _outv = octave_value();
20113 return octave_value_list();
20121 octave_value_list _out;
20122 octave_value_list *_outp=&_out;
20123 octave_value _outv;
20132 arg1 =
static_cast< PLINT
>(val1);
20134 _outv = octave_value();
20138 return octave_value_list();
20143 PLINT *arg1 = (PLINT *) 0 ;
20146 octave_value_list _out;
20147 octave_value_list *_outp=&_out;
20148 octave_value _outv;
20155 _outv = octave_value();
20165 return octave_value_list();
20170 char *arg1 = (
char *) 0 ;
20174 char *arg5 = (
char *) 0 ;
20187 octave_value_list _out;
20188 octave_value_list *_outp=&_out;
20189 octave_value _outv;
20198 arg1 =
reinterpret_cast< char *
>(buf1);
20203 arg2 =
static_cast< PLFLT
>(val2);
20208 arg3 =
static_cast< PLFLT
>(val3);
20213 arg4 =
static_cast< PLFLT
>(val4);
20218 arg5 =
reinterpret_cast< char *
>(buf5);
20219 plmtex((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
20220 _outv = octave_value();
20228 return octave_value_list();
20233 char *arg1 = (
char *) 0 ;
20237 char *arg5 = (
char *) 0 ;
20250 octave_value_list _out;
20251 octave_value_list *_outp=&_out;
20252 octave_value _outv;
20261 arg1 =
reinterpret_cast< char *
>(buf1);
20266 arg2 =
static_cast< PLFLT
>(val2);
20271 arg3 =
static_cast< PLFLT
>(val3);
20276 arg4 =
static_cast< PLFLT
>(val4);
20281 arg5 =
reinterpret_cast< char *
>(buf5);
20282 plmtex3((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
20283 _outv = octave_value();
20291 return octave_value_list();
20296 int *arg1 = (
int *) 0 ;
20297 char **arg2 = (
char **) 0 ;
20305 octave_value_list _out;
20306 octave_value_list *_outp=&_out;
20307 octave_value _outv;
20317 arg1 =
reinterpret_cast< int *
>(argp1);
20322 arg2 =
reinterpret_cast< char **
>(argp2);
20327 arg3 =
static_cast< PLINT
>(val3);
20333 return octave_value_list();
20339 PLINT *arg2 = (PLINT *) 0 ;
20340 PLINT *arg3 = (PLINT *) 0 ;
20343 octave_value_list _out;
20344 octave_value_list *_outp=&_out;
20345 octave_value _outv;
20351 if (
_n_dims( args(0) ) > 1 )
20355 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
20356 arg2 =
new PLINT[
Alen];
20357 temp1 = args(0).matrix_value();
20361 if (
_n_dims( args(1) ) > 1 )
20365 if (
_dim( args(1), 0 ) != Alen )
20369 temp3 = args(1).matrix_value();
20370 arg3 =
new PLINT[
Alen];
20373 plpat(arg1,(
int const *)arg2,(
int const *)arg3);
20374 _outv = octave_value();
20390 return octave_value_list();
20410 octave_value_list _out;
20411 octave_value_list *_outp=&_out;
20412 octave_value _outv;
20421 arg1 =
static_cast< PLINT
>(val1);
20426 arg2 =
static_cast< PLFLT
>(val2);
20431 arg3 =
static_cast< PLFLT
>(val3);
20436 arg4 =
static_cast< PLFLT
>(val4);
20441 arg5 =
static_cast< PLFLT
>(val5);
20442 plpath(arg1,arg2,arg3,arg4,arg5);
20443 _outv = octave_value();
20447 return octave_value_list();
20453 PLFLT *arg2 = (PLFLT *) 0 ;
20454 PLFLT *arg3 = (PLFLT *) 0 ;
20460 octave_value_list _out;
20461 octave_value_list *_outp=&_out;
20462 octave_value _outv;
20468 if (
_n_dims( args(0) ) > 1 )
20472 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
20473 temp1 = args(0).matrix_value();
20474 arg2 = &temp1( 0, 0 );
20477 if (
_n_dims( args(1) ) > 1 )
20481 if (
_dim( args(1), 0 ) != Alen )
20485 temp3 = args(1).matrix_value();
20486 arg3 = &temp3( 0, 0 );
20492 arg4 =
static_cast< PLINT
>(val4);
20493 plpoin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
20494 _outv = octave_value();
20510 return octave_value_list();
20516 PLFLT *arg2 = (PLFLT *) 0 ;
20517 PLFLT *arg3 = (PLFLT *) 0 ;
20518 PLFLT *arg4 = (PLFLT *) 0 ;
20525 octave_value_list _out;
20526 octave_value_list *_outp=&_out;
20527 octave_value _outv;
20533 if (
_n_dims( args(0) ) > 1 )
20537 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
20538 temp1 = args(0).matrix_value();
20539 arg2 = &temp1( 0, 0 );
20542 if (
_n_dims( args(1) ) > 1 )
20546 if (
_dim( args(1), 0 ) != Alen )
20550 temp3 = args(1).matrix_value();
20551 arg3 = &temp3( 0, 0 );
20554 if (
_n_dims( args(2) ) > 1 )
20558 if (
_dim( args(2), 0 ) != Alen )
20562 temp4 = args(2).matrix_value();
20563 arg4 = &temp4( 0, 0 );
20569 arg5 =
static_cast< PLINT
>(val5);
20570 plpoin3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,arg5);
20571 _outv = octave_value();
20593 return octave_value_list();
20599 PLFLT *arg2 = (PLFLT *) 0 ;
20600 PLFLT *arg3 = (PLFLT *) 0 ;
20601 PLFLT *arg4 = (PLFLT *) 0 ;
20610 octave_value_list _out;
20611 octave_value_list *_outp=&_out;
20612 octave_value _outv;
20618 if (
_n_dims( args(0) ) > 1 )
20622 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
20623 temp1 = args(0).matrix_value();
20624 arg2 = &temp1( 0, 0 );
20627 if (
_n_dims( args(1) ) > 1 )
20631 if (
_dim( args(1), 0 ) != Alen )
20635 temp3 = args(1).matrix_value();
20636 arg3 = &temp3( 0, 0 );
20639 if (
_n_dims( args(2) ) > 1 )
20643 if (
_dim( args(2), 0 ) != Alen )
20647 temp4 = args(2).matrix_value();
20648 arg4 = &temp4( 0, 0 );
20651 if (
_n_dims( args(3) ) > 1 )
20655 if ( !(
_dim( args(3), 0 ) == Alen ||
_dim( args(3), 0 ) == Alen - 1 ) )
20657 error(
"argument vector must be same length or one less" );
SWIG_fail;
20659 temp5 = args(3).matrix_value();
20660 arg5 =
new PLINT[
Alen];
20667 arg6 =
static_cast< PLBOOL >(val6);
20668 plpoly3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
int const *)arg5,arg6);
20669 _outv = octave_value();
20697 return octave_value_list();
20708 octave_value_list _out;
20709 octave_value_list *_outp=&_out;
20710 octave_value _outv;
20719 arg1 =
static_cast< PLINT
>(val1);
20724 arg2 =
static_cast< PLINT
>(val2);
20726 _outv = octave_value();
20730 return octave_value_list();
20738 octave_value_list _out;
20739 octave_value_list *_outp=&_out;
20740 octave_value _outv;
20749 arg1 =
static_cast< PLINT
>(val1);
20751 _outv = octave_value();
20755 return octave_value_list();
20765 char *arg6 = (
char *) 0 ;
20779 octave_value_list _out;
20780 octave_value_list *_outp=&_out;
20781 octave_value _outv;
20790 arg1 =
static_cast< PLFLT
>(val1);
20795 arg2 =
static_cast< PLFLT
>(val2);
20800 arg3 =
static_cast< PLFLT
>(val3);
20805 arg4 =
static_cast< PLFLT
>(val4);
20810 arg5 =
static_cast< PLFLT
>(val5);
20815 arg6 =
reinterpret_cast< char *
>(buf6);
20816 plptex(arg1,arg2,arg3,arg4,arg5,(
char const *)arg6);
20817 _outv = octave_value();
20823 return octave_value_list();
20838 char *arg11 = (
char *) 0 ;
20862 octave_value_list _out;
20863 octave_value_list *_outp=&_out;
20864 octave_value _outv;
20873 arg1 =
static_cast< PLFLT
>(val1);
20878 arg2 =
static_cast< PLFLT
>(val2);
20883 arg3 =
static_cast< PLFLT
>(val3);
20888 arg4 =
static_cast< PLFLT
>(val4);
20893 arg5 =
static_cast< PLFLT
>(val5);
20898 arg6 =
static_cast< PLFLT
>(val6);
20903 arg7 =
static_cast< PLFLT
>(val7);
20908 arg8 =
static_cast< PLFLT
>(val8);
20913 arg9 =
static_cast< PLFLT
>(val9);
20918 arg10 =
static_cast< PLFLT
>(val10);
20923 arg11 =
reinterpret_cast< char *
>(buf11);
20924 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(
char const *)arg11);
20925 _outv = octave_value();
20931 return octave_value_list();
20936 octave_value_list _out;
20937 octave_value_list *_outp=&_out;
20938 octave_value _outv;
20949 return octave_value_list();
20954 octave_value_list _out;
20955 octave_value_list *_outp=&_out;
20956 octave_value _outv;
20962 _outv = octave_value();
20966 return octave_value_list();
20974 PLFLT *arg4 = (PLFLT *) 0 ;
20975 PLFLT *arg5 = (PLFLT *) 0 ;
20976 PLFLT *arg6 = (PLFLT *) 0 ;
20989 octave_value_list _out;
20990 octave_value_list *_outp=&_out;
20991 octave_value _outv;
21003 arg1 =
static_cast< PLFLT
>(val1);
21008 arg2 =
static_cast< PLFLT
>(val2);
21013 arg3 =
static_cast< PLFLT
>(val3);
21014 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
21015 _outv = octave_value();
21037 return octave_value_list();
21048 octave_value_list _out;
21049 octave_value_list *_outp=&_out;
21050 octave_value _outv;
21059 arg1 =
static_cast< PLFLT
>(val1);
21064 arg2 =
static_cast< PLFLT
>(val2);
21066 _outv = octave_value();
21070 return octave_value_list();
21075 PLINT *arg1 = (PLINT *) 0 ;
21076 PLINT *arg2 = (PLINT *) 0 ;
21077 PLINT *arg3 = (PLINT *) 0 ;
21082 octave_value_list _out;
21083 octave_value_list *_outp=&_out;
21084 octave_value _outv;
21090 if (
_n_dims( args(0) ) > 1 )
21095 temp1 = args(0).matrix_value();
21096 arg1 =
new PLINT[
Alen];
21100 if (
_n_dims( args(1) ) > 1 )
21104 if (
_dim( args(1), 0 ) != Alen )
21108 temp2 = args(1).matrix_value();
21109 arg2 =
new PLINT[
Alen];
21113 if (
_n_dims( args(2) ) > 1 )
21117 if (
_dim( args(2), 0 ) != Alen )
21121 temp3 = args(2).matrix_value();
21122 arg3 =
new PLINT[
Alen];
21126 plscmap0((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
21127 _outv = octave_value();
21149 return octave_value_list();
21154 PLINT *arg1 = (PLINT *) 0 ;
21155 PLINT *arg2 = (PLINT *) 0 ;
21156 PLINT *arg3 = (PLINT *) 0 ;
21157 PLFLT *arg4 = (PLFLT *) 0 ;
21163 octave_value_list _out;
21164 octave_value_list *_outp=&_out;
21165 octave_value _outv;
21171 if (
_n_dims( args(0) ) > 1 )
21176 temp1 = args(0).matrix_value();
21177 arg1 =
new PLINT[
Alen];
21181 if (
_n_dims( args(1) ) > 1 )
21185 if (
_dim( args(1), 0 ) != Alen )
21189 temp2 = args(1).matrix_value();
21190 arg2 =
new PLINT[
Alen];
21194 if (
_n_dims( args(2) ) > 1 )
21198 if (
_dim( args(2), 0 ) != Alen )
21202 temp3 = args(2).matrix_value();
21203 arg3 =
new PLINT[
Alen];
21207 if (
_n_dims( args(3) ) > 1 )
21211 if (
_dim( args(3), 0 ) != Alen )
21215 temp4 = args(3).matrix_value();
21216 arg4 = &temp4( 0, 0 );
21219 plscmap0a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
21220 _outv = octave_value();
21248 return octave_value_list();
21256 octave_value_list _out;
21257 octave_value_list *_outp=&_out;
21258 octave_value _outv;
21267 arg1 =
static_cast< PLINT
>(val1);
21269 _outv = octave_value();
21273 return octave_value_list();
21278 PLINT *arg1 = (PLINT *) 0 ;
21279 PLINT *arg2 = (PLINT *) 0 ;
21280 PLINT *arg3 = (PLINT *) 0 ;
21285 octave_value_list _out;
21286 octave_value_list *_outp=&_out;
21287 octave_value _outv;
21293 if (
_n_dims( args(0) ) > 1 )
21298 temp1 = args(0).matrix_value();
21299 arg1 =
new PLINT[
Alen];
21303 if (
_n_dims( args(1) ) > 1 )
21307 if (
_dim( args(1), 0 ) != Alen )
21311 temp2 = args(1).matrix_value();
21312 arg2 =
new PLINT[
Alen];
21316 if (
_n_dims( args(2) ) > 1 )
21320 if (
_dim( args(2), 0 ) != Alen )
21324 temp3 = args(2).matrix_value();
21325 arg3 =
new PLINT[
Alen];
21329 plscmap1((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
21330 _outv = octave_value();
21352 return octave_value_list();
21357 PLINT *arg1 = (PLINT *) 0 ;
21358 PLINT *arg2 = (PLINT *) 0 ;
21359 PLINT *arg3 = (PLINT *) 0 ;
21360 PLFLT *arg4 = (PLFLT *) 0 ;
21366 octave_value_list _out;
21367 octave_value_list *_outp=&_out;
21368 octave_value _outv;
21374 if (
_n_dims( args(0) ) > 1 )
21379 temp1 = args(0).matrix_value();
21380 arg1 =
new PLINT[
Alen];
21384 if (
_n_dims( args(1) ) > 1 )
21388 if (
_dim( args(1), 0 ) != Alen )
21392 temp2 = args(1).matrix_value();
21393 arg2 =
new PLINT[
Alen];
21397 if (
_n_dims( args(2) ) > 1 )
21401 if (
_dim( args(2), 0 ) != Alen )
21405 temp3 = args(2).matrix_value();
21406 arg3 =
new PLINT[
Alen];
21410 if (
_n_dims( args(3) ) > 1 )
21414 if (
_dim( args(3), 0 ) != Alen )
21418 temp4 = args(3).matrix_value();
21419 arg4 = &temp4( 0, 0 );
21422 plscmap1a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
21423 _outv = octave_value();
21451 return octave_value_list();
21458 PLFLT *arg3 = (PLFLT *) 0 ;
21459 PLFLT *arg4 = (PLFLT *) 0 ;
21460 PLFLT *arg5 = (PLFLT *) 0 ;
21461 PLFLT *arg6 = (PLFLT *) 0 ;
21470 octave_value_list _out;
21471 octave_value_list *_outp=&_out;
21472 octave_value _outv;
21481 arg1 =
static_cast< PLBOOL >(val1);
21483 if (
_n_dims( args(1) ) > 1 )
21487 arg2 = Alen = (
PLINT) (
_dim( args(1), 0 ) );
21488 temp2 = args(1).matrix_value();
21489 arg3 = &temp2( 0, 0 );
21492 if (
_n_dims( args(2) ) > 1 )
21496 if (
_dim( args(2), 0 ) != Alen )
21500 temp4 = args(2).matrix_value();
21501 arg4 = &temp4( 0, 0 );
21504 if (
_n_dims( args(3) ) > 1 )
21508 if (
_dim( args(3), 0 ) != Alen )
21512 temp5 = args(3).matrix_value();
21513 arg5 = &temp5( 0, 0 );
21516 if (
_n_dims( args(4) ) > 1 )
21520 if (
_dim( args(4), 0 ) != Alen )
21524 temp6 = args(4).matrix_value();
21525 arg6 = &temp6( 0, 0 );
21528 if (
_n_dims( args(5) ) > 1 )
21532 if ( !(
_dim( args(5), 0 ) == Alen ||
_dim( args(5), 0 ) == Alen - 1 ) )
21534 error(
"argument vector must be same length or one less" );
SWIG_fail;
21536 temp7 = args(5).matrix_value();
21537 arg7 =
new PLINT[
Alen];
21540 plscmap1l(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
int const *)arg7);
21541 _outv = octave_value();
21575 return octave_value_list();
21582 PLFLT *arg3 = (PLFLT *) 0 ;
21583 PLFLT *arg4 = (PLFLT *) 0 ;
21584 PLFLT *arg5 = (PLFLT *) 0 ;
21585 PLFLT *arg6 = (PLFLT *) 0 ;
21586 PLFLT *arg7 = (PLFLT *) 0 ;
21596 octave_value_list _out;
21597 octave_value_list *_outp=&_out;
21598 octave_value _outv;
21607 arg1 =
static_cast< PLBOOL >(val1);
21609 if (
_n_dims( args(1) ) > 1 )
21613 arg2 = Alen = (
PLINT) (
_dim( args(1), 0 ) );
21614 temp2 = args(1).matrix_value();
21615 arg3 = &temp2( 0, 0 );
21618 if (
_n_dims( args(2) ) > 1 )
21622 if (
_dim( args(2), 0 ) != Alen )
21626 temp4 = args(2).matrix_value();
21627 arg4 = &temp4( 0, 0 );
21630 if (
_n_dims( args(3) ) > 1 )
21634 if (
_dim( args(3), 0 ) != Alen )
21638 temp5 = args(3).matrix_value();
21639 arg5 = &temp5( 0, 0 );
21642 if (
_n_dims( args(4) ) > 1 )
21646 if (
_dim( args(4), 0 ) != Alen )
21650 temp6 = args(4).matrix_value();
21651 arg6 = &temp6( 0, 0 );
21654 if (
_n_dims( args(5) ) > 1 )
21658 if (
_dim( args(5), 0 ) != Alen )
21662 temp7 = args(5).matrix_value();
21663 arg7 = &temp7( 0, 0 );
21666 if (
_n_dims( args(6) ) > 1 )
21670 if ( !(
_dim( args(6), 0 ) == Alen ||
_dim( args(6), 0 ) == Alen - 1 ) )
21672 error(
"argument vector must be same length or one less" );
SWIG_fail;
21674 temp8 = args(6).matrix_value();
21675 arg8 =
new PLINT[
Alen];
21678 plscmap1la(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
double const *)arg7,(
int const *)arg8);
21679 _outv = octave_value();
21719 return octave_value_list();
21727 octave_value_list _out;
21728 octave_value_list *_outp=&_out;
21729 octave_value _outv;
21738 arg1 =
static_cast< PLINT
>(val1);
21740 _outv = octave_value();
21744 return octave_value_list();
21755 octave_value_list _out;
21756 octave_value_list *_outp=&_out;
21757 octave_value _outv;
21766 arg1 =
static_cast< PLFLT
>(val1);
21771 arg2 =
static_cast< PLFLT
>(val2);
21773 _outv = octave_value();
21777 return octave_value_list();
21782 PLFLT *arg1 = (PLFLT *) 0 ;
21783 PLFLT *arg2 = (PLFLT *) 0 ;
21788 octave_value_list _out;
21789 octave_value_list *_outp=&_out;
21790 octave_value _outv;
21798 _outv = octave_value();
21814 return octave_value_list();
21831 octave_value_list _out;
21832 octave_value_list *_outp=&_out;
21833 octave_value _outv;
21842 arg1 =
static_cast< PLINT
>(val1);
21847 arg2 =
static_cast< PLINT
>(val2);
21852 arg3 =
static_cast< PLINT
>(val3);
21857 arg4 =
static_cast< PLINT
>(val4);
21858 plscol0(arg1,arg2,arg3,arg4);
21859 _outv = octave_value();
21863 return octave_value_list();
21883 octave_value_list _out;
21884 octave_value_list *_outp=&_out;
21885 octave_value _outv;
21894 arg1 =
static_cast< PLINT
>(val1);
21899 arg2 =
static_cast< PLINT
>(val2);
21904 arg3 =
static_cast< PLINT
>(val3);
21909 arg4 =
static_cast< PLINT
>(val4);
21914 arg5 =
static_cast< PLFLT
>(val5);
21915 plscol0a(arg1,arg2,arg3,arg4,arg5);
21916 _outv = octave_value();
21920 return octave_value_list();
21934 octave_value_list _out;
21935 octave_value_list *_outp=&_out;
21936 octave_value _outv;
21945 arg1 =
static_cast< PLINT
>(val1);
21950 arg2 =
static_cast< PLINT
>(val2);
21955 arg3 =
static_cast< PLINT
>(val3);
21957 _outv = octave_value();
21961 return octave_value_list();
21978 octave_value_list _out;
21979 octave_value_list *_outp=&_out;
21980 octave_value _outv;
21989 arg1 =
static_cast< PLINT
>(val1);
21994 arg2 =
static_cast< PLINT
>(val2);
21999 arg3 =
static_cast< PLINT
>(val3);
22004 arg4 =
static_cast< PLFLT
>(val4);
22006 _outv = octave_value();
22010 return octave_value_list();
22018 octave_value_list _out;
22019 octave_value_list *_outp=&_out;
22020 octave_value _outv;
22029 arg1 =
static_cast< PLINT
>(val1);
22031 _outv = octave_value();
22035 return octave_value_list();
22043 octave_value_list _out;
22044 octave_value_list *_outp=&_out;
22045 octave_value _outv;
22054 arg1 =
static_cast< PLINT
>(val1);
22056 _outv = octave_value();
22060 return octave_value_list();
22065 char *arg1 = (
char *) 0 ;
22069 octave_value_list _out;
22070 octave_value_list *_outp=&_out;
22071 octave_value _outv;
22080 arg1 =
reinterpret_cast< char *
>(buf1);
22081 plsdev((
char const *)arg1);
22082 _outv = octave_value();
22088 return octave_value_list();
22105 octave_value_list _out;
22106 octave_value_list *_outp=&_out;
22107 octave_value _outv;
22116 arg1 =
static_cast< PLFLT
>(val1);
22121 arg2 =
static_cast< PLFLT
>(val2);
22126 arg3 =
static_cast< PLFLT
>(val3);
22131 arg4 =
static_cast< PLFLT
>(val4);
22133 _outv = octave_value();
22137 return octave_value_list();
22160 octave_value_list _out;
22161 octave_value_list *_outp=&_out;
22162 octave_value _outv;
22171 arg1 =
static_cast< PLINT
>(val1);
22176 arg2 =
static_cast< PLINT
>(val2);
22181 arg3 =
static_cast< PLINT
>(val3);
22186 arg4 =
static_cast< PLINT
>(val4);
22191 arg5 =
static_cast< PLFLT
>(val5);
22196 arg6 =
static_cast< PLFLT
>(val6);
22197 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
22198 _outv = octave_value();
22202 return octave_value_list();
22210 octave_value_list _out;
22211 octave_value_list *_outp=&_out;
22212 octave_value _outv;
22221 arg1 =
static_cast< PLFLT
>(val1);
22223 _outv = octave_value();
22227 return octave_value_list();
22244 octave_value_list _out;
22245 octave_value_list *_outp=&_out;
22246 octave_value _outv;
22255 arg1 =
static_cast< PLFLT
>(val1);
22260 arg2 =
static_cast< PLFLT
>(val2);
22265 arg3 =
static_cast< PLFLT
>(val3);
22270 arg4 =
static_cast< PLFLT
>(val4);
22272 _outv = octave_value();
22276 return octave_value_list();
22293 octave_value_list _out;
22294 octave_value_list *_outp=&_out;
22295 octave_value _outv;
22304 arg1 =
static_cast< PLFLT
>(val1);
22309 arg2 =
static_cast< PLFLT
>(val2);
22314 arg3 =
static_cast< PLFLT
>(val3);
22319 arg4 =
static_cast< PLFLT
>(val4);
22321 _outv = octave_value();
22325 return octave_value_list();
22330 unsigned int arg1 ;
22331 unsigned int val1 ;
22333 octave_value_list _out;
22334 octave_value_list *_outp=&_out;
22335 octave_value _outv;
22344 arg1 =
static_cast< unsigned int >(val1);
22346 _outv = octave_value();
22350 return octave_value_list();
22358 octave_value_list _out;
22359 octave_value_list *_outp=&_out;
22360 octave_value _outv;
22369 arg1 =
static_cast< char >(val1);
22371 _outv = octave_value();
22375 return octave_value_list();
22380 char *arg1 = (
char *) 0 ;
22381 char *arg2 = (
char *) 0 ;
22388 octave_value_list _out;
22389 octave_value_list *_outp=&_out;
22390 octave_value _outv;
22400 arg1 =
reinterpret_cast< char *
>(buf1);
22405 arg2 =
reinterpret_cast< char *
>(buf2);
22406 result = (
PLINT)
plsetopt((
char const *)arg1,(
char const *)arg2);
22415 return octave_value_list();
22429 octave_value_list _out;
22430 octave_value_list *_outp=&_out;
22431 octave_value _outv;
22440 arg1 =
static_cast< PLINT
>(val1);
22445 arg2 =
static_cast< PLINT
>(val2);
22450 arg3 =
static_cast< PLINT
>(val3);
22452 _outv = octave_value();
22456 return octave_value_list();
22462 unsigned int val1 ;
22464 octave_value_list _out;
22465 octave_value_list *_outp=&_out;
22466 octave_value _outv;
22477 _outv = octave_value();
22481 return octave_value_list();
22486 char *arg1 = (
char *) 0 ;
22490 octave_value_list _out;
22491 octave_value_list *_outp=&_out;
22492 octave_value _outv;
22501 arg1 =
reinterpret_cast< char *
>(buf1);
22503 _outv = octave_value();
22509 return octave_value_list();
22523 octave_value_list _out;
22524 octave_value_list *_outp=&_out;
22525 octave_value _outv;
22534 arg1 =
static_cast< PLINT
>(val1);
22539 arg2 =
static_cast< PLINT
>(val2);
22544 arg3 =
static_cast< PLINT
>(val3);
22546 _outv = octave_value();
22550 return octave_value_list();
22558 octave_value_list _out;
22559 octave_value_list *_outp=&_out;
22560 octave_value _outv;
22566 octave_value obj = args(0);
22567 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 22568 if ( !obj.isempty() )
22570 if ( !obj.is_empty() )
22573 if ( obj.is_function_handle() || obj.is_inline_function() )
22575 fcnLabelFunc = obj.function_value();
22577 else if ( obj.is_string() )
22579 nameLabelFunc = obj.string_value();
22580 fcnLabelFunc = NULL;
22594 _outv = octave_value();
22598 return octave_value_list();
22609 octave_value_list _out;
22610 octave_value_list *_outp=&_out;
22611 octave_value _outv;
22620 arg1 =
static_cast< PLFLT
>(val1);
22625 arg2 =
static_cast< PLFLT
>(val2);
22627 _outv = octave_value();
22631 return octave_value_list();
22642 octave_value_list _out;
22643 octave_value_list *_outp=&_out;
22644 octave_value _outv;
22653 arg1 =
static_cast< PLFLT
>(val1);
22658 arg2 =
static_cast< PLFLT
>(val2);
22660 _outv = octave_value();
22664 return octave_value_list();
22672 octave_value_list _out;
22673 octave_value_list *_outp=&_out;
22674 octave_value _outv;
22683 arg1 =
static_cast< PLINT
>(val1);
22685 _outv = octave_value();
22689 return octave_value_list();
22712 octave_value_list _out;
22713 octave_value_list *_outp=&_out;
22714 octave_value _outv;
22723 arg1 =
static_cast< PLFLT
>(val1);
22728 arg2 =
static_cast< PLFLT
>(val2);
22733 arg3 =
static_cast< PLINT
>(val3);
22738 arg4 =
static_cast< PLINT
>(val4);
22743 arg5 =
static_cast< PLINT
>(val5);
22748 arg6 =
static_cast< PLINT
>(val6);
22749 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
22750 _outv = octave_value();
22754 return octave_value_list();
22759 char *arg1 = (
char *) 0 ;
22763 octave_value_list _out;
22764 octave_value_list *_outp=&_out;
22765 octave_value _outv;
22774 arg1 =
reinterpret_cast< char *
>(buf1);
22776 _outv = octave_value();
22782 return octave_value_list();
22787 char *arg1 = (
char *) 0 ;
22794 octave_value_list _out;
22795 octave_value_list *_outp=&_out;
22796 octave_value _outv;
22805 arg1 =
reinterpret_cast< char *
>(buf1);
22810 arg2 =
static_cast< PLBOOL >(val2);
22811 plspal1((
char const *)arg1,arg2);
22812 _outv = octave_value();
22818 return octave_value_list();
22826 octave_value_list _out;
22827 octave_value_list *_outp=&_out;
22828 octave_value _outv;
22837 arg1 =
static_cast< PLBOOL >(val1);
22839 _outv = octave_value();
22843 return octave_value_list();
22851 octave_value_list _out;
22852 octave_value_list *_outp=&_out;
22853 octave_value _outv;
22862 arg1 =
static_cast< PLINT
>(val1);
22864 _outv = octave_value();
22868 return octave_value_list();
22879 octave_value_list _out;
22880 octave_value_list *_outp=&_out;
22881 octave_value _outv;
22890 arg1 =
static_cast< PLINT
>(val1);
22895 arg2 =
static_cast< PLINT
>(val2);
22897 _outv = octave_value();
22901 return octave_value_list();
22912 octave_value_list _out;
22913 octave_value_list *_outp=&_out;
22914 octave_value _outv;
22923 arg1 =
static_cast< PLFLT
>(val1);
22928 arg2 =
static_cast< PLFLT
>(val2);
22930 _outv = octave_value();
22934 return octave_value_list();
22945 octave_value_list _out;
22946 octave_value_list *_outp=&_out;
22947 octave_value _outv;
22956 arg1 =
static_cast< PLINT
>(val1);
22961 arg2 =
static_cast< PLINT
>(val2);
22963 _outv = octave_value();
22967 return octave_value_list();
22972 char *arg1 = (
char *) 0 ;
22982 octave_value_list _out;
22983 octave_value_list *_outp=&_out;
22984 octave_value _outv;
22993 arg1 =
reinterpret_cast< char *
>(buf1);
22998 arg2 =
static_cast< PLINT
>(val2);
23003 arg3 =
static_cast< PLINT
>(val3);
23004 plstart((
char const *)arg1,arg2,arg3);
23005 _outv = octave_value();
23011 return octave_value_list();
23019 octave_value_list _out;
23020 octave_value_list *_outp=&_out;
23021 octave_value _outv;
23027 octave_value obj = args(0);
23028 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 23029 if ( !obj.isempty() )
23031 if ( !obj.is_empty() )
23034 if ( obj.is_function_handle() || obj.is_inline_function() )
23036 fcnCoordTrans = obj.function_value();
23038 else if ( obj.is_string() )
23040 nameCoordTrans = obj.string_value();
23041 fcnCoordTrans = NULL;
23055 _outv = octave_value();
23059 return octave_value_list();
23065 PLFLT *arg2 = (PLFLT *) 0 ;
23066 PLFLT *arg3 = (PLFLT *) 0 ;
23067 char *arg4 = (
char *) 0 ;
23073 octave_value_list _out;
23074 octave_value_list *_outp=&_out;
23075 octave_value _outv;
23081 if (
_n_dims( args(0) ) > 1 )
23085 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
23086 temp1 = args(0).matrix_value();
23087 arg2 = &temp1( 0, 0 );
23090 if (
_n_dims( args(1) ) > 1 )
23094 if (
_dim( args(1), 0 ) != Alen )
23098 temp3 = args(1).matrix_value();
23099 arg3 = &temp3( 0, 0 );
23105 arg4 =
reinterpret_cast< char *
>(buf4);
23106 plstring(arg1,(
double const *)arg2,(
double const *)arg3,(
char const *)arg4);
23107 _outv = octave_value();
23125 return octave_value_list();
23131 PLFLT *arg2 = (PLFLT *) 0 ;
23132 PLFLT *arg3 = (PLFLT *) 0 ;
23133 PLFLT *arg4 = (PLFLT *) 0 ;
23134 char *arg5 = (
char *) 0 ;
23141 octave_value_list _out;
23142 octave_value_list *_outp=&_out;
23143 octave_value _outv;
23149 if (
_n_dims( args(0) ) > 1 )
23153 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
23154 temp1 = args(0).matrix_value();
23155 arg2 = &temp1( 0, 0 );
23158 if (
_n_dims( args(1) ) > 1 )
23162 if (
_dim( args(1), 0 ) != Alen )
23166 temp3 = args(1).matrix_value();
23167 arg3 = &temp3( 0, 0 );
23170 if (
_n_dims( args(2) ) > 1 )
23174 if (
_dim( args(2), 0 ) != Alen )
23178 temp4 = args(2).matrix_value();
23179 arg4 = &temp4( 0, 0 );
23185 arg5 =
reinterpret_cast< char *
>(buf5);
23186 plstring3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
char const *)arg5);
23187 _outv = octave_value();
23211 return octave_value_list();
23228 octave_value_list _out;
23229 octave_value_list *_outp=&_out;
23230 octave_value _outv;
23239 arg1 =
static_cast< PLINT
>(val1);
23244 arg2 =
static_cast< PLINT
>(val2);
23249 arg3 =
static_cast< PLFLT
>(val3);
23254 arg4 =
static_cast< PLFLT
>(val4);
23256 _outv = octave_value();
23260 return octave_value_list();
23268 octave_value_list _out;
23269 octave_value_list *_outp=&_out;
23270 octave_value _outv;
23279 arg1 =
static_cast< PLINT
>(val1);
23281 _outv = octave_value();
23285 return octave_value_list();
23291 PLINT *arg2 = (PLINT *) 0 ;
23292 PLINT *arg3 = (PLINT *) 0 ;
23295 octave_value_list _out;
23296 octave_value_list *_outp=&_out;
23297 octave_value _outv;
23303 if (
_n_dims( args(0) ) > 1 )
23307 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
23308 arg2 =
new PLINT[
Alen];
23309 temp1 = args(0).matrix_value();
23313 if (
_n_dims( args(1) ) > 1 )
23317 if (
_dim( args(1), 0 ) != Alen )
23321 temp3 = args(1).matrix_value();
23322 arg3 =
new PLINT[
Alen];
23325 plstyl(arg1,(
int const *)arg2,(
int const *)arg3);
23326 _outv = octave_value();
23342 return octave_value_list();
23347 PLFLT *arg1 = (PLFLT *) 0 ;
23348 PLFLT *arg2 = (PLFLT *) 0 ;
23355 octave_value_list _out;
23356 octave_value_list *_outp=&_out;
23357 octave_value _outv;
23363 if (
_n_dims( args(0) ) > 1 )
23367 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 23368 if ( !args(0).isempty() )
23370 if ( !args(0).is_empty() )
23374 temp1 = args(0).matrix_value();
23375 arg1 = &temp1( 0, 0 );
23384 if (
_n_dims( args(1) ) > 1 )
23388 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 23389 if ( !args(1).isempty() )
23391 if ( !args(1).is_empty() )
23394 if (
_dim( args(1), 0 ) != Alen )
23398 temp2 = args(1).matrix_value();
23399 arg2 = &temp2( 0, 0 );
23412 arg4 =
static_cast< PLBOOL >(val4);
23413 plsvect((
double const *)arg1,(
double const *)arg2,arg3,arg4);
23414 _outv = octave_value();
23430 return octave_value_list();
23447 octave_value_list _out;
23448 octave_value_list *_outp=&_out;
23449 octave_value _outv;
23458 arg1 =
static_cast< PLFLT
>(val1);
23463 arg2 =
static_cast< PLFLT
>(val2);
23468 arg3 =
static_cast< PLFLT
>(val3);
23473 arg4 =
static_cast< PLFLT
>(val4);
23474 plsvpa(arg1,arg2,arg3,arg4);
23475 _outv = octave_value();
23479 return octave_value_list();
23490 octave_value_list _out;
23491 octave_value_list *_outp=&_out;
23492 octave_value _outv;
23501 arg1 =
static_cast< PLINT
>(val1);
23506 arg2 =
static_cast< PLINT
>(val2);
23508 _outv = octave_value();
23512 return octave_value_list();
23523 octave_value_list _out;
23524 octave_value_list *_outp=&_out;
23525 octave_value _outv;
23534 arg1 =
static_cast< PLINT
>(val1);
23539 arg2 =
static_cast< PLINT
>(val2);
23541 _outv = octave_value();
23545 return octave_value_list();
23551 PLFLT *arg2 = (PLFLT *) 0 ;
23552 PLFLT *arg3 = (PLFLT *) 0 ;
23558 octave_value_list _out;
23559 octave_value_list *_outp=&_out;
23560 octave_value _outv;
23566 if (
_n_dims( args(0) ) > 1 )
23570 arg1 = Alen = (
PLINT) (
_dim( args(0), 0 ) );
23571 temp1 = args(0).matrix_value();
23572 arg2 = &temp1( 0, 0 );
23575 if (
_n_dims( args(1) ) > 1 )
23579 if (
_dim( args(1), 0 ) != Alen )
23583 temp3 = args(1).matrix_value();
23584 arg3 = &temp3( 0, 0 );
23590 arg4 =
static_cast< PLINT
>(val4);
23591 plsym(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
23592 _outv = octave_value();
23608 return octave_value_list();
23619 octave_value_list _out;
23620 octave_value_list *_outp=&_out;
23621 octave_value _outv;
23630 arg1 =
static_cast< PLINT
>(val1);
23635 arg2 =
static_cast< PLINT
>(val2);
23637 _outv = octave_value();
23641 return octave_value_list();
23646 octave_value_list _out;
23647 octave_value_list *_outp=&_out;
23648 octave_value _outv;
23654 _outv = octave_value();
23658 return octave_value_list();
23663 char *arg1 = (
char *) 0 ;
23667 octave_value_list _out;
23668 octave_value_list *_outp=&_out;
23669 octave_value _outv;
23678 arg1 =
reinterpret_cast< char *
>(buf1);
23680 _outv = octave_value();
23686 return octave_value_list();
23694 octave_value_list _out;
23695 octave_value_list *_outp=&_out;
23696 octave_value _outv;
23705 arg1 =
static_cast< PLFLT
>(val1);
23707 _outv = octave_value();
23711 return octave_value_list();
23731 octave_value_list _out;
23732 octave_value_list *_outp=&_out;
23733 octave_value _outv;
23742 arg1 =
static_cast< PLFLT
>(val1);
23747 arg2 =
static_cast< PLFLT
>(val2);
23752 arg3 =
static_cast< PLFLT
>(val3);
23757 arg4 =
static_cast< PLFLT
>(val4);
23762 arg5 =
static_cast< PLFLT
>(val5);
23763 plvpas(arg1,arg2,arg3,arg4,arg5);
23764 _outv = octave_value();
23768 return octave_value_list();
23785 octave_value_list _out;
23786 octave_value_list *_outp=&_out;
23787 octave_value _outv;
23796 arg1 =
static_cast< PLFLT
>(val1);
23801 arg2 =
static_cast< PLFLT
>(val2);
23806 arg3 =
static_cast< PLFLT
>(val3);
23811 arg4 =
static_cast< PLFLT
>(val4);
23812 plvpor(arg1,arg2,arg3,arg4);
23813 _outv = octave_value();
23817 return octave_value_list();
23822 octave_value_list _out;
23823 octave_value_list *_outp=&_out;
23824 octave_value _outv;
23830 _outv = octave_value();
23834 return octave_value_list();
23872 octave_value_list _out;
23873 octave_value_list *_outp=&_out;
23874 octave_value _outv;
23883 arg1 =
static_cast< PLFLT
>(val1);
23888 arg2 =
static_cast< PLFLT
>(val2);
23893 arg3 =
static_cast< PLFLT
>(val3);
23898 arg4 =
static_cast< PLFLT
>(val4);
23903 arg5 =
static_cast< PLFLT
>(val5);
23908 arg6 =
static_cast< PLFLT
>(val6);
23913 arg7 =
static_cast< PLFLT
>(val7);
23918 arg8 =
static_cast< PLFLT
>(val8);
23923 arg9 =
static_cast< PLFLT
>(val9);
23928 arg10 =
static_cast< PLFLT
>(val10);
23933 arg11 =
static_cast< PLFLT
>(val11);
23934 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
23935 _outv = octave_value();
23939 return octave_value_list();
23947 octave_value_list _out;
23948 octave_value_list *_outp=&_out;
23949 octave_value _outv;
23958 arg1 =
static_cast< PLFLT
>(val1);
23960 _outv = octave_value();
23964 return octave_value_list();
23981 octave_value_list _out;
23982 octave_value_list *_outp=&_out;
23983 octave_value _outv;
23992 arg1 =
static_cast< PLFLT
>(val1);
23997 arg2 =
static_cast< PLFLT
>(val2);
24002 arg3 =
static_cast< PLFLT
>(val3);
24007 arg4 =
static_cast< PLFLT
>(val4);
24008 plwind(arg1,arg2,arg3,arg4);
24009 _outv = octave_value();
24013 return octave_value_list();
24024 octave_value_list _out;
24025 octave_value_list *_outp=&_out;
24026 octave_value _outv;
24036 arg1 =
static_cast< PLBOOL >(val1);
24038 _outv = octave_value();
24048 return octave_value_list();
24054 char *arg2 = (
char *) 0 ;
24070 octave_value_list _out;
24071 octave_value_list *_outp=&_out;
24072 octave_value _outv;
24078 octave_value obj = args(0);
24079 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 24080 if ( !obj.isempty() )
24082 if ( !obj.is_empty() )
24085 if ( obj.is_function_handle() || obj.is_inline_function() )
24087 fcnMapForm = obj.function_value();
24089 else if ( obj.is_string() )
24091 nameMapForm = obj.string_value();
24105 arg2 =
reinterpret_cast< char *
>(buf2);
24110 arg3 =
static_cast< PLFLT
>(val3);
24115 arg4 =
static_cast< PLFLT
>(val4);
24120 arg5 =
static_cast< PLFLT
>(val5);
24125 arg6 =
static_cast< PLFLT
>(val6);
24126 plmap(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6);
24127 _outv = octave_value();
24133 return octave_value_list();
24139 char *arg2 = (
char *) 0 ;
24144 PLINT *arg7 = (PLINT *) 0 ;
24158 octave_value_list _out;
24159 octave_value_list *_outp=&_out;
24160 octave_value _outv;
24166 octave_value obj = args(0);
24167 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 24168 if ( !obj.isempty() )
24170 if ( !obj.is_empty() )
24173 if ( obj.is_function_handle() || obj.is_inline_function() )
24175 fcnMapForm = obj.function_value();
24177 else if ( obj.is_string() )
24179 nameMapForm = obj.string_value();
24193 arg2 =
reinterpret_cast< char *
>(buf2);
24198 arg3 =
static_cast< PLFLT
>(val3);
24203 arg4 =
static_cast< PLFLT
>(val4);
24208 arg5 =
static_cast< PLFLT
>(val5);
24213 arg6 =
static_cast< PLFLT
>(val6);
24215 if (
_n_dims( args(6) ) > 1 )
24219 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 24220 if ( !args(6).isempty() )
24222 if ( !args(6).is_empty() )
24226 temp7 = args(6).matrix_value();
24227 arg7 =
new PLINT[arg8];
24236 plmapline(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
24237 _outv = octave_value();
24249 return octave_value_list();
24255 char *arg2 = (
char *) 0 ;
24256 char *arg3 = (
char *) 0 ;
24261 PLINT *arg8 = (PLINT *) 0 ;
24278 octave_value_list _out;
24279 octave_value_list *_outp=&_out;
24280 octave_value _outv;
24286 octave_value obj = args(0);
24287 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 24288 if ( !obj.isempty() )
24290 if ( !obj.is_empty() )
24293 if ( obj.is_function_handle() || obj.is_inline_function() )
24295 fcnMapForm = obj.function_value();
24297 else if ( obj.is_string() )
24299 nameMapForm = obj.string_value();
24313 arg2 =
reinterpret_cast< char *
>(buf2);
24318 arg3 =
reinterpret_cast< char *
>(buf3);
24323 arg4 =
static_cast< PLFLT
>(val4);
24328 arg5 =
static_cast< PLFLT
>(val5);
24333 arg6 =
static_cast< PLFLT
>(val6);
24338 arg7 =
static_cast< PLFLT
>(val7);
24340 if (
_n_dims( args(7) ) > 1 )
24344 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 24345 if ( !args(7).isempty() )
24347 if ( !args(7).is_empty() )
24351 temp8 = args(7).matrix_value();
24352 arg8 =
new PLINT[arg9];
24361 plmapstring(arg1,(
char const *)arg2,(
char const *)arg3,arg4,arg5,arg6,arg7,(
int const *)arg8,arg9);
24362 _outv = octave_value();
24376 return octave_value_list();
24382 char *arg2 = (
char *) 0 ;
24386 char *arg6 = (
char *) 0 ;
24414 octave_value_list _out;
24415 octave_value_list *_outp=&_out;
24416 octave_value _outv;
24422 octave_value obj = args(0);
24423 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 24424 if ( !obj.isempty() )
24426 if ( !obj.is_empty() )
24429 if ( obj.is_function_handle() || obj.is_inline_function() )
24431 fcnMapForm = obj.function_value();
24433 else if ( obj.is_string() )
24435 nameMapForm = obj.string_value();
24449 arg2 =
reinterpret_cast< char *
>(buf2);
24454 arg3 =
static_cast< PLFLT
>(val3);
24459 arg4 =
static_cast< PLFLT
>(val4);
24464 arg5 =
static_cast< PLFLT
>(val5);
24469 arg6 =
reinterpret_cast< char *
>(buf6);
24474 arg7 =
static_cast< PLFLT
>(val7);
24479 arg8 =
static_cast< PLFLT
>(val8);
24484 arg9 =
static_cast< PLFLT
>(val9);
24489 arg10 =
static_cast< PLFLT
>(val10);
24494 arg11 =
static_cast< PLINT
>(val11);
24495 plmaptex(arg1,(
char const *)arg2,arg3,arg4,arg5,(
char const *)arg6,arg7,arg8,arg9,arg10,arg11);
24496 _outv = octave_value();
24504 return octave_value_list();
24510 char *arg2 = (
char *) 0 ;
24515 PLINT *arg7 = (PLINT *) 0 ;
24529 octave_value_list _out;
24530 octave_value_list *_outp=&_out;
24531 octave_value _outv;
24537 octave_value obj = args(0);
24538 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 24539 if ( !obj.isempty() )
24541 if ( !obj.is_empty() )
24544 if ( obj.is_function_handle() || obj.is_inline_function() )
24546 fcnMapForm = obj.function_value();
24548 else if ( obj.is_string() )
24550 nameMapForm = obj.string_value();
24564 arg2 =
reinterpret_cast< char *
>(buf2);
24569 arg3 =
static_cast< PLFLT
>(val3);
24574 arg4 =
static_cast< PLFLT
>(val4);
24579 arg5 =
static_cast< PLFLT
>(val5);
24584 arg6 =
static_cast< PLFLT
>(val6);
24586 if (
_n_dims( args(6) ) > 1 )
24590 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 24591 if ( !args(6).isempty() )
24593 if ( !args(6).is_empty() )
24597 temp7 = args(6).matrix_value();
24598 arg7 =
new PLINT[arg8];
24607 plmapfill(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
24608 _outv = octave_value();
24620 return octave_value_list();
24644 octave_value_list _out;
24645 octave_value_list *_outp=&_out;
24646 octave_value _outv;
24652 octave_value obj = args(0);
24653 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 ) 24654 if ( !obj.isempty() )
24656 if ( !obj.is_empty() )
24659 if ( obj.is_function_handle() || obj.is_inline_function() )
24661 fcnMapForm = obj.function_value();
24663 else if ( obj.is_string() )
24665 nameMapForm = obj.string_value();
24679 arg2 =
static_cast< PLFLT
>(val2);
24684 arg3 =
static_cast< PLFLT
>(val3);
24689 arg4 =
static_cast< PLFLT
>(val4);
24694 arg5 =
static_cast< PLFLT
>(val5);
24699 arg6 =
static_cast< PLFLT
>(val6);
24704 arg7 =
static_cast< PLFLT
>(val7);
24706 _outv = octave_value();
24710 return octave_value_list();
24715 octave_value_list _out;
24716 octave_value_list *_outp=&_out;
24717 octave_value _outv;
24723 _outv = octave_value();
24727 return octave_value_list();
24732 octave_value_list _out;
24733 octave_value_list *_outp=&_out;
24734 octave_value _outv;
24740 _outv = octave_value();
24744 return octave_value_list();
24749 char *arg1 = (
char *) 0 ;
24750 char *arg2 = (
char *) 0 ;
24757 octave_value_list _out;
24758 octave_value_list *_outp=&_out;
24759 octave_value _outv;
24768 arg1 =
reinterpret_cast< char *
>(buf1);
24773 arg2 =
reinterpret_cast< char *
>(buf2);
24774 plSetUsage((
char const *)arg1,(
char const *)arg2);
24775 _outv = octave_value();
24783 return octave_value_list();
24788 octave_value_list _out;
24789 octave_value_list *_outp=&_out;
24790 octave_value _outv;
24796 _outv = octave_value();
24800 return octave_value_list();
24806 {
"testppchar",_wrap_testppchar,0,0,2,0},
24808 {
"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
24811 {
"plcont0",_wrap_plcont0,0,0,2,0},
24812 {
"plcont1",_wrap_plcont1,0,0,2,0},
24813 {
"plcont2",_wrap_plcont2,0,0,2,0},
24814 {
"plcont2p",_wrap_plcont2p,0,0,2,0},
24824 {
"plshade1",_wrap_plshade1,0,0,2,0},
24825 {
"plshade2",_wrap_plshade2,0,0,2,0},
24827 {
"plshadesx",_wrap_plshadesx,0,0,2,0},
24828 {
"plshades1",_wrap_plshades1,0,0,2,0},
24829 {
"plshades2",_wrap_plshades2,0,0,2,0},
24831 {
"plvect1",_wrap_plvect1,0,0,2,0},
24832 {
"plvect2",_wrap_plvect2,0,0,2,0},
24833 {
"pplimage",_wrap_pplimage,0,0,2,0},
24835 {
"plimagefrx",_wrap_plimagefrx,0,0,2,0},
24836 {
"plimagefr1",_wrap_plimagefr1,0,0,2,0},
24837 {
"plimagefr2",_wrap_plimagefr2,0,0,2,0},
24972 {
"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
25123 #define SWIGRUNTIME_DEBUG 25134 if (swig_module.
next==0) {
25146 if (!module_head) {
25154 if (iter==&swig_module) {
25159 }
while (iter!= module_head);
25162 swig_module.
next = module_head->
next;
25170 if (init == 0)
return;
25173 #ifdef SWIGRUNTIME_DEBUG 25174 printf(
"SWIG_InitializeModule: size %d\n", swig_module.
size);
25176 for (i = 0; i < swig_module.
size; ++i) {
25181 #ifdef SWIGRUNTIME_DEBUG 25182 printf(
"SWIG_InitializeModule: type %d %s\n", i, swig_module.
type_initial[i]->
name);
25186 if (swig_module.
next != &swig_module) {
25191 #ifdef SWIGRUNTIME_DEBUG 25192 printf(
"SWIG_InitializeModule: found type %s\n", type->
name);
25196 #ifdef SWIGRUNTIME_DEBUG 25197 printf(
"SWIG_InitializeModule: found and overwrite type %s \n", type->
name);
25206 while (cast->
type) {
25210 #ifdef SWIGRUNTIME_DEBUG 25211 printf(
"SWIG_InitializeModule: look cast %s\n", cast->
type->
name);
25213 if (swig_module.
next != &swig_module) {
25215 #ifdef SWIGRUNTIME_DEBUG 25216 if (ret) printf(
"SWIG_InitializeModule: found cast %s\n", ret->
name);
25221 #ifdef SWIGRUNTIME_DEBUG 25222 printf(
"SWIG_InitializeModule: skip old type %s\n", ret->
name);
25229 #ifdef SWIGRUNTIME_DEBUG 25230 if (ocast) printf(
"SWIG_InitializeModule: skip old cast %s\n", ret->
name);
25232 if (!ocast) ret = 0;
25237 #ifdef SWIGRUNTIME_DEBUG 25238 printf(
"SWIG_InitializeModule: adding cast %s\n", cast->
type->
name);
25249 swig_module.
types[i] = type;
25251 swig_module.
types[i] = 0;
25253 #ifdef SWIGRUNTIME_DEBUG 25254 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
25255 for (i = 0; i < swig_module.
size; ++i) {
25258 printf(
"SWIG_InitializeModule: type %d %s\n", i, swig_module.
type_initial[i]->
name);
25259 while (cast->
type) {
25260 printf(
"SWIG_InitializeModule: cast type %s\n", cast->
type->
name);
25264 printf(
"---- Total casts: %d\n",j);
25266 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
25279 static int init_run = 0;
25281 if (init_run)
return;
25284 for (i = 0; i < swig_module.
size; i++) {
25292 equiv = equiv->
next;
25312 #if SWIG_OCTAVE_PREREQ(4,2,0) 25313 octave::unwind_protect frame;
25314 frame.protect_var(discard_error_messages); discard_error_messages =
true;
25315 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
25316 #elif SWIG_OCTAVE_PREREQ(3,3,50) 25317 unwind_protect frame;
25318 frame.protect_var(error_state); error_state = 0;
25319 frame.protect_var(warning_state); warning_state = 0;
25320 frame.protect_var(discard_error_messages); discard_error_messages =
true;
25321 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
25323 unwind_protect::begin_frame(
"SWIG_Octave_LoadModule");
25324 unwind_protect_int(error_state); error_state = 0;
25325 unwind_protect_int(warning_state); warning_state = 0;
25326 unwind_protect_bool(discard_error_messages); discard_error_messages =
true;
25327 unwind_protect_bool(discard_warning_messages); discard_warning_messages =
true;
25329 #if SWIG_OCTAVE_PREREQ(4,2,0) 25331 #if SWIG_OCTAVE_PREREQ(4,4,0) 25332 octave::feval(name, octave_value_list(), 0);
25334 feval(name, octave_value_list(), 0);
25337 }
catch (octave::execution_exception&) { }
25339 feval(name, octave_value_list(), 0);
25340 retn = (error_state == 0);
25342 #if !SWIG_OCTAVE_PREREQ(3,3,50) 25343 unwind_protect::run_frame(
"SWIG_Octave_LoadModule");
25355 #if SWIG_OCTAVE_PREREQ(4,2,0) 25356 octave::unwind_protect frame;
25357 frame.protect_var(discard_error_messages); discard_error_messages =
true;
25358 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
25359 #elif SWIG_OCTAVE_PREREQ(3,3,50) 25360 unwind_protect frame;
25361 frame.protect_var(error_state); error_state = 0;
25362 frame.protect_var(warning_state); warning_state = 0;
25363 frame.protect_var(discard_error_messages); discard_error_messages =
true;
25364 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
25366 unwind_protect::begin_frame(
"SWIG_Octave_InstallFunction");
25367 unwind_protect_int(error_state); error_state = 0;
25368 unwind_protect_int(warning_state); warning_state = 0;
25369 unwind_protect_bool(discard_error_messages); discard_error_messages =
true;
25370 unwind_protect_bool(discard_warning_messages); discard_warning_messages =
true;
25372 octave_value_list args;
25374 args.append(octloadfcn->fcn_file_name());
25375 #if SWIG_OCTAVE_PREREQ(4,2,0) 25377 #if SWIG_OCTAVE_PREREQ(4,4,0) 25378 octave::feval(
"autoload", args, 0);
25380 feval(
"autoload", args, 0);
25383 }
catch (octave::execution_exception&) { }
25385 feval(
"autoload", args, 0);
25386 retn = (error_state == 0);
25388 #if !SWIG_OCTAVE_PREREQ(3,3,50) 25389 unwind_protect::run_frame(
"SWIG_Octave_InstallFunction");
25399 @deftypefn {Loadable Function} {} subclass()\n\ 25400 @deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\ 25401 Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\ 25403 See the SWIG manual for usage examples.\n\ 25408 for (
int j = 0; j < args.length(); ++j) {
25409 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
25412 if (!ost->is_owned()) {
25413 error(
"subclass: cannot subclass object not constructed on octave side");
25414 return octave_value_list();
25417 }
else if (args(j).is_function_handle()) {
25418 top->
assign(args(j).fcn_handle_value()->fcn_name(), args(j));
25419 }
else if (args(j).is_string()) {
25420 if (j + 1 >= args.length()) {
25421 error(
"subclass: member assignments must be of string,value form");
25422 return octave_value_list();
25424 top->
assign(args(j).string_value(), args(j + 1));
25427 error(
"subclass: invalid arguments to subclass()");
25428 return octave_value_list();
25435 @deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\ 25436 Return the underlying C/C++ type name of a SWIG-wrapped object.\n\ 25440 if (args.length() != 1) {
25441 error(
"swig_type: must be called with only a single object");
25442 return octave_value_list();
25446 error(
"swig_type: object is not a swig_ref");
25447 return octave_value_list();
25453 @deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\ 25454 Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\ 25455 otherwise return `<unknown>'.\n\ 25458 DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
25459 if (args.length() != 1 || !args(0).is_string()) {
25460 error(
"swig_typequery: must be called with single string argument");
25461 return octave_value_list();
25466 return octave_value(
"<unknown>");
25467 return octave_value(type->
name);
25471 @deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\ 25472 Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\ 25476 if (args.length() != 1) {
25477 error(
"swig_this: must be called with only a single object");
25478 return octave_value_list();
25480 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
25481 return octave_value(octave_uint64(0));
25484 error(
"swig_this: object is not a swig_ref");
25485 return octave_value_list();
25487 return octave_value(octave_uint64((
unsigned long long) ost->
swig_this()));
25491 @deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\ 25492 Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\ 25495 DEFUN_DLD( swig_octave_prereq, args, nargout, swig_octave_prereq_usage ) {
25496 if (args.length() != 3) {
25497 error(
"swig_octave_prereq: must be called with 3 arguments");
25498 return octave_value_list();
25500 const int major = args(0).int_value();
25501 const int minor = args(1).int_value();
25502 const int patch = args(2).int_value();
25504 return octave_value(prereq);
25508 @deftypefn {Loadable Module} {} " SWIG_name_d "\n\ 25509 Loads the SWIG-generated module `" SWIG_name_d "'.\n\ 25523 #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK 25524 #if SWIG_OCTAVE_PREREQ(4,4,0) 25526 #elif SWIG_OCTAVE_PREREQ(3,2,0) 25527 octave_exit = ::_Exit;
25532 if (args.length() != 0 || nargout != 0) {
25534 return octave_value_list();
25542 #if SWIG_OCTAVE_PREREQ(3,2,0) 25543 octave_value_list eval_args;
25544 eval_args.append(
"base");
25545 eval_args.append(
"function __swig_atexit__; " 25552 "__swig_atexit__; " 25553 "atexit(\"__swig_atexit__\", false); " 25554 "atexit(\"__swig_atexit__\")");
25555 #if SWIG_OCTAVE_PREREQ(4,4,0) 25556 octave::feval(
"evalin", eval_args, 0);
25558 feval(
"evalin", eval_args, 0);
25562 #if SWIG_OCTAVE_PREREQ(4,4,0) 25564 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
25565 string_vector types = typeinfo.installed_type_names();
25566 bool register_octave_swig_ref =
true;
25567 bool register_octave_swig_packed =
true;
25568 bool register_octave_swig_bound_func =
true;
25569 for (
int i = 0; i < types.numel(); ++i) {
25570 if (types(i) == octave_swig_ref::static_type_name()) {
25571 register_octave_swig_ref =
false;
25573 if (types(i) == octave_swig_packed::static_type_name()) {
25574 register_octave_swig_packed =
false;
25576 if (types(i) == octave_swig_bound_func::static_type_name()) {
25577 register_octave_swig_bound_func =
false;
25580 if (register_octave_swig_ref) {
25581 octave_swig_ref::register_type();
25583 if (register_octave_swig_packed) {
25584 octave_swig_packed::register_type();
25586 if (register_octave_swig_bound_func) {
25587 octave_swig_bound_func::register_type();
25591 octave_swig_ref::register_type();
25592 octave_swig_packed::register_type();
25597 #if SWIG_OCTAVE_PREREQ(4,4,0) 25598 octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
25599 octave_function *me = stack.current();
25601 octave_function *me = octave_call_stack::current();
25605 return octave_value_list();
25608 return octave_value_list();
25611 return octave_value_list();
25614 return octave_value_list();
25617 return octave_value_list();
25623 for (
int j=0;swig_globals[j].
name;++j)
25625 cvar_ns->
assign(swig_globals[j].name,&swig_globals[j]);
25633 for (
int j=0;swig_globals[j].
name;++j)
25635 module_ns->
assign(swig_globals[j].name,&swig_globals[j]);
25637 for (
int j=0;swig_globals[j].
name;++j)
25638 if (swig_globals[j].
method)
25639 module_ns->
assign(swig_globals[j].name,&swig_globals[j]);
25644 for (
int j=0;swig_types[j];++j)
25645 if (swig_types[j]->clientdata) {
25655 return octave_value_list();
25662 if (mb->second.first && mb->second.first->method) {
25664 return octave_value_list();
25669 #if SWIG_OCTAVE_PREREQ(4,4,0) 25670 octave::interpreter::the_interpreter()->mlock();
25671 #elif SWIG_OCTAVE_PREREQ(3,2,0) 25681 if (mb->second.second.is_defined()) {
25690 return octave_value_list();
static const char * _wrap_pljoin_texinfo
SWIGINTERN PyObject * _wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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_plscolbg(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
SWIGINTERN PyObject * _wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_base_value * clone() const
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_base_value * clone() const
void merge(octave_swig_type &rhs)
#define swigreg_binary_op(name)
void load_members(member_map &out) const
SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
static const char * _wrap_plcol0_texinfo
static const char * _wrap_plimagefr_texinfo
SWIGINTERN PyObject * _wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_CheckState(r)
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define swig_binary_op(name)
virtual bool is_map() const
octave_base_value * empty_clone() const
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)
void *(* swig_converter_func)(void *, int *)
SWIGINTERNINLINE octave_value SWIG_From_double(double value)
static bool SWIG_init_user(octave_swig_type *module_ns)
static const char * _wrap_plsmin_texinfo
integer(kind=private_plint), parameter, private maxlen
octave_function * fcnLabelFunc
static const char * _wrap_plsyax_texinfo
static const char * swig_PLGraphicsIn_base_names[]
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char *const swig_typequery_usage
SWIGINTERN PyObject * _wrap_plot3dc(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)
PLINT plGetCursor(PLGraphicsIn *plg)
SWIGINTERN PyObject * _wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual std::string string_value(bool force=false) const
octave_value operator*() const
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
void c_plmeshc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
static const char * _wrap_plschr_texinfo
SWIGINTERN PyObject * _wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plstripc(PLINT *id, const char *xspec, const char *yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLBOOL y_ascl, PLBOOL acc, PLINT colbox, PLINT collab, const PLINT *colline, const PLINT *styline, const char *legline1, const char *legline2, const char *legline3, const char *legline4, const char *labx, const char *laby, const char *labtop)
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plszax_texinfo
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_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_OverflowError
SWIGINTERN PyObject * _wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_GetModule(clientdata)
SWIGINTERN PyObject * _wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual double scalar_value(bool frc_str_conv=false) const
static const char * _wrap_pltimefmt_texinfo
SWIGINTERN PyObject * _wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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
SWIGINTERN PyObject * _wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual type_conv_info numeric_conversion_function(void) const
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_plgxax(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)
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
SWIGINTERN PyObject * _wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
const char * help_text() const
static const char * _wrap_plstransform_texinfo
SWIGINTERN PyObject * _wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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)
static const char * _wrap_plscmap1a_texinfo
virtual bool save_ascii(std::ostream &os)
SWIGRUNTIMEINLINE octave_value SWIG_Octave_GetGlobalValue(std::string name)
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
SWIGINTERN PyObject * _wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static void _cvt_double_to(FLOAT *out_arr, double *in_arr, unsigned n_el)
SWIGRUNTIME void SWIG_InstallUnaryOps(int tid)
SWIGINTERN PyObject * _wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name)
std::string nameLabelFunc
static const char * _wrap_plstripd_texinfo
int cast(void **vptr, swig_type_info *type, int *_own, int flags)
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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
SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name)
virtual bool is_string() const
void my_plvect(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr)
static const char * _wrap_plmtex3_texinfo
octave_base_value * empty_clone() const
static const char * _wrap_plpoin_texinfo
SWIGRUNTIME void SWIG_PropagateClientData(void)
SWIGINTERN PyObject * _wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char *const swig_octave_prereq_usage
SWIGINTERN PyObject * _wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref, "swig_ref", "swig_ref")
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_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plpoin3_texinfo
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_swig_type * get_ptr() const
virtual bool is_object() const
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
SWIGINTERN PyObject * _wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pl_setcontlabelparam
#define SWIGTYPE_p_p_char
SWIGINTERN PyObject * _wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_double
struct swig_cast_info * cast
static const char * _wrap_plsstrm_texinfo
void print(std::ostream &os, bool pr_as_read_syntax=false) const
static PyObject * swig_this
SWIGINTERN PyObject * _wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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)
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_module_info * SWIG_Octave_GetModule(void *clientdata)
#define SWIG_TypeQuery(name)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(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
void print(std::ostream &os, bool pr_as_read_syntax=false) const
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLINT plTranslateCursor(PLGraphicsIn *plg)
SWIGINTERN PyObject * _wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plpsty_texinfo
DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
virtual Octave_map map_value() const
SWIGINTERN PyObject * _wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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)
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
SWIGINTERN PyObject * _wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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)
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)
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
static swig_type_info _swigt__p_p_char
struct swig_module_info swig_module_info
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
SWIGINTERN PyObject * _wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plot3d(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, PLINT side)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_ConvertPtr(obj, pptr, type, flags)
SWIGINTERN PyObject * _wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plshades(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 PyObject * _wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgdidev_texinfo
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_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(const octave_value &ov, unsigned long *val)
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_f_int_p_double_p_double__void
SWIGINTERN int SWIG_AsVal_int(octave_value obj, int *val)
SWIGINTERN PyObject * _wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
SWIGINTERN PyObject * _wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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)
static const char * _wrap_plarc_texinfo
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plwind_texinfo
SWIGINTERN int SWIG_AsCharArray(octave_value obj, char *val, size_t size)
SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout)
SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own)
SWIGINTERN PyObject * _wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgdiori_texinfo
SWIGRUNTIME octave_value_list * SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov)
SWIGINTERN PyObject * _wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plstring3_texinfo
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plsfont_texinfo
SWIGINTERN PyObject * _wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_double[]
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
member_value_pair * find_member(const std::string &name, bool insert_if_not_found)
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type='"') const
void my_plcont2p(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg)
void my_plmesh(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt)
static const char * _wrap_plgcompression_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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)
static const char * _wrap_plgstrm_texinfo
static swig_type_info _swigt__p_char
static const char * _wrap_plscmap0a_texinfo
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
static const char * _wrap_plstyl_texinfo
static const char * _wrap_pleop_texinfo
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgcol0_texinfo
octave_value_list(* octave_func)(const octave_value_list &, int)
static const char * _wrap_plgchr_texinfo
static const char * _wrap_plbox_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_p_char[]
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
SWIGINTERN PyObject * _wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgfci_texinfo
SWIGINTERNINLINE octave_value SWIG_From_long(long value)
octave_function * fcnMapForm
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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)
static const char * _wrap_plgver_texinfo
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
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plsvect_texinfo
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
static const char * _wrap_plsfnam_texinfo
static const char * _wrap_plgfam_texinfo
octave_function * fcnCoordTrans
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)
swig_member_const_iterator swig_members_begin()
SWIGINTERN PyObject * _wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plspage_texinfo
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plstripc_texinfo
void assign(const std::string &name, const swig_octave_member *m)
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[]
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
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_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdimap(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)
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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)
virtual bool is_map() const
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plscmap1_range_texinfo
SWIGINTERN int SWIG_AsCharPtrAndSize(octave_value ov, char **cptr, size_t *psize, int *alloc)
#define SWIG_exception_fail(code, msg)
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_module_info * next
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_SetModule(clientdata, pointer)
static const char * _wrap_plvasp_texinfo
static const char * _wrap_plvsta_texinfo
SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov)
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_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
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)
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
SWIGINTERN PyObject * _wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
dim_vector dims(void) const
static swig_module_info swig_module
SWIGRUNTIME octave_value SWIG_ErrorType(int code)
swig_converter_func converter
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfill(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)
static const char * _wrap_plsdidev_texinfo
#define SWIGTYPE_p_unsigned_int
SWIGINTERN PyObject * _wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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
SWIGINTERN PyObject * _wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_DelNewMask(r)
static const char * _wrap_plend1_texinfo
std::pair< const swig_type_info *, cpp_ptr > type_ptr_pair
static const char * _wrap_plspal0_texinfo
static const char * _wrap_plsxax_texinfo
static const char * _wrap_plscmap1_texinfo
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
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
static const char * _wrap_plshades_texinfo
static void _cvt_to_double(FLOAT *arr, double *d_arr, unsigned n_el)
static const char * _wrap_plgvpd_texinfo
PLINT(* defined_func)(PLFLT, PLFLT)
std::string nameCoordTrans
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)
std::string swig_type_name() const
SWIGINTERN PyObject * _wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgdiplt_texinfo
static const char * _wrap_plvpor_texinfo
bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const
SWIGINTERN int SWIG_AsVal_double(const octave_value &ov, double *val)
static const char * _wrap_plflush_texinfo
SWIGINTERN PyObject * _wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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_plenv0(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)
void xform(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
#define SWIG_as_voidptrptr(a)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plprec_texinfo
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
SWIGINTERN PyObject * _wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_TYPE_TABLE_NAME
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)
dim_vector dims(void) const
static const char * _wrap_plptex_texinfo
SWIGINTERN PyObject * _wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_int
virtual bool is_string() const
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
SWIGINTERN PyObject * _wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plscmap0n_texinfo
SWIGINTERN PyObject * _wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plscolbg_texinfo
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type='"') const
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 PLFLT value(double n1, double n2, double hue)
SWIGINTERN PyObject * _wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plsdev_texinfo
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
#define SWIG_OCTAVE_BOUND_FUNC(func, args)
const swig_type_info ** base
static swig_type_info * swig_types[10]
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plot3dcl_texinfo
SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value &value)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
DEFUN_DLD(subclass, args, nargout, subclass_usage)
SWIGINTERN PyObject * _wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgzax_texinfo
static const char * _wrap_plenv_texinfo
struct swig_type_info *(* swig_dycast_func)(void **)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plscmap1l_texinfo
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiplt(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_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool load_ascii(std::istream &is)
SWIGINTERN PyObject * _wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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)
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
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
SWIGINTERN PyObject * _wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plerry_texinfo
SWIGINTERN PyObject * _wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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)
SWIGINTERN PyObject * _wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual string_vector map_keys() const
static swig_octave_class _wrap_class_PLGraphicsIn
virtual bool is_object() const
SWIGINTERN int SWIG_AsVal_long(const octave_value &ov, long *val)
SWIGINTERN PyObject * _wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIGRUNTIMEINLINE
SWIGINTERN PyObject * _wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_unsigned_int[]
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgcolbg_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_CAST_NEW_MEMORY
static const char * _wrap_plrandd_texinfo
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plspal1_texinfo
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_Octave_LinkGlobalValue(std::string name)
SWIGINTERN PyObject * _wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plmtex_texinfo
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
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plbop_texinfo
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_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plssym(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)
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
static const char * _wrap_pltext_texinfo
SWIGINTERN PyObject * _wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plxormod_texinfo
static const char * _wrap_plerrx_texinfo
static octave_base_value * default_numeric_conversion_function(const octave_base_value &a)
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
bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const
static const char * _wrap_plpoly3_texinfo
static const char * _wrap_plscolor_texinfo
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_plgspa(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
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plbin_texinfo
octave_base_value * empty_clone() const
SWIGINTERN PyObject * _wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const
virtual string_vector map_keys() const
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define swigreg_unary_op(name)
swig_member_const_iterator swig_members_end()
static const char * _wrap_plsesc_texinfo
virtual Octave_map map_value() const
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
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
bool copy(swig_type_info *outtype, void *ptr, size_t sz) const
static const char * _wrap_plvect_texinfo
static const char * _wrap_plw3d_texinfo
SWIGINTERN PyObject * _wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_unsigned_int
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plglevel_texinfo
const swig_octave_member * members
SWIGINTERN PyObject * _wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual double scalar_value(bool frc_str_conv=false) const
#define SWIG_RuntimeError
SWIGRUNTIME void SWIG_InstallOps(int tid)
SWIGINTERN PyObject * _wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllab(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
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
static const char * _wrap_plstart_texinfo
void testppchar(PLINT nlegend, const PLINT *opt_array, const char **text)
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool load_ascii(std::istream &is)
static const char * _wrap_plsurf3d_texinfo
static const char * _wrap_pllab_texinfo
SWIGINTERN PyObject * _wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
static const char * _wrap_plgpage_texinfo
octave_base_value * clone() const
struct swig_cast_info swig_cast_info
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const struct swig_octave_member swig_globals[]
SWIGINTERN PyObject * _wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void load_members(const swig_octave_class *c, member_map &out) const
static const char * _wrap_plsdiplz_texinfo
SWIGRUNTIME void SWIG_InitializeModule(void *clientdata)
std::pair< const swig_octave_member *, octave_value > member_value_pair
octave_value_ref(const octave_value_list &_ovl, int _j)
SWIGINTERN PyObject * _wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pl_setcontlabelformat
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_POINTER_DISOWN
static const char * _wrap_plcalc_world_texinfo
struct swig_cast_info * prev
virtual std::string string_value(bool force=false) const
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
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
swig_cast_info ** cast_initial
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plmeshc_texinfo
SWIGINTERN PyObject * _wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plmkstrm_texinfo
static swig_type_info * swig_type_initial[]
#define SWIG_DEFUN(cname, wname, doc)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plrgbhls_texinfo
static const char * _wrap_plpath_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(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)
SWIGRUNTIME octave_swig_type * swig_value_deref(const octave_base_value &ov)
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
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)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
static const char * _wrap_plmap_texinfo
const swig_type_info * construct_type
static const char * _wrap_pllsty_texinfo
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_OCTAVE_PREREQ(major, minor, patch)
static const char * _wrap_pllegend_texinfo
static const char * _wrap_plptex3_texinfo
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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
static const char * _wrap_plsdiori_texinfo
swig_type_info ** type_initial
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plend_texinfo
static const char * _wrap_plhlsrgb_texinfo
SWIGINTERN PyObject * _wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plscol0_texinfo
SWIGINTERN PyObject * _wrap_plmeshc(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_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
static const char * _wrap_plmaptex_texinfo
SWIGINTERN PyObject * _wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plssub(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_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_type_info swig_type_info
octave_value_list member_deref(member_value_pair *m, const octave_value_list &args)
static swig_octave_member swig_PLGraphicsIn_members[]
static const char * _wrap_plmapfill_texinfo
static const char * _wrap_plscmap1la_texinfo
static const char * _wrap_pl_setcontlabelparam_texinfo
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plfamadv_texinfo
SWIGINTERN PyObject * _wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
static const char * _wrap_plgxax_texinfo
static const char * _wrap_plspause_texinfo
static const char * _wrap_plmapstring_texinfo
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plctime_texinfo
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plsvpa_texinfo
SWIGINTERN PyObject * _wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
static swig_cast_info _swigc__p_PLGraphicsIn[]
SWIGINTERN PyObject * _wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plvpas_texinfo
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
SWIGINTERN PyObject * _wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout)
SWIGINTERN PyObject * _wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERNINLINE octave_value SWIG_From_int(int value)
static const char * _wrap_plconfigtime_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN size_t SWIG_strnlen(const char *s, size_t maxlen)
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_long(unsigned long value)
static const char * _wrap_plot3dc_texinfo
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
DEFINE_OCTAVE_ALLOCATOR(octave_swig_ref)
void __swig_atexit__(void)
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_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
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)