16 #define SWIG_name_d "plplot_octave"
17 #define SWIG_name plplot_octave
19 #define SWIG_global_name "cvar"
20 #define SWIG_op_prefix "op_"
25 template<
typename T>
class SwigValueWrapper {
26 struct SwigMovePointer {
28 SwigMovePointer(T *p) : ptr(p) { }
29 ~SwigMovePointer() {
delete ptr; }
30 SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0;
delete oldptr; ptr = rhs.ptr; rhs.ptr = 0;
return *
this; }
32 SwigValueWrapper& operator=(
const SwigValueWrapper<T>& rhs);
33 SwigValueWrapper(
const SwigValueWrapper<T>& rhs);
35 SwigValueWrapper() : pointer(0) { }
36 SwigValueWrapper& operator=(
const T& t) { SwigMovePointer tmp(
new T(t)); pointer = tmp;
return *
this; }
37 operator T&()
const {
return *pointer.ptr; }
38 T *operator&() {
return pointer.ptr; }
41 template <
typename T> T SwigValueInit() {
52 #ifndef SWIGTEMPLATEDISAMBIGUATOR
53 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
54 # define SWIGTEMPLATEDISAMBIGUATOR template
55 # elif defined(__HP_aCC)
58 # define SWIGTEMPLATEDISAMBIGUATOR template
60 # define SWIGTEMPLATEDISAMBIGUATOR
66 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
67 # define SWIGINLINE inline
75 # if defined(__GNUC__)
76 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
77 # define SWIGUNUSED __attribute__ ((__unused__))
82 # define SWIGUNUSED __attribute__ ((__unused__))
88 #ifndef SWIG_MSC_UNSUPPRESS_4505
89 # if defined(_MSC_VER)
90 # pragma warning(disable : 4505)
94 #ifndef SWIGUNUSEDPARM
96 # define SWIGUNUSEDPARM(p)
98 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
104 # define SWIGINTERN static SWIGUNUSED
108 #ifndef SWIGINTERNINLINE
109 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
113 #if defined(__GNUC__)
114 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
115 # ifndef GCC_HASCLASSVISIBILITY
116 # define GCC_HASCLASSVISIBILITY
122 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
123 # if defined(STATIC_LINKED)
126 # define SWIGEXPORT __declspec(dllexport)
129 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
130 # define SWIGEXPORT __attribute__ ((visibility("default")))
139 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
140 # define SWIGSTDCALL __stdcall
147 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
148 # define _CRT_SECURE_NO_DEPRECATE
152 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
153 # define _SCL_SECURE_NO_DEPRECATE
157 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
158 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
166 #ifdef __INTEL_COMPILER
167 # pragma warning disable 592
175 #include <octave/oct.h>
176 #include <octave/version.h>
180 #define SWIG_OCTAVE_PREREQ(major, minor, patch) \
181 ( (OCTAVE_MAJOR_VERSION<<16) + (OCTAVE_MINOR_VERSION<<8) + (OCTAVE_PATCH_VERSION + 0) >= ((major)<<16) + ((minor)<<8) + (patch) )
184 #if !defined(OCTAVE_MAJOR_VERSION)
186 # if !defined(OCTAVE_API_VERSION_NUMBER)
190 # include <octave/ov.h>
191 # if defined(octave_ov_h)
192 # define OCTAVE_MAJOR_VERSION 3
193 # define OCTAVE_MINOR_VERSION 8
194 # define OCTAVE_PATCH_VERSION 0
198 # define ComplexLU __ignore
199 # include <octave/CmplxLU.h>
201 # if defined(octave_Complex_LU_h)
204 # define OCTAVE_MAJOR_VERSION 3
205 # define OCTAVE_MINOR_VERSION 1
206 # define OCTAVE_PATCH_VERSION 99
211 # define OCTAVE_MAJOR_VERSION 3
212 # define OCTAVE_MINOR_VERSION 2
213 # define OCTAVE_PATCH_VERSION 0
215 # endif // defined(octave_Complex_LU_h)
217 # endif // defined(octave_ov_h)
221 # elif OCTAVE_API_VERSION_NUMBER >= 48
222 # define OCTAVE_MAJOR_VERSION 3
223 # define OCTAVE_MINOR_VERSION 6
224 # define OCTAVE_PATCH_VERSION 0
226 # elif OCTAVE_API_VERSION_NUMBER >= 45
227 # define OCTAVE_MAJOR_VERSION 3
228 # define OCTAVE_MINOR_VERSION 4
229 # define OCTAVE_PATCH_VERSION 1
231 # elif OCTAVE_API_VERSION_NUMBER >= 42
232 # define OCTAVE_MAJOR_VERSION 3
233 # define OCTAVE_MINOR_VERSION 3
234 # define OCTAVE_PATCH_VERSION 54
236 # elif OCTAVE_API_VERSION_NUMBER >= 41
237 # define OCTAVE_MAJOR_VERSION 3
238 # define OCTAVE_MINOR_VERSION 3
239 # define OCTAVE_PATCH_VERSION 53
241 # elif OCTAVE_API_VERSION_NUMBER >= 40
242 # define OCTAVE_MAJOR_VERSION 3
243 # define OCTAVE_MINOR_VERSION 3
244 # define OCTAVE_PATCH_VERSION 52
246 # elif OCTAVE_API_VERSION_NUMBER >= 39
247 # define OCTAVE_MAJOR_VERSION 3
248 # define OCTAVE_MINOR_VERSION 3
249 # define OCTAVE_PATCH_VERSION 51
251 # else // OCTAVE_API_VERSION_NUMBER == 38
252 # define OCTAVE_MAJOR_VERSION 3
253 # define OCTAVE_MINOR_VERSION 3
254 # define OCTAVE_PATCH_VERSION 50
256 # endif // !defined(OCTAVE_API_VERSION_NUMBER)
258 #endif // !defined(OCTAVE_MAJOR_VERSION)
260 #include <octave/Cell.h>
261 #include <octave/dynamic-ld.h>
262 #include <octave/oct-env.h>
263 #include <octave/oct-map.h>
264 #include <octave/ov-scalar.h>
265 #include <octave/ov-fcn-handle.h>
266 #include <octave/parse.h>
267 #if SWIG_OCTAVE_PREREQ(4,2,0)
268 #include <octave/interpreter.h>
270 #include <octave/toplev.h>
272 #include <octave/unwind-prot.h>
273 #if SWIG_OCTAVE_PREREQ(4,2,0)
274 #include <octave/call-stack.h>
287 #define SWIG_RUNTIME_VERSION "4"
290 #ifdef SWIG_TYPE_TABLE
291 # define SWIG_QUOTE_STRING(x) #x
292 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
293 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
295 # define SWIG_TYPE_TABLE_NAME
308 # define SWIGRUNTIME SWIGINTERN
311 #ifndef SWIGRUNTIMEINLINE
312 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
316 #ifndef SWIG_BUFFER_SIZE
317 # define SWIG_BUFFER_SIZE 1024
321 #define SWIG_POINTER_DISOWN 0x1
322 #define SWIG_CAST_NEW_MEMORY 0x2
323 #define SWIG_POINTER_NO_NULL 0x4
326 #define SWIG_POINTER_OWN 0x1
409 #define SWIG_ERROR (-1)
410 #define SWIG_IsOK(r) (r >= 0)
411 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
414 #define SWIG_CASTRANKLIMIT (1 << 8)
416 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
418 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
420 #define SWIG_BADOBJ (SWIG_ERROR)
421 #define SWIG_OLDOBJ (SWIG_OK)
422 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
423 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
425 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
426 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
427 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
428 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
429 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
430 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
433 #if defined(SWIG_CASTRANK_MODE)
434 # ifndef SWIG_TypeRank
435 # define SWIG_TypeRank unsigned long
437 # ifndef SWIG_MAXCASTRANK
438 # define SWIG_MAXCASTRANK (2)
440 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
441 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
446 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
449 # define SWIG_AddCast(r) (r)
450 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
460 typedef void *(*swig_converter_func)(
void *,
int *);
502 const char *f2,
const char *l2) {
503 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
504 while ((*f1 ==
' ') && (f1 != l1)) ++f1;
505 while ((*f2 ==
' ') && (f2 != l2)) ++f2;
506 if (*f1 != *f2)
return (*f1 > *f2) ? 1 : -1;
508 return (
int)((l1 - f1) - (l2 - f2));
518 const char* te = tb + strlen(tb);
520 while (equiv != 0 && *ne) {
521 for (nb = ne; *ne; ++ne) {
522 if (*ne ==
'|')
break;
547 if (strcmp(iter->
type->
name, c) == 0) {
548 if (iter == ty->
cast)
574 if (iter->
type == from) {
575 if (iter == ty->
cast)
607 if (!ty || !ty->
dcast)
return ty;
608 while (ty && (ty->
dcast)) {
609 ty = (*ty->
dcast)(ptr);
633 if (!type)
return NULL;
634 if (type->
str != NULL) {
635 const char *last_name = type->
str;
637 for (s = type->
str; *s; s++)
638 if (*s ==
'|') last_name = s+1;
686 size_t r = iter->
size - 1;
689 size_t i = (l + r) >> 1;
690 const char *iname = iter->
types[i]->
name;
692 int compare = strcmp(
name, iname);
694 return iter->
types[i];
695 }
else if (compare < 0) {
701 }
else if (compare > 0) {
710 }
while (iter != end);
737 for (; i < iter->
size; ++i) {
739 return iter->
types[i];
742 }
while (iter != end);
754 static const char hex[17] =
"0123456789abcdef";
755 const unsigned char *u = (
unsigned char *) ptr;
756 const unsigned char *eu = u + sz;
757 for (; u != eu; ++u) {
758 unsigned char uu = *u;
759 *(c++) = hex[(uu & 0xf0) >> 4];
760 *(c++) = hex[uu & 0xf];
770 unsigned char *u = (
unsigned char *) ptr;
771 const unsigned char *eu = u + sz;
772 for (; u != eu; ++u) {
775 if ((d >=
'0') && (d <=
'9'))
776 uu = (
unsigned char)((d -
'0') << 4);
777 else if ((d >=
'a') && (d <=
'f'))
778 uu = (
unsigned char)((d - (
'a'-10)) << 4);
782 if ((d >=
'0') && (d <=
'9'))
783 uu |= (
unsigned char)(d -
'0');
784 else if ((d >=
'a') && (d <=
'f'))
785 uu |= (
unsigned char)(d - (
'a'-10));
799 if ((2*
sizeof(
void *) + 2) > bsz)
return 0;
802 if (strlen(
name) + 1 > (bsz - (r - buff)))
return 0;
810 if (strcmp(c,
"NULL") == 0) {
823 size_t lname = (
name ? strlen(
name) : 0);
824 if ((2*sz + 2 + lname) > bsz)
return 0;
828 strncpy(r,
name,lname+1);
838 if (strcmp(c,
"NULL") == 0) {
853 #define SWIG_UnknownError -1
854 #define SWIG_IOError -2
855 #define SWIG_RuntimeError -3
856 #define SWIG_IndexError -4
857 #define SWIG_TypeError -5
858 #define SWIG_DivisionByZero -6
859 #define SWIG_OverflowError -7
860 #define SWIG_SyntaxError -8
861 #define SWIG_ValueError -9
862 #define SWIG_SystemError -10
863 #define SWIG_AttributeError -11
864 #define SWIG_MemoryError -12
865 #define SWIG_NullReferenceError -13
869 #if !SWIG_OCTAVE_PREREQ(3,2,0)
870 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
872 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
876 if (num_args > max_args && !varargs)
877 error(
"function %s takes at most %i arguments", func_name, max_args);
878 else if (num_args < min_args)
879 error(
"function %s requires at least %i arguments", func_name, min_args);
893 return "SWIG_MemoryError";
895 return "SWIG_IOError";
897 return "SWIG_RuntimeError";
899 return "SWIG_IndexError";
901 return "SWIG_TypeError";
903 return "SWIG_DivisionByZero";
905 return "SWIG_OverflowError";
907 return "SWIG_SyntaxError";
909 return "SWIG_ValueError";
911 return "SWIG_SystemError";
913 return "SWIG_AttributeError";
915 return "SWIG unknown error";
921 r +=
" (" + type.string_value() +
")";
922 error(
"%s", r.c_str());
923 return octave_value(r);
926 #define SWIG_fail goto fail
928 #define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
929 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
930 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
931 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
932 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
933 #define swig_owntype int
935 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
936 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
938 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
939 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
941 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
942 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
944 #define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
945 #define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
946 #define SWIG_MODULE_CLIENTDATA_TYPE void*
948 #define Octave_Error_Occurred() 0
949 #define SWIG_Octave_AddErrorMsg(msg) {;}
955 #define SWIG_POINTER_EXCEPTION 0
956 #define SWIG_arg_fail(arg) 0
964 typedef octave_value_list(*
octave_func) (
const octave_value_list &, int);
969 #ifdef SWIG_DIRECTORS
973 typedef std::map < void *, Director * > rtdir_map;
990 #ifdef SWIG_DIRECTORS
991 SWIGRUNTIME void swig_acquire_ownership(
void *vptr);
992 SWIGRUNTIME void swig_acquire_ownership_array(
void *vptr);
993 SWIGRUNTIME void swig_acquire_ownership_obj(
void *vptr,
int own);
1022 #if SWIG_OCTAVE_PREREQ(4,4,0)
1025 #define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(new octave_swig_bound_func(func, args))
1026 class octave_swig_bound_func :
public octave_function {
1029 octave_swig_bound_func(
void) : octave_function(), method(0), first_args()
1032 octave_swig_bound_func(octave_function* _method, octave_value_list _first_args)
1033 : octave_function(
"",
""), method(_method), first_args(_first_args)
1036 octave_swig_bound_func(
const octave_swig_bound_func& f) =
delete;
1038 octave_swig_bound_func& operator= (
const octave_swig_bound_func& f) =
delete;
1040 ~octave_swig_bound_func(
void) =
default;
1042 bool is_function(
void)
const {
return true; }
1044 octave_function* function_value(
bool =
false) {
return this; }
1046 octave_value_list call(octave::tree_evaluator& tw,
int nargout = 0,
const octave_value_list& args = octave_value_list()) {
1047 octave_value_list all_args;
1048 all_args.append(first_args);
1049 all_args.append(args);
1050 return method->call(tw, nargout, all_args);
1053 octave_value subsref(
const std::string &ops,
const std::list < octave_value_list > &idx) {
1054 octave_value_list ovl = subsref(ops, idx, 1);
1055 return ovl.length() ? ovl(0) : octave_value();
1058 octave_value_list subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout) {
1059 assert(ops.size() > 0);
1060 assert(ops.size() == idx.size());
1062 error(
"invalid function call");
1063 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1064 return call(tw, nargout, *idx.begin());
1069 octave_function* method;
1070 octave_value_list first_args;
1072 std::set<std::string> dispatch_classes;
1076 DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
1080 #define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(func)
1115 if (m->name ==
name)
1137 for (
unsigned int j = 0; j <
types.size(); ++j)
1139 return &
members.insert(std::make_pair(
name, std::make_pair(m, octave_value()))).first->second;
1140 if (!insert_if_not_found)
1147 for (
unsigned int j = 0; j <
types.size(); ++j) {
1148 assert(
types[j].first->clientdata);
1151 return types[j].first;
1176 if (out.find(m->name) == out.end())
1177 out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1197 for (
unsigned int j = 0; j <
types.size(); ++j)
1198 if (
types[j].first->clientdata)
1203 if (m->second.is_defined())
1204 return m->second.subsref(
"(", std::list < octave_value_list > (1, args), nargout);
1205 else if (m->first && m->first->method)
1206 return m->first->method(args, nargout);
1207 error(
"member not defined or not invocable");
1208 return octave_value_list();
1214 if (!m || m->first->is_static() || m->first->is_global())
1216 octave_value_list args;
1218 octave_value_list argout(nc_this->
member_invoke(m, args, 1));
1219 if (argout.length() < 1)
1225 bool dispatch_binary_op(
const std::string &symbol,
const octave_base_value &rhs, octave_value &ret)
const {
1228 if (!m || m->first->is_static() || m->first->is_global())
1230 octave_value_list args;
1233 octave_value_list argout(nc_this->
member_invoke(m, args, 1));
1234 if (argout.length() < 1)
1240 bool dispatch_index_op(
const std::string &symbol,
const octave_value_list &rhs, octave_value_list &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 if (m->second.is_defined()) {
1256 if (m->second.is_function() || m->second.is_function_handle()) {
1261 }
else if (m->first) {
1262 if (m->first->get_method)
1263 return m->first->get_method(args, 1);
1264 else if (m->first->method)
1267 error(
"undefined member");
1268 return octave_value_list();
1273 return octave_value((octave_base_value *) &x);
1281 bool _always_static =
false)
1285 types.push_back(std::make_pair(_type, _ptr));
1286 #ifdef SWIG_DIRECTORS
1288 Swig::Director *d = Swig::get_rtdir(_ptr);
1290 Swig::swig_director_set_self(d,
this);
1298 for (
unsigned int j = 0; j <
types.size(); ++j) {
1299 if (!
types[j].first || !
types[j].first->clientdata)
1307 #ifdef SWIG_DIRECTORS
1308 for (
unsigned int j = 0; j <
types.size(); ++j)
1309 Swig::erase_rtdir(
types[j].second.ptr);
1316 return dim_vector(1,1);
1319 #if SWIG_OCTAVE_PREREQ(4,4,0)
1322 if (out.is_cell()) {
1324 const Cell & c=out.cell_value();
1325 int ndim = c.rows();
1326 if (ndim==1 && c.columns()!=1) ndim = c.columns();
1329 d.resize(ndim < 2 ? 2 : ndim);
1333 for (
int k=0;k<ndim;k++) {
1334 const octave_value& obj = c(k);
1335 d.elem(k) = obj.int_value();
1338 if (error_state)
return dim_vector(1,1);
1341 #if SWIG_OCTAVE_PREREQ(4,4,0)
1342 }
else if (out.is_matrix_type() || out.isnumeric() ) {
1344 }
else if (out.is_matrix_type() || out.is_numeric_type() ) {
1346 if (out.rows()==1 || out.columns()==1) {
1347 Array<int> a = out.int_vector_value();
1348 if (error_state)
return dim_vector(1,1);
1350 d.resize(a.numel() < 2 ? 2 : a.numel());
1352 for (
int k=0;k<a.numel();k++) {
1357 return dim_vector(1,1);
1360 return dim_vector(1,1);
1381 return (
long)
types[0].second.ptr;
1386 if (!
types[0].first->clientdata)
1396 for (
unsigned int j = 0; j <
types.size(); ++j) {
1399 if (
types[j].first->clientdata) {
1403 ret +=
types[j].first->name;
1410 for (
unsigned int j = 0; j < rhs.
types.size(); ++j) {
1411 assert(!rhs.
types[j].second.destroyed);
1412 #ifdef SWIG_DIRECTORS
1413 Swig::Director *d = Swig::get_rtdir(rhs.
types[j].second.ptr);
1415 Swig::swig_director_set_self(d,
this);
1420 #if SWIG_OCTAVE_PREREQ(4,4,0)
1438 if (!type &&
types.size()) {
1440 *vptr =
types[0].second.ptr;
1443 for (
unsigned int j = 0; j <
types.size(); ++j)
1444 if (type ==
types[j].first) {
1446 *vptr =
types[j].second.ptr;
1449 for (
unsigned int j = 0; j <
types.size(); ++j) {
1472 #ifdef SWIG_DIRECTORS
1473 void director_destroyed(Swig::Director *d) {
1475 for (
unsigned int j = 0; j <
types.size(); ++j) {
1476 Swig::Director *dj = Swig::get_rtdir(
types[j].second.ptr);
1478 types[j].second.destroyed =
true;
1491 members[
name] = std::make_pair(m, octave_value());
1514 virtual octave_value
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx) {
1515 octave_value_list ovl =
subsref(ops, idx, 1);
1516 return ovl.length()? ovl(0) : octave_value();
1519 virtual octave_value_list
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout) {
1520 assert(ops.size() > 0);
1521 assert(ops.size() == idx.size());
1523 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1525 octave_value_list sub_ovl;
1532 error(
"cannot create instance");
1533 return octave_value_list();
1535 octave_value_list args;
1538 args.append(*idx_it++);
1543 else if (ops[skip] ==
'.') {
1544 std::string subname;
1547 octave_value_list subname_ovl(*idx_it++);
1549 assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1550 subname = subname_ovl(0).string_value();
1553 if (!next_base || skip >= (
int) ops.size() || ops[skip] !=
'.')
1559 if (!base || !(m->first =
find_member(base, subname)))
1562 error(
"member not found");
1563 return octave_value_list();
1566 octave_value_list args;
1568 (!m->first || (!m->first->is_static() && !m->first->is_global())))
1570 if (skip < (
int) ops.size() && ops[skip] ==
'(' &&
1571 ((m->first && m->first->method) || m->second.is_function() ||
1572 m->second.is_function_handle())) {
1573 args.append(*idx_it++);
1582 if (ops[skip] ==
'(' || ops[skip] ==
'{') {
1583 const char *op_name = ops[skip] ==
'(' ?
"__paren__" :
"__brace__";
1584 octave_value_list args;
1585 args.append(*idx_it++);
1588 error(
"error evaluating index operator");
1589 return octave_value_list();
1592 error(
"unsupported subsref");
1593 return octave_value_list();
1597 if (skip >= (
int) ops.size())
1599 if (sub_ovl.length() < 1) {
1600 error(
"bad subs ref");
1601 return octave_value_list();
1603 return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1606 octave_value
subsasgn(
const std::string &ops,
const std::list < octave_value_list > &idx,
const octave_value &rhs) {
1607 assert(ops.size() > 0);
1608 assert(ops.size() == idx.size());
1610 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1613 if (ops.size() > 1) {
1614 std::list < octave_value_list >::const_iterator last = idx.end();
1616 std::list < octave_value_list > next_idx(idx.begin(), last);
1617 octave_value next_ov =
subsref(ops.substr(0, ops.size() - 1), next_idx);
1618 next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1621 else if (ops[skip] ==
'(' || ops[skip] ==
'{') {
1622 const char *op_name = ops[skip] ==
'(' ?
"__paren_asgn__" :
"__brace_asgn__";
1625 octave_value_list args;
1627 args.append(*idx_it);
1631 error(
"%s member not found", op_name);
1634 else if (ops[skip] ==
'.') {
1635 octave_value_list subname_ovl(*idx_it++);
1637 assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1638 std::string subname = subname_ovl(0).string_value();
1641 if (!m->first || !m->first->set_method) {
1644 }
else if (m->first->set_method) {
1645 octave_value_list args;
1646 if (!m->first->is_static() && !m->first->is_global())
1649 m->first->set_method(args, 1);
1651 error(
"member not assignable");
1653 error(
"unsupported subsasgn");
1670 error(
"__str__ method not defined");
1671 return std::string();
1673 if (!ret.is_string()) {
1674 error(
"__str__ method did not return a string");
1675 return std::string();
1677 return ret.string_value();
1683 error(
"__float__ method not defined");
1685 return ret.scalar_value();
1688 #if SWIG_OCTAVE_PREREQ(4,2,0)
1689 virtual octave_value as_double(
void)
const {
1692 error(
"__float__ method not defined");
1694 return ret.as_double();
1697 virtual octave_value as_single(
void)
const {
1700 error(
"__float__ method not defined");
1702 return ret.as_single();
1706 #if SWIG_OCTAVE_PREREQ(3,8,0)
1707 virtual octave_value map(octave_base_value::unary_mapper_t umap)
const {
1708 const std::string opname = std::string(
"__") + octave_base_value::get_umap_name(umap) + std::string(
"__");
1711 error(
"%s", (opname + std::string(
" method not found")).c_str());
1712 return octave_value();
1718 #if SWIG_OCTAVE_PREREQ(3,3,52)
1720 return octave_map();
1724 return Octave_map();
1732 string_vector keys(tmp.size());
1734 for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1735 keys(k++) = it->first;
1753 oct_mach_info::float_format fmt) {
1757 #if defined (HAVE_HDF5)
1758 # if SWIG_OCTAVE_PREREQ(4,0,0)
1760 save_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool save_as_floats) {
1765 load_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool have_h5giterate_bug) {
1770 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats) {
1775 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug) {
1781 virtual octave_value
convert_to_str(
bool pad =
false,
bool force =
false,
char type =
'"')
const {
1789 static bool dispatch_global_op(
const std::string &symbol,
const octave_value_list &args, octave_value &ret) {
1793 octave_function *fcn = is_valid_function(symbol, std::string(),
false);
1796 #if SWIG_OCTAVE_PREREQ(4,4,0)
1797 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1798 octave_value_list retval = fcn->call(tw, 1, args);
1799 if (retval.length() == 1)
1802 ret = fcn->do_multi_index_op(1, args)(0);
1812 if (ost->
dispatch_unary_op(std::string(
"__") + op_name + std::string(
"__"), ret))
1815 octave_value_list args;
1820 error(
"could not dispatch unary operator");
1821 return octave_value();
1824 static octave_value
dispatch_binary_op(
const octave_base_value &lhs,
const octave_base_value &rhs,
const char *op_name) {
1829 if (lhs_ost && lhs_ost->
dispatch_binary_op(std::string(
"__") + op_name + std::string(
"__"), rhs, ret))
1832 if (strlen(op_name) == 2 && (op_name[1] ==
't' || op_name[1] ==
'e')) {
1833 if (op_name[0] ==
'l' && rhs_ost->
dispatch_binary_op(std::string(
"__g") + op_name[1] + std::string(
"__"), lhs, ret))
1835 if (op_name[0] ==
'g' && rhs_ost->
dispatch_binary_op(std::string(
"__l") + op_name[1] + std::string(
"__"), lhs, ret))
1838 if (rhs_ost->
dispatch_binary_op(std::string(
"__r") + op_name + std::string(
"__"), lhs, ret))
1843 octave_value_list args;
1874 error(
"could not dispatch binary operator");
1875 return octave_value();
1878 #if SWIG_OCTAVE_PREREQ(4,0,0)
1879 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
1881 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
1893 os <<
"{"; newline(os);
1894 increment_indent_level();
1895 for (
unsigned int j = 0; j <
types.size(); ++j) {
1897 if (
types[j].first->clientdata) {
1899 os << c->
name <<
", ptr = " <<
types[j].second.ptr; newline(os);
1901 os <<
types[j].first->name <<
", ptr = " <<
types[j].second.ptr; newline(os);
1904 for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
1906 if (it->second.first) {
1907 const char *objtype = it->second.first->method ?
"method" :
"variable";
1908 const char *modifier = (it->second.first->flags &1) ?
"static " : (it->second.first->flags &2) ?
"global " :
"";
1909 os << it->second.first->name <<
" (" << modifier << objtype <<
")"; newline(os);
1910 assert(it->second.first->name == it->first);
1912 os << it->first; newline(os);
1915 decrement_indent_level();
1917 os <<
"}"; newline(os);
1940 {
if (ptr) ptr->
decref(); }
1952 {
return ptr->
dims(); }
1958 {
return ptr->
is_map(); }
1960 virtual octave_value
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx)
1961 {
return ptr->
subsref(ops, idx); }
1963 virtual octave_value_list
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout)
1964 {
return ptr->
subsref(ops, idx, nargout); }
1966 octave_value
subsasgn(
const std::string &ops,
const std::list < octave_value_list > &idx,
const octave_value &rhs)
1967 {
return ptr->
subsasgn(ops, idx, rhs); }
1981 #if SWIG_OCTAVE_PREREQ(4,2,0)
1982 virtual octave_value as_double(
void)
const
1983 {
return ptr->as_double(); }
1985 virtual octave_value as_single(
void)
const
1986 {
return ptr->as_single(); }
1989 #if SWIG_OCTAVE_PREREQ(3,8,0)
1990 virtual octave_value map(octave_base_value::unary_mapper_t umap)
const
1991 {
return ptr->map(umap); }
1994 #if SWIG_OCTAVE_PREREQ(3,3,52)
2015 oct_mach_info::float_format fmt)
2018 #if defined (HAVE_HDF5)
2019 # if SWIG_OCTAVE_PREREQ(4,0,0)
2021 save_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool save_as_floats)
2022 {
return ptr->save_hdf5(loc_id,
name, save_as_floats); }
2025 load_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool have_h5giterate_bug)
2026 {
return ptr->load_hdf5(loc_id,
name, have_h5giterate_bug); }
2029 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats)
2030 {
return ptr->save_hdf5(loc_id,
name, save_as_floats); }
2033 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug)
2034 {
return ptr->load_hdf5(loc_id,
name, have_h5giterate_bug); }
2038 virtual octave_value
convert_to_str(
bool pad =
false,
bool force =
false,
char type =
'"')
const
2044 #if SWIG_OCTAVE_PREREQ(4,0,0)
2045 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
2047 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
2049 {
return ptr->
print(os, pr_as_read_syntax); }
2052 return octave_base_value::type_conv_info (default_numeric_conversion_function,
2053 octave_scalar::static_type_id ());
2062 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2067 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2078 : type(_type),
buf((const char*)_buf, (const char*)_buf + _buf_len) {
2082 if (outtype && outtype != type)
2084 assert(sz <=
buf.size());
2085 std::copy(
buf.begin(),
buf.begin()+sz, (
char*)ptr);
2101 #if SWIG_OCTAVE_PREREQ(4,0,0)
2102 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
2104 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
2108 os <<
"swig packed type: name = " << (type ? type->
name : std::string()) <<
", len = " <<
buf.size(); newline(os);
2125 oct_mach_info::float_format fmt) {
2129 #if defined (HAVE_HDF5)
2130 # if SWIG_OCTAVE_PREREQ(4,0,0)
2132 save_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool save_as_floats) {
2137 load_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool have_h5giterate_bug) {
2142 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats) {
2147 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug) {
2154 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2159 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2165 error(
"attempt to set immutable member variable");
2166 return octave_value_list();
2174 :ovl(_ovl), j(_j) { }
2176 operator octave_value()
const {
2199 && ov.rows() == 1 && ov.columns() == 1)
2200 ov = ov.cell_value()(0);
2205 if (ov.type_id() != octave_swig_ref::static_type_id())
2207 const octave_swig_ref *osr = static_cast < const octave_swig_ref *>(&ov);
2214 #define swig_unary_op(name) \
2215 SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
2216 return octave_swig_type::dispatch_unary_op(x,#name); \
2218 #define swig_binary_op(name) \
2219 SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
2220 return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
2222 #if SWIG_OCTAVE_PREREQ(4,4,0)
2223 #define swigreg_unary_op(name) \
2224 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2225 typeinfo.register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2227 #define swigreg_unary_op(name) \
2228 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2229 octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2231 #if SWIG_OCTAVE_PREREQ(4,4,0)
2232 #define swigreg_binary_op(name) \
2233 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2234 typeinfo.register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2236 #define swigreg_binary_op(name) \
2237 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2238 octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2255 #if !SWIG_OCTAVE_PREREQ(4,2,0)
2273 #if SWIG_OCTAVE_PREREQ(4,4,0)
2274 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2285 #if SWIG_OCTAVE_PREREQ(4,4,0)
2286 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2294 #if !SWIG_OCTAVE_PREREQ(4,2,0)
2318 for (
int j = 0; j < tid; ++j) {
2327 #ifdef SWIG_DIRECTORS
2328 Swig::Director *d = Swig::get_rtdir(ptr);
2329 if (d && Swig::swig_director_get_self(d))
2330 return Swig::swig_director_get_self(d)->as_value();
2342 && ov.rows() == 1 && ov.columns() == 1)
2343 ov = ov.cell_value()(0);
2344 if (!ov.is_defined() ||
2345 (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2350 if (ov.type_id() != octave_swig_ref::static_type_id())
2352 octave_swig_ref *osr = static_cast < octave_swig_ref *>(ov.internal_rep());
2354 return ost->
cast(ptr, type,
own, flags);
2362 if (!ov.is_defined())
2364 if (ov.type_id() != octave_swig_packed::static_type_id())
2375 #if SWIG_OCTAVE_PREREQ(4,4,0)
2376 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2377 return symtab.global_varval(
name);
2379 return get_global_value(
name,
true);
2384 #if SWIG_OCTAVE_PREREQ(4,4,0)
2385 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2393 #if SWIG_OCTAVE_PREREQ(4,4,0)
2394 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2395 octave::symbol_scope symscope = octave::interpreter::the_interpreter()->get_current_scope();
2396 symscope.assign(
name, symtab.global_varval(
name));
2397 symscope.mark_global(
name);
2399 #if !SWIG_OCTAVE_PREREQ(3,2,0)
2400 link_to_global_variable(curr_sym_tab->lookup(
name,
true));
2402 #if !SWIG_OCTAVE_PREREQ(3,8,0)
2403 symbol_table::varref(
name);
2405 symbol_table::mark_global(
name);
2412 if (!ov.is_defined() ||
2413 ov.type_id() != octave_swig_packed::static_type_id())
2416 static_cast < const octave_swig_packed *> (ov.internal_rep());
2429 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2431 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2437 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2438 #define SWIGTYPE_p_char swig_types[1]
2439 #define SWIGTYPE_p_double swig_types[2]
2440 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2441 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2442 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2443 #define SWIGTYPE_p_int swig_types[6]
2444 #define SWIGTYPE_p_p_char swig_types[7]
2445 #define SWIGTYPE_p_unsigned_int swig_types[8]
2448 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2449 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2454 #define SWIGVERSION 0x040001
2455 #define SWIG_VERSION SWIGVERSION
2458 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2459 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2462 #include <stdexcept>
2472 #ifdef OCTAVE_EXPORT
2473 #if defined ( __GNUC__ ) && __GNUC__ > 3
2474 #undef OCTAVE_EXPORT
2475 #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2493 inline int max(
int a,
int b )
2495 return a >= b ? a : b;
2497 inline int min(
int a,
int b )
2499 return a >= b ? a : b;
2513 return max( o_obj.rows(), 1 ) *
max( o_obj.columns(), 1 );
2525 if (
max( o_obj.columns(), 1 ) > 1 )
2530 else if (
max( o_obj.rows(), 1 ) > 1 )
2540 _dim(
const octave_value &o_obj,
int dim_idx )
2543 return max( o_obj.rows(), 0 );
2547 else if ( dim_idx == 1 )
2548 return max( o_obj.columns(), 0 );
2561 template <
class FLOAT>
2565 while ( n_el-- > 0 )
2566 *out_arr++ = (FLOAT) ( *in_arr++ );
2572 template void _cvt_double_to(
unsigned long *,
double *,
unsigned );
2574 template void _cvt_double_to(
unsigned short *,
double *,
unsigned );
2585 template <
class FLOAT>
2589 while ( n_el-- > 0 )
2590 *d_arr++ = double(*arr++);
2596 template void _cvt_to_double(
unsigned long *,
double *,
unsigned );
2598 template void _cvt_to_double(
unsigned short *,
double *,
unsigned );
2621 octave_value_list functionArguments;
2622 octave_value_list retval;
2629 for ( i = 0; i < n; i++ )
2635 functionArguments( 0 ) = xin;
2636 functionArguments( 1 ) = yin;
2639 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2640 retval = octave::feval(
fcnMapForm, functionArguments, 1 );
2642 retval = feval(
fcnMapForm, functionArguments, 1 );
2645 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2646 retval = octave::feval(
nameMapForm, functionArguments, 1 );
2648 retval = feval(
nameMapForm, functionArguments, 1 );
2651 if ( retval.length() >= 2 )
2653 xout = retval( 0 ).matrix_value();
2654 yout = retval( 1 ).matrix_value();
2656 for ( i = 0; i < n; i++ )
2658 x[i] = xout( i, 0 );
2659 y[i] = yout( i, 0 );
2671 octave_value_list functionArguments;
2672 octave_value_list retval;
2674 Matrix inAxis( 1, 1 );
2675 Matrix inValue( 1, 1 );
2676 inAxis( 0, 0 ) = axis;
2677 inValue( 0, 0 ) =
value;
2679 functionArguments( 0 ) = inAxis;
2680 functionArguments( 1 ) = inValue;
2683 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2684 retval = octave::feval(
fcnLabelFunc, functionArguments, 1 );
2689 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2690 retval = octave::feval(
nameLabelFunc, functionArguments, 1 );
2695 strncpy( label, retval( 0 ).
string_value().c_str(), length );
2705 octave_value_list functionArguments;
2706 octave_value_list retval;
2716 functionArguments( 0 ) = xin;
2717 functionArguments( 1 ) = yin;
2720 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2721 retval = octave::feval(
fcnCoordTrans, functionArguments, 1 );
2726 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2732 if ( retval.length() >= 2 )
2734 xout = retval( 0 ).matrix_value();
2735 yout = retval( 1 ).matrix_value();
2746 printf(
"nlegend =%d\n", nlegend );
2747 for ( i = 0; i < nlegend; i++ )
2749 printf(
"opt_array[%d] =%d\n", i, opt_array[i] );
2750 printf(
"strlen(text[%d]) =%d\n", i, (
int) strlen(
text[i] ) );
2751 printf(
"text[%d] =%s\n", i,
text[i] );
2757 #if !defined(SWIG_NO_LLONG_MAX)
2758 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2759 # define LLONG_MAX __LONG_LONG_MAX__
2760 # define LLONG_MIN (-LLONG_MAX - 1LL)
2761 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2768 if (!ov.is_scalar_type())
2770 if (ov.is_complex_scalar())
2772 if (ov.is_double_type()||ov.is_single_type()) {
2773 double v=ov.double_value();
2778 *val = ov.long_value();
2789 if ((v < INT_MIN || v > INT_MAX)) {
2792 if (val) *val = static_cast< int >(v);
2799 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 )
2807 *pX = gin.
pX; *pY = gin.
pY; *dX = gin.
dX; *dY = gin.
dY; *wX = gin.
wX; *wY = gin.
wY;
2821 && ov.rows() == 1 && ov.columns() == 1)
2822 ov = ov.cell_value()(0);
2823 if (!ov.is_string())
2826 std::string str=ov.string_value();
2827 size_t len=str.size();
2828 char* cstr=(
char*)str.c_str();
2830 *cptr = reinterpret_cast< char* >(memcpy(
new char[len + 1], cstr,
sizeof(
char)*(len + 1)));
2845 return octave_value(
value);
2858 return octave_value(
value);
2867 gin.
dX = x_in; gin.
dY = y_in;
2869 *x = gin.
wX; *y = gin.
wY;
2876 if (!ov.is_scalar_type())
2878 if (ov.is_complex_scalar())
2881 *val = ov.double_value();
2894 const char *legline1,
const char *legline2,
const char *legline3,
const char *legline4,
2895 const char *labx,
const char *laby,
const char *labtop )
2897 const char *legline[4];
2898 legline[0] = legline1; legline[1] = legline2;
2899 legline[2] = legline3; legline[3] = legline4;
2900 c_plstripc(
id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
2901 xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
2902 labx, laby, labtop );
2920 *tx = *( (
PLFLT *) pltr_data + 0 ) * x + *( (
PLFLT *) pltr_data + 1 ) * y + *( (
PLFLT *) pltr_data + 2 );
2921 *ty = *( (
PLFLT *) pltr_data + 3 ) * x + *( (
PLFLT *) pltr_data + 4 ) * y + *( (
PLFLT *) pltr_data + 5 );
2926 #define f2c( f, ff, nx, ny ) \
2928 ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
2929 for ( int i = 0; i < nx; i++ ) { \
2930 ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
2931 for ( int j = 0; j < ny; j++ ) \
2932 *( ff[i] + j ) = *( f + nx * j + i );}
2939 f2c( f, ff, nx, ny );
2940 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
xform, tr );
2948 f2c( f, ff, nx, ny );
2949 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr0, NULL );
2958 grid1.
nx = nx; grid1.
ny = ny;
2960 f2c( f, ff, nx, ny );
2961 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr1, &grid1 );
2969 f2c( xg, xgg, nx, ny );
2970 f2c( yg, ygg, nx, ny );
2971 grid2.
nx = nx; grid2.
ny = ny;
2972 grid2.
xg = xgg; grid2.
yg = ygg;
2973 f2c( f, ff, nx, ny );
2974 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
2983 f2c( xg, xgg, nx, ny );
2984 f2c( yg, ygg, nx, ny );
2985 grid2.
nx = nx; grid2.
ny = ny;
2986 grid2.
xg = xgg; grid2.
yg = ygg;
2987 f2c( f, ff, nx, ny );
2988 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
2993 const PLFLT *xg,
int nptsx,
const PLFLT *yg,
int nptsy,
2996 f2c( zg, zgg, nptsx, nptsy );
2997 plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
2998 for (
int i = 0; i < nptsx; i++ )
2999 for (
int j = 0; j < nptsy; j++ )
3000 *( zg + nptsx * j + i ) = zgg[i][j];
3008 f2c( z, zz, nx, ny );
3016 f2c( z, zz, nx, ny );
3017 c_plmeshc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3025 f2c( z, zz, nx, ny );
3034 f2c( z, zz, nx, ny );
3035 c_plot3dc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3044 f2c( z, zz, nx, ny );
3046 indexxmin, indexxmax, indexymin, indexymax );
3053 f2c( z, zz, nx, ny );
3061 f2c( z, zz, nx, ny );
3063 indexxmin, indexxmax, indexymin, indexymax );
3081 f2c( a, aa, nx, ny );
3082 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3083 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3084 min_color, min_width, max_color, max_width,
3098 grid1.
nx = nx; grid1.
ny = ny;
3100 f2c( a, aa, nx, ny );
3101 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3102 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3103 min_color, min_width, max_color, max_width,
3117 f2c( xg, xgg, nx, ny );
3118 f2c( yg, ygg, nx, ny );
3119 grid2.
nx = nx; grid2.
ny = ny;
3120 grid2.
xg = xgg; grid2.
yg = ygg;
3121 f2c( a, aa, nx, ny );
3122 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3123 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3124 min_color, min_width, max_color, max_width,
3136 f2c( a, aa, nx, ny );
3137 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3138 clevel, nlevel, fill_width, cont_color, cont_width,
3139 plfill, rectangular, NULL, NULL );
3148 f2c( a, aa, nx, ny );
3149 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3150 clevel, nlevel, fill_width, cont_color, cont_width,
3161 grid1.
nx = nx; grid1.
ny = ny;
3164 f2c( a, aa, nx, ny );
3165 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3166 clevel, nlevel, fill_width, cont_color, cont_width,
3177 f2c( xg, xgg, nx, ny );
3178 f2c( yg, ygg, nx, ny );
3179 grid2.
nx = nx; grid2.
ny = ny;
3180 grid2.
xg = xgg; grid2.
yg = ygg;
3181 f2c( a, aa, nx, ny );
3182 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3183 clevel, nlevel, fill_width, cont_color, cont_width,
3193 f2c( u, uu, nx, ny );
3194 f2c( v, vv, nx, ny );
3202 grid1.
nx = nx; grid1.
ny = ny;
3204 f2c( u, uu, nx, ny );
3205 f2c( v, vv, nx, ny );
3213 f2c( xg, xgg, nx, ny );
3214 f2c( yg, ygg, nx, ny );
3215 grid2.
nx = nx; grid2.
ny = ny;
3216 grid2.
xg = xgg; grid2.
yg = ygg;
3217 f2c( u, uu, nx, ny );
3218 f2c( v, vv, nx, ny );
3229 f2c( a, aa, nx, ny );
3230 plimage( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
3240 f2c( a, aa, nx, ny );
3241 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
3249 f2c( a, aa, nx, ny );
3250 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
xform, tr );
3260 grid1.
nx = nx + 1; grid1.
ny = ny + 1;
3262 f2c( a, aa, nx, ny );
3263 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr1, &grid1 );
3273 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
3274 f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
3275 grid2.
nx = nx + 1; grid2.
ny = ny + 1;
3276 grid2.
xg = xgg; grid2.
yg = ygg;
3277 f2c( a, aa, nx, ny );
3278 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr2, &grid2 );
3289 PLINT n_labels,
const PLINT *label_opts,
const char **label,
3290 PLINT n_axes,
const char ** axis_opts,
3297 for ( i = 0; i < nx; i++ )
3298 if ( n_values[i] > ny )
3300 f2c( a, aa, nx, ny );
3302 opt, position, x, y,
3304 bg_color, bb_color, bb_style,
3305 low_cap_color, high_cap_color,
3306 cont_color, cont_width,
3307 n_labels, label_opts, label,
3317 if (!ov.is_scalar_type())
3319 if (ov.is_complex_scalar())
3321 if (ov.is_double_type()||ov.is_single_type()) {
3322 double v=ov.double_value();
3328 if (ov.is_int8_type()||ov.is_int16_type()||
3329 ov.is_int32_type()) {
3330 long v=ov.long_value();
3334 if (ov.is_int64_type()) {
3335 long long v=ov.int64_scalar_value().value();
3340 *val = ov.ulong_value();
3351 if ((v > UINT_MAX)) {
3354 if (val) *val = static_cast< unsigned int >(v);
3363 return octave_value(
value);
3377 char* cptr = 0;
size_t csize = 0;
int alloc =
SWIG_OLDOBJ;
3381 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3382 if (csize <= size) {
3384 if (csize) memcpy(val, cptr, csize*
sizeof(
char));
3385 if (csize < size) memset(val + csize, 0, (size - csize)*
sizeof(
char));
3402 static int init = 0;
3415 return std::string(carray,carray+size);
3423 for (p = s;
maxlen-- && *p; p++)
3437 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3438 if (val) *val = static_cast< char >(v);
3448 Specify viewport in absolute coordinates\n\
3452 Alternate routine to plvpor for setting up the viewport. This routine\n\
3453 should be used only if the viewport is required to have a definite\n\
3454 size in millimeters. The routine plgspa is useful for finding out the\n\
3455 size of the current subpage.\n\
3457 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
3459 This function is used in example 10.\n\
3465 plsvpa(xmin, xmax, ymin, ymax)\n\
3469 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
3470 viewport from the left-hand edge of the subpage in millimeters.\n\
3472 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
3473 viewport from the left-hand edge of the subpage in millimeters.\n\
3475 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
3476 viewport from the bottom edge of the subpage in millimeters.\n\
3478 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
3479 from the bottom edge of the subpage in millimeters.\n\
3482 Write text relative to viewport boundaries in 3D plots\n\
3486 Writes text at a specified position relative to the viewport\n\
3487 boundaries. Text may be written inside or outside the viewport, but\n\
3488 is clipped at the subpage boundaries. The reference point of a string\n\
3489 lies along a line passing through the string at half the height of a\n\
3490 capital letter. The position of the reference point along this line\n\
3491 is determined by just, and the position of the reference point\n\
3492 relative to the viewport is set by disp and pos.\n\
3494 Redacted form: plmtex3(side, disp, pos, just, text)\n\
3496 This function is used in example 28.\n\
3502 plmtex3(side, disp, pos, just, text)\n\
3506 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
3507 the side of the viewport along which the text is to be written.\n\
3508 The string should contain one or more of the following characters:\n\
3509 [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
3510 only label the X axis, not both the X and Y axes. x: Label the X\n\
3512 y: Label the Y axis.\n\
3513 z: Label the Z axis.\n\
3514 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
3515 For X it is the axis that starts at y-min. For Y it is the\n\
3516 axis that starts at x-min.\n\
3517 s: Label the secondary axis.\n\
3518 v: Draw the text perpendicular to the axis.\n\
3521 disp (PLFLT, input) : Position of the reference point of string,\n\
3522 measured outwards from the specified viewport edge in units of the\n\
3523 current character height. Use negative disp to write within the\n\
3526 pos (PLFLT, input) : Position of the reference point of string\n\
3527 along the specified edge, expressed as a fraction of the length of\n\
3530 just (PLFLT, input) : Specifies the position of the string relative\n\
3531 to its reference point. If just=0. , the reference point is at\n\
3532 the left and if just=1. , it is at the right of the string. Other\n\
3533 values of just give intermediate justifications.\n\
3535 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3539 Set semitransparent cmap1 RGBA colors.\n\
3543 Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
3544 RGBA vector values. This function also sets the number of cmap1\n\
3545 colors. N.B. Continuous cmap1 colors are indexed with a\n\
3546 floating-point index in the range from 0.0-1.0 which is linearly\n\
3547 transformed (e.g., by plcol1) to an integer index of these RGBA\n\
3548 vectors in the range from 0 to\n\
3549 ncol1-1. So in order for this continuous color model to work\n\
3550 properly, it is the responsibility of the user of plscmap1 to insure\n\
3551 that these RGBA vectors are continuous functions of their integer\n\
3554 Redacted form: plscmap1a(r, g, b, alpha)\n\
3556 This function is used in example 31.\n\
3562 plscmap1a(r, g, b, alpha, ncol1)\n\
3566 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3567 8-bit integers in the range from 0-255) the degree of red in the\n\
3568 color as a continuous function of the integer index of the vector.\n\
3570 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3571 8-bit integers in the range from 0-255) the degree of green in the\n\
3572 color as a continuous function of the integer index of the vector.\n\
3574 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3575 8-bit integers in the range from 0-255) the degree of blue in the\n\
3576 color as a continuous function of the integer index of the vector.\n\
3578 alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
3579 values in the range from 0.0-1.0 where 0.0 corresponds to\n\
3580 completely transparent and 1.0 corresponds to completely opaque)\n\
3581 the alpha transparency of the color as a continuous function of\n\
3582 the integer index of the vector.\n\
3584 ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
3588 Select standard viewport\n\
3592 Selects the largest viewport within the subpage that leaves a standard\n\
3593 margin (left-hand margin of eight character heights, and a margin\n\
3594 around the other three sides of five character heights).\n\
3596 Redacted form: plvsta()\n\
3598 This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
3607 Switch to graphics screen\n\
3611 Sets an interactive device to graphics mode, used in conjunction with\n\
3612 pltext to allow graphics and text to be interspersed. On a device\n\
3613 which supports separate text and graphics windows, this command causes\n\
3614 control to be switched to the graphics window. If already in graphics\n\
3615 mode, this command is ignored. It is also ignored on devices which\n\
3616 only support a single window or use a different method for shifting\n\
3617 focus. See also pltext.\n\
3619 Redacted form: plgra()\n\
3621 This function is used in example 1.\n\
3630 Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
3634 Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
3635 (see the PLplot documentation) index. Overwrites the previous color\n\
3636 value for the given index and, thus, does not result in any additional\n\
3637 allocation of space for colors.\n\
3639 This function is used in example 30.\n\
3645 plscol0a(icol0, r, g, b, alpha)\n\
3649 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
3650 number of colors (which is set by default, by plscmap0n, or even\n\
3653 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3654 degree of red in the color.\n\
3656 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3657 degree of green in the color.\n\
3659 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3660 degree of blue in the color.\n\
3662 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
3666 Set y axis parameters\n\
3670 Identical to plsxax, except that arguments are flags for y axis. See\n\
3671 the description of plsxax for more detail.\n\
3673 Redacted form: plsyax(digmax, digits)\n\
3675 This function is used in examples 1, 14, and 31.\n\
3681 plsyax(digmax, digits)\n\
3685 digmax (PLINT, input) : Variable to set the maximum number of\n\
3686 digits for the y axis. If nonzero, the printed label will be\n\
3687 switched to a floating-point representation when the number of\n\
3688 digits exceeds digmax.\n\
3690 digits (PLINT, input) : Field digits value. Currently, changing\n\
3691 its value here has no effect since it is set only by plbox or\n\
3692 plbox3. However, the user may obtain its value after a call to\n\
3693 either of these functions by calling plgyax.\n\
3696 Returns 8-bit RGB values for given color index from cmap0\n\
3700 Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
3701 PLplot documentation). Values are negative if an invalid color id is\n\
3704 Redacted form: plgcol0(icol0, r, g, b)\n\
3706 This function is used in example 2.\n\
3712 plgcol0(icol0, r, g, b)\n\
3716 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
3718 r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
3721 g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
3724 b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
3728 Set seed for internal random number generator.\n\
3732 Set the seed for the internal random number generator. See plrandd for\n\
3735 Redacted form: plseed(seed)\n\
3737 This function is used in example 21.\n\
3747 seed (unsigned int, input) : Seed for random number generator.\n\
3750 Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
3754 When the implementation is completed this variant of plot3dc (see that\n\
3755 function\'s documentation for more details) should be suitable for the\n\
3756 case where the area of the x, y coordinate grid where z is defined can\n\
3757 be non-rectangular. The implementation is incomplete so the last 4\n\
3758 parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
3759 indexymax; are currently ignored and the functionality is otherwise\n\
3760 identical to that of plot3dc.\n\
3762 Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
3763 indexymin, indexymax)\n\
3766 This function is not used in any example.\n\
3772 plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
3776 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3777 which the function is evaluated.\n\
3779 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3780 which the function is evaluated.\n\
3782 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3783 plot. Should have dimensions of\n\
3787 nx (PLINT, input) : Number of x values at which the function is\n\
3790 ny (PLINT, input) : Number of y values at which the function is\n\
3793 opt (PLINT, input) : Determines the way in which the surface is\n\
3794 represented. To specify more than one option just add the options,\n\
3795 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3796 showing z as a function of x for each value of y[j] .\n\
3797 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3798 for each value of x[i] .\n\
3799 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3800 at which function is defined.\n\
3801 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3802 the z value being plotted. The color is used from the current\n\
3804 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3808 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3809 the borders of the plotted function.\n\
3812 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3815 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3817 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
3818 corresponds to the first x index where z is defined.\n\
3820 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
3821 which corresponds (by convention) to one more than the last x\n\
3822 index value where z is defined.\n\
3824 indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
3825 values which all must be ≥ 0. These values are the first y index\n\
3826 where z is defined for a particular x index in the range from\n\
3827 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
3830 indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
3831 values which all must be ≤ ny. These values correspond (by\n\
3832 convention) to one more than the last y index where z is defined\n\
3833 for a particular x index in the range from indexxmin to indexxmax\n\
3834 - 1. The dimension of indexymax is indexxmax.\n\
3837 Get output file name\n\
3841 Gets the current output file name, if applicable.\n\
3843 Redacted form: plgfnam(fnam)\n\
3845 This function is used in example 31.\n\
3855 fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
3856 (with preallocated length of 80 characters or more) containing the\n\
3864 Specify the window, i.e., the world coordinates of the edges of the\n\
3867 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
3869 This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
3876 plwind(xmin, xmax, ymin, ymax)\n\
3880 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
3883 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
3886 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
3889 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
3893 Set cmap1 colors using a piece-wise linear relationship\n\
3897 Set cmap1 colors using a piece-wise linear relationship between the\n\
3898 cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
3899 (see the PLplot documentation). May be called at any time.\n\
3901 The idea here is to specify a number of control points that define the\n\
3902 mapping between input cmap1 intensity indices and HLS or RGB. Between\n\
3903 these points, linear interpolation is used which gives a smooth\n\
3904 variation of color with intensity index. Any number of control points\n\
3905 may be specified, located at arbitrary positions, although typically 2\n\
3906 - 4 are enough. Another way of stating this is that we are traversing\n\
3907 a given number of lines through HLS or RGB space as we move through\n\
3908 cmap1 intensity indices. The control points at the minimum and\n\
3909 maximum position (0 and 1) must always be specified. By adding more\n\
3910 control points you can get more variation. One good technique for\n\
3911 plotting functions that vary about some expected average is to use an\n\
3912 additional 2 control points in the center (position ~= 0.5) that are\n\
3913 the same lightness as the background (typically white for paper\n\
3914 output, black for crt), and same hue as the boundary control points.\n\
3915 This allows the highs and lows to be very easily distinguished.\n\
3917 Each control point must specify the cmap1 intensity index and the\n\
3918 associated three coordinates in HLS or RGB space. The first point\n\
3919 must correspond to position = 0, and the last to position = 1.\n\
3921 If RGB colors are provided then the interpolation takes place in RGB\n\
3922 space and is trivial. However if HLS colors are provided then, because\n\
3923 of the circular nature of the color wheel for the hue coordinate, the\n\
3924 interpolation could be performed in either direction around the color\n\
3925 wheel. The default behaviour is for the hue to be linearly\n\
3926 interpolated ignoring this circular property of hue. So for example,\n\
3927 the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\
3928 green and cyan. If instead you wish to interpolate the other way\n\
3929 around the color wheel you have two options. You may provide hues\n\
3930 outside the range [0, 360), so by using a hue of -120 for blue or 360\n\
3931 for red the interpolation will proceed via magenta. Alternatively you\n\
3932 can utilise the alt_hue_path variable to reverse the direction of\n\
3933 interpolation if you need to provide hues within the [0-360) range.\n\
3935 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
3936 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
3937 -120]falsegreen-yellow-red-magenta-blue[240\n\
3938 480]falseblue-magenta-red-yellow-green[120\n\
3939 240]truegreen-yellow-red-magenta-blue[240\n\
3940 120]trueblue-magenta-red-yellow-green\n\
3942 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
3943 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
3944 1]magnitudeHLSsaturation[0, 1]magnitude\n\
3946 Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
3949 This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
3955 plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
3959 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
3961 npts (PLINT, input) : number of control points\n\
3963 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
3964 intensity index (0.0-1.0) in ascending order for each control\n\
3967 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
3968 coordinate (H or R) for each control point.\n\
3970 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
3971 coordinate (L or G) for each control point.\n\
3973 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
3974 coordinate (S or B) for each control point.\n\
3976 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
3977 npts - 1 elements), each containing either true to use the reversed\n\
3978 HLS interpolation or false to use the regular HLS interpolation.\n\
3979 (alt_hue_path[i] refers to the interpolation interval between the\n\
3980 i and i + 1 control points). This parameter is not used for RGB\n\
3985 Set the pause (on end-of-page) status\n\
3989 Set the pause (on end-of-page) status.\n\
3991 Redacted form: plspause(pause)\n\
3993 This function is in examples 14,20.\n\
4003 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
4004 end-of-page for those drivers which support this. Otherwise there\n\
4008 Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
4012 Routine for creating a discrete plot legend with a plotted filled box,\n\
4013 line, and/or line of symbols for each annotated legend entry. (See\n\
4014 plcolorbar for similar functionality for creating continuous color\n\
4015 bars.) The arguments of pllegend provide control over the location\n\
4016 and size of the legend as well as the location and characteristics of\n\
4017 the elements (most of which are optional) within that legend. The\n\
4018 resulting legend is clipped at the boundaries of the current subpage.\n\
4019 (N.B. the adopted coordinate system used for some of the parameters is\n\
4020 defined in the documentation of the position parameter.)\n\
4022 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
4023 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
4024 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
4025 test_justification, text_colors, text, box_colors, box_patterns,\n\
4026 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
4027 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
4029 This function is used in examples 4, 26, and 33.\n\
4035 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\
4039 p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
4040 legend width in adopted coordinates. This quantity is calculated\n\
4041 from plot_width, text_offset, ncolumn (possibly modified inside\n\
4042 the routine depending on nlegend and nrow), and the length\n\
4043 (calculated internally) of the longest text string.\n\
4045 p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
4046 legend height in adopted coordinates. This quantity is calculated\n\
4047 from text_scale, text_spacing, and nrow (possibly modified inside\n\
4048 the routine depending on nlegend and nrow).\n\
4050 opt (PLINT, input) : opt contains bits controlling the overall\n\
4051 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
4052 on the left of the legend and the plotted area on the right.\n\
4053 Otherwise, put the text area on the right of the legend and the\n\
4054 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
4055 plot a (semitransparent) background for the legend. If the\n\
4056 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
4057 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
4058 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
4059 plot the resulting array of legend entries in row-major order.\n\
4060 Otherwise, plot the legend entries in column-major order.\n\
4062 position (PLINT, input) : position contains bits which control the\n\
4063 overall position of the legend and the definition of the adopted\n\
4064 coordinates used for positions just like what is done for the\n\
4065 position argument for plcolorbar. However, note that the defaults\n\
4066 for the position bits (see below) are different than the\n\
4067 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
4068 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
4069 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
4070 the 16 possible standard positions (the 4 corners and centers of\n\
4071 the 4 sides for both the inside and outside cases) of the legend\n\
4072 relative to the adopted coordinate system. The corner positions\n\
4073 are specified by the appropriate combination of two of the\n\
4074 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
4075 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
4076 value of one of those bits. The adopted coordinates are\n\
4077 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
4078 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
4079 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
4080 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
4081 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
4082 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
4083 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
4084 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
4086 x (PLFLT, input) : X offset of the legend position in adopted\n\
4087 coordinates from the specified standard position of the legend.\n\
4088 For positive x, the direction of motion away from the standard\n\
4089 position is inward/outward from the standard corner positions or\n\
4090 standard left or right positions if the\n\
4091 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
4092 For the standard top or bottom positions, the direction of motion\n\
4093 is toward positive X.\n\
4095 y (PLFLT, input) : Y offset of the legend position in adopted\n\
4096 coordinates from the specified standard position of the legend.\n\
4097 For positive y, the direction of motion away from the standard\n\
4098 position is inward/outward from the standard corner positions or\n\
4099 standard top or bottom positions if the\n\
4100 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
4101 the standard left or right positions, the direction of motion is\n\
4102 toward positive Y.\n\
4104 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
4105 of the plot area (where the colored boxes, lines, and/or lines of\n\
4106 symbols are drawn) of the legend.\n\
4108 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
4109 legend (PL_LEGEND_BACKGROUND).\n\
4111 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
4112 for the legend (PL_LEGEND_BOUNDING_BOX).\n\
4114 bb_style (PLINT, input) : The pllsty style number for the\n\
4115 bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
4117 nrow (PLINT, input) : The number of rows in the matrix used to\n\
4119 nlegend legend entries. For internal transformations of\n\
4120 nrow, see further remarks under\n\
4123 ncolumn (PLINT, input) : The number of columns in the matrix used\n\
4125 nlegend legend entries. For internal transformations of\n\
4126 ncolumn, see further remarks under\n\
4129 nlegend (PLINT, input) : Number of legend entries. The above\n\
4131 ncolumn values are transformed internally to be consistent with\n\
4132 nlegend. If either\n\
4134 ncolumn is non-positive it is replaced by 1. If the resulting product\n\
4137 ncolumn is less than\n\
4138 nlegend, the smaller of the two (or\n\
4141 ncolumn) is increased so the product is >=\n\
4142 nlegend. Thus, for example, the common\n\
4144 ncolumn = 0 case is transformed internally to\n\
4147 ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
4150 opt_array (PLINT_VECTOR, input) : A vector of\n\
4151 nlegend values of options to control each individual plotted area\n\
4152 corresponding to a legend entry. If the\n\
4153 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
4155 PL_LEGEND_COLOR_BOX,\n\
4156 PL_LEGEND_LINE, and/or\n\
4157 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
4158 entry is plotted with a colored box; a line; and/or a line of\n\
4161 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
4162 area in units of character width.\n\
4164 text_scale (PLFLT, input) : Character height scale for text\n\
4167 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
4168 character height from one legend entry to the next.\n\
4170 text_justification (PLFLT, input) : Justification parameter used\n\
4171 for text justification. The most common values of\n\
4172 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
4173 is left justified, centred, or right justified within the text\n\
4174 area, but other values are allowed as well.\n\
4176 text_colors (PLINT_VECTOR, input) : A vector containing\n\
4177 nlegend cmap0 text colors.\n\
4179 text (PLCHAR_MATRIX, input) : A vector of\n\
4180 nlegend UTF-8 character strings containing the legend annotations.\n\
4182 box_colors (PLINT_VECTOR, input) : A vector containing\n\
4183 nlegend cmap0 colors for the discrete colored boxes (\n\
4184 PL_LEGEND_COLOR_BOX).\n\
4186 box_patterns (PLINT_VECTOR, input) : A vector containing\n\
4187 nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
4188 PL_LEGEND_COLOR_BOX).\n\
4190 box_scales (PLFLT_VECTOR, input) : A vector containing\n\
4191 nlegend scales (units of fraction of character height) for the height\n\
4192 of the discrete colored boxes (\n\
4193 PL_LEGEND_COLOR_BOX).\n\
4195 box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
4196 nlegend line widths for the patterns specified by box_patterns (\n\
4197 PL_LEGEND_COLOR_BOX).\n\
4199 line_colors (PLINT_VECTOR, input) : A vector containing\n\
4200 nlegend cmap0 line colors (\n\
4203 line_styles (PLINT_VECTOR, input) : A vector containing\n\
4204 nlegend line styles (plsty indices) (\n\
4207 line_widths (PLFLT_VECTOR, input) : A vector containing\n\
4208 nlegend line widths (\n\
4211 symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
4212 nlegend cmap0 symbol colors (\n\
4213 PL_LEGEND_SYMBOL).\n\
4215 symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
4216 nlegend scale values for the symbol height (\n\
4217 PL_LEGEND_SYMBOL).\n\
4219 symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
4220 nlegend numbers of symbols to be drawn across the width of the plotted\n\
4222 PL_LEGEND_SYMBOL).\n\
4224 symbols (PLCHAR_MATRIX, input) : A vector of\n\
4225 nlegend UTF-8 character strings containing the legend symbols. (\n\
4226 PL_LEGEND_SYMBOL).\n\
4229 Set number of colors in cmap1\n\
4233 Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
4234 values if this is the first allocation (see the PLplot documentation).\n\
4236 Redacted form: plscmap1n(ncol1)\n\
4238 This function is used in examples 8, 11, 20, and 21.\n\
4248 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
4249 the cmap1 palette. If this number is zero or less, then the value\n\
4250 from the previous call to plscmap1n is used and if there is no\n\
4251 previous call, then a default value is used.\n\
4254 Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
4258 Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
4259 (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
4260 Values are negative if an invalid color id is given.\n\
4262 Redacted form: plgcola(r, g, b)\n\
4264 This function is used in example 30.\n\
4270 plgcol0a(icol0, r, g, b, alpha)\n\
4274 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
4276 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
4277 in the range from 0 to 255.\n\
4279 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
4280 in the range from 0 to 255.\n\
4282 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
4283 in the range from 0 to 255.\n\
4285 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
4286 transparency in the range from (0.0-1.0).\n\
4289 Replays contents of plot buffer to current device/file\n\
4293 Replays contents of plot buffer to current device/file.\n\
4295 Redacted form: plreplot()\n\
4297 This function is used in example 1,20.\n\
4306 Simple routine to write labels\n\
4310 Routine for writing simple labels. Use plmtex for more complex labels.\n\
4312 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
4314 This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
4320 pllab(xlabel, ylabel, tlabel)\n\
4324 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4325 the label for the x axis.\n\
4327 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4328 the label for the y axis.\n\
4330 tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4331 the title of the plot.\n\
4334 Set parameters that define current device-space window\n\
4338 Set relative margin width, aspect ratio, and relative justification\n\
4339 that define current device-space window. If you want to just use the\n\
4340 previous value for any of these, just pass in the magic value\n\
4341 PL_NOTSET. It is unlikely that one should ever need to change the\n\
4342 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
4343 called the default values of mar, jx, and jy are all 0. aspect is set\n\
4344 to a device-specific value.\n\
4346 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
4348 This function is used in example 31.\n\
4354 plsdidev(mar, aspect, jx, jy)\n\
4358 mar (PLFLT, input) : Relative margin width.\n\
4360 aspect (PLFLT, input) : Aspect ratio.\n\
4362 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
4363 the range -0.5 to 0.5.\n\
4365 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
4366 the range -0.5 to 0.5.\n\
4373 Begins a new page. For a file driver, the output file is opened if\n\
4374 necessary. Advancing the page via pleop and plbop is useful when a\n\
4375 page break is desired at a particular point when plotting to subpages.\n\
4376 Another use for pleop and plbop is when plotting pages to different\n\
4377 files, since you can manually set the file name by calling plsfnam\n\
4378 after the call to pleop. (In fact some drivers may only support a\n\
4379 single page per file, making this a necessity.) One way to handle\n\
4380 this case automatically is to page advance via pladv, but enable\n\
4381 familying (see plsfam) with a small limit on the file size so that a\n\
4382 new family member file will be created on each page break.\n\
4384 Redacted form: plbop()\n\
4386 This function is used in examples 2 and 20.\n\
4395 Set cmap0 colors by 8-bit RGB values\n\
4399 Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
4400 documentation). This sets the entire color map -- only as many colors\n\
4401 as specified will be allocated.\n\
4403 Redacted form: plscmap0(r, g, b)\n\
4405 This function is used in examples 2 and 24.\n\
4411 plscmap0(r, g, b, ncol0)\n\
4415 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4416 integers (0-255) representing the degree of red in the color.\n\
4418 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4419 integers (0-255) representing the degree of green in the color.\n\
4421 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4422 integers (0-255) representing the degree of blue in the color.\n\
4424 ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4427 Set the number of subpages in x and y\n\
4431 Set the number of subpages in x and y.\n\
4433 Redacted form: plssub(nx, ny)\n\
4435 This function is examples 1,2,14,21,25,27.\n\
4445 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
4446 of window columns).\n\
4448 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
4452 Set a global coordinate transform function\n\
4456 This function can be used to define a coordinate transformation which\n\
4457 affects all elements drawn within the current plot window. The\n\
4458 coordinate_transform callback function is similar to that provided for\n\
4459 the plmap and plmeridians functions. The coordinate_transform_data\n\
4460 parameter may be used to pass extra data to coordinate_transform.\n\
4462 Redacted form: General: plstransform(coordinate_transform,\n\
4463 coordinate_transform_data)\n\
4466 This function is used in examples 19 and 22.\n\
4472 plstransform(coordinate_transform, coordinate_transform_data)\n\
4476 coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
4477 function that defines the transformation from the input (x, y)\n\
4478 world coordinates to new PLplot world coordinates. If\n\
4479 coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
4480 case), then no transform is applied.\n\
4482 coordinate_transform_data (PLPointer, input) : Optional extra data\n\
4484 coordinate_transform.\n\
4487 Set opaque RGB cmap1 colors values\n\
4491 Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
4492 vector values. This function also sets the number of cmap1 colors.\n\
4493 N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
4494 in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
4495 plcol1) to an integer index of these RGB vectors in the range from 0\n\
4497 ncol1-1. So in order for this continuous color model to work\n\
4498 properly, it is the responsibility of the user of plscmap1 to insure\n\
4499 that these RGB vectors are continuous functions of their integer\n\
4502 Redacted form: plscmap1(r, g, b)\n\
4504 This function is used in example 31.\n\
4510 plscmap1(r, g, b, ncol1)\n\
4514 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4515 8-bit integers in the range from 0-255) the degree of red in the\n\
4516 color as a continuous function of the integer index of the vector.\n\
4518 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4519 8-bit integers in the range from 0-255) the degree of green in the\n\
4520 color as a continuous function of the integer index of the vector.\n\
4522 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4523 8-bit integers in the range from 0-255) the degree of blue in the\n\
4524 color as a continuous function of the integer index of the vector.\n\
4526 ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4529 Configure the transformation between continuous and broken-down time for the current stream\n\
4533 Configure the transformation between continuous and broken-down time\n\
4534 for the current stream. This transformation is used by both plbtime\n\
4537 Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
4538 ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4541 This function is used in example 29.\n\
4547 plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4551 scale (PLFLT, input) : The number of days per continuous time unit.\n\
4552 As a special case, if\n\
4553 scale is 0., then all other arguments are ignored, and the result (the\n\
4554 default used by PLplot) is the equivalent of a call to\n\
4555 plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
4556 That is, for this special case broken-down time is calculated with\n\
4557 the proleptic Gregorian calendar with no leap seconds inserted,\n\
4558 and the continuous time is defined as the number of seconds since\n\
4559 the Unix epoch of 1970-01-01T00:00:00Z.\n\
4561 offset1 (PLFLT, input) : If\n\
4562 ifbtime_offset is true, the parameters\n\
4564 offset2 are completely ignored. Otherwise, the sum of these parameters\n\
4565 (with units in days) specify the epoch of the continuous time\n\
4566 relative to the MJD epoch corresponding to the Gregorian calendar\n\
4567 date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
4568 are used to specify the origin to allow users (by specifying\n\
4569 offset1 as an integer that can be exactly represented by a\n\
4570 floating-point variable and specifying\n\
4571 offset2 as a number in the range from 0. to 1) the chance to minimize\n\
4572 the numerical errors of the continuous time representation.\n\
4574 offset2 (PLFLT, input) : See documentation of\n\
4577 ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
4578 transformation. If the 0x1 bit is set, then the proleptic Julian\n\
4579 calendar is used for broken-down time rather than the proleptic\n\
4580 Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
4581 have been historically used to define UTC are inserted into the\n\
4582 broken-down time. Other possibilities for additional control bits\n\
4583 for ccontrol exist such as making the historical time corrections\n\
4584 in the broken-down time corresponding to ET (ephemeris time) or\n\
4585 making the (slightly non-constant) corrections from international\n\
4586 atomic time (TAI) to what astronomers define as terrestrial time\n\
4587 (TT). But those additional possibilities have not been\n\
4588 implemented yet in the qsastime library (one of the PLplot utility\n\
4591 ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
4592 epoch of the continuous time scale is specified by the user. If\n\
4593 ifbtime_offset is false, then\n\
4595 offset2 are used to specify the epoch, and the following broken-down\n\
4596 time parameters are completely ignored. If\n\
4597 ifbtime_offset is true, then\n\
4599 offset2 are completely ignored, and the following broken-down time\n\
4600 parameters are used to specify the epoch.\n\
4602 year (PLINT, input) : Year of epoch.\n\
4604 month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
4607 day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
4609 hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
4611 min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
4613 sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
4616 Set length of minor ticks\n\
4620 This sets up the length of the minor ticks and the length of the\n\
4621 terminals on error bars. The actual length is the product of the\n\
4622 default length and a scaling factor as for character height.\n\
4624 Redacted form: plsmin(def, scale)\n\
4626 This function is used in example 29.\n\
4632 plsmin(def, scale)\n\
4636 def (PLFLT, input) : The default length of a minor tick in\n\
4637 millimeters, should be set to zero if the default length is to\n\
4638 remain unchanged.\n\
4640 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4641 actual tick length.\n\
4644 Set character size\n\
4648 This sets up the size of all subsequent characters drawn. The actual\n\
4649 height of a character is the product of the default character size and\n\
4650 a scaling factor.\n\
4652 Redacted form: plschr(def, scale)\n\
4654 This function is used in examples 2, 13, 23, and 24.\n\
4660 plschr(def, scale)\n\
4664 def (PLFLT, input) : The default height of a character in\n\
4665 millimeters, should be set to zero if the default height is to\n\
4666 remain unchanged. For rasterized drivers the dx and dy values\n\
4667 specified in plspage are used to convert from mm to pixels (note\n\
4668 the different unit systems used). This dpi aware scaling is not\n\
4669 implemented for all drivers yet.\n\
4671 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4672 actual character height.\n\
4675 Initialize PLplot\n\
4679 Initializing the plotting package. The program prompts for the device\n\
4680 keyword or number of the desired output device. Hitting a RETURN in\n\
4681 response to the prompt is the same as selecting the first device.\n\
4682 plinit will issue no prompt if either the device was specified\n\
4683 previously (via command line flag, the plsetopt function, or the\n\
4684 plsdev function), or if only one device is enabled when PLplot is\n\
4685 installed. If subpages have been specified, the output device is\n\
4686 divided into nx by ny subpages, each of which may be used\n\
4687 independently. If plinit is called again during a program, the\n\
4688 previously opened file will be closed. The subroutine pladv is used\n\
4689 to advance from one subpage to the next.\n\
4691 Redacted form: plinit()\n\
4693 This function is used in all of the examples.\n\
4702 Draw a box with axes, etc\n\
4706 Draws a box around the currently defined viewport, and labels it with\n\
4707 world coordinate values appropriate to the window. Thus plbox should\n\
4708 only be called after defining both viewport and window. The ascii\n\
4709 character strings xopt and yopt specify how the box should be drawn as\n\
4710 described below. If ticks and/or subticks are to be drawn for a\n\
4711 particular axis, the tick intervals and number of subintervals may be\n\
4712 specified explicitly, or they may be defaulted by setting the\n\
4713 appropriate arguments to zero.\n\
4715 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4718 This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
4725 plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4729 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4730 options for the x axis. The string can include any combination of\n\
4731 the following letters (upper or lower case) in any order: a: Draws\n\
4732 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
4734 b: Draws bottom (X) or left (Y) edge of frame.\n\
4735 c: Draws top (X) or right (Y) edge of frame.\n\
4736 d: Plot labels as date / time. Values are assumed to be\n\
4737 seconds since the epoch (as used by gmtime).\n\
4738 f: Always use fixed point numeric labels.\n\
4739 g: Draws a grid at the major tick interval.\n\
4740 h: Draws a grid at the minor tick interval.\n\
4741 i: Inverts tick marks, so they are drawn outwards, rather than\n\
4743 l: Labels axis logarithmically. This only affects the labels,\n\
4744 not the data, and so it is necessary to compute the logarithms\n\
4745 of data points before passing them to any of the drawing\n\
4747 m: Writes numeric labels at major tick intervals in the\n\
4748 unconventional location (above box for X, right of box for Y).\n\
4749 n: Writes numeric labels at major tick intervals in the\n\
4750 conventional location (below box for X, left of box for Y).\n\
4751 o: Use custom labelling function to generate axis label text.\n\
4752 The custom labelling function can be defined with the\n\
4753 plslabelfunc command.\n\
4754 s: Enables subticks between major ticks, only valid if t is\n\
4756 t: Draws major ticks.\n\
4757 u: Exactly like \"b\" except don\'t draw edge line.\n\
4758 w: Exactly like \"c\" except don\'t draw edge line.\n\
4759 x: Exactly like \"t\" (including the side effect of the\n\
4760 numerical labels for the major ticks) except exclude drawing\n\
4761 the major and minor tick marks.\n\
4764 xtick (PLFLT, input) : World coordinate interval between major\n\
4765 ticks on the x axis. If it is set to zero, PLplot automatically\n\
4766 generates a suitable tick interval.\n\
4768 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
4769 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4770 generates a suitable minor tick interval.\n\
4772 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4773 options for the y axis. The string can include any combination of\n\
4774 the letters defined above for xopt, and in addition may contain:\n\
4775 v: Write numeric labels for the y axis parallel to the base of the\n\
4776 graph, rather than parallel to the axis.\n\
4779 ytick (PLFLT, input) : World coordinate interval between major\n\
4780 ticks on the y axis. If it is set to zero, PLplot automatically\n\
4781 generates a suitable tick interval.\n\
4783 nysub (PLINT, input) : Number of subintervals between major y axis\n\
4784 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4785 generates a suitable minor tick interval.\n\
4788 Get parameters that define current device-space window\n\
4792 Get relative margin width, aspect ratio, and relative justification\n\
4793 that define current device-space window. If plsdidev has not been\n\
4794 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
4795 p_jy will all be 0.\n\
4797 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4799 This function is used in example 31.\n\
4805 plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4809 p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4812 p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
4815 p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4816 justification in x.\n\
4818 p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4819 justification in y.\n\
4822 Plot a glyph at the specified points\n\
4826 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
4827 because many[!] more glyphs are accessible with plstring.) The glyph\n\
4828 is specified with a PLplot user string. Note that the user string is\n\
4829 not actually limited to one glyph so it is possible (but not normally\n\
4830 useful) to plot more than one glyph at the specified points with this\n\
4831 function. As with plmtex and plptex, the user string can contain FCI\n\
4832 escapes to determine the font, UTF-8 code to determine the glyph or\n\
4833 else PLplot escapes for Hershey or unicode text to determine the\n\
4836 Redacted form: plstring(x, y, string)\n\
4838 This function is used in examples 4, 21 and 26.\n\
4844 plstring(n, x, y, string)\n\
4848 n (PLINT, input) : Number of points in the x and y vectors.\n\
4850 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4853 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4856 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
4857 the glyph(s) to be plotted at each of the n points.\n\
4860 Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
4864 As per plmapline, however the items are plotted as strings or points\n\
4865 in the same way as plstring.\n\
4867 Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
4868 maxy, plotentries)\n\
4870 This function is not used in any examples.\n\
4876 plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
4880 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
4881 transform the coordinates given in the shapefile into a plot\n\
4882 coordinate system. By using this transform, we can change from a\n\
4883 longitude, latitude coordinate to a polar stereographic project,\n\
4884 for example. Initially, x[0]..[n-1] are the longitudes and\n\
4885 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
4886 mapform(), x[] and y[] should be replaced by the corresponding\n\
4887 plot coordinates. If no transform is desired, mapform can be\n\
4888 replaced by NULL.\n\
4890 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4891 the file name of a set of Shapefile files without the file\n\
4894 string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
4897 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
4898 be in the same units as used by the Shapefile. You could use a\n\
4899 very large negative number to plot everything, but you can improve\n\
4900 performance by limiting the area drawn. The units must match those\n\
4901 of the Shapefile projection, which may be for example longitude or\n\
4902 distance. The value of minx must be less than the value of maxx.\n\
4904 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
4905 use a very large number to plot everything, but you can improve\n\
4906 performance by limiting the area drawn.\n\
4908 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
4909 be in the same units as used by the Shapefile. You could use a\n\
4910 very large negative number to plot everything, but you can improve\n\
4911 performance by limiting the area drawn. The units must match those\n\
4912 of the Shapefile projection, which may be for example latitude or\n\
4913 distance. The value of miny must be less than the value of maxy.\n\
4915 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
4916 use a very large number to plot everything, but you can improve\n\
4917 performance by limiting the area drawn.\n\
4919 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
4920 zero-based indices of the Shapefile elements which will be drawn.\n\
4922 plotentries to NULL will plot all elements of the Shapefile.\n\
4924 nplotentries (PLINT, input) : The number of items in\n\
4925 plotentries. Ignored if\n\
4926 plotentries is NULL.\n\
4929 Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
4933 Sets up plotter environment for simple graphs by calling pladv and\n\
4934 setting up viewport and window to sensible default values. plenv0\n\
4935 leaves a standard margin (left-hand margin of eight character heights,\n\
4936 and a margin around the other three sides of five character heights)\n\
4937 around most graphs for axis labels and a title. When these defaults\n\
4938 are not suitable, use the individual routines plvpas, plvpor, or\n\
4939 plvasp for setting up the viewport, plwind for defining the window,\n\
4940 and plbox for drawing the box.\n\
4942 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4944 This function is used in example 21.\n\
4950 plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4954 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
4955 world coordinates).\n\
4957 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
4958 world coordinates).\n\
4960 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
4963 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
4966 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
4967 scales will not be set, the user must set up the scale before\n\
4968 calling plenv0 using plsvpa, plvasp or other.\n\
4969 0: the x and y axes are scaled independently to use as much of\n\
4970 the screen as possible.\n\
4971 1: the scales of the x and y axes are made equal.\n\
4972 2: the axis of the x and y axes are made equal, and the plot\n\
4973 box will be square.\n\
4976 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
4977 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
4978 -1: draw box only.\n\
4979 0: draw box, ticks, and numeric tick labels.\n\
4980 1: also draw coordinate axes at x=0 and y=0.\n\
4981 2: also draw a grid at major tick positions in both\n\
4983 3: also draw a grid at minor tick positions in both\n\
4985 10: same as 0 except logarithmic x tick marks. (The x data\n\
4986 have to be converted to logarithms separately.)\n\
4987 11: same as 1 except logarithmic x tick marks. (The x data\n\
4988 have to be converted to logarithms separately.)\n\
4989 12: same as 2 except logarithmic x tick marks. (The x data\n\
4990 have to be converted to logarithms separately.)\n\
4991 13: same as 3 except logarithmic x tick marks. (The x data\n\
4992 have to be converted to logarithms separately.)\n\
4993 20: same as 0 except logarithmic y tick marks. (The y data\n\
4994 have to be converted to logarithms separately.)\n\
4995 21: same as 1 except logarithmic y tick marks. (The y data\n\
4996 have to be converted to logarithms separately.)\n\
4997 22: same as 2 except logarithmic y tick marks. (The y data\n\
4998 have to be converted to logarithms separately.)\n\
4999 23: same as 3 except logarithmic y tick marks. (The y data\n\
5000 have to be converted to logarithms separately.)\n\
5001 30: same as 0 except logarithmic x and y tick marks. (The x\n\
5002 and y data have to be converted to logarithms separately.)\n\
5003 31: same as 1 except logarithmic x and y tick marks. (The x\n\
5004 and y data have to be converted to logarithms separately.)\n\
5005 32: same as 2 except logarithmic x and y tick marks. (The x\n\
5006 and y data have to be converted to logarithms separately.)\n\
5007 33: same as 3 except logarithmic x and y tick marks. (The x\n\
5008 and y data have to be converted to logarithms separately.)\n\
5009 40: same as 0 except date / time x labels.\n\
5010 41: same as 1 except date / time x labels.\n\
5011 42: same as 2 except date / time x labels.\n\
5012 43: same as 3 except date / time x labels.\n\
5013 50: same as 0 except date / time y labels.\n\
5014 51: same as 1 except date / time y labels.\n\
5015 52: same as 2 except date / time y labels.\n\
5016 53: same as 3 except date / time y labels.\n\
5017 60: same as 0 except date / time x and y labels.\n\
5018 61: same as 1 except date / time x and y labels.\n\
5019 62: same as 2 except date / time x and y labels.\n\
5020 63: same as 3 except date / time x and y labels.\n\
5021 70: same as 0 except custom x and y labels.\n\
5022 71: same as 1 except custom x and y labels.\n\
5023 72: same as 2 except custom x and y labels.\n\
5024 73: same as 3 except custom x and y labels.\n\
5027 Configure the transformations required for projecting a 3D surface on a 2D window\n\
5031 Configure the transformations required for projecting a 3D surface on\n\
5032 an existing 2D window. Those transformations (see the PLplot\n\
5033 documentation) are done to a rectangular cuboid enclosing the 3D\n\
5034 surface which has its limits expressed in 3D world coordinates and\n\
5035 also normalized 3D coordinates (used for interpreting the altitude and\n\
5036 azimuth of the viewing angle). The transformations consist of the\n\
5037 linear transform from 3D world coordinates to normalized 3D\n\
5038 coordinates, and the 3D rotation of normalized coordinates required to\n\
5039 align the pole of the new 3D coordinate system with the viewing\n\
5040 direction specified by altitude and azimuth so that x and y of the\n\
5041 surface elements in that transformed coordinate system are the\n\
5042 projection of the 3D surface with given viewing direction on the 2D\n\
5045 The enclosing rectangular cuboid for the surface plot is defined by\n\
5046 xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
5047 mapped into the same rectangular cuboid with normalized 3D coordinate\n\
5048 sizes of basex by basey by height so that xmin maps to -\n\
5049 basex/2, xmax maps to basex/2, ymin maps to -\n\
5050 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
5051 The resulting rectangular cuboid in normalized coordinates is then\n\
5052 viewed by an observer at altitude alt and azimuth az. This routine\n\
5053 must be called before plbox3 or any of the 3D surface plotting\n\
5054 routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
5055 plsurf3dl or plfill3.\n\
5057 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
5058 zmin, zmax, alt, az)\n\
5060 This function is examples 8, 11, 18, and 21.\n\
5066 plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
5070 basex (PLFLT, input) : The normalized x coordinate size of the\n\
5071 rectangular cuboid.\n\
5073 basey (PLFLT, input) : The normalized y coordinate size of the\n\
5074 rectangular cuboid.\n\
5076 height (PLFLT, input) : The normalized z coordinate size of the\n\
5077 rectangular cuboid.\n\
5079 xmin (PLFLT, input) : The minimum x world coordinate of the\n\
5080 rectangular cuboid.\n\
5082 xmax (PLFLT, input) : The maximum x world coordinate of the\n\
5083 rectangular cuboid.\n\
5085 ymin (PLFLT, input) : The minimum y world coordinate of the\n\
5086 rectangular cuboid.\n\
5088 ymax (PLFLT, input) : The maximum y world coordinate of the\n\
5089 rectangular cuboid.\n\
5091 zmin (PLFLT, input) : The minimum z world coordinate of the\n\
5092 rectangular cuboid.\n\
5094 zmax (PLFLT, input) : The maximum z world coordinate of the\n\
5095 rectangular cuboid.\n\
5097 alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
5098 plane of the rectangular cuboid in normalized coordinates.\n\
5100 az (PLFLT, input) : The viewing azimuth in degrees of the\n\
5101 rectangular cuboid in normalized coordinates. When az=0, the\n\
5102 observer is looking face onto the zx plane of the rectangular\n\
5103 cuboid in normalized coordinates, and as az is increased, the\n\
5104 observer moves clockwise around that cuboid when viewed from above\n\
5108 Draw filled polygon\n\
5112 Fills the polygon defined by the n points (\n\
5114 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
5115 style is a solid fill. The routine will automatically close the\n\
5116 polygon between the last and first vertices. If multiple closed\n\
5117 polygons are passed in x and y then plfill will fill in between them.\n\
5119 Redacted form: plfill(x,y)\n\
5121 This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
5131 n (PLINT, input) : Number of vertices in polygon.\n\
5133 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5136 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5140 Magnitude colored plot surface with contour\n\
5144 Aside from dropping the\n\
5145 side functionality this is a more powerful form of plot3d: the surface\n\
5146 mesh can be colored accordingly to the current z value being plotted,\n\
5147 a contour plot can be drawn at the base XY plane, and a curtain can be\n\
5148 drawn between the plotted function border and the base XY plane. The\n\
5149 arguments are identical to those of plmeshc. The only difference\n\
5150 between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
5151 the surface, while plot3dc only draws the surface as viewed from the\n\
5154 Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
5157 This function is used in example 21.\n\
5163 plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
5167 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5168 which the function is evaluated.\n\
5170 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5171 which the function is evaluated.\n\
5173 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5174 plot. Should have dimensions of\n\
5178 nx (PLINT, input) : Number of x values at which function is\n\
5181 ny (PLINT, input) : Number of y values at which function is\n\
5184 opt (PLINT, input) : Determines the way in which the surface is\n\
5185 represented. To specify more than one option just add the options,\n\
5186 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
5187 showing z as a function of x for each value of y[j] .\n\
5188 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5189 for each value of x[i] .\n\
5190 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5191 at which function is defined.\n\
5192 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
5193 the z value being plotted. The color is used from the current\n\
5195 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5199 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5200 the borders of the plotted function.\n\
5203 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
5206 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
5209 Write text relative to viewport boundaries\n\
5213 Writes text at a specified position relative to the viewport\n\
5214 boundaries. Text may be written inside or outside the viewport, but\n\
5215 is clipped at the subpage boundaries. The reference point of a string\n\
5216 lies along a line passing through the string at half the height of a\n\
5217 capital letter. The position of the reference point along this line\n\
5218 is determined by just, and the position of the reference point\n\
5219 relative to the viewport is set by disp and pos.\n\
5221 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
5224 This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
5231 plmtex(side, disp, pos, just, text)\n\
5235 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5236 the side of the viewport along which the text is to be written.\n\
5237 The string must be one of: b: Bottom of viewport, text written\n\
5238 parallel to edge.\n\
5239 bv: Bottom of viewport, text written at right angles to edge.\n\
5240 l: Left of viewport, text written parallel to edge.\n\
5241 lv: Left of viewport, text written at right angles to edge.\n\
5242 r: Right of viewport, text written parallel to edge.\n\
5243 rv: Right of viewport, text written at right angles to edge.\n\
5244 t: Top of viewport, text written parallel to edge.\n\
5245 tv: Top of viewport, text written at right angles to edge.\n\
5248 disp (PLFLT, input) : Position of the reference point of string,\n\
5249 measured outwards from the specified viewport edge in units of the\n\
5250 current character height. Use negative disp to write within the\n\
5253 pos (PLFLT, input) : Position of the reference point of string\n\
5254 along the specified edge, expressed as a fraction of the length of\n\
5257 just (PLFLT, input) : Specifies the position of the string relative\n\
5258 to its reference point. If just=0. , the reference point is at\n\
5259 the left and if just=1. , it is at the right of the string. Other\n\
5260 values of just give intermediate justifications.\n\
5262 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5266 Set arrow style for vector plots\n\
5270 Set the style for the arrow used by plvect to plot vectors.\n\
5272 Redacted form: plsvect(arrowx, arrowy, fill)\n\
5274 This function is used in example 22.\n\
5280 plsvect(arrowx, arrowy, npts, fill)\n\
5284 arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
5285 the x and y points which make up the arrow. The arrow is plotted\n\
5286 by joining these points to form a polygon. The scaling assumes\n\
5287 that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
5288 <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
5289 will be reset to its default.\n\
5291 npts (PLINT, input) : Number of points in the vectors arrowx and\n\
5294 fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
5295 fill is false then the arrow is open.\n\
5298 Get family file parameters\n\
5302 Gets information about current family file, if familying is enabled.\n\
5303 See the PLplot documentation for more information.\n\
5305 Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5307 This function is used in examples 14 and 31.\n\
5313 plgfam(p_fam, p_num, p_bmax)\n\
5317 p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5318 family flag value. If nonzero, familying is enabled for the\n\
5321 p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5322 family file number.\n\
5324 p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5325 file size (in bytes) for a family file.\n\
5328 Random number generator returning a real random number in the range [0,1]\n\
5332 Random number generator returning a real random number in the range\n\
5333 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
5334 / compilers provide their own random number generator, and so this is\n\
5335 provided purely for convenience and to give a consistent random number\n\
5336 generator across all languages supported by PLplot. This is\n\
5337 particularly useful for comparing results from the test suite of\n\
5340 Redacted form: plrandd()\n\
5342 This function is used in examples 17 and 21.\n\
5355 Draws a contour plot of the data in f[\n\
5357 ny], using the nlevel contour levels specified by clevel. Only the\n\
5358 region of the matrix from kx to lx and from ky to ly is plotted out\n\
5359 where all these index ranges are interpreted as one-based for\n\
5360 historical reasons. A transformation routine pointed to by pltr with\n\
5361 a generic pointer pltr_data for additional data required by the\n\
5362 transformation routine is used to map indices within the matrix to the\n\
5363 world coordinates.\n\
5365 Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5366 where (see above discussion) the pltr, pltr_data callback arguments\n\
5367 are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5368 vectors; or xg and yg matrices.\n\
5370 This function is used in examples 9, 14, 16, and 22.\n\
5376 plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5380 f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5382 nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5384 kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5385 kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5386 zero-based for historical backwards-compatibility reasons.\n\
5388 ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5389 ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5390 zero-based for historical backwards-compatibility reasons.\n\
5392 clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5393 which to draw contours.\n\
5395 nlevel (PLINT, input) : Number of contour levels to draw.\n\
5397 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5398 defines the transformation between the zero-based indices of the\n\
5399 matrix f and the world coordinates.For the C case, transformation\n\
5400 functions are provided in the PLplot library: pltr0 for the\n\
5401 identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5402 respectively defined by vectors and matrices. In addition, C\n\
5403 callback routines for the transformation can be supplied by the\n\
5404 user such as the mypltr function in examples/c/x09c.c which\n\
5405 provides a general linear transformation between index coordinates\n\
5406 and world coordinates.For languages other than C you should\n\
5407 consult the PLplot documentation for the details concerning how\n\
5408 PLTRANSFORM_callback arguments are interfaced. However, in\n\
5409 general, a particular pattern of callback-associated arguments\n\
5410 such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5411 yg matrices are respectively interfaced to a linear-transformation\n\
5412 routine similar to the above mypltr function; pltr1; and pltr2.\n\
5413 Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5414 the PLplot documentation) support native language callbacks for\n\
5415 handling index to world-coordinate transformations. Examples of\n\
5416 these various approaches are given in examples/<language>x09*,\n\
5417 examples/<language>x16*, examples/<language>x20*,\n\
5418 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5419 supported languages.\n\
5421 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5422 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5423 that is externally supplied.\n\
5430 This sets up the line style for all lines subsequently drawn. A line\n\
5431 consists of segments in which the pen is alternately down and up. The\n\
5432 lengths of these segments are passed in the vectors mark and space\n\
5433 respectively. The number of mark-space pairs is specified by nms. In\n\
5434 order to return the line style to the default continuous line, plstyl\n\
5435 should be called with nms =0 .(see also pllsty)\n\
5437 Redacted form: plstyl(mark, space)\n\
5439 This function is used in examples 1, 9, and 14.\n\
5445 plstyl(nms, mark, space)\n\
5449 nms (PLINT, input) : The number of mark and space elements in a\n\
5450 line. Thus a simple broken line can be obtained by setting nms=1\n\
5451 . A continuous line is specified by setting nms=0 .\n\
5453 mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
5454 segments during which the pen is down, measured in micrometers.\n\
5456 space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
5457 the segments during which the pen is up, measured in micrometers.\n\
5460 Set the cmap0 palette using the specified cmap0*.pal format file\n\
5464 Set the cmap0 palette using the specified cmap0*.pal format file.\n\
5466 Redacted form: plspal0(filename)\n\
5468 This function is in example 16.\n\
5474 plspal0(filename)\n\
5478 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5479 containing the name of the cmap0*.pal file. If this string is\n\
5480 empty, use the default cmap0*.pal file.\n\
5483 Set the cmap1 palette using the specified cmap1*.pal format file\n\
5487 Set the cmap1 palette using the specified cmap1*.pal format file.\n\
5489 Redacted form: plspal1(filename, interpolate)\n\
5491 This function is used in example 16.\n\
5497 plspal1(filename, interpolate)\n\
5501 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5502 containing the name of the cmap1*.pal file. If this string is\n\
5503 empty, use the default cmap1*.pal file.\n\
5505 interpolate (PLBOOL, input) : If this parameter is true, the\n\
5506 columns containing the intensity index, r, g, b, alpha and\n\
5507 alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
5508 palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
5509 a flag which controls whether the r, g, b data sent to plscmap1la\n\
5510 are interpreted as HLS or RGB.) If this parameter is false, the\n\
5511 intensity index and alt_hue_path columns are ignored and the r, g,\n\
5512 b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
5513 are used instead to set the cmap1 palette directly with a call to\n\
5517 Set current output stream\n\
5521 Sets the number of the current output stream. The stream number\n\
5522 defaults to 0 unless changed by this routine. The first use of this\n\
5523 routine must be followed by a call initializing PLplot (e.g. plstar).\n\
5525 Redacted form: plsstrm(strm)\n\
5527 This function is examples 1,14,20.\n\
5537 strm (PLINT, input) : The current stream number.\n\
5540 Specify viewport using normalized subpage coordinates\n\
5544 Device-independent routine for setting up the viewport. This defines\n\
5545 the viewport in terms of normalized subpage coordinates which run from\n\
5546 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
5547 current subpage. Use the alternate routine plsvpa in order to create\n\
5548 a viewport of a definite size.\n\
5550 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
5552 This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
5553 24, 26, 27, and 31.\n\
5559 plvpor(xmin, xmax, ymin, ymax)\n\
5563 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5564 left-hand edge of the viewport.\n\
5566 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5567 right-hand edge of the viewport.\n\
5569 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5570 bottom edge of the viewport.\n\
5572 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5573 edge of the viewport.\n\
5576 Write text inside the viewport\n\
5580 Writes text at a specified position and inclination within the\n\
5581 viewport. Text is clipped at the viewport boundaries. The reference\n\
5582 point of a string lies along a line passing through the string at half\n\
5583 the height of a capital letter. The position of the reference point\n\
5584 along this line is determined by just, the reference point is placed\n\
5585 at world coordinates (\n\
5587 y) within the viewport. The inclination of the string is specified\n\
5588 in terms of differences of world coordinates making it easy to write\n\
5589 text parallel to a line in a graph.\n\
5591 Redacted form: plptex(x, y, dx, dy, just, text)\n\
5593 This function is used in example 2-4,10,12-14,20,23,24,26.\n\
5599 plptex(x, y, dx, dy, just, text)\n\
5603 x (PLFLT, input) : x coordinate of reference point of string.\n\
5605 y (PLFLT, input) : y coordinate of reference point of string.\n\
5607 dx (PLFLT, input) : Together with dy, this specifies the\n\
5608 inclination of the string. The baseline of the string is parallel\n\
5609 to a line joining (\n\
5617 dy (PLFLT, input) : Together with dx, this specifies the\n\
5618 inclination of the string.\n\
5620 just (PLFLT, input) : Specifies the position of the string relative\n\
5621 to its reference point. If just=0. , the reference point is at\n\
5622 the left and if just=1. , it is at the right of the string. Other\n\
5623 values of just give intermediate justifications.\n\
5625 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5629 Set z axis parameters\n\
5633 Identical to plsxax, except that arguments are flags for z axis. See\n\
5634 the description of plsxax for more detail.\n\
5636 Redacted form: plszax(digmax, digits)\n\
5638 This function is used in example 31.\n\
5644 plszax(digmax, digits)\n\
5648 digmax (PLINT, input) : Variable to set the maximum number of\n\
5649 digits for the z axis. If nonzero, the printed label will be\n\
5650 switched to a floating-point representation when the number of\n\
5651 digits exceeds digmax.\n\
5653 digits (PLINT, input) : Field digits value. Currently, changing\n\
5654 its value here has no effect since it is set only by plbox or\n\
5655 plbox3. However, the user may obtain its value after a call to\n\
5656 either of these functions by calling plgzax.\n\
5659 Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
5663 This variant of plsurf3d (see that function\'s documentation for more\n\
5664 details) should be suitable for the case where the area of the x, y\n\
5665 coordinate grid where z is defined can be non-rectangular. The limits\n\
5666 of that grid are provided by the parameters indexxmin, indexxmax,\n\
5667 indexymin, and indexymax.\n\
5669 Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
5672 This function is used in example 8.\n\
5678 plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
5682 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5683 which the function is evaluated.\n\
5685 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5686 which the function is evaluated.\n\
5688 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5689 plot. Should have dimensions of\n\
5693 nx (PLINT, input) : Number of x values at which function is\n\
5696 ny (PLINT, input) : Number of y values at which function is\n\
5699 opt (PLINT, input) : Determines the way in which the surface is\n\
5700 represented. To specify more than one option just add the options,\n\
5701 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
5702 connecting points at which function is defined.\n\
5703 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5707 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
5711 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5712 the borders of the plotted function.\n\
5713 opt=MAG_COLOR : the surface is colored according to the value\n\
5714 of Z; if MAG_COLOR is not used, then the surface is colored\n\
5715 according to the intensity of the reflected light in the\n\
5716 surface from a light source whose position is set using\n\
5720 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
5723 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
5725 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
5726 corresponds to the first x index where z is defined.\n\
5728 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
5729 which corresponds (by convention) to one more than the last x\n\
5730 index value where z is defined.\n\
5732 indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
5733 values which all must be ≥ 0. These values are the first y index\n\
5734 where z is defined for a particular x index in the range from\n\
5735 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
5738 indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
5739 values which all must be ≤ ny. These values correspond (by\n\
5740 convention) to one more than the last y index where z is defined\n\
5741 for a particular x index in the range from indexxmin to indexxmax\n\
5742 - 1. The dimension of indexymax is indexxmax.\n\
5749 Sets the font used for subsequent text and symbols. For devices that\n\
5750 still use Hershey fonts this routine has no effect unless the Hershey\n\
5751 fonts with extended character set are loaded (see plfontld). For\n\
5752 unicode-aware devices that use system fonts instead of Hershey fonts,\n\
5753 this routine calls the plsfci routine with argument set up\n\
5754 appropriately for the various cases below. However, this method of\n\
5755 specifying the font for unicode-aware devices is deprecated, and the\n\
5756 much more flexible method of calling plsfont directly is recommended\n\
5757 instead (where plsfont provides a user-friendly interface to plsfci),\n\
5759 Redacted form: plfont(ifont)\n\
5761 This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
5771 ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
5772 (simplest and fastest)\n\
5778 Get the cmap1 argument range for continuous color plots\n\
5782 Get the cmap1 argument range for continuous color plots. (Use\n\
5783 plscmap1_range to set the cmap1 argument range.)\n\
5785 Redacted form: plgcmap1_range(min_color, max_color)\n\
5787 This function is currently not used in any example.\n\
5793 plgcmap1_range(min_color, max_color)\n\
5797 min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5798 minimum cmap1 argument.\n\
5800 max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5801 maximum cmap1 argument.\n\
5804 Set the cmap1 argument range for continuous color plots\n\
5808 Set the cmap1 argument range for continuous color plots that\n\
5809 corresponds to the range of data values. The maximum range\n\
5810 corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
5811 the cmap1 argument range that is specified with this routine, the\n\
5812 smaller the subset of the cmap1 color palette that is used to\n\
5813 represent the continuous data being plotted. If\n\
5814 min_color is greater than\n\
5816 max_color is greater than 1.0 or\n\
5817 min_color is less than 0.0 then no change is made to the cmap1\n\
5818 argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
5820 Redacted form: plscmap1_range(min_color, max_color)\n\
5822 This function is currently used in example 33.\n\
5828 plscmap1_range(min_color, max_color)\n\
5832 min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
5833 than 0.0, then 0.0 is used instead.\n\
5835 max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
5836 than 1.0, then 1.0 is used instead.\n\
5839 Draw a circular or elliptical arc\n\
5843 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
5844 semiminor axis b, starting at angle1 and ending at angle2.\n\
5846 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
5850 This function is used in examples 3 and 27.\n\
5856 plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
5860 x (PLFLT, input) : X coordinate of arc center.\n\
5862 y (PLFLT, input) : Y coordinate of arc center.\n\
5864 a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
5866 b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
5868 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
5871 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
5874 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
5877 fill (PLBOOL, input) : Draw a filled arc.\n\
5880 Plot 3-d surface plot\n\
5884 Plots a three-dimensional surface plot within the environment set up\n\
5885 by plw3d. The surface is defined by the matrix z[\n\
5887 ny] , the point z[i][j] being the value of the function at (\n\
5889 y[j]). Note that the points in vectors x and y do not need to be\n\
5890 equally spaced, but must be stored in ascending order. The parameter\n\
5891 opt controls the way in which the surface is displayed. For further\n\
5892 details see the PLplot documentation. The only difference between\n\
5893 plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5894 while plot3d only draws the surface as viewed from the top.\n\
5896 Redacted form: plot3d(x, y, z, opt, side)\n\
5898 This function is used in examples 11 and 21.\n\
5904 plot3d(x, y, z, nx, ny, opt, side)\n\
5908 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5909 which the function is evaluated.\n\
5911 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5912 which the function is evaluated.\n\
5914 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5915 plot. Should have dimensions of\n\
5919 nx (PLINT, input) : Number of x values at which function is\n\
5922 ny (PLINT, input) : Number of y values at which function is\n\
5925 opt (PLINT, input) : Determines the way in which the surface is\n\
5926 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5927 function of x for each value of y[j] .\n\
5928 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5929 for each value of x[i] .\n\
5930 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5931 at which function is defined.\n\
5934 side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5935 should be draw on the figure. If side is true sides are drawn,\n\
5936 otherwise no sides are drawn.\n\
5939 Set area line fill pattern\n\
5943 Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
5944 The pattern consists of 1 or 2 sets of parallel lines with specified\n\
5945 inclinations and spacings. The arguments to this routine are the\n\
5946 number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
5947 elements) specifying the inclinations in tenths of a degree and the\n\
5948 spacing in micrometers. (See also plpsty)\n\
5950 Redacted form: General: plpat(inc, del)\n\
5953 This function is used in example 15.\n\
5959 plpat(nlin, inc, del)\n\
5963 nlin (PLINT, input) : Number of sets of lines making up the\n\
5964 pattern, either 1 or 2.\n\
5966 inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5967 inclination in tenths of a degree. (Should be between -900 and\n\
5970 del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5971 spacing in micrometers between the lines making up the pattern.\n\
5974 Get x axis parameters\n\
5978 Returns current values of the p_digmax and p_digits flags for the x\n\
5979 axis. p_digits is updated after the plot is drawn, so this routine\n\
5980 should only be called after the call to plbox (or plbox3) is complete.\n\
5981 See the PLplot documentation for more information.\n\
5983 Redacted form: plgxax(p_digmax, p_digits)\n\
5985 This function is used in example 31.\n\
5991 plgxax(p_digmax, p_digits)\n\
5995 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5996 number of digits for the x axis. If nonzero, the printed label\n\
5997 has been switched to a floating-point representation when the\n\
5998 number of digits exceeds this value.\n\
6000 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
6001 number of digits for the numeric labels (x axis) from the last\n\
6005 Draw filled polygon in 3D\n\
6009 Fills the 3D polygon defined by the n points in the x, y, and z\n\
6010 vectors using the pattern defined by plpsty or plpat. The routine\n\
6011 will automatically close the polygon between the last and first\n\
6012 vertices. If multiple closed polygons are passed in x, y, and z then\n\
6013 plfill3 will fill in between them.\n\
6015 Redacted form: General: plfill3(x, y, z)\n\
6018 This function is used in example 15.\n\
6024 plfill3(n, x, y, z)\n\
6028 n (PLINT, input) : Number of vertices in polygon.\n\
6030 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6033 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6036 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
6044 Sets the color index for cmap0 (see the PLplot documentation).\n\
6046 Redacted form: plcol0(icol0)\n\
6048 This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6058 icol0 (PLINT, input) : Integer representing the color. The\n\
6059 defaults at present are (these may change):\n\
6060 0 black (default background)\n\
6061 1 red (default foreground)\n\
6077 Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6078 change an individual color in the cmap0 color palette.\n\
6081 Draw text at points defined by Shapefile data in world coordinates\n\
6085 As per plmapline, however the items are plotted as text in the same\n\
6088 Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
6089 miny, maxy, plotentry)\n\
6091 This function is used in example 19.\n\
6097 plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
6101 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6102 transform the coordinates given in the shapefile into a plot\n\
6103 coordinate system. By using this transform, we can change from a\n\
6104 longitude, latitude coordinate to a polar stereographic project,\n\
6105 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6106 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6107 mapform(), x[] and y[] should be replaced by the corresponding\n\
6108 plot coordinates. If no transform is desired, mapform can be\n\
6109 replaced by NULL.\n\
6111 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6112 the file name of a set of Shapefile files without the file\n\
6115 dx (PLFLT, input) : Used to define the slope of the texts which is\n\
6118 dy (PLFLT, input) : Used to define the slope of the texts which is\n\
6121 just (PLFLT, input) : Set the justification of the text. The value\n\
6122 given will be the fraction of the distance along the string that\n\
6123 sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
6124 centralized text and 1.0 gives right aligned text.\n\
6126 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
6128 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6129 be in the same units as used by the Shapefile. You could use a\n\
6130 very large negative number to plot everything, but you can improve\n\
6131 performance by limiting the area drawn. The units must match those\n\
6132 of the Shapefile projection, which may be for example longitude or\n\
6133 distance. The value of minx must be less than the value of maxx.\n\
6135 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6136 use a very large number to plot everything, but you can improve\n\
6137 performance by limiting the area drawn.\n\
6139 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6140 be in the same units as used by the Shapefile. You could use a\n\
6141 very large negative number to plot everything, but you can improve\n\
6142 performance by limiting the area drawn. The units must match those\n\
6143 of the Shapefile projection, which may be for example latitude or\n\
6144 distance. The value of miny must be less than the value of maxy.\n\
6146 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6147 use a very large number to plot everything, but you can improve\n\
6148 performance by limiting the area drawn.\n\
6150 plotentry (PLINT, input) : An integer indicating which text string\n\
6151 of the Shapefile (zero indexed) will be drawn.\n\
6154 Draw a line between two points\n\
6158 Joins the point (\n\
6164 Redacted form: pljoin(x1,y1,x2,y2)\n\
6166 This function is used in examples 3 and 14.\n\
6172 pljoin(x1, y1, x2, y2)\n\
6176 x1 (PLFLT, input) : x coordinate of first point.\n\
6178 y1 (PLFLT, input) : y coordinate of first point.\n\
6180 x2 (PLFLT, input) : x coordinate of second point.\n\
6182 y2 (PLFLT, input) : y coordinate of second point.\n\
6189 Sets the color for cmap1 (see the PLplot documentation).\n\
6191 Redacted form: plcol1(col1)\n\
6193 This function is used in examples 12 and 21.\n\
6203 col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6204 is mapped to color using the continuous cmap1 palette which by\n\
6205 default ranges from blue to the background color to red. The\n\
6206 cmap1 palette can also be straightforwardly changed by the user\n\
6207 with plscmap1 or plscmap1l.\n\
6214 Set integer plot orientation parameter. This function is identical to\n\
6215 plsdiori except for the type of the argument, and should be used in\n\
6216 the same way. See the documentation of plsdiori for details.\n\
6218 Redacted form: plsori(ori)\n\
6220 This function is used in example 3.\n\
6230 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
6231 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
6235 Calculate continuous time from broken-down time for the current stream\n\
6239 Calculate continuous time, ctime, from broken-down time for the\n\
6240 current stream. The broken-down\n\
6241 time is specified by the following parameters: year, month, day, hour,\n\
6242 min, and sec. This function is the inverse of plbtime.\n\
6244 The PLplot definition of broken-down time is a calendar time that\n\
6245 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6246 responsibility to apply those offsets (if so desired) before using the\n\
6247 PLplot time API. By default broken-down time is defined using the\n\
6248 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6249 continuous time is defined as the number of seconds since the Unix\n\
6250 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6251 broken-down and continuous time are possible, see plconfigtime which\n\
6252 specifies that transformation for the current stream.\n\
6254 Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6258 This function is used in example 29.\n\
6264 plctime(year, month, day, hour, min, sec, ctime)\n\
6268 year (PLINT, input) : Input year.\n\
6270 month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6273 day (PLINT, input) : Input day in range from 1 to 31.\n\
6275 hour (PLINT, input) : Input hour in range from 0 to 23\n\
6277 min (PLINT, input) : Input minute in range from 0 to 59.\n\
6279 sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6281 ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6282 time calculated from the broken-down time specified by the\n\
6283 previous parameters.\n\
6286 Plot continental outline or shapefile data in world coordinates\n\
6290 Plots continental outlines or shapefile data in world coordinates. A\n\
6291 demonstration of how to use this function to create different\n\
6292 projections can be found in examples/c/x19c. PLplot is provided with\n\
6293 basic coastal outlines and USA state borders. To use the map\n\
6294 functionality PLplot must be compiled with the shapelib library.\n\
6295 Shapefiles have become a popular standard for geographical data and\n\
6296 data in this format can be easily found from a number of online\n\
6297 sources. Shapefile data is actually provided as three or more files\n\
6298 with the same filename, but different extensions. The .shp and .shx\n\
6299 files are required for plotting Shapefile data with PLplot.\n\
6301 PLplot currently supports the point, multipoint, polyline and polygon\n\
6302 objects within shapefiles. However holes in polygons are not\n\
6303 supported. When plmap is used the type of object is derived from the\n\
6304 shapefile, if you wish to override the type then use one of the other\n\
6305 plmap variants. The built in maps have line data only.\n\
6307 Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
6309 This function is used in example 19.\n\
6315 plmap(mapform, name, minx, maxx, miny, maxy)\n\
6319 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6320 transform the original map data coordinates to a new coordinate\n\
6321 system. The PLplot-supplied map data is provided as latitudes and\n\
6322 longitudes; other Shapefile data may be provided in other\n\
6323 coordinate systems as can be found in their .prj plain text files.\n\
6324 For example, by using this transform we can change from a\n\
6325 longitude, latitude coordinate to a polar stereographic\n\
6326 projection. Initially, x[0]..[n-1] are the original x coordinates\n\
6327 (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
6328 corresponding y coordinates (latitudes for the PLplot supplied\n\
6329 data). After the call to mapform(), x[] and y[] should be\n\
6330 replaced by the corresponding plot coordinates. If no transform is\n\
6331 desired, mapform can be replaced by NULL.\n\
6333 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6334 the type of map plotted. This is either one of the PLplot built-in\n\
6335 maps or the file name of a set of Shapefile files without the file\n\
6336 extensions. For the PLplot built-in maps the possible values are:\n\
6337 \"globe\" -- continental outlines\n\
6338 \"usa\" -- USA and state boundaries\n\
6339 \"cglobe\" -- continental outlines and countries\n\
6340 \"usaglobe\" -- USA, state boundaries and continental outlines\n\
6343 minx (PLFLT, input) : The minimum x value of map elements to be\n\
6344 drawn. The units must match the shapefile (built in maps are\n\
6345 degrees lat/lon). Objects in the file which do not encroach on the\n\
6346 box defined by minx, maxx, miny, maxy will not be rendered. But\n\
6347 note this is simply an optimisation, not a clipping so for objects\n\
6348 with some points inside the box and some points outside the box\n\
6349 all the points will be rendered. These parameters also define\n\
6350 latitude and longitude wrapping for shapefiles using these units.\n\
6351 Longitude points will be wrapped by integer multiples of 360\n\
6352 degrees to place them in the box. This allows the same data to be\n\
6353 used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
6354 you plot from -180-540 you will get two cycles of data drawn. The\n\
6355 value of minx must be less than the value of maxx. Passing in a\n\
6356 nan, max/-max floating point number or +/-infinity will case the\n\
6357 bounding box from the shapefile to be used.\n\
6359 maxx (PLFLT, input) : The maximum x value of map elements to be\n\
6360 drawn - see minx.\n\
6362 miny (PLFLT, input) : The minimum y value of map elements to be\n\
6363 drawn - see minx.\n\
6365 maxy (PLFLT, input) : The maximum y value of map elements to be\n\
6366 drawn - see minx.\n\
6369 Calculate broken-down time from continuous time for the current stream\n\
6373 Calculate broken-down time; year, month, day, hour, min, sec; from\n\
6374 continuous time, ctime for the current stream. This function is the\n\
6375 inverse of plctime.\n\
6377 The PLplot definition of broken-down time is a calendar time that\n\
6378 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6379 responsibility to apply those offsets (if so desired) before using the\n\
6380 PLplot time API. By default broken-down time is defined using the\n\
6381 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6382 continuous time is defined as the number of seconds since the Unix\n\
6383 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6384 broken-down and continuous time are possible, see plconfigtime.\n\
6386 Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
6390 This function is used in example 29.\n\
6396 plbtime(year, month, day, hour, min, sec, ctime)\n\
6400 year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
6401 positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
6402 non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
6405 month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
6406 the year in the range from 0 (January) to 11 (December).\n\
6408 day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
6409 month in the range from 1 to 31.\n\
6411 hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
6412 day in the range from 0 to 23.\n\
6414 min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
6415 hour in the range from 0 to 59\n\
6417 sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
6418 minute in range from 0. to 60.\n\
6420 ctime (PLFLT, input) : Continuous time from which the broken-down\n\
6421 time is calculated.\n\
6424 Get current stream number\n\
6428 Gets the number of the current output stream. See also plsstrm.\n\
6430 Redacted form: plgstrm(p_strm)\n\
6432 This function is used in example 1,20.\n\
6442 p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6446 Draw a line in 3 space\n\
6450 Draws line in 3 space defined by n points in x, y, and z. You must\n\
6451 first set up the viewport, the 2d viewing window (in world\n\
6452 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
6455 Redacted form: plline3(x, y, z)\n\
6457 This function is used in example 18.\n\
6463 plline3(n, x, y, z)\n\
6467 n (PLINT, input) : Number of points defining line.\n\
6469 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6472 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6475 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
6479 Load Hershey fonts\n\
6483 Loads the Hershey fonts used for text and symbols. This routine may\n\
6484 be called before or after initializing PLplot. If not explicitly\n\
6485 called before PLplot initialization, then by default that\n\
6486 initialization loads Hershey fonts with the extended character set.\n\
6487 This routine only has a practical effect for devices that still use\n\
6488 Hershey fonts (as opposed to modern devices that use unicode-aware\n\
6489 system fonts instead of Hershey fonts).\n\
6491 Redacted form: plfontld(fnt)\n\
6493 This function is used in examples 1 and 7.\n\
6503 fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
6504 A zero value specifies Hershey fonts with the standard character\n\
6505 set and a non-zero value (the default assumed if plfontld is never\n\
6506 called) specifies Hershey fonts with the extended character set.\n\
6509 Set any command-line option\n\
6513 Set any command-line option internally from a program before it\n\
6514 invokes plinit. opt is the name of the command-line option and optarg\n\
6515 is the corresponding command-line option argument.\n\
6517 This function returns 0 on success.\n\
6519 Redacted form: plsetopt(opt, optarg)\n\
6521 This function is used in example 14.\n\
6527 PLINT plsetopt(opt, optarg)\n\
6531 opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6532 the command-line option.\n\
6534 optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
6535 containing the argument of the command-line option.\n\
6538 Plot all or a subset of Shapefile data using lines in world coordinates\n\
6542 Plot all or a subset of Shapefile data using lines in world\n\
6543 coordinates. Our 19th standard example demonstrates how to use this\n\
6544 function. This function plots data from a Shapefile using lines as in\n\
6545 plmap, however it also has the option of also only drawing specified\n\
6546 elements from the Shapefile. The vector of indices of the required\n\
6547 elements are passed as a function argument. The Shapefile data should\n\
6548 include a metadata file (extension.dbf) listing all items within the\n\
6549 Shapefile. This file can be opened by most popular spreadsheet\n\
6550 programs and can be used to decide which indices to pass to this\n\
6553 Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
6556 This function is used in example 19.\n\
6562 plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6566 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6567 transform the coordinates given in the shapefile into a plot\n\
6568 coordinate system. By using this transform, we can change from a\n\
6569 longitude, latitude coordinate to a polar stereographic project,\n\
6570 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6571 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6572 mapform(), x[] and y[] should be replaced by the corresponding\n\
6573 plot coordinates. If no transform is desired, mapform can be\n\
6574 replaced by NULL.\n\
6576 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6577 the file name of a set of Shapefile files without the file\n\
6580 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6581 be in the same units as used by the Shapefile. You could use a\n\
6582 very large negative number to plot everything, but you can improve\n\
6583 performance by limiting the area drawn. The units must match those\n\
6584 of the Shapefile projection, which may be for example longitude or\n\
6585 distance. The value of minx must be less than the value of maxx.\n\
6587 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6588 use a very large number to plot everything, but you can improve\n\
6589 performance by limiting the area drawn.\n\
6591 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6592 be in the same units as used by the Shapefile. You could use a\n\
6593 very large negative number to plot everything, but you can improve\n\
6594 performance by limiting the area drawn. The units must match those\n\
6595 of the Shapefile projection, which may be for example latitude or\n\
6596 distance. The value of miny must be less than the value of maxy.\n\
6598 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6599 use a very large number to plot everything, but you can improve\n\
6600 performance by limiting the area drawn.\n\
6602 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6603 zero-based indices of the Shapefile elements which will be drawn.\n\
6605 plotentries to NULL will plot all elements of the Shapefile.\n\
6607 nplotentries (PLINT, input) : The number of items in\n\
6608 plotentries. Ignored if\n\
6609 plotentries is NULL.\n\
6612 Used to globally turn color output on/off\n\
6616 Used to globally turn color output on/off for those drivers/devices\n\
6619 Redacted form: plscolor(color)\n\
6621 This function is used in example 31.\n\
6631 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6632 turned off. If non-zero, color is turned on.\n\
6635 Wait for graphics input event and translate to world coordinates.\n\
6639 Wait for graphics input event and translate to world coordinates.\n\
6640 Returns 0 if no translation to world coordinates is possible.\n\
6642 This function returns 1 on success and 0 if no translation to world\n\
6643 coordinates is possible.\n\
6645 Redacted form: plGetCursor(gin)\n\
6647 This function is used in examples 1 and 20.\n\
6653 PLINT plGetCursor(gin)\n\
6657 gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
6658 which will contain the output. The structure is not allocated by\n\
6659 the routine and must exist before the function is called.\n\
6662 Get the current device (keyword) name\n\
6666 Get the current device (keyword) name. Note: you must have allocated\n\
6667 space for this (80 characters is safe).\n\
6669 Redacted form: plgdev(p_dev)\n\
6671 This function is used in example 14.\n\
6681 p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
6682 (with preallocated length of 80 characters or more) containing the\n\
6683 device (keyword) name.\n\
6686 Add a point to a strip chart\n\
6690 Add a point to a given pen of a given strip chart. There is no need\n\
6691 for all pens to have the same number of points or to be equally\n\
6692 sampled in the x coordinate. Allocates memory and rescales as\n\
6695 Redacted form: plstripa(id, pen, x, y)\n\
6697 This function is used in example 17.\n\
6703 plstripa(id, pen, x, y)\n\
6707 id (PLINT, input) : Identification number of the strip chart (set\n\
6710 pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
6712 x (PLFLT, input) : X coordinate of point to plot.\n\
6714 y (PLFLT, input) : Y coordinate of point to plot.\n\
6717 Create a 4-pen strip chart\n\
6721 Create a 4-pen strip chart, to be used afterwards by plstripa\n\
6723 Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
6724 ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
6725 styline, legline, labx, laby, labz)\n\
6728 This function is used in example 17.\n\
6734 plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
6738 id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
6739 number of the strip chart to use on plstripa and plstripd.\n\
6741 xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6742 the x-axis specification as in plbox.\n\
6744 yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6745 the y-axis specification as in plbox.\n\
6747 xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6748 change as data are added.\n\
6750 xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6751 change as data are added.\n\
6753 xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
6754 is multiplied by the factor (1 +\n\
6757 ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6758 change as data are added.\n\
6760 ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6761 change as data are added.\n\
6763 xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
6765 ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
6767 y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
6768 true, otherwise not.\n\
6770 acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
6771 otherwise slide display.\n\
6773 colbox (PLINT, input) : Plot box color index (cmap0).\n\
6775 collab (PLINT, input) : Legend color index (cmap0).\n\
6777 colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
6778 indices for the 4 pens.\n\
6780 styline (PLINT_VECTOR, input) : A vector containing the line style\n\
6781 indices for the 4 pens.\n\
6783 legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
6784 strings containing legends for the 4 pens.\n\
6786 labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6787 the label for the x axis.\n\
6789 laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6790 the label for the y axis.\n\
6792 labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6796 Deletes and releases memory used by a strip chart\n\
6800 Deletes and releases memory used by a strip chart.\n\
6802 Redacted form: plstripd(id)\n\
6804 This function is used in example 17.\n\
6814 id (PLINT, input) : Identification number of strip chart to delete.\n\
6817 Specify viewport using coordinates and aspect ratio\n\
6821 Device-independent routine for setting up the viewport. The viewport\n\
6822 is chosen to be the largest with the given aspect ratio that fits\n\
6823 within the specified region (in terms of normalized subpage\n\
6824 coordinates). This routine is functionally equivalent to plvpor when\n\
6825 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
6826 routine reserves no extra space at the edges for labels.\n\
6828 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6830 This function is used in example 9.\n\
6836 plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6840 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
6841 left-hand edge of the viewport.\n\
6843 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
6844 right-hand edge of the viewport.\n\
6846 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
6847 bottom edge of the viewport.\n\
6849 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
6850 edge of the viewport.\n\
6852 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
6856 Assign a function to use for generating custom axis labels\n\
6860 This function allows a user to provide their own function to provide\n\
6861 axis label text. The user function is given the numeric value for a\n\
6862 point on an axis and returns a string label to correspond with that\n\
6863 value. Custom axis labels can be enabled by passing appropriate\n\
6864 arguments to plenv, plbox, plbox3 and similar functions.\n\
6866 This function is used in example 19.\n\
6872 plslabelfunc(label_func, label_data)\n\
6876 label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
6877 label function. In order to reset to the default labelling, set\n\
6878 this to NULL. The labelling function parameters are, in order:\n\
6879 axis: This indicates which axis a label is being requested for.\n\
6880 The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
6882 value: This is the value along the axis which is being labelled.\n\
6884 label_text: The string representation of the label value.\n\
6886 length: The maximum length in characters allowed for label_text.\n\
6889 label_data (PLPointer, input) : This parameter may be used to pass\n\
6890 data to the label_func function.\n\
6893 Set length of major ticks\n\
6897 This sets up the length of the major ticks. The actual length is the\n\
6898 product of the default length and a scaling factor as for character\n\
6901 Redacted form: plsmaj(def, scale)\n\
6903 This function is used in example 29.\n\
6909 plsmaj(def, scale)\n\
6913 def (PLFLT, input) : The default length of a major tick in\n\
6914 millimeters, should be set to zero if the default length is to\n\
6915 remain unchanged.\n\
6917 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6918 actual tick length.\n\
6921 Get the current library version number\n\
6925 Get the current library version number. Note: you must have allocated\n\
6926 space for this (80 characters is safe).\n\
6928 Redacted form: plgver(p_ver)\n\
6930 This function is used in example 1.\n\
6940 p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
6941 (with preallocated length of 80 characters or more) containing the\n\
6942 PLplot version number.\n\
6945 Set format of numerical label for contours\n\
6949 Set format of numerical label for contours.\n\
6951 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
6953 This function is used example 9.\n\
6959 pl_setcontlabelformat(lexp, sigdig)\n\
6963 lexp (PLINT, input) : If the contour numerical label is greater\n\
6964 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
6965 format is used. Default value of lexp is 4.\n\
6967 sigdig (PLINT, input) : Number of significant digits. Default\n\
6971 Parse command-line arguments\n\
6975 Parse command-line arguments.\n\
6977 plparseopts removes all recognized flags (decreasing argc\n\
6978 accordingly), so that invalid input may be readily detected. It can\n\
6979 also be used to process user command line flags. The user can merge\n\
6980 an option table of type PLOptionTable into the internal option table\n\
6981 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
6982 the external table(s) be parsed by calling plClearOpts before\n\
6985 The default action taken by plparseopts is as follows:\n\
6986 Returns with an error if an unrecognized option or badly formed\n\
6987 option-value pair are encountered.\n\
6988 Returns immediately (return code 0) when the first non-option command\n\
6989 line argument is found.\n\
6990 Returns with the return code of the option handler, if one was called.\n\
6992 Deletes command line arguments from argv list as they are found, and\n\
6993 decrements argc accordingly.\n\
6994 Does not show \"invisible\" options in usage or help messages.\n\
6995 Assumes the program name is contained in argv[0].\n\
6997 These behaviors may be controlled through the\n\
7000 Redacted form: General: plparseopts(argv, mode)\n\
7003 This function is used in all of the examples.\n\
7009 PLINT plparseopts(p_argc, argv, mode)\n\
7013 p_argc (int *, input/output) : Number of arguments.\n\
7015 argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
7016 strings containing *p_argc command-line arguments.\n\
7018 mode (PLINT, input) : Parsing mode with the following\n\
7019 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
7020 and all error messages enabled, including program exit when an\n\
7021 error occurs. Anything on the command line that isn\'t recognized\n\
7022 as a valid option or option argument is flagged as an error.\n\
7023 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
7025 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
7027 PL_PARSE_SHOWALL (8) -- Show invisible options\n\
7028 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
7029 pointer to the program name.\n\
7030 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
7031 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
7032 unrecognized arguments.\n\
7039 Initializing the plotting package. The program prompts for the device\n\
7040 keyword or number of the desired output device. Hitting a RETURN in\n\
7041 response to the prompt is the same as selecting the first device. If\n\
7042 only one device is enabled when PLplot is installed, plstar will issue\n\
7043 no prompt. The output device is divided into nx by ny subpages, each\n\
7044 of which may be used independently. The subroutine pladv is used to\n\
7045 advance from one subpage to the next.\n\
7047 Redacted form: plstar(nx, ny)\n\
7049 This function is used in example 1.\n\
7059 nx (PLINT, input) : Number of subpages to divide output page in the\n\
7062 ny (PLINT, input) : Number of subpages to divide output page in the\n\
7066 Get FCI (font characterization integer)\n\
7070 Gets information about the current font using the FCI approach. See\n\
7071 the PLplot documentation for more information.\n\
7073 Redacted form: plgfci(p_fci)\n\
7075 This function is used in example 23.\n\
7085 p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
7089 Set family file parameters\n\
7093 Sets variables dealing with output file familying. Does nothing if\n\
7094 familying not supported by the driver. This routine, if used, must be\n\
7095 called before initializing PLplot. See the PLplot documentation for\n\
7096 more information.\n\
7098 Redacted form: plsfam(fam, num, bmax)\n\
7100 This function is used in examples 14 and 31.\n\
7106 plsfam(fam, num, bmax)\n\
7110 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
7113 num (PLINT, input) : Current family file number.\n\
7115 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
7119 Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
7123 This is a variant of plscmap1l that supports alpha channel\n\
7124 transparency. It sets cmap1 colors using a piece-wise linear\n\
7125 relationship between cmap1 intensity index (0.0-1.0) and position in\n\
7126 HLS or RGB color space (see the PLplot documentation) with alpha\n\
7127 transparency value (0.0-1.0). It may be called at any time.\n\
7129 Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
7130 alpha, alt_hue_path)\n\
7132 This function is used in example 30.\n\
7138 plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
7142 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
7144 npts (PLINT, input) : number of control points.\n\
7146 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
7147 intensity index (0.0-1.0) in ascending order for each control\n\
7150 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
7151 coordinate (H or R) for each control point.\n\
7153 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
7154 coordinate (L or G) for each control point.\n\
7156 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
7157 coordinate (S or B) for each control point.\n\
7159 alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
7160 transparency value (0.0-1.0) for each control point.\n\
7162 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
7163 npts - 1 elements) containing the alternative interpolation method\n\
7164 Boolean value for each control point interval. (alt_hue_path[i]\n\
7165 refers to the interpolation interval between the i and i + 1\n\
7169 Set page parameters\n\
7173 Sets the page configuration (optional). If an individual parameter is\n\
7174 zero then that parameter value is not updated. Not all parameters are\n\
7175 recognized by all drivers and the interpretation is device-dependent.\n\
7176 The X-window driver uses the length and offset parameters to determine\n\
7177 the window size and location. The length and offset values are\n\
7178 expressed in units that are specific to the current driver. For\n\
7179 instance: screen drivers will usually interpret them as number of\n\
7180 pixels, whereas printer drivers will usually use mm.\n\
7182 This routine, if used, must be called before initializing PLplot. It\n\
7183 may be called at later times for interactive drivers to change only\n\
7184 the dpi for subsequent redraws which you can force via a call to\n\
7185 plreplot. If this function is not called then the page size defaults\n\
7186 to landscape A4 for drivers which use real world page sizes and 744\n\
7187 pixels wide by 538 pixels high for raster drivers. The default value\n\
7188 for dx and dy is 90 pixels per inch for raster drivers.\n\
7192 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
7194 This function is used in examples 14 and 31.\n\
7200 plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
7204 xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
7205 by raster drivers, ignored by drivers which use \"real world\" units\n\
7208 yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
7209 by raster drivers, ignored by drivers which use \"real world\" units\n\
7212 xleng (PLINT, input) : Page length, x.\n\
7214 yleng (PLINT, input) : Page length, y.\n\
7216 xoff (PLINT, input) : Page offset, x.\n\
7218 yoff (PLINT, input) : Page offset, y.\n\
7221 Set precision in numeric labels\n\
7225 Sets the number of places after the decimal point in numeric labels.\n\
7227 Redacted form: plprec(setp, prec)\n\
7229 This function is used in example 29.\n\
7235 plprec(setp, prec)\n\
7239 setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7240 automatically determines the number of places to use after the\n\
7241 decimal point in numeric labels (like those used to label axes).\n\
7242 If setp is 1 then prec sets the number of places.\n\
7244 prec (PLINT, input) : The number of characters to draw after the\n\
7245 decimal point in numeric labels.\n\
7248 Copy state parameters from the reference stream to the current stream\n\
7252 Copies state parameters from the reference stream to the current\n\
7253 stream. Tell driver interface to map device coordinates unless flags\n\
7256 This function is used for making save files of selected plots (e.g.\n\
7257 from the TK driver). After initializing, you can get a copy of the\n\
7258 current plot to the specified device by switching to this stream and\n\
7259 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
7260 appropriate. The plot buffer must have previously been enabled (done\n\
7261 automatically by some display drivers, such as X).\n\
7263 Redacted form: plcpstrm(iplsr, flags)\n\
7265 This function is used in example 1,20.\n\
7271 plcpstrm(iplsr, flags)\n\
7275 iplsr (PLINT, input) : Number of reference stream.\n\
7277 flags (PLBOOL, input) : If flags is set to true the device\n\
7278 coordinates are not copied from the reference to current stream.\n\
7281 Plot a glyph at the specified points\n\
7285 Plot a glyph at the specified points. (This function is largely\n\
7286 superseded by plstring which gives access to many[!] more glyphs.)\n\
7287 code=-1 means try to just draw a point. Right now it\'s just a move\n\
7288 and a draw at the same place. Not ideal, since a sufficiently\n\
7289 intelligent output device may optimize it away, or there may be faster\n\
7290 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
7291 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
7292 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
7293 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
7294 code <= 127 the corresponding printable ASCII character is plotted.\n\
7296 Redacted form: plpoin(x, y, code)\n\
7298 This function is used in examples 1, 6, 14, and 29.\n\
7304 plpoin(n, x, y, code)\n\
7308 n (PLINT, input) : Number of points in the x and y vectors.\n\
7310 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7313 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7316 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
7317 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
7318 each of the n points.\n\
7321 Enter or leave xor mode\n\
7325 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
7326 those drivers (e.g., the xwin driver) that support it. Enables\n\
7327 erasing plots by drawing twice the same line, symbol, etc. If driver\n\
7328 is not capable of xor operation it returns a status of false.\n\
7330 Redacted form: plxormod(mode, status)\n\
7332 This function is used in examples 1 and 20.\n\
7338 plxormod(mode, status)\n\
7342 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
7343 is false means leave xor mode.\n\
7345 status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
7346 modestatus of true (false) means driver is capable (incapable) of\n\
7350 Get viewport limits in normalized device coordinates\n\
7354 Get viewport limits in normalized device coordinates.\n\
7356 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7359 This function is used in example 31.\n\
7365 plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7369 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7370 viewport limit of the normalized device coordinate in x.\n\
7372 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7373 viewport limit of the normalized device coordinate in x.\n\
7375 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7376 viewport limit of the normalized device coordinate in y.\n\
7378 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7379 viewport limit of the normalized device coordinate in y.\n\
7382 Plot surface mesh\n\
7386 Plots a surface mesh within the environment set up by plw3d. The\n\
7387 surface is defined by the matrix z[\n\
7389 ny] , the point z[i][j] being the value of the function at (\n\
7391 y[j]). Note that the points in vectors x and y do not need to be\n\
7392 equally spaced, but must be stored in ascending order. The parameter\n\
7393 opt controls the way in which the surface is displayed. For further\n\
7394 details see the PLplot documentation.\n\
7396 Redacted form: plmesh(x, y, z, opt)\n\
7398 This function is used in example 11.\n\
7404 plmesh(x, y, z, nx, ny, opt)\n\
7408 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7409 which the function is evaluated.\n\
7411 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7412 which the function is evaluated.\n\
7414 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7415 plot. Should have dimensions of\n\
7419 nx (PLINT, input) : Number of x values at which function has been\n\
7422 ny (PLINT, input) : Number of y values at which function has been\n\
7425 opt (PLINT, input) : Determines the way in which the surface is\n\
7426 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
7427 function of x for each value of y[j] .\n\
7428 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7429 for each value of x[i] .\n\
7430 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7431 at which function is defined.\n\
7434 Magnitude colored plot surface mesh with contour\n\
7438 A more powerful form of plmesh: the surface mesh can be colored\n\
7439 accordingly to the current z value being plotted, a contour plot can\n\
7440 be drawn at the base XY plane, and a curtain can be drawn between the\n\
7441 plotted function border and the base XY plane.\n\
7443 Redacted form: plmeshc(x, y, z, opt, clevel)\n\
7445 This function is used in example 11.\n\
7451 plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7455 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7456 which the function is evaluated.\n\
7458 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7459 which the function is evaluated.\n\
7461 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7462 plot. Should have dimensions of\n\
7466 nx (PLINT, input) : Number of x values at which function is\n\
7469 ny (PLINT, input) : Number of y values at which function is\n\
7472 opt (PLINT, input) : Determines the way in which the surface is\n\
7473 represented. To specify more than one option just add the options,\n\
7474 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
7475 showing z as a function of x for each value of y[j] .\n\
7476 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7477 for each value of x[i] .\n\
7478 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7479 at which function is defined.\n\
7480 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
7481 the z value being plotted. The color is used from the current\n\
7483 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7487 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7488 the borders of the plotted function.\n\
7491 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7494 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7497 End plotting session for current stream\n\
7501 Ends a plotting session for the current output stream only. See\n\
7502 plsstrm for more info.\n\
7504 Redacted form: plend1()\n\
7506 This function is used in examples 1 and 20.\n\
7515 Get y axis parameters\n\
7519 Identical to plgxax, except that arguments are flags for y axis. See\n\
7520 the description of plgxax for more detail.\n\
7522 Redacted form: plgyax(p_digmax, p_digits)\n\
7524 This function is used in example 31.\n\
7530 plgyax(p_digmax, p_digits)\n\
7534 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
7535 number of digits for the y axis. If nonzero, the printed label\n\
7536 has been switched to a floating-point representation when the\n\
7537 number of digits exceeds this value.\n\
7539 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
7540 number of digits for the numeric labels (y axis) from the last\n\
7544 Set plot orientation\n\
7548 Set plot orientation parameter which is multiplied by 90 degrees to\n\
7549 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7550 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7551 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7552 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7553 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
7554 not called the default value of rot is 0.\n\
7556 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
7557 probably want to change the aspect ratio to a value suitable for the\n\
7558 plot orientation using a call to plsdidev or the command-line options\n\
7559 -a or -freeaspect. For more documentation of those options see the\n\
7560 PLplot documentation. Such command-line options can be set internally\n\
7561 using plsetopt or set directly using the command line and parsed using\n\
7562 a call to plparseopts.\n\
7564 Redacted form: plsdiori(rot)\n\
7566 This function is not used in any examples.\n\
7576 rot (PLFLT, input) : Plot orientation parameter.\n\
7579 Plot a histogram from unbinned data\n\
7583 Plots a histogram from n data points stored in the data vector. This\n\
7584 routine bins the data into nbin bins equally spaced between datmin and\n\
7585 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7586 opt allows, among other things, the histogram either to be plotted in\n\
7587 an existing window or causes plhist to call plenv with suitable limits\n\
7588 before plotting the histogram.\n\
7590 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7592 This function is used in example 5.\n\
7598 plhist(n, data, datmin, datmax, nbin, opt)\n\
7602 n (PLINT, input) : Number of data points.\n\
7604 data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7607 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7609 datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7611 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7612 divide the interval xmin to xmax.\n\
7614 opt (PLINT, input) : Is a combination of several flags:\n\
7615 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7616 the histogram data, the outer bins are expanded to fill up the\n\
7617 entire x-axis, data outside the given extremes are assigned to the\n\
7618 outer bins and bins of zero height are simply drawn.\n\
7619 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7620 to fit the histogram data, without this flag, plenv is called\n\
7621 to set the world coordinates.\n\
7622 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7623 extremes are not taken into account. This option should\n\
7624 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7625 properly present the data.\n\
7626 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7627 size as the ones inside.\n\
7628 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7629 (there is a gap for such bins).\n\
7632 End plotting session\n\
7636 Ends a plotting session, tidies up all the output files, switches\n\
7637 interactive devices back into text mode and frees up any memory that\n\
7638 was allocated. Must be called before end of program.\n\
7640 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
7641 wait state after a call to plend or other functions which trigger the\n\
7642 end of a plot page. To avoid this, use the plspause function.\n\
7644 Redacted form: plend()\n\
7646 This function is used in all of the examples.\n\
7655 Plot shaded 3-d surface plot\n\
7659 Plots a three-dimensional shaded surface plot within the environment\n\
7660 set up by plw3d. The surface is defined by the two-dimensional matrix\n\
7663 ny], the point z[i][j] being the value of the function at (\n\
7665 y[j]). Note that the points in vectors x and y do not need to be\n\
7666 equally spaced, but must be stored in ascending order. For further\n\
7667 details see the PLplot documentation.\n\
7669 Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
7671 This function is not used in any examples.\n\
7677 plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7681 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7682 which the function is evaluated.\n\
7684 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7685 which the function is evaluated.\n\
7687 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7688 plot. Should have dimensions of\n\
7692 nx (PLINT, input) : Number of x values at which function is\n\
7695 ny (PLINT, input) : Number of y values at which function is\n\
7698 opt (PLINT, input) : Determines the way in which the surface is\n\
7699 represented. To specify more than one option just add the options,\n\
7700 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
7701 connecting points at which function is defined.\n\
7702 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7706 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
7710 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7711 the borders of the plotted function.\n\
7712 opt=MAG_COLOR : the surface is colored according to the value\n\
7713 of Z; if MAG_COLOR is not used, then the surface is colored\n\
7714 according to the intensity of the reflected light in the\n\
7715 surface from a light source whose position is set using\n\
7719 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7722 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7725 Set device-compression level\n\
7729 Set device-compression level. Only used for drivers that provide\n\
7730 compression. This function, if used, should be invoked before a call\n\
7733 Redacted form: plscompression(compression)\n\
7735 This function is used in example 31.\n\
7741 plscompression(compression)\n\
7745 compression (PLINT, input) : The desired compression level. This is\n\
7746 a device-dependent value. Currently only the jpeg and png devices\n\
7747 use these values. For jpeg value is the jpeg quality which should\n\
7748 normally be in the range 0-95. Higher values denote higher quality\n\
7749 and hence larger image sizes. For png values are in the range -1\n\
7750 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
7751 A value of -1 denotes the default zlib compression level. Values\n\
7752 in the range 10-99 are divided by 10 and then used as the zlib\n\
7753 compression level. Higher compression levels correspond to greater\n\
7754 compression and small file sizes at the expense of more\n\
7758 Get the current device-compression setting\n\
7762 Get the current device-compression setting. This parameter is only\n\
7763 used for drivers that provide compression.\n\
7765 Redacted form: plgcompression(compression)\n\
7767 This function is used in example 31.\n\
7773 plgcompression(compression)\n\
7777 compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
7778 compression setting for the current device.\n\
7781 Advance the (sub-)page\n\
7785 Advances to the next subpage if sub=0, performing a page advance if\n\
7786 there are no remaining subpages on the current page. If subpages\n\
7787 aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
7788 PLplot switches to the specified subpage. Note that this allows you\n\
7789 to overwrite a plot on the specified subpage; if this is not what you\n\
7790 intended, use pleop followed by plbop to first advance the page. This\n\
7791 routine is called automatically (with page=0) by plenv, but if plenv\n\
7792 is not used, pladv must be called after initializing PLplot but before\n\
7793 defining the viewport.\n\
7795 Redacted form: pladv(page)\n\
7797 This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
7808 page (PLINT, input) : Specifies the subpage number (starting from 1\n\
7809 in the top left corner and increasing along the rows) to which to\n\
7810 advance. Set to zero to advance to the next subpage (or to the\n\
7811 next page if subpages are not being used).\n\
7814 Set parameters of contour labelling other than format of numerical label\n\
7818 Set parameters of contour labelling other than those handled by\n\
7819 pl_setcontlabelformat.\n\
7821 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7823 This function is used in example 9.\n\
7829 pl_setcontlabelparam(offset, size, spacing, active)\n\
7833 offset (PLFLT, input) : Offset of label from contour line (if set\n\
7834 to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7836 size (PLFLT, input) : Font height for contour labels (normalized).\n\
7837 Default value is 0.3.\n\
7839 spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7840 Default value is 0.1.\n\
7842 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7843 contour labels on. Default is off (0).\n\
7846 Set family, style and weight of the current font\n\
7850 Sets the current font. See the PLplot documentation for more\n\
7851 information on font selection.\n\
7853 Redacted form: plsfont(family, style, weight)\n\
7855 This function is used in example 23.\n\
7861 plsfont(family, style, weight)\n\
7865 family (PLINT, input) : Font family to select for the current font.\n\
7866 The available values are given by the PL_FCI_* constants in\n\
7867 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
7868 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
7869 signifies that the font family should not be altered.\n\
7871 style (PLINT, input) : Font style to select for the current font.\n\
7872 The available values are given by the PL_FCI_* constants in\n\
7873 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
7874 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
7875 should not be altered.\n\
7877 weight (PLINT, input) : Font weight to select for the current font.\n\
7878 The available values are given by the PL_FCI_* constants in\n\
7879 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
7880 negative value signifies that the font weight should not be\n\
7884 Sets the 3D position of the light source\n\
7888 Sets the 3D position of the light source for use with plsurf3d and\n\
7891 Redacted form: pllightsource(x, y, z)\n\
7893 This function is used in example 8.\n\
7899 pllightsource(x, y, z)\n\
7903 x (PLFLT, input) : X-coordinate of the light source.\n\
7905 y (PLFLT, input) : Y-coordinate of the light source.\n\
7907 z (PLFLT, input) : Z-coordinate of the light source.\n\
7914 Draws line defined by n points in x and y.\n\
7916 Redacted form: plline(x, y)\n\
7918 This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
7929 n (PLINT, input) : Number of points defining line.\n\
7931 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7934 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7942 Sets the pen width.\n\
7944 Redacted form: plwidth(width)\n\
7946 This function is used in examples 1 and 2.\n\
7956 width (PLFLT, input) : The desired pen width. If width is negative\n\
7957 or the same as the previous value no action is taken. width = 0.\n\
7958 should be interpreted as as the minimum valid pen width for the\n\
7959 device. The interpretation of positive width values is also\n\
7960 device dependent.\n\
7963 Draw linear gradient inside polygon\n\
7967 Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
7970 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
7971 polygon coordinates and the gradient angle are all expressed in world\n\
7972 coordinates. The angle from the x axis for both the rotated\n\
7973 coordinate system and the gradient vector is specified by angle. The\n\
7974 magnitude of the gradient vector is the difference between the maximum\n\
7975 and minimum values of x for the vertices in the rotated coordinate\n\
7976 system. The origin of the gradient vector can be interpreted as being\n\
7977 anywhere on the line corresponding to the minimum x value for the\n\
7978 vertices in the rotated coordinate system. The distance along the\n\
7979 gradient vector is linearly transformed to the independent variable of\n\
7980 color map 1 which ranges from 0. at the tail of the gradient vector to\n\
7981 1. at the head of the gradient vector. What is drawn is the RGBA\n\
7982 color corresponding to the independent variable of cmap1. For more\n\
7983 information about cmap1 (see the PLplot documentation).\n\
7985 Redacted form: plgradient(x,y,angle)\n\
7987 This function is used in examples 25 and 30.\n\
7993 plgradient(n, x, y, angle)\n\
7997 n (PLINT, input) : Number of vertices in polygon.\n\
7999 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8002 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8005 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
8009 Flushes the output stream\n\
8013 Flushes the output stream. Use sparingly, if at all.\n\
8015 Redacted form: plflush()\n\
8017 This function is used in examples 1 and 14.\n\
8026 Get plot orientation\n\
8030 Get plot orientation parameter which is multiplied by 90 degrees to\n\
8031 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
8032 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
8033 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
8034 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
8035 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
8036 not been called the default value pointed to by p_rot will be 0.\n\
8038 Redacted form: plgdiori(p_rot)\n\
8040 This function is not used in any examples.\n\
8050 p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
8054 Set x axis parameters\n\
8058 Sets values of the digmax and digits flags for the x axis. See the\n\
8059 PLplot documentation for more information.\n\
8061 Redacted form: plsxax(digmax, digits)\n\
8063 This function is used in example 31.\n\
8069 plsxax(digmax, digits)\n\
8073 digmax (PLINT, input) : Variable to set the maximum number of\n\
8074 digits for the x axis. If nonzero, the printed label will be\n\
8075 switched to a floating-point representation when the number of\n\
8076 digits exceeds digmax.\n\
8078 digits (PLINT, input) : Field digits value. Currently, changing\n\
8079 its value here has no effect since it is set only by plbox or\n\
8080 plbox3. However, the user may obtain its value after a call to\n\
8081 either of these functions by calling plgxax.\n\
8084 Get viewport limits in world coordinates\n\
8088 Get viewport limits in world coordinates.\n\
8090 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
8093 This function is used in example 31.\n\
8099 plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
8103 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
8104 viewport limit of the world coordinate in x.\n\
8106 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
8107 viewport limit of the world coordinate in x.\n\
8109 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
8110 viewport limit of the world coordinate in y.\n\
8112 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
8113 viewport limit of the world coordinate in y.\n\
8116 Shade regions on the basis of value\n\
8120 Shade regions on the basis of value. This is the high-level routine\n\
8121 for making continuous color shaded plots with cmap1 while plshade\n\
8122 should be used to plot individual shaded regions using either cmap0 or\n\
8123 cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
8124 our supported languages.\n\
8126 Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
8127 clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
8131 This function is used in examples 16, 21, and 22.\n\
8137 plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
8141 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
8142 plot. Should have dimensions of\n\
8146 nx (PLINT, input) : First dimension of matrix \"a\".\n\
8148 ny (PLINT, input) : Second dimension of matrix \"a\".\n\
8150 defined (PLDEFINED_callback, input) : Callback function specifying\n\
8151 the region that should be plotted in the shade plot. This\n\
8152 function accepts x and y coordinates as input arguments and must\n\
8153 return 1 if the point is to be included in the shade plot and 0\n\
8154 otherwise. If you want to plot the entire shade plot (the usual\n\
8155 case), this argument should be set to NULL.\n\
8157 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
8158 pltr below for how these arguments are used (only for the special case\n\
8159 when the callback function\n\
8160 pltr is not supplied).\n\
8162 clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
8163 corresponding to the edges of each shaded region that will be\n\
8164 plotted by this function. To work properly the levels should be\n\
8167 nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
8168 of shade edge values in clevel).\n\
8170 fill_width (PLFLT, input) : Defines the line width used by the fill\n\
8173 cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
8174 contours defining edges of shaded regions. The pen color is only\n\
8175 temporary set for the contour drawing. Set this value to zero or\n\
8176 less if no shade edge contours are wanted.\n\
8178 cont_width (PLFLT, input) : Defines line width used for contours\n\
8179 defining edges of shaded regions. This value may not be honored\n\
8180 by all drivers. The pen width is only temporary set for the\n\
8181 contour drawing. Set this value to zero or less if no shade edge\n\
8182 contours are wanted.\n\
8184 fill (PLFILL_callback, input) : Callback routine used to fill the\n\
8185 region. Use plfill for this purpose.\n\
8187 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
8188 map to rectangles after coordinate transformation with pltrl.\n\
8189 Otherwise, set rectangular to false. If rectangular is set to\n\
8190 true, plshade tries to save time by filling large rectangles.\n\
8191 This optimization fails if the coordinate transformation distorts\n\
8192 the shape of rectangles. For example a plot in polar coordinates\n\
8193 has to have rectangular set to false.\n\
8195 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
8196 defines the transformation between the zero-based indices of the\n\
8197 matrix a and world coordinates. If\n\
8198 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
8199 indices of a are mapped to the range\n\
8201 xmax and the y indices of a are mapped to the range\n\
8203 ymax.For the C case, transformation functions are provided in the\n\
8204 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
8205 pltr2 for arbitrary mappings respectively defined by vectors and\n\
8206 matrices. In addition, C callback routines for the transformation\n\
8207 can be supplied by the user such as the mypltr function in\n\
8208 examples/c/x09c.c which provides a general linear transformation\n\
8209 between index coordinates and world coordinates.For languages\n\
8210 other than C you should consult the PLplot documentation for the\n\
8211 details concerning how PLTRANSFORM_callback arguments are\n\
8212 interfaced. However, in general, a particular pattern of\n\
8213 callback-associated arguments such as a tr vector with 6 elements;\n\
8214 xg and yg vectors; or xg and yg matrices are respectively\n\
8215 interfaced to a linear-transformation routine similar to the above\n\
8216 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
8217 sophisticated bindings (see, e.g., the PLplot documentation)\n\
8218 support native language callbacks for handling index to\n\
8219 world-coordinate transformations. Examples of these various\n\
8220 approaches are given in examples/<language>x09*,\n\
8221 examples/<language>x16*, examples/<language>x20*,\n\
8222 examples/<language>x21*, and examples/<language>x22*, for all our\n\
8223 supported languages.\n\
8225 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8226 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8227 externally supplied.\n\
8230 Plot color bar for image, shade or gradient plots\n\
8234 Routine for creating a continuous color bar for image, shade, or\n\
8235 gradient plots. (See pllegend for similar functionality for creating\n\
8236 legends with discrete elements). The arguments of plcolorbar provide\n\
8237 control over the location and size of the color bar as well as the\n\
8238 location and characteristics of the elements (most of which are\n\
8239 optional) within that color bar. The resulting color bar is clipped\n\
8240 at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
8241 system used for some of the parameters is defined in the documentation\n\
8242 of the position parameter.)\n\
8244 Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
8245 position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
8246 low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
8247 labels, axis_opts, ticks, sub_ticks, values)\n\
8249 This function is used in examples 16 and 33.\n\
8255 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\
8259 p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8260 labelled and decorated color bar width in adopted coordinates.\n\
8262 p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8263 labelled and decorated color bar height in adopted coordinates.\n\
8265 opt (PLINT, input) : opt contains bits controlling the overall\n\
8266 color bar. The orientation (direction of the maximum value) of\n\
8267 the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
8268 PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
8269 specified, the default orientation is toward the top if the\n\
8270 colorbar is placed on the left or right of the viewport or toward\n\
8271 the right if the colorbar is placed on the top or bottom of the\n\
8272 viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
8273 (semitransparent) background for the color bar. If the\n\
8274 PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8275 color bar. The type of color bar must be specified with one of\n\
8276 PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
8277 more than one of those bits is set only the first one in the above\n\
8278 list is honored. The position of the (optional) label/title can be\n\
8279 specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
8280 PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
8281 will be drawn. If more than one of this list of bits is specified,\n\
8282 only the first one on the list is honored. End-caps for the color\n\
8283 bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
8284 If a particular color bar cap option is not specified then no cap\n\
8285 will be drawn for that end. As a special case for\n\
8286 PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
8287 specified. If this option is provided then any tick marks and tick\n\
8288 labels will be placed at the breaks between shaded segments. TODO:\n\
8289 This should be expanded to support custom placement of tick marks\n\
8290 and tick labels at custom value locations for any color bar type.\n\
8292 position (PLINT, input) : position contains bits which control the\n\
8293 overall position of the color bar and the definition of the\n\
8294 adopted coordinates used for positions just like what is done for\n\
8295 the position argument for pllegend. However, note that the\n\
8296 defaults for the position bits (see below) are different than the\n\
8297 pllegend case. The combination of the PL_POSITION_LEFT,\n\
8298 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8299 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8300 the 16 possible standard positions (the 4 corners and centers of\n\
8301 the 4 sides for both the inside and outside cases) of the color\n\
8302 bar relative to the adopted coordinate system. The corner\n\
8303 positions are specified by the appropriate combination of two of\n\
8304 the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8305 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8306 value of one of those bits. The adopted coordinates are\n\
8307 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8308 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8309 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8310 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8311 then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
8312 PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
8313 PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
8314 PL_POSITION_VIEWPORT.\n\
8316 x (PLFLT, input) : X offset of the color bar position in adopted\n\
8317 coordinates from the specified standard position of the color bar.\n\
8318 For positive x, the direction of motion away from the standard\n\
8319 position is inward/outward from the standard corner positions or\n\
8320 standard left or right positions if the\n\
8321 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8322 For the standard top or bottom positions, the direction of motion\n\
8323 is toward positive X.\n\
8325 y (PLFLT, input) : Y offset of the color bar position in adopted\n\
8326 coordinates from the specified standard position of the color bar.\n\
8327 For positive y, the direction of motion away from the standard\n\
8328 position is inward/outward from the standard corner positions or\n\
8329 standard top or bottom positions if the\n\
8330 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8331 For the standard left or right positions, the direction of motion\n\
8332 is toward positive Y.\n\
8334 x_length (PLFLT, input) : Length of the body of the color bar in\n\
8335 the X direction in adopted coordinates.\n\
8337 y_length (PLFLT, input) : Length of the body of the color bar in\n\
8338 the Y direction in adopted coordinates.\n\
8340 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8341 color bar (PL_COLORBAR_BACKGROUND).\n\
8343 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8344 for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
8346 bb_style (PLINT, input) : The pllsty style number for the\n\
8347 bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
8349 low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
8350 bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
8352 high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
8353 color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
8355 cont_color (PLINT, input) : The cmap0 contour color for\n\
8356 PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
8357 it will be interpreted according to the design of plshades.\n\
8359 cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
8360 plots. This is passed directly to plshades, so it will be\n\
8361 interpreted according to the design of plshades.\n\
8363 n_labels (PLINT, input) : Number of labels to place around the\n\
8366 label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
8369 labels (PLCHAR_MATRIX, input) : A vector of\n\
8370 n_labels UTF-8 character strings containing the labels for the color\n\
8371 bar. Ignored if no label position is specified with one of the\n\
8372 PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
8373 PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
8374 corresponding label_opts field.\n\
8376 n_axes (PLINT, input) : Number of axis definitions provided. This\n\
8377 value must be greater than 0. It is typically 1 (numerical axis\n\
8378 labels are provided for one of the long edges of the color bar),\n\
8379 but it can be larger if multiple numerical axis labels for the\n\
8380 long edges of the color bar are desired.\n\
8382 axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
8383 n_axes ascii character strings containing options (interpreted as for\n\
8384 plbox) for the color bar\'s axis definitions.\n\
8386 ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
8387 spacing of the major tick marks (interpreted as for plbox) for the\n\
8388 color bar\'s axis definitions.\n\
8390 sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
8391 number of subticks (interpreted as for plbox) for the color bar\'s\n\
8392 axis definitions.\n\
8394 n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
8395 elements in each of the n_axes rows of the values matrix.\n\
8397 values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
8398 values for the data range represented by the color bar. For a row\n\
8399 index of i_axis (where 0 < i_axis < n_axes), the number of\n\
8400 elements in the row is specified by n_values[i_axis]. For\n\
8401 PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
8402 is 2, and the corresponding row elements of the values matrix are\n\
8403 the minimum and maximum value represented by the colorbar. For\n\
8404 PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
8405 of the values matrix is interpreted the same as the nlevel and\n\
8406 clevel arguments of plshades.\n\
8409 Get current subpage parameters\n\
8413 Gets the size of the current subpage in millimeters measured from the\n\
8414 bottom left hand corner of the output device page or screen. Can be\n\
8415 used in conjunction with plsvpa for setting the size of a viewport in\n\
8416 absolute coordinates (millimeters).\n\
8418 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
8420 This function is used in example 23.\n\
8426 plgspa(xmin, xmax, ymin, ymax)\n\
8430 xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8431 the left hand edge of the subpage in millimeters.\n\
8433 xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8434 the right hand edge of the subpage in millimeters.\n\
8436 ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8437 the bottom edge of the subpage in millimeters.\n\
8439 ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8440 the top edge of the subpage in millimeters.\n\
8443 Shade individual region on the basis of value\n\
8447 Shade individual region on the basis of value. Use plshades if you\n\
8448 want to shade a number of contiguous regions using continuous colors.\n\
8449 In particular the edge contours are treated properly in plshades. If\n\
8450 you attempt to do contiguous regions with plshade the contours at the\n\
8451 edge of the shade are partially obliterated by subsequent plots of\n\
8452 contiguous shaded regions.\n\
8454 Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
8455 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
8456 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
8459 This function is used in example 15.\n\
8465 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\
8469 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
8470 plot. Should have dimensions of\n\
8474 nx (PLINT, input) : First dimension of the matrix \"a\".\n\
8476 ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
8478 defined (PLDEFINED_callback, input) : Callback function specifying\n\
8479 the region that should be plotted in the shade plot. This\n\
8480 function accepts x and y coordinates as input arguments and must\n\
8481 return 1 if the point is to be included in the shade plot and 0\n\
8482 otherwise. If you want to plot the entire shade plot (the usual\n\
8483 case), this argument should be set to NULL.\n\
8485 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
8486 pltr below for how these arguments are used (only for the special case\n\
8487 when the callback function\n\
8488 pltr is not supplied).\n\
8490 shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
8491 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8493 shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
8494 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8496 sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
8497 sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
8498 then sh_color is interpreted as a cmap1 argument in the range\n\
8501 sh_color (PLFLT, input) : Defines color map index with integer\n\
8502 value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
8504 sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
8506 min_color (PLINT, input) : Defines pen color, width used by the\n\
8507 boundary of shaded region. The min values are used for the\n\
8508 shade_min boundary, and the max values are used on the shade_max\n\
8509 boundary. Set color and width to zero for no plotted boundaries.\n\
8511 min_width (PLFLT, input) : Defines pen color, width used by the\n\
8512 boundary of shaded region. The min values are used for the\n\
8513 shade_min boundary, and the max values are used on the shade_max\n\
8514 boundary. Set color and width to zero for no plotted boundaries.\n\
8516 max_color (PLINT, input) : Defines pen color, width used by the\n\
8517 boundary of shaded region. The min values are used for the\n\
8518 shade_min boundary, and the max values are used on the shade_max\n\
8519 boundary. Set color and width to zero for no plotted boundaries.\n\
8521 max_width (PLFLT, input) : Defines pen color, width used by the\n\
8522 boundary of shaded region. The min values are used for the\n\
8523 shade_min boundary, and the max values are used on the shade_max\n\
8524 boundary. Set color and width to zero for no plotted boundaries.\n\
8526 fill (PLFILL_callback, input) : Routine used to fill the region.\n\
8527 Use plfill. Future version of PLplot may have other fill\n\
8530 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
8531 map to rectangles after coordinate transformation with pltrl.\n\
8532 Otherwise, set rectangular to false. If rectangular is set to\n\
8533 true, plshade tries to save time by filling large rectangles.\n\
8534 This optimization fails if the coordinate transformation distorts\n\
8535 the shape of rectangles. For example a plot in polar coordinates\n\
8536 has to have rectangular set to false.\n\
8538 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
8539 defines the transformation between the zero-based indices of the\n\
8540 matrix a and world coordinates. If\n\
8541 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
8542 indices of a are mapped to the range\n\
8544 xmax and the y indices of a are mapped to the range\n\
8546 ymax.For the C case, transformation functions are provided in the\n\
8547 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
8548 pltr2 for arbitrary mappings respectively defined by vectors and\n\
8549 matrices. In addition, C callback routines for the transformation\n\
8550 can be supplied by the user such as the mypltr function in\n\
8551 examples/c/x09c.c which provides a general linear transformation\n\
8552 between index coordinates and world coordinates.For languages\n\
8553 other than C you should consult the PLplot documentation for the\n\
8554 details concerning how PLTRANSFORM_callback arguments are\n\
8555 interfaced. However, in general, a particular pattern of\n\
8556 callback-associated arguments such as a tr vector with 6 elements;\n\
8557 xg and yg vectors; or xg and yg matrices are respectively\n\
8558 interfaced to a linear-transformation routine similar to the above\n\
8559 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
8560 sophisticated bindings (see, e.g., the PLplot documentation)\n\
8561 support native language callbacks for handling index to\n\
8562 world-coordinate transformations. Examples of these various\n\
8563 approaches are given in examples/<language>x09*,\n\
8564 examples/<language>x16*, examples/<language>x20*,\n\
8565 examples/<language>x21*, and examples/<language>x22*, for all our\n\
8566 supported languages.\n\
8568 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8569 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8570 externally supplied.\n\
8573 Calculate world coordinates and corresponding window index from relative device coordinates\n\
8577 Calculate world coordinates, wx and wy, and corresponding window index\n\
8578 from relative device coordinates, rx and ry.\n\
8580 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
8583 This function is used in example 31.\n\
8589 plcalc_world(rx, ry, wx, wy, window)\n\
8593 rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8594 the x coordinate.\n\
8596 ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8597 the y coordinate.\n\
8599 wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
8600 coordinate corresponding to the relative device coordinates rx and\n\
8603 wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
8604 coordinate corresponding to the relative device coordinates rx and\n\
8607 window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
8608 defined window index that corresponds to the input relative device\n\
8609 coordinates (and the returned world coordinates). To give some\n\
8610 background on the window index, for each page the initial window\n\
8611 index is set to zero, and each time plwind is called within the\n\
8612 page, world and device coordinates are stored for the window and\n\
8613 the window index is incremented. Thus, for a simple page layout\n\
8614 with non-overlapping viewports and one window per viewport, window\n\
8615 corresponds to the viewport index (in the order which the\n\
8616 viewport/windows were created) of the only viewport/window\n\
8617 corresponding to rx and ry. However, for more complicated layouts\n\
8618 with potentially overlapping viewports and possibly more than one\n\
8619 window (set of world coordinates) per viewport, window and the\n\
8620 corresponding output world coordinates corresponds to the last\n\
8621 window created that fulfills the criterion that the relative\n\
8622 device coordinates are inside it. Finally, in all cases where the\n\
8623 input relative device coordinates are not inside any\n\
8624 viewport/window, then the returned value of the last defined\n\
8625 window index is set to -1.\n\
8628 Draw a box with axes, etc, in 3-d\n\
8632 Draws axes, numeric and text labels for a three-dimensional surface\n\
8633 plot. For a more complete description of three-dimensional plotting\n\
8634 see the PLplot documentation.\n\
8636 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
8637 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8640 This function is used in examples 8, 11, 18, and 21.\n\
8646 plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8650 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8651 options for the x axis. The string can include any combination of\n\
8652 the following letters (upper or lower case) in any order: b: Draws\n\
8653 axis at base, at height z=\n\
8654 zmin where zmin is defined by call to plw3d. This character must be\n\
8655 specified in order to use any of the other options.\n\
8656 d: Plot labels as date / time. Values are assumed to be\n\
8657 seconds since the epoch (as used by gmtime).\n\
8658 f: Always use fixed point numeric labels.\n\
8659 i: Inverts tick marks, so they are drawn downwards, rather\n\
8661 l: Labels axis logarithmically. This only affects the labels,\n\
8662 not the data, and so it is necessary to compute the logarithms\n\
8663 of data points before passing them to any of the drawing\n\
8665 n: Writes numeric labels at major tick intervals.\n\
8666 o: Use custom labelling function to generate axis label text.\n\
8667 The custom labelling function can be defined with the\n\
8668 plslabelfunc command.\n\
8669 s: Enables subticks between major ticks, only valid if t is\n\
8671 t: Draws major ticks.\n\
8672 u: If this is specified, the text label for the axis is\n\
8673 written under the axis.\n\
8676 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8677 the text label for the x axis. It is only drawn if u is in the\n\
8680 xtick (PLFLT, input) : World coordinate interval between major\n\
8681 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8682 generates a suitable tick interval.\n\
8684 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8685 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8686 generates a suitable minor tick interval.\n\
8688 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8689 options for the y axis. The string is interpreted in the same way\n\
8692 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8693 the text label for the y axis. It is only drawn if u is in the\n\
8696 ytick (PLFLT, input) : World coordinate interval between major\n\
8697 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8698 generates a suitable tick interval.\n\
8700 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8701 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8702 generates a suitable minor tick interval.\n\
8704 zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8705 options for the z axis. The string can include any combination of\n\
8706 the following letters (upper or lower case) in any order: b: Draws\n\
8707 z axis to the left of the surface plot.\n\
8708 c: Draws z axis to the right of the surface plot.\n\
8709 d: Draws grid lines parallel to the x-y plane behind the\n\
8710 figure. These lines are not drawn until after plot3d or\n\
8711 plmesh are called because of the need for hidden line removal.\n\
8712 e: Plot labels as date / time. Values are assumed to be\n\
8713 seconds since the epoch (as used by gmtime). Note this\n\
8714 suboption is interpreted the same as the d suboption for xopt\n\
8715 and yopt, but it has to be identified as e for zopt since d\n\
8716 has already been used for the different purpose above.\n\
8717 f: Always use fixed point numeric labels.\n\
8718 i: Inverts tick marks, so they are drawn away from the center.\n\
8719 l: Labels axis logarithmically. This only affects the labels,\n\
8720 not the data, and so it is necessary to compute the logarithms\n\
8721 of data points before passing them to any of the drawing\n\
8723 m: Writes numeric labels at major tick intervals on the\n\
8724 right-hand z axis.\n\
8725 n: Writes numeric labels at major tick intervals on the\n\
8726 left-hand z axis.\n\
8727 o: Use custom labelling function to generate axis label text.\n\
8728 The custom labelling function can be defined with the\n\
8729 plslabelfunc command.\n\
8730 s: Enables subticks between major ticks, only valid if t is\n\
8732 t: Draws major ticks.\n\
8733 u: If this is specified, the text label is written beside the\n\
8735 v: If this is specified, the text label is written beside the\n\
8739 zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8740 the text label for the z axis. It is only drawn if u or v are in\n\
8743 ztick (PLFLT, input) : World coordinate interval between major\n\
8744 ticks on the z axis. If it is set to zero, PLplot automatically\n\
8745 generates a suitable tick interval.\n\
8747 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
8748 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8749 generates a suitable minor tick interval.\n\
8752 Get character default height and current (scaled) height\n\
8756 Get character default height and current (scaled) height.\n\
8758 Redacted form: plgchr(p_def, p_ht)\n\
8760 This function is used in example 23.\n\
8766 plgchr(p_def, p_ht)\n\
8770 p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
8771 character height (mm).\n\
8773 p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
8774 character height (mm).\n\
8777 Set the escape character for text strings\n\
8781 Set the escape character for text strings. From C (in contrast to\n\
8782 Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
8783 characters are allowed to prevent the user from shooting himself in\n\
8784 the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
8785 use of backslash as a character escape). Here are the allowed escape\n\
8786 characters and their corresponding decimal ASCII values: !, ASCII 33\n\
8797 Redacted form: General: plsesc(esc)\n\
8800 This function is used in example 29.\n\
8810 esc (char, input) : Escape character.\n\
8813 Draw a line between two points, accounting for coordinate transforms\n\
8817 Joins the point (\n\
8821 y2) . If a global coordinate transform is defined then the line is\n\
8822 broken in to n segments to approximate the path. If no transform is\n\
8823 defined then this simply acts like a call to pljoin.\n\
8825 Redacted form: plpath(n,x1,y1,x2,y2)\n\
8827 This function is used in example 22.\n\
8833 plpath(n, x1, y1, x2, y2)\n\
8837 n (PLINT, input) : number of points to use to approximate the path.\n\
8839 x1 (PLFLT, input) : x coordinate of first point.\n\
8841 y1 (PLFLT, input) : y coordinate of first point.\n\
8843 x2 (PLFLT, input) : x coordinate of second point.\n\
8845 y2 (PLFLT, input) : y coordinate of second point.\n\
8848 Set up standard window and draw box\n\
8852 Sets up plotter environment for simple graphs by calling pladv and\n\
8853 setting up viewport and window to sensible default values. plenv\n\
8854 leaves a standard margin (left-hand margin of eight character heights,\n\
8855 and a margin around the other three sides of five character heights)\n\
8856 around most graphs for axis labels and a title. When these defaults\n\
8857 are not suitable, use the individual routines plvpas, plvpor, or\n\
8858 plvasp for setting up the viewport, plwind for defining the window,\n\
8859 and plbox for drawing the box.\n\
8861 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8863 This function is used in example 1,3,9,13,14,19-22,29.\n\
8869 plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8873 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
8874 world coordinates).\n\
8876 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
8877 world coordinates).\n\
8879 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
8882 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
8885 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
8886 scales will not be set, the user must set up the scale before\n\
8887 calling plenv using plsvpa, plvasp or other.\n\
8888 0: the x and y axes are scaled independently to use as much of\n\
8889 the screen as possible.\n\
8890 1: the scales of the x and y axes are made equal.\n\
8891 2: the axis of the x and y axes are made equal, and the plot\n\
8892 box will be square.\n\
8895 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
8896 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
8897 -1: draw box only.\n\
8898 0: draw box, ticks, and numeric tick labels.\n\
8899 1: also draw coordinate axes at x=0 and y=0.\n\
8900 2: also draw a grid at major tick positions in both\n\
8902 3: also draw a grid at minor tick positions in both\n\
8904 10: same as 0 except logarithmic x tick marks. (The x data\n\
8905 have to be converted to logarithms separately.)\n\
8906 11: same as 1 except logarithmic x tick marks. (The x data\n\
8907 have to be converted to logarithms separately.)\n\
8908 12: same as 2 except logarithmic x tick marks. (The x data\n\
8909 have to be converted to logarithms separately.)\n\
8910 13: same as 3 except logarithmic x tick marks. (The x data\n\
8911 have to be converted to logarithms separately.)\n\
8912 20: same as 0 except logarithmic y tick marks. (The y data\n\
8913 have to be converted to logarithms separately.)\n\
8914 21: same as 1 except logarithmic y tick marks. (The y data\n\
8915 have to be converted to logarithms separately.)\n\
8916 22: same as 2 except logarithmic y tick marks. (The y data\n\
8917 have to be converted to logarithms separately.)\n\
8918 23: same as 3 except logarithmic y tick marks. (The y data\n\
8919 have to be converted to logarithms separately.)\n\
8920 30: same as 0 except logarithmic x and y tick marks. (The x\n\
8921 and y data have to be converted to logarithms separately.)\n\
8922 31: same as 1 except logarithmic x and y tick marks. (The x\n\
8923 and y data have to be converted to logarithms separately.)\n\
8924 32: same as 2 except logarithmic x and y tick marks. (The x\n\
8925 and y data have to be converted to logarithms separately.)\n\
8926 33: same as 3 except logarithmic x and y tick marks. (The x\n\
8927 and y data have to be converted to logarithms separately.)\n\
8928 40: same as 0 except date / time x labels.\n\
8929 41: same as 1 except date / time x labels.\n\
8930 42: same as 2 except date / time x labels.\n\
8931 43: same as 3 except date / time x labels.\n\
8932 50: same as 0 except date / time y labels.\n\
8933 51: same as 1 except date / time y labels.\n\
8934 52: same as 2 except date / time y labels.\n\
8935 53: same as 3 except date / time y labels.\n\
8936 60: same as 0 except date / time x and y labels.\n\
8937 61: same as 1 except date / time x and y labels.\n\
8938 62: same as 2 except date / time x and y labels.\n\
8939 63: same as 3 except date / time x and y labels.\n\
8940 70: same as 0 except custom x and y labels.\n\
8941 71: same as 1 except custom x and y labels.\n\
8942 72: same as 2 except custom x and y labels.\n\
8943 73: same as 3 except custom x and y labels.\n\
8946 Grid data from irregularly sampled data\n\
8950 Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
8951 require data organized as a grid, i.e., with x sample point values\n\
8952 independent of y coordinate and vice versa. This function takes\n\
8953 irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
8954 vectors; reads the desired grid location from the input vectors\n\
8955 xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
8956 grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
8957 interpolate the data to the grid is specified with the argument type\n\
8958 which can have one parameter specified in argument data.\n\
8960 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
8961 Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
8964 This function is used in example 21.\n\
8970 plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
8974 x (PLFLT_VECTOR, input) : The input x vector.\n\
8976 y (PLFLT_VECTOR, input) : The input y vector.\n\
8978 z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
8979 y[i], z[i] represents one data sample coordinate.\n\
8981 npts (PLINT, input) : The number of data samples in the x, y and z\n\
8984 xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
8985 in the x direction. Usually xg has nptsx equally spaced values\n\
8986 from the minimum to the maximum values of the x input vector.\n\
8988 nptsx (PLINT, input) : The number of points in the xg vector.\n\
8990 yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
8991 in the y direction. Similar to the xg parameter.\n\
8993 nptsy (PLINT, input) : The number of points in the yg vector.\n\
8995 zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
8996 where data lies in the grid specified by xg and yg. Therefore the\n\
8997 zg matrix must be dimensioned\n\
9001 type (PLINT, input) : The type of grid interpolation algorithm to\n\
9002 use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
9003 GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
9004 GRID_NNI: Natural Neighbors Interpolation\n\
9005 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
9006 GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
9007 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
9009 For details of the algorithms read the source file plgridd.c.\n\
9011 data (PLFLT, input) : Some gridding algorithms require extra data,\n\
9012 which can be specified through this argument. Currently, for\n\
9013 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
9014 use, the lower the value, the noisier (more local) the\n\
9015 approximation is.\n\
9016 GRID_NNLI, data specifies what a thin triangle is, in the\n\
9017 range [1. .. 2.]. High values enable the usage of very thin\n\
9018 triangles for interpolation, possibly resulting in error in\n\
9019 the approximation.\n\
9020 GRID_NNI, only weights greater than data will be accepted. If\n\
9021 0, all weights will be accepted.\n\
9024 Clear current (sub)page\n\
9028 Clears the current page, effectively erasing everything that have been\n\
9029 drawn. This command only works with interactive drivers; if the\n\
9030 driver does not support this, the page is filled with the background\n\
9031 color in use. If the current page is divided into subpages, only the\n\
9032 current subpage is erased. The nth subpage can be selected with\n\
9035 Redacted form: General: plclear()\n\
9038 This function is not used in any examples.\n\
9047 Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
9051 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
9052 and PLFLT alpha transparency value. This sets the entire color map --\n\
9053 only as many colors as specified will be allocated.\n\
9055 Redacted form: plscmap0a(r, g, b, alpha)\n\
9057 This function is used in examples 30.\n\
9063 plscmap0a(r, g, b, alpha, ncol0)\n\
9067 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9068 integers (0-255) representing the degree of red in the color.\n\
9070 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9071 integers (0-255) representing the degree of green in the color.\n\
9073 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9074 integers (0-255) representing the degree of blue in the color.\n\
9076 alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
9077 representing the alpha transparency of the color.\n\
9079 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9083 Set 8-bit RGB values for given cmap0 color index\n\
9087 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
9088 index. Overwrites the previous color value for the given index and,\n\
9089 thus, does not result in any additional allocation of space for\n\
9092 Redacted form: plscol0(icol0, r, g, b)\n\
9094 This function is used in any example 31.\n\
9100 plscol0(icol0, r, g, b)\n\
9104 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
9105 number of colors (which is set by default, by plscmap0n, or even\n\
9108 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9109 degree of red in the color.\n\
9111 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9112 degree of green in the color.\n\
9114 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9115 degree of blue in the color.\n\
9118 Set up transformation from metafile coordinates\n\
9122 Set up transformation from metafile coordinates. The size of the plot\n\
9123 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
9124 general-purpose facility just yet (not sure why the user would need\n\
9127 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
9130 This function is not used in any examples.\n\
9136 plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
9140 dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
9142 dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
9144 dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
9146 dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
9148 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
9150 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
9153 Creates a new stream and makes it the default\n\
9157 Creates a new stream and makes it the default. Differs from using\n\
9158 plsstrm, in that a free stream number is found, and returned.\n\
9159 Unfortunately, I have to start at stream 1 and work upward, since\n\
9160 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
9161 that no initial, library-opening call is required. So stream 0 must\n\
9162 be preallocated, and there is no simple way of determining whether it\n\
9163 is already in use or not.\n\
9165 Redacted form: plmkstrm(p_strm)\n\
9167 This function is used in examples 1 and 20.\n\
9177 p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
9178 number of the created stream.\n\
9181 Get page parameters\n\
9185 Gets the current page configuration. The length and offset values are\n\
9186 expressed in units that are specific to the current driver. For\n\
9187 instance: screen drivers will usually interpret them as number of\n\
9188 pixels, whereas printer drivers will usually use mm.\n\
9190 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
9192 This function is used in examples 14 and 31.\n\
9198 plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
9202 p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
9203 pixels/inch (DPI) in x.\n\
9205 p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
9206 pixels/inch (DPI) in y.\n\
9208 p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
9211 p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
9214 p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
9217 p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
9221 Set format for date / time labels\n\
9225 Sets the format for date / time labels. To enable date / time format\n\
9226 labels see the options to plbox, plbox3, and plenv.\n\
9228 Redacted form: pltimefmt(fmt)\n\
9230 This function is used in example 29.\n\
9240 fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
9241 interpreted similarly to the format specifier of typical system\n\
9242 strftime routines except that PLplot ignores locale and also\n\
9243 supplies some useful extensions in the context of plotting. All\n\
9244 text in the string is printed as-is other than conversion\n\
9245 specifications which take the form of a \'%\' character followed by\n\
9246 further conversion specification character. The conversion\n\
9247 specifications which are similar to those provided by system\n\
9248 strftime routines are the following: %a: The abbreviated (English)\n\
9250 %A: The full (English) weekday name.\n\
9251 %b: The abbreviated (English) month name.\n\
9252 %B: The full (English) month name.\n\
9253 %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
9254 %C: The century number (year/100) as a 2-digit integer.\n\
9255 %d: The day of the month as a decimal number (range 01 to 31).\n\
9256 %D: Equivalent to %m/%d/%y (non-ISO).\n\
9257 %e: Like %d, but a leading zero is replaced by a space.\n\
9258 %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
9259 %h: Equivalent to %b.\n\
9260 %H: The hour as a decimal number using a 24-hour clock (range\n\
9262 %I: The hour as a decimal number using a 12-hour clock (range\n\
9264 %j: The day of the year as a decimal number (range 001 to\n\
9266 %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
9267 23); single digits are preceded by a blank. (See also %H.)\n\
9268 %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
9269 12); single digits are preceded by a blank. (See also %I.)\n\
9270 %m: The month as a decimal number (range 01 to 12).\n\
9271 %M: The minute as a decimal number (range 00 to 59).\n\
9272 %n: A newline character.\n\
9273 %p: Either \"AM\" or \"PM\" according to the given time value.\n\
9274 Noon is treated as \"PM\" and midnight as \"AM\".\n\
9275 %r: Equivalent to %I:%M:%S %p.\n\
9276 %R: The time in 24-hour notation (%H:%M). For a version\n\
9277 including the seconds, see %T below.\n\
9278 %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
9280 %S: The second as a decimal number (range 00 to 60). (The\n\
9281 range is up to 60 to allow for occasional leap seconds.)\n\
9282 %t: A tab character.\n\
9283 %T: The time in 24-hour notation (%H:%M:%S).\n\
9284 %u: The day of the week as a decimal, range 1 to 7, Monday\n\
9285 being 1. See also %w.\n\
9286 %U: The week number of the current year as a decimal number,\n\
9287 range 00 to 53, starting with the first Sunday as the first\n\
9288 day of week 01. See also %V and %W.\n\
9289 %v: Equivalent to %e-%b-%Y.\n\
9290 %V: The ISO 8601 week number of the current year as a decimal\n\
9291 number, range 01 to 53, where week 1 is the first week that\n\
9292 has at least 4 days in the new year. See also %U and %W.\n\
9293 %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
9294 being 0. See also %u.\n\
9295 %W: The week number of the current year as a decimal number,\n\
9296 range 00 to 53, starting with the first Monday as the first\n\
9298 %x: Equivalent to %a %b %d %Y.\n\
9299 %X: Equivalent to %T.\n\
9300 %y: The year as a decimal number without a century (range 00\n\
9302 %Y: The year as a decimal number including a century.\n\
9303 %z: The UTC time-zone string = \"+0000\".\n\
9304 %Z: The UTC time-zone abbreviation = \"UTC\".\n\
9305 %+: The UTC date and time in default format of the Unix date\n\
9306 command which is equivalent to %a %b %d %T %Z %Y.\n\
9307 %%: A literal \"%\" character.\n\
9308 The conversion specifications which are extensions to those normally\n\
9309 provided by system strftime routines are the following: %(0-9):\n\
9310 The fractional part of the seconds field (including leading\n\
9311 decimal point) to the specified accuracy. Thus %S%3 would give\n\
9312 seconds to millisecond accuracy (00.000).\n\
9313 %.: The fractional part of the seconds field (including\n\
9314 leading decimal point) to the maximum available accuracy. Thus\n\
9315 %S%. would give seconds with fractional part up to 9 decimal\n\
9316 places if available.\n\
9319 Specify viewport using aspect ratio only\n\
9323 Selects the largest viewport with the given aspect ratio within the\n\
9324 subpage that leaves a standard margin (left-hand margin of eight\n\
9325 character heights, and a margin around the other three sides of five\n\
9326 character heights).\n\
9328 Redacted form: plvasp(aspect)\n\
9330 This function is used in example 13.\n\
9340 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
9341 axis of resulting viewport.\n\
9344 Set output file name\n\
9348 Sets the current output file name, if applicable. If the file name\n\
9349 has not been specified and is required by the driver, the user will be\n\
9350 prompted for it. If using the X-windows output driver, this sets the\n\
9351 display name. This routine, if used, must be called before\n\
9352 initializing PLplot.\n\
9354 Redacted form: plsfnam(fnam)\n\
9356 This function is used in examples 1 and 20.\n\
9366 fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9374 Draws a plot of vector data contained in the matrices (\n\
9380 ny]) . The scaling factor for the vectors is given by scale. A\n\
9381 transformation routine pointed to by pltr with a pointer pltr_data for\n\
9382 additional data required by the transformation routine to map indices\n\
9383 within the matrices to the world coordinates. The style of the vector\n\
9384 arrow may be set using plsvect.\n\
9386 Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
9387 discussion) the pltr, pltr_data callback arguments are sometimes\n\
9388 replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
9389 with either one or two dimensions.\n\
9391 This function is used in example 22.\n\
9397 plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
9401 u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
9402 and y components of the vector data to be plotted.\n\
9404 nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
9406 scale (PLFLT, input) : Parameter to control the scaling factor of\n\
9407 the vectors for plotting. If scale = 0 then the scaling factor is\n\
9408 automatically calculated for the data. If scale < 0 then the\n\
9409 scaling factor is automatically calculated for the data and then\n\
9411 scale. If scale > 0 then the scaling factor is set to scale.\n\
9413 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
9414 defines the transformation between the zero-based indices of the\n\
9415 matrices u and v and world coordinates.For the C case,\n\
9416 transformation functions are provided in the PLplot library: pltr0\n\
9417 for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
9418 mappings respectively defined by vectors and matrices. In\n\
9419 addition, C callback routines for the transformation can be\n\
9420 supplied by the user such as the mypltr function in\n\
9421 examples/c/x09c.c which provides a general linear transformation\n\
9422 between index coordinates and world coordinates.For languages\n\
9423 other than C you should consult the PLplot documentation for the\n\
9424 details concerning how PLTRANSFORM_callback arguments are\n\
9425 interfaced. However, in general, a particular pattern of\n\
9426 callback-associated arguments such as a tr vector with 6 elements;\n\
9427 xg and yg vectors; or xg and yg matrices are respectively\n\
9428 interfaced to a linear-transformation routine similar to the above\n\
9429 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
9430 sophisticated bindings (see, e.g., the PLplot documentation)\n\
9431 support native language callbacks for handling index to\n\
9432 world-coordinate transformations. Examples of these various\n\
9433 approaches are given in examples/<language>x09*,\n\
9434 examples/<language>x16*, examples/<language>x20*,\n\
9435 examples/<language>x21*, and examples/<language>x22*, for all our\n\
9436 supported languages.\n\
9438 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
9439 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
9440 that is externally supplied.\n\
9443 Set parameters that define current plot-space window\n\
9447 Set relative minima and maxima that define the current plot-space\n\
9448 window. If plsdiplt is not called the default values of xmin, ymin,\n\
9449 xmax, and ymax are 0., 0., 1., and 1.\n\
9451 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
9453 This function is used in example 31.\n\
9459 plsdiplt(xmin, ymin, xmax, ymax)\n\
9463 xmin (PLFLT, input) : Relative minimum in x.\n\
9465 ymin (PLFLT, input) : Relative minimum in y.\n\
9467 xmax (PLFLT, input) : Relative maximum in x.\n\
9469 ymax (PLFLT, input) : Relative maximum in y.\n\
9472 Select line style\n\
9476 This sets the line style according to one of eight predefined patterns\n\
9477 (also see plstyl).\n\
9479 Redacted form: pllsty(lin)\n\
9481 This function is used in examples 9, 12, 22, and 25.\n\
9491 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
9492 a continuous line, line style 2 is a line with short dashes and\n\
9493 gaps, line style 3 is a line with long dashes and gaps, line style\n\
9494 4 has long dashes and short gaps and so on.\n\
9497 Plot a glyph at the specified points\n\
9501 Plot a glyph at the specified points. (This function is largely\n\
9502 superseded by plstring which gives access to many[!] more glyphs.)\n\
9504 Redacted form: plsym(x, y, code)\n\
9506 This function is used in example 7.\n\
9512 plsym(n, x, y, code)\n\
9516 n (PLINT, input) : Number of points in the x and y vectors.\n\
9518 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9521 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9524 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
9525 to be plotted at each of the n points.\n\
9528 Set the device (keyword) name\n\
9532 Set the device (keyword) name.\n\
9534 Redacted form: plsdev(devname)\n\
9536 This function is used in examples 1, 14, and 20.\n\
9546 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
9547 containing the device name keyword of the required output device.\n\
9549 devname is NULL or if the first character of the string is a ``?\'\',\n\
9550 the normal (prompted) start up is used.\n\
9553 Set the background color by 8-bit RGB value\n\
9557 Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
9558 the PLplot documentation).\n\
9560 Redacted form: plscolbg(r, g, b)\n\
9562 This function is used in examples 15 and 31.\n\
9568 plscolbg(r, g, b)\n\
9572 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9573 degree of red in the color.\n\
9575 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9576 degree of green in the color.\n\
9578 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9579 degree of blue in the color.\n\
9582 Set parameters incrementally (zoom mode) that define current plot-space window\n\
9586 Set relative minima and maxima incrementally (zoom mode) that define\n\
9587 the current plot-space window. This function has the same effect as\n\
9588 plsdiplt if that function has not been previously called. Otherwise,\n\
9589 this function implements zoom mode using the transformation min_used =\n\
9590 old_min + old_length*min and max_used = old_min + old_length*max for\n\
9591 each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
9592 repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
9594 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
9596 This function is used in example 31.\n\
9602 plsdiplz(xmin, ymin, xmax, ymax)\n\
9606 xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
9608 ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
9610 xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
9612 ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
9615 Advance to the next family file on the next new page\n\
9619 Advance to the next family file on the next new page.\n\
9621 Redacted form: plfamadv()\n\
9623 This function is not used in any examples.\n\
9632 Set number of colors in cmap0\n\
9636 Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9637 (or reallocate) cmap0, and fill with default values for those colors\n\
9638 not previously allocated. The first 16 default colors are given in\n\
9639 the plcol0 documentation. For larger indices the default color is\n\
9642 The drivers are not guaranteed to support more than 16 colors.\n\
9644 Redacted form: plscmap0n(ncol0)\n\
9646 This function is used in examples 15, 16, and 24.\n\
9656 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9657 the cmap0 palette. If this number is zero or less, then the value\n\
9658 from the previous call to plscmap0n is used and if there is no\n\
9659 previous call, then a default value is used.\n\
9662 Plot latitude and longitude lines\n\
9666 Displays latitude and longitude on the current plot. The lines are\n\
9667 plotted in the current color and line style.\n\
9669 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
9672 This function is used in example 19.\n\
9678 plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
9682 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
9683 transform the coordinate longitudes and latitudes to a plot\n\
9684 coordinate system. By using this transform, we can change from a\n\
9685 longitude, latitude coordinate to a polar stereographic project,\n\
9686 for example. Initially, x[0]..[n-1] are the longitudes and\n\
9687 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
9688 mapform(), x[] and y[] should be replaced by the corresponding\n\
9689 plot coordinates. If no transform is desired, mapform can be\n\
9690 replaced by NULL.\n\
9692 dlong (PLFLT, input) : The interval in degrees at which the\n\
9693 longitude lines are to be plotted.\n\
9695 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
9696 lines are to be plotted.\n\
9698 minlong (PLFLT, input) : The value of the longitude on the left\n\
9699 side of the plot. The value of minlong must be less than the value\n\
9700 of maxlong, and the quantity maxlong-minlong must be less than or\n\
9703 maxlong (PLFLT, input) : The value of the longitude on the right\n\
9704 side of the plot.\n\
9706 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
9707 background. One can always use -90.0 as the boundary outside the\n\
9708 plot window will be automatically eliminated. However, the\n\
9709 program will be faster if one can reduce the size of the\n\
9710 background plotted.\n\
9712 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
9713 background. One can always use 90.0 as the boundary outside the\n\
9714 plot window will be automatically eliminated.\n\
9717 Convert RGB color to HLS\n\
9721 Convert RGB color coordinates to HLS\n\
9723 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9726 This function is used in example 2.\n\
9732 plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9736 r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9738 g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9740 b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9742 p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9743 degrees (0.0-360.0) on the color cylinder.\n\
9745 p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9746 expressed as a fraction (0.0-1.0) of the axis of the color\n\
9749 p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9750 expressed as a fraction (0.0-1.0) of the radius of the color\n\
9754 Plot a glyph at the specified 3D points\n\
9758 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
9759 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
9760 this function similar to what is done for plline3. The glyph is\n\
9761 specified with a PLplot user string. Note that the user string is not\n\
9762 actually limited to one glyph so it is possible (but not normally\n\
9763 useful) to plot more than one glyph at the specified points with this\n\
9764 function. As with plmtex and plptex, the user string can contain FCI\n\
9765 escapes to determine the font, UTF-8 code to determine the glyph or\n\
9766 else PLplot escapes for Hershey or unicode text to determine the\n\
9769 Redacted form: plstring3(x, y, z, string)\n\
9771 This function is used in example 18.\n\
9777 plstring3(n, x, y, z, string)\n\
9781 n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
9783 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9786 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9789 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
9792 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
9793 the glyph(s) to be plotted at each of the n points. points.\n\
9796 Switch to text screen\n\
9800 Sets an interactive device to text mode, used in conjunction with\n\
9801 plgra to allow graphics and text to be interspersed. On a device\n\
9802 which supports separate text and graphics windows, this command causes\n\
9803 control to be switched to the text window. This can be useful for\n\
9804 printing diagnostic messages or getting user input, which would\n\
9805 otherwise interfere with the plots. The program must switch back to\n\
9806 the graphics window before issuing plot commands, as the text (or\n\
9807 console) device will probably become quite confused otherwise. If\n\
9808 already in text mode, this command is ignored. It is also ignored on\n\
9809 devices which only support a single window or use a different method\n\
9810 for shifting focus (see also plgra).\n\
9812 Redacted form: pltext()\n\
9814 This function is used in example 1.\n\
9823 Get parameters that define current plot-space window\n\
9827 Get relative minima and maxima that define current plot-space window.\n\
9828 If plsdiplt has not been called the default values pointed to by\n\
9829 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
9831 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9833 This function is used in example 31.\n\
9839 plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9843 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9846 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9849 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9852 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9856 Get the (current) run level\n\
9860 Get the (current) run level. Valid settings are: 0, uninitialized\n\
9862 2, viewport defined\n\
9863 3, world coordinates defined\n\
9866 Redacted form: plglevel(p_level)\n\
9868 This function is used in example 31.\n\
9874 plglevel(p_level)\n\
9878 p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
9882 Plot a histogram from binned data\n\
9886 Plots a histogram consisting of nbin bins. The value associated with\n\
9887 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
9888 placed in y[i]. For proper operation, the values in x[i] must form a\n\
9889 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
9890 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
9891 placed midway between the values in the x vector. Also see plhist for\n\
9892 drawing histograms from unbinned data.\n\
9894 Redacted form: General: plbin(x, y, opt)\n\
9895 Python: plbin(nbin, x, y, opt)\n\
9898 This function is not used in any examples.\n\
9904 plbin(nbin, x, y, opt)\n\
9908 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
9911 x (PLFLT_VECTOR, input) : A vector containing values associated\n\
9912 with bins. These must form a strictly increasing sequence.\n\
9914 y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
9915 proportional to the number of points in each bin. This is a PLFLT\n\
9916 (instead of PLINT) vector so as to allow histograms of\n\
9917 probabilities, etc.\n\
9919 opt (PLINT, input) : Is a combination of several flags:\n\
9920 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
9921 outer bins are expanded to fill up the entire x-axis and bins of\n\
9922 zero height are simply drawn.\n\
9923 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
9924 between the x values. If the values in x are equally spaced,\n\
9925 the values are the center values of the bins.\n\
9926 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
9927 size as the ones inside.\n\
9928 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
9929 (there is a gap for such bins).\n\
9932 Plot a 2D matrix using cmap1\n\
9936 Plot a 2D matrix using cmap1.\n\
9938 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
9939 zmax, valuemin, valuemax, pltr, pltr_data)\n\
9942 This function is used in example 20.\n\
9948 plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
9952 idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
9953 plot. Should have dimensions of\n\
9957 nx, ny (PLINT, input) : Dimensions of idata\n\
9959 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
9960 pltr below for how these arguments are used (only for the special case\n\
9961 when the callback function\n\
9962 pltr is not supplied).\n\
9964 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
9965 (inclusive) will be plotted.\n\
9967 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
9968 values to use for value to color mappings. A datum equal to or\n\
9969 less than valuemin will be plotted with color 0.0, while a datum\n\
9970 equal to or greater than valuemax will be plotted with color 1.0.\n\
9971 Data between valuemin and valuemax map linearly to colors in the\n\
9974 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
9975 defines the transformation between the zero-based indices of the\n\
9976 matrix idata and world coordinates. If\n\
9977 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
9978 indices of idata are mapped to the range\n\
9980 xmax and the y indices of idata are mapped to the range\n\
9982 ymax.For the C case, transformation functions are provided in the\n\
9983 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
9984 pltr2 for arbitrary mappings respectively defined by vectors and\n\
9985 matrices. In addition, C callback routines for the transformation\n\
9986 can be supplied by the user such as the mypltr function in\n\
9987 examples/c/x09c.c which provides a general linear transformation\n\
9988 between index coordinates and world coordinates.For languages\n\
9989 other than C you should consult the PLplot documentation for the\n\
9990 details concerning how PLTRANSFORM_callback arguments are\n\
9991 interfaced. However, in general, a particular pattern of\n\
9992 callback-associated arguments such as a tr vector with 6 elements;\n\
9993 xg and yg vectors; or xg and yg matrices are respectively\n\
9994 interfaced to a linear-transformation routine similar to the above\n\
9995 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
9996 sophisticated bindings (see, e.g., the PLplot documentation)\n\
9997 support native language callbacks for handling index to\n\
9998 world-coordinate transformations. Examples of these various\n\
9999 approaches are given in examples/<language>x09*,\n\
10000 examples/<language>x16*, examples/<language>x20*,\n\
10001 examples/<language>x21*, and examples/<language>x22*, for all our\n\
10002 supported languages.\n\
10004 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
10005 information to pltr0, pltr1, pltr2, or whatever routine is\n\
10006 externally supplied.\n\
10009 Get family, style and weight of the current font\n\
10013 Gets information about current font. See the PLplot documentation for\n\
10014 more information on font selection.\n\
10016 Redacted form: plgfont(p_family, p_style, p_weight)\n\
10018 This function is used in example 23.\n\
10024 plgfont(p_family, p_style, p_weight)\n\
10028 p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10029 font family. The available values are given by the PL_FCI_*\n\
10030 constants in plplot.h. Current options are PL_FCI_SANS,\n\
10031 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
10032 p_family is NULL then the font family is not returned.\n\
10034 p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10035 font style. The available values are given by the PL_FCI_*\n\
10036 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
10037 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
10038 style is not returned.\n\
10040 p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10041 font weight. The available values are given by the PL_FCI_*\n\
10042 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
10043 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
10047 Get z axis parameters\n\
10051 Identical to plgxax, except that arguments are flags for z axis. See\n\
10052 the description of plgxax for more detail.\n\
10054 Redacted form: plgzax(p_digmax, p_digits)\n\
10056 This function is used in example 31.\n\
10062 plgzax(p_digmax, p_digits)\n\
10066 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
10067 number of digits for the z axis. If nonzero, the printed label\n\
10068 has been switched to a floating-point representation when the\n\
10069 number of digits exceeds this value.\n\
10071 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
10072 number of digits for the numeric labels (z axis) from the last\n\
10076 Write text inside the viewport of a 3D plot\n\
10080 Writes text at a specified position and inclination and with a\n\
10081 specified shear within the viewport. Text is clipped at the viewport\n\
10082 boundaries. The reference point of a string lies along a line passing\n\
10083 through the string at half the height of a capital letter. The\n\
10084 position of the reference point along this line is determined by just,\n\
10085 and the reference point is placed at world coordinates (\n\
10088 wz) within the viewport. The inclination and shear of the string is\n\
10089 specified in terms of differences of world coordinates making it easy\n\
10090 to write text parallel to a line in a graph.\n\
10092 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
10094 This function is used in example 28.\n\
10100 plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
10104 wx (PLFLT, input) : x world coordinate of reference point of\n\
10107 wy (PLFLT, input) : y world coordinate of reference point of\n\
10110 wz (PLFLT, input) : z world coordinate of reference point of\n\
10113 dx (PLFLT, input) : Together with dy and\n\
10114 dz , this specifies the inclination of the string. The baseline of\n\
10115 the string is parallel to a line joining (\n\
10126 dy (PLFLT, input) : Together with dx and\n\
10127 dz, this specifies the inclination of the string.\n\
10129 dz (PLFLT, input) : Together with dx and\n\
10130 dy, this specifies the inclination of the string.\n\
10132 sx (PLFLT, input) : Together with sy and\n\
10133 sz , this specifies the shear of the string. The string is sheared so\n\
10134 that the characters are vertically parallel to a line joining (\n\
10145 sz = 0.) then the text is not sheared.\n\
10147 sy (PLFLT, input) : Together with sx and\n\
10148 sz, this specifies shear of the string.\n\
10150 sz (PLFLT, input) : Together with sx and\n\
10151 sy, this specifies shear of the string.\n\
10153 just (PLFLT, input) : Specifies the position of the string relative\n\
10154 to its reference point. If just=0. , the reference point is at\n\
10155 the left and if just=1. , it is at the right of the string. Other\n\
10156 values of just give intermediate justifications.\n\
10158 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
10162 Draw a box with axes, etc. with arbitrary origin\n\
10166 Draws a box around the currently defined viewport with arbitrary\n\
10167 world-coordinate origin specified by x0 and y0 and labels it with\n\
10168 world coordinate values appropriate to the window. Thus plaxes should\n\
10169 only be called after defining both viewport and window. The ascii\n\
10170 character strings xopt and yopt specify how the box should be drawn as\n\
10171 described below. If ticks and/or subticks are to be drawn for a\n\
10172 particular axis, the tick intervals and number of subintervals may be\n\
10173 specified explicitly, or they may be defaulted by setting the\n\
10174 appropriate arguments to zero.\n\
10176 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
10180 This function is not used in any examples.\n\
10186 plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
10190 x0 (PLFLT, input) : World X coordinate of origin.\n\
10192 y0 (PLFLT, input) : World Y coordinate of origin.\n\
10194 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10195 options for the x axis. The string can include any combination of\n\
10196 the following letters (upper or lower case) in any order: a: Draws\n\
10197 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
10199 b: Draws bottom (X) or left (Y) edge of frame.\n\
10200 c: Draws top (X) or right (Y) edge of frame.\n\
10201 d: Plot labels as date / time. Values are assumed to be\n\
10202 seconds since the epoch (as used by gmtime).\n\
10203 f: Always use fixed point numeric labels.\n\
10204 g: Draws a grid at the major tick interval.\n\
10205 h: Draws a grid at the minor tick interval.\n\
10206 i: Inverts tick marks, so they are drawn outwards, rather than\n\
10208 l: Labels axis logarithmically. This only affects the labels,\n\
10209 not the data, and so it is necessary to compute the logarithms\n\
10210 of data points before passing them to any of the drawing\n\
10212 m: Writes numeric labels at major tick intervals in the\n\
10213 unconventional location (above box for X, right of box for Y).\n\
10214 n: Writes numeric labels at major tick intervals in the\n\
10215 conventional location (below box for X, left of box for Y).\n\
10216 o: Use custom labelling function to generate axis label text.\n\
10217 The custom labelling function can be defined with the\n\
10218 plslabelfunc command.\n\
10219 s: Enables subticks between major ticks, only valid if t is\n\
10221 t: Draws major ticks.\n\
10222 u: Exactly like \"b\" except don\'t draw edge line.\n\
10223 w: Exactly like \"c\" except don\'t draw edge line.\n\
10224 x: Exactly like \"t\" (including the side effect of the\n\
10225 numerical labels for the major ticks) except exclude drawing\n\
10226 the major and minor tick marks.\n\
10229 xtick (PLFLT, input) : World coordinate interval between major\n\
10230 ticks on the x axis. If it is set to zero, PLplot automatically\n\
10231 generates a suitable tick interval.\n\
10233 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
10234 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
10235 generates a suitable minor tick interval.\n\
10237 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10238 options for the y axis. The string can include any combination of\n\
10239 the letters defined above for xopt, and in addition may contain:\n\
10240 v: Write numeric labels for the y axis parallel to the base of the\n\
10241 graph, rather than parallel to the axis.\n\
10244 ytick (PLFLT, input) : World coordinate interval between major\n\
10245 ticks on the y axis. If it is set to zero, PLplot automatically\n\
10246 generates a suitable tick interval.\n\
10248 nysub (PLINT, input) : Number of subintervals between major y axis\n\
10249 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
10250 generates a suitable minor tick interval.\n\
10253 Returns the background color (cmap0[0]) by 8-bit RGB value\n\
10257 Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
10259 Redacted form: plgcolbg(r, g, b)\n\
10261 This function is used in example 31.\n\
10267 plgcolbg(r, g, b)\n\
10271 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
10272 in the range from 0 to 255.\n\
10274 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
10275 in the range from 0 to 255.\n\
10277 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
10278 in the range from 0 to 255.\n\
10281 Plot a glyph at the specified 3D points\n\
10285 Plot a glyph at the specified 3D points. (This function is largely\n\
10286 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
10287 Set up the call to this function similar to what is done for plline3.\n\
10288 code=-1 means try to just draw a point. Right now it\'s just a move\n\
10289 and a draw at the same place. Not ideal, since a sufficiently\n\
10290 intelligent output device may optimize it away, or there may be faster\n\
10291 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
10292 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
10293 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
10294 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
10295 code <= 127 the corresponding printable ASCII character is plotted.\n\
10297 Redacted form: plpoin3(x, y, z, code)\n\
10299 This function is not used in any example.\n\
10305 plpoin3(n, x, y, z, code)\n\
10309 n (PLINT, input) : Number of points in the x and y vectors.\n\
10311 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
10314 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10317 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
10320 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
10321 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
10322 each of the n points.\n\
10325 Draw a polygon in 3 space\n\
10329 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10330 like plline3, but differs from that function in that plpoly3 attempts\n\
10331 to determine if the polygon is viewable depending on the order of the\n\
10332 points within the vector and the value of ifcc. If the back of\n\
10333 polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10334 you want, then use plline3 instead.\n\
10336 The points are assumed to be in a plane, and the directionality of the\n\
10337 plane is determined from the first three points. Additional points do\n\
10338 not have to lie on the plane defined by the first three, but if they\n\
10339 do not, then the determination of visibility obviously can\'t be 100%\n\
10340 accurate... So if you\'re 3 space polygons are too far from planar,\n\
10341 consider breaking them into smaller polygons. 3 points define a plane\n\
10344 Bugs: If one of the first two segments is of zero length, or if they\n\
10345 are co-linear, the calculation of visibility has a 50/50 chance of\n\
10346 being correct. Avoid such situations :-). See x18c.c for an example\n\
10347 of this problem. (Search for 20.1).\n\
10349 Redacted form: plpoly3(x, y, z, code)\n\
10351 This function is used in example 18.\n\
10357 plpoly3(n, x, y, z, draw, ifcc)\n\
10361 n (PLINT, input) : Number of points defining line.\n\
10363 x (PLFLT_VECTOR, input) : A vector containing\n\
10364 n x coordinates of points.\n\
10366 y (PLFLT_VECTOR, input) : A vector containing\n\
10367 n y coordinates of points.\n\
10369 z (PLFLT_VECTOR, input) : A vector containing\n\
10370 n z coordinates of points.\n\
10372 draw (PLBOOL_VECTOR, input) : A vector containing\n\
10373 n-1 Boolean values which control drawing the segments of the polygon.\n\
10374 If draw[i] is true, then the polygon segment from index [i] to\n\
10375 [i+1] is drawn, otherwise, not.\n\
10377 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10378 polygon is determined by assuming the points are laid out in a\n\
10379 counter-clockwise order. Otherwise, the directionality of the\n\
10380 polygon is determined by assuming the points are laid out in a\n\
10381 clockwise order.\n\
10384 Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
10388 Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
10389 PLFLT alpha transparency value (see the PLplot documentation).\n\
10391 This function is used in example 31.\n\
10397 plscolbga(r, g, b, alpha)\n\
10401 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10402 degree of red in the color.\n\
10404 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10405 degree of green in the color.\n\
10407 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10408 degree of blue in the color.\n\
10410 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
10414 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
10418 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
10419 alpha transparency value.\n\
10421 This function is used in example 31.\n\
10427 plgcolbga(r, g, b, alpha)\n\
10431 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
10432 in the range from 0 to 255.\n\
10434 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
10435 in the range from 0 to 255.\n\
10437 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
10438 in the range from 0 to 255.\n\
10440 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
10441 transparency in the range (0.0-1.0).\n\
10444 Draw error bars in x direction\n\
10448 Draws a set of n error bars in x direction, the i\'th error bar\n\
10449 extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
10450 of the error bars are of length equal to the minor tick length\n\
10451 (settable using plsmin).\n\
10453 Redacted form: General: plerrx(xmin, ymax, y)\n\
10456 This function is used in example 29.\n\
10462 plerrx(n, xmin, xmax, y)\n\
10466 n (PLINT, input) : Number of error bars to draw.\n\
10468 xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10469 of the left-hand endpoints of the error bars.\n\
10471 xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10472 of the right-hand endpoints of the error bars.\n\
10474 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10478 Eject current page\n\
10482 Clears the graphics screen of an interactive device, or ejects a page\n\
10483 on a plotter. See plbop for more information.\n\
10485 Redacted form: pleop()\n\
10487 This function is used in example 2,14.\n\
10496 Convert HLS color to RGB\n\
10500 Convert HLS color coordinates to RGB.\n\
10502 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10505 This function is used in example 2.\n\
10511 plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10515 h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
10518 l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
10519 the axis of the color cylinder.\n\
10521 s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
10522 the radius of the color cylinder.\n\
10524 p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
10525 (0.0-1.0) of the color.\n\
10527 p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
10528 intensity (0.0-1.0) of the color.\n\
10530 p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
10531 intensity (0.0-1.0) of the color.\n\
10534 Plot all or a subset of Shapefile data, filling the polygons\n\
10538 As per plmapline, however the items are filled in the same way as\n\
10541 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
10544 This function is used in example 19.\n\
10550 plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
10554 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
10555 transform the coordinates given in the shapefile into a plot\n\
10556 coordinate system. By using this transform, we can change from a\n\
10557 longitude, latitude coordinate to a polar stereographic project,\n\
10558 for example. Initially, x[0]..[n-1] are the longitudes and\n\
10559 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
10560 mapform(), x[] and y[] should be replaced by the corresponding\n\
10561 plot coordinates. If no transform is desired, mapform can be\n\
10562 replaced by NULL.\n\
10564 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10565 the file name of a set of Shapefile files without the file\n\
10568 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
10569 be in the same units as used by the Shapefile. You could use a\n\
10570 very large negative number to plot everything, but you can improve\n\
10571 performance by limiting the area drawn. The units must match those\n\
10572 of the Shapefile projection, which may be for example longitude or\n\
10573 distance. The value of minx must be less than the value of maxx.\n\
10575 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
10576 use a very large number to plot everything, but you can improve\n\
10577 performance by limiting the area drawn.\n\
10579 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
10580 be in the same units as used by the Shapefile. You could use a\n\
10581 very large negative number to plot everything, but you can improve\n\
10582 performance by limiting the area drawn. The units must match those\n\
10583 of the Shapefile projection, which may be for example latitude or\n\
10584 distance. The value of miny must be less than the value of maxy.\n\
10586 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
10587 use a very large number to plot everything, but you can improve\n\
10588 performance by limiting the area drawn.\n\
10590 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
10591 zero-based indices of the Shapefile elements which will be drawn.\n\
10593 plotentries to NULL will plot all elements of the Shapefile.\n\
10595 nplotentries (PLINT, input) : The number of items in\n\
10596 plotentries. Ignored if\n\
10597 plotentries is NULL.\n\
10600 Draw error bars in the y direction\n\
10604 Draws a set of n error bars in the y direction, the i\'th error bar\n\
10605 extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
10606 of the error bars are of length equal to the minor tick length\n\
10607 (settable using plsmin).\n\
10609 Redacted form: General: plerry(x, ymin, ymax)\n\
10612 This function is used in example 29.\n\
10618 plerry(n, x, ymin, ymax)\n\
10622 n (PLINT, input) : Number of error bars to draw.\n\
10624 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
10627 ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10628 of the lower endpoints of the error bars.\n\
10630 ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10631 of the upper endpoints of the error bars.\n\
10634 Set FCI (font characterization integer)\n\
10638 Sets font characteristics to be used at the start of the next string\n\
10639 using the FCI approach. See the PLplot documentation for more\n\
10640 information. Note, plsfont (which calls plsfci internally) provides a\n\
10641 more user-friendly API for setting the font characterisitics.\n\
10643 Redacted form: General: plsfci(fci)\n\
10646 This function is used in example 23.\n\
10656 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
10660 Select area fill pattern\n\
10665 patt is zero or less use either a hardware solid fill if the drivers\n\
10666 have that capability (virtually all do) or fall back to a software\n\
10667 emulation of a solid fill using the eighth area line fill pattern. If\n\
10669 patt <= 8, then select one of eight predefined area line fill patterns\n\
10670 to use (see plpat if you desire other patterns).\n\
10672 Redacted form: plpsty(patt)\n\
10674 This function is used in examples 12, 13, 15, 16, and 25.\n\
10684 patt (PLINT, input) : The desired pattern index. If\n\
10685 patt is zero or less, then a solid fill is (normally, see qualifiers\n\
10686 above) used. For\n\
10687 patt in the range from 1 to 8 and assuming the driver has not supplied\n\
10688 line fill capability itself (most deliberately do not so that line\n\
10689 fill patterns look identical for those drivers), the patterns\n\
10690 consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
10691 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
10692 lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
10693 (8) lines at both 45 degrees and -45 degrees.\n\
10700 This sets up the size of all subsequent symbols drawn by plpoin and\n\
10701 plsym. The actual height of a symbol is the product of the default\n\
10702 symbol size and a scaling factor as for the character height.\n\
10704 Redacted form: plssym(def, scale)\n\
10706 This function is used in example 29.\n\
10712 plssym(def, scale)\n\
10716 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
10717 should be set to zero if the default height is to remain\n\
10720 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
10721 actual symbol height.\n\
10728 Alternative to plstar for initializing the plotting package. The\n\
10729 device name keyword for the desired output device must be supplied as\n\
10730 an argument. These keywords are the same as those printed out by\n\
10731 plstar. If the requested device is not available, or if the input\n\
10732 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
10733 is used. This routine also divides the output device page into nx by\n\
10734 ny subpages, each of which may be used independently. The subroutine\n\
10735 pladv is used to advance from one subpage to the next.\n\
10737 Redacted form: General: plstart(devname, nx, ny)\n\
10740 This function is not used in any examples.\n\
10746 plstart(devname, nx, ny)\n\
10750 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
10751 containing the device name keyword of the required output device.\n\
10753 devname is NULL or if the first character of the string is a ``?\'\',\n\
10754 the normal (prompted) start up is used.\n\
10756 nx (PLINT, input) : Number of subpages to divide output page in the\n\
10759 ny (PLINT, input) : Number of subpages to divide output page in the\n\
10766 char **arg3 = (
char **) 0 ;
10768 octave_value_list _out;
10769 octave_value_list *_outp=&_out;
10770 octave_value _outv;
10776 if (
_n_dims( args(0) ) > 1 )
10782 temp1 = args(0).matrix_value();
10786 charMatrix temp_matrix;
10790 size_t max_length = 0, non_blank_length;
10792 if (
_n_dims( args(1) ) > 2 )
10794 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
10796 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10797 if ( !args(1).isempty() )
10799 if ( !args(1).is_empty() )
10804 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
10806 arg3 =
new char*[
Alen];
10807 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10808 ifcell = args(1).iscell();
10810 ifcell = args(1).is_cell();
10814 temp_cell = args(1).cell_value();
10818 temp_matrix = args(1).char_matrix_value();
10820 max_length =
_dim( args(1), 1 ) + 1;
10823 for ( i = 0; i <
Alen; i++ )
10830 if ( temp_cell.elem( i ).is_string() )
10832 str = temp_cell.elem( i ).string_value();
10834 max_length = str.size() + 1;
10835 tmp_cstring = (
char *) str.c_str();
10845 tmp_cstring = (
char *)
"";
10850 str = temp_matrix.row_as_string( i );
10851 tmp_cstring = (
char *) str.c_str();
10853 arg3[i] =
new char[max_length];
10854 strncpy( arg3[i], tmp_cstring, max_length - 1 );
10855 arg3[i][max_length - 1] =
'\0';
10870 non_blank_length = max_length - 2;
10871 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
'\0' )
10873 non_blank_length--;
10875 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
' ' )
10877 non_blank_length--;
10879 arg3[i][non_blank_length + 1] =
'\0';
10888 testppchar(arg1,(
int const *)arg2,(
char const **)arg3);
10889 _outv = octave_value();
10896 if ( arg3 != NULL )
10898 for ( i = 0; i <
Alen; i++ )
10912 if ( arg3 != NULL )
10914 for ( i = 0; i <
Alen; i++ )
10921 return octave_value_list();
10926 int *arg1 = (
int *) 0 ;
10927 int *arg2 = (
int *) 0 ;
10928 int *arg3 = (
int *) 0 ;
10929 char *arg4 = (
char *) 0 ;
10930 int *arg5 = (
int *) 0 ;
10931 int *arg6 = (
int *) 0 ;
10936 int *arg11 = (
int *) 0 ;
10943 char local_string4[80] ;
10958 size_t local_string_length4 ;
10959 charMatrix local_charMatrix4 ;
10960 octave_value_list retval4 ;
10961 octave_value_list _out;
10962 octave_value_list *_outp=&_out;
10963 octave_value _outv;
10970 arg4 = local_string4;
10982 result = (int)
my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11004 local_string_length4 = strlen( local_string4 );
11005 local_charMatrix4 = charMatrix( 1, local_string_length4 );
11006 local_charMatrix4.insert( local_string4, 0, 0 );
11007 retval4( 0 ) = octave_value( local_charMatrix4 );
11054 return octave_value_list();
11071 octave_value_list _out;
11072 octave_value_list *_outp=&_out;
11073 octave_value _outv;
11085 arg3 = static_cast< PLFLT >(val3);
11090 arg4 = static_cast< PLFLT >(val4);
11108 return octave_value_list();
11114 char *arg2 = (
char *) 0 ;
11115 char *arg3 = (
char *) 0 ;
11129 char *arg17 = (
char *) 0 ;
11130 char *arg18 = (
char *) 0 ;
11131 char *arg19 = (
char *) 0 ;
11132 char *arg20 = (
char *) 0 ;
11133 char *arg21 = (
char *) 0 ;
11134 char *arg22 = (
char *) 0 ;
11135 char *arg23 = (
char *) 0 ;
11189 octave_value_list _out;
11190 octave_value_list *_outp=&_out;
11191 octave_value _outv;
11201 arg2 = reinterpret_cast< char * >(buf2);
11206 arg3 = reinterpret_cast< char * >(buf3);
11211 arg4 = static_cast< PLFLT >(val4);
11216 arg5 = static_cast< PLFLT >(val5);
11221 arg6 = static_cast< PLFLT >(val6);
11226 arg7 = static_cast< PLFLT >(val7);
11231 arg8 = static_cast< PLFLT >(val8);
11236 arg9 = static_cast< PLFLT >(val9);
11241 arg10 = static_cast< PLFLT >(val10);
11246 arg11 = static_cast< PLBOOL >(val11);
11251 arg12 = static_cast< PLBOOL >(val12);
11256 arg13 = static_cast< PLINT >(val13);
11261 arg14 = static_cast< PLINT >(val14);
11263 if (
_n_dims( args(13) ) > 1 )
11268 temp15 = args(13).matrix_value();
11273 if (
_n_dims( args(14) ) > 1 )
11277 if (
_dim( args(14), 0 ) !=
Alen )
11281 temp16 = args(14).matrix_value();
11289 arg17 = reinterpret_cast< char * >(buf17);
11294 arg18 = reinterpret_cast< char * >(buf18);
11299 arg19 = reinterpret_cast< char * >(buf19);
11304 arg20 = reinterpret_cast< char * >(buf20);
11309 arg21 = reinterpret_cast< char * >(buf21);
11314 arg22 = reinterpret_cast< char * >(buf22);
11319 arg23 = reinterpret_cast< char * >(buf23);
11320 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);
11321 _outv = octave_value();
11361 return octave_value_list();
11387 octave_value_list _out;
11388 octave_value_list *_outp=&_out;
11389 octave_value _outv;
11395 if (
_n_dims( args(0) ) > 2 )
11397 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11399 temp1 = args(0).matrix_value();
11400 arg1 = &temp1( 0, 0 );
11408 arg4 = static_cast< PLINT >(val4);
11413 arg5 = static_cast< PLINT >(val5);
11418 arg6 = static_cast< PLINT >(val6);
11423 arg7 = static_cast< PLINT >(val7);
11425 if (
_n_dims( args(5) ) > 1 )
11429 temp8 = args(5).matrix_value();
11430 arg8 = &temp8( 0, 0 );
11434 if (
_n_dims( args(6) ) > 1 )
11438 if (
_dim( args(6), 0 ) != 6 )
11442 temp10 = args(6).matrix_value();
11443 arg10 = &temp10( 0, 0 );
11445 my_plcont((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10);
11446 _outv = octave_value();
11468 return octave_value_list();
11492 octave_value_list _out;
11493 octave_value_list *_outp=&_out;
11494 octave_value _outv;
11500 if (
_n_dims( args(0) ) > 2 )
11502 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11504 temp1 = args(0).matrix_value();
11505 arg1 = &temp1( 0, 0 );
11513 arg4 = static_cast< PLINT >(val4);
11518 arg5 = static_cast< PLINT >(val5);
11523 arg6 = static_cast< PLINT >(val6);
11528 arg7 = static_cast< PLINT >(val7);
11530 if (
_n_dims( args(5) ) > 1 )
11534 temp8 = args(5).matrix_value();
11535 arg8 = &temp8( 0, 0 );
11538 my_plcont0((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9);
11539 _outv = octave_value();
11555 return octave_value_list();
11583 octave_value_list _out;
11584 octave_value_list *_outp=&_out;
11585 octave_value _outv;
11591 if (
_n_dims( args(0) ) > 2 )
11593 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11595 temp1 = args(0).matrix_value();
11596 arg1 = &temp1( 0, 0 );
11604 arg4 = static_cast< PLINT >(val4);
11609 arg5 = static_cast< PLINT >(val5);
11614 arg6 = static_cast< PLINT >(val6);
11619 arg7 = static_cast< PLINT >(val7);
11621 if (
_n_dims( args(5) ) > 1 )
11625 temp8 = args(5).matrix_value();
11626 arg8 = &temp8( 0, 0 );
11630 if (
_n_dims( args(6) ) > 1 )
11638 temp10 = args(6).matrix_value();
11639 arg10 = &temp10( 0, 0 );
11642 if (
_n_dims( args(7) ) > 1 )
11650 temp11 = args(7).matrix_value();
11651 arg11 = &temp11( 0, 0 );
11653 my_plcont1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11654 _outv = octave_value();
11682 return octave_value_list();
11710 octave_value_list _out;
11711 octave_value_list *_outp=&_out;
11712 octave_value _outv;
11718 if (
_n_dims( args(0) ) > 2 )
11720 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11722 temp1 = args(0).matrix_value();
11723 arg1 = &temp1( 0, 0 );
11731 arg4 = static_cast< PLINT >(val4);
11736 arg5 = static_cast< PLINT >(val5);
11741 arg6 = static_cast< PLINT >(val6);
11746 arg7 = static_cast< PLINT >(val7);
11748 if (
_n_dims( args(5) ) > 1 )
11752 temp8 = args(5).matrix_value();
11753 arg8 = &temp8( 0, 0 );
11757 if (
_n_dims( args(6) ) > 2 )
11759 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11763 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11767 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11769 temp10 = args(6).matrix_value();
11770 arg10 = &temp10( 0, 0 );
11773 if (
_n_dims( args(7) ) > 2 )
11775 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11779 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11783 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11785 temp11 = args(7).matrix_value();
11786 arg11 = &temp11( 0, 0 );
11788 my_plcont2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11789 _outv = octave_value();
11817 return octave_value_list();
11845 octave_value_list _out;
11846 octave_value_list *_outp=&_out;
11847 octave_value _outv;
11853 if (
_n_dims( args(0) ) > 2 )
11855 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11857 temp1 = args(0).matrix_value();
11858 arg1 = &temp1( 0, 0 );
11866 arg4 = static_cast< PLINT >(val4);
11871 arg5 = static_cast< PLINT >(val5);
11876 arg6 = static_cast< PLINT >(val6);
11881 arg7 = static_cast< PLINT >(val7);
11883 if (
_n_dims( args(5) ) > 1 )
11887 temp8 = args(5).matrix_value();
11888 arg8 = &temp8( 0, 0 );
11892 if (
_n_dims( args(6) ) > 2 )
11894 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11898 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11902 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11904 temp10 = args(6).matrix_value();
11905 arg10 = &temp10( 0, 0 );
11908 if (
_n_dims( args(7) ) > 2 )
11910 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11914 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11918 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11920 temp11 = args(7).matrix_value();
11921 arg11 = &temp11( 0, 0 );
11923 my_plcont2p((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11924 _outv = octave_value();
11952 return octave_value_list();
11973 octave_value_list retval7 ;
11978 octave_value_list _out;
11979 octave_value_list *_outp=&_out;
11980 octave_value _outv;
11986 if (
_n_dims( args(0) ) > 1 )
11991 temp1 = args(0).matrix_value();
11992 arg1 = &temp1( 0, 0 );
11995 if (
_n_dims( args(1) ) > 1 )
12003 temp2 = args(1).matrix_value();
12004 arg2 = &temp2( 0, 0 );
12007 if (
_n_dims( args(2) ) > 1 )
12015 temp3 = args(2).matrix_value();
12016 arg3 = &temp3( 0, 0 );
12020 if (
_n_dims( args(3) ) > 1 )
12024 temp5 = args(3).matrix_value();
12025 arg5 = &temp5( 0, 0 );
12029 if (
_n_dims( args(4) ) > 1 )
12033 temp7 = args(4).matrix_value();
12034 arg7 = &temp7( 0, 0 );
12036 retval7( 0 ) = octave_value( Matrix(
Xlen,
Ylen ) );
12037 arg9 = (
PLFLT *) retval7( 0 ).matrix_value().data();
12043 arg10 = static_cast< PLINT >(val10);
12048 arg11 = static_cast< PLFLT >(val11);
12049 my_plgriddata((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,(
double const *)arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,arg11);
12050 _outv = octave_value();
12087 return octave_value_list();
12103 octave_value_list _out;
12104 octave_value_list *_outp=&_out;
12105 octave_value _outv;
12111 if (
_n_dims( args(0) ) > 1 )
12115 temp1 = args(0).matrix_value();
12116 arg1 = &temp1( 0, 0 );
12120 if (
_n_dims( args(1) ) > 1 )
12124 temp2 = args(1).matrix_value();
12125 arg2 = &temp2( 0, 0 );
12129 if (
_n_dims( args(2) ) > 2 )
12131 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12135 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12139 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12141 temp3 = args(2).matrix_value();
12142 arg3 = &temp3( 0, 0 );
12150 arg6 = static_cast< PLINT >(val6);
12151 my_plmesh((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6);
12152 _outv = octave_value();
12174 return octave_value_list();
12193 octave_value_list _out;
12194 octave_value_list *_outp=&_out;
12195 octave_value _outv;
12201 if (
_n_dims( args(0) ) > 1 )
12205 temp1 = args(0).matrix_value();
12206 arg1 = &temp1( 0, 0 );
12210 if (
_n_dims( args(1) ) > 1 )
12214 temp2 = args(1).matrix_value();
12215 arg2 = &temp2( 0, 0 );
12219 if (
_n_dims( args(2) ) > 2 )
12221 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12225 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12229 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12231 temp3 = args(2).matrix_value();
12232 arg3 = &temp3( 0, 0 );
12240 arg6 = static_cast< PLINT >(val6);
12242 if (
_n_dims( args(4) ) > 1 )
12246 temp7 = args(4).matrix_value();
12247 arg7 = &temp7( 0, 0 );
12250 my_plmeshc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12251 _outv = octave_value();
12279 return octave_value_list();
12298 octave_value_list _out;
12299 octave_value_list *_outp=&_out;
12300 octave_value _outv;
12306 if (
_n_dims( args(0) ) > 1 )
12310 temp1 = args(0).matrix_value();
12311 arg1 = &temp1( 0, 0 );
12315 if (
_n_dims( args(1) ) > 1 )
12319 temp2 = args(1).matrix_value();
12320 arg2 = &temp2( 0, 0 );
12324 if (
_n_dims( args(2) ) > 2 )
12326 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12330 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12334 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12336 temp3 = args(2).matrix_value();
12337 arg3 = &temp3( 0, 0 );
12345 arg6 = static_cast< PLINT >(val6);
12350 arg7 = static_cast< PLBOOL >(val7);
12351 my_plot3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,arg7);
12352 _outv = octave_value();
12374 return octave_value_list();
12393 octave_value_list _out;
12394 octave_value_list *_outp=&_out;
12395 octave_value _outv;
12401 if (
_n_dims( args(0) ) > 1 )
12405 temp1 = args(0).matrix_value();
12406 arg1 = &temp1( 0, 0 );
12410 if (
_n_dims( args(1) ) > 1 )
12414 temp2 = args(1).matrix_value();
12415 arg2 = &temp2( 0, 0 );
12419 if (
_n_dims( args(2) ) > 2 )
12421 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12425 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12429 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12431 temp3 = args(2).matrix_value();
12432 arg3 = &temp3( 0, 0 );
12440 arg6 = static_cast< PLINT >(val6);
12442 if (
_n_dims( args(4) ) > 1 )
12446 temp7 = args(4).matrix_value();
12447 arg7 = &temp7( 0, 0 );
12450 my_plot3dc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12451 _outv = octave_value();
12479 return octave_value_list();
12506 octave_value_list _out;
12507 octave_value_list *_outp=&_out;
12508 octave_value _outv;
12514 if (
_n_dims( args(0) ) > 1 )
12518 temp1 = args(0).matrix_value();
12519 arg1 = &temp1( 0, 0 );
12523 if (
_n_dims( args(1) ) > 1 )
12527 temp2 = args(1).matrix_value();
12528 arg2 = &temp2( 0, 0 );
12532 if (
_n_dims( args(2) ) > 2 )
12534 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12538 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12542 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12544 temp3 = args(2).matrix_value();
12545 arg3 = &temp3( 0, 0 );
12553 arg6 = static_cast< PLINT >(val6);
12555 if (
_n_dims( args(4) ) > 1 )
12559 temp7 = args(4).matrix_value();
12560 arg7 = &temp7( 0, 0 );
12567 arg9 = static_cast< PLINT >(val9);
12569 if (
_n_dims( args(6) ) > 1 )
12575 temp10 = args(6).matrix_value();
12579 if (
_n_dims( args(7) ) > 1 )
12587 temp12 = args(7).matrix_value();
12591 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);
12592 _outv = octave_value();
12632 return octave_value_list();
12651 octave_value_list _out;
12652 octave_value_list *_outp=&_out;
12653 octave_value _outv;
12659 if (
_n_dims( args(0) ) > 1 )
12663 temp1 = args(0).matrix_value();
12664 arg1 = &temp1( 0, 0 );
12668 if (
_n_dims( args(1) ) > 1 )
12672 temp2 = args(1).matrix_value();
12673 arg2 = &temp2( 0, 0 );
12677 if (
_n_dims( args(2) ) > 2 )
12679 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12683 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12687 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12689 temp3 = args(2).matrix_value();
12690 arg3 = &temp3( 0, 0 );
12698 arg6 = static_cast< PLINT >(val6);
12700 if (
_n_dims( args(4) ) > 1 )
12704 temp7 = args(4).matrix_value();
12705 arg7 = &temp7( 0, 0 );
12708 my_plsurf3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12709 _outv = octave_value();
12737 return octave_value_list();
12764 octave_value_list _out;
12765 octave_value_list *_outp=&_out;
12766 octave_value _outv;
12772 if (
_n_dims( args(0) ) > 1 )
12776 temp1 = args(0).matrix_value();
12777 arg1 = &temp1( 0, 0 );
12781 if (
_n_dims( args(1) ) > 1 )
12785 temp2 = args(1).matrix_value();
12786 arg2 = &temp2( 0, 0 );
12790 if (
_n_dims( args(2) ) > 2 )
12792 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12796 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12800 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12802 temp3 = args(2).matrix_value();
12803 arg3 = &temp3( 0, 0 );
12811 arg6 = static_cast< PLINT >(val6);
12813 if (
_n_dims( args(4) ) > 1 )
12817 temp7 = args(4).matrix_value();
12818 arg7 = &temp7( 0, 0 );
12825 arg9 = static_cast< PLINT >(val9);
12827 if (
_n_dims( args(6) ) > 1 )
12833 temp10 = args(6).matrix_value();
12837 if (
_n_dims( args(7) ) > 1 )
12845 temp12 = args(7).matrix_value();
12849 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);
12850 _outv = octave_value();
12890 return octave_value_list();
12945 octave_value_list _out;
12946 octave_value_list *_outp=&_out;
12947 octave_value _outv;
12953 if (
_n_dims( args(0) ) > 2 )
12955 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12957 temp1 = args(0).matrix_value();
12958 arg1 = &temp1( 0, 0 );
12963 if (
_n_dims( args(1) ) > 1 )
12968 temp4 = args(1).matrix_value();
12969 arg4 = &temp4( 0, 0 );
12975 arg5 = static_cast< PLFLT >(val5);
12980 arg6 = static_cast< PLFLT >(val6);
12985 arg7 = static_cast< PLFLT >(val7);
12990 arg8 = static_cast< PLFLT >(val8);
12995 arg9 = static_cast< PLFLT >(val9);
13000 arg10 = static_cast< PLFLT >(val10);
13005 arg11 = static_cast< PLINT >(val11);
13010 arg12 = static_cast< PLFLT >(val12);
13015 arg13 = static_cast< PLINT >(val13);
13020 arg14 = static_cast< PLINT >(val14);
13025 arg15 = static_cast< PLINT >(val15);
13030 arg16 = static_cast< PLINT >(val16);
13035 arg17 = static_cast< PLINT >(val17);
13040 arg18 = static_cast< PLBOOL >(val18);
13042 if (
_n_dims( args(16) ) > 1 )
13046 if (
_dim( args(16), 0 ) != 6 )
13050 temp19 = args(16).matrix_value();
13051 arg19 = &temp19( 0, 0 );
13053 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);
13054 _outv = octave_value();
13076 return octave_value_list();
13084 char *arg4 = (
char *) 0 ;
13135 octave_value_list _out;
13136 octave_value_list *_outp=&_out;
13137 octave_value _outv;
13143 if (
_n_dims( args(0) ) > 2 )
13145 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13147 temp1 = args(0).matrix_value();
13148 arg1 = &temp1( 0, 0 );
13156 arg4 = reinterpret_cast< char * >(buf4);
13161 arg5 = static_cast< PLFLT >(val5);
13166 arg6 = static_cast< PLFLT >(val6);
13171 arg7 = static_cast< PLFLT >(val7);
13176 arg8 = static_cast< PLFLT >(val8);
13181 arg9 = static_cast< PLFLT >(val9);
13186 arg10 = static_cast< PLFLT >(val10);
13191 arg11 = static_cast< PLINT >(val11);
13196 arg12 = static_cast< PLFLT >(val12);
13201 arg13 = static_cast< PLINT >(val13);
13206 arg14 = static_cast< PLINT >(val14);
13211 arg15 = static_cast< PLINT >(val15);
13216 arg16 = static_cast< PLINT >(val16);
13221 arg17 = static_cast< PLINT >(val17);
13226 arg18 = static_cast< PLBOOL >(val18);
13228 if (
_n_dims( args(16) ) > 1 )
13232 if (
_dim( args(16), 0 ) !=
Xlen )
13236 temp19 = args(16).matrix_value();
13237 arg19 = &temp19( 0, 0 );
13240 if (
_n_dims( args(17) ) > 1 )
13244 if (
_dim( args(17), 0 ) !=
Ylen )
13248 temp20 = args(17).matrix_value();
13249 arg20 = &temp20( 0, 0 );
13251 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);
13252 _outv = octave_value();
13276 return octave_value_list();
13284 char *arg4 = (
char *) 0 ;
13335 octave_value_list _out;
13336 octave_value_list *_outp=&_out;
13337 octave_value _outv;
13343 if (
_n_dims( args(0) ) > 2 )
13345 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13347 temp1 = args(0).matrix_value();
13348 arg1 = &temp1( 0, 0 );
13356 arg4 = reinterpret_cast< char * >(buf4);
13361 arg5 = static_cast< PLFLT >(val5);
13366 arg6 = static_cast< PLFLT >(val6);
13371 arg7 = static_cast< PLFLT >(val7);
13376 arg8 = static_cast< PLFLT >(val8);
13381 arg9 = static_cast< PLFLT >(val9);
13386 arg10 = static_cast< PLFLT >(val10);
13391 arg11 = static_cast< PLINT >(val11);
13396 arg12 = static_cast< PLFLT >(val12);
13401 arg13 = static_cast< PLINT >(val13);
13406 arg14 = static_cast< PLINT >(val14);
13411 arg15 = static_cast< PLINT >(val15);
13416 arg16 = static_cast< PLINT >(val16);
13421 arg17 = static_cast< PLINT >(val17);
13426 arg18 = static_cast< PLBOOL >(val18);
13428 if (
_n_dims( args(16) ) > 2 )
13430 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13432 temp19 = args(16).matrix_value();
13433 arg19 = &temp19( 0, 0 );
13438 if (
_n_dims( args(17) ) > 2 )
13440 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13442 temp20 = args(17).matrix_value();
13443 arg20 = &temp20( 0, 0 );
13447 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);
13448 _outv = octave_value();
13472 return octave_value_list();
13508 octave_value_list _out;
13509 octave_value_list *_outp=&_out;
13510 octave_value _outv;
13516 if (
_n_dims( args(0) ) > 2 )
13518 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13520 temp1 = args(0).matrix_value();
13521 arg1 = &temp1( 0, 0 );
13529 arg4 = static_cast< PLFLT >(val4);
13534 arg5 = static_cast< PLFLT >(val5);
13539 arg6 = static_cast< PLFLT >(val6);
13544 arg7 = static_cast< PLFLT >(val7);
13546 if (
_n_dims( args(5) ) > 1 )
13550 temp8 = args(5).matrix_value();
13551 arg8 = &temp8( 0, 0 );
13558 arg10 = static_cast< PLINT >(val10);
13563 arg11 = static_cast< PLINT >(val11);
13568 arg12 = static_cast< PLINT >(val12);
13573 arg13 = static_cast< PLBOOL >(val13);
13574 my_plshades((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13);
13575 _outv = octave_value();
13591 return octave_value_list();
13629 octave_value_list _out;
13630 octave_value_list *_outp=&_out;
13631 octave_value _outv;
13637 if (
_n_dims( args(0) ) > 2 )
13639 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13641 temp1 = args(0).matrix_value();
13642 arg1 = &temp1( 0, 0 );
13650 arg4 = static_cast< PLFLT >(val4);
13655 arg5 = static_cast< PLFLT >(val5);
13660 arg6 = static_cast< PLFLT >(val6);
13665 arg7 = static_cast< PLFLT >(val7);
13667 if (
_n_dims( args(5) ) > 1 )
13671 temp8 = args(5).matrix_value();
13672 arg8 = &temp8( 0, 0 );
13679 arg10 = static_cast< PLINT >(val10);
13684 arg11 = static_cast< PLINT >(val11);
13689 arg12 = static_cast< PLINT >(val12);
13694 arg13 = static_cast< PLBOOL >(val13);
13696 if (
_n_dims( args(10) ) > 1 )
13700 if (
_dim( args(10), 0 ) != 6 )
13704 temp14 = args(10).matrix_value();
13705 arg14 = &temp14( 0, 0 );
13707 my_plshadesx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
13708 _outv = octave_value();
13730 return octave_value_list();
13770 octave_value_list _out;
13771 octave_value_list *_outp=&_out;
13772 octave_value _outv;
13778 if (
_n_dims( args(0) ) > 2 )
13780 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13782 temp1 = args(0).matrix_value();
13783 arg1 = &temp1( 0, 0 );
13791 arg4 = static_cast< PLFLT >(val4);
13796 arg5 = static_cast< PLFLT >(val5);
13801 arg6 = static_cast< PLFLT >(val6);
13806 arg7 = static_cast< PLFLT >(val7);
13808 if (
_n_dims( args(5) ) > 1 )
13812 temp8 = args(5).matrix_value();
13813 arg8 = &temp8( 0, 0 );
13820 arg10 = static_cast< PLINT >(val10);
13825 arg11 = static_cast< PLINT >(val11);
13830 arg12 = static_cast< PLINT >(val12);
13835 arg13 = static_cast< PLBOOL >(val13);
13837 if (
_n_dims( args(10) ) > 1 )
13841 if (
_dim( args(10), 0 ) !=
Xlen )
13845 temp14 = args(10).matrix_value();
13846 arg14 = &temp14( 0, 0 );
13849 if (
_n_dims( args(11) ) > 1 )
13853 if (
_dim( args(11), 0 ) !=
Ylen )
13857 temp15 = args(11).matrix_value();
13858 arg15 = &temp15( 0, 0 );
13860 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);
13861 _outv = octave_value();
13889 return octave_value_list();
13929 octave_value_list _out;
13930 octave_value_list *_outp=&_out;
13931 octave_value _outv;
13937 if (
_n_dims( args(0) ) > 2 )
13939 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13941 temp1 = args(0).matrix_value();
13942 arg1 = &temp1( 0, 0 );
13950 arg4 = static_cast< PLFLT >(val4);
13955 arg5 = static_cast< PLFLT >(val5);
13960 arg6 = static_cast< PLFLT >(val6);
13965 arg7 = static_cast< PLFLT >(val7);
13967 if (
_n_dims( args(5) ) > 1 )
13971 temp8 = args(5).matrix_value();
13972 arg8 = &temp8( 0, 0 );
13979 arg10 = static_cast< PLINT >(val10);
13984 arg11 = static_cast< PLINT >(val11);
13989 arg12 = static_cast< PLINT >(val12);
13994 arg13 = static_cast< PLBOOL >(val13);
13996 if (
_n_dims( args(10) ) > 2 )
13998 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14000 temp14 = args(10).matrix_value();
14001 arg14 = &temp14( 0, 0 );
14006 if (
_n_dims( args(11) ) > 2 )
14008 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14010 temp15 = args(11).matrix_value();
14011 arg15 = &temp15( 0, 0 );
14015 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);
14016 _outv = octave_value();
14044 return octave_value_list();
14060 octave_value_list _out;
14061 octave_value_list *_outp=&_out;
14062 octave_value _outv;
14068 if (
_n_dims( args(0) ) > 2 )
14070 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14072 temp1 = args(0).matrix_value();
14073 arg1 = &temp1( 0, 0 );
14078 if (
_n_dims( args(1) ) > 2 )
14080 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14084 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14088 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14090 temp2 = args(1).matrix_value();
14091 arg2 = &temp2( 0, 0 );
14099 arg5 = static_cast< PLFLT >(val5);
14101 if (
_n_dims( args(3) ) > 1 )
14105 if (
_dim( args(3), 0 ) != 6 )
14109 temp6 = args(3).matrix_value();
14110 arg6 = &temp6( 0, 0 );
14112 my_plvect((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
14113 _outv = octave_value();
14135 return octave_value_list();
14153 octave_value_list _out;
14154 octave_value_list *_outp=&_out;
14155 octave_value _outv;
14161 if (
_n_dims( args(0) ) > 2 )
14163 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14165 temp1 = args(0).matrix_value();
14166 arg1 = &temp1( 0, 0 );
14171 if (
_n_dims( args(1) ) > 2 )
14173 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14177 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14181 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14183 temp2 = args(1).matrix_value();
14184 arg2 = &temp2( 0, 0 );
14192 arg5 = static_cast< PLFLT >(val5);
14194 if (
_n_dims( args(3) ) > 1 )
14202 temp6 = args(3).matrix_value();
14203 arg6 = &temp6( 0, 0 );
14206 if (
_n_dims( args(4) ) > 1 )
14214 temp7 = args(4).matrix_value();
14215 arg7 = &temp7( 0, 0 );
14217 my_plvect1((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14218 _outv = octave_value();
14246 return octave_value_list();
14264 octave_value_list _out;
14265 octave_value_list *_outp=&_out;
14266 octave_value _outv;
14272 if (
_n_dims( args(0) ) > 2 )
14274 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14276 temp1 = args(0).matrix_value();
14277 arg1 = &temp1( 0, 0 );
14282 if (
_n_dims( args(1) ) > 2 )
14284 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14288 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14292 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14294 temp2 = args(1).matrix_value();
14295 arg2 = &temp2( 0, 0 );
14303 arg5 = static_cast< PLFLT >(val5);
14305 if (
_n_dims( args(3) ) > 2 )
14307 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14309 temp6 = args(3).matrix_value();
14310 arg6 = &temp6( 0, 0 );
14315 if (
_n_dims( args(4) ) > 2 )
14317 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14319 temp7 = args(4).matrix_value();
14320 arg7 = &temp7( 0, 0 );
14324 my_plvect2((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14325 _outv = octave_value();
14353 return octave_value_list();
14392 octave_value_list _out;
14393 octave_value_list *_outp=&_out;
14394 octave_value _outv;
14400 if (
_n_dims( args(0) ) > 2 )
14402 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14404 temp1 = args(0).matrix_value();
14405 arg1 = &temp1( 0, 0 );
14413 arg4 = static_cast< PLFLT >(val4);
14418 arg5 = static_cast< PLFLT >(val5);
14423 arg6 = static_cast< PLFLT >(val6);
14428 arg7 = static_cast< PLFLT >(val7);
14433 arg8 = static_cast< PLFLT >(val8);
14438 arg9 = static_cast< PLFLT >(val9);
14443 arg10 = static_cast< PLFLT >(val10);
14448 arg11 = static_cast< PLFLT >(val11);
14453 arg12 = static_cast< PLFLT >(val12);
14458 arg13 = static_cast< PLFLT >(val13);
14459 my_plimage((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14460 _outv = octave_value();
14470 return octave_value_list();
14503 octave_value_list _out;
14504 octave_value_list *_outp=&_out;
14505 octave_value _outv;
14511 if (
_n_dims( args(0) ) > 2 )
14513 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14515 temp1 = args(0).matrix_value();
14516 arg1 = &temp1( 0, 0 );
14524 arg4 = static_cast< PLFLT >(val4);
14529 arg5 = static_cast< PLFLT >(val5);
14534 arg6 = static_cast< PLFLT >(val6);
14539 arg7 = static_cast< PLFLT >(val7);
14544 arg8 = static_cast< PLFLT >(val8);
14549 arg9 = static_cast< PLFLT >(val9);
14554 arg10 = static_cast< PLFLT >(val10);
14559 arg11 = static_cast< PLFLT >(val11);
14560 my_plimagefr((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
14561 _outv = octave_value();
14571 return octave_value_list();
14606 octave_value_list _out;
14607 octave_value_list *_outp=&_out;
14608 octave_value _outv;
14614 if (
_n_dims( args(0) ) > 2 )
14616 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14618 temp1 = args(0).matrix_value();
14619 arg1 = &temp1( 0, 0 );
14627 arg4 = static_cast< PLFLT >(val4);
14632 arg5 = static_cast< PLFLT >(val5);
14637 arg6 = static_cast< PLFLT >(val6);
14642 arg7 = static_cast< PLFLT >(val7);
14647 arg8 = static_cast< PLFLT >(val8);
14652 arg9 = static_cast< PLFLT >(val9);
14657 arg10 = static_cast< PLFLT >(val10);
14662 arg11 = static_cast< PLFLT >(val11);
14664 if (
_n_dims( args(9) ) > 1 )
14668 if (
_dim( args(9), 0 ) != 6 )
14672 temp12 = args(9).matrix_value();
14673 arg12 = &temp12( 0, 0 );
14675 my_plimagefrx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14676 _outv = octave_value();
14692 return octave_value_list();
14729 octave_value_list _out;
14730 octave_value_list *_outp=&_out;
14731 octave_value _outv;
14737 if (
_n_dims( args(0) ) > 2 )
14739 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14741 temp1 = args(0).matrix_value();
14742 arg1 = &temp1( 0, 0 );
14750 arg4 = static_cast< PLFLT >(val4);
14755 arg5 = static_cast< PLFLT >(val5);
14760 arg6 = static_cast< PLFLT >(val6);
14765 arg7 = static_cast< PLFLT >(val7);
14770 arg8 = static_cast< PLFLT >(val8);
14775 arg9 = static_cast< PLFLT >(val9);
14780 arg10 = static_cast< PLFLT >(val10);
14785 arg11 = static_cast< PLFLT >(val11);
14787 if (
_n_dims( args(9) ) > 1 )
14795 temp12 = args(9).matrix_value();
14796 arg12 = &temp12( 0, 0 );
14799 if (
_n_dims( args(10) ) > 1 )
14803 if (
_dim( args(10), 0 ) !=
Ylen )
14807 temp13 = args(10).matrix_value();
14808 arg13 = &temp13( 0, 0 );
14810 my_plimagefr1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
14811 _outv = octave_value();
14833 return octave_value_list();
14870 octave_value_list _out;
14871 octave_value_list *_outp=&_out;
14872 octave_value _outv;
14878 if (
_n_dims( args(0) ) > 2 )
14880 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14882 temp1 = args(0).matrix_value();
14883 arg1 = &temp1( 0, 0 );
14891 arg4 = static_cast< PLFLT >(val4);
14896 arg5 = static_cast< PLFLT >(val5);
14901 arg6 = static_cast< PLFLT >(val6);
14906 arg7 = static_cast< PLFLT >(val7);
14911 arg8 = static_cast< PLFLT >(val8);
14916 arg9 = static_cast< PLFLT >(val9);
14921 arg10 = static_cast< PLFLT >(val10);
14926 arg11 = static_cast< PLFLT >(val11);
14928 if (
_n_dims( args(9) ) > 2 )
14930 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14932 temp12 = args(9).matrix_value();
14933 arg12 = &temp12( 0, 0 );
14938 if (
_n_dims( args(10) ) > 2 )
14940 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14942 temp13 = args(10).matrix_value();
14943 arg13 = &temp13( 0, 0 );
14947 my_plimagefr2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
14948 _outv = octave_value();
14970 return octave_value_list();
14992 char **arg18 = (
char **) 0 ;
14994 char **arg20 = (
char **) 0 ;
15034 octave_value_list _out;
15035 octave_value_list *_outp=&_out;
15036 octave_value _outv;
15047 arg3 = static_cast< PLINT >(val3);
15052 arg4 = static_cast< PLINT >(val4);
15057 arg5 = static_cast< PLFLT >(val5);
15062 arg6 = static_cast< PLFLT >(val6);
15067 arg7 = static_cast< PLFLT >(val7);
15072 arg8 = static_cast< PLFLT >(val8);
15077 arg9 = static_cast< PLINT >(val9);
15082 arg10 = static_cast< PLINT >(val10);
15087 arg11 = static_cast< PLINT >(val11);
15092 arg12 = static_cast< PLFLT >(val12);
15097 arg13 = static_cast< PLFLT >(val13);
15102 arg14 = static_cast< PLINT >(val14);
15107 arg15 = static_cast< PLFLT >(val15);
15109 if (
_n_dims( args(13) ) > 1 )
15115 temp16 = args(13).matrix_value();
15119 charMatrix temp_matrix;
15123 size_t max_length = 0, non_blank_length;
15125 if (
_n_dims( args(14) ) > 2 )
15127 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
15129 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15130 if ( !args(14).isempty() )
15132 if ( !args(14).is_empty() )
15135 if (
_dim( args(14), 0 ) !=
Alen )
15137 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
15139 arg18 =
new char*[
Alen];
15140 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15141 ifcell = args(14).iscell();
15143 ifcell = args(14).is_cell();
15147 temp_cell = args(14).cell_value();
15151 temp_matrix = args(14).char_matrix_value();
15153 max_length =
_dim( args(14), 1 ) + 1;
15156 for ( i = 0; i <
Alen; i++ )
15163 if ( temp_cell.elem( i ).is_string() )
15165 str = temp_cell.elem( i ).string_value();
15167 max_length = str.size() + 1;
15168 tmp_cstring = (
char *) str.c_str();
15178 tmp_cstring = (
char *)
"";
15183 str = temp_matrix.row_as_string( i );
15184 tmp_cstring = (
char *) str.c_str();
15186 arg18[i] =
new char[max_length];
15187 strncpy( arg18[i], tmp_cstring, max_length - 1 );
15188 arg18[i][max_length - 1] =
'\0';
15203 non_blank_length = max_length - 2;
15204 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
'\0' )
15206 non_blank_length--;
15208 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
' ' )
15210 non_blank_length--;
15212 arg18[i][non_blank_length + 1] =
'\0';
15222 charMatrix temp_matrix;
15226 size_t max_length = 0, non_blank_length;
15228 if (
_n_dims( args(15) ) > 2 )
15230 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
15232 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15233 if ( !args(15).isempty() )
15235 if ( !args(15).is_empty() )
15240 arg20 =
new char*[
Alen];
15241 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15242 ifcell = args(15).iscell();
15244 ifcell = args(15).is_cell();
15248 temp_cell = args(15).cell_value();
15252 temp_matrix = args(15).char_matrix_value();
15254 max_length =
_dim( args(15), 1 ) + 1;
15257 for ( i = 0; i <
Alen; i++ )
15264 if ( temp_cell.elem( i ).is_string() )
15266 str = temp_cell.elem( i ).string_value();
15268 max_length = str.size() + 1;
15269 tmp_cstring = (
char *) str.c_str();
15279 tmp_cstring = (
char *)
"";
15284 str = temp_matrix.row_as_string( i );
15285 tmp_cstring = (
char *) str.c_str();
15287 arg20[i] =
new char[max_length];
15288 strncpy( arg20[i], tmp_cstring, max_length - 1 );
15289 arg20[i][max_length - 1] =
'\0';
15304 non_blank_length = max_length - 2;
15305 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
15307 non_blank_length--;
15309 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
15311 non_blank_length--;
15313 arg20[i][non_blank_length + 1] =
'\0';
15324 if (
_n_dims( args(16) ) > 1 )
15328 if (
_dim( args(16), 0 ) !=
Alen )
15332 temp21 = args(16).matrix_value();
15333 arg21 = &temp21( 0, 0 );
15336 if (
_n_dims( args(17) ) > 1 )
15340 if (
_dim( args(17), 0 ) !=
Alen )
15344 temp22 = args(17).matrix_value();
15350 if (
_n_dims( args(18) ) > 1 )
15354 if (
_dim( args(18), 0 ) !=
Alen )
15359 temp23 = args(18).matrix_value();
15363 for ( i = 0; i <
Xlen; i++ )
15364 if ( arg23[i] >
Ylen )
15368 if (
_n_dims( args(19) ) > 2 )
15370 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15372 if (
_dim( args(19), 0 ) !=
Xlen )
15374 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
15376 if (
_dim( args(19), 1 ) !=
Ylen )
15378 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
15380 temp24 = args(19).matrix_value();
15381 arg24 = &temp24( 0, 0 );
15383 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);
15384 _outv = octave_value();
15403 if ( arg18 != NULL )
15405 for ( i = 0; i <
Alen; i++ )
15414 if ( arg20 != NULL )
15416 for ( i = 0; i <
Alen; i++ )
15442 if ( arg18 != NULL )
15444 for ( i = 0; i <
Alen; i++ )
15453 if ( arg20 != NULL )
15455 for ( i = 0; i <
Alen; i++ )
15474 return octave_value_list();
15485 octave_value_list _out;
15486 octave_value_list *_outp=&_out;
15487 octave_value _outv;
15496 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15501 arg2 = static_cast< int >(val2);
15502 if (arg1) (arg1)->type = arg2;
15503 _outv = octave_value();
15507 return octave_value_list();
15515 octave_value_list _out;
15516 octave_value_list *_outp=&_out;
15517 octave_value _outv;
15527 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15528 result = (int) ((arg1)->type);
15533 return octave_value_list();
15539 unsigned int arg2 ;
15542 unsigned int val2 ;
15544 octave_value_list _out;
15545 octave_value_list *_outp=&_out;
15546 octave_value _outv;
15555 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15560 arg2 = static_cast< unsigned int >(val2);
15561 if (arg1) (arg1)->state = arg2;
15562 _outv = octave_value();
15566 return octave_value_list();
15574 octave_value_list _out;
15575 octave_value_list *_outp=&_out;
15576 octave_value _outv;
15577 unsigned int result;
15586 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15587 result = (
unsigned int) ((arg1)->state);
15592 return octave_value_list();
15598 unsigned int arg2 ;
15601 unsigned int val2 ;
15603 octave_value_list _out;
15604 octave_value_list *_outp=&_out;
15605 octave_value _outv;
15614 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15619 arg2 = static_cast< unsigned int >(val2);
15620 if (arg1) (arg1)->keysym = arg2;
15621 _outv = octave_value();
15625 return octave_value_list();
15633 octave_value_list _out;
15634 octave_value_list *_outp=&_out;
15635 octave_value _outv;
15636 unsigned int result;
15645 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15646 result = (
unsigned int) ((arg1)->keysym);
15651 return octave_value_list();
15657 unsigned int arg2 ;
15660 unsigned int val2 ;
15662 octave_value_list _out;
15663 octave_value_list *_outp=&_out;
15664 octave_value _outv;
15673 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15678 arg2 = static_cast< unsigned int >(val2);
15679 if (arg1) (arg1)->button = arg2;
15680 _outv = octave_value();
15684 return octave_value_list();
15692 octave_value_list _out;
15693 octave_value_list *_outp=&_out;
15694 octave_value _outv;
15695 unsigned int result;
15704 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15705 result = (
unsigned int) ((arg1)->button);
15710 return octave_value_list();
15721 octave_value_list _out;
15722 octave_value_list *_outp=&_out;
15723 octave_value _outv;
15732 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15737 arg2 = static_cast< PLINT >(val2);
15738 if (arg1) (arg1)->subwindow = arg2;
15739 _outv = octave_value();
15743 return octave_value_list();
15751 octave_value_list _out;
15752 octave_value_list *_outp=&_out;
15753 octave_value _outv;
15763 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15764 result = (
PLINT) ((arg1)->subwindow);
15769 return octave_value_list();
15780 octave_value_list _out;
15781 octave_value_list *_outp=&_out;
15782 octave_value _outv;
15791 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15796 arg2 = reinterpret_cast< char * >(temp2);
15797 if (arg2) memcpy(arg1->
string,arg2,16*
sizeof(
char));
15798 else memset(arg1->
string,0,16*
sizeof(
char));
15799 _outv = octave_value();
15803 return octave_value_list();
15811 octave_value_list _out;
15812 octave_value_list *_outp=&_out;
15813 octave_value _outv;
15823 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15824 result = (
char *)(
char *) ((arg1)->
string);
15835 return octave_value_list();
15846 octave_value_list _out;
15847 octave_value_list *_outp=&_out;
15848 octave_value _outv;
15857 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15862 arg2 = static_cast< int >(val2);
15863 if (arg1) (arg1)->pX = arg2;
15864 _outv = octave_value();
15868 return octave_value_list();
15876 octave_value_list _out;
15877 octave_value_list *_outp=&_out;
15878 octave_value _outv;
15888 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15889 result = (int) ((arg1)->pX);
15894 return octave_value_list();
15905 octave_value_list _out;
15906 octave_value_list *_outp=&_out;
15907 octave_value _outv;
15916 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15921 arg2 = static_cast< int >(val2);
15922 if (arg1) (arg1)->pY = arg2;
15923 _outv = octave_value();
15927 return octave_value_list();
15935 octave_value_list _out;
15936 octave_value_list *_outp=&_out;
15937 octave_value _outv;
15947 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15948 result = (int) ((arg1)->pY);
15953 return octave_value_list();
15964 octave_value_list _out;
15965 octave_value_list *_outp=&_out;
15966 octave_value _outv;
15975 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15980 arg2 = static_cast< PLFLT >(val2);
15981 if (arg1) (arg1)->dX = arg2;
15982 _outv = octave_value();
15986 return octave_value_list();
15994 octave_value_list _out;
15995 octave_value_list *_outp=&_out;
15996 octave_value _outv;
16006 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16007 result = (
PLFLT) ((arg1)->dX);
16012 return octave_value_list();
16023 octave_value_list _out;
16024 octave_value_list *_outp=&_out;
16025 octave_value _outv;
16034 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16039 arg2 = static_cast< PLFLT >(val2);
16040 if (arg1) (arg1)->dY = arg2;
16041 _outv = octave_value();
16045 return octave_value_list();
16053 octave_value_list _out;
16054 octave_value_list *_outp=&_out;
16055 octave_value _outv;
16065 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16066 result = (
PLFLT) ((arg1)->dY);
16071 return octave_value_list();
16082 octave_value_list _out;
16083 octave_value_list *_outp=&_out;
16084 octave_value _outv;
16093 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16098 arg2 = static_cast< PLFLT >(val2);
16099 if (arg1) (arg1)->wX = arg2;
16100 _outv = octave_value();
16104 return octave_value_list();
16112 octave_value_list _out;
16113 octave_value_list *_outp=&_out;
16114 octave_value _outv;
16124 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16125 result = (
PLFLT) ((arg1)->wX);
16130 return octave_value_list();
16141 octave_value_list _out;
16142 octave_value_list *_outp=&_out;
16143 octave_value _outv;
16152 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16157 arg2 = static_cast< PLFLT >(val2);
16158 if (arg1) (arg1)->wY = arg2;
16159 _outv = octave_value();
16163 return octave_value_list();
16171 octave_value_list _out;
16172 octave_value_list *_outp=&_out;
16173 octave_value _outv;
16183 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16184 result = (
PLFLT) ((arg1)->wY);
16189 return octave_value_list();
16194 octave_value_list _out;
16195 octave_value_list *_outp=&_out;
16196 octave_value _outv;
16207 return octave_value_list();
16215 octave_value_list _out;
16216 octave_value_list *_outp=&_out;
16217 octave_value _outv;
16226 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16228 _outv = octave_value();
16232 return octave_value_list();
16262 octave_value_list _out;
16263 octave_value_list *_outp=&_out;
16264 octave_value _outv;
16273 arg1 = static_cast< PLINT >(val1);
16278 arg2 = static_cast< PLINT >(val2);
16280 _outv = octave_value();
16284 return octave_value_list();
16301 octave_value_list _out;
16302 octave_value_list *_outp=&_out;
16303 octave_value _outv;
16312 arg1 = static_cast< PLFLT >(val1);
16317 arg2 = static_cast< PLFLT >(val2);
16322 arg3 = static_cast< PLFLT >(val3);
16327 arg4 = static_cast< PLINT >(val4);
16329 _outv = octave_value();
16333 return octave_value_list();
16341 octave_value_list _out;
16342 octave_value_list *_outp=&_out;
16343 octave_value _outv;
16352 arg1 = static_cast< PLINT >(val1);
16354 _outv = octave_value();
16358 return octave_value_list();
16387 octave_value_list _out;
16388 octave_value_list *_outp=&_out;
16389 octave_value _outv;
16398 arg1 = static_cast< PLFLT >(val1);
16403 arg2 = static_cast< PLFLT >(val2);
16408 arg3 = static_cast< PLFLT >(val3);
16413 arg4 = static_cast< PLFLT >(val4);
16418 arg5 = static_cast< PLFLT >(val5);
16423 arg6 = static_cast< PLFLT >(val6);
16428 arg7 = static_cast< PLFLT >(val7);
16433 arg8 = static_cast< PLBOOL >(val8);
16434 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
16435 _outv = octave_value();
16439 return octave_value_list();
16446 char *arg3 = (
char *) 0 ;
16449 char *arg6 = (
char *) 0 ;
16470 octave_value_list _out;
16471 octave_value_list *_outp=&_out;
16472 octave_value _outv;
16481 arg1 = static_cast< PLFLT >(val1);
16486 arg2 = static_cast< PLFLT >(val2);
16491 arg3 = reinterpret_cast< char * >(buf3);
16496 arg4 = static_cast< PLFLT >(val4);
16501 arg5 = static_cast< PLINT >(val5);
16506 arg6 = reinterpret_cast< char * >(buf6);
16511 arg7 = static_cast< PLFLT >(val7);
16516 arg8 = static_cast< PLINT >(val8);
16517 plaxes(arg1,arg2,(
char const *)arg3,arg4,arg5,(
char const *)arg6,arg7,arg8);
16518 _outv = octave_value();
16526 return octave_value_list();
16539 octave_value_list _out;
16540 octave_value_list *_outp=&_out;
16541 octave_value _outv;
16547 if (
_n_dims( args(0) ) > 1 )
16552 temp1 = args(0).matrix_value();
16553 arg2 = &temp1( 0, 0 );
16556 if (
_n_dims( args(1) ) > 1 )
16564 temp3 = args(1).matrix_value();
16565 arg3 = &temp3( 0, 0 );
16571 arg4 = static_cast< PLINT >(val4);
16572 plbin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
16573 _outv = octave_value();
16589 return octave_value_list();
16615 octave_value_list _out;
16616 octave_value_list *_outp=&_out;
16617 octave_value _outv;
16632 arg7 = static_cast< PLFLT >(val7);
16633 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
16634 _outv = octave_value();
16674 return octave_value_list();
16679 octave_value_list _out;
16680 octave_value_list *_outp=&_out;
16681 octave_value _outv;
16687 _outv = octave_value();
16691 return octave_value_list();
16696 char *arg1 = (
char *) 0 ;
16699 char *arg4 = (
char *) 0 ;
16716 octave_value_list _out;
16717 octave_value_list *_outp=&_out;
16718 octave_value _outv;
16727 arg1 = reinterpret_cast< char * >(buf1);
16732 arg2 = static_cast< PLFLT >(val2);
16737 arg3 = static_cast< PLINT >(val3);
16742 arg4 = reinterpret_cast< char * >(buf4);
16747 arg5 = static_cast< PLFLT >(val5);
16752 arg6 = static_cast< PLINT >(val6);
16753 plbox((
char const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6);
16754 _outv = octave_value();
16762 return octave_value_list();
16767 char *arg1 = (
char *) 0 ;
16768 char *arg2 = (
char *) 0 ;
16771 char *arg5 = (
char *) 0 ;
16772 char *arg6 = (
char *) 0 ;
16775 char *arg9 = (
char *) 0 ;
16776 char *arg10 = (
char *) 0 ;
16809 octave_value_list _out;
16810 octave_value_list *_outp=&_out;
16811 octave_value _outv;
16820 arg1 = reinterpret_cast< char * >(buf1);
16825 arg2 = reinterpret_cast< char * >(buf2);
16830 arg3 = static_cast< PLFLT >(val3);
16835 arg4 = static_cast< PLINT >(val4);
16840 arg5 = reinterpret_cast< char * >(buf5);
16845 arg6 = reinterpret_cast< char * >(buf6);
16850 arg7 = static_cast< PLFLT >(val7);
16855 arg8 = static_cast< PLINT >(val8);
16860 arg9 = reinterpret_cast< char * >(buf9);
16865 arg10 = reinterpret_cast< char * >(buf10);
16870 arg11 = static_cast< PLFLT >(val11);
16875 arg12 = static_cast< PLINT >(val12);
16876 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);
16877 _outv = octave_value();
16893 return octave_value_list();
16913 octave_value_list _out;
16914 octave_value_list *_outp=&_out;
16915 octave_value _outv;
16927 arg1 = static_cast< PLFLT >(val1);
16932 arg2 = static_cast< PLFLT >(val2);
16934 _outv = octave_value();
16956 return octave_value_list();
16961 octave_value_list _out;
16962 octave_value_list *_outp=&_out;
16963 octave_value _outv;
16969 _outv = octave_value();
16973 return octave_value_list();
16981 octave_value_list _out;
16982 octave_value_list *_outp=&_out;
16983 octave_value _outv;
16992 arg1 = static_cast< PLINT >(val1);
16994 _outv = octave_value();
16998 return octave_value_list();
17006 octave_value_list _out;
17007 octave_value_list *_outp=&_out;
17008 octave_value _outv;
17017 arg1 = static_cast< PLFLT >(val1);
17019 _outv = octave_value();
17023 return octave_value_list();
17061 octave_value_list _out;
17062 octave_value_list *_outp=&_out;
17063 octave_value _outv;
17072 arg1 = static_cast< PLFLT >(val1);
17077 arg2 = static_cast< PLFLT >(val2);
17082 arg3 = static_cast< PLFLT >(val3);
17087 arg4 = static_cast< PLINT >(val4);
17092 arg5 = static_cast< PLBOOL >(val5);
17097 arg6 = static_cast< PLINT >(val6);
17102 arg7 = static_cast< PLINT >(val7);
17107 arg8 = static_cast< PLINT >(val8);
17112 arg9 = static_cast< PLINT >(val9);
17117 arg10 = static_cast< PLINT >(val10);
17122 arg11 = static_cast< PLFLT >(val11);
17123 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
17124 _outv = octave_value();
17128 return octave_value_list();
17154 octave_value_list _out;
17155 octave_value_list *_outp=&_out;
17156 octave_value _outv;
17166 arg1 = static_cast< PLINT >(val1);
17171 arg2 = static_cast< PLINT >(val2);
17176 arg3 = static_cast< PLINT >(val3);
17181 arg4 = static_cast< PLINT >(val4);
17186 arg5 = static_cast< PLINT >(val5);
17191 arg6 = static_cast< PLFLT >(val6);
17192 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17193 _outv = octave_value();
17203 return octave_value_list();
17214 octave_value_list _out;
17215 octave_value_list *_outp=&_out;
17216 octave_value _outv;
17225 arg1 = static_cast< PLINT >(val1);
17230 arg2 = static_cast< PLBOOL >(val2);
17232 _outv = octave_value();
17236 return octave_value_list();
17241 octave_value_list _out;
17242 octave_value_list *_outp=&_out;
17243 octave_value _outv;
17249 _outv = octave_value();
17253 return octave_value_list();
17258 octave_value_list _out;
17259 octave_value_list *_outp=&_out;
17260 octave_value _outv;
17266 _outv = octave_value();
17270 return octave_value_list();
17293 octave_value_list _out;
17294 octave_value_list *_outp=&_out;
17295 octave_value _outv;
17304 arg1 = static_cast< PLFLT >(val1);
17309 arg2 = static_cast< PLFLT >(val2);
17314 arg3 = static_cast< PLFLT >(val3);
17319 arg4 = static_cast< PLFLT >(val4);
17324 arg5 = static_cast< PLINT >(val5);
17329 arg6 = static_cast< PLINT >(val6);
17330 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
17331 _outv = octave_value();
17335 return octave_value_list();
17358 octave_value_list _out;
17359 octave_value_list *_outp=&_out;
17360 octave_value _outv;
17369 arg1 = static_cast< PLFLT >(val1);
17374 arg2 = static_cast< PLFLT >(val2);
17379 arg3 = static_cast< PLFLT >(val3);
17384 arg4 = static_cast< PLFLT >(val4);
17389 arg5 = static_cast< PLINT >(val5);
17394 arg6 = static_cast< PLINT >(val6);
17395 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
17396 _outv = octave_value();
17400 return octave_value_list();
17405 octave_value_list _out;
17406 octave_value_list *_outp=&_out;
17407 octave_value _outv;
17413 _outv = octave_value();
17417 return octave_value_list();
17429 octave_value_list _out;
17430 octave_value_list *_outp=&_out;
17431 octave_value _outv;
17437 if (
_n_dims( args(0) ) > 1 )
17442 temp1 = args(0).matrix_value();
17443 arg2 = &temp1( 0, 0 );
17446 if (
_n_dims( args(1) ) > 1 )
17454 temp3 = args(1).matrix_value();
17455 arg3 = &temp3( 0, 0 );
17458 if (
_n_dims( args(2) ) > 1 )
17466 temp4 = args(2).matrix_value();
17467 arg4 = &temp4( 0, 0 );
17469 plerrx(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
17470 _outv = octave_value();
17492 return octave_value_list();
17504 octave_value_list _out;
17505 octave_value_list *_outp=&_out;
17506 octave_value _outv;
17512 if (
_n_dims( args(0) ) > 1 )
17517 temp1 = args(0).matrix_value();
17518 arg2 = &temp1( 0, 0 );
17521 if (
_n_dims( args(1) ) > 1 )
17529 temp3 = args(1).matrix_value();
17530 arg3 = &temp3( 0, 0 );
17533 if (
_n_dims( args(2) ) > 1 )
17541 temp4 = args(2).matrix_value();
17542 arg4 = &temp4( 0, 0 );
17544 plerry(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
17545 _outv = octave_value();
17567 return octave_value_list();
17572 octave_value_list _out;
17573 octave_value_list *_outp=&_out;
17574 octave_value _outv;
17580 _outv = octave_value();
17584 return octave_value_list();
17594 octave_value_list _out;
17595 octave_value_list *_outp=&_out;
17596 octave_value _outv;
17602 if (
_n_dims( args(0) ) > 1 )
17607 temp1 = args(0).matrix_value();
17608 arg2 = &temp1( 0, 0 );
17611 if (
_n_dims( args(1) ) > 1 )
17619 temp3 = args(1).matrix_value();
17620 arg3 = &temp3( 0, 0 );
17622 plfill(arg1,(
double const *)arg2,(
double const *)arg3);
17623 _outv = octave_value();
17639 return octave_value_list();
17651 octave_value_list _out;
17652 octave_value_list *_outp=&_out;
17653 octave_value _outv;
17659 if (
_n_dims( args(0) ) > 1 )
17664 temp1 = args(0).matrix_value();
17665 arg2 = &temp1( 0, 0 );
17668 if (
_n_dims( args(1) ) > 1 )
17676 temp3 = args(1).matrix_value();
17677 arg3 = &temp3( 0, 0 );
17680 if (
_n_dims( args(2) ) > 1 )
17688 temp4 = args(2).matrix_value();
17689 arg4 = &temp4( 0, 0 );
17691 plfill3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
17692 _outv = octave_value();
17714 return octave_value_list();
17727 octave_value_list _out;
17728 octave_value_list *_outp=&_out;
17729 octave_value _outv;
17735 if (
_n_dims( args(0) ) > 1 )
17740 temp1 = args(0).matrix_value();
17741 arg2 = &temp1( 0, 0 );
17744 if (
_n_dims( args(1) ) > 1 )
17752 temp3 = args(1).matrix_value();
17753 arg3 = &temp3( 0, 0 );
17759 arg4 = static_cast< PLFLT >(val4);
17760 plgradient(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
17761 _outv = octave_value();
17777 return octave_value_list();
17782 octave_value_list _out;
17783 octave_value_list *_outp=&_out;
17784 octave_value _outv;
17790 _outv = octave_value();
17794 return octave_value_list();
17802 octave_value_list _out;
17803 octave_value_list *_outp=&_out;
17804 octave_value _outv;
17813 arg1 = static_cast< PLINT >(val1);
17815 _outv = octave_value();
17819 return octave_value_list();
17827 octave_value_list _out;
17828 octave_value_list *_outp=&_out;
17829 octave_value _outv;
17838 arg1 = static_cast< PLINT >(val1);
17840 _outv = octave_value();
17844 return octave_value_list();
17855 octave_value_list _out;
17856 octave_value_list *_outp=&_out;
17857 octave_value _outv;
17865 _outv = octave_value();
17881 return octave_value_list();
17898 octave_value_list _out;
17899 octave_value_list *_outp=&_out;
17900 octave_value _outv;
17912 arg1 = static_cast< PLINT >(val1);
17913 plgcol0(arg1,arg2,arg3,arg4);
17914 _outv = octave_value();
17936 return octave_value_list();
17956 octave_value_list _out;
17957 octave_value_list *_outp=&_out;
17958 octave_value _outv;
17971 arg1 = static_cast< PLINT >(val1);
17972 plgcol0a(arg1,arg2,arg3,arg4,arg5);
17973 _outv = octave_value();
18001 return octave_value_list();
18015 octave_value_list _out;
18016 octave_value_list *_outp=&_out;
18017 octave_value _outv;
18026 _outv = octave_value();
18048 return octave_value_list();
18065 octave_value_list _out;
18066 octave_value_list *_outp=&_out;
18067 octave_value _outv;
18077 _outv = octave_value();
18105 return octave_value_list();
18113 octave_value_list _out;
18114 octave_value_list *_outp=&_out;
18115 octave_value _outv;
18122 _outv = octave_value();
18132 return octave_value_list();
18137 char *arg1 = (
char *) 0 ;
18138 char local_string1[80] ;
18139 size_t local_string_length1 ;
18140 charMatrix local_charMatrix1 ;
18141 octave_value_list retval1 ;
18142 octave_value_list _out;
18143 octave_value_list *_outp=&_out;
18144 octave_value _outv;
18147 arg1 = local_string1;
18153 _outv = octave_value();
18156 local_string_length1 = strlen( local_string1 );
18157 local_charMatrix1 = charMatrix( 1, local_string_length1 );
18158 local_charMatrix1.insert( local_string1, 0, 0 );
18159 retval1( 0 ) = octave_value( local_charMatrix1 );
18164 return octave_value_list();
18181 octave_value_list _out;
18182 octave_value_list *_outp=&_out;
18183 octave_value _outv;
18193 _outv = octave_value();
18221 return octave_value_list();
18229 octave_value_list _out;
18230 octave_value_list *_outp=&_out;
18231 octave_value _outv;
18238 _outv = octave_value();
18248 return octave_value_list();
18265 octave_value_list _out;
18266 octave_value_list *_outp=&_out;
18267 octave_value _outv;
18277 _outv = octave_value();
18305 return octave_value_list();
18319 octave_value_list _out;
18320 octave_value_list *_outp=&_out;
18321 octave_value _outv;
18330 _outv = octave_value();
18352 return octave_value_list();
18360 octave_value_list _out;
18361 octave_value_list *_outp=&_out;
18362 octave_value _outv;
18369 _outv = octave_value();
18379 return octave_value_list();
18384 char *arg1 = (
char *) 0 ;
18385 char local_string1[80] ;
18386 size_t local_string_length1 ;
18387 charMatrix local_charMatrix1 ;
18388 octave_value_list retval1 ;
18389 octave_value_list _out;
18390 octave_value_list *_outp=&_out;
18391 octave_value _outv;
18394 arg1 = local_string1;
18400 _outv = octave_value();
18403 local_string_length1 = strlen( local_string1 );
18404 local_charMatrix1 = charMatrix( 1, local_string_length1 );
18405 local_charMatrix1.insert( local_string1, 0, 0 );
18406 retval1( 0 ) = octave_value( local_charMatrix1 );
18411 return octave_value_list();
18425 octave_value_list _out;
18426 octave_value_list *_outp=&_out;
18427 octave_value _outv;
18436 _outv = octave_value();
18458 return octave_value_list();
18466 octave_value_list _out;
18467 octave_value_list *_outp=&_out;
18468 octave_value _outv;
18475 _outv = octave_value();
18485 return octave_value_list();
18508 octave_value_list _out;
18509 octave_value_list *_outp=&_out;
18510 octave_value _outv;
18521 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
18522 _outv = octave_value();
18562 return octave_value_list();
18567 octave_value_list _out;
18568 octave_value_list *_outp=&_out;
18569 octave_value _outv;
18575 _outv = octave_value();
18579 return octave_value_list();
18596 octave_value_list _out;
18597 octave_value_list *_outp=&_out;
18598 octave_value _outv;
18607 plgspa(arg1,arg2,arg3,arg4);
18608 _outv = octave_value();
18636 return octave_value_list();
18644 octave_value_list _out;
18645 octave_value_list *_outp=&_out;
18646 octave_value _outv;
18653 _outv = octave_value();
18663 return octave_value_list();
18668 char *arg1 = (
char *) 0 ;
18669 char local_string1[80] ;
18670 size_t local_string_length1 ;
18671 charMatrix local_charMatrix1 ;
18672 octave_value_list retval1 ;
18673 octave_value_list _out;
18674 octave_value_list *_outp=&_out;
18675 octave_value _outv;
18678 arg1 = local_string1;
18684 _outv = octave_value();
18687 local_string_length1 = strlen( local_string1 );
18688 local_charMatrix1 = charMatrix( 1, local_string_length1 );
18689 local_charMatrix1.insert( local_string1, 0, 0 );
18690 retval1( 0 ) = octave_value( local_charMatrix1 );
18695 return octave_value_list();
18712 octave_value_list _out;
18713 octave_value_list *_outp=&_out;
18714 octave_value _outv;
18723 plgvpd(arg1,arg2,arg3,arg4);
18724 _outv = octave_value();
18752 return octave_value_list();
18769 octave_value_list _out;
18770 octave_value_list *_outp=&_out;
18771 octave_value _outv;
18780 plgvpw(arg1,arg2,arg3,arg4);
18781 _outv = octave_value();
18809 return octave_value_list();
18820 octave_value_list _out;
18821 octave_value_list *_outp=&_out;
18822 octave_value _outv;
18830 _outv = octave_value();
18846 return octave_value_list();
18857 octave_value_list _out;
18858 octave_value_list *_outp=&_out;
18859 octave_value _outv;
18867 _outv = octave_value();
18883 return octave_value_list();
18894 octave_value_list _out;
18895 octave_value_list *_outp=&_out;
18896 octave_value _outv;
18904 _outv = octave_value();
18920 return octave_value_list();
18940 octave_value_list _out;
18941 octave_value_list *_outp=&_out;
18942 octave_value _outv;
18948 if (
_n_dims( args(0) ) > 1 )
18953 temp1 = args(0).matrix_value();
18954 arg2 = &temp1( 0, 0 );
18960 arg3 = static_cast< PLFLT >(val3);
18965 arg4 = static_cast< PLFLT >(val4);
18970 arg5 = static_cast< PLINT >(val5);
18975 arg6 = static_cast< PLINT >(val6);
18976 plhist(arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
18977 _outv = octave_value();
18987 return octave_value_list();
19010 octave_value_list _out;
19011 octave_value_list *_outp=&_out;
19012 octave_value _outv;
19024 arg1 = static_cast< PLFLT >(val1);
19029 arg2 = static_cast< PLFLT >(val2);
19034 arg3 = static_cast< PLFLT >(val3);
19035 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
19036 _outv = octave_value();
19058 return octave_value_list();
19063 octave_value_list _out;
19064 octave_value_list *_outp=&_out;
19065 octave_value _outv;
19071 _outv = octave_value();
19075 return octave_value_list();
19092 octave_value_list _out;
19093 octave_value_list *_outp=&_out;
19094 octave_value _outv;
19103 arg1 = static_cast< PLFLT >(val1);
19108 arg2 = static_cast< PLFLT >(val2);
19113 arg3 = static_cast< PLFLT >(val3);
19118 arg4 = static_cast< PLFLT >(val4);
19119 pljoin(arg1,arg2,arg3,arg4);
19120 _outv = octave_value();
19124 return octave_value_list();
19129 char *arg1 = (
char *) 0 ;
19130 char *arg2 = (
char *) 0 ;
19131 char *arg3 = (
char *) 0 ;
19141 octave_value_list _out;
19142 octave_value_list *_outp=&_out;
19143 octave_value _outv;
19152 arg1 = reinterpret_cast< char * >(buf1);
19157 arg2 = reinterpret_cast< char * >(buf2);
19162 arg3 = reinterpret_cast< char * >(buf3);
19163 pllab((
char const *)arg1,(
char const *)arg2,(
char const *)arg3);
19164 _outv = octave_value();
19174 return octave_value_list();
19198 char **arg20 = (
char **) 0 ;
19209 char **arg31 = (
char **) 0 ;
19254 octave_value_list _out;
19255 octave_value_list *_outp=&_out;
19256 octave_value _outv;
19267 arg3 = static_cast< PLINT >(val3);
19272 arg4 = static_cast< PLINT >(val4);
19277 arg5 = static_cast< PLFLT >(val5);
19282 arg6 = static_cast< PLFLT >(val6);
19287 arg7 = static_cast< PLFLT >(val7);
19292 arg8 = static_cast< PLINT >(val8);
19297 arg9 = static_cast< PLINT >(val9);
19302 arg10 = static_cast< PLINT >(val10);
19307 arg11 = static_cast< PLINT >(val11);
19312 arg12 = static_cast< PLINT >(val12);
19314 if (
_n_dims( args(10) ) > 1 )
19320 temp13 = args(10).matrix_value();
19327 arg15 = static_cast< PLFLT >(val15);
19332 arg16 = static_cast< PLFLT >(val16);
19337 arg17 = static_cast< PLFLT >(val17);
19342 arg18 = static_cast< PLFLT >(val18);
19344 if (
_n_dims( args(15) ) > 1 )
19348 if (
_dim( args(15), 0 ) !=
Alen )
19352 temp19 = args(15).matrix_value();
19357 charMatrix temp_matrix;
19361 size_t max_length = 0, non_blank_length;
19363 if (
_n_dims( args(16) ) > 2 )
19365 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
19367 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19368 if ( !args(16).isempty() )
19370 if ( !args(16).is_empty() )
19373 if (
_dim( args(16), 0 ) !=
Alen )
19375 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
19377 arg20 =
new char*[
Alen];
19378 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19379 ifcell = args(16).iscell();
19381 ifcell = args(16).is_cell();
19385 temp_cell = args(16).cell_value();
19389 temp_matrix = args(16).char_matrix_value();
19391 max_length =
_dim( args(16), 1 ) + 1;
19394 for ( i = 0; i <
Alen; i++ )
19401 if ( temp_cell.elem( i ).is_string() )
19403 str = temp_cell.elem( i ).string_value();
19405 max_length = str.size() + 1;
19406 tmp_cstring = (
char *) str.c_str();
19416 tmp_cstring = (
char *)
"";
19421 str = temp_matrix.row_as_string( i );
19422 tmp_cstring = (
char *) str.c_str();
19424 arg20[i] =
new char[max_length];
19425 strncpy( arg20[i], tmp_cstring, max_length - 1 );
19426 arg20[i][max_length - 1] =
'\0';
19441 non_blank_length = max_length - 2;
19442 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
19444 non_blank_length--;
19446 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
19448 non_blank_length--;
19450 arg20[i][non_blank_length + 1] =
'\0';
19460 if (
_n_dims( args(17) ) > 1 )
19464 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19465 if ( !args(17).isempty() )
19467 if ( !args(17).is_empty() )
19470 if (
_dim( args(17), 0 ) !=
Alen )
19474 temp21 = args(17).matrix_value();
19484 if (
_n_dims( args(18) ) > 1 )
19488 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19489 if ( !args(18).isempty() )
19491 if ( !args(18).is_empty() )
19494 if (
_dim( args(18), 0 ) !=
Alen )
19498 temp22 = args(18).matrix_value();
19508 if (
_n_dims( args(19) ) > 1 )
19512 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19513 if ( !args(19).isempty() )
19515 if ( !args(19).is_empty() )
19518 if (
_dim( args(19), 0 ) !=
Alen )
19522 temp23 = args(19).matrix_value();
19523 arg23 = &temp23( 0, 0 );
19531 if (
_n_dims( args(20) ) > 1 )
19535 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19536 if ( !args(20).isempty() )
19538 if ( !args(20).is_empty() )
19541 if (
_dim( args(20), 0 ) !=
Alen )
19545 temp24 = args(20).matrix_value();
19546 arg24 = &temp24( 0, 0 );
19554 if (
_n_dims( args(21) ) > 1 )
19558 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19559 if ( !args(21).isempty() )
19561 if ( !args(21).is_empty() )
19564 if (
_dim( args(21), 0 ) !=
Alen )
19568 temp25 = args(21).matrix_value();
19578 if (
_n_dims( args(22) ) > 1 )
19582 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19583 if ( !args(22).isempty() )
19585 if ( !args(22).is_empty() )
19588 if (
_dim( args(22), 0 ) !=
Alen )
19592 temp26 = args(22).matrix_value();
19602 if (
_n_dims( args(23) ) > 1 )
19606 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19607 if ( !args(23).isempty() )
19609 if ( !args(23).is_empty() )
19612 if (
_dim( args(23), 0 ) !=
Alen )
19616 temp27 = args(23).matrix_value();
19617 arg27 = &temp27( 0, 0 );
19625 if (
_n_dims( args(24) ) > 1 )
19629 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19630 if ( !args(24).isempty() )
19632 if ( !args(24).is_empty() )
19635 if (
_dim( args(24), 0 ) !=
Alen )
19639 temp28 = args(24).matrix_value();
19649 if (
_n_dims( args(25) ) > 1 )
19653 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19654 if ( !args(25).isempty() )
19656 if ( !args(25).is_empty() )
19659 if (
_dim( args(25), 0 ) !=
Alen )
19663 temp29 = args(25).matrix_value();
19664 arg29 = &temp29( 0, 0 );
19672 if (
_n_dims( args(26) ) > 1 )
19676 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19677 if ( !args(26).isempty() )
19679 if ( !args(26).is_empty() )
19682 if (
_dim( args(26), 0 ) !=
Alen )
19686 temp30 = args(26).matrix_value();
19696 charMatrix temp_matrix;
19700 size_t max_length = 0, non_blank_length;
19702 if (
_n_dims( args(27) ) > 2 )
19704 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
19706 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19707 if ( !args(27).isempty() )
19709 if ( !args(27).is_empty() )
19712 if (
_dim( args(27), 0 ) !=
Alen )
19714 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
19716 arg31 =
new char*[
Alen];
19717 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19718 ifcell = args(27).iscell();
19720 ifcell = args(27).is_cell();
19724 temp_cell = args(27).cell_value();
19728 temp_matrix = args(27).char_matrix_value();
19730 max_length =
_dim( args(27), 1 ) + 1;
19733 for ( i = 0; i <
Alen; i++ )
19740 if ( temp_cell.elem( i ).is_string() )
19742 str = temp_cell.elem( i ).string_value();
19744 max_length = str.size() + 1;
19745 tmp_cstring = (
char *) str.c_str();
19755 tmp_cstring = (
char *)
"";
19760 str = temp_matrix.row_as_string( i );
19761 tmp_cstring = (
char *) str.c_str();
19763 arg31[i] =
new char[max_length];
19764 strncpy( arg31[i], tmp_cstring, max_length - 1 );
19765 arg31[i][max_length - 1] =
'\0';
19780 non_blank_length = max_length - 2;
19781 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
'\0' )
19783 non_blank_length--;
19785 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
' ' )
19787 non_blank_length--;
19789 arg31[i][non_blank_length + 1] =
'\0';
19798 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);
19799 _outv = octave_value();
19821 if ( arg20 != NULL )
19823 for ( i = 0; i <
Alen; i++ )
19831 if ( arg21 != NULL )
19835 if ( arg22 != NULL )
19845 if ( arg25 != NULL )
19849 if ( arg26 != NULL )
19856 if ( arg28 != NULL )
19863 if ( arg30 != NULL )
19868 if ( arg31 != NULL )
19870 for ( i = 0; i <
Alen; i++ )
19887 if ( arg20 != NULL )
19889 for ( i = 0; i <
Alen; i++ )
19897 if ( arg21 != NULL )
19901 if ( arg22 != NULL )
19911 if ( arg25 != NULL )
19915 if ( arg26 != NULL )
19922 if ( arg28 != NULL )
19929 if ( arg30 != NULL )
19934 if ( arg31 != NULL )
19936 for ( i = 0; i <
Alen; i++ )
19943 return octave_value_list();
19957 octave_value_list _out;
19958 octave_value_list *_outp=&_out;
19959 octave_value _outv;
19968 arg1 = static_cast< PLFLT >(val1);
19973 arg2 = static_cast< PLFLT >(val2);
19978 arg3 = static_cast< PLFLT >(val3);
19980 _outv = octave_value();
19984 return octave_value_list();
19994 octave_value_list _out;
19995 octave_value_list *_outp=&_out;
19996 octave_value _outv;
20002 if (
_n_dims( args(0) ) > 1 )
20007 temp1 = args(0).matrix_value();
20008 arg2 = &temp1( 0, 0 );
20011 if (
_n_dims( args(1) ) > 1 )
20019 temp3 = args(1).matrix_value();
20020 arg3 = &temp3( 0, 0 );
20022 plline(arg1,(
double const *)arg2,(
double const *)arg3);
20023 _outv = octave_value();
20039 return octave_value_list();
20051 octave_value_list _out;
20052 octave_value_list *_outp=&_out;
20053 octave_value _outv;
20059 if (
_n_dims( args(0) ) > 1 )
20064 temp1 = args(0).matrix_value();
20065 arg2 = &temp1( 0, 0 );
20068 if (
_n_dims( args(1) ) > 1 )
20076 temp3 = args(1).matrix_value();
20077 arg3 = &temp3( 0, 0 );
20080 if (
_n_dims( args(2) ) > 1 )
20088 temp4 = args(2).matrix_value();
20089 arg4 = &temp4( 0, 0 );
20091 plline3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
20092 _outv = octave_value();
20114 return octave_value_list();
20122 octave_value_list _out;
20123 octave_value_list *_outp=&_out;
20124 octave_value _outv;
20133 arg1 = static_cast< PLINT >(val1);
20135 _outv = octave_value();
20139 return octave_value_list();
20147 octave_value_list _out;
20148 octave_value_list *_outp=&_out;
20149 octave_value _outv;
20156 _outv = octave_value();
20166 return octave_value_list();
20171 char *arg1 = (
char *) 0 ;
20175 char *arg5 = (
char *) 0 ;
20188 octave_value_list _out;
20189 octave_value_list *_outp=&_out;
20190 octave_value _outv;
20199 arg1 = reinterpret_cast< char * >(buf1);
20204 arg2 = static_cast< PLFLT >(val2);
20209 arg3 = static_cast< PLFLT >(val3);
20214 arg4 = static_cast< PLFLT >(val4);
20219 arg5 = reinterpret_cast< char * >(buf5);
20220 plmtex((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
20221 _outv = octave_value();
20229 return octave_value_list();
20234 char *arg1 = (
char *) 0 ;
20238 char *arg5 = (
char *) 0 ;
20251 octave_value_list _out;
20252 octave_value_list *_outp=&_out;
20253 octave_value _outv;
20262 arg1 = reinterpret_cast< char * >(buf1);
20267 arg2 = static_cast< PLFLT >(val2);
20272 arg3 = static_cast< PLFLT >(val3);
20277 arg4 = static_cast< PLFLT >(val4);
20282 arg5 = reinterpret_cast< char * >(buf5);
20283 plmtex3((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
20284 _outv = octave_value();
20292 return octave_value_list();
20297 int *arg1 = (
int *) 0 ;
20298 char **arg2 = (
char **) 0 ;
20306 octave_value_list _out;
20307 octave_value_list *_outp=&_out;
20308 octave_value _outv;
20318 arg1 = reinterpret_cast< int * >(argp1);
20323 arg2 = reinterpret_cast< char ** >(argp2);
20328 arg3 = static_cast< PLINT >(val3);
20334 return octave_value_list();
20344 octave_value_list _out;
20345 octave_value_list *_outp=&_out;
20346 octave_value _outv;
20352 if (
_n_dims( args(0) ) > 1 )
20358 temp1 = args(0).matrix_value();
20362 if (
_n_dims( args(1) ) > 1 )
20370 temp3 = args(1).matrix_value();
20374 plpat(arg1,(
int const *)arg2,(
int const *)arg3);
20375 _outv = octave_value();
20391 return octave_value_list();
20411 octave_value_list _out;
20412 octave_value_list *_outp=&_out;
20413 octave_value _outv;
20422 arg1 = static_cast< PLINT >(val1);
20427 arg2 = static_cast< PLFLT >(val2);
20432 arg3 = static_cast< PLFLT >(val3);
20437 arg4 = static_cast< PLFLT >(val4);
20442 arg5 = static_cast< PLFLT >(val5);
20443 plpath(arg1,arg2,arg3,arg4,arg5);
20444 _outv = octave_value();
20448 return octave_value_list();
20461 octave_value_list _out;
20462 octave_value_list *_outp=&_out;
20463 octave_value _outv;
20469 if (
_n_dims( args(0) ) > 1 )
20474 temp1 = args(0).matrix_value();
20475 arg2 = &temp1( 0, 0 );
20478 if (
_n_dims( args(1) ) > 1 )
20486 temp3 = args(1).matrix_value();
20487 arg3 = &temp3( 0, 0 );
20493 arg4 = static_cast< PLINT >(val4);
20494 plpoin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
20495 _outv = octave_value();
20511 return octave_value_list();
20526 octave_value_list _out;
20527 octave_value_list *_outp=&_out;
20528 octave_value _outv;
20534 if (
_n_dims( args(0) ) > 1 )
20539 temp1 = args(0).matrix_value();
20540 arg2 = &temp1( 0, 0 );
20543 if (
_n_dims( args(1) ) > 1 )
20551 temp3 = args(1).matrix_value();
20552 arg3 = &temp3( 0, 0 );
20555 if (
_n_dims( args(2) ) > 1 )
20563 temp4 = args(2).matrix_value();
20564 arg4 = &temp4( 0, 0 );
20570 arg5 = static_cast< PLINT >(val5);
20571 plpoin3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,arg5);
20572 _outv = octave_value();
20594 return octave_value_list();
20611 octave_value_list _out;
20612 octave_value_list *_outp=&_out;
20613 octave_value _outv;
20619 if (
_n_dims( args(0) ) > 1 )
20624 temp1 = args(0).matrix_value();
20625 arg2 = &temp1( 0, 0 );
20628 if (
_n_dims( args(1) ) > 1 )
20636 temp3 = args(1).matrix_value();
20637 arg3 = &temp3( 0, 0 );
20640 if (
_n_dims( args(2) ) > 1 )
20648 temp4 = args(2).matrix_value();
20649 arg4 = &temp4( 0, 0 );
20652 if (
_n_dims( args(3) ) > 1 )
20658 error(
"argument vector must be same length or one less" );
SWIG_fail;
20660 temp5 = args(3).matrix_value();
20668 arg6 = static_cast< PLBOOL >(val6);
20669 plpoly3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
int const *)arg5,arg6);
20670 _outv = octave_value();
20698 return octave_value_list();
20709 octave_value_list _out;
20710 octave_value_list *_outp=&_out;
20711 octave_value _outv;
20720 arg1 = static_cast< PLINT >(val1);
20725 arg2 = static_cast< PLINT >(val2);
20727 _outv = octave_value();
20731 return octave_value_list();
20739 octave_value_list _out;
20740 octave_value_list *_outp=&_out;
20741 octave_value _outv;
20750 arg1 = static_cast< PLINT >(val1);
20752 _outv = octave_value();
20756 return octave_value_list();
20766 char *arg6 = (
char *) 0 ;
20780 octave_value_list _out;
20781 octave_value_list *_outp=&_out;
20782 octave_value _outv;
20791 arg1 = static_cast< PLFLT >(val1);
20796 arg2 = static_cast< PLFLT >(val2);
20801 arg3 = static_cast< PLFLT >(val3);
20806 arg4 = static_cast< PLFLT >(val4);
20811 arg5 = static_cast< PLFLT >(val5);
20816 arg6 = reinterpret_cast< char * >(buf6);
20817 plptex(arg1,arg2,arg3,arg4,arg5,(
char const *)arg6);
20818 _outv = octave_value();
20824 return octave_value_list();
20839 char *arg11 = (
char *) 0 ;
20863 octave_value_list _out;
20864 octave_value_list *_outp=&_out;
20865 octave_value _outv;
20874 arg1 = static_cast< PLFLT >(val1);
20879 arg2 = static_cast< PLFLT >(val2);
20884 arg3 = static_cast< PLFLT >(val3);
20889 arg4 = static_cast< PLFLT >(val4);
20894 arg5 = static_cast< PLFLT >(val5);
20899 arg6 = static_cast< PLFLT >(val6);
20904 arg7 = static_cast< PLFLT >(val7);
20909 arg8 = static_cast< PLFLT >(val8);
20914 arg9 = static_cast< PLFLT >(val9);
20919 arg10 = static_cast< PLFLT >(val10);
20924 arg11 = reinterpret_cast< char * >(buf11);
20925 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(
char const *)arg11);
20926 _outv = octave_value();
20932 return octave_value_list();
20937 octave_value_list _out;
20938 octave_value_list *_outp=&_out;
20939 octave_value _outv;
20950 return octave_value_list();
20955 octave_value_list _out;
20956 octave_value_list *_outp=&_out;
20957 octave_value _outv;
20963 _outv = octave_value();
20967 return octave_value_list();
20990 octave_value_list _out;
20991 octave_value_list *_outp=&_out;
20992 octave_value _outv;
21004 arg1 = static_cast< PLFLT >(val1);
21009 arg2 = static_cast< PLFLT >(val2);
21014 arg3 = static_cast< PLFLT >(val3);
21015 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
21016 _outv = octave_value();
21038 return octave_value_list();
21049 octave_value_list _out;
21050 octave_value_list *_outp=&_out;
21051 octave_value _outv;
21060 arg1 = static_cast< PLFLT >(val1);
21065 arg2 = static_cast< PLFLT >(val2);
21067 _outv = octave_value();
21071 return octave_value_list();
21083 octave_value_list _out;
21084 octave_value_list *_outp=&_out;
21085 octave_value _outv;
21091 if (
_n_dims( args(0) ) > 1 )
21096 temp1 = args(0).matrix_value();
21101 if (
_n_dims( args(1) ) > 1 )
21109 temp2 = args(1).matrix_value();
21114 if (
_n_dims( args(2) ) > 1 )
21122 temp3 = args(2).matrix_value();
21127 plscmap0((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
21128 _outv = octave_value();
21150 return octave_value_list();
21164 octave_value_list _out;
21165 octave_value_list *_outp=&_out;
21166 octave_value _outv;
21172 if (
_n_dims( args(0) ) > 1 )
21177 temp1 = args(0).matrix_value();
21182 if (
_n_dims( args(1) ) > 1 )
21190 temp2 = args(1).matrix_value();
21195 if (
_n_dims( args(2) ) > 1 )
21203 temp3 = args(2).matrix_value();
21208 if (
_n_dims( args(3) ) > 1 )
21216 temp4 = args(3).matrix_value();
21217 arg4 = &temp4( 0, 0 );
21220 plscmap0a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
21221 _outv = octave_value();
21249 return octave_value_list();
21257 octave_value_list _out;
21258 octave_value_list *_outp=&_out;
21259 octave_value _outv;
21268 arg1 = static_cast< PLINT >(val1);
21270 _outv = octave_value();
21274 return octave_value_list();
21286 octave_value_list _out;
21287 octave_value_list *_outp=&_out;
21288 octave_value _outv;
21294 if (
_n_dims( args(0) ) > 1 )
21299 temp1 = args(0).matrix_value();
21304 if (
_n_dims( args(1) ) > 1 )
21312 temp2 = args(1).matrix_value();
21317 if (
_n_dims( args(2) ) > 1 )
21325 temp3 = args(2).matrix_value();
21330 plscmap1((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
21331 _outv = octave_value();
21353 return octave_value_list();
21367 octave_value_list _out;
21368 octave_value_list *_outp=&_out;
21369 octave_value _outv;
21375 if (
_n_dims( args(0) ) > 1 )
21380 temp1 = args(0).matrix_value();
21385 if (
_n_dims( args(1) ) > 1 )
21393 temp2 = args(1).matrix_value();
21398 if (
_n_dims( args(2) ) > 1 )
21406 temp3 = args(2).matrix_value();
21411 if (
_n_dims( args(3) ) > 1 )
21419 temp4 = args(3).matrix_value();
21420 arg4 = &temp4( 0, 0 );
21423 plscmap1a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
21424 _outv = octave_value();
21452 return octave_value_list();
21471 octave_value_list _out;
21472 octave_value_list *_outp=&_out;
21473 octave_value _outv;
21482 arg1 = static_cast< PLBOOL >(val1);
21484 if (
_n_dims( args(1) ) > 1 )
21489 temp2 = args(1).matrix_value();
21490 arg3 = &temp2( 0, 0 );
21493 if (
_n_dims( args(2) ) > 1 )
21501 temp4 = args(2).matrix_value();
21502 arg4 = &temp4( 0, 0 );
21505 if (
_n_dims( args(3) ) > 1 )
21513 temp5 = args(3).matrix_value();
21514 arg5 = &temp5( 0, 0 );
21517 if (
_n_dims( args(4) ) > 1 )
21525 temp6 = args(4).matrix_value();
21526 arg6 = &temp6( 0, 0 );
21529 if (
_n_dims( args(5) ) > 1 )
21535 error(
"argument vector must be same length or one less" );
SWIG_fail;
21537 temp7 = args(5).matrix_value();
21541 plscmap1l(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
int const *)arg7);
21542 _outv = octave_value();
21576 return octave_value_list();
21597 octave_value_list _out;
21598 octave_value_list *_outp=&_out;
21599 octave_value _outv;
21608 arg1 = static_cast< PLBOOL >(val1);
21610 if (
_n_dims( args(1) ) > 1 )
21615 temp2 = args(1).matrix_value();
21616 arg3 = &temp2( 0, 0 );
21619 if (
_n_dims( args(2) ) > 1 )
21627 temp4 = args(2).matrix_value();
21628 arg4 = &temp4( 0, 0 );
21631 if (
_n_dims( args(3) ) > 1 )
21639 temp5 = args(3).matrix_value();
21640 arg5 = &temp5( 0, 0 );
21643 if (
_n_dims( args(4) ) > 1 )
21651 temp6 = args(4).matrix_value();
21652 arg6 = &temp6( 0, 0 );
21655 if (
_n_dims( args(5) ) > 1 )
21663 temp7 = args(5).matrix_value();
21664 arg7 = &temp7( 0, 0 );
21667 if (
_n_dims( args(6) ) > 1 )
21673 error(
"argument vector must be same length or one less" );
SWIG_fail;
21675 temp8 = args(6).matrix_value();
21679 plscmap1la(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
double const *)arg7,(
int const *)arg8);
21680 _outv = octave_value();
21720 return octave_value_list();
21728 octave_value_list _out;
21729 octave_value_list *_outp=&_out;
21730 octave_value _outv;
21739 arg1 = static_cast< PLINT >(val1);
21741 _outv = octave_value();
21745 return octave_value_list();
21756 octave_value_list _out;
21757 octave_value_list *_outp=&_out;
21758 octave_value _outv;
21767 arg1 = static_cast< PLFLT >(val1);
21772 arg2 = static_cast< PLFLT >(val2);
21774 _outv = octave_value();
21778 return octave_value_list();
21789 octave_value_list _out;
21790 octave_value_list *_outp=&_out;
21791 octave_value _outv;
21799 _outv = octave_value();
21815 return octave_value_list();
21832 octave_value_list _out;
21833 octave_value_list *_outp=&_out;
21834 octave_value _outv;
21843 arg1 = static_cast< PLINT >(val1);
21848 arg2 = static_cast< PLINT >(val2);
21853 arg3 = static_cast< PLINT >(val3);
21858 arg4 = static_cast< PLINT >(val4);
21859 plscol0(arg1,arg2,arg3,arg4);
21860 _outv = octave_value();
21864 return octave_value_list();
21884 octave_value_list _out;
21885 octave_value_list *_outp=&_out;
21886 octave_value _outv;
21895 arg1 = static_cast< PLINT >(val1);
21900 arg2 = static_cast< PLINT >(val2);
21905 arg3 = static_cast< PLINT >(val3);
21910 arg4 = static_cast< PLINT >(val4);
21915 arg5 = static_cast< PLFLT >(val5);
21916 plscol0a(arg1,arg2,arg3,arg4,arg5);
21917 _outv = octave_value();
21921 return octave_value_list();
21935 octave_value_list _out;
21936 octave_value_list *_outp=&_out;
21937 octave_value _outv;
21946 arg1 = static_cast< PLINT >(val1);
21951 arg2 = static_cast< PLINT >(val2);
21956 arg3 = static_cast< PLINT >(val3);
21958 _outv = octave_value();
21962 return octave_value_list();
21979 octave_value_list _out;
21980 octave_value_list *_outp=&_out;
21981 octave_value _outv;
21990 arg1 = static_cast< PLINT >(val1);
21995 arg2 = static_cast< PLINT >(val2);
22000 arg3 = static_cast< PLINT >(val3);
22005 arg4 = static_cast< PLFLT >(val4);
22007 _outv = octave_value();
22011 return octave_value_list();
22019 octave_value_list _out;
22020 octave_value_list *_outp=&_out;
22021 octave_value _outv;
22030 arg1 = static_cast< PLINT >(val1);
22032 _outv = octave_value();
22036 return octave_value_list();
22044 octave_value_list _out;
22045 octave_value_list *_outp=&_out;
22046 octave_value _outv;
22055 arg1 = static_cast< PLINT >(val1);
22057 _outv = octave_value();
22061 return octave_value_list();
22066 char *arg1 = (
char *) 0 ;
22070 octave_value_list _out;
22071 octave_value_list *_outp=&_out;
22072 octave_value _outv;
22081 arg1 = reinterpret_cast< char * >(buf1);
22082 plsdev((
char const *)arg1);
22083 _outv = octave_value();
22089 return octave_value_list();
22106 octave_value_list _out;
22107 octave_value_list *_outp=&_out;
22108 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);
22134 _outv = octave_value();
22138 return octave_value_list();
22161 octave_value_list _out;
22162 octave_value_list *_outp=&_out;
22163 octave_value _outv;
22172 arg1 = static_cast< PLINT >(val1);
22177 arg2 = static_cast< PLINT >(val2);
22182 arg3 = static_cast< PLINT >(val3);
22187 arg4 = static_cast< PLINT >(val4);
22192 arg5 = static_cast< PLFLT >(val5);
22197 arg6 = static_cast< PLFLT >(val6);
22198 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
22199 _outv = octave_value();
22203 return octave_value_list();
22211 octave_value_list _out;
22212 octave_value_list *_outp=&_out;
22213 octave_value _outv;
22222 arg1 = static_cast< PLFLT >(val1);
22224 _outv = octave_value();
22228 return octave_value_list();
22245 octave_value_list _out;
22246 octave_value_list *_outp=&_out;
22247 octave_value _outv;
22256 arg1 = static_cast< PLFLT >(val1);
22261 arg2 = static_cast< PLFLT >(val2);
22266 arg3 = static_cast< PLFLT >(val3);
22271 arg4 = static_cast< PLFLT >(val4);
22273 _outv = octave_value();
22277 return octave_value_list();
22294 octave_value_list _out;
22295 octave_value_list *_outp=&_out;
22296 octave_value _outv;
22305 arg1 = static_cast< PLFLT >(val1);
22310 arg2 = static_cast< PLFLT >(val2);
22315 arg3 = static_cast< PLFLT >(val3);
22320 arg4 = static_cast< PLFLT >(val4);
22322 _outv = octave_value();
22326 return octave_value_list();
22331 unsigned int arg1 ;
22332 unsigned int val1 ;
22334 octave_value_list _out;
22335 octave_value_list *_outp=&_out;
22336 octave_value _outv;
22345 arg1 = static_cast< unsigned int >(val1);
22347 _outv = octave_value();
22351 return octave_value_list();
22359 octave_value_list _out;
22360 octave_value_list *_outp=&_out;
22361 octave_value _outv;
22370 arg1 = static_cast< char >(val1);
22372 _outv = octave_value();
22376 return octave_value_list();
22381 char *arg1 = (
char *) 0 ;
22382 char *arg2 = (
char *) 0 ;
22389 octave_value_list _out;
22390 octave_value_list *_outp=&_out;
22391 octave_value _outv;
22401 arg1 = reinterpret_cast< char * >(buf1);
22406 arg2 = reinterpret_cast< char * >(buf2);
22407 result = (
PLINT)
plsetopt((
char const *)arg1,(
char const *)arg2);
22416 return octave_value_list();
22430 octave_value_list _out;
22431 octave_value_list *_outp=&_out;
22432 octave_value _outv;
22441 arg1 = static_cast< PLINT >(val1);
22446 arg2 = static_cast< PLINT >(val2);
22451 arg3 = static_cast< PLINT >(val3);
22453 _outv = octave_value();
22457 return octave_value_list();
22463 unsigned int val1 ;
22465 octave_value_list _out;
22466 octave_value_list *_outp=&_out;
22467 octave_value _outv;
22476 arg1 = static_cast< PLUNICODE >(val1);
22478 _outv = octave_value();
22482 return octave_value_list();
22487 char *arg1 = (
char *) 0 ;
22491 octave_value_list _out;
22492 octave_value_list *_outp=&_out;
22493 octave_value _outv;
22502 arg1 = reinterpret_cast< char * >(buf1);
22504 _outv = octave_value();
22510 return octave_value_list();
22524 octave_value_list _out;
22525 octave_value_list *_outp=&_out;
22526 octave_value _outv;
22535 arg1 = static_cast< PLINT >(val1);
22540 arg2 = static_cast< PLINT >(val2);
22545 arg3 = static_cast< PLINT >(val3);
22547 _outv = octave_value();
22551 return octave_value_list();
22559 octave_value_list _out;
22560 octave_value_list *_outp=&_out;
22561 octave_value _outv;
22567 octave_value obj = args(0);
22568 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
22569 if ( !obj.isempty() )
22571 if ( !obj.is_empty() )
22574 if ( obj.is_function_handle() || obj.is_inline_function() )
22578 else if ( obj.is_string() )
22595 _outv = octave_value();
22599 return octave_value_list();
22610 octave_value_list _out;
22611 octave_value_list *_outp=&_out;
22612 octave_value _outv;
22621 arg1 = static_cast< PLFLT >(val1);
22626 arg2 = static_cast< PLFLT >(val2);
22628 _outv = octave_value();
22632 return octave_value_list();
22643 octave_value_list _out;
22644 octave_value_list *_outp=&_out;
22645 octave_value _outv;
22654 arg1 = static_cast< PLFLT >(val1);
22659 arg2 = static_cast< PLFLT >(val2);
22661 _outv = octave_value();
22665 return octave_value_list();
22673 octave_value_list _out;
22674 octave_value_list *_outp=&_out;
22675 octave_value _outv;
22684 arg1 = static_cast< PLINT >(val1);
22686 _outv = octave_value();
22690 return octave_value_list();
22713 octave_value_list _out;
22714 octave_value_list *_outp=&_out;
22715 octave_value _outv;
22724 arg1 = static_cast< PLFLT >(val1);
22729 arg2 = static_cast< PLFLT >(val2);
22734 arg3 = static_cast< PLINT >(val3);
22739 arg4 = static_cast< PLINT >(val4);
22744 arg5 = static_cast< PLINT >(val5);
22749 arg6 = static_cast< PLINT >(val6);
22750 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
22751 _outv = octave_value();
22755 return octave_value_list();
22760 char *arg1 = (
char *) 0 ;
22764 octave_value_list _out;
22765 octave_value_list *_outp=&_out;
22766 octave_value _outv;
22775 arg1 = reinterpret_cast< char * >(buf1);
22777 _outv = octave_value();
22783 return octave_value_list();
22788 char *arg1 = (
char *) 0 ;
22795 octave_value_list _out;
22796 octave_value_list *_outp=&_out;
22797 octave_value _outv;
22806 arg1 = reinterpret_cast< char * >(buf1);
22811 arg2 = static_cast< PLBOOL >(val2);
22812 plspal1((
char const *)arg1,arg2);
22813 _outv = octave_value();
22819 return octave_value_list();
22827 octave_value_list _out;
22828 octave_value_list *_outp=&_out;
22829 octave_value _outv;
22838 arg1 = static_cast< PLBOOL >(val1);
22840 _outv = octave_value();
22844 return octave_value_list();
22852 octave_value_list _out;
22853 octave_value_list *_outp=&_out;
22854 octave_value _outv;
22863 arg1 = static_cast< PLINT >(val1);
22865 _outv = octave_value();
22869 return octave_value_list();
22880 octave_value_list _out;
22881 octave_value_list *_outp=&_out;
22882 octave_value _outv;
22891 arg1 = static_cast< PLINT >(val1);
22896 arg2 = static_cast< PLINT >(val2);
22898 _outv = octave_value();
22902 return octave_value_list();
22913 octave_value_list _out;
22914 octave_value_list *_outp=&_out;
22915 octave_value _outv;
22924 arg1 = static_cast< PLFLT >(val1);
22929 arg2 = static_cast< PLFLT >(val2);
22931 _outv = octave_value();
22935 return octave_value_list();
22946 octave_value_list _out;
22947 octave_value_list *_outp=&_out;
22948 octave_value _outv;
22957 arg1 = static_cast< PLINT >(val1);
22962 arg2 = static_cast< PLINT >(val2);
22964 _outv = octave_value();
22968 return octave_value_list();
22973 char *arg1 = (
char *) 0 ;
22983 octave_value_list _out;
22984 octave_value_list *_outp=&_out;
22985 octave_value _outv;
22994 arg1 = reinterpret_cast< char * >(buf1);
22999 arg2 = static_cast< PLINT >(val2);
23004 arg3 = static_cast< PLINT >(val3);
23005 plstart((
char const *)arg1,arg2,arg3);
23006 _outv = octave_value();
23012 return octave_value_list();
23020 octave_value_list _out;
23021 octave_value_list *_outp=&_out;
23022 octave_value _outv;
23028 octave_value obj = args(0);
23029 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
23030 if ( !obj.isempty() )
23032 if ( !obj.is_empty() )
23035 if ( obj.is_function_handle() || obj.is_inline_function() )
23039 else if ( obj.is_string() )
23056 _outv = octave_value();
23060 return octave_value_list();
23068 char *arg4 = (
char *) 0 ;
23074 octave_value_list _out;
23075 octave_value_list *_outp=&_out;
23076 octave_value _outv;
23082 if (
_n_dims( args(0) ) > 1 )
23087 temp1 = args(0).matrix_value();
23088 arg2 = &temp1( 0, 0 );
23091 if (
_n_dims( args(1) ) > 1 )
23099 temp3 = args(1).matrix_value();
23100 arg3 = &temp3( 0, 0 );
23106 arg4 = reinterpret_cast< char * >(buf4);
23107 plstring(arg1,(
double const *)arg2,(
double const *)arg3,(
char const *)arg4);
23108 _outv = octave_value();
23126 return octave_value_list();
23135 char *arg5 = (
char *) 0 ;
23142 octave_value_list _out;
23143 octave_value_list *_outp=&_out;
23144 octave_value _outv;
23150 if (
_n_dims( args(0) ) > 1 )
23155 temp1 = args(0).matrix_value();
23156 arg2 = &temp1( 0, 0 );
23159 if (
_n_dims( args(1) ) > 1 )
23167 temp3 = args(1).matrix_value();
23168 arg3 = &temp3( 0, 0 );
23171 if (
_n_dims( args(2) ) > 1 )
23179 temp4 = args(2).matrix_value();
23180 arg4 = &temp4( 0, 0 );
23186 arg5 = reinterpret_cast< char * >(buf5);
23187 plstring3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
char const *)arg5);
23188 _outv = octave_value();
23212 return octave_value_list();
23229 octave_value_list _out;
23230 octave_value_list *_outp=&_out;
23231 octave_value _outv;
23240 arg1 = static_cast< PLINT >(val1);
23245 arg2 = static_cast< PLINT >(val2);
23250 arg3 = static_cast< PLFLT >(val3);
23255 arg4 = static_cast< PLFLT >(val4);
23257 _outv = octave_value();
23261 return octave_value_list();
23269 octave_value_list _out;
23270 octave_value_list *_outp=&_out;
23271 octave_value _outv;
23280 arg1 = static_cast< PLINT >(val1);
23282 _outv = octave_value();
23286 return octave_value_list();
23296 octave_value_list _out;
23297 octave_value_list *_outp=&_out;
23298 octave_value _outv;
23304 if (
_n_dims( args(0) ) > 1 )
23310 temp1 = args(0).matrix_value();
23314 if (
_n_dims( args(1) ) > 1 )
23322 temp3 = args(1).matrix_value();
23326 plstyl(arg1,(
int const *)arg2,(
int const *)arg3);
23327 _outv = octave_value();
23343 return octave_value_list();
23356 octave_value_list _out;
23357 octave_value_list *_outp=&_out;
23358 octave_value _outv;
23364 if (
_n_dims( args(0) ) > 1 )
23368 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
23369 if ( !args(0).isempty() )
23371 if ( !args(0).is_empty() )
23375 temp1 = args(0).matrix_value();
23376 arg1 = &temp1( 0, 0 );
23385 if (
_n_dims( args(1) ) > 1 )
23389 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
23390 if ( !args(1).isempty() )
23392 if ( !args(1).is_empty() )
23399 temp2 = args(1).matrix_value();
23400 arg2 = &temp2( 0, 0 );
23413 arg4 = static_cast< PLBOOL >(val4);
23414 plsvect((
double const *)arg1,(
double const *)arg2,arg3,arg4);
23415 _outv = octave_value();
23431 return octave_value_list();
23448 octave_value_list _out;
23449 octave_value_list *_outp=&_out;
23450 octave_value _outv;
23459 arg1 = static_cast< PLFLT >(val1);
23464 arg2 = static_cast< PLFLT >(val2);
23469 arg3 = static_cast< PLFLT >(val3);
23474 arg4 = static_cast< PLFLT >(val4);
23475 plsvpa(arg1,arg2,arg3,arg4);
23476 _outv = octave_value();
23480 return octave_value_list();
23491 octave_value_list _out;
23492 octave_value_list *_outp=&_out;
23493 octave_value _outv;
23502 arg1 = static_cast< PLINT >(val1);
23507 arg2 = static_cast< PLINT >(val2);
23509 _outv = octave_value();
23513 return octave_value_list();
23524 octave_value_list _out;
23525 octave_value_list *_outp=&_out;
23526 octave_value _outv;
23535 arg1 = static_cast< PLINT >(val1);
23540 arg2 = static_cast< PLINT >(val2);
23542 _outv = octave_value();
23546 return octave_value_list();
23559 octave_value_list _out;
23560 octave_value_list *_outp=&_out;
23561 octave_value _outv;
23567 if (
_n_dims( args(0) ) > 1 )
23572 temp1 = args(0).matrix_value();
23573 arg2 = &temp1( 0, 0 );
23576 if (
_n_dims( args(1) ) > 1 )
23584 temp3 = args(1).matrix_value();
23585 arg3 = &temp3( 0, 0 );
23591 arg4 = static_cast< PLINT >(val4);
23592 plsym(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
23593 _outv = octave_value();
23609 return octave_value_list();
23620 octave_value_list _out;
23621 octave_value_list *_outp=&_out;
23622 octave_value _outv;
23631 arg1 = static_cast< PLINT >(val1);
23636 arg2 = static_cast< PLINT >(val2);
23638 _outv = octave_value();
23642 return octave_value_list();
23647 octave_value_list _out;
23648 octave_value_list *_outp=&_out;
23649 octave_value _outv;
23655 _outv = octave_value();
23659 return octave_value_list();
23664 char *arg1 = (
char *) 0 ;
23668 octave_value_list _out;
23669 octave_value_list *_outp=&_out;
23670 octave_value _outv;
23679 arg1 = reinterpret_cast< char * >(buf1);
23681 _outv = octave_value();
23687 return octave_value_list();
23695 octave_value_list _out;
23696 octave_value_list *_outp=&_out;
23697 octave_value _outv;
23706 arg1 = static_cast< PLFLT >(val1);
23708 _outv = octave_value();
23712 return octave_value_list();
23732 octave_value_list _out;
23733 octave_value_list *_outp=&_out;
23734 octave_value _outv;
23743 arg1 = static_cast< PLFLT >(val1);
23748 arg2 = static_cast< PLFLT >(val2);
23753 arg3 = static_cast< PLFLT >(val3);
23758 arg4 = static_cast< PLFLT >(val4);
23763 arg5 = static_cast< PLFLT >(val5);
23764 plvpas(arg1,arg2,arg3,arg4,arg5);
23765 _outv = octave_value();
23769 return octave_value_list();
23786 octave_value_list _out;
23787 octave_value_list *_outp=&_out;
23788 octave_value _outv;
23797 arg1 = static_cast< PLFLT >(val1);
23802 arg2 = static_cast< PLFLT >(val2);
23807 arg3 = static_cast< PLFLT >(val3);
23812 arg4 = static_cast< PLFLT >(val4);
23813 plvpor(arg1,arg2,arg3,arg4);
23814 _outv = octave_value();
23818 return octave_value_list();
23823 octave_value_list _out;
23824 octave_value_list *_outp=&_out;
23825 octave_value _outv;
23831 _outv = octave_value();
23835 return octave_value_list();
23873 octave_value_list _out;
23874 octave_value_list *_outp=&_out;
23875 octave_value _outv;
23884 arg1 = static_cast< PLFLT >(val1);
23889 arg2 = static_cast< PLFLT >(val2);
23894 arg3 = static_cast< PLFLT >(val3);
23899 arg4 = static_cast< PLFLT >(val4);
23904 arg5 = static_cast< PLFLT >(val5);
23909 arg6 = static_cast< PLFLT >(val6);
23914 arg7 = static_cast< PLFLT >(val7);
23919 arg8 = static_cast< PLFLT >(val8);
23924 arg9 = static_cast< PLFLT >(val9);
23929 arg10 = static_cast< PLFLT >(val10);
23934 arg11 = static_cast< PLFLT >(val11);
23935 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
23936 _outv = octave_value();
23940 return octave_value_list();
23948 octave_value_list _out;
23949 octave_value_list *_outp=&_out;
23950 octave_value _outv;
23959 arg1 = static_cast< PLFLT >(val1);
23961 _outv = octave_value();
23965 return octave_value_list();
23982 octave_value_list _out;
23983 octave_value_list *_outp=&_out;
23984 octave_value _outv;
23993 arg1 = static_cast< PLFLT >(val1);
23998 arg2 = static_cast< PLFLT >(val2);
24003 arg3 = static_cast< PLFLT >(val3);
24008 arg4 = static_cast< PLFLT >(val4);
24009 plwind(arg1,arg2,arg3,arg4);
24010 _outv = octave_value();
24014 return octave_value_list();
24025 octave_value_list _out;
24026 octave_value_list *_outp=&_out;
24027 octave_value _outv;
24037 arg1 = static_cast< PLBOOL >(val1);
24039 _outv = octave_value();
24049 return octave_value_list();
24055 char *arg2 = (
char *) 0 ;
24071 octave_value_list _out;
24072 octave_value_list *_outp=&_out;
24073 octave_value _outv;
24079 octave_value obj = args(0);
24080 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24081 if ( !obj.isempty() )
24083 if ( !obj.is_empty() )
24086 if ( obj.is_function_handle() || obj.is_inline_function() )
24090 else if ( obj.is_string() )
24106 arg2 = reinterpret_cast< char * >(buf2);
24111 arg3 = static_cast< PLFLT >(val3);
24116 arg4 = static_cast< PLFLT >(val4);
24121 arg5 = static_cast< PLFLT >(val5);
24126 arg6 = static_cast< PLFLT >(val6);
24127 plmap(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6);
24128 _outv = octave_value();
24134 return octave_value_list();
24140 char *arg2 = (
char *) 0 ;
24159 octave_value_list _out;
24160 octave_value_list *_outp=&_out;
24161 octave_value _outv;
24167 octave_value obj = args(0);
24168 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24169 if ( !obj.isempty() )
24171 if ( !obj.is_empty() )
24174 if ( obj.is_function_handle() || obj.is_inline_function() )
24178 else if ( obj.is_string() )
24194 arg2 = reinterpret_cast< char * >(buf2);
24199 arg3 = static_cast< PLFLT >(val3);
24204 arg4 = static_cast< PLFLT >(val4);
24209 arg5 = static_cast< PLFLT >(val5);
24214 arg6 = static_cast< PLFLT >(val6);
24216 if (
_n_dims( args(6) ) > 1 )
24220 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24221 if ( !args(6).isempty() )
24223 if ( !args(6).is_empty() )
24227 temp7 = args(6).matrix_value();
24228 arg7 =
new PLINT[arg8];
24237 plmapline(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
24238 _outv = octave_value();
24250 return octave_value_list();
24256 char *arg2 = (
char *) 0 ;
24257 char *arg3 = (
char *) 0 ;
24279 octave_value_list _out;
24280 octave_value_list *_outp=&_out;
24281 octave_value _outv;
24287 octave_value obj = args(0);
24288 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24289 if ( !obj.isempty() )
24291 if ( !obj.is_empty() )
24294 if ( obj.is_function_handle() || obj.is_inline_function() )
24298 else if ( obj.is_string() )
24314 arg2 = reinterpret_cast< char * >(buf2);
24319 arg3 = reinterpret_cast< char * >(buf3);
24324 arg4 = static_cast< PLFLT >(val4);
24329 arg5 = static_cast< PLFLT >(val5);
24334 arg6 = static_cast< PLFLT >(val6);
24339 arg7 = static_cast< PLFLT >(val7);
24341 if (
_n_dims( args(7) ) > 1 )
24345 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24346 if ( !args(7).isempty() )
24348 if ( !args(7).is_empty() )
24352 temp8 = args(7).matrix_value();
24353 arg8 =
new PLINT[arg9];
24362 plmapstring(arg1,(
char const *)arg2,(
char const *)arg3,arg4,arg5,arg6,arg7,(
int const *)arg8,arg9);
24363 _outv = octave_value();
24377 return octave_value_list();
24383 char *arg2 = (
char *) 0 ;
24387 char *arg6 = (
char *) 0 ;
24415 octave_value_list _out;
24416 octave_value_list *_outp=&_out;
24417 octave_value _outv;
24423 octave_value obj = args(0);
24424 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24425 if ( !obj.isempty() )
24427 if ( !obj.is_empty() )
24430 if ( obj.is_function_handle() || obj.is_inline_function() )
24434 else if ( obj.is_string() )
24450 arg2 = reinterpret_cast< char * >(buf2);
24455 arg3 = static_cast< PLFLT >(val3);
24460 arg4 = static_cast< PLFLT >(val4);
24465 arg5 = static_cast< PLFLT >(val5);
24470 arg6 = reinterpret_cast< char * >(buf6);
24475 arg7 = static_cast< PLFLT >(val7);
24480 arg8 = static_cast< PLFLT >(val8);
24485 arg9 = static_cast< PLFLT >(val9);
24490 arg10 = static_cast< PLFLT >(val10);
24495 arg11 = static_cast< PLINT >(val11);
24496 plmaptex(arg1,(
char const *)arg2,arg3,arg4,arg5,(
char const *)arg6,arg7,arg8,arg9,arg10,arg11);
24497 _outv = octave_value();
24505 return octave_value_list();
24511 char *arg2 = (
char *) 0 ;
24530 octave_value_list _out;
24531 octave_value_list *_outp=&_out;
24532 octave_value _outv;
24538 octave_value obj = args(0);
24539 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24540 if ( !obj.isempty() )
24542 if ( !obj.is_empty() )
24545 if ( obj.is_function_handle() || obj.is_inline_function() )
24549 else if ( obj.is_string() )
24565 arg2 = reinterpret_cast< char * >(buf2);
24570 arg3 = static_cast< PLFLT >(val3);
24575 arg4 = static_cast< PLFLT >(val4);
24580 arg5 = static_cast< PLFLT >(val5);
24585 arg6 = static_cast< PLFLT >(val6);
24587 if (
_n_dims( args(6) ) > 1 )
24591 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24592 if ( !args(6).isempty() )
24594 if ( !args(6).is_empty() )
24598 temp7 = args(6).matrix_value();
24599 arg7 =
new PLINT[arg8];
24608 plmapfill(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
24609 _outv = octave_value();
24621 return octave_value_list();
24645 octave_value_list _out;
24646 octave_value_list *_outp=&_out;
24647 octave_value _outv;
24653 octave_value obj = args(0);
24654 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24655 if ( !obj.isempty() )
24657 if ( !obj.is_empty() )
24660 if ( obj.is_function_handle() || obj.is_inline_function() )
24664 else if ( obj.is_string() )
24680 arg2 = static_cast< PLFLT >(val2);
24685 arg3 = static_cast< PLFLT >(val3);
24690 arg4 = static_cast< PLFLT >(val4);
24695 arg5 = static_cast< PLFLT >(val5);
24700 arg6 = static_cast< PLFLT >(val6);
24705 arg7 = static_cast< PLFLT >(val7);
24707 _outv = octave_value();
24711 return octave_value_list();
24716 octave_value_list _out;
24717 octave_value_list *_outp=&_out;
24718 octave_value _outv;
24724 _outv = octave_value();
24728 return octave_value_list();
24733 octave_value_list _out;
24734 octave_value_list *_outp=&_out;
24735 octave_value _outv;
24741 _outv = octave_value();
24745 return octave_value_list();
24750 char *arg1 = (
char *) 0 ;
24751 char *arg2 = (
char *) 0 ;
24758 octave_value_list _out;
24759 octave_value_list *_outp=&_out;
24760 octave_value _outv;
24769 arg1 = reinterpret_cast< char * >(buf1);
24774 arg2 = reinterpret_cast< char * >(buf2);
24775 plSetUsage((
char const *)arg1,(
char const *)arg2);
24776 _outv = octave_value();
24784 return octave_value_list();
24789 octave_value_list _out;
24790 octave_value_list *_outp=&_out;
24791 octave_value _outv;
24797 _outv = octave_value();
24801 return octave_value_list();
24807 {
"testppchar",_wrap_testppchar,0,0,2,0},
24809 {
"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
24812 {
"plcont0",_wrap_plcont0,0,0,2,0},
24813 {
"plcont1",_wrap_plcont1,0,0,2,0},
24814 {
"plcont2",_wrap_plcont2,0,0,2,0},
24815 {
"plcont2p",_wrap_plcont2p,0,0,2,0},
24825 {
"plshade1",_wrap_plshade1,0,0,2,0},
24826 {
"plshade2",_wrap_plshade2,0,0,2,0},
24828 {
"plshadesx",_wrap_plshadesx,0,0,2,0},
24829 {
"plshades1",_wrap_plshades1,0,0,2,0},
24830 {
"plshades2",_wrap_plshades2,0,0,2,0},
24832 {
"plvect1",_wrap_plvect1,0,0,2,0},
24833 {
"plvect2",_wrap_plvect2,0,0,2,0},
24834 {
"pplimage",_wrap_pplimage,0,0,2,0},
24836 {
"plimagefrx",_wrap_plimagefrx,0,0,2,0},
24837 {
"plimagefr1",_wrap_plimagefr1,0,0,2,0},
24838 {
"plimagefr2",_wrap_plimagefr2,0,0,2,0},
25124 #define SWIGRUNTIME_DEBUG
25147 if (!module_head) {
25160 }
while (iter!= module_head);
25171 if (init == 0)
return;
25174 #ifdef SWIGRUNTIME_DEBUG
25175 printf(
"SWIG_InitializeModule: size %lu\n", (
unsigned long)
swig_module.
size);
25182 #ifdef SWIGRUNTIME_DEBUG
25192 #ifdef SWIGRUNTIME_DEBUG
25193 printf(
"SWIG_InitializeModule: found type %s\n", type->
name);
25197 #ifdef SWIGRUNTIME_DEBUG
25198 printf(
"SWIG_InitializeModule: found and overwrite type %s \n", type->
name);
25207 while (
cast->type) {
25211 #ifdef SWIGRUNTIME_DEBUG
25212 printf(
"SWIG_InitializeModule: look cast %s\n",
cast->type->name);
25216 #ifdef SWIGRUNTIME_DEBUG
25217 if (ret) printf(
"SWIG_InitializeModule: found cast %s\n", ret->
name);
25222 #ifdef SWIGRUNTIME_DEBUG
25223 printf(
"SWIG_InitializeModule: skip old type %s\n", ret->
name);
25230 #ifdef SWIGRUNTIME_DEBUG
25231 if (ocast) printf(
"SWIG_InitializeModule: skip old cast %s\n", ret->
name);
25233 if (!ocast) ret = 0;
25238 #ifdef SWIGRUNTIME_DEBUG
25239 printf(
"SWIG_InitializeModule: adding cast %s\n",
cast->type->name);
25254 #ifdef SWIGRUNTIME_DEBUG
25255 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
25260 while (
cast->type) {
25261 printf(
"SWIG_InitializeModule: cast type %s\n",
cast->type->name);
25265 printf(
"---- Total casts: %d\n",j);
25267 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
25280 static int init_run = 0;
25282 if (init_run)
return;
25293 equiv = equiv->
next;
25313 #if SWIG_OCTAVE_PREREQ(4,2,0)
25314 octave::unwind_protect frame;
25315 frame.protect_var(discard_error_messages); discard_error_messages =
true;
25316 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
25317 #elif SWIG_OCTAVE_PREREQ(3,3,50)
25318 unwind_protect frame;
25319 frame.protect_var(error_state); error_state = 0;
25320 frame.protect_var(warning_state); warning_state = 0;
25321 frame.protect_var(discard_error_messages); discard_error_messages =
true;
25322 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
25324 unwind_protect::begin_frame(
"SWIG_Octave_LoadModule");
25325 unwind_protect_int(error_state); error_state = 0;
25326 unwind_protect_int(warning_state); warning_state = 0;
25327 unwind_protect_bool(discard_error_messages); discard_error_messages =
true;
25328 unwind_protect_bool(discard_warning_messages); discard_warning_messages =
true;
25330 #if SWIG_OCTAVE_PREREQ(4,2,0)
25332 #if SWIG_OCTAVE_PREREQ(4,4,0)
25333 octave::feval(
name, octave_value_list(), 0);
25335 feval(
name, octave_value_list(), 0);
25338 }
catch (octave::execution_exception&) { }
25340 feval(
name, octave_value_list(), 0);
25341 retn = (error_state == 0);
25343 #if !SWIG_OCTAVE_PREREQ(3,3,50)
25344 unwind_protect::run_frame(
"SWIG_Octave_LoadModule");
25356 #if SWIG_OCTAVE_PREREQ(4,2,0)
25357 octave::unwind_protect frame;
25358 frame.protect_var(discard_error_messages); discard_error_messages =
true;
25359 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
25360 #elif SWIG_OCTAVE_PREREQ(3,3,50)
25361 unwind_protect frame;
25362 frame.protect_var(error_state); error_state = 0;
25363 frame.protect_var(warning_state); warning_state = 0;
25364 frame.protect_var(discard_error_messages); discard_error_messages =
true;
25365 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
25367 unwind_protect::begin_frame(
"SWIG_Octave_InstallFunction");
25368 unwind_protect_int(error_state); error_state = 0;
25369 unwind_protect_int(warning_state); warning_state = 0;
25370 unwind_protect_bool(discard_error_messages); discard_error_messages =
true;
25371 unwind_protect_bool(discard_warning_messages); discard_warning_messages =
true;
25373 octave_value_list args;
25375 args.append(octloadfcn->fcn_file_name());
25376 #if SWIG_OCTAVE_PREREQ(4,2,0)
25378 #if SWIG_OCTAVE_PREREQ(4,4,0)
25379 octave::feval(
"autoload", args, 0);
25381 feval(
"autoload", args, 0);
25384 }
catch (octave::execution_exception&) { }
25386 feval(
"autoload", args, 0);
25387 retn = (error_state == 0);
25389 #if !SWIG_OCTAVE_PREREQ(3,3,50)
25390 unwind_protect::run_frame(
"SWIG_Octave_InstallFunction");
25400 @deftypefn {Loadable Function} {} subclass()\n\
25401 @deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
25402 Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
25404 See the SWIG manual for usage examples.\n\
25409 for (
int j = 0; j < args.length(); ++j) {
25410 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
25411 octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
25414 error(
"subclass: cannot subclass object not constructed on octave side");
25415 return octave_value_list();
25418 }
else if (args(j).is_function_handle()) {
25419 top->
assign(args(j).fcn_handle_value()->fcn_name(), args(j));
25421 if (j + 1 >= args.length()) {
25422 error(
"subclass: member assignments must be of string,value form");
25423 return octave_value_list();
25428 error(
"subclass: invalid arguments to subclass()");
25429 return octave_value_list();
25436 @deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
25437 Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
25441 if (args.length() != 1) {
25442 error(
"swig_type: must be called with only a single object");
25443 return octave_value_list();
25447 error(
"swig_type: object is not a swig_ref");
25448 return octave_value_list();
25454 @deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
25455 Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
25456 otherwise return `<unknown>'.\n\
25460 if (args.length() != 1 || !args(0).is_string()) {
25461 error(
"swig_typequery: must be called with single string argument");
25462 return octave_value_list();
25467 return octave_value(
"<unknown>");
25468 return octave_value(type->
name);
25472 @deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
25473 Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
25477 if (args.length() != 1) {
25478 error(
"swig_this: must be called with only a single object");
25479 return octave_value_list();
25481 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
25482 return octave_value(octave_uint64(0));
25485 error(
"swig_this: object is not a swig_ref");
25486 return octave_value_list();
25488 return octave_value(octave_uint64((
unsigned long long) ost->
swig_this()));
25492 @deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
25493 Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
25497 if (args.length() != 3) {
25498 error(
"swig_octave_prereq: must be called with 3 arguments");
25499 return octave_value_list();
25501 const int major = args(0).int_value();
25502 const int minor = args(1).int_value();
25503 const int patch = args(2).int_value();
25505 return octave_value(prereq);
25509 @deftypefn {Loadable Module} {} " SWIG_name_d "\n\
25510 Loads the SWIG-generated module `" SWIG_name_d "'.\n\
25524 #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
25525 #if SWIG_OCTAVE_PREREQ(4,4,0)
25527 #elif SWIG_OCTAVE_PREREQ(3,2,0)
25528 octave_exit = ::_Exit;
25533 if (args.length() != 0 || nargout != 0) {
25535 return octave_value_list();
25543 #if SWIG_OCTAVE_PREREQ(3,2,0)
25544 octave_value_list eval_args;
25545 eval_args.append(
"base");
25546 eval_args.append(
"function __swig_atexit__; "
25553 "__swig_atexit__; "
25554 "atexit(\"__swig_atexit__\", false); "
25555 "atexit(\"__swig_atexit__\")");
25556 #if SWIG_OCTAVE_PREREQ(4,4,0)
25557 octave::feval(
"evalin", eval_args, 0);
25559 feval(
"evalin", eval_args, 0);
25563 #if SWIG_OCTAVE_PREREQ(4,4,0)
25565 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
25566 string_vector
types = typeinfo.installed_type_names();
25567 bool register_octave_swig_ref =
true;
25568 bool register_octave_swig_packed =
true;
25569 bool register_octave_swig_bound_func =
true;
25570 for (
int i = 0; i <
types.numel(); ++i) {
25571 if (
types(i) == octave_swig_ref::static_type_name()) {
25572 register_octave_swig_ref =
false;
25574 if (
types(i) == octave_swig_packed::static_type_name()) {
25575 register_octave_swig_packed =
false;
25577 if (
types(i) == octave_swig_bound_func::static_type_name()) {
25578 register_octave_swig_bound_func =
false;
25581 if (register_octave_swig_ref) {
25582 octave_swig_ref::register_type();
25584 if (register_octave_swig_packed) {
25585 octave_swig_packed::register_type();
25587 if (register_octave_swig_bound_func) {
25588 octave_swig_bound_func::register_type();
25592 octave_swig_ref::register_type();
25593 octave_swig_packed::register_type();
25598 #if SWIG_OCTAVE_PREREQ(4,4,0)
25599 octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
25600 octave_function *me = stack.current();
25602 octave_function *me = octave_call_stack::current();
25606 return octave_value_list();
25609 return octave_value_list();
25612 return octave_value_list();
25615 return octave_value_list();
25618 return octave_value_list();
25656 return octave_value_list();
25663 if (mb->second.first && mb->second.first->method) {
25665 return octave_value_list();
25670 #if SWIG_OCTAVE_PREREQ(4,4,0)
25671 octave::interpreter::the_interpreter()->mlock();
25672 #elif SWIG_OCTAVE_PREREQ(3,2,0)
25682 if (mb->second.second.is_defined()) {
25691 return octave_value_list();