10#define SWIG_VERSION 0x040101
12#define SWIG_name_d "plplot_octave"
13#define SWIG_name plplot_octave
15#define SWIG_global_name "cvar"
16#define SWIG_op_prefix "op_"
24#ifndef SWIGTEMPLATEDISAMBIGUATOR
25# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
26# define SWIGTEMPLATEDISAMBIGUATOR template
27# elif defined(__HP_aCC)
30# define SWIGTEMPLATEDISAMBIGUATOR template
32# define SWIGTEMPLATEDISAMBIGUATOR
38# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
39# define SWIGINLINE inline
48# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
49# define SWIGUNUSED __attribute__ ((__unused__))
54# define SWIGUNUSED __attribute__ ((__unused__))
60#ifndef SWIG_MSC_UNSUPPRESS_4505
62# pragma warning(disable : 4505)
68# define SWIGUNUSEDPARM(p)
70# define SWIGUNUSEDPARM(p) p SWIGUNUSED
76# define SWIGINTERN static SWIGUNUSED
80#ifndef SWIGINTERNINLINE
81# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
86# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
87# ifndef GCC_HASCLASSVISIBILITY
88# define GCC_HASCLASSVISIBILITY
94# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
95# if defined(STATIC_LINKED)
98# define SWIGEXPORT __declspec(dllexport)
101# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
102# define SWIGEXPORT __attribute__ ((visibility("default")))
111# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
112# define SWIGSTDCALL __stdcall
119#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
120# define _CRT_SECURE_NO_DEPRECATE
124#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
125# define _SCL_SECURE_NO_DEPRECATE
129#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
130# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
138#ifdef __INTEL_COMPILER
139# pragma warning disable 592
153#if !defined(SWIG_OCTAVE_OCTHEADERS_HPP)
154#define SWIG_OCTAVE_OCTHEADERS_HPP
168#include <octave/oct.h>
169#include <octave/version.h>
173#define SWIG_OCTAVE_PREREQ(major, minor, patch) \
174 ( (OCTAVE_MAJOR_VERSION<<16) + (OCTAVE_MINOR_VERSION<<8) + (OCTAVE_PATCH_VERSION + 0) >= ((major)<<16) + ((minor)<<8) + (patch) )
177#if !defined(OCTAVE_MAJOR_VERSION)
179# if !defined(OCTAVE_API_VERSION_NUMBER)
183# include <octave/ov.h>
184# if defined(octave_ov_h)
185# define OCTAVE_MAJOR_VERSION 3
186# define OCTAVE_MINOR_VERSION 8
187# define OCTAVE_PATCH_VERSION 0
191# define ComplexLU __ignore
192# include <octave/CmplxLU.h>
194# if defined(octave_Complex_LU_h)
197# define OCTAVE_MAJOR_VERSION 3
198# define OCTAVE_MINOR_VERSION 1
199# define OCTAVE_PATCH_VERSION 99
204# define OCTAVE_MAJOR_VERSION 3
205# define OCTAVE_MINOR_VERSION 2
206# define OCTAVE_PATCH_VERSION 0
214# elif OCTAVE_API_VERSION_NUMBER >= 48
215# define OCTAVE_MAJOR_VERSION 3
216# define OCTAVE_MINOR_VERSION 6
217# define OCTAVE_PATCH_VERSION 0
219# elif OCTAVE_API_VERSION_NUMBER >= 45
220# define OCTAVE_MAJOR_VERSION 3
221# define OCTAVE_MINOR_VERSION 4
222# define OCTAVE_PATCH_VERSION 1
224# elif OCTAVE_API_VERSION_NUMBER >= 42
225# define OCTAVE_MAJOR_VERSION 3
226# define OCTAVE_MINOR_VERSION 3
227# define OCTAVE_PATCH_VERSION 54
229# elif OCTAVE_API_VERSION_NUMBER >= 41
230# define OCTAVE_MAJOR_VERSION 3
231# define OCTAVE_MINOR_VERSION 3
232# define OCTAVE_PATCH_VERSION 53
234# elif OCTAVE_API_VERSION_NUMBER >= 40
235# define OCTAVE_MAJOR_VERSION 3
236# define OCTAVE_MINOR_VERSION 3
237# define OCTAVE_PATCH_VERSION 52
239# elif OCTAVE_API_VERSION_NUMBER >= 39
240# define OCTAVE_MAJOR_VERSION 3
241# define OCTAVE_MINOR_VERSION 3
242# define OCTAVE_PATCH_VERSION 51
245# define OCTAVE_MAJOR_VERSION 3
246# define OCTAVE_MINOR_VERSION 3
247# define OCTAVE_PATCH_VERSION 50
254#include <octave/Cell.h>
255#include <octave/dynamic-ld.h>
256#include <octave/oct-env.h>
257#include <octave/oct-map.h>
258#include <octave/ov-scalar.h>
259#include <octave/ov-fcn-handle.h>
260#include <octave/parse.h>
261#if SWIG_OCTAVE_PREREQ(4,2,0)
262#include <octave/interpreter.h>
264#include <octave/toplev.h>
266#include <octave/unwind-prot.h>
267#if SWIG_OCTAVE_PREREQ(4,2,0)
268#include <octave/call-stack.h>
282#define SWIG_RUNTIME_VERSION "4"
285#ifdef SWIG_TYPE_TABLE
286# define SWIG_QUOTE_STRING(x) #x
287# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
288# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
290# define SWIG_TYPE_TABLE_NAME
303# define SWIGRUNTIME SWIGINTERN
306#ifndef SWIGRUNTIMEINLINE
307# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
311#ifndef SWIG_BUFFER_SIZE
312# define SWIG_BUFFER_SIZE 1024
316#define SWIG_POINTER_DISOWN 0x1
317#define SWIG_CAST_NEW_MEMORY 0x2
318#define SWIG_POINTER_NO_NULL 0x4
319#define SWIG_POINTER_CLEAR 0x8
320#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
323#define SWIG_POINTER_OWN 0x1
407#define SWIG_ERROR (-1)
411#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
413#define SWIG_IsOK(r) (r >= 0)
414#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
417#define SWIG_CASTRANKLIMIT (1 << 8)
419#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
421#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
423#define SWIG_BADOBJ (SWIG_ERROR)
424#define SWIG_OLDOBJ (SWIG_OK)
425#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
426#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
428#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
429#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
430#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
431#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
432#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
433#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
436#if defined(SWIG_CASTRANK_MODE)
437# ifndef SWIG_TypeRank
438# define SWIG_TypeRank unsigned long
440# ifndef SWIG_MAXCASTRANK
441# define SWIG_MAXCASTRANK (2)
443# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
444# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
449 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
452# define SWIG_AddCast(r) (r)
453# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
463typedef void *(*swig_converter_func)(
void *,
int *);
505 const char *f2,
const char *l2) {
506 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
507 while ((*f1 ==
' ') && (f1 != l1)) ++f1;
508 while ((*f2 ==
' ') && (f2 != l2)) ++f2;
509 if (*f1 != *f2)
return (*f1 > *f2) ? 1 : -1;
511 return (
int)((l1 - f1) - (l2 - f2));
521 const char* te = tb + strlen(tb);
523 while (equiv != 0 && *ne) {
524 for (nb = ne; *ne; ++ne) {
525 if (*ne ==
'|')
break;
550 if (strcmp(iter->
type->
name, c) == 0) {
551 if (iter == ty->
cast)
577 if (iter->
type == from) {
578 if (iter == ty->
cast)
610 if (!ty || !ty->
dcast)
return ty;
611 while (ty && (ty->
dcast)) {
612 ty = (*ty->
dcast)(ptr);
636 if (!type)
return NULL;
637 if (type->
str != NULL) {
638 const char *last_name = type->
str;
640 for (s = type->
str; *s; s++)
641 if (*s ==
'|') last_name = s+1;
689 size_t r = iter->
size - 1;
692 size_t i = (l + r) >> 1;
693 const char *iname = iter->
types[i]->
name;
695 int compare = strcmp(
name, iname);
697 return iter->
types[i];
698 }
else if (compare < 0) {
704 }
else if (compare > 0) {
713 }
while (iter != end);
740 for (; i < iter->
size; ++i) {
742 return iter->
types[i];
745 }
while (iter != end);
757 static const char hex[17] =
"0123456789abcdef";
758 const unsigned char *u = (
unsigned char *) ptr;
759 const unsigned char *eu = u + sz;
760 for (; u != eu; ++u) {
761 unsigned char uu = *u;
762 *(c++) = hex[(uu & 0xf0) >> 4];
763 *(c++) = hex[uu & 0xf];
773 unsigned char *u = (
unsigned char *) ptr;
774 const unsigned char *eu = u + sz;
775 for (; u != eu; ++u) {
778 if ((d >=
'0') && (d <=
'9'))
779 uu = (
unsigned char)((d -
'0') << 4);
780 else if ((d >=
'a') && (d <=
'f'))
781 uu = (
unsigned char)((d - (
'a'-10)) << 4);
785 if ((d >=
'0') && (d <=
'9'))
786 uu |= (
unsigned char)(d -
'0');
787 else if ((d >=
'a') && (d <=
'f'))
788 uu |= (
unsigned char)(d - (
'a'-10));
802 if ((2*
sizeof(
void *) + 2) > bsz)
return 0;
805 if (strlen(
name) + 1 > (bsz - (r - buff)))
return 0;
813 if (strcmp(c,
"NULL") == 0) {
826 size_t lname = (
name ? strlen(
name) : 0);
827 if ((2*sz + 2 + lname) > bsz)
return 0;
831 strncpy(r,
name,lname+1);
841 if (strcmp(c,
"NULL") == 0) {
856#define SWIG_UnknownError -1
857#define SWIG_IOError -2
858#define SWIG_RuntimeError -3
859#define SWIG_IndexError -4
860#define SWIG_TypeError -5
861#define SWIG_DivisionByZero -6
862#define SWIG_OverflowError -7
863#define SWIG_SyntaxError -8
864#define SWIG_ValueError -9
865#define SWIG_SystemError -10
866#define SWIG_AttributeError -11
867#define SWIG_MemoryError -12
868#define SWIG_NullReferenceError -13
871#if !SWIG_OCTAVE_PREREQ(3,2,0)
872#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
874#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
878 if (num_args > max_args && !varargs)
879 error(
"function %s takes at most %i arguments", func_name, max_args);
880 else if (num_args < min_args)
881 error(
"function %s requires at least %i arguments", func_name, min_args);
895 return "SWIG_MemoryError";
897 return "SWIG_IOError";
899 return "SWIG_RuntimeError";
901 return "SWIG_IndexError";
903 return "SWIG_TypeError";
905 return "SWIG_DivisionByZero";
907 return "SWIG_OverflowError";
909 return "SWIG_SyntaxError";
911 return "SWIG_ValueError";
913 return "SWIG_SystemError";
915 return "SWIG_AttributeError";
917 return "SWIG unknown error";
923 r +=
" (" + type.string_value() +
")";
924 error(
"%s", r.c_str());
925 return octave_value(r);
928#define SWIG_fail goto fail
930#define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
931#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
932#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
933#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
934#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
935#define swig_owntype int
937#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
938#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
940#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
941#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
943#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
944#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
946#define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
947#define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
948#define SWIG_MODULE_CLIENTDATA_TYPE void*
950#define Octave_Error_Occurred() 0
951#define SWIG_Octave_AddErrorMsg(msg) {;}
957#define SWIG_POINTER_EXCEPTION 0
958#define SWIG_arg_fail(arg) 0
962typedef octave_value_list(*
octave_func) (
const octave_value_list &, int);
971 typedef std::map < void *, Director * > rtdir_map;
989SWIGRUNTIME void swig_acquire_ownership(
void *vptr);
990SWIGRUNTIME void swig_acquire_ownership_array(
void *vptr);
991SWIGRUNTIME void swig_acquire_ownership_obj(
void *vptr,
int own);
1020#if SWIG_OCTAVE_PREREQ(4,4,0)
1023#define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(new octave_swig_bound_func(func, args))
1024 class octave_swig_bound_func :
public octave_function {
1027 octave_swig_bound_func(
void) : octave_function(), method(0), first_args()
1030 octave_swig_bound_func(octave_function* _method, octave_value_list _first_args)
1031 : octave_function(
"",
""), method(_method), first_args(_first_args)
1034 octave_swig_bound_func(
const octave_swig_bound_func& f) =
delete;
1036 octave_swig_bound_func& operator= (
const octave_swig_bound_func& f) =
delete;
1038 ~octave_swig_bound_func(
void) =
default;
1040 bool is_function(
void)
const {
return true; }
1042 octave_function* function_value(
bool =
false) {
return this; }
1044#if SWIG_OCTAVE_PREREQ(6,0,0)
1045 octave_value_list call(octave::tree_evaluator& tw,
int nargout = 0,
const octave_value_list& args = octave_value_list()) {
1046 return execute(tw,nargout,args);
1049#if SWIG_OCTAVE_PREREQ(6,0,0)
1050 octave_value_list execute(octave::tree_evaluator& tw,
int nargout = 0,
const octave_value_list& args = octave_value_list()) {
1052 octave_value_list call(octave::tree_evaluator& tw,
int nargout = 0,
const octave_value_list& args = octave_value_list()) {
1054 octave_value_list all_args;
1055 all_args.append(first_args);
1056 all_args.append(args);
1057 return method->call(tw, nargout, all_args);
1060 octave_value subsref(
const std::string &ops,
const std::list < octave_value_list > &idx) {
1061 octave_value_list ovl = subsref(ops, idx, 1);
1062 return ovl.length() ? ovl(0) : octave_value();
1065 octave_value_list subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout) {
1066 assert(ops.size() > 0);
1067 assert(ops.size() == idx.size());
1069 error(
"invalid function call");
1070 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1071 return call(tw, nargout, *idx.begin());
1076 octave_function* method;
1077 octave_value_list first_args;
1079 std::set<std::string> dispatch_classes;
1083#define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(func)
1118 if (m->name ==
name)
1129 if ((m = find_member(c->
base[j],
name)))
1136 member_map::iterator it = members.find(
name);
1137 if (it != members.end())
1140 for (
unsigned int j = 0; j < types.size(); ++j)
1141 if ((m = find_member(types[j].first,
name)))
1142 return &members.insert(std::make_pair(
name, std::make_pair(m, octave_value()))).first->second;
1143 if (!insert_if_not_found)
1145 return &members[
name];
1150 for (
unsigned int j = 0; j < types.size(); ++j) {
1151 assert(types[j].first->clientdata);
1154 return types[j].first;
1179 if (out.find(m->name) == out.end())
1180 out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1194 load_members(cj,out);
1200 for (
unsigned int j = 0; j < types.size(); ++j)
1201 if (types[j].first->clientdata)
1206 if (m->second.is_defined())
1207 return m->second.subsref(
"(", std::list < octave_value_list > (1, args), nargout);
1208 else if (m->first && m->first->method)
1209 return m->first->method(args, nargout);
1210 error(
"member not defined or not invocable");
1211 return octave_value_list();
1217 if (!m || m->first->is_static() || m->first->is_global())
1219 octave_value_list args;
1221 octave_value_list argout(nc_this->
member_invoke(m, args, 1));
1222 if (argout.length() < 1)
1228 bool dispatch_binary_op(
const std::string &symbol,
const octave_base_value &rhs, octave_value &ret)
const {
1231 if (!m || m->first->is_static() || m->first->is_global())
1233 octave_value_list args;
1235 args.append(make_value_hack(rhs));
1236 octave_value_list argout(nc_this->
member_invoke(m, args, 1));
1237 if (argout.length() < 1)
1243 bool dispatch_index_op(
const std::string &symbol,
const octave_value_list &rhs, octave_value_list &ret)
const {
1246 if (!m || m->first->is_static() || m->first->is_global())
1248 octave_value_list args;
1251 octave_value_list argout(nc_this->
member_invoke(m, args, 1));
1252 if (argout.length() >= 1)
1258 if (m->second.is_defined()) {
1259 if (m->second.is_function() || m->second.is_function_handle()) {
1264 }
else if (m->first) {
1265 if (m->first->get_method)
1266 return m->first->get_method(args, 1);
1267 else if (m->first->method)
1270 error(
"undefined member");
1271 return octave_value_list();
1276 return octave_value((octave_base_value *) &x);
1284 bool _always_static =
false)
1285 : module(0), construct_type(_ptr ? 0 : _type), thisown(_own),
1286 always_static(_always_static) {
1288 types.push_back(std::make_pair(_type, _ptr));
1289#ifdef SWIG_DIRECTORS
1291 Swig::Director *d = Swig::get_rtdir(_ptr);
1293 Swig::swig_director_set_self(d,
this);
1301 for (
unsigned int j = 0; j < types.size(); ++j) {
1302 if (!types[j].first || !types[j].first->clientdata)
1305 if (c->
destructor && !types[j].second.destroyed && types[j].second.ptr) {
1310#ifdef SWIG_DIRECTORS
1311 for (
unsigned int j = 0; j < types.size(); ++j)
1312 Swig::erase_rtdir(types[j].second.ptr);
1318 if (!dispatch_unary_op(
"__dims__", out))
1319 return dim_vector(1,1);
1322#if SWIG_OCTAVE_PREREQ(4,4,0)
1325 if (out.is_cell()) {
1327 const Cell & c=out.cell_value();
1328 int ndim = c.rows();
1329 if (ndim==1 && c.columns()!=1) ndim = c.columns();
1332 d.resize(ndim < 2 ? 2 : ndim);
1336 for (
int k=0;k<ndim;k++) {
1337 const octave_value& obj = c(k);
1338#if SWIG_OCTAVE_PREREQ(6,0,0)
1340 d.elem(k) = obj.int_value();
1342 catch (octave::execution_exception& oee) {
1344 return dim_vector(1,1);
1347 d.elem(k) = obj.int_value();
1350 if (error_state)
return dim_vector(1,1);
1354#if SWIG_OCTAVE_PREREQ(4,4,0)
1355 }
else if (out.is_matrix_type() || out.isnumeric() ) {
1357 }
else if (out.is_matrix_type() || out.is_numeric_type() ) {
1359 if (out.rows()==1 || out.columns()==1) {
1360#if SWIG_OCTAVE_PREREQ(6,0,0)
1363 a = out.int_vector_value();
1365 catch (octave::execution_exception& oee) {
1366 return dim_vector(1,1);
1369 Array<int> a = out.int_vector_value();
1370 if (error_state)
return dim_vector(1,1);
1373 d.resize(a.numel() < 2 ? 2 : a.numel());
1375 for (
int k=0;k<a.numel();k++) {
1380 return dim_vector(1,1);
1383 return dim_vector(1,1);
1403 return (
size_t)
this;
1404 return (
size_t) types[0].second.ptr;
1409 if (!types[0].first->clientdata)
1419 for (
unsigned int j = 0; j < types.size(); ++j) {
1422 if (types[j].first->clientdata) {
1426 ret += types[j].first->name;
1433 for (
unsigned int j = 0; j < rhs.
types.size(); ++j) {
1434 assert(!rhs.
types[j].second.destroyed);
1435#ifdef SWIG_DIRECTORS
1436 Swig::Director *d = Swig::get_rtdir(rhs.
types[j].second.ptr);
1438 Swig::swig_director_set_self(d,
this);
1441 types.insert(types.end(), rhs.
types.begin(), rhs.
types.end());
1443#if SWIG_OCTAVE_PREREQ(4,4,0)
1457 int clear_pointer = 0;
1465 *own = *own | thisown;
1474 if (!type && types.size()) {
1476 *vptr = types[0].second.ptr;
1478 types[0].second.ptr = 0;
1482 for (
unsigned int j = 0; j < types.size(); ++j)
1483 if (type == types[j].first) {
1485 *vptr = types[j].second.ptr;
1487 types[j].second.ptr = 0;
1491 for (
unsigned int j = 0; j < types.size(); ++j) {
1504 types[j].second.ptr = 0;
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(4,4,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(4,4,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) \
2308SWIGRUNTIME 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) \
2312SWIGRUNTIME 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) \
2317if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2318typeinfo.register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2320#define swigreg_unary_op(name) \
2321if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2322octave_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) \
2326if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2327typeinfo.register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2329#define swigreg_binary_op(name) \
2330if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2331octave_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) {
2421#ifdef SWIG_DIRECTORS
2422 Swig::Director *d = Swig::get_rtdir(ptr);
2423 if (d && Swig::swig_director_get_self(d))
2424 return Swig::swig_director_get_self(d)->as_value();
2428 return octave_value(Matrix());
2438 && ov.rows() == 1 && ov.columns() == 1)
2439 ov = ov.cell_value()(0);
2440 if (!ov.is_defined() ||
2441 (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2446 if (ov.type_id() != octave_swig_ref::static_type_id())
2450 return ost->
cast(ptr, type, own, flags);
2458 if (!ov.is_defined())
2460 if (ov.type_id() != octave_swig_packed::static_type_id())
2471#if SWIG_OCTAVE_PREREQ(6,0,0)
2472 octave::interpreter *
interp = octave::interpreter::the_interpreter ();
2475#if SWIG_OCTAVE_PREREQ(4,4,0)
2476 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2477 return symtab.global_varval(
name);
2479 return get_global_value(
name,
true);
2485#if SWIG_OCTAVE_PREREQ(6,0,0)
2486 octave::interpreter *
interp = octave::interpreter::the_interpreter ();
2488#elif SWIG_OCTAVE_PREREQ(4,4,0)
2489 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2497#if SWIG_OCTAVE_PREREQ(4,4,0)
2498 octave::symbol_scope symscope = octave::interpreter::the_interpreter()->get_current_scope();
2499#if SWIG_OCTAVE_PREREQ(6,0,0)
2500 octave::interpreter *
interp = octave::interpreter::the_interpreter ();
2502 octave::tree_evaluator& tree_eval =
interp->get_evaluator();
2503 octave::call_stack& callStack = tree_eval.get_call_stack();
2504 std::shared_ptr<octave::stack_frame> stackFrame = callStack.get_current_stack_frame();
2505 octave::symbol_record sym=symscope.lookup_symbol(
name);
2506 stackFrame->mark_global(sym);
2508 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2509 symscope.assign(
name, symtab.global_varval(
name));
2510 symscope.mark_global(
name);
2513#if !SWIG_OCTAVE_PREREQ(3,2,0)
2514 link_to_global_variable(curr_sym_tab->lookup(
name,
true));
2516#if !SWIG_OCTAVE_PREREQ(3,8,0)
2517 symbol_table::varref(
name);
2519 symbol_table::mark_global(
name);
2526 if (!ov.is_defined() ||
2527 ov.type_id() != octave_swig_packed::static_type_id())
2543 if (obj.is_string())
2544 error(
"%s", obj.string_value().c_str());
2546 error(
"C++ side threw an exception of type %s", type);
2551#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2553#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
2559#define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2560#define SWIGTYPE_p_char swig_types[1]
2561#define SWIGTYPE_p_double swig_types[2]
2562#define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2563#define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2564#define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2565#define SWIGTYPE_p_int swig_types[6]
2566#define SWIGTYPE_p_p_char swig_types[7]
2567#define SWIGTYPE_p_unsigned_int swig_types[8]
2570#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2571#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2579template<
typename T>
class SwigValueWrapper {
2580 struct SwigSmartPointer {
2582 SwigSmartPointer(T *p) : ptr(p) { }
2583 ~SwigSmartPointer() {
delete ptr; }
2584 SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0;
delete oldptr; ptr = rhs.ptr; rhs.ptr = 0;
return *
this; }
2585 void reset(T *p) { T* oldptr = ptr; ptr = 0;
delete oldptr; ptr = p; }
2587 SwigValueWrapper& operator=(
const SwigValueWrapper<T>& rhs);
2588 SwigValueWrapper(
const SwigValueWrapper<T>& rhs);
2590 SwigValueWrapper() : pointer(0) { }
2591 SwigValueWrapper& operator=(
const T& t) { SwigSmartPointer tmp(
new T(t)); pointer = tmp;
return *
this; }
2592#if __cplusplus >=201103L
2593 SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(
new T(std::move(t))); pointer = tmp;
return *
this; }
2594 operator T&&()
const {
return std::move(*pointer.ptr); }
2596 operator T&()
const {
return *pointer.ptr; }
2598 T *operator&()
const {
return pointer.ptr; }
2599 static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
2611template <
typename T> T SwigValueInit() {
2615#if __cplusplus >=201103L
2616# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
2618# define SWIG_STD_MOVE(OBJ) OBJ
2624#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2625#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2639 #if defined ( __GNUC__ ) && __GNUC__ > 3
2640 #undef OCTAVE_EXPORT
2641 #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2659 inline int max(
int a,
int b )
2661 return a >= b ? a : b;
2663 inline int min(
int a,
int b )
2665 return a >= b ? a : b;
2679 return max( o_obj.rows(), 1 ) *
max( o_obj.columns(), 1 );
2691 if (
max( o_obj.columns(), 1 ) > 1 )
2696 else if (
max( o_obj.rows(), 1 ) > 1 )
2706 _dim(
const octave_value &o_obj,
int dim_idx )
2709 return max( o_obj.rows(), 0 );
2713 else if ( dim_idx == 1 )
2714 return max( o_obj.columns(), 0 );
2727 template <
class FLOAT>
2731 while ( n_el-- > 0 )
2732 *out_arr++ = (FLOAT) ( *in_arr++ );
2751 template <
class FLOAT>
2755 while ( n_el-- > 0 )
2756 *d_arr++ = double(*arr++);
2787 octave_value_list functionArguments;
2788 octave_value_list retval;
2795 for ( i = 0; i < n; i++ )
2801 functionArguments( 0 ) = xin;
2802 functionArguments( 1 ) = yin;
2805#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2806 retval = octave::feval(
fcnMapForm, functionArguments, 1 );
2808 retval = feval(
fcnMapForm, functionArguments, 1 );
2811#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2812 retval = octave::feval(
nameMapForm, functionArguments, 1 );
2814 retval = feval(
nameMapForm, functionArguments, 1 );
2817 if ( retval.length() >= 2 )
2819 xout = retval( 0 ).matrix_value();
2820 yout = retval( 1 ).matrix_value();
2822 for ( i = 0; i < n; i++ )
2824 x[i] = xout( i, 0 );
2825 y[i] = yout( i, 0 );
2837 octave_value_list functionArguments;
2838 octave_value_list retval;
2840 Matrix inAxis( 1, 1 );
2841 Matrix inValue( 1, 1 );
2842 inAxis( 0, 0 ) = axis;
2843 inValue( 0, 0 ) =
value;
2845 functionArguments( 0 ) = inAxis;
2846 functionArguments( 1 ) = inValue;
2849#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2850 retval = octave::feval(
fcnLabelFunc, functionArguments, 1 );
2855#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2856 retval = octave::feval(
nameLabelFunc, functionArguments, 1 );
2861 strncpy( label, retval( 0 ).string_value().c_str(), length );
2871 octave_value_list functionArguments;
2872 octave_value_list retval;
2882 functionArguments( 0 ) = xin;
2883 functionArguments( 1 ) = yin;
2886#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2887 retval = octave::feval(
fcnCoordTrans, functionArguments, 1 );
2892#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2898 if ( retval.length() >= 2 )
2900 xout = retval( 0 ).matrix_value();
2901 yout = retval( 1 ).matrix_value();
2912 printf(
"nlegend =%d\n", nlegend );
2913 for ( i = 0; i < nlegend; i++ )
2915 printf(
"opt_array[%d] =%d\n", i, opt_array[i] );
2916 printf(
"strlen(text[%d]) =%d\n", i, (
int) strlen(
text[i] ) );
2917 printf(
"text[%d] =%s\n", i,
text[i] );
2923#if !defined(SWIG_NO_LLONG_MAX)
2924# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2925# define LLONG_MAX __LONG_LONG_MAX__
2926# define LLONG_MIN (-LLONG_MAX - 1LL)
2927# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2934 if (!ov.is_scalar_type())
2936 if (ov.is_complex_scalar())
2938 if (ov.is_double_type()||ov.is_single_type()) {
2939 double v=ov.double_value();
2944 *val = ov.long_value();
2955 if ((v < INT_MIN || v > INT_MAX)) {
2958 if (val) *val =
static_cast< int >(v);
2965 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 )
2973 *pX = gin.
pX; *pY = gin.
pY; *dX = gin.
dX; *dY = gin.
dY; *wX = gin.
wX; *wY = gin.
wY;
2987 && ov.rows() == 1 && ov.columns() == 1)
2988 ov = ov.cell_value()(0);
2989 if (!ov.is_string())
2992 std::string str=ov.string_value();
2993 size_t len=str.size();
2994 char* cstr=(
char*)str.c_str();
2996 *cptr =
reinterpret_cast< char*
>(memcpy(
new char[len + 1], cstr,
sizeof(
char)*(len + 1)));
3011 return octave_value(
value);
3024 return octave_value(
value);
3033 gin.
dX = x_in; gin.
dY = y_in;
3035 *x = gin.
wX; *y = gin.
wY;
3042 if (!ov.is_scalar_type())
3044 if (ov.is_complex_scalar())
3047 *val = ov.double_value();
3060 const char *legline1,
const char *legline2,
const char *legline3,
const char *legline4,
3061 const char *labx,
const char *laby,
const char *labtop )
3063 const char *legline[4];
3064 legline[0] = legline1; legline[1] = legline2;
3065 legline[2] = legline3; legline[3] = legline4;
3066 c_plstripc(
id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
3067 xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
3068 labx, laby, labtop );
3086 *tx = *( (
PLFLT *) pltr_data + 0 ) * x + *( (
PLFLT *) pltr_data + 1 ) * y + *( (
PLFLT *) pltr_data + 2 );
3087 *ty = *( (
PLFLT *) pltr_data + 3 ) * x + *( (
PLFLT *) pltr_data + 4 ) * y + *( (
PLFLT *) pltr_data + 5 );
3092#define f2c( f, ff, nx, ny ) \
3094 ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
3095 for ( int i = 0; i < nx; i++ ) { \
3096 ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
3097 for ( int j = 0; j < ny; j++ ) \
3098 *( ff[i] + j ) = *( f + nx * j + i );}
3105 f2c( f, ff, nx, ny );
3106 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
xform, tr );
3114 f2c( f, ff, nx, ny );
3115 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr0, NULL );
3124 grid1.
nx = nx; grid1.
ny = ny;
3126 f2c( f, ff, nx, ny );
3127 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr1, &grid1 );
3135 f2c( xg, xgg, nx, ny );
3136 f2c(
yg, ygg, nx, ny );
3137 grid2.
nx = nx; grid2.
ny = ny;
3138 grid2.
xg = xgg; grid2.
yg = ygg;
3139 f2c( f, ff, nx, ny );
3140 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
3149 f2c( xg, xgg, nx, ny );
3150 f2c(
yg, ygg, nx, ny );
3151 grid2.
nx = nx; grid2.
ny = ny;
3152 grid2.
xg = xgg; grid2.
yg = ygg;
3153 f2c( f, ff, nx, ny );
3154 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
3159 const PLFLT *xg,
int nptsx,
const PLFLT *yg,
int nptsy,
3162 f2c(
zg, zgg, nptsx, nptsy );
3163 plgriddata( x, y, z, npts, xg, nptsx,
yg, nptsy, zgg, type, data );
3164 for (
int i = 0; i < nptsx; i++ )
3165 for (
int j = 0; j < nptsy; j++ )
3166 *(
zg + nptsx * j + i ) = zgg[i][j];
3174 f2c( z, zz, nx, ny );
3182 f2c( z, zz, nx, ny );
3183 c_plmeshc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3191 f2c( z, zz, nx, ny );
3200 f2c( z, zz, nx, ny );
3201 c_plot3dc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3210 f2c( z, zz, nx, ny );
3212 indexxmin, indexxmax, indexymin, indexymax );
3219 f2c( z, zz, nx, ny );
3227 f2c( z, zz, nx, ny );
3229 indexxmin, indexxmax, indexymin, indexymax );
3247 f2c( a, aa, nx, ny );
3248 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3249 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3250 min_color, min_width, max_color, max_width,
3264 grid1.
nx = nx; grid1.
ny = ny;
3266 f2c( a, aa, nx, ny );
3267 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3268 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3269 min_color, min_width, max_color, max_width,
3283 f2c( xg, xgg, nx, ny );
3284 f2c(
yg, ygg, nx, ny );
3285 grid2.
nx = nx; grid2.
ny = ny;
3286 grid2.
xg = xgg; grid2.
yg = ygg;
3287 f2c( a, aa, nx, ny );
3288 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3289 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3290 min_color, min_width, max_color, max_width,
3302 f2c( a, aa, nx, ny );
3303 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3304 clevel, nlevel, fill_width, cont_color, cont_width,
3305 plfill, rectangular, NULL, NULL );
3314 f2c( a, aa, nx, ny );
3315 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3316 clevel, nlevel, fill_width, cont_color, cont_width,
3327 grid1.
nx = nx; grid1.
ny = ny;
3330 f2c( a, aa, nx, ny );
3331 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3332 clevel, nlevel, fill_width, cont_color, cont_width,
3343 f2c( xg, xgg, nx, ny );
3344 f2c(
yg, ygg, nx, ny );
3345 grid2.
nx = nx; grid2.
ny = ny;
3346 grid2.
xg = xgg; grid2.
yg = ygg;
3347 f2c( a, aa, nx, ny );
3348 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3349 clevel, nlevel, fill_width, cont_color, cont_width,
3359 f2c( u, uu, nx, ny );
3360 f2c( v, vv, nx, ny );
3368 grid1.
nx = nx; grid1.
ny = ny;
3370 f2c( u, uu, nx, ny );
3371 f2c( v, vv, nx, ny );
3379 f2c( xg, xgg, nx, ny );
3380 f2c(
yg, ygg, nx, ny );
3381 grid2.
nx = nx; grid2.
ny = ny;
3382 grid2.
xg = xgg; grid2.
yg = ygg;
3383 f2c( u, uu, nx, ny );
3384 f2c( v, vv, nx, ny );
3395 f2c( a, aa, nx, ny );
3396 plimage( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
3406 f2c( a, aa, nx, ny );
3407 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
3415 f2c( a, aa, nx, ny );
3416 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
xform, tr );
3426 grid1.
nx = nx + 1; grid1.
ny = ny + 1;
3428 f2c( a, aa, nx, ny );
3429 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr1, &grid1 );
3439 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
3440 f2c(
yg, ygg, ( nx + 1 ), ( ny + 1 ) );
3441 grid2.
nx = nx + 1; grid2.
ny = ny + 1;
3442 grid2.
xg = xgg; grid2.
yg = ygg;
3443 f2c( a, aa, nx, ny );
3444 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr2, &grid2 );
3455 PLINT n_labels,
const PLINT *label_opts,
const char **label,
3456 PLINT n_axes,
const char ** axis_opts,
3463 for ( i = 0; i < nx; i++ )
3464 if ( n_values[i] > ny )
3466 f2c( a, aa, nx, ny );
3468 opt, position, x, y,
3470 bg_color, bb_color, bb_style,
3471 low_cap_color, high_cap_color,
3472 cont_color, cont_width,
3473 n_labels, label_opts, label,
3483 if (!ov.is_scalar_type())
3485 if (ov.is_complex_scalar())
3487 if (ov.is_double_type()||ov.is_single_type()) {
3488 double v=ov.double_value();
3494 if (ov.is_int8_type()||ov.is_int16_type()||
3495 ov.is_int32_type()) {
3496 long v=ov.long_value();
3500 if (ov.is_int64_type()) {
3501 long long v=ov.int64_scalar_value().value();
3506 *val = ov.ulong_value();
3517 if ((v > UINT_MAX)) {
3520 if (val) *val =
static_cast< unsigned int >(v);
3529 return octave_value(
value);
3543 char* cptr = 0;
size_t csize = 0;
int alloc =
SWIG_OLDOBJ;
3547 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3548 if (csize <= size) {
3550 if (csize) memcpy(val, cptr, csize*
sizeof(
char));
3551 if (csize < size) memset(val + csize, 0, (size - csize)*
sizeof(
char));
3568 static int init = 0;
3581 return std::string(carray,carray+size);
3589 for (p = s; maxlen-- && *p; p++)
3603 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3604 if (val) *val =
static_cast< char >(v);
3614Set up transformation from metafile coordinates\n\
3618 Set up transformation from metafile coordinates. The size of the plot\n\
3619 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
3620 general-purpose facility just yet (not sure why the user would need\n\
3623 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
3626 This function is not used in any examples.\n\
3632plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
3636 dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
3638 dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
3640 dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
3642 dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
3644 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3646 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3649Set the cmap0 palette using the specified cmap0*.pal format file\n\
3653 Set the cmap0 palette using the specified cmap0*.pal format file.\n\
3655 Redacted form: plspal0(filename)\n\
3657 This function is in example 16.\n\
3667 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3668 containing the name of the cmap0*.pal file. If this string is\n\
3669 empty, use the default cmap0*.pal file.\n\
3672Set the cmap1 palette using the specified cmap1*.pal format file\n\
3676 Set the cmap1 palette using the specified cmap1*.pal format file.\n\
3678 Redacted form: plspal1(filename, interpolate)\n\
3680 This function is used in example 16.\n\
3686plspal1(filename, interpolate)\n\
3690 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3691 containing the name of the cmap1*.pal file. If this string is\n\
3692 empty, use the default cmap1*.pal file.\n\
3694 interpolate (PLBOOL, input) : If this parameter is true, the\n\
3695 columns containing the intensity index, r, g, b, alpha and\n\
3696 alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
3697 palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
3698 a flag which controls whether the r, g, b data sent to plscmap1la\n\
3699 are interpreted as HLS or RGB.) If this parameter is false, the\n\
3700 intensity index and alt_hue_path columns are ignored and the r, g,\n\
3701 b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
3702 are used instead to set the cmap1 palette directly with a call to\n\
3706Draw a line in 3 space\n\
3710 Draws line in 3 space defined by n points in x, y, and z. You must\n\
3711 first set up the viewport, the 2d viewing window (in world\n\
3712 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
3715 Redacted form: plline3(x, y, z)\n\
3717 This function is used in example 18.\n\
3723plline3(n, x, y, z)\n\
3727 n (PLINT, input) : Number of points defining line.\n\
3729 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
3732 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
3735 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
3739Magnitude colored plot surface mesh with contour\n\
3743 A more powerful form of plmesh: the surface mesh can be colored\n\
3744 accordingly to the current z value being plotted, a contour plot can\n\
3745 be drawn at the base XY plane, and a curtain can be drawn between the\n\
3746 plotted function border and the base XY plane.\n\
3748 Redacted form: plmeshc(x, y, z, opt, clevel)\n\
3750 This function is used in example 11.\n\
3756plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
3760 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3761 which the function is evaluated.\n\
3763 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3764 which the function is evaluated.\n\
3766 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3767 plot. Should have dimensions of\n\
3771 nx (PLINT, input) : Number of x values at which function is\n\
3774 ny (PLINT, input) : Number of y values at which function is\n\
3777 opt (PLINT, input) : Determines the way in which the surface is\n\
3778 represented. To specify more than one option just add the options,\n\
3779 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3780 showing z as a function of x for each value of y[j] .\n\
3781 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3782 for each value of x[i] .\n\
3783 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3784 at which function is defined.\n\
3785 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3786 the z value being plotted. The color is used from the current\n\
3788 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3792 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3793 the borders of the plotted function.\n\
3796 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3799 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3802Draw a line between two points, accounting for coordinate transforms\n\
3806 Joins the point (\n\
3810 y2) . If a global coordinate transform is defined then the line is\n\
3811 broken in to n segments to approximate the path. If no transform is\n\
3812 defined then this simply acts like a call to pljoin.\n\
3814 Redacted form: plpath(n,x1,y1,x2,y2)\n\
3816 This function is used in example 22.\n\
3822plpath(n, x1, y1, x2, y2)\n\
3826 n (PLINT, input) : number of points to use to approximate the path.\n\
3828 x1 (PLFLT, input) : x coordinate of first point.\n\
3830 y1 (PLFLT, input) : y coordinate of first point.\n\
3832 x2 (PLFLT, input) : x coordinate of second point.\n\
3834 y2 (PLFLT, input) : y coordinate of second point.\n\
3837Write text inside the viewport\n\
3841 Writes text at a specified position and inclination within the\n\
3842 viewport. Text is clipped at the viewport boundaries. The reference\n\
3843 point of a string lies along a line passing through the string at half\n\
3844 the height of a capital letter. The position of the reference point\n\
3845 along this line is determined by just, the reference point is placed\n\
3846 at world coordinates (\n\
3848 y) within the viewport. The inclination of the string is specified\n\
3849 in terms of differences of world coordinates making it easy to write\n\
3850 text parallel to a line in a graph.\n\
3852 Redacted form: plptex(x, y, dx, dy, just, text)\n\
3854 This function is used in example 2-4,10,12-14,20,23,24,26.\n\
3860plptex(x, y, dx, dy, just, text)\n\
3864 x (PLFLT, input) : x coordinate of reference point of string.\n\
3866 y (PLFLT, input) : y coordinate of reference point of string.\n\
3868 dx (PLFLT, input) : Together with dy, this specifies the\n\
3869 inclination of the string. The baseline of the string is parallel\n\
3870 to a line joining (\n\
3878 dy (PLFLT, input) : Together with dx, this specifies the\n\
3879 inclination of the string.\n\
3881 just (PLFLT, input) : Specifies the position of the string relative\n\
3882 to its reference point. If just=0. , the reference point is at\n\
3883 the left and if just=1. , it is at the right of the string. Other\n\
3884 values of just give intermediate justifications.\n\
3886 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3890Set family file parameters\n\
3894 Sets variables dealing with output file familying. Does nothing if\n\
3895 familying not supported by the driver. This routine, if used, must be\n\
3896 called before initializing PLplot. See the PLplot documentation for\n\
3897 more information.\n\
3899 Redacted form: plsfam(fam, num, bmax)\n\
3901 This function is used in examples 14 and 31.\n\
3907plsfam(fam, num, bmax)\n\
3911 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
3914 num (PLINT, input) : Current family file number.\n\
3916 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
3920Set y axis parameters\n\
3924 Identical to plsxax, except that arguments are flags for y axis. See\n\
3925 the description of plsxax for more detail.\n\
3927 Redacted form: plsyax(digmax, digits)\n\
3929 This function is used in examples 1, 14, and 31.\n\
3935plsyax(digmax, digits)\n\
3939 digmax (PLINT, input) : Variable to set the maximum number of\n\
3940 digits for the y axis. If nonzero, the printed label will be\n\
3941 switched to a floating-point representation when the number of\n\
3942 digits exceeds digmax.\n\
3944 digits (PLINT, input) : Field digits value. Currently, changing\n\
3945 its value here has no effect since it is set only by plbox or\n\
3946 plbox3. However, the user may obtain its value after a call to\n\
3947 either of these functions by calling plgyax.\n\
3950Get z axis parameters\n\
3954 Identical to plgxax, except that arguments are flags for z axis. See\n\
3955 the description of plgxax for more detail.\n\
3957 Redacted form: plgzax(p_digmax, p_digits)\n\
3959 This function is used in example 31.\n\
3965plgzax(p_digmax, p_digits)\n\
3969 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
3970 number of digits for the z axis. If nonzero, the printed label\n\
3971 has been switched to a floating-point representation when the\n\
3972 number of digits exceeds this value.\n\
3974 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
3975 number of digits for the numeric labels (z axis) from the last\n\
3979Set format of numerical label for contours\n\
3983 Set format of numerical label for contours.\n\
3985 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
3987 This function is used example 9.\n\
3993pl_setcontlabelformat(lexp, sigdig)\n\
3997 lexp (PLINT, input) : If the contour numerical label is greater\n\
3998 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
3999 format is used. Default value of lexp is 4.\n\
4001 sigdig (PLINT, input) : Number of significant digits. Default\n\
4009 Sets the pen width.\n\
4011 Redacted form: plwidth(width)\n\
4013 This function is used in examples 1 and 2.\n\
4023 width (PLFLT, input) : The desired pen width. If width is negative\n\
4024 or the same as the previous value no action is taken. width = 0.\n\
4025 should be interpreted as as the minimum valid pen width for the\n\
4026 device. The interpretation of positive width values is also\n\
4027 device dependent.\n\
4030Get parameters that define current plot-space window\n\
4034 Get relative minima and maxima that define current plot-space window.\n\
4035 If plsdiplt has not been called the default values pointed to by\n\
4036 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
4038 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4040 This function is used in example 31.\n\
4046plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4050 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4053 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4056 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4059 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4063Set the cmap1 argument range for continuous color plots\n\
4067 Set the cmap1 argument range for continuous color plots that\n\
4068 corresponds to the range of data values. The maximum range\n\
4069 corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
4070 the cmap1 argument range that is specified with this routine, the\n\
4071 smaller the subset of the cmap1 color palette that is used to\n\
4072 represent the continuous data being plotted. If\n\
4073 min_color is greater than\n\
4075 max_color is greater than 1.0 or\n\
4076 min_color is less than 0.0 then no change is made to the cmap1\n\
4077 argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
4079 Redacted form: plscmap1_range(min_color, max_color)\n\
4081 This function is currently used in example 33.\n\
4087plscmap1_range(min_color, max_color)\n\
4091 min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
4092 than 0.0, then 0.0 is used instead.\n\
4094 max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
4095 than 1.0, then 1.0 is used instead.\n\
4098Select standard viewport\n\
4102 Selects the largest viewport within the subpage that leaves a standard\n\
4103 margin (left-hand margin of eight character heights, and a margin\n\
4104 around the other three sides of five character heights).\n\
4106 Redacted form: plvsta()\n\
4108 This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
4117Load Hershey fonts\n\
4121 Loads the Hershey fonts used for text and symbols. This routine may\n\
4122 be called before or after initializing PLplot. If not explicitly\n\
4123 called before PLplot initialization, then by default that\n\
4124 initialization loads Hershey fonts with the extended character set.\n\
4125 This routine only has a practical effect for devices that still use\n\
4126 Hershey fonts (as opposed to modern devices that use unicode-aware\n\
4127 system fonts instead of Hershey fonts).\n\
4129 Redacted form: plfontld(fnt)\n\
4131 This function is used in examples 1 and 7.\n\
4141 fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
4142 A zero value specifies Hershey fonts with the standard character\n\
4143 set and a non-zero value (the default assumed if plfontld is never\n\
4144 called) specifies Hershey fonts with the extended character set.\n\
4147Draw error bars in x direction\n\
4151 Draws a set of n error bars in x direction, the i\'th error bar\n\
4152 extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
4153 of the error bars are of length equal to the minor tick length\n\
4154 (settable using plsmin).\n\
4156 Redacted form: General: plerrx(xmin, ymax, y)\n\
4159 This function is used in example 29.\n\
4165plerrx(n, xmin, xmax, y)\n\
4169 n (PLINT, input) : Number of error bars to draw.\n\
4171 xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4172 of the left-hand endpoints of the error bars.\n\
4174 xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4175 of the right-hand endpoints of the error bars.\n\
4177 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4181Plot shaded 3-d surface plot\n\
4185 Plots a three-dimensional shaded surface plot within the environment\n\
4186 set up by plw3d. The surface is defined by the two-dimensional matrix\n\
4189 ny], the point z[i][j] being the value of the function at (\n\
4191 y[j]). Note that the points in vectors x and y do not need to be\n\
4192 equally spaced, but must be stored in ascending order. For further\n\
4193 details see the PLplot documentation.\n\
4195 Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
4197 This function is not used in any examples.\n\
4203plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
4207 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4208 which the function is evaluated.\n\
4210 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4211 which the function is evaluated.\n\
4213 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4214 plot. Should have dimensions of\n\
4218 nx (PLINT, input) : Number of x values at which function is\n\
4221 ny (PLINT, input) : Number of y values at which function is\n\
4224 opt (PLINT, input) : Determines the way in which the surface is\n\
4225 represented. To specify more than one option just add the options,\n\
4226 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
4227 connecting points at which function is defined.\n\
4228 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
4232 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
4236 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
4237 the borders of the plotted function.\n\
4238 opt=MAG_COLOR : the surface is colored according to the value\n\
4239 of Z; if MAG_COLOR is not used, then the surface is colored\n\
4240 according to the intensity of the reflected light in the\n\
4241 surface from a light source whose position is set using\n\
4245 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
4248 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
4251Get the current library version number\n\
4255 Get the current library version number. Note: you must have allocated\n\
4256 space for this (80 characters is safe).\n\
4258 Redacted form: plgver(p_ver)\n\
4260 This function is used in example 1.\n\
4270 p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4271 (with preallocated length of 80 characters or more) containing the\n\
4272 PLplot version number.\n\
4275End plotting session for current stream\n\
4279 Ends a plotting session for the current output stream only. See\n\
4280 plsstrm for more info.\n\
4282 Redacted form: plend1()\n\
4284 This function is used in examples 1 and 20.\n\
4293Draw error bars in the y direction\n\
4297 Draws a set of n error bars in the y direction, the i\'th error bar\n\
4298 extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
4299 of the error bars are of length equal to the minor tick length\n\
4300 (settable using plsmin).\n\
4302 Redacted form: General: plerry(x, ymin, ymax)\n\
4305 This function is used in example 29.\n\
4311plerry(n, x, ymin, ymax)\n\
4315 n (PLINT, input) : Number of error bars to draw.\n\
4317 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4320 ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4321 of the lower endpoints of the error bars.\n\
4323 ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4324 of the upper endpoints of the error bars.\n\
4327Set seed for internal random number generator.\n\
4331 Set the seed for the internal random number generator. See plrandd for\n\
4334 Redacted form: plseed(seed)\n\
4336 This function is used in example 21.\n\
4346 seed (unsigned int, input) : Seed for random number generator.\n\
4349Specify viewport using normalized subpage coordinates\n\
4353 Device-independent routine for setting up the viewport. This defines\n\
4354 the viewport in terms of normalized subpage coordinates which run from\n\
4355 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
4356 current subpage. Use the alternate routine plsvpa in order to create\n\
4357 a viewport of a definite size.\n\
4359 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
4361 This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
4362 24, 26, 27, and 31.\n\
4368plvpor(xmin, xmax, ymin, ymax)\n\
4372 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
4373 left-hand edge of the viewport.\n\
4375 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
4376 right-hand edge of the viewport.\n\
4378 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
4379 bottom edge of the viewport.\n\
4381 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
4382 edge of the viewport.\n\
4389 Plots a surface mesh within the environment set up by plw3d. The\n\
4390 surface is defined by the matrix z[\n\
4392 ny] , the point z[i][j] being the value of the function at (\n\
4394 y[j]). Note that the points in vectors x and y do not need to be\n\
4395 equally spaced, but must be stored in ascending order. The parameter\n\
4396 opt controls the way in which the surface is displayed. For further\n\
4397 details see the PLplot documentation.\n\
4399 Redacted form: plmesh(x, y, z, opt)\n\
4401 This function is used in example 11.\n\
4407plmesh(x, y, z, nx, ny, opt)\n\
4411 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4412 which the function is evaluated.\n\
4414 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4415 which the function is evaluated.\n\
4417 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4418 plot. Should have dimensions of\n\
4422 nx (PLINT, input) : Number of x values at which function has been\n\
4425 ny (PLINT, input) : Number of y values at which function has been\n\
4428 opt (PLINT, input) : Determines the way in which the surface is\n\
4429 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
4430 function of x for each value of y[j] .\n\
4431 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
4432 for each value of x[i] .\n\
4433 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
4434 at which function is defined.\n\
4437Get the cmap1 argument range for continuous color plots\n\
4441 Get the cmap1 argument range for continuous color plots. (Use\n\
4442 plscmap1_range to set the cmap1 argument range.)\n\
4444 Redacted form: plgcmap1_range(min_color, max_color)\n\
4446 This function is currently not used in any example.\n\
4452plgcmap1_range(min_color, max_color)\n\
4456 min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4457 minimum cmap1 argument.\n\
4459 max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4460 maximum cmap1 argument.\n\
4463Set arrow style for vector plots\n\
4467 Set the style for the arrow used by plvect to plot vectors.\n\
4469 Redacted form: plsvect(arrowx, arrowy, fill)\n\
4471 This function is used in example 22.\n\
4477plsvect(arrowx, arrowy, npts, fill)\n\
4481 arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
4482 the x and y points which make up the arrow. The arrow is plotted\n\
4483 by joining these points to form a polygon. The scaling assumes\n\
4484 that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
4485 <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
4486 will be reset to its default.\n\
4488 npts (PLINT, input) : Number of points in the vectors arrowx and\n\
4491 fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
4492 fill is false then the arrow is open.\n\
4495Draw filled polygon\n\
4499 Fills the polygon defined by the n points (\n\
4501 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4502 style is a solid fill. The routine will automatically close the\n\
4503 polygon between the last and first vertices. If multiple closed\n\
4504 polygons are passed in x and y then plfill will fill in between them.\n\
4506 Redacted form: plfill(x,y)\n\
4508 This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
4518 n (PLINT, input) : Number of vertices in polygon.\n\
4520 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4523 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4527Convert HLS color to RGB\n\
4531 Convert HLS color coordinates to RGB.\n\
4533 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4536 This function is used in example 2.\n\
4542plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4546 h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
4549 l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
4550 the axis of the color cylinder.\n\
4552 s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
4553 the radius of the color cylinder.\n\
4555 p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
4556 (0.0-1.0) of the color.\n\
4558 p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
4559 intensity (0.0-1.0) of the color.\n\
4561 p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
4562 intensity (0.0-1.0) of the color.\n\
4565Set format for date / time labels\n\
4569 Sets the format for date / time labels. To enable date / time format\n\
4570 labels see the options to plbox, plbox3, and plenv.\n\
4572 Redacted form: pltimefmt(fmt)\n\
4574 This function is used in example 29.\n\
4584 fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
4585 interpreted similarly to the format specifier of typical system\n\
4586 strftime routines except that PLplot ignores locale and also\n\
4587 supplies some useful extensions in the context of plotting. All\n\
4588 text in the string is printed as-is other than conversion\n\
4589 specifications which take the form of a \'%\' character followed by\n\
4590 further conversion specification character. The conversion\n\
4591 specifications which are similar to those provided by system\n\
4592 strftime routines are the following: %a: The abbreviated (English)\n\
4594 %A: The full (English) weekday name.\n\
4595 %b: The abbreviated (English) month name.\n\
4596 %B: The full (English) month name.\n\
4597 %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
4598 %C: The century number (year/100) as a 2-digit integer.\n\
4599 %d: The day of the month as a decimal number (range 01 to 31).\n\
4600 %D: Equivalent to %m/%d/%y (non-ISO).\n\
4601 %e: Like %d, but a leading zero is replaced by a space.\n\
4602 %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
4603 %h: Equivalent to %b.\n\
4604 %H: The hour as a decimal number using a 24-hour clock (range\n\
4606 %I: The hour as a decimal number using a 12-hour clock (range\n\
4608 %j: The day of the year as a decimal number (range 001 to\n\
4610 %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
4611 23); single digits are preceded by a blank. (See also %H.)\n\
4612 %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
4613 12); single digits are preceded by a blank. (See also %I.)\n\
4614 %m: The month as a decimal number (range 01 to 12).\n\
4615 %M: The minute as a decimal number (range 00 to 59).\n\
4616 %n: A newline character.\n\
4617 %p: Either \"AM\" or \"PM\" according to the given time value.\n\
4618 Noon is treated as \"PM\" and midnight as \"AM\".\n\
4619 %r: Equivalent to %I:%M:%S %p.\n\
4620 %R: The time in 24-hour notation (%H:%M). For a version\n\
4621 including the seconds, see %T below.\n\
4622 %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
4624 %S: The second as a decimal number (range 00 to 60). (The\n\
4625 range is up to 60 to allow for occasional leap seconds.)\n\
4626 %t: A tab character.\n\
4627 %T: The time in 24-hour notation (%H:%M:%S).\n\
4628 %u: The day of the week as a decimal, range 1 to 7, Monday\n\
4629 being 1. See also %w.\n\
4630 %U: The week number of the current year as a decimal number,\n\
4631 range 00 to 53, starting with the first Sunday as the first\n\
4632 day of week 01. See also %V and %W.\n\
4633 %v: Equivalent to %e-%b-%Y.\n\
4634 %V: The ISO 8601 week number of the current year as a decimal\n\
4635 number, range 01 to 53, where week 1 is the first week that\n\
4636 has at least 4 days in the new year. See also %U and %W.\n\
4637 %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
4638 being 0. See also %u.\n\
4639 %W: The week number of the current year as a decimal number,\n\
4640 range 00 to 53, starting with the first Monday as the first\n\
4642 %x: Equivalent to %a %b %d %Y.\n\
4643 %X: Equivalent to %T.\n\
4644 %y: The year as a decimal number without a century (range 00\n\
4646 %Y: The year as a decimal number including a century.\n\
4647 %z: The UTC time-zone string = \"+0000\".\n\
4648 %Z: The UTC time-zone abbreviation = \"UTC\".\n\
4649 %+: The UTC date and time in default format of the Unix date\n\
4650 command which is equivalent to %a %b %d %T %Z %Y.\n\
4651 %%: A literal \"%\" character.\n\
4652 The conversion specifications which are extensions to those normally\n\
4653 provided by system strftime routines are the following: %(0-9):\n\
4654 The fractional part of the seconds field (including leading\n\
4655 decimal point) to the specified accuracy. Thus %S%3 would give\n\
4656 seconds to millisecond accuracy (00.000).\n\
4657 %.: The fractional part of the seconds field (including\n\
4658 leading decimal point) to the maximum available accuracy. Thus\n\
4659 %S%. would give seconds with fractional part up to 9 decimal\n\
4660 places if available.\n\
4663Get current subpage parameters\n\
4667 Gets the size of the current subpage in millimeters measured from the\n\
4668 bottom left hand corner of the output device page or screen. Can be\n\
4669 used in conjunction with plsvpa for setting the size of a viewport in\n\
4670 absolute coordinates (millimeters).\n\
4672 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
4674 This function is used in example 23.\n\
4680plgspa(xmin, xmax, ymin, ymax)\n\
4684 xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4685 the left hand edge of the subpage in millimeters.\n\
4687 xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4688 the right hand edge of the subpage in millimeters.\n\
4690 ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4691 the bottom edge of the subpage in millimeters.\n\
4693 ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4694 the top edge of the subpage in millimeters.\n\
4697Calculate world coordinates and corresponding window index from relative device coordinates\n\
4701 Calculate world coordinates, wx and wy, and corresponding window index\n\
4702 from relative device coordinates, rx and ry.\n\
4704 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
4707 This function is used in example 31.\n\
4713plcalc_world(rx, ry, wx, wy, window)\n\
4717 rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4718 the x coordinate.\n\
4720 ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4721 the y coordinate.\n\
4723 wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
4724 coordinate corresponding to the relative device coordinates rx and\n\
4727 wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
4728 coordinate corresponding to the relative device coordinates rx and\n\
4731 window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
4732 defined window index that corresponds to the input relative device\n\
4733 coordinates (and the returned world coordinates). To give some\n\
4734 background on the window index, for each page the initial window\n\
4735 index is set to zero, and each time plwind is called within the\n\
4736 page, world and device coordinates are stored for the window and\n\
4737 the window index is incremented. Thus, for a simple page layout\n\
4738 with non-overlapping viewports and one window per viewport, window\n\
4739 corresponds to the viewport index (in the order which the\n\
4740 viewport/windows were created) of the only viewport/window\n\
4741 corresponding to rx and ry. However, for more complicated layouts\n\
4742 with potentially overlapping viewports and possibly more than one\n\
4743 window (set of world coordinates) per viewport, window and the\n\
4744 corresponding output world coordinates corresponds to the last\n\
4745 window created that fulfills the criterion that the relative\n\
4746 device coordinates are inside it. Finally, in all cases where the\n\
4747 input relative device coordinates are not inside any\n\
4748 viewport/window, then the returned value of the last defined\n\
4749 window index is set to -1.\n\
4752Get output file name\n\
4756 Gets the current output file name, if applicable.\n\
4758 Redacted form: plgfnam(fnam)\n\
4760 This function is used in example 31.\n\
4770 fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4771 (with preallocated length of 80 characters or more) containing the\n\
4779 Draws a plot of vector data contained in the matrices (\n\
4785 ny]) . The scaling factor for the vectors is given by scale. A\n\
4786 transformation routine pointed to by pltr with a pointer pltr_data for\n\
4787 additional data required by the transformation routine to map indices\n\
4788 within the matrices to the world coordinates. The style of the vector\n\
4789 arrow may be set using plsvect.\n\
4791 Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
4792 discussion) the pltr, pltr_data callback arguments are sometimes\n\
4793 replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
4794 with either one or two dimensions.\n\
4796 This function is used in example 22.\n\
4802plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
4806 u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
4807 and y components of the vector data to be plotted.\n\
4809 nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
4811 scale (PLFLT, input) : Parameter to control the scaling factor of\n\
4812 the vectors for plotting. If scale = 0 then the scaling factor is\n\
4813 automatically calculated for the data. If scale < 0 then the\n\
4814 scaling factor is automatically calculated for the data and then\n\
4816 scale. If scale > 0 then the scaling factor is set to scale.\n\
4818 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
4819 defines the transformation between the zero-based indices of the\n\
4820 matrices u and v and world coordinates.For the C case,\n\
4821 transformation functions are provided in the PLplot library: pltr0\n\
4822 for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
4823 mappings respectively defined by vectors and matrices. In\n\
4824 addition, C callback routines for the transformation can be\n\
4825 supplied by the user such as the mypltr function in\n\
4826 examples/c/x09c.c which provides a general linear transformation\n\
4827 between index coordinates and world coordinates.For languages\n\
4828 other than C you should consult the PLplot documentation for the\n\
4829 details concerning how PLTRANSFORM_callback arguments are\n\
4830 interfaced. However, in general, a particular pattern of\n\
4831 callback-associated arguments such as a tr vector with 6 elements;\n\
4832 xg and yg vectors; or xg and yg matrices are respectively\n\
4833 interfaced to a linear-transformation routine similar to the above\n\
4834 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
4835 sophisticated bindings (see, e.g., the PLplot documentation)\n\
4836 support native language callbacks for handling index to\n\
4837 world-coordinate transformations. Examples of these various\n\
4838 approaches are given in examples/<language>x09*,\n\
4839 examples/<language>x16*, examples/<language>x20*,\n\
4840 examples/<language>x21*, and examples/<language>x22*, for all our\n\
4841 supported languages.\n\
4843 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
4844 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
4845 that is externally supplied.\n\
4848Plot a glyph at the specified points\n\
4852 Plot a glyph at the specified points. (This function is largely\n\
4853 superseded by plstring which gives access to many[!] more glyphs.)\n\
4855 Redacted form: plsym(x, y, code)\n\
4857 This function is used in example 7.\n\
4863plsym(n, x, y, code)\n\
4867 n (PLINT, input) : Number of points in the x and y vectors.\n\
4869 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4872 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4875 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
4876 to be plotted at each of the n points.\n\
4879Get viewport limits in normalized device coordinates\n\
4883 Get viewport limits in normalized device coordinates.\n\
4885 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4888 This function is used in example 31.\n\
4894plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4898 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4899 viewport limit of the normalized device coordinate in x.\n\
4901 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4902 viewport limit of the normalized device coordinate in x.\n\
4904 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4905 viewport limit of the normalized device coordinate in y.\n\
4907 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4908 viewport limit of the normalized device coordinate in y.\n\
4911Get page parameters\n\
4915 Gets the current page configuration. The length and offset values are\n\
4916 expressed in units that are specific to the current driver. For\n\
4917 instance: screen drivers will usually interpret them as number of\n\
4918 pixels, whereas printer drivers will usually use mm.\n\
4920 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
4922 This function is used in examples 14 and 31.\n\
4928plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
4932 p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
4933 pixels/inch (DPI) in x.\n\
4935 p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
4936 pixels/inch (DPI) in y.\n\
4938 p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
4941 p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
4944 p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
4947 p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
4951Plot a glyph at the specified 3D points\n\
4955 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
4956 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
4957 this function similar to what is done for plline3. The glyph is\n\
4958 specified with a PLplot user string. Note that the user string is not\n\
4959 actually limited to one glyph so it is possible (but not normally\n\
4960 useful) to plot more than one glyph at the specified points with this\n\
4961 function. As with plmtex and plptex, the user string can contain FCI\n\
4962 escapes to determine the font, UTF-8 code to determine the glyph or\n\
4963 else PLplot escapes for Hershey or unicode text to determine the\n\
4966 Redacted form: plstring3(x, y, z, string)\n\
4968 This function is used in example 18.\n\
4974plstring3(n, x, y, z, string)\n\
4978 n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
4980 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4983 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4986 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
4989 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
4990 the glyph(s) to be plotted at each of the n points. points.\n\
4993Shade regions on the basis of value\n\
4997 Shade regions on the basis of value. This is the high-level routine\n\
4998 for making continuous color shaded plots with cmap1 while plshade\n\
4999 should be used to plot individual shaded regions using either cmap0 or\n\
5000 cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
5001 our supported languages.\n\
5003 Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
5004 clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
5008 This function is used in examples 16, 21, and 22.\n\
5014plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
5018 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5019 plot. Should have dimensions of\n\
5023 nx (PLINT, input) : First dimension of matrix \"a\".\n\
5025 ny (PLINT, input) : Second dimension of matrix \"a\".\n\
5027 defined (PLDEFINED_callback, input) : Callback function specifying\n\
5028 the region that should be plotted in the shade plot. This\n\
5029 function accepts x and y coordinates as input arguments and must\n\
5030 return 1 if the point is to be included in the shade plot and 0\n\
5031 otherwise. If you want to plot the entire shade plot (the usual\n\
5032 case), this argument should be set to NULL.\n\
5034 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
5035 pltr below for how these arguments are used (only for the special case\n\
5036 when the callback function\n\
5037 pltr is not supplied).\n\
5039 clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
5040 corresponding to the edges of each shaded region that will be\n\
5041 plotted by this function. To work properly the levels should be\n\
5044 nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
5045 of shade edge values in clevel).\n\
5047 fill_width (PLFLT, input) : Defines the line width used by the fill\n\
5050 cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
5051 contours defining edges of shaded regions. The pen color is only\n\
5052 temporary set for the contour drawing. Set this value to zero or\n\
5053 less if no shade edge contours are wanted.\n\
5055 cont_width (PLFLT, input) : Defines line width used for contours\n\
5056 defining edges of shaded regions. This value may not be honored\n\
5057 by all drivers. The pen width is only temporary set for the\n\
5058 contour drawing. Set this value to zero or less if no shade edge\n\
5059 contours are wanted.\n\
5061 fill (PLFILL_callback, input) : Callback routine used to fill the\n\
5062 region. Use plfill for this purpose.\n\
5064 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
5065 map to rectangles after coordinate transformation with pltrl.\n\
5066 Otherwise, set rectangular to false. If rectangular is set to\n\
5067 true, plshade tries to save time by filling large rectangles.\n\
5068 This optimization fails if the coordinate transformation distorts\n\
5069 the shape of rectangles. For example a plot in polar coordinates\n\
5070 has to have rectangular set to false.\n\
5072 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5073 defines the transformation between the zero-based indices of the\n\
5074 matrix a and world coordinates. If\n\
5075 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
5076 indices of a are mapped to the range\n\
5078 xmax and the y indices of a are mapped to the range\n\
5080 ymax.For the C case, transformation functions are provided in the\n\
5081 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
5082 pltr2 for arbitrary mappings respectively defined by vectors and\n\
5083 matrices. In addition, C callback routines for the transformation\n\
5084 can be supplied by the user such as the mypltr function in\n\
5085 examples/c/x09c.c which provides a general linear transformation\n\
5086 between index coordinates and world coordinates.For languages\n\
5087 other than C you should consult the PLplot documentation for the\n\
5088 details concerning how PLTRANSFORM_callback arguments are\n\
5089 interfaced. However, in general, a particular pattern of\n\
5090 callback-associated arguments such as a tr vector with 6 elements;\n\
5091 xg and yg vectors; or xg and yg matrices are respectively\n\
5092 interfaced to a linear-transformation routine similar to the above\n\
5093 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
5094 sophisticated bindings (see, e.g., the PLplot documentation)\n\
5095 support native language callbacks for handling index to\n\
5096 world-coordinate transformations. Examples of these various\n\
5097 approaches are given in examples/<language>x09*,\n\
5098 examples/<language>x16*, examples/<language>x20*,\n\
5099 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5100 supported languages.\n\
5102 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5103 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
5104 externally supplied.\n\
5107Set output file name\n\
5111 Sets the current output file name, if applicable. If the file name\n\
5112 has not been specified and is required by the driver, the user will be\n\
5113 prompted for it. If using the X-windows output driver, this sets the\n\
5114 display name. This routine, if used, must be called before\n\
5115 initializing PLplot.\n\
5117 Redacted form: plsfnam(fnam)\n\
5119 This function is used in examples 1 and 20.\n\
5129 fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
5137 Draws a contour plot of the data in f[\n\
5139 ny], using the nlevel contour levels specified by clevel. Only the\n\
5140 region of the matrix from kx to lx and from ky to ly is plotted out\n\
5141 where all these index ranges are interpreted as one-based for\n\
5142 historical reasons. A transformation routine pointed to by pltr with\n\
5143 a generic pointer pltr_data for additional data required by the\n\
5144 transformation routine is used to map indices within the matrix to the\n\
5145 world coordinates.\n\
5147 Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5148 where (see above discussion) the pltr, pltr_data callback arguments\n\
5149 are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5150 vectors; or xg and yg matrices.\n\
5152 This function is used in examples 9, 14, 16, and 22.\n\
5158plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5162 f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5164 nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5166 kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5167 kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5168 zero-based for historical backwards-compatibility reasons.\n\
5170 ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5171 ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5172 zero-based for historical backwards-compatibility reasons.\n\
5174 clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5175 which to draw contours.\n\
5177 nlevel (PLINT, input) : Number of contour levels to draw.\n\
5179 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5180 defines the transformation between the zero-based indices of the\n\
5181 matrix f and the world coordinates.For the C case, transformation\n\
5182 functions are provided in the PLplot library: pltr0 for the\n\
5183 identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5184 respectively defined by vectors and matrices. In addition, C\n\
5185 callback routines for the transformation can be supplied by the\n\
5186 user such as the mypltr function in examples/c/x09c.c which\n\
5187 provides a general linear transformation between index coordinates\n\
5188 and world coordinates.For languages other than C you should\n\
5189 consult the PLplot documentation for the details concerning how\n\
5190 PLTRANSFORM_callback arguments are interfaced. However, in\n\
5191 general, a particular pattern of callback-associated arguments\n\
5192 such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5193 yg matrices are respectively interfaced to a linear-transformation\n\
5194 routine similar to the above mypltr function; pltr1; and pltr2.\n\
5195 Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5196 the PLplot documentation) support native language callbacks for\n\
5197 handling index to world-coordinate transformations. Examples of\n\
5198 these various approaches are given in examples/<language>x09*,\n\
5199 examples/<language>x16*, examples/<language>x20*,\n\
5200 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5201 supported languages.\n\
5203 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5204 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5205 that is externally supplied.\n\
5208Set parameters that define current plot-space window\n\
5212 Set relative minima and maxima that define the current plot-space\n\
5213 window. If plsdiplt is not called the default values of xmin, ymin,\n\
5214 xmax, and ymax are 0., 0., 1., and 1.\n\
5216 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
5218 This function is used in example 31.\n\
5224plsdiplt(xmin, ymin, xmax, ymax)\n\
5228 xmin (PLFLT, input) : Relative minimum in x.\n\
5230 ymin (PLFLT, input) : Relative minimum in y.\n\
5232 xmax (PLFLT, input) : Relative maximum in x.\n\
5234 ymax (PLFLT, input) : Relative maximum in y.\n\
5237Write text inside the viewport of a 3D plot\n\
5241 Writes text at a specified position and inclination and with a\n\
5242 specified shear within the viewport. Text is clipped at the viewport\n\
5243 boundaries. The reference point of a string lies along a line passing\n\
5244 through the string at half the height of a capital letter. The\n\
5245 position of the reference point along this line is determined by just,\n\
5246 and the reference point is placed at world coordinates (\n\
5249 wz) within the viewport. The inclination and shear of the string is\n\
5250 specified in terms of differences of world coordinates making it easy\n\
5251 to write text parallel to a line in a graph.\n\
5253 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
5255 This function is used in example 28.\n\
5261plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
5265 wx (PLFLT, input) : x world coordinate of reference point of\n\
5268 wy (PLFLT, input) : y world coordinate of reference point of\n\
5271 wz (PLFLT, input) : z world coordinate of reference point of\n\
5274 dx (PLFLT, input) : Together with dy and\n\
5275 dz , this specifies the inclination of the string. The baseline of\n\
5276 the string is parallel to a line joining (\n\
5287 dy (PLFLT, input) : Together with dx and\n\
5288 dz, this specifies the inclination of the string.\n\
5290 dz (PLFLT, input) : Together with dx and\n\
5291 dy, this specifies the inclination of the string.\n\
5293 sx (PLFLT, input) : Together with sy and\n\
5294 sz , this specifies the shear of the string. The string is sheared so\n\
5295 that the characters are vertically parallel to a line joining (\n\
5306 sz = 0.) then the text is not sheared.\n\
5308 sy (PLFLT, input) : Together with sx and\n\
5309 sz, this specifies shear of the string.\n\
5311 sz (PLFLT, input) : Together with sx and\n\
5312 sy, this specifies shear of the string.\n\
5314 just (PLFLT, input) : Specifies the position of the string relative\n\
5315 to its reference point. If just=0. , the reference point is at\n\
5316 the left and if just=1. , it is at the right of the string. Other\n\
5317 values of just give intermediate justifications.\n\
5319 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5323Plot continental outline or shapefile data in world coordinates\n\
5327 Plots continental outlines or shapefile data in world coordinates. A\n\
5328 demonstration of how to use this function to create different\n\
5329 projections can be found in examples/c/x19c. PLplot is provided with\n\
5330 basic coastal outlines and USA state borders. To use the map\n\
5331 functionality PLplot must be compiled with the shapelib library.\n\
5332 Shapefiles have become a popular standard for geographical data and\n\
5333 data in this format can be easily found from a number of online\n\
5334 sources. Shapefile data is actually provided as three or more files\n\
5335 with the same filename, but different extensions. The .shp and .shx\n\
5336 files are required for plotting Shapefile data with PLplot.\n\
5338 PLplot currently supports the point, multipoint, polyline and polygon\n\
5339 objects within shapefiles. However holes in polygons are not\n\
5340 supported. When plmap is used the type of object is derived from the\n\
5341 shapefile, if you wish to override the type then use one of the other\n\
5342 plmap variants. The built in maps have line data only.\n\
5344 Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
5346 This function is used in example 19.\n\
5352plmap(mapform, name, minx, maxx, miny, maxy)\n\
5356 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5357 transform the original map data coordinates to a new coordinate\n\
5358 system. The PLplot-supplied map data is provided as latitudes and\n\
5359 longitudes; other Shapefile data may be provided in other\n\
5360 coordinate systems as can be found in their .prj plain text files.\n\
5361 For example, by using this transform we can change from a\n\
5362 longitude, latitude coordinate to a polar stereographic\n\
5363 projection. Initially, x[0]..[n-1] are the original x coordinates\n\
5364 (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
5365 corresponding y coordinates (latitudes for the PLplot supplied\n\
5366 data). After the call to mapform(), x[] and y[] should be\n\
5367 replaced by the corresponding plot coordinates. If no transform is\n\
5368 desired, mapform can be replaced by NULL.\n\
5370 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5371 the type of map plotted. This is either one of the PLplot built-in\n\
5372 maps or the file name of a set of Shapefile files without the file\n\
5373 extensions. For the PLplot built-in maps the possible values are:\n\
5374 \"globe\" -- continental outlines\n\
5375 \"usa\" -- USA and state boundaries\n\
5376 \"cglobe\" -- continental outlines and countries\n\
5377 \"usaglobe\" -- USA, state boundaries and continental outlines\n\
5380 minx (PLFLT, input) : The minimum x value of map elements to be\n\
5381 drawn. The units must match the shapefile (built in maps are\n\
5382 degrees lat/lon). Objects in the file which do not encroach on the\n\
5383 box defined by minx, maxx, miny, maxy will not be rendered. But\n\
5384 note this is simply an optimisation, not a clipping so for objects\n\
5385 with some points inside the box and some points outside the box\n\
5386 all the points will be rendered. These parameters also define\n\
5387 latitude and longitude wrapping for shapefiles using these units.\n\
5388 Longitude points will be wrapped by integer multiples of 360\n\
5389 degrees to place them in the box. This allows the same data to be\n\
5390 used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
5391 you plot from -180-540 you will get two cycles of data drawn. The\n\
5392 value of minx must be less than the value of maxx. Passing in a\n\
5393 nan, max/-max floating point number or +/-infinity will case the\n\
5394 bounding box from the shapefile to be used.\n\
5396 maxx (PLFLT, input) : The maximum x value of map elements to be\n\
5397 drawn - see minx.\n\
5399 miny (PLFLT, input) : The minimum y value of map elements to be\n\
5400 drawn - see minx.\n\
5402 maxy (PLFLT, input) : The maximum y value of map elements to be\n\
5403 drawn - see minx.\n\
5406Specify viewport using coordinates and aspect ratio\n\
5410 Device-independent routine for setting up the viewport. The viewport\n\
5411 is chosen to be the largest with the given aspect ratio that fits\n\
5412 within the specified region (in terms of normalized subpage\n\
5413 coordinates). This routine is functionally equivalent to plvpor when\n\
5414 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
5415 routine reserves no extra space at the edges for labels.\n\
5417 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5419 This function is used in example 9.\n\
5425plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5429 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5430 left-hand edge of the viewport.\n\
5432 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5433 right-hand edge of the viewport.\n\
5435 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5436 bottom edge of the viewport.\n\
5438 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5439 edge of the viewport.\n\
5441 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
5445Set the pause (on end-of-page) status\n\
5449 Set the pause (on end-of-page) status.\n\
5451 Redacted form: plspause(pause)\n\
5453 This function is in examples 14,20.\n\
5463 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
5464 end-of-page for those drivers which support this. Otherwise there\n\
5468Plot 3-d surface plot\n\
5472 Plots a three-dimensional surface plot within the environment set up\n\
5473 by plw3d. The surface is defined by the matrix z[\n\
5475 ny] , the point z[i][j] being the value of the function at (\n\
5477 y[j]). Note that the points in vectors x and y do not need to be\n\
5478 equally spaced, but must be stored in ascending order. The parameter\n\
5479 opt controls the way in which the surface is displayed. For further\n\
5480 details see the PLplot documentation. The only difference between\n\
5481 plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5482 while plot3d only draws the surface as viewed from the top.\n\
5484 Redacted form: plot3d(x, y, z, opt, side)\n\
5486 This function is used in examples 11 and 21.\n\
5492plot3d(x, y, z, nx, ny, opt, side)\n\
5496 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5497 which the function is evaluated.\n\
5499 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5500 which the function is evaluated.\n\
5502 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5503 plot. Should have dimensions of\n\
5507 nx (PLINT, input) : Number of x values at which function is\n\
5510 ny (PLINT, input) : Number of y values at which function is\n\
5513 opt (PLINT, input) : Determines the way in which the surface is\n\
5514 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5515 function of x for each value of y[j] .\n\
5516 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5517 for each value of x[i] .\n\
5518 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5519 at which function is defined.\n\
5522 side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5523 should be draw on the figure. If side is true sides are drawn,\n\
5524 otherwise no sides are drawn.\n\
5527Copy state parameters from the reference stream to the current stream\n\
5531 Copies state parameters from the reference stream to the current\n\
5532 stream. Tell driver interface to map device coordinates unless flags\n\
5535 This function is used for making save files of selected plots (e.g.\n\
5536 from the TK driver). After initializing, you can get a copy of the\n\
5537 current plot to the specified device by switching to this stream and\n\
5538 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
5539 appropriate. The plot buffer must have previously been enabled (done\n\
5540 automatically by some display drivers, such as X).\n\
5542 Redacted form: plcpstrm(iplsr, flags)\n\
5544 This function is used in example 1,20.\n\
5550plcpstrm(iplsr, flags)\n\
5554 iplsr (PLINT, input) : Number of reference stream.\n\
5556 flags (PLBOOL, input) : If flags is set to true the device\n\
5557 coordinates are not copied from the reference to current stream.\n\
5560Set page parameters\n\
5564 Sets the page configuration (optional). If an individual parameter is\n\
5565 zero then that parameter value is not updated. Not all parameters are\n\
5566 recognized by all drivers and the interpretation is device-dependent.\n\
5567 The X-window driver uses the length and offset parameters to determine\n\
5568 the window size and location. The length and offset values are\n\
5569 expressed in units that are specific to the current driver. For\n\
5570 instance: screen drivers will usually interpret them as number of\n\
5571 pixels, whereas printer drivers will usually use mm.\n\
5573 This routine, if used, must be called before initializing PLplot. It\n\
5574 may be called at later times for interactive drivers to change only\n\
5575 the dpi for subsequent redraws which you can force via a call to\n\
5576 plreplot. If this function is not called then the page size defaults\n\
5577 to landscape A4 for drivers which use real world page sizes and 744\n\
5578 pixels wide by 538 pixels high for raster drivers. The default value\n\
5579 for dx and dy is 90 pixels per inch for raster drivers.\n\
5583 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5585 This function is used in examples 14 and 31.\n\
5591plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5595 xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
5596 by raster drivers, ignored by drivers which use \"real world\" units\n\
5599 yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
5600 by raster drivers, ignored by drivers which use \"real world\" units\n\
5603 xleng (PLINT, input) : Page length, x.\n\
5605 yleng (PLINT, input) : Page length, y.\n\
5607 xoff (PLINT, input) : Page offset, x.\n\
5609 yoff (PLINT, input) : Page offset, y.\n\
5612Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
5616 Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
5617 (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
5618 Values are negative if an invalid color id is given.\n\
5620 Redacted form: plgcola(r, g, b)\n\
5622 This function is used in example 30.\n\
5628plgcol0a(icol0, r, g, b, alpha)\n\
5632 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5634 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
5635 in the range from 0 to 255.\n\
5637 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
5638 in the range from 0 to 255.\n\
5640 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
5641 in the range from 0 to 255.\n\
5643 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
5644 transparency in the range from (0.0-1.0).\n\
5647Returns 8-bit RGB values for given color index from cmap0\n\
5651 Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
5652 PLplot documentation). Values are negative if an invalid color id is\n\
5655 Redacted form: plgcol0(icol0, r, g, b)\n\
5657 This function is used in example 2.\n\
5663plgcol0(icol0, r, g, b)\n\
5667 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5669 r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
5672 g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
5675 b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
5679Set parameters incrementally (zoom mode) that define current plot-space window\n\
5683 Set relative minima and maxima incrementally (zoom mode) that define\n\
5684 the current plot-space window. This function has the same effect as\n\
5685 plsdiplt if that function has not been previously called. Otherwise,\n\
5686 this function implements zoom mode using the transformation min_used =\n\
5687 old_min + old_length*min and max_used = old_min + old_length*max for\n\
5688 each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
5689 repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
5691 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
5693 This function is used in example 31.\n\
5699plsdiplz(xmin, ymin, xmax, ymax)\n\
5703 xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
5705 ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
5707 xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
5709 ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
5712Plot all or a subset of Shapefile data, filling the polygons\n\
5716 As per plmapline, however the items are filled in the same way as\n\
5719 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
5722 This function is used in example 19.\n\
5728plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
5732 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5733 transform the coordinates given in the shapefile into a plot\n\
5734 coordinate system. By using this transform, we can change from a\n\
5735 longitude, latitude coordinate to a polar stereographic project,\n\
5736 for example. Initially, x[0]..[n-1] are the longitudes and\n\
5737 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
5738 mapform(), x[] and y[] should be replaced by the corresponding\n\
5739 plot coordinates. If no transform is desired, mapform can be\n\
5740 replaced by NULL.\n\
5742 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5743 the file name of a set of Shapefile files without the file\n\
5746 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
5747 be in the same units as used by the Shapefile. You could use a\n\
5748 very large negative number to plot everything, but you can improve\n\
5749 performance by limiting the area drawn. The units must match those\n\
5750 of the Shapefile projection, which may be for example longitude or\n\
5751 distance. The value of minx must be less than the value of maxx.\n\
5753 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
5754 use a very large number to plot everything, but you can improve\n\
5755 performance by limiting the area drawn.\n\
5757 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
5758 be in the same units as used by the Shapefile. You could use a\n\
5759 very large negative number to plot everything, but you can improve\n\
5760 performance by limiting the area drawn. The units must match those\n\
5761 of the Shapefile projection, which may be for example latitude or\n\
5762 distance. The value of miny must be less than the value of maxy.\n\
5764 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
5765 use a very large number to plot everything, but you can improve\n\
5766 performance by limiting the area drawn.\n\
5768 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
5769 zero-based indices of the Shapefile elements which will be drawn.\n\
5771 plotentries to NULL will plot all elements of the Shapefile.\n\
5773 nplotentries (PLINT, input) : The number of items in\n\
5774 plotentries. Ignored if\n\
5775 plotentries is NULL.\n\
5782 Draws line defined by n points in x and y.\n\
5784 Redacted form: plline(x, y)\n\
5786 This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
5797 n (PLINT, input) : Number of points defining line.\n\
5799 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5802 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5806Get viewport limits in world coordinates\n\
5810 Get viewport limits in world coordinates.\n\
5812 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5815 This function is used in example 31.\n\
5821plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5825 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5826 viewport limit of the world coordinate in x.\n\
5828 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5829 viewport limit of the world coordinate in x.\n\
5831 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5832 viewport limit of the world coordinate in y.\n\
5834 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5835 viewport limit of the world coordinate in y.\n\
5838Set area line fill pattern\n\
5842 Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
5843 The pattern consists of 1 or 2 sets of parallel lines with specified\n\
5844 inclinations and spacings. The arguments to this routine are the\n\
5845 number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
5846 elements) specifying the inclinations in tenths of a degree and the\n\
5847 spacing in micrometers. (See also plpsty)\n\
5849 Redacted form: General: plpat(inc, del)\n\
5852 This function is used in example 15.\n\
5858plpat(nlin, inc, del)\n\
5862 nlin (PLINT, input) : Number of sets of lines making up the\n\
5863 pattern, either 1 or 2.\n\
5865 inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5866 inclination in tenths of a degree. (Should be between -900 and\n\
5869 del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5870 spacing in micrometers between the lines making up the pattern.\n\
5873Set x axis parameters\n\
5877 Sets values of the digmax and digits flags for the x axis. See the\n\
5878 PLplot documentation for more information.\n\
5880 Redacted form: plsxax(digmax, digits)\n\
5882 This function is used in example 31.\n\
5888plsxax(digmax, digits)\n\
5892 digmax (PLINT, input) : Variable to set the maximum number of\n\
5893 digits for the x axis. If nonzero, the printed label will be\n\
5894 switched to a floating-point representation when the number of\n\
5895 digits exceeds digmax.\n\
5897 digits (PLINT, input) : Field digits value. Currently, changing\n\
5898 its value here has no effect since it is set only by plbox or\n\
5899 plbox3. However, the user may obtain its value after a call to\n\
5900 either of these functions by calling plgxax.\n\
5903Get family file parameters\n\
5907 Gets information about current family file, if familying is enabled.\n\
5908 See the PLplot documentation for more information.\n\
5910 Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5912 This function is used in examples 14 and 31.\n\
5918plgfam(p_fam, p_num, p_bmax)\n\
5922 p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5923 family flag value. If nonzero, familying is enabled for the\n\
5926 p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5927 family file number.\n\
5929 p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5930 file size (in bytes) for a family file.\n\
5933Get y axis parameters\n\
5937 Identical to plgxax, except that arguments are flags for y axis. See\n\
5938 the description of plgxax for more detail.\n\
5940 Redacted form: plgyax(p_digmax, p_digits)\n\
5942 This function is used in example 31.\n\
5948plgyax(p_digmax, p_digits)\n\
5952 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5953 number of digits for the y axis. If nonzero, the printed label\n\
5954 has been switched to a floating-point representation when the\n\
5955 number of digits exceeds this value.\n\
5957 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
5958 number of digits for the numeric labels (y axis) from the last\n\
5962Plot a glyph at the specified points\n\
5966 Plot a glyph at the specified points. (This function is largely\n\
5967 superseded by plstring which gives access to many[!] more glyphs.)\n\
5968 code=-1 means try to just draw a point. Right now it\'s just a move\n\
5969 and a draw at the same place. Not ideal, since a sufficiently\n\
5970 intelligent output device may optimize it away, or there may be faster\n\
5971 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
5972 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
5973 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
5974 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
5975 code <= 127 the corresponding printable ASCII character is plotted.\n\
5977 Redacted form: plpoin(x, y, code)\n\
5979 This function is used in examples 1, 6, 14, and 29.\n\
5985plpoin(n, x, y, code)\n\
5989 n (PLINT, input) : Number of points in the x and y vectors.\n\
5991 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5994 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5997 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
5998 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
5999 each of the n points.\n\
6002Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
6006 As per plmapline, however the items are plotted as strings or points\n\
6007 in the same way as plstring.\n\
6009 Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
6010 maxy, plotentries)\n\
6012 This function is not used in any examples.\n\
6018plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6022 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6023 transform the coordinates given in the shapefile into a plot\n\
6024 coordinate system. By using this transform, we can change from a\n\
6025 longitude, latitude coordinate to a polar stereographic project,\n\
6026 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6027 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6028 mapform(), x[] and y[] should be replaced by the corresponding\n\
6029 plot coordinates. If no transform is desired, mapform can be\n\
6030 replaced by NULL.\n\
6032 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6033 the file name of a set of Shapefile files without the file\n\
6036 string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
6039 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6040 be in the same units as used by the Shapefile. You could use a\n\
6041 very large negative number to plot everything, but you can improve\n\
6042 performance by limiting the area drawn. The units must match those\n\
6043 of the Shapefile projection, which may be for example longitude or\n\
6044 distance. The value of minx must be less than the value of maxx.\n\
6046 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6047 use a very large number to plot everything, but you can improve\n\
6048 performance by limiting the area drawn.\n\
6050 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6051 be in the same units as used by the Shapefile. You could use a\n\
6052 very large negative number to plot everything, but you can improve\n\
6053 performance by limiting the area drawn. The units must match those\n\
6054 of the Shapefile projection, which may be for example latitude or\n\
6055 distance. The value of miny must be less than the value of maxy.\n\
6057 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6058 use a very large number to plot everything, but you can improve\n\
6059 performance by limiting the area drawn.\n\
6061 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6062 zero-based indices of the Shapefile elements which will be drawn.\n\
6064 plotentries to NULL will plot all elements of the Shapefile.\n\
6066 nplotentries (PLINT, input) : The number of items in\n\
6067 plotentries. Ignored if\n\
6068 plotentries is NULL.\n\
6071Select area fill pattern\n\
6076 patt is zero or less use either a hardware solid fill if the drivers\n\
6077 have that capability (virtually all do) or fall back to a software\n\
6078 emulation of a solid fill using the eighth area line fill pattern. If\n\
6080 patt <= 8, then select one of eight predefined area line fill patterns\n\
6081 to use (see plpat if you desire other patterns).\n\
6083 Redacted form: plpsty(patt)\n\
6085 This function is used in examples 12, 13, 15, 16, and 25.\n\
6095 patt (PLINT, input) : The desired pattern index. If\n\
6096 patt is zero or less, then a solid fill is (normally, see qualifiers\n\
6098 patt in the range from 1 to 8 and assuming the driver has not supplied\n\
6099 line fill capability itself (most deliberately do not so that line\n\
6100 fill patterns look identical for those drivers), the patterns\n\
6101 consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
6102 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
6103 lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
6104 (8) lines at both 45 degrees and -45 degrees.\n\
6107Set 8-bit RGB values for given cmap0 color index\n\
6111 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
6112 index. Overwrites the previous color value for the given index and,\n\
6113 thus, does not result in any additional allocation of space for\n\
6116 Redacted form: plscol0(icol0, r, g, b)\n\
6118 This function is used in any example 31.\n\
6124plscol0(icol0, r, g, b)\n\
6128 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
6129 number of colors (which is set by default, by plscmap0n, or even\n\
6132 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6133 degree of red in the color.\n\
6135 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6136 degree of green in the color.\n\
6138 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6139 degree of blue in the color.\n\
6142Used to globally turn color output on/off\n\
6146 Used to globally turn color output on/off for those drivers/devices\n\
6149 Redacted form: plscolor(color)\n\
6151 This function is used in example 31.\n\
6161 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6162 turned off. If non-zero, color is turned on.\n\
6165End plotting session\n\
6169 Ends a plotting session, tidies up all the output files, switches\n\
6170 interactive devices back into text mode and frees up any memory that\n\
6171 was allocated. Must be called before end of program.\n\
6173 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
6174 wait state after a call to plend or other functions which trigger the\n\
6175 end of a plot page. To avoid this, use the plspause function.\n\
6177 Redacted form: plend()\n\
6179 This function is used in all of the examples.\n\
6188Plot a histogram from binned data\n\
6192 Plots a histogram consisting of nbin bins. The value associated with\n\
6193 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
6194 placed in y[i]. For proper operation, the values in x[i] must form a\n\
6195 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
6196 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
6197 placed midway between the values in the x vector. Also see plhist for\n\
6198 drawing histograms from unbinned data.\n\
6200 Redacted form: General: plbin(x, y, opt)\n\
6201 Python: plbin(nbin, x, y, opt)\n\
6204 This function is not used in any examples.\n\
6210plbin(nbin, x, y, opt)\n\
6214 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
6217 x (PLFLT_VECTOR, input) : A vector containing values associated\n\
6218 with bins. These must form a strictly increasing sequence.\n\
6220 y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
6221 proportional to the number of points in each bin. This is a PLFLT\n\
6222 (instead of PLINT) vector so as to allow histograms of\n\
6223 probabilities, etc.\n\
6225 opt (PLINT, input) : Is a combination of several flags:\n\
6226 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
6227 outer bins are expanded to fill up the entire x-axis and bins of\n\
6228 zero height are simply drawn.\n\
6229 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
6230 between the x values. If the values in x are equally spaced,\n\
6231 the values are the center values of the bins.\n\
6232 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
6233 size as the ones inside.\n\
6234 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
6235 (there is a gap for such bins).\n\
6238Plot a 2D matrix using cmap1\n\
6242 Plot a 2D matrix using cmap1.\n\
6244 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
6245 zmax, valuemin, valuemax, pltr, pltr_data)\n\
6248 This function is used in example 20.\n\
6254plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
6258 idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
6259 plot. Should have dimensions of\n\
6263 nx, ny (PLINT, input) : Dimensions of idata\n\
6265 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
6266 pltr below for how these arguments are used (only for the special case\n\
6267 when the callback function\n\
6268 pltr is not supplied).\n\
6270 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
6271 (inclusive) will be plotted.\n\
6273 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
6274 values to use for value to color mappings. A datum equal to or\n\
6275 less than valuemin will be plotted with color 0.0, while a datum\n\
6276 equal to or greater than valuemax will be plotted with color 1.0.\n\
6277 Data between valuemin and valuemax map linearly to colors in the\n\
6280 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
6281 defines the transformation between the zero-based indices of the\n\
6282 matrix idata and world coordinates. If\n\
6283 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
6284 indices of idata are mapped to the range\n\
6286 xmax and the y indices of idata are mapped to the range\n\
6288 ymax.For the C case, transformation functions are provided in the\n\
6289 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
6290 pltr2 for arbitrary mappings respectively defined by vectors and\n\
6291 matrices. In addition, C callback routines for the transformation\n\
6292 can be supplied by the user such as the mypltr function in\n\
6293 examples/c/x09c.c which provides a general linear transformation\n\
6294 between index coordinates and world coordinates.For languages\n\
6295 other than C you should consult the PLplot documentation for the\n\
6296 details concerning how PLTRANSFORM_callback arguments are\n\
6297 interfaced. However, in general, a particular pattern of\n\
6298 callback-associated arguments such as a tr vector with 6 elements;\n\
6299 xg and yg vectors; or xg and yg matrices are respectively\n\
6300 interfaced to a linear-transformation routine similar to the above\n\
6301 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
6302 sophisticated bindings (see, e.g., the PLplot documentation)\n\
6303 support native language callbacks for handling index to\n\
6304 world-coordinate transformations. Examples of these various\n\
6305 approaches are given in examples/<language>x09*,\n\
6306 examples/<language>x16*, examples/<language>x20*,\n\
6307 examples/<language>x21*, and examples/<language>x22*, for all our\n\
6308 supported languages.\n\
6310 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
6311 information to pltr0, pltr1, pltr2, or whatever routine is\n\
6312 externally supplied.\n\
6315Sets the 3D position of the light source\n\
6319 Sets the 3D position of the light source for use with plsurf3d and\n\
6322 Redacted form: pllightsource(x, y, z)\n\
6324 This function is used in example 8.\n\
6330pllightsource(x, y, z)\n\
6334 x (PLFLT, input) : X-coordinate of the light source.\n\
6336 y (PLFLT, input) : Y-coordinate of the light source.\n\
6338 z (PLFLT, input) : Z-coordinate of the light source.\n\
6341Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
6345 When the implementation is completed this variant of plot3dc (see that\n\
6346 function\'s documentation for more details) should be suitable for the\n\
6347 case where the area of the x, y coordinate grid where z is defined can\n\
6348 be non-rectangular. The implementation is incomplete so the last 4\n\
6349 parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
6350 indexymax; are currently ignored and the functionality is otherwise\n\
6351 identical to that of plot3dc.\n\
6353 Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
6354 indexymin, indexymax)\n\
6357 This function is not used in any example.\n\
6363plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
6367 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
6368 which the function is evaluated.\n\
6370 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
6371 which the function is evaluated.\n\
6373 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
6374 plot. Should have dimensions of\n\
6378 nx (PLINT, input) : Number of x values at which the function is\n\
6381 ny (PLINT, input) : Number of y values at which the function is\n\
6384 opt (PLINT, input) : Determines the way in which the surface is\n\
6385 represented. To specify more than one option just add the options,\n\
6386 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
6387 showing z as a function of x for each value of y[j] .\n\
6388 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
6389 for each value of x[i] .\n\
6390 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
6391 at which function is defined.\n\
6392 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
6393 the z value being plotted. The color is used from the current\n\
6395 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
6399 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
6400 the borders of the plotted function.\n\
6403 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
6406 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
6408 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
6409 corresponds to the first x index where z is defined.\n\
6411 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
6412 which corresponds (by convention) to one more than the last x\n\
6413 index value where z is defined.\n\
6415 indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
6416 values which all must be ≥ 0. These values are the first y index\n\
6417 where z is defined for a particular x index in the range from\n\
6418 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
6421 indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
6422 values which all must be ≤ ny. These values correspond (by\n\
6423 convention) to one more than the last y index where z is defined\n\
6424 for a particular x index in the range from indexxmin to indexxmax\n\
6425 - 1. The dimension of indexymax is indexxmax.\n\
6428Creates a new stream and makes it the default\n\
6432 Creates a new stream and makes it the default. Differs from using\n\
6433 plsstrm, in that a free stream number is found, and returned.\n\
6434 Unfortunately, I have to start at stream 1 and work upward, since\n\
6435 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
6436 that no initial, library-opening call is required. So stream 0 must\n\
6437 be preallocated, and there is no simple way of determining whether it\n\
6438 is already in use or not.\n\
6440 Redacted form: plmkstrm(p_strm)\n\
6442 This function is used in examples 1 and 20.\n\
6452 p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
6453 number of the created stream.\n\
6456Set FCI (font characterization integer)\n\
6460 Sets font characteristics to be used at the start of the next string\n\
6461 using the FCI approach. See the PLplot documentation for more\n\
6462 information. Note, plsfont (which calls plsfci internally) provides a\n\
6463 more user-friendly API for setting the font characterisitics.\n\
6465 Redacted form: General: plsfci(fci)\n\
6468 This function is used in example 23.\n\
6478 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
6486 Initializing the plotting package. The program prompts for the device\n\
6487 keyword or number of the desired output device. Hitting a RETURN in\n\
6488 response to the prompt is the same as selecting the first device.\n\
6489 plinit will issue no prompt if either the device was specified\n\
6490 previously (via command line flag, the plsetopt function, or the\n\
6491 plsdev function), or if only one device is enabled when PLplot is\n\
6492 installed. If subpages have been specified, the output device is\n\
6493 divided into nx by ny subpages, each of which may be used\n\
6494 independently. If plinit is called again during a program, the\n\
6495 previously opened file will be closed. The subroutine pladv is used\n\
6496 to advance from one subpage to the next.\n\
6498 Redacted form: plinit()\n\
6500 This function is used in all of the examples.\n\
6513 This sets up the line style for all lines subsequently drawn. A line\n\
6514 consists of segments in which the pen is alternately down and up. The\n\
6515 lengths of these segments are passed in the vectors mark and space\n\
6516 respectively. The number of mark-space pairs is specified by nms. In\n\
6517 order to return the line style to the default continuous line, plstyl\n\
6518 should be called with nms =0 .(see also pllsty)\n\
6520 Redacted form: plstyl(mark, space)\n\
6522 This function is used in examples 1, 9, and 14.\n\
6528plstyl(nms, mark, space)\n\
6532 nms (PLINT, input) : The number of mark and space elements in a\n\
6533 line. Thus a simple broken line can be obtained by setting nms=1\n\
6534 . A continuous line is specified by setting nms=0 .\n\
6536 mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
6537 segments during which the pen is down, measured in micrometers.\n\
6539 space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
6540 the segments during which the pen is up, measured in micrometers.\n\
6543Set length of minor ticks\n\
6547 This sets up the length of the minor ticks and the length of the\n\
6548 terminals on error bars. The actual length is the product of the\n\
6549 default length and a scaling factor as for character height.\n\
6551 Redacted form: plsmin(def, scale)\n\
6553 This function is used in example 29.\n\
6559plsmin(def, scale)\n\
6563 def (PLFLT, input) : The default length of a minor tick in\n\
6564 millimeters, should be set to zero if the default length is to\n\
6565 remain unchanged.\n\
6567 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6568 actual tick length.\n\
6571Draw a box with axes, etc, in 3-d\n\
6575 Draws axes, numeric and text labels for a three-dimensional surface\n\
6576 plot. For a more complete description of three-dimensional plotting\n\
6577 see the PLplot documentation.\n\
6579 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
6580 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6583 This function is used in examples 8, 11, 18, and 21.\n\
6589plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6593 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6594 options for the x axis. The string can include any combination of\n\
6595 the following letters (upper or lower case) in any order: b: Draws\n\
6596 axis at base, at height z=\n\
6597 zmin where zmin is defined by call to plw3d. This character must be\n\
6598 specified in order to use any of the other options.\n\
6599 d: Plot labels as date / time. Values are assumed to be\n\
6600 seconds since the epoch (as used by gmtime).\n\
6601 f: Always use fixed point numeric labels.\n\
6602 i: Inverts tick marks, so they are drawn downwards, rather\n\
6604 l: Labels axis logarithmically. This only affects the labels,\n\
6605 not the data, and so it is necessary to compute the logarithms\n\
6606 of data points before passing them to any of the drawing\n\
6608 n: Writes numeric labels at major tick intervals.\n\
6609 o: Use custom labelling function to generate axis label text.\n\
6610 The custom labelling function can be defined with the\n\
6611 plslabelfunc command.\n\
6612 s: Enables subticks between major ticks, only valid if t is\n\
6614 t: Draws major ticks.\n\
6615 u: If this is specified, the text label for the axis is\n\
6616 written under the axis.\n\
6619 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6620 the text label for the x axis. It is only drawn if u is in the\n\
6623 xtick (PLFLT, input) : World coordinate interval between major\n\
6624 ticks on the x axis. If it is set to zero, PLplot automatically\n\
6625 generates a suitable tick interval.\n\
6627 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
6628 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6629 generates a suitable minor tick interval.\n\
6631 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6632 options for the y axis. The string is interpreted in the same way\n\
6635 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6636 the text label for the y axis. It is only drawn if u is in the\n\
6639 ytick (PLFLT, input) : World coordinate interval between major\n\
6640 ticks on the y axis. If it is set to zero, PLplot automatically\n\
6641 generates a suitable tick interval.\n\
6643 nysub (PLINT, input) : Number of subintervals between major y axis\n\
6644 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6645 generates a suitable minor tick interval.\n\
6647 zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6648 options for the z axis. The string can include any combination of\n\
6649 the following letters (upper or lower case) in any order: b: Draws\n\
6650 z axis to the left of the surface plot.\n\
6651 c: Draws z axis to the right of the surface plot.\n\
6652 d: Draws grid lines parallel to the x-y plane behind the\n\
6653 figure. These lines are not drawn until after plot3d or\n\
6654 plmesh are called because of the need for hidden line removal.\n\
6655 e: Plot labels as date / time. Values are assumed to be\n\
6656 seconds since the epoch (as used by gmtime). Note this\n\
6657 suboption is interpreted the same as the d suboption for xopt\n\
6658 and yopt, but it has to be identified as e for zopt since d\n\
6659 has already been used for the different purpose above.\n\
6660 f: Always use fixed point numeric labels.\n\
6661 i: Inverts tick marks, so they are drawn away from the center.\n\
6662 l: Labels axis logarithmically. This only affects the labels,\n\
6663 not the data, and so it is necessary to compute the logarithms\n\
6664 of data points before passing them to any of the drawing\n\
6666 m: Writes numeric labels at major tick intervals on the\n\
6667 right-hand z axis.\n\
6668 n: Writes numeric labels at major tick intervals on the\n\
6669 left-hand z axis.\n\
6670 o: Use custom labelling function to generate axis label text.\n\
6671 The custom labelling function can be defined with the\n\
6672 plslabelfunc command.\n\
6673 s: Enables subticks between major ticks, only valid if t is\n\
6675 t: Draws major ticks.\n\
6676 u: If this is specified, the text label is written beside the\n\
6678 v: If this is specified, the text label is written beside the\n\
6682 zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6683 the text label for the z axis. It is only drawn if u or v are in\n\
6686 ztick (PLFLT, input) : World coordinate interval between major\n\
6687 ticks on the z axis. If it is set to zero, PLplot automatically\n\
6688 generates a suitable tick interval.\n\
6690 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
6691 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6692 generates a suitable minor tick interval.\n\
6695Set character size\n\
6699 This sets up the size of all subsequent characters drawn. The actual\n\
6700 height of a character is the product of the default character size and\n\
6701 a scaling factor.\n\
6703 Redacted form: plschr(def, scale)\n\
6705 This function is used in examples 2, 13, 23, and 24.\n\
6711plschr(def, scale)\n\
6715 def (PLFLT, input) : The default height of a character in\n\
6716 millimeters, should be set to zero if the default height is to\n\
6717 remain unchanged. For rasterized drivers the dx and dy values\n\
6718 specified in plspage are used to convert from mm to pixels (note\n\
6719 the different unit systems used). This dpi aware scaling is not\n\
6720 implemented for all drivers yet.\n\
6722 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6723 actual character height.\n\
6726Calculate continuous time from broken-down time for the current stream\n\
6730 Calculate continuous time, ctime, from broken-down time for the\n\
6731 current stream. The broken-down\n\
6732 time is specified by the following parameters: year, month, day, hour,\n\
6733 min, and sec. This function is the inverse of plbtime.\n\
6735 The PLplot definition of broken-down time is a calendar time that\n\
6736 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6737 responsibility to apply those offsets (if so desired) before using the\n\
6738 PLplot time API. By default broken-down time is defined using the\n\
6739 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6740 continuous time is defined as the number of seconds since the Unix\n\
6741 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6742 broken-down and continuous time are possible, see plconfigtime which\n\
6743 specifies that transformation for the current stream.\n\
6745 Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6749 This function is used in example 29.\n\
6755plctime(year, month, day, hour, min, sec, ctime)\n\
6759 year (PLINT, input) : Input year.\n\
6761 month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6764 day (PLINT, input) : Input day in range from 1 to 31.\n\
6766 hour (PLINT, input) : Input hour in range from 0 to 23\n\
6768 min (PLINT, input) : Input minute in range from 0 to 59.\n\
6770 sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6772 ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6773 time calculated from the broken-down time specified by the\n\
6774 previous parameters.\n\
6781 Sets the color index for cmap0 (see the PLplot documentation).\n\
6783 Redacted form: plcol0(icol0)\n\
6785 This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6795 icol0 (PLINT, input) : Integer representing the color. The\n\
6796 defaults at present are (these may change):\n\
6797 0 black (default background)\n\
6798 1 red (default foreground)\n\
6814 Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6815 change an individual color in the cmap0 color palette.\n\
6822 Sets the color for cmap1 (see the PLplot documentation).\n\
6824 Redacted form: plcol1(col1)\n\
6826 This function is used in examples 12 and 21.\n\
6836 col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6837 is mapped to color using the continuous cmap1 palette which by\n\
6838 default ranges from blue to the background color to red. The\n\
6839 cmap1 palette can also be straightforwardly changed by the user\n\
6840 with plscmap1 or plscmap1l.\n\
6843Returns the background color (cmap0[0]) by 8-bit RGB value\n\
6847 Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
6849 Redacted form: plgcolbg(r, g, b)\n\
6851 This function is used in example 31.\n\
6861 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
6862 in the range from 0 to 255.\n\
6864 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
6865 in the range from 0 to 255.\n\
6867 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
6868 in the range from 0 to 255.\n\
6871Draw a circular or elliptical arc\n\
6875 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
6876 semiminor axis b, starting at angle1 and ending at angle2.\n\
6878 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
6882 This function is used in examples 3 and 27.\n\
6888plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
6892 x (PLFLT, input) : X coordinate of arc center.\n\
6894 y (PLFLT, input) : Y coordinate of arc center.\n\
6896 a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
6898 b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
6900 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
6903 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
6906 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
6909 fill (PLBOOL, input) : Draw a filled arc.\n\
6912Parse command-line arguments\n\
6916 Parse command-line arguments.\n\
6918 plparseopts removes all recognized flags (decreasing argc\n\
6919 accordingly), so that invalid input may be readily detected. It can\n\
6920 also be used to process user command line flags. The user can merge\n\
6921 an option table of type PLOptionTable into the internal option table\n\
6922 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
6923 the external table(s) be parsed by calling plClearOpts before\n\
6926 The default action taken by plparseopts is as follows:\n\
6927 Returns with an error if an unrecognized option or badly formed\n\
6928 option-value pair are encountered.\n\
6929 Returns immediately (return code 0) when the first non-option command\n\
6930 line argument is found.\n\
6931 Returns with the return code of the option handler, if one was called.\n\
6933 Deletes command line arguments from argv list as they are found, and\n\
6934 decrements argc accordingly.\n\
6935 Does not show \"invisible\" options in usage or help messages.\n\
6936 Assumes the program name is contained in argv[0].\n\
6938 These behaviors may be controlled through the\n\
6941 Redacted form: General: plparseopts(argv, mode)\n\
6944 This function is used in all of the examples.\n\
6950PLINT plparseopts(p_argc, argv, mode)\n\
6954 p_argc (int *, input/output) : Number of arguments.\n\
6956 argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
6957 strings containing *p_argc command-line arguments.\n\
6959 mode (PLINT, input) : Parsing mode with the following\n\
6960 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
6961 and all error messages enabled, including program exit when an\n\
6962 error occurs. Anything on the command line that isn\'t recognized\n\
6963 as a valid option or option argument is flagged as an error.\n\
6964 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
6966 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
6968 PL_PARSE_SHOWALL (8) -- Show invisible options\n\
6969 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
6970 pointer to the program name.\n\
6971 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
6972 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
6973 unrecognized arguments.\n\
6976Get parameters that define current device-space window\n\
6980 Get relative margin width, aspect ratio, and relative justification\n\
6981 that define current device-space window. If plsdidev has not been\n\
6982 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
6983 p_jy will all be 0.\n\
6985 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
6987 This function is used in example 31.\n\
6993plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
6997 p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7000 p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
7003 p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7004 justification in x.\n\
7006 p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7007 justification in y.\n\
7010Assign a function to use for generating custom axis labels\n\
7014 This function allows a user to provide their own function to provide\n\
7015 axis label text. The user function is given the numeric value for a\n\
7016 point on an axis and returns a string label to correspond with that\n\
7017 value. Custom axis labels can be enabled by passing appropriate\n\
7018 arguments to plenv, plbox, plbox3 and similar functions.\n\
7020 This function is used in example 19.\n\
7026plslabelfunc(label_func, label_data)\n\
7030 label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
7031 label function. In order to reset to the default labelling, set\n\
7032 this to NULL. The labelling function parameters are, in order:\n\
7033 axis: This indicates which axis a label is being requested for.\n\
7034 The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
7036 value: This is the value along the axis which is being labelled.\n\
7038 label_text: The string representation of the label value.\n\
7040 length: The maximum length in characters allowed for label_text.\n\
7043 label_data (PLPointer, input) : This parameter may be used to pass\n\
7044 data to the label_func function.\n\
7047Get the (current) run level\n\
7051 Get the (current) run level. Valid settings are: 0, uninitialized\n\
7053 2, viewport defined\n\
7054 3, world coordinates defined\n\
7057 Redacted form: plglevel(p_level)\n\
7059 This function is used in example 31.\n\
7069 p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
7077 This sets the line style according to one of eight predefined patterns\n\
7078 (also see plstyl).\n\
7080 Redacted form: pllsty(lin)\n\
7082 This function is used in examples 9, 12, 22, and 25.\n\
7092 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
7093 a continuous line, line style 2 is a line with short dashes and\n\
7094 gaps, line style 3 is a line with long dashes and gaps, line style\n\
7095 4 has long dashes and short gaps and so on.\n\
7098Set up standard window and draw box\n\
7102 Sets up plotter environment for simple graphs by calling pladv and\n\
7103 setting up viewport and window to sensible default values. plenv\n\
7104 leaves a standard margin (left-hand margin of eight character heights,\n\
7105 and a margin around the other three sides of five character heights)\n\
7106 around most graphs for axis labels and a title. When these defaults\n\
7107 are not suitable, use the individual routines plvpas, plvpor, or\n\
7108 plvasp for setting up the viewport, plwind for defining the window,\n\
7109 and plbox for drawing the box.\n\
7111 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7113 This function is used in example 1,3,9,13,14,19-22,29.\n\
7119plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7123 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
7124 world coordinates).\n\
7126 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
7127 world coordinates).\n\
7129 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
7132 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
7135 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
7136 scales will not be set, the user must set up the scale before\n\
7137 calling plenv using plsvpa, plvasp or other.\n\
7138 0: the x and y axes are scaled independently to use as much of\n\
7139 the screen as possible.\n\
7140 1: the scales of the x and y axes are made equal.\n\
7141 2: the axis of the x and y axes are made equal, and the plot\n\
7142 box will be square.\n\
7145 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
7146 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
7147 -1: draw box only.\n\
7148 0: draw box, ticks, and numeric tick labels.\n\
7149 1: also draw coordinate axes at x=0 and y=0.\n\
7150 2: also draw a grid at major tick positions in both\n\
7152 3: also draw a grid at minor tick positions in both\n\
7154 10: same as 0 except logarithmic x tick marks. (The x data\n\
7155 have to be converted to logarithms separately.)\n\
7156 11: same as 1 except logarithmic x tick marks. (The x data\n\
7157 have to be converted to logarithms separately.)\n\
7158 12: same as 2 except logarithmic x tick marks. (The x data\n\
7159 have to be converted to logarithms separately.)\n\
7160 13: same as 3 except logarithmic x tick marks. (The x data\n\
7161 have to be converted to logarithms separately.)\n\
7162 20: same as 0 except logarithmic y tick marks. (The y data\n\
7163 have to be converted to logarithms separately.)\n\
7164 21: same as 1 except logarithmic y tick marks. (The y data\n\
7165 have to be converted to logarithms separately.)\n\
7166 22: same as 2 except logarithmic y tick marks. (The y data\n\
7167 have to be converted to logarithms separately.)\n\
7168 23: same as 3 except logarithmic y tick marks. (The y data\n\
7169 have to be converted to logarithms separately.)\n\
7170 30: same as 0 except logarithmic x and y tick marks. (The x\n\
7171 and y data have to be converted to logarithms separately.)\n\
7172 31: same as 1 except logarithmic x and y tick marks. (The x\n\
7173 and y data have to be converted to logarithms separately.)\n\
7174 32: same as 2 except logarithmic x and y tick marks. (The x\n\
7175 and y data have to be converted to logarithms separately.)\n\
7176 33: same as 3 except logarithmic x and y tick marks. (The x\n\
7177 and y data have to be converted to logarithms separately.)\n\
7178 40: same as 0 except date / time x labels.\n\
7179 41: same as 1 except date / time x labels.\n\
7180 42: same as 2 except date / time x labels.\n\
7181 43: same as 3 except date / time x labels.\n\
7182 50: same as 0 except date / time y labels.\n\
7183 51: same as 1 except date / time y labels.\n\
7184 52: same as 2 except date / time y labels.\n\
7185 53: same as 3 except date / time y labels.\n\
7186 60: same as 0 except date / time x and y labels.\n\
7187 61: same as 1 except date / time x and y labels.\n\
7188 62: same as 2 except date / time x and y labels.\n\
7189 63: same as 3 except date / time x and y labels.\n\
7190 70: same as 0 except custom x and y labels.\n\
7191 71: same as 1 except custom x and y labels.\n\
7192 72: same as 2 except custom x and y labels.\n\
7193 73: same as 3 except custom x and y labels.\n\
7200 Alternative to plstar for initializing the plotting package. The\n\
7201 device name keyword for the desired output device must be supplied as\n\
7202 an argument. These keywords are the same as those printed out by\n\
7203 plstar. If the requested device is not available, or if the input\n\
7204 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
7205 is used. This routine also divides the output device page into nx by\n\
7206 ny subpages, each of which may be used independently. The subroutine\n\
7207 pladv is used to advance from one subpage to the next.\n\
7209 Redacted form: General: plstart(devname, nx, ny)\n\
7212 This function is not used in any examples.\n\
7218plstart(devname, nx, ny)\n\
7222 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7223 containing the device name keyword of the required output device.\n\
7225 devname is NULL or if the first character of the string is a ``?\'\',\n\
7226 the normal (prompted) start up is used.\n\
7228 nx (PLINT, input) : Number of subpages to divide output page in the\n\
7231 ny (PLINT, input) : Number of subpages to divide output page in the\n\
7235Plot a glyph at the specified points\n\
7239 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
7240 because many[!] more glyphs are accessible with plstring.) The glyph\n\
7241 is specified with a PLplot user string. Note that the user string is\n\
7242 not actually limited to one glyph so it is possible (but not normally\n\
7243 useful) to plot more than one glyph at the specified points with this\n\
7244 function. As with plmtex and plptex, the user string can contain FCI\n\
7245 escapes to determine the font, UTF-8 code to determine the glyph or\n\
7246 else PLplot escapes for Hershey or unicode text to determine the\n\
7249 Redacted form: plstring(x, y, string)\n\
7251 This function is used in examples 4, 21 and 26.\n\
7257plstring(n, x, y, string)\n\
7261 n (PLINT, input) : Number of points in the x and y vectors.\n\
7263 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7266 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7269 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
7270 the glyph(s) to be plotted at each of the n points.\n\
7273Write text relative to viewport boundaries in 3D plots\n\
7277 Writes text at a specified position relative to the viewport\n\
7278 boundaries. Text may be written inside or outside the viewport, but\n\
7279 is clipped at the subpage boundaries. The reference point of a string\n\
7280 lies along a line passing through the string at half the height of a\n\
7281 capital letter. The position of the reference point along this line\n\
7282 is determined by just, and the position of the reference point\n\
7283 relative to the viewport is set by disp and pos.\n\
7285 Redacted form: plmtex3(side, disp, pos, just, text)\n\
7287 This function is used in example 28.\n\
7293plmtex3(side, disp, pos, just, text)\n\
7297 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7298 the side of the viewport along which the text is to be written.\n\
7299 The string should contain one or more of the following characters:\n\
7300 [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
7301 only label the X axis, not both the X and Y axes. x: Label the X\n\
7303 y: Label the Y axis.\n\
7304 z: Label the Z axis.\n\
7305 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
7306 For X it is the axis that starts at y-min. For Y it is the\n\
7307 axis that starts at x-min.\n\
7308 s: Label the secondary axis.\n\
7309 v: Draw the text perpendicular to the axis.\n\
7312 disp (PLFLT, input) : Position of the reference point of string,\n\
7313 measured outwards from the specified viewport edge in units of the\n\
7314 current character height. Use negative disp to write within the\n\
7317 pos (PLFLT, input) : Position of the reference point of string\n\
7318 along the specified edge, expressed as a fraction of the length of\n\
7321 just (PLFLT, input) : Specifies the position of the string relative\n\
7322 to its reference point. If just=0. , the reference point is at\n\
7323 the left and if just=1. , it is at the right of the string. Other\n\
7324 values of just give intermediate justifications.\n\
7326 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
7330Get plot orientation\n\
7334 Get plot orientation parameter which is multiplied by 90 degrees to\n\
7335 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7336 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7337 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7338 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7339 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
7340 not been called the default value pointed to by p_rot will be 0.\n\
7342 Redacted form: plgdiori(p_rot)\n\
7344 This function is not used in any examples.\n\
7354 p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
7358Simple routine to write labels\n\
7362 Routine for writing simple labels. Use plmtex for more complex labels.\n\
7364 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
7366 This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
7372pllab(xlabel, ylabel, tlabel)\n\
7376 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7377 the label for the x axis.\n\
7379 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7380 the label for the y axis.\n\
7382 tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7383 the title of the plot.\n\
7386Switch to text screen\n\
7390 Sets an interactive device to text mode, used in conjunction with\n\
7391 plgra to allow graphics and text to be interspersed. On a device\n\
7392 which supports separate text and graphics windows, this command causes\n\
7393 control to be switched to the text window. This can be useful for\n\
7394 printing diagnostic messages or getting user input, which would\n\
7395 otherwise interfere with the plots. The program must switch back to\n\
7396 the graphics window before issuing plot commands, as the text (or\n\
7397 console) device will probably become quite confused otherwise. If\n\
7398 already in text mode, this command is ignored. It is also ignored on\n\
7399 devices which only support a single window or use a different method\n\
7400 for shifting focus (see also plgra).\n\
7402 Redacted form: pltext()\n\
7404 This function is used in example 1.\n\
7413Plot all or a subset of Shapefile data using lines in world coordinates\n\
7417 Plot all or a subset of Shapefile data using lines in world\n\
7418 coordinates. Our 19th standard example demonstrates how to use this\n\
7419 function. This function plots data from a Shapefile using lines as in\n\
7420 plmap, however it also has the option of also only drawing specified\n\
7421 elements from the Shapefile. The vector of indices of the required\n\
7422 elements are passed as a function argument. The Shapefile data should\n\
7423 include a metadata file (extension.dbf) listing all items within the\n\
7424 Shapefile. This file can be opened by most popular spreadsheet\n\
7425 programs and can be used to decide which indices to pass to this\n\
7428 Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
7431 This function is used in example 19.\n\
7437plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
7441 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7442 transform the coordinates given in the shapefile into a plot\n\
7443 coordinate system. By using this transform, we can change from a\n\
7444 longitude, latitude coordinate to a polar stereographic project,\n\
7445 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7446 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7447 mapform(), x[] and y[] should be replaced by the corresponding\n\
7448 plot coordinates. If no transform is desired, mapform can be\n\
7449 replaced by NULL.\n\
7451 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7452 the file name of a set of Shapefile files without the file\n\
7455 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7456 be in the same units as used by the Shapefile. You could use a\n\
7457 very large negative number to plot everything, but you can improve\n\
7458 performance by limiting the area drawn. The units must match those\n\
7459 of the Shapefile projection, which may be for example longitude or\n\
7460 distance. The value of minx must be less than the value of maxx.\n\
7462 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7463 use a very large number to plot everything, but you can improve\n\
7464 performance by limiting the area drawn.\n\
7466 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7467 be in the same units as used by the Shapefile. You could use a\n\
7468 very large negative number to plot everything, but you can improve\n\
7469 performance by limiting the area drawn. The units must match those\n\
7470 of the Shapefile projection, which may be for example latitude or\n\
7471 distance. The value of miny must be less than the value of maxy.\n\
7473 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7474 use a very large number to plot everything, but you can improve\n\
7475 performance by limiting the area drawn.\n\
7477 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
7478 zero-based indices of the Shapefile elements which will be drawn.\n\
7480 plotentries to NULL will plot all elements of the Shapefile.\n\
7482 nplotentries (PLINT, input) : The number of items in\n\
7483 plotentries. Ignored if\n\
7484 plotentries is NULL.\n\
7487Set precision in numeric labels\n\
7491 Sets the number of places after the decimal point in numeric labels.\n\
7493 Redacted form: plprec(setp, prec)\n\
7495 This function is used in example 29.\n\
7501plprec(setp, prec)\n\
7505 setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7506 automatically determines the number of places to use after the\n\
7507 decimal point in numeric labels (like those used to label axes).\n\
7508 If setp is 1 then prec sets the number of places.\n\
7510 prec (PLINT, input) : The number of characters to draw after the\n\
7511 decimal point in numeric labels.\n\
7514Draw a line between two points\n\
7518 Joins the point (\n\
7524 Redacted form: pljoin(x1,y1,x2,y2)\n\
7526 This function is used in examples 3 and 14.\n\
7532pljoin(x1, y1, x2, y2)\n\
7536 x1 (PLFLT, input) : x coordinate of first point.\n\
7538 y1 (PLFLT, input) : y coordinate of first point.\n\
7540 x2 (PLFLT, input) : x coordinate of second point.\n\
7542 y2 (PLFLT, input) : y coordinate of second point.\n\
7545Set the device (keyword) name\n\
7549 Set the device (keyword) name.\n\
7551 Redacted form: plsdev(devname)\n\
7553 This function is used in examples 1, 14, and 20.\n\
7563 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7564 containing the device name keyword of the required output device.\n\
7566 devname is NULL or if the first character of the string is a ``?\'\',\n\
7567 the normal (prompted) start up is used.\n\
7570Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
7574 Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
7575 (see the PLplot documentation) index. Overwrites the previous color\n\
7576 value for the given index and, thus, does not result in any additional\n\
7577 allocation of space for colors.\n\
7579 This function is used in example 30.\n\
7585plscol0a(icol0, r, g, b, alpha)\n\
7589 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
7590 number of colors (which is set by default, by plscmap0n, or even\n\
7593 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7594 degree of red in the color.\n\
7596 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7597 degree of green in the color.\n\
7599 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7600 degree of blue in the color.\n\
7602 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
7606Draw filled polygon in 3D\n\
7610 Fills the 3D polygon defined by the n points in the x, y, and z\n\
7611 vectors using the pattern defined by plpsty or plpat. The routine\n\
7612 will automatically close the polygon between the last and first\n\
7613 vertices. If multiple closed polygons are passed in x, y, and z then\n\
7614 plfill3 will fill in between them.\n\
7616 Redacted form: General: plfill3(x, y, z)\n\
7619 This function is used in example 15.\n\
7625plfill3(n, x, y, z)\n\
7629 n (PLINT, input) : Number of vertices in polygon.\n\
7631 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7634 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7637 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
7645 Specify the window, i.e., the world coordinates of the edges of the\n\
7648 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
7650 This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
7657plwind(xmin, xmax, ymin, ymax)\n\
7661 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
7664 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
7667 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
7670 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
7674Draw text at points defined by Shapefile data in world coordinates\n\
7678 As per plmapline, however the items are plotted as text in the same\n\
7681 Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
7682 miny, maxy, plotentry)\n\
7684 This function is used in example 19.\n\
7690plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
7694 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7695 transform the coordinates given in the shapefile into a plot\n\
7696 coordinate system. By using this transform, we can change from a\n\
7697 longitude, latitude coordinate to a polar stereographic project,\n\
7698 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7699 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7700 mapform(), x[] and y[] should be replaced by the corresponding\n\
7701 plot coordinates. If no transform is desired, mapform can be\n\
7702 replaced by NULL.\n\
7704 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7705 the file name of a set of Shapefile files without the file\n\
7708 dx (PLFLT, input) : Used to define the slope of the texts which is\n\
7711 dy (PLFLT, input) : Used to define the slope of the texts which is\n\
7714 just (PLFLT, input) : Set the justification of the text. The value\n\
7715 given will be the fraction of the distance along the string that\n\
7716 sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
7717 centralized text and 1.0 gives right aligned text.\n\
7719 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
7721 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7722 be in the same units as used by the Shapefile. You could use a\n\
7723 very large negative number to plot everything, but you can improve\n\
7724 performance by limiting the area drawn. The units must match those\n\
7725 of the Shapefile projection, which may be for example longitude or\n\
7726 distance. The value of minx must be less than the value of maxx.\n\
7728 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7729 use a very large number to plot everything, but you can improve\n\
7730 performance by limiting the area drawn.\n\
7732 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7733 be in the same units as used by the Shapefile. You could use a\n\
7734 very large negative number to plot everything, but you can improve\n\
7735 performance by limiting the area drawn. The units must match those\n\
7736 of the Shapefile projection, which may be for example latitude or\n\
7737 distance. The value of miny must be less than the value of maxy.\n\
7739 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7740 use a very large number to plot everything, but you can improve\n\
7741 performance by limiting the area drawn.\n\
7743 plotentry (PLINT, input) : An integer indicating which text string\n\
7744 of the Shapefile (zero indexed) will be drawn.\n\
7747Switch to graphics screen\n\
7751 Sets an interactive device to graphics mode, used in conjunction with\n\
7752 pltext to allow graphics and text to be interspersed. On a device\n\
7753 which supports separate text and graphics windows, this command causes\n\
7754 control to be switched to the graphics window. If already in graphics\n\
7755 mode, this command is ignored. It is also ignored on devices which\n\
7756 only support a single window or use a different method for shifting\n\
7757 focus. See also pltext.\n\
7759 Redacted form: plgra()\n\
7761 This function is used in example 1.\n\
7770Set parameters of contour labelling other than format of numerical label\n\
7774 Set parameters of contour labelling other than those handled by\n\
7775 pl_setcontlabelformat.\n\
7777 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7779 This function is used in example 9.\n\
7785pl_setcontlabelparam(offset, size, spacing, active)\n\
7789 offset (PLFLT, input) : Offset of label from contour line (if set\n\
7790 to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7792 size (PLFLT, input) : Font height for contour labels (normalized).\n\
7793 Default value is 0.3.\n\
7795 spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7796 Default value is 0.1.\n\
7798 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7799 contour labels on. Default is off (0).\n\
7802Get family, style and weight of the current font\n\
7806 Gets information about current font. See the PLplot documentation for\n\
7807 more information on font selection.\n\
7809 Redacted form: plgfont(p_family, p_style, p_weight)\n\
7811 This function is used in example 23.\n\
7817plgfont(p_family, p_style, p_weight)\n\
7821 p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7822 font family. The available values are given by the PL_FCI_*\n\
7823 constants in plplot.h. Current options are PL_FCI_SANS,\n\
7824 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
7825 p_family is NULL then the font family is not returned.\n\
7827 p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7828 font style. The available values are given by the PL_FCI_*\n\
7829 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
7830 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
7831 style is not returned.\n\
7833 p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7834 font weight. The available values are given by the PL_FCI_*\n\
7835 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
7836 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
7840Plot a histogram from unbinned data\n\
7844 Plots a histogram from n data points stored in the data vector. This\n\
7845 routine bins the data into nbin bins equally spaced between datmin and\n\
7846 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7847 opt allows, among other things, the histogram either to be plotted in\n\
7848 an existing window or causes plhist to call plenv with suitable limits\n\
7849 before plotting the histogram.\n\
7851 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7853 This function is used in example 5.\n\
7859plhist(n, data, datmin, datmax, nbin, opt)\n\
7863 n (PLINT, input) : Number of data points.\n\
7865 data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7868 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7870 datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7872 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7873 divide the interval xmin to xmax.\n\
7875 opt (PLINT, input) : Is a combination of several flags:\n\
7876 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7877 the histogram data, the outer bins are expanded to fill up the\n\
7878 entire x-axis, data outside the given extremes are assigned to the\n\
7879 outer bins and bins of zero height are simply drawn.\n\
7880 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7881 to fit the histogram data, without this flag, plenv is called\n\
7882 to set the world coordinates.\n\
7883 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7884 extremes are not taken into account. This option should\n\
7885 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7886 properly present the data.\n\
7887 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7888 size as the ones inside.\n\
7889 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7890 (there is a gap for such bins).\n\
7893Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
7897 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
7898 alpha transparency value.\n\
7900 This function is used in example 31.\n\
7906plgcolbga(r, g, b, alpha)\n\
7910 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
7911 in the range from 0 to 255.\n\
7913 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
7914 in the range from 0 to 255.\n\
7916 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
7917 in the range from 0 to 255.\n\
7919 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
7920 transparency in the range (0.0-1.0).\n\
7927 Set integer plot orientation parameter. This function is identical to\n\
7928 plsdiori except for the type of the argument, and should be used in\n\
7929 the same way. See the documentation of plsdiori for details.\n\
7931 Redacted form: plsori(ori)\n\
7933 This function is used in example 3.\n\
7943 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
7944 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
7948Plot latitude and longitude lines\n\
7952 Displays latitude and longitude on the current plot. The lines are\n\
7953 plotted in the current color and line style.\n\
7955 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
7958 This function is used in example 19.\n\
7964plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
7968 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7969 transform the coordinate longitudes and latitudes to a plot\n\
7970 coordinate system. By using this transform, we can change from a\n\
7971 longitude, latitude coordinate to a polar stereographic project,\n\
7972 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7973 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7974 mapform(), x[] and y[] should be replaced by the corresponding\n\
7975 plot coordinates. If no transform is desired, mapform can be\n\
7976 replaced by NULL.\n\
7978 dlong (PLFLT, input) : The interval in degrees at which the\n\
7979 longitude lines are to be plotted.\n\
7981 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
7982 lines are to be plotted.\n\
7984 minlong (PLFLT, input) : The value of the longitude on the left\n\
7985 side of the plot. The value of minlong must be less than the value\n\
7986 of maxlong, and the quantity maxlong-minlong must be less than or\n\
7989 maxlong (PLFLT, input) : The value of the longitude on the right\n\
7990 side of the plot.\n\
7992 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
7993 background. One can always use -90.0 as the boundary outside the\n\
7994 plot window will be automatically eliminated. However, the\n\
7995 program will be faster if one can reduce the size of the\n\
7996 background plotted.\n\
7998 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
7999 background. One can always use 90.0 as the boundary outside the\n\
8000 plot window will be automatically eliminated.\n\
8003Clear current (sub)page\n\
8007 Clears the current page, effectively erasing everything that have been\n\
8008 drawn. This command only works with interactive drivers; if the\n\
8009 driver does not support this, the page is filled with the background\n\
8010 color in use. If the current page is divided into subpages, only the\n\
8011 current subpage is erased. The nth subpage can be selected with\n\
8014 Redacted form: General: plclear()\n\
8017 This function is not used in any examples.\n\
8030 Initializing the plotting package. The program prompts for the device\n\
8031 keyword or number of the desired output device. Hitting a RETURN in\n\
8032 response to the prompt is the same as selecting the first device. If\n\
8033 only one device is enabled when PLplot is installed, plstar will issue\n\
8034 no prompt. The output device is divided into nx by ny subpages, each\n\
8035 of which may be used independently. The subroutine pladv is used to\n\
8036 advance from one subpage to the next.\n\
8038 Redacted form: plstar(nx, ny)\n\
8040 This function is used in example 1.\n\
8050 nx (PLINT, input) : Number of subpages to divide output page in the\n\
8053 ny (PLINT, input) : Number of subpages to divide output page in the\n\
8057Write text relative to viewport boundaries\n\
8061 Writes text at a specified position relative to the viewport\n\
8062 boundaries. Text may be written inside or outside the viewport, but\n\
8063 is clipped at the subpage boundaries. The reference point of a string\n\
8064 lies along a line passing through the string at half the height of a\n\
8065 capital letter. The position of the reference point along this line\n\
8066 is determined by just, and the position of the reference point\n\
8067 relative to the viewport is set by disp and pos.\n\
8069 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
8072 This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
8079plmtex(side, disp, pos, just, text)\n\
8083 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8084 the side of the viewport along which the text is to be written.\n\
8085 The string must be one of: b: Bottom of viewport, text written\n\
8086 parallel to edge.\n\
8087 bv: Bottom of viewport, text written at right angles to edge.\n\
8088 l: Left of viewport, text written parallel to edge.\n\
8089 lv: Left of viewport, text written at right angles to edge.\n\
8090 r: Right of viewport, text written parallel to edge.\n\
8091 rv: Right of viewport, text written at right angles to edge.\n\
8092 t: Top of viewport, text written parallel to edge.\n\
8093 tv: Top of viewport, text written at right angles to edge.\n\
8096 disp (PLFLT, input) : Position of the reference point of string,\n\
8097 measured outwards from the specified viewport edge in units of the\n\
8098 current character height. Use negative disp to write within the\n\
8101 pos (PLFLT, input) : Position of the reference point of string\n\
8102 along the specified edge, expressed as a fraction of the length of\n\
8105 just (PLFLT, input) : Specifies the position of the string relative\n\
8106 to its reference point. If just=0. , the reference point is at\n\
8107 the left and if just=1. , it is at the right of the string. Other\n\
8108 values of just give intermediate justifications.\n\
8110 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
8114Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
8118 Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
8119 PLFLT alpha transparency value (see the PLplot documentation).\n\
8121 This function is used in example 31.\n\
8127plscolbga(r, g, b, alpha)\n\
8131 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8132 degree of red in the color.\n\
8134 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8135 degree of green in the color.\n\
8137 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8138 degree of blue in the color.\n\
8140 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
8144Replays contents of plot buffer to current device/file\n\
8148 Replays contents of plot buffer to current device/file.\n\
8150 Redacted form: plreplot()\n\
8152 This function is used in example 1,20.\n\
8161Plot a glyph at the specified 3D points\n\
8165 Plot a glyph at the specified 3D points. (This function is largely\n\
8166 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
8167 Set up the call to this function similar to what is done for plline3.\n\
8168 code=-1 means try to just draw a point. Right now it\'s just a move\n\
8169 and a draw at the same place. Not ideal, since a sufficiently\n\
8170 intelligent output device may optimize it away, or there may be faster\n\
8171 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
8172 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
8173 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
8174 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
8175 code <= 127 the corresponding printable ASCII character is plotted.\n\
8177 Redacted form: plpoin3(x, y, z, code)\n\
8179 This function is not used in any example.\n\
8185plpoin3(n, x, y, z, code)\n\
8189 n (PLINT, input) : Number of points in the x and y vectors.\n\
8191 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8194 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8197 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
8200 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
8201 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
8202 each of the n points.\n\
8205Set family, style and weight of the current font\n\
8209 Sets the current font. See the PLplot documentation for more\n\
8210 information on font selection.\n\
8212 Redacted form: plsfont(family, style, weight)\n\
8214 This function is used in example 23.\n\
8220plsfont(family, style, weight)\n\
8224 family (PLINT, input) : Font family to select for the current font.\n\
8225 The available values are given by the PL_FCI_* constants in\n\
8226 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
8227 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
8228 signifies that the font family should not be altered.\n\
8230 style (PLINT, input) : Font style to select for the current font.\n\
8231 The available values are given by the PL_FCI_* constants in\n\
8232 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
8233 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
8234 should not be altered.\n\
8236 weight (PLINT, input) : Font weight to select for the current font.\n\
8237 The available values are given by the PL_FCI_* constants in\n\
8238 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
8239 negative value signifies that the font weight should not be\n\
8243Draw a box with axes, etc. with arbitrary origin\n\
8247 Draws a box around the currently defined viewport with arbitrary\n\
8248 world-coordinate origin specified by x0 and y0 and labels it with\n\
8249 world coordinate values appropriate to the window. Thus plaxes should\n\
8250 only be called after defining both viewport and window. The ascii\n\
8251 character strings xopt and yopt specify how the box should be drawn as\n\
8252 described below. If ticks and/or subticks are to be drawn for a\n\
8253 particular axis, the tick intervals and number of subintervals may be\n\
8254 specified explicitly, or they may be defaulted by setting the\n\
8255 appropriate arguments to zero.\n\
8257 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
8261 This function is not used in any examples.\n\
8267plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8271 x0 (PLFLT, input) : World X coordinate of origin.\n\
8273 y0 (PLFLT, input) : World Y coordinate of origin.\n\
8275 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8276 options for the x axis. The string can include any combination of\n\
8277 the following letters (upper or lower case) in any order: a: Draws\n\
8278 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8280 b: Draws bottom (X) or left (Y) edge of frame.\n\
8281 c: Draws top (X) or right (Y) edge of frame.\n\
8282 d: Plot labels as date / time. Values are assumed to be\n\
8283 seconds since the epoch (as used by gmtime).\n\
8284 f: Always use fixed point numeric labels.\n\
8285 g: Draws a grid at the major tick interval.\n\
8286 h: Draws a grid at the minor tick interval.\n\
8287 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8289 l: Labels axis logarithmically. This only affects the labels,\n\
8290 not the data, and so it is necessary to compute the logarithms\n\
8291 of data points before passing them to any of the drawing\n\
8293 m: Writes numeric labels at major tick intervals in the\n\
8294 unconventional location (above box for X, right of box for Y).\n\
8295 n: Writes numeric labels at major tick intervals in the\n\
8296 conventional location (below box for X, left of box for Y).\n\
8297 o: Use custom labelling function to generate axis label text.\n\
8298 The custom labelling function can be defined with the\n\
8299 plslabelfunc command.\n\
8300 s: Enables subticks between major ticks, only valid if t is\n\
8302 t: Draws major ticks.\n\
8303 u: Exactly like \"b\" except don\'t draw edge line.\n\
8304 w: Exactly like \"c\" except don\'t draw edge line.\n\
8305 x: Exactly like \"t\" (including the side effect of the\n\
8306 numerical labels for the major ticks) except exclude drawing\n\
8307 the major and minor tick marks.\n\
8310 xtick (PLFLT, input) : World coordinate interval between major\n\
8311 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8312 generates a suitable tick interval.\n\
8314 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8315 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8316 generates a suitable minor tick interval.\n\
8318 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8319 options for the y axis. The string can include any combination of\n\
8320 the letters defined above for xopt, and in addition may contain:\n\
8321 v: Write numeric labels for the y axis parallel to the base of the\n\
8322 graph, rather than parallel to the axis.\n\
8325 ytick (PLFLT, input) : World coordinate interval between major\n\
8326 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8327 generates a suitable tick interval.\n\
8329 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8330 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8331 generates a suitable minor tick interval.\n\
8338 Begins a new page. For a file driver, the output file is opened if\n\
8339 necessary. Advancing the page via pleop and plbop is useful when a\n\
8340 page break is desired at a particular point when plotting to subpages.\n\
8341 Another use for pleop and plbop is when plotting pages to different\n\
8342 files, since you can manually set the file name by calling plsfnam\n\
8343 after the call to pleop. (In fact some drivers may only support a\n\
8344 single page per file, making this a necessity.) One way to handle\n\
8345 this case automatically is to page advance via pladv, but enable\n\
8346 familying (see plsfam) with a small limit on the file size so that a\n\
8347 new family member file will be created on each page break.\n\
8349 Redacted form: plbop()\n\
8351 This function is used in examples 2 and 20.\n\
8360Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
8364 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
8365 and PLFLT alpha transparency value. This sets the entire color map --\n\
8366 only as many colors as specified will be allocated.\n\
8368 Redacted form: plscmap0a(r, g, b, alpha)\n\
8370 This function is used in examples 30.\n\
8376plscmap0a(r, g, b, alpha, ncol0)\n\
8380 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8381 integers (0-255) representing the degree of red in the color.\n\
8383 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8384 integers (0-255) representing the degree of green in the color.\n\
8386 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8387 integers (0-255) representing the degree of blue in the color.\n\
8389 alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
8390 representing the alpha transparency of the color.\n\
8392 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
8396Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
8400 This is a variant of plscmap1l that supports alpha channel\n\
8401 transparency. It sets cmap1 colors using a piece-wise linear\n\
8402 relationship between cmap1 intensity index (0.0-1.0) and position in\n\
8403 HLS or RGB color space (see the PLplot documentation) with alpha\n\
8404 transparency value (0.0-1.0). It may be called at any time.\n\
8406 Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
8407 alpha, alt_hue_path)\n\
8409 This function is used in example 30.\n\
8415plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
8419 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
8421 npts (PLINT, input) : number of control points.\n\
8423 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
8424 intensity index (0.0-1.0) in ascending order for each control\n\
8427 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
8428 coordinate (H or R) for each control point.\n\
8430 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
8431 coordinate (L or G) for each control point.\n\
8433 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
8434 coordinate (S or B) for each control point.\n\
8436 alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
8437 transparency value (0.0-1.0) for each control point.\n\
8439 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
8440 npts - 1 elements) containing the alternative interpolation method\n\
8441 Boolean value for each control point interval. (alt_hue_path[i]\n\
8442 refers to the interpolation interval between the i and i + 1\n\
8446Enter or leave xor mode\n\
8450 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
8451 those drivers (e.g., the xwin driver) that support it. Enables\n\
8452 erasing plots by drawing twice the same line, symbol, etc. If driver\n\
8453 is not capable of xor operation it returns a status of false.\n\
8455 Redacted form: plxormod(mode, status)\n\
8457 This function is used in examples 1 and 20.\n\
8463plxormod(mode, status)\n\
8467 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
8468 is false means leave xor mode.\n\
8470 status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
8471 modestatus of true (false) means driver is capable (incapable) of\n\
8475Eject current page\n\
8479 Clears the graphics screen of an interactive device, or ejects a page\n\
8480 on a plotter. See plbop for more information.\n\
8482 Redacted form: pleop()\n\
8484 This function is used in example 2,14.\n\
8493Draw a box with axes, etc\n\
8497 Draws a box around the currently defined viewport, and labels it with\n\
8498 world coordinate values appropriate to the window. Thus plbox should\n\
8499 only be called after defining both viewport and window. The ascii\n\
8500 character strings xopt and yopt specify how the box should be drawn as\n\
8501 described below. If ticks and/or subticks are to be drawn for a\n\
8502 particular axis, the tick intervals and number of subintervals may be\n\
8503 specified explicitly, or they may be defaulted by setting the\n\
8504 appropriate arguments to zero.\n\
8506 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8509 This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
8516plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8520 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8521 options for the x axis. The string can include any combination of\n\
8522 the following letters (upper or lower case) in any order: a: Draws\n\
8523 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8525 b: Draws bottom (X) or left (Y) edge of frame.\n\
8526 c: Draws top (X) or right (Y) edge of frame.\n\
8527 d: Plot labels as date / time. Values are assumed to be\n\
8528 seconds since the epoch (as used by gmtime).\n\
8529 f: Always use fixed point numeric labels.\n\
8530 g: Draws a grid at the major tick interval.\n\
8531 h: Draws a grid at the minor tick interval.\n\
8532 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8534 l: Labels axis logarithmically. This only affects the labels,\n\
8535 not the data, and so it is necessary to compute the logarithms\n\
8536 of data points before passing them to any of the drawing\n\
8538 m: Writes numeric labels at major tick intervals in the\n\
8539 unconventional location (above box for X, right of box for Y).\n\
8540 n: Writes numeric labels at major tick intervals in the\n\
8541 conventional location (below box for X, left of box for Y).\n\
8542 o: Use custom labelling function to generate axis label text.\n\
8543 The custom labelling function can be defined with the\n\
8544 plslabelfunc command.\n\
8545 s: Enables subticks between major ticks, only valid if t is\n\
8547 t: Draws major ticks.\n\
8548 u: Exactly like \"b\" except don\'t draw edge line.\n\
8549 w: Exactly like \"c\" except don\'t draw edge line.\n\
8550 x: Exactly like \"t\" (including the side effect of the\n\
8551 numerical labels for the major ticks) except exclude drawing\n\
8552 the major and minor tick marks.\n\
8555 xtick (PLFLT, input) : World coordinate interval between major\n\
8556 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8557 generates a suitable tick interval.\n\
8559 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8560 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8561 generates a suitable minor tick interval.\n\
8563 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8564 options for the y axis. The string can include any combination of\n\
8565 the letters defined above for xopt, and in addition may contain:\n\
8566 v: Write numeric labels for the y axis parallel to the base of the\n\
8567 graph, rather than parallel to the axis.\n\
8570 ytick (PLFLT, input) : World coordinate interval between major\n\
8571 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8572 generates a suitable tick interval.\n\
8574 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8575 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8576 generates a suitable minor tick interval.\n\
8579Get x axis parameters\n\
8583 Returns current values of the p_digmax and p_digits flags for the x\n\
8584 axis. p_digits is updated after the plot is drawn, so this routine\n\
8585 should only be called after the call to plbox (or plbox3) is complete.\n\
8586 See the PLplot documentation for more information.\n\
8588 Redacted form: plgxax(p_digmax, p_digits)\n\
8590 This function is used in example 31.\n\
8596plgxax(p_digmax, p_digits)\n\
8600 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
8601 number of digits for the x axis. If nonzero, the printed label\n\
8602 has been switched to a floating-point representation when the\n\
8603 number of digits exceeds this value.\n\
8605 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
8606 number of digits for the numeric labels (x axis) from the last\n\
8614 Sets the font used for subsequent text and symbols. For devices that\n\
8615 still use Hershey fonts this routine has no effect unless the Hershey\n\
8616 fonts with extended character set are loaded (see plfontld). For\n\
8617 unicode-aware devices that use system fonts instead of Hershey fonts,\n\
8618 this routine calls the plsfci routine with argument set up\n\
8619 appropriately for the various cases below. However, this method of\n\
8620 specifying the font for unicode-aware devices is deprecated, and the\n\
8621 much more flexible method of calling plsfont directly is recommended\n\
8622 instead (where plsfont provides a user-friendly interface to plsfci),\n\
8624 Redacted form: plfont(ifont)\n\
8626 This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
8636 ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
8637 (simplest and fastest)\n\
8643Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
8647 Routine for creating a discrete plot legend with a plotted filled box,\n\
8648 line, and/or line of symbols for each annotated legend entry. (See\n\
8649 plcolorbar for similar functionality for creating continuous color\n\
8650 bars.) The arguments of pllegend provide control over the location\n\
8651 and size of the legend as well as the location and characteristics of\n\
8652 the elements (most of which are optional) within that legend. The\n\
8653 resulting legend is clipped at the boundaries of the current subpage.\n\
8654 (N.B. the adopted coordinate system used for some of the parameters is\n\
8655 defined in the documentation of the position parameter.)\n\
8657 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
8658 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
8659 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
8660 test_justification, text_colors, text, box_colors, box_patterns,\n\
8661 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
8662 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
8664 This function is used in examples 4, 26, and 33.\n\
8670pllegend(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\
8674 p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8675 legend width in adopted coordinates. This quantity is calculated\n\
8676 from plot_width, text_offset, ncolumn (possibly modified inside\n\
8677 the routine depending on nlegend and nrow), and the length\n\
8678 (calculated internally) of the longest text string.\n\
8680 p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8681 legend height in adopted coordinates. This quantity is calculated\n\
8682 from text_scale, text_spacing, and nrow (possibly modified inside\n\
8683 the routine depending on nlegend and nrow).\n\
8685 opt (PLINT, input) : opt contains bits controlling the overall\n\
8686 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
8687 on the left of the legend and the plotted area on the right.\n\
8688 Otherwise, put the text area on the right of the legend and the\n\
8689 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
8690 plot a (semitransparent) background for the legend. If the\n\
8691 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8692 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
8693 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
8694 plot the resulting array of legend entries in row-major order.\n\
8695 Otherwise, plot the legend entries in column-major order.\n\
8697 position (PLINT, input) : position contains bits which control the\n\
8698 overall position of the legend and the definition of the adopted\n\
8699 coordinates used for positions just like what is done for the\n\
8700 position argument for plcolorbar. However, note that the defaults\n\
8701 for the position bits (see below) are different than the\n\
8702 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
8703 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8704 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8705 the 16 possible standard positions (the 4 corners and centers of\n\
8706 the 4 sides for both the inside and outside cases) of the legend\n\
8707 relative to the adopted coordinate system. The corner positions\n\
8708 are specified by the appropriate combination of two of the\n\
8709 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8710 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8711 value of one of those bits. The adopted coordinates are\n\
8712 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8713 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8714 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8715 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8716 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
8717 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
8718 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
8719 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
8721 x (PLFLT, input) : X offset of the legend position in adopted\n\
8722 coordinates from the specified standard position of the legend.\n\
8723 For positive x, the direction of motion away from the standard\n\
8724 position is inward/outward from the standard corner positions or\n\
8725 standard left or right positions if the\n\
8726 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8727 For the standard top or bottom positions, the direction of motion\n\
8728 is toward positive X.\n\
8730 y (PLFLT, input) : Y offset of the legend position in adopted\n\
8731 coordinates from the specified standard position of the legend.\n\
8732 For positive y, the direction of motion away from the standard\n\
8733 position is inward/outward from the standard corner positions or\n\
8734 standard top or bottom positions if the\n\
8735 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
8736 the standard left or right positions, the direction of motion is\n\
8737 toward positive Y.\n\
8739 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
8740 of the plot area (where the colored boxes, lines, and/or lines of\n\
8741 symbols are drawn) of the legend.\n\
8743 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8744 legend (PL_LEGEND_BACKGROUND).\n\
8746 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8747 for the legend (PL_LEGEND_BOUNDING_BOX).\n\
8749 bb_style (PLINT, input) : The pllsty style number for the\n\
8750 bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
8752 nrow (PLINT, input) : The number of rows in the matrix used to\n\
8754 nlegend legend entries. For internal transformations of\n\
8755 nrow, see further remarks under\n\
8758 ncolumn (PLINT, input) : The number of columns in the matrix used\n\
8760 nlegend legend entries. For internal transformations of\n\
8761 ncolumn, see further remarks under\n\
8764 nlegend (PLINT, input) : Number of legend entries. The above\n\
8766 ncolumn values are transformed internally to be consistent with\n\
8767 nlegend. If either\n\
8769 ncolumn is non-positive it is replaced by 1. If the resulting product\n\
8772 ncolumn is less than\n\
8773 nlegend, the smaller of the two (or\n\
8776 ncolumn) is increased so the product is >=\n\
8777 nlegend. Thus, for example, the common\n\
8779 ncolumn = 0 case is transformed internally to\n\
8782 ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
8785 opt_array (PLINT_VECTOR, input) : A vector of\n\
8786 nlegend values of options to control each individual plotted area\n\
8787 corresponding to a legend entry. If the\n\
8788 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
8790 PL_LEGEND_COLOR_BOX,\n\
8791 PL_LEGEND_LINE, and/or\n\
8792 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
8793 entry is plotted with a colored box; a line; and/or a line of\n\
8796 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
8797 area in units of character width.\n\
8799 text_scale (PLFLT, input) : Character height scale for text\n\
8802 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
8803 character height from one legend entry to the next.\n\
8805 text_justification (PLFLT, input) : Justification parameter used\n\
8806 for text justification. The most common values of\n\
8807 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
8808 is left justified, centred, or right justified within the text\n\
8809 area, but other values are allowed as well.\n\
8811 text_colors (PLINT_VECTOR, input) : A vector containing\n\
8812 nlegend cmap0 text colors.\n\
8814 text (PLCHAR_MATRIX, input) : A vector of\n\
8815 nlegend UTF-8 character strings containing the legend annotations.\n\
8817 box_colors (PLINT_VECTOR, input) : A vector containing\n\
8818 nlegend cmap0 colors for the discrete colored boxes (\n\
8819 PL_LEGEND_COLOR_BOX).\n\
8821 box_patterns (PLINT_VECTOR, input) : A vector containing\n\
8822 nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
8823 PL_LEGEND_COLOR_BOX).\n\
8825 box_scales (PLFLT_VECTOR, input) : A vector containing\n\
8826 nlegend scales (units of fraction of character height) for the height\n\
8827 of the discrete colored boxes (\n\
8828 PL_LEGEND_COLOR_BOX).\n\
8830 box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8831 nlegend line widths for the patterns specified by box_patterns (\n\
8832 PL_LEGEND_COLOR_BOX).\n\
8834 line_colors (PLINT_VECTOR, input) : A vector containing\n\
8835 nlegend cmap0 line colors (\n\
8838 line_styles (PLINT_VECTOR, input) : A vector containing\n\
8839 nlegend line styles (plsty indices) (\n\
8842 line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8843 nlegend line widths (\n\
8846 symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
8847 nlegend cmap0 symbol colors (\n\
8848 PL_LEGEND_SYMBOL).\n\
8850 symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
8851 nlegend scale values for the symbol height (\n\
8852 PL_LEGEND_SYMBOL).\n\
8854 symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
8855 nlegend numbers of symbols to be drawn across the width of the plotted\n\
8857 PL_LEGEND_SYMBOL).\n\
8859 symbols (PLCHAR_MATRIX, input) : A vector of\n\
8860 nlegend UTF-8 character strings containing the legend symbols. (\n\
8861 PL_LEGEND_SYMBOL).\n\
8864Set the background color by 8-bit RGB value\n\
8868 Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
8869 the PLplot documentation).\n\
8871 Redacted form: plscolbg(r, g, b)\n\
8873 This function is used in examples 15 and 31.\n\
8883 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8884 degree of red in the color.\n\
8886 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8887 degree of green in the color.\n\
8889 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8890 degree of blue in the color.\n\
8893Set parameters that define current device-space window\n\
8897 Set relative margin width, aspect ratio, and relative justification\n\
8898 that define current device-space window. If you want to just use the\n\
8899 previous value for any of these, just pass in the magic value\n\
8900 PL_NOTSET. It is unlikely that one should ever need to change the\n\
8901 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
8902 called the default values of mar, jx, and jy are all 0. aspect is set\n\
8903 to a device-specific value.\n\
8905 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
8907 This function is used in example 31.\n\
8913plsdidev(mar, aspect, jx, jy)\n\
8917 mar (PLFLT, input) : Relative margin width.\n\
8919 aspect (PLFLT, input) : Aspect ratio.\n\
8921 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
8922 the range -0.5 to 0.5.\n\
8924 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
8925 the range -0.5 to 0.5.\n\
8928Specify viewport using aspect ratio only\n\
8932 Selects the largest viewport with the given aspect ratio within the\n\
8933 subpage that leaves a standard margin (left-hand margin of eight\n\
8934 character heights, and a margin around the other three sides of five\n\
8935 character heights).\n\
8937 Redacted form: plvasp(aspect)\n\
8939 This function is used in example 13.\n\
8949 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
8950 axis of resulting viewport.\n\
8953Configure the transformations required for projecting a 3D surface on a 2D window\n\
8957 Configure the transformations required for projecting a 3D surface on\n\
8958 an existing 2D window. Those transformations (see the PLplot\n\
8959 documentation) are done to a rectangular cuboid enclosing the 3D\n\
8960 surface which has its limits expressed in 3D world coordinates and\n\
8961 also normalized 3D coordinates (used for interpreting the altitude and\n\
8962 azimuth of the viewing angle). The transformations consist of the\n\
8963 linear transform from 3D world coordinates to normalized 3D\n\
8964 coordinates, and the 3D rotation of normalized coordinates required to\n\
8965 align the pole of the new 3D coordinate system with the viewing\n\
8966 direction specified by altitude and azimuth so that x and y of the\n\
8967 surface elements in that transformed coordinate system are the\n\
8968 projection of the 3D surface with given viewing direction on the 2D\n\
8971 The enclosing rectangular cuboid for the surface plot is defined by\n\
8972 xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
8973 mapped into the same rectangular cuboid with normalized 3D coordinate\n\
8974 sizes of basex by basey by height so that xmin maps to -\n\
8975 basex/2, xmax maps to basex/2, ymin maps to -\n\
8976 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
8977 The resulting rectangular cuboid in normalized coordinates is then\n\
8978 viewed by an observer at altitude alt and azimuth az. This routine\n\
8979 must be called before plbox3 or any of the 3D surface plotting\n\
8980 routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
8981 plsurf3dl or plfill3.\n\
8983 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
8984 zmin, zmax, alt, az)\n\
8986 This function is examples 8, 11, 18, and 21.\n\
8992plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
8996 basex (PLFLT, input) : The normalized x coordinate size of the\n\
8997 rectangular cuboid.\n\
8999 basey (PLFLT, input) : The normalized y coordinate size of the\n\
9000 rectangular cuboid.\n\
9002 height (PLFLT, input) : The normalized z coordinate size of the\n\
9003 rectangular cuboid.\n\
9005 xmin (PLFLT, input) : The minimum x world coordinate of the\n\
9006 rectangular cuboid.\n\
9008 xmax (PLFLT, input) : The maximum x world coordinate of the\n\
9009 rectangular cuboid.\n\
9011 ymin (PLFLT, input) : The minimum y world coordinate of the\n\
9012 rectangular cuboid.\n\
9014 ymax (PLFLT, input) : The maximum y world coordinate of the\n\
9015 rectangular cuboid.\n\
9017 zmin (PLFLT, input) : The minimum z world coordinate of the\n\
9018 rectangular cuboid.\n\
9020 zmax (PLFLT, input) : The maximum z world coordinate of the\n\
9021 rectangular cuboid.\n\
9023 alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
9024 plane of the rectangular cuboid in normalized coordinates.\n\
9026 az (PLFLT, input) : The viewing azimuth in degrees of the\n\
9027 rectangular cuboid in normalized coordinates. When az=0, the\n\
9028 observer is looking face onto the zx plane of the rectangular\n\
9029 cuboid in normalized coordinates, and as az is increased, the\n\
9030 observer moves clockwise around that cuboid when viewed from above\n\
9034Wait for graphics input event and translate to world coordinates.\n\
9038 Wait for graphics input event and translate to world coordinates.\n\
9039 Returns 0 if no translation to world coordinates is possible.\n\
9041 This function returns 1 on success and 0 if no translation to world\n\
9042 coordinates is possible.\n\
9044 Redacted form: plGetCursor(gin)\n\
9046 This function is used in examples 1 and 20.\n\
9052PLINT plGetCursor(gin)\n\
9056 gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
9057 which will contain the output. The structure is not allocated by\n\
9058 the routine and must exist before the function is called.\n\
9061Set number of colors in cmap0\n\
9065 Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9066 (or reallocate) cmap0, and fill with default values for those colors\n\
9067 not previously allocated. The first 16 default colors are given in\n\
9068 the plcol0 documentation. For larger indices the default color is\n\
9071 The drivers are not guaranteed to support more than 16 colors.\n\
9073 Redacted form: plscmap0n(ncol0)\n\
9075 This function is used in examples 15, 16, and 24.\n\
9085 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9086 the cmap0 palette. If this number is zero or less, then the value\n\
9087 from the previous call to plscmap0n is used and if there is no\n\
9088 previous call, then a default value is used.\n\
9091Set z axis parameters\n\
9095 Identical to plsxax, except that arguments are flags for z axis. See\n\
9096 the description of plsxax for more detail.\n\
9098 Redacted form: plszax(digmax, digits)\n\
9100 This function is used in example 31.\n\
9106plszax(digmax, digits)\n\
9110 digmax (PLINT, input) : Variable to set the maximum number of\n\
9111 digits for the z axis. If nonzero, the printed label will be\n\
9112 switched to a floating-point representation when the number of\n\
9113 digits exceeds digmax.\n\
9115 digits (PLINT, input) : Field digits value. Currently, changing\n\
9116 its value here has no effect since it is set only by plbox or\n\
9117 plbox3. However, the user may obtain its value after a call to\n\
9118 either of these functions by calling plgzax.\n\
9121Get FCI (font characterization integer)\n\
9125 Gets information about the current font using the FCI approach. See\n\
9126 the PLplot documentation for more information.\n\
9128 Redacted form: plgfci(p_fci)\n\
9130 This function is used in example 23.\n\
9140 p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
9144Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
9148 Sets up plotter environment for simple graphs by calling pladv and\n\
9149 setting up viewport and window to sensible default values. plenv0\n\
9150 leaves a standard margin (left-hand margin of eight character heights,\n\
9151 and a margin around the other three sides of five character heights)\n\
9152 around most graphs for axis labels and a title. When these defaults\n\
9153 are not suitable, use the individual routines plvpas, plvpor, or\n\
9154 plvasp for setting up the viewport, plwind for defining the window,\n\
9155 and plbox for drawing the box.\n\
9157 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9159 This function is used in example 21.\n\
9165plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9169 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
9170 world coordinates).\n\
9172 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
9173 world coordinates).\n\
9175 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
9178 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
9181 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
9182 scales will not be set, the user must set up the scale before\n\
9183 calling plenv0 using plsvpa, plvasp or other.\n\
9184 0: the x and y axes are scaled independently to use as much of\n\
9185 the screen as possible.\n\
9186 1: the scales of the x and y axes are made equal.\n\
9187 2: the axis of the x and y axes are made equal, and the plot\n\
9188 box will be square.\n\
9191 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
9192 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
9193 -1: draw box only.\n\
9194 0: draw box, ticks, and numeric tick labels.\n\
9195 1: also draw coordinate axes at x=0 and y=0.\n\
9196 2: also draw a grid at major tick positions in both\n\
9198 3: also draw a grid at minor tick positions in both\n\
9200 10: same as 0 except logarithmic x tick marks. (The x data\n\
9201 have to be converted to logarithms separately.)\n\
9202 11: same as 1 except logarithmic x tick marks. (The x data\n\
9203 have to be converted to logarithms separately.)\n\
9204 12: same as 2 except logarithmic x tick marks. (The x data\n\
9205 have to be converted to logarithms separately.)\n\
9206 13: same as 3 except logarithmic x tick marks. (The x data\n\
9207 have to be converted to logarithms separately.)\n\
9208 20: same as 0 except logarithmic y tick marks. (The y data\n\
9209 have to be converted to logarithms separately.)\n\
9210 21: same as 1 except logarithmic y tick marks. (The y data\n\
9211 have to be converted to logarithms separately.)\n\
9212 22: same as 2 except logarithmic y tick marks. (The y data\n\
9213 have to be converted to logarithms separately.)\n\
9214 23: same as 3 except logarithmic y tick marks. (The y data\n\
9215 have to be converted to logarithms separately.)\n\
9216 30: same as 0 except logarithmic x and y tick marks. (The x\n\
9217 and y data have to be converted to logarithms separately.)\n\
9218 31: same as 1 except logarithmic x and y tick marks. (The x\n\
9219 and y data have to be converted to logarithms separately.)\n\
9220 32: same as 2 except logarithmic x and y tick marks. (The x\n\
9221 and y data have to be converted to logarithms separately.)\n\
9222 33: same as 3 except logarithmic x and y tick marks. (The x\n\
9223 and y data have to be converted to logarithms separately.)\n\
9224 40: same as 0 except date / time x labels.\n\
9225 41: same as 1 except date / time x labels.\n\
9226 42: same as 2 except date / time x labels.\n\
9227 43: same as 3 except date / time x labels.\n\
9228 50: same as 0 except date / time y labels.\n\
9229 51: same as 1 except date / time y labels.\n\
9230 52: same as 2 except date / time y labels.\n\
9231 53: same as 3 except date / time y labels.\n\
9232 60: same as 0 except date / time x and y labels.\n\
9233 61: same as 1 except date / time x and y labels.\n\
9234 62: same as 2 except date / time x and y labels.\n\
9235 63: same as 3 except date / time x and y labels.\n\
9236 70: same as 0 except custom x and y labels.\n\
9237 71: same as 1 except custom x and y labels.\n\
9238 72: same as 2 except custom x and y labels.\n\
9239 73: same as 3 except custom x and y labels.\n\
9246 This sets up the size of all subsequent symbols drawn by plpoin and\n\
9247 plsym. The actual height of a symbol is the product of the default\n\
9248 symbol size and a scaling factor as for the character height.\n\
9250 Redacted form: plssym(def, scale)\n\
9252 This function is used in example 29.\n\
9258plssym(def, scale)\n\
9262 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
9263 should be set to zero if the default height is to remain\n\
9266 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9267 actual symbol height.\n\
9270Set plot orientation\n\
9274 Set plot orientation parameter which is multiplied by 90 degrees to\n\
9275 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
9276 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
9277 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
9278 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
9279 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
9280 not called the default value of rot is 0.\n\
9282 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
9283 probably want to change the aspect ratio to a value suitable for the\n\
9284 plot orientation using a call to plsdidev or the command-line options\n\
9285 -a or -freeaspect. For more documentation of those options see the\n\
9286 PLplot documentation. Such command-line options can be set internally\n\
9287 using plsetopt or set directly using the command line and parsed using\n\
9288 a call to plparseopts.\n\
9290 Redacted form: plsdiori(rot)\n\
9292 This function is not used in any examples.\n\
9302 rot (PLFLT, input) : Plot orientation parameter.\n\
9305Advance the (sub-)page\n\
9309 Advances to the next subpage if sub=0, performing a page advance if\n\
9310 there are no remaining subpages on the current page. If subpages\n\
9311 aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
9312 PLplot switches to the specified subpage. Note that this allows you\n\
9313 to overwrite a plot on the specified subpage; if this is not what you\n\
9314 intended, use pleop followed by plbop to first advance the page. This\n\
9315 routine is called automatically (with page=0) by plenv, but if plenv\n\
9316 is not used, pladv must be called after initializing PLplot but before\n\
9317 defining the viewport.\n\
9319 Redacted form: pladv(page)\n\
9321 This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
9332 page (PLINT, input) : Specifies the subpage number (starting from 1\n\
9333 in the top left corner and increasing along the rows) to which to\n\
9334 advance. Set to zero to advance to the next subpage (or to the\n\
9335 next page if subpages are not being used).\n\
9338Set cmap0 colors by 8-bit RGB values\n\
9342 Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
9343 documentation). This sets the entire color map -- only as many colors\n\
9344 as specified will be allocated.\n\
9346 Redacted form: plscmap0(r, g, b)\n\
9348 This function is used in examples 2 and 24.\n\
9354plscmap0(r, g, b, ncol0)\n\
9358 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9359 integers (0-255) representing the degree of red in the color.\n\
9361 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9362 integers (0-255) representing the degree of green in the color.\n\
9364 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9365 integers (0-255) representing the degree of blue in the color.\n\
9367 ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9370Get character default height and current (scaled) height\n\
9374 Get character default height and current (scaled) height.\n\
9376 Redacted form: plgchr(p_def, p_ht)\n\
9378 This function is used in example 23.\n\
9384plgchr(p_def, p_ht)\n\
9388 p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
9389 character height (mm).\n\
9391 p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
9392 character height (mm).\n\
9395Set opaque RGB cmap1 colors values\n\
9399 Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
9400 vector values. This function also sets the number of cmap1 colors.\n\
9401 N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
9402 in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
9403 plcol1) to an integer index of these RGB vectors in the range from 0\n\
9405 ncol1-1. So in order for this continuous color model to work\n\
9406 properly, it is the responsibility of the user of plscmap1 to insure\n\
9407 that these RGB vectors are continuous functions of their integer\n\
9410 Redacted form: plscmap1(r, g, b)\n\
9412 This function is used in example 31.\n\
9418plscmap1(r, g, b, ncol1)\n\
9422 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9423 8-bit integers in the range from 0-255) the degree of red in the\n\
9424 color as a continuous function of the integer index of the vector.\n\
9426 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9427 8-bit integers in the range from 0-255) the degree of green in the\n\
9428 color as a continuous function of the integer index of the vector.\n\
9430 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9431 8-bit integers in the range from 0-255) the degree of blue in the\n\
9432 color as a continuous function of the integer index of the vector.\n\
9434 ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9437Set any command-line option\n\
9441 Set any command-line option internally from a program before it\n\
9442 invokes plinit. opt is the name of the command-line option and optarg\n\
9443 is the corresponding command-line option argument.\n\
9445 This function returns 0 on success.\n\
9447 Redacted form: plsetopt(opt, optarg)\n\
9449 This function is used in example 14.\n\
9455PLINT plsetopt(opt, optarg)\n\
9459 opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9460 the command-line option.\n\
9462 optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
9463 containing the argument of the command-line option.\n\
9466Draw linear gradient inside polygon\n\
9470 Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
9473 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
9474 polygon coordinates and the gradient angle are all expressed in world\n\
9475 coordinates. The angle from the x axis for both the rotated\n\
9476 coordinate system and the gradient vector is specified by angle. The\n\
9477 magnitude of the gradient vector is the difference between the maximum\n\
9478 and minimum values of x for the vertices in the rotated coordinate\n\
9479 system. The origin of the gradient vector can be interpreted as being\n\
9480 anywhere on the line corresponding to the minimum x value for the\n\
9481 vertices in the rotated coordinate system. The distance along the\n\
9482 gradient vector is linearly transformed to the independent variable of\n\
9483 color map 1 which ranges from 0. at the tail of the gradient vector to\n\
9484 1. at the head of the gradient vector. What is drawn is the RGBA\n\
9485 color corresponding to the independent variable of cmap1. For more\n\
9486 information about cmap1 (see the PLplot documentation).\n\
9488 Redacted form: plgradient(x,y,angle)\n\
9490 This function is used in examples 25 and 30.\n\
9496plgradient(n, x, y, angle)\n\
9500 n (PLINT, input) : Number of vertices in polygon.\n\
9502 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9505 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9508 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
9512Set length of major ticks\n\
9516 This sets up the length of the major ticks. The actual length is the\n\
9517 product of the default length and a scaling factor as for character\n\
9520 Redacted form: plsmaj(def, scale)\n\
9522 This function is used in example 29.\n\
9528plsmaj(def, scale)\n\
9532 def (PLFLT, input) : The default length of a major tick in\n\
9533 millimeters, should be set to zero if the default length is to\n\
9534 remain unchanged.\n\
9536 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9537 actual tick length.\n\
9540Set a global coordinate transform function\n\
9544 This function can be used to define a coordinate transformation which\n\
9545 affects all elements drawn within the current plot window. The\n\
9546 coordinate_transform callback function is similar to that provided for\n\
9547 the plmap and plmeridians functions. The coordinate_transform_data\n\
9548 parameter may be used to pass extra data to coordinate_transform.\n\
9550 Redacted form: General: plstransform(coordinate_transform,\n\
9551 coordinate_transform_data)\n\
9554 This function is used in examples 19 and 22.\n\
9560plstransform(coordinate_transform, coordinate_transform_data)\n\
9564 coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
9565 function that defines the transformation from the input (x, y)\n\
9566 world coordinates to new PLplot world coordinates. If\n\
9567 coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
9568 case), then no transform is applied.\n\
9570 coordinate_transform_data (PLPointer, input) : Optional extra data\n\
9572 coordinate_transform.\n\
9575Configure the transformation between continuous and broken-down time for the current stream\n\
9579 Configure the transformation between continuous and broken-down time\n\
9580 for the current stream. This transformation is used by both plbtime\n\
9583 Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
9584 ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9587 This function is used in example 29.\n\
9593plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9597 scale (PLFLT, input) : The number of days per continuous time unit.\n\
9598 As a special case, if\n\
9599 scale is 0., then all other arguments are ignored, and the result (the\n\
9600 default used by PLplot) is the equivalent of a call to\n\
9601 plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
9602 That is, for this special case broken-down time is calculated with\n\
9603 the proleptic Gregorian calendar with no leap seconds inserted,\n\
9604 and the continuous time is defined as the number of seconds since\n\
9605 the Unix epoch of 1970-01-01T00:00:00Z.\n\
9607 offset1 (PLFLT, input) : If\n\
9608 ifbtime_offset is true, the parameters\n\
9610 offset2 are completely ignored. Otherwise, the sum of these parameters\n\
9611 (with units in days) specify the epoch of the continuous time\n\
9612 relative to the MJD epoch corresponding to the Gregorian calendar\n\
9613 date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
9614 are used to specify the origin to allow users (by specifying\n\
9615 offset1 as an integer that can be exactly represented by a\n\
9616 floating-point variable and specifying\n\
9617 offset2 as a number in the range from 0. to 1) the chance to minimize\n\
9618 the numerical errors of the continuous time representation.\n\
9620 offset2 (PLFLT, input) : See documentation of\n\
9623 ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
9624 transformation. If the 0x1 bit is set, then the proleptic Julian\n\
9625 calendar is used for broken-down time rather than the proleptic\n\
9626 Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
9627 have been historically used to define UTC are inserted into the\n\
9628 broken-down time. Other possibilities for additional control bits\n\
9629 for ccontrol exist such as making the historical time corrections\n\
9630 in the broken-down time corresponding to ET (ephemeris time) or\n\
9631 making the (slightly non-constant) corrections from international\n\
9632 atomic time (TAI) to what astronomers define as terrestrial time\n\
9633 (TT). But those additional possibilities have not been\n\
9634 implemented yet in the qsastime library (one of the PLplot utility\n\
9637 ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
9638 epoch of the continuous time scale is specified by the user. If\n\
9639 ifbtime_offset is false, then\n\
9641 offset2 are used to specify the epoch, and the following broken-down\n\
9642 time parameters are completely ignored. If\n\
9643 ifbtime_offset is true, then\n\
9645 offset2 are completely ignored, and the following broken-down time\n\
9646 parameters are used to specify the epoch.\n\
9648 year (PLINT, input) : Year of epoch.\n\
9650 month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
9653 day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
9655 hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
9657 min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
9659 sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
9662Flushes the output stream\n\
9666 Flushes the output stream. Use sparingly, if at all.\n\
9668 Redacted form: plflush()\n\
9670 This function is used in examples 1 and 14.\n\
9679Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
9683 This variant of plsurf3d (see that function\'s documentation for more\n\
9684 details) should be suitable for the case where the area of the x, y\n\
9685 coordinate grid where z is defined can be non-rectangular. The limits\n\
9686 of that grid are provided by the parameters indexxmin, indexxmax,\n\
9687 indexymin, and indexymax.\n\
9689 Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
9692 This function is used in example 8.\n\
9698plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
9702 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
9703 which the function is evaluated.\n\
9705 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
9706 which the function is evaluated.\n\
9708 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
9709 plot. Should have dimensions of\n\
9713 nx (PLINT, input) : Number of x values at which function is\n\
9716 ny (PLINT, input) : Number of y values at which function is\n\
9719 opt (PLINT, input) : Determines the way in which the surface is\n\
9720 represented. To specify more than one option just add the options,\n\
9721 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
9722 connecting points at which function is defined.\n\
9723 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
9727 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
9731 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
9732 the borders of the plotted function.\n\
9733 opt=MAG_COLOR : the surface is colored according to the value\n\
9734 of Z; if MAG_COLOR is not used, then the surface is colored\n\
9735 according to the intensity of the reflected light in the\n\
9736 surface from a light source whose position is set using\n\
9740 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
9743 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
9745 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
9746 corresponds to the first x index where z is defined.\n\
9748 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
9749 which corresponds (by convention) to one more than the last x\n\
9750 index value where z is defined.\n\
9752 indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
9753 values which all must be ≥ 0. These values are the first y index\n\
9754 where z is defined for a particular x index in the range from\n\
9755 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
9758 indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
9759 values which all must be ≤ ny. These values correspond (by\n\
9760 convention) to one more than the last y index where z is defined\n\
9761 for a particular x index in the range from indexxmin to indexxmax\n\
9762 - 1. The dimension of indexymax is indexxmax.\n\
9765Set semitransparent cmap1 RGBA colors.\n\
9769 Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
9770 RGBA vector values. This function also sets the number of cmap1\n\
9771 colors. N.B. Continuous cmap1 colors are indexed with a\n\
9772 floating-point index in the range from 0.0-1.0 which is linearly\n\
9773 transformed (e.g., by plcol1) to an integer index of these RGBA\n\
9774 vectors in the range from 0 to\n\
9775 ncol1-1. So in order for this continuous color model to work\n\
9776 properly, it is the responsibility of the user of plscmap1 to insure\n\
9777 that these RGBA vectors are continuous functions of their integer\n\
9780 Redacted form: plscmap1a(r, g, b, alpha)\n\
9782 This function is used in example 31.\n\
9788plscmap1a(r, g, b, alpha, ncol1)\n\
9792 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9793 8-bit integers in the range from 0-255) the degree of red in the\n\
9794 color as a continuous function of the integer index of the vector.\n\
9796 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9797 8-bit integers in the range from 0-255) the degree of green in the\n\
9798 color as a continuous function of the integer index of the vector.\n\
9800 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9801 8-bit integers in the range from 0-255) the degree of blue in the\n\
9802 color as a continuous function of the integer index of the vector.\n\
9804 alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
9805 values in the range from 0.0-1.0 where 0.0 corresponds to\n\
9806 completely transparent and 1.0 corresponds to completely opaque)\n\
9807 the alpha transparency of the color as a continuous function of\n\
9808 the integer index of the vector.\n\
9810 ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9814Calculate broken-down time from continuous time for the current stream\n\
9818 Calculate broken-down time; year, month, day, hour, min, sec; from\n\
9819 continuous time, ctime for the current stream. This function is the\n\
9820 inverse of plctime.\n\
9822 The PLplot definition of broken-down time is a calendar time that\n\
9823 completely ignores all time zone offsets, i.e., it is the user\'s\n\
9824 responsibility to apply those offsets (if so desired) before using the\n\
9825 PLplot time API. By default broken-down time is defined using the\n\
9826 proleptic Gregorian calendar without the insertion of leap seconds and\n\
9827 continuous time is defined as the number of seconds since the Unix\n\
9828 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
9829 broken-down and continuous time are possible, see plconfigtime.\n\
9831 Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
9835 This function is used in example 29.\n\
9841plbtime(year, month, day, hour, min, sec, ctime)\n\
9845 year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
9846 positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
9847 non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
9850 month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
9851 the year in the range from 0 (January) to 11 (December).\n\
9853 day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
9854 month in the range from 1 to 31.\n\
9856 hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
9857 day in the range from 0 to 23.\n\
9859 min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
9860 hour in the range from 0 to 59\n\
9862 sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
9863 minute in range from 0. to 60.\n\
9865 ctime (PLFLT, input) : Continuous time from which the broken-down\n\
9866 time is calculated.\n\
9869Convert RGB color to HLS\n\
9873 Convert RGB color coordinates to HLS\n\
9875 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9878 This function is used in example 2.\n\
9884plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9888 r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9890 g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9892 b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9894 p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9895 degrees (0.0-360.0) on the color cylinder.\n\
9897 p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9898 expressed as a fraction (0.0-1.0) of the axis of the color\n\
9901 p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9902 expressed as a fraction (0.0-1.0) of the radius of the color\n\
9906Get the current device (keyword) name\n\
9910 Get the current device (keyword) name. Note: you must have allocated\n\
9911 space for this (80 characters is safe).\n\
9913 Redacted form: plgdev(p_dev)\n\
9915 This function is used in example 14.\n\
9925 p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
9926 (with preallocated length of 80 characters or more) containing the\n\
9927 device (keyword) name.\n\
9930Set the number of subpages in x and y\n\
9934 Set the number of subpages in x and y.\n\
9936 Redacted form: plssub(nx, ny)\n\
9938 This function is examples 1,2,14,21,25,27.\n\
9948 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
9949 of window columns).\n\
9951 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
9955Get current stream number\n\
9959 Gets the number of the current output stream. See also plsstrm.\n\
9961 Redacted form: plgstrm(p_strm)\n\
9963 This function is used in example 1,20.\n\
9973 p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
9977Random number generator returning a real random number in the range [0,1]\n\
9981 Random number generator returning a real random number in the range\n\
9982 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
9983 / compilers provide their own random number generator, and so this is\n\
9984 provided purely for convenience and to give a consistent random number\n\
9985 generator across all languages supported by PLplot. This is\n\
9986 particularly useful for comparing results from the test suite of\n\
9989 Redacted form: plrandd()\n\
9991 This function is used in examples 17 and 21.\n\
10000Add a point to a strip chart\n\
10004 Add a point to a given pen of a given strip chart. There is no need\n\
10005 for all pens to have the same number of points or to be equally\n\
10006 sampled in the x coordinate. Allocates memory and rescales as\n\
10009 Redacted form: plstripa(id, pen, x, y)\n\
10011 This function is used in example 17.\n\
10017plstripa(id, pen, x, y)\n\
10021 id (PLINT, input) : Identification number of the strip chart (set\n\
10022 up in plstripc).\n\
10024 pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
10026 x (PLFLT, input) : X coordinate of point to plot.\n\
10028 y (PLFLT, input) : Y coordinate of point to plot.\n\
10031Set device-compression level\n\
10035 Set device-compression level. Only used for drivers that provide\n\
10036 compression. This function, if used, should be invoked before a call\n\
10039 Redacted form: plscompression(compression)\n\
10041 This function is used in example 31.\n\
10047plscompression(compression)\n\
10051 compression (PLINT, input) : The desired compression level. This is\n\
10052 a device-dependent value. Currently only the jpeg and png devices\n\
10053 use these values. For jpeg value is the jpeg quality which should\n\
10054 normally be in the range 0-95. Higher values denote higher quality\n\
10055 and hence larger image sizes. For png values are in the range -1\n\
10056 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
10057 A value of -1 denotes the default zlib compression level. Values\n\
10058 in the range 10-99 are divided by 10 and then used as the zlib\n\
10059 compression level. Higher compression levels correspond to greater\n\
10060 compression and small file sizes at the expense of more\n\
10064Specify viewport in absolute coordinates\n\
10068 Alternate routine to plvpor for setting up the viewport. This routine\n\
10069 should be used only if the viewport is required to have a definite\n\
10070 size in millimeters. The routine plgspa is useful for finding out the\n\
10071 size of the current subpage.\n\
10073 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
10075 This function is used in example 10.\n\
10081plsvpa(xmin, xmax, ymin, ymax)\n\
10085 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
10086 viewport from the left-hand edge of the subpage in millimeters.\n\
10088 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
10089 viewport from the left-hand edge of the subpage in millimeters.\n\
10091 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
10092 viewport from the bottom edge of the subpage in millimeters.\n\
10094 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
10095 from the bottom edge of the subpage in millimeters.\n\
10098Draw a polygon in 3 space\n\
10102 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10103 like plline3, but differs from that function in that plpoly3 attempts\n\
10104 to determine if the polygon is viewable depending on the order of the\n\
10105 points within the vector and the value of ifcc. If the back of\n\
10106 polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10107 you want, then use plline3 instead.\n\
10109 The points are assumed to be in a plane, and the directionality of the\n\
10110 plane is determined from the first three points. Additional points do\n\
10111 not have to lie on the plane defined by the first three, but if they\n\
10112 do not, then the determination of visibility obviously can\'t be 100%\n\
10113 accurate... So if you\'re 3 space polygons are too far from planar,\n\
10114 consider breaking them into smaller polygons. 3 points define a plane\n\
10117 Bugs: If one of the first two segments is of zero length, or if they\n\
10118 are co-linear, the calculation of visibility has a 50/50 chance of\n\
10119 being correct. Avoid such situations :-). See x18c.c for an example\n\
10120 of this problem. (Search for 20.1).\n\
10122 Redacted form: plpoly3(x, y, z, code)\n\
10124 This function is used in example 18.\n\
10130plpoly3(n, x, y, z, draw, ifcc)\n\
10134 n (PLINT, input) : Number of points defining line.\n\
10136 x (PLFLT_VECTOR, input) : A vector containing\n\
10137 n x coordinates of points.\n\
10139 y (PLFLT_VECTOR, input) : A vector containing\n\
10140 n y coordinates of points.\n\
10142 z (PLFLT_VECTOR, input) : A vector containing\n\
10143 n z coordinates of points.\n\
10145 draw (PLBOOL_VECTOR, input) : A vector containing\n\
10146 n-1 Boolean values which control drawing the segments of the polygon.\n\
10147 If draw[i] is true, then the polygon segment from index [i] to\n\
10148 [i+1] is drawn, otherwise, not.\n\
10150 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10151 polygon is determined by assuming the points are laid out in a\n\
10152 counter-clockwise order. Otherwise, the directionality of the\n\
10153 polygon is determined by assuming the points are laid out in a\n\
10154 clockwise order.\n\
10157Magnitude colored plot surface with contour\n\
10161 Aside from dropping the\n\
10162 side functionality this is a more powerful form of plot3d: the surface\n\
10163 mesh can be colored accordingly to the current z value being plotted,\n\
10164 a contour plot can be drawn at the base XY plane, and a curtain can be\n\
10165 drawn between the plotted function border and the base XY plane. The\n\
10166 arguments are identical to those of plmeshc. The only difference\n\
10167 between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
10168 the surface, while plot3dc only draws the surface as viewed from the\n\
10171 Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
10174 This function is used in example 21.\n\
10180plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
10184 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
10185 which the function is evaluated.\n\
10187 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
10188 which the function is evaluated.\n\
10190 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10191 plot. Should have dimensions of\n\
10195 nx (PLINT, input) : Number of x values at which function is\n\
10198 ny (PLINT, input) : Number of y values at which function is\n\
10201 opt (PLINT, input) : Determines the way in which the surface is\n\
10202 represented. To specify more than one option just add the options,\n\
10203 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
10204 showing z as a function of x for each value of y[j] .\n\
10205 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
10206 for each value of x[i] .\n\
10207 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
10208 at which function is defined.\n\
10209 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
10210 the z value being plotted. The color is used from the current\n\
10212 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
10213 using parameters\n\
10216 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
10217 the borders of the plotted function.\n\
10220 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
10223 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
10226Create a 4-pen strip chart\n\
10230 Create a 4-pen strip chart, to be used afterwards by plstripa\n\
10232 Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
10233 ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
10234 styline, legline, labx, laby, labz)\n\
10237 This function is used in example 17.\n\
10243plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
10247 id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
10248 number of the strip chart to use on plstripa and plstripd.\n\
10250 xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10251 the x-axis specification as in plbox.\n\
10253 yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10254 the y-axis specification as in plbox.\n\
10256 xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10257 change as data are added.\n\
10259 xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10260 change as data are added.\n\
10262 xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
10263 is multiplied by the factor (1 +\n\
10266 ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10267 change as data are added.\n\
10269 ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10270 change as data are added.\n\
10272 xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
10274 ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
10276 y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
10277 true, otherwise not.\n\
10279 acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
10280 otherwise slide display.\n\
10282 colbox (PLINT, input) : Plot box color index (cmap0).\n\
10284 collab (PLINT, input) : Legend color index (cmap0).\n\
10286 colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
10287 indices for the 4 pens.\n\
10289 styline (PLINT_VECTOR, input) : A vector containing the line style\n\
10290 indices for the 4 pens.\n\
10292 legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
10293 strings containing legends for the 4 pens.\n\
10295 labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10296 the label for the x axis.\n\
10298 laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10299 the label for the y axis.\n\
10301 labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10305Deletes and releases memory used by a strip chart\n\
10309 Deletes and releases memory used by a strip chart.\n\
10311 Redacted form: plstripd(id)\n\
10313 This function is used in example 17.\n\
10323 id (PLINT, input) : Identification number of strip chart to delete.\n\
10326Set cmap1 colors using a piece-wise linear relationship\n\
10330 Set cmap1 colors using a piece-wise linear relationship between the\n\
10331 cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
10332 (see the PLplot documentation). May be called at any time.\n\
10334 The idea here is to specify a number of control points that define the\n\
10335 mapping between input cmap1 intensity indices and HLS or RGB. Between\n\
10336 these points, linear interpolation is used which gives a smooth\n\
10337 variation of color with intensity index. Any number of control points\n\
10338 may be specified, located at arbitrary positions, although typically 2\n\
10339 - 4 are enough. Another way of stating this is that we are traversing\n\
10340 a given number of lines through HLS or RGB space as we move through\n\
10341 cmap1 intensity indices. The control points at the minimum and\n\
10342 maximum position (0 and 1) must always be specified. By adding more\n\
10343 control points you can get more variation. One good technique for\n\
10344 plotting functions that vary about some expected average is to use an\n\
10345 additional 2 control points in the center (position ~= 0.5) that are\n\
10346 the same lightness as the background (typically white for paper\n\
10347 output, black for crt), and same hue as the boundary control points.\n\
10348 This allows the highs and lows to be very easily distinguished.\n\
10350 Each control point must specify the cmap1 intensity index and the\n\
10351 associated three coordinates in HLS or RGB space. The first point\n\
10352 must correspond to position = 0, and the last to position = 1.\n\
10354 If RGB colors are provided then the interpolation takes place in RGB\n\
10355 space and is trivial. However if HLS colors are provided then, because\n\
10356 of the circular nature of the color wheel for the hue coordinate, the\n\
10357 interpolation could be performed in either direction around the color\n\
10358 wheel. The default behaviour is for the hue to be linearly\n\
10359 interpolated ignoring this circular property of hue. So for example,\n\
10360 the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\
10361 green and cyan. If instead you wish to interpolate the other way\n\
10362 around the color wheel you have two options. You may provide hues\n\
10363 outside the range [0, 360), so by using a hue of -120 for blue or 360\n\
10364 for red the interpolation will proceed via magenta. Alternatively you\n\
10365 can utilise the alt_hue_path variable to reverse the direction of\n\
10366 interpolation if you need to provide hues within the [0-360) range.\n\
10368 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
10369 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
10370 -120]falsegreen-yellow-red-magenta-blue[240\n\
10371 480]falseblue-magenta-red-yellow-green[120\n\
10372 240]truegreen-yellow-red-magenta-blue[240\n\
10373 120]trueblue-magenta-red-yellow-green\n\
10375 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
10376 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
10377 1]magnitudeHLSsaturation[0, 1]magnitude\n\
10379 Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
10382 This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
10388plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
10392 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
10394 npts (PLINT, input) : number of control points\n\
10396 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
10397 intensity index (0.0-1.0) in ascending order for each control\n\
10400 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
10401 coordinate (H or R) for each control point.\n\
10403 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
10404 coordinate (L or G) for each control point.\n\
10406 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
10407 coordinate (S or B) for each control point.\n\
10409 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
10410 npts - 1 elements), each containing either true to use the reversed\n\
10411 HLS interpolation or false to use the regular HLS interpolation.\n\
10412 (alt_hue_path[i] refers to the interpolation interval between the\n\
10413 i and i + 1 control points). This parameter is not used for RGB\n\
10418Shade individual region on the basis of value\n\
10422 Shade individual region on the basis of value. Use plshades if you\n\
10423 want to shade a number of contiguous regions using continuous colors.\n\
10424 In particular the edge contours are treated properly in plshades. If\n\
10425 you attempt to do contiguous regions with plshade the contours at the\n\
10426 edge of the shade are partially obliterated by subsequent plots of\n\
10427 contiguous shaded regions.\n\
10429 Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
10430 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
10431 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
10434 This function is used in example 15.\n\
10440plshade(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\
10444 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10445 plot. Should have dimensions of\n\
10449 nx (PLINT, input) : First dimension of the matrix \"a\".\n\
10451 ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
10453 defined (PLDEFINED_callback, input) : Callback function specifying\n\
10454 the region that should be plotted in the shade plot. This\n\
10455 function accepts x and y coordinates as input arguments and must\n\
10456 return 1 if the point is to be included in the shade plot and 0\n\
10457 otherwise. If you want to plot the entire shade plot (the usual\n\
10458 case), this argument should be set to NULL.\n\
10460 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
10461 pltr below for how these arguments are used (only for the special case\n\
10462 when the callback function\n\
10463 pltr is not supplied).\n\
10465 shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
10466 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10468 shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
10469 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10471 sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
10472 sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
10473 then sh_color is interpreted as a cmap1 argument in the range\n\
10476 sh_color (PLFLT, input) : Defines color map index with integer\n\
10477 value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
10479 sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
10481 min_color (PLINT, input) : Defines pen color, width used by the\n\
10482 boundary of shaded region. The min values are used for the\n\
10483 shade_min boundary, and the max values are used on the shade_max\n\
10484 boundary. Set color and width to zero for no plotted boundaries.\n\
10486 min_width (PLFLT, input) : Defines pen color, width used by the\n\
10487 boundary of shaded region. The min values are used for the\n\
10488 shade_min boundary, and the max values are used on the shade_max\n\
10489 boundary. Set color and width to zero for no plotted boundaries.\n\
10491 max_color (PLINT, input) : Defines pen color, width used by the\n\
10492 boundary of shaded region. The min values are used for the\n\
10493 shade_min boundary, and the max values are used on the shade_max\n\
10494 boundary. Set color and width to zero for no plotted boundaries.\n\
10496 max_width (PLFLT, input) : Defines pen color, width used by the\n\
10497 boundary of shaded region. The min values are used for the\n\
10498 shade_min boundary, and the max values are used on the shade_max\n\
10499 boundary. Set color and width to zero for no plotted boundaries.\n\
10501 fill (PLFILL_callback, input) : Routine used to fill the region.\n\
10502 Use plfill. Future version of PLplot may have other fill\n\
10505 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
10506 map to rectangles after coordinate transformation with pltrl.\n\
10507 Otherwise, set rectangular to false. If rectangular is set to\n\
10508 true, plshade tries to save time by filling large rectangles.\n\
10509 This optimization fails if the coordinate transformation distorts\n\
10510 the shape of rectangles. For example a plot in polar coordinates\n\
10511 has to have rectangular set to false.\n\
10513 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
10514 defines the transformation between the zero-based indices of the\n\
10515 matrix a and world coordinates. If\n\
10516 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
10517 indices of a are mapped to the range\n\
10519 xmax and the y indices of a are mapped to the range\n\
10521 ymax.For the C case, transformation functions are provided in the\n\
10522 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
10523 pltr2 for arbitrary mappings respectively defined by vectors and\n\
10524 matrices. In addition, C callback routines for the transformation\n\
10525 can be supplied by the user such as the mypltr function in\n\
10526 examples/c/x09c.c which provides a general linear transformation\n\
10527 between index coordinates and world coordinates.For languages\n\
10528 other than C you should consult the PLplot documentation for the\n\
10529 details concerning how PLTRANSFORM_callback arguments are\n\
10530 interfaced. However, in general, a particular pattern of\n\
10531 callback-associated arguments such as a tr vector with 6 elements;\n\
10532 xg and yg vectors; or xg and yg matrices are respectively\n\
10533 interfaced to a linear-transformation routine similar to the above\n\
10534 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
10535 sophisticated bindings (see, e.g., the PLplot documentation)\n\
10536 support native language callbacks for handling index to\n\
10537 world-coordinate transformations. Examples of these various\n\
10538 approaches are given in examples/<language>x09*,\n\
10539 examples/<language>x16*, examples/<language>x20*,\n\
10540 examples/<language>x21*, and examples/<language>x22*, for all our\n\
10541 supported languages.\n\
10543 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
10544 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
10545 externally supplied.\n\
10548Set number of colors in cmap1\n\
10552 Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
10553 values if this is the first allocation (see the PLplot documentation).\n\
10555 Redacted form: plscmap1n(ncol1)\n\
10557 This function is used in examples 8, 11, 20, and 21.\n\
10567 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
10568 the cmap1 palette. If this number is zero or less, then the value\n\
10569 from the previous call to plscmap1n is used and if there is no\n\
10570 previous call, then a default value is used.\n\
10573Advance to the next family file on the next new page\n\
10577 Advance to the next family file on the next new page.\n\
10579 Redacted form: plfamadv()\n\
10581 This function is not used in any examples.\n\
10590Set the escape character for text strings\n\
10594 Set the escape character for text strings. From C (in contrast to\n\
10595 Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
10596 characters are allowed to prevent the user from shooting himself in\n\
10597 the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
10598 use of backslash as a character escape). Here are the allowed escape\n\
10599 characters and their corresponding decimal ASCII values: !, ASCII 33\n\
10610 Redacted form: General: plsesc(esc)\n\
10613 This function is used in example 29.\n\
10623 esc (char, input) : Escape character.\n\
10625static const char* _wrap_plcolorbar_texinfo =
"-*- texinfo -*-\n\
10626Plot color bar for image, shade or gradient plots\n\
10630 Routine for creating a continuous color bar for image, shade, or\n\
10631 gradient plots. (See pllegend for similar functionality for creating\n\
10632 legends with discrete elements). The arguments of plcolorbar provide\n\
10633 control over the location and size of the color bar as well as the\n\
10634 location and characteristics of the elements (most of which are\n\
10635 optional) within that color bar. The resulting color bar is clipped\n\
10636 at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
10637 system used for some of the parameters is defined in the documentation\n\
10638 of the position parameter.)\n\
10640 Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
10641 position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
10642 low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
10643 labels, axis_opts, ticks, sub_ticks, values)\n\
10645 This function is used in examples 16 and 33.\n\
10651plcolorbar(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\
10655 p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10656 labelled and decorated color bar width in adopted coordinates.\n\
10658 p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10659 labelled and decorated color bar height in adopted coordinates.\n\
10661 opt (PLINT, input) : opt contains bits controlling the overall\n\
10662 color bar. The orientation (direction of the maximum value) of\n\
10663 the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
10664 PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
10665 specified, the default orientation is toward the top if the\n\
10666 colorbar is placed on the left or right of the viewport or toward\n\
10667 the right if the colorbar is placed on the top or bottom of the\n\
10668 viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
10669 (semitransparent) background for the color bar. If the\n\
10670 PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
10671 color bar. The type of color bar must be specified with one of\n\
10672 PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
10673 more than one of those bits is set only the first one in the above\n\
10674 list is honored. The position of the (optional) label/title can be\n\
10675 specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
10676 PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
10677 will be drawn. If more than one of this list of bits is specified,\n\
10678 only the first one on the list is honored. End-caps for the color\n\
10679 bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
10680 If a particular color bar cap option is not specified then no cap\n\
10681 will be drawn for that end. As a special case for\n\
10682 PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
10683 specified. If this option is provided then any tick marks and tick\n\
10684 labels will be placed at the breaks between shaded segments. TODO:\n\
10685 This should be expanded to support custom placement of tick marks\n\
10686 and tick labels at custom value locations for any color bar type.\n\
10688 position (PLINT, input) : position contains bits which control the\n\
10689 overall position of the color bar and the definition of the\n\
10690 adopted coordinates used for positions just like what is done for\n\
10691 the position argument for pllegend. However, note that the\n\
10692 defaults for the position bits (see below) are different than the\n\
10693 pllegend case. The combination of the PL_POSITION_LEFT,\n\
10694 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
10695 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
10696 the 16 possible standard positions (the 4 corners and centers of\n\
10697 the 4 sides for both the inside and outside cases) of the color\n\
10698 bar relative to the adopted coordinate system. The corner\n\
10699 positions are specified by the appropriate combination of two of\n\
10700 the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
10701 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
10702 value of one of those bits. The adopted coordinates are\n\
10703 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
10704 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
10705 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
10706 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
10707 then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
10708 PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
10709 PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
10710 PL_POSITION_VIEWPORT.\n\
10712 x (PLFLT, input) : X offset of the color bar position in adopted\n\
10713 coordinates from the specified standard position of the color bar.\n\
10714 For positive x, the direction of motion away from the standard\n\
10715 position is inward/outward from the standard corner positions or\n\
10716 standard left or right positions if the\n\
10717 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10718 For the standard top or bottom positions, the direction of motion\n\
10719 is toward positive X.\n\
10721 y (PLFLT, input) : Y offset of the color bar position in adopted\n\
10722 coordinates from the specified standard position of the color bar.\n\
10723 For positive y, the direction of motion away from the standard\n\
10724 position is inward/outward from the standard corner positions or\n\
10725 standard top or bottom positions if the\n\
10726 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10727 For the standard left or right positions, the direction of motion\n\
10728 is toward positive Y.\n\
10730 x_length (PLFLT, input) : Length of the body of the color bar in\n\
10731 the X direction in adopted coordinates.\n\
10733 y_length (PLFLT, input) : Length of the body of the color bar in\n\
10734 the Y direction in adopted coordinates.\n\
10736 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
10737 color bar (PL_COLORBAR_BACKGROUND).\n\
10739 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
10740 for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
10742 bb_style (PLINT, input) : The pllsty style number for the\n\
10743 bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
10745 low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
10746 bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
10748 high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
10749 color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
10751 cont_color (PLINT, input) : The cmap0 contour color for\n\
10752 PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
10753 it will be interpreted according to the design of plshades.\n\
10755 cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
10756 plots. This is passed directly to plshades, so it will be\n\
10757 interpreted according to the design of plshades.\n\
10759 n_labels (PLINT, input) : Number of labels to place around the\n\
10762 label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
10763 n_labels labels.\n\
10765 labels (PLCHAR_MATRIX, input) : A vector of\n\
10766 n_labels UTF-8 character strings containing the labels for the color\n\
10767 bar. Ignored if no label position is specified with one of the\n\
10768 PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
10769 PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
10770 corresponding label_opts field.\n\
10772 n_axes (PLINT, input) : Number of axis definitions provided. This\n\
10773 value must be greater than 0. It is typically 1 (numerical axis\n\
10774 labels are provided for one of the long edges of the color bar),\n\
10775 but it can be larger if multiple numerical axis labels for the\n\
10776 long edges of the color bar are desired.\n\
10778 axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
10779 n_axes ascii character strings containing options (interpreted as for\n\
10780 plbox) for the color bar\'s axis definitions.\n\
10782 ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
10783 spacing of the major tick marks (interpreted as for plbox) for the\n\
10784 color bar\'s axis definitions.\n\
10786 sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
10787 number of subticks (interpreted as for plbox) for the color bar\'s\n\
10788 axis definitions.\n\
10790 n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
10791 elements in each of the n_axes rows of the values matrix.\n\
10793 values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
10794 values for the data range represented by the color bar. For a row\n\
10795 index of i_axis (where 0 < i_axis < n_axes), the number of\n\
10796 elements in the row is specified by n_values[i_axis]. For\n\
10797 PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
10798 is 2, and the corresponding row elements of the values matrix are\n\
10799 the minimum and maximum value represented by the colorbar. For\n\
10800 PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
10801 of the values matrix is interpreted the same as the nlevel and\n\
10802 clevel arguments of plshades.\n\
10804static const char* _wrap_plsstrm_texinfo =
"-*- texinfo -*-\n\
10805Set current output stream\n\
10809 Sets the number of the current output stream. The stream number\n\
10810 defaults to 0 unless changed by this routine. The first use of this\n\
10811 routine must be followed by a call initializing PLplot (e.g. plstar).\n\
10813 Redacted form: plsstrm(strm)\n\
10815 This function is examples 1,14,20.\n\
10825 strm (PLINT, input) : The current stream number.\n\
10827static const char* _wrap_plgcompression_texinfo =
"-*- texinfo -*-\n\
10828Get the current device-compression setting\n\
10832 Get the current device-compression setting. This parameter is only\n\
10833 used for drivers that provide compression.\n\
10835 Redacted form: plgcompression(compression)\n\
10837 This function is used in example 31.\n\
10843plgcompression(compression)\n\
10847 compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
10848 compression setting for the current device.\n\
10850static const char* _wrap_plgriddata_texinfo =
"-*- texinfo -*-\n\
10851Grid data from irregularly sampled data\n\
10855 Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
10856 require data organized as a grid, i.e., with x sample point values\n\
10857 independent of y coordinate and vice versa. This function takes\n\
10858 irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
10859 vectors; reads the desired grid location from the input vectors\n\
10860 xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
10861 grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
10862 interpolate the data to the grid is specified with the argument type\n\
10863 which can have one parameter specified in argument data.\n\
10865 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
10866 Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
10869 This function is used in example 21.\n\
10875plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
10879 x (PLFLT_VECTOR, input) : The input x vector.\n\
10881 y (PLFLT_VECTOR, input) : The input y vector.\n\
10883 z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
10884 y[i], z[i] represents one data sample coordinate.\n\
10886 npts (PLINT, input) : The number of data samples in the x, y and z\n\
10889 xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10890 in the x direction. Usually xg has nptsx equally spaced values\n\
10891 from the minimum to the maximum values of the x input vector.\n\
10893 nptsx (PLINT, input) : The number of points in the xg vector.\n\
10895 yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10896 in the y direction. Similar to the xg parameter.\n\
10898 nptsy (PLINT, input) : The number of points in the yg vector.\n\
10900 zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
10901 where data lies in the grid specified by xg and yg. Therefore the\n\
10902 zg matrix must be dimensioned\n\
10906 type (PLINT, input) : The type of grid interpolation algorithm to\n\
10907 use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
10908 GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
10909 GRID_NNI: Natural Neighbors Interpolation\n\
10910 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
10911 GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
10912 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
10914 For details of the algorithms read the source file plgridd.c.\n\
10916 data (PLFLT, input) : Some gridding algorithms require extra data,\n\
10917 which can be specified through this argument. Currently, for\n\
10918 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
10919 use, the lower the value, the noisier (more local) the\n\
10920 approximation is.\n\
10921 GRID_NNLI, data specifies what a thin triangle is, in the\n\
10922 range [1. .. 2.]. High values enable the usage of very thin\n\
10923 triangles for interpolation, possibly resulting in error in\n\
10924 the approximation.\n\
10925 GRID_NNI, only weights greater than data will be accepted. If\n\
10926 0, all weights will be accepted.\n\
10932 char **arg3 = (
char **) 0 ;
10934 octave_value_list _out;
10935 octave_value_list *_outp=&_out;
10936 octave_value _outv;
10943 if (
_n_dims( args(0) ) > 1 )
10949 temp1 = args(0).matrix_value();
10953 charMatrix temp_matrix;
10957 size_t max_length = 0, non_blank_length;
10959 if (
_n_dims( args(1) ) > 2 )
10961 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
10963#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10964 if ( !args(1).isempty() )
10966 if ( !args(1).is_empty() )
10971 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
10973 arg3 =
new char*[
Alen];
10974#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10975 ifcell = args(1).iscell();
10977 ifcell = args(1).is_cell();
10981 temp_cell = args(1).cell_value();
10985 temp_matrix = args(1).char_matrix_value();
10987 max_length =
_dim( args(1), 1 ) + 1;
10990 for ( i = 0; i <
Alen; i++ )
10997 if ( temp_cell.elem( i ).is_string() )
10999 str = temp_cell.elem( i ).string_value();
11001 max_length = str.size() + 1;
11002 tmp_cstring = (
char *) str.c_str();
11012 tmp_cstring = (
char *)
"";
11017 str = temp_matrix.row_as_string( i );
11018 tmp_cstring = (
char *) str.c_str();
11020 arg3[i] =
new char[max_length];
11021 strncpy( arg3[i], tmp_cstring, max_length - 1 );
11022 arg3[i][max_length - 1] =
'\0';
11037 non_blank_length = max_length - 2;
11038 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
'\0' )
11040 non_blank_length--;
11042 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
' ' )
11044 non_blank_length--;
11046 arg3[i][non_blank_length + 1] =
'\0';
11055 testppchar(arg1,(
int const *)arg2,(
char const **)arg3);
11056 _outv = octave_value();
11063 if ( arg3 != NULL )
11065 for ( i = 0; i <
Alen; i++ )
11079 if ( arg3 != NULL )
11081 for ( i = 0; i <
Alen; i++ )
11088 return octave_value_list();
11096 if ( arg3 != NULL )
11098 for ( i = 0; i <
Alen; i++ )
11111 int *arg1 = (
int *) 0 ;
11112 int *arg2 = (
int *) 0 ;
11113 int *arg3 = (
int *) 0 ;
11114 char *arg4 = (
char *) 0 ;
11115 int *arg5 = (
int *) 0 ;
11116 int *arg6 = (
int *) 0 ;
11121 int *arg11 = (
int *) 0 ;
11128 char local_string4[80] ;
11143 size_t local_string_length4 ;
11144 charMatrix local_charMatrix4 ;
11145 octave_value_list retval4 ;
11146 octave_value_list _out;
11147 octave_value_list *_outp=&_out;
11148 octave_value _outv;
11156 arg4 = local_string4;
11168 result = (int)
my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11190 local_string_length4 = strlen( local_string4 );
11191 local_charMatrix4 = charMatrix( 1, local_string_length4 );
11192 local_charMatrix4.insert( local_string4, 0, 0 );
11193 retval4( 0 ) = octave_value( local_charMatrix4 );
11240 return octave_value_list();
11261 octave_value_list _out;
11262 octave_value_list *_outp=&_out;
11263 octave_value _outv;
11276 arg3 =
static_cast< PLFLT >(val3);
11281 arg4 =
static_cast< PLFLT >(val4);
11299 return octave_value_list();
11309 char *arg2 = (
char *) 0 ;
11310 char *arg3 = (
char *) 0 ;
11324 char *arg17 = (
char *) 0 ;
11325 char *arg18 = (
char *) 0 ;
11326 char *arg19 = (
char *) 0 ;
11327 char *arg20 = (
char *) 0 ;
11328 char *arg21 = (
char *) 0 ;
11329 char *arg22 = (
char *) 0 ;
11330 char *arg23 = (
char *) 0 ;
11384 octave_value_list _out;
11385 octave_value_list *_outp=&_out;
11386 octave_value _outv;
11397 arg2 =
reinterpret_cast< char *
>(buf2);
11402 arg3 =
reinterpret_cast< char *
>(buf3);
11407 arg4 =
static_cast< PLFLT >(val4);
11412 arg5 =
static_cast< PLFLT >(val5);
11417 arg6 =
static_cast< PLFLT >(val6);
11422 arg7 =
static_cast< PLFLT >(val7);
11427 arg8 =
static_cast< PLFLT >(val8);
11432 arg9 =
static_cast< PLFLT >(val9);
11437 arg10 =
static_cast< PLFLT >(val10);
11442 arg11 =
static_cast< PLBOOL >(val11);
11447 arg12 =
static_cast< PLBOOL >(val12);
11452 arg13 =
static_cast< PLINT >(val13);
11457 arg14 =
static_cast< PLINT >(val14);
11459 if (
_n_dims( args(13) ) > 1 )
11464 temp15 = args(13).matrix_value();
11469 if (
_n_dims( args(14) ) > 1 )
11473 if (
_dim( args(14), 0 ) !=
Alen )
11477 temp16 = args(14).matrix_value();
11485 arg17 =
reinterpret_cast< char *
>(buf17);
11490 arg18 =
reinterpret_cast< char *
>(buf18);
11495 arg19 =
reinterpret_cast< char *
>(buf19);
11500 arg20 =
reinterpret_cast< char *
>(buf20);
11505 arg21 =
reinterpret_cast< char *
>(buf21);
11510 arg22 =
reinterpret_cast< char *
>(buf22);
11515 arg23 =
reinterpret_cast< char *
>(buf23);
11516 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);
11517 _outv = octave_value();
11557 return octave_value_list();
11602 octave_value_list _out;
11603 octave_value_list *_outp=&_out;
11604 octave_value _outv;
11611 if (
_n_dims( args(0) ) > 2 )
11613 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11615 temp1 = args(0).matrix_value();
11616 arg1 = &temp1( 0, 0 );
11624 arg4 =
static_cast< PLINT >(val4);
11629 arg5 =
static_cast< PLINT >(val5);
11634 arg6 =
static_cast< PLINT >(val6);
11639 arg7 =
static_cast< PLINT >(val7);
11641 if (
_n_dims( args(5) ) > 1 )
11645 temp8 = args(5).matrix_value();
11646 arg8 = &temp8( 0, 0 );
11650 if (
_n_dims( args(6) ) > 1 )
11654 if (
_dim( args(6), 0 ) != 6 )
11658 temp10 = args(6).matrix_value();
11659 arg10 = &temp10( 0, 0 );
11661 my_plcont((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10);
11662 _outv = octave_value();
11684 return octave_value_list();
11721 octave_value_list _out;
11722 octave_value_list *_outp=&_out;
11723 octave_value _outv;
11730 if (
_n_dims( args(0) ) > 2 )
11732 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11734 temp1 = args(0).matrix_value();
11735 arg1 = &temp1( 0, 0 );
11743 arg4 =
static_cast< PLINT >(val4);
11748 arg5 =
static_cast< PLINT >(val5);
11753 arg6 =
static_cast< PLINT >(val6);
11758 arg7 =
static_cast< PLINT >(val7);
11760 if (
_n_dims( args(5) ) > 1 )
11764 temp8 = args(5).matrix_value();
11765 arg8 = &temp8( 0, 0 );
11768 my_plcont0((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9);
11769 _outv = octave_value();
11785 return octave_value_list();
11823 octave_value_list _out;
11824 octave_value_list *_outp=&_out;
11825 octave_value _outv;
11832 if (
_n_dims( args(0) ) > 2 )
11834 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11836 temp1 = args(0).matrix_value();
11837 arg1 = &temp1( 0, 0 );
11845 arg4 =
static_cast< PLINT >(val4);
11850 arg5 =
static_cast< PLINT >(val5);
11855 arg6 =
static_cast< PLINT >(val6);
11860 arg7 =
static_cast< PLINT >(val7);
11862 if (
_n_dims( args(5) ) > 1 )
11866 temp8 = args(5).matrix_value();
11867 arg8 = &temp8( 0, 0 );
11871 if (
_n_dims( args(6) ) > 1 )
11879 temp10 = args(6).matrix_value();
11880 arg10 = &temp10( 0, 0 );
11883 if (
_n_dims( args(7) ) > 1 )
11891 temp11 = args(7).matrix_value();
11892 arg11 = &temp11( 0, 0 );
11894 my_plcont1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11895 _outv = octave_value();
11923 return octave_value_list();
11967 octave_value_list _out;
11968 octave_value_list *_outp=&_out;
11969 octave_value _outv;
11976 if (
_n_dims( args(0) ) > 2 )
11978 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11980 temp1 = args(0).matrix_value();
11981 arg1 = &temp1( 0, 0 );
11989 arg4 =
static_cast< PLINT >(val4);
11994 arg5 =
static_cast< PLINT >(val5);
11999 arg6 =
static_cast< PLINT >(val6);
12004 arg7 =
static_cast< PLINT >(val7);
12006 if (
_n_dims( args(5) ) > 1 )
12010 temp8 = args(5).matrix_value();
12011 arg8 = &temp8( 0, 0 );
12015 if (
_n_dims( args(6) ) > 2 )
12017 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12021 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12025 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12027 temp10 = args(6).matrix_value();
12028 arg10 = &temp10( 0, 0 );
12031 if (
_n_dims( args(7) ) > 2 )
12033 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12037 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12041 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12043 temp11 = args(7).matrix_value();
12044 arg11 = &temp11( 0, 0 );
12046 my_plcont2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
12047 _outv = octave_value();
12075 return octave_value_list();
12119 octave_value_list _out;
12120 octave_value_list *_outp=&_out;
12121 octave_value _outv;
12128 if (
_n_dims( args(0) ) > 2 )
12130 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12132 temp1 = args(0).matrix_value();
12133 arg1 = &temp1( 0, 0 );
12141 arg4 =
static_cast< PLINT >(val4);
12146 arg5 =
static_cast< PLINT >(val5);
12151 arg6 =
static_cast< PLINT >(val6);
12156 arg7 =
static_cast< PLINT >(val7);
12158 if (
_n_dims( args(5) ) > 1 )
12162 temp8 = args(5).matrix_value();
12163 arg8 = &temp8( 0, 0 );
12167 if (
_n_dims( args(6) ) > 2 )
12169 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12173 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12177 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12179 temp10 = args(6).matrix_value();
12180 arg10 = &temp10( 0, 0 );
12183 if (
_n_dims( args(7) ) > 2 )
12185 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12189 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12193 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12195 temp11 = args(7).matrix_value();
12196 arg11 = &temp11( 0, 0 );
12198 my_plcont2p((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
12199 _outv = octave_value();
12227 return octave_value_list();
12264 octave_value_list retval7 ;
12269 octave_value_list _out;
12270 octave_value_list *_outp=&_out;
12271 octave_value _outv;
12278 if (
_n_dims( args(0) ) > 1 )
12283 temp1 = args(0).matrix_value();
12284 arg1 = &temp1( 0, 0 );
12287 if (
_n_dims( args(1) ) > 1 )
12295 temp2 = args(1).matrix_value();
12296 arg2 = &temp2( 0, 0 );
12299 if (
_n_dims( args(2) ) > 1 )
12307 temp3 = args(2).matrix_value();
12308 arg3 = &temp3( 0, 0 );
12312 if (
_n_dims( args(3) ) > 1 )
12316 temp5 = args(3).matrix_value();
12317 arg5 = &temp5( 0, 0 );
12321 if (
_n_dims( args(4) ) > 1 )
12325 temp7 = args(4).matrix_value();
12326 arg7 = &temp7( 0, 0 );
12328 retval7( 0 ) = octave_value( Matrix(
Xlen,
Ylen ) );
12329 arg9 = (
PLFLT *) retval7( 0 ).matrix_value().data();
12335 arg10 =
static_cast< PLINT >(val10);
12340 arg11 =
static_cast< PLFLT >(val11);
12341 my_plgriddata((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,(
double const *)arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,arg11);
12342 _outv = octave_value();
12379 return octave_value_list();
12414 octave_value_list _out;
12415 octave_value_list *_outp=&_out;
12416 octave_value _outv;
12423 if (
_n_dims( args(0) ) > 1 )
12427 temp1 = args(0).matrix_value();
12428 arg1 = &temp1( 0, 0 );
12432 if (
_n_dims( args(1) ) > 1 )
12436 temp2 = args(1).matrix_value();
12437 arg2 = &temp2( 0, 0 );
12441 if (
_n_dims( args(2) ) > 2 )
12443 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12447 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12451 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12453 temp3 = args(2).matrix_value();
12454 arg3 = &temp3( 0, 0 );
12462 arg6 =
static_cast< PLINT >(val6);
12463 my_plmesh((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6);
12464 _outv = octave_value();
12486 return octave_value_list();
12518 octave_value_list _out;
12519 octave_value_list *_outp=&_out;
12520 octave_value _outv;
12527 if (
_n_dims( args(0) ) > 1 )
12531 temp1 = args(0).matrix_value();
12532 arg1 = &temp1( 0, 0 );
12536 if (
_n_dims( args(1) ) > 1 )
12540 temp2 = args(1).matrix_value();
12541 arg2 = &temp2( 0, 0 );
12545 if (
_n_dims( args(2) ) > 2 )
12547 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12551 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12555 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12557 temp3 = args(2).matrix_value();
12558 arg3 = &temp3( 0, 0 );
12566 arg6 =
static_cast< PLINT >(val6);
12568 if (
_n_dims( args(4) ) > 1 )
12572 temp7 = args(4).matrix_value();
12573 arg7 = &temp7( 0, 0 );
12576 my_plmeshc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12577 _outv = octave_value();
12605 return octave_value_list();
12640 octave_value_list _out;
12641 octave_value_list *_outp=&_out;
12642 octave_value _outv;
12649 if (
_n_dims( args(0) ) > 1 )
12653 temp1 = args(0).matrix_value();
12654 arg1 = &temp1( 0, 0 );
12658 if (
_n_dims( args(1) ) > 1 )
12662 temp2 = args(1).matrix_value();
12663 arg2 = &temp2( 0, 0 );
12667 if (
_n_dims( args(2) ) > 2 )
12669 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12673 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12677 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12679 temp3 = args(2).matrix_value();
12680 arg3 = &temp3( 0, 0 );
12688 arg6 =
static_cast< PLINT >(val6);
12693 arg7 =
static_cast< PLBOOL >(val7);
12694 my_plot3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,arg7);
12695 _outv = octave_value();
12717 return octave_value_list();
12749 octave_value_list _out;
12750 octave_value_list *_outp=&_out;
12751 octave_value _outv;
12758 if (
_n_dims( args(0) ) > 1 )
12762 temp1 = args(0).matrix_value();
12763 arg1 = &temp1( 0, 0 );
12767 if (
_n_dims( args(1) ) > 1 )
12771 temp2 = args(1).matrix_value();
12772 arg2 = &temp2( 0, 0 );
12776 if (
_n_dims( args(2) ) > 2 )
12778 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12782 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12786 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12788 temp3 = args(2).matrix_value();
12789 arg3 = &temp3( 0, 0 );
12797 arg6 =
static_cast< PLINT >(val6);
12799 if (
_n_dims( args(4) ) > 1 )
12803 temp7 = args(4).matrix_value();
12804 arg7 = &temp7( 0, 0 );
12807 my_plot3dc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12808 _outv = octave_value();
12836 return octave_value_list();
12879 octave_value_list _out;
12880 octave_value_list *_outp=&_out;
12881 octave_value _outv;
12888 if (
_n_dims( args(0) ) > 1 )
12892 temp1 = args(0).matrix_value();
12893 arg1 = &temp1( 0, 0 );
12897 if (
_n_dims( args(1) ) > 1 )
12901 temp2 = args(1).matrix_value();
12902 arg2 = &temp2( 0, 0 );
12906 if (
_n_dims( args(2) ) > 2 )
12908 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12912 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12916 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12918 temp3 = args(2).matrix_value();
12919 arg3 = &temp3( 0, 0 );
12927 arg6 =
static_cast< PLINT >(val6);
12929 if (
_n_dims( args(4) ) > 1 )
12933 temp7 = args(4).matrix_value();
12934 arg7 = &temp7( 0, 0 );
12941 arg9 =
static_cast< PLINT >(val9);
12943 if (
_n_dims( args(6) ) > 1 )
12949 temp10 = args(6).matrix_value();
12953 if (
_n_dims( args(7) ) > 1 )
12961 temp12 = args(7).matrix_value();
12965 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);
12966 _outv = octave_value();
13006 return octave_value_list();
13047 octave_value_list _out;
13048 octave_value_list *_outp=&_out;
13049 octave_value _outv;
13056 if (
_n_dims( args(0) ) > 1 )
13060 temp1 = args(0).matrix_value();
13061 arg1 = &temp1( 0, 0 );
13065 if (
_n_dims( args(1) ) > 1 )
13069 temp2 = args(1).matrix_value();
13070 arg2 = &temp2( 0, 0 );
13074 if (
_n_dims( args(2) ) > 2 )
13076 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13080 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13084 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13086 temp3 = args(2).matrix_value();
13087 arg3 = &temp3( 0, 0 );
13095 arg6 =
static_cast< PLINT >(val6);
13097 if (
_n_dims( args(4) ) > 1 )
13101 temp7 = args(4).matrix_value();
13102 arg7 = &temp7( 0, 0 );
13105 my_plsurf3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
13106 _outv = octave_value();
13134 return octave_value_list();
13177 octave_value_list _out;
13178 octave_value_list *_outp=&_out;
13179 octave_value _outv;
13186 if (
_n_dims( args(0) ) > 1 )
13190 temp1 = args(0).matrix_value();
13191 arg1 = &temp1( 0, 0 );
13195 if (
_n_dims( args(1) ) > 1 )
13199 temp2 = args(1).matrix_value();
13200 arg2 = &temp2( 0, 0 );
13204 if (
_n_dims( args(2) ) > 2 )
13206 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13210 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13214 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13216 temp3 = args(2).matrix_value();
13217 arg3 = &temp3( 0, 0 );
13225 arg6 =
static_cast< PLINT >(val6);
13227 if (
_n_dims( args(4) ) > 1 )
13231 temp7 = args(4).matrix_value();
13232 arg7 = &temp7( 0, 0 );
13239 arg9 =
static_cast< PLINT >(val9);
13241 if (
_n_dims( args(6) ) > 1 )
13247 temp10 = args(6).matrix_value();
13251 if (
_n_dims( args(7) ) > 1 )
13259 temp12 = args(7).matrix_value();
13263 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);
13264 _outv = octave_value();
13304 return octave_value_list();
13381 octave_value_list _out;
13382 octave_value_list *_outp=&_out;
13383 octave_value _outv;
13390 if (
_n_dims( args(0) ) > 2 )
13392 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13394 temp1 = args(0).matrix_value();
13395 arg1 = &temp1( 0, 0 );
13400 if (
_n_dims( args(1) ) > 1 )
13405 temp4 = args(1).matrix_value();
13406 arg4 = &temp4( 0, 0 );
13412 arg5 =
static_cast< PLFLT >(val5);
13417 arg6 =
static_cast< PLFLT >(val6);
13422 arg7 =
static_cast< PLFLT >(val7);
13427 arg8 =
static_cast< PLFLT >(val8);
13432 arg9 =
static_cast< PLFLT >(val9);
13437 arg10 =
static_cast< PLFLT >(val10);
13442 arg11 =
static_cast< PLINT >(val11);
13447 arg12 =
static_cast< PLFLT >(val12);
13452 arg13 =
static_cast< PLINT >(val13);
13457 arg14 =
static_cast< PLINT >(val14);
13462 arg15 =
static_cast< PLINT >(val15);
13467 arg16 =
static_cast< PLINT >(val16);
13472 arg17 =
static_cast< PLINT >(val17);
13477 arg18 =
static_cast< PLBOOL >(val18);
13479 if (
_n_dims( args(16) ) > 1 )
13483 if (
_dim( args(16), 0 ) != 6 )
13487 temp19 = args(16).matrix_value();
13488 arg19 = &temp19( 0, 0 );
13490 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);
13491 _outv = octave_value();
13513 return octave_value_list();
13534 char *arg4 = (
char *) 0 ;
13585 octave_value_list _out;
13586 octave_value_list *_outp=&_out;
13587 octave_value _outv;
13594 if (
_n_dims( args(0) ) > 2 )
13596 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13598 temp1 = args(0).matrix_value();
13599 arg1 = &temp1( 0, 0 );
13607 arg4 =
reinterpret_cast< char *
>(buf4);
13612 arg5 =
static_cast< PLFLT >(val5);
13617 arg6 =
static_cast< PLFLT >(val6);
13622 arg7 =
static_cast< PLFLT >(val7);
13627 arg8 =
static_cast< PLFLT >(val8);
13632 arg9 =
static_cast< PLFLT >(val9);
13637 arg10 =
static_cast< PLFLT >(val10);
13642 arg11 =
static_cast< PLINT >(val11);
13647 arg12 =
static_cast< PLFLT >(val12);
13652 arg13 =
static_cast< PLINT >(val13);
13657 arg14 =
static_cast< PLINT >(val14);
13662 arg15 =
static_cast< PLINT >(val15);
13667 arg16 =
static_cast< PLINT >(val16);
13672 arg17 =
static_cast< PLINT >(val17);
13677 arg18 =
static_cast< PLBOOL >(val18);
13679 if (
_n_dims( args(16) ) > 1 )
13683 if (
_dim( args(16), 0 ) !=
Xlen )
13687 temp19 = args(16).matrix_value();
13688 arg19 = &temp19( 0, 0 );
13691 if (
_n_dims( args(17) ) > 1 )
13695 if (
_dim( args(17), 0 ) !=
Ylen )
13699 temp20 = args(17).matrix_value();
13700 arg20 = &temp20( 0, 0 );
13702 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);
13703 _outv = octave_value();
13727 return octave_value_list();
13749 char *arg4 = (
char *) 0 ;
13800 octave_value_list _out;
13801 octave_value_list *_outp=&_out;
13802 octave_value _outv;
13809 if (
_n_dims( args(0) ) > 2 )
13811 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13813 temp1 = args(0).matrix_value();
13814 arg1 = &temp1( 0, 0 );
13822 arg4 =
reinterpret_cast< char *
>(buf4);
13827 arg5 =
static_cast< PLFLT >(val5);
13832 arg6 =
static_cast< PLFLT >(val6);
13837 arg7 =
static_cast< PLFLT >(val7);
13842 arg8 =
static_cast< PLFLT >(val8);
13847 arg9 =
static_cast< PLFLT >(val9);
13852 arg10 =
static_cast< PLFLT >(val10);
13857 arg11 =
static_cast< PLINT >(val11);
13862 arg12 =
static_cast< PLFLT >(val12);
13867 arg13 =
static_cast< PLINT >(val13);
13872 arg14 =
static_cast< PLINT >(val14);
13877 arg15 =
static_cast< PLINT >(val15);
13882 arg16 =
static_cast< PLINT >(val16);
13887 arg17 =
static_cast< PLINT >(val17);
13892 arg18 =
static_cast< PLBOOL >(val18);
13894 if (
_n_dims( args(16) ) > 2 )
13896 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13898 temp19 = args(16).matrix_value();
13899 arg19 = &temp19( 0, 0 );
13904 if (
_n_dims( args(17) ) > 2 )
13906 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13908 temp20 = args(17).matrix_value();
13909 arg20 = &temp20( 0, 0 );
13913 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);
13914 _outv = octave_value();
13938 return octave_value_list();
13988 octave_value_list _out;
13989 octave_value_list *_outp=&_out;
13990 octave_value _outv;
13997 if (
_n_dims( args(0) ) > 2 )
13999 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14001 temp1 = args(0).matrix_value();
14002 arg1 = &temp1( 0, 0 );
14010 arg4 =
static_cast< PLFLT >(val4);
14015 arg5 =
static_cast< PLFLT >(val5);
14020 arg6 =
static_cast< PLFLT >(val6);
14025 arg7 =
static_cast< PLFLT >(val7);
14027 if (
_n_dims( args(5) ) > 1 )
14031 temp8 = args(5).matrix_value();
14032 arg8 = &temp8( 0, 0 );
14039 arg10 =
static_cast< PLINT >(val10);
14044 arg11 =
static_cast< PLINT >(val11);
14049 arg12 =
static_cast< PLINT >(val12);
14054 arg13 =
static_cast< PLBOOL >(val13);
14055 my_plshades((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13);
14056 _outv = octave_value();
14072 return octave_value_list();
14120 octave_value_list _out;
14121 octave_value_list *_outp=&_out;
14122 octave_value _outv;
14129 if (
_n_dims( args(0) ) > 2 )
14131 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14133 temp1 = args(0).matrix_value();
14134 arg1 = &temp1( 0, 0 );
14142 arg4 =
static_cast< PLFLT >(val4);
14147 arg5 =
static_cast< PLFLT >(val5);
14152 arg6 =
static_cast< PLFLT >(val6);
14157 arg7 =
static_cast< PLFLT >(val7);
14159 if (
_n_dims( args(5) ) > 1 )
14163 temp8 = args(5).matrix_value();
14164 arg8 = &temp8( 0, 0 );
14171 arg10 =
static_cast< PLINT >(val10);
14176 arg11 =
static_cast< PLINT >(val11);
14181 arg12 =
static_cast< PLINT >(val12);
14186 arg13 =
static_cast< PLBOOL >(val13);
14188 if (
_n_dims( args(10) ) > 1 )
14192 if (
_dim( args(10), 0 ) != 6 )
14196 temp14 = args(10).matrix_value();
14197 arg14 = &temp14( 0, 0 );
14199 my_plshadesx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
14200 _outv = octave_value();
14222 return octave_value_list();
14275 octave_value_list _out;
14276 octave_value_list *_outp=&_out;
14277 octave_value _outv;
14284 if (
_n_dims( args(0) ) > 2 )
14286 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14288 temp1 = args(0).matrix_value();
14289 arg1 = &temp1( 0, 0 );
14297 arg4 =
static_cast< PLFLT >(val4);
14302 arg5 =
static_cast< PLFLT >(val5);
14307 arg6 =
static_cast< PLFLT >(val6);
14312 arg7 =
static_cast< PLFLT >(val7);
14314 if (
_n_dims( args(5) ) > 1 )
14318 temp8 = args(5).matrix_value();
14319 arg8 = &temp8( 0, 0 );
14326 arg10 =
static_cast< PLINT >(val10);
14331 arg11 =
static_cast< PLINT >(val11);
14336 arg12 =
static_cast< PLINT >(val12);
14341 arg13 =
static_cast< PLBOOL >(val13);
14343 if (
_n_dims( args(10) ) > 1 )
14347 if (
_dim( args(10), 0 ) !=
Xlen )
14351 temp14 = args(10).matrix_value();
14352 arg14 = &temp14( 0, 0 );
14355 if (
_n_dims( args(11) ) > 1 )
14359 if (
_dim( args(11), 0 ) !=
Ylen )
14363 temp15 = args(11).matrix_value();
14364 arg15 = &temp15( 0, 0 );
14366 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);
14367 _outv = octave_value();
14395 return octave_value_list();
14451 octave_value_list _out;
14452 octave_value_list *_outp=&_out;
14453 octave_value _outv;
14460 if (
_n_dims( args(0) ) > 2 )
14462 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14464 temp1 = args(0).matrix_value();
14465 arg1 = &temp1( 0, 0 );
14473 arg4 =
static_cast< PLFLT >(val4);
14478 arg5 =
static_cast< PLFLT >(val5);
14483 arg6 =
static_cast< PLFLT >(val6);
14488 arg7 =
static_cast< PLFLT >(val7);
14490 if (
_n_dims( args(5) ) > 1 )
14494 temp8 = args(5).matrix_value();
14495 arg8 = &temp8( 0, 0 );
14502 arg10 =
static_cast< PLINT >(val10);
14507 arg11 =
static_cast< PLINT >(val11);
14512 arg12 =
static_cast< PLINT >(val12);
14517 arg13 =
static_cast< PLBOOL >(val13);
14519 if (
_n_dims( args(10) ) > 2 )
14521 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14523 temp14 = args(10).matrix_value();
14524 arg14 = &temp14( 0, 0 );
14529 if (
_n_dims( args(11) ) > 2 )
14531 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14533 temp15 = args(11).matrix_value();
14534 arg15 = &temp15( 0, 0 );
14538 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);
14539 _outv = octave_value();
14567 return octave_value_list();
14599 octave_value_list _out;
14600 octave_value_list *_outp=&_out;
14601 octave_value _outv;
14608 if (
_n_dims( args(0) ) > 2 )
14610 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14612 temp1 = args(0).matrix_value();
14613 arg1 = &temp1( 0, 0 );
14618 if (
_n_dims( args(1) ) > 2 )
14620 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14624 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14628 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14630 temp2 = args(1).matrix_value();
14631 arg2 = &temp2( 0, 0 );
14639 arg5 =
static_cast< PLFLT >(val5);
14641 if (
_n_dims( args(3) ) > 1 )
14645 if (
_dim( args(3), 0 ) != 6 )
14649 temp6 = args(3).matrix_value();
14650 arg6 = &temp6( 0, 0 );
14652 my_plvect((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
14653 _outv = octave_value();
14675 return octave_value_list();
14706 octave_value_list _out;
14707 octave_value_list *_outp=&_out;
14708 octave_value _outv;
14715 if (
_n_dims( args(0) ) > 2 )
14717 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14719 temp1 = args(0).matrix_value();
14720 arg1 = &temp1( 0, 0 );
14725 if (
_n_dims( args(1) ) > 2 )
14727 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14731 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14735 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14737 temp2 = args(1).matrix_value();
14738 arg2 = &temp2( 0, 0 );
14746 arg5 =
static_cast< PLFLT >(val5);
14748 if (
_n_dims( args(3) ) > 1 )
14756 temp6 = args(3).matrix_value();
14757 arg6 = &temp6( 0, 0 );
14760 if (
_n_dims( args(4) ) > 1 )
14768 temp7 = args(4).matrix_value();
14769 arg7 = &temp7( 0, 0 );
14771 my_plvect1((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14772 _outv = octave_value();
14800 return octave_value_list();
14834 octave_value_list _out;
14835 octave_value_list *_outp=&_out;
14836 octave_value _outv;
14843 if (
_n_dims( args(0) ) > 2 )
14845 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14847 temp1 = args(0).matrix_value();
14848 arg1 = &temp1( 0, 0 );
14853 if (
_n_dims( args(1) ) > 2 )
14855 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14859 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14863 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14865 temp2 = args(1).matrix_value();
14866 arg2 = &temp2( 0, 0 );
14874 arg5 =
static_cast< PLFLT >(val5);
14876 if (
_n_dims( args(3) ) > 2 )
14878 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14880 temp6 = args(3).matrix_value();
14881 arg6 = &temp6( 0, 0 );
14886 if (
_n_dims( args(4) ) > 2 )
14888 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14890 temp7 = args(4).matrix_value();
14891 arg7 = &temp7( 0, 0 );
14895 my_plvect2((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14896 _outv = octave_value();
14924 return octave_value_list();
14979 octave_value_list _out;
14980 octave_value_list *_outp=&_out;
14981 octave_value _outv;
14988 if (
_n_dims( args(0) ) > 2 )
14990 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14992 temp1 = args(0).matrix_value();
14993 arg1 = &temp1( 0, 0 );
15001 arg4 =
static_cast< PLFLT >(val4);
15006 arg5 =
static_cast< PLFLT >(val5);
15011 arg6 =
static_cast< PLFLT >(val6);
15016 arg7 =
static_cast< PLFLT >(val7);
15021 arg8 =
static_cast< PLFLT >(val8);
15026 arg9 =
static_cast< PLFLT >(val9);
15031 arg10 =
static_cast< PLFLT >(val10);
15036 arg11 =
static_cast< PLFLT >(val11);
15041 arg12 =
static_cast< PLFLT >(val12);
15046 arg13 =
static_cast< PLFLT >(val13);
15047 my_plimage((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15048 _outv = octave_value();
15058 return octave_value_list();
15098 octave_value_list _out;
15099 octave_value_list *_outp=&_out;
15100 octave_value _outv;
15107 if (
_n_dims( args(0) ) > 2 )
15109 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15111 temp1 = args(0).matrix_value();
15112 arg1 = &temp1( 0, 0 );
15120 arg4 =
static_cast< PLFLT >(val4);
15125 arg5 =
static_cast< PLFLT >(val5);
15130 arg6 =
static_cast< PLFLT >(val6);
15135 arg7 =
static_cast< PLFLT >(val7);
15140 arg8 =
static_cast< PLFLT >(val8);
15145 arg9 =
static_cast< PLFLT >(val9);
15150 arg10 =
static_cast< PLFLT >(val10);
15155 arg11 =
static_cast< PLFLT >(val11);
15156 my_plimagefr((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
15157 _outv = octave_value();
15167 return octave_value_list();
15209 octave_value_list _out;
15210 octave_value_list *_outp=&_out;
15211 octave_value _outv;
15218 if (
_n_dims( args(0) ) > 2 )
15220 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15222 temp1 = args(0).matrix_value();
15223 arg1 = &temp1( 0, 0 );
15231 arg4 =
static_cast< PLFLT >(val4);
15236 arg5 =
static_cast< PLFLT >(val5);
15241 arg6 =
static_cast< PLFLT >(val6);
15246 arg7 =
static_cast< PLFLT >(val7);
15251 arg8 =
static_cast< PLFLT >(val8);
15256 arg9 =
static_cast< PLFLT >(val9);
15261 arg10 =
static_cast< PLFLT >(val10);
15266 arg11 =
static_cast< PLFLT >(val11);
15268 if (
_n_dims( args(9) ) > 1 )
15272 if (
_dim( args(9), 0 ) != 6 )
15276 temp12 = args(9).matrix_value();
15277 arg12 = &temp12( 0, 0 );
15279 my_plimagefrx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
15280 _outv = octave_value();
15296 return octave_value_list();
15343 octave_value_list _out;
15344 octave_value_list *_outp=&_out;
15345 octave_value _outv;
15352 if (
_n_dims( args(0) ) > 2 )
15354 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15356 temp1 = args(0).matrix_value();
15357 arg1 = &temp1( 0, 0 );
15365 arg4 =
static_cast< PLFLT >(val4);
15370 arg5 =
static_cast< PLFLT >(val5);
15375 arg6 =
static_cast< PLFLT >(val6);
15380 arg7 =
static_cast< PLFLT >(val7);
15385 arg8 =
static_cast< PLFLT >(val8);
15390 arg9 =
static_cast< PLFLT >(val9);
15395 arg10 =
static_cast< PLFLT >(val10);
15400 arg11 =
static_cast< PLFLT >(val11);
15402 if (
_n_dims( args(9) ) > 1 )
15410 temp12 = args(9).matrix_value();
15411 arg12 = &temp12( 0, 0 );
15414 if (
_n_dims( args(10) ) > 1 )
15418 if (
_dim( args(10), 0 ) !=
Ylen )
15422 temp13 = args(10).matrix_value();
15423 arg13 = &temp13( 0, 0 );
15425 my_plimagefr1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
15426 _outv = octave_value();
15448 return octave_value_list();
15498 octave_value_list _out;
15499 octave_value_list *_outp=&_out;
15500 octave_value _outv;
15507 if (
_n_dims( args(0) ) > 2 )
15509 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15511 temp1 = args(0).matrix_value();
15512 arg1 = &temp1( 0, 0 );
15520 arg4 =
static_cast< PLFLT >(val4);
15525 arg5 =
static_cast< PLFLT >(val5);
15530 arg6 =
static_cast< PLFLT >(val6);
15535 arg7 =
static_cast< PLFLT >(val7);
15540 arg8 =
static_cast< PLFLT >(val8);
15545 arg9 =
static_cast< PLFLT >(val9);
15550 arg10 =
static_cast< PLFLT >(val10);
15555 arg11 =
static_cast< PLFLT >(val11);
15557 if (
_n_dims( args(9) ) > 2 )
15559 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15561 temp12 = args(9).matrix_value();
15562 arg12 = &temp12( 0, 0 );
15567 if (
_n_dims( args(10) ) > 2 )
15569 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15571 temp13 = args(10).matrix_value();
15572 arg13 = &temp13( 0, 0 );
15576 my_plimagefr2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
15577 _outv = octave_value();
15599 return octave_value_list();
15634 char **arg18 = (
char **) 0 ;
15636 char **arg20 = (
char **) 0 ;
15676 octave_value_list _out;
15677 octave_value_list *_outp=&_out;
15678 octave_value _outv;
15690 arg3 =
static_cast< PLINT >(val3);
15695 arg4 =
static_cast< PLINT >(val4);
15700 arg5 =
static_cast< PLFLT >(val5);
15705 arg6 =
static_cast< PLFLT >(val6);
15710 arg7 =
static_cast< PLFLT >(val7);
15715 arg8 =
static_cast< PLFLT >(val8);
15720 arg9 =
static_cast< PLINT >(val9);
15725 arg10 =
static_cast< PLINT >(val10);
15730 arg11 =
static_cast< PLINT >(val11);
15735 arg12 =
static_cast< PLFLT >(val12);
15740 arg13 =
static_cast< PLFLT >(val13);
15745 arg14 =
static_cast< PLINT >(val14);
15750 arg15 =
static_cast< PLFLT >(val15);
15752 if (
_n_dims( args(13) ) > 1 )
15758 temp16 = args(13).matrix_value();
15762 charMatrix temp_matrix;
15766 size_t max_length = 0, non_blank_length;
15768 if (
_n_dims( args(14) ) > 2 )
15770 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
15772#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15773 if ( !args(14).isempty() )
15775 if ( !args(14).is_empty() )
15778 if (
_dim( args(14), 0 ) !=
Alen )
15780 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
15782 arg18 =
new char*[
Alen];
15783#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15784 ifcell = args(14).iscell();
15786 ifcell = args(14).is_cell();
15790 temp_cell = args(14).cell_value();
15794 temp_matrix = args(14).char_matrix_value();
15796 max_length =
_dim( args(14), 1 ) + 1;
15799 for ( i = 0; i <
Alen; i++ )
15806 if ( temp_cell.elem( i ).is_string() )
15808 str = temp_cell.elem( i ).string_value();
15810 max_length = str.size() + 1;
15811 tmp_cstring = (
char *) str.c_str();
15821 tmp_cstring = (
char *)
"";
15826 str = temp_matrix.row_as_string( i );
15827 tmp_cstring = (
char *) str.c_str();
15829 arg18[i] =
new char[max_length];
15830 strncpy( arg18[i], tmp_cstring, max_length - 1 );
15831 arg18[i][max_length - 1] =
'\0';
15846 non_blank_length = max_length - 2;
15847 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
'\0' )
15849 non_blank_length--;
15851 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
' ' )
15853 non_blank_length--;
15855 arg18[i][non_blank_length + 1] =
'\0';
15865 charMatrix temp_matrix;
15869 size_t max_length = 0, non_blank_length;
15871 if (
_n_dims( args(15) ) > 2 )
15873 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
15875#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15876 if ( !args(15).isempty() )
15878 if ( !args(15).is_empty() )
15883 arg20 =
new char*[
Alen];
15884#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15885 ifcell = args(15).iscell();
15887 ifcell = args(15).is_cell();
15891 temp_cell = args(15).cell_value();
15895 temp_matrix = args(15).char_matrix_value();
15897 max_length =
_dim( args(15), 1 ) + 1;
15900 for ( i = 0; i <
Alen; i++ )
15907 if ( temp_cell.elem( i ).is_string() )
15909 str = temp_cell.elem( i ).string_value();
15911 max_length = str.size() + 1;
15912 tmp_cstring = (
char *) str.c_str();
15922 tmp_cstring = (
char *)
"";
15927 str = temp_matrix.row_as_string( i );
15928 tmp_cstring = (
char *) str.c_str();
15930 arg20[i] =
new char[max_length];
15931 strncpy( arg20[i], tmp_cstring, max_length - 1 );
15932 arg20[i][max_length - 1] =
'\0';
15947 non_blank_length = max_length - 2;
15948 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
15950 non_blank_length--;
15952 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
15954 non_blank_length--;
15956 arg20[i][non_blank_length + 1] =
'\0';
15967 if (
_n_dims( args(16) ) > 1 )
15971 if (
_dim( args(16), 0 ) !=
Alen )
15975 temp21 = args(16).matrix_value();
15976 arg21 = &temp21( 0, 0 );
15979 if (
_n_dims( args(17) ) > 1 )
15983 if (
_dim( args(17), 0 ) !=
Alen )
15987 temp22 = args(17).matrix_value();
15993 if (
_n_dims( args(18) ) > 1 )
15997 if (
_dim( args(18), 0 ) !=
Alen )
16002 temp23 = args(18).matrix_value();
16006 for ( i = 0; i <
Xlen; i++ )
16007 if ( arg23[i] >
Ylen )
16011 if (
_n_dims( args(19) ) > 2 )
16013 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
16015 if (
_dim( args(19), 0 ) !=
Xlen )
16017 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
16019 if (
_dim( args(19), 1 ) !=
Ylen )
16021 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
16023 temp24 = args(19).matrix_value();
16024 arg24 = &temp24( 0, 0 );
16026 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);
16027 _outv = octave_value();
16046 if ( arg18 != NULL )
16048 for ( i = 0; i <
Alen; i++ )
16057 if ( arg20 != NULL )
16059 for ( i = 0; i <
Alen; i++ )
16085 if ( arg18 != NULL )
16087 for ( i = 0; i <
Alen; i++ )
16096 if ( arg20 != NULL )
16098 for ( i = 0; i <
Alen; i++ )
16117 return octave_value_list();
16125 if ( arg18 != NULL )
16127 for ( i = 0; i <
Alen; i++ )
16136 if ( arg20 != NULL )
16138 for ( i = 0; i <
Alen; i++ )
16169 octave_value_list _out;
16170 octave_value_list *_outp=&_out;
16171 octave_value _outv;
16186 arg2 =
static_cast< int >(val2);
16187 if (arg1) (arg1)->type = arg2;
16188 _outv = octave_value();
16192 return octave_value_list();
16204 octave_value_list _out;
16205 octave_value_list *_outp=&_out;
16206 octave_value _outv;
16218 result = (int) ((arg1)->type);
16223 return octave_value_list();
16233 unsigned int arg2 ;
16236 unsigned int val2 ;
16238 octave_value_list _out;
16239 octave_value_list *_outp=&_out;
16240 octave_value _outv;
16255 arg2 =
static_cast< unsigned int >(val2);
16256 if (arg1) (arg1)->state = arg2;
16257 _outv = octave_value();
16261 return octave_value_list();
16273 octave_value_list _out;
16274 octave_value_list *_outp=&_out;
16275 octave_value _outv;
16276 unsigned int result;
16287 result = (
unsigned int) ((arg1)->state);
16292 return octave_value_list();
16302 unsigned int arg2 ;
16305 unsigned int val2 ;
16307 octave_value_list _out;
16308 octave_value_list *_outp=&_out;
16309 octave_value _outv;
16324 arg2 =
static_cast< unsigned int >(val2);
16325 if (arg1) (arg1)->keysym = arg2;
16326 _outv = octave_value();
16330 return octave_value_list();
16342 octave_value_list _out;
16343 octave_value_list *_outp=&_out;
16344 octave_value _outv;
16345 unsigned int result;
16356 result = (
unsigned int) ((arg1)->keysym);
16361 return octave_value_list();
16371 unsigned int arg2 ;
16374 unsigned int val2 ;
16376 octave_value_list _out;
16377 octave_value_list *_outp=&_out;
16378 octave_value _outv;
16393 arg2 =
static_cast< unsigned int >(val2);
16394 if (arg1) (arg1)->button = arg2;
16395 _outv = octave_value();
16399 return octave_value_list();
16411 octave_value_list _out;
16412 octave_value_list *_outp=&_out;
16413 octave_value _outv;
16414 unsigned int result;
16425 result = (
unsigned int) ((arg1)->button);
16430 return octave_value_list();
16445 octave_value_list _out;
16446 octave_value_list *_outp=&_out;
16447 octave_value _outv;
16462 arg2 =
static_cast< PLINT >(val2);
16463 if (arg1) (arg1)->subwindow = arg2;
16464 _outv = octave_value();
16468 return octave_value_list();
16480 octave_value_list _out;
16481 octave_value_list *_outp=&_out;
16482 octave_value _outv;
16494 result = (
PLINT) ((arg1)->subwindow);
16499 return octave_value_list();
16514 octave_value_list _out;
16515 octave_value_list *_outp=&_out;
16516 octave_value _outv;
16531 arg2 =
reinterpret_cast< char *
>(temp2);
16532 if (arg2) memcpy(arg1->
string,arg2,16*
sizeof(
char));
16533 else memset(arg1->
string,0,16*
sizeof(
char));
16534 _outv = octave_value();
16538 return octave_value_list();
16550 octave_value_list _out;
16551 octave_value_list *_outp=&_out;
16552 octave_value _outv;
16564 result = (
char *)(
char *) ((arg1)->
string);
16575 return octave_value_list();
16590 octave_value_list _out;
16591 octave_value_list *_outp=&_out;
16592 octave_value _outv;
16607 arg2 =
static_cast< int >(val2);
16608 if (arg1) (arg1)->pX = arg2;
16609 _outv = octave_value();
16613 return octave_value_list();
16625 octave_value_list _out;
16626 octave_value_list *_outp=&_out;
16627 octave_value _outv;
16639 result = (int) ((arg1)->pX);
16644 return octave_value_list();
16659 octave_value_list _out;
16660 octave_value_list *_outp=&_out;
16661 octave_value _outv;
16676 arg2 =
static_cast< int >(val2);
16677 if (arg1) (arg1)->pY = arg2;
16678 _outv = octave_value();
16682 return octave_value_list();
16694 octave_value_list _out;
16695 octave_value_list *_outp=&_out;
16696 octave_value _outv;
16708 result = (int) ((arg1)->pY);
16713 return octave_value_list();
16728 octave_value_list _out;
16729 octave_value_list *_outp=&_out;
16730 octave_value _outv;
16745 arg2 =
static_cast< PLFLT >(val2);
16746 if (arg1) (arg1)->dX = arg2;
16747 _outv = octave_value();
16751 return octave_value_list();
16763 octave_value_list _out;
16764 octave_value_list *_outp=&_out;
16765 octave_value _outv;
16777 result = (
PLFLT) ((arg1)->dX);
16782 return octave_value_list();
16797 octave_value_list _out;
16798 octave_value_list *_outp=&_out;
16799 octave_value _outv;
16814 arg2 =
static_cast< PLFLT >(val2);
16815 if (arg1) (arg1)->dY = arg2;
16816 _outv = octave_value();
16820 return octave_value_list();
16832 octave_value_list _out;
16833 octave_value_list *_outp=&_out;
16834 octave_value _outv;
16846 result = (
PLFLT) ((arg1)->dY);
16851 return octave_value_list();
16866 octave_value_list _out;
16867 octave_value_list *_outp=&_out;
16868 octave_value _outv;
16883 arg2 =
static_cast< PLFLT >(val2);
16884 if (arg1) (arg1)->wX = arg2;
16885 _outv = octave_value();
16889 return octave_value_list();
16901 octave_value_list _out;
16902 octave_value_list *_outp=&_out;
16903 octave_value _outv;
16915 result = (
PLFLT) ((arg1)->wX);
16920 return octave_value_list();
16935 octave_value_list _out;
16936 octave_value_list *_outp=&_out;
16937 octave_value _outv;
16952 arg2 =
static_cast< PLFLT >(val2);
16953 if (arg1) (arg1)->wY = arg2;
16954 _outv = octave_value();
16958 return octave_value_list();
16970 octave_value_list _out;
16971 octave_value_list *_outp=&_out;
16972 octave_value _outv;
16984 result = (
PLFLT) ((arg1)->wY);
16989 return octave_value_list();
16998 octave_value_list _out;
16999 octave_value_list *_outp=&_out;
17000 octave_value _outv;
17012 return octave_value_list();
17024 octave_value_list _out;
17025 octave_value_list *_outp=&_out;
17026 octave_value _outv;
17038 _outv = octave_value();
17042 return octave_value_list();
17076 octave_value_list _out;
17077 octave_value_list *_outp=&_out;
17078 octave_value _outv;
17088 arg1 =
static_cast< PLINT >(val1);
17093 arg2 =
static_cast< PLINT >(val2);
17095 _outv = octave_value();
17099 return octave_value_list();
17120 octave_value_list _out;
17121 octave_value_list *_outp=&_out;
17122 octave_value _outv;
17132 arg1 =
static_cast< PLFLT >(val1);
17137 arg2 =
static_cast< PLFLT >(val2);
17142 arg3 =
static_cast< PLFLT >(val3);
17147 arg4 =
static_cast< PLINT >(val4);
17149 _outv = octave_value();
17153 return octave_value_list();
17165 octave_value_list _out;
17166 octave_value_list *_outp=&_out;
17167 octave_value _outv;
17177 arg1 =
static_cast< PLINT >(val1);
17179 _outv = octave_value();
17183 return octave_value_list();
17216 octave_value_list _out;
17217 octave_value_list *_outp=&_out;
17218 octave_value _outv;
17228 arg1 =
static_cast< PLFLT >(val1);
17233 arg2 =
static_cast< PLFLT >(val2);
17238 arg3 =
static_cast< PLFLT >(val3);
17243 arg4 =
static_cast< PLFLT >(val4);
17248 arg5 =
static_cast< PLFLT >(val5);
17253 arg6 =
static_cast< PLFLT >(val6);
17258 arg7 =
static_cast< PLFLT >(val7);
17263 arg8 =
static_cast< PLBOOL >(val8);
17264 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
17265 _outv = octave_value();
17269 return octave_value_list();
17280 char *arg3 = (
char *) 0 ;
17283 char *arg6 = (
char *) 0 ;
17304 octave_value_list _out;
17305 octave_value_list *_outp=&_out;
17306 octave_value _outv;
17316 arg1 =
static_cast< PLFLT >(val1);
17321 arg2 =
static_cast< PLFLT >(val2);
17326 arg3 =
reinterpret_cast< char *
>(buf3);
17331 arg4 =
static_cast< PLFLT >(val4);
17336 arg5 =
static_cast< PLINT >(val5);
17341 arg6 =
reinterpret_cast< char *
>(buf6);
17346 arg7 =
static_cast< PLFLT >(val7);
17351 arg8 =
static_cast< PLINT >(val8);
17352 plaxes(arg1,arg2,(
char const *)arg3,arg4,arg5,(
char const *)arg6,arg7,arg8);
17353 _outv = octave_value();
17361 return octave_value_list();
17380 octave_value_list _out;
17381 octave_value_list *_outp=&_out;
17382 octave_value _outv;
17389 if (
_n_dims( args(0) ) > 1 )
17394 temp1 = args(0).matrix_value();
17395 arg2 = &temp1( 0, 0 );
17398 if (
_n_dims( args(1) ) > 1 )
17406 temp3 = args(1).matrix_value();
17407 arg3 = &temp3( 0, 0 );
17413 arg4 =
static_cast< PLINT >(val4);
17414 plbin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
17415 _outv = octave_value();
17431 return octave_value_list();
17467 octave_value_list _out;
17468 octave_value_list *_outp=&_out;
17469 octave_value _outv;
17485 arg7 =
static_cast< PLFLT >(val7);
17486 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17487 _outv = octave_value();
17527 return octave_value_list();
17536 octave_value_list _out;
17537 octave_value_list *_outp=&_out;
17538 octave_value _outv;
17545 _outv = octave_value();
17549 return octave_value_list();
17558 char *arg1 = (
char *) 0 ;
17561 char *arg4 = (
char *) 0 ;
17578 octave_value_list _out;
17579 octave_value_list *_outp=&_out;
17580 octave_value _outv;
17590 arg1 =
reinterpret_cast< char *
>(buf1);
17595 arg2 =
static_cast< PLFLT >(val2);
17600 arg3 =
static_cast< PLINT >(val3);
17605 arg4 =
reinterpret_cast< char *
>(buf4);
17610 arg5 =
static_cast< PLFLT >(val5);
17615 arg6 =
static_cast< PLINT >(val6);
17616 plbox((
char const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6);
17617 _outv = octave_value();
17625 return octave_value_list();
17636 char *arg1 = (
char *) 0 ;
17637 char *arg2 = (
char *) 0 ;
17640 char *arg5 = (
char *) 0 ;
17641 char *arg6 = (
char *) 0 ;
17644 char *arg9 = (
char *) 0 ;
17645 char *arg10 = (
char *) 0 ;
17678 octave_value_list _out;
17679 octave_value_list *_outp=&_out;
17680 octave_value _outv;
17690 arg1 =
reinterpret_cast< char *
>(buf1);
17695 arg2 =
reinterpret_cast< char *
>(buf2);
17700 arg3 =
static_cast< PLFLT >(val3);
17705 arg4 =
static_cast< PLINT >(val4);
17710 arg5 =
reinterpret_cast< char *
>(buf5);
17715 arg6 =
reinterpret_cast< char *
>(buf6);
17720 arg7 =
static_cast< PLFLT >(val7);
17725 arg8 =
static_cast< PLINT >(val8);
17730 arg9 =
reinterpret_cast< char *
>(buf9);
17735 arg10 =
reinterpret_cast< char *
>(buf10);
17740 arg11 =
static_cast< PLFLT >(val11);
17745 arg12 =
static_cast< PLINT >(val12);
17746 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);
17747 _outv = octave_value();
17763 return octave_value_list();
17793 octave_value_list _out;
17794 octave_value_list *_outp=&_out;
17795 octave_value _outv;
17808 arg1 =
static_cast< PLFLT >(val1);
17813 arg2 =
static_cast< PLFLT >(val2);
17815 _outv = octave_value();
17837 return octave_value_list();
17846 octave_value_list _out;
17847 octave_value_list *_outp=&_out;
17848 octave_value _outv;
17855 _outv = octave_value();
17859 return octave_value_list();
17871 octave_value_list _out;
17872 octave_value_list *_outp=&_out;
17873 octave_value _outv;
17883 arg1 =
static_cast< PLINT >(val1);
17885 _outv = octave_value();
17889 return octave_value_list();
17901 octave_value_list _out;
17902 octave_value_list *_outp=&_out;
17903 octave_value _outv;
17913 arg1 =
static_cast< PLFLT >(val1);
17915 _outv = octave_value();
17919 return octave_value_list();
17961 octave_value_list _out;
17962 octave_value_list *_outp=&_out;
17963 octave_value _outv;
17973 arg1 =
static_cast< PLFLT >(val1);
17978 arg2 =
static_cast< PLFLT >(val2);
17983 arg3 =
static_cast< PLFLT >(val3);
17988 arg4 =
static_cast< PLINT >(val4);
17993 arg5 =
static_cast< PLBOOL >(val5);
17998 arg6 =
static_cast< PLINT >(val6);
18003 arg7 =
static_cast< PLINT >(val7);
18008 arg8 =
static_cast< PLINT >(val8);
18013 arg9 =
static_cast< PLINT >(val9);
18018 arg10 =
static_cast< PLINT >(val10);
18023 arg11 =
static_cast< PLFLT >(val11);
18024 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
18025 _outv = octave_value();
18029 return octave_value_list();
18059 octave_value_list _out;
18060 octave_value_list *_outp=&_out;
18061 octave_value _outv;
18072 arg1 =
static_cast< PLINT >(val1);
18077 arg2 =
static_cast< PLINT >(val2);
18082 arg3 =
static_cast< PLINT >(val3);
18087 arg4 =
static_cast< PLINT >(val4);
18092 arg5 =
static_cast< PLINT >(val5);
18097 arg6 =
static_cast< PLFLT >(val6);
18098 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
18099 _outv = octave_value();
18109 return octave_value_list();
18124 octave_value_list _out;
18125 octave_value_list *_outp=&_out;
18126 octave_value _outv;
18136 arg1 =
static_cast< PLINT >(val1);
18141 arg2 =
static_cast< PLBOOL >(val2);
18143 _outv = octave_value();
18147 return octave_value_list();
18156 octave_value_list _out;
18157 octave_value_list *_outp=&_out;
18158 octave_value _outv;
18165 _outv = octave_value();
18169 return octave_value_list();
18178 octave_value_list _out;
18179 octave_value_list *_outp=&_out;
18180 octave_value _outv;
18187 _outv = octave_value();
18191 return octave_value_list();
18218 octave_value_list _out;
18219 octave_value_list *_outp=&_out;
18220 octave_value _outv;
18230 arg1 =
static_cast< PLFLT >(val1);
18235 arg2 =
static_cast< PLFLT >(val2);
18240 arg3 =
static_cast< PLFLT >(val3);
18245 arg4 =
static_cast< PLFLT >(val4);
18250 arg5 =
static_cast< PLINT >(val5);
18255 arg6 =
static_cast< PLINT >(val6);
18256 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
18257 _outv = octave_value();
18261 return octave_value_list();
18288 octave_value_list _out;
18289 octave_value_list *_outp=&_out;
18290 octave_value _outv;
18300 arg1 =
static_cast< PLFLT >(val1);
18305 arg2 =
static_cast< PLFLT >(val2);
18310 arg3 =
static_cast< PLFLT >(val3);
18315 arg4 =
static_cast< PLFLT >(val4);
18320 arg5 =
static_cast< PLINT >(val5);
18325 arg6 =
static_cast< PLINT >(val6);
18326 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
18327 _outv = octave_value();
18331 return octave_value_list();
18340 octave_value_list _out;
18341 octave_value_list *_outp=&_out;
18342 octave_value _outv;
18349 _outv = octave_value();
18353 return octave_value_list();
18369 octave_value_list _out;
18370 octave_value_list *_outp=&_out;
18371 octave_value _outv;
18378 if (
_n_dims( args(0) ) > 1 )
18383 temp1 = args(0).matrix_value();
18384 arg2 = &temp1( 0, 0 );
18387 if (
_n_dims( args(1) ) > 1 )
18395 temp3 = args(1).matrix_value();
18396 arg3 = &temp3( 0, 0 );
18399 if (
_n_dims( args(2) ) > 1 )
18407 temp4 = args(2).matrix_value();
18408 arg4 = &temp4( 0, 0 );
18410 plerrx(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18411 _outv = octave_value();
18433 return octave_value_list();
18458 octave_value_list _out;
18459 octave_value_list *_outp=&_out;
18460 octave_value _outv;
18467 if (
_n_dims( args(0) ) > 1 )
18472 temp1 = args(0).matrix_value();
18473 arg2 = &temp1( 0, 0 );
18476 if (
_n_dims( args(1) ) > 1 )
18484 temp3 = args(1).matrix_value();
18485 arg3 = &temp3( 0, 0 );
18488 if (
_n_dims( args(2) ) > 1 )
18496 temp4 = args(2).matrix_value();
18497 arg4 = &temp4( 0, 0 );
18499 plerry(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18500 _outv = octave_value();
18522 return octave_value_list();
18540 octave_value_list _out;
18541 octave_value_list *_outp=&_out;
18542 octave_value _outv;
18549 _outv = octave_value();
18553 return octave_value_list();
18567 octave_value_list _out;
18568 octave_value_list *_outp=&_out;
18569 octave_value _outv;
18576 if (
_n_dims( args(0) ) > 1 )
18581 temp1 = args(0).matrix_value();
18582 arg2 = &temp1( 0, 0 );
18585 if (
_n_dims( args(1) ) > 1 )
18593 temp3 = args(1).matrix_value();
18594 arg3 = &temp3( 0, 0 );
18596 plfill(arg1,(
double const *)arg2,(
double const *)arg3);
18597 _outv = octave_value();
18613 return octave_value_list();
18635 octave_value_list _out;
18636 octave_value_list *_outp=&_out;
18637 octave_value _outv;
18644 if (
_n_dims( args(0) ) > 1 )
18649 temp1 = args(0).matrix_value();
18650 arg2 = &temp1( 0, 0 );
18653 if (
_n_dims( args(1) ) > 1 )
18661 temp3 = args(1).matrix_value();
18662 arg3 = &temp3( 0, 0 );
18665 if (
_n_dims( args(2) ) > 1 )
18673 temp4 = args(2).matrix_value();
18674 arg4 = &temp4( 0, 0 );
18676 plfill3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18677 _outv = octave_value();
18699 return octave_value_list();
18725 octave_value_list _out;
18726 octave_value_list *_outp=&_out;
18727 octave_value _outv;
18734 if (
_n_dims( args(0) ) > 1 )
18739 temp1 = args(0).matrix_value();
18740 arg2 = &temp1( 0, 0 );
18743 if (
_n_dims( args(1) ) > 1 )
18751 temp3 = args(1).matrix_value();
18752 arg3 = &temp3( 0, 0 );
18758 arg4 =
static_cast< PLFLT >(val4);
18759 plgradient(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
18760 _outv = octave_value();
18776 return octave_value_list();
18791 octave_value_list _out;
18792 octave_value_list *_outp=&_out;
18793 octave_value _outv;
18800 _outv = octave_value();
18804 return octave_value_list();
18816 octave_value_list _out;
18817 octave_value_list *_outp=&_out;
18818 octave_value _outv;
18828 arg1 =
static_cast< PLINT >(val1);
18830 _outv = octave_value();
18834 return octave_value_list();
18846 octave_value_list _out;
18847 octave_value_list *_outp=&_out;
18848 octave_value _outv;
18858 arg1 =
static_cast< PLINT >(val1);
18860 _outv = octave_value();
18864 return octave_value_list();
18879 octave_value_list _out;
18880 octave_value_list *_outp=&_out;
18881 octave_value _outv;
18890 _outv = octave_value();
18906 return octave_value_list();
18927 octave_value_list _out;
18928 octave_value_list *_outp=&_out;
18929 octave_value _outv;
18942 arg1 =
static_cast< PLINT >(val1);
18943 plgcol0(arg1,arg2,arg3,arg4);
18944 _outv = octave_value();
18966 return octave_value_list();
18990 octave_value_list _out;
18991 octave_value_list *_outp=&_out;
18992 octave_value _outv;
19006 arg1 =
static_cast< PLINT >(val1);
19007 plgcol0a(arg1,arg2,arg3,arg4,arg5);
19008 _outv = octave_value();
19036 return octave_value_list();
19054 octave_value_list _out;
19055 octave_value_list *_outp=&_out;
19056 octave_value _outv;
19066 _outv = octave_value();
19088 return octave_value_list();
19109 octave_value_list _out;
19110 octave_value_list *_outp=&_out;
19111 octave_value _outv;
19122 _outv = octave_value();
19150 return octave_value_list();
19162 octave_value_list _out;
19163 octave_value_list *_outp=&_out;
19164 octave_value _outv;
19172 _outv = octave_value();
19182 return octave_value_list();
19191 char *arg1 = (
char *) 0 ;
19192 char local_string1[80] ;
19193 size_t local_string_length1 ;
19194 charMatrix local_charMatrix1 ;
19195 octave_value_list retval1 ;
19196 octave_value_list _out;
19197 octave_value_list *_outp=&_out;
19198 octave_value _outv;
19202 arg1 = local_string1;
19208 _outv = octave_value();
19211 local_string_length1 = strlen( local_string1 );
19212 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19213 local_charMatrix1.insert( local_string1, 0, 0 );
19214 retval1( 0 ) = octave_value( local_charMatrix1 );
19219 return octave_value_list();
19240 octave_value_list _out;
19241 octave_value_list *_outp=&_out;
19242 octave_value _outv;
19253 _outv = octave_value();
19281 return octave_value_list();
19293 octave_value_list _out;
19294 octave_value_list *_outp=&_out;
19295 octave_value _outv;
19303 _outv = octave_value();
19313 return octave_value_list();
19334 octave_value_list _out;
19335 octave_value_list *_outp=&_out;
19336 octave_value _outv;
19347 _outv = octave_value();
19375 return octave_value_list();
19393 octave_value_list _out;
19394 octave_value_list *_outp=&_out;
19395 octave_value _outv;
19405 _outv = octave_value();
19427 return octave_value_list();
19439 octave_value_list _out;
19440 octave_value_list *_outp=&_out;
19441 octave_value _outv;
19449 _outv = octave_value();
19459 return octave_value_list();
19468 char *arg1 = (
char *) 0 ;
19469 char local_string1[80] ;
19470 size_t local_string_length1 ;
19471 charMatrix local_charMatrix1 ;
19472 octave_value_list retval1 ;
19473 octave_value_list _out;
19474 octave_value_list *_outp=&_out;
19475 octave_value _outv;
19479 arg1 = local_string1;
19485 _outv = octave_value();
19488 local_string_length1 = strlen( local_string1 );
19489 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19490 local_charMatrix1.insert( local_string1, 0, 0 );
19491 retval1( 0 ) = octave_value( local_charMatrix1 );
19496 return octave_value_list();
19514 octave_value_list _out;
19515 octave_value_list *_outp=&_out;
19516 octave_value _outv;
19526 _outv = octave_value();
19548 return octave_value_list();
19560 octave_value_list _out;
19561 octave_value_list *_outp=&_out;
19562 octave_value _outv;
19570 _outv = octave_value();
19580 return octave_value_list();
19607 octave_value_list _out;
19608 octave_value_list *_outp=&_out;
19609 octave_value _outv;
19621 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
19622 _outv = octave_value();
19662 return octave_value_list();
19671 octave_value_list _out;
19672 octave_value_list *_outp=&_out;
19673 octave_value _outv;
19680 _outv = octave_value();
19684 return octave_value_list();
19705 octave_value_list _out;
19706 octave_value_list *_outp=&_out;
19707 octave_value _outv;
19717 plgspa(arg1,arg2,arg3,arg4);
19718 _outv = octave_value();
19746 return octave_value_list();
19758 octave_value_list _out;
19759 octave_value_list *_outp=&_out;
19760 octave_value _outv;
19768 _outv = octave_value();
19778 return octave_value_list();
19787 char *arg1 = (
char *) 0 ;
19788 char local_string1[80] ;
19789 size_t local_string_length1 ;
19790 charMatrix local_charMatrix1 ;
19791 octave_value_list retval1 ;
19792 octave_value_list _out;
19793 octave_value_list *_outp=&_out;
19794 octave_value _outv;
19798 arg1 = local_string1;
19804 _outv = octave_value();
19807 local_string_length1 = strlen( local_string1 );
19808 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19809 local_charMatrix1.insert( local_string1, 0, 0 );
19810 retval1( 0 ) = octave_value( local_charMatrix1 );
19815 return octave_value_list();
19836 octave_value_list _out;
19837 octave_value_list *_outp=&_out;
19838 octave_value _outv;
19848 plgvpd(arg1,arg2,arg3,arg4);
19849 _outv = octave_value();
19877 return octave_value_list();
19898 octave_value_list _out;
19899 octave_value_list *_outp=&_out;
19900 octave_value _outv;
19910 plgvpw(arg1,arg2,arg3,arg4);
19911 _outv = octave_value();
19939 return octave_value_list();
19954 octave_value_list _out;
19955 octave_value_list *_outp=&_out;
19956 octave_value _outv;
19965 _outv = octave_value();
19981 return octave_value_list();
19996 octave_value_list _out;
19997 octave_value_list *_outp=&_out;
19998 octave_value _outv;
20007 _outv = octave_value();
20023 return octave_value_list();
20038 octave_value_list _out;
20039 octave_value_list *_outp=&_out;
20040 octave_value _outv;
20049 _outv = octave_value();
20065 return octave_value_list();
20089 octave_value_list _out;
20090 octave_value_list *_outp=&_out;
20091 octave_value _outv;
20098 if (
_n_dims( args(0) ) > 1 )
20103 temp1 = args(0).matrix_value();
20104 arg2 = &temp1( 0, 0 );
20110 arg3 =
static_cast< PLFLT >(val3);
20115 arg4 =
static_cast< PLFLT >(val4);
20120 arg5 =
static_cast< PLINT >(val5);
20125 arg6 =
static_cast< PLINT >(val6);
20126 plhist(arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
20127 _outv = octave_value();
20137 return octave_value_list();
20167 octave_value_list _out;
20168 octave_value_list *_outp=&_out;
20169 octave_value _outv;
20182 arg1 =
static_cast< PLFLT >(val1);
20187 arg2 =
static_cast< PLFLT >(val2);
20192 arg3 =
static_cast< PLFLT >(val3);
20193 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
20194 _outv = octave_value();
20216 return octave_value_list();
20225 octave_value_list _out;
20226 octave_value_list *_outp=&_out;
20227 octave_value _outv;
20234 _outv = octave_value();
20238 return octave_value_list();
20259 octave_value_list _out;
20260 octave_value_list *_outp=&_out;
20261 octave_value _outv;
20271 arg1 =
static_cast< PLFLT >(val1);
20276 arg2 =
static_cast< PLFLT >(val2);
20281 arg3 =
static_cast< PLFLT >(val3);
20286 arg4 =
static_cast< PLFLT >(val4);
20287 pljoin(arg1,arg2,arg3,arg4);
20288 _outv = octave_value();
20292 return octave_value_list();
20301 char *arg1 = (
char *) 0 ;
20302 char *arg2 = (
char *) 0 ;
20303 char *arg3 = (
char *) 0 ;
20313 octave_value_list _out;
20314 octave_value_list *_outp=&_out;
20315 octave_value _outv;
20325 arg1 =
reinterpret_cast< char *
>(buf1);
20330 arg2 =
reinterpret_cast< char *
>(buf2);
20335 arg3 =
reinterpret_cast< char *
>(buf3);
20336 pllab((
char const *)arg1,(
char const *)arg2,(
char const *)arg3);
20337 _outv = octave_value();
20347 return octave_value_list();
20378 char **arg20 = (
char **) 0 ;
20389 char **arg31 = (
char **) 0 ;
20434 octave_value_list _out;
20435 octave_value_list *_outp=&_out;
20436 octave_value _outv;
20448 arg3 =
static_cast< PLINT >(val3);
20453 arg4 =
static_cast< PLINT >(val4);
20458 arg5 =
static_cast< PLFLT >(val5);
20463 arg6 =
static_cast< PLFLT >(val6);
20468 arg7 =
static_cast< PLFLT >(val7);
20473 arg8 =
static_cast< PLINT >(val8);
20478 arg9 =
static_cast< PLINT >(val9);
20483 arg10 =
static_cast< PLINT >(val10);
20488 arg11 =
static_cast< PLINT >(val11);
20493 arg12 =
static_cast< PLINT >(val12);
20495 if (
_n_dims( args(10) ) > 1 )
20501 temp13 = args(10).matrix_value();
20508 arg15 =
static_cast< PLFLT >(val15);
20513 arg16 =
static_cast< PLFLT >(val16);
20518 arg17 =
static_cast< PLFLT >(val17);
20523 arg18 =
static_cast< PLFLT >(val18);
20525 if (
_n_dims( args(15) ) > 1 )
20529 if (
_dim( args(15), 0 ) !=
Alen )
20533 temp19 = args(15).matrix_value();
20538 charMatrix temp_matrix;
20542 size_t max_length = 0, non_blank_length;
20544 if (
_n_dims( args(16) ) > 2 )
20546 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
20548#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20549 if ( !args(16).isempty() )
20551 if ( !args(16).is_empty() )
20554 if (
_dim( args(16), 0 ) !=
Alen )
20556 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
20558 arg20 =
new char*[
Alen];
20559#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20560 ifcell = args(16).iscell();
20562 ifcell = args(16).is_cell();
20566 temp_cell = args(16).cell_value();
20570 temp_matrix = args(16).char_matrix_value();
20572 max_length =
_dim( args(16), 1 ) + 1;
20575 for ( i = 0; i <
Alen; i++ )
20582 if ( temp_cell.elem( i ).is_string() )
20584 str = temp_cell.elem( i ).string_value();
20586 max_length = str.size() + 1;
20587 tmp_cstring = (
char *) str.c_str();
20597 tmp_cstring = (
char *)
"";
20602 str = temp_matrix.row_as_string( i );
20603 tmp_cstring = (
char *) str.c_str();
20605 arg20[i] =
new char[max_length];
20606 strncpy( arg20[i], tmp_cstring, max_length - 1 );
20607 arg20[i][max_length - 1] =
'\0';
20622 non_blank_length = max_length - 2;
20623 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
20625 non_blank_length--;
20627 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
20629 non_blank_length--;
20631 arg20[i][non_blank_length + 1] =
'\0';
20641 if (
_n_dims( args(17) ) > 1 )
20645#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20646 if ( !args(17).isempty() )
20648 if ( !args(17).is_empty() )
20651 if (
_dim( args(17), 0 ) !=
Alen )
20655 temp21 = args(17).matrix_value();
20665 if (
_n_dims( args(18) ) > 1 )
20669#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20670 if ( !args(18).isempty() )
20672 if ( !args(18).is_empty() )
20675 if (
_dim( args(18), 0 ) !=
Alen )
20679 temp22 = args(18).matrix_value();
20689 if (
_n_dims( args(19) ) > 1 )
20693#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20694 if ( !args(19).isempty() )
20696 if ( !args(19).is_empty() )
20699 if (
_dim( args(19), 0 ) !=
Alen )
20703 temp23 = args(19).matrix_value();
20704 arg23 = &temp23( 0, 0 );
20712 if (
_n_dims( args(20) ) > 1 )
20716#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20717 if ( !args(20).isempty() )
20719 if ( !args(20).is_empty() )
20722 if (
_dim( args(20), 0 ) !=
Alen )
20726 temp24 = args(20).matrix_value();
20727 arg24 = &temp24( 0, 0 );
20735 if (
_n_dims( args(21) ) > 1 )
20739#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20740 if ( !args(21).isempty() )
20742 if ( !args(21).is_empty() )
20745 if (
_dim( args(21), 0 ) !=
Alen )
20749 temp25 = args(21).matrix_value();
20759 if (
_n_dims( args(22) ) > 1 )
20763#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20764 if ( !args(22).isempty() )
20766 if ( !args(22).is_empty() )
20769 if (
_dim( args(22), 0 ) !=
Alen )
20773 temp26 = args(22).matrix_value();
20783 if (
_n_dims( args(23) ) > 1 )
20787#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20788 if ( !args(23).isempty() )
20790 if ( !args(23).is_empty() )
20793 if (
_dim( args(23), 0 ) !=
Alen )
20797 temp27 = args(23).matrix_value();
20798 arg27 = &temp27( 0, 0 );
20806 if (
_n_dims( args(24) ) > 1 )
20810#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20811 if ( !args(24).isempty() )
20813 if ( !args(24).is_empty() )
20816 if (
_dim( args(24), 0 ) !=
Alen )
20820 temp28 = args(24).matrix_value();
20830 if (
_n_dims( args(25) ) > 1 )
20834#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20835 if ( !args(25).isempty() )
20837 if ( !args(25).is_empty() )
20840 if (
_dim( args(25), 0 ) !=
Alen )
20844 temp29 = args(25).matrix_value();
20845 arg29 = &temp29( 0, 0 );
20853 if (
_n_dims( args(26) ) > 1 )
20857#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20858 if ( !args(26).isempty() )
20860 if ( !args(26).is_empty() )
20863 if (
_dim( args(26), 0 ) !=
Alen )
20867 temp30 = args(26).matrix_value();
20877 charMatrix temp_matrix;
20881 size_t max_length = 0, non_blank_length;
20883 if (
_n_dims( args(27) ) > 2 )
20885 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
20887#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20888 if ( !args(27).isempty() )
20890 if ( !args(27).is_empty() )
20893 if (
_dim( args(27), 0 ) !=
Alen )
20895 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
20897 arg31 =
new char*[
Alen];
20898#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20899 ifcell = args(27).iscell();
20901 ifcell = args(27).is_cell();
20905 temp_cell = args(27).cell_value();
20909 temp_matrix = args(27).char_matrix_value();
20911 max_length =
_dim( args(27), 1 ) + 1;
20914 for ( i = 0; i <
Alen; i++ )
20921 if ( temp_cell.elem( i ).is_string() )
20923 str = temp_cell.elem( i ).string_value();
20925 max_length = str.size() + 1;
20926 tmp_cstring = (
char *) str.c_str();
20936 tmp_cstring = (
char *)
"";
20941 str = temp_matrix.row_as_string( i );
20942 tmp_cstring = (
char *) str.c_str();
20944 arg31[i] =
new char[max_length];
20945 strncpy( arg31[i], tmp_cstring, max_length - 1 );
20946 arg31[i][max_length - 1] =
'\0';
20961 non_blank_length = max_length - 2;
20962 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
'\0' )
20964 non_blank_length--;
20966 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
' ' )
20968 non_blank_length--;
20970 arg31[i][non_blank_length + 1] =
'\0';
20979 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);
20980 _outv = octave_value();
21002 if ( arg20 != NULL )
21004 for ( i = 0; i <
Alen; i++ )
21012 if ( arg21 != NULL )
21016 if ( arg22 != NULL )
21026 if ( arg25 != NULL )
21030 if ( arg26 != NULL )
21037 if ( arg28 != NULL )
21044 if ( arg30 != NULL )
21049 if ( arg31 != NULL )
21051 for ( i = 0; i <
Alen; i++ )
21068 if ( arg20 != NULL )
21070 for ( i = 0; i <
Alen; i++ )
21078 if ( arg21 != NULL )
21082 if ( arg22 != NULL )
21092 if ( arg25 != NULL )
21096 if ( arg26 != NULL )
21103 if ( arg28 != NULL )
21110 if ( arg30 != NULL )
21115 if ( arg31 != NULL )
21117 for ( i = 0; i <
Alen; i++ )
21124 return octave_value_list();
21135 if ( arg20 != NULL )
21137 for ( i = 0; i <
Alen; i++ )
21145 if ( arg21 != NULL )
21149 if ( arg22 != NULL )
21159 if ( arg25 != NULL )
21163 if ( arg26 != NULL )
21170 if ( arg28 != NULL )
21177 if ( arg30 != NULL )
21182 if ( arg31 != NULL )
21184 for ( i = 0; i <
Alen; i++ )
21206 octave_value_list _out;
21207 octave_value_list *_outp=&_out;
21208 octave_value _outv;
21218 arg1 =
static_cast< PLFLT >(val1);
21223 arg2 =
static_cast< PLFLT >(val2);
21228 arg3 =
static_cast< PLFLT >(val3);
21230 _outv = octave_value();
21234 return octave_value_list();
21248 octave_value_list _out;
21249 octave_value_list *_outp=&_out;
21250 octave_value _outv;
21257 if (
_n_dims( args(0) ) > 1 )
21262 temp1 = args(0).matrix_value();
21263 arg2 = &temp1( 0, 0 );
21266 if (
_n_dims( args(1) ) > 1 )
21274 temp3 = args(1).matrix_value();
21275 arg3 = &temp3( 0, 0 );
21277 plline(arg1,(
double const *)arg2,(
double const *)arg3);
21278 _outv = octave_value();
21294 return octave_value_list();
21316 octave_value_list _out;
21317 octave_value_list *_outp=&_out;
21318 octave_value _outv;
21325 if (
_n_dims( args(0) ) > 1 )
21330 temp1 = args(0).matrix_value();
21331 arg2 = &temp1( 0, 0 );
21334 if (
_n_dims( args(1) ) > 1 )
21342 temp3 = args(1).matrix_value();
21343 arg3 = &temp3( 0, 0 );
21346 if (
_n_dims( args(2) ) > 1 )
21354 temp4 = args(2).matrix_value();
21355 arg4 = &temp4( 0, 0 );
21357 plline3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
21358 _outv = octave_value();
21380 return octave_value_list();
21401 octave_value_list _out;
21402 octave_value_list *_outp=&_out;
21403 octave_value _outv;
21413 arg1 =
static_cast< PLINT >(val1);
21415 _outv = octave_value();
21419 return octave_value_list();
21431 octave_value_list _out;
21432 octave_value_list *_outp=&_out;
21433 octave_value _outv;
21441 _outv = octave_value();
21451 return octave_value_list();
21460 char *arg1 = (
char *) 0 ;
21464 char *arg5 = (
char *) 0 ;
21477 octave_value_list _out;
21478 octave_value_list *_outp=&_out;
21479 octave_value _outv;
21489 arg1 =
reinterpret_cast< char *
>(buf1);
21494 arg2 =
static_cast< PLFLT >(val2);
21499 arg3 =
static_cast< PLFLT >(val3);
21504 arg4 =
static_cast< PLFLT >(val4);
21509 arg5 =
reinterpret_cast< char *
>(buf5);
21510 plmtex((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
21511 _outv = octave_value();
21519 return octave_value_list();
21530 char *arg1 = (
char *) 0 ;
21534 char *arg5 = (
char *) 0 ;
21547 octave_value_list _out;
21548 octave_value_list *_outp=&_out;
21549 octave_value _outv;
21559 arg1 =
reinterpret_cast< char *
>(buf1);
21564 arg2 =
static_cast< PLFLT >(val2);
21569 arg3 =
static_cast< PLFLT >(val3);
21574 arg4 =
static_cast< PLFLT >(val4);
21579 arg5 =
reinterpret_cast< char *
>(buf5);
21580 plmtex3((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
21581 _outv = octave_value();
21589 return octave_value_list();
21600 int *arg1 = (
int *) 0 ;
21601 char **arg2 = (
char **) 0 ;
21609 octave_value_list _out;
21610 octave_value_list *_outp=&_out;
21611 octave_value _outv;
21622 arg1 =
reinterpret_cast< int *
>(argp1);
21627 arg2 =
reinterpret_cast< char **
>(argp2);
21632 arg3 =
static_cast< PLINT >(val3);
21638 return octave_value_list();
21652 octave_value_list _out;
21653 octave_value_list *_outp=&_out;
21654 octave_value _outv;
21661 if (
_n_dims( args(0) ) > 1 )
21667 temp1 = args(0).matrix_value();
21671 if (
_n_dims( args(1) ) > 1 )
21679 temp3 = args(1).matrix_value();
21683 plpat(arg1,(
int const *)arg2,(
int const *)arg3);
21684 _outv = octave_value();
21700 return octave_value_list();
21730 octave_value_list _out;
21731 octave_value_list *_outp=&_out;
21732 octave_value _outv;
21742 arg1 =
static_cast< PLINT >(val1);
21747 arg2 =
static_cast< PLFLT >(val2);
21752 arg3 =
static_cast< PLFLT >(val3);
21757 arg4 =
static_cast< PLFLT >(val4);
21762 arg5 =
static_cast< PLFLT >(val5);
21763 plpath(arg1,arg2,arg3,arg4,arg5);
21764 _outv = octave_value();
21768 return octave_value_list();
21785 octave_value_list _out;
21786 octave_value_list *_outp=&_out;
21787 octave_value _outv;
21794 if (
_n_dims( args(0) ) > 1 )
21799 temp1 = args(0).matrix_value();
21800 arg2 = &temp1( 0, 0 );
21803 if (
_n_dims( args(1) ) > 1 )
21811 temp3 = args(1).matrix_value();
21812 arg3 = &temp3( 0, 0 );
21818 arg4 =
static_cast< PLINT >(val4);
21819 plpoin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
21820 _outv = octave_value();
21836 return octave_value_list();
21861 octave_value_list _out;
21862 octave_value_list *_outp=&_out;
21863 octave_value _outv;
21870 if (
_n_dims( args(0) ) > 1 )
21875 temp1 = args(0).matrix_value();
21876 arg2 = &temp1( 0, 0 );
21879 if (
_n_dims( args(1) ) > 1 )
21887 temp3 = args(1).matrix_value();
21888 arg3 = &temp3( 0, 0 );
21891 if (
_n_dims( args(2) ) > 1 )
21899 temp4 = args(2).matrix_value();
21900 arg4 = &temp4( 0, 0 );
21906 arg5 =
static_cast< PLINT >(val5);
21907 plpoin3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,arg5);
21908 _outv = octave_value();
21930 return octave_value_list();
21960 octave_value_list _out;
21961 octave_value_list *_outp=&_out;
21962 octave_value _outv;
21969 if (
_n_dims( args(0) ) > 1 )
21974 temp1 = args(0).matrix_value();
21975 arg2 = &temp1( 0, 0 );
21978 if (
_n_dims( args(1) ) > 1 )
21986 temp3 = args(1).matrix_value();
21987 arg3 = &temp3( 0, 0 );
21990 if (
_n_dims( args(2) ) > 1 )
21998 temp4 = args(2).matrix_value();
21999 arg4 = &temp4( 0, 0 );
22002 if (
_n_dims( args(3) ) > 1 )
22008 error(
"argument vector must be same length or one less" );
SWIG_fail;
22010 temp5 = args(3).matrix_value();
22018 arg6 =
static_cast< PLBOOL >(val6);
22019 plpoly3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
int const *)arg5,arg6);
22020 _outv = octave_value();
22048 return octave_value_list();
22075 octave_value_list _out;
22076 octave_value_list *_outp=&_out;
22077 octave_value _outv;
22087 arg1 =
static_cast< PLINT >(val1);
22092 arg2 =
static_cast< PLINT >(val2);
22094 _outv = octave_value();
22098 return octave_value_list();
22110 octave_value_list _out;
22111 octave_value_list *_outp=&_out;
22112 octave_value _outv;
22122 arg1 =
static_cast< PLINT >(val1);
22124 _outv = octave_value();
22128 return octave_value_list();
22142 char *arg6 = (
char *) 0 ;
22156 octave_value_list _out;
22157 octave_value_list *_outp=&_out;
22158 octave_value _outv;
22168 arg1 =
static_cast< PLFLT >(val1);
22173 arg2 =
static_cast< PLFLT >(val2);
22178 arg3 =
static_cast< PLFLT >(val3);
22183 arg4 =
static_cast< PLFLT >(val4);
22188 arg5 =
static_cast< PLFLT >(val5);
22193 arg6 =
reinterpret_cast< char *
>(buf6);
22194 plptex(arg1,arg2,arg3,arg4,arg5,(
char const *)arg6);
22195 _outv = octave_value();
22201 return octave_value_list();
22221 char *arg11 = (
char *) 0 ;
22245 octave_value_list _out;
22246 octave_value_list *_outp=&_out;
22247 octave_value _outv;
22257 arg1 =
static_cast< PLFLT >(val1);
22262 arg2 =
static_cast< PLFLT >(val2);
22267 arg3 =
static_cast< PLFLT >(val3);
22272 arg4 =
static_cast< PLFLT >(val4);
22277 arg5 =
static_cast< PLFLT >(val5);
22282 arg6 =
static_cast< PLFLT >(val6);
22287 arg7 =
static_cast< PLFLT >(val7);
22292 arg8 =
static_cast< PLFLT >(val8);
22297 arg9 =
static_cast< PLFLT >(val9);
22302 arg10 =
static_cast< PLFLT >(val10);
22307 arg11 =
reinterpret_cast< char *
>(buf11);
22308 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(
char const *)arg11);
22309 _outv = octave_value();
22315 return octave_value_list();
22325 octave_value_list _out;
22326 octave_value_list *_outp=&_out;
22327 octave_value _outv;
22339 return octave_value_list();
22348 octave_value_list _out;
22349 octave_value_list *_outp=&_out;
22350 octave_value _outv;
22357 _outv = octave_value();
22361 return octave_value_list();
22388 octave_value_list _out;
22389 octave_value_list *_outp=&_out;
22390 octave_value _outv;
22403 arg1 =
static_cast< PLFLT >(val1);
22408 arg2 =
static_cast< PLFLT >(val2);
22413 arg3 =
static_cast< PLFLT >(val3);
22414 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
22415 _outv = octave_value();
22437 return octave_value_list();
22452 octave_value_list _out;
22453 octave_value_list *_outp=&_out;
22454 octave_value _outv;
22464 arg1 =
static_cast< PLFLT >(val1);
22469 arg2 =
static_cast< PLFLT >(val2);
22471 _outv = octave_value();
22475 return octave_value_list();
22491 octave_value_list _out;
22492 octave_value_list *_outp=&_out;
22493 octave_value _outv;
22500 if (
_n_dims( args(0) ) > 1 )
22505 temp1 = args(0).matrix_value();
22510 if (
_n_dims( args(1) ) > 1 )
22518 temp2 = args(1).matrix_value();
22523 if (
_n_dims( args(2) ) > 1 )
22531 temp3 = args(2).matrix_value();
22536 plscmap0((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
22537 _outv = octave_value();
22559 return octave_value_list();
22586 octave_value_list _out;
22587 octave_value_list *_outp=&_out;
22588 octave_value _outv;
22595 if (
_n_dims( args(0) ) > 1 )
22600 temp1 = args(0).matrix_value();
22605 if (
_n_dims( args(1) ) > 1 )
22613 temp2 = args(1).matrix_value();
22618 if (
_n_dims( args(2) ) > 1 )
22626 temp3 = args(2).matrix_value();
22631 if (
_n_dims( args(3) ) > 1 )
22639 temp4 = args(3).matrix_value();
22640 arg4 = &temp4( 0, 0 );
22643 plscmap0a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
22644 _outv = octave_value();
22672 return octave_value_list();
22696 octave_value_list _out;
22697 octave_value_list *_outp=&_out;
22698 octave_value _outv;
22708 arg1 =
static_cast< PLINT >(val1);
22710 _outv = octave_value();
22714 return octave_value_list();
22730 octave_value_list _out;
22731 octave_value_list *_outp=&_out;
22732 octave_value _outv;
22739 if (
_n_dims( args(0) ) > 1 )
22744 temp1 = args(0).matrix_value();
22749 if (
_n_dims( args(1) ) > 1 )
22757 temp2 = args(1).matrix_value();
22762 if (
_n_dims( args(2) ) > 1 )
22770 temp3 = args(2).matrix_value();
22775 plscmap1((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
22776 _outv = octave_value();
22798 return octave_value_list();
22825 octave_value_list _out;
22826 octave_value_list *_outp=&_out;
22827 octave_value _outv;
22834 if (
_n_dims( args(0) ) > 1 )
22839 temp1 = args(0).matrix_value();
22844 if (
_n_dims( args(1) ) > 1 )
22852 temp2 = args(1).matrix_value();
22857 if (
_n_dims( args(2) ) > 1 )
22865 temp3 = args(2).matrix_value();
22870 if (
_n_dims( args(3) ) > 1 )
22878 temp4 = args(3).matrix_value();
22879 arg4 = &temp4( 0, 0 );
22882 plscmap1a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
22883 _outv = octave_value();
22911 return octave_value_list();
22946 octave_value_list _out;
22947 octave_value_list *_outp=&_out;
22948 octave_value _outv;
22958 arg1 =
static_cast< PLBOOL >(val1);
22960 if (
_n_dims( args(1) ) > 1 )
22965 temp2 = args(1).matrix_value();
22966 arg3 = &temp2( 0, 0 );
22969 if (
_n_dims( args(2) ) > 1 )
22977 temp4 = args(2).matrix_value();
22978 arg4 = &temp4( 0, 0 );
22981 if (
_n_dims( args(3) ) > 1 )
22989 temp5 = args(3).matrix_value();
22990 arg5 = &temp5( 0, 0 );
22993 if (
_n_dims( args(4) ) > 1 )
23001 temp6 = args(4).matrix_value();
23002 arg6 = &temp6( 0, 0 );
23005 if (
_n_dims( args(5) ) > 1 )
23011 error(
"argument vector must be same length or one less" );
SWIG_fail;
23013 temp7 = args(5).matrix_value();
23017 plscmap1l(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
int const *)arg7);
23018 _outv = octave_value();
23052 return octave_value_list();
23092 octave_value_list _out;
23093 octave_value_list *_outp=&_out;
23094 octave_value _outv;
23104 arg1 =
static_cast< PLBOOL >(val1);
23106 if (
_n_dims( args(1) ) > 1 )
23111 temp2 = args(1).matrix_value();
23112 arg3 = &temp2( 0, 0 );
23115 if (
_n_dims( args(2) ) > 1 )
23123 temp4 = args(2).matrix_value();
23124 arg4 = &temp4( 0, 0 );
23127 if (
_n_dims( args(3) ) > 1 )
23135 temp5 = args(3).matrix_value();
23136 arg5 = &temp5( 0, 0 );
23139 if (
_n_dims( args(4) ) > 1 )
23147 temp6 = args(4).matrix_value();
23148 arg6 = &temp6( 0, 0 );
23151 if (
_n_dims( args(5) ) > 1 )
23159 temp7 = args(5).matrix_value();
23160 arg7 = &temp7( 0, 0 );
23163 if (
_n_dims( args(6) ) > 1 )
23169 error(
"argument vector must be same length or one less" );
SWIG_fail;
23171 temp8 = args(6).matrix_value();
23175 plscmap1la(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
double const *)arg7,(
int const *)arg8);
23176 _outv = octave_value();
23216 return octave_value_list();
23246 octave_value_list _out;
23247 octave_value_list *_outp=&_out;
23248 octave_value _outv;
23258 arg1 =
static_cast< PLINT >(val1);
23260 _outv = octave_value();
23264 return octave_value_list();
23279 octave_value_list _out;
23280 octave_value_list *_outp=&_out;
23281 octave_value _outv;
23291 arg1 =
static_cast< PLFLT >(val1);
23296 arg2 =
static_cast< PLFLT >(val2);
23298 _outv = octave_value();
23302 return octave_value_list();
23317 octave_value_list _out;
23318 octave_value_list *_outp=&_out;
23319 octave_value _outv;
23328 _outv = octave_value();
23344 return octave_value_list();
23365 octave_value_list _out;
23366 octave_value_list *_outp=&_out;
23367 octave_value _outv;
23377 arg1 =
static_cast< PLINT >(val1);
23382 arg2 =
static_cast< PLINT >(val2);
23387 arg3 =
static_cast< PLINT >(val3);
23392 arg4 =
static_cast< PLINT >(val4);
23393 plscol0(arg1,arg2,arg3,arg4);
23394 _outv = octave_value();
23398 return octave_value_list();
23422 octave_value_list _out;
23423 octave_value_list *_outp=&_out;
23424 octave_value _outv;
23434 arg1 =
static_cast< PLINT >(val1);
23439 arg2 =
static_cast< PLINT >(val2);
23444 arg3 =
static_cast< PLINT >(val3);
23449 arg4 =
static_cast< PLINT >(val4);
23454 arg5 =
static_cast< PLFLT >(val5);
23455 plscol0a(arg1,arg2,arg3,arg4,arg5);
23456 _outv = octave_value();
23460 return octave_value_list();
23478 octave_value_list _out;
23479 octave_value_list *_outp=&_out;
23480 octave_value _outv;
23490 arg1 =
static_cast< PLINT >(val1);
23495 arg2 =
static_cast< PLINT >(val2);
23500 arg3 =
static_cast< PLINT >(val3);
23502 _outv = octave_value();
23506 return octave_value_list();
23527 octave_value_list _out;
23528 octave_value_list *_outp=&_out;
23529 octave_value _outv;
23539 arg1 =
static_cast< PLINT >(val1);
23544 arg2 =
static_cast< PLINT >(val2);
23549 arg3 =
static_cast< PLINT >(val3);
23554 arg4 =
static_cast< PLFLT >(val4);
23556 _outv = octave_value();
23560 return octave_value_list();
23572 octave_value_list _out;
23573 octave_value_list *_outp=&_out;
23574 octave_value _outv;
23584 arg1 =
static_cast< PLINT >(val1);
23586 _outv = octave_value();
23590 return octave_value_list();
23602 octave_value_list _out;
23603 octave_value_list *_outp=&_out;
23604 octave_value _outv;
23614 arg1 =
static_cast< PLINT >(val1);
23616 _outv = octave_value();
23620 return octave_value_list();
23629 char *arg1 = (
char *) 0 ;
23633 octave_value_list _out;
23634 octave_value_list *_outp=&_out;
23635 octave_value _outv;
23645 arg1 =
reinterpret_cast< char *
>(buf1);
23646 plsdev((
char const *)arg1);
23647 _outv = octave_value();
23653 return octave_value_list();
23675 octave_value_list _out;
23676 octave_value_list *_outp=&_out;
23677 octave_value _outv;
23687 arg1 =
static_cast< PLFLT >(val1);
23692 arg2 =
static_cast< PLFLT >(val2);
23697 arg3 =
static_cast< PLFLT >(val3);
23702 arg4 =
static_cast< PLFLT >(val4);
23704 _outv = octave_value();
23708 return octave_value_list();
23735 octave_value_list _out;
23736 octave_value_list *_outp=&_out;
23737 octave_value _outv;
23747 arg1 =
static_cast< PLINT >(val1);
23752 arg2 =
static_cast< PLINT >(val2);
23757 arg3 =
static_cast< PLINT >(val3);
23762 arg4 =
static_cast< PLINT >(val4);
23767 arg5 =
static_cast< PLFLT >(val5);
23772 arg6 =
static_cast< PLFLT >(val6);
23773 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
23774 _outv = octave_value();
23778 return octave_value_list();
23790 octave_value_list _out;
23791 octave_value_list *_outp=&_out;
23792 octave_value _outv;
23802 arg1 =
static_cast< PLFLT >(val1);
23804 _outv = octave_value();
23808 return octave_value_list();
23829 octave_value_list _out;
23830 octave_value_list *_outp=&_out;
23831 octave_value _outv;
23841 arg1 =
static_cast< PLFLT >(val1);
23846 arg2 =
static_cast< PLFLT >(val2);
23851 arg3 =
static_cast< PLFLT >(val3);
23856 arg4 =
static_cast< PLFLT >(val4);
23858 _outv = octave_value();
23862 return octave_value_list();
23883 octave_value_list _out;
23884 octave_value_list *_outp=&_out;
23885 octave_value _outv;
23895 arg1 =
static_cast< PLFLT >(val1);
23900 arg2 =
static_cast< PLFLT >(val2);
23905 arg3 =
static_cast< PLFLT >(val3);
23910 arg4 =
static_cast< PLFLT >(val4);
23912 _outv = octave_value();
23916 return octave_value_list();
23925 unsigned int arg1 ;
23926 unsigned int val1 ;
23928 octave_value_list _out;
23929 octave_value_list *_outp=&_out;
23930 octave_value _outv;
23940 arg1 =
static_cast< unsigned int >(val1);
23942 _outv = octave_value();
23946 return octave_value_list();
23958 octave_value_list _out;
23959 octave_value_list *_outp=&_out;
23960 octave_value _outv;
23970 arg1 =
static_cast< char >(val1);
23972 _outv = octave_value();
23976 return octave_value_list();
23985 char *arg1 = (
char *) 0 ;
23986 char *arg2 = (
char *) 0 ;
23993 octave_value_list _out;
23994 octave_value_list *_outp=&_out;
23995 octave_value _outv;
24006 arg1 =
reinterpret_cast< char *
>(buf1);
24011 arg2 =
reinterpret_cast< char *
>(buf2);
24012 result = (
PLINT)
plsetopt((
char const *)arg1,(
char const *)arg2);
24021 return octave_value_list();
24041 octave_value_list _out;
24042 octave_value_list *_outp=&_out;
24043 octave_value _outv;
24053 arg1 =
static_cast< PLINT >(val1);
24058 arg2 =
static_cast< PLINT >(val2);
24063 arg3 =
static_cast< PLINT >(val3);
24065 _outv = octave_value();
24069 return octave_value_list();
24079 unsigned int val1 ;
24081 octave_value_list _out;
24082 octave_value_list *_outp=&_out;
24083 octave_value _outv;
24095 _outv = octave_value();
24099 return octave_value_list();
24108 char *arg1 = (
char *) 0 ;
24112 octave_value_list _out;
24113 octave_value_list *_outp=&_out;
24114 octave_value _outv;
24124 arg1 =
reinterpret_cast< char *
>(buf1);
24126 _outv = octave_value();
24132 return octave_value_list();
24151 octave_value_list _out;
24152 octave_value_list *_outp=&_out;
24153 octave_value _outv;
24163 arg1 =
static_cast< PLINT >(val1);
24168 arg2 =
static_cast< PLINT >(val2);
24173 arg3 =
static_cast< PLINT >(val3);
24175 _outv = octave_value();
24179 return octave_value_list();
24191 octave_value_list _out;
24192 octave_value_list *_outp=&_out;
24193 octave_value _outv;
24200 octave_value obj = args(0);
24201#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24202 if ( !obj.isempty() )
24204 if ( !obj.is_empty() )
24207 if ( obj.is_function_handle() || obj.is_inline_function() )
24211 else if ( obj.is_string() )
24228 _outv = octave_value();
24232 return octave_value_list();
24247 octave_value_list _out;
24248 octave_value_list *_outp=&_out;
24249 octave_value _outv;
24259 arg1 =
static_cast< PLFLT >(val1);
24264 arg2 =
static_cast< PLFLT >(val2);
24266 _outv = octave_value();
24270 return octave_value_list();
24285 octave_value_list _out;
24286 octave_value_list *_outp=&_out;
24287 octave_value _outv;
24297 arg1 =
static_cast< PLFLT >(val1);
24302 arg2 =
static_cast< PLFLT >(val2);
24304 _outv = octave_value();
24308 return octave_value_list();
24320 octave_value_list _out;
24321 octave_value_list *_outp=&_out;
24322 octave_value _outv;
24332 arg1 =
static_cast< PLINT >(val1);
24334 _outv = octave_value();
24338 return octave_value_list();
24365 octave_value_list _out;
24366 octave_value_list *_outp=&_out;
24367 octave_value _outv;
24377 arg1 =
static_cast< PLFLT >(val1);
24382 arg2 =
static_cast< PLFLT >(val2);
24387 arg3 =
static_cast< PLINT >(val3);
24392 arg4 =
static_cast< PLINT >(val4);
24397 arg5 =
static_cast< PLINT >(val5);
24402 arg6 =
static_cast< PLINT >(val6);
24403 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
24404 _outv = octave_value();
24408 return octave_value_list();
24417 char *arg1 = (
char *) 0 ;
24421 octave_value_list _out;
24422 octave_value_list *_outp=&_out;
24423 octave_value _outv;
24433 arg1 =
reinterpret_cast< char *
>(buf1);
24435 _outv = octave_value();
24441 return octave_value_list();
24451 char *arg1 = (
char *) 0 ;
24458 octave_value_list _out;
24459 octave_value_list *_outp=&_out;
24460 octave_value _outv;
24470 arg1 =
reinterpret_cast< char *
>(buf1);
24475 arg2 =
static_cast< PLBOOL >(val2);
24476 plspal1((
char const *)arg1,arg2);
24477 _outv = octave_value();
24483 return octave_value_list();
24496 octave_value_list _out;
24497 octave_value_list *_outp=&_out;
24498 octave_value _outv;
24508 arg1 =
static_cast< PLBOOL >(val1);
24510 _outv = octave_value();
24514 return octave_value_list();
24526 octave_value_list _out;
24527 octave_value_list *_outp=&_out;
24528 octave_value _outv;
24538 arg1 =
static_cast< PLINT >(val1);
24540 _outv = octave_value();
24544 return octave_value_list();
24559 octave_value_list _out;
24560 octave_value_list *_outp=&_out;
24561 octave_value _outv;
24571 arg1 =
static_cast< PLINT >(val1);
24576 arg2 =
static_cast< PLINT >(val2);
24578 _outv = octave_value();
24582 return octave_value_list();
24597 octave_value_list _out;
24598 octave_value_list *_outp=&_out;
24599 octave_value _outv;
24609 arg1 =
static_cast< PLFLT >(val1);
24614 arg2 =
static_cast< PLFLT >(val2);
24616 _outv = octave_value();
24620 return octave_value_list();
24635 octave_value_list _out;
24636 octave_value_list *_outp=&_out;
24637 octave_value _outv;
24647 arg1 =
static_cast< PLINT >(val1);
24652 arg2 =
static_cast< PLINT >(val2);
24654 _outv = octave_value();
24658 return octave_value_list();
24667 char *arg1 = (
char *) 0 ;
24677 octave_value_list _out;
24678 octave_value_list *_outp=&_out;
24679 octave_value _outv;
24689 arg1 =
reinterpret_cast< char *
>(buf1);
24694 arg2 =
static_cast< PLINT >(val2);
24699 arg3 =
static_cast< PLINT >(val3);
24700 plstart((
char const *)arg1,arg2,arg3);
24701 _outv = octave_value();
24707 return octave_value_list();
24720 octave_value_list _out;
24721 octave_value_list *_outp=&_out;
24722 octave_value _outv;
24729 octave_value obj = args(0);
24730#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24731 if ( !obj.isempty() )
24733 if ( !obj.is_empty() )
24736 if ( obj.is_function_handle() || obj.is_inline_function() )
24740 else if ( obj.is_string() )
24757 _outv = octave_value();
24761 return octave_value_list();
24773 char *arg4 = (
char *) 0 ;
24779 octave_value_list _out;
24780 octave_value_list *_outp=&_out;
24781 octave_value _outv;
24788 if (
_n_dims( args(0) ) > 1 )
24793 temp1 = args(0).matrix_value();
24794 arg2 = &temp1( 0, 0 );
24797 if (
_n_dims( args(1) ) > 1 )
24805 temp3 = args(1).matrix_value();
24806 arg3 = &temp3( 0, 0 );
24812 arg4 =
reinterpret_cast< char *
>(buf4);
24813 plstring(arg1,(
double const *)arg2,(
double const *)arg3,(
char const *)arg4);
24814 _outv = octave_value();
24832 return octave_value_list();
24852 char *arg5 = (
char *) 0 ;
24859 octave_value_list _out;
24860 octave_value_list *_outp=&_out;
24861 octave_value _outv;
24868 if (
_n_dims( args(0) ) > 1 )
24873 temp1 = args(0).matrix_value();
24874 arg2 = &temp1( 0, 0 );
24877 if (
_n_dims( args(1) ) > 1 )
24885 temp3 = args(1).matrix_value();
24886 arg3 = &temp3( 0, 0 );
24889 if (
_n_dims( args(2) ) > 1 )
24897 temp4 = args(2).matrix_value();
24898 arg4 = &temp4( 0, 0 );
24904 arg5 =
reinterpret_cast< char *
>(buf5);
24905 plstring3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
char const *)arg5);
24906 _outv = octave_value();
24930 return octave_value_list();
24961 octave_value_list _out;
24962 octave_value_list *_outp=&_out;
24963 octave_value _outv;
24973 arg1 =
static_cast< PLINT >(val1);
24978 arg2 =
static_cast< PLINT >(val2);
24983 arg3 =
static_cast< PLFLT >(val3);
24988 arg4 =
static_cast< PLFLT >(val4);
24990 _outv = octave_value();
24994 return octave_value_list();
25006 octave_value_list _out;
25007 octave_value_list *_outp=&_out;
25008 octave_value _outv;
25018 arg1 =
static_cast< PLINT >(val1);
25020 _outv = octave_value();
25024 return octave_value_list();
25038 octave_value_list _out;
25039 octave_value_list *_outp=&_out;
25040 octave_value _outv;
25047 if (
_n_dims( args(0) ) > 1 )
25053 temp1 = args(0).matrix_value();
25057 if (
_n_dims( args(1) ) > 1 )
25065 temp3 = args(1).matrix_value();
25069 plstyl(arg1,(
int const *)arg2,(
int const *)arg3);
25070 _outv = octave_value();
25086 return octave_value_list();
25109 octave_value_list _out;
25110 octave_value_list *_outp=&_out;
25111 octave_value _outv;
25118 if (
_n_dims( args(0) ) > 1 )
25122#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25123 if ( !args(0).isempty() )
25125 if ( !args(0).is_empty() )
25129 temp1 = args(0).matrix_value();
25130 arg1 = &temp1( 0, 0 );
25139 if (
_n_dims( args(1) ) > 1 )
25143#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25144 if ( !args(1).isempty() )
25146 if ( !args(1).is_empty() )
25153 temp2 = args(1).matrix_value();
25154 arg2 = &temp2( 0, 0 );
25167 arg4 =
static_cast< PLBOOL >(val4);
25168 plsvect((
double const *)arg1,(
double const *)arg2,arg3,arg4);
25169 _outv = octave_value();
25185 return octave_value_list();
25212 octave_value_list _out;
25213 octave_value_list *_outp=&_out;
25214 octave_value _outv;
25224 arg1 =
static_cast< PLFLT >(val1);
25229 arg2 =
static_cast< PLFLT >(val2);
25234 arg3 =
static_cast< PLFLT >(val3);
25239 arg4 =
static_cast< PLFLT >(val4);
25240 plsvpa(arg1,arg2,arg3,arg4);
25241 _outv = octave_value();
25245 return octave_value_list();
25260 octave_value_list _out;
25261 octave_value_list *_outp=&_out;
25262 octave_value _outv;
25272 arg1 =
static_cast< PLINT >(val1);
25277 arg2 =
static_cast< PLINT >(val2);
25279 _outv = octave_value();
25283 return octave_value_list();
25298 octave_value_list _out;
25299 octave_value_list *_outp=&_out;
25300 octave_value _outv;
25310 arg1 =
static_cast< PLINT >(val1);
25315 arg2 =
static_cast< PLINT >(val2);
25317 _outv = octave_value();
25321 return octave_value_list();
25338 octave_value_list _out;
25339 octave_value_list *_outp=&_out;
25340 octave_value _outv;
25347 if (
_n_dims( args(0) ) > 1 )
25352 temp1 = args(0).matrix_value();
25353 arg2 = &temp1( 0, 0 );
25356 if (
_n_dims( args(1) ) > 1 )
25364 temp3 = args(1).matrix_value();
25365 arg3 = &temp3( 0, 0 );
25371 arg4 =
static_cast< PLINT >(val4);
25372 plsym(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
25373 _outv = octave_value();
25389 return octave_value_list();
25410 octave_value_list _out;
25411 octave_value_list *_outp=&_out;
25412 octave_value _outv;
25422 arg1 =
static_cast< PLINT >(val1);
25427 arg2 =
static_cast< PLINT >(val2);
25429 _outv = octave_value();
25433 return octave_value_list();
25442 octave_value_list _out;
25443 octave_value_list *_outp=&_out;
25444 octave_value _outv;
25451 _outv = octave_value();
25455 return octave_value_list();
25464 char *arg1 = (
char *) 0 ;
25468 octave_value_list _out;
25469 octave_value_list *_outp=&_out;
25470 octave_value _outv;
25480 arg1 =
reinterpret_cast< char *
>(buf1);
25482 _outv = octave_value();
25488 return octave_value_list();
25501 octave_value_list _out;
25502 octave_value_list *_outp=&_out;
25503 octave_value _outv;
25513 arg1 =
static_cast< PLFLT >(val1);
25515 _outv = octave_value();
25519 return octave_value_list();
25543 octave_value_list _out;
25544 octave_value_list *_outp=&_out;
25545 octave_value _outv;
25555 arg1 =
static_cast< PLFLT >(val1);
25560 arg2 =
static_cast< PLFLT >(val2);
25565 arg3 =
static_cast< PLFLT >(val3);
25570 arg4 =
static_cast< PLFLT >(val4);
25575 arg5 =
static_cast< PLFLT >(val5);
25576 plvpas(arg1,arg2,arg3,arg4,arg5);
25577 _outv = octave_value();
25581 return octave_value_list();
25602 octave_value_list _out;
25603 octave_value_list *_outp=&_out;
25604 octave_value _outv;
25614 arg1 =
static_cast< PLFLT >(val1);
25619 arg2 =
static_cast< PLFLT >(val2);
25624 arg3 =
static_cast< PLFLT >(val3);
25629 arg4 =
static_cast< PLFLT >(val4);
25630 plvpor(arg1,arg2,arg3,arg4);
25631 _outv = octave_value();
25635 return octave_value_list();
25644 octave_value_list _out;
25645 octave_value_list *_outp=&_out;
25646 octave_value _outv;
25653 _outv = octave_value();
25657 return octave_value_list();
25699 octave_value_list _out;
25700 octave_value_list *_outp=&_out;
25701 octave_value _outv;
25711 arg1 =
static_cast< PLFLT >(val1);
25716 arg2 =
static_cast< PLFLT >(val2);
25721 arg3 =
static_cast< PLFLT >(val3);
25726 arg4 =
static_cast< PLFLT >(val4);
25731 arg5 =
static_cast< PLFLT >(val5);
25736 arg6 =
static_cast< PLFLT >(val6);
25741 arg7 =
static_cast< PLFLT >(val7);
25746 arg8 =
static_cast< PLFLT >(val8);
25751 arg9 =
static_cast< PLFLT >(val9);
25756 arg10 =
static_cast< PLFLT >(val10);
25761 arg11 =
static_cast< PLFLT >(val11);
25762 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25763 _outv = octave_value();
25767 return octave_value_list();
25779 octave_value_list _out;
25780 octave_value_list *_outp=&_out;
25781 octave_value _outv;
25791 arg1 =
static_cast< PLFLT >(val1);
25793 _outv = octave_value();
25797 return octave_value_list();
25818 octave_value_list _out;
25819 octave_value_list *_outp=&_out;
25820 octave_value _outv;
25830 arg1 =
static_cast< PLFLT >(val1);
25835 arg2 =
static_cast< PLFLT >(val2);
25840 arg3 =
static_cast< PLFLT >(val3);
25845 arg4 =
static_cast< PLFLT >(val4);
25846 plwind(arg1,arg2,arg3,arg4);
25847 _outv = octave_value();
25851 return octave_value_list();
25866 octave_value_list _out;
25867 octave_value_list *_outp=&_out;
25868 octave_value _outv;
25879 arg1 =
static_cast< PLBOOL >(val1);
25881 _outv = octave_value();
25891 return octave_value_list();
25901 char *arg2 = (
char *) 0 ;
25917 octave_value_list _out;
25918 octave_value_list *_outp=&_out;
25919 octave_value _outv;
25926 octave_value obj = args(0);
25927#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25928 if ( !obj.isempty() )
25930 if ( !obj.is_empty() )
25933 if ( obj.is_function_handle() || obj.is_inline_function() )
25937 else if ( obj.is_string() )
25953 arg2 =
reinterpret_cast< char *
>(buf2);
25958 arg3 =
static_cast< PLFLT >(val3);
25963 arg4 =
static_cast< PLFLT >(val4);
25968 arg5 =
static_cast< PLFLT >(val5);
25973 arg6 =
static_cast< PLFLT >(val6);
25974 plmap(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6);
25975 _outv = octave_value();
25981 return octave_value_list();
25992 char *arg2 = (
char *) 0 ;
26011 octave_value_list _out;
26012 octave_value_list *_outp=&_out;
26013 octave_value _outv;
26020 octave_value obj = args(0);
26021#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26022 if ( !obj.isempty() )
26024 if ( !obj.is_empty() )
26027 if ( obj.is_function_handle() || obj.is_inline_function() )
26031 else if ( obj.is_string() )
26047 arg2 =
reinterpret_cast< char *
>(buf2);
26052 arg3 =
static_cast< PLFLT >(val3);
26057 arg4 =
static_cast< PLFLT >(val4);
26062 arg5 =
static_cast< PLFLT >(val5);
26067 arg6 =
static_cast< PLFLT >(val6);
26069 if (
_n_dims( args(6) ) > 1 )
26073#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26074 if ( !args(6).isempty() )
26076 if ( !args(6).is_empty() )
26080 temp7 = args(6).matrix_value();
26081 arg7 =
new PLINT[arg8];
26090 plmapline(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
26091 _outv = octave_value();
26103 return octave_value_list();
26117 char *arg2 = (
char *) 0 ;
26118 char *arg3 = (
char *) 0 ;
26140 octave_value_list _out;
26141 octave_value_list *_outp=&_out;
26142 octave_value _outv;
26149 octave_value obj = args(0);
26150#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26151 if ( !obj.isempty() )
26153 if ( !obj.is_empty() )
26156 if ( obj.is_function_handle() || obj.is_inline_function() )
26160 else if ( obj.is_string() )
26176 arg2 =
reinterpret_cast< char *
>(buf2);
26181 arg3 =
reinterpret_cast< char *
>(buf3);
26186 arg4 =
static_cast< PLFLT >(val4);
26191 arg5 =
static_cast< PLFLT >(val5);
26196 arg6 =
static_cast< PLFLT >(val6);
26201 arg7 =
static_cast< PLFLT >(val7);
26203 if (
_n_dims( args(7) ) > 1 )
26207#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26208 if ( !args(7).isempty() )
26210 if ( !args(7).is_empty() )
26214 temp8 = args(7).matrix_value();
26215 arg8 =
new PLINT[arg9];
26224 plmapstring(arg1,(
char const *)arg2,(
char const *)arg3,arg4,arg5,arg6,arg7,(
int const *)arg8,arg9);
26225 _outv = octave_value();
26239 return octave_value_list();
26254 char *arg2 = (
char *) 0 ;
26258 char *arg6 = (
char *) 0 ;
26286 octave_value_list _out;
26287 octave_value_list *_outp=&_out;
26288 octave_value _outv;
26295 octave_value obj = args(0);
26296#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26297 if ( !obj.isempty() )
26299 if ( !obj.is_empty() )
26302 if ( obj.is_function_handle() || obj.is_inline_function() )
26306 else if ( obj.is_string() )
26322 arg2 =
reinterpret_cast< char *
>(buf2);
26327 arg3 =
static_cast< PLFLT >(val3);
26332 arg4 =
static_cast< PLFLT >(val4);
26337 arg5 =
static_cast< PLFLT >(val5);
26342 arg6 =
reinterpret_cast< char *
>(buf6);
26347 arg7 =
static_cast< PLFLT >(val7);
26352 arg8 =
static_cast< PLFLT >(val8);
26357 arg9 =
static_cast< PLFLT >(val9);
26362 arg10 =
static_cast< PLFLT >(val10);
26367 arg11 =
static_cast< PLINT >(val11);
26368 plmaptex(arg1,(
char const *)arg2,arg3,arg4,arg5,(
char const *)arg6,arg7,arg8,arg9,arg10,arg11);
26369 _outv = octave_value();
26377 return octave_value_list();
26389 char *arg2 = (
char *) 0 ;
26408 octave_value_list _out;
26409 octave_value_list *_outp=&_out;
26410 octave_value _outv;
26417 octave_value obj = args(0);
26418#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26419 if ( !obj.isempty() )
26421 if ( !obj.is_empty() )
26424 if ( obj.is_function_handle() || obj.is_inline_function() )
26428 else if ( obj.is_string() )
26444 arg2 =
reinterpret_cast< char *
>(buf2);
26449 arg3 =
static_cast< PLFLT >(val3);
26454 arg4 =
static_cast< PLFLT >(val4);
26459 arg5 =
static_cast< PLFLT >(val5);
26464 arg6 =
static_cast< PLFLT >(val6);
26466 if (
_n_dims( args(6) ) > 1 )
26470#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26471 if ( !args(6).isempty() )
26473 if ( !args(6).is_empty() )
26477 temp7 = args(6).matrix_value();
26478 arg7 =
new PLINT[arg8];
26487 plmapfill(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
26488 _outv = octave_value();
26500 return octave_value_list();
26532 octave_value_list _out;
26533 octave_value_list *_outp=&_out;
26534 octave_value _outv;
26541 octave_value obj = args(0);
26542#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26543 if ( !obj.isempty() )
26545 if ( !obj.is_empty() )
26548 if ( obj.is_function_handle() || obj.is_inline_function() )
26552 else if ( obj.is_string() )
26568 arg2 =
static_cast< PLFLT >(val2);
26573 arg3 =
static_cast< PLFLT >(val3);
26578 arg4 =
static_cast< PLFLT >(val4);
26583 arg5 =
static_cast< PLFLT >(val5);
26588 arg6 =
static_cast< PLFLT >(val6);
26593 arg7 =
static_cast< PLFLT >(val7);
26595 _outv = octave_value();
26599 return octave_value_list();
26608 octave_value_list _out;
26609 octave_value_list *_outp=&_out;
26610 octave_value _outv;
26617 _outv = octave_value();
26621 return octave_value_list();
26630 octave_value_list _out;
26631 octave_value_list *_outp=&_out;
26632 octave_value _outv;
26639 _outv = octave_value();
26643 return octave_value_list();
26652 char *arg1 = (
char *) 0 ;
26653 char *arg2 = (
char *) 0 ;
26660 octave_value_list _out;
26661 octave_value_list *_outp=&_out;
26662 octave_value _outv;
26672 arg1 =
reinterpret_cast< char *
>(buf1);
26677 arg2 =
reinterpret_cast< char *
>(buf2);
26678 plSetUsage((
char const *)arg1,(
char const *)arg2);
26679 _outv = octave_value();
26687 return octave_value_list();
26698 octave_value_list _out;
26699 octave_value_list *_outp=&_out;
26700 octave_value _outv;
26707 _outv = octave_value();
26711 return octave_value_list();
26721{
"testppchar",_wrap_testppchar,0,0,2,0},
26723{
"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
26726{
"plcont0",_wrap_plcont0,0,0,2,0},
26727{
"plcont1",_wrap_plcont1,0,0,2,0},
26728{
"plcont2",_wrap_plcont2,0,0,2,0},
26729{
"plcont2p",_wrap_plcont2p,0,0,2,0},
26739{
"plshade1",_wrap_plshade1,0,0,2,0},
26740{
"plshade2",_wrap_plshade2,0,0,2,0},
26742{
"plshadesx",_wrap_plshadesx,0,0,2,0},
26743{
"plshades1",_wrap_plshades1,0,0,2,0},
26744{
"plshades2",_wrap_plshades2,0,0,2,0},
26746{
"plvect1",_wrap_plvect1,0,0,2,0},
26747{
"plvect2",_wrap_plvect2,0,0,2,0},
26748{
"pplimage",_wrap_pplimage,0,0,2,0},
26750{
"plimagefrx",_wrap_plimagefrx,0,0,2,0},
26751{
"plimagefr1",_wrap_plimagefr1,0,0,2,0},
26752{
"plimagefr2",_wrap_plimagefr2,0,0,2,0},
27038#define SWIGRUNTIME_DEBUG
27041#ifndef SWIG_INIT_CLIENT_DATA_TYPE
27042#define SWIG_INIT_CLIENT_DATA_TYPE void *
27064 if (!module_head) {
27077 }
while (iter!= module_head);
27088 if (init == 0)
return;
27091#ifdef SWIGRUNTIME_DEBUG
27092 printf(
"SWIG_InitializeModule: size %lu\n", (
unsigned long)
swig_module.
size);
27099#ifdef SWIGRUNTIME_DEBUG
27109#ifdef SWIGRUNTIME_DEBUG
27110 printf(
"SWIG_InitializeModule: found type %s\n", type->
name);
27114#ifdef SWIGRUNTIME_DEBUG
27115 printf(
"SWIG_InitializeModule: found and overwrite type %s \n", type->
name);
27124 while (cast->
type) {
27128#ifdef SWIGRUNTIME_DEBUG
27129 printf(
"SWIG_InitializeModule: look cast %s\n", cast->
type->
name);
27133#ifdef SWIGRUNTIME_DEBUG
27134 if (ret) printf(
"SWIG_InitializeModule: found cast %s\n", ret->
name);
27139#ifdef SWIGRUNTIME_DEBUG
27140 printf(
"SWIG_InitializeModule: skip old type %s\n", ret->
name);
27147#ifdef SWIGRUNTIME_DEBUG
27148 if (ocast) printf(
"SWIG_InitializeModule: skip old cast %s\n", ret->
name);
27150 if (!ocast) ret = 0;
27155#ifdef SWIGRUNTIME_DEBUG
27156 printf(
"SWIG_InitializeModule: adding cast %s\n", cast->
type->
name);
27171#ifdef SWIGRUNTIME_DEBUG
27172 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
27177 while (cast->
type) {
27178 printf(
"SWIG_InitializeModule: cast type %s\n", cast->
type->
name);
27182 printf(
"---- Total casts: %d\n",j);
27184 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
27197 static int init_run = 0;
27199 if (init_run)
return;
27210 equiv = equiv->
next;
27230#if SWIG_OCTAVE_PREREQ(6,0,0)
27231#elif SWIG_OCTAVE_PREREQ(4,2,0)
27232 octave::unwind_protect frame;
27233 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27234 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27235#elif SWIG_OCTAVE_PREREQ(3,3,50)
27236 unwind_protect frame;
27237 frame.protect_var(error_state); error_state = 0;
27238 frame.protect_var(warning_state); warning_state = 0;
27239 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27240 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27242 unwind_protect::begin_frame(
"SWIG_Octave_LoadModule");
27243 unwind_protect_int(error_state); error_state = 0;
27244 unwind_protect_int(warning_state); warning_state = 0;
27245 unwind_protect_bool(discard_error_messages); discard_error_messages =
true;
27246 unwind_protect_bool(discard_warning_messages); discard_warning_messages =
true;
27248#if SWIG_OCTAVE_PREREQ(4,2,0)
27250#if SWIG_OCTAVE_PREREQ(4,4,0)
27251 octave::feval(
name, octave_value_list(), 0);
27253 feval(
name, octave_value_list(), 0);
27256 }
catch (octave::execution_exception&) { }
27258 feval(
name, octave_value_list(), 0);
27259 retn = (error_state == 0);
27261#if !SWIG_OCTAVE_PREREQ(3,3,50)
27262 unwind_protect::run_frame(
"SWIG_Octave_LoadModule");
27274#if SWIG_OCTAVE_PREREQ(6,0,0)
27275#elif SWIG_OCTAVE_PREREQ(4,2,0)
27276 octave::unwind_protect frame;
27277 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27278 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27279#elif SWIG_OCTAVE_PREREQ(3,3,50)
27280 unwind_protect frame;
27281 frame.protect_var(error_state); error_state = 0;
27282 frame.protect_var(warning_state); warning_state = 0;
27283 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27284 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27286 unwind_protect::begin_frame(
"SWIG_Octave_InstallFunction");
27287 unwind_protect_int(error_state); error_state = 0;
27288 unwind_protect_int(warning_state); warning_state = 0;
27289 unwind_protect_bool(discard_error_messages); discard_error_messages =
true;
27290 unwind_protect_bool(discard_warning_messages); discard_warning_messages =
true;
27292 octave_value_list args;
27294 args.append(octloadfcn->fcn_file_name());
27295#if SWIG_OCTAVE_PREREQ(4,2,0)
27297#if SWIG_OCTAVE_PREREQ(4,4,0)
27298 octave::feval(
"autoload", args, 0);
27300 feval(
"autoload", args, 0);
27303 }
catch (octave::execution_exception&) { }
27305 feval(
"autoload", args, 0);
27306 retn = (error_state == 0);
27308#if !SWIG_OCTAVE_PREREQ(3,3,50)
27309 unwind_protect::run_frame(
"SWIG_Octave_InstallFunction");
27319@deftypefn {Loadable Function} {} subclass()\n\
27320@deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
27321Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
27323See the SWIG manual for usage examples.\n\
27328 for (
int j = 0; j < args.length(); ++j) {
27329 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
27333 error(
"subclass: cannot subclass object not constructed on octave side");
27334 return octave_value_list();
27337 }
else if (args(j).is_function_handle()) {
27338 top->
assign(args(j).fcn_handle_value()->fcn_name(), args(j));
27339 }
else if (args(j).is_string()) {
27340 if (j + 1 >= args.length()) {
27341 error(
"subclass: member assignments must be of string,value form");
27342 return octave_value_list();
27344 top->
assign(args(j).string_value(), args(j + 1));
27347 error(
"subclass: invalid arguments to subclass()");
27348 return octave_value_list();
27355@deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
27356Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
27360 if (args.length() != 1) {
27361 error(
"swig_type: must be called with only a single object");
27362 return octave_value_list();
27366 error(
"swig_type: object is not a swig_ref");
27367 return octave_value_list();
27373@deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
27374Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
27375otherwise return `<unknown>'.\n\
27379 if (args.length() != 1 || !args(0).is_string()) {
27380 error(
"swig_typequery: must be called with single string argument");
27381 return octave_value_list();
27386 return octave_value(
"<unknown>");
27387 return octave_value(type->
name);
27391@deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
27392Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
27396 if (args.length() != 1) {
27397 error(
"swig_this: must be called with only a single object");
27398 return octave_value_list();
27400 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
27401 return octave_value(octave_uint64(0));
27404 error(
"swig_this: object is not a swig_ref");
27405 return octave_value_list();
27407 return octave_value(octave_uint64((
unsigned long long) ost->
swig_this()));
27411@deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
27412Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
27416 if (args.length() != 3) {
27417 error(
"swig_octave_prereq: must be called with 3 arguments");
27418 return octave_value_list();
27420 const int major = args(0).int_value();
27421 const int minor = args(1).int_value();
27422 const int patch = args(2).int_value();
27424 return octave_value(prereq);
27428@deftypefn {Loadable Function} {} swig_exit([@var{exit_status}])\n\
27429Exit Octave without performing any memory cleanup.\n\
27433 if (args.length() > 1) {
27434 error(
"swig_exit: must be called with at most one arguments");
27435 return octave_value_list();
27437 int exit_status = 0;
27438 if (args.length() == 1) {
27439 exit_status = args(0).int_value();
27441 ::_Exit(exit_status);
27442 return octave_value();
27446@deftypefn {Loadable Module} {} " SWIG_name_d "\n\
27447Loads the SWIG-generated module `" SWIG_name_d "'.\n\
27460#ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
27461#if !SWIG_OCTAVE_PREREQ(4,4,0)
27462#if SWIG_OCTAVE_PREREQ(3,2,0)
27463 octave_exit = ::_Exit;
27469 if (args.length() != 0 || nargout != 0) {
27471 return octave_value_list();
27479#if SWIG_OCTAVE_PREREQ(3,2,0)
27480 octave_value_list eval_args;
27481 eval_args.append(
"base");
27482 eval_args.append(
"function __swig_atexit__; "
27489 "__swig_atexit__; "
27490 "atexit(\"__swig_atexit__\", false); "
27491 "atexit(\"__swig_atexit__\")");
27492#if SWIG_OCTAVE_PREREQ(4,4,0)
27493 octave::feval(
"evalin", eval_args, 0);
27495 feval(
"evalin", eval_args, 0);
27499#if SWIG_OCTAVE_PREREQ(4,4,0)
27501 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
27502 string_vector types = typeinfo.installed_type_names();
27503 bool register_octave_swig_ref =
true;
27504 bool register_octave_swig_packed =
true;
27505 for (
int i = 0; i < types.numel(); ++i) {
27506 if (types(i) == octave_swig_ref::static_type_name()) {
27507 register_octave_swig_ref =
false;
27508 octave_swig_ref::set_type_id(i);
27510 if (types(i) == octave_swig_packed::static_type_name()) {
27511 register_octave_swig_packed =
false;
27512 octave_swig_packed::set_type_id(i);
27515 if (register_octave_swig_ref) {
27516 octave_swig_ref::register_type();
27518 if (register_octave_swig_packed) {
27519 octave_swig_packed::register_type();
27523 octave_swig_ref::register_type();
27524 octave_swig_packed::register_type();
27529#if SWIG_OCTAVE_PREREQ(6,0,0)
27530 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27531 octave::call_stack& stack = tree_eval.get_call_stack();
27532 octave_function *me = stack.current_function();
27533#elif SWIG_OCTAVE_PREREQ(4,4,0)
27534 octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
27535 octave_function *me = stack.current();
27537 octave_function *me = octave_call_stack::current();
27541 return octave_value_list();
27544 return octave_value_list();
27547 return octave_value_list();
27550 return octave_value_list();
27553 return octave_value_list();
27556 return octave_value_list();
27594 return octave_value_list();
27601 if (mb->second.first && mb->second.first->method) {
27603 return octave_value_list();
27608#if SWIG_OCTAVE_PREREQ(4,4,0)
27609 octave::interpreter::the_interpreter()->mlock();
27610#elif SWIG_OCTAVE_PREREQ(3,2,0)
27620 if (mb->second.second.is_defined()) {
27629 return octave_value_list();
virtual bool load_ascii(std::istream &is)
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
octave_base_value * empty_clone() const
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
octave_base_value * clone() const
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)
octave_swig_type * get_ptr() const
dim_vector dims(void) const
octave_base_value * clone() 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
virtual type_conv_info numeric_conversion_function(void) const
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type='"') const
octave_base_value * empty_clone() 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_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)
const swig_octave_member * find_member(const swig_type_info *type, const std::string &name)
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)
swig_member_const_iterator swig_members_begin()
std::map< std::string, member_value_pair > member_map
member_value_pair * find_member(const std::string &name, bool insert_if_not_found)
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()
octave_base_value * empty_clone() const
dim_vector dims(void) const
octave_base_value * clone() const
bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) 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
const char * help_text() const
void assign(const std::string &name, const swig_octave_member *m)
octave_swig_type & operator=(const octave_swig_type &rhs)
octave_swig_type(void *_ptr=0, const swig_type_info *_type=0, int _own=0, bool _always_static=false)
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
int cast(void **vptr, swig_type_info *type, int *own, int flags)
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
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
const swig_type_info * construct_type
const swig_type_info * find_base(const std::string &name, const swig_type_info *base)
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)
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 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
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)
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)
void my_plot3dc(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
static const char * _wrap_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 const char * _wrap_plgdev_texinfo
static const char * _wrap_plcol0_texinfo
static const char * _wrap_plfamadv_texinfo
SWIGRUNTIME void SWIG_InstallUnaryOps(int tid)
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
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
void my_plmesh(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt)
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
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)
#define swig_unary_op(name)
static const char * _wrap_plsdiori_texinfo
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
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)
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
static const char * _wrap_plslabelfunc_texinfo
static const char * _wrap_plsfci_texinfo
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
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
#define SWIG_AttributeError
static const char * _wrap_plstripc_texinfo
static const char * _wrap_plgfam_texinfo
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
static const char * _wrap_plseed_texinfo
static const char * _wrap_plerrx_texinfo
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)
SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags)
static const char * _wrap_plrgbhls_texinfo
static const char * _wrap_plrandd_texinfo
static const char * _wrap_plmesh_texinfo
static const char * _wrap_plsurf3dl_texinfo
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
plgriddata(x, y, z, xg, yg, type, data)\n\ \n\ \n\ This function is used in example 21.\n\ \n\ \n\ \n\ SYNOPSIS:\n\ \n\ plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\ \n\ ARGUMENTS:\n\ \n\ x(PLFLT_VECTOR, input) :The input x vector.\n\ \n\ y(PLFLT_VECTOR, input) :The input y vector.\n\ \n\ z(PLFLT_VECTOR, input) :The input z vector. Each triple x[i],\n\ y[i], z[i] represents one data sample coordinate.\n\ \n\ npts(PLINT, input) :The number of data samples in the x, y and z\n\ vectors.\n\ \n\ xg(PLFLT_VECTOR, input) :A vector that specifies the grid spacing\n\ in the x direction. Usually xg has nptsx equally spaced values\n\ from the minimum to the maximum values of the x input vector.\n\ \n\ nptsx(PLINT, input) :The number of points in the xg vector.\n\ \n\ yg(PLFLT_VECTOR, input) :A vector that specifies the grid spacing\n\ in the y direction. Similar to the xg parameter.\n\ \n\ nptsy(PLINT, input) :The number of points in the yg vector.\n\ \n\ zg(PLFLT_NC_MATRIX, output) :The matrix of interpolated results\n\ where data lies in the grid specified by xg and yg. Therefore the\n\ zg matrix must be dimensioned\n\ nptsx by\n\ nptsy.\n\ \n\ type(PLINT, input) :The type of grid interpolation algorithm to\n\ use, which can be:GRID_CSA:Bivariate Cubic Spline approximation\n\ GRID_DTLI:Delaunay Triangulation Linear Interpolation\n\ GRID_NNI:Natural Neighbors Interpolation\n\ GRID_NNIDW:Nearest Neighbors Inverse Distance Weighted\n\ GRID_NNLI:Nearest Neighbors Linear Interpolation\n\ GRID_NNAIDW:Nearest Neighbors Around Inverse Distance\n\ Weighted\n\ For details of the algorithms read the source file plgridd.c.\n\ \n\ data(PLFLT, input) :Some gridding algorithms require extra data,\n\ which can be specified through this argument. Currently, for\n\ algorithm:GRID_NNIDW, data specifies the number of neighbors to\n\ use, the lower the value, the noisier(more local) the\n\ approximation is.\n\ GRID_NNLI, data specifies what a thin triangle is, in the\n\ range[1. .. 2.]. High values enable the usage of very thin\n\ triangles for interpolation, possibly resulting in error in\n\ the approximation.\n\ GRID_NNI, only weights greater than data will be accepted. If\n\ 0, all weights will be accepted.\n\ " zg
static const char * _wrap_plgvpw_texinfo
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
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
#define SWIG_as_voidptr(a)
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
void my_plcont0(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel)
SWIGINTERN void SWIG_Octave_Raise(const octave_value &obj, const char *type)
static const char * _wrap_plsdiplz_texinfo
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
static const char * _wrap_plgzax_texinfo
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
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)
#define SWIG_DEFUN(cname, wname, doc)
SWIGINTERN int SWIG_AsCharPtrAndSize(octave_value ov, char **cptr, size_t *psize, int *alloc)
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 const char * _wrap_plscolbga_texinfo
static const char * _wrap_plscol0a_texinfo
void labelfunc_octave(PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data)
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
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
static const char * _wrap_plstar_texinfo
SWIGINTERN int SWIG_AsCharArray(octave_value obj, char *val, size_t size)
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
static const char * _wrap_plsmin_texinfo
static const char * _wrap_plglevel_texinfo
static const char * _wrap_plvpor_texinfo
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
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
static const char * _wrap_plhlsrgb_texinfo
static const char * _wrap_plgvpd_texinfo
SWIGINTERN int SWIG_AsVal_int(octave_value obj, int *val)
static const char * _wrap_plsxax_texinfo
static const char * _wrap_plmtex3_texinfo
struct swig_type_info swig_type_info
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
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
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
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 const char shade or gradient plots n n or n gradient plots(See pllegend for similar functionality for creating\n\ legends with discrete elements). The arguments of plcolorbar provide\n\ control over the location and size of the color bar as well as the\n\ location and characteristics of the elements(most of which are\n\ optional) within that color bar. The resulting color bar is clipped\n\ at the boundaries of the current subpage.(N.B. the adopted coordinate\n\ system used for some of the parameters is defined in the documentation\n\ of the position parameter.)\n\ \n\ Redacted form reads the desired grid location from the input vectors n xg[nptsx] and yg[nptsy]
static const char * _wrap_plfill3_texinfo
static const char * _wrap_plptex3_texinfo
octave_function * fcnMapForm
static const char * _wrap_pleop_texinfo
static const char * _wrap_pltext_texinfo
static const char * _wrap_plgyax_texinfo
static const char * _wrap_plbox_texinfo
static const char * _wrap_pllab_texinfo
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 swig_cast_info * SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty)
static const char * _wrap_plsyax_texinfo
static const char * _wrap_plsdimap_texinfo
static const char * _wrap_plpoin_texinfo
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)
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
DEFUN_DLD(subclass, args, nargout, subclass_usage)
static const char * _wrap_plspal0_texinfo
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
static const char * _wrap_plclear_texinfo
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 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 const char * _wrap_plgspa_texinfo
static const char * _wrap_plpat_texinfo
static const char * _wrap_plline3_texinfo
#define swig_binary_op(name)
static const char * _wrap_plmaptex_texinfo
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
static const char * _wrap_plgdidev_texinfo
static const char *const swig_this_usage
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
SWIGRUNTIME octave_value_list * SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov)
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
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)
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)
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)
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)
static const char * _wrap_plreplot_texinfo
static const char * _wrap_plsvect_texinfo
static const char * _wrap_plerry_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)
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
SWIGINTERN PyObject * _wrap_plstransform(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *self, PyObject *args)
#define SWIG_Error(code, msg)
SWIGINTERN PyObject * _wrap_plgchr(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plshade(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgra(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvpas(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plssub(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plshades(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plerrx(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plprec(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfill3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvsta(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plschr(PyObject *self, PyObject *args)
#define SWIG_ErrorType(code)
SWIGINTERN PyObject * _wrap_plstart(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgyax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcol1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpoin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltext(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgradient(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pladv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgxax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspal1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plwidth(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plline(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvasp(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscolor(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plssym(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plptex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstar(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plwind(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstyl(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsmin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plarc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgdev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plw3d(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pllab(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstring3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscol0(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapline(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpsty(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbox3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmesh(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plszax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plinit(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *self, PyObject *args)
void *(* swig_converter_func)(void *, int *)
SWIGINTERN PyObject * _wrap_plsvect(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pljoin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfill(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plglevel(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpath(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgspa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsesc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *self, PyObject *args)
struct swig_type_info *(* swig_dycast_func)(void **)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsxax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pleop(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plflush(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plrandd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsym(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbop(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgver(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plreplot(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvect(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pllsty(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcol0(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plenv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plenv0(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscompression(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plerry(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plxormod(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plclear(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmap(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plhist(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsyax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpat(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plseed(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfontld(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstring(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plctime(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspause(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspal0(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbtime(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbox(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plaxes(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata)
static int _wrap_PLGraphicsIn_wX_get(lua_State *L)
static swig_cast_info * swig_cast_initial[]
static int _wrap_PLGraphicsIn_button_get(lua_State *L)
static int _wrap_PLGraphicsIn_keysym_get(lua_State *L)
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
static int _wrap_PLGraphicsIn_subwindow_get(lua_State *L)
#define SWIG_TypeQuery(name)
static int _wrap_plend(lua_State *L)
static swig_cast_info _swigc__p_int[]
static swig_cast_info _swigc__p_double[]
#define SWIGTYPE_p_PLGraphicsIn
static int _wrap_plGetCursor(lua_State *L)
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
static int _wrap_PLGraphicsIn_pY_set(lua_State *L)
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
#define SWIG_ConvertPtr(L, idx, ptr, type, flags)
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
static int _wrap_PLGraphicsIn_state_get(lua_State *L)
#define SWIG_RUNTIME_VERSION
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
static int _wrap_new_PLGraphicsIn(lua_State *L)
static int _wrap_PLGraphicsIn_dX_get(lua_State *L)
static int _wrap_PLGraphicsIn_pY_get(lua_State *L)
static swig_type_info * swig_types[13]
static int _wrap_plResetOpts(lua_State *L)
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
static int _wrap_plot3dcl(lua_State *L)
static int _wrap_plOptUsage(lua_State *L)
static swig_module_info swig_module
static const char * swig_PLGraphicsIn_base_names[]
static int _wrap_PLGraphicsIn_state_set(lua_State *L)
static swig_type_info _swigt__p_double
#define SWIG_SetModule(clientdata, pointer)
#define SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_POINTER_RELEASE
static int _wrap_PLGraphicsIn_string_get(lua_State *L)
static swig_type_info _swigt__p_p_char
static int _wrap_plend1(lua_State *L)
#define SWIG_POINTER_CLEAR
#define SWIG_check_num_args(func_name, a, b)
static int _wrap_PLGraphicsIn_string_set(lua_State *L)
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
static int _wrap_plClearOpts(lua_State *L)
static swig_cast_info _swigc__p_char[]
static int _wrap_plot3d(lua_State *L)
PLINT(* defined_func)(PLFLT, PLFLT)
#define SWIG_NewPointerObj(L, ptr, type, owner)
static int _wrap_PLGraphicsIn_keysym_set(lua_State *L)
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
static int _wrap_PLGraphicsIn_dY_get(lua_State *L)
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
#define SWIG_POINTER_NO_NULL
static int _wrap_PLGraphicsIn_type_get(lua_State *L)
#define SWIG_NullReferenceError
static int _wrap_PLGraphicsIn_type_set(lua_State *L)
#define SWIG_POINTER_DISOWN
static swig_type_info _swigt__p_PLGraphicsIn
static int _wrap_PLGraphicsIn_subwindow_set(lua_State *L)
static int _wrap_plot3dc(lua_State *L)
static int _wrap_PLGraphicsIn_wY_get(lua_State *L)
#define SWIG_DelNewMask(r)
static int _wrap_PLGraphicsIn_dX_set(lua_State *L)
#define SWIG_GetModule(clientdata)
static int _wrap_PLGraphicsIn_wX_set(lua_State *L)
static swig_cast_info _swigc__p_unsigned_int[]
static swig_type_info _swigt__p_int
SWIGRUNTIME void SWIG_PropagateClientData(void)
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
static int _wrap_plSetUsage(lua_State *L)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
static int _wrap_PLGraphicsIn_pX_set(lua_State *L)
#define SWIG_ERROR_RELEASE_NOT_OWNED
#define SWIG_TYPE_TABLE_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
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
static int _wrap_PLGraphicsIn_button_set(lua_State *L)
static swig_type_info * swig_type_initial[]
static swig_cast_info _swigc__p_PLGraphicsIn[]
static swig_cast_info _swigc__p_p_char[]
static int _wrap_PLGraphicsIn_pX_get(lua_State *L)
#define SWIGTYPE_p_double
#define SWIGTYPE_p_p_char
static swig_type_info _swigt__p_char
#define SWIG_OverflowError
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
static swig_lua_class _wrap_class_PLGraphicsIn
static int _wrap_PLGraphicsIn_dY_set(lua_State *L)
static int _wrap_PLGraphicsIn_wY_set(lua_State *L)
#define SWIGRUNTIMEINLINE
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
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