16 #define SWIG_name_d "plplot_octave"
17 #define SWIG_name plplot_octave
19 #define SWIG_global_name "cvar"
20 #define SWIG_op_prefix "op_"
25 template<
typename T>
class SwigValueWrapper {
26 struct SwigMovePointer {
28 SwigMovePointer(T *p) : ptr(p) { }
29 ~SwigMovePointer() {
delete ptr; }
30 SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0;
delete oldptr; ptr = rhs.ptr; rhs.ptr = 0;
return *
this; }
32 SwigValueWrapper& operator=(
const SwigValueWrapper<T>& rhs);
33 SwigValueWrapper(
const SwigValueWrapper<T>& rhs);
35 SwigValueWrapper() : pointer(0) { }
36 SwigValueWrapper& operator=(
const T& t) { SwigMovePointer tmp(
new T(t)); pointer = tmp;
return *
this; }
37 operator T&()
const {
return *pointer.ptr; }
38 T *operator&() {
return pointer.ptr; }
41 template <
typename T> T SwigValueInit() {
52 #ifndef SWIGTEMPLATEDISAMBIGUATOR
53 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
54 # define SWIGTEMPLATEDISAMBIGUATOR template
55 # elif defined(__HP_aCC)
58 # define SWIGTEMPLATEDISAMBIGUATOR template
60 # define SWIGTEMPLATEDISAMBIGUATOR
66 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
67 # define SWIGINLINE inline
75 # if defined(__GNUC__)
76 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
77 # define SWIGUNUSED __attribute__ ((__unused__))
82 # define SWIGUNUSED __attribute__ ((__unused__))
88 #ifndef SWIG_MSC_UNSUPPRESS_4505
89 # if defined(_MSC_VER)
90 # pragma warning(disable : 4505)
94 #ifndef SWIGUNUSEDPARM
96 # define SWIGUNUSEDPARM(p)
98 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
104 # define SWIGINTERN static SWIGUNUSED
108 #ifndef SWIGINTERNINLINE
109 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
113 #if defined(__GNUC__)
114 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
115 # ifndef GCC_HASCLASSVISIBILITY
116 # define GCC_HASCLASSVISIBILITY
122 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
123 # if defined(STATIC_LINKED)
126 # define SWIGEXPORT __declspec(dllexport)
129 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
130 # define SWIGEXPORT __attribute__ ((visibility("default")))
139 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
140 # define SWIGSTDCALL __stdcall
147 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
148 # define _CRT_SECURE_NO_DEPRECATE
152 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
153 # define _SCL_SECURE_NO_DEPRECATE
157 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
158 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
166 #ifdef __INTEL_COMPILER
167 # pragma warning disable 592
181 #if !defined(_SWIG_OCTAVE_OCTHEADERS_HPP)
182 #define _SWIG_OCTAVE_OCTHEADERS_HPP
189 #include <functional>
196 #include <octave/oct.h>
197 #include <octave/version.h>
201 #define SWIG_OCTAVE_PREREQ(major, minor, patch) \
202 ( (OCTAVE_MAJOR_VERSION<<16) + (OCTAVE_MINOR_VERSION<<8) + (OCTAVE_PATCH_VERSION + 0) >= ((major)<<16) + ((minor)<<8) + (patch) )
205 #if !defined(OCTAVE_MAJOR_VERSION)
207 # if !defined(OCTAVE_API_VERSION_NUMBER)
211 # include <octave/ov.h>
212 # if defined(octave_ov_h)
213 # define OCTAVE_MAJOR_VERSION 3
214 # define OCTAVE_MINOR_VERSION 8
215 # define OCTAVE_PATCH_VERSION 0
219 # define ComplexLU __ignore
220 # include <octave/CmplxLU.h>
222 # if defined(octave_Complex_LU_h)
225 # define OCTAVE_MAJOR_VERSION 3
226 # define OCTAVE_MINOR_VERSION 1
227 # define OCTAVE_PATCH_VERSION 99
232 # define OCTAVE_MAJOR_VERSION 3
233 # define OCTAVE_MINOR_VERSION 2
234 # define OCTAVE_PATCH_VERSION 0
242 # elif OCTAVE_API_VERSION_NUMBER >= 48
243 # define OCTAVE_MAJOR_VERSION 3
244 # define OCTAVE_MINOR_VERSION 6
245 # define OCTAVE_PATCH_VERSION 0
247 # elif OCTAVE_API_VERSION_NUMBER >= 45
248 # define OCTAVE_MAJOR_VERSION 3
249 # define OCTAVE_MINOR_VERSION 4
250 # define OCTAVE_PATCH_VERSION 1
252 # elif OCTAVE_API_VERSION_NUMBER >= 42
253 # define OCTAVE_MAJOR_VERSION 3
254 # define OCTAVE_MINOR_VERSION 3
255 # define OCTAVE_PATCH_VERSION 54
257 # elif OCTAVE_API_VERSION_NUMBER >= 41
258 # define OCTAVE_MAJOR_VERSION 3
259 # define OCTAVE_MINOR_VERSION 3
260 # define OCTAVE_PATCH_VERSION 53
262 # elif OCTAVE_API_VERSION_NUMBER >= 40
263 # define OCTAVE_MAJOR_VERSION 3
264 # define OCTAVE_MINOR_VERSION 3
265 # define OCTAVE_PATCH_VERSION 52
267 # elif OCTAVE_API_VERSION_NUMBER >= 39
268 # define OCTAVE_MAJOR_VERSION 3
269 # define OCTAVE_MINOR_VERSION 3
270 # define OCTAVE_PATCH_VERSION 51
273 # define OCTAVE_MAJOR_VERSION 3
274 # define OCTAVE_MINOR_VERSION 3
275 # define OCTAVE_PATCH_VERSION 50
282 #include <octave/Cell.h>
283 #include <octave/dynamic-ld.h>
284 #include <octave/oct-env.h>
285 #include <octave/oct-map.h>
286 #include <octave/ov-scalar.h>
287 #include <octave/ov-fcn-handle.h>
288 #include <octave/parse.h>
289 #if SWIG_OCTAVE_PREREQ(4,2,0)
290 #include <octave/interpreter.h>
292 #include <octave/toplev.h>
294 #include <octave/unwind-prot.h>
295 #if SWIG_OCTAVE_PREREQ(4,2,0)
296 #include <octave/call-stack.h>
310 #define SWIG_RUNTIME_VERSION "4"
313 #ifdef SWIG_TYPE_TABLE
314 # define SWIG_QUOTE_STRING(x) #x
315 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
316 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
318 # define SWIG_TYPE_TABLE_NAME
331 # define SWIGRUNTIME SWIGINTERN
334 #ifndef SWIGRUNTIMEINLINE
335 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
339 #ifndef SWIG_BUFFER_SIZE
340 # define SWIG_BUFFER_SIZE 1024
344 #define SWIG_POINTER_DISOWN 0x1
345 #define SWIG_CAST_NEW_MEMORY 0x2
346 #define SWIG_POINTER_NO_NULL 0x4
349 #define SWIG_POINTER_OWN 0x1
432 #define SWIG_ERROR (-1)
433 #define SWIG_IsOK(r) (r >= 0)
434 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
437 #define SWIG_CASTRANKLIMIT (1 << 8)
439 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
441 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
443 #define SWIG_BADOBJ (SWIG_ERROR)
444 #define SWIG_OLDOBJ (SWIG_OK)
445 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
446 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
448 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
449 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
450 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
451 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
452 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
453 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
456 #if defined(SWIG_CASTRANK_MODE)
457 # ifndef SWIG_TypeRank
458 # define SWIG_TypeRank unsigned long
460 # ifndef SWIG_MAXCASTRANK
461 # define SWIG_MAXCASTRANK (2)
463 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
464 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
469 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
472 # define SWIG_AddCast(r) (r)
473 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
483 typedef void *(*swig_converter_func)(
void *,
int *);
525 const char *f2,
const char *l2) {
526 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
527 while ((*f1 ==
' ') && (f1 != l1)) ++f1;
528 while ((*f2 ==
' ') && (f2 != l2)) ++f2;
529 if (*f1 != *f2)
return (*f1 > *f2) ? 1 : -1;
531 return (
int)((l1 - f1) - (l2 - f2));
541 const char* te = tb + strlen(tb);
543 while (equiv != 0 && *ne) {
544 for (nb = ne; *ne; ++ne) {
545 if (*ne ==
'|')
break;
570 if (strcmp(iter->
type->
name, c) == 0) {
571 if (iter == ty->
cast)
597 if (iter->
type == from) {
598 if (iter == ty->
cast)
630 if (!ty || !ty->
dcast)
return ty;
631 while (ty && (ty->
dcast)) {
632 ty = (*ty->
dcast)(ptr);
656 if (!type)
return NULL;
657 if (type->
str != NULL) {
658 const char *last_name = type->
str;
660 for (s = type->
str; *s; s++)
661 if (*s ==
'|') last_name = s+1;
709 size_t r = iter->
size - 1;
712 size_t i = (l + r) >> 1;
713 const char *iname = iter->
types[i]->
name;
715 int compare = strcmp(
name, iname);
717 return iter->
types[i];
718 }
else if (compare < 0) {
724 }
else if (compare > 0) {
733 }
while (iter != end);
760 for (; i < iter->
size; ++i) {
762 return iter->
types[i];
765 }
while (iter != end);
777 static const char hex[17] =
"0123456789abcdef";
778 const unsigned char *u = (
unsigned char *) ptr;
779 const unsigned char *eu = u + sz;
780 for (; u != eu; ++u) {
781 unsigned char uu = *u;
782 *(c++) = hex[(uu & 0xf0) >> 4];
783 *(c++) = hex[uu & 0xf];
793 unsigned char *u = (
unsigned char *) ptr;
794 const unsigned char *eu = u + sz;
795 for (; u != eu; ++u) {
798 if ((d >=
'0') && (d <=
'9'))
799 uu = (
unsigned char)((d -
'0') << 4);
800 else if ((d >=
'a') && (d <=
'f'))
801 uu = (
unsigned char)((d - (
'a'-10)) << 4);
805 if ((d >=
'0') && (d <=
'9'))
806 uu |= (
unsigned char)(d -
'0');
807 else if ((d >=
'a') && (d <=
'f'))
808 uu |= (
unsigned char)(d - (
'a'-10));
822 if ((2*
sizeof(
void *) + 2) > bsz)
return 0;
825 if (strlen(
name) + 1 > (bsz - (r - buff)))
return 0;
833 if (strcmp(c,
"NULL") == 0) {
846 size_t lname = (
name ? strlen(
name) : 0);
847 if ((2*sz + 2 + lname) > bsz)
return 0;
851 strncpy(r,
name,lname+1);
861 if (strcmp(c,
"NULL") == 0) {
876 #define SWIG_UnknownError -1
877 #define SWIG_IOError -2
878 #define SWIG_RuntimeError -3
879 #define SWIG_IndexError -4
880 #define SWIG_TypeError -5
881 #define SWIG_DivisionByZero -6
882 #define SWIG_OverflowError -7
883 #define SWIG_SyntaxError -8
884 #define SWIG_ValueError -9
885 #define SWIG_SystemError -10
886 #define SWIG_AttributeError -11
887 #define SWIG_MemoryError -12
888 #define SWIG_NullReferenceError -13
892 #if !SWIG_OCTAVE_PREREQ(3,2,0)
893 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
895 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
899 if (num_args > max_args && !varargs)
900 error(
"function %s takes at most %i arguments", func_name, max_args);
901 else if (num_args < min_args)
902 error(
"function %s requires at least %i arguments", func_name, min_args);
916 return "SWIG_MemoryError";
918 return "SWIG_IOError";
920 return "SWIG_RuntimeError";
922 return "SWIG_IndexError";
924 return "SWIG_TypeError";
926 return "SWIG_DivisionByZero";
928 return "SWIG_OverflowError";
930 return "SWIG_SyntaxError";
932 return "SWIG_ValueError";
934 return "SWIG_SystemError";
936 return "SWIG_AttributeError";
938 return "SWIG unknown error";
944 r +=
" (" + type.string_value() +
")";
945 error(
"%s", r.c_str());
946 return octave_value(r);
949 #define SWIG_fail goto fail
951 #define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
952 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
953 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
954 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
955 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
956 #define swig_owntype int
958 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
959 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
961 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
962 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
964 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
965 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
967 #define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
968 #define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
969 #define SWIG_MODULE_CLIENTDATA_TYPE void*
971 #define Octave_Error_Occurred() 0
972 #define SWIG_Octave_AddErrorMsg(msg) {;}
978 #define SWIG_POINTER_EXCEPTION 0
979 #define SWIG_arg_fail(arg) 0
983 typedef octave_value_list(*
octave_func) (
const octave_value_list &, int);
988 #ifdef SWIG_DIRECTORS
992 typedef std::map < void *, Director * > rtdir_map;
1009 #ifdef SWIG_DIRECTORS
1010 SWIGRUNTIME void swig_acquire_ownership(
void *vptr);
1011 SWIGRUNTIME void swig_acquire_ownership_array(
void *vptr);
1012 SWIGRUNTIME void swig_acquire_ownership_obj(
void *vptr,
int own);
1041 #if SWIG_OCTAVE_PREREQ(4,4,0)
1044 #define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(new octave_swig_bound_func(func, args))
1045 class octave_swig_bound_func :
public octave_function {
1048 octave_swig_bound_func(
void) : octave_function(), method(0), first_args()
1051 octave_swig_bound_func(octave_function* _method, octave_value_list _first_args)
1052 : octave_function(
"",
""), method(_method), first_args(_first_args)
1055 octave_swig_bound_func(
const octave_swig_bound_func& f) =
delete;
1057 octave_swig_bound_func& operator= (
const octave_swig_bound_func& f) =
delete;
1059 ~octave_swig_bound_func(
void) =
default;
1061 bool is_function(
void)
const {
return true; }
1063 octave_function* function_value(
bool =
false) {
return this; }
1065 #if SWIG_OCTAVE_PREREQ(6,0,0)
1066 octave_value_list call(octave::tree_evaluator& tw,
int nargout = 0,
const octave_value_list& args = octave_value_list()) {
1067 return execute(tw,nargout,args);
1070 #if SWIG_OCTAVE_PREREQ(6,0,0)
1071 octave_value_list execute(octave::tree_evaluator& tw,
int nargout = 0,
const octave_value_list& args = octave_value_list()) {
1073 octave_value_list call(octave::tree_evaluator& tw,
int nargout = 0,
const octave_value_list& args = octave_value_list()) {
1075 octave_value_list all_args;
1076 all_args.append(first_args);
1077 all_args.append(args);
1078 return method->call(tw, nargout, all_args);
1081 octave_value subsref(
const std::string &ops,
const std::list < octave_value_list > &idx) {
1082 octave_value_list ovl = subsref(ops, idx, 1);
1083 return ovl.length() ? ovl(0) : octave_value();
1086 octave_value_list subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout) {
1087 assert(ops.size() > 0);
1088 assert(ops.size() == idx.size());
1090 error(
"invalid function call");
1091 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1092 return call(tw, nargout, *idx.begin());
1097 octave_function* method;
1098 octave_value_list first_args;
1100 std::set<std::string> dispatch_classes;
1104 #define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(func)
1139 if (m->name ==
name)
1150 if ((m = find_member(c->
base[j],
name)))
1157 member_map::iterator it = members.find(
name);
1158 if (it != members.end())
1161 for (
unsigned int j = 0; j < types.size(); ++j)
1162 if ((m = find_member(types[j].first,
name)))
1163 return &members.insert(std::make_pair(
name, std::make_pair(m, octave_value()))).first->second;
1164 if (!insert_if_not_found)
1166 return &members[
name];
1171 for (
unsigned int j = 0; j < types.size(); ++j) {
1172 assert(types[j].first->clientdata);
1175 return types[j].first;
1200 if (out.find(m->name) == out.end())
1201 out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1215 load_members(cj,out);
1221 for (
unsigned int j = 0; j < types.size(); ++j)
1222 if (types[j].first->clientdata)
1227 if (m->second.is_defined())
1228 return m->second.subsref(
"(", std::list < octave_value_list > (1, args), nargout);
1229 else if (m->first && m->first->method)
1230 return m->first->method(args, nargout);
1231 error(
"member not defined or not invocable");
1232 return octave_value_list();
1238 if (!m || m->first->is_static() || m->first->is_global())
1240 octave_value_list args;
1242 octave_value_list argout(nc_this->
member_invoke(m, args, 1));
1243 if (argout.length() < 1)
1249 bool dispatch_binary_op(
const std::string &symbol,
const octave_base_value &rhs, octave_value &ret)
const {
1252 if (!m || m->first->is_static() || m->first->is_global())
1254 octave_value_list args;
1256 args.append(make_value_hack(rhs));
1257 octave_value_list argout(nc_this->
member_invoke(m, args, 1));
1258 if (argout.length() < 1)
1264 bool dispatch_index_op(
const std::string &symbol,
const octave_value_list &rhs, octave_value_list &ret)
const {
1267 if (!m || m->first->is_static() || m->first->is_global())
1269 octave_value_list args;
1272 octave_value_list argout(nc_this->
member_invoke(m, args, 1));
1273 if (argout.length() >= 1)
1279 if (m->second.is_defined()) {
1280 if (m->second.is_function() || m->second.is_function_handle()) {
1285 }
else if (m->first) {
1286 if (m->first->get_method)
1287 return m->first->get_method(args, 1);
1288 else if (m->first->method)
1291 error(
"undefined member");
1292 return octave_value_list();
1297 return octave_value((octave_base_value *) &x);
1305 bool _always_static =
false)
1306 : module(0), construct_type(_ptr ? 0 : _type), own(_own),
1307 always_static(_always_static) {
1309 types.push_back(std::make_pair(_type, _ptr));
1310 #ifdef SWIG_DIRECTORS
1312 Swig::Director *d = Swig::get_rtdir(_ptr);
1314 Swig::swig_director_set_self(d,
this);
1322 for (
unsigned int j = 0; j < types.size(); ++j) {
1323 if (!types[j].first || !types[j].first->clientdata)
1326 if (c->
destructor && !types[j].second.destroyed && types[j].second.ptr) {
1331 #ifdef SWIG_DIRECTORS
1332 for (
unsigned int j = 0; j < types.size(); ++j)
1333 Swig::erase_rtdir(types[j].second.ptr);
1339 if (!dispatch_unary_op(
"__dims__", out))
1340 return dim_vector(1,1);
1343 #if SWIG_OCTAVE_PREREQ(4,4,0)
1346 if (out.is_cell()) {
1348 const Cell & c=out.cell_value();
1349 int ndim = c.rows();
1350 if (ndim==1 && c.columns()!=1) ndim = c.columns();
1353 d.resize(ndim < 2 ? 2 : ndim);
1357 for (
int k=0;k<ndim;k++) {
1358 const octave_value& obj = c(k);
1359 #if SWIG_OCTAVE_PREREQ(6,0,0)
1361 d.elem(k) = obj.int_value();
1363 catch (octave::execution_exception& oee) {
1365 return dim_vector(1,1);
1368 d.elem(k) = obj.int_value();
1371 if (error_state)
return dim_vector(1,1);
1375 #if SWIG_OCTAVE_PREREQ(4,4,0)
1376 }
else if (out.is_matrix_type() || out.isnumeric() ) {
1378 }
else if (out.is_matrix_type() || out.is_numeric_type() ) {
1380 if (out.rows()==1 || out.columns()==1) {
1381 #if SWIG_OCTAVE_PREREQ(6,0,0)
1384 a = out.int_vector_value();
1386 catch (octave::execution_exception& oee) {
1387 return dim_vector(1,1);
1390 Array<int> a = out.int_vector_value();
1391 if (error_state)
return dim_vector(1,1);
1394 d.resize(a.numel() < 2 ? 2 : a.numel());
1396 for (
int k=0;k<a.numel();k++) {
1401 return dim_vector(1,1);
1404 return dim_vector(1,1);
1424 return (
size_t)
this;
1425 return (
size_t) types[0].second.ptr;
1430 if (!types[0].first->clientdata)
1440 for (
unsigned int j = 0; j < types.size(); ++j) {
1443 if (types[j].first->clientdata) {
1447 ret += types[j].first->name;
1454 for (
unsigned int j = 0; j < rhs.
types.size(); ++j) {
1455 assert(!rhs.
types[j].second.destroyed);
1456 #ifdef SWIG_DIRECTORS
1457 Swig::Director *d = Swig::get_rtdir(rhs.
types[j].second.ptr);
1459 Swig::swig_director_set_self(d,
this);
1462 types.insert(types.end(), rhs.
types.begin(), rhs.
types.end());
1464 #if SWIG_OCTAVE_PREREQ(4,4,0)
1482 if (!type && types.size()) {
1484 *vptr = types[0].second.ptr;
1487 for (
unsigned int j = 0; j < types.size(); ++j)
1488 if (type == types[j].first) {
1490 *vptr = types[j].second.ptr;
1493 for (
unsigned int j = 0; j < types.size(); ++j) {
1516 #ifdef SWIG_DIRECTORS
1517 void director_destroyed(Swig::Director *d) {
1519 for (
unsigned int j = 0; j < types.size(); ++j) {
1520 Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1522 types[j].second.destroyed =
true;
1535 members[
name] = std::make_pair(m, octave_value());
1554 #if SWIG_OCTAVE_PREREQ(6,0,0)
1555 virtual bool isstruct()
const {
1562 virtual octave_value
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx) {
1563 octave_value_list ovl = subsref(ops, idx, 1);
1564 return ovl.length()? ovl(0) : octave_value();
1567 virtual octave_value_list
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout) {
1568 assert(ops.size() > 0);
1569 assert(ops.size() == idx.size());
1571 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1573 octave_value_list sub_ovl;
1576 if (ops[skip] ==
'(' && construct_type) {
1580 error(
"cannot create instance");
1581 return octave_value_list();
1583 octave_value_list args;
1586 args.append(*idx_it++);
1591 else if (ops[skip] ==
'.') {
1592 std::string subname;
1595 octave_value_list subname_ovl(*idx_it++);
1597 assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1598 subname = subname_ovl(0).string_value();
1601 if (!next_base || skip >= (
int) ops.size() || ops[skip] !=
'.')
1607 if (!base || !(m->first = find_member(base, subname)))
1608 m = find_member(subname,
false);
1610 error(
"member not found");
1611 return octave_value_list();
1614 octave_value_list args;
1615 if (!always_static &&
1616 (!m->first || (!m->first->is_static() && !m->first->is_global())))
1617 args.append(as_value());
1618 if (skip < (
int) ops.size() && ops[skip] ==
'(' &&
1619 ((m->first && m->first->method) || m->second.is_function() ||
1620 m->second.is_function_handle())) {
1621 args.append(*idx_it++);
1623 sub_ovl = member_invoke(m, args, nargout);
1625 sub_ovl = member_deref(m, args);
1630 if (ops[skip] ==
'(' || ops[skip] ==
'{') {
1631 const char *op_name = ops[skip] ==
'(' ?
"__paren__" :
"__brace__";
1632 octave_value_list args;
1633 args.append(*idx_it++);
1635 if (!dispatch_index_op(op_name, args, sub_ovl)) {
1636 error(
"error evaluating index operator");
1637 return octave_value_list();
1640 error(
"unsupported subsref");
1641 return octave_value_list();
1645 if (skip >= (
int) ops.size())
1647 if (sub_ovl.length() < 1) {
1648 error(
"bad subs ref");
1649 return octave_value_list();
1651 return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1654 octave_value
subsasgn(
const std::string &ops,
const std::list < octave_value_list > &idx,
const octave_value &rhs) {
1655 assert(ops.size() > 0);
1656 assert(ops.size() == idx.size());
1658 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1661 if (ops.size() > 1) {
1662 std::list < octave_value_list >::const_iterator last = idx.end();
1664 std::list < octave_value_list > next_idx(idx.begin(), last);
1665 octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
1666 next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1669 else if (ops[skip] ==
'(' || ops[skip] ==
'{') {
1670 const char *op_name = ops[skip] ==
'(' ?
"__paren_asgn__" :
"__brace_asgn__";
1673 octave_value_list args;
1674 args.append(as_value());
1675 args.append(*idx_it);
1677 member_invoke(m, args, 1);
1679 error(
"%s member not found", op_name);
1682 else if (ops[skip] ==
'.') {
1683 octave_value_list subname_ovl(*idx_it++);
1685 assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1686 std::string subname = subname_ovl(0).string_value();
1689 if (!m->first || !m->first->set_method) {
1692 }
else if (m->first->set_method) {
1693 octave_value_list args;
1694 if (!m->first->is_static() && !m->first->is_global())
1695 args.append(as_value());
1697 m->first->set_method(args, 1);
1699 error(
"member not assignable");
1701 error(
"unsupported subsasgn");
1706 #if SWIG_OCTAVE_PREREQ(6,0,0)
1707 virtual bool isobject()
const {
1721 if (!dispatch_unary_op(
"__str__", ret)) {
1722 error(
"__str__ method not defined");
1723 return std::string();
1725 if (!ret.is_string()) {
1726 error(
"__str__ method did not return a string");
1727 return std::string();
1729 return ret.string_value();
1734 if (!dispatch_unary_op(
"__float__", ret)) {
1735 error(
"__float__ method not defined");
1737 return ret.scalar_value();
1740 #if SWIG_OCTAVE_PREREQ(4,2,0)
1741 virtual octave_value as_double(
void)
const {
1743 if (!dispatch_unary_op(
"__float__", ret)) {
1744 error(
"__float__ method not defined");
1746 return ret.as_double();
1749 virtual octave_value as_single(
void)
const {
1751 if (!dispatch_unary_op(
"__float__", ret)) {
1752 error(
"__float__ method not defined");
1754 return ret.as_single();
1758 #if SWIG_OCTAVE_PREREQ(3,8,0)
1759 virtual octave_value map(octave_base_value::unary_mapper_t umap)
const {
1760 const std::string opname = std::string(
"__") + octave_base_value::get_umap_name(umap) + std::string(
"__");
1762 if (!dispatch_unary_op(opname, ret)) {
1763 error(
"%s", (opname + std::string(
" method not found")).c_str());
1764 return octave_value();
1770 #if SWIG_OCTAVE_PREREQ(3,3,52)
1771 virtual octave_map map_value()
const {
1772 return octave_map();
1776 return Octave_map();
1784 string_vector keys(tmp.size());
1786 for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1787 keys(k++) = it->first;
1806 octave::mach_info::float_format fmt) {
1808 oct_mach_info::float_format fmt) {
1813 #if defined (HAVE_HDF5)
1814 # if SWIG_OCTAVE_PREREQ(4,0,0)
1816 save_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool save_as_floats) {
1821 load_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool have_h5giterate_bug) {
1826 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats) {
1831 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug) {
1837 virtual octave_value
convert_to_str(
bool pad =
false,
bool force =
false,
char type =
'"')
const {
1838 return string_value();
1842 return string_value();
1845 static bool dispatch_global_op(
const std::string &symbol,
const octave_value_list &args, octave_value &ret) {
1849 octave_function *fcn = is_valid_function(symbol, std::string(),
false);
1852 #if SWIG_OCTAVE_PREREQ(4,4,0)
1853 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1854 octave_value_list retval = fcn->call(tw, 1, args);
1855 if (retval.length() == 1)
1858 ret = fcn->do_multi_index_op(1, args)(0);
1868 if (ost->
dispatch_unary_op(std::string(
"__") + op_name + std::string(
"__"), ret))
1871 octave_value_list args;
1872 args.append(make_value_hack(x));
1873 if (dispatch_global_op(symbol, args, ret))
1876 error(
"could not dispatch unary operator");
1877 return octave_value();
1880 static octave_value
dispatch_binary_op(
const octave_base_value &lhs,
const octave_base_value &rhs,
const char *op_name) {
1885 if (lhs_ost && lhs_ost->
dispatch_binary_op(std::string(
"__") + op_name + std::string(
"__"), rhs, ret))
1888 if (strlen(op_name) == 2 && (op_name[1] ==
't' || op_name[1] ==
'e')) {
1889 if (op_name[0] ==
'l' && rhs_ost->
dispatch_binary_op(std::string(
"__g") + op_name[1] + std::string(
"__"), lhs, ret))
1891 if (op_name[0] ==
'g' && rhs_ost->
dispatch_binary_op(std::string(
"__l") + op_name[1] + std::string(
"__"), lhs, ret))
1894 if (rhs_ost->
dispatch_binary_op(std::string(
"__r") + op_name + std::string(
"__"), lhs, ret))
1899 octave_value_list args;
1900 args.append(make_value_hack(lhs));
1901 args.append(make_value_hack(rhs));
1909 if (dispatch_global_op(symbol, args, ret))
1918 if (dispatch_global_op(symbol, args, ret))
1927 if (dispatch_global_op(symbol, args, ret))
1930 error(
"could not dispatch binary operator");
1931 return octave_value();
1934 #if SWIG_OCTAVE_PREREQ(4,0,0)
1935 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
1937 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
1941 os << string_value();
1949 os <<
"{"; newline(os);
1950 increment_indent_level();
1951 for (
unsigned int j = 0; j < types.size(); ++j) {
1953 if (types[j].first->clientdata) {
1955 os << c->
name <<
", ptr = " << types[j].second.ptr; newline(os);
1957 os << types[j].first->name <<
", ptr = " << types[j].second.ptr; newline(os);
1960 for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
1962 if (it->second.first) {
1963 const char *objtype = it->second.first->method ?
"method" :
"variable";
1964 const char *modifier = (it->second.first->flags &1) ?
"static " : (it->second.first->flags &2) ?
"global " :
"";
1965 os << it->second.first->name <<
" (" << modifier << objtype <<
")"; newline(os);
1966 assert(it->second.first->name == it->first);
1968 os << it->first; newline(os);
1971 decrement_indent_level();
1973 os <<
"}"; newline(os);
1997 t_id = octave_swig_ref::static_type_id();
2002 {
if (ptr) ptr->
decref(); }
2014 {
return ptr->
dims(); }
2019 #if SWIG_OCTAVE_PREREQ(6,0,0)
2020 virtual bool isstruct()
const
2021 {
return ptr->isstruct(); }
2024 {
return ptr->
is_map(); }
2027 virtual octave_value
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx)
2028 {
return ptr->
subsref(ops, idx); }
2030 virtual octave_value_list
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout)
2031 {
return ptr->
subsref(ops, idx, nargout); }
2033 octave_value
subsasgn(
const std::string &ops,
const std::list < octave_value_list > &idx,
const octave_value &rhs)
2034 {
return ptr->
subsasgn(ops, idx, rhs); }
2036 #if SWIG_OCTAVE_PREREQ(6,0,0)
2037 virtual bool isobject()
const
2038 {
return ptr->isobject(); }
2053 #if SWIG_OCTAVE_PREREQ(4,2,0)
2054 virtual octave_value as_double(
void)
const
2055 {
return ptr->as_double(); }
2057 virtual octave_value as_single(
void)
const
2058 {
return ptr->as_single(); }
2061 #if SWIG_OCTAVE_PREREQ(3,8,0)
2062 virtual octave_value map(octave_base_value::unary_mapper_t umap)
const
2063 {
return ptr->map(umap); }
2066 #if SWIG_OCTAVE_PREREQ(3,3,52)
2067 virtual octave_map map_value()
const
2088 octave::mach_info::float_format fmt)
2090 oct_mach_info::float_format fmt)
2094 #if defined (HAVE_HDF5)
2095 # if SWIG_OCTAVE_PREREQ(4,0,0)
2097 save_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool save_as_floats)
2098 {
return ptr->save_hdf5(loc_id,
name, save_as_floats); }
2101 load_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool have_h5giterate_bug)
2102 {
return ptr->load_hdf5(loc_id,
name, have_h5giterate_bug); }
2105 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats)
2106 {
return ptr->save_hdf5(loc_id,
name, save_as_floats); }
2109 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug)
2110 {
return ptr->load_hdf5(loc_id,
name, have_h5giterate_bug); }
2114 virtual octave_value
convert_to_str(
bool pad =
false,
bool force =
false,
char type =
'"')
const
2120 #if SWIG_OCTAVE_PREREQ(4,0,0)
2121 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
2123 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
2125 {
return ptr->
print(os, pr_as_read_syntax); }
2127 #if SWIG_OCTAVE_PREREQ(4,4,0)
2128 static void set_type_id(
int type_id) { t_id=type_id; }
2132 return octave_base_value::type_conv_info (default_numeric_conversion_function,
2133 octave_scalar::static_type_id ());
2142 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2147 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2158 : type(_type),
buf((const char*)_buf, (const char*)_buf + _buf_len)
2162 t_id = octave_swig_packed::static_type_id();
2167 if (outtype && outtype != type)
2169 assert(sz <=
buf.size());
2170 std::copy(
buf.begin(),
buf.begin()+sz, (
char*)ptr);
2186 #if SWIG_OCTAVE_PREREQ(4,0,0)
2187 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
2189 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
2193 os <<
"swig packed type: name = " << (type ? type->
name : std::string()) <<
", len = " <<
buf.size(); newline(os);
2211 octave::mach_info::float_format fmt) {
2213 oct_mach_info::float_format fmt) {
2218 #if defined (HAVE_HDF5)
2219 # if SWIG_OCTAVE_PREREQ(4,0,0)
2221 save_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool save_as_floats) {
2226 load_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool have_h5giterate_bug) {
2231 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats) {
2236 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug) {
2242 #if SWIG_OCTAVE_PREREQ(4,4,0)
2243 static void set_type_id(
int type_id) { t_id=type_id; }
2247 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2252 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2258 error(
"attempt to set immutable member variable");
2259 return octave_value_list();
2267 :ovl(_ovl), j(_j) { }
2269 operator octave_value()
const {
2292 && ov.rows() == 1 && ov.columns() == 1)
2293 ov = ov.cell_value()(0);
2298 if (ov.type_id() != octave_swig_ref::static_type_id())
2307 #define swig_unary_op(name) \
2308 SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
2309 return octave_swig_type::dispatch_unary_op(x,#name); \
2311 #define swig_binary_op(name) \
2312 SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
2313 return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
2315 #if SWIG_OCTAVE_PREREQ(4,4,0)
2316 #define swigreg_unary_op(name) \
2317 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2318 typeinfo.register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2320 #define swigreg_unary_op(name) \
2321 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2322 octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2324 #if SWIG_OCTAVE_PREREQ(4,4,0)
2325 #define swigreg_binary_op(name) \
2326 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2327 typeinfo.register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2329 #define swigreg_binary_op(name) \
2330 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2331 octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2348 #if !SWIG_OCTAVE_PREREQ(4,2,0)
2366 #if SWIG_OCTAVE_PREREQ(4,4,0)
2367 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2378 #if SWIG_OCTAVE_PREREQ(4,4,0)
2379 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2387 #if !SWIG_OCTAVE_PREREQ(4,2,0)
2411 for (
int j = 0; j < tid; ++j) {
2420 #ifdef SWIG_DIRECTORS
2421 Swig::Director *d = Swig::get_rtdir(ptr);
2422 if (d && Swig::swig_director_get_self(d))
2423 return Swig::swig_director_get_self(d)->as_value();
2435 && ov.rows() == 1 && ov.columns() == 1)
2436 ov = ov.cell_value()(0);
2437 if (!ov.is_defined() ||
2438 (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2443 if (ov.type_id() != octave_swig_ref::static_type_id())
2447 return ost->
cast(ptr, type, own, flags);
2455 if (!ov.is_defined())
2457 if (ov.type_id() != octave_swig_packed::static_type_id())
2468 #if SWIG_OCTAVE_PREREQ(6,0,0)
2469 octave::interpreter *
interp = octave::interpreter::the_interpreter ();
2472 #if SWIG_OCTAVE_PREREQ(4,4,0)
2473 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2474 return symtab.global_varval(
name);
2476 return get_global_value(
name,
true);
2482 #if SWIG_OCTAVE_PREREQ(6,0,0)
2483 octave::interpreter *
interp = octave::interpreter::the_interpreter ();
2485 #elif SWIG_OCTAVE_PREREQ(4,4,0)
2486 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2494 #if SWIG_OCTAVE_PREREQ(4,4,0)
2495 octave::symbol_scope symscope = octave::interpreter::the_interpreter()->get_current_scope();
2496 #if SWIG_OCTAVE_PREREQ(6,0,0)
2497 octave::interpreter *
interp = octave::interpreter::the_interpreter ();
2499 octave::tree_evaluator& tree_eval =
interp->get_evaluator();
2500 octave::call_stack& callStack = tree_eval.get_call_stack();
2501 std::shared_ptr<octave::stack_frame> stackFrame = callStack.get_current_stack_frame();
2502 octave::symbol_record sym=symscope.lookup_symbol(
name);
2503 stackFrame->mark_global(sym);
2505 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2506 symscope.assign(
name, symtab.global_varval(
name));
2507 symscope.mark_global(
name);
2510 #if !SWIG_OCTAVE_PREREQ(3,2,0)
2511 link_to_global_variable(curr_sym_tab->lookup(
name,
true));
2513 #if !SWIG_OCTAVE_PREREQ(3,8,0)
2514 symbol_table::varref(
name);
2516 symbol_table::mark_global(
name);
2523 if (!ov.is_defined() ||
2524 ov.type_id() != octave_swig_packed::static_type_id())
2540 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2542 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2548 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2549 #define SWIGTYPE_p_char swig_types[1]
2550 #define SWIGTYPE_p_double swig_types[2]
2551 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2552 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2553 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2554 #define SWIGTYPE_p_int swig_types[6]
2555 #define SWIGTYPE_p_p_char swig_types[7]
2556 #define SWIGTYPE_p_unsigned_int swig_types[8]
2559 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2560 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2565 #define SWIGVERSION 0x040002
2566 #define SWIG_VERSION SWIGVERSION
2569 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2570 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2573 #include <stdexcept>
2583 #ifdef OCTAVE_EXPORT
2584 #if defined ( __GNUC__ ) && __GNUC__ > 3
2585 #undef OCTAVE_EXPORT
2586 #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2604 inline int max(
int a,
int b )
2606 return a >= b ? a : b;
2608 inline int min(
int a,
int b )
2610 return a >= b ? a : b;
2624 return max( o_obj.rows(), 1 ) *
max( o_obj.columns(), 1 );
2636 if (
max( o_obj.columns(), 1 ) > 1 )
2641 else if (
max( o_obj.rows(), 1 ) > 1 )
2651 _dim(
const octave_value &o_obj,
int dim_idx )
2654 return max( o_obj.rows(), 0 );
2658 else if ( dim_idx == 1 )
2659 return max( o_obj.columns(), 0 );
2672 template <
class FLOAT>
2676 while ( n_el-- > 0 )
2677 *out_arr++ = (FLOAT) ( *in_arr++ );
2696 template <
class FLOAT>
2700 while ( n_el-- > 0 )
2701 *d_arr++ = double(*arr++);
2732 octave_value_list functionArguments;
2733 octave_value_list retval;
2740 for ( i = 0; i < n; i++ )
2746 functionArguments( 0 ) = xin;
2747 functionArguments( 1 ) = yin;
2750 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2751 retval = octave::feval(
fcnMapForm, functionArguments, 1 );
2753 retval = feval(
fcnMapForm, functionArguments, 1 );
2756 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2757 retval = octave::feval(
nameMapForm, functionArguments, 1 );
2759 retval = feval(
nameMapForm, functionArguments, 1 );
2762 if ( retval.length() >= 2 )
2764 xout = retval( 0 ).matrix_value();
2765 yout = retval( 1 ).matrix_value();
2767 for ( i = 0; i < n; i++ )
2769 x[i] = xout( i, 0 );
2770 y[i] = yout( i, 0 );
2782 octave_value_list functionArguments;
2783 octave_value_list retval;
2785 Matrix inAxis( 1, 1 );
2786 Matrix inValue( 1, 1 );
2787 inAxis( 0, 0 ) = axis;
2788 inValue( 0, 0 ) =
value;
2790 functionArguments( 0 ) = inAxis;
2791 functionArguments( 1 ) = inValue;
2794 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2795 retval = octave::feval(
fcnLabelFunc, functionArguments, 1 );
2800 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2801 retval = octave::feval(
nameLabelFunc, functionArguments, 1 );
2806 strncpy( label, retval( 0 ).string_value().c_str(), length );
2816 octave_value_list functionArguments;
2817 octave_value_list retval;
2827 functionArguments( 0 ) = xin;
2828 functionArguments( 1 ) = yin;
2831 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2832 retval = octave::feval(
fcnCoordTrans, functionArguments, 1 );
2837 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2843 if ( retval.length() >= 2 )
2845 xout = retval( 0 ).matrix_value();
2846 yout = retval( 1 ).matrix_value();
2857 printf(
"nlegend =%d\n", nlegend );
2858 for ( i = 0; i < nlegend; i++ )
2860 printf(
"opt_array[%d] =%d\n", i, opt_array[i] );
2861 printf(
"strlen(text[%d]) =%d\n", i, (
int) strlen(
text[i] ) );
2862 printf(
"text[%d] =%s\n", i,
text[i] );
2868 #if !defined(SWIG_NO_LLONG_MAX)
2869 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2870 # define LLONG_MAX __LONG_LONG_MAX__
2871 # define LLONG_MIN (-LLONG_MAX - 1LL)
2872 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2879 if (!ov.is_scalar_type())
2881 if (ov.is_complex_scalar())
2883 if (ov.is_double_type()||ov.is_single_type()) {
2884 double v=ov.double_value();
2889 *val = ov.long_value();
2900 if ((v < INT_MIN || v > INT_MAX)) {
2903 if (val) *val =
static_cast< int >(v);
2910 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 )
2918 *pX = gin.
pX; *pY = gin.
pY; *dX = gin.
dX; *dY = gin.
dY; *wX = gin.
wX; *wY = gin.
wY;
2932 && ov.rows() == 1 && ov.columns() == 1)
2933 ov = ov.cell_value()(0);
2934 if (!ov.is_string())
2937 std::string str=ov.string_value();
2938 size_t len=str.size();
2939 char* cstr=(
char*)str.c_str();
2941 *cptr =
reinterpret_cast< char*
>(memcpy(
new char[len + 1], cstr,
sizeof(
char)*(len + 1)));
2956 return octave_value(
value);
2969 return octave_value(
value);
2978 gin.
dX = x_in; gin.
dY = y_in;
2980 *x = gin.
wX; *y = gin.
wY;
2987 if (!ov.is_scalar_type())
2989 if (ov.is_complex_scalar())
2992 *val = ov.double_value();
3005 const char *legline1,
const char *legline2,
const char *legline3,
const char *legline4,
3006 const char *labx,
const char *laby,
const char *labtop )
3008 const char *legline[4];
3009 legline[0] = legline1; legline[1] = legline2;
3010 legline[2] = legline3; legline[3] = legline4;
3011 c_plstripc(
id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
3012 xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
3013 labx, laby, labtop );
3031 *tx = *( (
PLFLT *) pltr_data + 0 ) * x + *( (
PLFLT *) pltr_data + 1 ) * y + *( (
PLFLT *) pltr_data + 2 );
3032 *ty = *( (
PLFLT *) pltr_data + 3 ) * x + *( (
PLFLT *) pltr_data + 4 ) * y + *( (
PLFLT *) pltr_data + 5 );
3037 #define f2c( f, ff, nx, ny ) \
3039 ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
3040 for ( int i = 0; i < nx; i++ ) { \
3041 ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
3042 for ( int j = 0; j < ny; j++ ) \
3043 *( ff[i] + j ) = *( f + nx * j + i );}
3050 f2c( f, ff, nx, ny );
3051 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
xform, tr );
3059 f2c( f, ff, nx, ny );
3060 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr0, NULL );
3069 grid1.
nx = nx; grid1.
ny = ny;
3071 f2c( f, ff, nx, ny );
3072 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr1, &grid1 );
3080 f2c( xg, xgg, nx, ny );
3081 f2c( yg, ygg, nx, ny );
3082 grid2.
nx = nx; grid2.
ny = ny;
3083 grid2.
xg = xgg; grid2.
yg = ygg;
3084 f2c( f, ff, nx, ny );
3085 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
3094 f2c( xg, xgg, nx, ny );
3095 f2c( yg, ygg, nx, ny );
3096 grid2.
nx = nx; grid2.
ny = ny;
3097 grid2.
xg = xgg; grid2.
yg = ygg;
3098 f2c( f, ff, nx, ny );
3099 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
3104 const PLFLT *xg,
int nptsx,
const PLFLT *yg,
int nptsy,
3107 f2c( zg, zgg, nptsx, nptsy );
3108 plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
3109 for (
int i = 0; i < nptsx; i++ )
3110 for (
int j = 0; j < nptsy; j++ )
3111 *( zg + nptsx * j + i ) = zgg[i][j];
3119 f2c( z, zz, nx, ny );
3127 f2c( z, zz, nx, ny );
3128 c_plmeshc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3136 f2c( z, zz, nx, ny );
3145 f2c( z, zz, nx, ny );
3146 c_plot3dc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3155 f2c( z, zz, nx, ny );
3157 indexxmin, indexxmax, indexymin, indexymax );
3164 f2c( z, zz, nx, ny );
3172 f2c( z, zz, nx, ny );
3174 indexxmin, indexxmax, indexymin, indexymax );
3192 f2c( a, aa, nx, ny );
3193 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3194 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3195 min_color, min_width, max_color, max_width,
3209 grid1.
nx = nx; grid1.
ny = ny;
3211 f2c( a, aa, nx, ny );
3212 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3213 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3214 min_color, min_width, max_color, max_width,
3228 f2c( xg, xgg, nx, ny );
3229 f2c( yg, ygg, nx, ny );
3230 grid2.
nx = nx; grid2.
ny = ny;
3231 grid2.
xg = xgg; grid2.
yg = ygg;
3232 f2c( a, aa, nx, ny );
3233 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3234 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3235 min_color, min_width, max_color, max_width,
3247 f2c( a, aa, nx, ny );
3248 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3249 clevel, nlevel, fill_width, cont_color, cont_width,
3250 plfill, rectangular, NULL, NULL );
3259 f2c( a, aa, nx, ny );
3260 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3261 clevel, nlevel, fill_width, cont_color, cont_width,
3272 grid1.
nx = nx; grid1.
ny = ny;
3275 f2c( a, aa, nx, ny );
3276 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3277 clevel, nlevel, fill_width, cont_color, cont_width,
3288 f2c( xg, xgg, nx, ny );
3289 f2c( yg, ygg, nx, ny );
3290 grid2.
nx = nx; grid2.
ny = ny;
3291 grid2.
xg = xgg; grid2.
yg = ygg;
3292 f2c( a, aa, nx, ny );
3293 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3294 clevel, nlevel, fill_width, cont_color, cont_width,
3304 f2c( u, uu, nx, ny );
3305 f2c( v, vv, nx, ny );
3313 grid1.
nx = nx; grid1.
ny = ny;
3315 f2c( u, uu, nx, ny );
3316 f2c( v, vv, nx, ny );
3324 f2c( xg, xgg, nx, ny );
3325 f2c( yg, ygg, nx, ny );
3326 grid2.
nx = nx; grid2.
ny = ny;
3327 grid2.
xg = xgg; grid2.
yg = ygg;
3328 f2c( u, uu, nx, ny );
3329 f2c( v, vv, nx, ny );
3340 f2c( a, aa, nx, ny );
3341 plimage( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
3351 f2c( a, aa, nx, ny );
3352 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
3360 f2c( a, aa, nx, ny );
3361 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
xform, tr );
3371 grid1.
nx = nx + 1; grid1.
ny = ny + 1;
3373 f2c( a, aa, nx, ny );
3374 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr1, &grid1 );
3384 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
3385 f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
3386 grid2.
nx = nx + 1; grid2.
ny = ny + 1;
3387 grid2.
xg = xgg; grid2.
yg = ygg;
3388 f2c( a, aa, nx, ny );
3389 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr2, &grid2 );
3400 PLINT n_labels,
const PLINT *label_opts,
const char **label,
3401 PLINT n_axes,
const char ** axis_opts,
3408 for ( i = 0; i < nx; i++ )
3409 if ( n_values[i] > ny )
3411 f2c( a, aa, nx, ny );
3413 opt, position, x, y,
3415 bg_color, bb_color, bb_style,
3416 low_cap_color, high_cap_color,
3417 cont_color, cont_width,
3418 n_labels, label_opts, label,
3428 if (!ov.is_scalar_type())
3430 if (ov.is_complex_scalar())
3432 if (ov.is_double_type()||ov.is_single_type()) {
3433 double v=ov.double_value();
3439 if (ov.is_int8_type()||ov.is_int16_type()||
3440 ov.is_int32_type()) {
3441 long v=ov.long_value();
3445 if (ov.is_int64_type()) {
3446 long long v=ov.int64_scalar_value().value();
3451 *val = ov.ulong_value();
3462 if ((v > UINT_MAX)) {
3465 if (val) *val =
static_cast< unsigned int >(v);
3474 return octave_value(
value);
3488 char* cptr = 0;
size_t csize = 0;
int alloc =
SWIG_OLDOBJ;
3492 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3493 if (csize <= size) {
3495 if (csize) memcpy(val, cptr, csize*
sizeof(
char));
3496 if (csize < size) memset(val + csize, 0, (size - csize)*
sizeof(
char));
3513 static int init = 0;
3526 return std::string(carray,carray+size);
3534 for (p = s;
maxlen-- && *p; p++)
3548 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3549 if (val) *val =
static_cast< char >(v);
3559 Specify viewport in absolute coordinates\n\
3563 Alternate routine to plvpor for setting up the viewport. This routine\n\
3564 should be used only if the viewport is required to have a definite\n\
3565 size in millimeters. The routine plgspa is useful for finding out the\n\
3566 size of the current subpage.\n\
3568 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
3570 This function is used in example 10.\n\
3576 plsvpa(xmin, xmax, ymin, ymax)\n\
3580 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
3581 viewport from the left-hand edge of the subpage in millimeters.\n\
3583 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
3584 viewport from the left-hand edge of the subpage in millimeters.\n\
3586 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
3587 viewport from the bottom edge of the subpage in millimeters.\n\
3589 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
3590 from the bottom edge of the subpage in millimeters.\n\
3593 Write text relative to viewport boundaries in 3D plots\n\
3597 Writes text at a specified position relative to the viewport\n\
3598 boundaries. Text may be written inside or outside the viewport, but\n\
3599 is clipped at the subpage boundaries. The reference point of a string\n\
3600 lies along a line passing through the string at half the height of a\n\
3601 capital letter. The position of the reference point along this line\n\
3602 is determined by just, and the position of the reference point\n\
3603 relative to the viewport is set by disp and pos.\n\
3605 Redacted form: plmtex3(side, disp, pos, just, text)\n\
3607 This function is used in example 28.\n\
3613 plmtex3(side, disp, pos, just, text)\n\
3617 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
3618 the side of the viewport along which the text is to be written.\n\
3619 The string should contain one or more of the following characters:\n\
3620 [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
3621 only label the X axis, not both the X and Y axes. x: Label the X\n\
3623 y: Label the Y axis.\n\
3624 z: Label the Z axis.\n\
3625 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
3626 For X it is the axis that starts at y-min. For Y it is the\n\
3627 axis that starts at x-min.\n\
3628 s: Label the secondary axis.\n\
3629 v: Draw the text perpendicular to the axis.\n\
3632 disp (PLFLT, input) : Position of the reference point of string,\n\
3633 measured outwards from the specified viewport edge in units of the\n\
3634 current character height. Use negative disp to write within the\n\
3637 pos (PLFLT, input) : Position of the reference point of string\n\
3638 along the specified edge, expressed as a fraction of the length of\n\
3641 just (PLFLT, input) : Specifies the position of the string relative\n\
3642 to its reference point. If just=0. , the reference point is at\n\
3643 the left and if just=1. , it is at the right of the string. Other\n\
3644 values of just give intermediate justifications.\n\
3646 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3650 Set semitransparent cmap1 RGBA colors.\n\
3654 Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
3655 RGBA vector values. This function also sets the number of cmap1\n\
3656 colors. N.B. Continuous cmap1 colors are indexed with a\n\
3657 floating-point index in the range from 0.0-1.0 which is linearly\n\
3658 transformed (e.g., by plcol1) to an integer index of these RGBA\n\
3659 vectors in the range from 0 to\n\
3660 ncol1-1. So in order for this continuous color model to work\n\
3661 properly, it is the responsibility of the user of plscmap1 to insure\n\
3662 that these RGBA vectors are continuous functions of their integer\n\
3665 Redacted form: plscmap1a(r, g, b, alpha)\n\
3667 This function is used in example 31.\n\
3673 plscmap1a(r, g, b, alpha, ncol1)\n\
3677 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3678 8-bit integers in the range from 0-255) the degree of red in the\n\
3679 color as a continuous function of the integer index of the vector.\n\
3681 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3682 8-bit integers in the range from 0-255) the degree of green in the\n\
3683 color as a continuous function of the integer index of the vector.\n\
3685 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3686 8-bit integers in the range from 0-255) the degree of blue in the\n\
3687 color as a continuous function of the integer index of the vector.\n\
3689 alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
3690 values in the range from 0.0-1.0 where 0.0 corresponds to\n\
3691 completely transparent and 1.0 corresponds to completely opaque)\n\
3692 the alpha transparency of the color as a continuous function of\n\
3693 the integer index of the vector.\n\
3695 ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
3699 Select standard viewport\n\
3703 Selects the largest viewport within the subpage that leaves a standard\n\
3704 margin (left-hand margin of eight character heights, and a margin\n\
3705 around the other three sides of five character heights).\n\
3707 Redacted form: plvsta()\n\
3709 This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
3718 Switch to graphics screen\n\
3722 Sets an interactive device to graphics mode, used in conjunction with\n\
3723 pltext to allow graphics and text to be interspersed. On a device\n\
3724 which supports separate text and graphics windows, this command causes\n\
3725 control to be switched to the graphics window. If already in graphics\n\
3726 mode, this command is ignored. It is also ignored on devices which\n\
3727 only support a single window or use a different method for shifting\n\
3728 focus. See also pltext.\n\
3730 Redacted form: plgra()\n\
3732 This function is used in example 1.\n\
3741 Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
3745 Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
3746 (see the PLplot documentation) index. Overwrites the previous color\n\
3747 value for the given index and, thus, does not result in any additional\n\
3748 allocation of space for colors.\n\
3750 This function is used in example 30.\n\
3756 plscol0a(icol0, r, g, b, alpha)\n\
3760 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
3761 number of colors (which is set by default, by plscmap0n, or even\n\
3764 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3765 degree of red in the color.\n\
3767 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3768 degree of green in the color.\n\
3770 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3771 degree of blue in the color.\n\
3773 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
3777 Set y axis parameters\n\
3781 Identical to plsxax, except that arguments are flags for y axis. See\n\
3782 the description of plsxax for more detail.\n\
3784 Redacted form: plsyax(digmax, digits)\n\
3786 This function is used in examples 1, 14, and 31.\n\
3792 plsyax(digmax, digits)\n\
3796 digmax (PLINT, input) : Variable to set the maximum number of\n\
3797 digits for the y axis. If nonzero, the printed label will be\n\
3798 switched to a floating-point representation when the number of\n\
3799 digits exceeds digmax.\n\
3801 digits (PLINT, input) : Field digits value. Currently, changing\n\
3802 its value here has no effect since it is set only by plbox or\n\
3803 plbox3. However, the user may obtain its value after a call to\n\
3804 either of these functions by calling plgyax.\n\
3807 Returns 8-bit RGB values for given color index from cmap0\n\
3811 Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
3812 PLplot documentation). Values are negative if an invalid color id is\n\
3815 Redacted form: plgcol0(icol0, r, g, b)\n\
3817 This function is used in example 2.\n\
3823 plgcol0(icol0, r, g, b)\n\
3827 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
3829 r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
3832 g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
3835 b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
3839 Set seed for internal random number generator.\n\
3843 Set the seed for the internal random number generator. See plrandd for\n\
3846 Redacted form: plseed(seed)\n\
3848 This function is used in example 21.\n\
3858 seed (unsigned int, input) : Seed for random number generator.\n\
3861 Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
3865 When the implementation is completed this variant of plot3dc (see that\n\
3866 function\'s documentation for more details) should be suitable for the\n\
3867 case where the area of the x, y coordinate grid where z is defined can\n\
3868 be non-rectangular. The implementation is incomplete so the last 4\n\
3869 parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
3870 indexymax; are currently ignored and the functionality is otherwise\n\
3871 identical to that of plot3dc.\n\
3873 Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
3874 indexymin, indexymax)\n\
3877 This function is not used in any example.\n\
3883 plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
3887 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3888 which the function is evaluated.\n\
3890 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3891 which the function is evaluated.\n\
3893 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3894 plot. Should have dimensions of\n\
3898 nx (PLINT, input) : Number of x values at which the function is\n\
3901 ny (PLINT, input) : Number of y values at which the function is\n\
3904 opt (PLINT, input) : Determines the way in which the surface is\n\
3905 represented. To specify more than one option just add the options,\n\
3906 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3907 showing z as a function of x for each value of y[j] .\n\
3908 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3909 for each value of x[i] .\n\
3910 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3911 at which function is defined.\n\
3912 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3913 the z value being plotted. The color is used from the current\n\
3915 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3919 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3920 the borders of the plotted function.\n\
3923 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3926 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3928 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
3929 corresponds to the first x index where z is defined.\n\
3931 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
3932 which corresponds (by convention) to one more than the last x\n\
3933 index value where z is defined.\n\
3935 indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
3936 values which all must be ≥ 0. These values are the first y index\n\
3937 where z is defined for a particular x index in the range from\n\
3938 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
3941 indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
3942 values which all must be ≤ ny. These values correspond (by\n\
3943 convention) to one more than the last y index where z is defined\n\
3944 for a particular x index in the range from indexxmin to indexxmax\n\
3945 - 1. The dimension of indexymax is indexxmax.\n\
3948 Get output file name\n\
3952 Gets the current output file name, if applicable.\n\
3954 Redacted form: plgfnam(fnam)\n\
3956 This function is used in example 31.\n\
3966 fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
3967 (with preallocated length of 80 characters or more) containing the\n\
3975 Specify the window, i.e., the world coordinates of the edges of the\n\
3978 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
3980 This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
3987 plwind(xmin, xmax, ymin, ymax)\n\
3991 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
3994 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
3997 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
4000 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
4004 Set cmap1 colors using a piece-wise linear relationship\n\
4008 Set cmap1 colors using a piece-wise linear relationship between the\n\
4009 cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
4010 (see the PLplot documentation). May be called at any time.\n\
4012 The idea here is to specify a number of control points that define the\n\
4013 mapping between input cmap1 intensity indices and HLS or RGB. Between\n\
4014 these points, linear interpolation is used which gives a smooth\n\
4015 variation of color with intensity index. Any number of control points\n\
4016 may be specified, located at arbitrary positions, although typically 2\n\
4017 - 4 are enough. Another way of stating this is that we are traversing\n\
4018 a given number of lines through HLS or RGB space as we move through\n\
4019 cmap1 intensity indices. The control points at the minimum and\n\
4020 maximum position (0 and 1) must always be specified. By adding more\n\
4021 control points you can get more variation. One good technique for\n\
4022 plotting functions that vary about some expected average is to use an\n\
4023 additional 2 control points in the center (position ~= 0.5) that are\n\
4024 the same lightness as the background (typically white for paper\n\
4025 output, black for crt), and same hue as the boundary control points.\n\
4026 This allows the highs and lows to be very easily distinguished.\n\
4028 Each control point must specify the cmap1 intensity index and the\n\
4029 associated three coordinates in HLS or RGB space. The first point\n\
4030 must correspond to position = 0, and the last to position = 1.\n\
4032 If RGB colors are provided then the interpolation takes place in RGB\n\
4033 space and is trivial. However if HLS colors are provided then, because\n\
4034 of the circular nature of the color wheel for the hue coordinate, the\n\
4035 interpolation could be performed in either direction around the color\n\
4036 wheel. The default behaviour is for the hue to be linearly\n\
4037 interpolated ignoring this circular property of hue. So for example,\n\
4038 the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\
4039 green and cyan. If instead you wish to interpolate the other way\n\
4040 around the color wheel you have two options. You may provide hues\n\
4041 outside the range [0, 360), so by using a hue of -120 for blue or 360\n\
4042 for red the interpolation will proceed via magenta. Alternatively you\n\
4043 can utilise the alt_hue_path variable to reverse the direction of\n\
4044 interpolation if you need to provide hues within the [0-360) range.\n\
4046 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
4047 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
4048 -120]falsegreen-yellow-red-magenta-blue[240\n\
4049 480]falseblue-magenta-red-yellow-green[120\n\
4050 240]truegreen-yellow-red-magenta-blue[240\n\
4051 120]trueblue-magenta-red-yellow-green\n\
4053 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
4054 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
4055 1]magnitudeHLSsaturation[0, 1]magnitude\n\
4057 Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
4060 This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
4066 plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
4070 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
4072 npts (PLINT, input) : number of control points\n\
4074 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
4075 intensity index (0.0-1.0) in ascending order for each control\n\
4078 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
4079 coordinate (H or R) for each control point.\n\
4081 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
4082 coordinate (L or G) for each control point.\n\
4084 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
4085 coordinate (S or B) for each control point.\n\
4087 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
4088 npts - 1 elements), each containing either true to use the reversed\n\
4089 HLS interpolation or false to use the regular HLS interpolation.\n\
4090 (alt_hue_path[i] refers to the interpolation interval between the\n\
4091 i and i + 1 control points). This parameter is not used for RGB\n\
4096 Set the pause (on end-of-page) status\n\
4100 Set the pause (on end-of-page) status.\n\
4102 Redacted form: plspause(pause)\n\
4104 This function is in examples 14,20.\n\
4114 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
4115 end-of-page for those drivers which support this. Otherwise there\n\
4119 Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
4123 Routine for creating a discrete plot legend with a plotted filled box,\n\
4124 line, and/or line of symbols for each annotated legend entry. (See\n\
4125 plcolorbar for similar functionality for creating continuous color\n\
4126 bars.) The arguments of pllegend provide control over the location\n\
4127 and size of the legend as well as the location and characteristics of\n\
4128 the elements (most of which are optional) within that legend. The\n\
4129 resulting legend is clipped at the boundaries of the current subpage.\n\
4130 (N.B. the adopted coordinate system used for some of the parameters is\n\
4131 defined in the documentation of the position parameter.)\n\
4133 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
4134 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
4135 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
4136 test_justification, text_colors, text, box_colors, box_patterns,\n\
4137 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
4138 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
4140 This function is used in examples 4, 26, and 33.\n\
4146 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\
4150 p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
4151 legend width in adopted coordinates. This quantity is calculated\n\
4152 from plot_width, text_offset, ncolumn (possibly modified inside\n\
4153 the routine depending on nlegend and nrow), and the length\n\
4154 (calculated internally) of the longest text string.\n\
4156 p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
4157 legend height in adopted coordinates. This quantity is calculated\n\
4158 from text_scale, text_spacing, and nrow (possibly modified inside\n\
4159 the routine depending on nlegend and nrow).\n\
4161 opt (PLINT, input) : opt contains bits controlling the overall\n\
4162 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
4163 on the left of the legend and the plotted area on the right.\n\
4164 Otherwise, put the text area on the right of the legend and the\n\
4165 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
4166 plot a (semitransparent) background for the legend. If the\n\
4167 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
4168 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
4169 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
4170 plot the resulting array of legend entries in row-major order.\n\
4171 Otherwise, plot the legend entries in column-major order.\n\
4173 position (PLINT, input) : position contains bits which control the\n\
4174 overall position of the legend and the definition of the adopted\n\
4175 coordinates used for positions just like what is done for the\n\
4176 position argument for plcolorbar. However, note that the defaults\n\
4177 for the position bits (see below) are different than the\n\
4178 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
4179 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
4180 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
4181 the 16 possible standard positions (the 4 corners and centers of\n\
4182 the 4 sides for both the inside and outside cases) of the legend\n\
4183 relative to the adopted coordinate system. The corner positions\n\
4184 are specified by the appropriate combination of two of the\n\
4185 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
4186 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
4187 value of one of those bits. The adopted coordinates are\n\
4188 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
4189 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
4190 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
4191 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
4192 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
4193 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
4194 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
4195 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
4197 x (PLFLT, input) : X offset of the legend position in adopted\n\
4198 coordinates from the specified standard position of the legend.\n\
4199 For positive x, the direction of motion away from the standard\n\
4200 position is inward/outward from the standard corner positions or\n\
4201 standard left or right positions if the\n\
4202 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
4203 For the standard top or bottom positions, the direction of motion\n\
4204 is toward positive X.\n\
4206 y (PLFLT, input) : Y offset of the legend position in adopted\n\
4207 coordinates from the specified standard position of the legend.\n\
4208 For positive y, the direction of motion away from the standard\n\
4209 position is inward/outward from the standard corner positions or\n\
4210 standard top or bottom positions if the\n\
4211 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
4212 the standard left or right positions, the direction of motion is\n\
4213 toward positive Y.\n\
4215 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
4216 of the plot area (where the colored boxes, lines, and/or lines of\n\
4217 symbols are drawn) of the legend.\n\
4219 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
4220 legend (PL_LEGEND_BACKGROUND).\n\
4222 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
4223 for the legend (PL_LEGEND_BOUNDING_BOX).\n\
4225 bb_style (PLINT, input) : The pllsty style number for the\n\
4226 bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
4228 nrow (PLINT, input) : The number of rows in the matrix used to\n\
4230 nlegend legend entries. For internal transformations of\n\
4231 nrow, see further remarks under\n\
4234 ncolumn (PLINT, input) : The number of columns in the matrix used\n\
4236 nlegend legend entries. For internal transformations of\n\
4237 ncolumn, see further remarks under\n\
4240 nlegend (PLINT, input) : Number of legend entries. The above\n\
4242 ncolumn values are transformed internally to be consistent with\n\
4243 nlegend. If either\n\
4245 ncolumn is non-positive it is replaced by 1. If the resulting product\n\
4248 ncolumn is less than\n\
4249 nlegend, the smaller of the two (or\n\
4252 ncolumn) is increased so the product is >=\n\
4253 nlegend. Thus, for example, the common\n\
4255 ncolumn = 0 case is transformed internally to\n\
4258 ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
4261 opt_array (PLINT_VECTOR, input) : A vector of\n\
4262 nlegend values of options to control each individual plotted area\n\
4263 corresponding to a legend entry. If the\n\
4264 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
4266 PL_LEGEND_COLOR_BOX,\n\
4267 PL_LEGEND_LINE, and/or\n\
4268 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
4269 entry is plotted with a colored box; a line; and/or a line of\n\
4272 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
4273 area in units of character width.\n\
4275 text_scale (PLFLT, input) : Character height scale for text\n\
4278 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
4279 character height from one legend entry to the next.\n\
4281 text_justification (PLFLT, input) : Justification parameter used\n\
4282 for text justification. The most common values of\n\
4283 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
4284 is left justified, centred, or right justified within the text\n\
4285 area, but other values are allowed as well.\n\
4287 text_colors (PLINT_VECTOR, input) : A vector containing\n\
4288 nlegend cmap0 text colors.\n\
4290 text (PLCHAR_MATRIX, input) : A vector of\n\
4291 nlegend UTF-8 character strings containing the legend annotations.\n\
4293 box_colors (PLINT_VECTOR, input) : A vector containing\n\
4294 nlegend cmap0 colors for the discrete colored boxes (\n\
4295 PL_LEGEND_COLOR_BOX).\n\
4297 box_patterns (PLINT_VECTOR, input) : A vector containing\n\
4298 nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
4299 PL_LEGEND_COLOR_BOX).\n\
4301 box_scales (PLFLT_VECTOR, input) : A vector containing\n\
4302 nlegend scales (units of fraction of character height) for the height\n\
4303 of the discrete colored boxes (\n\
4304 PL_LEGEND_COLOR_BOX).\n\
4306 box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
4307 nlegend line widths for the patterns specified by box_patterns (\n\
4308 PL_LEGEND_COLOR_BOX).\n\
4310 line_colors (PLINT_VECTOR, input) : A vector containing\n\
4311 nlegend cmap0 line colors (\n\
4314 line_styles (PLINT_VECTOR, input) : A vector containing\n\
4315 nlegend line styles (plsty indices) (\n\
4318 line_widths (PLFLT_VECTOR, input) : A vector containing\n\
4319 nlegend line widths (\n\
4322 symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
4323 nlegend cmap0 symbol colors (\n\
4324 PL_LEGEND_SYMBOL).\n\
4326 symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
4327 nlegend scale values for the symbol height (\n\
4328 PL_LEGEND_SYMBOL).\n\
4330 symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
4331 nlegend numbers of symbols to be drawn across the width of the plotted\n\
4333 PL_LEGEND_SYMBOL).\n\
4335 symbols (PLCHAR_MATRIX, input) : A vector of\n\
4336 nlegend UTF-8 character strings containing the legend symbols. (\n\
4337 PL_LEGEND_SYMBOL).\n\
4340 Set number of colors in cmap1\n\
4344 Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
4345 values if this is the first allocation (see the PLplot documentation).\n\
4347 Redacted form: plscmap1n(ncol1)\n\
4349 This function is used in examples 8, 11, 20, and 21.\n\
4359 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
4360 the cmap1 palette. If this number is zero or less, then the value\n\
4361 from the previous call to plscmap1n is used and if there is no\n\
4362 previous call, then a default value is used.\n\
4365 Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
4369 Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
4370 (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
4371 Values are negative if an invalid color id is given.\n\
4373 Redacted form: plgcola(r, g, b)\n\
4375 This function is used in example 30.\n\
4381 plgcol0a(icol0, r, g, b, alpha)\n\
4385 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
4387 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
4388 in the range from 0 to 255.\n\
4390 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
4391 in the range from 0 to 255.\n\
4393 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
4394 in the range from 0 to 255.\n\
4396 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
4397 transparency in the range from (0.0-1.0).\n\
4400 Replays contents of plot buffer to current device/file\n\
4404 Replays contents of plot buffer to current device/file.\n\
4406 Redacted form: plreplot()\n\
4408 This function is used in example 1,20.\n\
4417 Simple routine to write labels\n\
4421 Routine for writing simple labels. Use plmtex for more complex labels.\n\
4423 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
4425 This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
4431 pllab(xlabel, ylabel, tlabel)\n\
4435 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4436 the label for the x axis.\n\
4438 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4439 the label for the y axis.\n\
4441 tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4442 the title of the plot.\n\
4445 Set parameters that define current device-space window\n\
4449 Set relative margin width, aspect ratio, and relative justification\n\
4450 that define current device-space window. If you want to just use the\n\
4451 previous value for any of these, just pass in the magic value\n\
4452 PL_NOTSET. It is unlikely that one should ever need to change the\n\
4453 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
4454 called the default values of mar, jx, and jy are all 0. aspect is set\n\
4455 to a device-specific value.\n\
4457 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
4459 This function is used in example 31.\n\
4465 plsdidev(mar, aspect, jx, jy)\n\
4469 mar (PLFLT, input) : Relative margin width.\n\
4471 aspect (PLFLT, input) : Aspect ratio.\n\
4473 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
4474 the range -0.5 to 0.5.\n\
4476 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
4477 the range -0.5 to 0.5.\n\
4484 Begins a new page. For a file driver, the output file is opened if\n\
4485 necessary. Advancing the page via pleop and plbop is useful when a\n\
4486 page break is desired at a particular point when plotting to subpages.\n\
4487 Another use for pleop and plbop is when plotting pages to different\n\
4488 files, since you can manually set the file name by calling plsfnam\n\
4489 after the call to pleop. (In fact some drivers may only support a\n\
4490 single page per file, making this a necessity.) One way to handle\n\
4491 this case automatically is to page advance via pladv, but enable\n\
4492 familying (see plsfam) with a small limit on the file size so that a\n\
4493 new family member file will be created on each page break.\n\
4495 Redacted form: plbop()\n\
4497 This function is used in examples 2 and 20.\n\
4506 Set cmap0 colors by 8-bit RGB values\n\
4510 Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
4511 documentation). This sets the entire color map -- only as many colors\n\
4512 as specified will be allocated.\n\
4514 Redacted form: plscmap0(r, g, b)\n\
4516 This function is used in examples 2 and 24.\n\
4522 plscmap0(r, g, b, ncol0)\n\
4526 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4527 integers (0-255) representing the degree of red in the color.\n\
4529 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4530 integers (0-255) representing the degree of green in the color.\n\
4532 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4533 integers (0-255) representing the degree of blue in the color.\n\
4535 ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4538 Set the number of subpages in x and y\n\
4542 Set the number of subpages in x and y.\n\
4544 Redacted form: plssub(nx, ny)\n\
4546 This function is examples 1,2,14,21,25,27.\n\
4556 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
4557 of window columns).\n\
4559 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
4563 Set a global coordinate transform function\n\
4567 This function can be used to define a coordinate transformation which\n\
4568 affects all elements drawn within the current plot window. The\n\
4569 coordinate_transform callback function is similar to that provided for\n\
4570 the plmap and plmeridians functions. The coordinate_transform_data\n\
4571 parameter may be used to pass extra data to coordinate_transform.\n\
4573 Redacted form: General: plstransform(coordinate_transform,\n\
4574 coordinate_transform_data)\n\
4577 This function is used in examples 19 and 22.\n\
4583 plstransform(coordinate_transform, coordinate_transform_data)\n\
4587 coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
4588 function that defines the transformation from the input (x, y)\n\
4589 world coordinates to new PLplot world coordinates. If\n\
4590 coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
4591 case), then no transform is applied.\n\
4593 coordinate_transform_data (PLPointer, input) : Optional extra data\n\
4595 coordinate_transform.\n\
4598 Set opaque RGB cmap1 colors values\n\
4602 Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
4603 vector values. This function also sets the number of cmap1 colors.\n\
4604 N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
4605 in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
4606 plcol1) to an integer index of these RGB vectors in the range from 0\n\
4608 ncol1-1. So in order for this continuous color model to work\n\
4609 properly, it is the responsibility of the user of plscmap1 to insure\n\
4610 that these RGB vectors are continuous functions of their integer\n\
4613 Redacted form: plscmap1(r, g, b)\n\
4615 This function is used in example 31.\n\
4621 plscmap1(r, g, b, ncol1)\n\
4625 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4626 8-bit integers in the range from 0-255) the degree of red in the\n\
4627 color as a continuous function of the integer index of the vector.\n\
4629 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4630 8-bit integers in the range from 0-255) the degree of green in the\n\
4631 color as a continuous function of the integer index of the vector.\n\
4633 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4634 8-bit integers in the range from 0-255) the degree of blue in the\n\
4635 color as a continuous function of the integer index of the vector.\n\
4637 ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4640 Configure the transformation between continuous and broken-down time for the current stream\n\
4644 Configure the transformation between continuous and broken-down time\n\
4645 for the current stream. This transformation is used by both plbtime\n\
4648 Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
4649 ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4652 This function is used in example 29.\n\
4658 plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4662 scale (PLFLT, input) : The number of days per continuous time unit.\n\
4663 As a special case, if\n\
4664 scale is 0., then all other arguments are ignored, and the result (the\n\
4665 default used by PLplot) is the equivalent of a call to\n\
4666 plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
4667 That is, for this special case broken-down time is calculated with\n\
4668 the proleptic Gregorian calendar with no leap seconds inserted,\n\
4669 and the continuous time is defined as the number of seconds since\n\
4670 the Unix epoch of 1970-01-01T00:00:00Z.\n\
4672 offset1 (PLFLT, input) : If\n\
4673 ifbtime_offset is true, the parameters\n\
4675 offset2 are completely ignored. Otherwise, the sum of these parameters\n\
4676 (with units in days) specify the epoch of the continuous time\n\
4677 relative to the MJD epoch corresponding to the Gregorian calendar\n\
4678 date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
4679 are used to specify the origin to allow users (by specifying\n\
4680 offset1 as an integer that can be exactly represented by a\n\
4681 floating-point variable and specifying\n\
4682 offset2 as a number in the range from 0. to 1) the chance to minimize\n\
4683 the numerical errors of the continuous time representation.\n\
4685 offset2 (PLFLT, input) : See documentation of\n\
4688 ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
4689 transformation. If the 0x1 bit is set, then the proleptic Julian\n\
4690 calendar is used for broken-down time rather than the proleptic\n\
4691 Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
4692 have been historically used to define UTC are inserted into the\n\
4693 broken-down time. Other possibilities for additional control bits\n\
4694 for ccontrol exist such as making the historical time corrections\n\
4695 in the broken-down time corresponding to ET (ephemeris time) or\n\
4696 making the (slightly non-constant) corrections from international\n\
4697 atomic time (TAI) to what astronomers define as terrestrial time\n\
4698 (TT). But those additional possibilities have not been\n\
4699 implemented yet in the qsastime library (one of the PLplot utility\n\
4702 ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
4703 epoch of the continuous time scale is specified by the user. If\n\
4704 ifbtime_offset is false, then\n\
4706 offset2 are used to specify the epoch, and the following broken-down\n\
4707 time parameters are completely ignored. If\n\
4708 ifbtime_offset is true, then\n\
4710 offset2 are completely ignored, and the following broken-down time\n\
4711 parameters are used to specify the epoch.\n\
4713 year (PLINT, input) : Year of epoch.\n\
4715 month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
4718 day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
4720 hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
4722 min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
4724 sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
4727 Set length of minor ticks\n\
4731 This sets up the length of the minor ticks and the length of the\n\
4732 terminals on error bars. The actual length is the product of the\n\
4733 default length and a scaling factor as for character height.\n\
4735 Redacted form: plsmin(def, scale)\n\
4737 This function is used in example 29.\n\
4743 plsmin(def, scale)\n\
4747 def (PLFLT, input) : The default length of a minor tick in\n\
4748 millimeters, should be set to zero if the default length is to\n\
4749 remain unchanged.\n\
4751 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4752 actual tick length.\n\
4755 Set character size\n\
4759 This sets up the size of all subsequent characters drawn. The actual\n\
4760 height of a character is the product of the default character size and\n\
4761 a scaling factor.\n\
4763 Redacted form: plschr(def, scale)\n\
4765 This function is used in examples 2, 13, 23, and 24.\n\
4771 plschr(def, scale)\n\
4775 def (PLFLT, input) : The default height of a character in\n\
4776 millimeters, should be set to zero if the default height is to\n\
4777 remain unchanged. For rasterized drivers the dx and dy values\n\
4778 specified in plspage are used to convert from mm to pixels (note\n\
4779 the different unit systems used). This dpi aware scaling is not\n\
4780 implemented for all drivers yet.\n\
4782 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4783 actual character height.\n\
4786 Initialize PLplot\n\
4790 Initializing the plotting package. The program prompts for the device\n\
4791 keyword or number of the desired output device. Hitting a RETURN in\n\
4792 response to the prompt is the same as selecting the first device.\n\
4793 plinit will issue no prompt if either the device was specified\n\
4794 previously (via command line flag, the plsetopt function, or the\n\
4795 plsdev function), or if only one device is enabled when PLplot is\n\
4796 installed. If subpages have been specified, the output device is\n\
4797 divided into nx by ny subpages, each of which may be used\n\
4798 independently. If plinit is called again during a program, the\n\
4799 previously opened file will be closed. The subroutine pladv is used\n\
4800 to advance from one subpage to the next.\n\
4802 Redacted form: plinit()\n\
4804 This function is used in all of the examples.\n\
4813 Draw a box with axes, etc\n\
4817 Draws a box around the currently defined viewport, and labels it with\n\
4818 world coordinate values appropriate to the window. Thus plbox should\n\
4819 only be called after defining both viewport and window. The ascii\n\
4820 character strings xopt and yopt specify how the box should be drawn as\n\
4821 described below. If ticks and/or subticks are to be drawn for a\n\
4822 particular axis, the tick intervals and number of subintervals may be\n\
4823 specified explicitly, or they may be defaulted by setting the\n\
4824 appropriate arguments to zero.\n\
4826 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4829 This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
4836 plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4840 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4841 options for the x axis. The string can include any combination of\n\
4842 the following letters (upper or lower case) in any order: a: Draws\n\
4843 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
4845 b: Draws bottom (X) or left (Y) edge of frame.\n\
4846 c: Draws top (X) or right (Y) edge of frame.\n\
4847 d: Plot labels as date / time. Values are assumed to be\n\
4848 seconds since the epoch (as used by gmtime).\n\
4849 f: Always use fixed point numeric labels.\n\
4850 g: Draws a grid at the major tick interval.\n\
4851 h: Draws a grid at the minor tick interval.\n\
4852 i: Inverts tick marks, so they are drawn outwards, rather than\n\
4854 l: Labels axis logarithmically. This only affects the labels,\n\
4855 not the data, and so it is necessary to compute the logarithms\n\
4856 of data points before passing them to any of the drawing\n\
4858 m: Writes numeric labels at major tick intervals in the\n\
4859 unconventional location (above box for X, right of box for Y).\n\
4860 n: Writes numeric labels at major tick intervals in the\n\
4861 conventional location (below box for X, left of box for Y).\n\
4862 o: Use custom labelling function to generate axis label text.\n\
4863 The custom labelling function can be defined with the\n\
4864 plslabelfunc command.\n\
4865 s: Enables subticks between major ticks, only valid if t is\n\
4867 t: Draws major ticks.\n\
4868 u: Exactly like \"b\" except don\'t draw edge line.\n\
4869 w: Exactly like \"c\" except don\'t draw edge line.\n\
4870 x: Exactly like \"t\" (including the side effect of the\n\
4871 numerical labels for the major ticks) except exclude drawing\n\
4872 the major and minor tick marks.\n\
4875 xtick (PLFLT, input) : World coordinate interval between major\n\
4876 ticks on the x axis. If it is set to zero, PLplot automatically\n\
4877 generates a suitable tick interval.\n\
4879 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
4880 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4881 generates a suitable minor tick interval.\n\
4883 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4884 options for the y axis. The string can include any combination of\n\
4885 the letters defined above for xopt, and in addition may contain:\n\
4886 v: Write numeric labels for the y axis parallel to the base of the\n\
4887 graph, rather than parallel to the axis.\n\
4890 ytick (PLFLT, input) : World coordinate interval between major\n\
4891 ticks on the y axis. If it is set to zero, PLplot automatically\n\
4892 generates a suitable tick interval.\n\
4894 nysub (PLINT, input) : Number of subintervals between major y axis\n\
4895 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4896 generates a suitable minor tick interval.\n\
4899 Get parameters that define current device-space window\n\
4903 Get relative margin width, aspect ratio, and relative justification\n\
4904 that define current device-space window. If plsdidev has not been\n\
4905 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
4906 p_jy will all be 0.\n\
4908 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4910 This function is used in example 31.\n\
4916 plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4920 p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4923 p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
4926 p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4927 justification in x.\n\
4929 p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4930 justification in y.\n\
4933 Plot a glyph at the specified points\n\
4937 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
4938 because many[!] more glyphs are accessible with plstring.) The glyph\n\
4939 is specified with a PLplot user string. Note that the user string is\n\
4940 not actually limited to one glyph so it is possible (but not normally\n\
4941 useful) to plot more than one glyph at the specified points with this\n\
4942 function. As with plmtex and plptex, the user string can contain FCI\n\
4943 escapes to determine the font, UTF-8 code to determine the glyph or\n\
4944 else PLplot escapes for Hershey or unicode text to determine the\n\
4947 Redacted form: plstring(x, y, string)\n\
4949 This function is used in examples 4, 21 and 26.\n\
4955 plstring(n, x, y, string)\n\
4959 n (PLINT, input) : Number of points in the x and y vectors.\n\
4961 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4964 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4967 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
4968 the glyph(s) to be plotted at each of the n points.\n\
4971 Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
4975 As per plmapline, however the items are plotted as strings or points\n\
4976 in the same way as plstring.\n\
4978 Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
4979 maxy, plotentries)\n\
4981 This function is not used in any examples.\n\
4987 plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
4991 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
4992 transform the coordinates given in the shapefile into a plot\n\
4993 coordinate system. By using this transform, we can change from a\n\
4994 longitude, latitude coordinate to a polar stereographic project,\n\
4995 for example. Initially, x[0]..[n-1] are the longitudes and\n\
4996 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
4997 mapform(), x[] and y[] should be replaced by the corresponding\n\
4998 plot coordinates. If no transform is desired, mapform can be\n\
4999 replaced by NULL.\n\
5001 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5002 the file name of a set of Shapefile files without the file\n\
5005 string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5008 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
5009 be in the same units as used by the Shapefile. You could use a\n\
5010 very large negative number to plot everything, but you can improve\n\
5011 performance by limiting the area drawn. The units must match those\n\
5012 of the Shapefile projection, which may be for example longitude or\n\
5013 distance. The value of minx must be less than the value of maxx.\n\
5015 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
5016 use a very large number to plot everything, but you can improve\n\
5017 performance by limiting the area drawn.\n\
5019 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
5020 be in the same units as used by the Shapefile. You could use a\n\
5021 very large negative number to plot everything, but you can improve\n\
5022 performance by limiting the area drawn. The units must match those\n\
5023 of the Shapefile projection, which may be for example latitude or\n\
5024 distance. The value of miny must be less than the value of maxy.\n\
5026 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
5027 use a very large number to plot everything, but you can improve\n\
5028 performance by limiting the area drawn.\n\
5030 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
5031 zero-based indices of the Shapefile elements which will be drawn.\n\
5033 plotentries to NULL will plot all elements of the Shapefile.\n\
5035 nplotentries (PLINT, input) : The number of items in\n\
5036 plotentries. Ignored if\n\
5037 plotentries is NULL.\n\
5040 Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
5044 Sets up plotter environment for simple graphs by calling pladv and\n\
5045 setting up viewport and window to sensible default values. plenv0\n\
5046 leaves a standard margin (left-hand margin of eight character heights,\n\
5047 and a margin around the other three sides of five character heights)\n\
5048 around most graphs for axis labels and a title. When these defaults\n\
5049 are not suitable, use the individual routines plvpas, plvpor, or\n\
5050 plvasp for setting up the viewport, plwind for defining the window,\n\
5051 and plbox for drawing the box.\n\
5053 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
5055 This function is used in example 21.\n\
5061 plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
5065 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
5066 world coordinates).\n\
5068 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
5069 world coordinates).\n\
5071 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
5074 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
5077 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
5078 scales will not be set, the user must set up the scale before\n\
5079 calling plenv0 using plsvpa, plvasp or other.\n\
5080 0: the x and y axes are scaled independently to use as much of\n\
5081 the screen as possible.\n\
5082 1: the scales of the x and y axes are made equal.\n\
5083 2: the axis of the x and y axes are made equal, and the plot\n\
5084 box will be square.\n\
5087 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
5088 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
5089 -1: draw box only.\n\
5090 0: draw box, ticks, and numeric tick labels.\n\
5091 1: also draw coordinate axes at x=0 and y=0.\n\
5092 2: also draw a grid at major tick positions in both\n\
5094 3: also draw a grid at minor tick positions in both\n\
5096 10: same as 0 except logarithmic x tick marks. (The x data\n\
5097 have to be converted to logarithms separately.)\n\
5098 11: same as 1 except logarithmic x tick marks. (The x data\n\
5099 have to be converted to logarithms separately.)\n\
5100 12: same as 2 except logarithmic x tick marks. (The x data\n\
5101 have to be converted to logarithms separately.)\n\
5102 13: same as 3 except logarithmic x tick marks. (The x data\n\
5103 have to be converted to logarithms separately.)\n\
5104 20: same as 0 except logarithmic y tick marks. (The y data\n\
5105 have to be converted to logarithms separately.)\n\
5106 21: same as 1 except logarithmic y tick marks. (The y data\n\
5107 have to be converted to logarithms separately.)\n\
5108 22: same as 2 except logarithmic y tick marks. (The y data\n\
5109 have to be converted to logarithms separately.)\n\
5110 23: same as 3 except logarithmic y tick marks. (The y data\n\
5111 have to be converted to logarithms separately.)\n\
5112 30: same as 0 except logarithmic x and y tick marks. (The x\n\
5113 and y data have to be converted to logarithms separately.)\n\
5114 31: same as 1 except logarithmic x and y tick marks. (The x\n\
5115 and y data have to be converted to logarithms separately.)\n\
5116 32: same as 2 except logarithmic x and y tick marks. (The x\n\
5117 and y data have to be converted to logarithms separately.)\n\
5118 33: same as 3 except logarithmic x and y tick marks. (The x\n\
5119 and y data have to be converted to logarithms separately.)\n\
5120 40: same as 0 except date / time x labels.\n\
5121 41: same as 1 except date / time x labels.\n\
5122 42: same as 2 except date / time x labels.\n\
5123 43: same as 3 except date / time x labels.\n\
5124 50: same as 0 except date / time y labels.\n\
5125 51: same as 1 except date / time y labels.\n\
5126 52: same as 2 except date / time y labels.\n\
5127 53: same as 3 except date / time y labels.\n\
5128 60: same as 0 except date / time x and y labels.\n\
5129 61: same as 1 except date / time x and y labels.\n\
5130 62: same as 2 except date / time x and y labels.\n\
5131 63: same as 3 except date / time x and y labels.\n\
5132 70: same as 0 except custom x and y labels.\n\
5133 71: same as 1 except custom x and y labels.\n\
5134 72: same as 2 except custom x and y labels.\n\
5135 73: same as 3 except custom x and y labels.\n\
5138 Configure the transformations required for projecting a 3D surface on a 2D window\n\
5142 Configure the transformations required for projecting a 3D surface on\n\
5143 an existing 2D window. Those transformations (see the PLplot\n\
5144 documentation) are done to a rectangular cuboid enclosing the 3D\n\
5145 surface which has its limits expressed in 3D world coordinates and\n\
5146 also normalized 3D coordinates (used for interpreting the altitude and\n\
5147 azimuth of the viewing angle). The transformations consist of the\n\
5148 linear transform from 3D world coordinates to normalized 3D\n\
5149 coordinates, and the 3D rotation of normalized coordinates required to\n\
5150 align the pole of the new 3D coordinate system with the viewing\n\
5151 direction specified by altitude and azimuth so that x and y of the\n\
5152 surface elements in that transformed coordinate system are the\n\
5153 projection of the 3D surface with given viewing direction on the 2D\n\
5156 The enclosing rectangular cuboid for the surface plot is defined by\n\
5157 xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
5158 mapped into the same rectangular cuboid with normalized 3D coordinate\n\
5159 sizes of basex by basey by height so that xmin maps to -\n\
5160 basex/2, xmax maps to basex/2, ymin maps to -\n\
5161 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
5162 The resulting rectangular cuboid in normalized coordinates is then\n\
5163 viewed by an observer at altitude alt and azimuth az. This routine\n\
5164 must be called before plbox3 or any of the 3D surface plotting\n\
5165 routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
5166 plsurf3dl or plfill3.\n\
5168 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
5169 zmin, zmax, alt, az)\n\
5171 This function is examples 8, 11, 18, and 21.\n\
5177 plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
5181 basex (PLFLT, input) : The normalized x coordinate size of the\n\
5182 rectangular cuboid.\n\
5184 basey (PLFLT, input) : The normalized y coordinate size of the\n\
5185 rectangular cuboid.\n\
5187 height (PLFLT, input) : The normalized z coordinate size of the\n\
5188 rectangular cuboid.\n\
5190 xmin (PLFLT, input) : The minimum x world coordinate of the\n\
5191 rectangular cuboid.\n\
5193 xmax (PLFLT, input) : The maximum x world coordinate of the\n\
5194 rectangular cuboid.\n\
5196 ymin (PLFLT, input) : The minimum y world coordinate of the\n\
5197 rectangular cuboid.\n\
5199 ymax (PLFLT, input) : The maximum y world coordinate of the\n\
5200 rectangular cuboid.\n\
5202 zmin (PLFLT, input) : The minimum z world coordinate of the\n\
5203 rectangular cuboid.\n\
5205 zmax (PLFLT, input) : The maximum z world coordinate of the\n\
5206 rectangular cuboid.\n\
5208 alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
5209 plane of the rectangular cuboid in normalized coordinates.\n\
5211 az (PLFLT, input) : The viewing azimuth in degrees of the\n\
5212 rectangular cuboid in normalized coordinates. When az=0, the\n\
5213 observer is looking face onto the zx plane of the rectangular\n\
5214 cuboid in normalized coordinates, and as az is increased, the\n\
5215 observer moves clockwise around that cuboid when viewed from above\n\
5219 Draw filled polygon\n\
5223 Fills the polygon defined by the n points (\n\
5225 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
5226 style is a solid fill. The routine will automatically close the\n\
5227 polygon between the last and first vertices. If multiple closed\n\
5228 polygons are passed in x and y then plfill will fill in between them.\n\
5230 Redacted form: plfill(x,y)\n\
5232 This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
5242 n (PLINT, input) : Number of vertices in polygon.\n\
5244 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5247 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5251 Magnitude colored plot surface with contour\n\
5255 Aside from dropping the\n\
5256 side functionality this is a more powerful form of plot3d: the surface\n\
5257 mesh can be colored accordingly to the current z value being plotted,\n\
5258 a contour plot can be drawn at the base XY plane, and a curtain can be\n\
5259 drawn between the plotted function border and the base XY plane. The\n\
5260 arguments are identical to those of plmeshc. The only difference\n\
5261 between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
5262 the surface, while plot3dc only draws the surface as viewed from the\n\
5265 Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
5268 This function is used in example 21.\n\
5274 plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
5278 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5279 which the function is evaluated.\n\
5281 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5282 which the function is evaluated.\n\
5284 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5285 plot. Should have dimensions of\n\
5289 nx (PLINT, input) : Number of x values at which function is\n\
5292 ny (PLINT, input) : Number of y values at which function is\n\
5295 opt (PLINT, input) : Determines the way in which the surface is\n\
5296 represented. To specify more than one option just add the options,\n\
5297 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
5298 showing z as a function of x for each value of y[j] .\n\
5299 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5300 for each value of x[i] .\n\
5301 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5302 at which function is defined.\n\
5303 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
5304 the z value being plotted. The color is used from the current\n\
5306 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5310 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5311 the borders of the plotted function.\n\
5314 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
5317 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
5320 Write text relative to viewport boundaries\n\
5324 Writes text at a specified position relative to the viewport\n\
5325 boundaries. Text may be written inside or outside the viewport, but\n\
5326 is clipped at the subpage boundaries. The reference point of a string\n\
5327 lies along a line passing through the string at half the height of a\n\
5328 capital letter. The position of the reference point along this line\n\
5329 is determined by just, and the position of the reference point\n\
5330 relative to the viewport is set by disp and pos.\n\
5332 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
5335 This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
5342 plmtex(side, disp, pos, just, text)\n\
5346 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5347 the side of the viewport along which the text is to be written.\n\
5348 The string must be one of: b: Bottom of viewport, text written\n\
5349 parallel to edge.\n\
5350 bv: Bottom of viewport, text written at right angles to edge.\n\
5351 l: Left of viewport, text written parallel to edge.\n\
5352 lv: Left of viewport, text written at right angles to edge.\n\
5353 r: Right of viewport, text written parallel to edge.\n\
5354 rv: Right of viewport, text written at right angles to edge.\n\
5355 t: Top of viewport, text written parallel to edge.\n\
5356 tv: Top of viewport, text written at right angles to edge.\n\
5359 disp (PLFLT, input) : Position of the reference point of string,\n\
5360 measured outwards from the specified viewport edge in units of the\n\
5361 current character height. Use negative disp to write within the\n\
5364 pos (PLFLT, input) : Position of the reference point of string\n\
5365 along the specified edge, expressed as a fraction of the length of\n\
5368 just (PLFLT, input) : Specifies the position of the string relative\n\
5369 to its reference point. If just=0. , the reference point is at\n\
5370 the left and if just=1. , it is at the right of the string. Other\n\
5371 values of just give intermediate justifications.\n\
5373 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5377 Set arrow style for vector plots\n\
5381 Set the style for the arrow used by plvect to plot vectors.\n\
5383 Redacted form: plsvect(arrowx, arrowy, fill)\n\
5385 This function is used in example 22.\n\
5391 plsvect(arrowx, arrowy, npts, fill)\n\
5395 arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
5396 the x and y points which make up the arrow. The arrow is plotted\n\
5397 by joining these points to form a polygon. The scaling assumes\n\
5398 that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
5399 <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
5400 will be reset to its default.\n\
5402 npts (PLINT, input) : Number of points in the vectors arrowx and\n\
5405 fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
5406 fill is false then the arrow is open.\n\
5409 Get family file parameters\n\
5413 Gets information about current family file, if familying is enabled.\n\
5414 See the PLplot documentation for more information.\n\
5416 Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5418 This function is used in examples 14 and 31.\n\
5424 plgfam(p_fam, p_num, p_bmax)\n\
5428 p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5429 family flag value. If nonzero, familying is enabled for the\n\
5432 p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5433 family file number.\n\
5435 p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5436 file size (in bytes) for a family file.\n\
5439 Random number generator returning a real random number in the range [0,1]\n\
5443 Random number generator returning a real random number in the range\n\
5444 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
5445 / compilers provide their own random number generator, and so this is\n\
5446 provided purely for convenience and to give a consistent random number\n\
5447 generator across all languages supported by PLplot. This is\n\
5448 particularly useful for comparing results from the test suite of\n\
5451 Redacted form: plrandd()\n\
5453 This function is used in examples 17 and 21.\n\
5466 Draws a contour plot of the data in f[\n\
5468 ny], using the nlevel contour levels specified by clevel. Only the\n\
5469 region of the matrix from kx to lx and from ky to ly is plotted out\n\
5470 where all these index ranges are interpreted as one-based for\n\
5471 historical reasons. A transformation routine pointed to by pltr with\n\
5472 a generic pointer pltr_data for additional data required by the\n\
5473 transformation routine is used to map indices within the matrix to the\n\
5474 world coordinates.\n\
5476 Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5477 where (see above discussion) the pltr, pltr_data callback arguments\n\
5478 are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5479 vectors; or xg and yg matrices.\n\
5481 This function is used in examples 9, 14, 16, and 22.\n\
5487 plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5491 f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5493 nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5495 kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5496 kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5497 zero-based for historical backwards-compatibility reasons.\n\
5499 ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5500 ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5501 zero-based for historical backwards-compatibility reasons.\n\
5503 clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5504 which to draw contours.\n\
5506 nlevel (PLINT, input) : Number of contour levels to draw.\n\
5508 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5509 defines the transformation between the zero-based indices of the\n\
5510 matrix f and the world coordinates.For the C case, transformation\n\
5511 functions are provided in the PLplot library: pltr0 for the\n\
5512 identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5513 respectively defined by vectors and matrices. In addition, C\n\
5514 callback routines for the transformation can be supplied by the\n\
5515 user such as the mypltr function in examples/c/x09c.c which\n\
5516 provides a general linear transformation between index coordinates\n\
5517 and world coordinates.For languages other than C you should\n\
5518 consult the PLplot documentation for the details concerning how\n\
5519 PLTRANSFORM_callback arguments are interfaced. However, in\n\
5520 general, a particular pattern of callback-associated arguments\n\
5521 such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5522 yg matrices are respectively interfaced to a linear-transformation\n\
5523 routine similar to the above mypltr function; pltr1; and pltr2.\n\
5524 Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5525 the PLplot documentation) support native language callbacks for\n\
5526 handling index to world-coordinate transformations. Examples of\n\
5527 these various approaches are given in examples/<language>x09*,\n\
5528 examples/<language>x16*, examples/<language>x20*,\n\
5529 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5530 supported languages.\n\
5532 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5533 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5534 that is externally supplied.\n\
5541 This sets up the line style for all lines subsequently drawn. A line\n\
5542 consists of segments in which the pen is alternately down and up. The\n\
5543 lengths of these segments are passed in the vectors mark and space\n\
5544 respectively. The number of mark-space pairs is specified by nms. In\n\
5545 order to return the line style to the default continuous line, plstyl\n\
5546 should be called with nms =0 .(see also pllsty)\n\
5548 Redacted form: plstyl(mark, space)\n\
5550 This function is used in examples 1, 9, and 14.\n\
5556 plstyl(nms, mark, space)\n\
5560 nms (PLINT, input) : The number of mark and space elements in a\n\
5561 line. Thus a simple broken line can be obtained by setting nms=1\n\
5562 . A continuous line is specified by setting nms=0 .\n\
5564 mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
5565 segments during which the pen is down, measured in micrometers.\n\
5567 space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
5568 the segments during which the pen is up, measured in micrometers.\n\
5571 Set the cmap0 palette using the specified cmap0*.pal format file\n\
5575 Set the cmap0 palette using the specified cmap0*.pal format file.\n\
5577 Redacted form: plspal0(filename)\n\
5579 This function is in example 16.\n\
5585 plspal0(filename)\n\
5589 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5590 containing the name of the cmap0*.pal file. If this string is\n\
5591 empty, use the default cmap0*.pal file.\n\
5594 Set the cmap1 palette using the specified cmap1*.pal format file\n\
5598 Set the cmap1 palette using the specified cmap1*.pal format file.\n\
5600 Redacted form: plspal1(filename, interpolate)\n\
5602 This function is used in example 16.\n\
5608 plspal1(filename, interpolate)\n\
5612 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5613 containing the name of the cmap1*.pal file. If this string is\n\
5614 empty, use the default cmap1*.pal file.\n\
5616 interpolate (PLBOOL, input) : If this parameter is true, the\n\
5617 columns containing the intensity index, r, g, b, alpha and\n\
5618 alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
5619 palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
5620 a flag which controls whether the r, g, b data sent to plscmap1la\n\
5621 are interpreted as HLS or RGB.) If this parameter is false, the\n\
5622 intensity index and alt_hue_path columns are ignored and the r, g,\n\
5623 b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
5624 are used instead to set the cmap1 palette directly with a call to\n\
5628 Set current output stream\n\
5632 Sets the number of the current output stream. The stream number\n\
5633 defaults to 0 unless changed by this routine. The first use of this\n\
5634 routine must be followed by a call initializing PLplot (e.g. plstar).\n\
5636 Redacted form: plsstrm(strm)\n\
5638 This function is examples 1,14,20.\n\
5648 strm (PLINT, input) : The current stream number.\n\
5651 Specify viewport using normalized subpage coordinates\n\
5655 Device-independent routine for setting up the viewport. This defines\n\
5656 the viewport in terms of normalized subpage coordinates which run from\n\
5657 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
5658 current subpage. Use the alternate routine plsvpa in order to create\n\
5659 a viewport of a definite size.\n\
5661 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
5663 This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
5664 24, 26, 27, and 31.\n\
5670 plvpor(xmin, xmax, ymin, ymax)\n\
5674 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5675 left-hand edge of the viewport.\n\
5677 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5678 right-hand edge of the viewport.\n\
5680 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5681 bottom edge of the viewport.\n\
5683 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5684 edge of the viewport.\n\
5687 Write text inside the viewport\n\
5691 Writes text at a specified position and inclination within the\n\
5692 viewport. Text is clipped at the viewport boundaries. The reference\n\
5693 point of a string lies along a line passing through the string at half\n\
5694 the height of a capital letter. The position of the reference point\n\
5695 along this line is determined by just, the reference point is placed\n\
5696 at world coordinates (\n\
5698 y) within the viewport. The inclination of the string is specified\n\
5699 in terms of differences of world coordinates making it easy to write\n\
5700 text parallel to a line in a graph.\n\
5702 Redacted form: plptex(x, y, dx, dy, just, text)\n\
5704 This function is used in example 2-4,10,12-14,20,23,24,26.\n\
5710 plptex(x, y, dx, dy, just, text)\n\
5714 x (PLFLT, input) : x coordinate of reference point of string.\n\
5716 y (PLFLT, input) : y coordinate of reference point of string.\n\
5718 dx (PLFLT, input) : Together with dy, this specifies the\n\
5719 inclination of the string. The baseline of the string is parallel\n\
5720 to a line joining (\n\
5728 dy (PLFLT, input) : Together with dx, this specifies the\n\
5729 inclination of the string.\n\
5731 just (PLFLT, input) : Specifies the position of the string relative\n\
5732 to its reference point. If just=0. , the reference point is at\n\
5733 the left and if just=1. , it is at the right of the string. Other\n\
5734 values of just give intermediate justifications.\n\
5736 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5740 Set z axis parameters\n\
5744 Identical to plsxax, except that arguments are flags for z axis. See\n\
5745 the description of plsxax for more detail.\n\
5747 Redacted form: plszax(digmax, digits)\n\
5749 This function is used in example 31.\n\
5755 plszax(digmax, digits)\n\
5759 digmax (PLINT, input) : Variable to set the maximum number of\n\
5760 digits for the z axis. If nonzero, the printed label will be\n\
5761 switched to a floating-point representation when the number of\n\
5762 digits exceeds digmax.\n\
5764 digits (PLINT, input) : Field digits value. Currently, changing\n\
5765 its value here has no effect since it is set only by plbox or\n\
5766 plbox3. However, the user may obtain its value after a call to\n\
5767 either of these functions by calling plgzax.\n\
5770 Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
5774 This variant of plsurf3d (see that function\'s documentation for more\n\
5775 details) should be suitable for the case where the area of the x, y\n\
5776 coordinate grid where z is defined can be non-rectangular. The limits\n\
5777 of that grid are provided by the parameters indexxmin, indexxmax,\n\
5778 indexymin, and indexymax.\n\
5780 Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
5783 This function is used in example 8.\n\
5789 plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
5793 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5794 which the function is evaluated.\n\
5796 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5797 which the function is evaluated.\n\
5799 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5800 plot. Should have dimensions of\n\
5804 nx (PLINT, input) : Number of x values at which function is\n\
5807 ny (PLINT, input) : Number of y values at which function is\n\
5810 opt (PLINT, input) : Determines the way in which the surface is\n\
5811 represented. To specify more than one option just add the options,\n\
5812 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
5813 connecting points at which function is defined.\n\
5814 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5818 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
5822 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5823 the borders of the plotted function.\n\
5824 opt=MAG_COLOR : the surface is colored according to the value\n\
5825 of Z; if MAG_COLOR is not used, then the surface is colored\n\
5826 according to the intensity of the reflected light in the\n\
5827 surface from a light source whose position is set using\n\
5831 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
5834 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
5836 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
5837 corresponds to the first x index where z is defined.\n\
5839 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
5840 which corresponds (by convention) to one more than the last x\n\
5841 index value where z is defined.\n\
5843 indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
5844 values which all must be ≥ 0. These values are the first y index\n\
5845 where z is defined for a particular x index in the range from\n\
5846 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
5849 indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
5850 values which all must be ≤ ny. These values correspond (by\n\
5851 convention) to one more than the last y index where z is defined\n\
5852 for a particular x index in the range from indexxmin to indexxmax\n\
5853 - 1. The dimension of indexymax is indexxmax.\n\
5860 Sets the font used for subsequent text and symbols. For devices that\n\
5861 still use Hershey fonts this routine has no effect unless the Hershey\n\
5862 fonts with extended character set are loaded (see plfontld). For\n\
5863 unicode-aware devices that use system fonts instead of Hershey fonts,\n\
5864 this routine calls the plsfci routine with argument set up\n\
5865 appropriately for the various cases below. However, this method of\n\
5866 specifying the font for unicode-aware devices is deprecated, and the\n\
5867 much more flexible method of calling plsfont directly is recommended\n\
5868 instead (where plsfont provides a user-friendly interface to plsfci),\n\
5870 Redacted form: plfont(ifont)\n\
5872 This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
5882 ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
5883 (simplest and fastest)\n\
5889 Get the cmap1 argument range for continuous color plots\n\
5893 Get the cmap1 argument range for continuous color plots. (Use\n\
5894 plscmap1_range to set the cmap1 argument range.)\n\
5896 Redacted form: plgcmap1_range(min_color, max_color)\n\
5898 This function is currently not used in any example.\n\
5904 plgcmap1_range(min_color, max_color)\n\
5908 min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5909 minimum cmap1 argument.\n\
5911 max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5912 maximum cmap1 argument.\n\
5915 Set the cmap1 argument range for continuous color plots\n\
5919 Set the cmap1 argument range for continuous color plots that\n\
5920 corresponds to the range of data values. The maximum range\n\
5921 corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
5922 the cmap1 argument range that is specified with this routine, the\n\
5923 smaller the subset of the cmap1 color palette that is used to\n\
5924 represent the continuous data being plotted. If\n\
5925 min_color is greater than\n\
5927 max_color is greater than 1.0 or\n\
5928 min_color is less than 0.0 then no change is made to the cmap1\n\
5929 argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
5931 Redacted form: plscmap1_range(min_color, max_color)\n\
5933 This function is currently used in example 33.\n\
5939 plscmap1_range(min_color, max_color)\n\
5943 min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
5944 than 0.0, then 0.0 is used instead.\n\
5946 max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
5947 than 1.0, then 1.0 is used instead.\n\
5950 Draw a circular or elliptical arc\n\
5954 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
5955 semiminor axis b, starting at angle1 and ending at angle2.\n\
5957 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
5961 This function is used in examples 3 and 27.\n\
5967 plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
5971 x (PLFLT, input) : X coordinate of arc center.\n\
5973 y (PLFLT, input) : Y coordinate of arc center.\n\
5975 a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
5977 b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
5979 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
5982 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
5985 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
5988 fill (PLBOOL, input) : Draw a filled arc.\n\
5991 Plot 3-d surface plot\n\
5995 Plots a three-dimensional surface plot within the environment set up\n\
5996 by plw3d. The surface is defined by the matrix z[\n\
5998 ny] , the point z[i][j] being the value of the function at (\n\
6000 y[j]). Note that the points in vectors x and y do not need to be\n\
6001 equally spaced, but must be stored in ascending order. The parameter\n\
6002 opt controls the way in which the surface is displayed. For further\n\
6003 details see the PLplot documentation. The only difference between\n\
6004 plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
6005 while plot3d only draws the surface as viewed from the top.\n\
6007 Redacted form: plot3d(x, y, z, opt, side)\n\
6009 This function is used in examples 11 and 21.\n\
6015 plot3d(x, y, z, nx, ny, opt, side)\n\
6019 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
6020 which the function is evaluated.\n\
6022 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
6023 which the function is evaluated.\n\
6025 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
6026 plot. Should have dimensions of\n\
6030 nx (PLINT, input) : Number of x values at which function is\n\
6033 ny (PLINT, input) : Number of y values at which function is\n\
6036 opt (PLINT, input) : Determines the way in which the surface is\n\
6037 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
6038 function of x for each value of y[j] .\n\
6039 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
6040 for each value of x[i] .\n\
6041 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
6042 at which function is defined.\n\
6045 side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
6046 should be draw on the figure. If side is true sides are drawn,\n\
6047 otherwise no sides are drawn.\n\
6050 Set area line fill pattern\n\
6054 Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
6055 The pattern consists of 1 or 2 sets of parallel lines with specified\n\
6056 inclinations and spacings. The arguments to this routine are the\n\
6057 number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
6058 elements) specifying the inclinations in tenths of a degree and the\n\
6059 spacing in micrometers. (See also plpsty)\n\
6061 Redacted form: General: plpat(inc, del)\n\
6064 This function is used in example 15.\n\
6070 plpat(nlin, inc, del)\n\
6074 nlin (PLINT, input) : Number of sets of lines making up the\n\
6075 pattern, either 1 or 2.\n\
6077 inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
6078 inclination in tenths of a degree. (Should be between -900 and\n\
6081 del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
6082 spacing in micrometers between the lines making up the pattern.\n\
6085 Get x axis parameters\n\
6089 Returns current values of the p_digmax and p_digits flags for the x\n\
6090 axis. p_digits is updated after the plot is drawn, so this routine\n\
6091 should only be called after the call to plbox (or plbox3) is complete.\n\
6092 See the PLplot documentation for more information.\n\
6094 Redacted form: plgxax(p_digmax, p_digits)\n\
6096 This function is used in example 31.\n\
6102 plgxax(p_digmax, p_digits)\n\
6106 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6107 number of digits for the x axis. If nonzero, the printed label\n\
6108 has been switched to a floating-point representation when the\n\
6109 number of digits exceeds this value.\n\
6111 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
6112 number of digits for the numeric labels (x axis) from the last\n\
6116 Draw filled polygon in 3D\n\
6120 Fills the 3D polygon defined by the n points in the x, y, and z\n\
6121 vectors using the pattern defined by plpsty or plpat. The routine\n\
6122 will automatically close the polygon between the last and first\n\
6123 vertices. If multiple closed polygons are passed in x, y, and z then\n\
6124 plfill3 will fill in between them.\n\
6126 Redacted form: General: plfill3(x, y, z)\n\
6129 This function is used in example 15.\n\
6135 plfill3(n, x, y, z)\n\
6139 n (PLINT, input) : Number of vertices in polygon.\n\
6141 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6144 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6147 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
6155 Sets the color index for cmap0 (see the PLplot documentation).\n\
6157 Redacted form: plcol0(icol0)\n\
6159 This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6169 icol0 (PLINT, input) : Integer representing the color. The\n\
6170 defaults at present are (these may change):\n\
6171 0 black (default background)\n\
6172 1 red (default foreground)\n\
6188 Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6189 change an individual color in the cmap0 color palette.\n\
6192 Draw text at points defined by Shapefile data in world coordinates\n\
6196 As per plmapline, however the items are plotted as text in the same\n\
6199 Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
6200 miny, maxy, plotentry)\n\
6202 This function is used in example 19.\n\
6208 plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
6212 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6213 transform the coordinates given in the shapefile into a plot\n\
6214 coordinate system. By using this transform, we can change from a\n\
6215 longitude, latitude coordinate to a polar stereographic project,\n\
6216 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6217 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6218 mapform(), x[] and y[] should be replaced by the corresponding\n\
6219 plot coordinates. If no transform is desired, mapform can be\n\
6220 replaced by NULL.\n\
6222 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6223 the file name of a set of Shapefile files without the file\n\
6226 dx (PLFLT, input) : Used to define the slope of the texts which is\n\
6229 dy (PLFLT, input) : Used to define the slope of the texts which is\n\
6232 just (PLFLT, input) : Set the justification of the text. The value\n\
6233 given will be the fraction of the distance along the string that\n\
6234 sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
6235 centralized text and 1.0 gives right aligned text.\n\
6237 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
6239 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6240 be in the same units as used by the Shapefile. You could use a\n\
6241 very large negative number to plot everything, but you can improve\n\
6242 performance by limiting the area drawn. The units must match those\n\
6243 of the Shapefile projection, which may be for example longitude or\n\
6244 distance. The value of minx must be less than the value of maxx.\n\
6246 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6247 use a very large number to plot everything, but you can improve\n\
6248 performance by limiting the area drawn.\n\
6250 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6251 be in the same units as used by the Shapefile. You could use a\n\
6252 very large negative number to plot everything, but you can improve\n\
6253 performance by limiting the area drawn. The units must match those\n\
6254 of the Shapefile projection, which may be for example latitude or\n\
6255 distance. The value of miny must be less than the value of maxy.\n\
6257 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6258 use a very large number to plot everything, but you can improve\n\
6259 performance by limiting the area drawn.\n\
6261 plotentry (PLINT, input) : An integer indicating which text string\n\
6262 of the Shapefile (zero indexed) will be drawn.\n\
6265 Draw a line between two points\n\
6269 Joins the point (\n\
6275 Redacted form: pljoin(x1,y1,x2,y2)\n\
6277 This function is used in examples 3 and 14.\n\
6283 pljoin(x1, y1, x2, y2)\n\
6287 x1 (PLFLT, input) : x coordinate of first point.\n\
6289 y1 (PLFLT, input) : y coordinate of first point.\n\
6291 x2 (PLFLT, input) : x coordinate of second point.\n\
6293 y2 (PLFLT, input) : y coordinate of second point.\n\
6300 Sets the color for cmap1 (see the PLplot documentation).\n\
6302 Redacted form: plcol1(col1)\n\
6304 This function is used in examples 12 and 21.\n\
6314 col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6315 is mapped to color using the continuous cmap1 palette which by\n\
6316 default ranges from blue to the background color to red. The\n\
6317 cmap1 palette can also be straightforwardly changed by the user\n\
6318 with plscmap1 or plscmap1l.\n\
6325 Set integer plot orientation parameter. This function is identical to\n\
6326 plsdiori except for the type of the argument, and should be used in\n\
6327 the same way. See the documentation of plsdiori for details.\n\
6329 Redacted form: plsori(ori)\n\
6331 This function is used in example 3.\n\
6341 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
6342 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
6346 Calculate continuous time from broken-down time for the current stream\n\
6350 Calculate continuous time, ctime, from broken-down time for the\n\
6351 current stream. The broken-down\n\
6352 time is specified by the following parameters: year, month, day, hour,\n\
6353 min, and sec. This function is the inverse of plbtime.\n\
6355 The PLplot definition of broken-down time is a calendar time that\n\
6356 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6357 responsibility to apply those offsets (if so desired) before using the\n\
6358 PLplot time API. By default broken-down time is defined using the\n\
6359 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6360 continuous time is defined as the number of seconds since the Unix\n\
6361 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6362 broken-down and continuous time are possible, see plconfigtime which\n\
6363 specifies that transformation for the current stream.\n\
6365 Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6369 This function is used in example 29.\n\
6375 plctime(year, month, day, hour, min, sec, ctime)\n\
6379 year (PLINT, input) : Input year.\n\
6381 month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6384 day (PLINT, input) : Input day in range from 1 to 31.\n\
6386 hour (PLINT, input) : Input hour in range from 0 to 23\n\
6388 min (PLINT, input) : Input minute in range from 0 to 59.\n\
6390 sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6392 ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6393 time calculated from the broken-down time specified by the\n\
6394 previous parameters.\n\
6397 Plot continental outline or shapefile data in world coordinates\n\
6401 Plots continental outlines or shapefile data in world coordinates. A\n\
6402 demonstration of how to use this function to create different\n\
6403 projections can be found in examples/c/x19c. PLplot is provided with\n\
6404 basic coastal outlines and USA state borders. To use the map\n\
6405 functionality PLplot must be compiled with the shapelib library.\n\
6406 Shapefiles have become a popular standard for geographical data and\n\
6407 data in this format can be easily found from a number of online\n\
6408 sources. Shapefile data is actually provided as three or more files\n\
6409 with the same filename, but different extensions. The .shp and .shx\n\
6410 files are required for plotting Shapefile data with PLplot.\n\
6412 PLplot currently supports the point, multipoint, polyline and polygon\n\
6413 objects within shapefiles. However holes in polygons are not\n\
6414 supported. When plmap is used the type of object is derived from the\n\
6415 shapefile, if you wish to override the type then use one of the other\n\
6416 plmap variants. The built in maps have line data only.\n\
6418 Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
6420 This function is used in example 19.\n\
6426 plmap(mapform, name, minx, maxx, miny, maxy)\n\
6430 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6431 transform the original map data coordinates to a new coordinate\n\
6432 system. The PLplot-supplied map data is provided as latitudes and\n\
6433 longitudes; other Shapefile data may be provided in other\n\
6434 coordinate systems as can be found in their .prj plain text files.\n\
6435 For example, by using this transform we can change from a\n\
6436 longitude, latitude coordinate to a polar stereographic\n\
6437 projection. Initially, x[0]..[n-1] are the original x coordinates\n\
6438 (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
6439 corresponding y coordinates (latitudes for the PLplot supplied\n\
6440 data). After the call to mapform(), x[] and y[] should be\n\
6441 replaced by the corresponding plot coordinates. If no transform is\n\
6442 desired, mapform can be replaced by NULL.\n\
6444 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6445 the type of map plotted. This is either one of the PLplot built-in\n\
6446 maps or the file name of a set of Shapefile files without the file\n\
6447 extensions. For the PLplot built-in maps the possible values are:\n\
6448 \"globe\" -- continental outlines\n\
6449 \"usa\" -- USA and state boundaries\n\
6450 \"cglobe\" -- continental outlines and countries\n\
6451 \"usaglobe\" -- USA, state boundaries and continental outlines\n\
6454 minx (PLFLT, input) : The minimum x value of map elements to be\n\
6455 drawn. The units must match the shapefile (built in maps are\n\
6456 degrees lat/lon). Objects in the file which do not encroach on the\n\
6457 box defined by minx, maxx, miny, maxy will not be rendered. But\n\
6458 note this is simply an optimisation, not a clipping so for objects\n\
6459 with some points inside the box and some points outside the box\n\
6460 all the points will be rendered. These parameters also define\n\
6461 latitude and longitude wrapping for shapefiles using these units.\n\
6462 Longitude points will be wrapped by integer multiples of 360\n\
6463 degrees to place them in the box. This allows the same data to be\n\
6464 used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
6465 you plot from -180-540 you will get two cycles of data drawn. The\n\
6466 value of minx must be less than the value of maxx. Passing in a\n\
6467 nan, max/-max floating point number or +/-infinity will case the\n\
6468 bounding box from the shapefile to be used.\n\
6470 maxx (PLFLT, input) : The maximum x value of map elements to be\n\
6471 drawn - see minx.\n\
6473 miny (PLFLT, input) : The minimum y value of map elements to be\n\
6474 drawn - see minx.\n\
6476 maxy (PLFLT, input) : The maximum y value of map elements to be\n\
6477 drawn - see minx.\n\
6480 Calculate broken-down time from continuous time for the current stream\n\
6484 Calculate broken-down time; year, month, day, hour, min, sec; from\n\
6485 continuous time, ctime for the current stream. This function is the\n\
6486 inverse of plctime.\n\
6488 The PLplot definition of broken-down time is a calendar time that\n\
6489 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6490 responsibility to apply those offsets (if so desired) before using the\n\
6491 PLplot time API. By default broken-down time is defined using the\n\
6492 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6493 continuous time is defined as the number of seconds since the Unix\n\
6494 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6495 broken-down and continuous time are possible, see plconfigtime.\n\
6497 Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
6501 This function is used in example 29.\n\
6507 plbtime(year, month, day, hour, min, sec, ctime)\n\
6511 year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
6512 positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
6513 non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
6516 month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
6517 the year in the range from 0 (January) to 11 (December).\n\
6519 day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
6520 month in the range from 1 to 31.\n\
6522 hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
6523 day in the range from 0 to 23.\n\
6525 min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
6526 hour in the range from 0 to 59\n\
6528 sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
6529 minute in range from 0. to 60.\n\
6531 ctime (PLFLT, input) : Continuous time from which the broken-down\n\
6532 time is calculated.\n\
6535 Get current stream number\n\
6539 Gets the number of the current output stream. See also plsstrm.\n\
6541 Redacted form: plgstrm(p_strm)\n\
6543 This function is used in example 1,20.\n\
6553 p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6557 Draw a line in 3 space\n\
6561 Draws line in 3 space defined by n points in x, y, and z. You must\n\
6562 first set up the viewport, the 2d viewing window (in world\n\
6563 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
6566 Redacted form: plline3(x, y, z)\n\
6568 This function is used in example 18.\n\
6574 plline3(n, x, y, z)\n\
6578 n (PLINT, input) : Number of points defining line.\n\
6580 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6583 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6586 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
6590 Load Hershey fonts\n\
6594 Loads the Hershey fonts used for text and symbols. This routine may\n\
6595 be called before or after initializing PLplot. If not explicitly\n\
6596 called before PLplot initialization, then by default that\n\
6597 initialization loads Hershey fonts with the extended character set.\n\
6598 This routine only has a practical effect for devices that still use\n\
6599 Hershey fonts (as opposed to modern devices that use unicode-aware\n\
6600 system fonts instead of Hershey fonts).\n\
6602 Redacted form: plfontld(fnt)\n\
6604 This function is used in examples 1 and 7.\n\
6614 fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
6615 A zero value specifies Hershey fonts with the standard character\n\
6616 set and a non-zero value (the default assumed if plfontld is never\n\
6617 called) specifies Hershey fonts with the extended character set.\n\
6620 Set any command-line option\n\
6624 Set any command-line option internally from a program before it\n\
6625 invokes plinit. opt is the name of the command-line option and optarg\n\
6626 is the corresponding command-line option argument.\n\
6628 This function returns 0 on success.\n\
6630 Redacted form: plsetopt(opt, optarg)\n\
6632 This function is used in example 14.\n\
6638 PLINT plsetopt(opt, optarg)\n\
6642 opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6643 the command-line option.\n\
6645 optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
6646 containing the argument of the command-line option.\n\
6649 Plot all or a subset of Shapefile data using lines in world coordinates\n\
6653 Plot all or a subset of Shapefile data using lines in world\n\
6654 coordinates. Our 19th standard example demonstrates how to use this\n\
6655 function. This function plots data from a Shapefile using lines as in\n\
6656 plmap, however it also has the option of also only drawing specified\n\
6657 elements from the Shapefile. The vector of indices of the required\n\
6658 elements are passed as a function argument. The Shapefile data should\n\
6659 include a metadata file (extension.dbf) listing all items within the\n\
6660 Shapefile. This file can be opened by most popular spreadsheet\n\
6661 programs and can be used to decide which indices to pass to this\n\
6664 Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
6667 This function is used in example 19.\n\
6673 plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6677 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6678 transform the coordinates given in the shapefile into a plot\n\
6679 coordinate system. By using this transform, we can change from a\n\
6680 longitude, latitude coordinate to a polar stereographic project,\n\
6681 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6682 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6683 mapform(), x[] and y[] should be replaced by the corresponding\n\
6684 plot coordinates. If no transform is desired, mapform can be\n\
6685 replaced by NULL.\n\
6687 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6688 the file name of a set of Shapefile files without the file\n\
6691 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6692 be in the same units as used by the Shapefile. You could use a\n\
6693 very large negative number to plot everything, but you can improve\n\
6694 performance by limiting the area drawn. The units must match those\n\
6695 of the Shapefile projection, which may be for example longitude or\n\
6696 distance. The value of minx must be less than the value of maxx.\n\
6698 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6699 use a very large number to plot everything, but you can improve\n\
6700 performance by limiting the area drawn.\n\
6702 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6703 be in the same units as used by the Shapefile. You could use a\n\
6704 very large negative number to plot everything, but you can improve\n\
6705 performance by limiting the area drawn. The units must match those\n\
6706 of the Shapefile projection, which may be for example latitude or\n\
6707 distance. The value of miny must be less than the value of maxy.\n\
6709 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6710 use a very large number to plot everything, but you can improve\n\
6711 performance by limiting the area drawn.\n\
6713 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6714 zero-based indices of the Shapefile elements which will be drawn.\n\
6716 plotentries to NULL will plot all elements of the Shapefile.\n\
6718 nplotentries (PLINT, input) : The number of items in\n\
6719 plotentries. Ignored if\n\
6720 plotentries is NULL.\n\
6723 Used to globally turn color output on/off\n\
6727 Used to globally turn color output on/off for those drivers/devices\n\
6730 Redacted form: plscolor(color)\n\
6732 This function is used in example 31.\n\
6742 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6743 turned off. If non-zero, color is turned on.\n\
6746 Wait for graphics input event and translate to world coordinates.\n\
6750 Wait for graphics input event and translate to world coordinates.\n\
6751 Returns 0 if no translation to world coordinates is possible.\n\
6753 This function returns 1 on success and 0 if no translation to world\n\
6754 coordinates is possible.\n\
6756 Redacted form: plGetCursor(gin)\n\
6758 This function is used in examples 1 and 20.\n\
6764 PLINT plGetCursor(gin)\n\
6768 gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
6769 which will contain the output. The structure is not allocated by\n\
6770 the routine and must exist before the function is called.\n\
6773 Get the current device (keyword) name\n\
6777 Get the current device (keyword) name. Note: you must have allocated\n\
6778 space for this (80 characters is safe).\n\
6780 Redacted form: plgdev(p_dev)\n\
6782 This function is used in example 14.\n\
6792 p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
6793 (with preallocated length of 80 characters or more) containing the\n\
6794 device (keyword) name.\n\
6797 Add a point to a strip chart\n\
6801 Add a point to a given pen of a given strip chart. There is no need\n\
6802 for all pens to have the same number of points or to be equally\n\
6803 sampled in the x coordinate. Allocates memory and rescales as\n\
6806 Redacted form: plstripa(id, pen, x, y)\n\
6808 This function is used in example 17.\n\
6814 plstripa(id, pen, x, y)\n\
6818 id (PLINT, input) : Identification number of the strip chart (set\n\
6821 pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
6823 x (PLFLT, input) : X coordinate of point to plot.\n\
6825 y (PLFLT, input) : Y coordinate of point to plot.\n\
6828 Create a 4-pen strip chart\n\
6832 Create a 4-pen strip chart, to be used afterwards by plstripa\n\
6834 Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
6835 ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
6836 styline, legline, labx, laby, labz)\n\
6839 This function is used in example 17.\n\
6845 plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
6849 id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
6850 number of the strip chart to use on plstripa and plstripd.\n\
6852 xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6853 the x-axis specification as in plbox.\n\
6855 yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6856 the y-axis specification as in plbox.\n\
6858 xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6859 change as data are added.\n\
6861 xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6862 change as data are added.\n\
6864 xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
6865 is multiplied by the factor (1 +\n\
6868 ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6869 change as data are added.\n\
6871 ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6872 change as data are added.\n\
6874 xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
6876 ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
6878 y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
6879 true, otherwise not.\n\
6881 acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
6882 otherwise slide display.\n\
6884 colbox (PLINT, input) : Plot box color index (cmap0).\n\
6886 collab (PLINT, input) : Legend color index (cmap0).\n\
6888 colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
6889 indices for the 4 pens.\n\
6891 styline (PLINT_VECTOR, input) : A vector containing the line style\n\
6892 indices for the 4 pens.\n\
6894 legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
6895 strings containing legends for the 4 pens.\n\
6897 labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6898 the label for the x axis.\n\
6900 laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6901 the label for the y axis.\n\
6903 labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6907 Deletes and releases memory used by a strip chart\n\
6911 Deletes and releases memory used by a strip chart.\n\
6913 Redacted form: plstripd(id)\n\
6915 This function is used in example 17.\n\
6925 id (PLINT, input) : Identification number of strip chart to delete.\n\
6928 Specify viewport using coordinates and aspect ratio\n\
6932 Device-independent routine for setting up the viewport. The viewport\n\
6933 is chosen to be the largest with the given aspect ratio that fits\n\
6934 within the specified region (in terms of normalized subpage\n\
6935 coordinates). This routine is functionally equivalent to plvpor when\n\
6936 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
6937 routine reserves no extra space at the edges for labels.\n\
6939 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6941 This function is used in example 9.\n\
6947 plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6951 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
6952 left-hand edge of the viewport.\n\
6954 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
6955 right-hand edge of the viewport.\n\
6957 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
6958 bottom edge of the viewport.\n\
6960 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
6961 edge of the viewport.\n\
6963 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
6967 Assign a function to use for generating custom axis labels\n\
6971 This function allows a user to provide their own function to provide\n\
6972 axis label text. The user function is given the numeric value for a\n\
6973 point on an axis and returns a string label to correspond with that\n\
6974 value. Custom axis labels can be enabled by passing appropriate\n\
6975 arguments to plenv, plbox, plbox3 and similar functions.\n\
6977 This function is used in example 19.\n\
6983 plslabelfunc(label_func, label_data)\n\
6987 label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
6988 label function. In order to reset to the default labelling, set\n\
6989 this to NULL. The labelling function parameters are, in order:\n\
6990 axis: This indicates which axis a label is being requested for.\n\
6991 The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
6993 value: This is the value along the axis which is being labelled.\n\
6995 label_text: The string representation of the label value.\n\
6997 length: The maximum length in characters allowed for label_text.\n\
7000 label_data (PLPointer, input) : This parameter may be used to pass\n\
7001 data to the label_func function.\n\
7004 Set length of major ticks\n\
7008 This sets up the length of the major ticks. The actual length is the\n\
7009 product of the default length and a scaling factor as for character\n\
7012 Redacted form: plsmaj(def, scale)\n\
7014 This function is used in example 29.\n\
7020 plsmaj(def, scale)\n\
7024 def (PLFLT, input) : The default length of a major tick in\n\
7025 millimeters, should be set to zero if the default length is to\n\
7026 remain unchanged.\n\
7028 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
7029 actual tick length.\n\
7032 Get the current library version number\n\
7036 Get the current library version number. Note: you must have allocated\n\
7037 space for this (80 characters is safe).\n\
7039 Redacted form: plgver(p_ver)\n\
7041 This function is used in example 1.\n\
7051 p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
7052 (with preallocated length of 80 characters or more) containing the\n\
7053 PLplot version number.\n\
7056 Set format of numerical label for contours\n\
7060 Set format of numerical label for contours.\n\
7062 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
7064 This function is used example 9.\n\
7070 pl_setcontlabelformat(lexp, sigdig)\n\
7074 lexp (PLINT, input) : If the contour numerical label is greater\n\
7075 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
7076 format is used. Default value of lexp is 4.\n\
7078 sigdig (PLINT, input) : Number of significant digits. Default\n\
7082 Parse command-line arguments\n\
7086 Parse command-line arguments.\n\
7088 plparseopts removes all recognized flags (decreasing argc\n\
7089 accordingly), so that invalid input may be readily detected. It can\n\
7090 also be used to process user command line flags. The user can merge\n\
7091 an option table of type PLOptionTable into the internal option table\n\
7092 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
7093 the external table(s) be parsed by calling plClearOpts before\n\
7096 The default action taken by plparseopts is as follows:\n\
7097 Returns with an error if an unrecognized option or badly formed\n\
7098 option-value pair are encountered.\n\
7099 Returns immediately (return code 0) when the first non-option command\n\
7100 line argument is found.\n\
7101 Returns with the return code of the option handler, if one was called.\n\
7103 Deletes command line arguments from argv list as they are found, and\n\
7104 decrements argc accordingly.\n\
7105 Does not show \"invisible\" options in usage or help messages.\n\
7106 Assumes the program name is contained in argv[0].\n\
7108 These behaviors may be controlled through the\n\
7111 Redacted form: General: plparseopts(argv, mode)\n\
7114 This function is used in all of the examples.\n\
7120 PLINT plparseopts(p_argc, argv, mode)\n\
7124 p_argc (int *, input/output) : Number of arguments.\n\
7126 argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
7127 strings containing *p_argc command-line arguments.\n\
7129 mode (PLINT, input) : Parsing mode with the following\n\
7130 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
7131 and all error messages enabled, including program exit when an\n\
7132 error occurs. Anything on the command line that isn\'t recognized\n\
7133 as a valid option or option argument is flagged as an error.\n\
7134 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
7136 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
7138 PL_PARSE_SHOWALL (8) -- Show invisible options\n\
7139 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
7140 pointer to the program name.\n\
7141 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
7142 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
7143 unrecognized arguments.\n\
7150 Initializing the plotting package. The program prompts for the device\n\
7151 keyword or number of the desired output device. Hitting a RETURN in\n\
7152 response to the prompt is the same as selecting the first device. If\n\
7153 only one device is enabled when PLplot is installed, plstar will issue\n\
7154 no prompt. The output device is divided into nx by ny subpages, each\n\
7155 of which may be used independently. The subroutine pladv is used to\n\
7156 advance from one subpage to the next.\n\
7158 Redacted form: plstar(nx, ny)\n\
7160 This function is used in example 1.\n\
7170 nx (PLINT, input) : Number of subpages to divide output page in the\n\
7173 ny (PLINT, input) : Number of subpages to divide output page in the\n\
7177 Get FCI (font characterization integer)\n\
7181 Gets information about the current font using the FCI approach. See\n\
7182 the PLplot documentation for more information.\n\
7184 Redacted form: plgfci(p_fci)\n\
7186 This function is used in example 23.\n\
7196 p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
7200 Set family file parameters\n\
7204 Sets variables dealing with output file familying. Does nothing if\n\
7205 familying not supported by the driver. This routine, if used, must be\n\
7206 called before initializing PLplot. See the PLplot documentation for\n\
7207 more information.\n\
7209 Redacted form: plsfam(fam, num, bmax)\n\
7211 This function is used in examples 14 and 31.\n\
7217 plsfam(fam, num, bmax)\n\
7221 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
7224 num (PLINT, input) : Current family file number.\n\
7226 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
7230 Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
7234 This is a variant of plscmap1l that supports alpha channel\n\
7235 transparency. It sets cmap1 colors using a piece-wise linear\n\
7236 relationship between cmap1 intensity index (0.0-1.0) and position in\n\
7237 HLS or RGB color space (see the PLplot documentation) with alpha\n\
7238 transparency value (0.0-1.0). It may be called at any time.\n\
7240 Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
7241 alpha, alt_hue_path)\n\
7243 This function is used in example 30.\n\
7249 plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
7253 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
7255 npts (PLINT, input) : number of control points.\n\
7257 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
7258 intensity index (0.0-1.0) in ascending order for each control\n\
7261 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
7262 coordinate (H or R) for each control point.\n\
7264 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
7265 coordinate (L or G) for each control point.\n\
7267 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
7268 coordinate (S or B) for each control point.\n\
7270 alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
7271 transparency value (0.0-1.0) for each control point.\n\
7273 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
7274 npts - 1 elements) containing the alternative interpolation method\n\
7275 Boolean value for each control point interval. (alt_hue_path[i]\n\
7276 refers to the interpolation interval between the i and i + 1\n\
7280 Set page parameters\n\
7284 Sets the page configuration (optional). If an individual parameter is\n\
7285 zero then that parameter value is not updated. Not all parameters are\n\
7286 recognized by all drivers and the interpretation is device-dependent.\n\
7287 The X-window driver uses the length and offset parameters to determine\n\
7288 the window size and location. The length and offset values are\n\
7289 expressed in units that are specific to the current driver. For\n\
7290 instance: screen drivers will usually interpret them as number of\n\
7291 pixels, whereas printer drivers will usually use mm.\n\
7293 This routine, if used, must be called before initializing PLplot. It\n\
7294 may be called at later times for interactive drivers to change only\n\
7295 the dpi for subsequent redraws which you can force via a call to\n\
7296 plreplot. If this function is not called then the page size defaults\n\
7297 to landscape A4 for drivers which use real world page sizes and 744\n\
7298 pixels wide by 538 pixels high for raster drivers. The default value\n\
7299 for dx and dy is 90 pixels per inch for raster drivers.\n\
7303 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
7305 This function is used in examples 14 and 31.\n\
7311 plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
7315 xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
7316 by raster drivers, ignored by drivers which use \"real world\" units\n\
7319 yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
7320 by raster drivers, ignored by drivers which use \"real world\" units\n\
7323 xleng (PLINT, input) : Page length, x.\n\
7325 yleng (PLINT, input) : Page length, y.\n\
7327 xoff (PLINT, input) : Page offset, x.\n\
7329 yoff (PLINT, input) : Page offset, y.\n\
7332 Set precision in numeric labels\n\
7336 Sets the number of places after the decimal point in numeric labels.\n\
7338 Redacted form: plprec(setp, prec)\n\
7340 This function is used in example 29.\n\
7346 plprec(setp, prec)\n\
7350 setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7351 automatically determines the number of places to use after the\n\
7352 decimal point in numeric labels (like those used to label axes).\n\
7353 If setp is 1 then prec sets the number of places.\n\
7355 prec (PLINT, input) : The number of characters to draw after the\n\
7356 decimal point in numeric labels.\n\
7359 Copy state parameters from the reference stream to the current stream\n\
7363 Copies state parameters from the reference stream to the current\n\
7364 stream. Tell driver interface to map device coordinates unless flags\n\
7367 This function is used for making save files of selected plots (e.g.\n\
7368 from the TK driver). After initializing, you can get a copy of the\n\
7369 current plot to the specified device by switching to this stream and\n\
7370 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
7371 appropriate. The plot buffer must have previously been enabled (done\n\
7372 automatically by some display drivers, such as X).\n\
7374 Redacted form: plcpstrm(iplsr, flags)\n\
7376 This function is used in example 1,20.\n\
7382 plcpstrm(iplsr, flags)\n\
7386 iplsr (PLINT, input) : Number of reference stream.\n\
7388 flags (PLBOOL, input) : If flags is set to true the device\n\
7389 coordinates are not copied from the reference to current stream.\n\
7392 Plot a glyph at the specified points\n\
7396 Plot a glyph at the specified points. (This function is largely\n\
7397 superseded by plstring which gives access to many[!] more glyphs.)\n\
7398 code=-1 means try to just draw a point. Right now it\'s just a move\n\
7399 and a draw at the same place. Not ideal, since a sufficiently\n\
7400 intelligent output device may optimize it away, or there may be faster\n\
7401 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
7402 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
7403 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
7404 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
7405 code <= 127 the corresponding printable ASCII character is plotted.\n\
7407 Redacted form: plpoin(x, y, code)\n\
7409 This function is used in examples 1, 6, 14, and 29.\n\
7415 plpoin(n, x, y, code)\n\
7419 n (PLINT, input) : Number of points in the x and y vectors.\n\
7421 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7424 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7427 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
7428 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
7429 each of the n points.\n\
7432 Enter or leave xor mode\n\
7436 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
7437 those drivers (e.g., the xwin driver) that support it. Enables\n\
7438 erasing plots by drawing twice the same line, symbol, etc. If driver\n\
7439 is not capable of xor operation it returns a status of false.\n\
7441 Redacted form: plxormod(mode, status)\n\
7443 This function is used in examples 1 and 20.\n\
7449 plxormod(mode, status)\n\
7453 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
7454 is false means leave xor mode.\n\
7456 status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
7457 modestatus of true (false) means driver is capable (incapable) of\n\
7461 Get viewport limits in normalized device coordinates\n\
7465 Get viewport limits in normalized device coordinates.\n\
7467 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7470 This function is used in example 31.\n\
7476 plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7480 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7481 viewport limit of the normalized device coordinate in x.\n\
7483 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7484 viewport limit of the normalized device coordinate in x.\n\
7486 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7487 viewport limit of the normalized device coordinate in y.\n\
7489 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7490 viewport limit of the normalized device coordinate in y.\n\
7493 Plot surface mesh\n\
7497 Plots a surface mesh within the environment set up by plw3d. The\n\
7498 surface is defined by the matrix z[\n\
7500 ny] , the point z[i][j] being the value of the function at (\n\
7502 y[j]). Note that the points in vectors x and y do not need to be\n\
7503 equally spaced, but must be stored in ascending order. The parameter\n\
7504 opt controls the way in which the surface is displayed. For further\n\
7505 details see the PLplot documentation.\n\
7507 Redacted form: plmesh(x, y, z, opt)\n\
7509 This function is used in example 11.\n\
7515 plmesh(x, y, z, nx, ny, opt)\n\
7519 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7520 which the function is evaluated.\n\
7522 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7523 which the function is evaluated.\n\
7525 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7526 plot. Should have dimensions of\n\
7530 nx (PLINT, input) : Number of x values at which function has been\n\
7533 ny (PLINT, input) : Number of y values at which function has been\n\
7536 opt (PLINT, input) : Determines the way in which the surface is\n\
7537 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
7538 function of x for each value of y[j] .\n\
7539 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7540 for each value of x[i] .\n\
7541 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7542 at which function is defined.\n\
7545 Magnitude colored plot surface mesh with contour\n\
7549 A more powerful form of plmesh: the surface mesh can be colored\n\
7550 accordingly to the current z value being plotted, a contour plot can\n\
7551 be drawn at the base XY plane, and a curtain can be drawn between the\n\
7552 plotted function border and the base XY plane.\n\
7554 Redacted form: plmeshc(x, y, z, opt, clevel)\n\
7556 This function is used in example 11.\n\
7562 plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7566 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7567 which the function is evaluated.\n\
7569 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7570 which the function is evaluated.\n\
7572 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7573 plot. Should have dimensions of\n\
7577 nx (PLINT, input) : Number of x values at which function is\n\
7580 ny (PLINT, input) : Number of y values at which function is\n\
7583 opt (PLINT, input) : Determines the way in which the surface is\n\
7584 represented. To specify more than one option just add the options,\n\
7585 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
7586 showing z as a function of x for each value of y[j] .\n\
7587 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7588 for each value of x[i] .\n\
7589 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7590 at which function is defined.\n\
7591 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
7592 the z value being plotted. The color is used from the current\n\
7594 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7598 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7599 the borders of the plotted function.\n\
7602 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7605 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7608 End plotting session for current stream\n\
7612 Ends a plotting session for the current output stream only. See\n\
7613 plsstrm for more info.\n\
7615 Redacted form: plend1()\n\
7617 This function is used in examples 1 and 20.\n\
7626 Get y axis parameters\n\
7630 Identical to plgxax, except that arguments are flags for y axis. See\n\
7631 the description of plgxax for more detail.\n\
7633 Redacted form: plgyax(p_digmax, p_digits)\n\
7635 This function is used in example 31.\n\
7641 plgyax(p_digmax, p_digits)\n\
7645 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
7646 number of digits for the y axis. If nonzero, the printed label\n\
7647 has been switched to a floating-point representation when the\n\
7648 number of digits exceeds this value.\n\
7650 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
7651 number of digits for the numeric labels (y axis) from the last\n\
7655 Set plot orientation\n\
7659 Set plot orientation parameter which is multiplied by 90 degrees to\n\
7660 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7661 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7662 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7663 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7664 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
7665 not called the default value of rot is 0.\n\
7667 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
7668 probably want to change the aspect ratio to a value suitable for the\n\
7669 plot orientation using a call to plsdidev or the command-line options\n\
7670 -a or -freeaspect. For more documentation of those options see the\n\
7671 PLplot documentation. Such command-line options can be set internally\n\
7672 using plsetopt or set directly using the command line and parsed using\n\
7673 a call to plparseopts.\n\
7675 Redacted form: plsdiori(rot)\n\
7677 This function is not used in any examples.\n\
7687 rot (PLFLT, input) : Plot orientation parameter.\n\
7690 Plot a histogram from unbinned data\n\
7694 Plots a histogram from n data points stored in the data vector. This\n\
7695 routine bins the data into nbin bins equally spaced between datmin and\n\
7696 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7697 opt allows, among other things, the histogram either to be plotted in\n\
7698 an existing window or causes plhist to call plenv with suitable limits\n\
7699 before plotting the histogram.\n\
7701 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7703 This function is used in example 5.\n\
7709 plhist(n, data, datmin, datmax, nbin, opt)\n\
7713 n (PLINT, input) : Number of data points.\n\
7715 data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7718 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7720 datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7722 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7723 divide the interval xmin to xmax.\n\
7725 opt (PLINT, input) : Is a combination of several flags:\n\
7726 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7727 the histogram data, the outer bins are expanded to fill up the\n\
7728 entire x-axis, data outside the given extremes are assigned to the\n\
7729 outer bins and bins of zero height are simply drawn.\n\
7730 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7731 to fit the histogram data, without this flag, plenv is called\n\
7732 to set the world coordinates.\n\
7733 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7734 extremes are not taken into account. This option should\n\
7735 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7736 properly present the data.\n\
7737 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7738 size as the ones inside.\n\
7739 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7740 (there is a gap for such bins).\n\
7743 End plotting session\n\
7747 Ends a plotting session, tidies up all the output files, switches\n\
7748 interactive devices back into text mode and frees up any memory that\n\
7749 was allocated. Must be called before end of program.\n\
7751 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
7752 wait state after a call to plend or other functions which trigger the\n\
7753 end of a plot page. To avoid this, use the plspause function.\n\
7755 Redacted form: plend()\n\
7757 This function is used in all of the examples.\n\
7766 Plot shaded 3-d surface plot\n\
7770 Plots a three-dimensional shaded surface plot within the environment\n\
7771 set up by plw3d. The surface is defined by the two-dimensional matrix\n\
7774 ny], the point z[i][j] being the value of the function at (\n\
7776 y[j]). Note that the points in vectors x and y do not need to be\n\
7777 equally spaced, but must be stored in ascending order. For further\n\
7778 details see the PLplot documentation.\n\
7780 Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
7782 This function is not used in any examples.\n\
7788 plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7792 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7793 which the function is evaluated.\n\
7795 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7796 which the function is evaluated.\n\
7798 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7799 plot. Should have dimensions of\n\
7803 nx (PLINT, input) : Number of x values at which function is\n\
7806 ny (PLINT, input) : Number of y values at which function is\n\
7809 opt (PLINT, input) : Determines the way in which the surface is\n\
7810 represented. To specify more than one option just add the options,\n\
7811 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
7812 connecting points at which function is defined.\n\
7813 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7817 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
7821 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7822 the borders of the plotted function.\n\
7823 opt=MAG_COLOR : the surface is colored according to the value\n\
7824 of Z; if MAG_COLOR is not used, then the surface is colored\n\
7825 according to the intensity of the reflected light in the\n\
7826 surface from a light source whose position is set using\n\
7830 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7833 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7836 Set device-compression level\n\
7840 Set device-compression level. Only used for drivers that provide\n\
7841 compression. This function, if used, should be invoked before a call\n\
7844 Redacted form: plscompression(compression)\n\
7846 This function is used in example 31.\n\
7852 plscompression(compression)\n\
7856 compression (PLINT, input) : The desired compression level. This is\n\
7857 a device-dependent value. Currently only the jpeg and png devices\n\
7858 use these values. For jpeg value is the jpeg quality which should\n\
7859 normally be in the range 0-95. Higher values denote higher quality\n\
7860 and hence larger image sizes. For png values are in the range -1\n\
7861 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
7862 A value of -1 denotes the default zlib compression level. Values\n\
7863 in the range 10-99 are divided by 10 and then used as the zlib\n\
7864 compression level. Higher compression levels correspond to greater\n\
7865 compression and small file sizes at the expense of more\n\
7869 Get the current device-compression setting\n\
7873 Get the current device-compression setting. This parameter is only\n\
7874 used for drivers that provide compression.\n\
7876 Redacted form: plgcompression(compression)\n\
7878 This function is used in example 31.\n\
7884 plgcompression(compression)\n\
7888 compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
7889 compression setting for the current device.\n\
7892 Advance the (sub-)page\n\
7896 Advances to the next subpage if sub=0, performing a page advance if\n\
7897 there are no remaining subpages on the current page. If subpages\n\
7898 aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
7899 PLplot switches to the specified subpage. Note that this allows you\n\
7900 to overwrite a plot on the specified subpage; if this is not what you\n\
7901 intended, use pleop followed by plbop to first advance the page. This\n\
7902 routine is called automatically (with page=0) by plenv, but if plenv\n\
7903 is not used, pladv must be called after initializing PLplot but before\n\
7904 defining the viewport.\n\
7906 Redacted form: pladv(page)\n\
7908 This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
7919 page (PLINT, input) : Specifies the subpage number (starting from 1\n\
7920 in the top left corner and increasing along the rows) to which to\n\
7921 advance. Set to zero to advance to the next subpage (or to the\n\
7922 next page if subpages are not being used).\n\
7925 Set parameters of contour labelling other than format of numerical label\n\
7929 Set parameters of contour labelling other than those handled by\n\
7930 pl_setcontlabelformat.\n\
7932 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7934 This function is used in example 9.\n\
7940 pl_setcontlabelparam(offset, size, spacing, active)\n\
7944 offset (PLFLT, input) : Offset of label from contour line (if set\n\
7945 to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7947 size (PLFLT, input) : Font height for contour labels (normalized).\n\
7948 Default value is 0.3.\n\
7950 spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7951 Default value is 0.1.\n\
7953 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7954 contour labels on. Default is off (0).\n\
7957 Set family, style and weight of the current font\n\
7961 Sets the current font. See the PLplot documentation for more\n\
7962 information on font selection.\n\
7964 Redacted form: plsfont(family, style, weight)\n\
7966 This function is used in example 23.\n\
7972 plsfont(family, style, weight)\n\
7976 family (PLINT, input) : Font family to select for the current font.\n\
7977 The available values are given by the PL_FCI_* constants in\n\
7978 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
7979 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
7980 signifies that the font family should not be altered.\n\
7982 style (PLINT, input) : Font style to select for the current font.\n\
7983 The available values are given by the PL_FCI_* constants in\n\
7984 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
7985 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
7986 should not be altered.\n\
7988 weight (PLINT, input) : Font weight to select for the current font.\n\
7989 The available values are given by the PL_FCI_* constants in\n\
7990 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
7991 negative value signifies that the font weight should not be\n\
7995 Sets the 3D position of the light source\n\
7999 Sets the 3D position of the light source for use with plsurf3d and\n\
8002 Redacted form: pllightsource(x, y, z)\n\
8004 This function is used in example 8.\n\
8010 pllightsource(x, y, z)\n\
8014 x (PLFLT, input) : X-coordinate of the light source.\n\
8016 y (PLFLT, input) : Y-coordinate of the light source.\n\
8018 z (PLFLT, input) : Z-coordinate of the light source.\n\
8025 Draws line defined by n points in x and y.\n\
8027 Redacted form: plline(x, y)\n\
8029 This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
8040 n (PLINT, input) : Number of points defining line.\n\
8042 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8045 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8053 Sets the pen width.\n\
8055 Redacted form: plwidth(width)\n\
8057 This function is used in examples 1 and 2.\n\
8067 width (PLFLT, input) : The desired pen width. If width is negative\n\
8068 or the same as the previous value no action is taken. width = 0.\n\
8069 should be interpreted as as the minimum valid pen width for the\n\
8070 device. The interpretation of positive width values is also\n\
8071 device dependent.\n\
8074 Draw linear gradient inside polygon\n\
8078 Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
8081 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
8082 polygon coordinates and the gradient angle are all expressed in world\n\
8083 coordinates. The angle from the x axis for both the rotated\n\
8084 coordinate system and the gradient vector is specified by angle. The\n\
8085 magnitude of the gradient vector is the difference between the maximum\n\
8086 and minimum values of x for the vertices in the rotated coordinate\n\
8087 system. The origin of the gradient vector can be interpreted as being\n\
8088 anywhere on the line corresponding to the minimum x value for the\n\
8089 vertices in the rotated coordinate system. The distance along the\n\
8090 gradient vector is linearly transformed to the independent variable of\n\
8091 color map 1 which ranges from 0. at the tail of the gradient vector to\n\
8092 1. at the head of the gradient vector. What is drawn is the RGBA\n\
8093 color corresponding to the independent variable of cmap1. For more\n\
8094 information about cmap1 (see the PLplot documentation).\n\
8096 Redacted form: plgradient(x,y,angle)\n\
8098 This function is used in examples 25 and 30.\n\
8104 plgradient(n, x, y, angle)\n\
8108 n (PLINT, input) : Number of vertices in polygon.\n\
8110 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8113 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8116 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
8120 Flushes the output stream\n\
8124 Flushes the output stream. Use sparingly, if at all.\n\
8126 Redacted form: plflush()\n\
8128 This function is used in examples 1 and 14.\n\
8137 Get plot orientation\n\
8141 Get plot orientation parameter which is multiplied by 90 degrees to\n\
8142 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
8143 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
8144 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
8145 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
8146 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
8147 not been called the default value pointed to by p_rot will be 0.\n\
8149 Redacted form: plgdiori(p_rot)\n\
8151 This function is not used in any examples.\n\
8161 p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
8165 Set x axis parameters\n\
8169 Sets values of the digmax and digits flags for the x axis. See the\n\
8170 PLplot documentation for more information.\n\
8172 Redacted form: plsxax(digmax, digits)\n\
8174 This function is used in example 31.\n\
8180 plsxax(digmax, digits)\n\
8184 digmax (PLINT, input) : Variable to set the maximum number of\n\
8185 digits for the x axis. If nonzero, the printed label will be\n\
8186 switched to a floating-point representation when the number of\n\
8187 digits exceeds digmax.\n\
8189 digits (PLINT, input) : Field digits value. Currently, changing\n\
8190 its value here has no effect since it is set only by plbox or\n\
8191 plbox3. However, the user may obtain its value after a call to\n\
8192 either of these functions by calling plgxax.\n\
8195 Get viewport limits in world coordinates\n\
8199 Get viewport limits in world coordinates.\n\
8201 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
8204 This function is used in example 31.\n\
8210 plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
8214 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
8215 viewport limit of the world coordinate in x.\n\
8217 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
8218 viewport limit of the world coordinate in x.\n\
8220 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
8221 viewport limit of the world coordinate in y.\n\
8223 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
8224 viewport limit of the world coordinate in y.\n\
8227 Shade regions on the basis of value\n\
8231 Shade regions on the basis of value. This is the high-level routine\n\
8232 for making continuous color shaded plots with cmap1 while plshade\n\
8233 should be used to plot individual shaded regions using either cmap0 or\n\
8234 cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
8235 our supported languages.\n\
8237 Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
8238 clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
8242 This function is used in examples 16, 21, and 22.\n\
8248 plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
8252 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
8253 plot. Should have dimensions of\n\
8257 nx (PLINT, input) : First dimension of matrix \"a\".\n\
8259 ny (PLINT, input) : Second dimension of matrix \"a\".\n\
8261 defined (PLDEFINED_callback, input) : Callback function specifying\n\
8262 the region that should be plotted in the shade plot. This\n\
8263 function accepts x and y coordinates as input arguments and must\n\
8264 return 1 if the point is to be included in the shade plot and 0\n\
8265 otherwise. If you want to plot the entire shade plot (the usual\n\
8266 case), this argument should be set to NULL.\n\
8268 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
8269 pltr below for how these arguments are used (only for the special case\n\
8270 when the callback function\n\
8271 pltr is not supplied).\n\
8273 clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
8274 corresponding to the edges of each shaded region that will be\n\
8275 plotted by this function. To work properly the levels should be\n\
8278 nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
8279 of shade edge values in clevel).\n\
8281 fill_width (PLFLT, input) : Defines the line width used by the fill\n\
8284 cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
8285 contours defining edges of shaded regions. The pen color is only\n\
8286 temporary set for the contour drawing. Set this value to zero or\n\
8287 less if no shade edge contours are wanted.\n\
8289 cont_width (PLFLT, input) : Defines line width used for contours\n\
8290 defining edges of shaded regions. This value may not be honored\n\
8291 by all drivers. The pen width is only temporary set for the\n\
8292 contour drawing. Set this value to zero or less if no shade edge\n\
8293 contours are wanted.\n\
8295 fill (PLFILL_callback, input) : Callback routine used to fill the\n\
8296 region. Use plfill for this purpose.\n\
8298 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
8299 map to rectangles after coordinate transformation with pltrl.\n\
8300 Otherwise, set rectangular to false. If rectangular is set to\n\
8301 true, plshade tries to save time by filling large rectangles.\n\
8302 This optimization fails if the coordinate transformation distorts\n\
8303 the shape of rectangles. For example a plot in polar coordinates\n\
8304 has to have rectangular set to false.\n\
8306 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
8307 defines the transformation between the zero-based indices of the\n\
8308 matrix a and world coordinates. If\n\
8309 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
8310 indices of a are mapped to the range\n\
8312 xmax and the y indices of a are mapped to the range\n\
8314 ymax.For the C case, transformation functions are provided in the\n\
8315 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
8316 pltr2 for arbitrary mappings respectively defined by vectors and\n\
8317 matrices. In addition, C callback routines for the transformation\n\
8318 can be supplied by the user such as the mypltr function in\n\
8319 examples/c/x09c.c which provides a general linear transformation\n\
8320 between index coordinates and world coordinates.For languages\n\
8321 other than C you should consult the PLplot documentation for the\n\
8322 details concerning how PLTRANSFORM_callback arguments are\n\
8323 interfaced. However, in general, a particular pattern of\n\
8324 callback-associated arguments such as a tr vector with 6 elements;\n\
8325 xg and yg vectors; or xg and yg matrices are respectively\n\
8326 interfaced to a linear-transformation routine similar to the above\n\
8327 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
8328 sophisticated bindings (see, e.g., the PLplot documentation)\n\
8329 support native language callbacks for handling index to\n\
8330 world-coordinate transformations. Examples of these various\n\
8331 approaches are given in examples/<language>x09*,\n\
8332 examples/<language>x16*, examples/<language>x20*,\n\
8333 examples/<language>x21*, and examples/<language>x22*, for all our\n\
8334 supported languages.\n\
8336 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8337 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8338 externally supplied.\n\
8341 Plot color bar for image, shade or gradient plots\n\
8345 Routine for creating a continuous color bar for image, shade, or\n\
8346 gradient plots. (See pllegend for similar functionality for creating\n\
8347 legends with discrete elements). The arguments of plcolorbar provide\n\
8348 control over the location and size of the color bar as well as the\n\
8349 location and characteristics of the elements (most of which are\n\
8350 optional) within that color bar. The resulting color bar is clipped\n\
8351 at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
8352 system used for some of the parameters is defined in the documentation\n\
8353 of the position parameter.)\n\
8355 Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
8356 position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
8357 low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
8358 labels, axis_opts, ticks, sub_ticks, values)\n\
8360 This function is used in examples 16 and 33.\n\
8366 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\
8370 p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8371 labelled and decorated color bar width in adopted coordinates.\n\
8373 p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8374 labelled and decorated color bar height in adopted coordinates.\n\
8376 opt (PLINT, input) : opt contains bits controlling the overall\n\
8377 color bar. The orientation (direction of the maximum value) of\n\
8378 the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
8379 PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
8380 specified, the default orientation is toward the top if the\n\
8381 colorbar is placed on the left or right of the viewport or toward\n\
8382 the right if the colorbar is placed on the top or bottom of the\n\
8383 viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
8384 (semitransparent) background for the color bar. If the\n\
8385 PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8386 color bar. The type of color bar must be specified with one of\n\
8387 PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
8388 more than one of those bits is set only the first one in the above\n\
8389 list is honored. The position of the (optional) label/title can be\n\
8390 specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
8391 PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
8392 will be drawn. If more than one of this list of bits is specified,\n\
8393 only the first one on the list is honored. End-caps for the color\n\
8394 bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
8395 If a particular color bar cap option is not specified then no cap\n\
8396 will be drawn for that end. As a special case for\n\
8397 PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
8398 specified. If this option is provided then any tick marks and tick\n\
8399 labels will be placed at the breaks between shaded segments. TODO:\n\
8400 This should be expanded to support custom placement of tick marks\n\
8401 and tick labels at custom value locations for any color bar type.\n\
8403 position (PLINT, input) : position contains bits which control the\n\
8404 overall position of the color bar and the definition of the\n\
8405 adopted coordinates used for positions just like what is done for\n\
8406 the position argument for pllegend. However, note that the\n\
8407 defaults for the position bits (see below) are different than the\n\
8408 pllegend case. The combination of the PL_POSITION_LEFT,\n\
8409 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8410 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8411 the 16 possible standard positions (the 4 corners and centers of\n\
8412 the 4 sides for both the inside and outside cases) of the color\n\
8413 bar relative to the adopted coordinate system. The corner\n\
8414 positions are specified by the appropriate combination of two of\n\
8415 the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8416 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8417 value of one of those bits. The adopted coordinates are\n\
8418 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8419 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8420 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8421 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8422 then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
8423 PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
8424 PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
8425 PL_POSITION_VIEWPORT.\n\
8427 x (PLFLT, input) : X offset of the color bar position in adopted\n\
8428 coordinates from the specified standard position of the color bar.\n\
8429 For positive x, the direction of motion away from the standard\n\
8430 position is inward/outward from the standard corner positions or\n\
8431 standard left or right positions if the\n\
8432 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8433 For the standard top or bottom positions, the direction of motion\n\
8434 is toward positive X.\n\
8436 y (PLFLT, input) : Y offset of the color bar position in adopted\n\
8437 coordinates from the specified standard position of the color bar.\n\
8438 For positive y, the direction of motion away from the standard\n\
8439 position is inward/outward from the standard corner positions or\n\
8440 standard top or bottom positions if the\n\
8441 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8442 For the standard left or right positions, the direction of motion\n\
8443 is toward positive Y.\n\
8445 x_length (PLFLT, input) : Length of the body of the color bar in\n\
8446 the X direction in adopted coordinates.\n\
8448 y_length (PLFLT, input) : Length of the body of the color bar in\n\
8449 the Y direction in adopted coordinates.\n\
8451 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8452 color bar (PL_COLORBAR_BACKGROUND).\n\
8454 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8455 for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
8457 bb_style (PLINT, input) : The pllsty style number for the\n\
8458 bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
8460 low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
8461 bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
8463 high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
8464 color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
8466 cont_color (PLINT, input) : The cmap0 contour color for\n\
8467 PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
8468 it will be interpreted according to the design of plshades.\n\
8470 cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
8471 plots. This is passed directly to plshades, so it will be\n\
8472 interpreted according to the design of plshades.\n\
8474 n_labels (PLINT, input) : Number of labels to place around the\n\
8477 label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
8480 labels (PLCHAR_MATRIX, input) : A vector of\n\
8481 n_labels UTF-8 character strings containing the labels for the color\n\
8482 bar. Ignored if no label position is specified with one of the\n\
8483 PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
8484 PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
8485 corresponding label_opts field.\n\
8487 n_axes (PLINT, input) : Number of axis definitions provided. This\n\
8488 value must be greater than 0. It is typically 1 (numerical axis\n\
8489 labels are provided for one of the long edges of the color bar),\n\
8490 but it can be larger if multiple numerical axis labels for the\n\
8491 long edges of the color bar are desired.\n\
8493 axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
8494 n_axes ascii character strings containing options (interpreted as for\n\
8495 plbox) for the color bar\'s axis definitions.\n\
8497 ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
8498 spacing of the major tick marks (interpreted as for plbox) for the\n\
8499 color bar\'s axis definitions.\n\
8501 sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
8502 number of subticks (interpreted as for plbox) for the color bar\'s\n\
8503 axis definitions.\n\
8505 n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
8506 elements in each of the n_axes rows of the values matrix.\n\
8508 values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
8509 values for the data range represented by the color bar. For a row\n\
8510 index of i_axis (where 0 < i_axis < n_axes), the number of\n\
8511 elements in the row is specified by n_values[i_axis]. For\n\
8512 PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
8513 is 2, and the corresponding row elements of the values matrix are\n\
8514 the minimum and maximum value represented by the colorbar. For\n\
8515 PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
8516 of the values matrix is interpreted the same as the nlevel and\n\
8517 clevel arguments of plshades.\n\
8520 Get current subpage parameters\n\
8524 Gets the size of the current subpage in millimeters measured from the\n\
8525 bottom left hand corner of the output device page or screen. Can be\n\
8526 used in conjunction with plsvpa for setting the size of a viewport in\n\
8527 absolute coordinates (millimeters).\n\
8529 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
8531 This function is used in example 23.\n\
8537 plgspa(xmin, xmax, ymin, ymax)\n\
8541 xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8542 the left hand edge of the subpage in millimeters.\n\
8544 xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8545 the right hand edge of the subpage in millimeters.\n\
8547 ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8548 the bottom edge of the subpage in millimeters.\n\
8550 ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8551 the top edge of the subpage in millimeters.\n\
8554 Shade individual region on the basis of value\n\
8558 Shade individual region on the basis of value. Use plshades if you\n\
8559 want to shade a number of contiguous regions using continuous colors.\n\
8560 In particular the edge contours are treated properly in plshades. If\n\
8561 you attempt to do contiguous regions with plshade the contours at the\n\
8562 edge of the shade are partially obliterated by subsequent plots of\n\
8563 contiguous shaded regions.\n\
8565 Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
8566 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
8567 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
8570 This function is used in example 15.\n\
8576 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\
8580 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
8581 plot. Should have dimensions of\n\
8585 nx (PLINT, input) : First dimension of the matrix \"a\".\n\
8587 ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
8589 defined (PLDEFINED_callback, input) : Callback function specifying\n\
8590 the region that should be plotted in the shade plot. This\n\
8591 function accepts x and y coordinates as input arguments and must\n\
8592 return 1 if the point is to be included in the shade plot and 0\n\
8593 otherwise. If you want to plot the entire shade plot (the usual\n\
8594 case), this argument should be set to NULL.\n\
8596 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
8597 pltr below for how these arguments are used (only for the special case\n\
8598 when the callback function\n\
8599 pltr is not supplied).\n\
8601 shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
8602 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8604 shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
8605 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8607 sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
8608 sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
8609 then sh_color is interpreted as a cmap1 argument in the range\n\
8612 sh_color (PLFLT, input) : Defines color map index with integer\n\
8613 value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
8615 sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
8617 min_color (PLINT, input) : Defines pen color, width used by the\n\
8618 boundary of shaded region. The min values are used for the\n\
8619 shade_min boundary, and the max values are used on the shade_max\n\
8620 boundary. Set color and width to zero for no plotted boundaries.\n\
8622 min_width (PLFLT, input) : Defines pen color, width used by the\n\
8623 boundary of shaded region. The min values are used for the\n\
8624 shade_min boundary, and the max values are used on the shade_max\n\
8625 boundary. Set color and width to zero for no plotted boundaries.\n\
8627 max_color (PLINT, input) : Defines pen color, width used by the\n\
8628 boundary of shaded region. The min values are used for the\n\
8629 shade_min boundary, and the max values are used on the shade_max\n\
8630 boundary. Set color and width to zero for no plotted boundaries.\n\
8632 max_width (PLFLT, input) : Defines pen color, width used by the\n\
8633 boundary of shaded region. The min values are used for the\n\
8634 shade_min boundary, and the max values are used on the shade_max\n\
8635 boundary. Set color and width to zero for no plotted boundaries.\n\
8637 fill (PLFILL_callback, input) : Routine used to fill the region.\n\
8638 Use plfill. Future version of PLplot may have other fill\n\
8641 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
8642 map to rectangles after coordinate transformation with pltrl.\n\
8643 Otherwise, set rectangular to false. If rectangular is set to\n\
8644 true, plshade tries to save time by filling large rectangles.\n\
8645 This optimization fails if the coordinate transformation distorts\n\
8646 the shape of rectangles. For example a plot in polar coordinates\n\
8647 has to have rectangular set to false.\n\
8649 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
8650 defines the transformation between the zero-based indices of the\n\
8651 matrix a and world coordinates. If\n\
8652 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
8653 indices of a are mapped to the range\n\
8655 xmax and the y indices of a are mapped to the range\n\
8657 ymax.For the C case, transformation functions are provided in the\n\
8658 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
8659 pltr2 for arbitrary mappings respectively defined by vectors and\n\
8660 matrices. In addition, C callback routines for the transformation\n\
8661 can be supplied by the user such as the mypltr function in\n\
8662 examples/c/x09c.c which provides a general linear transformation\n\
8663 between index coordinates and world coordinates.For languages\n\
8664 other than C you should consult the PLplot documentation for the\n\
8665 details concerning how PLTRANSFORM_callback arguments are\n\
8666 interfaced. However, in general, a particular pattern of\n\
8667 callback-associated arguments such as a tr vector with 6 elements;\n\
8668 xg and yg vectors; or xg and yg matrices are respectively\n\
8669 interfaced to a linear-transformation routine similar to the above\n\
8670 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
8671 sophisticated bindings (see, e.g., the PLplot documentation)\n\
8672 support native language callbacks for handling index to\n\
8673 world-coordinate transformations. Examples of these various\n\
8674 approaches are given in examples/<language>x09*,\n\
8675 examples/<language>x16*, examples/<language>x20*,\n\
8676 examples/<language>x21*, and examples/<language>x22*, for all our\n\
8677 supported languages.\n\
8679 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8680 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8681 externally supplied.\n\
8684 Calculate world coordinates and corresponding window index from relative device coordinates\n\
8688 Calculate world coordinates, wx and wy, and corresponding window index\n\
8689 from relative device coordinates, rx and ry.\n\
8691 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
8694 This function is used in example 31.\n\
8700 plcalc_world(rx, ry, wx, wy, window)\n\
8704 rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8705 the x coordinate.\n\
8707 ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8708 the y coordinate.\n\
8710 wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
8711 coordinate corresponding to the relative device coordinates rx and\n\
8714 wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
8715 coordinate corresponding to the relative device coordinates rx and\n\
8718 window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
8719 defined window index that corresponds to the input relative device\n\
8720 coordinates (and the returned world coordinates). To give some\n\
8721 background on the window index, for each page the initial window\n\
8722 index is set to zero, and each time plwind is called within the\n\
8723 page, world and device coordinates are stored for the window and\n\
8724 the window index is incremented. Thus, for a simple page layout\n\
8725 with non-overlapping viewports and one window per viewport, window\n\
8726 corresponds to the viewport index (in the order which the\n\
8727 viewport/windows were created) of the only viewport/window\n\
8728 corresponding to rx and ry. However, for more complicated layouts\n\
8729 with potentially overlapping viewports and possibly more than one\n\
8730 window (set of world coordinates) per viewport, window and the\n\
8731 corresponding output world coordinates corresponds to the last\n\
8732 window created that fulfills the criterion that the relative\n\
8733 device coordinates are inside it. Finally, in all cases where the\n\
8734 input relative device coordinates are not inside any\n\
8735 viewport/window, then the returned value of the last defined\n\
8736 window index is set to -1.\n\
8739 Draw a box with axes, etc, in 3-d\n\
8743 Draws axes, numeric and text labels for a three-dimensional surface\n\
8744 plot. For a more complete description of three-dimensional plotting\n\
8745 see the PLplot documentation.\n\
8747 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
8748 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8751 This function is used in examples 8, 11, 18, and 21.\n\
8757 plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8761 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8762 options for the x axis. The string can include any combination of\n\
8763 the following letters (upper or lower case) in any order: b: Draws\n\
8764 axis at base, at height z=\n\
8765 zmin where zmin is defined by call to plw3d. This character must be\n\
8766 specified in order to use any of the other options.\n\
8767 d: Plot labels as date / time. Values are assumed to be\n\
8768 seconds since the epoch (as used by gmtime).\n\
8769 f: Always use fixed point numeric labels.\n\
8770 i: Inverts tick marks, so they are drawn downwards, rather\n\
8772 l: Labels axis logarithmically. This only affects the labels,\n\
8773 not the data, and so it is necessary to compute the logarithms\n\
8774 of data points before passing them to any of the drawing\n\
8776 n: Writes numeric labels at major tick intervals.\n\
8777 o: Use custom labelling function to generate axis label text.\n\
8778 The custom labelling function can be defined with the\n\
8779 plslabelfunc command.\n\
8780 s: Enables subticks between major ticks, only valid if t is\n\
8782 t: Draws major ticks.\n\
8783 u: If this is specified, the text label for the axis is\n\
8784 written under the axis.\n\
8787 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8788 the text label for the x axis. It is only drawn if u is in the\n\
8791 xtick (PLFLT, input) : World coordinate interval between major\n\
8792 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8793 generates a suitable tick interval.\n\
8795 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8796 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8797 generates a suitable minor tick interval.\n\
8799 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8800 options for the y axis. The string is interpreted in the same way\n\
8803 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8804 the text label for the y axis. It is only drawn if u is in the\n\
8807 ytick (PLFLT, input) : World coordinate interval between major\n\
8808 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8809 generates a suitable tick interval.\n\
8811 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8812 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8813 generates a suitable minor tick interval.\n\
8815 zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8816 options for the z axis. The string can include any combination of\n\
8817 the following letters (upper or lower case) in any order: b: Draws\n\
8818 z axis to the left of the surface plot.\n\
8819 c: Draws z axis to the right of the surface plot.\n\
8820 d: Draws grid lines parallel to the x-y plane behind the\n\
8821 figure. These lines are not drawn until after plot3d or\n\
8822 plmesh are called because of the need for hidden line removal.\n\
8823 e: Plot labels as date / time. Values are assumed to be\n\
8824 seconds since the epoch (as used by gmtime). Note this\n\
8825 suboption is interpreted the same as the d suboption for xopt\n\
8826 and yopt, but it has to be identified as e for zopt since d\n\
8827 has already been used for the different purpose above.\n\
8828 f: Always use fixed point numeric labels.\n\
8829 i: Inverts tick marks, so they are drawn away from the center.\n\
8830 l: Labels axis logarithmically. This only affects the labels,\n\
8831 not the data, and so it is necessary to compute the logarithms\n\
8832 of data points before passing them to any of the drawing\n\
8834 m: Writes numeric labels at major tick intervals on the\n\
8835 right-hand z axis.\n\
8836 n: Writes numeric labels at major tick intervals on the\n\
8837 left-hand z axis.\n\
8838 o: Use custom labelling function to generate axis label text.\n\
8839 The custom labelling function can be defined with the\n\
8840 plslabelfunc command.\n\
8841 s: Enables subticks between major ticks, only valid if t is\n\
8843 t: Draws major ticks.\n\
8844 u: If this is specified, the text label is written beside the\n\
8846 v: If this is specified, the text label is written beside the\n\
8850 zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8851 the text label for the z axis. It is only drawn if u or v are in\n\
8854 ztick (PLFLT, input) : World coordinate interval between major\n\
8855 ticks on the z axis. If it is set to zero, PLplot automatically\n\
8856 generates a suitable tick interval.\n\
8858 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
8859 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8860 generates a suitable minor tick interval.\n\
8863 Get character default height and current (scaled) height\n\
8867 Get character default height and current (scaled) height.\n\
8869 Redacted form: plgchr(p_def, p_ht)\n\
8871 This function is used in example 23.\n\
8877 plgchr(p_def, p_ht)\n\
8881 p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
8882 character height (mm).\n\
8884 p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
8885 character height (mm).\n\
8888 Set the escape character for text strings\n\
8892 Set the escape character for text strings. From C (in contrast to\n\
8893 Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
8894 characters are allowed to prevent the user from shooting himself in\n\
8895 the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
8896 use of backslash as a character escape). Here are the allowed escape\n\
8897 characters and their corresponding decimal ASCII values: !, ASCII 33\n\
8908 Redacted form: General: plsesc(esc)\n\
8911 This function is used in example 29.\n\
8921 esc (char, input) : Escape character.\n\
8924 Draw a line between two points, accounting for coordinate transforms\n\
8928 Joins the point (\n\
8932 y2) . If a global coordinate transform is defined then the line is\n\
8933 broken in to n segments to approximate the path. If no transform is\n\
8934 defined then this simply acts like a call to pljoin.\n\
8936 Redacted form: plpath(n,x1,y1,x2,y2)\n\
8938 This function is used in example 22.\n\
8944 plpath(n, x1, y1, x2, y2)\n\
8948 n (PLINT, input) : number of points to use to approximate the path.\n\
8950 x1 (PLFLT, input) : x coordinate of first point.\n\
8952 y1 (PLFLT, input) : y coordinate of first point.\n\
8954 x2 (PLFLT, input) : x coordinate of second point.\n\
8956 y2 (PLFLT, input) : y coordinate of second point.\n\
8959 Set up standard window and draw box\n\
8963 Sets up plotter environment for simple graphs by calling pladv and\n\
8964 setting up viewport and window to sensible default values. plenv\n\
8965 leaves a standard margin (left-hand margin of eight character heights,\n\
8966 and a margin around the other three sides of five character heights)\n\
8967 around most graphs for axis labels and a title. When these defaults\n\
8968 are not suitable, use the individual routines plvpas, plvpor, or\n\
8969 plvasp for setting up the viewport, plwind for defining the window,\n\
8970 and plbox for drawing the box.\n\
8972 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8974 This function is used in example 1,3,9,13,14,19-22,29.\n\
8980 plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8984 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
8985 world coordinates).\n\
8987 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
8988 world coordinates).\n\
8990 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
8993 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
8996 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
8997 scales will not be set, the user must set up the scale before\n\
8998 calling plenv using plsvpa, plvasp or other.\n\
8999 0: the x and y axes are scaled independently to use as much of\n\
9000 the screen as possible.\n\
9001 1: the scales of the x and y axes are made equal.\n\
9002 2: the axis of the x and y axes are made equal, and the plot\n\
9003 box will be square.\n\
9006 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
9007 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
9008 -1: draw box only.\n\
9009 0: draw box, ticks, and numeric tick labels.\n\
9010 1: also draw coordinate axes at x=0 and y=0.\n\
9011 2: also draw a grid at major tick positions in both\n\
9013 3: also draw a grid at minor tick positions in both\n\
9015 10: same as 0 except logarithmic x tick marks. (The x data\n\
9016 have to be converted to logarithms separately.)\n\
9017 11: same as 1 except logarithmic x tick marks. (The x data\n\
9018 have to be converted to logarithms separately.)\n\
9019 12: same as 2 except logarithmic x tick marks. (The x data\n\
9020 have to be converted to logarithms separately.)\n\
9021 13: same as 3 except logarithmic x tick marks. (The x data\n\
9022 have to be converted to logarithms separately.)\n\
9023 20: same as 0 except logarithmic y tick marks. (The y data\n\
9024 have to be converted to logarithms separately.)\n\
9025 21: same as 1 except logarithmic y tick marks. (The y data\n\
9026 have to be converted to logarithms separately.)\n\
9027 22: same as 2 except logarithmic y tick marks. (The y data\n\
9028 have to be converted to logarithms separately.)\n\
9029 23: same as 3 except logarithmic y tick marks. (The y data\n\
9030 have to be converted to logarithms separately.)\n\
9031 30: same as 0 except logarithmic x and y tick marks. (The x\n\
9032 and y data have to be converted to logarithms separately.)\n\
9033 31: same as 1 except logarithmic x and y tick marks. (The x\n\
9034 and y data have to be converted to logarithms separately.)\n\
9035 32: same as 2 except logarithmic x and y tick marks. (The x\n\
9036 and y data have to be converted to logarithms separately.)\n\
9037 33: same as 3 except logarithmic x and y tick marks. (The x\n\
9038 and y data have to be converted to logarithms separately.)\n\
9039 40: same as 0 except date / time x labels.\n\
9040 41: same as 1 except date / time x labels.\n\
9041 42: same as 2 except date / time x labels.\n\
9042 43: same as 3 except date / time x labels.\n\
9043 50: same as 0 except date / time y labels.\n\
9044 51: same as 1 except date / time y labels.\n\
9045 52: same as 2 except date / time y labels.\n\
9046 53: same as 3 except date / time y labels.\n\
9047 60: same as 0 except date / time x and y labels.\n\
9048 61: same as 1 except date / time x and y labels.\n\
9049 62: same as 2 except date / time x and y labels.\n\
9050 63: same as 3 except date / time x and y labels.\n\
9051 70: same as 0 except custom x and y labels.\n\
9052 71: same as 1 except custom x and y labels.\n\
9053 72: same as 2 except custom x and y labels.\n\
9054 73: same as 3 except custom x and y labels.\n\
9057 Grid data from irregularly sampled data\n\
9061 Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
9062 require data organized as a grid, i.e., with x sample point values\n\
9063 independent of y coordinate and vice versa. This function takes\n\
9064 irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
9065 vectors; reads the desired grid location from the input vectors\n\
9066 xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
9067 grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
9068 interpolate the data to the grid is specified with the argument type\n\
9069 which can have one parameter specified in argument data.\n\
9071 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
9072 Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
9075 This function is used in example 21.\n\
9081 plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
9085 x (PLFLT_VECTOR, input) : The input x vector.\n\
9087 y (PLFLT_VECTOR, input) : The input y vector.\n\
9089 z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
9090 y[i], z[i] represents one data sample coordinate.\n\
9092 npts (PLINT, input) : The number of data samples in the x, y and z\n\
9095 xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
9096 in the x direction. Usually xg has nptsx equally spaced values\n\
9097 from the minimum to the maximum values of the x input vector.\n\
9099 nptsx (PLINT, input) : The number of points in the xg vector.\n\
9101 yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
9102 in the y direction. Similar to the xg parameter.\n\
9104 nptsy (PLINT, input) : The number of points in the yg vector.\n\
9106 zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
9107 where data lies in the grid specified by xg and yg. Therefore the\n\
9108 zg matrix must be dimensioned\n\
9112 type (PLINT, input) : The type of grid interpolation algorithm to\n\
9113 use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
9114 GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
9115 GRID_NNI: Natural Neighbors Interpolation\n\
9116 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
9117 GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
9118 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
9120 For details of the algorithms read the source file plgridd.c.\n\
9122 data (PLFLT, input) : Some gridding algorithms require extra data,\n\
9123 which can be specified through this argument. Currently, for\n\
9124 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
9125 use, the lower the value, the noisier (more local) the\n\
9126 approximation is.\n\
9127 GRID_NNLI, data specifies what a thin triangle is, in the\n\
9128 range [1. .. 2.]. High values enable the usage of very thin\n\
9129 triangles for interpolation, possibly resulting in error in\n\
9130 the approximation.\n\
9131 GRID_NNI, only weights greater than data will be accepted. If\n\
9132 0, all weights will be accepted.\n\
9135 Clear current (sub)page\n\
9139 Clears the current page, effectively erasing everything that have been\n\
9140 drawn. This command only works with interactive drivers; if the\n\
9141 driver does not support this, the page is filled with the background\n\
9142 color in use. If the current page is divided into subpages, only the\n\
9143 current subpage is erased. The nth subpage can be selected with\n\
9146 Redacted form: General: plclear()\n\
9149 This function is not used in any examples.\n\
9158 Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
9162 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
9163 and PLFLT alpha transparency value. This sets the entire color map --\n\
9164 only as many colors as specified will be allocated.\n\
9166 Redacted form: plscmap0a(r, g, b, alpha)\n\
9168 This function is used in examples 30.\n\
9174 plscmap0a(r, g, b, alpha, ncol0)\n\
9178 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9179 integers (0-255) representing the degree of red in the color.\n\
9181 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9182 integers (0-255) representing the degree of green in the color.\n\
9184 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9185 integers (0-255) representing the degree of blue in the color.\n\
9187 alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
9188 representing the alpha transparency of the color.\n\
9190 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9194 Set 8-bit RGB values for given cmap0 color index\n\
9198 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
9199 index. Overwrites the previous color value for the given index and,\n\
9200 thus, does not result in any additional allocation of space for\n\
9203 Redacted form: plscol0(icol0, r, g, b)\n\
9205 This function is used in any example 31.\n\
9211 plscol0(icol0, r, g, b)\n\
9215 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
9216 number of colors (which is set by default, by plscmap0n, or even\n\
9219 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9220 degree of red in the color.\n\
9222 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9223 degree of green in the color.\n\
9225 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9226 degree of blue in the color.\n\
9229 Set up transformation from metafile coordinates\n\
9233 Set up transformation from metafile coordinates. The size of the plot\n\
9234 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
9235 general-purpose facility just yet (not sure why the user would need\n\
9238 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
9241 This function is not used in any examples.\n\
9247 plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
9251 dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
9253 dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
9255 dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
9257 dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
9259 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
9261 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
9264 Creates a new stream and makes it the default\n\
9268 Creates a new stream and makes it the default. Differs from using\n\
9269 plsstrm, in that a free stream number is found, and returned.\n\
9270 Unfortunately, I have to start at stream 1 and work upward, since\n\
9271 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
9272 that no initial, library-opening call is required. So stream 0 must\n\
9273 be preallocated, and there is no simple way of determining whether it\n\
9274 is already in use or not.\n\
9276 Redacted form: plmkstrm(p_strm)\n\
9278 This function is used in examples 1 and 20.\n\
9288 p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
9289 number of the created stream.\n\
9292 Get page parameters\n\
9296 Gets the current page configuration. The length and offset values are\n\
9297 expressed in units that are specific to the current driver. For\n\
9298 instance: screen drivers will usually interpret them as number of\n\
9299 pixels, whereas printer drivers will usually use mm.\n\
9301 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
9303 This function is used in examples 14 and 31.\n\
9309 plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
9313 p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
9314 pixels/inch (DPI) in x.\n\
9316 p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
9317 pixels/inch (DPI) in y.\n\
9319 p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
9322 p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
9325 p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
9328 p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
9332 Set format for date / time labels\n\
9336 Sets the format for date / time labels. To enable date / time format\n\
9337 labels see the options to plbox, plbox3, and plenv.\n\
9339 Redacted form: pltimefmt(fmt)\n\
9341 This function is used in example 29.\n\
9351 fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
9352 interpreted similarly to the format specifier of typical system\n\
9353 strftime routines except that PLplot ignores locale and also\n\
9354 supplies some useful extensions in the context of plotting. All\n\
9355 text in the string is printed as-is other than conversion\n\
9356 specifications which take the form of a \'%\' character followed by\n\
9357 further conversion specification character. The conversion\n\
9358 specifications which are similar to those provided by system\n\
9359 strftime routines are the following: %a: The abbreviated (English)\n\
9361 %A: The full (English) weekday name.\n\
9362 %b: The abbreviated (English) month name.\n\
9363 %B: The full (English) month name.\n\
9364 %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
9365 %C: The century number (year/100) as a 2-digit integer.\n\
9366 %d: The day of the month as a decimal number (range 01 to 31).\n\
9367 %D: Equivalent to %m/%d/%y (non-ISO).\n\
9368 %e: Like %d, but a leading zero is replaced by a space.\n\
9369 %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
9370 %h: Equivalent to %b.\n\
9371 %H: The hour as a decimal number using a 24-hour clock (range\n\
9373 %I: The hour as a decimal number using a 12-hour clock (range\n\
9375 %j: The day of the year as a decimal number (range 001 to\n\
9377 %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
9378 23); single digits are preceded by a blank. (See also %H.)\n\
9379 %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
9380 12); single digits are preceded by a blank. (See also %I.)\n\
9381 %m: The month as a decimal number (range 01 to 12).\n\
9382 %M: The minute as a decimal number (range 00 to 59).\n\
9383 %n: A newline character.\n\
9384 %p: Either \"AM\" or \"PM\" according to the given time value.\n\
9385 Noon is treated as \"PM\" and midnight as \"AM\".\n\
9386 %r: Equivalent to %I:%M:%S %p.\n\
9387 %R: The time in 24-hour notation (%H:%M). For a version\n\
9388 including the seconds, see %T below.\n\
9389 %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
9391 %S: The second as a decimal number (range 00 to 60). (The\n\
9392 range is up to 60 to allow for occasional leap seconds.)\n\
9393 %t: A tab character.\n\
9394 %T: The time in 24-hour notation (%H:%M:%S).\n\
9395 %u: The day of the week as a decimal, range 1 to 7, Monday\n\
9396 being 1. See also %w.\n\
9397 %U: The week number of the current year as a decimal number,\n\
9398 range 00 to 53, starting with the first Sunday as the first\n\
9399 day of week 01. See also %V and %W.\n\
9400 %v: Equivalent to %e-%b-%Y.\n\
9401 %V: The ISO 8601 week number of the current year as a decimal\n\
9402 number, range 01 to 53, where week 1 is the first week that\n\
9403 has at least 4 days in the new year. See also %U and %W.\n\
9404 %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
9405 being 0. See also %u.\n\
9406 %W: The week number of the current year as a decimal number,\n\
9407 range 00 to 53, starting with the first Monday as the first\n\
9409 %x: Equivalent to %a %b %d %Y.\n\
9410 %X: Equivalent to %T.\n\
9411 %y: The year as a decimal number without a century (range 00\n\
9413 %Y: The year as a decimal number including a century.\n\
9414 %z: The UTC time-zone string = \"+0000\".\n\
9415 %Z: The UTC time-zone abbreviation = \"UTC\".\n\
9416 %+: The UTC date and time in default format of the Unix date\n\
9417 command which is equivalent to %a %b %d %T %Z %Y.\n\
9418 %%: A literal \"%\" character.\n\
9419 The conversion specifications which are extensions to those normally\n\
9420 provided by system strftime routines are the following: %(0-9):\n\
9421 The fractional part of the seconds field (including leading\n\
9422 decimal point) to the specified accuracy. Thus %S%3 would give\n\
9423 seconds to millisecond accuracy (00.000).\n\
9424 %.: The fractional part of the seconds field (including\n\
9425 leading decimal point) to the maximum available accuracy. Thus\n\
9426 %S%. would give seconds with fractional part up to 9 decimal\n\
9427 places if available.\n\
9430 Specify viewport using aspect ratio only\n\
9434 Selects the largest viewport with the given aspect ratio within the\n\
9435 subpage that leaves a standard margin (left-hand margin of eight\n\
9436 character heights, and a margin around the other three sides of five\n\
9437 character heights).\n\
9439 Redacted form: plvasp(aspect)\n\
9441 This function is used in example 13.\n\
9451 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
9452 axis of resulting viewport.\n\
9455 Set output file name\n\
9459 Sets the current output file name, if applicable. If the file name\n\
9460 has not been specified and is required by the driver, the user will be\n\
9461 prompted for it. If using the X-windows output driver, this sets the\n\
9462 display name. This routine, if used, must be called before\n\
9463 initializing PLplot.\n\
9465 Redacted form: plsfnam(fnam)\n\
9467 This function is used in examples 1 and 20.\n\
9477 fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9485 Draws a plot of vector data contained in the matrices (\n\
9491 ny]) . The scaling factor for the vectors is given by scale. A\n\
9492 transformation routine pointed to by pltr with a pointer pltr_data for\n\
9493 additional data required by the transformation routine to map indices\n\
9494 within the matrices to the world coordinates. The style of the vector\n\
9495 arrow may be set using plsvect.\n\
9497 Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
9498 discussion) the pltr, pltr_data callback arguments are sometimes\n\
9499 replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
9500 with either one or two dimensions.\n\
9502 This function is used in example 22.\n\
9508 plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
9512 u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
9513 and y components of the vector data to be plotted.\n\
9515 nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
9517 scale (PLFLT, input) : Parameter to control the scaling factor of\n\
9518 the vectors for plotting. If scale = 0 then the scaling factor is\n\
9519 automatically calculated for the data. If scale < 0 then the\n\
9520 scaling factor is automatically calculated for the data and then\n\
9522 scale. If scale > 0 then the scaling factor is set to scale.\n\
9524 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
9525 defines the transformation between the zero-based indices of the\n\
9526 matrices u and v and world coordinates.For the C case,\n\
9527 transformation functions are provided in the PLplot library: pltr0\n\
9528 for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
9529 mappings respectively defined by vectors and matrices. In\n\
9530 addition, C callback routines for the transformation can be\n\
9531 supplied by the user such as the mypltr function in\n\
9532 examples/c/x09c.c which provides a general linear transformation\n\
9533 between index coordinates and world coordinates.For languages\n\
9534 other than C you should consult the PLplot documentation for the\n\
9535 details concerning how PLTRANSFORM_callback arguments are\n\
9536 interfaced. However, in general, a particular pattern of\n\
9537 callback-associated arguments such as a tr vector with 6 elements;\n\
9538 xg and yg vectors; or xg and yg matrices are respectively\n\
9539 interfaced to a linear-transformation routine similar to the above\n\
9540 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
9541 sophisticated bindings (see, e.g., the PLplot documentation)\n\
9542 support native language callbacks for handling index to\n\
9543 world-coordinate transformations. Examples of these various\n\
9544 approaches are given in examples/<language>x09*,\n\
9545 examples/<language>x16*, examples/<language>x20*,\n\
9546 examples/<language>x21*, and examples/<language>x22*, for all our\n\
9547 supported languages.\n\
9549 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
9550 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
9551 that is externally supplied.\n\
9554 Set parameters that define current plot-space window\n\
9558 Set relative minima and maxima that define the current plot-space\n\
9559 window. If plsdiplt is not called the default values of xmin, ymin,\n\
9560 xmax, and ymax are 0., 0., 1., and 1.\n\
9562 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
9564 This function is used in example 31.\n\
9570 plsdiplt(xmin, ymin, xmax, ymax)\n\
9574 xmin (PLFLT, input) : Relative minimum in x.\n\
9576 ymin (PLFLT, input) : Relative minimum in y.\n\
9578 xmax (PLFLT, input) : Relative maximum in x.\n\
9580 ymax (PLFLT, input) : Relative maximum in y.\n\
9583 Select line style\n\
9587 This sets the line style according to one of eight predefined patterns\n\
9588 (also see plstyl).\n\
9590 Redacted form: pllsty(lin)\n\
9592 This function is used in examples 9, 12, 22, and 25.\n\
9602 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
9603 a continuous line, line style 2 is a line with short dashes and\n\
9604 gaps, line style 3 is a line with long dashes and gaps, line style\n\
9605 4 has long dashes and short gaps and so on.\n\
9608 Plot a glyph at the specified points\n\
9612 Plot a glyph at the specified points. (This function is largely\n\
9613 superseded by plstring which gives access to many[!] more glyphs.)\n\
9615 Redacted form: plsym(x, y, code)\n\
9617 This function is used in example 7.\n\
9623 plsym(n, x, y, code)\n\
9627 n (PLINT, input) : Number of points in the x and y vectors.\n\
9629 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9632 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9635 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
9636 to be plotted at each of the n points.\n\
9639 Set the device (keyword) name\n\
9643 Set the device (keyword) name.\n\
9645 Redacted form: plsdev(devname)\n\
9647 This function is used in examples 1, 14, and 20.\n\
9657 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
9658 containing the device name keyword of the required output device.\n\
9660 devname is NULL or if the first character of the string is a ``?\'\',\n\
9661 the normal (prompted) start up is used.\n\
9664 Set the background color by 8-bit RGB value\n\
9668 Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
9669 the PLplot documentation).\n\
9671 Redacted form: plscolbg(r, g, b)\n\
9673 This function is used in examples 15 and 31.\n\
9679 plscolbg(r, g, b)\n\
9683 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9684 degree of red in the color.\n\
9686 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9687 degree of green in the color.\n\
9689 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9690 degree of blue in the color.\n\
9693 Set parameters incrementally (zoom mode) that define current plot-space window\n\
9697 Set relative minima and maxima incrementally (zoom mode) that define\n\
9698 the current plot-space window. This function has the same effect as\n\
9699 plsdiplt if that function has not been previously called. Otherwise,\n\
9700 this function implements zoom mode using the transformation min_used =\n\
9701 old_min + old_length*min and max_used = old_min + old_length*max for\n\
9702 each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
9703 repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
9705 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
9707 This function is used in example 31.\n\
9713 plsdiplz(xmin, ymin, xmax, ymax)\n\
9717 xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
9719 ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
9721 xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
9723 ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
9726 Advance to the next family file on the next new page\n\
9730 Advance to the next family file on the next new page.\n\
9732 Redacted form: plfamadv()\n\
9734 This function is not used in any examples.\n\
9743 Set number of colors in cmap0\n\
9747 Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9748 (or reallocate) cmap0, and fill with default values for those colors\n\
9749 not previously allocated. The first 16 default colors are given in\n\
9750 the plcol0 documentation. For larger indices the default color is\n\
9753 The drivers are not guaranteed to support more than 16 colors.\n\
9755 Redacted form: plscmap0n(ncol0)\n\
9757 This function is used in examples 15, 16, and 24.\n\
9767 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9768 the cmap0 palette. If this number is zero or less, then the value\n\
9769 from the previous call to plscmap0n is used and if there is no\n\
9770 previous call, then a default value is used.\n\
9773 Plot latitude and longitude lines\n\
9777 Displays latitude and longitude on the current plot. The lines are\n\
9778 plotted in the current color and line style.\n\
9780 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
9783 This function is used in example 19.\n\
9789 plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
9793 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
9794 transform the coordinate longitudes and latitudes to a plot\n\
9795 coordinate system. By using this transform, we can change from a\n\
9796 longitude, latitude coordinate to a polar stereographic project,\n\
9797 for example. Initially, x[0]..[n-1] are the longitudes and\n\
9798 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
9799 mapform(), x[] and y[] should be replaced by the corresponding\n\
9800 plot coordinates. If no transform is desired, mapform can be\n\
9801 replaced by NULL.\n\
9803 dlong (PLFLT, input) : The interval in degrees at which the\n\
9804 longitude lines are to be plotted.\n\
9806 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
9807 lines are to be plotted.\n\
9809 minlong (PLFLT, input) : The value of the longitude on the left\n\
9810 side of the plot. The value of minlong must be less than the value\n\
9811 of maxlong, and the quantity maxlong-minlong must be less than or\n\
9814 maxlong (PLFLT, input) : The value of the longitude on the right\n\
9815 side of the plot.\n\
9817 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
9818 background. One can always use -90.0 as the boundary outside the\n\
9819 plot window will be automatically eliminated. However, the\n\
9820 program will be faster if one can reduce the size of the\n\
9821 background plotted.\n\
9823 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
9824 background. One can always use 90.0 as the boundary outside the\n\
9825 plot window will be automatically eliminated.\n\
9828 Convert RGB color to HLS\n\
9832 Convert RGB color coordinates to HLS\n\
9834 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9837 This function is used in example 2.\n\
9843 plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9847 r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9849 g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9851 b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9853 p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9854 degrees (0.0-360.0) on the color cylinder.\n\
9856 p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9857 expressed as a fraction (0.0-1.0) of the axis of the color\n\
9860 p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9861 expressed as a fraction (0.0-1.0) of the radius of the color\n\
9865 Plot a glyph at the specified 3D points\n\
9869 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
9870 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
9871 this function similar to what is done for plline3. The glyph is\n\
9872 specified with a PLplot user string. Note that the user string is not\n\
9873 actually limited to one glyph so it is possible (but not normally\n\
9874 useful) to plot more than one glyph at the specified points with this\n\
9875 function. As with plmtex and plptex, the user string can contain FCI\n\
9876 escapes to determine the font, UTF-8 code to determine the glyph or\n\
9877 else PLplot escapes for Hershey or unicode text to determine the\n\
9880 Redacted form: plstring3(x, y, z, string)\n\
9882 This function is used in example 18.\n\
9888 plstring3(n, x, y, z, string)\n\
9892 n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
9894 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9897 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9900 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
9903 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
9904 the glyph(s) to be plotted at each of the n points. points.\n\
9907 Switch to text screen\n\
9911 Sets an interactive device to text mode, used in conjunction with\n\
9912 plgra to allow graphics and text to be interspersed. On a device\n\
9913 which supports separate text and graphics windows, this command causes\n\
9914 control to be switched to the text window. This can be useful for\n\
9915 printing diagnostic messages or getting user input, which would\n\
9916 otherwise interfere with the plots. The program must switch back to\n\
9917 the graphics window before issuing plot commands, as the text (or\n\
9918 console) device will probably become quite confused otherwise. If\n\
9919 already in text mode, this command is ignored. It is also ignored on\n\
9920 devices which only support a single window or use a different method\n\
9921 for shifting focus (see also plgra).\n\
9923 Redacted form: pltext()\n\
9925 This function is used in example 1.\n\
9934 Get parameters that define current plot-space window\n\
9938 Get relative minima and maxima that define current plot-space window.\n\
9939 If plsdiplt has not been called the default values pointed to by\n\
9940 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
9942 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9944 This function is used in example 31.\n\
9950 plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9954 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9957 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9960 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9963 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9967 Get the (current) run level\n\
9971 Get the (current) run level. Valid settings are: 0, uninitialized\n\
9973 2, viewport defined\n\
9974 3, world coordinates defined\n\
9977 Redacted form: plglevel(p_level)\n\
9979 This function is used in example 31.\n\
9985 plglevel(p_level)\n\
9989 p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
9993 Plot a histogram from binned data\n\
9997 Plots a histogram consisting of nbin bins. The value associated with\n\
9998 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
9999 placed in y[i]. For proper operation, the values in x[i] must form a\n\
10000 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
10001 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
10002 placed midway between the values in the x vector. Also see plhist for\n\
10003 drawing histograms from unbinned data.\n\
10005 Redacted form: General: plbin(x, y, opt)\n\
10006 Python: plbin(nbin, x, y, opt)\n\
10009 This function is not used in any examples.\n\
10015 plbin(nbin, x, y, opt)\n\
10019 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
10022 x (PLFLT_VECTOR, input) : A vector containing values associated\n\
10023 with bins. These must form a strictly increasing sequence.\n\
10025 y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
10026 proportional to the number of points in each bin. This is a PLFLT\n\
10027 (instead of PLINT) vector so as to allow histograms of\n\
10028 probabilities, etc.\n\
10030 opt (PLINT, input) : Is a combination of several flags:\n\
10031 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
10032 outer bins are expanded to fill up the entire x-axis and bins of\n\
10033 zero height are simply drawn.\n\
10034 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
10035 between the x values. If the values in x are equally spaced,\n\
10036 the values are the center values of the bins.\n\
10037 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
10038 size as the ones inside.\n\
10039 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
10040 (there is a gap for such bins).\n\
10043 Plot a 2D matrix using cmap1\n\
10047 Plot a 2D matrix using cmap1.\n\
10049 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
10050 zmax, valuemin, valuemax, pltr, pltr_data)\n\
10053 This function is used in example 20.\n\
10059 plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
10063 idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
10064 plot. Should have dimensions of\n\
10068 nx, ny (PLINT, input) : Dimensions of idata\n\
10070 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
10071 pltr below for how these arguments are used (only for the special case\n\
10072 when the callback function\n\
10073 pltr is not supplied).\n\
10075 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
10076 (inclusive) will be plotted.\n\
10078 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
10079 values to use for value to color mappings. A datum equal to or\n\
10080 less than valuemin will be plotted with color 0.0, while a datum\n\
10081 equal to or greater than valuemax will be plotted with color 1.0.\n\
10082 Data between valuemin and valuemax map linearly to colors in the\n\
10083 range (0.0-1.0).\n\
10085 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
10086 defines the transformation between the zero-based indices of the\n\
10087 matrix idata and world coordinates. If\n\
10088 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
10089 indices of idata are mapped to the range\n\
10091 xmax and the y indices of idata are mapped to the range\n\
10093 ymax.For the C case, transformation functions are provided in the\n\
10094 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
10095 pltr2 for arbitrary mappings respectively defined by vectors and\n\
10096 matrices. In addition, C callback routines for the transformation\n\
10097 can be supplied by the user such as the mypltr function in\n\
10098 examples/c/x09c.c which provides a general linear transformation\n\
10099 between index coordinates and world coordinates.For languages\n\
10100 other than C you should consult the PLplot documentation for the\n\
10101 details concerning how PLTRANSFORM_callback arguments are\n\
10102 interfaced. However, in general, a particular pattern of\n\
10103 callback-associated arguments such as a tr vector with 6 elements;\n\
10104 xg and yg vectors; or xg and yg matrices are respectively\n\
10105 interfaced to a linear-transformation routine similar to the above\n\
10106 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
10107 sophisticated bindings (see, e.g., the PLplot documentation)\n\
10108 support native language callbacks for handling index to\n\
10109 world-coordinate transformations. Examples of these various\n\
10110 approaches are given in examples/<language>x09*,\n\
10111 examples/<language>x16*, examples/<language>x20*,\n\
10112 examples/<language>x21*, and examples/<language>x22*, for all our\n\
10113 supported languages.\n\
10115 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
10116 information to pltr0, pltr1, pltr2, or whatever routine is\n\
10117 externally supplied.\n\
10120 Get family, style and weight of the current font\n\
10124 Gets information about current font. See the PLplot documentation for\n\
10125 more information on font selection.\n\
10127 Redacted form: plgfont(p_family, p_style, p_weight)\n\
10129 This function is used in example 23.\n\
10135 plgfont(p_family, p_style, p_weight)\n\
10139 p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10140 font family. The available values are given by the PL_FCI_*\n\
10141 constants in plplot.h. Current options are PL_FCI_SANS,\n\
10142 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
10143 p_family is NULL then the font family is not returned.\n\
10145 p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10146 font style. The available values are given by the PL_FCI_*\n\
10147 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
10148 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
10149 style is not returned.\n\
10151 p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10152 font weight. The available values are given by the PL_FCI_*\n\
10153 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
10154 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
10158 Get z axis parameters\n\
10162 Identical to plgxax, except that arguments are flags for z axis. See\n\
10163 the description of plgxax for more detail.\n\
10165 Redacted form: plgzax(p_digmax, p_digits)\n\
10167 This function is used in example 31.\n\
10173 plgzax(p_digmax, p_digits)\n\
10177 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
10178 number of digits for the z axis. If nonzero, the printed label\n\
10179 has been switched to a floating-point representation when the\n\
10180 number of digits exceeds this value.\n\
10182 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
10183 number of digits for the numeric labels (z axis) from the last\n\
10187 Write text inside the viewport of a 3D plot\n\
10191 Writes text at a specified position and inclination and with a\n\
10192 specified shear within the viewport. Text is clipped at the viewport\n\
10193 boundaries. The reference point of a string lies along a line passing\n\
10194 through the string at half the height of a capital letter. The\n\
10195 position of the reference point along this line is determined by just,\n\
10196 and the reference point is placed at world coordinates (\n\
10199 wz) within the viewport. The inclination and shear of the string is\n\
10200 specified in terms of differences of world coordinates making it easy\n\
10201 to write text parallel to a line in a graph.\n\
10203 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
10205 This function is used in example 28.\n\
10211 plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
10215 wx (PLFLT, input) : x world coordinate of reference point of\n\
10218 wy (PLFLT, input) : y world coordinate of reference point of\n\
10221 wz (PLFLT, input) : z world coordinate of reference point of\n\
10224 dx (PLFLT, input) : Together with dy and\n\
10225 dz , this specifies the inclination of the string. The baseline of\n\
10226 the string is parallel to a line joining (\n\
10237 dy (PLFLT, input) : Together with dx and\n\
10238 dz, this specifies the inclination of the string.\n\
10240 dz (PLFLT, input) : Together with dx and\n\
10241 dy, this specifies the inclination of the string.\n\
10243 sx (PLFLT, input) : Together with sy and\n\
10244 sz , this specifies the shear of the string. The string is sheared so\n\
10245 that the characters are vertically parallel to a line joining (\n\
10256 sz = 0.) then the text is not sheared.\n\
10258 sy (PLFLT, input) : Together with sx and\n\
10259 sz, this specifies shear of the string.\n\
10261 sz (PLFLT, input) : Together with sx and\n\
10262 sy, this specifies shear of the string.\n\
10264 just (PLFLT, input) : Specifies the position of the string relative\n\
10265 to its reference point. If just=0. , the reference point is at\n\
10266 the left and if just=1. , it is at the right of the string. Other\n\
10267 values of just give intermediate justifications.\n\
10269 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
10273 Draw a box with axes, etc. with arbitrary origin\n\
10277 Draws a box around the currently defined viewport with arbitrary\n\
10278 world-coordinate origin specified by x0 and y0 and labels it with\n\
10279 world coordinate values appropriate to the window. Thus plaxes should\n\
10280 only be called after defining both viewport and window. The ascii\n\
10281 character strings xopt and yopt specify how the box should be drawn as\n\
10282 described below. If ticks and/or subticks are to be drawn for a\n\
10283 particular axis, the tick intervals and number of subintervals may be\n\
10284 specified explicitly, or they may be defaulted by setting the\n\
10285 appropriate arguments to zero.\n\
10287 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
10291 This function is not used in any examples.\n\
10297 plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
10301 x0 (PLFLT, input) : World X coordinate of origin.\n\
10303 y0 (PLFLT, input) : World Y coordinate of origin.\n\
10305 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10306 options for the x axis. The string can include any combination of\n\
10307 the following letters (upper or lower case) in any order: a: Draws\n\
10308 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
10310 b: Draws bottom (X) or left (Y) edge of frame.\n\
10311 c: Draws top (X) or right (Y) edge of frame.\n\
10312 d: Plot labels as date / time. Values are assumed to be\n\
10313 seconds since the epoch (as used by gmtime).\n\
10314 f: Always use fixed point numeric labels.\n\
10315 g: Draws a grid at the major tick interval.\n\
10316 h: Draws a grid at the minor tick interval.\n\
10317 i: Inverts tick marks, so they are drawn outwards, rather than\n\
10319 l: Labels axis logarithmically. This only affects the labels,\n\
10320 not the data, and so it is necessary to compute the logarithms\n\
10321 of data points before passing them to any of the drawing\n\
10323 m: Writes numeric labels at major tick intervals in the\n\
10324 unconventional location (above box for X, right of box for Y).\n\
10325 n: Writes numeric labels at major tick intervals in the\n\
10326 conventional location (below box for X, left of box for Y).\n\
10327 o: Use custom labelling function to generate axis label text.\n\
10328 The custom labelling function can be defined with the\n\
10329 plslabelfunc command.\n\
10330 s: Enables subticks between major ticks, only valid if t is\n\
10332 t: Draws major ticks.\n\
10333 u: Exactly like \"b\" except don\'t draw edge line.\n\
10334 w: Exactly like \"c\" except don\'t draw edge line.\n\
10335 x: Exactly like \"t\" (including the side effect of the\n\
10336 numerical labels for the major ticks) except exclude drawing\n\
10337 the major and minor tick marks.\n\
10340 xtick (PLFLT, input) : World coordinate interval between major\n\
10341 ticks on the x axis. If it is set to zero, PLplot automatically\n\
10342 generates a suitable tick interval.\n\
10344 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
10345 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
10346 generates a suitable minor tick interval.\n\
10348 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10349 options for the y axis. The string can include any combination of\n\
10350 the letters defined above for xopt, and in addition may contain:\n\
10351 v: Write numeric labels for the y axis parallel to the base of the\n\
10352 graph, rather than parallel to the axis.\n\
10355 ytick (PLFLT, input) : World coordinate interval between major\n\
10356 ticks on the y axis. If it is set to zero, PLplot automatically\n\
10357 generates a suitable tick interval.\n\
10359 nysub (PLINT, input) : Number of subintervals between major y axis\n\
10360 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
10361 generates a suitable minor tick interval.\n\
10364 Returns the background color (cmap0[0]) by 8-bit RGB value\n\
10368 Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
10370 Redacted form: plgcolbg(r, g, b)\n\
10372 This function is used in example 31.\n\
10378 plgcolbg(r, g, b)\n\
10382 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
10383 in the range from 0 to 255.\n\
10385 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
10386 in the range from 0 to 255.\n\
10388 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
10389 in the range from 0 to 255.\n\
10392 Plot a glyph at the specified 3D points\n\
10396 Plot a glyph at the specified 3D points. (This function is largely\n\
10397 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
10398 Set up the call to this function similar to what is done for plline3.\n\
10399 code=-1 means try to just draw a point. Right now it\'s just a move\n\
10400 and a draw at the same place. Not ideal, since a sufficiently\n\
10401 intelligent output device may optimize it away, or there may be faster\n\
10402 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
10403 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
10404 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
10405 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
10406 code <= 127 the corresponding printable ASCII character is plotted.\n\
10408 Redacted form: plpoin3(x, y, z, code)\n\
10410 This function is not used in any example.\n\
10416 plpoin3(n, x, y, z, code)\n\
10420 n (PLINT, input) : Number of points in the x and y vectors.\n\
10422 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
10425 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10428 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
10431 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
10432 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
10433 each of the n points.\n\
10436 Draw a polygon in 3 space\n\
10440 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10441 like plline3, but differs from that function in that plpoly3 attempts\n\
10442 to determine if the polygon is viewable depending on the order of the\n\
10443 points within the vector and the value of ifcc. If the back of\n\
10444 polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10445 you want, then use plline3 instead.\n\
10447 The points are assumed to be in a plane, and the directionality of the\n\
10448 plane is determined from the first three points. Additional points do\n\
10449 not have to lie on the plane defined by the first three, but if they\n\
10450 do not, then the determination of visibility obviously can\'t be 100%\n\
10451 accurate... So if you\'re 3 space polygons are too far from planar,\n\
10452 consider breaking them into smaller polygons. 3 points define a plane\n\
10455 Bugs: If one of the first two segments is of zero length, or if they\n\
10456 are co-linear, the calculation of visibility has a 50/50 chance of\n\
10457 being correct. Avoid such situations :-). See x18c.c for an example\n\
10458 of this problem. (Search for 20.1).\n\
10460 Redacted form: plpoly3(x, y, z, code)\n\
10462 This function is used in example 18.\n\
10468 plpoly3(n, x, y, z, draw, ifcc)\n\
10472 n (PLINT, input) : Number of points defining line.\n\
10474 x (PLFLT_VECTOR, input) : A vector containing\n\
10475 n x coordinates of points.\n\
10477 y (PLFLT_VECTOR, input) : A vector containing\n\
10478 n y coordinates of points.\n\
10480 z (PLFLT_VECTOR, input) : A vector containing\n\
10481 n z coordinates of points.\n\
10483 draw (PLBOOL_VECTOR, input) : A vector containing\n\
10484 n-1 Boolean values which control drawing the segments of the polygon.\n\
10485 If draw[i] is true, then the polygon segment from index [i] to\n\
10486 [i+1] is drawn, otherwise, not.\n\
10488 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10489 polygon is determined by assuming the points are laid out in a\n\
10490 counter-clockwise order. Otherwise, the directionality of the\n\
10491 polygon is determined by assuming the points are laid out in a\n\
10492 clockwise order.\n\
10495 Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
10499 Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
10500 PLFLT alpha transparency value (see the PLplot documentation).\n\
10502 This function is used in example 31.\n\
10508 plscolbga(r, g, b, alpha)\n\
10512 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10513 degree of red in the color.\n\
10515 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10516 degree of green in the color.\n\
10518 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10519 degree of blue in the color.\n\
10521 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
10525 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
10529 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
10530 alpha transparency value.\n\
10532 This function is used in example 31.\n\
10538 plgcolbga(r, g, b, alpha)\n\
10542 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
10543 in the range from 0 to 255.\n\
10545 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
10546 in the range from 0 to 255.\n\
10548 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
10549 in the range from 0 to 255.\n\
10551 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
10552 transparency in the range (0.0-1.0).\n\
10555 Draw error bars in x direction\n\
10559 Draws a set of n error bars in x direction, the i\'th error bar\n\
10560 extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
10561 of the error bars are of length equal to the minor tick length\n\
10562 (settable using plsmin).\n\
10564 Redacted form: General: plerrx(xmin, ymax, y)\n\
10567 This function is used in example 29.\n\
10573 plerrx(n, xmin, xmax, y)\n\
10577 n (PLINT, input) : Number of error bars to draw.\n\
10579 xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10580 of the left-hand endpoints of the error bars.\n\
10582 xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10583 of the right-hand endpoints of the error bars.\n\
10585 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10589 Eject current page\n\
10593 Clears the graphics screen of an interactive device, or ejects a page\n\
10594 on a plotter. See plbop for more information.\n\
10596 Redacted form: pleop()\n\
10598 This function is used in example 2,14.\n\
10607 Convert HLS color to RGB\n\
10611 Convert HLS color coordinates to RGB.\n\
10613 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10616 This function is used in example 2.\n\
10622 plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10626 h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
10629 l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
10630 the axis of the color cylinder.\n\
10632 s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
10633 the radius of the color cylinder.\n\
10635 p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
10636 (0.0-1.0) of the color.\n\
10638 p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
10639 intensity (0.0-1.0) of the color.\n\
10641 p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
10642 intensity (0.0-1.0) of the color.\n\
10645 Plot all or a subset of Shapefile data, filling the polygons\n\
10649 As per plmapline, however the items are filled in the same way as\n\
10652 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
10655 This function is used in example 19.\n\
10661 plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
10665 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
10666 transform the coordinates given in the shapefile into a plot\n\
10667 coordinate system. By using this transform, we can change from a\n\
10668 longitude, latitude coordinate to a polar stereographic project,\n\
10669 for example. Initially, x[0]..[n-1] are the longitudes and\n\
10670 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
10671 mapform(), x[] and y[] should be replaced by the corresponding\n\
10672 plot coordinates. If no transform is desired, mapform can be\n\
10673 replaced by NULL.\n\
10675 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10676 the file name of a set of Shapefile files without the file\n\
10679 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
10680 be in the same units as used by the Shapefile. You could use a\n\
10681 very large negative number to plot everything, but you can improve\n\
10682 performance by limiting the area drawn. The units must match those\n\
10683 of the Shapefile projection, which may be for example longitude or\n\
10684 distance. The value of minx must be less than the value of maxx.\n\
10686 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
10687 use a very large number to plot everything, but you can improve\n\
10688 performance by limiting the area drawn.\n\
10690 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
10691 be in the same units as used by the Shapefile. You could use a\n\
10692 very large negative number to plot everything, but you can improve\n\
10693 performance by limiting the area drawn. The units must match those\n\
10694 of the Shapefile projection, which may be for example latitude or\n\
10695 distance. The value of miny must be less than the value of maxy.\n\
10697 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
10698 use a very large number to plot everything, but you can improve\n\
10699 performance by limiting the area drawn.\n\
10701 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
10702 zero-based indices of the Shapefile elements which will be drawn.\n\
10704 plotentries to NULL will plot all elements of the Shapefile.\n\
10706 nplotentries (PLINT, input) : The number of items in\n\
10707 plotentries. Ignored if\n\
10708 plotentries is NULL.\n\
10711 Draw error bars in the y direction\n\
10715 Draws a set of n error bars in the y direction, the i\'th error bar\n\
10716 extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
10717 of the error bars are of length equal to the minor tick length\n\
10718 (settable using plsmin).\n\
10720 Redacted form: General: plerry(x, ymin, ymax)\n\
10723 This function is used in example 29.\n\
10729 plerry(n, x, ymin, ymax)\n\
10733 n (PLINT, input) : Number of error bars to draw.\n\
10735 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
10738 ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10739 of the lower endpoints of the error bars.\n\
10741 ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10742 of the upper endpoints of the error bars.\n\
10745 Set FCI (font characterization integer)\n\
10749 Sets font characteristics to be used at the start of the next string\n\
10750 using the FCI approach. See the PLplot documentation for more\n\
10751 information. Note, plsfont (which calls plsfci internally) provides a\n\
10752 more user-friendly API for setting the font characterisitics.\n\
10754 Redacted form: General: plsfci(fci)\n\
10757 This function is used in example 23.\n\
10767 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
10771 Select area fill pattern\n\
10776 patt is zero or less use either a hardware solid fill if the drivers\n\
10777 have that capability (virtually all do) or fall back to a software\n\
10778 emulation of a solid fill using the eighth area line fill pattern. If\n\
10780 patt <= 8, then select one of eight predefined area line fill patterns\n\
10781 to use (see plpat if you desire other patterns).\n\
10783 Redacted form: plpsty(patt)\n\
10785 This function is used in examples 12, 13, 15, 16, and 25.\n\
10795 patt (PLINT, input) : The desired pattern index. If\n\
10796 patt is zero or less, then a solid fill is (normally, see qualifiers\n\
10797 above) used. For\n\
10798 patt in the range from 1 to 8 and assuming the driver has not supplied\n\
10799 line fill capability itself (most deliberately do not so that line\n\
10800 fill patterns look identical for those drivers), the patterns\n\
10801 consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
10802 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
10803 lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
10804 (8) lines at both 45 degrees and -45 degrees.\n\
10811 This sets up the size of all subsequent symbols drawn by plpoin and\n\
10812 plsym. The actual height of a symbol is the product of the default\n\
10813 symbol size and a scaling factor as for the character height.\n\
10815 Redacted form: plssym(def, scale)\n\
10817 This function is used in example 29.\n\
10823 plssym(def, scale)\n\
10827 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
10828 should be set to zero if the default height is to remain\n\
10831 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
10832 actual symbol height.\n\
10839 Alternative to plstar for initializing the plotting package. The\n\
10840 device name keyword for the desired output device must be supplied as\n\
10841 an argument. These keywords are the same as those printed out by\n\
10842 plstar. If the requested device is not available, or if the input\n\
10843 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
10844 is used. This routine also divides the output device page into nx by\n\
10845 ny subpages, each of which may be used independently. The subroutine\n\
10846 pladv is used to advance from one subpage to the next.\n\
10848 Redacted form: General: plstart(devname, nx, ny)\n\
10851 This function is not used in any examples.\n\
10857 plstart(devname, nx, ny)\n\
10861 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
10862 containing the device name keyword of the required output device.\n\
10864 devname is NULL or if the first character of the string is a ``?\'\',\n\
10865 the normal (prompted) start up is used.\n\
10867 nx (PLINT, input) : Number of subpages to divide output page in the\n\
10870 ny (PLINT, input) : Number of subpages to divide output page in the\n\
10877 char **arg3 = (
char **) 0 ;
10879 octave_value_list _out;
10880 octave_value_list *_outp=&_out;
10881 octave_value _outv;
10888 if (
_n_dims( args(0) ) > 1 )
10894 temp1 = args(0).matrix_value();
10898 charMatrix temp_matrix;
10902 size_t max_length = 0, non_blank_length;
10904 if (
_n_dims( args(1) ) > 2 )
10906 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
10908 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10909 if ( !args(1).isempty() )
10911 if ( !args(1).is_empty() )
10916 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
10918 arg3 =
new char*[
Alen];
10919 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10920 ifcell = args(1).iscell();
10922 ifcell = args(1).is_cell();
10926 temp_cell = args(1).cell_value();
10930 temp_matrix = args(1).char_matrix_value();
10932 max_length =
_dim( args(1), 1 ) + 1;
10935 for ( i = 0; i <
Alen; i++ )
10942 if ( temp_cell.elem( i ).is_string() )
10944 str = temp_cell.elem( i ).string_value();
10946 max_length = str.size() + 1;
10947 tmp_cstring = (
char *) str.c_str();
10957 tmp_cstring = (
char *)
"";
10962 str = temp_matrix.row_as_string( i );
10963 tmp_cstring = (
char *) str.c_str();
10965 arg3[i] =
new char[max_length];
10966 strncpy( arg3[i], tmp_cstring, max_length - 1 );
10967 arg3[i][max_length - 1] =
'\0';
10982 non_blank_length = max_length - 2;
10983 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
'\0' )
10985 non_blank_length--;
10987 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
' ' )
10989 non_blank_length--;
10991 arg3[i][non_blank_length + 1] =
'\0';
11000 testppchar(arg1,(
int const *)arg2,(
char const **)arg3);
11001 _outv = octave_value();
11008 if ( arg3 != NULL )
11010 for ( i = 0; i <
Alen; i++ )
11024 if ( arg3 != NULL )
11026 for ( i = 0; i <
Alen; i++ )
11033 return octave_value_list();
11041 if ( arg3 != NULL )
11043 for ( i = 0; i <
Alen; i++ )
11056 int *arg1 = (
int *) 0 ;
11057 int *arg2 = (
int *) 0 ;
11058 int *arg3 = (
int *) 0 ;
11059 char *arg4 = (
char *) 0 ;
11060 int *arg5 = (
int *) 0 ;
11061 int *arg6 = (
int *) 0 ;
11066 int *arg11 = (
int *) 0 ;
11073 char local_string4[80] ;
11088 size_t local_string_length4 ;
11089 charMatrix local_charMatrix4 ;
11090 octave_value_list retval4 ;
11091 octave_value_list _out;
11092 octave_value_list *_outp=&_out;
11093 octave_value _outv;
11101 arg4 = local_string4;
11113 result = (int)
my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11135 local_string_length4 = strlen( local_string4 );
11136 local_charMatrix4 = charMatrix( 1, local_string_length4 );
11137 local_charMatrix4.insert( local_string4, 0, 0 );
11138 retval4( 0 ) = octave_value( local_charMatrix4 );
11185 return octave_value_list();
11206 octave_value_list _out;
11207 octave_value_list *_outp=&_out;
11208 octave_value _outv;
11221 arg3 =
static_cast< PLFLT >(val3);
11226 arg4 =
static_cast< PLFLT >(val4);
11244 return octave_value_list();
11254 char *arg2 = (
char *) 0 ;
11255 char *arg3 = (
char *) 0 ;
11269 char *arg17 = (
char *) 0 ;
11270 char *arg18 = (
char *) 0 ;
11271 char *arg19 = (
char *) 0 ;
11272 char *arg20 = (
char *) 0 ;
11273 char *arg21 = (
char *) 0 ;
11274 char *arg22 = (
char *) 0 ;
11275 char *arg23 = (
char *) 0 ;
11329 octave_value_list _out;
11330 octave_value_list *_outp=&_out;
11331 octave_value _outv;
11342 arg2 =
reinterpret_cast< char *
>(buf2);
11347 arg3 =
reinterpret_cast< char *
>(buf3);
11352 arg4 =
static_cast< PLFLT >(val4);
11357 arg5 =
static_cast< PLFLT >(val5);
11362 arg6 =
static_cast< PLFLT >(val6);
11367 arg7 =
static_cast< PLFLT >(val7);
11372 arg8 =
static_cast< PLFLT >(val8);
11377 arg9 =
static_cast< PLFLT >(val9);
11382 arg10 =
static_cast< PLFLT >(val10);
11387 arg11 =
static_cast< PLBOOL >(val11);
11392 arg12 =
static_cast< PLBOOL >(val12);
11397 arg13 =
static_cast< PLINT >(val13);
11402 arg14 =
static_cast< PLINT >(val14);
11404 if (
_n_dims( args(13) ) > 1 )
11409 temp15 = args(13).matrix_value();
11414 if (
_n_dims( args(14) ) > 1 )
11418 if (
_dim( args(14), 0 ) !=
Alen )
11422 temp16 = args(14).matrix_value();
11430 arg17 =
reinterpret_cast< char *
>(buf17);
11435 arg18 =
reinterpret_cast< char *
>(buf18);
11440 arg19 =
reinterpret_cast< char *
>(buf19);
11445 arg20 =
reinterpret_cast< char *
>(buf20);
11450 arg21 =
reinterpret_cast< char *
>(buf21);
11455 arg22 =
reinterpret_cast< char *
>(buf22);
11460 arg23 =
reinterpret_cast< char *
>(buf23);
11461 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);
11462 _outv = octave_value();
11502 return octave_value_list();
11547 octave_value_list _out;
11548 octave_value_list *_outp=&_out;
11549 octave_value _outv;
11556 if (
_n_dims( args(0) ) > 2 )
11558 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11560 temp1 = args(0).matrix_value();
11561 arg1 = &temp1( 0, 0 );
11569 arg4 =
static_cast< PLINT >(val4);
11574 arg5 =
static_cast< PLINT >(val5);
11579 arg6 =
static_cast< PLINT >(val6);
11584 arg7 =
static_cast< PLINT >(val7);
11586 if (
_n_dims( args(5) ) > 1 )
11590 temp8 = args(5).matrix_value();
11591 arg8 = &temp8( 0, 0 );
11595 if (
_n_dims( args(6) ) > 1 )
11599 if (
_dim( args(6), 0 ) != 6 )
11603 temp10 = args(6).matrix_value();
11604 arg10 = &temp10( 0, 0 );
11606 my_plcont((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10);
11607 _outv = octave_value();
11629 return octave_value_list();
11666 octave_value_list _out;
11667 octave_value_list *_outp=&_out;
11668 octave_value _outv;
11675 if (
_n_dims( args(0) ) > 2 )
11677 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11679 temp1 = args(0).matrix_value();
11680 arg1 = &temp1( 0, 0 );
11688 arg4 =
static_cast< PLINT >(val4);
11693 arg5 =
static_cast< PLINT >(val5);
11698 arg6 =
static_cast< PLINT >(val6);
11703 arg7 =
static_cast< PLINT >(val7);
11705 if (
_n_dims( args(5) ) > 1 )
11709 temp8 = args(5).matrix_value();
11710 arg8 = &temp8( 0, 0 );
11713 my_plcont0((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9);
11714 _outv = octave_value();
11730 return octave_value_list();
11768 octave_value_list _out;
11769 octave_value_list *_outp=&_out;
11770 octave_value _outv;
11777 if (
_n_dims( args(0) ) > 2 )
11779 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11781 temp1 = args(0).matrix_value();
11782 arg1 = &temp1( 0, 0 );
11790 arg4 =
static_cast< PLINT >(val4);
11795 arg5 =
static_cast< PLINT >(val5);
11800 arg6 =
static_cast< PLINT >(val6);
11805 arg7 =
static_cast< PLINT >(val7);
11807 if (
_n_dims( args(5) ) > 1 )
11811 temp8 = args(5).matrix_value();
11812 arg8 = &temp8( 0, 0 );
11816 if (
_n_dims( args(6) ) > 1 )
11824 temp10 = args(6).matrix_value();
11825 arg10 = &temp10( 0, 0 );
11828 if (
_n_dims( args(7) ) > 1 )
11836 temp11 = args(7).matrix_value();
11837 arg11 = &temp11( 0, 0 );
11839 my_plcont1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11840 _outv = octave_value();
11868 return octave_value_list();
11912 octave_value_list _out;
11913 octave_value_list *_outp=&_out;
11914 octave_value _outv;
11921 if (
_n_dims( args(0) ) > 2 )
11923 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11925 temp1 = args(0).matrix_value();
11926 arg1 = &temp1( 0, 0 );
11934 arg4 =
static_cast< PLINT >(val4);
11939 arg5 =
static_cast< PLINT >(val5);
11944 arg6 =
static_cast< PLINT >(val6);
11949 arg7 =
static_cast< PLINT >(val7);
11951 if (
_n_dims( args(5) ) > 1 )
11955 temp8 = args(5).matrix_value();
11956 arg8 = &temp8( 0, 0 );
11960 if (
_n_dims( args(6) ) > 2 )
11962 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11966 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11970 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11972 temp10 = args(6).matrix_value();
11973 arg10 = &temp10( 0, 0 );
11976 if (
_n_dims( args(7) ) > 2 )
11978 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11982 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
11986 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
11988 temp11 = args(7).matrix_value();
11989 arg11 = &temp11( 0, 0 );
11991 my_plcont2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11992 _outv = octave_value();
12020 return octave_value_list();
12064 octave_value_list _out;
12065 octave_value_list *_outp=&_out;
12066 octave_value _outv;
12073 if (
_n_dims( args(0) ) > 2 )
12075 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12077 temp1 = args(0).matrix_value();
12078 arg1 = &temp1( 0, 0 );
12086 arg4 =
static_cast< PLINT >(val4);
12091 arg5 =
static_cast< PLINT >(val5);
12096 arg6 =
static_cast< PLINT >(val6);
12101 arg7 =
static_cast< PLINT >(val7);
12103 if (
_n_dims( args(5) ) > 1 )
12107 temp8 = args(5).matrix_value();
12108 arg8 = &temp8( 0, 0 );
12112 if (
_n_dims( args(6) ) > 2 )
12114 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12118 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12122 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12124 temp10 = args(6).matrix_value();
12125 arg10 = &temp10( 0, 0 );
12128 if (
_n_dims( args(7) ) > 2 )
12130 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12134 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12138 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12140 temp11 = args(7).matrix_value();
12141 arg11 = &temp11( 0, 0 );
12143 my_plcont2p((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
12144 _outv = octave_value();
12172 return octave_value_list();
12209 octave_value_list retval7 ;
12214 octave_value_list _out;
12215 octave_value_list *_outp=&_out;
12216 octave_value _outv;
12223 if (
_n_dims( args(0) ) > 1 )
12228 temp1 = args(0).matrix_value();
12229 arg1 = &temp1( 0, 0 );
12232 if (
_n_dims( args(1) ) > 1 )
12240 temp2 = args(1).matrix_value();
12241 arg2 = &temp2( 0, 0 );
12244 if (
_n_dims( args(2) ) > 1 )
12252 temp3 = args(2).matrix_value();
12253 arg3 = &temp3( 0, 0 );
12257 if (
_n_dims( args(3) ) > 1 )
12261 temp5 = args(3).matrix_value();
12262 arg5 = &temp5( 0, 0 );
12266 if (
_n_dims( args(4) ) > 1 )
12270 temp7 = args(4).matrix_value();
12271 arg7 = &temp7( 0, 0 );
12273 retval7( 0 ) = octave_value( Matrix(
Xlen,
Ylen ) );
12274 arg9 = (
PLFLT *) retval7( 0 ).matrix_value().data();
12280 arg10 =
static_cast< PLINT >(val10);
12285 arg11 =
static_cast< PLFLT >(val11);
12286 my_plgriddata((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,(
double const *)arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,arg11);
12287 _outv = octave_value();
12324 return octave_value_list();
12359 octave_value_list _out;
12360 octave_value_list *_outp=&_out;
12361 octave_value _outv;
12368 if (
_n_dims( args(0) ) > 1 )
12372 temp1 = args(0).matrix_value();
12373 arg1 = &temp1( 0, 0 );
12377 if (
_n_dims( args(1) ) > 1 )
12381 temp2 = args(1).matrix_value();
12382 arg2 = &temp2( 0, 0 );
12386 if (
_n_dims( args(2) ) > 2 )
12388 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12392 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12396 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12398 temp3 = args(2).matrix_value();
12399 arg3 = &temp3( 0, 0 );
12407 arg6 =
static_cast< PLINT >(val6);
12408 my_plmesh((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6);
12409 _outv = octave_value();
12431 return octave_value_list();
12463 octave_value_list _out;
12464 octave_value_list *_outp=&_out;
12465 octave_value _outv;
12472 if (
_n_dims( args(0) ) > 1 )
12476 temp1 = args(0).matrix_value();
12477 arg1 = &temp1( 0, 0 );
12481 if (
_n_dims( args(1) ) > 1 )
12485 temp2 = args(1).matrix_value();
12486 arg2 = &temp2( 0, 0 );
12490 if (
_n_dims( args(2) ) > 2 )
12492 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12496 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12500 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12502 temp3 = args(2).matrix_value();
12503 arg3 = &temp3( 0, 0 );
12511 arg6 =
static_cast< PLINT >(val6);
12513 if (
_n_dims( args(4) ) > 1 )
12517 temp7 = args(4).matrix_value();
12518 arg7 = &temp7( 0, 0 );
12521 my_plmeshc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12522 _outv = octave_value();
12550 return octave_value_list();
12585 octave_value_list _out;
12586 octave_value_list *_outp=&_out;
12587 octave_value _outv;
12594 if (
_n_dims( args(0) ) > 1 )
12598 temp1 = args(0).matrix_value();
12599 arg1 = &temp1( 0, 0 );
12603 if (
_n_dims( args(1) ) > 1 )
12607 temp2 = args(1).matrix_value();
12608 arg2 = &temp2( 0, 0 );
12612 if (
_n_dims( args(2) ) > 2 )
12614 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12618 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12622 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12624 temp3 = args(2).matrix_value();
12625 arg3 = &temp3( 0, 0 );
12633 arg6 =
static_cast< PLINT >(val6);
12638 arg7 =
static_cast< PLBOOL >(val7);
12639 my_plot3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,arg7);
12640 _outv = octave_value();
12662 return octave_value_list();
12694 octave_value_list _out;
12695 octave_value_list *_outp=&_out;
12696 octave_value _outv;
12703 if (
_n_dims( args(0) ) > 1 )
12707 temp1 = args(0).matrix_value();
12708 arg1 = &temp1( 0, 0 );
12712 if (
_n_dims( args(1) ) > 1 )
12716 temp2 = args(1).matrix_value();
12717 arg2 = &temp2( 0, 0 );
12721 if (
_n_dims( args(2) ) > 2 )
12723 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12727 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12731 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12733 temp3 = args(2).matrix_value();
12734 arg3 = &temp3( 0, 0 );
12742 arg6 =
static_cast< PLINT >(val6);
12744 if (
_n_dims( args(4) ) > 1 )
12748 temp7 = args(4).matrix_value();
12749 arg7 = &temp7( 0, 0 );
12752 my_plot3dc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12753 _outv = octave_value();
12781 return octave_value_list();
12824 octave_value_list _out;
12825 octave_value_list *_outp=&_out;
12826 octave_value _outv;
12833 if (
_n_dims( args(0) ) > 1 )
12837 temp1 = args(0).matrix_value();
12838 arg1 = &temp1( 0, 0 );
12842 if (
_n_dims( args(1) ) > 1 )
12846 temp2 = args(1).matrix_value();
12847 arg2 = &temp2( 0, 0 );
12851 if (
_n_dims( args(2) ) > 2 )
12853 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12857 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12861 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12863 temp3 = args(2).matrix_value();
12864 arg3 = &temp3( 0, 0 );
12872 arg6 =
static_cast< PLINT >(val6);
12874 if (
_n_dims( args(4) ) > 1 )
12878 temp7 = args(4).matrix_value();
12879 arg7 = &temp7( 0, 0 );
12886 arg9 =
static_cast< PLINT >(val9);
12888 if (
_n_dims( args(6) ) > 1 )
12894 temp10 = args(6).matrix_value();
12898 if (
_n_dims( args(7) ) > 1 )
12906 temp12 = args(7).matrix_value();
12910 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);
12911 _outv = octave_value();
12951 return octave_value_list();
12992 octave_value_list _out;
12993 octave_value_list *_outp=&_out;
12994 octave_value _outv;
13001 if (
_n_dims( args(0) ) > 1 )
13005 temp1 = args(0).matrix_value();
13006 arg1 = &temp1( 0, 0 );
13010 if (
_n_dims( args(1) ) > 1 )
13014 temp2 = args(1).matrix_value();
13015 arg2 = &temp2( 0, 0 );
13019 if (
_n_dims( args(2) ) > 2 )
13021 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13025 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13029 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13031 temp3 = args(2).matrix_value();
13032 arg3 = &temp3( 0, 0 );
13040 arg6 =
static_cast< PLINT >(val6);
13042 if (
_n_dims( args(4) ) > 1 )
13046 temp7 = args(4).matrix_value();
13047 arg7 = &temp7( 0, 0 );
13050 my_plsurf3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
13051 _outv = octave_value();
13079 return octave_value_list();
13122 octave_value_list _out;
13123 octave_value_list *_outp=&_out;
13124 octave_value _outv;
13131 if (
_n_dims( args(0) ) > 1 )
13135 temp1 = args(0).matrix_value();
13136 arg1 = &temp1( 0, 0 );
13140 if (
_n_dims( args(1) ) > 1 )
13144 temp2 = args(1).matrix_value();
13145 arg2 = &temp2( 0, 0 );
13149 if (
_n_dims( args(2) ) > 2 )
13151 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13155 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13159 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13161 temp3 = args(2).matrix_value();
13162 arg3 = &temp3( 0, 0 );
13170 arg6 =
static_cast< PLINT >(val6);
13172 if (
_n_dims( args(4) ) > 1 )
13176 temp7 = args(4).matrix_value();
13177 arg7 = &temp7( 0, 0 );
13184 arg9 =
static_cast< PLINT >(val9);
13186 if (
_n_dims( args(6) ) > 1 )
13192 temp10 = args(6).matrix_value();
13196 if (
_n_dims( args(7) ) > 1 )
13204 temp12 = args(7).matrix_value();
13208 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);
13209 _outv = octave_value();
13249 return octave_value_list();
13326 octave_value_list _out;
13327 octave_value_list *_outp=&_out;
13328 octave_value _outv;
13335 if (
_n_dims( args(0) ) > 2 )
13337 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13339 temp1 = args(0).matrix_value();
13340 arg1 = &temp1( 0, 0 );
13345 if (
_n_dims( args(1) ) > 1 )
13350 temp4 = args(1).matrix_value();
13351 arg4 = &temp4( 0, 0 );
13357 arg5 =
static_cast< PLFLT >(val5);
13362 arg6 =
static_cast< PLFLT >(val6);
13367 arg7 =
static_cast< PLFLT >(val7);
13372 arg8 =
static_cast< PLFLT >(val8);
13377 arg9 =
static_cast< PLFLT >(val9);
13382 arg10 =
static_cast< PLFLT >(val10);
13387 arg11 =
static_cast< PLINT >(val11);
13392 arg12 =
static_cast< PLFLT >(val12);
13397 arg13 =
static_cast< PLINT >(val13);
13402 arg14 =
static_cast< PLINT >(val14);
13407 arg15 =
static_cast< PLINT >(val15);
13412 arg16 =
static_cast< PLINT >(val16);
13417 arg17 =
static_cast< PLINT >(val17);
13422 arg18 =
static_cast< PLBOOL >(val18);
13424 if (
_n_dims( args(16) ) > 1 )
13428 if (
_dim( args(16), 0 ) != 6 )
13432 temp19 = args(16).matrix_value();
13433 arg19 = &temp19( 0, 0 );
13435 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);
13436 _outv = octave_value();
13458 return octave_value_list();
13479 char *arg4 = (
char *) 0 ;
13530 octave_value_list _out;
13531 octave_value_list *_outp=&_out;
13532 octave_value _outv;
13539 if (
_n_dims( args(0) ) > 2 )
13541 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13543 temp1 = args(0).matrix_value();
13544 arg1 = &temp1( 0, 0 );
13552 arg4 =
reinterpret_cast< char *
>(buf4);
13557 arg5 =
static_cast< PLFLT >(val5);
13562 arg6 =
static_cast< PLFLT >(val6);
13567 arg7 =
static_cast< PLFLT >(val7);
13572 arg8 =
static_cast< PLFLT >(val8);
13577 arg9 =
static_cast< PLFLT >(val9);
13582 arg10 =
static_cast< PLFLT >(val10);
13587 arg11 =
static_cast< PLINT >(val11);
13592 arg12 =
static_cast< PLFLT >(val12);
13597 arg13 =
static_cast< PLINT >(val13);
13602 arg14 =
static_cast< PLINT >(val14);
13607 arg15 =
static_cast< PLINT >(val15);
13612 arg16 =
static_cast< PLINT >(val16);
13617 arg17 =
static_cast< PLINT >(val17);
13622 arg18 =
static_cast< PLBOOL >(val18);
13624 if (
_n_dims( args(16) ) > 1 )
13628 if (
_dim( args(16), 0 ) !=
Xlen )
13632 temp19 = args(16).matrix_value();
13633 arg19 = &temp19( 0, 0 );
13636 if (
_n_dims( args(17) ) > 1 )
13640 if (
_dim( args(17), 0 ) !=
Ylen )
13644 temp20 = args(17).matrix_value();
13645 arg20 = &temp20( 0, 0 );
13647 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);
13648 _outv = octave_value();
13672 return octave_value_list();
13694 char *arg4 = (
char *) 0 ;
13745 octave_value_list _out;
13746 octave_value_list *_outp=&_out;
13747 octave_value _outv;
13754 if (
_n_dims( args(0) ) > 2 )
13756 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13758 temp1 = args(0).matrix_value();
13759 arg1 = &temp1( 0, 0 );
13767 arg4 =
reinterpret_cast< char *
>(buf4);
13772 arg5 =
static_cast< PLFLT >(val5);
13777 arg6 =
static_cast< PLFLT >(val6);
13782 arg7 =
static_cast< PLFLT >(val7);
13787 arg8 =
static_cast< PLFLT >(val8);
13792 arg9 =
static_cast< PLFLT >(val9);
13797 arg10 =
static_cast< PLFLT >(val10);
13802 arg11 =
static_cast< PLINT >(val11);
13807 arg12 =
static_cast< PLFLT >(val12);
13812 arg13 =
static_cast< PLINT >(val13);
13817 arg14 =
static_cast< PLINT >(val14);
13822 arg15 =
static_cast< PLINT >(val15);
13827 arg16 =
static_cast< PLINT >(val16);
13832 arg17 =
static_cast< PLINT >(val17);
13837 arg18 =
static_cast< PLBOOL >(val18);
13839 if (
_n_dims( args(16) ) > 2 )
13841 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13843 temp19 = args(16).matrix_value();
13844 arg19 = &temp19( 0, 0 );
13849 if (
_n_dims( args(17) ) > 2 )
13851 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13853 temp20 = args(17).matrix_value();
13854 arg20 = &temp20( 0, 0 );
13858 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);
13859 _outv = octave_value();
13883 return octave_value_list();
13933 octave_value_list _out;
13934 octave_value_list *_outp=&_out;
13935 octave_value _outv;
13942 if (
_n_dims( args(0) ) > 2 )
13944 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13946 temp1 = args(0).matrix_value();
13947 arg1 = &temp1( 0, 0 );
13955 arg4 =
static_cast< PLFLT >(val4);
13960 arg5 =
static_cast< PLFLT >(val5);
13965 arg6 =
static_cast< PLFLT >(val6);
13970 arg7 =
static_cast< PLFLT >(val7);
13972 if (
_n_dims( args(5) ) > 1 )
13976 temp8 = args(5).matrix_value();
13977 arg8 = &temp8( 0, 0 );
13984 arg10 =
static_cast< PLINT >(val10);
13989 arg11 =
static_cast< PLINT >(val11);
13994 arg12 =
static_cast< PLINT >(val12);
13999 arg13 =
static_cast< PLBOOL >(val13);
14000 my_plshades((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13);
14001 _outv = octave_value();
14017 return octave_value_list();
14065 octave_value_list _out;
14066 octave_value_list *_outp=&_out;
14067 octave_value _outv;
14074 if (
_n_dims( args(0) ) > 2 )
14076 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14078 temp1 = args(0).matrix_value();
14079 arg1 = &temp1( 0, 0 );
14087 arg4 =
static_cast< PLFLT >(val4);
14092 arg5 =
static_cast< PLFLT >(val5);
14097 arg6 =
static_cast< PLFLT >(val6);
14102 arg7 =
static_cast< PLFLT >(val7);
14104 if (
_n_dims( args(5) ) > 1 )
14108 temp8 = args(5).matrix_value();
14109 arg8 = &temp8( 0, 0 );
14116 arg10 =
static_cast< PLINT >(val10);
14121 arg11 =
static_cast< PLINT >(val11);
14126 arg12 =
static_cast< PLINT >(val12);
14131 arg13 =
static_cast< PLBOOL >(val13);
14133 if (
_n_dims( args(10) ) > 1 )
14137 if (
_dim( args(10), 0 ) != 6 )
14141 temp14 = args(10).matrix_value();
14142 arg14 = &temp14( 0, 0 );
14144 my_plshadesx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
14145 _outv = octave_value();
14167 return octave_value_list();
14220 octave_value_list _out;
14221 octave_value_list *_outp=&_out;
14222 octave_value _outv;
14229 if (
_n_dims( args(0) ) > 2 )
14231 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14233 temp1 = args(0).matrix_value();
14234 arg1 = &temp1( 0, 0 );
14242 arg4 =
static_cast< PLFLT >(val4);
14247 arg5 =
static_cast< PLFLT >(val5);
14252 arg6 =
static_cast< PLFLT >(val6);
14257 arg7 =
static_cast< PLFLT >(val7);
14259 if (
_n_dims( args(5) ) > 1 )
14263 temp8 = args(5).matrix_value();
14264 arg8 = &temp8( 0, 0 );
14271 arg10 =
static_cast< PLINT >(val10);
14276 arg11 =
static_cast< PLINT >(val11);
14281 arg12 =
static_cast< PLINT >(val12);
14286 arg13 =
static_cast< PLBOOL >(val13);
14288 if (
_n_dims( args(10) ) > 1 )
14292 if (
_dim( args(10), 0 ) !=
Xlen )
14296 temp14 = args(10).matrix_value();
14297 arg14 = &temp14( 0, 0 );
14300 if (
_n_dims( args(11) ) > 1 )
14304 if (
_dim( args(11), 0 ) !=
Ylen )
14308 temp15 = args(11).matrix_value();
14309 arg15 = &temp15( 0, 0 );
14311 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);
14312 _outv = octave_value();
14340 return octave_value_list();
14396 octave_value_list _out;
14397 octave_value_list *_outp=&_out;
14398 octave_value _outv;
14405 if (
_n_dims( args(0) ) > 2 )
14407 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14409 temp1 = args(0).matrix_value();
14410 arg1 = &temp1( 0, 0 );
14418 arg4 =
static_cast< PLFLT >(val4);
14423 arg5 =
static_cast< PLFLT >(val5);
14428 arg6 =
static_cast< PLFLT >(val6);
14433 arg7 =
static_cast< PLFLT >(val7);
14435 if (
_n_dims( args(5) ) > 1 )
14439 temp8 = args(5).matrix_value();
14440 arg8 = &temp8( 0, 0 );
14447 arg10 =
static_cast< PLINT >(val10);
14452 arg11 =
static_cast< PLINT >(val11);
14457 arg12 =
static_cast< PLINT >(val12);
14462 arg13 =
static_cast< PLBOOL >(val13);
14464 if (
_n_dims( args(10) ) > 2 )
14466 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14468 temp14 = args(10).matrix_value();
14469 arg14 = &temp14( 0, 0 );
14474 if (
_n_dims( args(11) ) > 2 )
14476 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14478 temp15 = args(11).matrix_value();
14479 arg15 = &temp15( 0, 0 );
14483 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);
14484 _outv = octave_value();
14512 return octave_value_list();
14544 octave_value_list _out;
14545 octave_value_list *_outp=&_out;
14546 octave_value _outv;
14553 if (
_n_dims( args(0) ) > 2 )
14555 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14557 temp1 = args(0).matrix_value();
14558 arg1 = &temp1( 0, 0 );
14563 if (
_n_dims( args(1) ) > 2 )
14565 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14569 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14573 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14575 temp2 = args(1).matrix_value();
14576 arg2 = &temp2( 0, 0 );
14584 arg5 =
static_cast< PLFLT >(val5);
14586 if (
_n_dims( args(3) ) > 1 )
14590 if (
_dim( args(3), 0 ) != 6 )
14594 temp6 = args(3).matrix_value();
14595 arg6 = &temp6( 0, 0 );
14597 my_plvect((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
14598 _outv = octave_value();
14620 return octave_value_list();
14651 octave_value_list _out;
14652 octave_value_list *_outp=&_out;
14653 octave_value _outv;
14660 if (
_n_dims( args(0) ) > 2 )
14662 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14664 temp1 = args(0).matrix_value();
14665 arg1 = &temp1( 0, 0 );
14670 if (
_n_dims( args(1) ) > 2 )
14672 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14676 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14680 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14682 temp2 = args(1).matrix_value();
14683 arg2 = &temp2( 0, 0 );
14691 arg5 =
static_cast< PLFLT >(val5);
14693 if (
_n_dims( args(3) ) > 1 )
14701 temp6 = args(3).matrix_value();
14702 arg6 = &temp6( 0, 0 );
14705 if (
_n_dims( args(4) ) > 1 )
14713 temp7 = args(4).matrix_value();
14714 arg7 = &temp7( 0, 0 );
14716 my_plvect1((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14717 _outv = octave_value();
14745 return octave_value_list();
14779 octave_value_list _out;
14780 octave_value_list *_outp=&_out;
14781 octave_value _outv;
14788 if (
_n_dims( args(0) ) > 2 )
14790 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14792 temp1 = args(0).matrix_value();
14793 arg1 = &temp1( 0, 0 );
14798 if (
_n_dims( args(1) ) > 2 )
14800 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14804 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14808 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14810 temp2 = args(1).matrix_value();
14811 arg2 = &temp2( 0, 0 );
14819 arg5 =
static_cast< PLFLT >(val5);
14821 if (
_n_dims( args(3) ) > 2 )
14823 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14825 temp6 = args(3).matrix_value();
14826 arg6 = &temp6( 0, 0 );
14831 if (
_n_dims( args(4) ) > 2 )
14833 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14835 temp7 = args(4).matrix_value();
14836 arg7 = &temp7( 0, 0 );
14840 my_plvect2((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14841 _outv = octave_value();
14869 return octave_value_list();
14924 octave_value_list _out;
14925 octave_value_list *_outp=&_out;
14926 octave_value _outv;
14933 if (
_n_dims( args(0) ) > 2 )
14935 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14937 temp1 = args(0).matrix_value();
14938 arg1 = &temp1( 0, 0 );
14946 arg4 =
static_cast< PLFLT >(val4);
14951 arg5 =
static_cast< PLFLT >(val5);
14956 arg6 =
static_cast< PLFLT >(val6);
14961 arg7 =
static_cast< PLFLT >(val7);
14966 arg8 =
static_cast< PLFLT >(val8);
14971 arg9 =
static_cast< PLFLT >(val9);
14976 arg10 =
static_cast< PLFLT >(val10);
14981 arg11 =
static_cast< PLFLT >(val11);
14986 arg12 =
static_cast< PLFLT >(val12);
14991 arg13 =
static_cast< PLFLT >(val13);
14992 my_plimage((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14993 _outv = octave_value();
15003 return octave_value_list();
15043 octave_value_list _out;
15044 octave_value_list *_outp=&_out;
15045 octave_value _outv;
15052 if (
_n_dims( args(0) ) > 2 )
15054 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15056 temp1 = args(0).matrix_value();
15057 arg1 = &temp1( 0, 0 );
15065 arg4 =
static_cast< PLFLT >(val4);
15070 arg5 =
static_cast< PLFLT >(val5);
15075 arg6 =
static_cast< PLFLT >(val6);
15080 arg7 =
static_cast< PLFLT >(val7);
15085 arg8 =
static_cast< PLFLT >(val8);
15090 arg9 =
static_cast< PLFLT >(val9);
15095 arg10 =
static_cast< PLFLT >(val10);
15100 arg11 =
static_cast< PLFLT >(val11);
15101 my_plimagefr((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
15102 _outv = octave_value();
15112 return octave_value_list();
15154 octave_value_list _out;
15155 octave_value_list *_outp=&_out;
15156 octave_value _outv;
15163 if (
_n_dims( args(0) ) > 2 )
15165 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15167 temp1 = args(0).matrix_value();
15168 arg1 = &temp1( 0, 0 );
15176 arg4 =
static_cast< PLFLT >(val4);
15181 arg5 =
static_cast< PLFLT >(val5);
15186 arg6 =
static_cast< PLFLT >(val6);
15191 arg7 =
static_cast< PLFLT >(val7);
15196 arg8 =
static_cast< PLFLT >(val8);
15201 arg9 =
static_cast< PLFLT >(val9);
15206 arg10 =
static_cast< PLFLT >(val10);
15211 arg11 =
static_cast< PLFLT >(val11);
15213 if (
_n_dims( args(9) ) > 1 )
15217 if (
_dim( args(9), 0 ) != 6 )
15221 temp12 = args(9).matrix_value();
15222 arg12 = &temp12( 0, 0 );
15224 my_plimagefrx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
15225 _outv = octave_value();
15241 return octave_value_list();
15288 octave_value_list _out;
15289 octave_value_list *_outp=&_out;
15290 octave_value _outv;
15297 if (
_n_dims( args(0) ) > 2 )
15299 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15301 temp1 = args(0).matrix_value();
15302 arg1 = &temp1( 0, 0 );
15310 arg4 =
static_cast< PLFLT >(val4);
15315 arg5 =
static_cast< PLFLT >(val5);
15320 arg6 =
static_cast< PLFLT >(val6);
15325 arg7 =
static_cast< PLFLT >(val7);
15330 arg8 =
static_cast< PLFLT >(val8);
15335 arg9 =
static_cast< PLFLT >(val9);
15340 arg10 =
static_cast< PLFLT >(val10);
15345 arg11 =
static_cast< PLFLT >(val11);
15347 if (
_n_dims( args(9) ) > 1 )
15355 temp12 = args(9).matrix_value();
15356 arg12 = &temp12( 0, 0 );
15359 if (
_n_dims( args(10) ) > 1 )
15363 if (
_dim( args(10), 0 ) !=
Ylen )
15367 temp13 = args(10).matrix_value();
15368 arg13 = &temp13( 0, 0 );
15370 my_plimagefr1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
15371 _outv = octave_value();
15393 return octave_value_list();
15443 octave_value_list _out;
15444 octave_value_list *_outp=&_out;
15445 octave_value _outv;
15452 if (
_n_dims( args(0) ) > 2 )
15454 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15456 temp1 = args(0).matrix_value();
15457 arg1 = &temp1( 0, 0 );
15465 arg4 =
static_cast< PLFLT >(val4);
15470 arg5 =
static_cast< PLFLT >(val5);
15475 arg6 =
static_cast< PLFLT >(val6);
15480 arg7 =
static_cast< PLFLT >(val7);
15485 arg8 =
static_cast< PLFLT >(val8);
15490 arg9 =
static_cast< PLFLT >(val9);
15495 arg10 =
static_cast< PLFLT >(val10);
15500 arg11 =
static_cast< PLFLT >(val11);
15502 if (
_n_dims( args(9) ) > 2 )
15504 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15506 temp12 = args(9).matrix_value();
15507 arg12 = &temp12( 0, 0 );
15512 if (
_n_dims( args(10) ) > 2 )
15514 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15516 temp13 = args(10).matrix_value();
15517 arg13 = &temp13( 0, 0 );
15521 my_plimagefr2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
15522 _outv = octave_value();
15544 return octave_value_list();
15579 char **arg18 = (
char **) 0 ;
15581 char **arg20 = (
char **) 0 ;
15621 octave_value_list _out;
15622 octave_value_list *_outp=&_out;
15623 octave_value _outv;
15635 arg3 =
static_cast< PLINT >(val3);
15640 arg4 =
static_cast< PLINT >(val4);
15645 arg5 =
static_cast< PLFLT >(val5);
15650 arg6 =
static_cast< PLFLT >(val6);
15655 arg7 =
static_cast< PLFLT >(val7);
15660 arg8 =
static_cast< PLFLT >(val8);
15665 arg9 =
static_cast< PLINT >(val9);
15670 arg10 =
static_cast< PLINT >(val10);
15675 arg11 =
static_cast< PLINT >(val11);
15680 arg12 =
static_cast< PLFLT >(val12);
15685 arg13 =
static_cast< PLFLT >(val13);
15690 arg14 =
static_cast< PLINT >(val14);
15695 arg15 =
static_cast< PLFLT >(val15);
15697 if (
_n_dims( args(13) ) > 1 )
15703 temp16 = args(13).matrix_value();
15707 charMatrix temp_matrix;
15711 size_t max_length = 0, non_blank_length;
15713 if (
_n_dims( args(14) ) > 2 )
15715 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
15717 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15718 if ( !args(14).isempty() )
15720 if ( !args(14).is_empty() )
15723 if (
_dim( args(14), 0 ) !=
Alen )
15725 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
15727 arg18 =
new char*[
Alen];
15728 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15729 ifcell = args(14).iscell();
15731 ifcell = args(14).is_cell();
15735 temp_cell = args(14).cell_value();
15739 temp_matrix = args(14).char_matrix_value();
15741 max_length =
_dim( args(14), 1 ) + 1;
15744 for ( i = 0; i <
Alen; i++ )
15751 if ( temp_cell.elem( i ).is_string() )
15753 str = temp_cell.elem( i ).string_value();
15755 max_length = str.size() + 1;
15756 tmp_cstring = (
char *) str.c_str();
15766 tmp_cstring = (
char *)
"";
15771 str = temp_matrix.row_as_string( i );
15772 tmp_cstring = (
char *) str.c_str();
15774 arg18[i] =
new char[max_length];
15775 strncpy( arg18[i], tmp_cstring, max_length - 1 );
15776 arg18[i][max_length - 1] =
'\0';
15791 non_blank_length = max_length - 2;
15792 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
'\0' )
15794 non_blank_length--;
15796 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
' ' )
15798 non_blank_length--;
15800 arg18[i][non_blank_length + 1] =
'\0';
15810 charMatrix temp_matrix;
15814 size_t max_length = 0, non_blank_length;
15816 if (
_n_dims( args(15) ) > 2 )
15818 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
15820 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15821 if ( !args(15).isempty() )
15823 if ( !args(15).is_empty() )
15828 arg20 =
new char*[
Alen];
15829 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15830 ifcell = args(15).iscell();
15832 ifcell = args(15).is_cell();
15836 temp_cell = args(15).cell_value();
15840 temp_matrix = args(15).char_matrix_value();
15842 max_length =
_dim( args(15), 1 ) + 1;
15845 for ( i = 0; i <
Alen; i++ )
15852 if ( temp_cell.elem( i ).is_string() )
15854 str = temp_cell.elem( i ).string_value();
15856 max_length = str.size() + 1;
15857 tmp_cstring = (
char *) str.c_str();
15867 tmp_cstring = (
char *)
"";
15872 str = temp_matrix.row_as_string( i );
15873 tmp_cstring = (
char *) str.c_str();
15875 arg20[i] =
new char[max_length];
15876 strncpy( arg20[i], tmp_cstring, max_length - 1 );
15877 arg20[i][max_length - 1] =
'\0';
15892 non_blank_length = max_length - 2;
15893 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
15895 non_blank_length--;
15897 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
15899 non_blank_length--;
15901 arg20[i][non_blank_length + 1] =
'\0';
15912 if (
_n_dims( args(16) ) > 1 )
15916 if (
_dim( args(16), 0 ) !=
Alen )
15920 temp21 = args(16).matrix_value();
15921 arg21 = &temp21( 0, 0 );
15924 if (
_n_dims( args(17) ) > 1 )
15928 if (
_dim( args(17), 0 ) !=
Alen )
15932 temp22 = args(17).matrix_value();
15938 if (
_n_dims( args(18) ) > 1 )
15942 if (
_dim( args(18), 0 ) !=
Alen )
15947 temp23 = args(18).matrix_value();
15951 for ( i = 0; i <
Xlen; i++ )
15952 if ( arg23[i] >
Ylen )
15956 if (
_n_dims( args(19) ) > 2 )
15958 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15960 if (
_dim( args(19), 0 ) !=
Xlen )
15962 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
15964 if (
_dim( args(19), 1 ) !=
Ylen )
15966 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
15968 temp24 = args(19).matrix_value();
15969 arg24 = &temp24( 0, 0 );
15971 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);
15972 _outv = octave_value();
15991 if ( arg18 != NULL )
15993 for ( i = 0; i <
Alen; i++ )
16002 if ( arg20 != NULL )
16004 for ( i = 0; i <
Alen; i++ )
16030 if ( arg18 != NULL )
16032 for ( i = 0; i <
Alen; i++ )
16041 if ( arg20 != NULL )
16043 for ( i = 0; i <
Alen; i++ )
16062 return octave_value_list();
16070 if ( arg18 != NULL )
16072 for ( i = 0; i <
Alen; i++ )
16081 if ( arg20 != NULL )
16083 for ( i = 0; i <
Alen; i++ )
16114 octave_value_list _out;
16115 octave_value_list *_outp=&_out;
16116 octave_value _outv;
16131 arg2 =
static_cast< int >(val2);
16132 if (arg1) (arg1)->type = arg2;
16133 _outv = octave_value();
16137 return octave_value_list();
16149 octave_value_list _out;
16150 octave_value_list *_outp=&_out;
16151 octave_value _outv;
16163 result = (int) ((arg1)->type);
16168 return octave_value_list();
16178 unsigned int arg2 ;
16181 unsigned int val2 ;
16183 octave_value_list _out;
16184 octave_value_list *_outp=&_out;
16185 octave_value _outv;
16200 arg2 =
static_cast< unsigned int >(val2);
16201 if (arg1) (arg1)->state = arg2;
16202 _outv = octave_value();
16206 return octave_value_list();
16218 octave_value_list _out;
16219 octave_value_list *_outp=&_out;
16220 octave_value _outv;
16221 unsigned int result;
16232 result = (
unsigned int) ((arg1)->state);
16237 return octave_value_list();
16247 unsigned int arg2 ;
16250 unsigned int val2 ;
16252 octave_value_list _out;
16253 octave_value_list *_outp=&_out;
16254 octave_value _outv;
16269 arg2 =
static_cast< unsigned int >(val2);
16270 if (arg1) (arg1)->keysym = arg2;
16271 _outv = octave_value();
16275 return octave_value_list();
16287 octave_value_list _out;
16288 octave_value_list *_outp=&_out;
16289 octave_value _outv;
16290 unsigned int result;
16301 result = (
unsigned int) ((arg1)->keysym);
16306 return octave_value_list();
16316 unsigned int arg2 ;
16319 unsigned int val2 ;
16321 octave_value_list _out;
16322 octave_value_list *_outp=&_out;
16323 octave_value _outv;
16338 arg2 =
static_cast< unsigned int >(val2);
16339 if (arg1) (arg1)->button = arg2;
16340 _outv = octave_value();
16344 return octave_value_list();
16356 octave_value_list _out;
16357 octave_value_list *_outp=&_out;
16358 octave_value _outv;
16359 unsigned int result;
16370 result = (
unsigned int) ((arg1)->button);
16375 return octave_value_list();
16390 octave_value_list _out;
16391 octave_value_list *_outp=&_out;
16392 octave_value _outv;
16407 arg2 =
static_cast< PLINT >(val2);
16408 if (arg1) (arg1)->subwindow = arg2;
16409 _outv = octave_value();
16413 return octave_value_list();
16425 octave_value_list _out;
16426 octave_value_list *_outp=&_out;
16427 octave_value _outv;
16439 result = (
PLINT) ((arg1)->subwindow);
16444 return octave_value_list();
16459 octave_value_list _out;
16460 octave_value_list *_outp=&_out;
16461 octave_value _outv;
16476 arg2 =
reinterpret_cast< char *
>(temp2);
16477 if (arg2) memcpy(arg1->
string,arg2,16*
sizeof(
char));
16478 else memset(arg1->
string,0,16*
sizeof(
char));
16479 _outv = octave_value();
16483 return octave_value_list();
16495 octave_value_list _out;
16496 octave_value_list *_outp=&_out;
16497 octave_value _outv;
16509 result = (
char *)(
char *) ((arg1)->
string);
16520 return octave_value_list();
16535 octave_value_list _out;
16536 octave_value_list *_outp=&_out;
16537 octave_value _outv;
16552 arg2 =
static_cast< int >(val2);
16553 if (arg1) (arg1)->pX = arg2;
16554 _outv = octave_value();
16558 return octave_value_list();
16570 octave_value_list _out;
16571 octave_value_list *_outp=&_out;
16572 octave_value _outv;
16584 result = (int) ((arg1)->pX);
16589 return octave_value_list();
16604 octave_value_list _out;
16605 octave_value_list *_outp=&_out;
16606 octave_value _outv;
16621 arg2 =
static_cast< int >(val2);
16622 if (arg1) (arg1)->pY = arg2;
16623 _outv = octave_value();
16627 return octave_value_list();
16639 octave_value_list _out;
16640 octave_value_list *_outp=&_out;
16641 octave_value _outv;
16653 result = (int) ((arg1)->pY);
16658 return octave_value_list();
16673 octave_value_list _out;
16674 octave_value_list *_outp=&_out;
16675 octave_value _outv;
16690 arg2 =
static_cast< PLFLT >(val2);
16691 if (arg1) (arg1)->dX = arg2;
16692 _outv = octave_value();
16696 return octave_value_list();
16708 octave_value_list _out;
16709 octave_value_list *_outp=&_out;
16710 octave_value _outv;
16722 result = (
PLFLT) ((arg1)->dX);
16727 return octave_value_list();
16742 octave_value_list _out;
16743 octave_value_list *_outp=&_out;
16744 octave_value _outv;
16759 arg2 =
static_cast< PLFLT >(val2);
16760 if (arg1) (arg1)->dY = arg2;
16761 _outv = octave_value();
16765 return octave_value_list();
16777 octave_value_list _out;
16778 octave_value_list *_outp=&_out;
16779 octave_value _outv;
16791 result = (
PLFLT) ((arg1)->dY);
16796 return octave_value_list();
16811 octave_value_list _out;
16812 octave_value_list *_outp=&_out;
16813 octave_value _outv;
16828 arg2 =
static_cast< PLFLT >(val2);
16829 if (arg1) (arg1)->wX = arg2;
16830 _outv = octave_value();
16834 return octave_value_list();
16846 octave_value_list _out;
16847 octave_value_list *_outp=&_out;
16848 octave_value _outv;
16860 result = (
PLFLT) ((arg1)->wX);
16865 return octave_value_list();
16880 octave_value_list _out;
16881 octave_value_list *_outp=&_out;
16882 octave_value _outv;
16897 arg2 =
static_cast< PLFLT >(val2);
16898 if (arg1) (arg1)->wY = arg2;
16899 _outv = octave_value();
16903 return octave_value_list();
16915 octave_value_list _out;
16916 octave_value_list *_outp=&_out;
16917 octave_value _outv;
16929 result = (
PLFLT) ((arg1)->wY);
16934 return octave_value_list();
16943 octave_value_list _out;
16944 octave_value_list *_outp=&_out;
16945 octave_value _outv;
16957 return octave_value_list();
16969 octave_value_list _out;
16970 octave_value_list *_outp=&_out;
16971 octave_value _outv;
16983 _outv = octave_value();
16987 return octave_value_list();
17021 octave_value_list _out;
17022 octave_value_list *_outp=&_out;
17023 octave_value _outv;
17033 arg1 =
static_cast< PLINT >(val1);
17038 arg2 =
static_cast< PLINT >(val2);
17040 _outv = octave_value();
17044 return octave_value_list();
17065 octave_value_list _out;
17066 octave_value_list *_outp=&_out;
17067 octave_value _outv;
17077 arg1 =
static_cast< PLFLT >(val1);
17082 arg2 =
static_cast< PLFLT >(val2);
17087 arg3 =
static_cast< PLFLT >(val3);
17092 arg4 =
static_cast< PLINT >(val4);
17094 _outv = octave_value();
17098 return octave_value_list();
17110 octave_value_list _out;
17111 octave_value_list *_outp=&_out;
17112 octave_value _outv;
17122 arg1 =
static_cast< PLINT >(val1);
17124 _outv = octave_value();
17128 return octave_value_list();
17161 octave_value_list _out;
17162 octave_value_list *_outp=&_out;
17163 octave_value _outv;
17173 arg1 =
static_cast< PLFLT >(val1);
17178 arg2 =
static_cast< PLFLT >(val2);
17183 arg3 =
static_cast< PLFLT >(val3);
17188 arg4 =
static_cast< PLFLT >(val4);
17193 arg5 =
static_cast< PLFLT >(val5);
17198 arg6 =
static_cast< PLFLT >(val6);
17203 arg7 =
static_cast< PLFLT >(val7);
17208 arg8 =
static_cast< PLBOOL >(val8);
17209 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
17210 _outv = octave_value();
17214 return octave_value_list();
17225 char *arg3 = (
char *) 0 ;
17228 char *arg6 = (
char *) 0 ;
17249 octave_value_list _out;
17250 octave_value_list *_outp=&_out;
17251 octave_value _outv;
17261 arg1 =
static_cast< PLFLT >(val1);
17266 arg2 =
static_cast< PLFLT >(val2);
17271 arg3 =
reinterpret_cast< char *
>(buf3);
17276 arg4 =
static_cast< PLFLT >(val4);
17281 arg5 =
static_cast< PLINT >(val5);
17286 arg6 =
reinterpret_cast< char *
>(buf6);
17291 arg7 =
static_cast< PLFLT >(val7);
17296 arg8 =
static_cast< PLINT >(val8);
17297 plaxes(arg1,arg2,(
char const *)arg3,arg4,arg5,(
char const *)arg6,arg7,arg8);
17298 _outv = octave_value();
17306 return octave_value_list();
17325 octave_value_list _out;
17326 octave_value_list *_outp=&_out;
17327 octave_value _outv;
17334 if (
_n_dims( args(0) ) > 1 )
17339 temp1 = args(0).matrix_value();
17340 arg2 = &temp1( 0, 0 );
17343 if (
_n_dims( args(1) ) > 1 )
17351 temp3 = args(1).matrix_value();
17352 arg3 = &temp3( 0, 0 );
17358 arg4 =
static_cast< PLINT >(val4);
17359 plbin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
17360 _outv = octave_value();
17376 return octave_value_list();
17412 octave_value_list _out;
17413 octave_value_list *_outp=&_out;
17414 octave_value _outv;
17430 arg7 =
static_cast< PLFLT >(val7);
17431 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17432 _outv = octave_value();
17472 return octave_value_list();
17481 octave_value_list _out;
17482 octave_value_list *_outp=&_out;
17483 octave_value _outv;
17490 _outv = octave_value();
17494 return octave_value_list();
17503 char *arg1 = (
char *) 0 ;
17506 char *arg4 = (
char *) 0 ;
17523 octave_value_list _out;
17524 octave_value_list *_outp=&_out;
17525 octave_value _outv;
17535 arg1 =
reinterpret_cast< char *
>(buf1);
17540 arg2 =
static_cast< PLFLT >(val2);
17545 arg3 =
static_cast< PLINT >(val3);
17550 arg4 =
reinterpret_cast< char *
>(buf4);
17555 arg5 =
static_cast< PLFLT >(val5);
17560 arg6 =
static_cast< PLINT >(val6);
17561 plbox((
char const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6);
17562 _outv = octave_value();
17570 return octave_value_list();
17581 char *arg1 = (
char *) 0 ;
17582 char *arg2 = (
char *) 0 ;
17585 char *arg5 = (
char *) 0 ;
17586 char *arg6 = (
char *) 0 ;
17589 char *arg9 = (
char *) 0 ;
17590 char *arg10 = (
char *) 0 ;
17623 octave_value_list _out;
17624 octave_value_list *_outp=&_out;
17625 octave_value _outv;
17635 arg1 =
reinterpret_cast< char *
>(buf1);
17640 arg2 =
reinterpret_cast< char *
>(buf2);
17645 arg3 =
static_cast< PLFLT >(val3);
17650 arg4 =
static_cast< PLINT >(val4);
17655 arg5 =
reinterpret_cast< char *
>(buf5);
17660 arg6 =
reinterpret_cast< char *
>(buf6);
17665 arg7 =
static_cast< PLFLT >(val7);
17670 arg8 =
static_cast< PLINT >(val8);
17675 arg9 =
reinterpret_cast< char *
>(buf9);
17680 arg10 =
reinterpret_cast< char *
>(buf10);
17685 arg11 =
static_cast< PLFLT >(val11);
17690 arg12 =
static_cast< PLINT >(val12);
17691 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);
17692 _outv = octave_value();
17708 return octave_value_list();
17738 octave_value_list _out;
17739 octave_value_list *_outp=&_out;
17740 octave_value _outv;
17753 arg1 =
static_cast< PLFLT >(val1);
17758 arg2 =
static_cast< PLFLT >(val2);
17760 _outv = octave_value();
17782 return octave_value_list();
17791 octave_value_list _out;
17792 octave_value_list *_outp=&_out;
17793 octave_value _outv;
17800 _outv = octave_value();
17804 return octave_value_list();
17816 octave_value_list _out;
17817 octave_value_list *_outp=&_out;
17818 octave_value _outv;
17828 arg1 =
static_cast< PLINT >(val1);
17830 _outv = octave_value();
17834 return octave_value_list();
17846 octave_value_list _out;
17847 octave_value_list *_outp=&_out;
17848 octave_value _outv;
17858 arg1 =
static_cast< PLFLT >(val1);
17860 _outv = octave_value();
17864 return octave_value_list();
17906 octave_value_list _out;
17907 octave_value_list *_outp=&_out;
17908 octave_value _outv;
17918 arg1 =
static_cast< PLFLT >(val1);
17923 arg2 =
static_cast< PLFLT >(val2);
17928 arg3 =
static_cast< PLFLT >(val3);
17933 arg4 =
static_cast< PLINT >(val4);
17938 arg5 =
static_cast< PLBOOL >(val5);
17943 arg6 =
static_cast< PLINT >(val6);
17948 arg7 =
static_cast< PLINT >(val7);
17953 arg8 =
static_cast< PLINT >(val8);
17958 arg9 =
static_cast< PLINT >(val9);
17963 arg10 =
static_cast< PLINT >(val10);
17968 arg11 =
static_cast< PLFLT >(val11);
17969 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
17970 _outv = octave_value();
17974 return octave_value_list();
18004 octave_value_list _out;
18005 octave_value_list *_outp=&_out;
18006 octave_value _outv;
18017 arg1 =
static_cast< PLINT >(val1);
18022 arg2 =
static_cast< PLINT >(val2);
18027 arg3 =
static_cast< PLINT >(val3);
18032 arg4 =
static_cast< PLINT >(val4);
18037 arg5 =
static_cast< PLINT >(val5);
18042 arg6 =
static_cast< PLFLT >(val6);
18043 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
18044 _outv = octave_value();
18054 return octave_value_list();
18069 octave_value_list _out;
18070 octave_value_list *_outp=&_out;
18071 octave_value _outv;
18081 arg1 =
static_cast< PLINT >(val1);
18086 arg2 =
static_cast< PLBOOL >(val2);
18088 _outv = octave_value();
18092 return octave_value_list();
18101 octave_value_list _out;
18102 octave_value_list *_outp=&_out;
18103 octave_value _outv;
18110 _outv = octave_value();
18114 return octave_value_list();
18123 octave_value_list _out;
18124 octave_value_list *_outp=&_out;
18125 octave_value _outv;
18132 _outv = octave_value();
18136 return octave_value_list();
18163 octave_value_list _out;
18164 octave_value_list *_outp=&_out;
18165 octave_value _outv;
18175 arg1 =
static_cast< PLFLT >(val1);
18180 arg2 =
static_cast< PLFLT >(val2);
18185 arg3 =
static_cast< PLFLT >(val3);
18190 arg4 =
static_cast< PLFLT >(val4);
18195 arg5 =
static_cast< PLINT >(val5);
18200 arg6 =
static_cast< PLINT >(val6);
18201 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
18202 _outv = octave_value();
18206 return octave_value_list();
18233 octave_value_list _out;
18234 octave_value_list *_outp=&_out;
18235 octave_value _outv;
18245 arg1 =
static_cast< PLFLT >(val1);
18250 arg2 =
static_cast< PLFLT >(val2);
18255 arg3 =
static_cast< PLFLT >(val3);
18260 arg4 =
static_cast< PLFLT >(val4);
18265 arg5 =
static_cast< PLINT >(val5);
18270 arg6 =
static_cast< PLINT >(val6);
18271 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
18272 _outv = octave_value();
18276 return octave_value_list();
18285 octave_value_list _out;
18286 octave_value_list *_outp=&_out;
18287 octave_value _outv;
18294 _outv = octave_value();
18298 return octave_value_list();
18314 octave_value_list _out;
18315 octave_value_list *_outp=&_out;
18316 octave_value _outv;
18323 if (
_n_dims( args(0) ) > 1 )
18328 temp1 = args(0).matrix_value();
18329 arg2 = &temp1( 0, 0 );
18332 if (
_n_dims( args(1) ) > 1 )
18340 temp3 = args(1).matrix_value();
18341 arg3 = &temp3( 0, 0 );
18344 if (
_n_dims( args(2) ) > 1 )
18352 temp4 = args(2).matrix_value();
18353 arg4 = &temp4( 0, 0 );
18355 plerrx(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18356 _outv = octave_value();
18378 return octave_value_list();
18403 octave_value_list _out;
18404 octave_value_list *_outp=&_out;
18405 octave_value _outv;
18412 if (
_n_dims( args(0) ) > 1 )
18417 temp1 = args(0).matrix_value();
18418 arg2 = &temp1( 0, 0 );
18421 if (
_n_dims( args(1) ) > 1 )
18429 temp3 = args(1).matrix_value();
18430 arg3 = &temp3( 0, 0 );
18433 if (
_n_dims( args(2) ) > 1 )
18441 temp4 = args(2).matrix_value();
18442 arg4 = &temp4( 0, 0 );
18444 plerry(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18445 _outv = octave_value();
18467 return octave_value_list();
18485 octave_value_list _out;
18486 octave_value_list *_outp=&_out;
18487 octave_value _outv;
18494 _outv = octave_value();
18498 return octave_value_list();
18512 octave_value_list _out;
18513 octave_value_list *_outp=&_out;
18514 octave_value _outv;
18521 if (
_n_dims( args(0) ) > 1 )
18526 temp1 = args(0).matrix_value();
18527 arg2 = &temp1( 0, 0 );
18530 if (
_n_dims( args(1) ) > 1 )
18538 temp3 = args(1).matrix_value();
18539 arg3 = &temp3( 0, 0 );
18541 plfill(arg1,(
double const *)arg2,(
double const *)arg3);
18542 _outv = octave_value();
18558 return octave_value_list();
18580 octave_value_list _out;
18581 octave_value_list *_outp=&_out;
18582 octave_value _outv;
18589 if (
_n_dims( args(0) ) > 1 )
18594 temp1 = args(0).matrix_value();
18595 arg2 = &temp1( 0, 0 );
18598 if (
_n_dims( args(1) ) > 1 )
18606 temp3 = args(1).matrix_value();
18607 arg3 = &temp3( 0, 0 );
18610 if (
_n_dims( args(2) ) > 1 )
18618 temp4 = args(2).matrix_value();
18619 arg4 = &temp4( 0, 0 );
18621 plfill3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18622 _outv = octave_value();
18644 return octave_value_list();
18670 octave_value_list _out;
18671 octave_value_list *_outp=&_out;
18672 octave_value _outv;
18679 if (
_n_dims( args(0) ) > 1 )
18684 temp1 = args(0).matrix_value();
18685 arg2 = &temp1( 0, 0 );
18688 if (
_n_dims( args(1) ) > 1 )
18696 temp3 = args(1).matrix_value();
18697 arg3 = &temp3( 0, 0 );
18703 arg4 =
static_cast< PLFLT >(val4);
18704 plgradient(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
18705 _outv = octave_value();
18721 return octave_value_list();
18736 octave_value_list _out;
18737 octave_value_list *_outp=&_out;
18738 octave_value _outv;
18745 _outv = octave_value();
18749 return octave_value_list();
18761 octave_value_list _out;
18762 octave_value_list *_outp=&_out;
18763 octave_value _outv;
18773 arg1 =
static_cast< PLINT >(val1);
18775 _outv = octave_value();
18779 return octave_value_list();
18791 octave_value_list _out;
18792 octave_value_list *_outp=&_out;
18793 octave_value _outv;
18803 arg1 =
static_cast< PLINT >(val1);
18805 _outv = octave_value();
18809 return octave_value_list();
18824 octave_value_list _out;
18825 octave_value_list *_outp=&_out;
18826 octave_value _outv;
18835 _outv = octave_value();
18851 return octave_value_list();
18872 octave_value_list _out;
18873 octave_value_list *_outp=&_out;
18874 octave_value _outv;
18887 arg1 =
static_cast< PLINT >(val1);
18888 plgcol0(arg1,arg2,arg3,arg4);
18889 _outv = octave_value();
18911 return octave_value_list();
18935 octave_value_list _out;
18936 octave_value_list *_outp=&_out;
18937 octave_value _outv;
18951 arg1 =
static_cast< PLINT >(val1);
18952 plgcol0a(arg1,arg2,arg3,arg4,arg5);
18953 _outv = octave_value();
18981 return octave_value_list();
18999 octave_value_list _out;
19000 octave_value_list *_outp=&_out;
19001 octave_value _outv;
19011 _outv = octave_value();
19033 return octave_value_list();
19054 octave_value_list _out;
19055 octave_value_list *_outp=&_out;
19056 octave_value _outv;
19067 _outv = octave_value();
19095 return octave_value_list();
19107 octave_value_list _out;
19108 octave_value_list *_outp=&_out;
19109 octave_value _outv;
19117 _outv = octave_value();
19127 return octave_value_list();
19136 char *arg1 = (
char *) 0 ;
19137 char local_string1[80] ;
19138 size_t local_string_length1 ;
19139 charMatrix local_charMatrix1 ;
19140 octave_value_list retval1 ;
19141 octave_value_list _out;
19142 octave_value_list *_outp=&_out;
19143 octave_value _outv;
19147 arg1 = local_string1;
19153 _outv = octave_value();
19156 local_string_length1 = strlen( local_string1 );
19157 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19158 local_charMatrix1.insert( local_string1, 0, 0 );
19159 retval1( 0 ) = octave_value( local_charMatrix1 );
19164 return octave_value_list();
19185 octave_value_list _out;
19186 octave_value_list *_outp=&_out;
19187 octave_value _outv;
19198 _outv = octave_value();
19226 return octave_value_list();
19238 octave_value_list _out;
19239 octave_value_list *_outp=&_out;
19240 octave_value _outv;
19248 _outv = octave_value();
19258 return octave_value_list();
19279 octave_value_list _out;
19280 octave_value_list *_outp=&_out;
19281 octave_value _outv;
19292 _outv = octave_value();
19320 return octave_value_list();
19338 octave_value_list _out;
19339 octave_value_list *_outp=&_out;
19340 octave_value _outv;
19350 _outv = octave_value();
19372 return octave_value_list();
19384 octave_value_list _out;
19385 octave_value_list *_outp=&_out;
19386 octave_value _outv;
19394 _outv = octave_value();
19404 return octave_value_list();
19413 char *arg1 = (
char *) 0 ;
19414 char local_string1[80] ;
19415 size_t local_string_length1 ;
19416 charMatrix local_charMatrix1 ;
19417 octave_value_list retval1 ;
19418 octave_value_list _out;
19419 octave_value_list *_outp=&_out;
19420 octave_value _outv;
19424 arg1 = local_string1;
19430 _outv = octave_value();
19433 local_string_length1 = strlen( local_string1 );
19434 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19435 local_charMatrix1.insert( local_string1, 0, 0 );
19436 retval1( 0 ) = octave_value( local_charMatrix1 );
19441 return octave_value_list();
19459 octave_value_list _out;
19460 octave_value_list *_outp=&_out;
19461 octave_value _outv;
19471 _outv = octave_value();
19493 return octave_value_list();
19505 octave_value_list _out;
19506 octave_value_list *_outp=&_out;
19507 octave_value _outv;
19515 _outv = octave_value();
19525 return octave_value_list();
19552 octave_value_list _out;
19553 octave_value_list *_outp=&_out;
19554 octave_value _outv;
19566 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
19567 _outv = octave_value();
19607 return octave_value_list();
19616 octave_value_list _out;
19617 octave_value_list *_outp=&_out;
19618 octave_value _outv;
19625 _outv = octave_value();
19629 return octave_value_list();
19650 octave_value_list _out;
19651 octave_value_list *_outp=&_out;
19652 octave_value _outv;
19662 plgspa(arg1,arg2,arg3,arg4);
19663 _outv = octave_value();
19691 return octave_value_list();
19703 octave_value_list _out;
19704 octave_value_list *_outp=&_out;
19705 octave_value _outv;
19713 _outv = octave_value();
19723 return octave_value_list();
19732 char *arg1 = (
char *) 0 ;
19733 char local_string1[80] ;
19734 size_t local_string_length1 ;
19735 charMatrix local_charMatrix1 ;
19736 octave_value_list retval1 ;
19737 octave_value_list _out;
19738 octave_value_list *_outp=&_out;
19739 octave_value _outv;
19743 arg1 = local_string1;
19749 _outv = octave_value();
19752 local_string_length1 = strlen( local_string1 );
19753 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19754 local_charMatrix1.insert( local_string1, 0, 0 );
19755 retval1( 0 ) = octave_value( local_charMatrix1 );
19760 return octave_value_list();
19781 octave_value_list _out;
19782 octave_value_list *_outp=&_out;
19783 octave_value _outv;
19793 plgvpd(arg1,arg2,arg3,arg4);
19794 _outv = octave_value();
19822 return octave_value_list();
19843 octave_value_list _out;
19844 octave_value_list *_outp=&_out;
19845 octave_value _outv;
19855 plgvpw(arg1,arg2,arg3,arg4);
19856 _outv = octave_value();
19884 return octave_value_list();
19899 octave_value_list _out;
19900 octave_value_list *_outp=&_out;
19901 octave_value _outv;
19910 _outv = octave_value();
19926 return octave_value_list();
19941 octave_value_list _out;
19942 octave_value_list *_outp=&_out;
19943 octave_value _outv;
19952 _outv = octave_value();
19968 return octave_value_list();
19983 octave_value_list _out;
19984 octave_value_list *_outp=&_out;
19985 octave_value _outv;
19994 _outv = octave_value();
20010 return octave_value_list();
20034 octave_value_list _out;
20035 octave_value_list *_outp=&_out;
20036 octave_value _outv;
20043 if (
_n_dims( args(0) ) > 1 )
20048 temp1 = args(0).matrix_value();
20049 arg2 = &temp1( 0, 0 );
20055 arg3 =
static_cast< PLFLT >(val3);
20060 arg4 =
static_cast< PLFLT >(val4);
20065 arg5 =
static_cast< PLINT >(val5);
20070 arg6 =
static_cast< PLINT >(val6);
20071 plhist(arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
20072 _outv = octave_value();
20082 return octave_value_list();
20112 octave_value_list _out;
20113 octave_value_list *_outp=&_out;
20114 octave_value _outv;
20127 arg1 =
static_cast< PLFLT >(val1);
20132 arg2 =
static_cast< PLFLT >(val2);
20137 arg3 =
static_cast< PLFLT >(val3);
20138 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
20139 _outv = octave_value();
20161 return octave_value_list();
20170 octave_value_list _out;
20171 octave_value_list *_outp=&_out;
20172 octave_value _outv;
20179 _outv = octave_value();
20183 return octave_value_list();
20204 octave_value_list _out;
20205 octave_value_list *_outp=&_out;
20206 octave_value _outv;
20216 arg1 =
static_cast< PLFLT >(val1);
20221 arg2 =
static_cast< PLFLT >(val2);
20226 arg3 =
static_cast< PLFLT >(val3);
20231 arg4 =
static_cast< PLFLT >(val4);
20232 pljoin(arg1,arg2,arg3,arg4);
20233 _outv = octave_value();
20237 return octave_value_list();
20246 char *arg1 = (
char *) 0 ;
20247 char *arg2 = (
char *) 0 ;
20248 char *arg3 = (
char *) 0 ;
20258 octave_value_list _out;
20259 octave_value_list *_outp=&_out;
20260 octave_value _outv;
20270 arg1 =
reinterpret_cast< char *
>(buf1);
20275 arg2 =
reinterpret_cast< char *
>(buf2);
20280 arg3 =
reinterpret_cast< char *
>(buf3);
20281 pllab((
char const *)arg1,(
char const *)arg2,(
char const *)arg3);
20282 _outv = octave_value();
20292 return octave_value_list();
20323 char **arg20 = (
char **) 0 ;
20334 char **arg31 = (
char **) 0 ;
20379 octave_value_list _out;
20380 octave_value_list *_outp=&_out;
20381 octave_value _outv;
20393 arg3 =
static_cast< PLINT >(val3);
20398 arg4 =
static_cast< PLINT >(val4);
20403 arg5 =
static_cast< PLFLT >(val5);
20408 arg6 =
static_cast< PLFLT >(val6);
20413 arg7 =
static_cast< PLFLT >(val7);
20418 arg8 =
static_cast< PLINT >(val8);
20423 arg9 =
static_cast< PLINT >(val9);
20428 arg10 =
static_cast< PLINT >(val10);
20433 arg11 =
static_cast< PLINT >(val11);
20438 arg12 =
static_cast< PLINT >(val12);
20440 if (
_n_dims( args(10) ) > 1 )
20446 temp13 = args(10).matrix_value();
20453 arg15 =
static_cast< PLFLT >(val15);
20458 arg16 =
static_cast< PLFLT >(val16);
20463 arg17 =
static_cast< PLFLT >(val17);
20468 arg18 =
static_cast< PLFLT >(val18);
20470 if (
_n_dims( args(15) ) > 1 )
20474 if (
_dim( args(15), 0 ) !=
Alen )
20478 temp19 = args(15).matrix_value();
20483 charMatrix temp_matrix;
20487 size_t max_length = 0, non_blank_length;
20489 if (
_n_dims( args(16) ) > 2 )
20491 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
20493 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20494 if ( !args(16).isempty() )
20496 if ( !args(16).is_empty() )
20499 if (
_dim( args(16), 0 ) !=
Alen )
20501 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
20503 arg20 =
new char*[
Alen];
20504 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20505 ifcell = args(16).iscell();
20507 ifcell = args(16).is_cell();
20511 temp_cell = args(16).cell_value();
20515 temp_matrix = args(16).char_matrix_value();
20517 max_length =
_dim( args(16), 1 ) + 1;
20520 for ( i = 0; i <
Alen; i++ )
20527 if ( temp_cell.elem( i ).is_string() )
20529 str = temp_cell.elem( i ).string_value();
20531 max_length = str.size() + 1;
20532 tmp_cstring = (
char *) str.c_str();
20542 tmp_cstring = (
char *)
"";
20547 str = temp_matrix.row_as_string( i );
20548 tmp_cstring = (
char *) str.c_str();
20550 arg20[i] =
new char[max_length];
20551 strncpy( arg20[i], tmp_cstring, max_length - 1 );
20552 arg20[i][max_length - 1] =
'\0';
20567 non_blank_length = max_length - 2;
20568 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
20570 non_blank_length--;
20572 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
20574 non_blank_length--;
20576 arg20[i][non_blank_length + 1] =
'\0';
20586 if (
_n_dims( args(17) ) > 1 )
20590 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20591 if ( !args(17).isempty() )
20593 if ( !args(17).is_empty() )
20596 if (
_dim( args(17), 0 ) !=
Alen )
20600 temp21 = args(17).matrix_value();
20610 if (
_n_dims( args(18) ) > 1 )
20614 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20615 if ( !args(18).isempty() )
20617 if ( !args(18).is_empty() )
20620 if (
_dim( args(18), 0 ) !=
Alen )
20624 temp22 = args(18).matrix_value();
20634 if (
_n_dims( args(19) ) > 1 )
20638 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20639 if ( !args(19).isempty() )
20641 if ( !args(19).is_empty() )
20644 if (
_dim( args(19), 0 ) !=
Alen )
20648 temp23 = args(19).matrix_value();
20649 arg23 = &temp23( 0, 0 );
20657 if (
_n_dims( args(20) ) > 1 )
20661 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20662 if ( !args(20).isempty() )
20664 if ( !args(20).is_empty() )
20667 if (
_dim( args(20), 0 ) !=
Alen )
20671 temp24 = args(20).matrix_value();
20672 arg24 = &temp24( 0, 0 );
20680 if (
_n_dims( args(21) ) > 1 )
20684 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20685 if ( !args(21).isempty() )
20687 if ( !args(21).is_empty() )
20690 if (
_dim( args(21), 0 ) !=
Alen )
20694 temp25 = args(21).matrix_value();
20704 if (
_n_dims( args(22) ) > 1 )
20708 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20709 if ( !args(22).isempty() )
20711 if ( !args(22).is_empty() )
20714 if (
_dim( args(22), 0 ) !=
Alen )
20718 temp26 = args(22).matrix_value();
20728 if (
_n_dims( args(23) ) > 1 )
20732 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20733 if ( !args(23).isempty() )
20735 if ( !args(23).is_empty() )
20738 if (
_dim( args(23), 0 ) !=
Alen )
20742 temp27 = args(23).matrix_value();
20743 arg27 = &temp27( 0, 0 );
20751 if (
_n_dims( args(24) ) > 1 )
20755 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20756 if ( !args(24).isempty() )
20758 if ( !args(24).is_empty() )
20761 if (
_dim( args(24), 0 ) !=
Alen )
20765 temp28 = args(24).matrix_value();
20775 if (
_n_dims( args(25) ) > 1 )
20779 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20780 if ( !args(25).isempty() )
20782 if ( !args(25).is_empty() )
20785 if (
_dim( args(25), 0 ) !=
Alen )
20789 temp29 = args(25).matrix_value();
20790 arg29 = &temp29( 0, 0 );
20798 if (
_n_dims( args(26) ) > 1 )
20802 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20803 if ( !args(26).isempty() )
20805 if ( !args(26).is_empty() )
20808 if (
_dim( args(26), 0 ) !=
Alen )
20812 temp30 = args(26).matrix_value();
20822 charMatrix temp_matrix;
20826 size_t max_length = 0, non_blank_length;
20828 if (
_n_dims( args(27) ) > 2 )
20830 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
20832 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20833 if ( !args(27).isempty() )
20835 if ( !args(27).is_empty() )
20838 if (
_dim( args(27), 0 ) !=
Alen )
20840 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
20842 arg31 =
new char*[
Alen];
20843 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20844 ifcell = args(27).iscell();
20846 ifcell = args(27).is_cell();
20850 temp_cell = args(27).cell_value();
20854 temp_matrix = args(27).char_matrix_value();
20856 max_length =
_dim( args(27), 1 ) + 1;
20859 for ( i = 0; i <
Alen; i++ )
20866 if ( temp_cell.elem( i ).is_string() )
20868 str = temp_cell.elem( i ).string_value();
20870 max_length = str.size() + 1;
20871 tmp_cstring = (
char *) str.c_str();
20881 tmp_cstring = (
char *)
"";
20886 str = temp_matrix.row_as_string( i );
20887 tmp_cstring = (
char *) str.c_str();
20889 arg31[i] =
new char[max_length];
20890 strncpy( arg31[i], tmp_cstring, max_length - 1 );
20891 arg31[i][max_length - 1] =
'\0';
20906 non_blank_length = max_length - 2;
20907 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
'\0' )
20909 non_blank_length--;
20911 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
' ' )
20913 non_blank_length--;
20915 arg31[i][non_blank_length + 1] =
'\0';
20924 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);
20925 _outv = octave_value();
20947 if ( arg20 != NULL )
20949 for ( i = 0; i <
Alen; i++ )
20957 if ( arg21 != NULL )
20961 if ( arg22 != NULL )
20971 if ( arg25 != NULL )
20975 if ( arg26 != NULL )
20982 if ( arg28 != NULL )
20989 if ( arg30 != NULL )
20994 if ( arg31 != NULL )
20996 for ( i = 0; i <
Alen; i++ )
21013 if ( arg20 != NULL )
21015 for ( i = 0; i <
Alen; i++ )
21023 if ( arg21 != NULL )
21027 if ( arg22 != NULL )
21037 if ( arg25 != NULL )
21041 if ( arg26 != NULL )
21048 if ( arg28 != NULL )
21055 if ( arg30 != NULL )
21060 if ( arg31 != NULL )
21062 for ( i = 0; i <
Alen; i++ )
21069 return octave_value_list();
21080 if ( arg20 != NULL )
21082 for ( i = 0; i <
Alen; i++ )
21090 if ( arg21 != NULL )
21094 if ( arg22 != NULL )
21104 if ( arg25 != NULL )
21108 if ( arg26 != NULL )
21115 if ( arg28 != NULL )
21122 if ( arg30 != NULL )
21127 if ( arg31 != NULL )
21129 for ( i = 0; i <
Alen; i++ )
21151 octave_value_list _out;
21152 octave_value_list *_outp=&_out;
21153 octave_value _outv;
21163 arg1 =
static_cast< PLFLT >(val1);
21168 arg2 =
static_cast< PLFLT >(val2);
21173 arg3 =
static_cast< PLFLT >(val3);
21175 _outv = octave_value();
21179 return octave_value_list();
21193 octave_value_list _out;
21194 octave_value_list *_outp=&_out;
21195 octave_value _outv;
21202 if (
_n_dims( args(0) ) > 1 )
21207 temp1 = args(0).matrix_value();
21208 arg2 = &temp1( 0, 0 );
21211 if (
_n_dims( args(1) ) > 1 )
21219 temp3 = args(1).matrix_value();
21220 arg3 = &temp3( 0, 0 );
21222 plline(arg1,(
double const *)arg2,(
double const *)arg3);
21223 _outv = octave_value();
21239 return octave_value_list();
21261 octave_value_list _out;
21262 octave_value_list *_outp=&_out;
21263 octave_value _outv;
21270 if (
_n_dims( args(0) ) > 1 )
21275 temp1 = args(0).matrix_value();
21276 arg2 = &temp1( 0, 0 );
21279 if (
_n_dims( args(1) ) > 1 )
21287 temp3 = args(1).matrix_value();
21288 arg3 = &temp3( 0, 0 );
21291 if (
_n_dims( args(2) ) > 1 )
21299 temp4 = args(2).matrix_value();
21300 arg4 = &temp4( 0, 0 );
21302 plline3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
21303 _outv = octave_value();
21325 return octave_value_list();
21346 octave_value_list _out;
21347 octave_value_list *_outp=&_out;
21348 octave_value _outv;
21358 arg1 =
static_cast< PLINT >(val1);
21360 _outv = octave_value();
21364 return octave_value_list();
21376 octave_value_list _out;
21377 octave_value_list *_outp=&_out;
21378 octave_value _outv;
21386 _outv = octave_value();
21396 return octave_value_list();
21405 char *arg1 = (
char *) 0 ;
21409 char *arg5 = (
char *) 0 ;
21422 octave_value_list _out;
21423 octave_value_list *_outp=&_out;
21424 octave_value _outv;
21434 arg1 =
reinterpret_cast< char *
>(buf1);
21439 arg2 =
static_cast< PLFLT >(val2);
21444 arg3 =
static_cast< PLFLT >(val3);
21449 arg4 =
static_cast< PLFLT >(val4);
21454 arg5 =
reinterpret_cast< char *
>(buf5);
21455 plmtex((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
21456 _outv = octave_value();
21464 return octave_value_list();
21475 char *arg1 = (
char *) 0 ;
21479 char *arg5 = (
char *) 0 ;
21492 octave_value_list _out;
21493 octave_value_list *_outp=&_out;
21494 octave_value _outv;
21504 arg1 =
reinterpret_cast< char *
>(buf1);
21509 arg2 =
static_cast< PLFLT >(val2);
21514 arg3 =
static_cast< PLFLT >(val3);
21519 arg4 =
static_cast< PLFLT >(val4);
21524 arg5 =
reinterpret_cast< char *
>(buf5);
21525 plmtex3((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
21526 _outv = octave_value();
21534 return octave_value_list();
21545 int *arg1 = (
int *) 0 ;
21546 char **arg2 = (
char **) 0 ;
21554 octave_value_list _out;
21555 octave_value_list *_outp=&_out;
21556 octave_value _outv;
21567 arg1 =
reinterpret_cast< int *
>(argp1);
21572 arg2 =
reinterpret_cast< char **
>(argp2);
21577 arg3 =
static_cast< PLINT >(val3);
21583 return octave_value_list();
21597 octave_value_list _out;
21598 octave_value_list *_outp=&_out;
21599 octave_value _outv;
21606 if (
_n_dims( args(0) ) > 1 )
21612 temp1 = args(0).matrix_value();
21616 if (
_n_dims( args(1) ) > 1 )
21624 temp3 = args(1).matrix_value();
21628 plpat(arg1,(
int const *)arg2,(
int const *)arg3);
21629 _outv = octave_value();
21645 return octave_value_list();
21675 octave_value_list _out;
21676 octave_value_list *_outp=&_out;
21677 octave_value _outv;
21687 arg1 =
static_cast< PLINT >(val1);
21692 arg2 =
static_cast< PLFLT >(val2);
21697 arg3 =
static_cast< PLFLT >(val3);
21702 arg4 =
static_cast< PLFLT >(val4);
21707 arg5 =
static_cast< PLFLT >(val5);
21708 plpath(arg1,arg2,arg3,arg4,arg5);
21709 _outv = octave_value();
21713 return octave_value_list();
21730 octave_value_list _out;
21731 octave_value_list *_outp=&_out;
21732 octave_value _outv;
21739 if (
_n_dims( args(0) ) > 1 )
21744 temp1 = args(0).matrix_value();
21745 arg2 = &temp1( 0, 0 );
21748 if (
_n_dims( args(1) ) > 1 )
21756 temp3 = args(1).matrix_value();
21757 arg3 = &temp3( 0, 0 );
21763 arg4 =
static_cast< PLINT >(val4);
21764 plpoin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
21765 _outv = octave_value();
21781 return octave_value_list();
21806 octave_value_list _out;
21807 octave_value_list *_outp=&_out;
21808 octave_value _outv;
21815 if (
_n_dims( args(0) ) > 1 )
21820 temp1 = args(0).matrix_value();
21821 arg2 = &temp1( 0, 0 );
21824 if (
_n_dims( args(1) ) > 1 )
21832 temp3 = args(1).matrix_value();
21833 arg3 = &temp3( 0, 0 );
21836 if (
_n_dims( args(2) ) > 1 )
21844 temp4 = args(2).matrix_value();
21845 arg4 = &temp4( 0, 0 );
21851 arg5 =
static_cast< PLINT >(val5);
21852 plpoin3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,arg5);
21853 _outv = octave_value();
21875 return octave_value_list();
21905 octave_value_list _out;
21906 octave_value_list *_outp=&_out;
21907 octave_value _outv;
21914 if (
_n_dims( args(0) ) > 1 )
21919 temp1 = args(0).matrix_value();
21920 arg2 = &temp1( 0, 0 );
21923 if (
_n_dims( args(1) ) > 1 )
21931 temp3 = args(1).matrix_value();
21932 arg3 = &temp3( 0, 0 );
21935 if (
_n_dims( args(2) ) > 1 )
21943 temp4 = args(2).matrix_value();
21944 arg4 = &temp4( 0, 0 );
21947 if (
_n_dims( args(3) ) > 1 )
21953 error(
"argument vector must be same length or one less" );
SWIG_fail;
21955 temp5 = args(3).matrix_value();
21963 arg6 =
static_cast< PLBOOL >(val6);
21964 plpoly3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
int const *)arg5,arg6);
21965 _outv = octave_value();
21993 return octave_value_list();
22020 octave_value_list _out;
22021 octave_value_list *_outp=&_out;
22022 octave_value _outv;
22032 arg1 =
static_cast< PLINT >(val1);
22037 arg2 =
static_cast< PLINT >(val2);
22039 _outv = octave_value();
22043 return octave_value_list();
22055 octave_value_list _out;
22056 octave_value_list *_outp=&_out;
22057 octave_value _outv;
22067 arg1 =
static_cast< PLINT >(val1);
22069 _outv = octave_value();
22073 return octave_value_list();
22087 char *arg6 = (
char *) 0 ;
22101 octave_value_list _out;
22102 octave_value_list *_outp=&_out;
22103 octave_value _outv;
22113 arg1 =
static_cast< PLFLT >(val1);
22118 arg2 =
static_cast< PLFLT >(val2);
22123 arg3 =
static_cast< PLFLT >(val3);
22128 arg4 =
static_cast< PLFLT >(val4);
22133 arg5 =
static_cast< PLFLT >(val5);
22138 arg6 =
reinterpret_cast< char *
>(buf6);
22139 plptex(arg1,arg2,arg3,arg4,arg5,(
char const *)arg6);
22140 _outv = octave_value();
22146 return octave_value_list();
22166 char *arg11 = (
char *) 0 ;
22190 octave_value_list _out;
22191 octave_value_list *_outp=&_out;
22192 octave_value _outv;
22202 arg1 =
static_cast< PLFLT >(val1);
22207 arg2 =
static_cast< PLFLT >(val2);
22212 arg3 =
static_cast< PLFLT >(val3);
22217 arg4 =
static_cast< PLFLT >(val4);
22222 arg5 =
static_cast< PLFLT >(val5);
22227 arg6 =
static_cast< PLFLT >(val6);
22232 arg7 =
static_cast< PLFLT >(val7);
22237 arg8 =
static_cast< PLFLT >(val8);
22242 arg9 =
static_cast< PLFLT >(val9);
22247 arg10 =
static_cast< PLFLT >(val10);
22252 arg11 =
reinterpret_cast< char *
>(buf11);
22253 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(
char const *)arg11);
22254 _outv = octave_value();
22260 return octave_value_list();
22270 octave_value_list _out;
22271 octave_value_list *_outp=&_out;
22272 octave_value _outv;
22284 return octave_value_list();
22293 octave_value_list _out;
22294 octave_value_list *_outp=&_out;
22295 octave_value _outv;
22302 _outv = octave_value();
22306 return octave_value_list();
22333 octave_value_list _out;
22334 octave_value_list *_outp=&_out;
22335 octave_value _outv;
22348 arg1 =
static_cast< PLFLT >(val1);
22353 arg2 =
static_cast< PLFLT >(val2);
22358 arg3 =
static_cast< PLFLT >(val3);
22359 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
22360 _outv = octave_value();
22382 return octave_value_list();
22397 octave_value_list _out;
22398 octave_value_list *_outp=&_out;
22399 octave_value _outv;
22409 arg1 =
static_cast< PLFLT >(val1);
22414 arg2 =
static_cast< PLFLT >(val2);
22416 _outv = octave_value();
22420 return octave_value_list();
22436 octave_value_list _out;
22437 octave_value_list *_outp=&_out;
22438 octave_value _outv;
22445 if (
_n_dims( args(0) ) > 1 )
22450 temp1 = args(0).matrix_value();
22455 if (
_n_dims( args(1) ) > 1 )
22463 temp2 = args(1).matrix_value();
22468 if (
_n_dims( args(2) ) > 1 )
22476 temp3 = args(2).matrix_value();
22481 plscmap0((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
22482 _outv = octave_value();
22504 return octave_value_list();
22531 octave_value_list _out;
22532 octave_value_list *_outp=&_out;
22533 octave_value _outv;
22540 if (
_n_dims( args(0) ) > 1 )
22545 temp1 = args(0).matrix_value();
22550 if (
_n_dims( args(1) ) > 1 )
22558 temp2 = args(1).matrix_value();
22563 if (
_n_dims( args(2) ) > 1 )
22571 temp3 = args(2).matrix_value();
22576 if (
_n_dims( args(3) ) > 1 )
22584 temp4 = args(3).matrix_value();
22585 arg4 = &temp4( 0, 0 );
22588 plscmap0a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
22589 _outv = octave_value();
22617 return octave_value_list();
22641 octave_value_list _out;
22642 octave_value_list *_outp=&_out;
22643 octave_value _outv;
22653 arg1 =
static_cast< PLINT >(val1);
22655 _outv = octave_value();
22659 return octave_value_list();
22675 octave_value_list _out;
22676 octave_value_list *_outp=&_out;
22677 octave_value _outv;
22684 if (
_n_dims( args(0) ) > 1 )
22689 temp1 = args(0).matrix_value();
22694 if (
_n_dims( args(1) ) > 1 )
22702 temp2 = args(1).matrix_value();
22707 if (
_n_dims( args(2) ) > 1 )
22715 temp3 = args(2).matrix_value();
22720 plscmap1((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
22721 _outv = octave_value();
22743 return octave_value_list();
22770 octave_value_list _out;
22771 octave_value_list *_outp=&_out;
22772 octave_value _outv;
22779 if (
_n_dims( args(0) ) > 1 )
22784 temp1 = args(0).matrix_value();
22789 if (
_n_dims( args(1) ) > 1 )
22797 temp2 = args(1).matrix_value();
22802 if (
_n_dims( args(2) ) > 1 )
22810 temp3 = args(2).matrix_value();
22815 if (
_n_dims( args(3) ) > 1 )
22823 temp4 = args(3).matrix_value();
22824 arg4 = &temp4( 0, 0 );
22827 plscmap1a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
22828 _outv = octave_value();
22856 return octave_value_list();
22891 octave_value_list _out;
22892 octave_value_list *_outp=&_out;
22893 octave_value _outv;
22903 arg1 =
static_cast< PLBOOL >(val1);
22905 if (
_n_dims( args(1) ) > 1 )
22910 temp2 = args(1).matrix_value();
22911 arg3 = &temp2( 0, 0 );
22914 if (
_n_dims( args(2) ) > 1 )
22922 temp4 = args(2).matrix_value();
22923 arg4 = &temp4( 0, 0 );
22926 if (
_n_dims( args(3) ) > 1 )
22934 temp5 = args(3).matrix_value();
22935 arg5 = &temp5( 0, 0 );
22938 if (
_n_dims( args(4) ) > 1 )
22946 temp6 = args(4).matrix_value();
22947 arg6 = &temp6( 0, 0 );
22950 if (
_n_dims( args(5) ) > 1 )
22956 error(
"argument vector must be same length or one less" );
SWIG_fail;
22958 temp7 = args(5).matrix_value();
22962 plscmap1l(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
int const *)arg7);
22963 _outv = octave_value();
22997 return octave_value_list();
23037 octave_value_list _out;
23038 octave_value_list *_outp=&_out;
23039 octave_value _outv;
23049 arg1 =
static_cast< PLBOOL >(val1);
23051 if (
_n_dims( args(1) ) > 1 )
23056 temp2 = args(1).matrix_value();
23057 arg3 = &temp2( 0, 0 );
23060 if (
_n_dims( args(2) ) > 1 )
23068 temp4 = args(2).matrix_value();
23069 arg4 = &temp4( 0, 0 );
23072 if (
_n_dims( args(3) ) > 1 )
23080 temp5 = args(3).matrix_value();
23081 arg5 = &temp5( 0, 0 );
23084 if (
_n_dims( args(4) ) > 1 )
23092 temp6 = args(4).matrix_value();
23093 arg6 = &temp6( 0, 0 );
23096 if (
_n_dims( args(5) ) > 1 )
23104 temp7 = args(5).matrix_value();
23105 arg7 = &temp7( 0, 0 );
23108 if (
_n_dims( args(6) ) > 1 )
23114 error(
"argument vector must be same length or one less" );
SWIG_fail;
23116 temp8 = args(6).matrix_value();
23120 plscmap1la(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
double const *)arg7,(
int const *)arg8);
23121 _outv = octave_value();
23161 return octave_value_list();
23191 octave_value_list _out;
23192 octave_value_list *_outp=&_out;
23193 octave_value _outv;
23203 arg1 =
static_cast< PLINT >(val1);
23205 _outv = octave_value();
23209 return octave_value_list();
23224 octave_value_list _out;
23225 octave_value_list *_outp=&_out;
23226 octave_value _outv;
23236 arg1 =
static_cast< PLFLT >(val1);
23241 arg2 =
static_cast< PLFLT >(val2);
23243 _outv = octave_value();
23247 return octave_value_list();
23262 octave_value_list _out;
23263 octave_value_list *_outp=&_out;
23264 octave_value _outv;
23273 _outv = octave_value();
23289 return octave_value_list();
23310 octave_value_list _out;
23311 octave_value_list *_outp=&_out;
23312 octave_value _outv;
23322 arg1 =
static_cast< PLINT >(val1);
23327 arg2 =
static_cast< PLINT >(val2);
23332 arg3 =
static_cast< PLINT >(val3);
23337 arg4 =
static_cast< PLINT >(val4);
23338 plscol0(arg1,arg2,arg3,arg4);
23339 _outv = octave_value();
23343 return octave_value_list();
23367 octave_value_list _out;
23368 octave_value_list *_outp=&_out;
23369 octave_value _outv;
23379 arg1 =
static_cast< PLINT >(val1);
23384 arg2 =
static_cast< PLINT >(val2);
23389 arg3 =
static_cast< PLINT >(val3);
23394 arg4 =
static_cast< PLINT >(val4);
23399 arg5 =
static_cast< PLFLT >(val5);
23400 plscol0a(arg1,arg2,arg3,arg4,arg5);
23401 _outv = octave_value();
23405 return octave_value_list();
23423 octave_value_list _out;
23424 octave_value_list *_outp=&_out;
23425 octave_value _outv;
23435 arg1 =
static_cast< PLINT >(val1);
23440 arg2 =
static_cast< PLINT >(val2);
23445 arg3 =
static_cast< PLINT >(val3);
23447 _outv = octave_value();
23451 return octave_value_list();
23472 octave_value_list _out;
23473 octave_value_list *_outp=&_out;
23474 octave_value _outv;
23484 arg1 =
static_cast< PLINT >(val1);
23489 arg2 =
static_cast< PLINT >(val2);
23494 arg3 =
static_cast< PLINT >(val3);
23499 arg4 =
static_cast< PLFLT >(val4);
23501 _outv = octave_value();
23505 return octave_value_list();
23517 octave_value_list _out;
23518 octave_value_list *_outp=&_out;
23519 octave_value _outv;
23529 arg1 =
static_cast< PLINT >(val1);
23531 _outv = octave_value();
23535 return octave_value_list();
23547 octave_value_list _out;
23548 octave_value_list *_outp=&_out;
23549 octave_value _outv;
23559 arg1 =
static_cast< PLINT >(val1);
23561 _outv = octave_value();
23565 return octave_value_list();
23574 char *arg1 = (
char *) 0 ;
23578 octave_value_list _out;
23579 octave_value_list *_outp=&_out;
23580 octave_value _outv;
23590 arg1 =
reinterpret_cast< char *
>(buf1);
23591 plsdev((
char const *)arg1);
23592 _outv = octave_value();
23598 return octave_value_list();
23620 octave_value_list _out;
23621 octave_value_list *_outp=&_out;
23622 octave_value _outv;
23632 arg1 =
static_cast< PLFLT >(val1);
23637 arg2 =
static_cast< PLFLT >(val2);
23642 arg3 =
static_cast< PLFLT >(val3);
23647 arg4 =
static_cast< PLFLT >(val4);
23649 _outv = octave_value();
23653 return octave_value_list();
23680 octave_value_list _out;
23681 octave_value_list *_outp=&_out;
23682 octave_value _outv;
23692 arg1 =
static_cast< PLINT >(val1);
23697 arg2 =
static_cast< PLINT >(val2);
23702 arg3 =
static_cast< PLINT >(val3);
23707 arg4 =
static_cast< PLINT >(val4);
23712 arg5 =
static_cast< PLFLT >(val5);
23717 arg6 =
static_cast< PLFLT >(val6);
23718 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
23719 _outv = octave_value();
23723 return octave_value_list();
23735 octave_value_list _out;
23736 octave_value_list *_outp=&_out;
23737 octave_value _outv;
23747 arg1 =
static_cast< PLFLT >(val1);
23749 _outv = octave_value();
23753 return octave_value_list();
23774 octave_value_list _out;
23775 octave_value_list *_outp=&_out;
23776 octave_value _outv;
23786 arg1 =
static_cast< PLFLT >(val1);
23791 arg2 =
static_cast< PLFLT >(val2);
23796 arg3 =
static_cast< PLFLT >(val3);
23801 arg4 =
static_cast< PLFLT >(val4);
23803 _outv = octave_value();
23807 return octave_value_list();
23828 octave_value_list _out;
23829 octave_value_list *_outp=&_out;
23830 octave_value _outv;
23840 arg1 =
static_cast< PLFLT >(val1);
23845 arg2 =
static_cast< PLFLT >(val2);
23850 arg3 =
static_cast< PLFLT >(val3);
23855 arg4 =
static_cast< PLFLT >(val4);
23857 _outv = octave_value();
23861 return octave_value_list();
23870 unsigned int arg1 ;
23871 unsigned int val1 ;
23873 octave_value_list _out;
23874 octave_value_list *_outp=&_out;
23875 octave_value _outv;
23885 arg1 =
static_cast< unsigned int >(val1);
23887 _outv = octave_value();
23891 return octave_value_list();
23903 octave_value_list _out;
23904 octave_value_list *_outp=&_out;
23905 octave_value _outv;
23915 arg1 =
static_cast< char >(val1);
23917 _outv = octave_value();
23921 return octave_value_list();
23930 char *arg1 = (
char *) 0 ;
23931 char *arg2 = (
char *) 0 ;
23938 octave_value_list _out;
23939 octave_value_list *_outp=&_out;
23940 octave_value _outv;
23951 arg1 =
reinterpret_cast< char *
>(buf1);
23956 arg2 =
reinterpret_cast< char *
>(buf2);
23957 result = (
PLINT)
plsetopt((
char const *)arg1,(
char const *)arg2);
23966 return octave_value_list();
23986 octave_value_list _out;
23987 octave_value_list *_outp=&_out;
23988 octave_value _outv;
23998 arg1 =
static_cast< PLINT >(val1);
24003 arg2 =
static_cast< PLINT >(val2);
24008 arg3 =
static_cast< PLINT >(val3);
24010 _outv = octave_value();
24014 return octave_value_list();
24024 unsigned int val1 ;
24026 octave_value_list _out;
24027 octave_value_list *_outp=&_out;
24028 octave_value _outv;
24040 _outv = octave_value();
24044 return octave_value_list();
24053 char *arg1 = (
char *) 0 ;
24057 octave_value_list _out;
24058 octave_value_list *_outp=&_out;
24059 octave_value _outv;
24069 arg1 =
reinterpret_cast< char *
>(buf1);
24071 _outv = octave_value();
24077 return octave_value_list();
24096 octave_value_list _out;
24097 octave_value_list *_outp=&_out;
24098 octave_value _outv;
24108 arg1 =
static_cast< PLINT >(val1);
24113 arg2 =
static_cast< PLINT >(val2);
24118 arg3 =
static_cast< PLINT >(val3);
24120 _outv = octave_value();
24124 return octave_value_list();
24136 octave_value_list _out;
24137 octave_value_list *_outp=&_out;
24138 octave_value _outv;
24145 octave_value obj = args(0);
24146 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24147 if ( !obj.isempty() )
24149 if ( !obj.is_empty() )
24152 if ( obj.is_function_handle() || obj.is_inline_function() )
24156 else if ( obj.is_string() )
24173 _outv = octave_value();
24177 return octave_value_list();
24192 octave_value_list _out;
24193 octave_value_list *_outp=&_out;
24194 octave_value _outv;
24204 arg1 =
static_cast< PLFLT >(val1);
24209 arg2 =
static_cast< PLFLT >(val2);
24211 _outv = octave_value();
24215 return octave_value_list();
24230 octave_value_list _out;
24231 octave_value_list *_outp=&_out;
24232 octave_value _outv;
24242 arg1 =
static_cast< PLFLT >(val1);
24247 arg2 =
static_cast< PLFLT >(val2);
24249 _outv = octave_value();
24253 return octave_value_list();
24265 octave_value_list _out;
24266 octave_value_list *_outp=&_out;
24267 octave_value _outv;
24277 arg1 =
static_cast< PLINT >(val1);
24279 _outv = octave_value();
24283 return octave_value_list();
24310 octave_value_list _out;
24311 octave_value_list *_outp=&_out;
24312 octave_value _outv;
24322 arg1 =
static_cast< PLFLT >(val1);
24327 arg2 =
static_cast< PLFLT >(val2);
24332 arg3 =
static_cast< PLINT >(val3);
24337 arg4 =
static_cast< PLINT >(val4);
24342 arg5 =
static_cast< PLINT >(val5);
24347 arg6 =
static_cast< PLINT >(val6);
24348 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
24349 _outv = octave_value();
24353 return octave_value_list();
24362 char *arg1 = (
char *) 0 ;
24366 octave_value_list _out;
24367 octave_value_list *_outp=&_out;
24368 octave_value _outv;
24378 arg1 =
reinterpret_cast< char *
>(buf1);
24380 _outv = octave_value();
24386 return octave_value_list();
24396 char *arg1 = (
char *) 0 ;
24403 octave_value_list _out;
24404 octave_value_list *_outp=&_out;
24405 octave_value _outv;
24415 arg1 =
reinterpret_cast< char *
>(buf1);
24420 arg2 =
static_cast< PLBOOL >(val2);
24421 plspal1((
char const *)arg1,arg2);
24422 _outv = octave_value();
24428 return octave_value_list();
24441 octave_value_list _out;
24442 octave_value_list *_outp=&_out;
24443 octave_value _outv;
24453 arg1 =
static_cast< PLBOOL >(val1);
24455 _outv = octave_value();
24459 return octave_value_list();
24471 octave_value_list _out;
24472 octave_value_list *_outp=&_out;
24473 octave_value _outv;
24483 arg1 =
static_cast< PLINT >(val1);
24485 _outv = octave_value();
24489 return octave_value_list();
24504 octave_value_list _out;
24505 octave_value_list *_outp=&_out;
24506 octave_value _outv;
24516 arg1 =
static_cast< PLINT >(val1);
24521 arg2 =
static_cast< PLINT >(val2);
24523 _outv = octave_value();
24527 return octave_value_list();
24542 octave_value_list _out;
24543 octave_value_list *_outp=&_out;
24544 octave_value _outv;
24554 arg1 =
static_cast< PLFLT >(val1);
24559 arg2 =
static_cast< PLFLT >(val2);
24561 _outv = octave_value();
24565 return octave_value_list();
24580 octave_value_list _out;
24581 octave_value_list *_outp=&_out;
24582 octave_value _outv;
24592 arg1 =
static_cast< PLINT >(val1);
24597 arg2 =
static_cast< PLINT >(val2);
24599 _outv = octave_value();
24603 return octave_value_list();
24612 char *arg1 = (
char *) 0 ;
24622 octave_value_list _out;
24623 octave_value_list *_outp=&_out;
24624 octave_value _outv;
24634 arg1 =
reinterpret_cast< char *
>(buf1);
24639 arg2 =
static_cast< PLINT >(val2);
24644 arg3 =
static_cast< PLINT >(val3);
24645 plstart((
char const *)arg1,arg2,arg3);
24646 _outv = octave_value();
24652 return octave_value_list();
24665 octave_value_list _out;
24666 octave_value_list *_outp=&_out;
24667 octave_value _outv;
24674 octave_value obj = args(0);
24675 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24676 if ( !obj.isempty() )
24678 if ( !obj.is_empty() )
24681 if ( obj.is_function_handle() || obj.is_inline_function() )
24685 else if ( obj.is_string() )
24702 _outv = octave_value();
24706 return octave_value_list();
24718 char *arg4 = (
char *) 0 ;
24724 octave_value_list _out;
24725 octave_value_list *_outp=&_out;
24726 octave_value _outv;
24733 if (
_n_dims( args(0) ) > 1 )
24738 temp1 = args(0).matrix_value();
24739 arg2 = &temp1( 0, 0 );
24742 if (
_n_dims( args(1) ) > 1 )
24750 temp3 = args(1).matrix_value();
24751 arg3 = &temp3( 0, 0 );
24757 arg4 =
reinterpret_cast< char *
>(buf4);
24758 plstring(arg1,(
double const *)arg2,(
double const *)arg3,(
char const *)arg4);
24759 _outv = octave_value();
24777 return octave_value_list();
24797 char *arg5 = (
char *) 0 ;
24804 octave_value_list _out;
24805 octave_value_list *_outp=&_out;
24806 octave_value _outv;
24813 if (
_n_dims( args(0) ) > 1 )
24818 temp1 = args(0).matrix_value();
24819 arg2 = &temp1( 0, 0 );
24822 if (
_n_dims( args(1) ) > 1 )
24830 temp3 = args(1).matrix_value();
24831 arg3 = &temp3( 0, 0 );
24834 if (
_n_dims( args(2) ) > 1 )
24842 temp4 = args(2).matrix_value();
24843 arg4 = &temp4( 0, 0 );
24849 arg5 =
reinterpret_cast< char *
>(buf5);
24850 plstring3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
char const *)arg5);
24851 _outv = octave_value();
24875 return octave_value_list();
24906 octave_value_list _out;
24907 octave_value_list *_outp=&_out;
24908 octave_value _outv;
24918 arg1 =
static_cast< PLINT >(val1);
24923 arg2 =
static_cast< PLINT >(val2);
24928 arg3 =
static_cast< PLFLT >(val3);
24933 arg4 =
static_cast< PLFLT >(val4);
24935 _outv = octave_value();
24939 return octave_value_list();
24951 octave_value_list _out;
24952 octave_value_list *_outp=&_out;
24953 octave_value _outv;
24963 arg1 =
static_cast< PLINT >(val1);
24965 _outv = octave_value();
24969 return octave_value_list();
24983 octave_value_list _out;
24984 octave_value_list *_outp=&_out;
24985 octave_value _outv;
24992 if (
_n_dims( args(0) ) > 1 )
24998 temp1 = args(0).matrix_value();
25002 if (
_n_dims( args(1) ) > 1 )
25010 temp3 = args(1).matrix_value();
25014 plstyl(arg1,(
int const *)arg2,(
int const *)arg3);
25015 _outv = octave_value();
25031 return octave_value_list();
25054 octave_value_list _out;
25055 octave_value_list *_outp=&_out;
25056 octave_value _outv;
25063 if (
_n_dims( args(0) ) > 1 )
25067 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25068 if ( !args(0).isempty() )
25070 if ( !args(0).is_empty() )
25074 temp1 = args(0).matrix_value();
25075 arg1 = &temp1( 0, 0 );
25084 if (
_n_dims( args(1) ) > 1 )
25088 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25089 if ( !args(1).isempty() )
25091 if ( !args(1).is_empty() )
25098 temp2 = args(1).matrix_value();
25099 arg2 = &temp2( 0, 0 );
25112 arg4 =
static_cast< PLBOOL >(val4);
25113 plsvect((
double const *)arg1,(
double const *)arg2,arg3,arg4);
25114 _outv = octave_value();
25130 return octave_value_list();
25157 octave_value_list _out;
25158 octave_value_list *_outp=&_out;
25159 octave_value _outv;
25169 arg1 =
static_cast< PLFLT >(val1);
25174 arg2 =
static_cast< PLFLT >(val2);
25179 arg3 =
static_cast< PLFLT >(val3);
25184 arg4 =
static_cast< PLFLT >(val4);
25185 plsvpa(arg1,arg2,arg3,arg4);
25186 _outv = octave_value();
25190 return octave_value_list();
25205 octave_value_list _out;
25206 octave_value_list *_outp=&_out;
25207 octave_value _outv;
25217 arg1 =
static_cast< PLINT >(val1);
25222 arg2 =
static_cast< PLINT >(val2);
25224 _outv = octave_value();
25228 return octave_value_list();
25243 octave_value_list _out;
25244 octave_value_list *_outp=&_out;
25245 octave_value _outv;
25255 arg1 =
static_cast< PLINT >(val1);
25260 arg2 =
static_cast< PLINT >(val2);
25262 _outv = octave_value();
25266 return octave_value_list();
25283 octave_value_list _out;
25284 octave_value_list *_outp=&_out;
25285 octave_value _outv;
25292 if (
_n_dims( args(0) ) > 1 )
25297 temp1 = args(0).matrix_value();
25298 arg2 = &temp1( 0, 0 );
25301 if (
_n_dims( args(1) ) > 1 )
25309 temp3 = args(1).matrix_value();
25310 arg3 = &temp3( 0, 0 );
25316 arg4 =
static_cast< PLINT >(val4);
25317 plsym(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
25318 _outv = octave_value();
25334 return octave_value_list();
25355 octave_value_list _out;
25356 octave_value_list *_outp=&_out;
25357 octave_value _outv;
25367 arg1 =
static_cast< PLINT >(val1);
25372 arg2 =
static_cast< PLINT >(val2);
25374 _outv = octave_value();
25378 return octave_value_list();
25387 octave_value_list _out;
25388 octave_value_list *_outp=&_out;
25389 octave_value _outv;
25396 _outv = octave_value();
25400 return octave_value_list();
25409 char *arg1 = (
char *) 0 ;
25413 octave_value_list _out;
25414 octave_value_list *_outp=&_out;
25415 octave_value _outv;
25425 arg1 =
reinterpret_cast< char *
>(buf1);
25427 _outv = octave_value();
25433 return octave_value_list();
25446 octave_value_list _out;
25447 octave_value_list *_outp=&_out;
25448 octave_value _outv;
25458 arg1 =
static_cast< PLFLT >(val1);
25460 _outv = octave_value();
25464 return octave_value_list();
25488 octave_value_list _out;
25489 octave_value_list *_outp=&_out;
25490 octave_value _outv;
25500 arg1 =
static_cast< PLFLT >(val1);
25505 arg2 =
static_cast< PLFLT >(val2);
25510 arg3 =
static_cast< PLFLT >(val3);
25515 arg4 =
static_cast< PLFLT >(val4);
25520 arg5 =
static_cast< PLFLT >(val5);
25521 plvpas(arg1,arg2,arg3,arg4,arg5);
25522 _outv = octave_value();
25526 return octave_value_list();
25547 octave_value_list _out;
25548 octave_value_list *_outp=&_out;
25549 octave_value _outv;
25559 arg1 =
static_cast< PLFLT >(val1);
25564 arg2 =
static_cast< PLFLT >(val2);
25569 arg3 =
static_cast< PLFLT >(val3);
25574 arg4 =
static_cast< PLFLT >(val4);
25575 plvpor(arg1,arg2,arg3,arg4);
25576 _outv = octave_value();
25580 return octave_value_list();
25589 octave_value_list _out;
25590 octave_value_list *_outp=&_out;
25591 octave_value _outv;
25598 _outv = octave_value();
25602 return octave_value_list();
25644 octave_value_list _out;
25645 octave_value_list *_outp=&_out;
25646 octave_value _outv;
25656 arg1 =
static_cast< PLFLT >(val1);
25661 arg2 =
static_cast< PLFLT >(val2);
25666 arg3 =
static_cast< PLFLT >(val3);
25671 arg4 =
static_cast< PLFLT >(val4);
25676 arg5 =
static_cast< PLFLT >(val5);
25681 arg6 =
static_cast< PLFLT >(val6);
25686 arg7 =
static_cast< PLFLT >(val7);
25691 arg8 =
static_cast< PLFLT >(val8);
25696 arg9 =
static_cast< PLFLT >(val9);
25701 arg10 =
static_cast< PLFLT >(val10);
25706 arg11 =
static_cast< PLFLT >(val11);
25707 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25708 _outv = octave_value();
25712 return octave_value_list();
25724 octave_value_list _out;
25725 octave_value_list *_outp=&_out;
25726 octave_value _outv;
25736 arg1 =
static_cast< PLFLT >(val1);
25738 _outv = octave_value();
25742 return octave_value_list();
25763 octave_value_list _out;
25764 octave_value_list *_outp=&_out;
25765 octave_value _outv;
25775 arg1 =
static_cast< PLFLT >(val1);
25780 arg2 =
static_cast< PLFLT >(val2);
25785 arg3 =
static_cast< PLFLT >(val3);
25790 arg4 =
static_cast< PLFLT >(val4);
25791 plwind(arg1,arg2,arg3,arg4);
25792 _outv = octave_value();
25796 return octave_value_list();
25811 octave_value_list _out;
25812 octave_value_list *_outp=&_out;
25813 octave_value _outv;
25824 arg1 =
static_cast< PLBOOL >(val1);
25826 _outv = octave_value();
25836 return octave_value_list();
25846 char *arg2 = (
char *) 0 ;
25862 octave_value_list _out;
25863 octave_value_list *_outp=&_out;
25864 octave_value _outv;
25871 octave_value obj = args(0);
25872 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25873 if ( !obj.isempty() )
25875 if ( !obj.is_empty() )
25878 if ( obj.is_function_handle() || obj.is_inline_function() )
25882 else if ( obj.is_string() )
25898 arg2 =
reinterpret_cast< char *
>(buf2);
25903 arg3 =
static_cast< PLFLT >(val3);
25908 arg4 =
static_cast< PLFLT >(val4);
25913 arg5 =
static_cast< PLFLT >(val5);
25918 arg6 =
static_cast< PLFLT >(val6);
25919 plmap(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6);
25920 _outv = octave_value();
25926 return octave_value_list();
25937 char *arg2 = (
char *) 0 ;
25956 octave_value_list _out;
25957 octave_value_list *_outp=&_out;
25958 octave_value _outv;
25965 octave_value obj = args(0);
25966 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25967 if ( !obj.isempty() )
25969 if ( !obj.is_empty() )
25972 if ( obj.is_function_handle() || obj.is_inline_function() )
25976 else if ( obj.is_string() )
25992 arg2 =
reinterpret_cast< char *
>(buf2);
25997 arg3 =
static_cast< PLFLT >(val3);
26002 arg4 =
static_cast< PLFLT >(val4);
26007 arg5 =
static_cast< PLFLT >(val5);
26012 arg6 =
static_cast< PLFLT >(val6);
26014 if (
_n_dims( args(6) ) > 1 )
26018 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26019 if ( !args(6).isempty() )
26021 if ( !args(6).is_empty() )
26025 temp7 = args(6).matrix_value();
26026 arg7 =
new PLINT[arg8];
26035 plmapline(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
26036 _outv = octave_value();
26048 return octave_value_list();
26062 char *arg2 = (
char *) 0 ;
26063 char *arg3 = (
char *) 0 ;
26085 octave_value_list _out;
26086 octave_value_list *_outp=&_out;
26087 octave_value _outv;
26094 octave_value obj = args(0);
26095 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26096 if ( !obj.isempty() )
26098 if ( !obj.is_empty() )
26101 if ( obj.is_function_handle() || obj.is_inline_function() )
26105 else if ( obj.is_string() )
26121 arg2 =
reinterpret_cast< char *
>(buf2);
26126 arg3 =
reinterpret_cast< char *
>(buf3);
26131 arg4 =
static_cast< PLFLT >(val4);
26136 arg5 =
static_cast< PLFLT >(val5);
26141 arg6 =
static_cast< PLFLT >(val6);
26146 arg7 =
static_cast< PLFLT >(val7);
26148 if (
_n_dims( args(7) ) > 1 )
26152 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26153 if ( !args(7).isempty() )
26155 if ( !args(7).is_empty() )
26159 temp8 = args(7).matrix_value();
26160 arg8 =
new PLINT[arg9];
26169 plmapstring(arg1,(
char const *)arg2,(
char const *)arg3,arg4,arg5,arg6,arg7,(
int const *)arg8,arg9);
26170 _outv = octave_value();
26184 return octave_value_list();
26199 char *arg2 = (
char *) 0 ;
26203 char *arg6 = (
char *) 0 ;
26231 octave_value_list _out;
26232 octave_value_list *_outp=&_out;
26233 octave_value _outv;
26240 octave_value obj = args(0);
26241 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26242 if ( !obj.isempty() )
26244 if ( !obj.is_empty() )
26247 if ( obj.is_function_handle() || obj.is_inline_function() )
26251 else if ( obj.is_string() )
26267 arg2 =
reinterpret_cast< char *
>(buf2);
26272 arg3 =
static_cast< PLFLT >(val3);
26277 arg4 =
static_cast< PLFLT >(val4);
26282 arg5 =
static_cast< PLFLT >(val5);
26287 arg6 =
reinterpret_cast< char *
>(buf6);
26292 arg7 =
static_cast< PLFLT >(val7);
26297 arg8 =
static_cast< PLFLT >(val8);
26302 arg9 =
static_cast< PLFLT >(val9);
26307 arg10 =
static_cast< PLFLT >(val10);
26312 arg11 =
static_cast< PLINT >(val11);
26313 plmaptex(arg1,(
char const *)arg2,arg3,arg4,arg5,(
char const *)arg6,arg7,arg8,arg9,arg10,arg11);
26314 _outv = octave_value();
26322 return octave_value_list();
26334 char *arg2 = (
char *) 0 ;
26353 octave_value_list _out;
26354 octave_value_list *_outp=&_out;
26355 octave_value _outv;
26362 octave_value obj = args(0);
26363 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26364 if ( !obj.isempty() )
26366 if ( !obj.is_empty() )
26369 if ( obj.is_function_handle() || obj.is_inline_function() )
26373 else if ( obj.is_string() )
26389 arg2 =
reinterpret_cast< char *
>(buf2);
26394 arg3 =
static_cast< PLFLT >(val3);
26399 arg4 =
static_cast< PLFLT >(val4);
26404 arg5 =
static_cast< PLFLT >(val5);
26409 arg6 =
static_cast< PLFLT >(val6);
26411 if (
_n_dims( args(6) ) > 1 )
26415 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26416 if ( !args(6).isempty() )
26418 if ( !args(6).is_empty() )
26422 temp7 = args(6).matrix_value();
26423 arg7 =
new PLINT[arg8];
26432 plmapfill(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
26433 _outv = octave_value();
26445 return octave_value_list();
26477 octave_value_list _out;
26478 octave_value_list *_outp=&_out;
26479 octave_value _outv;
26486 octave_value obj = args(0);
26487 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26488 if ( !obj.isempty() )
26490 if ( !obj.is_empty() )
26493 if ( obj.is_function_handle() || obj.is_inline_function() )
26497 else if ( obj.is_string() )
26513 arg2 =
static_cast< PLFLT >(val2);
26518 arg3 =
static_cast< PLFLT >(val3);
26523 arg4 =
static_cast< PLFLT >(val4);
26528 arg5 =
static_cast< PLFLT >(val5);
26533 arg6 =
static_cast< PLFLT >(val6);
26538 arg7 =
static_cast< PLFLT >(val7);
26540 _outv = octave_value();
26544 return octave_value_list();
26553 octave_value_list _out;
26554 octave_value_list *_outp=&_out;
26555 octave_value _outv;
26562 _outv = octave_value();
26566 return octave_value_list();
26575 octave_value_list _out;
26576 octave_value_list *_outp=&_out;
26577 octave_value _outv;
26584 _outv = octave_value();
26588 return octave_value_list();
26597 char *arg1 = (
char *) 0 ;
26598 char *arg2 = (
char *) 0 ;
26605 octave_value_list _out;
26606 octave_value_list *_outp=&_out;
26607 octave_value _outv;
26617 arg1 =
reinterpret_cast< char *
>(buf1);
26622 arg2 =
reinterpret_cast< char *
>(buf2);
26623 plSetUsage((
char const *)arg1,(
char const *)arg2);
26624 _outv = octave_value();
26632 return octave_value_list();
26643 octave_value_list _out;
26644 octave_value_list *_outp=&_out;
26645 octave_value _outv;
26652 _outv = octave_value();
26656 return octave_value_list();
26666 {
"testppchar",_wrap_testppchar,0,0,2,0},
26668 {
"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
26671 {
"plcont0",_wrap_plcont0,0,0,2,0},
26672 {
"plcont1",_wrap_plcont1,0,0,2,0},
26673 {
"plcont2",_wrap_plcont2,0,0,2,0},
26674 {
"plcont2p",_wrap_plcont2p,0,0,2,0},
26684 {
"plshade1",_wrap_plshade1,0,0,2,0},
26685 {
"plshade2",_wrap_plshade2,0,0,2,0},
26687 {
"plshadesx",_wrap_plshadesx,0,0,2,0},
26688 {
"plshades1",_wrap_plshades1,0,0,2,0},
26689 {
"plshades2",_wrap_plshades2,0,0,2,0},
26691 {
"plvect1",_wrap_plvect1,0,0,2,0},
26692 {
"plvect2",_wrap_plvect2,0,0,2,0},
26693 {
"pplimage",_wrap_pplimage,0,0,2,0},
26695 {
"plimagefrx",_wrap_plimagefrx,0,0,2,0},
26696 {
"plimagefr1",_wrap_plimagefr1,0,0,2,0},
26697 {
"plimagefr2",_wrap_plimagefr2,0,0,2,0},
26983 #define SWIGRUNTIME_DEBUG
27006 if (!module_head) {
27019 }
while (iter!= module_head);
27030 if (init == 0)
return;
27033 #ifdef SWIGRUNTIME_DEBUG
27034 printf(
"SWIG_InitializeModule: size %lu\n", (
unsigned long)
swig_module.
size);
27041 #ifdef SWIGRUNTIME_DEBUG
27051 #ifdef SWIGRUNTIME_DEBUG
27052 printf(
"SWIG_InitializeModule: found type %s\n", type->
name);
27056 #ifdef SWIGRUNTIME_DEBUG
27057 printf(
"SWIG_InitializeModule: found and overwrite type %s \n", type->
name);
27066 while (cast->
type) {
27070 #ifdef SWIGRUNTIME_DEBUG
27071 printf(
"SWIG_InitializeModule: look cast %s\n", cast->
type->
name);
27075 #ifdef SWIGRUNTIME_DEBUG
27076 if (ret) printf(
"SWIG_InitializeModule: found cast %s\n", ret->
name);
27081 #ifdef SWIGRUNTIME_DEBUG
27082 printf(
"SWIG_InitializeModule: skip old type %s\n", ret->
name);
27089 #ifdef SWIGRUNTIME_DEBUG
27090 if (ocast) printf(
"SWIG_InitializeModule: skip old cast %s\n", ret->
name);
27092 if (!ocast) ret = 0;
27097 #ifdef SWIGRUNTIME_DEBUG
27098 printf(
"SWIG_InitializeModule: adding cast %s\n", cast->
type->
name);
27113 #ifdef SWIGRUNTIME_DEBUG
27114 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
27119 while (cast->
type) {
27120 printf(
"SWIG_InitializeModule: cast type %s\n", cast->
type->
name);
27124 printf(
"---- Total casts: %d\n",j);
27126 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
27139 static int init_run = 0;
27141 if (init_run)
return;
27152 equiv = equiv->
next;
27172 #if SWIG_OCTAVE_PREREQ(6,0,0)
27173 #elif SWIG_OCTAVE_PREREQ(4,2,0)
27174 octave::unwind_protect frame;
27175 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27176 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27177 #elif SWIG_OCTAVE_PREREQ(3,3,50)
27178 unwind_protect frame;
27179 frame.protect_var(error_state); error_state = 0;
27180 frame.protect_var(warning_state); warning_state = 0;
27181 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27182 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27184 unwind_protect::begin_frame(
"SWIG_Octave_LoadModule");
27185 unwind_protect_int(error_state); error_state = 0;
27186 unwind_protect_int(warning_state); warning_state = 0;
27187 unwind_protect_bool(discard_error_messages); discard_error_messages =
true;
27188 unwind_protect_bool(discard_warning_messages); discard_warning_messages =
true;
27190 #if SWIG_OCTAVE_PREREQ(4,2,0)
27192 #if SWIG_OCTAVE_PREREQ(4,4,0)
27193 octave::feval(
name, octave_value_list(), 0);
27195 feval(
name, octave_value_list(), 0);
27198 }
catch (octave::execution_exception&) { }
27200 feval(
name, octave_value_list(), 0);
27201 retn = (error_state == 0);
27203 #if !SWIG_OCTAVE_PREREQ(3,3,50)
27204 unwind_protect::run_frame(
"SWIG_Octave_LoadModule");
27216 #if SWIG_OCTAVE_PREREQ(6,0,0)
27217 #elif SWIG_OCTAVE_PREREQ(4,2,0)
27218 octave::unwind_protect frame;
27219 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27220 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27221 #elif SWIG_OCTAVE_PREREQ(3,3,50)
27222 unwind_protect frame;
27223 frame.protect_var(error_state); error_state = 0;
27224 frame.protect_var(warning_state); warning_state = 0;
27225 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27226 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27228 unwind_protect::begin_frame(
"SWIG_Octave_InstallFunction");
27229 unwind_protect_int(error_state); error_state = 0;
27230 unwind_protect_int(warning_state); warning_state = 0;
27231 unwind_protect_bool(discard_error_messages); discard_error_messages =
true;
27232 unwind_protect_bool(discard_warning_messages); discard_warning_messages =
true;
27234 octave_value_list args;
27236 args.append(octloadfcn->fcn_file_name());
27237 #if SWIG_OCTAVE_PREREQ(4,2,0)
27239 #if SWIG_OCTAVE_PREREQ(4,4,0)
27240 octave::feval(
"autoload", args, 0);
27242 feval(
"autoload", args, 0);
27245 }
catch (octave::execution_exception&) { }
27247 feval(
"autoload", args, 0);
27248 retn = (error_state == 0);
27250 #if !SWIG_OCTAVE_PREREQ(3,3,50)
27251 unwind_protect::run_frame(
"SWIG_Octave_InstallFunction");
27261 @deftypefn {Loadable Function} {} subclass()\n\
27262 @deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
27263 Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
27265 See the SWIG manual for usage examples.\n\
27270 for (
int j = 0; j < args.length(); ++j) {
27271 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
27275 error(
"subclass: cannot subclass object not constructed on octave side");
27276 return octave_value_list();
27279 }
else if (args(j).is_function_handle()) {
27280 top->
assign(args(j).fcn_handle_value()->fcn_name(), args(j));
27281 }
else if (args(j).is_string()) {
27282 if (j + 1 >= args.length()) {
27283 error(
"subclass: member assignments must be of string,value form");
27284 return octave_value_list();
27286 top->
assign(args(j).string_value(), args(j + 1));
27289 error(
"subclass: invalid arguments to subclass()");
27290 return octave_value_list();
27297 @deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
27298 Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
27302 if (args.length() != 1) {
27303 error(
"swig_type: must be called with only a single object");
27304 return octave_value_list();
27308 error(
"swig_type: object is not a swig_ref");
27309 return octave_value_list();
27315 @deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
27316 Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
27317 otherwise return `<unknown>'.\n\
27321 if (args.length() != 1 || !args(0).is_string()) {
27322 error(
"swig_typequery: must be called with single string argument");
27323 return octave_value_list();
27328 return octave_value(
"<unknown>");
27329 return octave_value(type->
name);
27333 @deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
27334 Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
27338 if (args.length() != 1) {
27339 error(
"swig_this: must be called with only a single object");
27340 return octave_value_list();
27342 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
27343 return octave_value(octave_uint64(0));
27346 error(
"swig_this: object is not a swig_ref");
27347 return octave_value_list();
27349 return octave_value(octave_uint64((
unsigned long long) ost->
swig_this()));
27353 @deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
27354 Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
27358 if (args.length() != 3) {
27359 error(
"swig_octave_prereq: must be called with 3 arguments");
27360 return octave_value_list();
27362 const int major = args(0).int_value();
27363 const int minor = args(1).int_value();
27364 const int patch = args(2).int_value();
27366 return octave_value(prereq);
27370 @deftypefn {Loadable Function} {} swig_exit([@var{exit_status}])\n\
27371 Exit Octave without performing any memory cleanup.\n\
27375 if (args.length() > 1) {
27376 error(
"swig_exit: must be called with at most one arguments");
27377 return octave_value_list();
27379 int exit_status = 0;
27380 if (args.length() == 1) {
27381 exit_status = args(0).int_value();
27383 ::_Exit(exit_status);
27384 return octave_value();
27388 @deftypefn {Loadable Module} {} " SWIG_name_d "\n\
27389 Loads the SWIG-generated module `" SWIG_name_d "'.\n\
27402 #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
27403 #if !SWIG_OCTAVE_PREREQ(4,4,0)
27404 #if SWIG_OCTAVE_PREREQ(3,2,0)
27405 octave_exit = ::_Exit;
27411 if (args.length() != 0 || nargout != 0) {
27413 return octave_value_list();
27421 #if SWIG_OCTAVE_PREREQ(3,2,0)
27422 octave_value_list eval_args;
27423 eval_args.append(
"base");
27424 eval_args.append(
"function __swig_atexit__; "
27431 "__swig_atexit__; "
27432 "atexit(\"__swig_atexit__\", false); "
27433 "atexit(\"__swig_atexit__\")");
27434 #if SWIG_OCTAVE_PREREQ(4,4,0)
27435 octave::feval(
"evalin", eval_args, 0);
27437 feval(
"evalin", eval_args, 0);
27441 #if SWIG_OCTAVE_PREREQ(4,4,0)
27443 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
27444 string_vector types = typeinfo.installed_type_names();
27445 bool register_octave_swig_ref =
true;
27446 bool register_octave_swig_packed =
true;
27447 for (
int i = 0; i < types.numel(); ++i) {
27448 if (types(i) == octave_swig_ref::static_type_name()) {
27449 register_octave_swig_ref =
false;
27450 octave_swig_ref::set_type_id(i);
27452 if (types(i) == octave_swig_packed::static_type_name()) {
27453 register_octave_swig_packed =
false;
27454 octave_swig_packed::set_type_id(i);
27457 if (register_octave_swig_ref) {
27458 octave_swig_ref::register_type();
27460 if (register_octave_swig_packed) {
27461 octave_swig_packed::register_type();
27465 octave_swig_ref::register_type();
27466 octave_swig_packed::register_type();
27471 #if SWIG_OCTAVE_PREREQ(6,0,0)
27472 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27473 octave::call_stack& stack = tree_eval.get_call_stack();
27474 octave_function *me = stack.current_function();
27475 #elif SWIG_OCTAVE_PREREQ(4,4,0)
27476 octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
27477 octave_function *me = stack.current();
27479 octave_function *me = octave_call_stack::current();
27483 return octave_value_list();
27486 return octave_value_list();
27489 return octave_value_list();
27492 return octave_value_list();
27495 return octave_value_list();
27498 return octave_value_list();
27536 return octave_value_list();
27543 if (mb->second.first && mb->second.first->method) {
27545 return octave_value_list();
27550 #if SWIG_OCTAVE_PREREQ(4,4,0)
27551 octave::interpreter::the_interpreter()->mlock();
27552 #elif SWIG_OCTAVE_PREREQ(3,2,0)
27562 if (mb->second.second.is_defined()) {
27571 return octave_value_list();
octave_base_value * clone() const
virtual bool load_ascii(std::istream &is)
octave_base_value * empty_clone() const
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
octave_swig_packed(swig_type_info *_type=0, const void *_buf=0, size_t _buf_len=0)
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
bool copy(swig_type_info *outtype, void *ptr, size_t sz) const
DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
virtual bool save_ascii(std::ostream &os)
virtual string_vector map_keys() const
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
virtual double scalar_value(bool frc_str_conv=false) const
virtual bool is_object() const
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
virtual bool save_ascii(std::ostream &os)
dim_vector dims(void) const
virtual Octave_map map_value() const
virtual bool is_map() const
virtual bool is_string() const
virtual std::string string_value(bool force=false) const
octave_base_value * empty_clone() const
octave_base_value * clone() const
virtual type_conv_info numeric_conversion_function(void) const
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type='"') const
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
static octave_base_value * default_numeric_conversion_function(const octave_base_value &a)
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
octave_swig_type * get_ptr() const
octave_swig_ref(octave_swig_type *_ptr=0)
virtual bool load_ascii(std::istream &is)
virtual octave_value_list subsref(const std::string &ops, const std::list< octave_value_list > &idx, int nargout)
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type='"') const
void load_members(member_map &out) const
virtual Octave_map map_value() const
std::pair< const swig_type_info *, cpp_ptr > type_ptr_pair
static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name)
static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name)
octave_swig_type(const octave_swig_type &x)
octave_base_value * clone() const
swig_member_const_iterator swig_members_begin()
std::map< std::string, member_value_pair > member_map
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
virtual bool save_ascii(std::ostream &os)
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
swig_member_const_iterator swig_members_end()
dim_vector dims(void) const
bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const
octave_base_value * empty_clone() const
virtual bool load_ascii(std::istream &is)
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
swig_module_info * module
octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout)
virtual bool is_object() const
void assign(const std::string &name, const swig_octave_member *m)
const swig_octave_member * find_member(const swig_type_info *type, const std::string &name)
const char * help_text() const
octave_swig_type(void *_ptr=0, const swig_type_info *_type=0, int _own=0, bool _always_static=false)
const swig_type_info * find_base(const std::string &name, const swig_type_info *base)
octave_value_list member_deref(member_value_pair *m, const octave_value_list &args)
virtual string_vector map_keys() const
void assign(const std::string &name, const octave_value &ov)
virtual bool is_string() const
static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret)
std::vector< type_ptr_pair > types
virtual double scalar_value(bool frc_str_conv=false) const
virtual octave_value_list subsref(const std::string &ops, const std::list< octave_value_list > &idx, int nargout)
virtual std::string string_value(bool force=false) const
static octave_value make_value_hack(const octave_base_value &x)
void load_members(const swig_octave_class *c, member_map &out) const
octave_swig_type & operator=(const octave_swig_type &rhs)
std::string swig_type_name() const
bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const
bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const
std::pair< const swig_octave_member *, octave_value > member_value_pair
member_value_pair * find_member(const std::string &name, bool insert_if_not_found)
void merge(octave_swig_type &rhs)
member_map::const_iterator swig_member_const_iterator
void print(std::ostream &os, bool pr_as_read_syntax=false) const
int cast(void **vptr, swig_type_info *type, int *_own, int flags)
const swig_type_info * construct_type
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
virtual bool is_map() const
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
SWIGRUNTIME octave_swig_type * swig_value_deref(octave_value ov)
SWIGRUNTIME octave_base_value * swig_value_ref(octave_swig_type *ost)
SWIGRUNTIME octave_swig_type * swig_value_deref(const octave_base_value &ov)
integer(kind=private_plint), parameter, private maxlen
void plSetUsage(PLCHAR_VECTOR program_string, PLCHAR_VECTOR usage_string)
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
void c_plcont(PLFLT_MATRIX f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT_VECTOR clevel, PLINT nlevel, PLTRANSFORM_callback pltr, PLPointer pltr_data)
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer PL_UNUSED(pltr_data))
static PLFLT value(double n1, double n2, double hue)
void c_plimagefr(PLFLT_MATRIX idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLTRANSFORM_callback pltr, PLPointer pltr_data)
void c_plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, PLINT_VECTOR label_opts, PLCHAR_MATRIX labels, PLINT n_axes, PLCHAR_MATRIX axis_opts, PLFLT_VECTOR ticks, PLINT_VECTOR sub_ticks, PLINT_VECTOR n_values, PLFLT_MATRIX values)
void plmaptex(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT dx, PLFLT dy, PLFLT just, PLCHAR_VECTOR text, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT plotentry)
void plmapstring(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLCHAR_VECTOR string, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
void plmapfill(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
void plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
void plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
void plmapline(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
void c_plsurf3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
void c_plmeshc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
void c_plot3dcl(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, PLINT_VECTOR indexymin, PLINT_VECTOR indexymax)
void c_plsurf3dl(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, PLINT_VECTOR indexymin, PLINT_VECTOR indexymax)
void c_plmesh(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt)
void c_plot3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLBOOL side)
void c_plot3dc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
PLINT plTranslateCursor(PLGraphicsIn *plg)
PLINT plGetCursor(PLGraphicsIn *plg)
#define pl_setcontlabelformat
#define pl_setcontlabelparam
void my_plsurf3d(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
void my_plgriddata(const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts, const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy, PLFLT *zg, int type, PLFLT data)
static const char * _wrap_plszax_texinfo
static const char * _wrap_plstring3_texinfo
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
static const char * _wrap_plvsta_texinfo
static const char * _wrap_plscmap1_texinfo
static const char * _wrap_plbox3_texinfo
void my_plimagefrx(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLFLT *tr)
static const char * _wrap_plmeshc_texinfo
SWIGINTERN bool SWIG_Octave_LoadModule(std::string name)
static swig_cast_info * swig_cast_initial[]
void my_plimagefr2(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plvpas_texinfo
static const char * _wrap_pladv_texinfo
static const char * _wrap_plcalc_world_texinfo
static const char * _wrap_plmkstrm_texinfo
SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value &value)
void my_plshades2(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
static swig_type_info * swig_types[10]
void my_plot3dc(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
static const char * _wrap_pltimefmt_texinfo
static const char * _wrap_plend_texinfo
static const swig_type_info * swig_PLGraphicsIn_base[]
static const char * _wrap_plsvpa_texinfo
SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2)
SWIGINTERN int SWIG_AsVal_long(const octave_value &ov, long *val)
octave_function * fcnCoordTrans
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
static const char * _wrap_plgdev_texinfo
static const char * _wrap_plcol0_texinfo
static const char * _wrap_plfamadv_texinfo
SWIGRUNTIME void SWIG_InstallUnaryOps(int tid)
#define SWIG_TypeQuery(name)
SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name)
static const char * _wrap_plmeridians_texinfo
static const char * _wrap_plsdidev_texinfo
DEFINE_OCTAVE_ALLOCATOR(octave_swig_ref)
static const char * _wrap_plflush_texinfo
static void _cvt_double_to(FLOAT *out_arr, double *in_arr, unsigned n_el)
static const char * _wrap_plsfnam_texinfo
#define SWIG_CheckState(r)
static void _cvt_to_double(FLOAT *arr, double *d_arr, unsigned n_el)
#define f2c(f, ff, nx, ny)
static const char * _wrap_plot3dc_texinfo
static const char * _wrap_plptex_texinfo
static swig_cast_info _swigc__p_int[]
SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own)
static const char * _wrap_plbin_texinfo
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
void my_plsurf3dl(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, const PLINT *indexymin, const PLINT *indexymax)
static const char * _wrap_plsmaj_texinfo
static const char * _wrap_plsstrm_texinfo
static swig_cast_info _swigc__p_double[]
void my_plmesh(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt)
#define SWIGTYPE_p_PLGraphicsIn
static const char * _wrap_plgcompression_texinfo
static const char * _wrap_plscolor_texinfo
void my_plimage(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax)
struct swig_cast_info swig_cast_info
static const char * _wrap_plfill_texinfo
static const struct swig_octave_member swig_globals[]
static const char * _wrap_pllightsource_texinfo
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
static const char * _wrap_plscmap0_texinfo
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
static const char *const swig_typequery_usage
SWIGINTERN size_t SWIG_strnlen(const char *s, size_t maxlen)
std::string nameCoordTrans
static const char * _wrap_plgcol0a_texinfo
static const char * _wrap_plSetOpt_texinfo
#define SWIG_RuntimeError
static const char * _wrap_plgcmap1_range_texinfo
static const char * _wrap_plarc_texinfo
SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout)
static const char * _wrap_plend1_texinfo
static const char * _wrap_plgcolbga_texinfo
void my_plcont1(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plprec_texinfo
void my_plot3d(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, PLINT side)
static const char *const SWIG_name_usage
static const char * _wrap_plgpage_texinfo
static const char * _wrap_plschr_texinfo
static int _arraylen(const octave_value &o_obj)
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
#define swig_unary_op(name)
static const char * _wrap_plsdiori_texinfo
SWIGINTERNINLINE octave_value SWIG_From_double(double value)
SWIGRUNTIMEINLINE octave_value SWIG_Octave_GetGlobalValue(std::string name)
static const char * _wrap_plsurf3d_texinfo
#define SWIG_OCTAVE_PREREQ(major, minor, patch)
static const char * _wrap_plgfnam_texinfo
static const char * _wrap_plenv0_texinfo
#define swigreg_binary_op(name)
static const char * _wrap_plenv_texinfo
#define SWIG_as_voidptrptr(a)
static const char * _wrap_plsym_texinfo
static const char * _wrap_plmapstring_texinfo
#define SWIG_RUNTIME_VERSION
void my_plimagefr(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax)
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
static const char * _wrap_plslabelfunc_texinfo
static const char * _wrap_plsfci_texinfo
static const char * _wrap_plgchr_texinfo
static const char * _wrap_plstripd_texinfo
static const char * _wrap_plsori_texinfo
static const char * _wrap_plsdiplt_texinfo
static const char * _wrap_plsfam_texinfo
static const char * _wrap_plgver_texinfo
static const char * _wrap_plstransform_texinfo
SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov)
#define SWIG_exception_fail(code, msg)
#define SWIG_OCTAVE_BOUND_FUNC(func, args)
static const char * _wrap_plgdiori_texinfo
static const char * _wrap_plbtime_texinfo
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
#define SWIG_AttributeError
static const char * _wrap_plstripc_texinfo
static const char * _wrap_plgfam_texinfo
static const char * _wrap_plseed_texinfo
static const char * _wrap_plerrx_texinfo
static swig_module_info swig_module
void my_plvect(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr)
static int _n_dims(const octave_value &o_obj)
static const char * _wrap_plot3d_texinfo
static const char * _wrap_plmtex_texinfo
static const char * _wrap_plmap_texinfo
#define swigreg_unary_op(name)
SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
static const char * swig_PLGraphicsIn_base_names[]
SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags)
static const char * _wrap_plrgbhls_texinfo
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
static const char * _wrap_plrandd_texinfo
static const char * _wrap_plmesh_texinfo
static const char * _wrap_plsurf3dl_texinfo
static swig_type_info _swigt__p_double
static const char * _wrap_plmapfill_texinfo
static const char * _wrap_plaxes_texinfo
static const char * _wrap_plscmap0n_texinfo
DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref, "swig_ref", "swig_ref")
static const char * _wrap_plsesc_texinfo
#define SWIG_SetModule(clientdata, pointer)
static const char * _wrap_plgvpw_texinfo
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
static const char * _wrap_plgfont_texinfo
static const char * _wrap_plshades_texinfo
static const char * _wrap_plscmap1n_texinfo
static const char * _wrap_plstyl_texinfo
static const char * _wrap_plwind_texinfo
#define SWIG_as_voidptr(a)
void my_plcont0(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel)
static const char * _wrap_plsdiplz_texinfo
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
static swig_type_info _swigt__p_p_char
static const char * _wrap_pllsty_texinfo
static const char *const subclass_usage
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
SWIGINTERN int SWIG_AsVal_char(octave_value obj, char *val)
static const char * _wrap_plgstrm_texinfo
static const char * _wrap_plconfigtime_texinfo
static const char * _wrap_plssub_texinfo
#define SWIG_ConvertPtr(obj, pptr, type, flags)
static const char * _wrap_plgzax_texinfo
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
static const char * _wrap_plline_texinfo
void my_plshade(const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLINT sh_width, PLINT min_color, PLINT min_width, PLINT max_color, PLINT max_width, PLINT rectangular, PLFLT *tr)
static const char *const swig_type_usage
static const char * _wrap_plshade_texinfo
static const char * _wrap_pl_setcontlabelformat_texinfo
static const char *const swig_exit_usage
static const char * _wrap_plsdev_texinfo
static const char * _wrap_plgxax_texinfo
static const char * _wrap_plinit_texinfo
static const char * _wrap_plpoin3_texinfo
static const char * _wrap_plfontld_texinfo
static const char * _wrap_plpsty_texinfo
static const char * _wrap_plmapline_texinfo
std::string nameLabelFunc
static const char * _wrap_plscompression_texinfo
static const char * _wrap_pl_setcontlabelparam_texinfo
static const char * _wrap_plstart_texinfo
static const char * _wrap_plscol0_texinfo
void my_plvect2(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg)
SWIGRUNTIME void SWIG_InitializeModule(void *clientdata)
#define SWIG_DEFUN(cname, wname, doc)
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
SWIGINTERN int SWIG_AsCharPtrAndSize(octave_value ov, char **cptr, size_t *psize, int *alloc)
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
static const char * _wrap_plgdiplt_texinfo
static const char * _wrap_plcpstrm_texinfo
SWIGINTERN int SWIG_AsVal_double(const octave_value &ov, double *val)
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_long(unsigned long value)
static const char * _wrap_plvect_texinfo
void my_plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, const PLINT *label_opts, const char **label, PLINT n_axes, const char **axis_opts, const PLFLT *ticks, const PLINT *sub_ticks, const PLINT *n_values, const PLFLT *a)
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(octave_value obj, unsigned int *val)
static swig_cast_info _swigc__p_char[]
static const char * _wrap_plscolbga_texinfo
static const char * _wrap_plscol0a_texinfo
void labelfunc_octave(PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty)
octave_value_list(* octave_func)(const octave_value_list &, int)
static const char * _wrap_plscmap1a_texinfo
SWIGINTERNINLINE octave_value SWIG_FromCharPtrAndSize(const char *carray, size_t size)
void my_plstripc(PLINT *id, const char *xspec, const char *yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLBOOL y_ascl, PLBOOL acc, PLINT colbox, PLINT collab, const PLINT *colline, const PLINT *styline, const char *legline1, const char *legline2, const char *legline3, const char *legline4, const char *labx, const char *laby, const char *labtop)
static int _dim(const octave_value &o_obj, int dim_idx)
void testppchar(PLINT nlegend, const PLINT *opt_array, const char **text)
void my_plot3dcl(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, const PLINT *indexymin, const PLINT *indexymax)
static const char * _wrap_plgcol0_texinfo
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
static const char * _wrap_plstar_texinfo
SWIGINTERN int SWIG_AsCharArray(octave_value obj, char *val, size_t size)
#define SWIG_NewPointerObj(ptr, type, flags)
static const char * _wrap_plsmin_texinfo
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
static const char * _wrap_plglevel_texinfo
static const char * _wrap_plvpor_texinfo
void *(* swig_converter_func)(void *, int *)
#define SWIG_POINTER_NO_NULL
void my_plshades1(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer)
octave_function * fcnLabelFunc
SWIGRUNTIME swig_module_info * SWIG_Octave_GetModule(void *clientdata)
static const char * _wrap_plgfci_texinfo
static const char * _wrap_plsfont_texinfo
SWIGINTERNINLINE octave_value SWIG_From_int(int value)
static const char * _wrap_pllegend_texinfo
#define SWIG_NullReferenceError
static const char * _wrap_plhlsrgb_texinfo
static const char * _wrap_plgvpd_texinfo
SWIGINTERN int SWIG_AsVal_int(octave_value obj, int *val)
SWIGRUNTIME octave_value_list * SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov)
static const char * _wrap_plsxax_texinfo
static const char * _wrap_plmtex3_texinfo
#define SWIG_POINTER_DISOWN
struct swig_type_info swig_type_info
static swig_type_info _swigt__p_PLGraphicsIn
SWIGRUNTIME void SWIG_Octave_LinkGlobalValue(std::string name)
void my_plcont(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr)
static const char *const swig_octave_prereq_usage
void my_plshade2(const PLFLT *a, PLINT nx, PLINT ny, const char *defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLINT sh_width, PLINT min_color, PLINT min_width, PLINT max_color, PLINT max_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plscmap1l_texinfo
static swig_octave_class _wrap_class_PLGraphicsIn
static const char * _wrap_plfill3_texinfo
static const char * _wrap_plptex3_texinfo
octave_function * fcnMapForm
#define SWIG_DelNewMask(r)
static const char * _wrap_pleop_texinfo
static const char * _wrap_pltext_texinfo
static const char * _wrap_plgyax_texinfo
static const char * _wrap_plbox_texinfo
#define SWIG_GetModule(clientdata)
static const char * _wrap_pllab_texinfo
static swig_cast_info _swigc__p_unsigned_int[]
static swig_type_info _swigt__p_int
static const char * _wrap_plspage_texinfo
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)
SWIGRUNTIME void SWIG_PropagateClientData(void)
static const char * _wrap_plsyax_texinfo
static const char * _wrap_plsdimap_texinfo
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
static const char * _wrap_plpoin_texinfo
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
static const char * _wrap_plspause_texinfo
SWIGINTERNINLINE octave_value SWIG_From_long(long value)
void my_plvect1(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plgriddata_texinfo
DEFUN_DLD(subclass, args, nargout, subclass_usage)
static const char * _wrap_plspal0_texinfo
SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs)
static const char * _wrap_plclear_texinfo
#define SWIG_TYPE_TABLE_NAME
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
static swig_type_info _swigt__p_unsigned_int
#define SWIG_CAST_NEW_MEMORY
static swig_type_info _swigt__p_f_int_p_double_p_double__void
#define SWIGTYPE_p_unsigned_int
SWIGRUNTIME octave_value SWIG_ErrorType(int code)
struct swig_module_info swig_module_info
static const char * _wrap_plxormod_texinfo
static const char * _wrap_plpath_texinfo
static const char * _wrap_plimagefr_texinfo
void xform(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
static const char * _wrap_pljoin_texinfo
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
static const char * _wrap_plwidth_texinfo
static const char * _wrap_plfont_texinfo
static const char * _wrap_plstripa_texinfo
static swig_octave_member swig_PLGraphicsIn_members[]
static const char * _wrap_plot3dcl_texinfo
static const char * _wrap_plparseopts_texinfo
static const char * _wrap_plgcolbg_texinfo
static swig_type_info * swig_type_initial[]
static const char * _wrap_plgspa_texinfo
static const char * _wrap_plpat_texinfo
static const char * _wrap_plline3_texinfo
#define swig_binary_op(name)
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
static const char * _wrap_plmaptex_texinfo
static swig_cast_info _swigc__p_PLGraphicsIn[]
void my_plshade1(const PLFLT *a, PLINT nx, PLINT ny, const char *defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLINT sh_width, PLINT min_color, PLINT min_width, PLINT max_color, PLINT max_width, PLINT rectangular, const PLFLT *xg, const PLFLT *yg)
static const char * _wrap_plstring_texinfo
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
static const char * _wrap_plgdidev_texinfo
static const char *const swig_this_usage
static swig_cast_info _swigc__p_p_char[]
static const char * _wrap_plpoly3_texinfo
void my_plcont2(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg)
static int my_plTranslateCursor(PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in)
static const char * _wrap_plvasp_texinfo
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
SWIGRUNTIME void SWIG_InstallOps(int tid)
void mapform_octave(PLINT n, PLFLT *x, PLFLT *y)
static const char * _wrap_plw3d_texinfo
#define SWIG_DivisionByZero
static const char * _wrap_plscmap1la_texinfo
static const char * _wrap_plbop_texinfo
#define SWIGTYPE_p_double
#define SWIGTYPE_p_p_char
void my_plimagefr1(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg)
static swig_type_info _swigt__p_char
void ct_octave(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
static const char * _wrap_plssym_texinfo
void my_plshades(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular)
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type)
#define SWIG_OverflowError
static const char * _wrap_plgra_texinfo
static const char * _wrap_plhist_texinfo
static const char * _wrap_plspal1_texinfo
static const char * _wrap_plscmap0a_texinfo
static const char * _wrap_plcont_texinfo
static const char * _wrap_plctime_texinfo
static const char * _wrap_plscolbg_texinfo
void my_plcont2p(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg)
struct swig_type_info *(* swig_dycast_func)(void **)
static const char * _wrap_plcol1_texinfo
void my_plshadesx(const PLFLT *a, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, const PLFLT *clevel, PLINT nlevel, PLINT fill_width, PLINT cont_color, PLINT cont_width, PLINT rectangular, PLFLT *tr)
SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg)
PLINT(* defined_func)(PLFLT, PLFLT)
static bool SWIG_init_user(octave_swig_type *module_ns)
static const char * _wrap_plreplot_texinfo
static const char * _wrap_plsvect_texinfo
static const char * _wrap_plerry_texinfo
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
static const char * _wrap_plcolorbar_texinfo
void my_plmeshc(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(const octave_value &ov, unsigned long *val)
static const char * _wrap_plgradient_texinfo
static const char * _wrap_plGetCursor_texinfo
static const char * _wrap_plscmap1_range_texinfo
#define SWIGRUNTIMEINLINE
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_int(unsigned int value)
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void c_plshades(PLFLT_MATRIX a, PLINT nx, PLINT ny, PLDEFINED_callback defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT_VECTOR clevel, PLINT nlevel, PLFLT fill_width, PLINT cont_color, PLFLT cont_width, PLFILL_callback fill, PLINT rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data)
void c_plshade(PLFLT_MATRIX a, PLINT nx, PLINT ny, PLDEFINED_callback defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width, PLINT min_color, PLFLT min_width, PLINT max_color, PLFLT max_width, PLFILL_callback fill, PLINT rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data)
void c_plstripc(PLINT *id, PLCHAR_VECTOR xspec, PLCHAR_VECTOR yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLINT y_ascl, PLINT acc, PLINT colbox, PLINT collab, PLINT_VECTOR colline, PLINT_VECTOR styline, PLCHAR_MATRIX legline, PLCHAR_VECTOR labx, PLCHAR_VECTOR laby, PLCHAR_VECTOR labtop)
void c_plvect(PLFLT_MATRIX u, PLFLT_MATRIX v, PLINT nx, PLINT ny, PLFLT scale, PLTRANSFORM_callback pltr, PLPointer pltr_data)
octave_value operator*() const
const octave_value_list & ovl
octave_value_ref(const octave_value_list &_ovl, int _j)
struct swig_cast_info * prev
struct swig_cast_info * next
swig_converter_func converter
swig_cast_info ** cast_initial
swig_type_info ** type_initial
struct swig_module_info * next
const swig_octave_member * members
const swig_type_info ** base
const char * constructor_doc
struct swig_cast_info * cast
static Tcl_Interp * interp