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
181 #if !defined(_SWIG_OCTAVE_OCTHEADERS_HPP)
182 #define _SWIG_OCTAVE_OCTHEADERS_HPP
189 #include <functional>
196 #include <octave/oct.h>
197 #include <octave/version.h>
201 #define SWIG_OCTAVE_PREREQ(major, minor, patch) \
202 ( (OCTAVE_MAJOR_VERSION<<16) + (OCTAVE_MINOR_VERSION<<8) + (OCTAVE_PATCH_VERSION + 0) >= ((major)<<16) + ((minor)<<8) + (patch) )
205 #if !defined(OCTAVE_MAJOR_VERSION)
207 # if !defined(OCTAVE_API_VERSION_NUMBER)
211 # include <octave/ov.h>
212 # if defined(octave_ov_h)
213 # define OCTAVE_MAJOR_VERSION 3
214 # define OCTAVE_MINOR_VERSION 8
215 # define OCTAVE_PATCH_VERSION 0
219 # define ComplexLU __ignore
220 # include <octave/CmplxLU.h>
222 # if defined(octave_Complex_LU_h)
225 # define OCTAVE_MAJOR_VERSION 3
226 # define OCTAVE_MINOR_VERSION 1
227 # define OCTAVE_PATCH_VERSION 99
232 # define OCTAVE_MAJOR_VERSION 3
233 # define OCTAVE_MINOR_VERSION 2
234 # define OCTAVE_PATCH_VERSION 0
236 # endif // defined(octave_Complex_LU_h)
238 # endif // defined(octave_ov_h)
242 # elif OCTAVE_API_VERSION_NUMBER >= 48
243 # define OCTAVE_MAJOR_VERSION 3
244 # define OCTAVE_MINOR_VERSION 6
245 # define OCTAVE_PATCH_VERSION 0
247 # elif OCTAVE_API_VERSION_NUMBER >= 45
248 # define OCTAVE_MAJOR_VERSION 3
249 # define OCTAVE_MINOR_VERSION 4
250 # define OCTAVE_PATCH_VERSION 1
252 # elif OCTAVE_API_VERSION_NUMBER >= 42
253 # define OCTAVE_MAJOR_VERSION 3
254 # define OCTAVE_MINOR_VERSION 3
255 # define OCTAVE_PATCH_VERSION 54
257 # elif OCTAVE_API_VERSION_NUMBER >= 41
258 # define OCTAVE_MAJOR_VERSION 3
259 # define OCTAVE_MINOR_VERSION 3
260 # define OCTAVE_PATCH_VERSION 53
262 # elif OCTAVE_API_VERSION_NUMBER >= 40
263 # define OCTAVE_MAJOR_VERSION 3
264 # define OCTAVE_MINOR_VERSION 3
265 # define OCTAVE_PATCH_VERSION 52
267 # elif OCTAVE_API_VERSION_NUMBER >= 39
268 # define OCTAVE_MAJOR_VERSION 3
269 # define OCTAVE_MINOR_VERSION 3
270 # define OCTAVE_PATCH_VERSION 51
272 # else // OCTAVE_API_VERSION_NUMBER == 38
273 # define OCTAVE_MAJOR_VERSION 3
274 # define OCTAVE_MINOR_VERSION 3
275 # define OCTAVE_PATCH_VERSION 50
277 # endif // !defined(OCTAVE_API_VERSION_NUMBER)
279 #endif // !defined(OCTAVE_MAJOR_VERSION)
282 #include <octave/Cell.h>
283 #include <octave/dynamic-ld.h>
284 #include <octave/oct-env.h>
285 #include <octave/oct-map.h>
286 #include <octave/ov-scalar.h>
287 #include <octave/ov-fcn-handle.h>
288 #include <octave/parse.h>
289 #if SWIG_OCTAVE_PREREQ(4,2,0)
290 #include <octave/interpreter.h>
292 #include <octave/toplev.h>
294 #include <octave/unwind-prot.h>
295 #if SWIG_OCTAVE_PREREQ(4,2,0)
296 #include <octave/call-stack.h>
299 #endif // !defined(_SWIG_OCTAVE_OCTHEADERS_HPP)
310 #define SWIG_RUNTIME_VERSION "4"
313 #ifdef SWIG_TYPE_TABLE
314 # define SWIG_QUOTE_STRING(x) #x
315 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
316 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
318 # define SWIG_TYPE_TABLE_NAME
331 # define SWIGRUNTIME SWIGINTERN
334 #ifndef SWIGRUNTIMEINLINE
335 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
339 #ifndef SWIG_BUFFER_SIZE
340 # define SWIG_BUFFER_SIZE 1024
344 #define SWIG_POINTER_DISOWN 0x1
345 #define SWIG_CAST_NEW_MEMORY 0x2
346 #define SWIG_POINTER_NO_NULL 0x4
349 #define SWIG_POINTER_OWN 0x1
432 #define SWIG_ERROR (-1)
433 #define SWIG_IsOK(r) (r >= 0)
434 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
437 #define SWIG_CASTRANKLIMIT (1 << 8)
439 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
441 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
443 #define SWIG_BADOBJ (SWIG_ERROR)
444 #define SWIG_OLDOBJ (SWIG_OK)
445 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
446 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
448 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
449 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
450 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
451 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
452 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
453 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
456 #if defined(SWIG_CASTRANK_MODE)
457 # ifndef SWIG_TypeRank
458 # define SWIG_TypeRank unsigned long
460 # ifndef SWIG_MAXCASTRANK
461 # define SWIG_MAXCASTRANK (2)
463 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
464 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
469 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
472 # define SWIG_AddCast(r) (r)
473 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
483 typedef void *(*swig_converter_func)(
void *,
int *);
525 const char *f2,
const char *l2) {
526 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
527 while ((*f1 ==
' ') && (f1 != l1)) ++f1;
528 while ((*f2 ==
' ') && (f2 != l2)) ++f2;
529 if (*f1 != *f2)
return (*f1 > *f2) ? 1 : -1;
531 return (
int)((l1 - f1) - (l2 - f2));
541 const char* te = tb + strlen(tb);
543 while (equiv != 0 && *ne) {
544 for (nb = ne; *ne; ++ne) {
545 if (*ne ==
'|')
break;
570 if (strcmp(iter->
type->
name, c) == 0) {
571 if (iter == ty->
cast)
597 if (iter->
type == from) {
598 if (iter == ty->
cast)
630 if (!ty || !ty->
dcast)
return ty;
631 while (ty && (ty->
dcast)) {
632 ty = (*ty->
dcast)(ptr);
656 if (!type)
return NULL;
657 if (type->
str != NULL) {
658 const char *last_name = type->
str;
660 for (s = type->
str; *s; s++)
661 if (*s ==
'|') last_name = s+1;
709 size_t r = iter->
size - 1;
712 size_t i = (l + r) >> 1;
713 const char *iname = iter->
types[i]->
name;
715 int compare = strcmp(
name, iname);
717 return iter->
types[i];
718 }
else if (compare < 0) {
724 }
else if (compare > 0) {
733 }
while (iter != end);
760 for (; i < iter->
size; ++i) {
762 return iter->
types[i];
765 }
while (iter != end);
777 static const char hex[17] =
"0123456789abcdef";
778 const unsigned char *u = (
unsigned char *) ptr;
779 const unsigned char *eu = u + sz;
780 for (; u != eu; ++u) {
781 unsigned char uu = *u;
782 *(c++) = hex[(uu & 0xf0) >> 4];
783 *(c++) = hex[uu & 0xf];
793 unsigned char *u = (
unsigned char *) ptr;
794 const unsigned char *eu = u + sz;
795 for (; u != eu; ++u) {
798 if ((d >=
'0') && (d <=
'9'))
799 uu = (
unsigned char)((d -
'0') << 4);
800 else if ((d >=
'a') && (d <=
'f'))
801 uu = (
unsigned char)((d - (
'a'-10)) << 4);
805 if ((d >=
'0') && (d <=
'9'))
806 uu |= (
unsigned char)(d -
'0');
807 else if ((d >=
'a') && (d <=
'f'))
808 uu |= (
unsigned char)(d - (
'a'-10));
822 if ((2*
sizeof(
void *) + 2) > bsz)
return 0;
825 if (strlen(
name) + 1 > (bsz - (r - buff)))
return 0;
833 if (strcmp(c,
"NULL") == 0) {
846 size_t lname = (
name ? strlen(
name) : 0);
847 if ((2*sz + 2 + lname) > bsz)
return 0;
851 strncpy(r,
name,lname+1);
861 if (strcmp(c,
"NULL") == 0) {
876 #define SWIG_UnknownError -1
877 #define SWIG_IOError -2
878 #define SWIG_RuntimeError -3
879 #define SWIG_IndexError -4
880 #define SWIG_TypeError -5
881 #define SWIG_DivisionByZero -6
882 #define SWIG_OverflowError -7
883 #define SWIG_SyntaxError -8
884 #define SWIG_ValueError -9
885 #define SWIG_SystemError -10
886 #define SWIG_AttributeError -11
887 #define SWIG_MemoryError -12
888 #define SWIG_NullReferenceError -13
892 #if !SWIG_OCTAVE_PREREQ(3,2,0)
893 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
895 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
899 if (num_args > max_args && !varargs)
900 error(
"function %s takes at most %i arguments", func_name, max_args);
901 else if (num_args < min_args)
902 error(
"function %s requires at least %i arguments", func_name, min_args);
916 return "SWIG_MemoryError";
918 return "SWIG_IOError";
920 return "SWIG_RuntimeError";
922 return "SWIG_IndexError";
924 return "SWIG_TypeError";
926 return "SWIG_DivisionByZero";
928 return "SWIG_OverflowError";
930 return "SWIG_SyntaxError";
932 return "SWIG_ValueError";
934 return "SWIG_SystemError";
936 return "SWIG_AttributeError";
938 return "SWIG unknown error";
944 r +=
" (" + type.string_value() +
")";
945 error(
"%s", r.c_str());
946 return octave_value(r);
949 #define SWIG_fail goto fail
951 #define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
952 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
953 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
954 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
955 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
956 #define swig_owntype int
958 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
959 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
961 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
962 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
964 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
965 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
967 #define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
968 #define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
969 #define SWIG_MODULE_CLIENTDATA_TYPE void*
971 #define Octave_Error_Occurred() 0
972 #define SWIG_Octave_AddErrorMsg(msg) {;}
978 #define SWIG_POINTER_EXCEPTION 0
979 #define SWIG_arg_fail(arg) 0
983 typedef octave_value_list(*
octave_func) (
const octave_value_list &, int);
988 #ifdef SWIG_DIRECTORS
992 typedef std::map < void *, Director * > rtdir_map;
1009 #ifdef SWIG_DIRECTORS
1010 SWIGRUNTIME void swig_acquire_ownership(
void *vptr);
1011 SWIGRUNTIME void swig_acquire_ownership_array(
void *vptr);
1012 SWIGRUNTIME void swig_acquire_ownership_obj(
void *vptr,
int own);
1041 #if SWIG_OCTAVE_PREREQ(4,4,0)
1044 #define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(new octave_swig_bound_func(func, args))
1045 class octave_swig_bound_func :
public octave_function {
1048 octave_swig_bound_func(
void) : octave_function(), method(0), first_args()
1051 octave_swig_bound_func(octave_function* _method, octave_value_list _first_args)
1052 : octave_function(
"",
""), method(_method), first_args(_first_args)
1055 octave_swig_bound_func(
const octave_swig_bound_func& f) =
delete;
1057 octave_swig_bound_func& operator= (
const octave_swig_bound_func& f) =
delete;
1059 ~octave_swig_bound_func(
void) =
default;
1061 bool is_function(
void)
const {
return true; }
1063 octave_function* function_value(
bool =
false) {
return this; }
1065 octave_value_list call(octave::tree_evaluator& tw,
int nargout = 0,
const octave_value_list& args = octave_value_list()) {
1066 octave_value_list all_args;
1067 all_args.append(first_args);
1068 all_args.append(args);
1069 return method->call(tw, nargout, all_args);
1072 octave_value subsref(
const std::string &ops,
const std::list < octave_value_list > &idx) {
1073 octave_value_list ovl = subsref(ops, idx, 1);
1074 return ovl.length() ? ovl(0) : octave_value();
1077 octave_value_list subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout) {
1078 assert(ops.size() > 0);
1079 assert(ops.size() == idx.size());
1081 error(
"invalid function call");
1082 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1083 return call(tw, nargout, *idx.begin());
1088 octave_function* method;
1089 octave_value_list first_args;
1091 std::set<std::string> dispatch_classes;
1095 #define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(func)
1130 if (m->name ==
name)
1152 for (
unsigned int j = 0; j <
types.size(); ++j)
1154 return &
members.insert(std::make_pair(
name, std::make_pair(m, octave_value()))).first->second;
1155 if (!insert_if_not_found)
1162 for (
unsigned int j = 0; j <
types.size(); ++j) {
1163 assert(
types[j].first->clientdata);
1166 return types[j].first;
1191 if (out.find(m->name) == out.end())
1192 out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1212 for (
unsigned int j = 0; j <
types.size(); ++j)
1213 if (
types[j].first->clientdata)
1218 if (m->second.is_defined())
1219 return m->second.subsref(
"(", std::list < octave_value_list > (1, args), nargout);
1220 else if (m->first && m->first->method)
1221 return m->first->method(args, nargout);
1222 error(
"member not defined or not invocable");
1223 return octave_value_list();
1229 if (!m || m->first->is_static() || m->first->is_global())
1231 octave_value_list args;
1233 octave_value_list argout(nc_this->
member_invoke(m, args, 1));
1234 if (argout.length() < 1)
1240 bool dispatch_binary_op(
const std::string &symbol,
const octave_base_value &rhs, octave_value &ret)
const {
1243 if (!m || m->first->is_static() || m->first->is_global())
1245 octave_value_list args;
1248 octave_value_list argout(nc_this->
member_invoke(m, args, 1));
1249 if (argout.length() < 1)
1255 bool dispatch_index_op(
const std::string &symbol,
const octave_value_list &rhs, octave_value_list &ret)
const {
1258 if (!m || m->first->is_static() || m->first->is_global())
1260 octave_value_list args;
1263 octave_value_list argout(nc_this->
member_invoke(m, args, 1));
1264 if (argout.length() >= 1)
1270 if (m->second.is_defined()) {
1271 if (m->second.is_function() || m->second.is_function_handle()) {
1276 }
else if (m->first) {
1277 if (m->first->get_method)
1278 return m->first->get_method(args, 1);
1279 else if (m->first->method)
1282 error(
"undefined member");
1283 return octave_value_list();
1288 return octave_value((octave_base_value *) &x);
1296 bool _always_static =
false)
1300 types.push_back(std::make_pair(_type, _ptr));
1301 #ifdef SWIG_DIRECTORS
1303 Swig::Director *d = Swig::get_rtdir(_ptr);
1305 Swig::swig_director_set_self(d,
this);
1313 for (
unsigned int j = 0; j <
types.size(); ++j) {
1314 if (!
types[j].first || !
types[j].first->clientdata)
1322 #ifdef SWIG_DIRECTORS
1323 for (
unsigned int j = 0; j <
types.size(); ++j)
1324 Swig::erase_rtdir(
types[j].second.ptr);
1331 return dim_vector(1,1);
1334 #if SWIG_OCTAVE_PREREQ(4,4,0)
1337 if (out.is_cell()) {
1339 const Cell & c=out.cell_value();
1340 int ndim = c.rows();
1341 if (ndim==1 && c.columns()!=1) ndim = c.columns();
1344 d.resize(ndim < 2 ? 2 : ndim);
1348 for (
int k=0;k<ndim;k++) {
1349 const octave_value& obj = c(k);
1350 d.elem(k) = obj.int_value();
1353 if (error_state)
return dim_vector(1,1);
1356 #if SWIG_OCTAVE_PREREQ(4,4,0)
1357 }
else if (out.is_matrix_type() || out.isnumeric() ) {
1359 }
else if (out.is_matrix_type() || out.is_numeric_type() ) {
1361 if (out.rows()==1 || out.columns()==1) {
1362 Array<int> a = out.int_vector_value();
1363 if (error_state)
return dim_vector(1,1);
1365 d.resize(a.numel() < 2 ? 2 : a.numel());
1367 for (
int k=0;k<a.numel();k++) {
1372 return dim_vector(1,1);
1375 return dim_vector(1,1);
1395 return (
size_t)
this;
1396 return (
size_t)
types[0].second.ptr;
1401 if (!
types[0].first->clientdata)
1411 for (
unsigned int j = 0; j <
types.size(); ++j) {
1414 if (
types[j].first->clientdata) {
1418 ret +=
types[j].first->name;
1425 for (
unsigned int j = 0; j < rhs.
types.size(); ++j) {
1426 assert(!rhs.
types[j].second.destroyed);
1427 #ifdef SWIG_DIRECTORS
1428 Swig::Director *d = Swig::get_rtdir(rhs.
types[j].second.ptr);
1430 Swig::swig_director_set_self(d,
this);
1435 #if SWIG_OCTAVE_PREREQ(4,4,0)
1453 if (!type &&
types.size()) {
1455 *vptr =
types[0].second.ptr;
1458 for (
unsigned int j = 0; j <
types.size(); ++j)
1459 if (type ==
types[j].first) {
1461 *vptr =
types[j].second.ptr;
1464 for (
unsigned int j = 0; j <
types.size(); ++j) {
1487 #ifdef SWIG_DIRECTORS
1488 void director_destroyed(Swig::Director *d) {
1490 for (
unsigned int j = 0; j <
types.size(); ++j) {
1491 Swig::Director *dj = Swig::get_rtdir(
types[j].second.ptr);
1493 types[j].second.destroyed =
true;
1506 members[
name] = std::make_pair(m, octave_value());
1529 virtual octave_value
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx) {
1530 octave_value_list ovl =
subsref(ops, idx, 1);
1531 return ovl.length()? ovl(0) : octave_value();
1534 virtual octave_value_list
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout) {
1535 assert(ops.size() > 0);
1536 assert(ops.size() == idx.size());
1538 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1540 octave_value_list sub_ovl;
1547 error(
"cannot create instance");
1548 return octave_value_list();
1550 octave_value_list args;
1553 args.append(*idx_it++);
1558 else if (ops[skip] ==
'.') {
1559 std::string subname;
1562 octave_value_list subname_ovl(*idx_it++);
1564 assert(subname_ovl.length() == 1 && subname_ovl(0).
is_string());
1565 subname = subname_ovl(0).string_value();
1568 if (!next_base || skip >= (
int) ops.size() || ops[skip] !=
'.')
1574 if (!base || !(m->first =
find_member(base, subname)))
1577 error(
"member not found");
1578 return octave_value_list();
1581 octave_value_list args;
1583 (!m->first || (!m->first->is_static() && !m->first->is_global())))
1585 if (skip < (
int) ops.size() && ops[skip] ==
'(' &&
1586 ((m->first && m->first->method) || m->second.is_function() ||
1587 m->second.is_function_handle())) {
1588 args.append(*idx_it++);
1597 if (ops[skip] ==
'(' || ops[skip] ==
'{') {
1598 const char *op_name = ops[skip] ==
'(' ?
"__paren__" :
"__brace__";
1599 octave_value_list args;
1600 args.append(*idx_it++);
1603 error(
"error evaluating index operator");
1604 return octave_value_list();
1607 error(
"unsupported subsref");
1608 return octave_value_list();
1612 if (skip >= (
int) ops.size())
1614 if (sub_ovl.length() < 1) {
1615 error(
"bad subs ref");
1616 return octave_value_list();
1618 return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1621 octave_value
subsasgn(
const std::string &ops,
const std::list < octave_value_list > &idx,
const octave_value &rhs) {
1622 assert(ops.size() > 0);
1623 assert(ops.size() == idx.size());
1625 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1628 if (ops.size() > 1) {
1629 std::list < octave_value_list >::const_iterator last = idx.end();
1631 std::list < octave_value_list > next_idx(idx.begin(), last);
1632 octave_value next_ov =
subsref(ops.substr(0, ops.size() - 1), next_idx);
1633 next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1636 else if (ops[skip] ==
'(' || ops[skip] ==
'{') {
1637 const char *op_name = ops[skip] ==
'(' ?
"__paren_asgn__" :
"__brace_asgn__";
1640 octave_value_list args;
1642 args.append(*idx_it);
1646 error(
"%s member not found", op_name);
1649 else if (ops[skip] ==
'.') {
1650 octave_value_list subname_ovl(*idx_it++);
1652 assert(subname_ovl.length() == 1 &&subname_ovl(0).
is_string());
1653 std::string subname = subname_ovl(0).string_value();
1656 if (!m->first || !m->first->set_method) {
1659 }
else if (m->first->set_method) {
1660 octave_value_list args;
1661 if (!m->first->is_static() && !m->first->is_global())
1664 m->first->set_method(args, 1);
1666 error(
"member not assignable");
1668 error(
"unsupported subsasgn");
1685 error(
"__str__ method not defined");
1686 return std::string();
1688 if (!ret.is_string()) {
1689 error(
"__str__ method did not return a string");
1690 return std::string();
1692 return ret.string_value();
1698 error(
"__float__ method not defined");
1700 return ret.scalar_value();
1703 #if SWIG_OCTAVE_PREREQ(4,2,0)
1704 virtual octave_value as_double(
void)
const {
1707 error(
"__float__ method not defined");
1709 return ret.as_double();
1712 virtual octave_value as_single(
void)
const {
1715 error(
"__float__ method not defined");
1717 return ret.as_single();
1721 #if SWIG_OCTAVE_PREREQ(3,8,0)
1722 virtual octave_value map(octave_base_value::unary_mapper_t umap)
const {
1723 const std::string opname = std::string(
"__") + octave_base_value::get_umap_name(umap) + std::string(
"__");
1726 error(
"%s", (opname + std::string(
" method not found")).c_str());
1727 return octave_value();
1733 #if SWIG_OCTAVE_PREREQ(3,3,52)
1735 return octave_map();
1739 return Octave_map();
1747 string_vector keys(tmp.size());
1749 for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1750 keys(k++) = it->first;
1768 oct_mach_info::float_format fmt) {
1772 #if defined (HAVE_HDF5)
1773 # if SWIG_OCTAVE_PREREQ(4,0,0)
1775 save_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool save_as_floats) {
1780 load_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool have_h5giterate_bug) {
1785 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats) {
1790 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug) {
1796 virtual octave_value
convert_to_str(
bool pad =
false,
bool force =
false,
char type =
'"')
const {
1804 static bool dispatch_global_op(
const std::string &symbol,
const octave_value_list &args, octave_value &ret) {
1808 octave_function *fcn = is_valid_function(symbol, std::string(),
false);
1811 #if SWIG_OCTAVE_PREREQ(4,4,0)
1812 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1813 octave_value_list retval = fcn->call(tw, 1, args);
1814 if (retval.length() == 1)
1817 ret = fcn->do_multi_index_op(1, args)(0);
1827 if (ost->
dispatch_unary_op(std::string(
"__") + op_name + std::string(
"__"), ret))
1830 octave_value_list args;
1835 error(
"could not dispatch unary operator");
1836 return octave_value();
1839 static octave_value
dispatch_binary_op(
const octave_base_value &lhs,
const octave_base_value &rhs,
const char *op_name) {
1844 if (lhs_ost && lhs_ost->
dispatch_binary_op(std::string(
"__") + op_name + std::string(
"__"), rhs, ret))
1847 if (strlen(op_name) == 2 && (op_name[1] ==
't' || op_name[1] ==
'e')) {
1848 if (op_name[0] ==
'l' && rhs_ost->
dispatch_binary_op(std::string(
"__g") + op_name[1] + std::string(
"__"), lhs, ret))
1850 if (op_name[0] ==
'g' && rhs_ost->
dispatch_binary_op(std::string(
"__l") + op_name[1] + std::string(
"__"), lhs, ret))
1853 if (rhs_ost->
dispatch_binary_op(std::string(
"__r") + op_name + std::string(
"__"), lhs, ret))
1858 octave_value_list args;
1889 error(
"could not dispatch binary operator");
1890 return octave_value();
1893 #if SWIG_OCTAVE_PREREQ(4,0,0)
1894 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
1896 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
1908 os <<
"{"; newline(os);
1909 increment_indent_level();
1910 for (
unsigned int j = 0; j <
types.size(); ++j) {
1912 if (
types[j].first->clientdata) {
1914 os << c->
name <<
", ptr = " <<
types[j].second.ptr; newline(os);
1916 os <<
types[j].first->name <<
", ptr = " <<
types[j].second.ptr; newline(os);
1919 for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
1921 if (it->second.first) {
1922 const char *objtype = it->second.first->method ?
"method" :
"variable";
1923 const char *modifier = (it->second.first->flags &1) ?
"static " : (it->second.first->flags &2) ?
"global " :
"";
1924 os << it->second.first->name <<
" (" << modifier << objtype <<
")"; newline(os);
1925 assert(it->second.first->name == it->first);
1927 os << it->first; newline(os);
1930 decrement_indent_level();
1932 os <<
"}"; newline(os);
1956 t_id = octave_swig_ref::static_type_id();
1961 {
if (ptr) ptr->
decref(); }
1973 {
return ptr->
dims(); }
1979 {
return ptr->
is_map(); }
1981 virtual octave_value
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx)
1982 {
return ptr->
subsref(ops, idx); }
1984 virtual octave_value_list
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout)
1985 {
return ptr->
subsref(ops, idx, nargout); }
1987 octave_value
subsasgn(
const std::string &ops,
const std::list < octave_value_list > &idx,
const octave_value &rhs)
1988 {
return ptr->
subsasgn(ops, idx, rhs); }
2002 #if SWIG_OCTAVE_PREREQ(4,2,0)
2003 virtual octave_value as_double(
void)
const
2004 {
return ptr->as_double(); }
2006 virtual octave_value as_single(
void)
const
2007 {
return ptr->as_single(); }
2010 #if SWIG_OCTAVE_PREREQ(3,8,0)
2011 virtual octave_value map(octave_base_value::unary_mapper_t umap)
const
2012 {
return ptr->map(umap); }
2015 #if SWIG_OCTAVE_PREREQ(3,3,52)
2036 oct_mach_info::float_format fmt)
2039 #if defined (HAVE_HDF5)
2040 # if SWIG_OCTAVE_PREREQ(4,0,0)
2042 save_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool save_as_floats)
2043 {
return ptr->save_hdf5(loc_id,
name, save_as_floats); }
2046 load_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool have_h5giterate_bug)
2047 {
return ptr->load_hdf5(loc_id,
name, have_h5giterate_bug); }
2050 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats)
2051 {
return ptr->save_hdf5(loc_id,
name, save_as_floats); }
2054 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug)
2055 {
return ptr->load_hdf5(loc_id,
name, have_h5giterate_bug); }
2059 virtual octave_value
convert_to_str(
bool pad =
false,
bool force =
false,
char type =
'"')
const
2065 #if SWIG_OCTAVE_PREREQ(4,0,0)
2066 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
2068 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
2070 {
return ptr->
print(os, pr_as_read_syntax); }
2073 return octave_base_value::type_conv_info (default_numeric_conversion_function,
2074 octave_scalar::static_type_id ());
2083 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2088 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2099 : type(_type),
buf((const char*)_buf, (const char*)_buf + _buf_len)
2103 t_id = octave_swig_packed::static_type_id();
2108 if (outtype && outtype != type)
2110 assert(sz <=
buf.size());
2111 std::copy(
buf.begin(),
buf.begin()+sz, (
char*)ptr);
2127 #if SWIG_OCTAVE_PREREQ(4,0,0)
2128 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
2130 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
2134 os <<
"swig packed type: name = " << (type ? type->
name : std::string()) <<
", len = " <<
buf.size(); newline(os);
2151 oct_mach_info::float_format fmt) {
2155 #if defined (HAVE_HDF5)
2156 # if SWIG_OCTAVE_PREREQ(4,0,0)
2158 save_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool save_as_floats) {
2163 load_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool have_h5giterate_bug) {
2168 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats) {
2173 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug) {
2180 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2185 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2191 error(
"attempt to set immutable member variable");
2192 return octave_value_list();
2200 :ovl(_ovl), j(_j) { }
2202 operator octave_value()
const {
2225 && ov.rows() == 1 && ov.columns() == 1)
2226 ov = ov.cell_value()(0);
2231 if (ov.type_id() != octave_swig_ref::static_type_id())
2240 #define swig_unary_op(name) \
2241 SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
2242 return octave_swig_type::dispatch_unary_op(x,#name); \
2244 #define swig_binary_op(name) \
2245 SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
2246 return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
2248 #if SWIG_OCTAVE_PREREQ(4,4,0)
2249 #define swigreg_unary_op(name) \
2250 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2251 typeinfo.register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2253 #define swigreg_unary_op(name) \
2254 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2255 octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2257 #if SWIG_OCTAVE_PREREQ(4,4,0)
2258 #define swigreg_binary_op(name) \
2259 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2260 typeinfo.register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2262 #define swigreg_binary_op(name) \
2263 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2264 octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2281 #if !SWIG_OCTAVE_PREREQ(4,2,0)
2299 #if SWIG_OCTAVE_PREREQ(4,4,0)
2300 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2311 #if SWIG_OCTAVE_PREREQ(4,4,0)
2312 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2320 #if !SWIG_OCTAVE_PREREQ(4,2,0)
2344 for (
int j = 0; j < tid; ++j) {
2353 #ifdef SWIG_DIRECTORS
2354 Swig::Director *d = Swig::get_rtdir(ptr);
2355 if (d && Swig::swig_director_get_self(d))
2356 return Swig::swig_director_get_self(d)->as_value();
2368 && ov.rows() == 1 && ov.columns() == 1)
2369 ov = ov.cell_value()(0);
2370 if (!ov.is_defined() ||
2371 (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2376 if (ov.type_id() != octave_swig_ref::static_type_id())
2380 return ost->
cast(ptr, type,
own, flags);
2388 if (!ov.is_defined())
2390 if (ov.type_id() != octave_swig_packed::static_type_id())
2401 #if SWIG_OCTAVE_PREREQ(4,4,0)
2402 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2403 return symtab.global_varval(
name);
2405 return get_global_value(
name,
true);
2410 #if SWIG_OCTAVE_PREREQ(4,4,0)
2411 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2419 #if SWIG_OCTAVE_PREREQ(4,4,0)
2420 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2421 octave::symbol_scope symscope = octave::interpreter::the_interpreter()->get_current_scope();
2422 symscope.assign(
name, symtab.global_varval(
name));
2423 symscope.mark_global(
name);
2425 #if !SWIG_OCTAVE_PREREQ(3,2,0)
2426 link_to_global_variable(curr_sym_tab->lookup(
name,
true));
2428 #if !SWIG_OCTAVE_PREREQ(3,8,0)
2429 symbol_table::varref(
name);
2431 symbol_table::mark_global(
name);
2438 if (!ov.is_defined() ||
2439 ov.type_id() != octave_swig_packed::static_type_id())
2455 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2457 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2463 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2464 #define SWIGTYPE_p_char swig_types[1]
2465 #define SWIGTYPE_p_double swig_types[2]
2466 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2467 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2468 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2469 #define SWIGTYPE_p_int swig_types[6]
2470 #define SWIGTYPE_p_p_char swig_types[7]
2471 #define SWIGTYPE_p_unsigned_int swig_types[8]
2474 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2475 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2480 #define SWIGVERSION 0x040002
2481 #define SWIG_VERSION SWIGVERSION
2484 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2485 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2488 #include <stdexcept>
2498 #ifdef OCTAVE_EXPORT
2499 #if defined ( __GNUC__ ) && __GNUC__ > 3
2500 #undef OCTAVE_EXPORT
2501 #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2519 inline int max(
int a,
int b )
2521 return a >= b ? a : b;
2523 inline int min(
int a,
int b )
2525 return a >= b ? a : b;
2539 return max( o_obj.rows(), 1 ) *
max( o_obj.columns(), 1 );
2551 if (
max( o_obj.columns(), 1 ) > 1 )
2556 else if (
max( o_obj.rows(), 1 ) > 1 )
2566 _dim(
const octave_value &o_obj,
int dim_idx )
2569 return max( o_obj.rows(), 0 );
2573 else if ( dim_idx == 1 )
2574 return max( o_obj.columns(), 0 );
2587 template <
class FLOAT>
2591 while ( n_el-- > 0 )
2592 *out_arr++ = (FLOAT) ( *in_arr++ );
2611 template <
class FLOAT>
2615 while ( n_el-- > 0 )
2616 *d_arr++ = double(*arr++);
2647 octave_value_list functionArguments;
2648 octave_value_list retval;
2655 for ( i = 0; i < n; i++ )
2661 functionArguments( 0 ) = xin;
2662 functionArguments( 1 ) = yin;
2665 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2666 retval = octave::feval(
fcnMapForm, functionArguments, 1 );
2668 retval = feval(
fcnMapForm, functionArguments, 1 );
2671 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2672 retval = octave::feval(
nameMapForm, functionArguments, 1 );
2674 retval = feval(
nameMapForm, functionArguments, 1 );
2677 if ( retval.length() >= 2 )
2679 xout = retval( 0 ).matrix_value();
2680 yout = retval( 1 ).matrix_value();
2682 for ( i = 0; i < n; i++ )
2684 x[i] = xout( i, 0 );
2685 y[i] = yout( i, 0 );
2697 octave_value_list functionArguments;
2698 octave_value_list retval;
2700 Matrix inAxis( 1, 1 );
2701 Matrix inValue( 1, 1 );
2702 inAxis( 0, 0 ) = axis;
2703 inValue( 0, 0 ) =
value;
2705 functionArguments( 0 ) = inAxis;
2706 functionArguments( 1 ) = inValue;
2709 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2710 retval = octave::feval(
fcnLabelFunc, functionArguments, 1 );
2715 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2716 retval = octave::feval(
nameLabelFunc, functionArguments, 1 );
2721 strncpy( label, retval( 0 ).
string_value().c_str(), length );
2731 octave_value_list functionArguments;
2732 octave_value_list retval;
2742 functionArguments( 0 ) = xin;
2743 functionArguments( 1 ) = yin;
2746 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2747 retval = octave::feval(
fcnCoordTrans, functionArguments, 1 );
2752 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2758 if ( retval.length() >= 2 )
2760 xout = retval( 0 ).matrix_value();
2761 yout = retval( 1 ).matrix_value();
2772 printf(
"nlegend =%d\n", nlegend );
2773 for ( i = 0; i < nlegend; i++ )
2775 printf(
"opt_array[%d] =%d\n", i, opt_array[i] );
2776 printf(
"strlen(text[%d]) =%d\n", i, (
int) strlen(
text[i] ) );
2777 printf(
"text[%d] =%s\n", i,
text[i] );
2783 #if !defined(SWIG_NO_LLONG_MAX)
2784 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2785 # define LLONG_MAX __LONG_LONG_MAX__
2786 # define LLONG_MIN (-LLONG_MAX - 1LL)
2787 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2794 if (!ov.is_scalar_type())
2796 if (ov.is_complex_scalar())
2798 if (ov.is_double_type()||ov.is_single_type()) {
2799 double v=ov.double_value();
2804 *val = ov.long_value();
2815 if ((v < INT_MIN || v > INT_MAX)) {
2818 if (val) *val =
static_cast< int >(v);
2825 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 )
2833 *pX = gin.
pX; *pY = gin.
pY; *dX = gin.
dX; *dY = gin.
dY; *wX = gin.
wX; *wY = gin.
wY;
2847 && ov.rows() == 1 && ov.columns() == 1)
2848 ov = ov.cell_value()(0);
2849 if (!ov.is_string())
2852 std::string str=ov.string_value();
2853 size_t len=str.size();
2854 char* cstr=(
char*)str.c_str();
2856 *cptr =
reinterpret_cast< char*
>(memcpy(
new char[len + 1], cstr,
sizeof(
char)*(len + 1)));
2871 return octave_value(
value);
2884 return octave_value(
value);
2893 gin.
dX = x_in; gin.
dY = y_in;
2895 *x = gin.
wX; *y = gin.
wY;
2902 if (!ov.is_scalar_type())
2904 if (ov.is_complex_scalar())
2907 *val = ov.double_value();
2920 const char *legline1,
const char *legline2,
const char *legline3,
const char *legline4,
2921 const char *labx,
const char *laby,
const char *labtop )
2923 const char *legline[4];
2924 legline[0] = legline1; legline[1] = legline2;
2925 legline[2] = legline3; legline[3] = legline4;
2926 c_plstripc(
id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
2927 xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
2928 labx, laby, labtop );
2946 *tx = *( (
PLFLT *) pltr_data + 0 ) * x + *( (
PLFLT *) pltr_data + 1 ) * y + *( (
PLFLT *) pltr_data + 2 );
2947 *ty = *( (
PLFLT *) pltr_data + 3 ) * x + *( (
PLFLT *) pltr_data + 4 ) * y + *( (
PLFLT *) pltr_data + 5 );
2952 #define f2c( f, ff, nx, ny ) \
2954 ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
2955 for ( int i = 0; i < nx; i++ ) { \
2956 ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
2957 for ( int j = 0; j < ny; j++ ) \
2958 *( ff[i] + j ) = *( f + nx * j + i );}
2965 f2c( f, ff, nx, ny );
2966 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
xform, tr );
2974 f2c( f, ff, nx, ny );
2975 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr0, NULL );
2984 grid1.
nx = nx; grid1.
ny = ny;
2986 f2c( f, ff, nx, ny );
2987 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr1, &grid1 );
2995 f2c( xg, xgg, nx, ny );
2996 f2c( yg, ygg, nx, ny );
2997 grid2.
nx = nx; grid2.
ny = ny;
2998 grid2.
xg = xgg; grid2.
yg = ygg;
2999 f2c( f, ff, nx, ny );
3000 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
3009 f2c( xg, xgg, nx, ny );
3010 f2c( yg, ygg, nx, ny );
3011 grid2.
nx = nx; grid2.
ny = ny;
3012 grid2.
xg = xgg; grid2.
yg = ygg;
3013 f2c( f, ff, nx, ny );
3014 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
3019 const PLFLT *xg,
int nptsx,
const PLFLT *yg,
int nptsy,
3022 f2c( zg, zgg, nptsx, nptsy );
3023 plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
3024 for (
int i = 0; i < nptsx; i++ )
3025 for (
int j = 0; j < nptsy; j++ )
3026 *( zg + nptsx * j + i ) = zgg[i][j];
3034 f2c( z, zz, nx, ny );
3042 f2c( z, zz, nx, ny );
3043 c_plmeshc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3051 f2c( z, zz, nx, ny );
3060 f2c( z, zz, nx, ny );
3061 c_plot3dc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3070 f2c( z, zz, nx, ny );
3072 indexxmin, indexxmax, indexymin, indexymax );
3079 f2c( z, zz, nx, ny );
3087 f2c( z, zz, nx, ny );
3089 indexxmin, indexxmax, indexymin, indexymax );
3107 f2c( a, aa, nx, ny );
3108 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3109 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3110 min_color, min_width, max_color, max_width,
3124 grid1.
nx = nx; grid1.
ny = ny;
3126 f2c( a, aa, nx, ny );
3127 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3128 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3129 min_color, min_width, max_color, max_width,
3143 f2c( xg, xgg, nx, ny );
3144 f2c( yg, ygg, nx, ny );
3145 grid2.
nx = nx; grid2.
ny = ny;
3146 grid2.
xg = xgg; grid2.
yg = ygg;
3147 f2c( a, aa, nx, ny );
3148 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3149 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3150 min_color, min_width, max_color, max_width,
3162 f2c( a, aa, nx, ny );
3163 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3164 clevel, nlevel, fill_width, cont_color, cont_width,
3165 plfill, rectangular, NULL, NULL );
3174 f2c( a, aa, nx, ny );
3175 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3176 clevel, nlevel, fill_width, cont_color, cont_width,
3187 grid1.
nx = nx; grid1.
ny = ny;
3190 f2c( a, aa, nx, ny );
3191 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3192 clevel, nlevel, fill_width, cont_color, cont_width,
3203 f2c( xg, xgg, nx, ny );
3204 f2c( yg, ygg, nx, ny );
3205 grid2.
nx = nx; grid2.
ny = ny;
3206 grid2.
xg = xgg; grid2.
yg = ygg;
3207 f2c( a, aa, nx, ny );
3208 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3209 clevel, nlevel, fill_width, cont_color, cont_width,
3219 f2c( u, uu, nx, ny );
3220 f2c( v, vv, nx, ny );
3228 grid1.
nx = nx; grid1.
ny = ny;
3230 f2c( u, uu, nx, ny );
3231 f2c( v, vv, nx, ny );
3239 f2c( xg, xgg, nx, ny );
3240 f2c( yg, ygg, nx, ny );
3241 grid2.
nx = nx; grid2.
ny = ny;
3242 grid2.
xg = xgg; grid2.
yg = ygg;
3243 f2c( u, uu, nx, ny );
3244 f2c( v, vv, nx, ny );
3255 f2c( a, aa, nx, ny );
3256 plimage( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
3266 f2c( a, aa, nx, ny );
3267 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
3275 f2c( a, aa, nx, ny );
3276 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
xform, tr );
3286 grid1.
nx = nx + 1; grid1.
ny = ny + 1;
3288 f2c( a, aa, nx, ny );
3289 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr1, &grid1 );
3299 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
3300 f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
3301 grid2.
nx = nx + 1; grid2.
ny = ny + 1;
3302 grid2.
xg = xgg; grid2.
yg = ygg;
3303 f2c( a, aa, nx, ny );
3304 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr2, &grid2 );
3315 PLINT n_labels,
const PLINT *label_opts,
const char **label,
3316 PLINT n_axes,
const char ** axis_opts,
3323 for ( i = 0; i < nx; i++ )
3324 if ( n_values[i] > ny )
3326 f2c( a, aa, nx, ny );
3328 opt, position, x, y,
3330 bg_color, bb_color, bb_style,
3331 low_cap_color, high_cap_color,
3332 cont_color, cont_width,
3333 n_labels, label_opts, label,
3343 if (!ov.is_scalar_type())
3345 if (ov.is_complex_scalar())
3347 if (ov.is_double_type()||ov.is_single_type()) {
3348 double v=ov.double_value();
3354 if (ov.is_int8_type()||ov.is_int16_type()||
3355 ov.is_int32_type()) {
3356 long v=ov.long_value();
3360 if (ov.is_int64_type()) {
3361 long long v=ov.int64_scalar_value().value();
3366 *val = ov.ulong_value();
3377 if ((v > UINT_MAX)) {
3380 if (val) *val =
static_cast< unsigned int >(v);
3389 return octave_value(
value);
3403 char* cptr = 0;
size_t csize = 0;
int alloc =
SWIG_OLDOBJ;
3407 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3408 if (csize <= size) {
3410 if (csize) memcpy(val, cptr, csize*
sizeof(
char));
3411 if (csize < size) memset(val + csize, 0, (size - csize)*
sizeof(
char));
3428 static int init = 0;
3441 return std::string(carray,carray+size);
3449 for (p = s;
maxlen-- && *p; p++)
3463 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3464 if (val) *val =
static_cast< char >(v);
3474 Specify viewport in absolute coordinates\n\
3478 Alternate routine to plvpor for setting up the viewport. This routine\n\
3479 should be used only if the viewport is required to have a definite\n\
3480 size in millimeters. The routine plgspa is useful for finding out the\n\
3481 size of the current subpage.\n\
3483 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
3485 This function is used in example 10.\n\
3491 plsvpa(xmin, xmax, ymin, ymax)\n\
3495 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
3496 viewport from the left-hand edge of the subpage in millimeters.\n\
3498 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
3499 viewport from the left-hand edge of the subpage in millimeters.\n\
3501 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
3502 viewport from the bottom edge of the subpage in millimeters.\n\
3504 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
3505 from the bottom edge of the subpage in millimeters.\n\
3508 Write text relative to viewport boundaries in 3D plots\n\
3512 Writes text at a specified position relative to the viewport\n\
3513 boundaries. Text may be written inside or outside the viewport, but\n\
3514 is clipped at the subpage boundaries. The reference point of a string\n\
3515 lies along a line passing through the string at half the height of a\n\
3516 capital letter. The position of the reference point along this line\n\
3517 is determined by just, and the position of the reference point\n\
3518 relative to the viewport is set by disp and pos.\n\
3520 Redacted form: plmtex3(side, disp, pos, just, text)\n\
3522 This function is used in example 28.\n\
3528 plmtex3(side, disp, pos, just, text)\n\
3532 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
3533 the side of the viewport along which the text is to be written.\n\
3534 The string should contain one or more of the following characters:\n\
3535 [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
3536 only label the X axis, not both the X and Y axes. x: Label the X\n\
3538 y: Label the Y axis.\n\
3539 z: Label the Z axis.\n\
3540 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
3541 For X it is the axis that starts at y-min. For Y it is the\n\
3542 axis that starts at x-min.\n\
3543 s: Label the secondary axis.\n\
3544 v: Draw the text perpendicular to the axis.\n\
3547 disp (PLFLT, input) : Position of the reference point of string,\n\
3548 measured outwards from the specified viewport edge in units of the\n\
3549 current character height. Use negative disp to write within the\n\
3552 pos (PLFLT, input) : Position of the reference point of string\n\
3553 along the specified edge, expressed as a fraction of the length of\n\
3556 just (PLFLT, input) : Specifies the position of the string relative\n\
3557 to its reference point. If just=0. , the reference point is at\n\
3558 the left and if just=1. , it is at the right of the string. Other\n\
3559 values of just give intermediate justifications.\n\
3561 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3565 Set semitransparent cmap1 RGBA colors.\n\
3569 Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
3570 RGBA vector values. This function also sets the number of cmap1\n\
3571 colors. N.B. Continuous cmap1 colors are indexed with a\n\
3572 floating-point index in the range from 0.0-1.0 which is linearly\n\
3573 transformed (e.g., by plcol1) to an integer index of these RGBA\n\
3574 vectors in the range from 0 to\n\
3575 ncol1-1. So in order for this continuous color model to work\n\
3576 properly, it is the responsibility of the user of plscmap1 to insure\n\
3577 that these RGBA vectors are continuous functions of their integer\n\
3580 Redacted form: plscmap1a(r, g, b, alpha)\n\
3582 This function is used in example 31.\n\
3588 plscmap1a(r, g, b, alpha, ncol1)\n\
3592 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3593 8-bit integers in the range from 0-255) the degree of red in the\n\
3594 color as a continuous function of the integer index of the vector.\n\
3596 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3597 8-bit integers in the range from 0-255) the degree of green in the\n\
3598 color as a continuous function of the integer index of the vector.\n\
3600 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3601 8-bit integers in the range from 0-255) the degree of blue in the\n\
3602 color as a continuous function of the integer index of the vector.\n\
3604 alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
3605 values in the range from 0.0-1.0 where 0.0 corresponds to\n\
3606 completely transparent and 1.0 corresponds to completely opaque)\n\
3607 the alpha transparency of the color as a continuous function of\n\
3608 the integer index of the vector.\n\
3610 ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
3614 Select standard viewport\n\
3618 Selects the largest viewport within the subpage that leaves a standard\n\
3619 margin (left-hand margin of eight character heights, and a margin\n\
3620 around the other three sides of five character heights).\n\
3622 Redacted form: plvsta()\n\
3624 This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
3633 Switch to graphics screen\n\
3637 Sets an interactive device to graphics mode, used in conjunction with\n\
3638 pltext to allow graphics and text to be interspersed. On a device\n\
3639 which supports separate text and graphics windows, this command causes\n\
3640 control to be switched to the graphics window. If already in graphics\n\
3641 mode, this command is ignored. It is also ignored on devices which\n\
3642 only support a single window or use a different method for shifting\n\
3643 focus. See also pltext.\n\
3645 Redacted form: plgra()\n\
3647 This function is used in example 1.\n\
3656 Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
3660 Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
3661 (see the PLplot documentation) index. Overwrites the previous color\n\
3662 value for the given index and, thus, does not result in any additional\n\
3663 allocation of space for colors.\n\
3665 This function is used in example 30.\n\
3671 plscol0a(icol0, r, g, b, alpha)\n\
3675 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
3676 number of colors (which is set by default, by plscmap0n, or even\n\
3679 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3680 degree of red in the color.\n\
3682 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3683 degree of green in the color.\n\
3685 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3686 degree of blue in the color.\n\
3688 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
3692 Set y axis parameters\n\
3696 Identical to plsxax, except that arguments are flags for y axis. See\n\
3697 the description of plsxax for more detail.\n\
3699 Redacted form: plsyax(digmax, digits)\n\
3701 This function is used in examples 1, 14, and 31.\n\
3707 plsyax(digmax, digits)\n\
3711 digmax (PLINT, input) : Variable to set the maximum number of\n\
3712 digits for the y axis. If nonzero, the printed label will be\n\
3713 switched to a floating-point representation when the number of\n\
3714 digits exceeds digmax.\n\
3716 digits (PLINT, input) : Field digits value. Currently, changing\n\
3717 its value here has no effect since it is set only by plbox or\n\
3718 plbox3. However, the user may obtain its value after a call to\n\
3719 either of these functions by calling plgyax.\n\
3722 Returns 8-bit RGB values for given color index from cmap0\n\
3726 Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
3727 PLplot documentation). Values are negative if an invalid color id is\n\
3730 Redacted form: plgcol0(icol0, r, g, b)\n\
3732 This function is used in example 2.\n\
3738 plgcol0(icol0, r, g, b)\n\
3742 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
3744 r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
3747 g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
3750 b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
3754 Set seed for internal random number generator.\n\
3758 Set the seed for the internal random number generator. See plrandd for\n\
3761 Redacted form: plseed(seed)\n\
3763 This function is used in example 21.\n\
3773 seed (unsigned int, input) : Seed for random number generator.\n\
3776 Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
3780 When the implementation is completed this variant of plot3dc (see that\n\
3781 function\'s documentation for more details) should be suitable for the\n\
3782 case where the area of the x, y coordinate grid where z is defined can\n\
3783 be non-rectangular. The implementation is incomplete so the last 4\n\
3784 parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
3785 indexymax; are currently ignored and the functionality is otherwise\n\
3786 identical to that of plot3dc.\n\
3788 Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
3789 indexymin, indexymax)\n\
3792 This function is not used in any example.\n\
3798 plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
3802 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3803 which the function is evaluated.\n\
3805 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3806 which the function is evaluated.\n\
3808 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3809 plot. Should have dimensions of\n\
3813 nx (PLINT, input) : Number of x values at which the function is\n\
3816 ny (PLINT, input) : Number of y values at which the function is\n\
3819 opt (PLINT, input) : Determines the way in which the surface is\n\
3820 represented. To specify more than one option just add the options,\n\
3821 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3822 showing z as a function of x for each value of y[j] .\n\
3823 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3824 for each value of x[i] .\n\
3825 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3826 at which function is defined.\n\
3827 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3828 the z value being plotted. The color is used from the current\n\
3830 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3834 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3835 the borders of the plotted function.\n\
3838 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3841 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3843 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
3844 corresponds to the first x index where z is defined.\n\
3846 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
3847 which corresponds (by convention) to one more than the last x\n\
3848 index value where z is defined.\n\
3850 indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
3851 values which all must be ≥ 0. These values are the first y index\n\
3852 where z is defined for a particular x index in the range from\n\
3853 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
3856 indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
3857 values which all must be ≤ ny. These values correspond (by\n\
3858 convention) to one more than the last y index where z is defined\n\
3859 for a particular x index in the range from indexxmin to indexxmax\n\
3860 - 1. The dimension of indexymax is indexxmax.\n\
3863 Get output file name\n\
3867 Gets the current output file name, if applicable.\n\
3869 Redacted form: plgfnam(fnam)\n\
3871 This function is used in example 31.\n\
3881 fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
3882 (with preallocated length of 80 characters or more) containing the\n\
3890 Specify the window, i.e., the world coordinates of the edges of the\n\
3893 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
3895 This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
3902 plwind(xmin, xmax, ymin, ymax)\n\
3906 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
3909 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
3912 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
3915 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
3919 Set cmap1 colors using a piece-wise linear relationship\n\
3923 Set cmap1 colors using a piece-wise linear relationship between the\n\
3924 cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
3925 (see the PLplot documentation). May be called at any time.\n\
3927 The idea here is to specify a number of control points that define the\n\
3928 mapping between input cmap1 intensity indices and HLS or RGB. Between\n\
3929 these points, linear interpolation is used which gives a smooth\n\
3930 variation of color with intensity index. Any number of control points\n\
3931 may be specified, located at arbitrary positions, although typically 2\n\
3932 - 4 are enough. Another way of stating this is that we are traversing\n\
3933 a given number of lines through HLS or RGB space as we move through\n\
3934 cmap1 intensity indices. The control points at the minimum and\n\
3935 maximum position (0 and 1) must always be specified. By adding more\n\
3936 control points you can get more variation. One good technique for\n\
3937 plotting functions that vary about some expected average is to use an\n\
3938 additional 2 control points in the center (position ~= 0.5) that are\n\
3939 the same lightness as the background (typically white for paper\n\
3940 output, black for crt), and same hue as the boundary control points.\n\
3941 This allows the highs and lows to be very easily distinguished.\n\
3943 Each control point must specify the cmap1 intensity index and the\n\
3944 associated three coordinates in HLS or RGB space. The first point\n\
3945 must correspond to position = 0, and the last to position = 1.\n\
3947 If RGB colors are provided then the interpolation takes place in RGB\n\
3948 space and is trivial. However if HLS colors are provided then, because\n\
3949 of the circular nature of the color wheel for the hue coordinate, the\n\
3950 interpolation could be performed in either direction around the color\n\
3951 wheel. The default behaviour is for the hue to be linearly\n\
3952 interpolated ignoring this circular property of hue. So for example,\n\
3953 the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\
3954 green and cyan. If instead you wish to interpolate the other way\n\
3955 around the color wheel you have two options. You may provide hues\n\
3956 outside the range [0, 360), so by using a hue of -120 for blue or 360\n\
3957 for red the interpolation will proceed via magenta. Alternatively you\n\
3958 can utilise the alt_hue_path variable to reverse the direction of\n\
3959 interpolation if you need to provide hues within the [0-360) range.\n\
3961 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
3962 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
3963 -120]falsegreen-yellow-red-magenta-blue[240\n\
3964 480]falseblue-magenta-red-yellow-green[120\n\
3965 240]truegreen-yellow-red-magenta-blue[240\n\
3966 120]trueblue-magenta-red-yellow-green\n\
3968 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
3969 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
3970 1]magnitudeHLSsaturation[0, 1]magnitude\n\
3972 Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
3975 This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
3981 plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
3985 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
3987 npts (PLINT, input) : number of control points\n\
3989 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
3990 intensity index (0.0-1.0) in ascending order for each control\n\
3993 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
3994 coordinate (H or R) for each control point.\n\
3996 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
3997 coordinate (L or G) for each control point.\n\
3999 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
4000 coordinate (S or B) for each control point.\n\
4002 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
4003 npts - 1 elements), each containing either true to use the reversed\n\
4004 HLS interpolation or false to use the regular HLS interpolation.\n\
4005 (alt_hue_path[i] refers to the interpolation interval between the\n\
4006 i and i + 1 control points). This parameter is not used for RGB\n\
4011 Set the pause (on end-of-page) status\n\
4015 Set the pause (on end-of-page) status.\n\
4017 Redacted form: plspause(pause)\n\
4019 This function is in examples 14,20.\n\
4029 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
4030 end-of-page for those drivers which support this. Otherwise there\n\
4034 Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
4038 Routine for creating a discrete plot legend with a plotted filled box,\n\
4039 line, and/or line of symbols for each annotated legend entry. (See\n\
4040 plcolorbar for similar functionality for creating continuous color\n\
4041 bars.) The arguments of pllegend provide control over the location\n\
4042 and size of the legend as well as the location and characteristics of\n\
4043 the elements (most of which are optional) within that legend. The\n\
4044 resulting legend is clipped at the boundaries of the current subpage.\n\
4045 (N.B. the adopted coordinate system used for some of the parameters is\n\
4046 defined in the documentation of the position parameter.)\n\
4048 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
4049 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
4050 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
4051 test_justification, text_colors, text, box_colors, box_patterns,\n\
4052 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
4053 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
4055 This function is used in examples 4, 26, and 33.\n\
4061 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\
4065 p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
4066 legend width in adopted coordinates. This quantity is calculated\n\
4067 from plot_width, text_offset, ncolumn (possibly modified inside\n\
4068 the routine depending on nlegend and nrow), and the length\n\
4069 (calculated internally) of the longest text string.\n\
4071 p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
4072 legend height in adopted coordinates. This quantity is calculated\n\
4073 from text_scale, text_spacing, and nrow (possibly modified inside\n\
4074 the routine depending on nlegend and nrow).\n\
4076 opt (PLINT, input) : opt contains bits controlling the overall\n\
4077 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
4078 on the left of the legend and the plotted area on the right.\n\
4079 Otherwise, put the text area on the right of the legend and the\n\
4080 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
4081 plot a (semitransparent) background for the legend. If the\n\
4082 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
4083 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
4084 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
4085 plot the resulting array of legend entries in row-major order.\n\
4086 Otherwise, plot the legend entries in column-major order.\n\
4088 position (PLINT, input) : position contains bits which control the\n\
4089 overall position of the legend and the definition of the adopted\n\
4090 coordinates used for positions just like what is done for the\n\
4091 position argument for plcolorbar. However, note that the defaults\n\
4092 for the position bits (see below) are different than the\n\
4093 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
4094 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
4095 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
4096 the 16 possible standard positions (the 4 corners and centers of\n\
4097 the 4 sides for both the inside and outside cases) of the legend\n\
4098 relative to the adopted coordinate system. The corner positions\n\
4099 are specified by the appropriate combination of two of the\n\
4100 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
4101 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
4102 value of one of those bits. The adopted coordinates are\n\
4103 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
4104 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
4105 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
4106 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
4107 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
4108 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
4109 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
4110 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
4112 x (PLFLT, input) : X offset of the legend position in adopted\n\
4113 coordinates from the specified standard position of the legend.\n\
4114 For positive x, the direction of motion away from the standard\n\
4115 position is inward/outward from the standard corner positions or\n\
4116 standard left or right positions if the\n\
4117 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
4118 For the standard top or bottom positions, the direction of motion\n\
4119 is toward positive X.\n\
4121 y (PLFLT, input) : Y offset of the legend position in adopted\n\
4122 coordinates from the specified standard position of the legend.\n\
4123 For positive y, the direction of motion away from the standard\n\
4124 position is inward/outward from the standard corner positions or\n\
4125 standard top or bottom positions if the\n\
4126 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
4127 the standard left or right positions, the direction of motion is\n\
4128 toward positive Y.\n\
4130 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
4131 of the plot area (where the colored boxes, lines, and/or lines of\n\
4132 symbols are drawn) of the legend.\n\
4134 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
4135 legend (PL_LEGEND_BACKGROUND).\n\
4137 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
4138 for the legend (PL_LEGEND_BOUNDING_BOX).\n\
4140 bb_style (PLINT, input) : The pllsty style number for the\n\
4141 bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
4143 nrow (PLINT, input) : The number of rows in the matrix used to\n\
4145 nlegend legend entries. For internal transformations of\n\
4146 nrow, see further remarks under\n\
4149 ncolumn (PLINT, input) : The number of columns in the matrix used\n\
4151 nlegend legend entries. For internal transformations of\n\
4152 ncolumn, see further remarks under\n\
4155 nlegend (PLINT, input) : Number of legend entries. The above\n\
4157 ncolumn values are transformed internally to be consistent with\n\
4158 nlegend. If either\n\
4160 ncolumn is non-positive it is replaced by 1. If the resulting product\n\
4163 ncolumn is less than\n\
4164 nlegend, the smaller of the two (or\n\
4167 ncolumn) is increased so the product is >=\n\
4168 nlegend. Thus, for example, the common\n\
4170 ncolumn = 0 case is transformed internally to\n\
4173 ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
4176 opt_array (PLINT_VECTOR, input) : A vector of\n\
4177 nlegend values of options to control each individual plotted area\n\
4178 corresponding to a legend entry. If the\n\
4179 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
4181 PL_LEGEND_COLOR_BOX,\n\
4182 PL_LEGEND_LINE, and/or\n\
4183 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
4184 entry is plotted with a colored box; a line; and/or a line of\n\
4187 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
4188 area in units of character width.\n\
4190 text_scale (PLFLT, input) : Character height scale for text\n\
4193 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
4194 character height from one legend entry to the next.\n\
4196 text_justification (PLFLT, input) : Justification parameter used\n\
4197 for text justification. The most common values of\n\
4198 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
4199 is left justified, centred, or right justified within the text\n\
4200 area, but other values are allowed as well.\n\
4202 text_colors (PLINT_VECTOR, input) : A vector containing\n\
4203 nlegend cmap0 text colors.\n\
4205 text (PLCHAR_MATRIX, input) : A vector of\n\
4206 nlegend UTF-8 character strings containing the legend annotations.\n\
4208 box_colors (PLINT_VECTOR, input) : A vector containing\n\
4209 nlegend cmap0 colors for the discrete colored boxes (\n\
4210 PL_LEGEND_COLOR_BOX).\n\
4212 box_patterns (PLINT_VECTOR, input) : A vector containing\n\
4213 nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
4214 PL_LEGEND_COLOR_BOX).\n\
4216 box_scales (PLFLT_VECTOR, input) : A vector containing\n\
4217 nlegend scales (units of fraction of character height) for the height\n\
4218 of the discrete colored boxes (\n\
4219 PL_LEGEND_COLOR_BOX).\n\
4221 box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
4222 nlegend line widths for the patterns specified by box_patterns (\n\
4223 PL_LEGEND_COLOR_BOX).\n\
4225 line_colors (PLINT_VECTOR, input) : A vector containing\n\
4226 nlegend cmap0 line colors (\n\
4229 line_styles (PLINT_VECTOR, input) : A vector containing\n\
4230 nlegend line styles (plsty indices) (\n\
4233 line_widths (PLFLT_VECTOR, input) : A vector containing\n\
4234 nlegend line widths (\n\
4237 symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
4238 nlegend cmap0 symbol colors (\n\
4239 PL_LEGEND_SYMBOL).\n\
4241 symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
4242 nlegend scale values for the symbol height (\n\
4243 PL_LEGEND_SYMBOL).\n\
4245 symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
4246 nlegend numbers of symbols to be drawn across the width of the plotted\n\
4248 PL_LEGEND_SYMBOL).\n\
4250 symbols (PLCHAR_MATRIX, input) : A vector of\n\
4251 nlegend UTF-8 character strings containing the legend symbols. (\n\
4252 PL_LEGEND_SYMBOL).\n\
4255 Set number of colors in cmap1\n\
4259 Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
4260 values if this is the first allocation (see the PLplot documentation).\n\
4262 Redacted form: plscmap1n(ncol1)\n\
4264 This function is used in examples 8, 11, 20, and 21.\n\
4274 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
4275 the cmap1 palette. If this number is zero or less, then the value\n\
4276 from the previous call to plscmap1n is used and if there is no\n\
4277 previous call, then a default value is used.\n\
4280 Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
4284 Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
4285 (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
4286 Values are negative if an invalid color id is given.\n\
4288 Redacted form: plgcola(r, g, b)\n\
4290 This function is used in example 30.\n\
4296 plgcol0a(icol0, r, g, b, alpha)\n\
4300 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
4302 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
4303 in the range from 0 to 255.\n\
4305 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
4306 in the range from 0 to 255.\n\
4308 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
4309 in the range from 0 to 255.\n\
4311 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
4312 transparency in the range from (0.0-1.0).\n\
4315 Replays contents of plot buffer to current device/file\n\
4319 Replays contents of plot buffer to current device/file.\n\
4321 Redacted form: plreplot()\n\
4323 This function is used in example 1,20.\n\
4332 Simple routine to write labels\n\
4336 Routine for writing simple labels. Use plmtex for more complex labels.\n\
4338 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
4340 This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
4346 pllab(xlabel, ylabel, tlabel)\n\
4350 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4351 the label for the x axis.\n\
4353 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4354 the label for the y axis.\n\
4356 tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4357 the title of the plot.\n\
4360 Set parameters that define current device-space window\n\
4364 Set relative margin width, aspect ratio, and relative justification\n\
4365 that define current device-space window. If you want to just use the\n\
4366 previous value for any of these, just pass in the magic value\n\
4367 PL_NOTSET. It is unlikely that one should ever need to change the\n\
4368 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
4369 called the default values of mar, jx, and jy are all 0. aspect is set\n\
4370 to a device-specific value.\n\
4372 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
4374 This function is used in example 31.\n\
4380 plsdidev(mar, aspect, jx, jy)\n\
4384 mar (PLFLT, input) : Relative margin width.\n\
4386 aspect (PLFLT, input) : Aspect ratio.\n\
4388 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
4389 the range -0.5 to 0.5.\n\
4391 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
4392 the range -0.5 to 0.5.\n\
4399 Begins a new page. For a file driver, the output file is opened if\n\
4400 necessary. Advancing the page via pleop and plbop is useful when a\n\
4401 page break is desired at a particular point when plotting to subpages.\n\
4402 Another use for pleop and plbop is when plotting pages to different\n\
4403 files, since you can manually set the file name by calling plsfnam\n\
4404 after the call to pleop. (In fact some drivers may only support a\n\
4405 single page per file, making this a necessity.) One way to handle\n\
4406 this case automatically is to page advance via pladv, but enable\n\
4407 familying (see plsfam) with a small limit on the file size so that a\n\
4408 new family member file will be created on each page break.\n\
4410 Redacted form: plbop()\n\
4412 This function is used in examples 2 and 20.\n\
4421 Set cmap0 colors by 8-bit RGB values\n\
4425 Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
4426 documentation). This sets the entire color map -- only as many colors\n\
4427 as specified will be allocated.\n\
4429 Redacted form: plscmap0(r, g, b)\n\
4431 This function is used in examples 2 and 24.\n\
4437 plscmap0(r, g, b, ncol0)\n\
4441 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4442 integers (0-255) representing the degree of red in the color.\n\
4444 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4445 integers (0-255) representing the degree of green in the color.\n\
4447 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4448 integers (0-255) representing the degree of blue in the color.\n\
4450 ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4453 Set the number of subpages in x and y\n\
4457 Set the number of subpages in x and y.\n\
4459 Redacted form: plssub(nx, ny)\n\
4461 This function is examples 1,2,14,21,25,27.\n\
4471 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
4472 of window columns).\n\
4474 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
4478 Set a global coordinate transform function\n\
4482 This function can be used to define a coordinate transformation which\n\
4483 affects all elements drawn within the current plot window. The\n\
4484 coordinate_transform callback function is similar to that provided for\n\
4485 the plmap and plmeridians functions. The coordinate_transform_data\n\
4486 parameter may be used to pass extra data to coordinate_transform.\n\
4488 Redacted form: General: plstransform(coordinate_transform,\n\
4489 coordinate_transform_data)\n\
4492 This function is used in examples 19 and 22.\n\
4498 plstransform(coordinate_transform, coordinate_transform_data)\n\
4502 coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
4503 function that defines the transformation from the input (x, y)\n\
4504 world coordinates to new PLplot world coordinates. If\n\
4505 coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
4506 case), then no transform is applied.\n\
4508 coordinate_transform_data (PLPointer, input) : Optional extra data\n\
4510 coordinate_transform.\n\
4513 Set opaque RGB cmap1 colors values\n\
4517 Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
4518 vector values. This function also sets the number of cmap1 colors.\n\
4519 N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
4520 in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
4521 plcol1) to an integer index of these RGB vectors in the range from 0\n\
4523 ncol1-1. So in order for this continuous color model to work\n\
4524 properly, it is the responsibility of the user of plscmap1 to insure\n\
4525 that these RGB vectors are continuous functions of their integer\n\
4528 Redacted form: plscmap1(r, g, b)\n\
4530 This function is used in example 31.\n\
4536 plscmap1(r, g, b, ncol1)\n\
4540 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4541 8-bit integers in the range from 0-255) the degree of red in the\n\
4542 color as a continuous function of the integer index of the vector.\n\
4544 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4545 8-bit integers in the range from 0-255) the degree of green in the\n\
4546 color as a continuous function of the integer index of the vector.\n\
4548 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4549 8-bit integers in the range from 0-255) the degree of blue in the\n\
4550 color as a continuous function of the integer index of the vector.\n\
4552 ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4555 Configure the transformation between continuous and broken-down time for the current stream\n\
4559 Configure the transformation between continuous and broken-down time\n\
4560 for the current stream. This transformation is used by both plbtime\n\
4563 Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
4564 ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4567 This function is used in example 29.\n\
4573 plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4577 scale (PLFLT, input) : The number of days per continuous time unit.\n\
4578 As a special case, if\n\
4579 scale is 0., then all other arguments are ignored, and the result (the\n\
4580 default used by PLplot) is the equivalent of a call to\n\
4581 plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
4582 That is, for this special case broken-down time is calculated with\n\
4583 the proleptic Gregorian calendar with no leap seconds inserted,\n\
4584 and the continuous time is defined as the number of seconds since\n\
4585 the Unix epoch of 1970-01-01T00:00:00Z.\n\
4587 offset1 (PLFLT, input) : If\n\
4588 ifbtime_offset is true, the parameters\n\
4590 offset2 are completely ignored. Otherwise, the sum of these parameters\n\
4591 (with units in days) specify the epoch of the continuous time\n\
4592 relative to the MJD epoch corresponding to the Gregorian calendar\n\
4593 date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
4594 are used to specify the origin to allow users (by specifying\n\
4595 offset1 as an integer that can be exactly represented by a\n\
4596 floating-point variable and specifying\n\
4597 offset2 as a number in the range from 0. to 1) the chance to minimize\n\
4598 the numerical errors of the continuous time representation.\n\
4600 offset2 (PLFLT, input) : See documentation of\n\
4603 ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
4604 transformation. If the 0x1 bit is set, then the proleptic Julian\n\
4605 calendar is used for broken-down time rather than the proleptic\n\
4606 Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
4607 have been historically used to define UTC are inserted into the\n\
4608 broken-down time. Other possibilities for additional control bits\n\
4609 for ccontrol exist such as making the historical time corrections\n\
4610 in the broken-down time corresponding to ET (ephemeris time) or\n\
4611 making the (slightly non-constant) corrections from international\n\
4612 atomic time (TAI) to what astronomers define as terrestrial time\n\
4613 (TT). But those additional possibilities have not been\n\
4614 implemented yet in the qsastime library (one of the PLplot utility\n\
4617 ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
4618 epoch of the continuous time scale is specified by the user. If\n\
4619 ifbtime_offset is false, then\n\
4621 offset2 are used to specify the epoch, and the following broken-down\n\
4622 time parameters are completely ignored. If\n\
4623 ifbtime_offset is true, then\n\
4625 offset2 are completely ignored, and the following broken-down time\n\
4626 parameters are used to specify the epoch.\n\
4628 year (PLINT, input) : Year of epoch.\n\
4630 month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
4633 day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
4635 hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
4637 min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
4639 sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
4642 Set length of minor ticks\n\
4646 This sets up the length of the minor ticks and the length of the\n\
4647 terminals on error bars. The actual length is the product of the\n\
4648 default length and a scaling factor as for character height.\n\
4650 Redacted form: plsmin(def, scale)\n\
4652 This function is used in example 29.\n\
4658 plsmin(def, scale)\n\
4662 def (PLFLT, input) : The default length of a minor tick in\n\
4663 millimeters, should be set to zero if the default length is to\n\
4664 remain unchanged.\n\
4666 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4667 actual tick length.\n\
4670 Set character size\n\
4674 This sets up the size of all subsequent characters drawn. The actual\n\
4675 height of a character is the product of the default character size and\n\
4676 a scaling factor.\n\
4678 Redacted form: plschr(def, scale)\n\
4680 This function is used in examples 2, 13, 23, and 24.\n\
4686 plschr(def, scale)\n\
4690 def (PLFLT, input) : The default height of a character in\n\
4691 millimeters, should be set to zero if the default height is to\n\
4692 remain unchanged. For rasterized drivers the dx and dy values\n\
4693 specified in plspage are used to convert from mm to pixels (note\n\
4694 the different unit systems used). This dpi aware scaling is not\n\
4695 implemented for all drivers yet.\n\
4697 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4698 actual character height.\n\
4701 Initialize PLplot\n\
4705 Initializing the plotting package. The program prompts for the device\n\
4706 keyword or number of the desired output device. Hitting a RETURN in\n\
4707 response to the prompt is the same as selecting the first device.\n\
4708 plinit will issue no prompt if either the device was specified\n\
4709 previously (via command line flag, the plsetopt function, or the\n\
4710 plsdev function), or if only one device is enabled when PLplot is\n\
4711 installed. If subpages have been specified, the output device is\n\
4712 divided into nx by ny subpages, each of which may be used\n\
4713 independently. If plinit is called again during a program, the\n\
4714 previously opened file will be closed. The subroutine pladv is used\n\
4715 to advance from one subpage to the next.\n\
4717 Redacted form: plinit()\n\
4719 This function is used in all of the examples.\n\
4728 Draw a box with axes, etc\n\
4732 Draws a box around the currently defined viewport, and labels it with\n\
4733 world coordinate values appropriate to the window. Thus plbox should\n\
4734 only be called after defining both viewport and window. The ascii\n\
4735 character strings xopt and yopt specify how the box should be drawn as\n\
4736 described below. If ticks and/or subticks are to be drawn for a\n\
4737 particular axis, the tick intervals and number of subintervals may be\n\
4738 specified explicitly, or they may be defaulted by setting the\n\
4739 appropriate arguments to zero.\n\
4741 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4744 This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
4751 plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4755 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4756 options for the x axis. The string can include any combination of\n\
4757 the following letters (upper or lower case) in any order: a: Draws\n\
4758 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
4760 b: Draws bottom (X) or left (Y) edge of frame.\n\
4761 c: Draws top (X) or right (Y) edge of frame.\n\
4762 d: Plot labels as date / time. Values are assumed to be\n\
4763 seconds since the epoch (as used by gmtime).\n\
4764 f: Always use fixed point numeric labels.\n\
4765 g: Draws a grid at the major tick interval.\n\
4766 h: Draws a grid at the minor tick interval.\n\
4767 i: Inverts tick marks, so they are drawn outwards, rather than\n\
4769 l: Labels axis logarithmically. This only affects the labels,\n\
4770 not the data, and so it is necessary to compute the logarithms\n\
4771 of data points before passing them to any of the drawing\n\
4773 m: Writes numeric labels at major tick intervals in the\n\
4774 unconventional location (above box for X, right of box for Y).\n\
4775 n: Writes numeric labels at major tick intervals in the\n\
4776 conventional location (below box for X, left of box for Y).\n\
4777 o: Use custom labelling function to generate axis label text.\n\
4778 The custom labelling function can be defined with the\n\
4779 plslabelfunc command.\n\
4780 s: Enables subticks between major ticks, only valid if t is\n\
4782 t: Draws major ticks.\n\
4783 u: Exactly like \"b\" except don\'t draw edge line.\n\
4784 w: Exactly like \"c\" except don\'t draw edge line.\n\
4785 x: Exactly like \"t\" (including the side effect of the\n\
4786 numerical labels for the major ticks) except exclude drawing\n\
4787 the major and minor tick marks.\n\
4790 xtick (PLFLT, input) : World coordinate interval between major\n\
4791 ticks on the x axis. If it is set to zero, PLplot automatically\n\
4792 generates a suitable tick interval.\n\
4794 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
4795 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4796 generates a suitable minor tick interval.\n\
4798 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4799 options for the y axis. The string can include any combination of\n\
4800 the letters defined above for xopt, and in addition may contain:\n\
4801 v: Write numeric labels for the y axis parallel to the base of the\n\
4802 graph, rather than parallel to the axis.\n\
4805 ytick (PLFLT, input) : World coordinate interval between major\n\
4806 ticks on the y axis. If it is set to zero, PLplot automatically\n\
4807 generates a suitable tick interval.\n\
4809 nysub (PLINT, input) : Number of subintervals between major y axis\n\
4810 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4811 generates a suitable minor tick interval.\n\
4814 Get parameters that define current device-space window\n\
4818 Get relative margin width, aspect ratio, and relative justification\n\
4819 that define current device-space window. If plsdidev has not been\n\
4820 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
4821 p_jy will all be 0.\n\
4823 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4825 This function is used in example 31.\n\
4831 plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4835 p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4838 p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
4841 p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4842 justification in x.\n\
4844 p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4845 justification in y.\n\
4848 Plot a glyph at the specified points\n\
4852 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
4853 because many[!] more glyphs are accessible with plstring.) The glyph\n\
4854 is specified with a PLplot user string. Note that the user string is\n\
4855 not actually limited to one glyph so it is possible (but not normally\n\
4856 useful) to plot more than one glyph at the specified points with this\n\
4857 function. As with plmtex and plptex, the user string can contain FCI\n\
4858 escapes to determine the font, UTF-8 code to determine the glyph or\n\
4859 else PLplot escapes for Hershey or unicode text to determine the\n\
4862 Redacted form: plstring(x, y, string)\n\
4864 This function is used in examples 4, 21 and 26.\n\
4870 plstring(n, x, y, string)\n\
4874 n (PLINT, input) : Number of points in the x and y vectors.\n\
4876 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4879 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4882 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
4883 the glyph(s) to be plotted at each of the n points.\n\
4886 Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
4890 As per plmapline, however the items are plotted as strings or points\n\
4891 in the same way as plstring.\n\
4893 Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
4894 maxy, plotentries)\n\
4896 This function is not used in any examples.\n\
4902 plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
4906 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
4907 transform the coordinates given in the shapefile into a plot\n\
4908 coordinate system. By using this transform, we can change from a\n\
4909 longitude, latitude coordinate to a polar stereographic project,\n\
4910 for example. Initially, x[0]..[n-1] are the longitudes and\n\
4911 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
4912 mapform(), x[] and y[] should be replaced by the corresponding\n\
4913 plot coordinates. If no transform is desired, mapform can be\n\
4914 replaced by NULL.\n\
4916 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4917 the file name of a set of Shapefile files without the file\n\
4920 string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
4923 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
4924 be in the same units as used by the Shapefile. You could use a\n\
4925 very large negative number to plot everything, but you can improve\n\
4926 performance by limiting the area drawn. The units must match those\n\
4927 of the Shapefile projection, which may be for example longitude or\n\
4928 distance. The value of minx must be less than the value of maxx.\n\
4930 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
4931 use a very large number to plot everything, but you can improve\n\
4932 performance by limiting the area drawn.\n\
4934 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
4935 be in the same units as used by the Shapefile. You could use a\n\
4936 very large negative number to plot everything, but you can improve\n\
4937 performance by limiting the area drawn. The units must match those\n\
4938 of the Shapefile projection, which may be for example latitude or\n\
4939 distance. The value of miny must be less than the value of maxy.\n\
4941 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
4942 use a very large number to plot everything, but you can improve\n\
4943 performance by limiting the area drawn.\n\
4945 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
4946 zero-based indices of the Shapefile elements which will be drawn.\n\
4948 plotentries to NULL will plot all elements of the Shapefile.\n\
4950 nplotentries (PLINT, input) : The number of items in\n\
4951 plotentries. Ignored if\n\
4952 plotentries is NULL.\n\
4955 Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
4959 Sets up plotter environment for simple graphs by calling pladv and\n\
4960 setting up viewport and window to sensible default values. plenv0\n\
4961 leaves a standard margin (left-hand margin of eight character heights,\n\
4962 and a margin around the other three sides of five character heights)\n\
4963 around most graphs for axis labels and a title. When these defaults\n\
4964 are not suitable, use the individual routines plvpas, plvpor, or\n\
4965 plvasp for setting up the viewport, plwind for defining the window,\n\
4966 and plbox for drawing the box.\n\
4968 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4970 This function is used in example 21.\n\
4976 plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4980 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
4981 world coordinates).\n\
4983 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
4984 world coordinates).\n\
4986 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
4989 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
4992 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
4993 scales will not be set, the user must set up the scale before\n\
4994 calling plenv0 using plsvpa, plvasp or other.\n\
4995 0: the x and y axes are scaled independently to use as much of\n\
4996 the screen as possible.\n\
4997 1: the scales of the x and y axes are made equal.\n\
4998 2: the axis of the x and y axes are made equal, and the plot\n\
4999 box will be square.\n\
5002 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
5003 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
5004 -1: draw box only.\n\
5005 0: draw box, ticks, and numeric tick labels.\n\
5006 1: also draw coordinate axes at x=0 and y=0.\n\
5007 2: also draw a grid at major tick positions in both\n\
5009 3: also draw a grid at minor tick positions in both\n\
5011 10: same as 0 except logarithmic x tick marks. (The x data\n\
5012 have to be converted to logarithms separately.)\n\
5013 11: same as 1 except logarithmic x tick marks. (The x data\n\
5014 have to be converted to logarithms separately.)\n\
5015 12: same as 2 except logarithmic x tick marks. (The x data\n\
5016 have to be converted to logarithms separately.)\n\
5017 13: same as 3 except logarithmic x tick marks. (The x data\n\
5018 have to be converted to logarithms separately.)\n\
5019 20: same as 0 except logarithmic y tick marks. (The y data\n\
5020 have to be converted to logarithms separately.)\n\
5021 21: same as 1 except logarithmic y tick marks. (The y data\n\
5022 have to be converted to logarithms separately.)\n\
5023 22: same as 2 except logarithmic y tick marks. (The y data\n\
5024 have to be converted to logarithms separately.)\n\
5025 23: same as 3 except logarithmic y tick marks. (The y data\n\
5026 have to be converted to logarithms separately.)\n\
5027 30: same as 0 except logarithmic x and y tick marks. (The x\n\
5028 and y data have to be converted to logarithms separately.)\n\
5029 31: same as 1 except logarithmic x and y tick marks. (The x\n\
5030 and y data have to be converted to logarithms separately.)\n\
5031 32: same as 2 except logarithmic x and y tick marks. (The x\n\
5032 and y data have to be converted to logarithms separately.)\n\
5033 33: same as 3 except logarithmic x and y tick marks. (The x\n\
5034 and y data have to be converted to logarithms separately.)\n\
5035 40: same as 0 except date / time x labels.\n\
5036 41: same as 1 except date / time x labels.\n\
5037 42: same as 2 except date / time x labels.\n\
5038 43: same as 3 except date / time x labels.\n\
5039 50: same as 0 except date / time y labels.\n\
5040 51: same as 1 except date / time y labels.\n\
5041 52: same as 2 except date / time y labels.\n\
5042 53: same as 3 except date / time y labels.\n\
5043 60: same as 0 except date / time x and y labels.\n\
5044 61: same as 1 except date / time x and y labels.\n\
5045 62: same as 2 except date / time x and y labels.\n\
5046 63: same as 3 except date / time x and y labels.\n\
5047 70: same as 0 except custom x and y labels.\n\
5048 71: same as 1 except custom x and y labels.\n\
5049 72: same as 2 except custom x and y labels.\n\
5050 73: same as 3 except custom x and y labels.\n\
5053 Configure the transformations required for projecting a 3D surface on a 2D window\n\
5057 Configure the transformations required for projecting a 3D surface on\n\
5058 an existing 2D window. Those transformations (see the PLplot\n\
5059 documentation) are done to a rectangular cuboid enclosing the 3D\n\
5060 surface which has its limits expressed in 3D world coordinates and\n\
5061 also normalized 3D coordinates (used for interpreting the altitude and\n\
5062 azimuth of the viewing angle). The transformations consist of the\n\
5063 linear transform from 3D world coordinates to normalized 3D\n\
5064 coordinates, and the 3D rotation of normalized coordinates required to\n\
5065 align the pole of the new 3D coordinate system with the viewing\n\
5066 direction specified by altitude and azimuth so that x and y of the\n\
5067 surface elements in that transformed coordinate system are the\n\
5068 projection of the 3D surface with given viewing direction on the 2D\n\
5071 The enclosing rectangular cuboid for the surface plot is defined by\n\
5072 xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
5073 mapped into the same rectangular cuboid with normalized 3D coordinate\n\
5074 sizes of basex by basey by height so that xmin maps to -\n\
5075 basex/2, xmax maps to basex/2, ymin maps to -\n\
5076 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
5077 The resulting rectangular cuboid in normalized coordinates is then\n\
5078 viewed by an observer at altitude alt and azimuth az. This routine\n\
5079 must be called before plbox3 or any of the 3D surface plotting\n\
5080 routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
5081 plsurf3dl or plfill3.\n\
5083 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
5084 zmin, zmax, alt, az)\n\
5086 This function is examples 8, 11, 18, and 21.\n\
5092 plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
5096 basex (PLFLT, input) : The normalized x coordinate size of the\n\
5097 rectangular cuboid.\n\
5099 basey (PLFLT, input) : The normalized y coordinate size of the\n\
5100 rectangular cuboid.\n\
5102 height (PLFLT, input) : The normalized z coordinate size of the\n\
5103 rectangular cuboid.\n\
5105 xmin (PLFLT, input) : The minimum x world coordinate of the\n\
5106 rectangular cuboid.\n\
5108 xmax (PLFLT, input) : The maximum x world coordinate of the\n\
5109 rectangular cuboid.\n\
5111 ymin (PLFLT, input) : The minimum y world coordinate of the\n\
5112 rectangular cuboid.\n\
5114 ymax (PLFLT, input) : The maximum y world coordinate of the\n\
5115 rectangular cuboid.\n\
5117 zmin (PLFLT, input) : The minimum z world coordinate of the\n\
5118 rectangular cuboid.\n\
5120 zmax (PLFLT, input) : The maximum z world coordinate of the\n\
5121 rectangular cuboid.\n\
5123 alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
5124 plane of the rectangular cuboid in normalized coordinates.\n\
5126 az (PLFLT, input) : The viewing azimuth in degrees of the\n\
5127 rectangular cuboid in normalized coordinates. When az=0, the\n\
5128 observer is looking face onto the zx plane of the rectangular\n\
5129 cuboid in normalized coordinates, and as az is increased, the\n\
5130 observer moves clockwise around that cuboid when viewed from above\n\
5134 Draw filled polygon\n\
5138 Fills the polygon defined by the n points (\n\
5140 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
5141 style is a solid fill. The routine will automatically close the\n\
5142 polygon between the last and first vertices. If multiple closed\n\
5143 polygons are passed in x and y then plfill will fill in between them.\n\
5145 Redacted form: plfill(x,y)\n\
5147 This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
5157 n (PLINT, input) : Number of vertices in polygon.\n\
5159 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5162 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5166 Magnitude colored plot surface with contour\n\
5170 Aside from dropping the\n\
5171 side functionality this is a more powerful form of plot3d: the surface\n\
5172 mesh can be colored accordingly to the current z value being plotted,\n\
5173 a contour plot can be drawn at the base XY plane, and a curtain can be\n\
5174 drawn between the plotted function border and the base XY plane. The\n\
5175 arguments are identical to those of plmeshc. The only difference\n\
5176 between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
5177 the surface, while plot3dc only draws the surface as viewed from the\n\
5180 Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
5183 This function is used in example 21.\n\
5189 plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
5193 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5194 which the function is evaluated.\n\
5196 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5197 which the function is evaluated.\n\
5199 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5200 plot. Should have dimensions of\n\
5204 nx (PLINT, input) : Number of x values at which function is\n\
5207 ny (PLINT, input) : Number of y values at which function is\n\
5210 opt (PLINT, input) : Determines the way in which the surface is\n\
5211 represented. To specify more than one option just add the options,\n\
5212 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
5213 showing z as a function of x for each value of y[j] .\n\
5214 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5215 for each value of x[i] .\n\
5216 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5217 at which function is defined.\n\
5218 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
5219 the z value being plotted. The color is used from the current\n\
5221 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5225 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5226 the borders of the plotted function.\n\
5229 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
5232 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
5235 Write text relative to viewport boundaries\n\
5239 Writes text at a specified position relative to the viewport\n\
5240 boundaries. Text may be written inside or outside the viewport, but\n\
5241 is clipped at the subpage boundaries. The reference point of a string\n\
5242 lies along a line passing through the string at half the height of a\n\
5243 capital letter. The position of the reference point along this line\n\
5244 is determined by just, and the position of the reference point\n\
5245 relative to the viewport is set by disp and pos.\n\
5247 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
5250 This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
5257 plmtex(side, disp, pos, just, text)\n\
5261 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5262 the side of the viewport along which the text is to be written.\n\
5263 The string must be one of: b: Bottom of viewport, text written\n\
5264 parallel to edge.\n\
5265 bv: Bottom of viewport, text written at right angles to edge.\n\
5266 l: Left of viewport, text written parallel to edge.\n\
5267 lv: Left of viewport, text written at right angles to edge.\n\
5268 r: Right of viewport, text written parallel to edge.\n\
5269 rv: Right of viewport, text written at right angles to edge.\n\
5270 t: Top of viewport, text written parallel to edge.\n\
5271 tv: Top of viewport, text written at right angles to edge.\n\
5274 disp (PLFLT, input) : Position of the reference point of string,\n\
5275 measured outwards from the specified viewport edge in units of the\n\
5276 current character height. Use negative disp to write within the\n\
5279 pos (PLFLT, input) : Position of the reference point of string\n\
5280 along the specified edge, expressed as a fraction of the length of\n\
5283 just (PLFLT, input) : Specifies the position of the string relative\n\
5284 to its reference point. If just=0. , the reference point is at\n\
5285 the left and if just=1. , it is at the right of the string. Other\n\
5286 values of just give intermediate justifications.\n\
5288 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5292 Set arrow style for vector plots\n\
5296 Set the style for the arrow used by plvect to plot vectors.\n\
5298 Redacted form: plsvect(arrowx, arrowy, fill)\n\
5300 This function is used in example 22.\n\
5306 plsvect(arrowx, arrowy, npts, fill)\n\
5310 arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
5311 the x and y points which make up the arrow. The arrow is plotted\n\
5312 by joining these points to form a polygon. The scaling assumes\n\
5313 that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
5314 <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
5315 will be reset to its default.\n\
5317 npts (PLINT, input) : Number of points in the vectors arrowx and\n\
5320 fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
5321 fill is false then the arrow is open.\n\
5324 Get family file parameters\n\
5328 Gets information about current family file, if familying is enabled.\n\
5329 See the PLplot documentation for more information.\n\
5331 Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5333 This function is used in examples 14 and 31.\n\
5339 plgfam(p_fam, p_num, p_bmax)\n\
5343 p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5344 family flag value. If nonzero, familying is enabled for the\n\
5347 p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5348 family file number.\n\
5350 p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5351 file size (in bytes) for a family file.\n\
5354 Random number generator returning a real random number in the range [0,1]\n\
5358 Random number generator returning a real random number in the range\n\
5359 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
5360 / compilers provide their own random number generator, and so this is\n\
5361 provided purely for convenience and to give a consistent random number\n\
5362 generator across all languages supported by PLplot. This is\n\
5363 particularly useful for comparing results from the test suite of\n\
5366 Redacted form: plrandd()\n\
5368 This function is used in examples 17 and 21.\n\
5381 Draws a contour plot of the data in f[\n\
5383 ny], using the nlevel contour levels specified by clevel. Only the\n\
5384 region of the matrix from kx to lx and from ky to ly is plotted out\n\
5385 where all these index ranges are interpreted as one-based for\n\
5386 historical reasons. A transformation routine pointed to by pltr with\n\
5387 a generic pointer pltr_data for additional data required by the\n\
5388 transformation routine is used to map indices within the matrix to the\n\
5389 world coordinates.\n\
5391 Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5392 where (see above discussion) the pltr, pltr_data callback arguments\n\
5393 are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5394 vectors; or xg and yg matrices.\n\
5396 This function is used in examples 9, 14, 16, and 22.\n\
5402 plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5406 f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5408 nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5410 kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5411 kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5412 zero-based for historical backwards-compatibility reasons.\n\
5414 ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5415 ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5416 zero-based for historical backwards-compatibility reasons.\n\
5418 clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5419 which to draw contours.\n\
5421 nlevel (PLINT, input) : Number of contour levels to draw.\n\
5423 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5424 defines the transformation between the zero-based indices of the\n\
5425 matrix f and the world coordinates.For the C case, transformation\n\
5426 functions are provided in the PLplot library: pltr0 for the\n\
5427 identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5428 respectively defined by vectors and matrices. In addition, C\n\
5429 callback routines for the transformation can be supplied by the\n\
5430 user such as the mypltr function in examples/c/x09c.c which\n\
5431 provides a general linear transformation between index coordinates\n\
5432 and world coordinates.For languages other than C you should\n\
5433 consult the PLplot documentation for the details concerning how\n\
5434 PLTRANSFORM_callback arguments are interfaced. However, in\n\
5435 general, a particular pattern of callback-associated arguments\n\
5436 such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5437 yg matrices are respectively interfaced to a linear-transformation\n\
5438 routine similar to the above mypltr function; pltr1; and pltr2.\n\
5439 Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5440 the PLplot documentation) support native language callbacks for\n\
5441 handling index to world-coordinate transformations. Examples of\n\
5442 these various approaches are given in examples/<language>x09*,\n\
5443 examples/<language>x16*, examples/<language>x20*,\n\
5444 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5445 supported languages.\n\
5447 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5448 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5449 that is externally supplied.\n\
5456 This sets up the line style for all lines subsequently drawn. A line\n\
5457 consists of segments in which the pen is alternately down and up. The\n\
5458 lengths of these segments are passed in the vectors mark and space\n\
5459 respectively. The number of mark-space pairs is specified by nms. In\n\
5460 order to return the line style to the default continuous line, plstyl\n\
5461 should be called with nms =0 .(see also pllsty)\n\
5463 Redacted form: plstyl(mark, space)\n\
5465 This function is used in examples 1, 9, and 14.\n\
5471 plstyl(nms, mark, space)\n\
5475 nms (PLINT, input) : The number of mark and space elements in a\n\
5476 line. Thus a simple broken line can be obtained by setting nms=1\n\
5477 . A continuous line is specified by setting nms=0 .\n\
5479 mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
5480 segments during which the pen is down, measured in micrometers.\n\
5482 space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
5483 the segments during which the pen is up, measured in micrometers.\n\
5486 Set the cmap0 palette using the specified cmap0*.pal format file\n\
5490 Set the cmap0 palette using the specified cmap0*.pal format file.\n\
5492 Redacted form: plspal0(filename)\n\
5494 This function is in example 16.\n\
5500 plspal0(filename)\n\
5504 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5505 containing the name of the cmap0*.pal file. If this string is\n\
5506 empty, use the default cmap0*.pal file.\n\
5509 Set the cmap1 palette using the specified cmap1*.pal format file\n\
5513 Set the cmap1 palette using the specified cmap1*.pal format file.\n\
5515 Redacted form: plspal1(filename, interpolate)\n\
5517 This function is used in example 16.\n\
5523 plspal1(filename, interpolate)\n\
5527 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5528 containing the name of the cmap1*.pal file. If this string is\n\
5529 empty, use the default cmap1*.pal file.\n\
5531 interpolate (PLBOOL, input) : If this parameter is true, the\n\
5532 columns containing the intensity index, r, g, b, alpha and\n\
5533 alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
5534 palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
5535 a flag which controls whether the r, g, b data sent to plscmap1la\n\
5536 are interpreted as HLS or RGB.) If this parameter is false, the\n\
5537 intensity index and alt_hue_path columns are ignored and the r, g,\n\
5538 b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
5539 are used instead to set the cmap1 palette directly with a call to\n\
5543 Set current output stream\n\
5547 Sets the number of the current output stream. The stream number\n\
5548 defaults to 0 unless changed by this routine. The first use of this\n\
5549 routine must be followed by a call initializing PLplot (e.g. plstar).\n\
5551 Redacted form: plsstrm(strm)\n\
5553 This function is examples 1,14,20.\n\
5563 strm (PLINT, input) : The current stream number.\n\
5566 Specify viewport using normalized subpage coordinates\n\
5570 Device-independent routine for setting up the viewport. This defines\n\
5571 the viewport in terms of normalized subpage coordinates which run from\n\
5572 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
5573 current subpage. Use the alternate routine plsvpa in order to create\n\
5574 a viewport of a definite size.\n\
5576 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
5578 This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
5579 24, 26, 27, and 31.\n\
5585 plvpor(xmin, xmax, ymin, ymax)\n\
5589 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5590 left-hand edge of the viewport.\n\
5592 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5593 right-hand edge of the viewport.\n\
5595 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5596 bottom edge of the viewport.\n\
5598 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5599 edge of the viewport.\n\
5602 Write text inside the viewport\n\
5606 Writes text at a specified position and inclination within the\n\
5607 viewport. Text is clipped at the viewport boundaries. The reference\n\
5608 point of a string lies along a line passing through the string at half\n\
5609 the height of a capital letter. The position of the reference point\n\
5610 along this line is determined by just, the reference point is placed\n\
5611 at world coordinates (\n\
5613 y) within the viewport. The inclination of the string is specified\n\
5614 in terms of differences of world coordinates making it easy to write\n\
5615 text parallel to a line in a graph.\n\
5617 Redacted form: plptex(x, y, dx, dy, just, text)\n\
5619 This function is used in example 2-4,10,12-14,20,23,24,26.\n\
5625 plptex(x, y, dx, dy, just, text)\n\
5629 x (PLFLT, input) : x coordinate of reference point of string.\n\
5631 y (PLFLT, input) : y coordinate of reference point of string.\n\
5633 dx (PLFLT, input) : Together with dy, this specifies the\n\
5634 inclination of the string. The baseline of the string is parallel\n\
5635 to a line joining (\n\
5643 dy (PLFLT, input) : Together with dx, this specifies the\n\
5644 inclination of the string.\n\
5646 just (PLFLT, input) : Specifies the position of the string relative\n\
5647 to its reference point. If just=0. , the reference point is at\n\
5648 the left and if just=1. , it is at the right of the string. Other\n\
5649 values of just give intermediate justifications.\n\
5651 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5655 Set z axis parameters\n\
5659 Identical to plsxax, except that arguments are flags for z axis. See\n\
5660 the description of plsxax for more detail.\n\
5662 Redacted form: plszax(digmax, digits)\n\
5664 This function is used in example 31.\n\
5670 plszax(digmax, digits)\n\
5674 digmax (PLINT, input) : Variable to set the maximum number of\n\
5675 digits for the z axis. If nonzero, the printed label will be\n\
5676 switched to a floating-point representation when the number of\n\
5677 digits exceeds digmax.\n\
5679 digits (PLINT, input) : Field digits value. Currently, changing\n\
5680 its value here has no effect since it is set only by plbox or\n\
5681 plbox3. However, the user may obtain its value after a call to\n\
5682 either of these functions by calling plgzax.\n\
5685 Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
5689 This variant of plsurf3d (see that function\'s documentation for more\n\
5690 details) should be suitable for the case where the area of the x, y\n\
5691 coordinate grid where z is defined can be non-rectangular. The limits\n\
5692 of that grid are provided by the parameters indexxmin, indexxmax,\n\
5693 indexymin, and indexymax.\n\
5695 Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
5698 This function is used in example 8.\n\
5704 plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
5708 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5709 which the function is evaluated.\n\
5711 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5712 which the function is evaluated.\n\
5714 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5715 plot. Should have dimensions of\n\
5719 nx (PLINT, input) : Number of x values at which function is\n\
5722 ny (PLINT, input) : Number of y values at which function is\n\
5725 opt (PLINT, input) : Determines the way in which the surface is\n\
5726 represented. To specify more than one option just add the options,\n\
5727 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
5728 connecting points at which function is defined.\n\
5729 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5733 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
5737 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5738 the borders of the plotted function.\n\
5739 opt=MAG_COLOR : the surface is colored according to the value\n\
5740 of Z; if MAG_COLOR is not used, then the surface is colored\n\
5741 according to the intensity of the reflected light in the\n\
5742 surface from a light source whose position is set using\n\
5746 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
5749 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
5751 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
5752 corresponds to the first x index where z is defined.\n\
5754 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
5755 which corresponds (by convention) to one more than the last x\n\
5756 index value where z is defined.\n\
5758 indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
5759 values which all must be ≥ 0. These values are the first y index\n\
5760 where z is defined for a particular x index in the range from\n\
5761 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
5764 indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
5765 values which all must be ≤ ny. These values correspond (by\n\
5766 convention) to one more than the last y index where z is defined\n\
5767 for a particular x index in the range from indexxmin to indexxmax\n\
5768 - 1. The dimension of indexymax is indexxmax.\n\
5775 Sets the font used for subsequent text and symbols. For devices that\n\
5776 still use Hershey fonts this routine has no effect unless the Hershey\n\
5777 fonts with extended character set are loaded (see plfontld). For\n\
5778 unicode-aware devices that use system fonts instead of Hershey fonts,\n\
5779 this routine calls the plsfci routine with argument set up\n\
5780 appropriately for the various cases below. However, this method of\n\
5781 specifying the font for unicode-aware devices is deprecated, and the\n\
5782 much more flexible method of calling plsfont directly is recommended\n\
5783 instead (where plsfont provides a user-friendly interface to plsfci),\n\
5785 Redacted form: plfont(ifont)\n\
5787 This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
5797 ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
5798 (simplest and fastest)\n\
5804 Get the cmap1 argument range for continuous color plots\n\
5808 Get the cmap1 argument range for continuous color plots. (Use\n\
5809 plscmap1_range to set the cmap1 argument range.)\n\
5811 Redacted form: plgcmap1_range(min_color, max_color)\n\
5813 This function is currently not used in any example.\n\
5819 plgcmap1_range(min_color, max_color)\n\
5823 min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5824 minimum cmap1 argument.\n\
5826 max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5827 maximum cmap1 argument.\n\
5830 Set the cmap1 argument range for continuous color plots\n\
5834 Set the cmap1 argument range for continuous color plots that\n\
5835 corresponds to the range of data values. The maximum range\n\
5836 corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
5837 the cmap1 argument range that is specified with this routine, the\n\
5838 smaller the subset of the cmap1 color palette that is used to\n\
5839 represent the continuous data being plotted. If\n\
5840 min_color is greater than\n\
5842 max_color is greater than 1.0 or\n\
5843 min_color is less than 0.0 then no change is made to the cmap1\n\
5844 argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
5846 Redacted form: plscmap1_range(min_color, max_color)\n\
5848 This function is currently used in example 33.\n\
5854 plscmap1_range(min_color, max_color)\n\
5858 min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
5859 than 0.0, then 0.0 is used instead.\n\
5861 max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
5862 than 1.0, then 1.0 is used instead.\n\
5865 Draw a circular or elliptical arc\n\
5869 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
5870 semiminor axis b, starting at angle1 and ending at angle2.\n\
5872 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
5876 This function is used in examples 3 and 27.\n\
5882 plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
5886 x (PLFLT, input) : X coordinate of arc center.\n\
5888 y (PLFLT, input) : Y coordinate of arc center.\n\
5890 a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
5892 b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
5894 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
5897 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
5900 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
5903 fill (PLBOOL, input) : Draw a filled arc.\n\
5906 Plot 3-d surface plot\n\
5910 Plots a three-dimensional surface plot within the environment set up\n\
5911 by plw3d. The surface is defined by the matrix z[\n\
5913 ny] , the point z[i][j] being the value of the function at (\n\
5915 y[j]). Note that the points in vectors x and y do not need to be\n\
5916 equally spaced, but must be stored in ascending order. The parameter\n\
5917 opt controls the way in which the surface is displayed. For further\n\
5918 details see the PLplot documentation. The only difference between\n\
5919 plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5920 while plot3d only draws the surface as viewed from the top.\n\
5922 Redacted form: plot3d(x, y, z, opt, side)\n\
5924 This function is used in examples 11 and 21.\n\
5930 plot3d(x, y, z, nx, ny, opt, side)\n\
5934 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5935 which the function is evaluated.\n\
5937 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5938 which the function is evaluated.\n\
5940 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5941 plot. Should have dimensions of\n\
5945 nx (PLINT, input) : Number of x values at which function is\n\
5948 ny (PLINT, input) : Number of y values at which function is\n\
5951 opt (PLINT, input) : Determines the way in which the surface is\n\
5952 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5953 function of x for each value of y[j] .\n\
5954 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5955 for each value of x[i] .\n\
5956 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5957 at which function is defined.\n\
5960 side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5961 should be draw on the figure. If side is true sides are drawn,\n\
5962 otherwise no sides are drawn.\n\
5965 Set area line fill pattern\n\
5969 Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
5970 The pattern consists of 1 or 2 sets of parallel lines with specified\n\
5971 inclinations and spacings. The arguments to this routine are the\n\
5972 number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
5973 elements) specifying the inclinations in tenths of a degree and the\n\
5974 spacing in micrometers. (See also plpsty)\n\
5976 Redacted form: General: plpat(inc, del)\n\
5979 This function is used in example 15.\n\
5985 plpat(nlin, inc, del)\n\
5989 nlin (PLINT, input) : Number of sets of lines making up the\n\
5990 pattern, either 1 or 2.\n\
5992 inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5993 inclination in tenths of a degree. (Should be between -900 and\n\
5996 del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5997 spacing in micrometers between the lines making up the pattern.\n\
6000 Get x axis parameters\n\
6004 Returns current values of the p_digmax and p_digits flags for the x\n\
6005 axis. p_digits is updated after the plot is drawn, so this routine\n\
6006 should only be called after the call to plbox (or plbox3) is complete.\n\
6007 See the PLplot documentation for more information.\n\
6009 Redacted form: plgxax(p_digmax, p_digits)\n\
6011 This function is used in example 31.\n\
6017 plgxax(p_digmax, p_digits)\n\
6021 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6022 number of digits for the x axis. If nonzero, the printed label\n\
6023 has been switched to a floating-point representation when the\n\
6024 number of digits exceeds this value.\n\
6026 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
6027 number of digits for the numeric labels (x axis) from the last\n\
6031 Draw filled polygon in 3D\n\
6035 Fills the 3D polygon defined by the n points in the x, y, and z\n\
6036 vectors using the pattern defined by plpsty or plpat. The routine\n\
6037 will automatically close the polygon between the last and first\n\
6038 vertices. If multiple closed polygons are passed in x, y, and z then\n\
6039 plfill3 will fill in between them.\n\
6041 Redacted form: General: plfill3(x, y, z)\n\
6044 This function is used in example 15.\n\
6050 plfill3(n, x, y, z)\n\
6054 n (PLINT, input) : Number of vertices in polygon.\n\
6056 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6059 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6062 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
6070 Sets the color index for cmap0 (see the PLplot documentation).\n\
6072 Redacted form: plcol0(icol0)\n\
6074 This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6084 icol0 (PLINT, input) : Integer representing the color. The\n\
6085 defaults at present are (these may change):\n\
6086 0 black (default background)\n\
6087 1 red (default foreground)\n\
6103 Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6104 change an individual color in the cmap0 color palette.\n\
6107 Draw text at points defined by Shapefile data in world coordinates\n\
6111 As per plmapline, however the items are plotted as text in the same\n\
6114 Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
6115 miny, maxy, plotentry)\n\
6117 This function is used in example 19.\n\
6123 plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
6127 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6128 transform the coordinates given in the shapefile into a plot\n\
6129 coordinate system. By using this transform, we can change from a\n\
6130 longitude, latitude coordinate to a polar stereographic project,\n\
6131 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6132 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6133 mapform(), x[] and y[] should be replaced by the corresponding\n\
6134 plot coordinates. If no transform is desired, mapform can be\n\
6135 replaced by NULL.\n\
6137 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6138 the file name of a set of Shapefile files without the file\n\
6141 dx (PLFLT, input) : Used to define the slope of the texts which is\n\
6144 dy (PLFLT, input) : Used to define the slope of the texts which is\n\
6147 just (PLFLT, input) : Set the justification of the text. The value\n\
6148 given will be the fraction of the distance along the string that\n\
6149 sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
6150 centralized text and 1.0 gives right aligned text.\n\
6152 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
6154 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6155 be in the same units as used by the Shapefile. You could use a\n\
6156 very large negative number to plot everything, but you can improve\n\
6157 performance by limiting the area drawn. The units must match those\n\
6158 of the Shapefile projection, which may be for example longitude or\n\
6159 distance. The value of minx must be less than the value of maxx.\n\
6161 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6162 use a very large number to plot everything, but you can improve\n\
6163 performance by limiting the area drawn.\n\
6165 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6166 be in the same units as used by the Shapefile. You could use a\n\
6167 very large negative number to plot everything, but you can improve\n\
6168 performance by limiting the area drawn. The units must match those\n\
6169 of the Shapefile projection, which may be for example latitude or\n\
6170 distance. The value of miny must be less than the value of maxy.\n\
6172 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6173 use a very large number to plot everything, but you can improve\n\
6174 performance by limiting the area drawn.\n\
6176 plotentry (PLINT, input) : An integer indicating which text string\n\
6177 of the Shapefile (zero indexed) will be drawn.\n\
6180 Draw a line between two points\n\
6184 Joins the point (\n\
6190 Redacted form: pljoin(x1,y1,x2,y2)\n\
6192 This function is used in examples 3 and 14.\n\
6198 pljoin(x1, y1, x2, y2)\n\
6202 x1 (PLFLT, input) : x coordinate of first point.\n\
6204 y1 (PLFLT, input) : y coordinate of first point.\n\
6206 x2 (PLFLT, input) : x coordinate of second point.\n\
6208 y2 (PLFLT, input) : y coordinate of second point.\n\
6215 Sets the color for cmap1 (see the PLplot documentation).\n\
6217 Redacted form: plcol1(col1)\n\
6219 This function is used in examples 12 and 21.\n\
6229 col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6230 is mapped to color using the continuous cmap1 palette which by\n\
6231 default ranges from blue to the background color to red. The\n\
6232 cmap1 palette can also be straightforwardly changed by the user\n\
6233 with plscmap1 or plscmap1l.\n\
6240 Set integer plot orientation parameter. This function is identical to\n\
6241 plsdiori except for the type of the argument, and should be used in\n\
6242 the same way. See the documentation of plsdiori for details.\n\
6244 Redacted form: plsori(ori)\n\
6246 This function is used in example 3.\n\
6256 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
6257 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
6261 Calculate continuous time from broken-down time for the current stream\n\
6265 Calculate continuous time, ctime, from broken-down time for the\n\
6266 current stream. The broken-down\n\
6267 time is specified by the following parameters: year, month, day, hour,\n\
6268 min, and sec. This function is the inverse of plbtime.\n\
6270 The PLplot definition of broken-down time is a calendar time that\n\
6271 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6272 responsibility to apply those offsets (if so desired) before using the\n\
6273 PLplot time API. By default broken-down time is defined using the\n\
6274 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6275 continuous time is defined as the number of seconds since the Unix\n\
6276 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6277 broken-down and continuous time are possible, see plconfigtime which\n\
6278 specifies that transformation for the current stream.\n\
6280 Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6284 This function is used in example 29.\n\
6290 plctime(year, month, day, hour, min, sec, ctime)\n\
6294 year (PLINT, input) : Input year.\n\
6296 month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6299 day (PLINT, input) : Input day in range from 1 to 31.\n\
6301 hour (PLINT, input) : Input hour in range from 0 to 23\n\
6303 min (PLINT, input) : Input minute in range from 0 to 59.\n\
6305 sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6307 ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6308 time calculated from the broken-down time specified by the\n\
6309 previous parameters.\n\
6312 Plot continental outline or shapefile data in world coordinates\n\
6316 Plots continental outlines or shapefile data in world coordinates. A\n\
6317 demonstration of how to use this function to create different\n\
6318 projections can be found in examples/c/x19c. PLplot is provided with\n\
6319 basic coastal outlines and USA state borders. To use the map\n\
6320 functionality PLplot must be compiled with the shapelib library.\n\
6321 Shapefiles have become a popular standard for geographical data and\n\
6322 data in this format can be easily found from a number of online\n\
6323 sources. Shapefile data is actually provided as three or more files\n\
6324 with the same filename, but different extensions. The .shp and .shx\n\
6325 files are required for plotting Shapefile data with PLplot.\n\
6327 PLplot currently supports the point, multipoint, polyline and polygon\n\
6328 objects within shapefiles. However holes in polygons are not\n\
6329 supported. When plmap is used the type of object is derived from the\n\
6330 shapefile, if you wish to override the type then use one of the other\n\
6331 plmap variants. The built in maps have line data only.\n\
6333 Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
6335 This function is used in example 19.\n\
6341 plmap(mapform, name, minx, maxx, miny, maxy)\n\
6345 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6346 transform the original map data coordinates to a new coordinate\n\
6347 system. The PLplot-supplied map data is provided as latitudes and\n\
6348 longitudes; other Shapefile data may be provided in other\n\
6349 coordinate systems as can be found in their .prj plain text files.\n\
6350 For example, by using this transform we can change from a\n\
6351 longitude, latitude coordinate to a polar stereographic\n\
6352 projection. Initially, x[0]..[n-1] are the original x coordinates\n\
6353 (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
6354 corresponding y coordinates (latitudes for the PLplot supplied\n\
6355 data). After the call to mapform(), x[] and y[] should be\n\
6356 replaced by the corresponding plot coordinates. If no transform is\n\
6357 desired, mapform can be replaced by NULL.\n\
6359 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6360 the type of map plotted. This is either one of the PLplot built-in\n\
6361 maps or the file name of a set of Shapefile files without the file\n\
6362 extensions. For the PLplot built-in maps the possible values are:\n\
6363 \"globe\" -- continental outlines\n\
6364 \"usa\" -- USA and state boundaries\n\
6365 \"cglobe\" -- continental outlines and countries\n\
6366 \"usaglobe\" -- USA, state boundaries and continental outlines\n\
6369 minx (PLFLT, input) : The minimum x value of map elements to be\n\
6370 drawn. The units must match the shapefile (built in maps are\n\
6371 degrees lat/lon). Objects in the file which do not encroach on the\n\
6372 box defined by minx, maxx, miny, maxy will not be rendered. But\n\
6373 note this is simply an optimisation, not a clipping so for objects\n\
6374 with some points inside the box and some points outside the box\n\
6375 all the points will be rendered. These parameters also define\n\
6376 latitude and longitude wrapping for shapefiles using these units.\n\
6377 Longitude points will be wrapped by integer multiples of 360\n\
6378 degrees to place them in the box. This allows the same data to be\n\
6379 used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
6380 you plot from -180-540 you will get two cycles of data drawn. The\n\
6381 value of minx must be less than the value of maxx. Passing in a\n\
6382 nan, max/-max floating point number or +/-infinity will case the\n\
6383 bounding box from the shapefile to be used.\n\
6385 maxx (PLFLT, input) : The maximum x value of map elements to be\n\
6386 drawn - see minx.\n\
6388 miny (PLFLT, input) : The minimum y value of map elements to be\n\
6389 drawn - see minx.\n\
6391 maxy (PLFLT, input) : The maximum y value of map elements to be\n\
6392 drawn - see minx.\n\
6395 Calculate broken-down time from continuous time for the current stream\n\
6399 Calculate broken-down time; year, month, day, hour, min, sec; from\n\
6400 continuous time, ctime for the current stream. This function is the\n\
6401 inverse of plctime.\n\
6403 The PLplot definition of broken-down time is a calendar time that\n\
6404 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6405 responsibility to apply those offsets (if so desired) before using the\n\
6406 PLplot time API. By default broken-down time is defined using the\n\
6407 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6408 continuous time is defined as the number of seconds since the Unix\n\
6409 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6410 broken-down and continuous time are possible, see plconfigtime.\n\
6412 Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
6416 This function is used in example 29.\n\
6422 plbtime(year, month, day, hour, min, sec, ctime)\n\
6426 year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
6427 positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
6428 non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
6431 month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
6432 the year in the range from 0 (January) to 11 (December).\n\
6434 day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
6435 month in the range from 1 to 31.\n\
6437 hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
6438 day in the range from 0 to 23.\n\
6440 min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
6441 hour in the range from 0 to 59\n\
6443 sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
6444 minute in range from 0. to 60.\n\
6446 ctime (PLFLT, input) : Continuous time from which the broken-down\n\
6447 time is calculated.\n\
6450 Get current stream number\n\
6454 Gets the number of the current output stream. See also plsstrm.\n\
6456 Redacted form: plgstrm(p_strm)\n\
6458 This function is used in example 1,20.\n\
6468 p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6472 Draw a line in 3 space\n\
6476 Draws line in 3 space defined by n points in x, y, and z. You must\n\
6477 first set up the viewport, the 2d viewing window (in world\n\
6478 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
6481 Redacted form: plline3(x, y, z)\n\
6483 This function is used in example 18.\n\
6489 plline3(n, x, y, z)\n\
6493 n (PLINT, input) : Number of points defining line.\n\
6495 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6498 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6501 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
6505 Load Hershey fonts\n\
6509 Loads the Hershey fonts used for text and symbols. This routine may\n\
6510 be called before or after initializing PLplot. If not explicitly\n\
6511 called before PLplot initialization, then by default that\n\
6512 initialization loads Hershey fonts with the extended character set.\n\
6513 This routine only has a practical effect for devices that still use\n\
6514 Hershey fonts (as opposed to modern devices that use unicode-aware\n\
6515 system fonts instead of Hershey fonts).\n\
6517 Redacted form: plfontld(fnt)\n\
6519 This function is used in examples 1 and 7.\n\
6529 fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
6530 A zero value specifies Hershey fonts with the standard character\n\
6531 set and a non-zero value (the default assumed if plfontld is never\n\
6532 called) specifies Hershey fonts with the extended character set.\n\
6535 Set any command-line option\n\
6539 Set any command-line option internally from a program before it\n\
6540 invokes plinit. opt is the name of the command-line option and optarg\n\
6541 is the corresponding command-line option argument.\n\
6543 This function returns 0 on success.\n\
6545 Redacted form: plsetopt(opt, optarg)\n\
6547 This function is used in example 14.\n\
6553 PLINT plsetopt(opt, optarg)\n\
6557 opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6558 the command-line option.\n\
6560 optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
6561 containing the argument of the command-line option.\n\
6564 Plot all or a subset of Shapefile data using lines in world coordinates\n\
6568 Plot all or a subset of Shapefile data using lines in world\n\
6569 coordinates. Our 19th standard example demonstrates how to use this\n\
6570 function. This function plots data from a Shapefile using lines as in\n\
6571 plmap, however it also has the option of also only drawing specified\n\
6572 elements from the Shapefile. The vector of indices of the required\n\
6573 elements are passed as a function argument. The Shapefile data should\n\
6574 include a metadata file (extension.dbf) listing all items within the\n\
6575 Shapefile. This file can be opened by most popular spreadsheet\n\
6576 programs and can be used to decide which indices to pass to this\n\
6579 Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
6582 This function is used in example 19.\n\
6588 plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6592 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6593 transform the coordinates given in the shapefile into a plot\n\
6594 coordinate system. By using this transform, we can change from a\n\
6595 longitude, latitude coordinate to a polar stereographic project,\n\
6596 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6597 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6598 mapform(), x[] and y[] should be replaced by the corresponding\n\
6599 plot coordinates. If no transform is desired, mapform can be\n\
6600 replaced by NULL.\n\
6602 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6603 the file name of a set of Shapefile files without the file\n\
6606 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6607 be in the same units as used by the Shapefile. You could use a\n\
6608 very large negative number to plot everything, but you can improve\n\
6609 performance by limiting the area drawn. The units must match those\n\
6610 of the Shapefile projection, which may be for example longitude or\n\
6611 distance. The value of minx must be less than the value of maxx.\n\
6613 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6614 use a very large number to plot everything, but you can improve\n\
6615 performance by limiting the area drawn.\n\
6617 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6618 be in the same units as used by the Shapefile. You could use a\n\
6619 very large negative number to plot everything, but you can improve\n\
6620 performance by limiting the area drawn. The units must match those\n\
6621 of the Shapefile projection, which may be for example latitude or\n\
6622 distance. The value of miny must be less than the value of maxy.\n\
6624 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6625 use a very large number to plot everything, but you can improve\n\
6626 performance by limiting the area drawn.\n\
6628 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6629 zero-based indices of the Shapefile elements which will be drawn.\n\
6631 plotentries to NULL will plot all elements of the Shapefile.\n\
6633 nplotentries (PLINT, input) : The number of items in\n\
6634 plotentries. Ignored if\n\
6635 plotentries is NULL.\n\
6638 Used to globally turn color output on/off\n\
6642 Used to globally turn color output on/off for those drivers/devices\n\
6645 Redacted form: plscolor(color)\n\
6647 This function is used in example 31.\n\
6657 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6658 turned off. If non-zero, color is turned on.\n\
6661 Wait for graphics input event and translate to world coordinates.\n\
6665 Wait for graphics input event and translate to world coordinates.\n\
6666 Returns 0 if no translation to world coordinates is possible.\n\
6668 This function returns 1 on success and 0 if no translation to world\n\
6669 coordinates is possible.\n\
6671 Redacted form: plGetCursor(gin)\n\
6673 This function is used in examples 1 and 20.\n\
6679 PLINT plGetCursor(gin)\n\
6683 gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
6684 which will contain the output. The structure is not allocated by\n\
6685 the routine and must exist before the function is called.\n\
6688 Get the current device (keyword) name\n\
6692 Get the current device (keyword) name. Note: you must have allocated\n\
6693 space for this (80 characters is safe).\n\
6695 Redacted form: plgdev(p_dev)\n\
6697 This function is used in example 14.\n\
6707 p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
6708 (with preallocated length of 80 characters or more) containing the\n\
6709 device (keyword) name.\n\
6712 Add a point to a strip chart\n\
6716 Add a point to a given pen of a given strip chart. There is no need\n\
6717 for all pens to have the same number of points or to be equally\n\
6718 sampled in the x coordinate. Allocates memory and rescales as\n\
6721 Redacted form: plstripa(id, pen, x, y)\n\
6723 This function is used in example 17.\n\
6729 plstripa(id, pen, x, y)\n\
6733 id (PLINT, input) : Identification number of the strip chart (set\n\
6736 pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
6738 x (PLFLT, input) : X coordinate of point to plot.\n\
6740 y (PLFLT, input) : Y coordinate of point to plot.\n\
6743 Create a 4-pen strip chart\n\
6747 Create a 4-pen strip chart, to be used afterwards by plstripa\n\
6749 Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
6750 ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
6751 styline, legline, labx, laby, labz)\n\
6754 This function is used in example 17.\n\
6760 plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
6764 id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
6765 number of the strip chart to use on plstripa and plstripd.\n\
6767 xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6768 the x-axis specification as in plbox.\n\
6770 yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6771 the y-axis specification as in plbox.\n\
6773 xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6774 change as data are added.\n\
6776 xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6777 change as data are added.\n\
6779 xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
6780 is multiplied by the factor (1 +\n\
6783 ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6784 change as data are added.\n\
6786 ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6787 change as data are added.\n\
6789 xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
6791 ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
6793 y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
6794 true, otherwise not.\n\
6796 acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
6797 otherwise slide display.\n\
6799 colbox (PLINT, input) : Plot box color index (cmap0).\n\
6801 collab (PLINT, input) : Legend color index (cmap0).\n\
6803 colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
6804 indices for the 4 pens.\n\
6806 styline (PLINT_VECTOR, input) : A vector containing the line style\n\
6807 indices for the 4 pens.\n\
6809 legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
6810 strings containing legends for the 4 pens.\n\
6812 labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6813 the label for the x axis.\n\
6815 laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6816 the label for the y axis.\n\
6818 labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6822 Deletes and releases memory used by a strip chart\n\
6826 Deletes and releases memory used by a strip chart.\n\
6828 Redacted form: plstripd(id)\n\
6830 This function is used in example 17.\n\
6840 id (PLINT, input) : Identification number of strip chart to delete.\n\
6843 Specify viewport using coordinates and aspect ratio\n\
6847 Device-independent routine for setting up the viewport. The viewport\n\
6848 is chosen to be the largest with the given aspect ratio that fits\n\
6849 within the specified region (in terms of normalized subpage\n\
6850 coordinates). This routine is functionally equivalent to plvpor when\n\
6851 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
6852 routine reserves no extra space at the edges for labels.\n\
6854 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6856 This function is used in example 9.\n\
6862 plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6866 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
6867 left-hand edge of the viewport.\n\
6869 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
6870 right-hand edge of the viewport.\n\
6872 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
6873 bottom edge of the viewport.\n\
6875 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
6876 edge of the viewport.\n\
6878 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
6882 Assign a function to use for generating custom axis labels\n\
6886 This function allows a user to provide their own function to provide\n\
6887 axis label text. The user function is given the numeric value for a\n\
6888 point on an axis and returns a string label to correspond with that\n\
6889 value. Custom axis labels can be enabled by passing appropriate\n\
6890 arguments to plenv, plbox, plbox3 and similar functions.\n\
6892 This function is used in example 19.\n\
6898 plslabelfunc(label_func, label_data)\n\
6902 label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
6903 label function. In order to reset to the default labelling, set\n\
6904 this to NULL. The labelling function parameters are, in order:\n\
6905 axis: This indicates which axis a label is being requested for.\n\
6906 The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
6908 value: This is the value along the axis which is being labelled.\n\
6910 label_text: The string representation of the label value.\n\
6912 length: The maximum length in characters allowed for label_text.\n\
6915 label_data (PLPointer, input) : This parameter may be used to pass\n\
6916 data to the label_func function.\n\
6919 Set length of major ticks\n\
6923 This sets up the length of the major ticks. The actual length is the\n\
6924 product of the default length and a scaling factor as for character\n\
6927 Redacted form: plsmaj(def, scale)\n\
6929 This function is used in example 29.\n\
6935 plsmaj(def, scale)\n\
6939 def (PLFLT, input) : The default length of a major tick in\n\
6940 millimeters, should be set to zero if the default length is to\n\
6941 remain unchanged.\n\
6943 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6944 actual tick length.\n\
6947 Get the current library version number\n\
6951 Get the current library version number. Note: you must have allocated\n\
6952 space for this (80 characters is safe).\n\
6954 Redacted form: plgver(p_ver)\n\
6956 This function is used in example 1.\n\
6966 p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
6967 (with preallocated length of 80 characters or more) containing the\n\
6968 PLplot version number.\n\
6971 Set format of numerical label for contours\n\
6975 Set format of numerical label for contours.\n\
6977 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
6979 This function is used example 9.\n\
6985 pl_setcontlabelformat(lexp, sigdig)\n\
6989 lexp (PLINT, input) : If the contour numerical label is greater\n\
6990 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
6991 format is used. Default value of lexp is 4.\n\
6993 sigdig (PLINT, input) : Number of significant digits. Default\n\
6997 Parse command-line arguments\n\
7001 Parse command-line arguments.\n\
7003 plparseopts removes all recognized flags (decreasing argc\n\
7004 accordingly), so that invalid input may be readily detected. It can\n\
7005 also be used to process user command line flags. The user can merge\n\
7006 an option table of type PLOptionTable into the internal option table\n\
7007 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
7008 the external table(s) be parsed by calling plClearOpts before\n\
7011 The default action taken by plparseopts is as follows:\n\
7012 Returns with an error if an unrecognized option or badly formed\n\
7013 option-value pair are encountered.\n\
7014 Returns immediately (return code 0) when the first non-option command\n\
7015 line argument is found.\n\
7016 Returns with the return code of the option handler, if one was called.\n\
7018 Deletes command line arguments from argv list as they are found, and\n\
7019 decrements argc accordingly.\n\
7020 Does not show \"invisible\" options in usage or help messages.\n\
7021 Assumes the program name is contained in argv[0].\n\
7023 These behaviors may be controlled through the\n\
7026 Redacted form: General: plparseopts(argv, mode)\n\
7029 This function is used in all of the examples.\n\
7035 PLINT plparseopts(p_argc, argv, mode)\n\
7039 p_argc (int *, input/output) : Number of arguments.\n\
7041 argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
7042 strings containing *p_argc command-line arguments.\n\
7044 mode (PLINT, input) : Parsing mode with the following\n\
7045 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
7046 and all error messages enabled, including program exit when an\n\
7047 error occurs. Anything on the command line that isn\'t recognized\n\
7048 as a valid option or option argument is flagged as an error.\n\
7049 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
7051 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
7053 PL_PARSE_SHOWALL (8) -- Show invisible options\n\
7054 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
7055 pointer to the program name.\n\
7056 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
7057 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
7058 unrecognized arguments.\n\
7065 Initializing the plotting package. The program prompts for the device\n\
7066 keyword or number of the desired output device. Hitting a RETURN in\n\
7067 response to the prompt is the same as selecting the first device. If\n\
7068 only one device is enabled when PLplot is installed, plstar will issue\n\
7069 no prompt. The output device is divided into nx by ny subpages, each\n\
7070 of which may be used independently. The subroutine pladv is used to\n\
7071 advance from one subpage to the next.\n\
7073 Redacted form: plstar(nx, ny)\n\
7075 This function is used in example 1.\n\
7085 nx (PLINT, input) : Number of subpages to divide output page in the\n\
7088 ny (PLINT, input) : Number of subpages to divide output page in the\n\
7092 Get FCI (font characterization integer)\n\
7096 Gets information about the current font using the FCI approach. See\n\
7097 the PLplot documentation for more information.\n\
7099 Redacted form: plgfci(p_fci)\n\
7101 This function is used in example 23.\n\
7111 p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
7115 Set family file parameters\n\
7119 Sets variables dealing with output file familying. Does nothing if\n\
7120 familying not supported by the driver. This routine, if used, must be\n\
7121 called before initializing PLplot. See the PLplot documentation for\n\
7122 more information.\n\
7124 Redacted form: plsfam(fam, num, bmax)\n\
7126 This function is used in examples 14 and 31.\n\
7132 plsfam(fam, num, bmax)\n\
7136 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
7139 num (PLINT, input) : Current family file number.\n\
7141 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
7145 Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
7149 This is a variant of plscmap1l that supports alpha channel\n\
7150 transparency. It sets cmap1 colors using a piece-wise linear\n\
7151 relationship between cmap1 intensity index (0.0-1.0) and position in\n\
7152 HLS or RGB color space (see the PLplot documentation) with alpha\n\
7153 transparency value (0.0-1.0). It may be called at any time.\n\
7155 Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
7156 alpha, alt_hue_path)\n\
7158 This function is used in example 30.\n\
7164 plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
7168 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
7170 npts (PLINT, input) : number of control points.\n\
7172 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
7173 intensity index (0.0-1.0) in ascending order for each control\n\
7176 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
7177 coordinate (H or R) for each control point.\n\
7179 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
7180 coordinate (L or G) for each control point.\n\
7182 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
7183 coordinate (S or B) for each control point.\n\
7185 alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
7186 transparency value (0.0-1.0) for each control point.\n\
7188 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
7189 npts - 1 elements) containing the alternative interpolation method\n\
7190 Boolean value for each control point interval. (alt_hue_path[i]\n\
7191 refers to the interpolation interval between the i and i + 1\n\
7195 Set page parameters\n\
7199 Sets the page configuration (optional). If an individual parameter is\n\
7200 zero then that parameter value is not updated. Not all parameters are\n\
7201 recognized by all drivers and the interpretation is device-dependent.\n\
7202 The X-window driver uses the length and offset parameters to determine\n\
7203 the window size and location. The length and offset values are\n\
7204 expressed in units that are specific to the current driver. For\n\
7205 instance: screen drivers will usually interpret them as number of\n\
7206 pixels, whereas printer drivers will usually use mm.\n\
7208 This routine, if used, must be called before initializing PLplot. It\n\
7209 may be called at later times for interactive drivers to change only\n\
7210 the dpi for subsequent redraws which you can force via a call to\n\
7211 plreplot. If this function is not called then the page size defaults\n\
7212 to landscape A4 for drivers which use real world page sizes and 744\n\
7213 pixels wide by 538 pixels high for raster drivers. The default value\n\
7214 for dx and dy is 90 pixels per inch for raster drivers.\n\
7218 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
7220 This function is used in examples 14 and 31.\n\
7226 plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
7230 xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
7231 by raster drivers, ignored by drivers which use \"real world\" units\n\
7234 yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
7235 by raster drivers, ignored by drivers which use \"real world\" units\n\
7238 xleng (PLINT, input) : Page length, x.\n\
7240 yleng (PLINT, input) : Page length, y.\n\
7242 xoff (PLINT, input) : Page offset, x.\n\
7244 yoff (PLINT, input) : Page offset, y.\n\
7247 Set precision in numeric labels\n\
7251 Sets the number of places after the decimal point in numeric labels.\n\
7253 Redacted form: plprec(setp, prec)\n\
7255 This function is used in example 29.\n\
7261 plprec(setp, prec)\n\
7265 setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7266 automatically determines the number of places to use after the\n\
7267 decimal point in numeric labels (like those used to label axes).\n\
7268 If setp is 1 then prec sets the number of places.\n\
7270 prec (PLINT, input) : The number of characters to draw after the\n\
7271 decimal point in numeric labels.\n\
7274 Copy state parameters from the reference stream to the current stream\n\
7278 Copies state parameters from the reference stream to the current\n\
7279 stream. Tell driver interface to map device coordinates unless flags\n\
7282 This function is used for making save files of selected plots (e.g.\n\
7283 from the TK driver). After initializing, you can get a copy of the\n\
7284 current plot to the specified device by switching to this stream and\n\
7285 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
7286 appropriate. The plot buffer must have previously been enabled (done\n\
7287 automatically by some display drivers, such as X).\n\
7289 Redacted form: plcpstrm(iplsr, flags)\n\
7291 This function is used in example 1,20.\n\
7297 plcpstrm(iplsr, flags)\n\
7301 iplsr (PLINT, input) : Number of reference stream.\n\
7303 flags (PLBOOL, input) : If flags is set to true the device\n\
7304 coordinates are not copied from the reference to current stream.\n\
7307 Plot a glyph at the specified points\n\
7311 Plot a glyph at the specified points. (This function is largely\n\
7312 superseded by plstring which gives access to many[!] more glyphs.)\n\
7313 code=-1 means try to just draw a point. Right now it\'s just a move\n\
7314 and a draw at the same place. Not ideal, since a sufficiently\n\
7315 intelligent output device may optimize it away, or there may be faster\n\
7316 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
7317 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
7318 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
7319 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
7320 code <= 127 the corresponding printable ASCII character is plotted.\n\
7322 Redacted form: plpoin(x, y, code)\n\
7324 This function is used in examples 1, 6, 14, and 29.\n\
7330 plpoin(n, x, y, code)\n\
7334 n (PLINT, input) : Number of points in the x and y vectors.\n\
7336 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7339 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7342 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
7343 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
7344 each of the n points.\n\
7347 Enter or leave xor mode\n\
7351 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
7352 those drivers (e.g., the xwin driver) that support it. Enables\n\
7353 erasing plots by drawing twice the same line, symbol, etc. If driver\n\
7354 is not capable of xor operation it returns a status of false.\n\
7356 Redacted form: plxormod(mode, status)\n\
7358 This function is used in examples 1 and 20.\n\
7364 plxormod(mode, status)\n\
7368 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
7369 is false means leave xor mode.\n\
7371 status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
7372 modestatus of true (false) means driver is capable (incapable) of\n\
7376 Get viewport limits in normalized device coordinates\n\
7380 Get viewport limits in normalized device coordinates.\n\
7382 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7385 This function is used in example 31.\n\
7391 plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7395 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7396 viewport limit of the normalized device coordinate in x.\n\
7398 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7399 viewport limit of the normalized device coordinate in x.\n\
7401 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7402 viewport limit of the normalized device coordinate in y.\n\
7404 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7405 viewport limit of the normalized device coordinate in y.\n\
7408 Plot surface mesh\n\
7412 Plots a surface mesh within the environment set up by plw3d. The\n\
7413 surface is defined by the matrix z[\n\
7415 ny] , the point z[i][j] being the value of the function at (\n\
7417 y[j]). Note that the points in vectors x and y do not need to be\n\
7418 equally spaced, but must be stored in ascending order. The parameter\n\
7419 opt controls the way in which the surface is displayed. For further\n\
7420 details see the PLplot documentation.\n\
7422 Redacted form: plmesh(x, y, z, opt)\n\
7424 This function is used in example 11.\n\
7430 plmesh(x, y, z, nx, ny, opt)\n\
7434 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7435 which the function is evaluated.\n\
7437 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7438 which the function is evaluated.\n\
7440 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7441 plot. Should have dimensions of\n\
7445 nx (PLINT, input) : Number of x values at which function has been\n\
7448 ny (PLINT, input) : Number of y values at which function has been\n\
7451 opt (PLINT, input) : Determines the way in which the surface is\n\
7452 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
7453 function of x for each value of y[j] .\n\
7454 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7455 for each value of x[i] .\n\
7456 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7457 at which function is defined.\n\
7460 Magnitude colored plot surface mesh with contour\n\
7464 A more powerful form of plmesh: the surface mesh can be colored\n\
7465 accordingly to the current z value being plotted, a contour plot can\n\
7466 be drawn at the base XY plane, and a curtain can be drawn between the\n\
7467 plotted function border and the base XY plane.\n\
7469 Redacted form: plmeshc(x, y, z, opt, clevel)\n\
7471 This function is used in example 11.\n\
7477 plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7481 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7482 which the function is evaluated.\n\
7484 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7485 which the function is evaluated.\n\
7487 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7488 plot. Should have dimensions of\n\
7492 nx (PLINT, input) : Number of x values at which function is\n\
7495 ny (PLINT, input) : Number of y values at which function is\n\
7498 opt (PLINT, input) : Determines the way in which the surface is\n\
7499 represented. To specify more than one option just add the options,\n\
7500 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
7501 showing z as a function of x for each value of y[j] .\n\
7502 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7503 for each value of x[i] .\n\
7504 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7505 at which function is defined.\n\
7506 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
7507 the z value being plotted. The color is used from the current\n\
7509 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7513 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7514 the borders of the plotted function.\n\
7517 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7520 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7523 End plotting session for current stream\n\
7527 Ends a plotting session for the current output stream only. See\n\
7528 plsstrm for more info.\n\
7530 Redacted form: plend1()\n\
7532 This function is used in examples 1 and 20.\n\
7541 Get y axis parameters\n\
7545 Identical to plgxax, except that arguments are flags for y axis. See\n\
7546 the description of plgxax for more detail.\n\
7548 Redacted form: plgyax(p_digmax, p_digits)\n\
7550 This function is used in example 31.\n\
7556 plgyax(p_digmax, p_digits)\n\
7560 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
7561 number of digits for the y axis. If nonzero, the printed label\n\
7562 has been switched to a floating-point representation when the\n\
7563 number of digits exceeds this value.\n\
7565 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
7566 number of digits for the numeric labels (y axis) from the last\n\
7570 Set plot orientation\n\
7574 Set plot orientation parameter which is multiplied by 90 degrees to\n\
7575 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7576 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7577 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7578 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7579 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
7580 not called the default value of rot is 0.\n\
7582 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
7583 probably want to change the aspect ratio to a value suitable for the\n\
7584 plot orientation using a call to plsdidev or the command-line options\n\
7585 -a or -freeaspect. For more documentation of those options see the\n\
7586 PLplot documentation. Such command-line options can be set internally\n\
7587 using plsetopt or set directly using the command line and parsed using\n\
7588 a call to plparseopts.\n\
7590 Redacted form: plsdiori(rot)\n\
7592 This function is not used in any examples.\n\
7602 rot (PLFLT, input) : Plot orientation parameter.\n\
7605 Plot a histogram from unbinned data\n\
7609 Plots a histogram from n data points stored in the data vector. This\n\
7610 routine bins the data into nbin bins equally spaced between datmin and\n\
7611 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7612 opt allows, among other things, the histogram either to be plotted in\n\
7613 an existing window or causes plhist to call plenv with suitable limits\n\
7614 before plotting the histogram.\n\
7616 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7618 This function is used in example 5.\n\
7624 plhist(n, data, datmin, datmax, nbin, opt)\n\
7628 n (PLINT, input) : Number of data points.\n\
7630 data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7633 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7635 datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7637 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7638 divide the interval xmin to xmax.\n\
7640 opt (PLINT, input) : Is a combination of several flags:\n\
7641 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7642 the histogram data, the outer bins are expanded to fill up the\n\
7643 entire x-axis, data outside the given extremes are assigned to the\n\
7644 outer bins and bins of zero height are simply drawn.\n\
7645 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7646 to fit the histogram data, without this flag, plenv is called\n\
7647 to set the world coordinates.\n\
7648 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7649 extremes are not taken into account. This option should\n\
7650 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7651 properly present the data.\n\
7652 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7653 size as the ones inside.\n\
7654 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7655 (there is a gap for such bins).\n\
7658 End plotting session\n\
7662 Ends a plotting session, tidies up all the output files, switches\n\
7663 interactive devices back into text mode and frees up any memory that\n\
7664 was allocated. Must be called before end of program.\n\
7666 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
7667 wait state after a call to plend or other functions which trigger the\n\
7668 end of a plot page. To avoid this, use the plspause function.\n\
7670 Redacted form: plend()\n\
7672 This function is used in all of the examples.\n\
7681 Plot shaded 3-d surface plot\n\
7685 Plots a three-dimensional shaded surface plot within the environment\n\
7686 set up by plw3d. The surface is defined by the two-dimensional matrix\n\
7689 ny], the point z[i][j] being the value of the function at (\n\
7691 y[j]). Note that the points in vectors x and y do not need to be\n\
7692 equally spaced, but must be stored in ascending order. For further\n\
7693 details see the PLplot documentation.\n\
7695 Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
7697 This function is not used in any examples.\n\
7703 plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7707 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7708 which the function is evaluated.\n\
7710 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7711 which the function is evaluated.\n\
7713 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7714 plot. Should have dimensions of\n\
7718 nx (PLINT, input) : Number of x values at which function is\n\
7721 ny (PLINT, input) : Number of y values at which function is\n\
7724 opt (PLINT, input) : Determines the way in which the surface is\n\
7725 represented. To specify more than one option just add the options,\n\
7726 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
7727 connecting points at which function is defined.\n\
7728 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7732 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
7736 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7737 the borders of the plotted function.\n\
7738 opt=MAG_COLOR : the surface is colored according to the value\n\
7739 of Z; if MAG_COLOR is not used, then the surface is colored\n\
7740 according to the intensity of the reflected light in the\n\
7741 surface from a light source whose position is set using\n\
7745 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7748 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7751 Set device-compression level\n\
7755 Set device-compression level. Only used for drivers that provide\n\
7756 compression. This function, if used, should be invoked before a call\n\
7759 Redacted form: plscompression(compression)\n\
7761 This function is used in example 31.\n\
7767 plscompression(compression)\n\
7771 compression (PLINT, input) : The desired compression level. This is\n\
7772 a device-dependent value. Currently only the jpeg and png devices\n\
7773 use these values. For jpeg value is the jpeg quality which should\n\
7774 normally be in the range 0-95. Higher values denote higher quality\n\
7775 and hence larger image sizes. For png values are in the range -1\n\
7776 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
7777 A value of -1 denotes the default zlib compression level. Values\n\
7778 in the range 10-99 are divided by 10 and then used as the zlib\n\
7779 compression level. Higher compression levels correspond to greater\n\
7780 compression and small file sizes at the expense of more\n\
7784 Get the current device-compression setting\n\
7788 Get the current device-compression setting. This parameter is only\n\
7789 used for drivers that provide compression.\n\
7791 Redacted form: plgcompression(compression)\n\
7793 This function is used in example 31.\n\
7799 plgcompression(compression)\n\
7803 compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
7804 compression setting for the current device.\n\
7807 Advance the (sub-)page\n\
7811 Advances to the next subpage if sub=0, performing a page advance if\n\
7812 there are no remaining subpages on the current page. If subpages\n\
7813 aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
7814 PLplot switches to the specified subpage. Note that this allows you\n\
7815 to overwrite a plot on the specified subpage; if this is not what you\n\
7816 intended, use pleop followed by plbop to first advance the page. This\n\
7817 routine is called automatically (with page=0) by plenv, but if plenv\n\
7818 is not used, pladv must be called after initializing PLplot but before\n\
7819 defining the viewport.\n\
7821 Redacted form: pladv(page)\n\
7823 This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
7834 page (PLINT, input) : Specifies the subpage number (starting from 1\n\
7835 in the top left corner and increasing along the rows) to which to\n\
7836 advance. Set to zero to advance to the next subpage (or to the\n\
7837 next page if subpages are not being used).\n\
7840 Set parameters of contour labelling other than format of numerical label\n\
7844 Set parameters of contour labelling other than those handled by\n\
7845 pl_setcontlabelformat.\n\
7847 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7849 This function is used in example 9.\n\
7855 pl_setcontlabelparam(offset, size, spacing, active)\n\
7859 offset (PLFLT, input) : Offset of label from contour line (if set\n\
7860 to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7862 size (PLFLT, input) : Font height for contour labels (normalized).\n\
7863 Default value is 0.3.\n\
7865 spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7866 Default value is 0.1.\n\
7868 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7869 contour labels on. Default is off (0).\n\
7872 Set family, style and weight of the current font\n\
7876 Sets the current font. See the PLplot documentation for more\n\
7877 information on font selection.\n\
7879 Redacted form: plsfont(family, style, weight)\n\
7881 This function is used in example 23.\n\
7887 plsfont(family, style, weight)\n\
7891 family (PLINT, input) : Font family to select for the current font.\n\
7892 The available values are given by the PL_FCI_* constants in\n\
7893 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
7894 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
7895 signifies that the font family should not be altered.\n\
7897 style (PLINT, input) : Font style to select for the current font.\n\
7898 The available values are given by the PL_FCI_* constants in\n\
7899 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
7900 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
7901 should not be altered.\n\
7903 weight (PLINT, input) : Font weight to select for the current font.\n\
7904 The available values are given by the PL_FCI_* constants in\n\
7905 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
7906 negative value signifies that the font weight should not be\n\
7910 Sets the 3D position of the light source\n\
7914 Sets the 3D position of the light source for use with plsurf3d and\n\
7917 Redacted form: pllightsource(x, y, z)\n\
7919 This function is used in example 8.\n\
7925 pllightsource(x, y, z)\n\
7929 x (PLFLT, input) : X-coordinate of the light source.\n\
7931 y (PLFLT, input) : Y-coordinate of the light source.\n\
7933 z (PLFLT, input) : Z-coordinate of the light source.\n\
7940 Draws line defined by n points in x and y.\n\
7942 Redacted form: plline(x, y)\n\
7944 This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
7955 n (PLINT, input) : Number of points defining line.\n\
7957 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7960 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7968 Sets the pen width.\n\
7970 Redacted form: plwidth(width)\n\
7972 This function is used in examples 1 and 2.\n\
7982 width (PLFLT, input) : The desired pen width. If width is negative\n\
7983 or the same as the previous value no action is taken. width = 0.\n\
7984 should be interpreted as as the minimum valid pen width for the\n\
7985 device. The interpretation of positive width values is also\n\
7986 device dependent.\n\
7989 Draw linear gradient inside polygon\n\
7993 Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
7996 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
7997 polygon coordinates and the gradient angle are all expressed in world\n\
7998 coordinates. The angle from the x axis for both the rotated\n\
7999 coordinate system and the gradient vector is specified by angle. The\n\
8000 magnitude of the gradient vector is the difference between the maximum\n\
8001 and minimum values of x for the vertices in the rotated coordinate\n\
8002 system. The origin of the gradient vector can be interpreted as being\n\
8003 anywhere on the line corresponding to the minimum x value for the\n\
8004 vertices in the rotated coordinate system. The distance along the\n\
8005 gradient vector is linearly transformed to the independent variable of\n\
8006 color map 1 which ranges from 0. at the tail of the gradient vector to\n\
8007 1. at the head of the gradient vector. What is drawn is the RGBA\n\
8008 color corresponding to the independent variable of cmap1. For more\n\
8009 information about cmap1 (see the PLplot documentation).\n\
8011 Redacted form: plgradient(x,y,angle)\n\
8013 This function is used in examples 25 and 30.\n\
8019 plgradient(n, x, y, angle)\n\
8023 n (PLINT, input) : Number of vertices in polygon.\n\
8025 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8028 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8031 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
8035 Flushes the output stream\n\
8039 Flushes the output stream. Use sparingly, if at all.\n\
8041 Redacted form: plflush()\n\
8043 This function is used in examples 1 and 14.\n\
8052 Get plot orientation\n\
8056 Get plot orientation parameter which is multiplied by 90 degrees to\n\
8057 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
8058 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
8059 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
8060 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
8061 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
8062 not been called the default value pointed to by p_rot will be 0.\n\
8064 Redacted form: plgdiori(p_rot)\n\
8066 This function is not used in any examples.\n\
8076 p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
8080 Set x axis parameters\n\
8084 Sets values of the digmax and digits flags for the x axis. See the\n\
8085 PLplot documentation for more information.\n\
8087 Redacted form: plsxax(digmax, digits)\n\
8089 This function is used in example 31.\n\
8095 plsxax(digmax, digits)\n\
8099 digmax (PLINT, input) : Variable to set the maximum number of\n\
8100 digits for the x axis. If nonzero, the printed label will be\n\
8101 switched to a floating-point representation when the number of\n\
8102 digits exceeds digmax.\n\
8104 digits (PLINT, input) : Field digits value. Currently, changing\n\
8105 its value here has no effect since it is set only by plbox or\n\
8106 plbox3. However, the user may obtain its value after a call to\n\
8107 either of these functions by calling plgxax.\n\
8110 Get viewport limits in world coordinates\n\
8114 Get viewport limits in world coordinates.\n\
8116 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
8119 This function is used in example 31.\n\
8125 plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
8129 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
8130 viewport limit of the world coordinate in x.\n\
8132 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
8133 viewport limit of the world coordinate in x.\n\
8135 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
8136 viewport limit of the world coordinate in y.\n\
8138 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
8139 viewport limit of the world coordinate in y.\n\
8142 Shade regions on the basis of value\n\
8146 Shade regions on the basis of value. This is the high-level routine\n\
8147 for making continuous color shaded plots with cmap1 while plshade\n\
8148 should be used to plot individual shaded regions using either cmap0 or\n\
8149 cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
8150 our supported languages.\n\
8152 Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
8153 clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
8157 This function is used in examples 16, 21, and 22.\n\
8163 plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
8167 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
8168 plot. Should have dimensions of\n\
8172 nx (PLINT, input) : First dimension of matrix \"a\".\n\
8174 ny (PLINT, input) : Second dimension of matrix \"a\".\n\
8176 defined (PLDEFINED_callback, input) : Callback function specifying\n\
8177 the region that should be plotted in the shade plot. This\n\
8178 function accepts x and y coordinates as input arguments and must\n\
8179 return 1 if the point is to be included in the shade plot and 0\n\
8180 otherwise. If you want to plot the entire shade plot (the usual\n\
8181 case), this argument should be set to NULL.\n\
8183 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
8184 pltr below for how these arguments are used (only for the special case\n\
8185 when the callback function\n\
8186 pltr is not supplied).\n\
8188 clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
8189 corresponding to the edges of each shaded region that will be\n\
8190 plotted by this function. To work properly the levels should be\n\
8193 nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
8194 of shade edge values in clevel).\n\
8196 fill_width (PLFLT, input) : Defines the line width used by the fill\n\
8199 cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
8200 contours defining edges of shaded regions. The pen color is only\n\
8201 temporary set for the contour drawing. Set this value to zero or\n\
8202 less if no shade edge contours are wanted.\n\
8204 cont_width (PLFLT, input) : Defines line width used for contours\n\
8205 defining edges of shaded regions. This value may not be honored\n\
8206 by all drivers. The pen width is only temporary set for the\n\
8207 contour drawing. Set this value to zero or less if no shade edge\n\
8208 contours are wanted.\n\
8210 fill (PLFILL_callback, input) : Callback routine used to fill the\n\
8211 region. Use plfill for this purpose.\n\
8213 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
8214 map to rectangles after coordinate transformation with pltrl.\n\
8215 Otherwise, set rectangular to false. If rectangular is set to\n\
8216 true, plshade tries to save time by filling large rectangles.\n\
8217 This optimization fails if the coordinate transformation distorts\n\
8218 the shape of rectangles. For example a plot in polar coordinates\n\
8219 has to have rectangular set to false.\n\
8221 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
8222 defines the transformation between the zero-based indices of the\n\
8223 matrix a and world coordinates. If\n\
8224 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
8225 indices of a are mapped to the range\n\
8227 xmax and the y indices of a are mapped to the range\n\
8229 ymax.For the C case, transformation functions are provided in the\n\
8230 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
8231 pltr2 for arbitrary mappings respectively defined by vectors and\n\
8232 matrices. In addition, C callback routines for the transformation\n\
8233 can be supplied by the user such as the mypltr function in\n\
8234 examples/c/x09c.c which provides a general linear transformation\n\
8235 between index coordinates and world coordinates.For languages\n\
8236 other than C you should consult the PLplot documentation for the\n\
8237 details concerning how PLTRANSFORM_callback arguments are\n\
8238 interfaced. However, in general, a particular pattern of\n\
8239 callback-associated arguments such as a tr vector with 6 elements;\n\
8240 xg and yg vectors; or xg and yg matrices are respectively\n\
8241 interfaced to a linear-transformation routine similar to the above\n\
8242 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
8243 sophisticated bindings (see, e.g., the PLplot documentation)\n\
8244 support native language callbacks for handling index to\n\
8245 world-coordinate transformations. Examples of these various\n\
8246 approaches are given in examples/<language>x09*,\n\
8247 examples/<language>x16*, examples/<language>x20*,\n\
8248 examples/<language>x21*, and examples/<language>x22*, for all our\n\
8249 supported languages.\n\
8251 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8252 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8253 externally supplied.\n\
8256 Plot color bar for image, shade or gradient plots\n\
8260 Routine for creating a continuous color bar for image, shade, or\n\
8261 gradient plots. (See pllegend for similar functionality for creating\n\
8262 legends with discrete elements). The arguments of plcolorbar provide\n\
8263 control over the location and size of the color bar as well as the\n\
8264 location and characteristics of the elements (most of which are\n\
8265 optional) within that color bar. The resulting color bar is clipped\n\
8266 at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
8267 system used for some of the parameters is defined in the documentation\n\
8268 of the position parameter.)\n\
8270 Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
8271 position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
8272 low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
8273 labels, axis_opts, ticks, sub_ticks, values)\n\
8275 This function is used in examples 16 and 33.\n\
8281 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\
8285 p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8286 labelled and decorated color bar width in adopted coordinates.\n\
8288 p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8289 labelled and decorated color bar height in adopted coordinates.\n\
8291 opt (PLINT, input) : opt contains bits controlling the overall\n\
8292 color bar. The orientation (direction of the maximum value) of\n\
8293 the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
8294 PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
8295 specified, the default orientation is toward the top if the\n\
8296 colorbar is placed on the left or right of the viewport or toward\n\
8297 the right if the colorbar is placed on the top or bottom of the\n\
8298 viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
8299 (semitransparent) background for the color bar. If the\n\
8300 PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8301 color bar. The type of color bar must be specified with one of\n\
8302 PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
8303 more than one of those bits is set only the first one in the above\n\
8304 list is honored. The position of the (optional) label/title can be\n\
8305 specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
8306 PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
8307 will be drawn. If more than one of this list of bits is specified,\n\
8308 only the first one on the list is honored. End-caps for the color\n\
8309 bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
8310 If a particular color bar cap option is not specified then no cap\n\
8311 will be drawn for that end. As a special case for\n\
8312 PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
8313 specified. If this option is provided then any tick marks and tick\n\
8314 labels will be placed at the breaks between shaded segments. TODO:\n\
8315 This should be expanded to support custom placement of tick marks\n\
8316 and tick labels at custom value locations for any color bar type.\n\
8318 position (PLINT, input) : position contains bits which control the\n\
8319 overall position of the color bar and the definition of the\n\
8320 adopted coordinates used for positions just like what is done for\n\
8321 the position argument for pllegend. However, note that the\n\
8322 defaults for the position bits (see below) are different than the\n\
8323 pllegend case. The combination of the PL_POSITION_LEFT,\n\
8324 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8325 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8326 the 16 possible standard positions (the 4 corners and centers of\n\
8327 the 4 sides for both the inside and outside cases) of the color\n\
8328 bar relative to the adopted coordinate system. The corner\n\
8329 positions are specified by the appropriate combination of two of\n\
8330 the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8331 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8332 value of one of those bits. The adopted coordinates are\n\
8333 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8334 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8335 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8336 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8337 then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
8338 PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
8339 PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
8340 PL_POSITION_VIEWPORT.\n\
8342 x (PLFLT, input) : X offset of the color bar position in adopted\n\
8343 coordinates from the specified standard position of the color bar.\n\
8344 For positive x, the direction of motion away from the standard\n\
8345 position is inward/outward from the standard corner positions or\n\
8346 standard left or right positions if the\n\
8347 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8348 For the standard top or bottom positions, the direction of motion\n\
8349 is toward positive X.\n\
8351 y (PLFLT, input) : Y offset of the color bar position in adopted\n\
8352 coordinates from the specified standard position of the color bar.\n\
8353 For positive y, the direction of motion away from the standard\n\
8354 position is inward/outward from the standard corner positions or\n\
8355 standard top or bottom positions if the\n\
8356 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8357 For the standard left or right positions, the direction of motion\n\
8358 is toward positive Y.\n\
8360 x_length (PLFLT, input) : Length of the body of the color bar in\n\
8361 the X direction in adopted coordinates.\n\
8363 y_length (PLFLT, input) : Length of the body of the color bar in\n\
8364 the Y direction in adopted coordinates.\n\
8366 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8367 color bar (PL_COLORBAR_BACKGROUND).\n\
8369 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8370 for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
8372 bb_style (PLINT, input) : The pllsty style number for the\n\
8373 bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
8375 low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
8376 bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
8378 high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
8379 color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
8381 cont_color (PLINT, input) : The cmap0 contour color for\n\
8382 PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
8383 it will be interpreted according to the design of plshades.\n\
8385 cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
8386 plots. This is passed directly to plshades, so it will be\n\
8387 interpreted according to the design of plshades.\n\
8389 n_labels (PLINT, input) : Number of labels to place around the\n\
8392 label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
8395 labels (PLCHAR_MATRIX, input) : A vector of\n\
8396 n_labels UTF-8 character strings containing the labels for the color\n\
8397 bar. Ignored if no label position is specified with one of the\n\
8398 PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
8399 PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
8400 corresponding label_opts field.\n\
8402 n_axes (PLINT, input) : Number of axis definitions provided. This\n\
8403 value must be greater than 0. It is typically 1 (numerical axis\n\
8404 labels are provided for one of the long edges of the color bar),\n\
8405 but it can be larger if multiple numerical axis labels for the\n\
8406 long edges of the color bar are desired.\n\
8408 axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
8409 n_axes ascii character strings containing options (interpreted as for\n\
8410 plbox) for the color bar\'s axis definitions.\n\
8412 ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
8413 spacing of the major tick marks (interpreted as for plbox) for the\n\
8414 color bar\'s axis definitions.\n\
8416 sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
8417 number of subticks (interpreted as for plbox) for the color bar\'s\n\
8418 axis definitions.\n\
8420 n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
8421 elements in each of the n_axes rows of the values matrix.\n\
8423 values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
8424 values for the data range represented by the color bar. For a row\n\
8425 index of i_axis (where 0 < i_axis < n_axes), the number of\n\
8426 elements in the row is specified by n_values[i_axis]. For\n\
8427 PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
8428 is 2, and the corresponding row elements of the values matrix are\n\
8429 the minimum and maximum value represented by the colorbar. For\n\
8430 PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
8431 of the values matrix is interpreted the same as the nlevel and\n\
8432 clevel arguments of plshades.\n\
8435 Get current subpage parameters\n\
8439 Gets the size of the current subpage in millimeters measured from the\n\
8440 bottom left hand corner of the output device page or screen. Can be\n\
8441 used in conjunction with plsvpa for setting the size of a viewport in\n\
8442 absolute coordinates (millimeters).\n\
8444 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
8446 This function is used in example 23.\n\
8452 plgspa(xmin, xmax, ymin, ymax)\n\
8456 xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8457 the left hand edge of the subpage in millimeters.\n\
8459 xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8460 the right hand edge of the subpage in millimeters.\n\
8462 ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8463 the bottom edge of the subpage in millimeters.\n\
8465 ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8466 the top edge of the subpage in millimeters.\n\
8469 Shade individual region on the basis of value\n\
8473 Shade individual region on the basis of value. Use plshades if you\n\
8474 want to shade a number of contiguous regions using continuous colors.\n\
8475 In particular the edge contours are treated properly in plshades. If\n\
8476 you attempt to do contiguous regions with plshade the contours at the\n\
8477 edge of the shade are partially obliterated by subsequent plots of\n\
8478 contiguous shaded regions.\n\
8480 Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
8481 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
8482 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
8485 This function is used in example 15.\n\
8491 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\
8495 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
8496 plot. Should have dimensions of\n\
8500 nx (PLINT, input) : First dimension of the matrix \"a\".\n\
8502 ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
8504 defined (PLDEFINED_callback, input) : Callback function specifying\n\
8505 the region that should be plotted in the shade plot. This\n\
8506 function accepts x and y coordinates as input arguments and must\n\
8507 return 1 if the point is to be included in the shade plot and 0\n\
8508 otherwise. If you want to plot the entire shade plot (the usual\n\
8509 case), this argument should be set to NULL.\n\
8511 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
8512 pltr below for how these arguments are used (only for the special case\n\
8513 when the callback function\n\
8514 pltr is not supplied).\n\
8516 shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
8517 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8519 shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
8520 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8522 sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
8523 sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
8524 then sh_color is interpreted as a cmap1 argument in the range\n\
8527 sh_color (PLFLT, input) : Defines color map index with integer\n\
8528 value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
8530 sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
8532 min_color (PLINT, input) : Defines pen color, width used by the\n\
8533 boundary of shaded region. The min values are used for the\n\
8534 shade_min boundary, and the max values are used on the shade_max\n\
8535 boundary. Set color and width to zero for no plotted boundaries.\n\
8537 min_width (PLFLT, input) : Defines pen color, width used by the\n\
8538 boundary of shaded region. The min values are used for the\n\
8539 shade_min boundary, and the max values are used on the shade_max\n\
8540 boundary. Set color and width to zero for no plotted boundaries.\n\
8542 max_color (PLINT, input) : Defines pen color, width used by the\n\
8543 boundary of shaded region. The min values are used for the\n\
8544 shade_min boundary, and the max values are used on the shade_max\n\
8545 boundary. Set color and width to zero for no plotted boundaries.\n\
8547 max_width (PLFLT, input) : Defines pen color, width used by the\n\
8548 boundary of shaded region. The min values are used for the\n\
8549 shade_min boundary, and the max values are used on the shade_max\n\
8550 boundary. Set color and width to zero for no plotted boundaries.\n\
8552 fill (PLFILL_callback, input) : Routine used to fill the region.\n\
8553 Use plfill. Future version of PLplot may have other fill\n\
8556 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
8557 map to rectangles after coordinate transformation with pltrl.\n\
8558 Otherwise, set rectangular to false. If rectangular is set to\n\
8559 true, plshade tries to save time by filling large rectangles.\n\
8560 This optimization fails if the coordinate transformation distorts\n\
8561 the shape of rectangles. For example a plot in polar coordinates\n\
8562 has to have rectangular set to false.\n\
8564 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
8565 defines the transformation between the zero-based indices of the\n\
8566 matrix a and world coordinates. If\n\
8567 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
8568 indices of a are mapped to the range\n\
8570 xmax and the y indices of a are mapped to the range\n\
8572 ymax.For the C case, transformation functions are provided in the\n\
8573 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
8574 pltr2 for arbitrary mappings respectively defined by vectors and\n\
8575 matrices. In addition, C callback routines for the transformation\n\
8576 can be supplied by the user such as the mypltr function in\n\
8577 examples/c/x09c.c which provides a general linear transformation\n\
8578 between index coordinates and world coordinates.For languages\n\
8579 other than C you should consult the PLplot documentation for the\n\
8580 details concerning how PLTRANSFORM_callback arguments are\n\
8581 interfaced. However, in general, a particular pattern of\n\
8582 callback-associated arguments such as a tr vector with 6 elements;\n\
8583 xg and yg vectors; or xg and yg matrices are respectively\n\
8584 interfaced to a linear-transformation routine similar to the above\n\
8585 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
8586 sophisticated bindings (see, e.g., the PLplot documentation)\n\
8587 support native language callbacks for handling index to\n\
8588 world-coordinate transformations. Examples of these various\n\
8589 approaches are given in examples/<language>x09*,\n\
8590 examples/<language>x16*, examples/<language>x20*,\n\
8591 examples/<language>x21*, and examples/<language>x22*, for all our\n\
8592 supported languages.\n\
8594 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8595 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8596 externally supplied.\n\
8599 Calculate world coordinates and corresponding window index from relative device coordinates\n\
8603 Calculate world coordinates, wx and wy, and corresponding window index\n\
8604 from relative device coordinates, rx and ry.\n\
8606 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
8609 This function is used in example 31.\n\
8615 plcalc_world(rx, ry, wx, wy, window)\n\
8619 rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8620 the x coordinate.\n\
8622 ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8623 the y coordinate.\n\
8625 wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
8626 coordinate corresponding to the relative device coordinates rx and\n\
8629 wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
8630 coordinate corresponding to the relative device coordinates rx and\n\
8633 window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
8634 defined window index that corresponds to the input relative device\n\
8635 coordinates (and the returned world coordinates). To give some\n\
8636 background on the window index, for each page the initial window\n\
8637 index is set to zero, and each time plwind is called within the\n\
8638 page, world and device coordinates are stored for the window and\n\
8639 the window index is incremented. Thus, for a simple page layout\n\
8640 with non-overlapping viewports and one window per viewport, window\n\
8641 corresponds to the viewport index (in the order which the\n\
8642 viewport/windows were created) of the only viewport/window\n\
8643 corresponding to rx and ry. However, for more complicated layouts\n\
8644 with potentially overlapping viewports and possibly more than one\n\
8645 window (set of world coordinates) per viewport, window and the\n\
8646 corresponding output world coordinates corresponds to the last\n\
8647 window created that fulfills the criterion that the relative\n\
8648 device coordinates are inside it. Finally, in all cases where the\n\
8649 input relative device coordinates are not inside any\n\
8650 viewport/window, then the returned value of the last defined\n\
8651 window index is set to -1.\n\
8654 Draw a box with axes, etc, in 3-d\n\
8658 Draws axes, numeric and text labels for a three-dimensional surface\n\
8659 plot. For a more complete description of three-dimensional plotting\n\
8660 see the PLplot documentation.\n\
8662 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
8663 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8666 This function is used in examples 8, 11, 18, and 21.\n\
8672 plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8676 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8677 options for the x axis. The string can include any combination of\n\
8678 the following letters (upper or lower case) in any order: b: Draws\n\
8679 axis at base, at height z=\n\
8680 zmin where zmin is defined by call to plw3d. This character must be\n\
8681 specified in order to use any of the other options.\n\
8682 d: Plot labels as date / time. Values are assumed to be\n\
8683 seconds since the epoch (as used by gmtime).\n\
8684 f: Always use fixed point numeric labels.\n\
8685 i: Inverts tick marks, so they are drawn downwards, rather\n\
8687 l: Labels axis logarithmically. This only affects the labels,\n\
8688 not the data, and so it is necessary to compute the logarithms\n\
8689 of data points before passing them to any of the drawing\n\
8691 n: Writes numeric labels at major tick intervals.\n\
8692 o: Use custom labelling function to generate axis label text.\n\
8693 The custom labelling function can be defined with the\n\
8694 plslabelfunc command.\n\
8695 s: Enables subticks between major ticks, only valid if t is\n\
8697 t: Draws major ticks.\n\
8698 u: If this is specified, the text label for the axis is\n\
8699 written under the axis.\n\
8702 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8703 the text label for the x axis. It is only drawn if u is in the\n\
8706 xtick (PLFLT, input) : World coordinate interval between major\n\
8707 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8708 generates a suitable tick interval.\n\
8710 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8711 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8712 generates a suitable minor tick interval.\n\
8714 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8715 options for the y axis. The string is interpreted in the same way\n\
8718 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8719 the text label for the y axis. It is only drawn if u is in the\n\
8722 ytick (PLFLT, input) : World coordinate interval between major\n\
8723 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8724 generates a suitable tick interval.\n\
8726 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8727 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8728 generates a suitable minor tick interval.\n\
8730 zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8731 options for the z axis. The string can include any combination of\n\
8732 the following letters (upper or lower case) in any order: b: Draws\n\
8733 z axis to the left of the surface plot.\n\
8734 c: Draws z axis to the right of the surface plot.\n\
8735 d: Draws grid lines parallel to the x-y plane behind the\n\
8736 figure. These lines are not drawn until after plot3d or\n\
8737 plmesh are called because of the need for hidden line removal.\n\
8738 e: Plot labels as date / time. Values are assumed to be\n\
8739 seconds since the epoch (as used by gmtime). Note this\n\
8740 suboption is interpreted the same as the d suboption for xopt\n\
8741 and yopt, but it has to be identified as e for zopt since d\n\
8742 has already been used for the different purpose above.\n\
8743 f: Always use fixed point numeric labels.\n\
8744 i: Inverts tick marks, so they are drawn away from the center.\n\
8745 l: Labels axis logarithmically. This only affects the labels,\n\
8746 not the data, and so it is necessary to compute the logarithms\n\
8747 of data points before passing them to any of the drawing\n\
8749 m: Writes numeric labels at major tick intervals on the\n\
8750 right-hand z axis.\n\
8751 n: Writes numeric labels at major tick intervals on the\n\
8752 left-hand z axis.\n\
8753 o: Use custom labelling function to generate axis label text.\n\
8754 The custom labelling function can be defined with the\n\
8755 plslabelfunc command.\n\
8756 s: Enables subticks between major ticks, only valid if t is\n\
8758 t: Draws major ticks.\n\
8759 u: If this is specified, the text label is written beside the\n\
8761 v: If this is specified, the text label is written beside the\n\
8765 zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8766 the text label for the z axis. It is only drawn if u or v are in\n\
8769 ztick (PLFLT, input) : World coordinate interval between major\n\
8770 ticks on the z axis. If it is set to zero, PLplot automatically\n\
8771 generates a suitable tick interval.\n\
8773 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
8774 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8775 generates a suitable minor tick interval.\n\
8778 Get character default height and current (scaled) height\n\
8782 Get character default height and current (scaled) height.\n\
8784 Redacted form: plgchr(p_def, p_ht)\n\
8786 This function is used in example 23.\n\
8792 plgchr(p_def, p_ht)\n\
8796 p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
8797 character height (mm).\n\
8799 p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
8800 character height (mm).\n\
8803 Set the escape character for text strings\n\
8807 Set the escape character for text strings. From C (in contrast to\n\
8808 Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
8809 characters are allowed to prevent the user from shooting himself in\n\
8810 the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
8811 use of backslash as a character escape). Here are the allowed escape\n\
8812 characters and their corresponding decimal ASCII values: !, ASCII 33\n\
8823 Redacted form: General: plsesc(esc)\n\
8826 This function is used in example 29.\n\
8836 esc (char, input) : Escape character.\n\
8839 Draw a line between two points, accounting for coordinate transforms\n\
8843 Joins the point (\n\
8847 y2) . If a global coordinate transform is defined then the line is\n\
8848 broken in to n segments to approximate the path. If no transform is\n\
8849 defined then this simply acts like a call to pljoin.\n\
8851 Redacted form: plpath(n,x1,y1,x2,y2)\n\
8853 This function is used in example 22.\n\
8859 plpath(n, x1, y1, x2, y2)\n\
8863 n (PLINT, input) : number of points to use to approximate the path.\n\
8865 x1 (PLFLT, input) : x coordinate of first point.\n\
8867 y1 (PLFLT, input) : y coordinate of first point.\n\
8869 x2 (PLFLT, input) : x coordinate of second point.\n\
8871 y2 (PLFLT, input) : y coordinate of second point.\n\
8874 Set up standard window and draw box\n\
8878 Sets up plotter environment for simple graphs by calling pladv and\n\
8879 setting up viewport and window to sensible default values. plenv\n\
8880 leaves a standard margin (left-hand margin of eight character heights,\n\
8881 and a margin around the other three sides of five character heights)\n\
8882 around most graphs for axis labels and a title. When these defaults\n\
8883 are not suitable, use the individual routines plvpas, plvpor, or\n\
8884 plvasp for setting up the viewport, plwind for defining the window,\n\
8885 and plbox for drawing the box.\n\
8887 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8889 This function is used in example 1,3,9,13,14,19-22,29.\n\
8895 plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8899 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
8900 world coordinates).\n\
8902 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
8903 world coordinates).\n\
8905 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
8908 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
8911 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
8912 scales will not be set, the user must set up the scale before\n\
8913 calling plenv using plsvpa, plvasp or other.\n\
8914 0: the x and y axes are scaled independently to use as much of\n\
8915 the screen as possible.\n\
8916 1: the scales of the x and y axes are made equal.\n\
8917 2: the axis of the x and y axes are made equal, and the plot\n\
8918 box will be square.\n\
8921 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
8922 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
8923 -1: draw box only.\n\
8924 0: draw box, ticks, and numeric tick labels.\n\
8925 1: also draw coordinate axes at x=0 and y=0.\n\
8926 2: also draw a grid at major tick positions in both\n\
8928 3: also draw a grid at minor tick positions in both\n\
8930 10: same as 0 except logarithmic x tick marks. (The x data\n\
8931 have to be converted to logarithms separately.)\n\
8932 11: same as 1 except logarithmic x tick marks. (The x data\n\
8933 have to be converted to logarithms separately.)\n\
8934 12: same as 2 except logarithmic x tick marks. (The x data\n\
8935 have to be converted to logarithms separately.)\n\
8936 13: same as 3 except logarithmic x tick marks. (The x data\n\
8937 have to be converted to logarithms separately.)\n\
8938 20: same as 0 except logarithmic y tick marks. (The y data\n\
8939 have to be converted to logarithms separately.)\n\
8940 21: same as 1 except logarithmic y tick marks. (The y data\n\
8941 have to be converted to logarithms separately.)\n\
8942 22: same as 2 except logarithmic y tick marks. (The y data\n\
8943 have to be converted to logarithms separately.)\n\
8944 23: same as 3 except logarithmic y tick marks. (The y data\n\
8945 have to be converted to logarithms separately.)\n\
8946 30: same as 0 except logarithmic x and y tick marks. (The x\n\
8947 and y data have to be converted to logarithms separately.)\n\
8948 31: same as 1 except logarithmic x and y tick marks. (The x\n\
8949 and y data have to be converted to logarithms separately.)\n\
8950 32: same as 2 except logarithmic x and y tick marks. (The x\n\
8951 and y data have to be converted to logarithms separately.)\n\
8952 33: same as 3 except logarithmic x and y tick marks. (The x\n\
8953 and y data have to be converted to logarithms separately.)\n\
8954 40: same as 0 except date / time x labels.\n\
8955 41: same as 1 except date / time x labels.\n\
8956 42: same as 2 except date / time x labels.\n\
8957 43: same as 3 except date / time x labels.\n\
8958 50: same as 0 except date / time y labels.\n\
8959 51: same as 1 except date / time y labels.\n\
8960 52: same as 2 except date / time y labels.\n\
8961 53: same as 3 except date / time y labels.\n\
8962 60: same as 0 except date / time x and y labels.\n\
8963 61: same as 1 except date / time x and y labels.\n\
8964 62: same as 2 except date / time x and y labels.\n\
8965 63: same as 3 except date / time x and y labels.\n\
8966 70: same as 0 except custom x and y labels.\n\
8967 71: same as 1 except custom x and y labels.\n\
8968 72: same as 2 except custom x and y labels.\n\
8969 73: same as 3 except custom x and y labels.\n\
8972 Grid data from irregularly sampled data\n\
8976 Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
8977 require data organized as a grid, i.e., with x sample point values\n\
8978 independent of y coordinate and vice versa. This function takes\n\
8979 irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
8980 vectors; reads the desired grid location from the input vectors\n\
8981 xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
8982 grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
8983 interpolate the data to the grid is specified with the argument type\n\
8984 which can have one parameter specified in argument data.\n\
8986 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
8987 Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
8990 This function is used in example 21.\n\
8996 plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
9000 x (PLFLT_VECTOR, input) : The input x vector.\n\
9002 y (PLFLT_VECTOR, input) : The input y vector.\n\
9004 z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
9005 y[i], z[i] represents one data sample coordinate.\n\
9007 npts (PLINT, input) : The number of data samples in the x, y and z\n\
9010 xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
9011 in the x direction. Usually xg has nptsx equally spaced values\n\
9012 from the minimum to the maximum values of the x input vector.\n\
9014 nptsx (PLINT, input) : The number of points in the xg vector.\n\
9016 yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
9017 in the y direction. Similar to the xg parameter.\n\
9019 nptsy (PLINT, input) : The number of points in the yg vector.\n\
9021 zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
9022 where data lies in the grid specified by xg and yg. Therefore the\n\
9023 zg matrix must be dimensioned\n\
9027 type (PLINT, input) : The type of grid interpolation algorithm to\n\
9028 use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
9029 GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
9030 GRID_NNI: Natural Neighbors Interpolation\n\
9031 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
9032 GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
9033 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
9035 For details of the algorithms read the source file plgridd.c.\n\
9037 data (PLFLT, input) : Some gridding algorithms require extra data,\n\
9038 which can be specified through this argument. Currently, for\n\
9039 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
9040 use, the lower the value, the noisier (more local) the\n\
9041 approximation is.\n\
9042 GRID_NNLI, data specifies what a thin triangle is, in the\n\
9043 range [1. .. 2.]. High values enable the usage of very thin\n\
9044 triangles for interpolation, possibly resulting in error in\n\
9045 the approximation.\n\
9046 GRID_NNI, only weights greater than data will be accepted. If\n\
9047 0, all weights will be accepted.\n\
9050 Clear current (sub)page\n\
9054 Clears the current page, effectively erasing everything that have been\n\
9055 drawn. This command only works with interactive drivers; if the\n\
9056 driver does not support this, the page is filled with the background\n\
9057 color in use. If the current page is divided into subpages, only the\n\
9058 current subpage is erased. The nth subpage can be selected with\n\
9061 Redacted form: General: plclear()\n\
9064 This function is not used in any examples.\n\
9073 Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
9077 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
9078 and PLFLT alpha transparency value. This sets the entire color map --\n\
9079 only as many colors as specified will be allocated.\n\
9081 Redacted form: plscmap0a(r, g, b, alpha)\n\
9083 This function is used in examples 30.\n\
9089 plscmap0a(r, g, b, alpha, ncol0)\n\
9093 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9094 integers (0-255) representing the degree of red in the color.\n\
9096 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9097 integers (0-255) representing the degree of green in the color.\n\
9099 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9100 integers (0-255) representing the degree of blue in the color.\n\
9102 alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
9103 representing the alpha transparency of the color.\n\
9105 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9109 Set 8-bit RGB values for given cmap0 color index\n\
9113 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
9114 index. Overwrites the previous color value for the given index and,\n\
9115 thus, does not result in any additional allocation of space for\n\
9118 Redacted form: plscol0(icol0, r, g, b)\n\
9120 This function is used in any example 31.\n\
9126 plscol0(icol0, r, g, b)\n\
9130 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
9131 number of colors (which is set by default, by plscmap0n, or even\n\
9134 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9135 degree of red in the color.\n\
9137 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9138 degree of green in the color.\n\
9140 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9141 degree of blue in the color.\n\
9144 Set up transformation from metafile coordinates\n\
9148 Set up transformation from metafile coordinates. The size of the plot\n\
9149 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
9150 general-purpose facility just yet (not sure why the user would need\n\
9153 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
9156 This function is not used in any examples.\n\
9162 plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
9166 dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
9168 dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
9170 dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
9172 dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
9174 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
9176 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
9179 Creates a new stream and makes it the default\n\
9183 Creates a new stream and makes it the default. Differs from using\n\
9184 plsstrm, in that a free stream number is found, and returned.\n\
9185 Unfortunately, I have to start at stream 1 and work upward, since\n\
9186 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
9187 that no initial, library-opening call is required. So stream 0 must\n\
9188 be preallocated, and there is no simple way of determining whether it\n\
9189 is already in use or not.\n\
9191 Redacted form: plmkstrm(p_strm)\n\
9193 This function is used in examples 1 and 20.\n\
9203 p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
9204 number of the created stream.\n\
9207 Get page parameters\n\
9211 Gets the current page configuration. The length and offset values are\n\
9212 expressed in units that are specific to the current driver. For\n\
9213 instance: screen drivers will usually interpret them as number of\n\
9214 pixels, whereas printer drivers will usually use mm.\n\
9216 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
9218 This function is used in examples 14 and 31.\n\
9224 plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
9228 p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
9229 pixels/inch (DPI) in x.\n\
9231 p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
9232 pixels/inch (DPI) in y.\n\
9234 p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
9237 p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
9240 p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
9243 p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
9247 Set format for date / time labels\n\
9251 Sets the format for date / time labels. To enable date / time format\n\
9252 labels see the options to plbox, plbox3, and plenv.\n\
9254 Redacted form: pltimefmt(fmt)\n\
9256 This function is used in example 29.\n\
9266 fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
9267 interpreted similarly to the format specifier of typical system\n\
9268 strftime routines except that PLplot ignores locale and also\n\
9269 supplies some useful extensions in the context of plotting. All\n\
9270 text in the string is printed as-is other than conversion\n\
9271 specifications which take the form of a \'%\' character followed by\n\
9272 further conversion specification character. The conversion\n\
9273 specifications which are similar to those provided by system\n\
9274 strftime routines are the following: %a: The abbreviated (English)\n\
9276 %A: The full (English) weekday name.\n\
9277 %b: The abbreviated (English) month name.\n\
9278 %B: The full (English) month name.\n\
9279 %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
9280 %C: The century number (year/100) as a 2-digit integer.\n\
9281 %d: The day of the month as a decimal number (range 01 to 31).\n\
9282 %D: Equivalent to %m/%d/%y (non-ISO).\n\
9283 %e: Like %d, but a leading zero is replaced by a space.\n\
9284 %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
9285 %h: Equivalent to %b.\n\
9286 %H: The hour as a decimal number using a 24-hour clock (range\n\
9288 %I: The hour as a decimal number using a 12-hour clock (range\n\
9290 %j: The day of the year as a decimal number (range 001 to\n\
9292 %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
9293 23); single digits are preceded by a blank. (See also %H.)\n\
9294 %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
9295 12); single digits are preceded by a blank. (See also %I.)\n\
9296 %m: The month as a decimal number (range 01 to 12).\n\
9297 %M: The minute as a decimal number (range 00 to 59).\n\
9298 %n: A newline character.\n\
9299 %p: Either \"AM\" or \"PM\" according to the given time value.\n\
9300 Noon is treated as \"PM\" and midnight as \"AM\".\n\
9301 %r: Equivalent to %I:%M:%S %p.\n\
9302 %R: The time in 24-hour notation (%H:%M). For a version\n\
9303 including the seconds, see %T below.\n\
9304 %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
9306 %S: The second as a decimal number (range 00 to 60). (The\n\
9307 range is up to 60 to allow for occasional leap seconds.)\n\
9308 %t: A tab character.\n\
9309 %T: The time in 24-hour notation (%H:%M:%S).\n\
9310 %u: The day of the week as a decimal, range 1 to 7, Monday\n\
9311 being 1. See also %w.\n\
9312 %U: The week number of the current year as a decimal number,\n\
9313 range 00 to 53, starting with the first Sunday as the first\n\
9314 day of week 01. See also %V and %W.\n\
9315 %v: Equivalent to %e-%b-%Y.\n\
9316 %V: The ISO 8601 week number of the current year as a decimal\n\
9317 number, range 01 to 53, where week 1 is the first week that\n\
9318 has at least 4 days in the new year. See also %U and %W.\n\
9319 %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
9320 being 0. See also %u.\n\
9321 %W: The week number of the current year as a decimal number,\n\
9322 range 00 to 53, starting with the first Monday as the first\n\
9324 %x: Equivalent to %a %b %d %Y.\n\
9325 %X: Equivalent to %T.\n\
9326 %y: The year as a decimal number without a century (range 00\n\
9328 %Y: The year as a decimal number including a century.\n\
9329 %z: The UTC time-zone string = \"+0000\".\n\
9330 %Z: The UTC time-zone abbreviation = \"UTC\".\n\
9331 %+: The UTC date and time in default format of the Unix date\n\
9332 command which is equivalent to %a %b %d %T %Z %Y.\n\
9333 %%: A literal \"%\" character.\n\
9334 The conversion specifications which are extensions to those normally\n\
9335 provided by system strftime routines are the following: %(0-9):\n\
9336 The fractional part of the seconds field (including leading\n\
9337 decimal point) to the specified accuracy. Thus %S%3 would give\n\
9338 seconds to millisecond accuracy (00.000).\n\
9339 %.: The fractional part of the seconds field (including\n\
9340 leading decimal point) to the maximum available accuracy. Thus\n\
9341 %S%. would give seconds with fractional part up to 9 decimal\n\
9342 places if available.\n\
9345 Specify viewport using aspect ratio only\n\
9349 Selects the largest viewport with the given aspect ratio within the\n\
9350 subpage that leaves a standard margin (left-hand margin of eight\n\
9351 character heights, and a margin around the other three sides of five\n\
9352 character heights).\n\
9354 Redacted form: plvasp(aspect)\n\
9356 This function is used in example 13.\n\
9366 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
9367 axis of resulting viewport.\n\
9370 Set output file name\n\
9374 Sets the current output file name, if applicable. If the file name\n\
9375 has not been specified and is required by the driver, the user will be\n\
9376 prompted for it. If using the X-windows output driver, this sets the\n\
9377 display name. This routine, if used, must be called before\n\
9378 initializing PLplot.\n\
9380 Redacted form: plsfnam(fnam)\n\
9382 This function is used in examples 1 and 20.\n\
9392 fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9400 Draws a plot of vector data contained in the matrices (\n\
9406 ny]) . The scaling factor for the vectors is given by scale. A\n\
9407 transformation routine pointed to by pltr with a pointer pltr_data for\n\
9408 additional data required by the transformation routine to map indices\n\
9409 within the matrices to the world coordinates. The style of the vector\n\
9410 arrow may be set using plsvect.\n\
9412 Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
9413 discussion) the pltr, pltr_data callback arguments are sometimes\n\
9414 replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
9415 with either one or two dimensions.\n\
9417 This function is used in example 22.\n\
9423 plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
9427 u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
9428 and y components of the vector data to be plotted.\n\
9430 nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
9432 scale (PLFLT, input) : Parameter to control the scaling factor of\n\
9433 the vectors for plotting. If scale = 0 then the scaling factor is\n\
9434 automatically calculated for the data. If scale < 0 then the\n\
9435 scaling factor is automatically calculated for the data and then\n\
9437 scale. If scale > 0 then the scaling factor is set to scale.\n\
9439 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
9440 defines the transformation between the zero-based indices of the\n\
9441 matrices u and v and world coordinates.For the C case,\n\
9442 transformation functions are provided in the PLplot library: pltr0\n\
9443 for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
9444 mappings respectively defined by vectors and matrices. In\n\
9445 addition, C callback routines for the transformation can be\n\
9446 supplied by the user such as the mypltr function in\n\
9447 examples/c/x09c.c which provides a general linear transformation\n\
9448 between index coordinates and world coordinates.For languages\n\
9449 other than C you should consult the PLplot documentation for the\n\
9450 details concerning how PLTRANSFORM_callback arguments are\n\
9451 interfaced. However, in general, a particular pattern of\n\
9452 callback-associated arguments such as a tr vector with 6 elements;\n\
9453 xg and yg vectors; or xg and yg matrices are respectively\n\
9454 interfaced to a linear-transformation routine similar to the above\n\
9455 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
9456 sophisticated bindings (see, e.g., the PLplot documentation)\n\
9457 support native language callbacks for handling index to\n\
9458 world-coordinate transformations. Examples of these various\n\
9459 approaches are given in examples/<language>x09*,\n\
9460 examples/<language>x16*, examples/<language>x20*,\n\
9461 examples/<language>x21*, and examples/<language>x22*, for all our\n\
9462 supported languages.\n\
9464 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
9465 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
9466 that is externally supplied.\n\
9469 Set parameters that define current plot-space window\n\
9473 Set relative minima and maxima that define the current plot-space\n\
9474 window. If plsdiplt is not called the default values of xmin, ymin,\n\
9475 xmax, and ymax are 0., 0., 1., and 1.\n\
9477 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
9479 This function is used in example 31.\n\
9485 plsdiplt(xmin, ymin, xmax, ymax)\n\
9489 xmin (PLFLT, input) : Relative minimum in x.\n\
9491 ymin (PLFLT, input) : Relative minimum in y.\n\
9493 xmax (PLFLT, input) : Relative maximum in x.\n\
9495 ymax (PLFLT, input) : Relative maximum in y.\n\
9498 Select line style\n\
9502 This sets the line style according to one of eight predefined patterns\n\
9503 (also see plstyl).\n\
9505 Redacted form: pllsty(lin)\n\
9507 This function is used in examples 9, 12, 22, and 25.\n\
9517 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
9518 a continuous line, line style 2 is a line with short dashes and\n\
9519 gaps, line style 3 is a line with long dashes and gaps, line style\n\
9520 4 has long dashes and short gaps and so on.\n\
9523 Plot a glyph at the specified points\n\
9527 Plot a glyph at the specified points. (This function is largely\n\
9528 superseded by plstring which gives access to many[!] more glyphs.)\n\
9530 Redacted form: plsym(x, y, code)\n\
9532 This function is used in example 7.\n\
9538 plsym(n, x, y, code)\n\
9542 n (PLINT, input) : Number of points in the x and y vectors.\n\
9544 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9547 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9550 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
9551 to be plotted at each of the n points.\n\
9554 Set the device (keyword) name\n\
9558 Set the device (keyword) name.\n\
9560 Redacted form: plsdev(devname)\n\
9562 This function is used in examples 1, 14, and 20.\n\
9572 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
9573 containing the device name keyword of the required output device.\n\
9575 devname is NULL or if the first character of the string is a ``?\'\',\n\
9576 the normal (prompted) start up is used.\n\
9579 Set the background color by 8-bit RGB value\n\
9583 Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
9584 the PLplot documentation).\n\
9586 Redacted form: plscolbg(r, g, b)\n\
9588 This function is used in examples 15 and 31.\n\
9594 plscolbg(r, g, b)\n\
9598 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9599 degree of red in the color.\n\
9601 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9602 degree of green in the color.\n\
9604 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9605 degree of blue in the color.\n\
9608 Set parameters incrementally (zoom mode) that define current plot-space window\n\
9612 Set relative minima and maxima incrementally (zoom mode) that define\n\
9613 the current plot-space window. This function has the same effect as\n\
9614 plsdiplt if that function has not been previously called. Otherwise,\n\
9615 this function implements zoom mode using the transformation min_used =\n\
9616 old_min + old_length*min and max_used = old_min + old_length*max for\n\
9617 each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
9618 repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
9620 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
9622 This function is used in example 31.\n\
9628 plsdiplz(xmin, ymin, xmax, ymax)\n\
9632 xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
9634 ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
9636 xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
9638 ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
9641 Advance to the next family file on the next new page\n\
9645 Advance to the next family file on the next new page.\n\
9647 Redacted form: plfamadv()\n\
9649 This function is not used in any examples.\n\
9658 Set number of colors in cmap0\n\
9662 Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9663 (or reallocate) cmap0, and fill with default values for those colors\n\
9664 not previously allocated. The first 16 default colors are given in\n\
9665 the plcol0 documentation. For larger indices the default color is\n\
9668 The drivers are not guaranteed to support more than 16 colors.\n\
9670 Redacted form: plscmap0n(ncol0)\n\
9672 This function is used in examples 15, 16, and 24.\n\
9682 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9683 the cmap0 palette. If this number is zero or less, then the value\n\
9684 from the previous call to plscmap0n is used and if there is no\n\
9685 previous call, then a default value is used.\n\
9688 Plot latitude and longitude lines\n\
9692 Displays latitude and longitude on the current plot. The lines are\n\
9693 plotted in the current color and line style.\n\
9695 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
9698 This function is used in example 19.\n\
9704 plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
9708 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
9709 transform the coordinate longitudes and latitudes to a plot\n\
9710 coordinate system. By using this transform, we can change from a\n\
9711 longitude, latitude coordinate to a polar stereographic project,\n\
9712 for example. Initially, x[0]..[n-1] are the longitudes and\n\
9713 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
9714 mapform(), x[] and y[] should be replaced by the corresponding\n\
9715 plot coordinates. If no transform is desired, mapform can be\n\
9716 replaced by NULL.\n\
9718 dlong (PLFLT, input) : The interval in degrees at which the\n\
9719 longitude lines are to be plotted.\n\
9721 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
9722 lines are to be plotted.\n\
9724 minlong (PLFLT, input) : The value of the longitude on the left\n\
9725 side of the plot. The value of minlong must be less than the value\n\
9726 of maxlong, and the quantity maxlong-minlong must be less than or\n\
9729 maxlong (PLFLT, input) : The value of the longitude on the right\n\
9730 side of the plot.\n\
9732 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
9733 background. One can always use -90.0 as the boundary outside the\n\
9734 plot window will be automatically eliminated. However, the\n\
9735 program will be faster if one can reduce the size of the\n\
9736 background plotted.\n\
9738 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
9739 background. One can always use 90.0 as the boundary outside the\n\
9740 plot window will be automatically eliminated.\n\
9743 Convert RGB color to HLS\n\
9747 Convert RGB color coordinates to HLS\n\
9749 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9752 This function is used in example 2.\n\
9758 plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9762 r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9764 g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9766 b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9768 p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9769 degrees (0.0-360.0) on the color cylinder.\n\
9771 p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9772 expressed as a fraction (0.0-1.0) of the axis of the color\n\
9775 p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9776 expressed as a fraction (0.0-1.0) of the radius of the color\n\
9780 Plot a glyph at the specified 3D points\n\
9784 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
9785 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
9786 this function similar to what is done for plline3. The glyph is\n\
9787 specified with a PLplot user string. Note that the user string is not\n\
9788 actually limited to one glyph so it is possible (but not normally\n\
9789 useful) to plot more than one glyph at the specified points with this\n\
9790 function. As with plmtex and plptex, the user string can contain FCI\n\
9791 escapes to determine the font, UTF-8 code to determine the glyph or\n\
9792 else PLplot escapes for Hershey or unicode text to determine the\n\
9795 Redacted form: plstring3(x, y, z, string)\n\
9797 This function is used in example 18.\n\
9803 plstring3(n, x, y, z, string)\n\
9807 n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
9809 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9812 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9815 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
9818 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
9819 the glyph(s) to be plotted at each of the n points. points.\n\
9822 Switch to text screen\n\
9826 Sets an interactive device to text mode, used in conjunction with\n\
9827 plgra to allow graphics and text to be interspersed. On a device\n\
9828 which supports separate text and graphics windows, this command causes\n\
9829 control to be switched to the text window. This can be useful for\n\
9830 printing diagnostic messages or getting user input, which would\n\
9831 otherwise interfere with the plots. The program must switch back to\n\
9832 the graphics window before issuing plot commands, as the text (or\n\
9833 console) device will probably become quite confused otherwise. If\n\
9834 already in text mode, this command is ignored. It is also ignored on\n\
9835 devices which only support a single window or use a different method\n\
9836 for shifting focus (see also plgra).\n\
9838 Redacted form: pltext()\n\
9840 This function is used in example 1.\n\
9849 Get parameters that define current plot-space window\n\
9853 Get relative minima and maxima that define current plot-space window.\n\
9854 If plsdiplt has not been called the default values pointed to by\n\
9855 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
9857 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9859 This function is used in example 31.\n\
9865 plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9869 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9872 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9875 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9878 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9882 Get the (current) run level\n\
9886 Get the (current) run level. Valid settings are: 0, uninitialized\n\
9888 2, viewport defined\n\
9889 3, world coordinates defined\n\
9892 Redacted form: plglevel(p_level)\n\
9894 This function is used in example 31.\n\
9900 plglevel(p_level)\n\
9904 p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
9908 Plot a histogram from binned data\n\
9912 Plots a histogram consisting of nbin bins. The value associated with\n\
9913 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
9914 placed in y[i]. For proper operation, the values in x[i] must form a\n\
9915 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
9916 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
9917 placed midway between the values in the x vector. Also see plhist for\n\
9918 drawing histograms from unbinned data.\n\
9920 Redacted form: General: plbin(x, y, opt)\n\
9921 Python: plbin(nbin, x, y, opt)\n\
9924 This function is not used in any examples.\n\
9930 plbin(nbin, x, y, opt)\n\
9934 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
9937 x (PLFLT_VECTOR, input) : A vector containing values associated\n\
9938 with bins. These must form a strictly increasing sequence.\n\
9940 y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
9941 proportional to the number of points in each bin. This is a PLFLT\n\
9942 (instead of PLINT) vector so as to allow histograms of\n\
9943 probabilities, etc.\n\
9945 opt (PLINT, input) : Is a combination of several flags:\n\
9946 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
9947 outer bins are expanded to fill up the entire x-axis and bins of\n\
9948 zero height are simply drawn.\n\
9949 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
9950 between the x values. If the values in x are equally spaced,\n\
9951 the values are the center values of the bins.\n\
9952 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
9953 size as the ones inside.\n\
9954 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
9955 (there is a gap for such bins).\n\
9958 Plot a 2D matrix using cmap1\n\
9962 Plot a 2D matrix using cmap1.\n\
9964 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
9965 zmax, valuemin, valuemax, pltr, pltr_data)\n\
9968 This function is used in example 20.\n\
9974 plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
9978 idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
9979 plot. Should have dimensions of\n\
9983 nx, ny (PLINT, input) : Dimensions of idata\n\
9985 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
9986 pltr below for how these arguments are used (only for the special case\n\
9987 when the callback function\n\
9988 pltr is not supplied).\n\
9990 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
9991 (inclusive) will be plotted.\n\
9993 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
9994 values to use for value to color mappings. A datum equal to or\n\
9995 less than valuemin will be plotted with color 0.0, while a datum\n\
9996 equal to or greater than valuemax will be plotted with color 1.0.\n\
9997 Data between valuemin and valuemax map linearly to colors in the\n\
10000 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
10001 defines the transformation between the zero-based indices of the\n\
10002 matrix idata and world coordinates. If\n\
10003 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
10004 indices of idata are mapped to the range\n\
10006 xmax and the y indices of idata are mapped to the range\n\
10008 ymax.For the C case, transformation functions are provided in the\n\
10009 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
10010 pltr2 for arbitrary mappings respectively defined by vectors and\n\
10011 matrices. In addition, C callback routines for the transformation\n\
10012 can be supplied by the user such as the mypltr function in\n\
10013 examples/c/x09c.c which provides a general linear transformation\n\
10014 between index coordinates and world coordinates.For languages\n\
10015 other than C you should consult the PLplot documentation for the\n\
10016 details concerning how PLTRANSFORM_callback arguments are\n\
10017 interfaced. However, in general, a particular pattern of\n\
10018 callback-associated arguments such as a tr vector with 6 elements;\n\
10019 xg and yg vectors; or xg and yg matrices are respectively\n\
10020 interfaced to a linear-transformation routine similar to the above\n\
10021 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
10022 sophisticated bindings (see, e.g., the PLplot documentation)\n\
10023 support native language callbacks for handling index to\n\
10024 world-coordinate transformations. Examples of these various\n\
10025 approaches are given in examples/<language>x09*,\n\
10026 examples/<language>x16*, examples/<language>x20*,\n\
10027 examples/<language>x21*, and examples/<language>x22*, for all our\n\
10028 supported languages.\n\
10030 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
10031 information to pltr0, pltr1, pltr2, or whatever routine is\n\
10032 externally supplied.\n\
10035 Get family, style and weight of the current font\n\
10039 Gets information about current font. See the PLplot documentation for\n\
10040 more information on font selection.\n\
10042 Redacted form: plgfont(p_family, p_style, p_weight)\n\
10044 This function is used in example 23.\n\
10050 plgfont(p_family, p_style, p_weight)\n\
10054 p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10055 font family. The available values are given by the PL_FCI_*\n\
10056 constants in plplot.h. Current options are PL_FCI_SANS,\n\
10057 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
10058 p_family is NULL then the font family is not returned.\n\
10060 p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10061 font style. The available values are given by the PL_FCI_*\n\
10062 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
10063 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
10064 style is not returned.\n\
10066 p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10067 font weight. The available values are given by the PL_FCI_*\n\
10068 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
10069 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
10073 Get z axis parameters\n\
10077 Identical to plgxax, except that arguments are flags for z axis. See\n\
10078 the description of plgxax for more detail.\n\
10080 Redacted form: plgzax(p_digmax, p_digits)\n\
10082 This function is used in example 31.\n\
10088 plgzax(p_digmax, p_digits)\n\
10092 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
10093 number of digits for the z axis. If nonzero, the printed label\n\
10094 has been switched to a floating-point representation when the\n\
10095 number of digits exceeds this value.\n\
10097 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
10098 number of digits for the numeric labels (z axis) from the last\n\
10102 Write text inside the viewport of a 3D plot\n\
10106 Writes text at a specified position and inclination and with a\n\
10107 specified shear within the viewport. Text is clipped at the viewport\n\
10108 boundaries. The reference point of a string lies along a line passing\n\
10109 through the string at half the height of a capital letter. The\n\
10110 position of the reference point along this line is determined by just,\n\
10111 and the reference point is placed at world coordinates (\n\
10114 wz) within the viewport. The inclination and shear of the string is\n\
10115 specified in terms of differences of world coordinates making it easy\n\
10116 to write text parallel to a line in a graph.\n\
10118 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
10120 This function is used in example 28.\n\
10126 plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
10130 wx (PLFLT, input) : x world coordinate of reference point of\n\
10133 wy (PLFLT, input) : y world coordinate of reference point of\n\
10136 wz (PLFLT, input) : z world coordinate of reference point of\n\
10139 dx (PLFLT, input) : Together with dy and\n\
10140 dz , this specifies the inclination of the string. The baseline of\n\
10141 the string is parallel to a line joining (\n\
10152 dy (PLFLT, input) : Together with dx and\n\
10153 dz, this specifies the inclination of the string.\n\
10155 dz (PLFLT, input) : Together with dx and\n\
10156 dy, this specifies the inclination of the string.\n\
10158 sx (PLFLT, input) : Together with sy and\n\
10159 sz , this specifies the shear of the string. The string is sheared so\n\
10160 that the characters are vertically parallel to a line joining (\n\
10171 sz = 0.) then the text is not sheared.\n\
10173 sy (PLFLT, input) : Together with sx and\n\
10174 sz, this specifies shear of the string.\n\
10176 sz (PLFLT, input) : Together with sx and\n\
10177 sy, this specifies shear of the string.\n\
10179 just (PLFLT, input) : Specifies the position of the string relative\n\
10180 to its reference point. If just=0. , the reference point is at\n\
10181 the left and if just=1. , it is at the right of the string. Other\n\
10182 values of just give intermediate justifications.\n\
10184 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
10188 Draw a box with axes, etc. with arbitrary origin\n\
10192 Draws a box around the currently defined viewport with arbitrary\n\
10193 world-coordinate origin specified by x0 and y0 and labels it with\n\
10194 world coordinate values appropriate to the window. Thus plaxes should\n\
10195 only be called after defining both viewport and window. The ascii\n\
10196 character strings xopt and yopt specify how the box should be drawn as\n\
10197 described below. If ticks and/or subticks are to be drawn for a\n\
10198 particular axis, the tick intervals and number of subintervals may be\n\
10199 specified explicitly, or they may be defaulted by setting the\n\
10200 appropriate arguments to zero.\n\
10202 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
10206 This function is not used in any examples.\n\
10212 plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
10216 x0 (PLFLT, input) : World X coordinate of origin.\n\
10218 y0 (PLFLT, input) : World Y coordinate of origin.\n\
10220 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10221 options for the x axis. The string can include any combination of\n\
10222 the following letters (upper or lower case) in any order: a: Draws\n\
10223 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
10225 b: Draws bottom (X) or left (Y) edge of frame.\n\
10226 c: Draws top (X) or right (Y) edge of frame.\n\
10227 d: Plot labels as date / time. Values are assumed to be\n\
10228 seconds since the epoch (as used by gmtime).\n\
10229 f: Always use fixed point numeric labels.\n\
10230 g: Draws a grid at the major tick interval.\n\
10231 h: Draws a grid at the minor tick interval.\n\
10232 i: Inverts tick marks, so they are drawn outwards, rather than\n\
10234 l: Labels axis logarithmically. This only affects the labels,\n\
10235 not the data, and so it is necessary to compute the logarithms\n\
10236 of data points before passing them to any of the drawing\n\
10238 m: Writes numeric labels at major tick intervals in the\n\
10239 unconventional location (above box for X, right of box for Y).\n\
10240 n: Writes numeric labels at major tick intervals in the\n\
10241 conventional location (below box for X, left of box for Y).\n\
10242 o: Use custom labelling function to generate axis label text.\n\
10243 The custom labelling function can be defined with the\n\
10244 plslabelfunc command.\n\
10245 s: Enables subticks between major ticks, only valid if t is\n\
10247 t: Draws major ticks.\n\
10248 u: Exactly like \"b\" except don\'t draw edge line.\n\
10249 w: Exactly like \"c\" except don\'t draw edge line.\n\
10250 x: Exactly like \"t\" (including the side effect of the\n\
10251 numerical labels for the major ticks) except exclude drawing\n\
10252 the major and minor tick marks.\n\
10255 xtick (PLFLT, input) : World coordinate interval between major\n\
10256 ticks on the x axis. If it is set to zero, PLplot automatically\n\
10257 generates a suitable tick interval.\n\
10259 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
10260 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
10261 generates a suitable minor tick interval.\n\
10263 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10264 options for the y axis. The string can include any combination of\n\
10265 the letters defined above for xopt, and in addition may contain:\n\
10266 v: Write numeric labels for the y axis parallel to the base of the\n\
10267 graph, rather than parallel to the axis.\n\
10270 ytick (PLFLT, input) : World coordinate interval between major\n\
10271 ticks on the y axis. If it is set to zero, PLplot automatically\n\
10272 generates a suitable tick interval.\n\
10274 nysub (PLINT, input) : Number of subintervals between major y axis\n\
10275 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
10276 generates a suitable minor tick interval.\n\
10279 Returns the background color (cmap0[0]) by 8-bit RGB value\n\
10283 Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
10285 Redacted form: plgcolbg(r, g, b)\n\
10287 This function is used in example 31.\n\
10293 plgcolbg(r, g, b)\n\
10297 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
10298 in the range from 0 to 255.\n\
10300 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
10301 in the range from 0 to 255.\n\
10303 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
10304 in the range from 0 to 255.\n\
10307 Plot a glyph at the specified 3D points\n\
10311 Plot a glyph at the specified 3D points. (This function is largely\n\
10312 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
10313 Set up the call to this function similar to what is done for plline3.\n\
10314 code=-1 means try to just draw a point. Right now it\'s just a move\n\
10315 and a draw at the same place. Not ideal, since a sufficiently\n\
10316 intelligent output device may optimize it away, or there may be faster\n\
10317 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
10318 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
10319 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
10320 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
10321 code <= 127 the corresponding printable ASCII character is plotted.\n\
10323 Redacted form: plpoin3(x, y, z, code)\n\
10325 This function is not used in any example.\n\
10331 plpoin3(n, x, y, z, code)\n\
10335 n (PLINT, input) : Number of points in the x and y vectors.\n\
10337 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
10340 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10343 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
10346 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
10347 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
10348 each of the n points.\n\
10351 Draw a polygon in 3 space\n\
10355 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10356 like plline3, but differs from that function in that plpoly3 attempts\n\
10357 to determine if the polygon is viewable depending on the order of the\n\
10358 points within the vector and the value of ifcc. If the back of\n\
10359 polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10360 you want, then use plline3 instead.\n\
10362 The points are assumed to be in a plane, and the directionality of the\n\
10363 plane is determined from the first three points. Additional points do\n\
10364 not have to lie on the plane defined by the first three, but if they\n\
10365 do not, then the determination of visibility obviously can\'t be 100%\n\
10366 accurate... So if you\'re 3 space polygons are too far from planar,\n\
10367 consider breaking them into smaller polygons. 3 points define a plane\n\
10370 Bugs: If one of the first two segments is of zero length, or if they\n\
10371 are co-linear, the calculation of visibility has a 50/50 chance of\n\
10372 being correct. Avoid such situations :-). See x18c.c for an example\n\
10373 of this problem. (Search for 20.1).\n\
10375 Redacted form: plpoly3(x, y, z, code)\n\
10377 This function is used in example 18.\n\
10383 plpoly3(n, x, y, z, draw, ifcc)\n\
10387 n (PLINT, input) : Number of points defining line.\n\
10389 x (PLFLT_VECTOR, input) : A vector containing\n\
10390 n x coordinates of points.\n\
10392 y (PLFLT_VECTOR, input) : A vector containing\n\
10393 n y coordinates of points.\n\
10395 z (PLFLT_VECTOR, input) : A vector containing\n\
10396 n z coordinates of points.\n\
10398 draw (PLBOOL_VECTOR, input) : A vector containing\n\
10399 n-1 Boolean values which control drawing the segments of the polygon.\n\
10400 If draw[i] is true, then the polygon segment from index [i] to\n\
10401 [i+1] is drawn, otherwise, not.\n\
10403 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10404 polygon is determined by assuming the points are laid out in a\n\
10405 counter-clockwise order. Otherwise, the directionality of the\n\
10406 polygon is determined by assuming the points are laid out in a\n\
10407 clockwise order.\n\
10410 Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
10414 Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
10415 PLFLT alpha transparency value (see the PLplot documentation).\n\
10417 This function is used in example 31.\n\
10423 plscolbga(r, g, b, alpha)\n\
10427 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10428 degree of red in the color.\n\
10430 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10431 degree of green in the color.\n\
10433 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10434 degree of blue in the color.\n\
10436 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
10440 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
10444 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
10445 alpha transparency value.\n\
10447 This function is used in example 31.\n\
10453 plgcolbga(r, g, b, alpha)\n\
10457 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
10458 in the range from 0 to 255.\n\
10460 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
10461 in the range from 0 to 255.\n\
10463 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
10464 in the range from 0 to 255.\n\
10466 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
10467 transparency in the range (0.0-1.0).\n\
10470 Draw error bars in x direction\n\
10474 Draws a set of n error bars in x direction, the i\'th error bar\n\
10475 extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
10476 of the error bars are of length equal to the minor tick length\n\
10477 (settable using plsmin).\n\
10479 Redacted form: General: plerrx(xmin, ymax, y)\n\
10482 This function is used in example 29.\n\
10488 plerrx(n, xmin, xmax, y)\n\
10492 n (PLINT, input) : Number of error bars to draw.\n\
10494 xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10495 of the left-hand endpoints of the error bars.\n\
10497 xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10498 of the right-hand endpoints of the error bars.\n\
10500 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10504 Eject current page\n\
10508 Clears the graphics screen of an interactive device, or ejects a page\n\
10509 on a plotter. See plbop for more information.\n\
10511 Redacted form: pleop()\n\
10513 This function is used in example 2,14.\n\
10522 Convert HLS color to RGB\n\
10526 Convert HLS color coordinates to RGB.\n\
10528 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10531 This function is used in example 2.\n\
10537 plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10541 h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
10544 l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
10545 the axis of the color cylinder.\n\
10547 s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
10548 the radius of the color cylinder.\n\
10550 p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
10551 (0.0-1.0) of the color.\n\
10553 p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
10554 intensity (0.0-1.0) of the color.\n\
10556 p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
10557 intensity (0.0-1.0) of the color.\n\
10560 Plot all or a subset of Shapefile data, filling the polygons\n\
10564 As per plmapline, however the items are filled in the same way as\n\
10567 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
10570 This function is used in example 19.\n\
10576 plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
10580 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
10581 transform the coordinates given in the shapefile into a plot\n\
10582 coordinate system. By using this transform, we can change from a\n\
10583 longitude, latitude coordinate to a polar stereographic project,\n\
10584 for example. Initially, x[0]..[n-1] are the longitudes and\n\
10585 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
10586 mapform(), x[] and y[] should be replaced by the corresponding\n\
10587 plot coordinates. If no transform is desired, mapform can be\n\
10588 replaced by NULL.\n\
10590 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10591 the file name of a set of Shapefile files without the file\n\
10594 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
10595 be in the same units as used by the Shapefile. You could use a\n\
10596 very large negative number to plot everything, but you can improve\n\
10597 performance by limiting the area drawn. The units must match those\n\
10598 of the Shapefile projection, which may be for example longitude or\n\
10599 distance. The value of minx must be less than the value of maxx.\n\
10601 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
10602 use a very large number to plot everything, but you can improve\n\
10603 performance by limiting the area drawn.\n\
10605 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
10606 be in the same units as used by the Shapefile. You could use a\n\
10607 very large negative number to plot everything, but you can improve\n\
10608 performance by limiting the area drawn. The units must match those\n\
10609 of the Shapefile projection, which may be for example latitude or\n\
10610 distance. The value of miny must be less than the value of maxy.\n\
10612 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
10613 use a very large number to plot everything, but you can improve\n\
10614 performance by limiting the area drawn.\n\
10616 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
10617 zero-based indices of the Shapefile elements which will be drawn.\n\
10619 plotentries to NULL will plot all elements of the Shapefile.\n\
10621 nplotentries (PLINT, input) : The number of items in\n\
10622 plotentries. Ignored if\n\
10623 plotentries is NULL.\n\
10626 Draw error bars in the y direction\n\
10630 Draws a set of n error bars in the y direction, the i\'th error bar\n\
10631 extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
10632 of the error bars are of length equal to the minor tick length\n\
10633 (settable using plsmin).\n\
10635 Redacted form: General: plerry(x, ymin, ymax)\n\
10638 This function is used in example 29.\n\
10644 plerry(n, x, ymin, ymax)\n\
10648 n (PLINT, input) : Number of error bars to draw.\n\
10650 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
10653 ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10654 of the lower endpoints of the error bars.\n\
10656 ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10657 of the upper endpoints of the error bars.\n\
10660 Set FCI (font characterization integer)\n\
10664 Sets font characteristics to be used at the start of the next string\n\
10665 using the FCI approach. See the PLplot documentation for more\n\
10666 information. Note, plsfont (which calls plsfci internally) provides a\n\
10667 more user-friendly API for setting the font characterisitics.\n\
10669 Redacted form: General: plsfci(fci)\n\
10672 This function is used in example 23.\n\
10682 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
10686 Select area fill pattern\n\
10691 patt is zero or less use either a hardware solid fill if the drivers\n\
10692 have that capability (virtually all do) or fall back to a software\n\
10693 emulation of a solid fill using the eighth area line fill pattern. If\n\
10695 patt <= 8, then select one of eight predefined area line fill patterns\n\
10696 to use (see plpat if you desire other patterns).\n\
10698 Redacted form: plpsty(patt)\n\
10700 This function is used in examples 12, 13, 15, 16, and 25.\n\
10710 patt (PLINT, input) : The desired pattern index. If\n\
10711 patt is zero or less, then a solid fill is (normally, see qualifiers\n\
10712 above) used. For\n\
10713 patt in the range from 1 to 8 and assuming the driver has not supplied\n\
10714 line fill capability itself (most deliberately do not so that line\n\
10715 fill patterns look identical for those drivers), the patterns\n\
10716 consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
10717 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
10718 lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
10719 (8) lines at both 45 degrees and -45 degrees.\n\
10726 This sets up the size of all subsequent symbols drawn by plpoin and\n\
10727 plsym. The actual height of a symbol is the product of the default\n\
10728 symbol size and a scaling factor as for the character height.\n\
10730 Redacted form: plssym(def, scale)\n\
10732 This function is used in example 29.\n\
10738 plssym(def, scale)\n\
10742 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
10743 should be set to zero if the default height is to remain\n\
10746 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
10747 actual symbol height.\n\
10754 Alternative to plstar for initializing the plotting package. The\n\
10755 device name keyword for the desired output device must be supplied as\n\
10756 an argument. These keywords are the same as those printed out by\n\
10757 plstar. If the requested device is not available, or if the input\n\
10758 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
10759 is used. This routine also divides the output device page into nx by\n\
10760 ny subpages, each of which may be used independently. The subroutine\n\
10761 pladv is used to advance from one subpage to the next.\n\
10763 Redacted form: General: plstart(devname, nx, ny)\n\
10766 This function is not used in any examples.\n\
10772 plstart(devname, nx, ny)\n\
10776 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
10777 containing the device name keyword of the required output device.\n\
10779 devname is NULL or if the first character of the string is a ``?\'\',\n\
10780 the normal (prompted) start up is used.\n\
10782 nx (PLINT, input) : Number of subpages to divide output page in the\n\
10785 ny (PLINT, input) : Number of subpages to divide output page in the\n\
10792 char **arg3 = (
char **) 0 ;
10794 octave_value_list _out;
10795 octave_value_list *_outp=&_out;
10796 octave_value _outv;
10803 if (
_n_dims( args(0) ) > 1 )
10809 temp1 = args(0).matrix_value();
10813 charMatrix temp_matrix;
10817 size_t max_length = 0, non_blank_length;
10819 if (
_n_dims( args(1) ) > 2 )
10821 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
10823 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10824 if ( !args(1).isempty() )
10826 if ( !args(1).is_empty() )
10831 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
10833 arg3 =
new char*[
Alen];
10834 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10835 ifcell = args(1).iscell();
10837 ifcell = args(1).is_cell();
10841 temp_cell = args(1).cell_value();
10845 temp_matrix = args(1).char_matrix_value();
10847 max_length =
_dim( args(1), 1 ) + 1;
10850 for ( i = 0; i <
Alen; i++ )
10857 if ( temp_cell.elem( i ).is_string() )
10859 str = temp_cell.elem( i ).string_value();
10861 max_length = str.size() + 1;
10862 tmp_cstring = (
char *) str.c_str();
10872 tmp_cstring = (
char *)
"";
10877 str = temp_matrix.row_as_string( i );
10878 tmp_cstring = (
char *) str.c_str();
10880 arg3[i] =
new char[max_length];
10881 strncpy( arg3[i], tmp_cstring, max_length - 1 );
10882 arg3[i][max_length - 1] =
'\0';
10897 non_blank_length = max_length - 2;
10898 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
'\0' )
10900 non_blank_length--;
10902 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
' ' )
10904 non_blank_length--;
10906 arg3[i][non_blank_length + 1] =
'\0';
10915 testppchar(arg1,(
int const *)arg2,(
char const **)arg3);
10916 _outv = octave_value();
10923 if ( arg3 != NULL )
10925 for ( i = 0; i <
Alen; i++ )
10939 if ( arg3 != NULL )
10941 for ( i = 0; i <
Alen; i++ )
10948 return octave_value_list();
10956 if ( arg3 != NULL )
10958 for ( i = 0; i <
Alen; i++ )
10971 int *arg1 = (
int *) 0 ;
10972 int *arg2 = (
int *) 0 ;
10973 int *arg3 = (
int *) 0 ;
10974 char *arg4 = (
char *) 0 ;
10975 int *arg5 = (
int *) 0 ;
10976 int *arg6 = (
int *) 0 ;
10981 int *arg11 = (
int *) 0 ;
10988 char local_string4[80] ;
11003 size_t local_string_length4 ;
11004 charMatrix local_charMatrix4 ;
11005 octave_value_list retval4 ;
11006 octave_value_list _out;
11007 octave_value_list *_outp=&_out;
11008 octave_value _outv;
11016 arg4 = local_string4;
11028 result = (int)
my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11050 local_string_length4 = strlen( local_string4 );
11051 local_charMatrix4 = charMatrix( 1, local_string_length4 );
11052 local_charMatrix4.insert( local_string4, 0, 0 );
11053 retval4( 0 ) = octave_value( local_charMatrix4 );
11100 return octave_value_list();
11121 octave_value_list _out;
11122 octave_value_list *_outp=&_out;
11123 octave_value _outv;
11136 arg3 =
static_cast< PLFLT >(val3);
11141 arg4 =
static_cast< PLFLT >(val4);
11159 return octave_value_list();
11169 char *arg2 = (
char *) 0 ;
11170 char *arg3 = (
char *) 0 ;
11184 char *arg17 = (
char *) 0 ;
11185 char *arg18 = (
char *) 0 ;
11186 char *arg19 = (
char *) 0 ;
11187 char *arg20 = (
char *) 0 ;
11188 char *arg21 = (
char *) 0 ;
11189 char *arg22 = (
char *) 0 ;
11190 char *arg23 = (
char *) 0 ;
11244 octave_value_list _out;
11245 octave_value_list *_outp=&_out;
11246 octave_value _outv;
11257 arg2 =
reinterpret_cast< char *
>(buf2);
11262 arg3 =
reinterpret_cast< char *
>(buf3);
11267 arg4 =
static_cast< PLFLT >(val4);
11272 arg5 =
static_cast< PLFLT >(val5);
11277 arg6 =
static_cast< PLFLT >(val6);
11282 arg7 =
static_cast< PLFLT >(val7);
11287 arg8 =
static_cast< PLFLT >(val8);
11292 arg9 =
static_cast< PLFLT >(val9);
11297 arg10 =
static_cast< PLFLT >(val10);
11302 arg11 =
static_cast< PLBOOL >(val11);
11307 arg12 =
static_cast< PLBOOL >(val12);
11312 arg13 =
static_cast< PLINT >(val13);
11317 arg14 =
static_cast< PLINT >(val14);
11319 if (
_n_dims( args(13) ) > 1 )
11324 temp15 = args(13).matrix_value();
11329 if (
_n_dims( args(14) ) > 1 )
11333 if (
_dim( args(14), 0 ) !=
Alen )
11337 temp16 = args(14).matrix_value();
11345 arg17 =
reinterpret_cast< char *
>(buf17);
11350 arg18 =
reinterpret_cast< char *
>(buf18);
11355 arg19 =
reinterpret_cast< char *
>(buf19);
11360 arg20 =
reinterpret_cast< char *
>(buf20);
11365 arg21 =
reinterpret_cast< char *
>(buf21);
11370 arg22 =
reinterpret_cast< char *
>(buf22);
11375 arg23 =
reinterpret_cast< char *
>(buf23);
11376 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);
11377 _outv = octave_value();
11417 return octave_value_list();
11462 octave_value_list _out;
11463 octave_value_list *_outp=&_out;
11464 octave_value _outv;
11471 if (
_n_dims( args(0) ) > 2 )
11473 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11475 temp1 = args(0).matrix_value();
11476 arg1 = &temp1( 0, 0 );
11484 arg4 =
static_cast< PLINT >(val4);
11489 arg5 =
static_cast< PLINT >(val5);
11494 arg6 =
static_cast< PLINT >(val6);
11499 arg7 =
static_cast< PLINT >(val7);
11501 if (
_n_dims( args(5) ) > 1 )
11505 temp8 = args(5).matrix_value();
11506 arg8 = &temp8( 0, 0 );
11510 if (
_n_dims( args(6) ) > 1 )
11514 if (
_dim( args(6), 0 ) != 6 )
11518 temp10 = args(6).matrix_value();
11519 arg10 = &temp10( 0, 0 );
11521 my_plcont((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10);
11522 _outv = octave_value();
11544 return octave_value_list();
11581 octave_value_list _out;
11582 octave_value_list *_outp=&_out;
11583 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 );
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 );
11628 my_plcont0((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9);
11629 _outv = octave_value();
11645 return octave_value_list();
11683 octave_value_list _out;
11684 octave_value_list *_outp=&_out;
11685 octave_value _outv;
11692 if (
_n_dims( args(0) ) > 2 )
11694 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11696 temp1 = args(0).matrix_value();
11697 arg1 = &temp1( 0, 0 );
11705 arg4 =
static_cast< PLINT >(val4);
11710 arg5 =
static_cast< PLINT >(val5);
11715 arg6 =
static_cast< PLINT >(val6);
11720 arg7 =
static_cast< PLINT >(val7);
11722 if (
_n_dims( args(5) ) > 1 )
11726 temp8 = args(5).matrix_value();
11727 arg8 = &temp8( 0, 0 );
11731 if (
_n_dims( args(6) ) > 1 )
11739 temp10 = args(6).matrix_value();
11740 arg10 = &temp10( 0, 0 );
11743 if (
_n_dims( args(7) ) > 1 )
11751 temp11 = args(7).matrix_value();
11752 arg11 = &temp11( 0, 0 );
11754 my_plcont1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11755 _outv = octave_value();
11783 return octave_value_list();
11827 octave_value_list _out;
11828 octave_value_list *_outp=&_out;
11829 octave_value _outv;
11836 if (
_n_dims( args(0) ) > 2 )
11838 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11840 temp1 = args(0).matrix_value();
11841 arg1 = &temp1( 0, 0 );
11849 arg4 =
static_cast< PLINT >(val4);
11854 arg5 =
static_cast< PLINT >(val5);
11859 arg6 =
static_cast< PLINT >(val6);
11864 arg7 =
static_cast< PLINT >(val7);
11866 if (
_n_dims( args(5) ) > 1 )
11870 temp8 = args(5).matrix_value();
11871 arg8 = &temp8( 0, 0 );
11875 if (
_n_dims( args(6) ) > 2 )
11877 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11881 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11885 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11887 temp10 = args(6).matrix_value();
11888 arg10 = &temp10( 0, 0 );
11891 if (
_n_dims( args(7) ) > 2 )
11893 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
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 temp11 = args(7).matrix_value();
11904 arg11 = &temp11( 0, 0 );
11906 my_plcont2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11907 _outv = octave_value();
11935 return octave_value_list();
11979 octave_value_list _out;
11980 octave_value_list *_outp=&_out;
11981 octave_value _outv;
11988 if (
_n_dims( args(0) ) > 2 )
11990 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11992 temp1 = args(0).matrix_value();
11993 arg1 = &temp1( 0, 0 );
12001 arg4 =
static_cast< PLINT >(val4);
12006 arg5 =
static_cast< PLINT >(val5);
12011 arg6 =
static_cast< PLINT >(val6);
12016 arg7 =
static_cast< PLINT >(val7);
12018 if (
_n_dims( args(5) ) > 1 )
12022 temp8 = args(5).matrix_value();
12023 arg8 = &temp8( 0, 0 );
12027 if (
_n_dims( args(6) ) > 2 )
12029 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12033 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12037 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12039 temp10 = args(6).matrix_value();
12040 arg10 = &temp10( 0, 0 );
12043 if (
_n_dims( args(7) ) > 2 )
12045 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12049 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12053 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12055 temp11 = args(7).matrix_value();
12056 arg11 = &temp11( 0, 0 );
12058 my_plcont2p((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
12059 _outv = octave_value();
12087 return octave_value_list();
12124 octave_value_list retval7 ;
12129 octave_value_list _out;
12130 octave_value_list *_outp=&_out;
12131 octave_value _outv;
12138 if (
_n_dims( args(0) ) > 1 )
12143 temp1 = args(0).matrix_value();
12144 arg1 = &temp1( 0, 0 );
12147 if (
_n_dims( args(1) ) > 1 )
12155 temp2 = args(1).matrix_value();
12156 arg2 = &temp2( 0, 0 );
12159 if (
_n_dims( args(2) ) > 1 )
12167 temp3 = args(2).matrix_value();
12168 arg3 = &temp3( 0, 0 );
12172 if (
_n_dims( args(3) ) > 1 )
12176 temp5 = args(3).matrix_value();
12177 arg5 = &temp5( 0, 0 );
12181 if (
_n_dims( args(4) ) > 1 )
12185 temp7 = args(4).matrix_value();
12186 arg7 = &temp7( 0, 0 );
12188 retval7( 0 ) = octave_value( Matrix(
Xlen,
Ylen ) );
12189 arg9 = (
PLFLT *) retval7( 0 ).matrix_value().data();
12195 arg10 =
static_cast< PLINT >(val10);
12200 arg11 =
static_cast< PLFLT >(val11);
12201 my_plgriddata((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,(
double const *)arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,arg11);
12202 _outv = octave_value();
12239 return octave_value_list();
12274 octave_value_list _out;
12275 octave_value_list *_outp=&_out;
12276 octave_value _outv;
12283 if (
_n_dims( args(0) ) > 1 )
12287 temp1 = args(0).matrix_value();
12288 arg1 = &temp1( 0, 0 );
12292 if (
_n_dims( args(1) ) > 1 )
12296 temp2 = args(1).matrix_value();
12297 arg2 = &temp2( 0, 0 );
12301 if (
_n_dims( args(2) ) > 2 )
12303 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12307 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12311 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12313 temp3 = args(2).matrix_value();
12314 arg3 = &temp3( 0, 0 );
12322 arg6 =
static_cast< PLINT >(val6);
12323 my_plmesh((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6);
12324 _outv = octave_value();
12346 return octave_value_list();
12378 octave_value_list _out;
12379 octave_value_list *_outp=&_out;
12380 octave_value _outv;
12387 if (
_n_dims( args(0) ) > 1 )
12391 temp1 = args(0).matrix_value();
12392 arg1 = &temp1( 0, 0 );
12396 if (
_n_dims( args(1) ) > 1 )
12400 temp2 = args(1).matrix_value();
12401 arg2 = &temp2( 0, 0 );
12405 if (
_n_dims( args(2) ) > 2 )
12407 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12411 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12415 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12417 temp3 = args(2).matrix_value();
12418 arg3 = &temp3( 0, 0 );
12426 arg6 =
static_cast< PLINT >(val6);
12428 if (
_n_dims( args(4) ) > 1 )
12432 temp7 = args(4).matrix_value();
12433 arg7 = &temp7( 0, 0 );
12436 my_plmeshc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12437 _outv = octave_value();
12465 return octave_value_list();
12500 octave_value_list _out;
12501 octave_value_list *_outp=&_out;
12502 octave_value _outv;
12509 if (
_n_dims( args(0) ) > 1 )
12513 temp1 = args(0).matrix_value();
12514 arg1 = &temp1( 0, 0 );
12518 if (
_n_dims( args(1) ) > 1 )
12522 temp2 = args(1).matrix_value();
12523 arg2 = &temp2( 0, 0 );
12527 if (
_n_dims( args(2) ) > 2 )
12529 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12533 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12537 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12539 temp3 = args(2).matrix_value();
12540 arg3 = &temp3( 0, 0 );
12548 arg6 =
static_cast< PLINT >(val6);
12553 arg7 =
static_cast< PLBOOL >(val7);
12554 my_plot3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,arg7);
12555 _outv = octave_value();
12577 return octave_value_list();
12609 octave_value_list _out;
12610 octave_value_list *_outp=&_out;
12611 octave_value _outv;
12618 if (
_n_dims( args(0) ) > 1 )
12622 temp1 = args(0).matrix_value();
12623 arg1 = &temp1( 0, 0 );
12627 if (
_n_dims( args(1) ) > 1 )
12631 temp2 = args(1).matrix_value();
12632 arg2 = &temp2( 0, 0 );
12636 if (
_n_dims( args(2) ) > 2 )
12638 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12642 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12646 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12648 temp3 = args(2).matrix_value();
12649 arg3 = &temp3( 0, 0 );
12657 arg6 =
static_cast< PLINT >(val6);
12659 if (
_n_dims( args(4) ) > 1 )
12663 temp7 = args(4).matrix_value();
12664 arg7 = &temp7( 0, 0 );
12667 my_plot3dc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12668 _outv = octave_value();
12696 return octave_value_list();
12739 octave_value_list _out;
12740 octave_value_list *_outp=&_out;
12741 octave_value _outv;
12748 if (
_n_dims( args(0) ) > 1 )
12752 temp1 = args(0).matrix_value();
12753 arg1 = &temp1( 0, 0 );
12757 if (
_n_dims( args(1) ) > 1 )
12761 temp2 = args(1).matrix_value();
12762 arg2 = &temp2( 0, 0 );
12766 if (
_n_dims( args(2) ) > 2 )
12768 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12772 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12776 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12778 temp3 = args(2).matrix_value();
12779 arg3 = &temp3( 0, 0 );
12787 arg6 =
static_cast< PLINT >(val6);
12789 if (
_n_dims( args(4) ) > 1 )
12793 temp7 = args(4).matrix_value();
12794 arg7 = &temp7( 0, 0 );
12801 arg9 =
static_cast< PLINT >(val9);
12803 if (
_n_dims( args(6) ) > 1 )
12809 temp10 = args(6).matrix_value();
12813 if (
_n_dims( args(7) ) > 1 )
12821 temp12 = args(7).matrix_value();
12825 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);
12826 _outv = octave_value();
12866 return octave_value_list();
12907 octave_value_list _out;
12908 octave_value_list *_outp=&_out;
12909 octave_value _outv;
12916 if (
_n_dims( args(0) ) > 1 )
12920 temp1 = args(0).matrix_value();
12921 arg1 = &temp1( 0, 0 );
12925 if (
_n_dims( args(1) ) > 1 )
12929 temp2 = args(1).matrix_value();
12930 arg2 = &temp2( 0, 0 );
12934 if (
_n_dims( args(2) ) > 2 )
12936 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12940 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12944 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12946 temp3 = args(2).matrix_value();
12947 arg3 = &temp3( 0, 0 );
12955 arg6 =
static_cast< PLINT >(val6);
12957 if (
_n_dims( args(4) ) > 1 )
12961 temp7 = args(4).matrix_value();
12962 arg7 = &temp7( 0, 0 );
12965 my_plsurf3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12966 _outv = octave_value();
12994 return octave_value_list();
13037 octave_value_list _out;
13038 octave_value_list *_outp=&_out;
13039 octave_value _outv;
13046 if (
_n_dims( args(0) ) > 1 )
13050 temp1 = args(0).matrix_value();
13051 arg1 = &temp1( 0, 0 );
13055 if (
_n_dims( args(1) ) > 1 )
13059 temp2 = args(1).matrix_value();
13060 arg2 = &temp2( 0, 0 );
13064 if (
_n_dims( args(2) ) > 2 )
13066 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13070 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13074 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13076 temp3 = args(2).matrix_value();
13077 arg3 = &temp3( 0, 0 );
13085 arg6 =
static_cast< PLINT >(val6);
13087 if (
_n_dims( args(4) ) > 1 )
13091 temp7 = args(4).matrix_value();
13092 arg7 = &temp7( 0, 0 );
13099 arg9 =
static_cast< PLINT >(val9);
13101 if (
_n_dims( args(6) ) > 1 )
13107 temp10 = args(6).matrix_value();
13111 if (
_n_dims( args(7) ) > 1 )
13119 temp12 = args(7).matrix_value();
13123 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);
13124 _outv = octave_value();
13164 return octave_value_list();
13241 octave_value_list _out;
13242 octave_value_list *_outp=&_out;
13243 octave_value _outv;
13250 if (
_n_dims( args(0) ) > 2 )
13252 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13254 temp1 = args(0).matrix_value();
13255 arg1 = &temp1( 0, 0 );
13260 if (
_n_dims( args(1) ) > 1 )
13265 temp4 = args(1).matrix_value();
13266 arg4 = &temp4( 0, 0 );
13272 arg5 =
static_cast< PLFLT >(val5);
13277 arg6 =
static_cast< PLFLT >(val6);
13282 arg7 =
static_cast< PLFLT >(val7);
13287 arg8 =
static_cast< PLFLT >(val8);
13292 arg9 =
static_cast< PLFLT >(val9);
13297 arg10 =
static_cast< PLFLT >(val10);
13302 arg11 =
static_cast< PLINT >(val11);
13307 arg12 =
static_cast< PLFLT >(val12);
13312 arg13 =
static_cast< PLINT >(val13);
13317 arg14 =
static_cast< PLINT >(val14);
13322 arg15 =
static_cast< PLINT >(val15);
13327 arg16 =
static_cast< PLINT >(val16);
13332 arg17 =
static_cast< PLINT >(val17);
13337 arg18 =
static_cast< PLBOOL >(val18);
13339 if (
_n_dims( args(16) ) > 1 )
13343 if (
_dim( args(16), 0 ) != 6 )
13347 temp19 = args(16).matrix_value();
13348 arg19 = &temp19( 0, 0 );
13350 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);
13351 _outv = octave_value();
13373 return octave_value_list();
13394 char *arg4 = (
char *) 0 ;
13445 octave_value_list _out;
13446 octave_value_list *_outp=&_out;
13447 octave_value _outv;
13454 if (
_n_dims( args(0) ) > 2 )
13456 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13458 temp1 = args(0).matrix_value();
13459 arg1 = &temp1( 0, 0 );
13467 arg4 =
reinterpret_cast< char *
>(buf4);
13472 arg5 =
static_cast< PLFLT >(val5);
13477 arg6 =
static_cast< PLFLT >(val6);
13482 arg7 =
static_cast< PLFLT >(val7);
13487 arg8 =
static_cast< PLFLT >(val8);
13492 arg9 =
static_cast< PLFLT >(val9);
13497 arg10 =
static_cast< PLFLT >(val10);
13502 arg11 =
static_cast< PLINT >(val11);
13507 arg12 =
static_cast< PLFLT >(val12);
13512 arg13 =
static_cast< PLINT >(val13);
13517 arg14 =
static_cast< PLINT >(val14);
13522 arg15 =
static_cast< PLINT >(val15);
13527 arg16 =
static_cast< PLINT >(val16);
13532 arg17 =
static_cast< PLINT >(val17);
13537 arg18 =
static_cast< PLBOOL >(val18);
13539 if (
_n_dims( args(16) ) > 1 )
13543 if (
_dim( args(16), 0 ) !=
Xlen )
13547 temp19 = args(16).matrix_value();
13548 arg19 = &temp19( 0, 0 );
13551 if (
_n_dims( args(17) ) > 1 )
13555 if (
_dim( args(17), 0 ) !=
Ylen )
13559 temp20 = args(17).matrix_value();
13560 arg20 = &temp20( 0, 0 );
13562 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);
13563 _outv = octave_value();
13587 return octave_value_list();
13609 char *arg4 = (
char *) 0 ;
13660 octave_value_list _out;
13661 octave_value_list *_outp=&_out;
13662 octave_value _outv;
13669 if (
_n_dims( args(0) ) > 2 )
13671 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13673 temp1 = args(0).matrix_value();
13674 arg1 = &temp1( 0, 0 );
13682 arg4 =
reinterpret_cast< char *
>(buf4);
13687 arg5 =
static_cast< PLFLT >(val5);
13692 arg6 =
static_cast< PLFLT >(val6);
13697 arg7 =
static_cast< PLFLT >(val7);
13702 arg8 =
static_cast< PLFLT >(val8);
13707 arg9 =
static_cast< PLFLT >(val9);
13712 arg10 =
static_cast< PLFLT >(val10);
13717 arg11 =
static_cast< PLINT >(val11);
13722 arg12 =
static_cast< PLFLT >(val12);
13727 arg13 =
static_cast< PLINT >(val13);
13732 arg14 =
static_cast< PLINT >(val14);
13737 arg15 =
static_cast< PLINT >(val15);
13742 arg16 =
static_cast< PLINT >(val16);
13747 arg17 =
static_cast< PLINT >(val17);
13752 arg18 =
static_cast< PLBOOL >(val18);
13754 if (
_n_dims( args(16) ) > 2 )
13756 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13758 temp19 = args(16).matrix_value();
13759 arg19 = &temp19( 0, 0 );
13764 if (
_n_dims( args(17) ) > 2 )
13766 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13768 temp20 = args(17).matrix_value();
13769 arg20 = &temp20( 0, 0 );
13773 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);
13774 _outv = octave_value();
13798 return octave_value_list();
13848 octave_value_list _out;
13849 octave_value_list *_outp=&_out;
13850 octave_value _outv;
13857 if (
_n_dims( args(0) ) > 2 )
13859 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13861 temp1 = args(0).matrix_value();
13862 arg1 = &temp1( 0, 0 );
13870 arg4 =
static_cast< PLFLT >(val4);
13875 arg5 =
static_cast< PLFLT >(val5);
13880 arg6 =
static_cast< PLFLT >(val6);
13885 arg7 =
static_cast< PLFLT >(val7);
13887 if (
_n_dims( args(5) ) > 1 )
13891 temp8 = args(5).matrix_value();
13892 arg8 = &temp8( 0, 0 );
13899 arg10 =
static_cast< PLINT >(val10);
13904 arg11 =
static_cast< PLINT >(val11);
13909 arg12 =
static_cast< PLINT >(val12);
13914 arg13 =
static_cast< PLBOOL >(val13);
13915 my_plshades((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13);
13916 _outv = octave_value();
13932 return octave_value_list();
13980 octave_value_list _out;
13981 octave_value_list *_outp=&_out;
13982 octave_value _outv;
13989 if (
_n_dims( args(0) ) > 2 )
13991 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13993 temp1 = args(0).matrix_value();
13994 arg1 = &temp1( 0, 0 );
14002 arg4 =
static_cast< PLFLT >(val4);
14007 arg5 =
static_cast< PLFLT >(val5);
14012 arg6 =
static_cast< PLFLT >(val6);
14017 arg7 =
static_cast< PLFLT >(val7);
14019 if (
_n_dims( args(5) ) > 1 )
14023 temp8 = args(5).matrix_value();
14024 arg8 = &temp8( 0, 0 );
14031 arg10 =
static_cast< PLINT >(val10);
14036 arg11 =
static_cast< PLINT >(val11);
14041 arg12 =
static_cast< PLINT >(val12);
14046 arg13 =
static_cast< PLBOOL >(val13);
14048 if (
_n_dims( args(10) ) > 1 )
14052 if (
_dim( args(10), 0 ) != 6 )
14056 temp14 = args(10).matrix_value();
14057 arg14 = &temp14( 0, 0 );
14059 my_plshadesx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
14060 _outv = octave_value();
14082 return octave_value_list();
14135 octave_value_list _out;
14136 octave_value_list *_outp=&_out;
14137 octave_value _outv;
14144 if (
_n_dims( args(0) ) > 2 )
14146 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14148 temp1 = args(0).matrix_value();
14149 arg1 = &temp1( 0, 0 );
14157 arg4 =
static_cast< PLFLT >(val4);
14162 arg5 =
static_cast< PLFLT >(val5);
14167 arg6 =
static_cast< PLFLT >(val6);
14172 arg7 =
static_cast< PLFLT >(val7);
14174 if (
_n_dims( args(5) ) > 1 )
14178 temp8 = args(5).matrix_value();
14179 arg8 = &temp8( 0, 0 );
14186 arg10 =
static_cast< PLINT >(val10);
14191 arg11 =
static_cast< PLINT >(val11);
14196 arg12 =
static_cast< PLINT >(val12);
14201 arg13 =
static_cast< PLBOOL >(val13);
14203 if (
_n_dims( args(10) ) > 1 )
14207 if (
_dim( args(10), 0 ) !=
Xlen )
14211 temp14 = args(10).matrix_value();
14212 arg14 = &temp14( 0, 0 );
14215 if (
_n_dims( args(11) ) > 1 )
14219 if (
_dim( args(11), 0 ) !=
Ylen )
14223 temp15 = args(11).matrix_value();
14224 arg15 = &temp15( 0, 0 );
14226 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);
14227 _outv = octave_value();
14255 return octave_value_list();
14311 octave_value_list _out;
14312 octave_value_list *_outp=&_out;
14313 octave_value _outv;
14320 if (
_n_dims( args(0) ) > 2 )
14322 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14324 temp1 = args(0).matrix_value();
14325 arg1 = &temp1( 0, 0 );
14333 arg4 =
static_cast< PLFLT >(val4);
14338 arg5 =
static_cast< PLFLT >(val5);
14343 arg6 =
static_cast< PLFLT >(val6);
14348 arg7 =
static_cast< PLFLT >(val7);
14350 if (
_n_dims( args(5) ) > 1 )
14354 temp8 = args(5).matrix_value();
14355 arg8 = &temp8( 0, 0 );
14362 arg10 =
static_cast< PLINT >(val10);
14367 arg11 =
static_cast< PLINT >(val11);
14372 arg12 =
static_cast< PLINT >(val12);
14377 arg13 =
static_cast< PLBOOL >(val13);
14379 if (
_n_dims( args(10) ) > 2 )
14381 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14383 temp14 = args(10).matrix_value();
14384 arg14 = &temp14( 0, 0 );
14389 if (
_n_dims( args(11) ) > 2 )
14391 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14393 temp15 = args(11).matrix_value();
14394 arg15 = &temp15( 0, 0 );
14398 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);
14399 _outv = octave_value();
14427 return octave_value_list();
14459 octave_value_list _out;
14460 octave_value_list *_outp=&_out;
14461 octave_value _outv;
14468 if (
_n_dims( args(0) ) > 2 )
14470 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14472 temp1 = args(0).matrix_value();
14473 arg1 = &temp1( 0, 0 );
14478 if (
_n_dims( args(1) ) > 2 )
14480 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14484 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14488 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14490 temp2 = args(1).matrix_value();
14491 arg2 = &temp2( 0, 0 );
14499 arg5 =
static_cast< PLFLT >(val5);
14501 if (
_n_dims( args(3) ) > 1 )
14505 if (
_dim( args(3), 0 ) != 6 )
14509 temp6 = args(3).matrix_value();
14510 arg6 = &temp6( 0, 0 );
14512 my_plvect((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
14513 _outv = octave_value();
14535 return octave_value_list();
14566 octave_value_list _out;
14567 octave_value_list *_outp=&_out;
14568 octave_value _outv;
14575 if (
_n_dims( args(0) ) > 2 )
14577 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14579 temp1 = args(0).matrix_value();
14580 arg1 = &temp1( 0, 0 );
14585 if (
_n_dims( args(1) ) > 2 )
14587 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14591 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14595 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14597 temp2 = args(1).matrix_value();
14598 arg2 = &temp2( 0, 0 );
14606 arg5 =
static_cast< PLFLT >(val5);
14608 if (
_n_dims( args(3) ) > 1 )
14616 temp6 = args(3).matrix_value();
14617 arg6 = &temp6( 0, 0 );
14620 if (
_n_dims( args(4) ) > 1 )
14628 temp7 = args(4).matrix_value();
14629 arg7 = &temp7( 0, 0 );
14631 my_plvect1((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14632 _outv = octave_value();
14660 return octave_value_list();
14694 octave_value_list _out;
14695 octave_value_list *_outp=&_out;
14696 octave_value _outv;
14703 if (
_n_dims( args(0) ) > 2 )
14705 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14707 temp1 = args(0).matrix_value();
14708 arg1 = &temp1( 0, 0 );
14713 if (
_n_dims( args(1) ) > 2 )
14715 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14719 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14723 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14725 temp2 = args(1).matrix_value();
14726 arg2 = &temp2( 0, 0 );
14734 arg5 =
static_cast< PLFLT >(val5);
14736 if (
_n_dims( args(3) ) > 2 )
14738 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14740 temp6 = args(3).matrix_value();
14741 arg6 = &temp6( 0, 0 );
14746 if (
_n_dims( args(4) ) > 2 )
14748 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14750 temp7 = args(4).matrix_value();
14751 arg7 = &temp7( 0, 0 );
14755 my_plvect2((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14756 _outv = octave_value();
14784 return octave_value_list();
14839 octave_value_list _out;
14840 octave_value_list *_outp=&_out;
14841 octave_value _outv;
14848 if (
_n_dims( args(0) ) > 2 )
14850 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14852 temp1 = args(0).matrix_value();
14853 arg1 = &temp1( 0, 0 );
14861 arg4 =
static_cast< PLFLT >(val4);
14866 arg5 =
static_cast< PLFLT >(val5);
14871 arg6 =
static_cast< PLFLT >(val6);
14876 arg7 =
static_cast< PLFLT >(val7);
14881 arg8 =
static_cast< PLFLT >(val8);
14886 arg9 =
static_cast< PLFLT >(val9);
14891 arg10 =
static_cast< PLFLT >(val10);
14896 arg11 =
static_cast< PLFLT >(val11);
14901 arg12 =
static_cast< PLFLT >(val12);
14906 arg13 =
static_cast< PLFLT >(val13);
14907 my_plimage((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14908 _outv = octave_value();
14918 return octave_value_list();
14958 octave_value_list _out;
14959 octave_value_list *_outp=&_out;
14960 octave_value _outv;
14967 if (
_n_dims( args(0) ) > 2 )
14969 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14971 temp1 = args(0).matrix_value();
14972 arg1 = &temp1( 0, 0 );
14980 arg4 =
static_cast< PLFLT >(val4);
14985 arg5 =
static_cast< PLFLT >(val5);
14990 arg6 =
static_cast< PLFLT >(val6);
14995 arg7 =
static_cast< PLFLT >(val7);
15000 arg8 =
static_cast< PLFLT >(val8);
15005 arg9 =
static_cast< PLFLT >(val9);
15010 arg10 =
static_cast< PLFLT >(val10);
15015 arg11 =
static_cast< PLFLT >(val11);
15016 my_plimagefr((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
15017 _outv = octave_value();
15027 return octave_value_list();
15069 octave_value_list _out;
15070 octave_value_list *_outp=&_out;
15071 octave_value _outv;
15078 if (
_n_dims( args(0) ) > 2 )
15080 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15082 temp1 = args(0).matrix_value();
15083 arg1 = &temp1( 0, 0 );
15091 arg4 =
static_cast< PLFLT >(val4);
15096 arg5 =
static_cast< PLFLT >(val5);
15101 arg6 =
static_cast< PLFLT >(val6);
15106 arg7 =
static_cast< PLFLT >(val7);
15111 arg8 =
static_cast< PLFLT >(val8);
15116 arg9 =
static_cast< PLFLT >(val9);
15121 arg10 =
static_cast< PLFLT >(val10);
15126 arg11 =
static_cast< PLFLT >(val11);
15128 if (
_n_dims( args(9) ) > 1 )
15132 if (
_dim( args(9), 0 ) != 6 )
15136 temp12 = args(9).matrix_value();
15137 arg12 = &temp12( 0, 0 );
15139 my_plimagefrx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
15140 _outv = octave_value();
15156 return octave_value_list();
15203 octave_value_list _out;
15204 octave_value_list *_outp=&_out;
15205 octave_value _outv;
15212 if (
_n_dims( args(0) ) > 2 )
15214 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15216 temp1 = args(0).matrix_value();
15217 arg1 = &temp1( 0, 0 );
15225 arg4 =
static_cast< PLFLT >(val4);
15230 arg5 =
static_cast< PLFLT >(val5);
15235 arg6 =
static_cast< PLFLT >(val6);
15240 arg7 =
static_cast< PLFLT >(val7);
15245 arg8 =
static_cast< PLFLT >(val8);
15250 arg9 =
static_cast< PLFLT >(val9);
15255 arg10 =
static_cast< PLFLT >(val10);
15260 arg11 =
static_cast< PLFLT >(val11);
15262 if (
_n_dims( args(9) ) > 1 )
15270 temp12 = args(9).matrix_value();
15271 arg12 = &temp12( 0, 0 );
15274 if (
_n_dims( args(10) ) > 1 )
15278 if (
_dim( args(10), 0 ) !=
Ylen )
15282 temp13 = args(10).matrix_value();
15283 arg13 = &temp13( 0, 0 );
15285 my_plimagefr1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
15286 _outv = octave_value();
15308 return octave_value_list();
15358 octave_value_list _out;
15359 octave_value_list *_outp=&_out;
15360 octave_value _outv;
15367 if (
_n_dims( args(0) ) > 2 )
15369 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15371 temp1 = args(0).matrix_value();
15372 arg1 = &temp1( 0, 0 );
15380 arg4 =
static_cast< PLFLT >(val4);
15385 arg5 =
static_cast< PLFLT >(val5);
15390 arg6 =
static_cast< PLFLT >(val6);
15395 arg7 =
static_cast< PLFLT >(val7);
15400 arg8 =
static_cast< PLFLT >(val8);
15405 arg9 =
static_cast< PLFLT >(val9);
15410 arg10 =
static_cast< PLFLT >(val10);
15415 arg11 =
static_cast< PLFLT >(val11);
15417 if (
_n_dims( args(9) ) > 2 )
15419 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15421 temp12 = args(9).matrix_value();
15422 arg12 = &temp12( 0, 0 );
15427 if (
_n_dims( args(10) ) > 2 )
15429 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15431 temp13 = args(10).matrix_value();
15432 arg13 = &temp13( 0, 0 );
15436 my_plimagefr2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
15437 _outv = octave_value();
15459 return octave_value_list();
15494 char **arg18 = (
char **) 0 ;
15496 char **arg20 = (
char **) 0 ;
15536 octave_value_list _out;
15537 octave_value_list *_outp=&_out;
15538 octave_value _outv;
15550 arg3 =
static_cast< PLINT >(val3);
15555 arg4 =
static_cast< PLINT >(val4);
15560 arg5 =
static_cast< PLFLT >(val5);
15565 arg6 =
static_cast< PLFLT >(val6);
15570 arg7 =
static_cast< PLFLT >(val7);
15575 arg8 =
static_cast< PLFLT >(val8);
15580 arg9 =
static_cast< PLINT >(val9);
15585 arg10 =
static_cast< PLINT >(val10);
15590 arg11 =
static_cast< PLINT >(val11);
15595 arg12 =
static_cast< PLFLT >(val12);
15600 arg13 =
static_cast< PLFLT >(val13);
15605 arg14 =
static_cast< PLINT >(val14);
15610 arg15 =
static_cast< PLFLT >(val15);
15612 if (
_n_dims( args(13) ) > 1 )
15618 temp16 = args(13).matrix_value();
15622 charMatrix temp_matrix;
15626 size_t max_length = 0, non_blank_length;
15628 if (
_n_dims( args(14) ) > 2 )
15630 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
15632 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15633 if ( !args(14).isempty() )
15635 if ( !args(14).is_empty() )
15638 if (
_dim( args(14), 0 ) !=
Alen )
15640 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
15642 arg18 =
new char*[
Alen];
15643 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15644 ifcell = args(14).iscell();
15646 ifcell = args(14).is_cell();
15650 temp_cell = args(14).cell_value();
15654 temp_matrix = args(14).char_matrix_value();
15656 max_length =
_dim( args(14), 1 ) + 1;
15659 for ( i = 0; i <
Alen; i++ )
15666 if ( temp_cell.elem( i ).is_string() )
15668 str = temp_cell.elem( i ).string_value();
15670 max_length = str.size() + 1;
15671 tmp_cstring = (
char *) str.c_str();
15681 tmp_cstring = (
char *)
"";
15686 str = temp_matrix.row_as_string( i );
15687 tmp_cstring = (
char *) str.c_str();
15689 arg18[i] =
new char[max_length];
15690 strncpy( arg18[i], tmp_cstring, max_length - 1 );
15691 arg18[i][max_length - 1] =
'\0';
15706 non_blank_length = max_length - 2;
15707 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
'\0' )
15709 non_blank_length--;
15711 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
' ' )
15713 non_blank_length--;
15715 arg18[i][non_blank_length + 1] =
'\0';
15725 charMatrix temp_matrix;
15729 size_t max_length = 0, non_blank_length;
15731 if (
_n_dims( args(15) ) > 2 )
15733 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
15735 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15736 if ( !args(15).isempty() )
15738 if ( !args(15).is_empty() )
15743 arg20 =
new char*[
Alen];
15744 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15745 ifcell = args(15).iscell();
15747 ifcell = args(15).is_cell();
15751 temp_cell = args(15).cell_value();
15755 temp_matrix = args(15).char_matrix_value();
15757 max_length =
_dim( args(15), 1 ) + 1;
15760 for ( i = 0; i <
Alen; i++ )
15767 if ( temp_cell.elem( i ).is_string() )
15769 str = temp_cell.elem( i ).string_value();
15771 max_length = str.size() + 1;
15772 tmp_cstring = (
char *) str.c_str();
15782 tmp_cstring = (
char *)
"";
15787 str = temp_matrix.row_as_string( i );
15788 tmp_cstring = (
char *) str.c_str();
15790 arg20[i] =
new char[max_length];
15791 strncpy( arg20[i], tmp_cstring, max_length - 1 );
15792 arg20[i][max_length - 1] =
'\0';
15807 non_blank_length = max_length - 2;
15808 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
15810 non_blank_length--;
15812 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
15814 non_blank_length--;
15816 arg20[i][non_blank_length + 1] =
'\0';
15827 if (
_n_dims( args(16) ) > 1 )
15831 if (
_dim( args(16), 0 ) !=
Alen )
15835 temp21 = args(16).matrix_value();
15836 arg21 = &temp21( 0, 0 );
15839 if (
_n_dims( args(17) ) > 1 )
15843 if (
_dim( args(17), 0 ) !=
Alen )
15847 temp22 = args(17).matrix_value();
15853 if (
_n_dims( args(18) ) > 1 )
15857 if (
_dim( args(18), 0 ) !=
Alen )
15862 temp23 = args(18).matrix_value();
15866 for ( i = 0; i <
Xlen; i++ )
15867 if ( arg23[i] >
Ylen )
15871 if (
_n_dims( args(19) ) > 2 )
15873 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15875 if (
_dim( args(19), 0 ) !=
Xlen )
15877 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
15879 if (
_dim( args(19), 1 ) !=
Ylen )
15881 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
15883 temp24 = args(19).matrix_value();
15884 arg24 = &temp24( 0, 0 );
15886 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);
15887 _outv = octave_value();
15906 if ( arg18 != NULL )
15908 for ( i = 0; i <
Alen; i++ )
15917 if ( arg20 != NULL )
15919 for ( i = 0; i <
Alen; i++ )
15945 if ( arg18 != NULL )
15947 for ( i = 0; i <
Alen; i++ )
15956 if ( arg20 != NULL )
15958 for ( i = 0; i <
Alen; i++ )
15977 return octave_value_list();
15985 if ( arg18 != NULL )
15987 for ( i = 0; i <
Alen; i++ )
15996 if ( arg20 != NULL )
15998 for ( i = 0; i <
Alen; i++ )
16029 octave_value_list _out;
16030 octave_value_list *_outp=&_out;
16031 octave_value _outv;
16046 arg2 =
static_cast< int >(val2);
16047 if (arg1) (arg1)->type = arg2;
16048 _outv = octave_value();
16052 return octave_value_list();
16064 octave_value_list _out;
16065 octave_value_list *_outp=&_out;
16066 octave_value _outv;
16078 result = (int) ((arg1)->type);
16083 return octave_value_list();
16093 unsigned int arg2 ;
16096 unsigned int val2 ;
16098 octave_value_list _out;
16099 octave_value_list *_outp=&_out;
16100 octave_value _outv;
16115 arg2 =
static_cast< unsigned int >(val2);
16116 if (arg1) (arg1)->state = arg2;
16117 _outv = octave_value();
16121 return octave_value_list();
16133 octave_value_list _out;
16134 octave_value_list *_outp=&_out;
16135 octave_value _outv;
16136 unsigned int result;
16147 result = (
unsigned int) ((arg1)->state);
16152 return octave_value_list();
16162 unsigned int arg2 ;
16165 unsigned int val2 ;
16167 octave_value_list _out;
16168 octave_value_list *_outp=&_out;
16169 octave_value _outv;
16184 arg2 =
static_cast< unsigned int >(val2);
16185 if (arg1) (arg1)->keysym = arg2;
16186 _outv = octave_value();
16190 return octave_value_list();
16202 octave_value_list _out;
16203 octave_value_list *_outp=&_out;
16204 octave_value _outv;
16205 unsigned int result;
16216 result = (
unsigned int) ((arg1)->keysym);
16221 return octave_value_list();
16231 unsigned int arg2 ;
16234 unsigned int val2 ;
16236 octave_value_list _out;
16237 octave_value_list *_outp=&_out;
16238 octave_value _outv;
16253 arg2 =
static_cast< unsigned int >(val2);
16254 if (arg1) (arg1)->button = arg2;
16255 _outv = octave_value();
16259 return octave_value_list();
16271 octave_value_list _out;
16272 octave_value_list *_outp=&_out;
16273 octave_value _outv;
16274 unsigned int result;
16285 result = (
unsigned int) ((arg1)->button);
16290 return octave_value_list();
16305 octave_value_list _out;
16306 octave_value_list *_outp=&_out;
16307 octave_value _outv;
16322 arg2 =
static_cast< PLINT >(val2);
16323 if (arg1) (arg1)->subwindow = arg2;
16324 _outv = octave_value();
16328 return octave_value_list();
16340 octave_value_list _out;
16341 octave_value_list *_outp=&_out;
16342 octave_value _outv;
16354 result = (
PLINT) ((arg1)->subwindow);
16359 return octave_value_list();
16374 octave_value_list _out;
16375 octave_value_list *_outp=&_out;
16376 octave_value _outv;
16391 arg2 =
reinterpret_cast< char *
>(temp2);
16392 if (arg2) memcpy(arg1->
string,arg2,16*
sizeof(
char));
16393 else memset(arg1->
string,0,16*
sizeof(
char));
16394 _outv = octave_value();
16398 return octave_value_list();
16410 octave_value_list _out;
16411 octave_value_list *_outp=&_out;
16412 octave_value _outv;
16424 result = (
char *)(
char *) ((arg1)->
string);
16435 return octave_value_list();
16450 octave_value_list _out;
16451 octave_value_list *_outp=&_out;
16452 octave_value _outv;
16467 arg2 =
static_cast< int >(val2);
16468 if (arg1) (arg1)->pX = arg2;
16469 _outv = octave_value();
16473 return octave_value_list();
16485 octave_value_list _out;
16486 octave_value_list *_outp=&_out;
16487 octave_value _outv;
16499 result = (int) ((arg1)->pX);
16504 return octave_value_list();
16519 octave_value_list _out;
16520 octave_value_list *_outp=&_out;
16521 octave_value _outv;
16536 arg2 =
static_cast< int >(val2);
16537 if (arg1) (arg1)->pY = arg2;
16538 _outv = octave_value();
16542 return octave_value_list();
16554 octave_value_list _out;
16555 octave_value_list *_outp=&_out;
16556 octave_value _outv;
16568 result = (int) ((arg1)->pY);
16573 return octave_value_list();
16588 octave_value_list _out;
16589 octave_value_list *_outp=&_out;
16590 octave_value _outv;
16605 arg2 =
static_cast< PLFLT >(val2);
16606 if (arg1) (arg1)->dX = arg2;
16607 _outv = octave_value();
16611 return octave_value_list();
16623 octave_value_list _out;
16624 octave_value_list *_outp=&_out;
16625 octave_value _outv;
16637 result = (
PLFLT) ((arg1)->dX);
16642 return octave_value_list();
16657 octave_value_list _out;
16658 octave_value_list *_outp=&_out;
16659 octave_value _outv;
16674 arg2 =
static_cast< PLFLT >(val2);
16675 if (arg1) (arg1)->dY = arg2;
16676 _outv = octave_value();
16680 return octave_value_list();
16692 octave_value_list _out;
16693 octave_value_list *_outp=&_out;
16694 octave_value _outv;
16706 result = (
PLFLT) ((arg1)->dY);
16711 return octave_value_list();
16726 octave_value_list _out;
16727 octave_value_list *_outp=&_out;
16728 octave_value _outv;
16743 arg2 =
static_cast< PLFLT >(val2);
16744 if (arg1) (arg1)->wX = arg2;
16745 _outv = octave_value();
16749 return octave_value_list();
16761 octave_value_list _out;
16762 octave_value_list *_outp=&_out;
16763 octave_value _outv;
16775 result = (
PLFLT) ((arg1)->wX);
16780 return octave_value_list();
16795 octave_value_list _out;
16796 octave_value_list *_outp=&_out;
16797 octave_value _outv;
16812 arg2 =
static_cast< PLFLT >(val2);
16813 if (arg1) (arg1)->wY = arg2;
16814 _outv = octave_value();
16818 return octave_value_list();
16830 octave_value_list _out;
16831 octave_value_list *_outp=&_out;
16832 octave_value _outv;
16844 result = (
PLFLT) ((arg1)->wY);
16849 return octave_value_list();
16858 octave_value_list _out;
16859 octave_value_list *_outp=&_out;
16860 octave_value _outv;
16872 return octave_value_list();
16884 octave_value_list _out;
16885 octave_value_list *_outp=&_out;
16886 octave_value _outv;
16898 _outv = octave_value();
16902 return octave_value_list();
16936 octave_value_list _out;
16937 octave_value_list *_outp=&_out;
16938 octave_value _outv;
16948 arg1 =
static_cast< PLINT >(val1);
16953 arg2 =
static_cast< PLINT >(val2);
16955 _outv = octave_value();
16959 return octave_value_list();
16980 octave_value_list _out;
16981 octave_value_list *_outp=&_out;
16982 octave_value _outv;
16992 arg1 =
static_cast< PLFLT >(val1);
16997 arg2 =
static_cast< PLFLT >(val2);
17002 arg3 =
static_cast< PLFLT >(val3);
17007 arg4 =
static_cast< PLINT >(val4);
17009 _outv = octave_value();
17013 return octave_value_list();
17025 octave_value_list _out;
17026 octave_value_list *_outp=&_out;
17027 octave_value _outv;
17037 arg1 =
static_cast< PLINT >(val1);
17039 _outv = octave_value();
17043 return octave_value_list();
17076 octave_value_list _out;
17077 octave_value_list *_outp=&_out;
17078 octave_value _outv;
17088 arg1 =
static_cast< PLFLT >(val1);
17093 arg2 =
static_cast< PLFLT >(val2);
17098 arg3 =
static_cast< PLFLT >(val3);
17103 arg4 =
static_cast< PLFLT >(val4);
17108 arg5 =
static_cast< PLFLT >(val5);
17113 arg6 =
static_cast< PLFLT >(val6);
17118 arg7 =
static_cast< PLFLT >(val7);
17123 arg8 =
static_cast< PLBOOL >(val8);
17124 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
17125 _outv = octave_value();
17129 return octave_value_list();
17140 char *arg3 = (
char *) 0 ;
17143 char *arg6 = (
char *) 0 ;
17164 octave_value_list _out;
17165 octave_value_list *_outp=&_out;
17166 octave_value _outv;
17176 arg1 =
static_cast< PLFLT >(val1);
17181 arg2 =
static_cast< PLFLT >(val2);
17186 arg3 =
reinterpret_cast< char *
>(buf3);
17191 arg4 =
static_cast< PLFLT >(val4);
17196 arg5 =
static_cast< PLINT >(val5);
17201 arg6 =
reinterpret_cast< char *
>(buf6);
17206 arg7 =
static_cast< PLFLT >(val7);
17211 arg8 =
static_cast< PLINT >(val8);
17212 plaxes(arg1,arg2,(
char const *)arg3,arg4,arg5,(
char const *)arg6,arg7,arg8);
17213 _outv = octave_value();
17221 return octave_value_list();
17240 octave_value_list _out;
17241 octave_value_list *_outp=&_out;
17242 octave_value _outv;
17249 if (
_n_dims( args(0) ) > 1 )
17254 temp1 = args(0).matrix_value();
17255 arg2 = &temp1( 0, 0 );
17258 if (
_n_dims( args(1) ) > 1 )
17266 temp3 = args(1).matrix_value();
17267 arg3 = &temp3( 0, 0 );
17273 arg4 =
static_cast< PLINT >(val4);
17274 plbin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
17275 _outv = octave_value();
17291 return octave_value_list();
17327 octave_value_list _out;
17328 octave_value_list *_outp=&_out;
17329 octave_value _outv;
17345 arg7 =
static_cast< PLFLT >(val7);
17346 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17347 _outv = octave_value();
17387 return octave_value_list();
17396 octave_value_list _out;
17397 octave_value_list *_outp=&_out;
17398 octave_value _outv;
17405 _outv = octave_value();
17409 return octave_value_list();
17418 char *arg1 = (
char *) 0 ;
17421 char *arg4 = (
char *) 0 ;
17438 octave_value_list _out;
17439 octave_value_list *_outp=&_out;
17440 octave_value _outv;
17450 arg1 =
reinterpret_cast< char *
>(buf1);
17455 arg2 =
static_cast< PLFLT >(val2);
17460 arg3 =
static_cast< PLINT >(val3);
17465 arg4 =
reinterpret_cast< char *
>(buf4);
17470 arg5 =
static_cast< PLFLT >(val5);
17475 arg6 =
static_cast< PLINT >(val6);
17476 plbox((
char const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6);
17477 _outv = octave_value();
17485 return octave_value_list();
17496 char *arg1 = (
char *) 0 ;
17497 char *arg2 = (
char *) 0 ;
17500 char *arg5 = (
char *) 0 ;
17501 char *arg6 = (
char *) 0 ;
17504 char *arg9 = (
char *) 0 ;
17505 char *arg10 = (
char *) 0 ;
17538 octave_value_list _out;
17539 octave_value_list *_outp=&_out;
17540 octave_value _outv;
17550 arg1 =
reinterpret_cast< char *
>(buf1);
17555 arg2 =
reinterpret_cast< char *
>(buf2);
17560 arg3 =
static_cast< PLFLT >(val3);
17565 arg4 =
static_cast< PLINT >(val4);
17570 arg5 =
reinterpret_cast< char *
>(buf5);
17575 arg6 =
reinterpret_cast< char *
>(buf6);
17580 arg7 =
static_cast< PLFLT >(val7);
17585 arg8 =
static_cast< PLINT >(val8);
17590 arg9 =
reinterpret_cast< char *
>(buf9);
17595 arg10 =
reinterpret_cast< char *
>(buf10);
17600 arg11 =
static_cast< PLFLT >(val11);
17605 arg12 =
static_cast< PLINT >(val12);
17606 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);
17607 _outv = octave_value();
17623 return octave_value_list();
17653 octave_value_list _out;
17654 octave_value_list *_outp=&_out;
17655 octave_value _outv;
17668 arg1 =
static_cast< PLFLT >(val1);
17673 arg2 =
static_cast< PLFLT >(val2);
17675 _outv = octave_value();
17697 return octave_value_list();
17706 octave_value_list _out;
17707 octave_value_list *_outp=&_out;
17708 octave_value _outv;
17715 _outv = octave_value();
17719 return octave_value_list();
17731 octave_value_list _out;
17732 octave_value_list *_outp=&_out;
17733 octave_value _outv;
17743 arg1 =
static_cast< PLINT >(val1);
17745 _outv = octave_value();
17749 return octave_value_list();
17761 octave_value_list _out;
17762 octave_value_list *_outp=&_out;
17763 octave_value _outv;
17773 arg1 =
static_cast< PLFLT >(val1);
17775 _outv = octave_value();
17779 return octave_value_list();
17821 octave_value_list _out;
17822 octave_value_list *_outp=&_out;
17823 octave_value _outv;
17833 arg1 =
static_cast< PLFLT >(val1);
17838 arg2 =
static_cast< PLFLT >(val2);
17843 arg3 =
static_cast< PLFLT >(val3);
17848 arg4 =
static_cast< PLINT >(val4);
17853 arg5 =
static_cast< PLBOOL >(val5);
17858 arg6 =
static_cast< PLINT >(val6);
17863 arg7 =
static_cast< PLINT >(val7);
17868 arg8 =
static_cast< PLINT >(val8);
17873 arg9 =
static_cast< PLINT >(val9);
17878 arg10 =
static_cast< PLINT >(val10);
17883 arg11 =
static_cast< PLFLT >(val11);
17884 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
17885 _outv = octave_value();
17889 return octave_value_list();
17919 octave_value_list _out;
17920 octave_value_list *_outp=&_out;
17921 octave_value _outv;
17932 arg1 =
static_cast< PLINT >(val1);
17937 arg2 =
static_cast< PLINT >(val2);
17942 arg3 =
static_cast< PLINT >(val3);
17947 arg4 =
static_cast< PLINT >(val4);
17952 arg5 =
static_cast< PLINT >(val5);
17957 arg6 =
static_cast< PLFLT >(val6);
17958 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17959 _outv = octave_value();
17969 return octave_value_list();
17984 octave_value_list _out;
17985 octave_value_list *_outp=&_out;
17986 octave_value _outv;
17996 arg1 =
static_cast< PLINT >(val1);
18001 arg2 =
static_cast< PLBOOL >(val2);
18003 _outv = octave_value();
18007 return octave_value_list();
18016 octave_value_list _out;
18017 octave_value_list *_outp=&_out;
18018 octave_value _outv;
18025 _outv = octave_value();
18029 return octave_value_list();
18038 octave_value_list _out;
18039 octave_value_list *_outp=&_out;
18040 octave_value _outv;
18047 _outv = octave_value();
18051 return octave_value_list();
18078 octave_value_list _out;
18079 octave_value_list *_outp=&_out;
18080 octave_value _outv;
18090 arg1 =
static_cast< PLFLT >(val1);
18095 arg2 =
static_cast< PLFLT >(val2);
18100 arg3 =
static_cast< PLFLT >(val3);
18105 arg4 =
static_cast< PLFLT >(val4);
18110 arg5 =
static_cast< PLINT >(val5);
18115 arg6 =
static_cast< PLINT >(val6);
18116 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
18117 _outv = octave_value();
18121 return octave_value_list();
18148 octave_value_list _out;
18149 octave_value_list *_outp=&_out;
18150 octave_value _outv;
18160 arg1 =
static_cast< PLFLT >(val1);
18165 arg2 =
static_cast< PLFLT >(val2);
18170 arg3 =
static_cast< PLFLT >(val3);
18175 arg4 =
static_cast< PLFLT >(val4);
18180 arg5 =
static_cast< PLINT >(val5);
18185 arg6 =
static_cast< PLINT >(val6);
18186 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
18187 _outv = octave_value();
18191 return octave_value_list();
18200 octave_value_list _out;
18201 octave_value_list *_outp=&_out;
18202 octave_value _outv;
18209 _outv = octave_value();
18213 return octave_value_list();
18229 octave_value_list _out;
18230 octave_value_list *_outp=&_out;
18231 octave_value _outv;
18238 if (
_n_dims( args(0) ) > 1 )
18243 temp1 = args(0).matrix_value();
18244 arg2 = &temp1( 0, 0 );
18247 if (
_n_dims( args(1) ) > 1 )
18255 temp3 = args(1).matrix_value();
18256 arg3 = &temp3( 0, 0 );
18259 if (
_n_dims( args(2) ) > 1 )
18267 temp4 = args(2).matrix_value();
18268 arg4 = &temp4( 0, 0 );
18270 plerrx(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18271 _outv = octave_value();
18293 return octave_value_list();
18318 octave_value_list _out;
18319 octave_value_list *_outp=&_out;
18320 octave_value _outv;
18327 if (
_n_dims( args(0) ) > 1 )
18332 temp1 = args(0).matrix_value();
18333 arg2 = &temp1( 0, 0 );
18336 if (
_n_dims( args(1) ) > 1 )
18344 temp3 = args(1).matrix_value();
18345 arg3 = &temp3( 0, 0 );
18348 if (
_n_dims( args(2) ) > 1 )
18356 temp4 = args(2).matrix_value();
18357 arg4 = &temp4( 0, 0 );
18359 plerry(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18360 _outv = octave_value();
18382 return octave_value_list();
18400 octave_value_list _out;
18401 octave_value_list *_outp=&_out;
18402 octave_value _outv;
18409 _outv = octave_value();
18413 return octave_value_list();
18427 octave_value_list _out;
18428 octave_value_list *_outp=&_out;
18429 octave_value _outv;
18436 if (
_n_dims( args(0) ) > 1 )
18441 temp1 = args(0).matrix_value();
18442 arg2 = &temp1( 0, 0 );
18445 if (
_n_dims( args(1) ) > 1 )
18453 temp3 = args(1).matrix_value();
18454 arg3 = &temp3( 0, 0 );
18456 plfill(arg1,(
double const *)arg2,(
double const *)arg3);
18457 _outv = octave_value();
18473 return octave_value_list();
18495 octave_value_list _out;
18496 octave_value_list *_outp=&_out;
18497 octave_value _outv;
18504 if (
_n_dims( args(0) ) > 1 )
18509 temp1 = args(0).matrix_value();
18510 arg2 = &temp1( 0, 0 );
18513 if (
_n_dims( args(1) ) > 1 )
18521 temp3 = args(1).matrix_value();
18522 arg3 = &temp3( 0, 0 );
18525 if (
_n_dims( args(2) ) > 1 )
18533 temp4 = args(2).matrix_value();
18534 arg4 = &temp4( 0, 0 );
18536 plfill3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18537 _outv = octave_value();
18559 return octave_value_list();
18585 octave_value_list _out;
18586 octave_value_list *_outp=&_out;
18587 octave_value _outv;
18594 if (
_n_dims( args(0) ) > 1 )
18599 temp1 = args(0).matrix_value();
18600 arg2 = &temp1( 0, 0 );
18603 if (
_n_dims( args(1) ) > 1 )
18611 temp3 = args(1).matrix_value();
18612 arg3 = &temp3( 0, 0 );
18618 arg4 =
static_cast< PLFLT >(val4);
18619 plgradient(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
18620 _outv = octave_value();
18636 return octave_value_list();
18651 octave_value_list _out;
18652 octave_value_list *_outp=&_out;
18653 octave_value _outv;
18660 _outv = octave_value();
18664 return octave_value_list();
18676 octave_value_list _out;
18677 octave_value_list *_outp=&_out;
18678 octave_value _outv;
18688 arg1 =
static_cast< PLINT >(val1);
18690 _outv = octave_value();
18694 return octave_value_list();
18706 octave_value_list _out;
18707 octave_value_list *_outp=&_out;
18708 octave_value _outv;
18718 arg1 =
static_cast< PLINT >(val1);
18720 _outv = octave_value();
18724 return octave_value_list();
18739 octave_value_list _out;
18740 octave_value_list *_outp=&_out;
18741 octave_value _outv;
18750 _outv = octave_value();
18766 return octave_value_list();
18787 octave_value_list _out;
18788 octave_value_list *_outp=&_out;
18789 octave_value _outv;
18802 arg1 =
static_cast< PLINT >(val1);
18803 plgcol0(arg1,arg2,arg3,arg4);
18804 _outv = octave_value();
18826 return octave_value_list();
18850 octave_value_list _out;
18851 octave_value_list *_outp=&_out;
18852 octave_value _outv;
18866 arg1 =
static_cast< PLINT >(val1);
18867 plgcol0a(arg1,arg2,arg3,arg4,arg5);
18868 _outv = octave_value();
18896 return octave_value_list();
18914 octave_value_list _out;
18915 octave_value_list *_outp=&_out;
18916 octave_value _outv;
18926 _outv = octave_value();
18948 return octave_value_list();
18969 octave_value_list _out;
18970 octave_value_list *_outp=&_out;
18971 octave_value _outv;
18982 _outv = octave_value();
19010 return octave_value_list();
19022 octave_value_list _out;
19023 octave_value_list *_outp=&_out;
19024 octave_value _outv;
19032 _outv = octave_value();
19042 return octave_value_list();
19051 char *arg1 = (
char *) 0 ;
19052 char local_string1[80] ;
19053 size_t local_string_length1 ;
19054 charMatrix local_charMatrix1 ;
19055 octave_value_list retval1 ;
19056 octave_value_list _out;
19057 octave_value_list *_outp=&_out;
19058 octave_value _outv;
19062 arg1 = local_string1;
19068 _outv = octave_value();
19071 local_string_length1 = strlen( local_string1 );
19072 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19073 local_charMatrix1.insert( local_string1, 0, 0 );
19074 retval1( 0 ) = octave_value( local_charMatrix1 );
19079 return octave_value_list();
19100 octave_value_list _out;
19101 octave_value_list *_outp=&_out;
19102 octave_value _outv;
19113 _outv = octave_value();
19141 return octave_value_list();
19153 octave_value_list _out;
19154 octave_value_list *_outp=&_out;
19155 octave_value _outv;
19163 _outv = octave_value();
19173 return octave_value_list();
19194 octave_value_list _out;
19195 octave_value_list *_outp=&_out;
19196 octave_value _outv;
19207 _outv = octave_value();
19235 return octave_value_list();
19253 octave_value_list _out;
19254 octave_value_list *_outp=&_out;
19255 octave_value _outv;
19265 _outv = octave_value();
19287 return octave_value_list();
19299 octave_value_list _out;
19300 octave_value_list *_outp=&_out;
19301 octave_value _outv;
19309 _outv = octave_value();
19319 return octave_value_list();
19328 char *arg1 = (
char *) 0 ;
19329 char local_string1[80] ;
19330 size_t local_string_length1 ;
19331 charMatrix local_charMatrix1 ;
19332 octave_value_list retval1 ;
19333 octave_value_list _out;
19334 octave_value_list *_outp=&_out;
19335 octave_value _outv;
19339 arg1 = local_string1;
19345 _outv = octave_value();
19348 local_string_length1 = strlen( local_string1 );
19349 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19350 local_charMatrix1.insert( local_string1, 0, 0 );
19351 retval1( 0 ) = octave_value( local_charMatrix1 );
19356 return octave_value_list();
19374 octave_value_list _out;
19375 octave_value_list *_outp=&_out;
19376 octave_value _outv;
19386 _outv = octave_value();
19408 return octave_value_list();
19420 octave_value_list _out;
19421 octave_value_list *_outp=&_out;
19422 octave_value _outv;
19430 _outv = octave_value();
19440 return octave_value_list();
19467 octave_value_list _out;
19468 octave_value_list *_outp=&_out;
19469 octave_value _outv;
19481 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
19482 _outv = octave_value();
19522 return octave_value_list();
19531 octave_value_list _out;
19532 octave_value_list *_outp=&_out;
19533 octave_value _outv;
19540 _outv = octave_value();
19544 return octave_value_list();
19565 octave_value_list _out;
19566 octave_value_list *_outp=&_out;
19567 octave_value _outv;
19577 plgspa(arg1,arg2,arg3,arg4);
19578 _outv = octave_value();
19606 return octave_value_list();
19618 octave_value_list _out;
19619 octave_value_list *_outp=&_out;
19620 octave_value _outv;
19628 _outv = octave_value();
19638 return octave_value_list();
19647 char *arg1 = (
char *) 0 ;
19648 char local_string1[80] ;
19649 size_t local_string_length1 ;
19650 charMatrix local_charMatrix1 ;
19651 octave_value_list retval1 ;
19652 octave_value_list _out;
19653 octave_value_list *_outp=&_out;
19654 octave_value _outv;
19658 arg1 = local_string1;
19664 _outv = octave_value();
19667 local_string_length1 = strlen( local_string1 );
19668 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19669 local_charMatrix1.insert( local_string1, 0, 0 );
19670 retval1( 0 ) = octave_value( local_charMatrix1 );
19675 return octave_value_list();
19696 octave_value_list _out;
19697 octave_value_list *_outp=&_out;
19698 octave_value _outv;
19708 plgvpd(arg1,arg2,arg3,arg4);
19709 _outv = octave_value();
19737 return octave_value_list();
19758 octave_value_list _out;
19759 octave_value_list *_outp=&_out;
19760 octave_value _outv;
19770 plgvpw(arg1,arg2,arg3,arg4);
19771 _outv = octave_value();
19799 return octave_value_list();
19814 octave_value_list _out;
19815 octave_value_list *_outp=&_out;
19816 octave_value _outv;
19825 _outv = octave_value();
19841 return octave_value_list();
19856 octave_value_list _out;
19857 octave_value_list *_outp=&_out;
19858 octave_value _outv;
19867 _outv = octave_value();
19883 return octave_value_list();
19898 octave_value_list _out;
19899 octave_value_list *_outp=&_out;
19900 octave_value _outv;
19909 _outv = octave_value();
19925 return octave_value_list();
19949 octave_value_list _out;
19950 octave_value_list *_outp=&_out;
19951 octave_value _outv;
19958 if (
_n_dims( args(0) ) > 1 )
19963 temp1 = args(0).matrix_value();
19964 arg2 = &temp1( 0, 0 );
19970 arg3 =
static_cast< PLFLT >(val3);
19975 arg4 =
static_cast< PLFLT >(val4);
19980 arg5 =
static_cast< PLINT >(val5);
19985 arg6 =
static_cast< PLINT >(val6);
19986 plhist(arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
19987 _outv = octave_value();
19997 return octave_value_list();
20027 octave_value_list _out;
20028 octave_value_list *_outp=&_out;
20029 octave_value _outv;
20042 arg1 =
static_cast< PLFLT >(val1);
20047 arg2 =
static_cast< PLFLT >(val2);
20052 arg3 =
static_cast< PLFLT >(val3);
20053 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
20054 _outv = octave_value();
20076 return octave_value_list();
20085 octave_value_list _out;
20086 octave_value_list *_outp=&_out;
20087 octave_value _outv;
20094 _outv = octave_value();
20098 return octave_value_list();
20119 octave_value_list _out;
20120 octave_value_list *_outp=&_out;
20121 octave_value _outv;
20131 arg1 =
static_cast< PLFLT >(val1);
20136 arg2 =
static_cast< PLFLT >(val2);
20141 arg3 =
static_cast< PLFLT >(val3);
20146 arg4 =
static_cast< PLFLT >(val4);
20147 pljoin(arg1,arg2,arg3,arg4);
20148 _outv = octave_value();
20152 return octave_value_list();
20161 char *arg1 = (
char *) 0 ;
20162 char *arg2 = (
char *) 0 ;
20163 char *arg3 = (
char *) 0 ;
20173 octave_value_list _out;
20174 octave_value_list *_outp=&_out;
20175 octave_value _outv;
20185 arg1 =
reinterpret_cast< char *
>(buf1);
20190 arg2 =
reinterpret_cast< char *
>(buf2);
20195 arg3 =
reinterpret_cast< char *
>(buf3);
20196 pllab((
char const *)arg1,(
char const *)arg2,(
char const *)arg3);
20197 _outv = octave_value();
20207 return octave_value_list();
20238 char **arg20 = (
char **) 0 ;
20249 char **arg31 = (
char **) 0 ;
20294 octave_value_list _out;
20295 octave_value_list *_outp=&_out;
20296 octave_value _outv;
20308 arg3 =
static_cast< PLINT >(val3);
20313 arg4 =
static_cast< PLINT >(val4);
20318 arg5 =
static_cast< PLFLT >(val5);
20323 arg6 =
static_cast< PLFLT >(val6);
20328 arg7 =
static_cast< PLFLT >(val7);
20333 arg8 =
static_cast< PLINT >(val8);
20338 arg9 =
static_cast< PLINT >(val9);
20343 arg10 =
static_cast< PLINT >(val10);
20348 arg11 =
static_cast< PLINT >(val11);
20353 arg12 =
static_cast< PLINT >(val12);
20355 if (
_n_dims( args(10) ) > 1 )
20361 temp13 = args(10).matrix_value();
20368 arg15 =
static_cast< PLFLT >(val15);
20373 arg16 =
static_cast< PLFLT >(val16);
20378 arg17 =
static_cast< PLFLT >(val17);
20383 arg18 =
static_cast< PLFLT >(val18);
20385 if (
_n_dims( args(15) ) > 1 )
20389 if (
_dim( args(15), 0 ) !=
Alen )
20393 temp19 = args(15).matrix_value();
20398 charMatrix temp_matrix;
20402 size_t max_length = 0, non_blank_length;
20404 if (
_n_dims( args(16) ) > 2 )
20406 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
20408 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20409 if ( !args(16).isempty() )
20411 if ( !args(16).is_empty() )
20414 if (
_dim( args(16), 0 ) !=
Alen )
20416 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
20418 arg20 =
new char*[
Alen];
20419 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20420 ifcell = args(16).iscell();
20422 ifcell = args(16).is_cell();
20426 temp_cell = args(16).cell_value();
20430 temp_matrix = args(16).char_matrix_value();
20432 max_length =
_dim( args(16), 1 ) + 1;
20435 for ( i = 0; i <
Alen; i++ )
20442 if ( temp_cell.elem( i ).is_string() )
20444 str = temp_cell.elem( i ).string_value();
20446 max_length = str.size() + 1;
20447 tmp_cstring = (
char *) str.c_str();
20457 tmp_cstring = (
char *)
"";
20462 str = temp_matrix.row_as_string( i );
20463 tmp_cstring = (
char *) str.c_str();
20465 arg20[i] =
new char[max_length];
20466 strncpy( arg20[i], tmp_cstring, max_length - 1 );
20467 arg20[i][max_length - 1] =
'\0';
20482 non_blank_length = max_length - 2;
20483 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
20485 non_blank_length--;
20487 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
20489 non_blank_length--;
20491 arg20[i][non_blank_length + 1] =
'\0';
20501 if (
_n_dims( args(17) ) > 1 )
20505 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20506 if ( !args(17).isempty() )
20508 if ( !args(17).is_empty() )
20511 if (
_dim( args(17), 0 ) !=
Alen )
20515 temp21 = args(17).matrix_value();
20525 if (
_n_dims( args(18) ) > 1 )
20529 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20530 if ( !args(18).isempty() )
20532 if ( !args(18).is_empty() )
20535 if (
_dim( args(18), 0 ) !=
Alen )
20539 temp22 = args(18).matrix_value();
20549 if (
_n_dims( args(19) ) > 1 )
20553 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20554 if ( !args(19).isempty() )
20556 if ( !args(19).is_empty() )
20559 if (
_dim( args(19), 0 ) !=
Alen )
20563 temp23 = args(19).matrix_value();
20564 arg23 = &temp23( 0, 0 );
20572 if (
_n_dims( args(20) ) > 1 )
20576 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20577 if ( !args(20).isempty() )
20579 if ( !args(20).is_empty() )
20582 if (
_dim( args(20), 0 ) !=
Alen )
20586 temp24 = args(20).matrix_value();
20587 arg24 = &temp24( 0, 0 );
20595 if (
_n_dims( args(21) ) > 1 )
20599 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20600 if ( !args(21).isempty() )
20602 if ( !args(21).is_empty() )
20605 if (
_dim( args(21), 0 ) !=
Alen )
20609 temp25 = args(21).matrix_value();
20619 if (
_n_dims( args(22) ) > 1 )
20623 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20624 if ( !args(22).isempty() )
20626 if ( !args(22).is_empty() )
20629 if (
_dim( args(22), 0 ) !=
Alen )
20633 temp26 = args(22).matrix_value();
20643 if (
_n_dims( args(23) ) > 1 )
20647 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20648 if ( !args(23).isempty() )
20650 if ( !args(23).is_empty() )
20653 if (
_dim( args(23), 0 ) !=
Alen )
20657 temp27 = args(23).matrix_value();
20658 arg27 = &temp27( 0, 0 );
20666 if (
_n_dims( args(24) ) > 1 )
20670 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20671 if ( !args(24).isempty() )
20673 if ( !args(24).is_empty() )
20676 if (
_dim( args(24), 0 ) !=
Alen )
20680 temp28 = args(24).matrix_value();
20690 if (
_n_dims( args(25) ) > 1 )
20694 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20695 if ( !args(25).isempty() )
20697 if ( !args(25).is_empty() )
20700 if (
_dim( args(25), 0 ) !=
Alen )
20704 temp29 = args(25).matrix_value();
20705 arg29 = &temp29( 0, 0 );
20713 if (
_n_dims( args(26) ) > 1 )
20717 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20718 if ( !args(26).isempty() )
20720 if ( !args(26).is_empty() )
20723 if (
_dim( args(26), 0 ) !=
Alen )
20727 temp30 = args(26).matrix_value();
20737 charMatrix temp_matrix;
20741 size_t max_length = 0, non_blank_length;
20743 if (
_n_dims( args(27) ) > 2 )
20745 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
20747 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20748 if ( !args(27).isempty() )
20750 if ( !args(27).is_empty() )
20753 if (
_dim( args(27), 0 ) !=
Alen )
20755 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
20757 arg31 =
new char*[
Alen];
20758 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20759 ifcell = args(27).iscell();
20761 ifcell = args(27).is_cell();
20765 temp_cell = args(27).cell_value();
20769 temp_matrix = args(27).char_matrix_value();
20771 max_length =
_dim( args(27), 1 ) + 1;
20774 for ( i = 0; i <
Alen; i++ )
20781 if ( temp_cell.elem( i ).is_string() )
20783 str = temp_cell.elem( i ).string_value();
20785 max_length = str.size() + 1;
20786 tmp_cstring = (
char *) str.c_str();
20796 tmp_cstring = (
char *)
"";
20801 str = temp_matrix.row_as_string( i );
20802 tmp_cstring = (
char *) str.c_str();
20804 arg31[i] =
new char[max_length];
20805 strncpy( arg31[i], tmp_cstring, max_length - 1 );
20806 arg31[i][max_length - 1] =
'\0';
20821 non_blank_length = max_length - 2;
20822 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
'\0' )
20824 non_blank_length--;
20826 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
' ' )
20828 non_blank_length--;
20830 arg31[i][non_blank_length + 1] =
'\0';
20839 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);
20840 _outv = octave_value();
20862 if ( arg20 != NULL )
20864 for ( i = 0; i <
Alen; i++ )
20872 if ( arg21 != NULL )
20876 if ( arg22 != NULL )
20886 if ( arg25 != NULL )
20890 if ( arg26 != NULL )
20897 if ( arg28 != NULL )
20904 if ( arg30 != NULL )
20909 if ( arg31 != NULL )
20911 for ( i = 0; i <
Alen; i++ )
20928 if ( arg20 != NULL )
20930 for ( i = 0; i <
Alen; i++ )
20938 if ( arg21 != NULL )
20942 if ( arg22 != NULL )
20952 if ( arg25 != NULL )
20956 if ( arg26 != NULL )
20963 if ( arg28 != NULL )
20970 if ( arg30 != NULL )
20975 if ( arg31 != NULL )
20977 for ( i = 0; i <
Alen; i++ )
20984 return octave_value_list();
20995 if ( arg20 != NULL )
20997 for ( i = 0; i <
Alen; i++ )
21005 if ( arg21 != NULL )
21009 if ( arg22 != NULL )
21019 if ( arg25 != NULL )
21023 if ( arg26 != NULL )
21030 if ( arg28 != NULL )
21037 if ( arg30 != NULL )
21042 if ( arg31 != NULL )
21044 for ( i = 0; i <
Alen; i++ )
21066 octave_value_list _out;
21067 octave_value_list *_outp=&_out;
21068 octave_value _outv;
21078 arg1 =
static_cast< PLFLT >(val1);
21083 arg2 =
static_cast< PLFLT >(val2);
21088 arg3 =
static_cast< PLFLT >(val3);
21090 _outv = octave_value();
21094 return octave_value_list();
21108 octave_value_list _out;
21109 octave_value_list *_outp=&_out;
21110 octave_value _outv;
21117 if (
_n_dims( args(0) ) > 1 )
21122 temp1 = args(0).matrix_value();
21123 arg2 = &temp1( 0, 0 );
21126 if (
_n_dims( args(1) ) > 1 )
21134 temp3 = args(1).matrix_value();
21135 arg3 = &temp3( 0, 0 );
21137 plline(arg1,(
double const *)arg2,(
double const *)arg3);
21138 _outv = octave_value();
21154 return octave_value_list();
21176 octave_value_list _out;
21177 octave_value_list *_outp=&_out;
21178 octave_value _outv;
21185 if (
_n_dims( args(0) ) > 1 )
21190 temp1 = args(0).matrix_value();
21191 arg2 = &temp1( 0, 0 );
21194 if (
_n_dims( args(1) ) > 1 )
21202 temp3 = args(1).matrix_value();
21203 arg3 = &temp3( 0, 0 );
21206 if (
_n_dims( args(2) ) > 1 )
21214 temp4 = args(2).matrix_value();
21215 arg4 = &temp4( 0, 0 );
21217 plline3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
21218 _outv = octave_value();
21240 return octave_value_list();
21261 octave_value_list _out;
21262 octave_value_list *_outp=&_out;
21263 octave_value _outv;
21273 arg1 =
static_cast< PLINT >(val1);
21275 _outv = octave_value();
21279 return octave_value_list();
21291 octave_value_list _out;
21292 octave_value_list *_outp=&_out;
21293 octave_value _outv;
21301 _outv = octave_value();
21311 return octave_value_list();
21320 char *arg1 = (
char *) 0 ;
21324 char *arg5 = (
char *) 0 ;
21337 octave_value_list _out;
21338 octave_value_list *_outp=&_out;
21339 octave_value _outv;
21349 arg1 =
reinterpret_cast< char *
>(buf1);
21354 arg2 =
static_cast< PLFLT >(val2);
21359 arg3 =
static_cast< PLFLT >(val3);
21364 arg4 =
static_cast< PLFLT >(val4);
21369 arg5 =
reinterpret_cast< char *
>(buf5);
21370 plmtex((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
21371 _outv = octave_value();
21379 return octave_value_list();
21390 char *arg1 = (
char *) 0 ;
21394 char *arg5 = (
char *) 0 ;
21407 octave_value_list _out;
21408 octave_value_list *_outp=&_out;
21409 octave_value _outv;
21419 arg1 =
reinterpret_cast< char *
>(buf1);
21424 arg2 =
static_cast< PLFLT >(val2);
21429 arg3 =
static_cast< PLFLT >(val3);
21434 arg4 =
static_cast< PLFLT >(val4);
21439 arg5 =
reinterpret_cast< char *
>(buf5);
21440 plmtex3((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
21441 _outv = octave_value();
21449 return octave_value_list();
21460 int *arg1 = (
int *) 0 ;
21461 char **arg2 = (
char **) 0 ;
21469 octave_value_list _out;
21470 octave_value_list *_outp=&_out;
21471 octave_value _outv;
21482 arg1 =
reinterpret_cast< int *
>(argp1);
21487 arg2 =
reinterpret_cast< char **
>(argp2);
21492 arg3 =
static_cast< PLINT >(val3);
21498 return octave_value_list();
21512 octave_value_list _out;
21513 octave_value_list *_outp=&_out;
21514 octave_value _outv;
21521 if (
_n_dims( args(0) ) > 1 )
21527 temp1 = args(0).matrix_value();
21531 if (
_n_dims( args(1) ) > 1 )
21539 temp3 = args(1).matrix_value();
21543 plpat(arg1,(
int const *)arg2,(
int const *)arg3);
21544 _outv = octave_value();
21560 return octave_value_list();
21590 octave_value_list _out;
21591 octave_value_list *_outp=&_out;
21592 octave_value _outv;
21602 arg1 =
static_cast< PLINT >(val1);
21607 arg2 =
static_cast< PLFLT >(val2);
21612 arg3 =
static_cast< PLFLT >(val3);
21617 arg4 =
static_cast< PLFLT >(val4);
21622 arg5 =
static_cast< PLFLT >(val5);
21623 plpath(arg1,arg2,arg3,arg4,arg5);
21624 _outv = octave_value();
21628 return octave_value_list();
21645 octave_value_list _out;
21646 octave_value_list *_outp=&_out;
21647 octave_value _outv;
21654 if (
_n_dims( args(0) ) > 1 )
21659 temp1 = args(0).matrix_value();
21660 arg2 = &temp1( 0, 0 );
21663 if (
_n_dims( args(1) ) > 1 )
21671 temp3 = args(1).matrix_value();
21672 arg3 = &temp3( 0, 0 );
21678 arg4 =
static_cast< PLINT >(val4);
21679 plpoin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
21680 _outv = octave_value();
21696 return octave_value_list();
21721 octave_value_list _out;
21722 octave_value_list *_outp=&_out;
21723 octave_value _outv;
21730 if (
_n_dims( args(0) ) > 1 )
21735 temp1 = args(0).matrix_value();
21736 arg2 = &temp1( 0, 0 );
21739 if (
_n_dims( args(1) ) > 1 )
21747 temp3 = args(1).matrix_value();
21748 arg3 = &temp3( 0, 0 );
21751 if (
_n_dims( args(2) ) > 1 )
21759 temp4 = args(2).matrix_value();
21760 arg4 = &temp4( 0, 0 );
21766 arg5 =
static_cast< PLINT >(val5);
21767 plpoin3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,arg5);
21768 _outv = octave_value();
21790 return octave_value_list();
21820 octave_value_list _out;
21821 octave_value_list *_outp=&_out;
21822 octave_value _outv;
21829 if (
_n_dims( args(0) ) > 1 )
21834 temp1 = args(0).matrix_value();
21835 arg2 = &temp1( 0, 0 );
21838 if (
_n_dims( args(1) ) > 1 )
21846 temp3 = args(1).matrix_value();
21847 arg3 = &temp3( 0, 0 );
21850 if (
_n_dims( args(2) ) > 1 )
21858 temp4 = args(2).matrix_value();
21859 arg4 = &temp4( 0, 0 );
21862 if (
_n_dims( args(3) ) > 1 )
21868 error(
"argument vector must be same length or one less" );
SWIG_fail;
21870 temp5 = args(3).matrix_value();
21878 arg6 =
static_cast< PLBOOL >(val6);
21879 plpoly3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
int const *)arg5,arg6);
21880 _outv = octave_value();
21908 return octave_value_list();
21935 octave_value_list _out;
21936 octave_value_list *_outp=&_out;
21937 octave_value _outv;
21947 arg1 =
static_cast< PLINT >(val1);
21952 arg2 =
static_cast< PLINT >(val2);
21954 _outv = octave_value();
21958 return octave_value_list();
21970 octave_value_list _out;
21971 octave_value_list *_outp=&_out;
21972 octave_value _outv;
21982 arg1 =
static_cast< PLINT >(val1);
21984 _outv = octave_value();
21988 return octave_value_list();
22002 char *arg6 = (
char *) 0 ;
22016 octave_value_list _out;
22017 octave_value_list *_outp=&_out;
22018 octave_value _outv;
22028 arg1 =
static_cast< PLFLT >(val1);
22033 arg2 =
static_cast< PLFLT >(val2);
22038 arg3 =
static_cast< PLFLT >(val3);
22043 arg4 =
static_cast< PLFLT >(val4);
22048 arg5 =
static_cast< PLFLT >(val5);
22053 arg6 =
reinterpret_cast< char *
>(buf6);
22054 plptex(arg1,arg2,arg3,arg4,arg5,(
char const *)arg6);
22055 _outv = octave_value();
22061 return octave_value_list();
22081 char *arg11 = (
char *) 0 ;
22105 octave_value_list _out;
22106 octave_value_list *_outp=&_out;
22107 octave_value _outv;
22117 arg1 =
static_cast< PLFLT >(val1);
22122 arg2 =
static_cast< PLFLT >(val2);
22127 arg3 =
static_cast< PLFLT >(val3);
22132 arg4 =
static_cast< PLFLT >(val4);
22137 arg5 =
static_cast< PLFLT >(val5);
22142 arg6 =
static_cast< PLFLT >(val6);
22147 arg7 =
static_cast< PLFLT >(val7);
22152 arg8 =
static_cast< PLFLT >(val8);
22157 arg9 =
static_cast< PLFLT >(val9);
22162 arg10 =
static_cast< PLFLT >(val10);
22167 arg11 =
reinterpret_cast< char *
>(buf11);
22168 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(
char const *)arg11);
22169 _outv = octave_value();
22175 return octave_value_list();
22185 octave_value_list _out;
22186 octave_value_list *_outp=&_out;
22187 octave_value _outv;
22199 return octave_value_list();
22208 octave_value_list _out;
22209 octave_value_list *_outp=&_out;
22210 octave_value _outv;
22217 _outv = octave_value();
22221 return octave_value_list();
22248 octave_value_list _out;
22249 octave_value_list *_outp=&_out;
22250 octave_value _outv;
22263 arg1 =
static_cast< PLFLT >(val1);
22268 arg2 =
static_cast< PLFLT >(val2);
22273 arg3 =
static_cast< PLFLT >(val3);
22274 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
22275 _outv = octave_value();
22297 return octave_value_list();
22312 octave_value_list _out;
22313 octave_value_list *_outp=&_out;
22314 octave_value _outv;
22324 arg1 =
static_cast< PLFLT >(val1);
22329 arg2 =
static_cast< PLFLT >(val2);
22331 _outv = octave_value();
22335 return octave_value_list();
22351 octave_value_list _out;
22352 octave_value_list *_outp=&_out;
22353 octave_value _outv;
22360 if (
_n_dims( args(0) ) > 1 )
22365 temp1 = args(0).matrix_value();
22370 if (
_n_dims( args(1) ) > 1 )
22378 temp2 = args(1).matrix_value();
22383 if (
_n_dims( args(2) ) > 1 )
22391 temp3 = args(2).matrix_value();
22396 plscmap0((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
22397 _outv = octave_value();
22419 return octave_value_list();
22446 octave_value_list _out;
22447 octave_value_list *_outp=&_out;
22448 octave_value _outv;
22455 if (
_n_dims( args(0) ) > 1 )
22460 temp1 = args(0).matrix_value();
22465 if (
_n_dims( args(1) ) > 1 )
22473 temp2 = args(1).matrix_value();
22478 if (
_n_dims( args(2) ) > 1 )
22486 temp3 = args(2).matrix_value();
22491 if (
_n_dims( args(3) ) > 1 )
22499 temp4 = args(3).matrix_value();
22500 arg4 = &temp4( 0, 0 );
22503 plscmap0a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
22504 _outv = octave_value();
22532 return octave_value_list();
22556 octave_value_list _out;
22557 octave_value_list *_outp=&_out;
22558 octave_value _outv;
22568 arg1 =
static_cast< PLINT >(val1);
22570 _outv = octave_value();
22574 return octave_value_list();
22590 octave_value_list _out;
22591 octave_value_list *_outp=&_out;
22592 octave_value _outv;
22599 if (
_n_dims( args(0) ) > 1 )
22604 temp1 = args(0).matrix_value();
22609 if (
_n_dims( args(1) ) > 1 )
22617 temp2 = args(1).matrix_value();
22622 if (
_n_dims( args(2) ) > 1 )
22630 temp3 = args(2).matrix_value();
22635 plscmap1((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
22636 _outv = octave_value();
22658 return octave_value_list();
22685 octave_value_list _out;
22686 octave_value_list *_outp=&_out;
22687 octave_value _outv;
22694 if (
_n_dims( args(0) ) > 1 )
22699 temp1 = args(0).matrix_value();
22704 if (
_n_dims( args(1) ) > 1 )
22712 temp2 = args(1).matrix_value();
22717 if (
_n_dims( args(2) ) > 1 )
22725 temp3 = args(2).matrix_value();
22730 if (
_n_dims( args(3) ) > 1 )
22738 temp4 = args(3).matrix_value();
22739 arg4 = &temp4( 0, 0 );
22742 plscmap1a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
22743 _outv = octave_value();
22771 return octave_value_list();
22806 octave_value_list _out;
22807 octave_value_list *_outp=&_out;
22808 octave_value _outv;
22818 arg1 =
static_cast< PLBOOL >(val1);
22820 if (
_n_dims( args(1) ) > 1 )
22825 temp2 = args(1).matrix_value();
22826 arg3 = &temp2( 0, 0 );
22829 if (
_n_dims( args(2) ) > 1 )
22837 temp4 = args(2).matrix_value();
22838 arg4 = &temp4( 0, 0 );
22841 if (
_n_dims( args(3) ) > 1 )
22849 temp5 = args(3).matrix_value();
22850 arg5 = &temp5( 0, 0 );
22853 if (
_n_dims( args(4) ) > 1 )
22861 temp6 = args(4).matrix_value();
22862 arg6 = &temp6( 0, 0 );
22865 if (
_n_dims( args(5) ) > 1 )
22871 error(
"argument vector must be same length or one less" );
SWIG_fail;
22873 temp7 = args(5).matrix_value();
22877 plscmap1l(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
int const *)arg7);
22878 _outv = octave_value();
22912 return octave_value_list();
22952 octave_value_list _out;
22953 octave_value_list *_outp=&_out;
22954 octave_value _outv;
22964 arg1 =
static_cast< PLBOOL >(val1);
22966 if (
_n_dims( args(1) ) > 1 )
22971 temp2 = args(1).matrix_value();
22972 arg3 = &temp2( 0, 0 );
22975 if (
_n_dims( args(2) ) > 1 )
22983 temp4 = args(2).matrix_value();
22984 arg4 = &temp4( 0, 0 );
22987 if (
_n_dims( args(3) ) > 1 )
22995 temp5 = args(3).matrix_value();
22996 arg5 = &temp5( 0, 0 );
22999 if (
_n_dims( args(4) ) > 1 )
23007 temp6 = args(4).matrix_value();
23008 arg6 = &temp6( 0, 0 );
23011 if (
_n_dims( args(5) ) > 1 )
23019 temp7 = args(5).matrix_value();
23020 arg7 = &temp7( 0, 0 );
23023 if (
_n_dims( args(6) ) > 1 )
23029 error(
"argument vector must be same length or one less" );
SWIG_fail;
23031 temp8 = args(6).matrix_value();
23035 plscmap1la(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
double const *)arg7,(
int const *)arg8);
23036 _outv = octave_value();
23076 return octave_value_list();
23106 octave_value_list _out;
23107 octave_value_list *_outp=&_out;
23108 octave_value _outv;
23118 arg1 =
static_cast< PLINT >(val1);
23120 _outv = octave_value();
23124 return octave_value_list();
23139 octave_value_list _out;
23140 octave_value_list *_outp=&_out;
23141 octave_value _outv;
23151 arg1 =
static_cast< PLFLT >(val1);
23156 arg2 =
static_cast< PLFLT >(val2);
23158 _outv = octave_value();
23162 return octave_value_list();
23177 octave_value_list _out;
23178 octave_value_list *_outp=&_out;
23179 octave_value _outv;
23188 _outv = octave_value();
23204 return octave_value_list();
23225 octave_value_list _out;
23226 octave_value_list *_outp=&_out;
23227 octave_value _outv;
23237 arg1 =
static_cast< PLINT >(val1);
23242 arg2 =
static_cast< PLINT >(val2);
23247 arg3 =
static_cast< PLINT >(val3);
23252 arg4 =
static_cast< PLINT >(val4);
23253 plscol0(arg1,arg2,arg3,arg4);
23254 _outv = octave_value();
23258 return octave_value_list();
23282 octave_value_list _out;
23283 octave_value_list *_outp=&_out;
23284 octave_value _outv;
23294 arg1 =
static_cast< PLINT >(val1);
23299 arg2 =
static_cast< PLINT >(val2);
23304 arg3 =
static_cast< PLINT >(val3);
23309 arg4 =
static_cast< PLINT >(val4);
23314 arg5 =
static_cast< PLFLT >(val5);
23315 plscol0a(arg1,arg2,arg3,arg4,arg5);
23316 _outv = octave_value();
23320 return octave_value_list();
23338 octave_value_list _out;
23339 octave_value_list *_outp=&_out;
23340 octave_value _outv;
23350 arg1 =
static_cast< PLINT >(val1);
23355 arg2 =
static_cast< PLINT >(val2);
23360 arg3 =
static_cast< PLINT >(val3);
23362 _outv = octave_value();
23366 return octave_value_list();
23387 octave_value_list _out;
23388 octave_value_list *_outp=&_out;
23389 octave_value _outv;
23399 arg1 =
static_cast< PLINT >(val1);
23404 arg2 =
static_cast< PLINT >(val2);
23409 arg3 =
static_cast< PLINT >(val3);
23414 arg4 =
static_cast< PLFLT >(val4);
23416 _outv = octave_value();
23420 return octave_value_list();
23432 octave_value_list _out;
23433 octave_value_list *_outp=&_out;
23434 octave_value _outv;
23444 arg1 =
static_cast< PLINT >(val1);
23446 _outv = octave_value();
23450 return octave_value_list();
23462 octave_value_list _out;
23463 octave_value_list *_outp=&_out;
23464 octave_value _outv;
23474 arg1 =
static_cast< PLINT >(val1);
23476 _outv = octave_value();
23480 return octave_value_list();
23489 char *arg1 = (
char *) 0 ;
23493 octave_value_list _out;
23494 octave_value_list *_outp=&_out;
23495 octave_value _outv;
23505 arg1 =
reinterpret_cast< char *
>(buf1);
23506 plsdev((
char const *)arg1);
23507 _outv = octave_value();
23513 return octave_value_list();
23535 octave_value_list _out;
23536 octave_value_list *_outp=&_out;
23537 octave_value _outv;
23547 arg1 =
static_cast< PLFLT >(val1);
23552 arg2 =
static_cast< PLFLT >(val2);
23557 arg3 =
static_cast< PLFLT >(val3);
23562 arg4 =
static_cast< PLFLT >(val4);
23564 _outv = octave_value();
23568 return octave_value_list();
23595 octave_value_list _out;
23596 octave_value_list *_outp=&_out;
23597 octave_value _outv;
23607 arg1 =
static_cast< PLINT >(val1);
23612 arg2 =
static_cast< PLINT >(val2);
23617 arg3 =
static_cast< PLINT >(val3);
23622 arg4 =
static_cast< PLINT >(val4);
23627 arg5 =
static_cast< PLFLT >(val5);
23632 arg6 =
static_cast< PLFLT >(val6);
23633 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
23634 _outv = octave_value();
23638 return octave_value_list();
23650 octave_value_list _out;
23651 octave_value_list *_outp=&_out;
23652 octave_value _outv;
23662 arg1 =
static_cast< PLFLT >(val1);
23664 _outv = octave_value();
23668 return octave_value_list();
23689 octave_value_list _out;
23690 octave_value_list *_outp=&_out;
23691 octave_value _outv;
23701 arg1 =
static_cast< PLFLT >(val1);
23706 arg2 =
static_cast< PLFLT >(val2);
23711 arg3 =
static_cast< PLFLT >(val3);
23716 arg4 =
static_cast< PLFLT >(val4);
23718 _outv = octave_value();
23722 return octave_value_list();
23743 octave_value_list _out;
23744 octave_value_list *_outp=&_out;
23745 octave_value _outv;
23755 arg1 =
static_cast< PLFLT >(val1);
23760 arg2 =
static_cast< PLFLT >(val2);
23765 arg3 =
static_cast< PLFLT >(val3);
23770 arg4 =
static_cast< PLFLT >(val4);
23772 _outv = octave_value();
23776 return octave_value_list();
23785 unsigned int arg1 ;
23786 unsigned int val1 ;
23788 octave_value_list _out;
23789 octave_value_list *_outp=&_out;
23790 octave_value _outv;
23800 arg1 =
static_cast< unsigned int >(val1);
23802 _outv = octave_value();
23806 return octave_value_list();
23818 octave_value_list _out;
23819 octave_value_list *_outp=&_out;
23820 octave_value _outv;
23830 arg1 =
static_cast< char >(val1);
23832 _outv = octave_value();
23836 return octave_value_list();
23845 char *arg1 = (
char *) 0 ;
23846 char *arg2 = (
char *) 0 ;
23853 octave_value_list _out;
23854 octave_value_list *_outp=&_out;
23855 octave_value _outv;
23866 arg1 =
reinterpret_cast< char *
>(buf1);
23871 arg2 =
reinterpret_cast< char *
>(buf2);
23872 result = (
PLINT)
plsetopt((
char const *)arg1,(
char const *)arg2);
23881 return octave_value_list();
23901 octave_value_list _out;
23902 octave_value_list *_outp=&_out;
23903 octave_value _outv;
23913 arg1 =
static_cast< PLINT >(val1);
23918 arg2 =
static_cast< PLINT >(val2);
23923 arg3 =
static_cast< PLINT >(val3);
23925 _outv = octave_value();
23929 return octave_value_list();
23939 unsigned int val1 ;
23941 octave_value_list _out;
23942 octave_value_list *_outp=&_out;
23943 octave_value _outv;
23955 _outv = octave_value();
23959 return octave_value_list();
23968 char *arg1 = (
char *) 0 ;
23972 octave_value_list _out;
23973 octave_value_list *_outp=&_out;
23974 octave_value _outv;
23984 arg1 =
reinterpret_cast< char *
>(buf1);
23986 _outv = octave_value();
23992 return octave_value_list();
24011 octave_value_list _out;
24012 octave_value_list *_outp=&_out;
24013 octave_value _outv;
24023 arg1 =
static_cast< PLINT >(val1);
24028 arg2 =
static_cast< PLINT >(val2);
24033 arg3 =
static_cast< PLINT >(val3);
24035 _outv = octave_value();
24039 return octave_value_list();
24051 octave_value_list _out;
24052 octave_value_list *_outp=&_out;
24053 octave_value _outv;
24060 octave_value obj = args(0);
24061 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24062 if ( !obj.isempty() )
24064 if ( !obj.is_empty() )
24067 if ( obj.is_function_handle() || obj.is_inline_function() )
24071 else if ( obj.is_string() )
24088 _outv = octave_value();
24092 return octave_value_list();
24107 octave_value_list _out;
24108 octave_value_list *_outp=&_out;
24109 octave_value _outv;
24119 arg1 =
static_cast< PLFLT >(val1);
24124 arg2 =
static_cast< PLFLT >(val2);
24126 _outv = octave_value();
24130 return octave_value_list();
24145 octave_value_list _out;
24146 octave_value_list *_outp=&_out;
24147 octave_value _outv;
24157 arg1 =
static_cast< PLFLT >(val1);
24162 arg2 =
static_cast< PLFLT >(val2);
24164 _outv = octave_value();
24168 return octave_value_list();
24180 octave_value_list _out;
24181 octave_value_list *_outp=&_out;
24182 octave_value _outv;
24192 arg1 =
static_cast< PLINT >(val1);
24194 _outv = octave_value();
24198 return octave_value_list();
24225 octave_value_list _out;
24226 octave_value_list *_outp=&_out;
24227 octave_value _outv;
24237 arg1 =
static_cast< PLFLT >(val1);
24242 arg2 =
static_cast< PLFLT >(val2);
24247 arg3 =
static_cast< PLINT >(val3);
24252 arg4 =
static_cast< PLINT >(val4);
24257 arg5 =
static_cast< PLINT >(val5);
24262 arg6 =
static_cast< PLINT >(val6);
24263 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
24264 _outv = octave_value();
24268 return octave_value_list();
24277 char *arg1 = (
char *) 0 ;
24281 octave_value_list _out;
24282 octave_value_list *_outp=&_out;
24283 octave_value _outv;
24293 arg1 =
reinterpret_cast< char *
>(buf1);
24295 _outv = octave_value();
24301 return octave_value_list();
24311 char *arg1 = (
char *) 0 ;
24318 octave_value_list _out;
24319 octave_value_list *_outp=&_out;
24320 octave_value _outv;
24330 arg1 =
reinterpret_cast< char *
>(buf1);
24335 arg2 =
static_cast< PLBOOL >(val2);
24336 plspal1((
char const *)arg1,arg2);
24337 _outv = octave_value();
24343 return octave_value_list();
24356 octave_value_list _out;
24357 octave_value_list *_outp=&_out;
24358 octave_value _outv;
24368 arg1 =
static_cast< PLBOOL >(val1);
24370 _outv = octave_value();
24374 return octave_value_list();
24386 octave_value_list _out;
24387 octave_value_list *_outp=&_out;
24388 octave_value _outv;
24398 arg1 =
static_cast< PLINT >(val1);
24400 _outv = octave_value();
24404 return octave_value_list();
24419 octave_value_list _out;
24420 octave_value_list *_outp=&_out;
24421 octave_value _outv;
24431 arg1 =
static_cast< PLINT >(val1);
24436 arg2 =
static_cast< PLINT >(val2);
24438 _outv = octave_value();
24442 return octave_value_list();
24457 octave_value_list _out;
24458 octave_value_list *_outp=&_out;
24459 octave_value _outv;
24469 arg1 =
static_cast< PLFLT >(val1);
24474 arg2 =
static_cast< PLFLT >(val2);
24476 _outv = octave_value();
24480 return octave_value_list();
24495 octave_value_list _out;
24496 octave_value_list *_outp=&_out;
24497 octave_value _outv;
24507 arg1 =
static_cast< PLINT >(val1);
24512 arg2 =
static_cast< PLINT >(val2);
24514 _outv = octave_value();
24518 return octave_value_list();
24527 char *arg1 = (
char *) 0 ;
24537 octave_value_list _out;
24538 octave_value_list *_outp=&_out;
24539 octave_value _outv;
24549 arg1 =
reinterpret_cast< char *
>(buf1);
24554 arg2 =
static_cast< PLINT >(val2);
24559 arg3 =
static_cast< PLINT >(val3);
24560 plstart((
char const *)arg1,arg2,arg3);
24561 _outv = octave_value();
24567 return octave_value_list();
24580 octave_value_list _out;
24581 octave_value_list *_outp=&_out;
24582 octave_value _outv;
24589 octave_value obj = args(0);
24590 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24591 if ( !obj.isempty() )
24593 if ( !obj.is_empty() )
24596 if ( obj.is_function_handle() || obj.is_inline_function() )
24600 else if ( obj.is_string() )
24617 _outv = octave_value();
24621 return octave_value_list();
24633 char *arg4 = (
char *) 0 ;
24639 octave_value_list _out;
24640 octave_value_list *_outp=&_out;
24641 octave_value _outv;
24648 if (
_n_dims( args(0) ) > 1 )
24653 temp1 = args(0).matrix_value();
24654 arg2 = &temp1( 0, 0 );
24657 if (
_n_dims( args(1) ) > 1 )
24665 temp3 = args(1).matrix_value();
24666 arg3 = &temp3( 0, 0 );
24672 arg4 =
reinterpret_cast< char *
>(buf4);
24673 plstring(arg1,(
double const *)arg2,(
double const *)arg3,(
char const *)arg4);
24674 _outv = octave_value();
24692 return octave_value_list();
24712 char *arg5 = (
char *) 0 ;
24719 octave_value_list _out;
24720 octave_value_list *_outp=&_out;
24721 octave_value _outv;
24728 if (
_n_dims( args(0) ) > 1 )
24733 temp1 = args(0).matrix_value();
24734 arg2 = &temp1( 0, 0 );
24737 if (
_n_dims( args(1) ) > 1 )
24745 temp3 = args(1).matrix_value();
24746 arg3 = &temp3( 0, 0 );
24749 if (
_n_dims( args(2) ) > 1 )
24757 temp4 = args(2).matrix_value();
24758 arg4 = &temp4( 0, 0 );
24764 arg5 =
reinterpret_cast< char *
>(buf5);
24765 plstring3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
char const *)arg5);
24766 _outv = octave_value();
24790 return octave_value_list();
24821 octave_value_list _out;
24822 octave_value_list *_outp=&_out;
24823 octave_value _outv;
24833 arg1 =
static_cast< PLINT >(val1);
24838 arg2 =
static_cast< PLINT >(val2);
24843 arg3 =
static_cast< PLFLT >(val3);
24848 arg4 =
static_cast< PLFLT >(val4);
24850 _outv = octave_value();
24854 return octave_value_list();
24866 octave_value_list _out;
24867 octave_value_list *_outp=&_out;
24868 octave_value _outv;
24878 arg1 =
static_cast< PLINT >(val1);
24880 _outv = octave_value();
24884 return octave_value_list();
24898 octave_value_list _out;
24899 octave_value_list *_outp=&_out;
24900 octave_value _outv;
24907 if (
_n_dims( args(0) ) > 1 )
24913 temp1 = args(0).matrix_value();
24917 if (
_n_dims( args(1) ) > 1 )
24925 temp3 = args(1).matrix_value();
24929 plstyl(arg1,(
int const *)arg2,(
int const *)arg3);
24930 _outv = octave_value();
24946 return octave_value_list();
24969 octave_value_list _out;
24970 octave_value_list *_outp=&_out;
24971 octave_value _outv;
24978 if (
_n_dims( args(0) ) > 1 )
24982 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24983 if ( !args(0).isempty() )
24985 if ( !args(0).is_empty() )
24989 temp1 = args(0).matrix_value();
24990 arg1 = &temp1( 0, 0 );
24999 if (
_n_dims( args(1) ) > 1 )
25003 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25004 if ( !args(1).isempty() )
25006 if ( !args(1).is_empty() )
25013 temp2 = args(1).matrix_value();
25014 arg2 = &temp2( 0, 0 );
25027 arg4 =
static_cast< PLBOOL >(val4);
25028 plsvect((
double const *)arg1,(
double const *)arg2,arg3,arg4);
25029 _outv = octave_value();
25045 return octave_value_list();
25072 octave_value_list _out;
25073 octave_value_list *_outp=&_out;
25074 octave_value _outv;
25084 arg1 =
static_cast< PLFLT >(val1);
25089 arg2 =
static_cast< PLFLT >(val2);
25094 arg3 =
static_cast< PLFLT >(val3);
25099 arg4 =
static_cast< PLFLT >(val4);
25100 plsvpa(arg1,arg2,arg3,arg4);
25101 _outv = octave_value();
25105 return octave_value_list();
25120 octave_value_list _out;
25121 octave_value_list *_outp=&_out;
25122 octave_value _outv;
25132 arg1 =
static_cast< PLINT >(val1);
25137 arg2 =
static_cast< PLINT >(val2);
25139 _outv = octave_value();
25143 return octave_value_list();
25158 octave_value_list _out;
25159 octave_value_list *_outp=&_out;
25160 octave_value _outv;
25170 arg1 =
static_cast< PLINT >(val1);
25175 arg2 =
static_cast< PLINT >(val2);
25177 _outv = octave_value();
25181 return octave_value_list();
25198 octave_value_list _out;
25199 octave_value_list *_outp=&_out;
25200 octave_value _outv;
25207 if (
_n_dims( args(0) ) > 1 )
25212 temp1 = args(0).matrix_value();
25213 arg2 = &temp1( 0, 0 );
25216 if (
_n_dims( args(1) ) > 1 )
25224 temp3 = args(1).matrix_value();
25225 arg3 = &temp3( 0, 0 );
25231 arg4 =
static_cast< PLINT >(val4);
25232 plsym(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
25233 _outv = octave_value();
25249 return octave_value_list();
25270 octave_value_list _out;
25271 octave_value_list *_outp=&_out;
25272 octave_value _outv;
25282 arg1 =
static_cast< PLINT >(val1);
25287 arg2 =
static_cast< PLINT >(val2);
25289 _outv = octave_value();
25293 return octave_value_list();
25302 octave_value_list _out;
25303 octave_value_list *_outp=&_out;
25304 octave_value _outv;
25311 _outv = octave_value();
25315 return octave_value_list();
25324 char *arg1 = (
char *) 0 ;
25328 octave_value_list _out;
25329 octave_value_list *_outp=&_out;
25330 octave_value _outv;
25340 arg1 =
reinterpret_cast< char *
>(buf1);
25342 _outv = octave_value();
25348 return octave_value_list();
25361 octave_value_list _out;
25362 octave_value_list *_outp=&_out;
25363 octave_value _outv;
25373 arg1 =
static_cast< PLFLT >(val1);
25375 _outv = octave_value();
25379 return octave_value_list();
25403 octave_value_list _out;
25404 octave_value_list *_outp=&_out;
25405 octave_value _outv;
25415 arg1 =
static_cast< PLFLT >(val1);
25420 arg2 =
static_cast< PLFLT >(val2);
25425 arg3 =
static_cast< PLFLT >(val3);
25430 arg4 =
static_cast< PLFLT >(val4);
25435 arg5 =
static_cast< PLFLT >(val5);
25436 plvpas(arg1,arg2,arg3,arg4,arg5);
25437 _outv = octave_value();
25441 return octave_value_list();
25462 octave_value_list _out;
25463 octave_value_list *_outp=&_out;
25464 octave_value _outv;
25474 arg1 =
static_cast< PLFLT >(val1);
25479 arg2 =
static_cast< PLFLT >(val2);
25484 arg3 =
static_cast< PLFLT >(val3);
25489 arg4 =
static_cast< PLFLT >(val4);
25490 plvpor(arg1,arg2,arg3,arg4);
25491 _outv = octave_value();
25495 return octave_value_list();
25504 octave_value_list _out;
25505 octave_value_list *_outp=&_out;
25506 octave_value _outv;
25513 _outv = octave_value();
25517 return octave_value_list();
25559 octave_value_list _out;
25560 octave_value_list *_outp=&_out;
25561 octave_value _outv;
25571 arg1 =
static_cast< PLFLT >(val1);
25576 arg2 =
static_cast< PLFLT >(val2);
25581 arg3 =
static_cast< PLFLT >(val3);
25586 arg4 =
static_cast< PLFLT >(val4);
25591 arg5 =
static_cast< PLFLT >(val5);
25596 arg6 =
static_cast< PLFLT >(val6);
25601 arg7 =
static_cast< PLFLT >(val7);
25606 arg8 =
static_cast< PLFLT >(val8);
25611 arg9 =
static_cast< PLFLT >(val9);
25616 arg10 =
static_cast< PLFLT >(val10);
25621 arg11 =
static_cast< PLFLT >(val11);
25622 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25623 _outv = octave_value();
25627 return octave_value_list();
25639 octave_value_list _out;
25640 octave_value_list *_outp=&_out;
25641 octave_value _outv;
25651 arg1 =
static_cast< PLFLT >(val1);
25653 _outv = octave_value();
25657 return octave_value_list();
25678 octave_value_list _out;
25679 octave_value_list *_outp=&_out;
25680 octave_value _outv;
25690 arg1 =
static_cast< PLFLT >(val1);
25695 arg2 =
static_cast< PLFLT >(val2);
25700 arg3 =
static_cast< PLFLT >(val3);
25705 arg4 =
static_cast< PLFLT >(val4);
25706 plwind(arg1,arg2,arg3,arg4);
25707 _outv = octave_value();
25711 return octave_value_list();
25726 octave_value_list _out;
25727 octave_value_list *_outp=&_out;
25728 octave_value _outv;
25739 arg1 =
static_cast< PLBOOL >(val1);
25741 _outv = octave_value();
25751 return octave_value_list();
25761 char *arg2 = (
char *) 0 ;
25777 octave_value_list _out;
25778 octave_value_list *_outp=&_out;
25779 octave_value _outv;
25786 octave_value obj = args(0);
25787 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25788 if ( !obj.isempty() )
25790 if ( !obj.is_empty() )
25793 if ( obj.is_function_handle() || obj.is_inline_function() )
25797 else if ( obj.is_string() )
25813 arg2 =
reinterpret_cast< char *
>(buf2);
25818 arg3 =
static_cast< PLFLT >(val3);
25823 arg4 =
static_cast< PLFLT >(val4);
25828 arg5 =
static_cast< PLFLT >(val5);
25833 arg6 =
static_cast< PLFLT >(val6);
25834 plmap(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6);
25835 _outv = octave_value();
25841 return octave_value_list();
25852 char *arg2 = (
char *) 0 ;
25871 octave_value_list _out;
25872 octave_value_list *_outp=&_out;
25873 octave_value _outv;
25880 octave_value obj = args(0);
25881 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25882 if ( !obj.isempty() )
25884 if ( !obj.is_empty() )
25887 if ( obj.is_function_handle() || obj.is_inline_function() )
25891 else if ( obj.is_string() )
25907 arg2 =
reinterpret_cast< char *
>(buf2);
25912 arg3 =
static_cast< PLFLT >(val3);
25917 arg4 =
static_cast< PLFLT >(val4);
25922 arg5 =
static_cast< PLFLT >(val5);
25927 arg6 =
static_cast< PLFLT >(val6);
25929 if (
_n_dims( args(6) ) > 1 )
25933 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25934 if ( !args(6).isempty() )
25936 if ( !args(6).is_empty() )
25940 temp7 = args(6).matrix_value();
25941 arg7 =
new PLINT[arg8];
25950 plmapline(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
25951 _outv = octave_value();
25963 return octave_value_list();
25977 char *arg2 = (
char *) 0 ;
25978 char *arg3 = (
char *) 0 ;
26000 octave_value_list _out;
26001 octave_value_list *_outp=&_out;
26002 octave_value _outv;
26009 octave_value obj = args(0);
26010 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26011 if ( !obj.isempty() )
26013 if ( !obj.is_empty() )
26016 if ( obj.is_function_handle() || obj.is_inline_function() )
26020 else if ( obj.is_string() )
26036 arg2 =
reinterpret_cast< char *
>(buf2);
26041 arg3 =
reinterpret_cast< char *
>(buf3);
26046 arg4 =
static_cast< PLFLT >(val4);
26051 arg5 =
static_cast< PLFLT >(val5);
26056 arg6 =
static_cast< PLFLT >(val6);
26061 arg7 =
static_cast< PLFLT >(val7);
26063 if (
_n_dims( args(7) ) > 1 )
26067 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26068 if ( !args(7).isempty() )
26070 if ( !args(7).is_empty() )
26074 temp8 = args(7).matrix_value();
26075 arg8 =
new PLINT[arg9];
26084 plmapstring(arg1,(
char const *)arg2,(
char const *)arg3,arg4,arg5,arg6,arg7,(
int const *)arg8,arg9);
26085 _outv = octave_value();
26099 return octave_value_list();
26114 char *arg2 = (
char *) 0 ;
26118 char *arg6 = (
char *) 0 ;
26146 octave_value_list _out;
26147 octave_value_list *_outp=&_out;
26148 octave_value _outv;
26155 octave_value obj = args(0);
26156 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26157 if ( !obj.isempty() )
26159 if ( !obj.is_empty() )
26162 if ( obj.is_function_handle() || obj.is_inline_function() )
26166 else if ( obj.is_string() )
26182 arg2 =
reinterpret_cast< char *
>(buf2);
26187 arg3 =
static_cast< PLFLT >(val3);
26192 arg4 =
static_cast< PLFLT >(val4);
26197 arg5 =
static_cast< PLFLT >(val5);
26202 arg6 =
reinterpret_cast< char *
>(buf6);
26207 arg7 =
static_cast< PLFLT >(val7);
26212 arg8 =
static_cast< PLFLT >(val8);
26217 arg9 =
static_cast< PLFLT >(val9);
26222 arg10 =
static_cast< PLFLT >(val10);
26227 arg11 =
static_cast< PLINT >(val11);
26228 plmaptex(arg1,(
char const *)arg2,arg3,arg4,arg5,(
char const *)arg6,arg7,arg8,arg9,arg10,arg11);
26229 _outv = octave_value();
26237 return octave_value_list();
26249 char *arg2 = (
char *) 0 ;
26268 octave_value_list _out;
26269 octave_value_list *_outp=&_out;
26270 octave_value _outv;
26277 octave_value obj = args(0);
26278 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26279 if ( !obj.isempty() )
26281 if ( !obj.is_empty() )
26284 if ( obj.is_function_handle() || obj.is_inline_function() )
26288 else if ( obj.is_string() )
26304 arg2 =
reinterpret_cast< char *
>(buf2);
26309 arg3 =
static_cast< PLFLT >(val3);
26314 arg4 =
static_cast< PLFLT >(val4);
26319 arg5 =
static_cast< PLFLT >(val5);
26324 arg6 =
static_cast< PLFLT >(val6);
26326 if (
_n_dims( args(6) ) > 1 )
26330 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26331 if ( !args(6).isempty() )
26333 if ( !args(6).is_empty() )
26337 temp7 = args(6).matrix_value();
26338 arg7 =
new PLINT[arg8];
26347 plmapfill(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
26348 _outv = octave_value();
26360 return octave_value_list();
26392 octave_value_list _out;
26393 octave_value_list *_outp=&_out;
26394 octave_value _outv;
26401 octave_value obj = args(0);
26402 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26403 if ( !obj.isempty() )
26405 if ( !obj.is_empty() )
26408 if ( obj.is_function_handle() || obj.is_inline_function() )
26412 else if ( obj.is_string() )
26428 arg2 =
static_cast< PLFLT >(val2);
26433 arg3 =
static_cast< PLFLT >(val3);
26438 arg4 =
static_cast< PLFLT >(val4);
26443 arg5 =
static_cast< PLFLT >(val5);
26448 arg6 =
static_cast< PLFLT >(val6);
26453 arg7 =
static_cast< PLFLT >(val7);
26455 _outv = octave_value();
26459 return octave_value_list();
26468 octave_value_list _out;
26469 octave_value_list *_outp=&_out;
26470 octave_value _outv;
26477 _outv = octave_value();
26481 return octave_value_list();
26490 octave_value_list _out;
26491 octave_value_list *_outp=&_out;
26492 octave_value _outv;
26499 _outv = octave_value();
26503 return octave_value_list();
26512 char *arg1 = (
char *) 0 ;
26513 char *arg2 = (
char *) 0 ;
26520 octave_value_list _out;
26521 octave_value_list *_outp=&_out;
26522 octave_value _outv;
26532 arg1 =
reinterpret_cast< char *
>(buf1);
26537 arg2 =
reinterpret_cast< char *
>(buf2);
26538 plSetUsage((
char const *)arg1,(
char const *)arg2);
26539 _outv = octave_value();
26547 return octave_value_list();
26558 octave_value_list _out;
26559 octave_value_list *_outp=&_out;
26560 octave_value _outv;
26567 _outv = octave_value();
26571 return octave_value_list();
26581 {
"testppchar",_wrap_testppchar,0,0,2,0},
26583 {
"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
26586 {
"plcont0",_wrap_plcont0,0,0,2,0},
26587 {
"plcont1",_wrap_plcont1,0,0,2,0},
26588 {
"plcont2",_wrap_plcont2,0,0,2,0},
26589 {
"plcont2p",_wrap_plcont2p,0,0,2,0},
26599 {
"plshade1",_wrap_plshade1,0,0,2,0},
26600 {
"plshade2",_wrap_plshade2,0,0,2,0},
26602 {
"plshadesx",_wrap_plshadesx,0,0,2,0},
26603 {
"plshades1",_wrap_plshades1,0,0,2,0},
26604 {
"plshades2",_wrap_plshades2,0,0,2,0},
26606 {
"plvect1",_wrap_plvect1,0,0,2,0},
26607 {
"plvect2",_wrap_plvect2,0,0,2,0},
26608 {
"pplimage",_wrap_pplimage,0,0,2,0},
26610 {
"plimagefrx",_wrap_plimagefrx,0,0,2,0},
26611 {
"plimagefr1",_wrap_plimagefr1,0,0,2,0},
26612 {
"plimagefr2",_wrap_plimagefr2,0,0,2,0},
26898 #define SWIGRUNTIME_DEBUG
26921 if (!module_head) {
26934 }
while (iter!= module_head);
26945 if (init == 0)
return;
26948 #ifdef SWIGRUNTIME_DEBUG
26949 printf(
"SWIG_InitializeModule: size %lu\n", (
unsigned long)
swig_module.
size);
26956 #ifdef SWIGRUNTIME_DEBUG
26966 #ifdef SWIGRUNTIME_DEBUG
26967 printf(
"SWIG_InitializeModule: found type %s\n", type->
name);
26971 #ifdef SWIGRUNTIME_DEBUG
26972 printf(
"SWIG_InitializeModule: found and overwrite type %s \n", type->
name);
26981 while (
cast->type) {
26985 #ifdef SWIGRUNTIME_DEBUG
26986 printf(
"SWIG_InitializeModule: look cast %s\n",
cast->type->name);
26990 #ifdef SWIGRUNTIME_DEBUG
26991 if (ret) printf(
"SWIG_InitializeModule: found cast %s\n", ret->
name);
26996 #ifdef SWIGRUNTIME_DEBUG
26997 printf(
"SWIG_InitializeModule: skip old type %s\n", ret->
name);
27004 #ifdef SWIGRUNTIME_DEBUG
27005 if (ocast) printf(
"SWIG_InitializeModule: skip old cast %s\n", ret->
name);
27007 if (!ocast) ret = 0;
27012 #ifdef SWIGRUNTIME_DEBUG
27013 printf(
"SWIG_InitializeModule: adding cast %s\n",
cast->type->name);
27028 #ifdef SWIGRUNTIME_DEBUG
27029 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
27034 while (
cast->type) {
27035 printf(
"SWIG_InitializeModule: cast type %s\n",
cast->type->name);
27039 printf(
"---- Total casts: %d\n",j);
27041 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
27054 static int init_run = 0;
27056 if (init_run)
return;
27067 equiv = equiv->
next;
27087 #if SWIG_OCTAVE_PREREQ(4,2,0)
27088 octave::unwind_protect frame;
27089 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27090 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27091 #elif SWIG_OCTAVE_PREREQ(3,3,50)
27092 unwind_protect frame;
27093 frame.protect_var(error_state); error_state = 0;
27094 frame.protect_var(warning_state); warning_state = 0;
27095 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27096 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27098 unwind_protect::begin_frame(
"SWIG_Octave_LoadModule");
27099 unwind_protect_int(error_state); error_state = 0;
27100 unwind_protect_int(warning_state); warning_state = 0;
27101 unwind_protect_bool(discard_error_messages); discard_error_messages =
true;
27102 unwind_protect_bool(discard_warning_messages); discard_warning_messages =
true;
27104 #if SWIG_OCTAVE_PREREQ(4,2,0)
27106 #if SWIG_OCTAVE_PREREQ(4,4,0)
27107 octave::feval(
name, octave_value_list(), 0);
27109 feval(
name, octave_value_list(), 0);
27112 }
catch (octave::execution_exception&) { }
27114 feval(
name, octave_value_list(), 0);
27115 retn = (error_state == 0);
27117 #if !SWIG_OCTAVE_PREREQ(3,3,50)
27118 unwind_protect::run_frame(
"SWIG_Octave_LoadModule");
27130 #if SWIG_OCTAVE_PREREQ(4,2,0)
27131 octave::unwind_protect frame;
27132 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27133 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27134 #elif SWIG_OCTAVE_PREREQ(3,3,50)
27135 unwind_protect frame;
27136 frame.protect_var(error_state); error_state = 0;
27137 frame.protect_var(warning_state); warning_state = 0;
27138 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27139 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27141 unwind_protect::begin_frame(
"SWIG_Octave_InstallFunction");
27142 unwind_protect_int(error_state); error_state = 0;
27143 unwind_protect_int(warning_state); warning_state = 0;
27144 unwind_protect_bool(discard_error_messages); discard_error_messages =
true;
27145 unwind_protect_bool(discard_warning_messages); discard_warning_messages =
true;
27147 octave_value_list args;
27149 args.append(octloadfcn->fcn_file_name());
27150 #if SWIG_OCTAVE_PREREQ(4,2,0)
27152 #if SWIG_OCTAVE_PREREQ(4,4,0)
27153 octave::feval(
"autoload", args, 0);
27155 feval(
"autoload", args, 0);
27158 }
catch (octave::execution_exception&) { }
27160 feval(
"autoload", args, 0);
27161 retn = (error_state == 0);
27163 #if !SWIG_OCTAVE_PREREQ(3,3,50)
27164 unwind_protect::run_frame(
"SWIG_Octave_InstallFunction");
27174 @deftypefn {Loadable Function} {} subclass()\n\
27175 @deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
27176 Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
27178 See the SWIG manual for usage examples.\n\
27183 for (
int j = 0; j < args.length(); ++j) {
27184 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
27188 error(
"subclass: cannot subclass object not constructed on octave side");
27189 return octave_value_list();
27192 }
else if (args(j).is_function_handle()) {
27193 top->
assign(args(j).fcn_handle_value()->fcn_name(), args(j));
27195 if (j + 1 >= args.length()) {
27196 error(
"subclass: member assignments must be of string,value form");
27197 return octave_value_list();
27202 error(
"subclass: invalid arguments to subclass()");
27203 return octave_value_list();
27210 @deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
27211 Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
27215 if (args.length() != 1) {
27216 error(
"swig_type: must be called with only a single object");
27217 return octave_value_list();
27221 error(
"swig_type: object is not a swig_ref");
27222 return octave_value_list();
27228 @deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
27229 Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
27230 otherwise return `<unknown>'.\n\
27234 if (args.length() != 1 || !args(0).
is_string()) {
27235 error(
"swig_typequery: must be called with single string argument");
27236 return octave_value_list();
27241 return octave_value(
"<unknown>");
27242 return octave_value(type->
name);
27246 @deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
27247 Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
27251 if (args.length() != 1) {
27252 error(
"swig_this: must be called with only a single object");
27253 return octave_value_list();
27255 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
27256 return octave_value(octave_uint64(0));
27259 error(
"swig_this: object is not a swig_ref");
27260 return octave_value_list();
27262 return octave_value(octave_uint64((
unsigned long long) ost->
swig_this()));
27266 @deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
27267 Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
27271 if (args.length() != 3) {
27272 error(
"swig_octave_prereq: must be called with 3 arguments");
27273 return octave_value_list();
27275 const int major = args(0).int_value();
27276 const int minor = args(1).int_value();
27277 const int patch = args(2).int_value();
27279 return octave_value(prereq);
27283 @deftypefn {Loadable Function} {} swig_exit([@var{exit_status}])\n\
27284 Exit Octave without performing any memory cleanup.\n\
27288 if (args.length() > 1) {
27289 error(
"swig_exit: must be called with at most one arguments");
27290 return octave_value_list();
27292 int exit_status = 0;
27293 if (args.length() == 1) {
27294 exit_status = args(0).int_value();
27296 ::_Exit(exit_status);
27297 return octave_value();
27301 @deftypefn {Loadable Module} {} " SWIG_name_d "\n\
27302 Loads the SWIG-generated module `" SWIG_name_d "'.\n\
27315 #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
27316 #if !SWIG_OCTAVE_PREREQ(4,4,0)
27317 #if SWIG_OCTAVE_PREREQ(3,2,0)
27318 octave_exit = ::_Exit;
27324 if (args.length() != 0 || nargout != 0) {
27326 return octave_value_list();
27334 #if SWIG_OCTAVE_PREREQ(3,2,0)
27335 octave_value_list eval_args;
27336 eval_args.append(
"base");
27337 eval_args.append(
"function __swig_atexit__; "
27344 "__swig_atexit__; "
27345 "atexit(\"__swig_atexit__\", false); "
27346 "atexit(\"__swig_atexit__\")");
27347 #if SWIG_OCTAVE_PREREQ(4,4,0)
27348 octave::feval(
"evalin", eval_args, 0);
27350 feval(
"evalin", eval_args, 0);
27354 #if SWIG_OCTAVE_PREREQ(4,4,0)
27356 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
27357 string_vector
types = typeinfo.installed_type_names();
27358 bool register_octave_swig_ref =
true;
27359 bool register_octave_swig_packed =
true;
27360 for (
int i = 0; i <
types.numel(); ++i) {
27361 if (
types(i) == octave_swig_ref::static_type_name()) {
27362 register_octave_swig_ref =
false;
27364 if (
types(i) == octave_swig_packed::static_type_name()) {
27365 register_octave_swig_packed =
false;
27368 if (register_octave_swig_ref) {
27369 octave_swig_ref::register_type();
27371 if (register_octave_swig_packed) {
27372 octave_swig_packed::register_type();
27376 octave_swig_ref::register_type();
27377 octave_swig_packed::register_type();
27382 #if SWIG_OCTAVE_PREREQ(4,4,0)
27383 octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
27384 octave_function *me = stack.current();
27386 octave_function *me = octave_call_stack::current();
27390 return octave_value_list();
27393 return octave_value_list();
27396 return octave_value_list();
27399 return octave_value_list();
27402 return octave_value_list();
27405 return octave_value_list();
27443 return octave_value_list();
27450 if (mb->second.first && mb->second.first->method) {
27452 return octave_value_list();
27457 #if SWIG_OCTAVE_PREREQ(4,4,0)
27458 octave::interpreter::the_interpreter()->mlock();
27459 #elif SWIG_OCTAVE_PREREQ(3,2,0)
27469 if (mb->second.second.is_defined()) {
27478 return octave_value_list();