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)
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#if SWIG_OCTAVE_PREREQ(8,0,0)
2504 std::shared_ptr<octave::stack_frame> stackFrame = tree_eval.get_current_stack_frame();
2506 octave::call_stack& callStack = tree_eval.get_call_stack();
2507 std::shared_ptr<octave::stack_frame> stackFrame = tree_eval.get_current_stack_frame();
2509 octave::symbol_record sym=symscope.lookup_symbol(
name);
2510 stackFrame->mark_global(sym);
2512 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2513 symscope.assign(
name, symtab.global_varval(
name));
2514 symscope.mark_global(
name);
2517#if !SWIG_OCTAVE_PREREQ(3,2,0)
2518 link_to_global_variable(curr_sym_tab->lookup(
name,
true));
2520#if !SWIG_OCTAVE_PREREQ(3,8,0)
2521 symbol_table::varref(
name);
2523 symbol_table::mark_global(
name);
2530 if (!ov.is_defined() ||
2531 ov.type_id() != octave_swig_packed::static_type_id())
2547 if (obj.is_string())
2548 error(
"%s", obj.string_value().c_str());
2550 error(
"C++ side threw an exception of type %s", type);
2555#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2557#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
2563#define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2564#define SWIGTYPE_p_char swig_types[1]
2565#define SWIGTYPE_p_double swig_types[2]
2566#define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2567#define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2568#define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2569#define SWIGTYPE_p_int swig_types[6]
2570#define SWIGTYPE_p_p_char swig_types[7]
2571#define SWIGTYPE_p_unsigned_int swig_types[8]
2574#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2575#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2583template<
typename T>
class SwigValueWrapper {
2584 struct SwigSmartPointer {
2586 SwigSmartPointer(T *p) : ptr(p) { }
2587 ~SwigSmartPointer() {
delete ptr; }
2588 SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0;
delete oldptr; ptr = rhs.ptr; rhs.ptr = 0;
return *
this; }
2589 void reset(T *p) { T* oldptr = ptr; ptr = 0;
delete oldptr; ptr = p; }
2591 SwigValueWrapper& operator=(
const SwigValueWrapper<T>& rhs);
2592 SwigValueWrapper(
const SwigValueWrapper<T>& rhs);
2594 SwigValueWrapper() : pointer(0) { }
2595 SwigValueWrapper& operator=(
const T& t) { SwigSmartPointer tmp(
new T(t)); pointer = tmp;
return *
this; }
2596#if __cplusplus >=201103L
2597 SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(
new T(std::move(t))); pointer = tmp;
return *
this; }
2598 operator T&&()
const {
return std::move(*pointer.ptr); }
2600 operator T&()
const {
return *pointer.ptr; }
2602 T *operator&()
const {
return pointer.ptr; }
2603 static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
2615template <
typename T> T SwigValueInit() {
2619#if __cplusplus >=201103L
2620# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
2622# define SWIG_STD_MOVE(OBJ) OBJ
2628#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2629#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2643 #if defined ( __GNUC__ ) && __GNUC__ > 3
2644 #undef OCTAVE_EXPORT
2645 #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2663 inline int max(
int a,
int b )
2665 return a >= b ? a : b;
2667 inline int min(
int a,
int b )
2669 return a >= b ? a : b;
2683 return max( o_obj.rows(), 1 ) *
max( o_obj.columns(), 1 );
2695 if (
max( o_obj.columns(), 1 ) > 1 )
2700 else if (
max( o_obj.rows(), 1 ) > 1 )
2710 _dim(
const octave_value &o_obj,
int dim_idx )
2713 return max( o_obj.rows(), 0 );
2717 else if ( dim_idx == 1 )
2718 return max( o_obj.columns(), 0 );
2731 template <
class FLOAT>
2735 while ( n_el-- > 0 )
2736 *out_arr++ = (FLOAT) ( *in_arr++ );
2755 template <
class FLOAT>
2759 while ( n_el-- > 0 )
2760 *d_arr++ = double(*arr++);
2791 octave_value_list functionArguments;
2792 octave_value_list retval;
2799 for ( i = 0; i < n; i++ )
2805 functionArguments( 0 ) = xin;
2806 functionArguments( 1 ) = yin;
2809#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2810 retval = octave::feval(
fcnMapForm, functionArguments, 1 );
2812 retval = feval(
fcnMapForm, functionArguments, 1 );
2815#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2816 retval = octave::feval(
nameMapForm, functionArguments, 1 );
2818 retval = feval(
nameMapForm, functionArguments, 1 );
2821 if ( retval.length() >= 2 )
2823 xout = retval( 0 ).matrix_value();
2824 yout = retval( 1 ).matrix_value();
2826 for ( i = 0; i < n; i++ )
2828 x[i] = xout( i, 0 );
2829 y[i] = yout( i, 0 );
2841 octave_value_list functionArguments;
2842 octave_value_list retval;
2844 Matrix inAxis( 1, 1 );
2845 Matrix inValue( 1, 1 );
2846 inAxis( 0, 0 ) = axis;
2847 inValue( 0, 0 ) =
value;
2849 functionArguments( 0 ) = inAxis;
2850 functionArguments( 1 ) = inValue;
2853#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2854 retval = octave::feval(
fcnLabelFunc, functionArguments, 1 );
2859#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2860 retval = octave::feval(
nameLabelFunc, functionArguments, 1 );
2865 strncpy( label, retval( 0 ).string_value().c_str(), length );
2875 octave_value_list functionArguments;
2876 octave_value_list retval;
2886 functionArguments( 0 ) = xin;
2887 functionArguments( 1 ) = yin;
2890#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2891 retval = octave::feval(
fcnCoordTrans, functionArguments, 1 );
2896#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2902 if ( retval.length() >= 2 )
2904 xout = retval( 0 ).matrix_value();
2905 yout = retval( 1 ).matrix_value();
2916 printf(
"nlegend =%d\n", nlegend );
2917 for ( i = 0; i < nlegend; i++ )
2919 printf(
"opt_array[%d] =%d\n", i, opt_array[i] );
2920 printf(
"strlen(text[%d]) =%d\n", i, (
int) strlen(
text[i] ) );
2921 printf(
"text[%d] =%s\n", i,
text[i] );
2927#if !defined(SWIG_NO_LLONG_MAX)
2928# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2929# define LLONG_MAX __LONG_LONG_MAX__
2930# define LLONG_MIN (-LLONG_MAX - 1LL)
2931# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2938 if (!ov.is_scalar_type())
2940 if (ov.is_complex_scalar())
2942 if (ov.is_double_type()||ov.is_single_type()) {
2943 double v=ov.double_value();
2948 *val = ov.long_value();
2959 if ((v < INT_MIN || v > INT_MAX)) {
2962 if (val) *val =
static_cast< int >(v);
2969 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 )
2977 *pX = gin.
pX; *pY = gin.
pY; *dX = gin.
dX; *dY = gin.
dY; *wX = gin.
wX; *wY = gin.
wY;
2991 && ov.rows() == 1 && ov.columns() == 1)
2992 ov = ov.cell_value()(0);
2993 if (!ov.is_string())
2996 std::string str=ov.string_value();
2997 size_t len=str.size();
2998 char* cstr=(
char*)str.c_str();
3000 *cptr =
reinterpret_cast< char*
>(memcpy(
new char[len + 1], cstr,
sizeof(
char)*(len + 1)));
3015 return octave_value(
value);
3028 return octave_value(
value);
3037 gin.
dX = x_in; gin.
dY = y_in;
3039 *x = gin.
wX; *y = gin.
wY;
3046 if (!ov.is_scalar_type())
3048 if (ov.is_complex_scalar())
3051 *val = ov.double_value();
3064 const char *legline1,
const char *legline2,
const char *legline3,
const char *legline4,
3065 const char *labx,
const char *laby,
const char *labtop )
3067 const char *legline[4];
3068 legline[0] = legline1; legline[1] = legline2;
3069 legline[2] = legline3; legline[3] = legline4;
3070 c_plstripc(
id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
3071 xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
3072 labx, laby, labtop );
3090 *tx = *( (
PLFLT *) pltr_data + 0 ) * x + *( (
PLFLT *) pltr_data + 1 ) * y + *( (
PLFLT *) pltr_data + 2 );
3091 *ty = *( (
PLFLT *) pltr_data + 3 ) * x + *( (
PLFLT *) pltr_data + 4 ) * y + *( (
PLFLT *) pltr_data + 5 );
3096#define f2c( f, ff, nx, ny ) \
3098 ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
3099 for ( int i = 0; i < nx; i++ ) { \
3100 ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
3101 for ( int j = 0; j < ny; j++ ) \
3102 *( ff[i] + j ) = *( f + nx * j + i );}
3109 f2c( f, ff, nx, ny );
3110 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
xform, tr );
3118 f2c( f, ff, nx, ny );
3119 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr0, NULL );
3128 grid1.
nx = nx; grid1.
ny = ny;
3130 f2c( f, ff, nx, ny );
3131 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr1, &grid1 );
3139 f2c( xg, xgg, nx, ny );
3140 f2c(
yg, ygg, nx, ny );
3141 grid2.
nx = nx; grid2.
ny = ny;
3142 grid2.
xg = xgg; grid2.
yg = ygg;
3143 f2c( f, ff, nx, ny );
3144 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
3153 f2c( xg, xgg, nx, ny );
3154 f2c(
yg, ygg, nx, ny );
3155 grid2.
nx = nx; grid2.
ny = ny;
3156 grid2.
xg = xgg; grid2.
yg = ygg;
3157 f2c( f, ff, nx, ny );
3158 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
3163 const PLFLT *xg,
int nptsx,
const PLFLT *yg,
int nptsy,
3166 f2c(
zg, zgg, nptsx, nptsy );
3167 plgriddata( x, y, z, npts, xg, nptsx,
yg, nptsy, zgg, type, data );
3168 for (
int i = 0; i < nptsx; i++ )
3169 for (
int j = 0; j < nptsy; j++ )
3170 *(
zg + nptsx * j + i ) = zgg[i][j];
3178 f2c( z, zz, nx, ny );
3186 f2c( z, zz, nx, ny );
3187 c_plmeshc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3195 f2c( z, zz, nx, ny );
3204 f2c( z, zz, nx, ny );
3205 c_plot3dc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3214 f2c( z, zz, nx, ny );
3216 indexxmin, indexxmax, indexymin, indexymax );
3223 f2c( z, zz, nx, ny );
3231 f2c( z, zz, nx, ny );
3233 indexxmin, indexxmax, indexymin, indexymax );
3251 f2c( a, aa, nx, ny );
3252 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3253 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3254 min_color, min_width, max_color, max_width,
3268 grid1.
nx = nx; grid1.
ny = ny;
3270 f2c( a, aa, nx, ny );
3271 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3272 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3273 min_color, min_width, max_color, max_width,
3287 f2c( xg, xgg, nx, ny );
3288 f2c(
yg, ygg, nx, ny );
3289 grid2.
nx = nx; grid2.
ny = ny;
3290 grid2.
xg = xgg; grid2.
yg = ygg;
3291 f2c( a, aa, nx, ny );
3292 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3293 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3294 min_color, min_width, max_color, max_width,
3306 f2c( a, aa, nx, ny );
3307 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3308 clevel, nlevel, fill_width, cont_color, cont_width,
3309 plfill, rectangular, NULL, NULL );
3318 f2c( a, aa, nx, ny );
3319 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3320 clevel, nlevel, fill_width, cont_color, cont_width,
3331 grid1.
nx = nx; grid1.
ny = ny;
3334 f2c( a, aa, nx, ny );
3335 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3336 clevel, nlevel, fill_width, cont_color, cont_width,
3347 f2c( xg, xgg, nx, ny );
3348 f2c(
yg, ygg, nx, ny );
3349 grid2.
nx = nx; grid2.
ny = ny;
3350 grid2.
xg = xgg; grid2.
yg = ygg;
3351 f2c( a, aa, nx, ny );
3352 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3353 clevel, nlevel, fill_width, cont_color, cont_width,
3363 f2c( u, uu, nx, ny );
3364 f2c( v, vv, nx, ny );
3372 grid1.
nx = nx; grid1.
ny = ny;
3374 f2c( u, uu, nx, ny );
3375 f2c( v, vv, nx, ny );
3383 f2c( xg, xgg, nx, ny );
3384 f2c(
yg, ygg, nx, ny );
3385 grid2.
nx = nx; grid2.
ny = ny;
3386 grid2.
xg = xgg; grid2.
yg = ygg;
3387 f2c( u, uu, nx, ny );
3388 f2c( v, vv, nx, ny );
3399 f2c( a, aa, nx, ny );
3400 plimage( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
3410 f2c( a, aa, nx, ny );
3411 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
3419 f2c( a, aa, nx, ny );
3420 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
xform, tr );
3430 grid1.
nx = nx + 1; grid1.
ny = ny + 1;
3432 f2c( a, aa, nx, ny );
3433 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr1, &grid1 );
3443 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
3444 f2c(
yg, ygg, ( nx + 1 ), ( ny + 1 ) );
3445 grid2.
nx = nx + 1; grid2.
ny = ny + 1;
3446 grid2.
xg = xgg; grid2.
yg = ygg;
3447 f2c( a, aa, nx, ny );
3448 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr2, &grid2 );
3459 PLINT n_labels,
const PLINT *label_opts,
const char **label,
3460 PLINT n_axes,
const char ** axis_opts,
3467 for ( i = 0; i < nx; i++ )
3468 if ( n_values[i] > ny )
3470 f2c( a, aa, nx, ny );
3472 opt, position, x, y,
3474 bg_color, bb_color, bb_style,
3475 low_cap_color, high_cap_color,
3476 cont_color, cont_width,
3477 n_labels, label_opts, label,
3487 if (!ov.is_scalar_type())
3489 if (ov.is_complex_scalar())
3491 if (ov.is_double_type()||ov.is_single_type()) {
3492 double v=ov.double_value();
3498 if (ov.is_int8_type()||ov.is_int16_type()||
3499 ov.is_int32_type()) {
3500 long v=ov.long_value();
3504 if (ov.is_int64_type()) {
3505 long long v=ov.int64_scalar_value().value();
3510 *val = ov.ulong_value();
3521 if ((v > UINT_MAX)) {
3524 if (val) *val =
static_cast< unsigned int >(v);
3533 return octave_value(
value);
3547 char* cptr = 0;
size_t csize = 0;
int alloc =
SWIG_OLDOBJ;
3551 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3552 if (csize <= size) {
3554 if (csize) memcpy(val, cptr, csize*
sizeof(
char));
3555 if (csize < size) memset(val + csize, 0, (size - csize)*
sizeof(
char));
3572 static int init = 0;
3585 return std::string(carray,carray+size);
3593 for (p = s; maxlen-- && *p; p++)
3607 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3608 if (val) *val =
static_cast< char >(v);
3618Set up transformation from metafile coordinates\n\
3622 Set up transformation from metafile coordinates. The size of the plot\n\
3623 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
3624 general-purpose facility just yet (not sure why the user would need\n\
3627 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
3630 This function is not used in any examples.\n\
3636plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
3640 dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
3642 dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
3644 dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
3646 dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
3648 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3650 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3653Set the cmap0 palette using the specified cmap0*.pal format file\n\
3657 Set the cmap0 palette using the specified cmap0*.pal format file.\n\
3659 Redacted form: plspal0(filename)\n\
3661 This function is in example 16.\n\
3671 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3672 containing the name of the cmap0*.pal file. If this string is\n\
3673 empty, use the default cmap0*.pal file.\n\
3676Set the cmap1 palette using the specified cmap1*.pal format file\n\
3680 Set the cmap1 palette using the specified cmap1*.pal format file.\n\
3682 Redacted form: plspal1(filename, interpolate)\n\
3684 This function is used in example 16.\n\
3690plspal1(filename, interpolate)\n\
3694 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3695 containing the name of the cmap1*.pal file. If this string is\n\
3696 empty, use the default cmap1*.pal file.\n\
3698 interpolate (PLBOOL, input) : If this parameter is true, the\n\
3699 columns containing the intensity index, r, g, b, alpha and\n\
3700 alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
3701 palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
3702 a flag which controls whether the r, g, b data sent to plscmap1la\n\
3703 are interpreted as HLS or RGB.) If this parameter is false, the\n\
3704 intensity index and alt_hue_path columns are ignored and the r, g,\n\
3705 b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
3706 are used instead to set the cmap1 palette directly with a call to\n\
3710Draw a line in 3 space\n\
3714 Draws line in 3 space defined by n points in x, y, and z. You must\n\
3715 first set up the viewport, the 2d viewing window (in world\n\
3716 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
3719 Redacted form: plline3(x, y, z)\n\
3721 This function is used in example 18.\n\
3727plline3(n, x, y, z)\n\
3731 n (PLINT, input) : Number of points defining line.\n\
3733 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
3736 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
3739 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
3743Magnitude colored plot surface mesh with contour\n\
3747 A more powerful form of plmesh: the surface mesh can be colored\n\
3748 accordingly to the current z value being plotted, a contour plot can\n\
3749 be drawn at the base XY plane, and a curtain can be drawn between the\n\
3750 plotted function border and the base XY plane.\n\
3752 Redacted form: plmeshc(x, y, z, opt, clevel)\n\
3754 This function is used in example 11.\n\
3760plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
3764 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3765 which the function is evaluated.\n\
3767 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3768 which the function is evaluated.\n\
3770 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3771 plot. Should have dimensions of\n\
3775 nx (PLINT, input) : Number of x values at which function is\n\
3778 ny (PLINT, input) : Number of y values at which function is\n\
3781 opt (PLINT, input) : Determines the way in which the surface is\n\
3782 represented. To specify more than one option just add the options,\n\
3783 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3784 showing z as a function of x for each value of y[j] .\n\
3785 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3786 for each value of x[i] .\n\
3787 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3788 at which function is defined.\n\
3789 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3790 the z value being plotted. The color is used from the current\n\
3792 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3796 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3797 the borders of the plotted function.\n\
3800 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3803 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3806Draw a line between two points, accounting for coordinate transforms\n\
3810 Joins the point (\n\
3814 y2) . If a global coordinate transform is defined then the line is\n\
3815 broken in to n segments to approximate the path. If no transform is\n\
3816 defined then this simply acts like a call to pljoin.\n\
3818 Redacted form: plpath(n,x1,y1,x2,y2)\n\
3820 This function is used in example 22.\n\
3826plpath(n, x1, y1, x2, y2)\n\
3830 n (PLINT, input) : number of points to use to approximate the path.\n\
3832 x1 (PLFLT, input) : x coordinate of first point.\n\
3834 y1 (PLFLT, input) : y coordinate of first point.\n\
3836 x2 (PLFLT, input) : x coordinate of second point.\n\
3838 y2 (PLFLT, input) : y coordinate of second point.\n\
3841Write text inside the viewport\n\
3845 Writes text at a specified position and inclination within the\n\
3846 viewport. Text is clipped at the viewport boundaries. The reference\n\
3847 point of a string lies along a line passing through the string at half\n\
3848 the height of a capital letter. The position of the reference point\n\
3849 along this line is determined by just, the reference point is placed\n\
3850 at world coordinates (\n\
3852 y) within the viewport. The inclination of the string is specified\n\
3853 in terms of differences of world coordinates making it easy to write\n\
3854 text parallel to a line in a graph.\n\
3856 Redacted form: plptex(x, y, dx, dy, just, text)\n\
3858 This function is used in example 2-4,10,12-14,20,23,24,26.\n\
3864plptex(x, y, dx, dy, just, text)\n\
3868 x (PLFLT, input) : x coordinate of reference point of string.\n\
3870 y (PLFLT, input) : y coordinate of reference point of string.\n\
3872 dx (PLFLT, input) : Together with dy, this specifies the\n\
3873 inclination of the string. The baseline of the string is parallel\n\
3874 to a line joining (\n\
3882 dy (PLFLT, input) : Together with dx, this specifies the\n\
3883 inclination of the string.\n\
3885 just (PLFLT, input) : Specifies the position of the string relative\n\
3886 to its reference point. If just=0. , the reference point is at\n\
3887 the left and if just=1. , it is at the right of the string. Other\n\
3888 values of just give intermediate justifications.\n\
3890 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3894Set family file parameters\n\
3898 Sets variables dealing with output file familying. Does nothing if\n\
3899 familying not supported by the driver. This routine, if used, must be\n\
3900 called before initializing PLplot. See the PLplot documentation for\n\
3901 more information.\n\
3903 Redacted form: plsfam(fam, num, bmax)\n\
3905 This function is used in examples 14 and 31.\n\
3911plsfam(fam, num, bmax)\n\
3915 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
3918 num (PLINT, input) : Current family file number.\n\
3920 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
3924Set y axis parameters\n\
3928 Identical to plsxax, except that arguments are flags for y axis. See\n\
3929 the description of plsxax for more detail.\n\
3931 Redacted form: plsyax(digmax, digits)\n\
3933 This function is used in examples 1, 14, and 31.\n\
3939plsyax(digmax, digits)\n\
3943 digmax (PLINT, input) : Variable to set the maximum number of\n\
3944 digits for the y axis. If nonzero, the printed label will be\n\
3945 switched to a floating-point representation when the number of\n\
3946 digits exceeds digmax.\n\
3948 digits (PLINT, input) : Field digits value. Currently, changing\n\
3949 its value here has no effect since it is set only by plbox or\n\
3950 plbox3. However, the user may obtain its value after a call to\n\
3951 either of these functions by calling plgyax.\n\
3954Get z axis parameters\n\
3958 Identical to plgxax, except that arguments are flags for z axis. See\n\
3959 the description of plgxax for more detail.\n\
3961 Redacted form: plgzax(p_digmax, p_digits)\n\
3963 This function is used in example 31.\n\
3969plgzax(p_digmax, p_digits)\n\
3973 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
3974 number of digits for the z axis. If nonzero, the printed label\n\
3975 has been switched to a floating-point representation when the\n\
3976 number of digits exceeds this value.\n\
3978 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
3979 number of digits for the numeric labels (z axis) from the last\n\
3983Set format of numerical label for contours\n\
3987 Set format of numerical label for contours.\n\
3989 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
3991 This function is used example 9.\n\
3997pl_setcontlabelformat(lexp, sigdig)\n\
4001 lexp (PLINT, input) : If the contour numerical label is greater\n\
4002 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
4003 format is used. Default value of lexp is 4.\n\
4005 sigdig (PLINT, input) : Number of significant digits. Default\n\
4013 Sets the pen width.\n\
4015 Redacted form: plwidth(width)\n\
4017 This function is used in examples 1 and 2.\n\
4027 width (PLFLT, input) : The desired pen width. If width is negative\n\
4028 or the same as the previous value no action is taken. width = 0.\n\
4029 should be interpreted as as the minimum valid pen width for the\n\
4030 device. The interpretation of positive width values is also\n\
4031 device dependent.\n\
4034Get parameters that define current plot-space window\n\
4038 Get relative minima and maxima that define current plot-space window.\n\
4039 If plsdiplt has not been called the default values pointed to by\n\
4040 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
4042 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4044 This function is used in example 31.\n\
4050plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4054 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4057 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4060 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4063 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4067Set the cmap1 argument range for continuous color plots\n\
4071 Set the cmap1 argument range for continuous color plots that\n\
4072 corresponds to the range of data values. The maximum range\n\
4073 corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
4074 the cmap1 argument range that is specified with this routine, the\n\
4075 smaller the subset of the cmap1 color palette that is used to\n\
4076 represent the continuous data being plotted. If\n\
4077 min_color is greater than\n\
4079 max_color is greater than 1.0 or\n\
4080 min_color is less than 0.0 then no change is made to the cmap1\n\
4081 argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
4083 Redacted form: plscmap1_range(min_color, max_color)\n\
4085 This function is currently used in example 33.\n\
4091plscmap1_range(min_color, max_color)\n\
4095 min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
4096 than 0.0, then 0.0 is used instead.\n\
4098 max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
4099 than 1.0, then 1.0 is used instead.\n\
4102Select standard viewport\n\
4106 Selects the largest viewport within the subpage that leaves a standard\n\
4107 margin (left-hand margin of eight character heights, and a margin\n\
4108 around the other three sides of five character heights).\n\
4110 Redacted form: plvsta()\n\
4112 This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
4121Load Hershey fonts\n\
4125 Loads the Hershey fonts used for text and symbols. This routine may\n\
4126 be called before or after initializing PLplot. If not explicitly\n\
4127 called before PLplot initialization, then by default that\n\
4128 initialization loads Hershey fonts with the extended character set.\n\
4129 This routine only has a practical effect for devices that still use\n\
4130 Hershey fonts (as opposed to modern devices that use unicode-aware\n\
4131 system fonts instead of Hershey fonts).\n\
4133 Redacted form: plfontld(fnt)\n\
4135 This function is used in examples 1 and 7.\n\
4145 fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
4146 A zero value specifies Hershey fonts with the standard character\n\
4147 set and a non-zero value (the default assumed if plfontld is never\n\
4148 called) specifies Hershey fonts with the extended character set.\n\
4151Draw error bars in x direction\n\
4155 Draws a set of n error bars in x direction, the i\'th error bar\n\
4156 extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
4157 of the error bars are of length equal to the minor tick length\n\
4158 (settable using plsmin).\n\
4160 Redacted form: General: plerrx(xmin, ymax, y)\n\
4163 This function is used in example 29.\n\
4169plerrx(n, xmin, xmax, y)\n\
4173 n (PLINT, input) : Number of error bars to draw.\n\
4175 xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4176 of the left-hand endpoints of the error bars.\n\
4178 xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4179 of the right-hand endpoints of the error bars.\n\
4181 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4185Plot shaded 3-d surface plot\n\
4189 Plots a three-dimensional shaded surface plot within the environment\n\
4190 set up by plw3d. The surface is defined by the two-dimensional matrix\n\
4193 ny], the point z[i][j] being the value of the function at (\n\
4195 y[j]). Note that the points in vectors x and y do not need to be\n\
4196 equally spaced, but must be stored in ascending order. For further\n\
4197 details see the PLplot documentation.\n\
4199 Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
4201 This function is not used in any examples.\n\
4207plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
4211 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4212 which the function is evaluated.\n\
4214 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4215 which the function is evaluated.\n\
4217 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4218 plot. Should have dimensions of\n\
4222 nx (PLINT, input) : Number of x values at which function is\n\
4225 ny (PLINT, input) : Number of y values at which function is\n\
4228 opt (PLINT, input) : Determines the way in which the surface is\n\
4229 represented. To specify more than one option just add the options,\n\
4230 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
4231 connecting points at which function is defined.\n\
4232 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
4236 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
4240 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
4241 the borders of the plotted function.\n\
4242 opt=MAG_COLOR : the surface is colored according to the value\n\
4243 of Z; if MAG_COLOR is not used, then the surface is colored\n\
4244 according to the intensity of the reflected light in the\n\
4245 surface from a light source whose position is set using\n\
4249 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
4252 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
4255Get the current library version number\n\
4259 Get the current library version number. Note: you must have allocated\n\
4260 space for this (80 characters is safe).\n\
4262 Redacted form: plgver(p_ver)\n\
4264 This function is used in example 1.\n\
4274 p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4275 (with preallocated length of 80 characters or more) containing the\n\
4276 PLplot version number.\n\
4279End plotting session for current stream\n\
4283 Ends a plotting session for the current output stream only. See\n\
4284 plsstrm for more info.\n\
4286 Redacted form: plend1()\n\
4288 This function is used in examples 1 and 20.\n\
4297Draw error bars in the y direction\n\
4301 Draws a set of n error bars in the y direction, the i\'th error bar\n\
4302 extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
4303 of the error bars are of length equal to the minor tick length\n\
4304 (settable using plsmin).\n\
4306 Redacted form: General: plerry(x, ymin, ymax)\n\
4309 This function is used in example 29.\n\
4315plerry(n, x, ymin, ymax)\n\
4319 n (PLINT, input) : Number of error bars to draw.\n\
4321 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4324 ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4325 of the lower endpoints of the error bars.\n\
4327 ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4328 of the upper endpoints of the error bars.\n\
4331Set seed for internal random number generator.\n\
4335 Set the seed for the internal random number generator. See plrandd for\n\
4338 Redacted form: plseed(seed)\n\
4340 This function is used in example 21.\n\
4350 seed (unsigned int, input) : Seed for random number generator.\n\
4353Specify viewport using normalized subpage coordinates\n\
4357 Device-independent routine for setting up the viewport. This defines\n\
4358 the viewport in terms of normalized subpage coordinates which run from\n\
4359 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
4360 current subpage. Use the alternate routine plsvpa in order to create\n\
4361 a viewport of a definite size.\n\
4363 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
4365 This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
4366 24, 26, 27, and 31.\n\
4372plvpor(xmin, xmax, ymin, ymax)\n\
4376 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
4377 left-hand edge of the viewport.\n\
4379 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
4380 right-hand edge of the viewport.\n\
4382 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
4383 bottom edge of the viewport.\n\
4385 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
4386 edge of the viewport.\n\
4393 Plots a surface mesh within the environment set up by plw3d. The\n\
4394 surface is defined by the matrix z[\n\
4396 ny] , the point z[i][j] being the value of the function at (\n\
4398 y[j]). Note that the points in vectors x and y do not need to be\n\
4399 equally spaced, but must be stored in ascending order. The parameter\n\
4400 opt controls the way in which the surface is displayed. For further\n\
4401 details see the PLplot documentation.\n\
4403 Redacted form: plmesh(x, y, z, opt)\n\
4405 This function is used in example 11.\n\
4411plmesh(x, y, z, nx, ny, opt)\n\
4415 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4416 which the function is evaluated.\n\
4418 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4419 which the function is evaluated.\n\
4421 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4422 plot. Should have dimensions of\n\
4426 nx (PLINT, input) : Number of x values at which function has been\n\
4429 ny (PLINT, input) : Number of y values at which function has been\n\
4432 opt (PLINT, input) : Determines the way in which the surface is\n\
4433 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
4434 function of x for each value of y[j] .\n\
4435 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
4436 for each value of x[i] .\n\
4437 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
4438 at which function is defined.\n\
4441Get the cmap1 argument range for continuous color plots\n\
4445 Get the cmap1 argument range for continuous color plots. (Use\n\
4446 plscmap1_range to set the cmap1 argument range.)\n\
4448 Redacted form: plgcmap1_range(min_color, max_color)\n\
4450 This function is currently not used in any example.\n\
4456plgcmap1_range(min_color, max_color)\n\
4460 min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4461 minimum cmap1 argument.\n\
4463 max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4464 maximum cmap1 argument.\n\
4467Set arrow style for vector plots\n\
4471 Set the style for the arrow used by plvect to plot vectors.\n\
4473 Redacted form: plsvect(arrowx, arrowy, fill)\n\
4475 This function is used in example 22.\n\
4481plsvect(arrowx, arrowy, npts, fill)\n\
4485 arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
4486 the x and y points which make up the arrow. The arrow is plotted\n\
4487 by joining these points to form a polygon. The scaling assumes\n\
4488 that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
4489 <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
4490 will be reset to its default.\n\
4492 npts (PLINT, input) : Number of points in the vectors arrowx and\n\
4495 fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
4496 fill is false then the arrow is open.\n\
4499Draw filled polygon\n\
4503 Fills the polygon defined by the n points (\n\
4505 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4506 style is a solid fill. The routine will automatically close the\n\
4507 polygon between the last and first vertices. If multiple closed\n\
4508 polygons are passed in x and y then plfill will fill in between them.\n\
4510 Redacted form: plfill(x,y)\n\
4512 This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
4522 n (PLINT, input) : Number of vertices in polygon.\n\
4524 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4527 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4531Convert HLS color to RGB\n\
4535 Convert HLS color coordinates to RGB.\n\
4537 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4540 This function is used in example 2.\n\
4546plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4550 h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
4553 l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
4554 the axis of the color cylinder.\n\
4556 s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
4557 the radius of the color cylinder.\n\
4559 p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
4560 (0.0-1.0) of the color.\n\
4562 p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
4563 intensity (0.0-1.0) of the color.\n\
4565 p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
4566 intensity (0.0-1.0) of the color.\n\
4569Set format for date / time labels\n\
4573 Sets the format for date / time labels. To enable date / time format\n\
4574 labels see the options to plbox, plbox3, and plenv.\n\
4576 Redacted form: pltimefmt(fmt)\n\
4578 This function is used in example 29.\n\
4588 fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
4589 interpreted similarly to the format specifier of typical system\n\
4590 strftime routines except that PLplot ignores locale and also\n\
4591 supplies some useful extensions in the context of plotting. All\n\
4592 text in the string is printed as-is other than conversion\n\
4593 specifications which take the form of a \'%\' character followed by\n\
4594 further conversion specification character. The conversion\n\
4595 specifications which are similar to those provided by system\n\
4596 strftime routines are the following: %a: The abbreviated (English)\n\
4598 %A: The full (English) weekday name.\n\
4599 %b: The abbreviated (English) month name.\n\
4600 %B: The full (English) month name.\n\
4601 %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
4602 %C: The century number (year/100) as a 2-digit integer.\n\
4603 %d: The day of the month as a decimal number (range 01 to 31).\n\
4604 %D: Equivalent to %m/%d/%y (non-ISO).\n\
4605 %e: Like %d, but a leading zero is replaced by a space.\n\
4606 %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
4607 %h: Equivalent to %b.\n\
4608 %H: The hour as a decimal number using a 24-hour clock (range\n\
4610 %I: The hour as a decimal number using a 12-hour clock (range\n\
4612 %j: The day of the year as a decimal number (range 001 to\n\
4614 %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
4615 23); single digits are preceded by a blank. (See also %H.)\n\
4616 %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
4617 12); single digits are preceded by a blank. (See also %I.)\n\
4618 %m: The month as a decimal number (range 01 to 12).\n\
4619 %M: The minute as a decimal number (range 00 to 59).\n\
4620 %n: A newline character.\n\
4621 %p: Either \"AM\" or \"PM\" according to the given time value.\n\
4622 Noon is treated as \"PM\" and midnight as \"AM\".\n\
4623 %r: Equivalent to %I:%M:%S %p.\n\
4624 %R: The time in 24-hour notation (%H:%M). For a version\n\
4625 including the seconds, see %T below.\n\
4626 %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
4628 %S: The second as a decimal number (range 00 to 60). (The\n\
4629 range is up to 60 to allow for occasional leap seconds.)\n\
4630 %t: A tab character.\n\
4631 %T: The time in 24-hour notation (%H:%M:%S).\n\
4632 %u: The day of the week as a decimal, range 1 to 7, Monday\n\
4633 being 1. See also %w.\n\
4634 %U: The week number of the current year as a decimal number,\n\
4635 range 00 to 53, starting with the first Sunday as the first\n\
4636 day of week 01. See also %V and %W.\n\
4637 %v: Equivalent to %e-%b-%Y.\n\
4638 %V: The ISO 8601 week number of the current year as a decimal\n\
4639 number, range 01 to 53, where week 1 is the first week that\n\
4640 has at least 4 days in the new year. See also %U and %W.\n\
4641 %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
4642 being 0. See also %u.\n\
4643 %W: The week number of the current year as a decimal number,\n\
4644 range 00 to 53, starting with the first Monday as the first\n\
4646 %x: Equivalent to %a %b %d %Y.\n\
4647 %X: Equivalent to %T.\n\
4648 %y: The year as a decimal number without a century (range 00\n\
4650 %Y: The year as a decimal number including a century.\n\
4651 %z: The UTC time-zone string = \"+0000\".\n\
4652 %Z: The UTC time-zone abbreviation = \"UTC\".\n\
4653 %+: The UTC date and time in default format of the Unix date\n\
4654 command which is equivalent to %a %b %d %T %Z %Y.\n\
4655 %%: A literal \"%\" character.\n\
4656 The conversion specifications which are extensions to those normally\n\
4657 provided by system strftime routines are the following: %(0-9):\n\
4658 The fractional part of the seconds field (including leading\n\
4659 decimal point) to the specified accuracy. Thus %S%3 would give\n\
4660 seconds to millisecond accuracy (00.000).\n\
4661 %.: The fractional part of the seconds field (including\n\
4662 leading decimal point) to the maximum available accuracy. Thus\n\
4663 %S%. would give seconds with fractional part up to 9 decimal\n\
4664 places if available.\n\
4667Get current subpage parameters\n\
4671 Gets the size of the current subpage in millimeters measured from the\n\
4672 bottom left hand corner of the output device page or screen. Can be\n\
4673 used in conjunction with plsvpa for setting the size of a viewport in\n\
4674 absolute coordinates (millimeters).\n\
4676 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
4678 This function is used in example 23.\n\
4684plgspa(xmin, xmax, ymin, ymax)\n\
4688 xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4689 the left hand edge of the subpage in millimeters.\n\
4691 xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4692 the right hand edge of the subpage in millimeters.\n\
4694 ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4695 the bottom edge of the subpage in millimeters.\n\
4697 ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4698 the top edge of the subpage in millimeters.\n\
4701Calculate world coordinates and corresponding window index from relative device coordinates\n\
4705 Calculate world coordinates, wx and wy, and corresponding window index\n\
4706 from relative device coordinates, rx and ry.\n\
4708 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
4711 This function is used in example 31.\n\
4717plcalc_world(rx, ry, wx, wy, window)\n\
4721 rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4722 the x coordinate.\n\
4724 ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4725 the y coordinate.\n\
4727 wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
4728 coordinate corresponding to the relative device coordinates rx and\n\
4731 wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
4732 coordinate corresponding to the relative device coordinates rx and\n\
4735 window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
4736 defined window index that corresponds to the input relative device\n\
4737 coordinates (and the returned world coordinates). To give some\n\
4738 background on the window index, for each page the initial window\n\
4739 index is set to zero, and each time plwind is called within the\n\
4740 page, world and device coordinates are stored for the window and\n\
4741 the window index is incremented. Thus, for a simple page layout\n\
4742 with non-overlapping viewports and one window per viewport, window\n\
4743 corresponds to the viewport index (in the order which the\n\
4744 viewport/windows were created) of the only viewport/window\n\
4745 corresponding to rx and ry. However, for more complicated layouts\n\
4746 with potentially overlapping viewports and possibly more than one\n\
4747 window (set of world coordinates) per viewport, window and the\n\
4748 corresponding output world coordinates corresponds to the last\n\
4749 window created that fulfills the criterion that the relative\n\
4750 device coordinates are inside it. Finally, in all cases where the\n\
4751 input relative device coordinates are not inside any\n\
4752 viewport/window, then the returned value of the last defined\n\
4753 window index is set to -1.\n\
4756Get output file name\n\
4760 Gets the current output file name, if applicable.\n\
4762 Redacted form: plgfnam(fnam)\n\
4764 This function is used in example 31.\n\
4774 fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4775 (with preallocated length of 80 characters or more) containing the\n\
4783 Draws a plot of vector data contained in the matrices (\n\
4789 ny]) . The scaling factor for the vectors is given by scale. A\n\
4790 transformation routine pointed to by pltr with a pointer pltr_data for\n\
4791 additional data required by the transformation routine to map indices\n\
4792 within the matrices to the world coordinates. The style of the vector\n\
4793 arrow may be set using plsvect.\n\
4795 Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
4796 discussion) the pltr, pltr_data callback arguments are sometimes\n\
4797 replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
4798 with either one or two dimensions.\n\
4800 This function is used in example 22.\n\
4806plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
4810 u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
4811 and y components of the vector data to be plotted.\n\
4813 nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
4815 scale (PLFLT, input) : Parameter to control the scaling factor of\n\
4816 the vectors for plotting. If scale = 0 then the scaling factor is\n\
4817 automatically calculated for the data. If scale < 0 then the\n\
4818 scaling factor is automatically calculated for the data and then\n\
4820 scale. If scale > 0 then the scaling factor is set to scale.\n\
4822 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
4823 defines the transformation between the zero-based indices of the\n\
4824 matrices u and v and world coordinates.For the C case,\n\
4825 transformation functions are provided in the PLplot library: pltr0\n\
4826 for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
4827 mappings respectively defined by vectors and matrices. In\n\
4828 addition, C callback routines for the transformation can be\n\
4829 supplied by the user such as the mypltr function in\n\
4830 examples/c/x09c.c which provides a general linear transformation\n\
4831 between index coordinates and world coordinates.For languages\n\
4832 other than C you should consult the PLplot documentation for the\n\
4833 details concerning how PLTRANSFORM_callback arguments are\n\
4834 interfaced. However, in general, a particular pattern of\n\
4835 callback-associated arguments such as a tr vector with 6 elements;\n\
4836 xg and yg vectors; or xg and yg matrices are respectively\n\
4837 interfaced to a linear-transformation routine similar to the above\n\
4838 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
4839 sophisticated bindings (see, e.g., the PLplot documentation)\n\
4840 support native language callbacks for handling index to\n\
4841 world-coordinate transformations. Examples of these various\n\
4842 approaches are given in examples/<language>x09*,\n\
4843 examples/<language>x16*, examples/<language>x20*,\n\
4844 examples/<language>x21*, and examples/<language>x22*, for all our\n\
4845 supported languages.\n\
4847 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
4848 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
4849 that is externally supplied.\n\
4852Plot a glyph at the specified points\n\
4856 Plot a glyph at the specified points. (This function is largely\n\
4857 superseded by plstring which gives access to many[!] more glyphs.)\n\
4859 Redacted form: plsym(x, y, code)\n\
4861 This function is used in example 7.\n\
4867plsym(n, x, y, code)\n\
4871 n (PLINT, input) : Number of points in the x and y vectors.\n\
4873 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4876 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4879 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
4880 to be plotted at each of the n points.\n\
4883Get viewport limits in normalized device coordinates\n\
4887 Get viewport limits in normalized device coordinates.\n\
4889 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4892 This function is used in example 31.\n\
4898plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4902 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4903 viewport limit of the normalized device coordinate in x.\n\
4905 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4906 viewport limit of the normalized device coordinate in x.\n\
4908 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4909 viewport limit of the normalized device coordinate in y.\n\
4911 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4912 viewport limit of the normalized device coordinate in y.\n\
4915Get page parameters\n\
4919 Gets the current page configuration. The length and offset values are\n\
4920 expressed in units that are specific to the current driver. For\n\
4921 instance: screen drivers will usually interpret them as number of\n\
4922 pixels, whereas printer drivers will usually use mm.\n\
4924 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
4926 This function is used in examples 14 and 31.\n\
4932plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
4936 p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
4937 pixels/inch (DPI) in x.\n\
4939 p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
4940 pixels/inch (DPI) in y.\n\
4942 p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
4945 p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
4948 p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
4951 p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
4955Plot a glyph at the specified 3D points\n\
4959 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
4960 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
4961 this function similar to what is done for plline3. The glyph is\n\
4962 specified with a PLplot user string. Note that the user string is not\n\
4963 actually limited to one glyph so it is possible (but not normally\n\
4964 useful) to plot more than one glyph at the specified points with this\n\
4965 function. As with plmtex and plptex, the user string can contain FCI\n\
4966 escapes to determine the font, UTF-8 code to determine the glyph or\n\
4967 else PLplot escapes for Hershey or unicode text to determine the\n\
4970 Redacted form: plstring3(x, y, z, string)\n\
4972 This function is used in example 18.\n\
4978plstring3(n, x, y, z, string)\n\
4982 n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
4984 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4987 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4990 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
4993 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
4994 the glyph(s) to be plotted at each of the n points. points.\n\
4997Shade regions on the basis of value\n\
5001 Shade regions on the basis of value. This is the high-level routine\n\
5002 for making continuous color shaded plots with cmap1 while plshade\n\
5003 should be used to plot individual shaded regions using either cmap0 or\n\
5004 cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
5005 our supported languages.\n\
5007 Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
5008 clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
5012 This function is used in examples 16, 21, and 22.\n\
5018plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
5022 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5023 plot. Should have dimensions of\n\
5027 nx (PLINT, input) : First dimension of matrix \"a\".\n\
5029 ny (PLINT, input) : Second dimension of matrix \"a\".\n\
5031 defined (PLDEFINED_callback, input) : Callback function specifying\n\
5032 the region that should be plotted in the shade plot. This\n\
5033 function accepts x and y coordinates as input arguments and must\n\
5034 return 1 if the point is to be included in the shade plot and 0\n\
5035 otherwise. If you want to plot the entire shade plot (the usual\n\
5036 case), this argument should be set to NULL.\n\
5038 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
5039 pltr below for how these arguments are used (only for the special case\n\
5040 when the callback function\n\
5041 pltr is not supplied).\n\
5043 clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
5044 corresponding to the edges of each shaded region that will be\n\
5045 plotted by this function. To work properly the levels should be\n\
5048 nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
5049 of shade edge values in clevel).\n\
5051 fill_width (PLFLT, input) : Defines the line width used by the fill\n\
5054 cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
5055 contours defining edges of shaded regions. The pen color is only\n\
5056 temporary set for the contour drawing. Set this value to zero or\n\
5057 less if no shade edge contours are wanted.\n\
5059 cont_width (PLFLT, input) : Defines line width used for contours\n\
5060 defining edges of shaded regions. This value may not be honored\n\
5061 by all drivers. The pen width is only temporary set for the\n\
5062 contour drawing. Set this value to zero or less if no shade edge\n\
5063 contours are wanted.\n\
5065 fill (PLFILL_callback, input) : Callback routine used to fill the\n\
5066 region. Use plfill for this purpose.\n\
5068 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
5069 map to rectangles after coordinate transformation with pltrl.\n\
5070 Otherwise, set rectangular to false. If rectangular is set to\n\
5071 true, plshade tries to save time by filling large rectangles.\n\
5072 This optimization fails if the coordinate transformation distorts\n\
5073 the shape of rectangles. For example a plot in polar coordinates\n\
5074 has to have rectangular set to false.\n\
5076 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5077 defines the transformation between the zero-based indices of the\n\
5078 matrix a and world coordinates. If\n\
5079 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
5080 indices of a are mapped to the range\n\
5082 xmax and the y indices of a are mapped to the range\n\
5084 ymax.For the C case, transformation functions are provided in the\n\
5085 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
5086 pltr2 for arbitrary mappings respectively defined by vectors and\n\
5087 matrices. In addition, C callback routines for the transformation\n\
5088 can be supplied by the user such as the mypltr function in\n\
5089 examples/c/x09c.c which provides a general linear transformation\n\
5090 between index coordinates and world coordinates.For languages\n\
5091 other than C you should consult the PLplot documentation for the\n\
5092 details concerning how PLTRANSFORM_callback arguments are\n\
5093 interfaced. However, in general, a particular pattern of\n\
5094 callback-associated arguments such as a tr vector with 6 elements;\n\
5095 xg and yg vectors; or xg and yg matrices are respectively\n\
5096 interfaced to a linear-transformation routine similar to the above\n\
5097 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
5098 sophisticated bindings (see, e.g., the PLplot documentation)\n\
5099 support native language callbacks for handling index to\n\
5100 world-coordinate transformations. Examples of these various\n\
5101 approaches are given in examples/<language>x09*,\n\
5102 examples/<language>x16*, examples/<language>x20*,\n\
5103 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5104 supported languages.\n\
5106 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5107 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
5108 externally supplied.\n\
5111Set output file name\n\
5115 Sets the current output file name, if applicable. If the file name\n\
5116 has not been specified and is required by the driver, the user will be\n\
5117 prompted for it. If using the X-windows output driver, this sets the\n\
5118 display name. This routine, if used, must be called before\n\
5119 initializing PLplot.\n\
5121 Redacted form: plsfnam(fnam)\n\
5123 This function is used in examples 1 and 20.\n\
5133 fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
5141 Draws a contour plot of the data in f[\n\
5143 ny], using the nlevel contour levels specified by clevel. Only the\n\
5144 region of the matrix from kx to lx and from ky to ly is plotted out\n\
5145 where all these index ranges are interpreted as one-based for\n\
5146 historical reasons. A transformation routine pointed to by pltr with\n\
5147 a generic pointer pltr_data for additional data required by the\n\
5148 transformation routine is used to map indices within the matrix to the\n\
5149 world coordinates.\n\
5151 Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5152 where (see above discussion) the pltr, pltr_data callback arguments\n\
5153 are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5154 vectors; or xg and yg matrices.\n\
5156 This function is used in examples 9, 14, 16, and 22.\n\
5162plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5166 f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5168 nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5170 kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5171 kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5172 zero-based for historical backwards-compatibility reasons.\n\
5174 ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5175 ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5176 zero-based for historical backwards-compatibility reasons.\n\
5178 clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5179 which to draw contours.\n\
5181 nlevel (PLINT, input) : Number of contour levels to draw.\n\
5183 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5184 defines the transformation between the zero-based indices of the\n\
5185 matrix f and the world coordinates.For the C case, transformation\n\
5186 functions are provided in the PLplot library: pltr0 for the\n\
5187 identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5188 respectively defined by vectors and matrices. In addition, C\n\
5189 callback routines for the transformation can be supplied by the\n\
5190 user such as the mypltr function in examples/c/x09c.c which\n\
5191 provides a general linear transformation between index coordinates\n\
5192 and world coordinates.For languages other than C you should\n\
5193 consult the PLplot documentation for the details concerning how\n\
5194 PLTRANSFORM_callback arguments are interfaced. However, in\n\
5195 general, a particular pattern of callback-associated arguments\n\
5196 such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5197 yg matrices are respectively interfaced to a linear-transformation\n\
5198 routine similar to the above mypltr function; pltr1; and pltr2.\n\
5199 Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5200 the PLplot documentation) support native language callbacks for\n\
5201 handling index to world-coordinate transformations. Examples of\n\
5202 these various approaches are given in examples/<language>x09*,\n\
5203 examples/<language>x16*, examples/<language>x20*,\n\
5204 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5205 supported languages.\n\
5207 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5208 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5209 that is externally supplied.\n\
5212Set parameters that define current plot-space window\n\
5216 Set relative minima and maxima that define the current plot-space\n\
5217 window. If plsdiplt is not called the default values of xmin, ymin,\n\
5218 xmax, and ymax are 0., 0., 1., and 1.\n\
5220 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
5222 This function is used in example 31.\n\
5228plsdiplt(xmin, ymin, xmax, ymax)\n\
5232 xmin (PLFLT, input) : Relative minimum in x.\n\
5234 ymin (PLFLT, input) : Relative minimum in y.\n\
5236 xmax (PLFLT, input) : Relative maximum in x.\n\
5238 ymax (PLFLT, input) : Relative maximum in y.\n\
5241Write text inside the viewport of a 3D plot\n\
5245 Writes text at a specified position and inclination and with a\n\
5246 specified shear within the viewport. Text is clipped at the viewport\n\
5247 boundaries. The reference point of a string lies along a line passing\n\
5248 through the string at half the height of a capital letter. The\n\
5249 position of the reference point along this line is determined by just,\n\
5250 and the reference point is placed at world coordinates (\n\
5253 wz) within the viewport. The inclination and shear of the string is\n\
5254 specified in terms of differences of world coordinates making it easy\n\
5255 to write text parallel to a line in a graph.\n\
5257 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
5259 This function is used in example 28.\n\
5265plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
5269 wx (PLFLT, input) : x world coordinate of reference point of\n\
5272 wy (PLFLT, input) : y world coordinate of reference point of\n\
5275 wz (PLFLT, input) : z world coordinate of reference point of\n\
5278 dx (PLFLT, input) : Together with dy and\n\
5279 dz , this specifies the inclination of the string. The baseline of\n\
5280 the string is parallel to a line joining (\n\
5291 dy (PLFLT, input) : Together with dx and\n\
5292 dz, this specifies the inclination of the string.\n\
5294 dz (PLFLT, input) : Together with dx and\n\
5295 dy, this specifies the inclination of the string.\n\
5297 sx (PLFLT, input) : Together with sy and\n\
5298 sz , this specifies the shear of the string. The string is sheared so\n\
5299 that the characters are vertically parallel to a line joining (\n\
5310 sz = 0.) then the text is not sheared.\n\
5312 sy (PLFLT, input) : Together with sx and\n\
5313 sz, this specifies shear of the string.\n\
5315 sz (PLFLT, input) : Together with sx and\n\
5316 sy, this specifies shear of the string.\n\
5318 just (PLFLT, input) : Specifies the position of the string relative\n\
5319 to its reference point. If just=0. , the reference point is at\n\
5320 the left and if just=1. , it is at the right of the string. Other\n\
5321 values of just give intermediate justifications.\n\
5323 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5327Plot continental outline or shapefile data in world coordinates\n\
5331 Plots continental outlines or shapefile data in world coordinates. A\n\
5332 demonstration of how to use this function to create different\n\
5333 projections can be found in examples/c/x19c. PLplot is provided with\n\
5334 basic coastal outlines and USA state borders. To use the map\n\
5335 functionality PLplot must be compiled with the shapelib library.\n\
5336 Shapefiles have become a popular standard for geographical data and\n\
5337 data in this format can be easily found from a number of online\n\
5338 sources. Shapefile data is actually provided as three or more files\n\
5339 with the same filename, but different extensions. The .shp and .shx\n\
5340 files are required for plotting Shapefile data with PLplot.\n\
5342 PLplot currently supports the point, multipoint, polyline and polygon\n\
5343 objects within shapefiles. However holes in polygons are not\n\
5344 supported. When plmap is used the type of object is derived from the\n\
5345 shapefile, if you wish to override the type then use one of the other\n\
5346 plmap variants. The built in maps have line data only.\n\
5348 Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
5350 This function is used in example 19.\n\
5356plmap(mapform, name, minx, maxx, miny, maxy)\n\
5360 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5361 transform the original map data coordinates to a new coordinate\n\
5362 system. The PLplot-supplied map data is provided as latitudes and\n\
5363 longitudes; other Shapefile data may be provided in other\n\
5364 coordinate systems as can be found in their .prj plain text files.\n\
5365 For example, by using this transform we can change from a\n\
5366 longitude, latitude coordinate to a polar stereographic\n\
5367 projection. Initially, x[0]..[n-1] are the original x coordinates\n\
5368 (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
5369 corresponding y coordinates (latitudes for the PLplot supplied\n\
5370 data). After the call to mapform(), x[] and y[] should be\n\
5371 replaced by the corresponding plot coordinates. If no transform is\n\
5372 desired, mapform can be replaced by NULL.\n\
5374 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5375 the type of map plotted. This is either one of the PLplot built-in\n\
5376 maps or the file name of a set of Shapefile files without the file\n\
5377 extensions. For the PLplot built-in maps the possible values are:\n\
5378 \"globe\" -- continental outlines\n\
5379 \"usa\" -- USA and state boundaries\n\
5380 \"cglobe\" -- continental outlines and countries\n\
5381 \"usaglobe\" -- USA, state boundaries and continental outlines\n\
5384 minx (PLFLT, input) : The minimum x value of map elements to be\n\
5385 drawn. The units must match the shapefile (built in maps are\n\
5386 degrees lat/lon). Objects in the file which do not encroach on the\n\
5387 box defined by minx, maxx, miny, maxy will not be rendered. But\n\
5388 note this is simply an optimisation, not a clipping so for objects\n\
5389 with some points inside the box and some points outside the box\n\
5390 all the points will be rendered. These parameters also define\n\
5391 latitude and longitude wrapping for shapefiles using these units.\n\
5392 Longitude points will be wrapped by integer multiples of 360\n\
5393 degrees to place them in the box. This allows the same data to be\n\
5394 used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
5395 you plot from -180-540 you will get two cycles of data drawn. The\n\
5396 value of minx must be less than the value of maxx. Passing in a\n\
5397 nan, max/-max floating point number or +/-infinity will case the\n\
5398 bounding box from the shapefile to be used.\n\
5400 maxx (PLFLT, input) : The maximum x value of map elements to be\n\
5401 drawn - see minx.\n\
5403 miny (PLFLT, input) : The minimum y value of map elements to be\n\
5404 drawn - see minx.\n\
5406 maxy (PLFLT, input) : The maximum y value of map elements to be\n\
5407 drawn - see minx.\n\
5410Specify viewport using coordinates and aspect ratio\n\
5414 Device-independent routine for setting up the viewport. The viewport\n\
5415 is chosen to be the largest with the given aspect ratio that fits\n\
5416 within the specified region (in terms of normalized subpage\n\
5417 coordinates). This routine is functionally equivalent to plvpor when\n\
5418 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
5419 routine reserves no extra space at the edges for labels.\n\
5421 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5423 This function is used in example 9.\n\
5429plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5433 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5434 left-hand edge of the viewport.\n\
5436 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5437 right-hand edge of the viewport.\n\
5439 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5440 bottom edge of the viewport.\n\
5442 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5443 edge of the viewport.\n\
5445 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
5449Set the pause (on end-of-page) status\n\
5453 Set the pause (on end-of-page) status.\n\
5455 Redacted form: plspause(pause)\n\
5457 This function is in examples 14,20.\n\
5467 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
5468 end-of-page for those drivers which support this. Otherwise there\n\
5472Plot 3-d surface plot\n\
5476 Plots a three-dimensional surface plot within the environment set up\n\
5477 by plw3d. The surface is defined by the matrix z[\n\
5479 ny] , the point z[i][j] being the value of the function at (\n\
5481 y[j]). Note that the points in vectors x and y do not need to be\n\
5482 equally spaced, but must be stored in ascending order. The parameter\n\
5483 opt controls the way in which the surface is displayed. For further\n\
5484 details see the PLplot documentation. The only difference between\n\
5485 plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5486 while plot3d only draws the surface as viewed from the top.\n\
5488 Redacted form: plot3d(x, y, z, opt, side)\n\
5490 This function is used in examples 11 and 21.\n\
5496plot3d(x, y, z, nx, ny, opt, side)\n\
5500 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5501 which the function is evaluated.\n\
5503 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5504 which the function is evaluated.\n\
5506 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5507 plot. Should have dimensions of\n\
5511 nx (PLINT, input) : Number of x values at which function is\n\
5514 ny (PLINT, input) : Number of y values at which function is\n\
5517 opt (PLINT, input) : Determines the way in which the surface is\n\
5518 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5519 function of x for each value of y[j] .\n\
5520 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5521 for each value of x[i] .\n\
5522 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5523 at which function is defined.\n\
5526 side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5527 should be draw on the figure. If side is true sides are drawn,\n\
5528 otherwise no sides are drawn.\n\
5531Copy state parameters from the reference stream to the current stream\n\
5535 Copies state parameters from the reference stream to the current\n\
5536 stream. Tell driver interface to map device coordinates unless flags\n\
5539 This function is used for making save files of selected plots (e.g.\n\
5540 from the TK driver). After initializing, you can get a copy of the\n\
5541 current plot to the specified device by switching to this stream and\n\
5542 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
5543 appropriate. The plot buffer must have previously been enabled (done\n\
5544 automatically by some display drivers, such as X).\n\
5546 Redacted form: plcpstrm(iplsr, flags)\n\
5548 This function is used in example 1,20.\n\
5554plcpstrm(iplsr, flags)\n\
5558 iplsr (PLINT, input) : Number of reference stream.\n\
5560 flags (PLBOOL, input) : If flags is set to true the device\n\
5561 coordinates are not copied from the reference to current stream.\n\
5564Set page parameters\n\
5568 Sets the page configuration (optional). If an individual parameter is\n\
5569 zero then that parameter value is not updated. Not all parameters are\n\
5570 recognized by all drivers and the interpretation is device-dependent.\n\
5571 The X-window driver uses the length and offset parameters to determine\n\
5572 the window size and location. The length and offset values are\n\
5573 expressed in units that are specific to the current driver. For\n\
5574 instance: screen drivers will usually interpret them as number of\n\
5575 pixels, whereas printer drivers will usually use mm.\n\
5577 This routine, if used, must be called before initializing PLplot. It\n\
5578 may be called at later times for interactive drivers to change only\n\
5579 the dpi for subsequent redraws which you can force via a call to\n\
5580 plreplot. If this function is not called then the page size defaults\n\
5581 to landscape A4 for drivers which use real world page sizes and 744\n\
5582 pixels wide by 538 pixels high for raster drivers. The default value\n\
5583 for dx and dy is 90 pixels per inch for raster drivers.\n\
5587 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5589 This function is used in examples 14 and 31.\n\
5595plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5599 xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
5600 by raster drivers, ignored by drivers which use \"real world\" units\n\
5603 yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
5604 by raster drivers, ignored by drivers which use \"real world\" units\n\
5607 xleng (PLINT, input) : Page length, x.\n\
5609 yleng (PLINT, input) : Page length, y.\n\
5611 xoff (PLINT, input) : Page offset, x.\n\
5613 yoff (PLINT, input) : Page offset, y.\n\
5616Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
5620 Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
5621 (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
5622 Values are negative if an invalid color id is given.\n\
5624 Redacted form: plgcola(r, g, b)\n\
5626 This function is used in example 30.\n\
5632plgcol0a(icol0, r, g, b, alpha)\n\
5636 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5638 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
5639 in the range from 0 to 255.\n\
5641 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
5642 in the range from 0 to 255.\n\
5644 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
5645 in the range from 0 to 255.\n\
5647 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
5648 transparency in the range from (0.0-1.0).\n\
5651Returns 8-bit RGB values for given color index from cmap0\n\
5655 Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
5656 PLplot documentation). Values are negative if an invalid color id is\n\
5659 Redacted form: plgcol0(icol0, r, g, b)\n\
5661 This function is used in example 2.\n\
5667plgcol0(icol0, r, g, b)\n\
5671 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5673 r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
5676 g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
5679 b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
5683Set parameters incrementally (zoom mode) that define current plot-space window\n\
5687 Set relative minima and maxima incrementally (zoom mode) that define\n\
5688 the current plot-space window. This function has the same effect as\n\
5689 plsdiplt if that function has not been previously called. Otherwise,\n\
5690 this function implements zoom mode using the transformation min_used =\n\
5691 old_min + old_length*min and max_used = old_min + old_length*max for\n\
5692 each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
5693 repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
5695 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
5697 This function is used in example 31.\n\
5703plsdiplz(xmin, ymin, xmax, ymax)\n\
5707 xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
5709 ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
5711 xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
5713 ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
5716Plot all or a subset of Shapefile data, filling the polygons\n\
5720 As per plmapline, however the items are filled in the same way as\n\
5723 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
5726 This function is used in example 19.\n\
5732plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
5736 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5737 transform the coordinates given in the shapefile into a plot\n\
5738 coordinate system. By using this transform, we can change from a\n\
5739 longitude, latitude coordinate to a polar stereographic project,\n\
5740 for example. Initially, x[0]..[n-1] are the longitudes and\n\
5741 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
5742 mapform(), x[] and y[] should be replaced by the corresponding\n\
5743 plot coordinates. If no transform is desired, mapform can be\n\
5744 replaced by NULL.\n\
5746 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5747 the file name of a set of Shapefile files without the file\n\
5750 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
5751 be in the same units as used by the Shapefile. You could use a\n\
5752 very large negative number to plot everything, but you can improve\n\
5753 performance by limiting the area drawn. The units must match those\n\
5754 of the Shapefile projection, which may be for example longitude or\n\
5755 distance. The value of minx must be less than the value of maxx.\n\
5757 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
5758 use a very large number to plot everything, but you can improve\n\
5759 performance by limiting the area drawn.\n\
5761 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
5762 be in the same units as used by the Shapefile. You could use a\n\
5763 very large negative number to plot everything, but you can improve\n\
5764 performance by limiting the area drawn. The units must match those\n\
5765 of the Shapefile projection, which may be for example latitude or\n\
5766 distance. The value of miny must be less than the value of maxy.\n\
5768 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
5769 use a very large number to plot everything, but you can improve\n\
5770 performance by limiting the area drawn.\n\
5772 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
5773 zero-based indices of the Shapefile elements which will be drawn.\n\
5775 plotentries to NULL will plot all elements of the Shapefile.\n\
5777 nplotentries (PLINT, input) : The number of items in\n\
5778 plotentries. Ignored if\n\
5779 plotentries is NULL.\n\
5786 Draws line defined by n points in x and y.\n\
5788 Redacted form: plline(x, y)\n\
5790 This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
5801 n (PLINT, input) : Number of points defining line.\n\
5803 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5806 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5810Get viewport limits in world coordinates\n\
5814 Get viewport limits in world coordinates.\n\
5816 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5819 This function is used in example 31.\n\
5825plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5829 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5830 viewport limit of the world coordinate in x.\n\
5832 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5833 viewport limit of the world coordinate in x.\n\
5835 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5836 viewport limit of the world coordinate in y.\n\
5838 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5839 viewport limit of the world coordinate in y.\n\
5842Set area line fill pattern\n\
5846 Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
5847 The pattern consists of 1 or 2 sets of parallel lines with specified\n\
5848 inclinations and spacings. The arguments to this routine are the\n\
5849 number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
5850 elements) specifying the inclinations in tenths of a degree and the\n\
5851 spacing in micrometers. (See also plpsty)\n\
5853 Redacted form: General: plpat(inc, del)\n\
5856 This function is used in example 15.\n\
5862plpat(nlin, inc, del)\n\
5866 nlin (PLINT, input) : Number of sets of lines making up the\n\
5867 pattern, either 1 or 2.\n\
5869 inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5870 inclination in tenths of a degree. (Should be between -900 and\n\
5873 del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5874 spacing in micrometers between the lines making up the pattern.\n\
5877Set x axis parameters\n\
5881 Sets values of the digmax and digits flags for the x axis. See the\n\
5882 PLplot documentation for more information.\n\
5884 Redacted form: plsxax(digmax, digits)\n\
5886 This function is used in example 31.\n\
5892plsxax(digmax, digits)\n\
5896 digmax (PLINT, input) : Variable to set the maximum number of\n\
5897 digits for the x axis. If nonzero, the printed label will be\n\
5898 switched to a floating-point representation when the number of\n\
5899 digits exceeds digmax.\n\
5901 digits (PLINT, input) : Field digits value. Currently, changing\n\
5902 its value here has no effect since it is set only by plbox or\n\
5903 plbox3. However, the user may obtain its value after a call to\n\
5904 either of these functions by calling plgxax.\n\
5907Get family file parameters\n\
5911 Gets information about current family file, if familying is enabled.\n\
5912 See the PLplot documentation for more information.\n\
5914 Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5916 This function is used in examples 14 and 31.\n\
5922plgfam(p_fam, p_num, p_bmax)\n\
5926 p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5927 family flag value. If nonzero, familying is enabled for the\n\
5930 p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5931 family file number.\n\
5933 p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5934 file size (in bytes) for a family file.\n\
5937Get y axis parameters\n\
5941 Identical to plgxax, except that arguments are flags for y axis. See\n\
5942 the description of plgxax for more detail.\n\
5944 Redacted form: plgyax(p_digmax, p_digits)\n\
5946 This function is used in example 31.\n\
5952plgyax(p_digmax, p_digits)\n\
5956 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5957 number of digits for the y axis. If nonzero, the printed label\n\
5958 has been switched to a floating-point representation when the\n\
5959 number of digits exceeds this value.\n\
5961 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
5962 number of digits for the numeric labels (y axis) from the last\n\
5966Plot a glyph at the specified points\n\
5970 Plot a glyph at the specified points. (This function is largely\n\
5971 superseded by plstring which gives access to many[!] more glyphs.)\n\
5972 code=-1 means try to just draw a point. Right now it\'s just a move\n\
5973 and a draw at the same place. Not ideal, since a sufficiently\n\
5974 intelligent output device may optimize it away, or there may be faster\n\
5975 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
5976 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
5977 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
5978 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
5979 code <= 127 the corresponding printable ASCII character is plotted.\n\
5981 Redacted form: plpoin(x, y, code)\n\
5983 This function is used in examples 1, 6, 14, and 29.\n\
5989plpoin(n, x, y, code)\n\
5993 n (PLINT, input) : Number of points in the x and y vectors.\n\
5995 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5998 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6001 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
6002 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
6003 each of the n points.\n\
6006Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
6010 As per plmapline, however the items are plotted as strings or points\n\
6011 in the same way as plstring.\n\
6013 Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
6014 maxy, plotentries)\n\
6016 This function is not used in any examples.\n\
6022plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6026 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6027 transform the coordinates given in the shapefile into a plot\n\
6028 coordinate system. By using this transform, we can change from a\n\
6029 longitude, latitude coordinate to a polar stereographic project,\n\
6030 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6031 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6032 mapform(), x[] and y[] should be replaced by the corresponding\n\
6033 plot coordinates. If no transform is desired, mapform can be\n\
6034 replaced by NULL.\n\
6036 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6037 the file name of a set of Shapefile files without the file\n\
6040 string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
6043 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6044 be in the same units as used by the Shapefile. You could use a\n\
6045 very large negative number to plot everything, but you can improve\n\
6046 performance by limiting the area drawn. The units must match those\n\
6047 of the Shapefile projection, which may be for example longitude or\n\
6048 distance. The value of minx must be less than the value of maxx.\n\
6050 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6051 use a very large number to plot everything, but you can improve\n\
6052 performance by limiting the area drawn.\n\
6054 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6055 be in the same units as used by the Shapefile. You could use a\n\
6056 very large negative number to plot everything, but you can improve\n\
6057 performance by limiting the area drawn. The units must match those\n\
6058 of the Shapefile projection, which may be for example latitude or\n\
6059 distance. The value of miny must be less than the value of maxy.\n\
6061 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6062 use a very large number to plot everything, but you can improve\n\
6063 performance by limiting the area drawn.\n\
6065 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6066 zero-based indices of the Shapefile elements which will be drawn.\n\
6068 plotentries to NULL will plot all elements of the Shapefile.\n\
6070 nplotentries (PLINT, input) : The number of items in\n\
6071 plotentries. Ignored if\n\
6072 plotentries is NULL.\n\
6075Select area fill pattern\n\
6080 patt is zero or less use either a hardware solid fill if the drivers\n\
6081 have that capability (virtually all do) or fall back to a software\n\
6082 emulation of a solid fill using the eighth area line fill pattern. If\n\
6084 patt <= 8, then select one of eight predefined area line fill patterns\n\
6085 to use (see plpat if you desire other patterns).\n\
6087 Redacted form: plpsty(patt)\n\
6089 This function is used in examples 12, 13, 15, 16, and 25.\n\
6099 patt (PLINT, input) : The desired pattern index. If\n\
6100 patt is zero or less, then a solid fill is (normally, see qualifiers\n\
6102 patt in the range from 1 to 8 and assuming the driver has not supplied\n\
6103 line fill capability itself (most deliberately do not so that line\n\
6104 fill patterns look identical for those drivers), the patterns\n\
6105 consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
6106 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
6107 lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
6108 (8) lines at both 45 degrees and -45 degrees.\n\
6111Set 8-bit RGB values for given cmap0 color index\n\
6115 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
6116 index. Overwrites the previous color value for the given index and,\n\
6117 thus, does not result in any additional allocation of space for\n\
6120 Redacted form: plscol0(icol0, r, g, b)\n\
6122 This function is used in any example 31.\n\
6128plscol0(icol0, r, g, b)\n\
6132 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
6133 number of colors (which is set by default, by plscmap0n, or even\n\
6136 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6137 degree of red in the color.\n\
6139 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6140 degree of green in the color.\n\
6142 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6143 degree of blue in the color.\n\
6146Used to globally turn color output on/off\n\
6150 Used to globally turn color output on/off for those drivers/devices\n\
6153 Redacted form: plscolor(color)\n\
6155 This function is used in example 31.\n\
6165 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6166 turned off. If non-zero, color is turned on.\n\
6169End plotting session\n\
6173 Ends a plotting session, tidies up all the output files, switches\n\
6174 interactive devices back into text mode and frees up any memory that\n\
6175 was allocated. Must be called before end of program.\n\
6177 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
6178 wait state after a call to plend or other functions which trigger the\n\
6179 end of a plot page. To avoid this, use the plspause function.\n\
6181 Redacted form: plend()\n\
6183 This function is used in all of the examples.\n\
6192Plot a histogram from binned data\n\
6196 Plots a histogram consisting of nbin bins. The value associated with\n\
6197 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
6198 placed in y[i]. For proper operation, the values in x[i] must form a\n\
6199 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
6200 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
6201 placed midway between the values in the x vector. Also see plhist for\n\
6202 drawing histograms from unbinned data.\n\
6204 Redacted form: General: plbin(x, y, opt)\n\
6205 Python: plbin(nbin, x, y, opt)\n\
6208 This function is not used in any examples.\n\
6214plbin(nbin, x, y, opt)\n\
6218 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
6221 x (PLFLT_VECTOR, input) : A vector containing values associated\n\
6222 with bins. These must form a strictly increasing sequence.\n\
6224 y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
6225 proportional to the number of points in each bin. This is a PLFLT\n\
6226 (instead of PLINT) vector so as to allow histograms of\n\
6227 probabilities, etc.\n\
6229 opt (PLINT, input) : Is a combination of several flags:\n\
6230 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
6231 outer bins are expanded to fill up the entire x-axis and bins of\n\
6232 zero height are simply drawn.\n\
6233 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
6234 between the x values. If the values in x are equally spaced,\n\
6235 the values are the center values of the bins.\n\
6236 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
6237 size as the ones inside.\n\
6238 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
6239 (there is a gap for such bins).\n\
6242Plot a 2D matrix using cmap1\n\
6246 Plot a 2D matrix using cmap1.\n\
6248 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
6249 zmax, valuemin, valuemax, pltr, pltr_data)\n\
6252 This function is used in example 20.\n\
6258plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
6262 idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
6263 plot. Should have dimensions of\n\
6267 nx, ny (PLINT, input) : Dimensions of idata\n\
6269 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
6270 pltr below for how these arguments are used (only for the special case\n\
6271 when the callback function\n\
6272 pltr is not supplied).\n\
6274 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
6275 (inclusive) will be plotted.\n\
6277 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
6278 values to use for value to color mappings. A datum equal to or\n\
6279 less than valuemin will be plotted with color 0.0, while a datum\n\
6280 equal to or greater than valuemax will be plotted with color 1.0.\n\
6281 Data between valuemin and valuemax map linearly to colors in the\n\
6284 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
6285 defines the transformation between the zero-based indices of the\n\
6286 matrix idata and world coordinates. If\n\
6287 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
6288 indices of idata are mapped to the range\n\
6290 xmax and the y indices of idata are mapped to the range\n\
6292 ymax.For the C case, transformation functions are provided in the\n\
6293 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
6294 pltr2 for arbitrary mappings respectively defined by vectors and\n\
6295 matrices. In addition, C callback routines for the transformation\n\
6296 can be supplied by the user such as the mypltr function in\n\
6297 examples/c/x09c.c which provides a general linear transformation\n\
6298 between index coordinates and world coordinates.For languages\n\
6299 other than C you should consult the PLplot documentation for the\n\
6300 details concerning how PLTRANSFORM_callback arguments are\n\
6301 interfaced. However, in general, a particular pattern of\n\
6302 callback-associated arguments such as a tr vector with 6 elements;\n\
6303 xg and yg vectors; or xg and yg matrices are respectively\n\
6304 interfaced to a linear-transformation routine similar to the above\n\
6305 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
6306 sophisticated bindings (see, e.g., the PLplot documentation)\n\
6307 support native language callbacks for handling index to\n\
6308 world-coordinate transformations. Examples of these various\n\
6309 approaches are given in examples/<language>x09*,\n\
6310 examples/<language>x16*, examples/<language>x20*,\n\
6311 examples/<language>x21*, and examples/<language>x22*, for all our\n\
6312 supported languages.\n\
6314 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
6315 information to pltr0, pltr1, pltr2, or whatever routine is\n\
6316 externally supplied.\n\
6319Sets the 3D position of the light source\n\
6323 Sets the 3D position of the light source for use with plsurf3d and\n\
6326 Redacted form: pllightsource(x, y, z)\n\
6328 This function is used in example 8.\n\
6334pllightsource(x, y, z)\n\
6338 x (PLFLT, input) : X-coordinate of the light source.\n\
6340 y (PLFLT, input) : Y-coordinate of the light source.\n\
6342 z (PLFLT, input) : Z-coordinate of the light source.\n\
6345Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
6349 When the implementation is completed this variant of plot3dc (see that\n\
6350 function\'s documentation for more details) should be suitable for the\n\
6351 case where the area of the x, y coordinate grid where z is defined can\n\
6352 be non-rectangular. The implementation is incomplete so the last 4\n\
6353 parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
6354 indexymax; are currently ignored and the functionality is otherwise\n\
6355 identical to that of plot3dc.\n\
6357 Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
6358 indexymin, indexymax)\n\
6361 This function is not used in any example.\n\
6367plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
6371 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
6372 which the function is evaluated.\n\
6374 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
6375 which the function is evaluated.\n\
6377 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
6378 plot. Should have dimensions of\n\
6382 nx (PLINT, input) : Number of x values at which the function is\n\
6385 ny (PLINT, input) : Number of y values at which the function is\n\
6388 opt (PLINT, input) : Determines the way in which the surface is\n\
6389 represented. To specify more than one option just add the options,\n\
6390 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
6391 showing z as a function of x for each value of y[j] .\n\
6392 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
6393 for each value of x[i] .\n\
6394 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
6395 at which function is defined.\n\
6396 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
6397 the z value being plotted. The color is used from the current\n\
6399 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
6403 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
6404 the borders of the plotted function.\n\
6407 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
6410 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
6412 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
6413 corresponds to the first x index where z is defined.\n\
6415 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
6416 which corresponds (by convention) to one more than the last x\n\
6417 index value where z is defined.\n\
6419 indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
6420 values which all must be ≥ 0. These values are the first y index\n\
6421 where z is defined for a particular x index in the range from\n\
6422 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
6425 indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
6426 values which all must be ≤ ny. These values correspond (by\n\
6427 convention) to one more than the last y index where z is defined\n\
6428 for a particular x index in the range from indexxmin to indexxmax\n\
6429 - 1. The dimension of indexymax is indexxmax.\n\
6432Creates a new stream and makes it the default\n\
6436 Creates a new stream and makes it the default. Differs from using\n\
6437 plsstrm, in that a free stream number is found, and returned.\n\
6438 Unfortunately, I have to start at stream 1 and work upward, since\n\
6439 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
6440 that no initial, library-opening call is required. So stream 0 must\n\
6441 be preallocated, and there is no simple way of determining whether it\n\
6442 is already in use or not.\n\
6444 Redacted form: plmkstrm(p_strm)\n\
6446 This function is used in examples 1 and 20.\n\
6456 p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
6457 number of the created stream.\n\
6460Set FCI (font characterization integer)\n\
6464 Sets font characteristics to be used at the start of the next string\n\
6465 using the FCI approach. See the PLplot documentation for more\n\
6466 information. Note, plsfont (which calls plsfci internally) provides a\n\
6467 more user-friendly API for setting the font characterisitics.\n\
6469 Redacted form: General: plsfci(fci)\n\
6472 This function is used in example 23.\n\
6482 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
6490 Initializing the plotting package. The program prompts for the device\n\
6491 keyword or number of the desired output device. Hitting a RETURN in\n\
6492 response to the prompt is the same as selecting the first device.\n\
6493 plinit will issue no prompt if either the device was specified\n\
6494 previously (via command line flag, the plsetopt function, or the\n\
6495 plsdev function), or if only one device is enabled when PLplot is\n\
6496 installed. If subpages have been specified, the output device is\n\
6497 divided into nx by ny subpages, each of which may be used\n\
6498 independently. If plinit is called again during a program, the\n\
6499 previously opened file will be closed. The subroutine pladv is used\n\
6500 to advance from one subpage to the next.\n\
6502 Redacted form: plinit()\n\
6504 This function is used in all of the examples.\n\
6517 This sets up the line style for all lines subsequently drawn. A line\n\
6518 consists of segments in which the pen is alternately down and up. The\n\
6519 lengths of these segments are passed in the vectors mark and space\n\
6520 respectively. The number of mark-space pairs is specified by nms. In\n\
6521 order to return the line style to the default continuous line, plstyl\n\
6522 should be called with nms =0 .(see also pllsty)\n\
6524 Redacted form: plstyl(mark, space)\n\
6526 This function is used in examples 1, 9, and 14.\n\
6532plstyl(nms, mark, space)\n\
6536 nms (PLINT, input) : The number of mark and space elements in a\n\
6537 line. Thus a simple broken line can be obtained by setting nms=1\n\
6538 . A continuous line is specified by setting nms=0 .\n\
6540 mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
6541 segments during which the pen is down, measured in micrometers.\n\
6543 space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
6544 the segments during which the pen is up, measured in micrometers.\n\
6547Set length of minor ticks\n\
6551 This sets up the length of the minor ticks and the length of the\n\
6552 terminals on error bars. The actual length is the product of the\n\
6553 default length and a scaling factor as for character height.\n\
6555 Redacted form: plsmin(def, scale)\n\
6557 This function is used in example 29.\n\
6563plsmin(def, scale)\n\
6567 def (PLFLT, input) : The default length of a minor tick in\n\
6568 millimeters, should be set to zero if the default length is to\n\
6569 remain unchanged.\n\
6571 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6572 actual tick length.\n\
6575Draw a box with axes, etc, in 3-d\n\
6579 Draws axes, numeric and text labels for a three-dimensional surface\n\
6580 plot. For a more complete description of three-dimensional plotting\n\
6581 see the PLplot documentation.\n\
6583 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
6584 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6587 This function is used in examples 8, 11, 18, and 21.\n\
6593plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6597 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6598 options for the x axis. The string can include any combination of\n\
6599 the following letters (upper or lower case) in any order: b: Draws\n\
6600 axis at base, at height z=\n\
6601 zmin where zmin is defined by call to plw3d. This character must be\n\
6602 specified in order to use any of the other options.\n\
6603 d: Plot labels as date / time. Values are assumed to be\n\
6604 seconds since the epoch (as used by gmtime).\n\
6605 f: Always use fixed point numeric labels.\n\
6606 i: Inverts tick marks, so they are drawn downwards, rather\n\
6608 l: Labels axis logarithmically. This only affects the labels,\n\
6609 not the data, and so it is necessary to compute the logarithms\n\
6610 of data points before passing them to any of the drawing\n\
6612 n: Writes numeric labels at major tick intervals.\n\
6613 o: Use custom labelling function to generate axis label text.\n\
6614 The custom labelling function can be defined with the\n\
6615 plslabelfunc command.\n\
6616 s: Enables subticks between major ticks, only valid if t is\n\
6618 t: Draws major ticks.\n\
6619 u: If this is specified, the text label for the axis is\n\
6620 written under the axis.\n\
6623 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6624 the text label for the x axis. It is only drawn if u is in the\n\
6627 xtick (PLFLT, input) : World coordinate interval between major\n\
6628 ticks on the x axis. If it is set to zero, PLplot automatically\n\
6629 generates a suitable tick interval.\n\
6631 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
6632 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6633 generates a suitable minor tick interval.\n\
6635 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6636 options for the y axis. The string is interpreted in the same way\n\
6639 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6640 the text label for the y axis. It is only drawn if u is in the\n\
6643 ytick (PLFLT, input) : World coordinate interval between major\n\
6644 ticks on the y axis. If it is set to zero, PLplot automatically\n\
6645 generates a suitable tick interval.\n\
6647 nysub (PLINT, input) : Number of subintervals between major y axis\n\
6648 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6649 generates a suitable minor tick interval.\n\
6651 zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6652 options for the z axis. The string can include any combination of\n\
6653 the following letters (upper or lower case) in any order: b: Draws\n\
6654 z axis to the left of the surface plot.\n\
6655 c: Draws z axis to the right of the surface plot.\n\
6656 d: Draws grid lines parallel to the x-y plane behind the\n\
6657 figure. These lines are not drawn until after plot3d or\n\
6658 plmesh are called because of the need for hidden line removal.\n\
6659 e: Plot labels as date / time. Values are assumed to be\n\
6660 seconds since the epoch (as used by gmtime). Note this\n\
6661 suboption is interpreted the same as the d suboption for xopt\n\
6662 and yopt, but it has to be identified as e for zopt since d\n\
6663 has already been used for the different purpose above.\n\
6664 f: Always use fixed point numeric labels.\n\
6665 i: Inverts tick marks, so they are drawn away from the center.\n\
6666 l: Labels axis logarithmically. This only affects the labels,\n\
6667 not the data, and so it is necessary to compute the logarithms\n\
6668 of data points before passing them to any of the drawing\n\
6670 m: Writes numeric labels at major tick intervals on the\n\
6671 right-hand z axis.\n\
6672 n: Writes numeric labels at major tick intervals on the\n\
6673 left-hand z axis.\n\
6674 o: Use custom labelling function to generate axis label text.\n\
6675 The custom labelling function can be defined with the\n\
6676 plslabelfunc command.\n\
6677 s: Enables subticks between major ticks, only valid if t is\n\
6679 t: Draws major ticks.\n\
6680 u: If this is specified, the text label is written beside the\n\
6682 v: If this is specified, the text label is written beside the\n\
6686 zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6687 the text label for the z axis. It is only drawn if u or v are in\n\
6690 ztick (PLFLT, input) : World coordinate interval between major\n\
6691 ticks on the z axis. If it is set to zero, PLplot automatically\n\
6692 generates a suitable tick interval.\n\
6694 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
6695 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6696 generates a suitable minor tick interval.\n\
6699Set character size\n\
6703 This sets up the size of all subsequent characters drawn. The actual\n\
6704 height of a character is the product of the default character size and\n\
6705 a scaling factor.\n\
6707 Redacted form: plschr(def, scale)\n\
6709 This function is used in examples 2, 13, 23, and 24.\n\
6715plschr(def, scale)\n\
6719 def (PLFLT, input) : The default height of a character in\n\
6720 millimeters, should be set to zero if the default height is to\n\
6721 remain unchanged. For rasterized drivers the dx and dy values\n\
6722 specified in plspage are used to convert from mm to pixels (note\n\
6723 the different unit systems used). This dpi aware scaling is not\n\
6724 implemented for all drivers yet.\n\
6726 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6727 actual character height.\n\
6730Calculate continuous time from broken-down time for the current stream\n\
6734 Calculate continuous time, ctime, from broken-down time for the\n\
6735 current stream. The broken-down\n\
6736 time is specified by the following parameters: year, month, day, hour,\n\
6737 min, and sec. This function is the inverse of plbtime.\n\
6739 The PLplot definition of broken-down time is a calendar time that\n\
6740 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6741 responsibility to apply those offsets (if so desired) before using the\n\
6742 PLplot time API. By default broken-down time is defined using the\n\
6743 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6744 continuous time is defined as the number of seconds since the Unix\n\
6745 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6746 broken-down and continuous time are possible, see plconfigtime which\n\
6747 specifies that transformation for the current stream.\n\
6749 Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6753 This function is used in example 29.\n\
6759plctime(year, month, day, hour, min, sec, ctime)\n\
6763 year (PLINT, input) : Input year.\n\
6765 month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6768 day (PLINT, input) : Input day in range from 1 to 31.\n\
6770 hour (PLINT, input) : Input hour in range from 0 to 23\n\
6772 min (PLINT, input) : Input minute in range from 0 to 59.\n\
6774 sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6776 ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6777 time calculated from the broken-down time specified by the\n\
6778 previous parameters.\n\
6785 Sets the color index for cmap0 (see the PLplot documentation).\n\
6787 Redacted form: plcol0(icol0)\n\
6789 This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6799 icol0 (PLINT, input) : Integer representing the color. The\n\
6800 defaults at present are (these may change):\n\
6801 0 black (default background)\n\
6802 1 red (default foreground)\n\
6818 Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6819 change an individual color in the cmap0 color palette.\n\
6826 Sets the color for cmap1 (see the PLplot documentation).\n\
6828 Redacted form: plcol1(col1)\n\
6830 This function is used in examples 12 and 21.\n\
6840 col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6841 is mapped to color using the continuous cmap1 palette which by\n\
6842 default ranges from blue to the background color to red. The\n\
6843 cmap1 palette can also be straightforwardly changed by the user\n\
6844 with plscmap1 or plscmap1l.\n\
6847Returns the background color (cmap0[0]) by 8-bit RGB value\n\
6851 Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
6853 Redacted form: plgcolbg(r, g, b)\n\
6855 This function is used in example 31.\n\
6865 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
6866 in the range from 0 to 255.\n\
6868 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
6869 in the range from 0 to 255.\n\
6871 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
6872 in the range from 0 to 255.\n\
6875Draw a circular or elliptical arc\n\
6879 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
6880 semiminor axis b, starting at angle1 and ending at angle2.\n\
6882 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
6886 This function is used in examples 3 and 27.\n\
6892plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
6896 x (PLFLT, input) : X coordinate of arc center.\n\
6898 y (PLFLT, input) : Y coordinate of arc center.\n\
6900 a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
6902 b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
6904 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
6907 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
6910 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
6913 fill (PLBOOL, input) : Draw a filled arc.\n\
6916Parse command-line arguments\n\
6920 Parse command-line arguments.\n\
6922 plparseopts removes all recognized flags (decreasing argc\n\
6923 accordingly), so that invalid input may be readily detected. It can\n\
6924 also be used to process user command line flags. The user can merge\n\
6925 an option table of type PLOptionTable into the internal option table\n\
6926 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
6927 the external table(s) be parsed by calling plClearOpts before\n\
6930 The default action taken by plparseopts is as follows:\n\
6931 Returns with an error if an unrecognized option or badly formed\n\
6932 option-value pair are encountered.\n\
6933 Returns immediately (return code 0) when the first non-option command\n\
6934 line argument is found.\n\
6935 Returns with the return code of the option handler, if one was called.\n\
6937 Deletes command line arguments from argv list as they are found, and\n\
6938 decrements argc accordingly.\n\
6939 Does not show \"invisible\" options in usage or help messages.\n\
6940 Assumes the program name is contained in argv[0].\n\
6942 These behaviors may be controlled through the\n\
6945 Redacted form: General: plparseopts(argv, mode)\n\
6948 This function is used in all of the examples.\n\
6954PLINT plparseopts(p_argc, argv, mode)\n\
6958 p_argc (int *, input/output) : Number of arguments.\n\
6960 argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
6961 strings containing *p_argc command-line arguments.\n\
6963 mode (PLINT, input) : Parsing mode with the following\n\
6964 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
6965 and all error messages enabled, including program exit when an\n\
6966 error occurs. Anything on the command line that isn\'t recognized\n\
6967 as a valid option or option argument is flagged as an error.\n\
6968 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
6970 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
6972 PL_PARSE_SHOWALL (8) -- Show invisible options\n\
6973 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
6974 pointer to the program name.\n\
6975 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
6976 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
6977 unrecognized arguments.\n\
6980Get parameters that define current device-space window\n\
6984 Get relative margin width, aspect ratio, and relative justification\n\
6985 that define current device-space window. If plsdidev has not been\n\
6986 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
6987 p_jy will all be 0.\n\
6989 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
6991 This function is used in example 31.\n\
6997plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
7001 p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7004 p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
7007 p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7008 justification in x.\n\
7010 p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7011 justification in y.\n\
7014Assign a function to use for generating custom axis labels\n\
7018 This function allows a user to provide their own function to provide\n\
7019 axis label text. The user function is given the numeric value for a\n\
7020 point on an axis and returns a string label to correspond with that\n\
7021 value. Custom axis labels can be enabled by passing appropriate\n\
7022 arguments to plenv, plbox, plbox3 and similar functions.\n\
7024 This function is used in example 19.\n\
7030plslabelfunc(label_func, label_data)\n\
7034 label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
7035 label function. In order to reset to the default labelling, set\n\
7036 this to NULL. The labelling function parameters are, in order:\n\
7037 axis: This indicates which axis a label is being requested for.\n\
7038 The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
7040 value: This is the value along the axis which is being labelled.\n\
7042 label_text: The string representation of the label value.\n\
7044 length: The maximum length in characters allowed for label_text.\n\
7047 label_data (PLPointer, input) : This parameter may be used to pass\n\
7048 data to the label_func function.\n\
7051Get the (current) run level\n\
7055 Get the (current) run level. Valid settings are: 0, uninitialized\n\
7057 2, viewport defined\n\
7058 3, world coordinates defined\n\
7061 Redacted form: plglevel(p_level)\n\
7063 This function is used in example 31.\n\
7073 p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
7081 This sets the line style according to one of eight predefined patterns\n\
7082 (also see plstyl).\n\
7084 Redacted form: pllsty(lin)\n\
7086 This function is used in examples 9, 12, 22, and 25.\n\
7096 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
7097 a continuous line, line style 2 is a line with short dashes and\n\
7098 gaps, line style 3 is a line with long dashes and gaps, line style\n\
7099 4 has long dashes and short gaps and so on.\n\
7102Set up standard window and draw box\n\
7106 Sets up plotter environment for simple graphs by calling pladv and\n\
7107 setting up viewport and window to sensible default values. plenv\n\
7108 leaves a standard margin (left-hand margin of eight character heights,\n\
7109 and a margin around the other three sides of five character heights)\n\
7110 around most graphs for axis labels and a title. When these defaults\n\
7111 are not suitable, use the individual routines plvpas, plvpor, or\n\
7112 plvasp for setting up the viewport, plwind for defining the window,\n\
7113 and plbox for drawing the box.\n\
7115 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7117 This function is used in example 1,3,9,13,14,19-22,29.\n\
7123plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7127 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
7128 world coordinates).\n\
7130 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
7131 world coordinates).\n\
7133 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
7136 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
7139 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
7140 scales will not be set, the user must set up the scale before\n\
7141 calling plenv using plsvpa, plvasp or other.\n\
7142 0: the x and y axes are scaled independently to use as much of\n\
7143 the screen as possible.\n\
7144 1: the scales of the x and y axes are made equal.\n\
7145 2: the axis of the x and y axes are made equal, and the plot\n\
7146 box will be square.\n\
7149 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
7150 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
7151 -1: draw box only.\n\
7152 0: draw box, ticks, and numeric tick labels.\n\
7153 1: also draw coordinate axes at x=0 and y=0.\n\
7154 2: also draw a grid at major tick positions in both\n\
7156 3: also draw a grid at minor tick positions in both\n\
7158 10: same as 0 except logarithmic x tick marks. (The x data\n\
7159 have to be converted to logarithms separately.)\n\
7160 11: same as 1 except logarithmic x tick marks. (The x data\n\
7161 have to be converted to logarithms separately.)\n\
7162 12: same as 2 except logarithmic x tick marks. (The x data\n\
7163 have to be converted to logarithms separately.)\n\
7164 13: same as 3 except logarithmic x tick marks. (The x data\n\
7165 have to be converted to logarithms separately.)\n\
7166 20: same as 0 except logarithmic y tick marks. (The y data\n\
7167 have to be converted to logarithms separately.)\n\
7168 21: same as 1 except logarithmic y tick marks. (The y data\n\
7169 have to be converted to logarithms separately.)\n\
7170 22: same as 2 except logarithmic y tick marks. (The y data\n\
7171 have to be converted to logarithms separately.)\n\
7172 23: same as 3 except logarithmic y tick marks. (The y data\n\
7173 have to be converted to logarithms separately.)\n\
7174 30: same as 0 except logarithmic x and y tick marks. (The x\n\
7175 and y data have to be converted to logarithms separately.)\n\
7176 31: same as 1 except logarithmic x and y tick marks. (The x\n\
7177 and y data have to be converted to logarithms separately.)\n\
7178 32: same as 2 except logarithmic x and y tick marks. (The x\n\
7179 and y data have to be converted to logarithms separately.)\n\
7180 33: same as 3 except logarithmic x and y tick marks. (The x\n\
7181 and y data have to be converted to logarithms separately.)\n\
7182 40: same as 0 except date / time x labels.\n\
7183 41: same as 1 except date / time x labels.\n\
7184 42: same as 2 except date / time x labels.\n\
7185 43: same as 3 except date / time x labels.\n\
7186 50: same as 0 except date / time y labels.\n\
7187 51: same as 1 except date / time y labels.\n\
7188 52: same as 2 except date / time y labels.\n\
7189 53: same as 3 except date / time y labels.\n\
7190 60: same as 0 except date / time x and y labels.\n\
7191 61: same as 1 except date / time x and y labels.\n\
7192 62: same as 2 except date / time x and y labels.\n\
7193 63: same as 3 except date / time x and y labels.\n\
7194 70: same as 0 except custom x and y labels.\n\
7195 71: same as 1 except custom x and y labels.\n\
7196 72: same as 2 except custom x and y labels.\n\
7197 73: same as 3 except custom x and y labels.\n\
7204 Alternative to plstar for initializing the plotting package. The\n\
7205 device name keyword for the desired output device must be supplied as\n\
7206 an argument. These keywords are the same as those printed out by\n\
7207 plstar. If the requested device is not available, or if the input\n\
7208 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
7209 is used. This routine also divides the output device page into nx by\n\
7210 ny subpages, each of which may be used independently. The subroutine\n\
7211 pladv is used to advance from one subpage to the next.\n\
7213 Redacted form: General: plstart(devname, nx, ny)\n\
7216 This function is not used in any examples.\n\
7222plstart(devname, nx, ny)\n\
7226 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7227 containing the device name keyword of the required output device.\n\
7229 devname is NULL or if the first character of the string is a ``?\'\',\n\
7230 the normal (prompted) start up is used.\n\
7232 nx (PLINT, input) : Number of subpages to divide output page in the\n\
7235 ny (PLINT, input) : Number of subpages to divide output page in the\n\
7239Plot a glyph at the specified points\n\
7243 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
7244 because many[!] more glyphs are accessible with plstring.) The glyph\n\
7245 is specified with a PLplot user string. Note that the user string is\n\
7246 not actually limited to one glyph so it is possible (but not normally\n\
7247 useful) to plot more than one glyph at the specified points with this\n\
7248 function. As with plmtex and plptex, the user string can contain FCI\n\
7249 escapes to determine the font, UTF-8 code to determine the glyph or\n\
7250 else PLplot escapes for Hershey or unicode text to determine the\n\
7253 Redacted form: plstring(x, y, string)\n\
7255 This function is used in examples 4, 21 and 26.\n\
7261plstring(n, x, y, string)\n\
7265 n (PLINT, input) : Number of points in the x and y vectors.\n\
7267 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7270 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7273 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
7274 the glyph(s) to be plotted at each of the n points.\n\
7277Write text relative to viewport boundaries in 3D plots\n\
7281 Writes text at a specified position relative to the viewport\n\
7282 boundaries. Text may be written inside or outside the viewport, but\n\
7283 is clipped at the subpage boundaries. The reference point of a string\n\
7284 lies along a line passing through the string at half the height of a\n\
7285 capital letter. The position of the reference point along this line\n\
7286 is determined by just, and the position of the reference point\n\
7287 relative to the viewport is set by disp and pos.\n\
7289 Redacted form: plmtex3(side, disp, pos, just, text)\n\
7291 This function is used in example 28.\n\
7297plmtex3(side, disp, pos, just, text)\n\
7301 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7302 the side of the viewport along which the text is to be written.\n\
7303 The string should contain one or more of the following characters:\n\
7304 [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
7305 only label the X axis, not both the X and Y axes. x: Label the X\n\
7307 y: Label the Y axis.\n\
7308 z: Label the Z axis.\n\
7309 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
7310 For X it is the axis that starts at y-min. For Y it is the\n\
7311 axis that starts at x-min.\n\
7312 s: Label the secondary axis.\n\
7313 v: Draw the text perpendicular to the axis.\n\
7316 disp (PLFLT, input) : Position of the reference point of string,\n\
7317 measured outwards from the specified viewport edge in units of the\n\
7318 current character height. Use negative disp to write within the\n\
7321 pos (PLFLT, input) : Position of the reference point of string\n\
7322 along the specified edge, expressed as a fraction of the length of\n\
7325 just (PLFLT, input) : Specifies the position of the string relative\n\
7326 to its reference point. If just=0. , the reference point is at\n\
7327 the left and if just=1. , it is at the right of the string. Other\n\
7328 values of just give intermediate justifications.\n\
7330 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
7334Get plot orientation\n\
7338 Get plot orientation parameter which is multiplied by 90 degrees to\n\
7339 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7340 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7341 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7342 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7343 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
7344 not been called the default value pointed to by p_rot will be 0.\n\
7346 Redacted form: plgdiori(p_rot)\n\
7348 This function is not used in any examples.\n\
7358 p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
7362Simple routine to write labels\n\
7366 Routine for writing simple labels. Use plmtex for more complex labels.\n\
7368 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
7370 This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
7376pllab(xlabel, ylabel, tlabel)\n\
7380 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7381 the label for the x axis.\n\
7383 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7384 the label for the y axis.\n\
7386 tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7387 the title of the plot.\n\
7390Switch to text screen\n\
7394 Sets an interactive device to text mode, used in conjunction with\n\
7395 plgra to allow graphics and text to be interspersed. On a device\n\
7396 which supports separate text and graphics windows, this command causes\n\
7397 control to be switched to the text window. This can be useful for\n\
7398 printing diagnostic messages or getting user input, which would\n\
7399 otherwise interfere with the plots. The program must switch back to\n\
7400 the graphics window before issuing plot commands, as the text (or\n\
7401 console) device will probably become quite confused otherwise. If\n\
7402 already in text mode, this command is ignored. It is also ignored on\n\
7403 devices which only support a single window or use a different method\n\
7404 for shifting focus (see also plgra).\n\
7406 Redacted form: pltext()\n\
7408 This function is used in example 1.\n\
7417Plot all or a subset of Shapefile data using lines in world coordinates\n\
7421 Plot all or a subset of Shapefile data using lines in world\n\
7422 coordinates. Our 19th standard example demonstrates how to use this\n\
7423 function. This function plots data from a Shapefile using lines as in\n\
7424 plmap, however it also has the option of also only drawing specified\n\
7425 elements from the Shapefile. The vector of indices of the required\n\
7426 elements are passed as a function argument. The Shapefile data should\n\
7427 include a metadata file (extension.dbf) listing all items within the\n\
7428 Shapefile. This file can be opened by most popular spreadsheet\n\
7429 programs and can be used to decide which indices to pass to this\n\
7432 Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
7435 This function is used in example 19.\n\
7441plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
7445 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7446 transform the coordinates given in the shapefile into a plot\n\
7447 coordinate system. By using this transform, we can change from a\n\
7448 longitude, latitude coordinate to a polar stereographic project,\n\
7449 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7450 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7451 mapform(), x[] and y[] should be replaced by the corresponding\n\
7452 plot coordinates. If no transform is desired, mapform can be\n\
7453 replaced by NULL.\n\
7455 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7456 the file name of a set of Shapefile files without the file\n\
7459 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7460 be in the same units as used by the Shapefile. You could use a\n\
7461 very large negative number to plot everything, but you can improve\n\
7462 performance by limiting the area drawn. The units must match those\n\
7463 of the Shapefile projection, which may be for example longitude or\n\
7464 distance. The value of minx must be less than the value of maxx.\n\
7466 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7467 use a very large number to plot everything, but you can improve\n\
7468 performance by limiting the area drawn.\n\
7470 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7471 be in the same units as used by the Shapefile. You could use a\n\
7472 very large negative number to plot everything, but you can improve\n\
7473 performance by limiting the area drawn. The units must match those\n\
7474 of the Shapefile projection, which may be for example latitude or\n\
7475 distance. The value of miny must be less than the value of maxy.\n\
7477 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7478 use a very large number to plot everything, but you can improve\n\
7479 performance by limiting the area drawn.\n\
7481 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
7482 zero-based indices of the Shapefile elements which will be drawn.\n\
7484 plotentries to NULL will plot all elements of the Shapefile.\n\
7486 nplotentries (PLINT, input) : The number of items in\n\
7487 plotentries. Ignored if\n\
7488 plotentries is NULL.\n\
7491Set precision in numeric labels\n\
7495 Sets the number of places after the decimal point in numeric labels.\n\
7497 Redacted form: plprec(setp, prec)\n\
7499 This function is used in example 29.\n\
7505plprec(setp, prec)\n\
7509 setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7510 automatically determines the number of places to use after the\n\
7511 decimal point in numeric labels (like those used to label axes).\n\
7512 If setp is 1 then prec sets the number of places.\n\
7514 prec (PLINT, input) : The number of characters to draw after the\n\
7515 decimal point in numeric labels.\n\
7518Draw a line between two points\n\
7522 Joins the point (\n\
7528 Redacted form: pljoin(x1,y1,x2,y2)\n\
7530 This function is used in examples 3 and 14.\n\
7536pljoin(x1, y1, x2, y2)\n\
7540 x1 (PLFLT, input) : x coordinate of first point.\n\
7542 y1 (PLFLT, input) : y coordinate of first point.\n\
7544 x2 (PLFLT, input) : x coordinate of second point.\n\
7546 y2 (PLFLT, input) : y coordinate of second point.\n\
7549Set the device (keyword) name\n\
7553 Set the device (keyword) name.\n\
7555 Redacted form: plsdev(devname)\n\
7557 This function is used in examples 1, 14, and 20.\n\
7567 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7568 containing the device name keyword of the required output device.\n\
7570 devname is NULL or if the first character of the string is a ``?\'\',\n\
7571 the normal (prompted) start up is used.\n\
7574Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
7578 Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
7579 (see the PLplot documentation) index. Overwrites the previous color\n\
7580 value for the given index and, thus, does not result in any additional\n\
7581 allocation of space for colors.\n\
7583 This function is used in example 30.\n\
7589plscol0a(icol0, r, g, b, alpha)\n\
7593 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
7594 number of colors (which is set by default, by plscmap0n, or even\n\
7597 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7598 degree of red in the color.\n\
7600 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7601 degree of green in the color.\n\
7603 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7604 degree of blue in the color.\n\
7606 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
7610Draw filled polygon in 3D\n\
7614 Fills the 3D polygon defined by the n points in the x, y, and z\n\
7615 vectors using the pattern defined by plpsty or plpat. The routine\n\
7616 will automatically close the polygon between the last and first\n\
7617 vertices. If multiple closed polygons are passed in x, y, and z then\n\
7618 plfill3 will fill in between them.\n\
7620 Redacted form: General: plfill3(x, y, z)\n\
7623 This function is used in example 15.\n\
7629plfill3(n, x, y, z)\n\
7633 n (PLINT, input) : Number of vertices in polygon.\n\
7635 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7638 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7641 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
7649 Specify the window, i.e., the world coordinates of the edges of the\n\
7652 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
7654 This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
7661plwind(xmin, xmax, ymin, ymax)\n\
7665 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
7668 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
7671 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
7674 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
7678Draw text at points defined by Shapefile data in world coordinates\n\
7682 As per plmapline, however the items are plotted as text in the same\n\
7685 Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
7686 miny, maxy, plotentry)\n\
7688 This function is used in example 19.\n\
7694plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
7698 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7699 transform the coordinates given in the shapefile into a plot\n\
7700 coordinate system. By using this transform, we can change from a\n\
7701 longitude, latitude coordinate to a polar stereographic project,\n\
7702 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7703 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7704 mapform(), x[] and y[] should be replaced by the corresponding\n\
7705 plot coordinates. If no transform is desired, mapform can be\n\
7706 replaced by NULL.\n\
7708 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7709 the file name of a set of Shapefile files without the file\n\
7712 dx (PLFLT, input) : Used to define the slope of the texts which is\n\
7715 dy (PLFLT, input) : Used to define the slope of the texts which is\n\
7718 just (PLFLT, input) : Set the justification of the text. The value\n\
7719 given will be the fraction of the distance along the string that\n\
7720 sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
7721 centralized text and 1.0 gives right aligned text.\n\
7723 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
7725 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7726 be in the same units as used by the Shapefile. You could use a\n\
7727 very large negative number to plot everything, but you can improve\n\
7728 performance by limiting the area drawn. The units must match those\n\
7729 of the Shapefile projection, which may be for example longitude or\n\
7730 distance. The value of minx must be less than the value of maxx.\n\
7732 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7733 use a very large number to plot everything, but you can improve\n\
7734 performance by limiting the area drawn.\n\
7736 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7737 be in the same units as used by the Shapefile. You could use a\n\
7738 very large negative number to plot everything, but you can improve\n\
7739 performance by limiting the area drawn. The units must match those\n\
7740 of the Shapefile projection, which may be for example latitude or\n\
7741 distance. The value of miny must be less than the value of maxy.\n\
7743 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7744 use a very large number to plot everything, but you can improve\n\
7745 performance by limiting the area drawn.\n\
7747 plotentry (PLINT, input) : An integer indicating which text string\n\
7748 of the Shapefile (zero indexed) will be drawn.\n\
7751Switch to graphics screen\n\
7755 Sets an interactive device to graphics mode, used in conjunction with\n\
7756 pltext to allow graphics and text to be interspersed. On a device\n\
7757 which supports separate text and graphics windows, this command causes\n\
7758 control to be switched to the graphics window. If already in graphics\n\
7759 mode, this command is ignored. It is also ignored on devices which\n\
7760 only support a single window or use a different method for shifting\n\
7761 focus. See also pltext.\n\
7763 Redacted form: plgra()\n\
7765 This function is used in example 1.\n\
7774Set parameters of contour labelling other than format of numerical label\n\
7778 Set parameters of contour labelling other than those handled by\n\
7779 pl_setcontlabelformat.\n\
7781 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7783 This function is used in example 9.\n\
7789pl_setcontlabelparam(offset, size, spacing, active)\n\
7793 offset (PLFLT, input) : Offset of label from contour line (if set\n\
7794 to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7796 size (PLFLT, input) : Font height for contour labels (normalized).\n\
7797 Default value is 0.3.\n\
7799 spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7800 Default value is 0.1.\n\
7802 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7803 contour labels on. Default is off (0).\n\
7806Get family, style and weight of the current font\n\
7810 Gets information about current font. See the PLplot documentation for\n\
7811 more information on font selection.\n\
7813 Redacted form: plgfont(p_family, p_style, p_weight)\n\
7815 This function is used in example 23.\n\
7821plgfont(p_family, p_style, p_weight)\n\
7825 p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7826 font family. The available values are given by the PL_FCI_*\n\
7827 constants in plplot.h. Current options are PL_FCI_SANS,\n\
7828 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
7829 p_family is NULL then the font family is not returned.\n\
7831 p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7832 font style. The available values are given by the PL_FCI_*\n\
7833 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
7834 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
7835 style is not returned.\n\
7837 p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7838 font weight. The available values are given by the PL_FCI_*\n\
7839 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
7840 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
7844Plot a histogram from unbinned data\n\
7848 Plots a histogram from n data points stored in the data vector. This\n\
7849 routine bins the data into nbin bins equally spaced between datmin and\n\
7850 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7851 opt allows, among other things, the histogram either to be plotted in\n\
7852 an existing window or causes plhist to call plenv with suitable limits\n\
7853 before plotting the histogram.\n\
7855 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7857 This function is used in example 5.\n\
7863plhist(n, data, datmin, datmax, nbin, opt)\n\
7867 n (PLINT, input) : Number of data points.\n\
7869 data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7872 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7874 datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7876 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7877 divide the interval xmin to xmax.\n\
7879 opt (PLINT, input) : Is a combination of several flags:\n\
7880 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7881 the histogram data, the outer bins are expanded to fill up the\n\
7882 entire x-axis, data outside the given extremes are assigned to the\n\
7883 outer bins and bins of zero height are simply drawn.\n\
7884 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7885 to fit the histogram data, without this flag, plenv is called\n\
7886 to set the world coordinates.\n\
7887 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7888 extremes are not taken into account. This option should\n\
7889 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7890 properly present the data.\n\
7891 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7892 size as the ones inside.\n\
7893 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7894 (there is a gap for such bins).\n\
7897Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
7901 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
7902 alpha transparency value.\n\
7904 This function is used in example 31.\n\
7910plgcolbga(r, g, b, alpha)\n\
7914 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
7915 in the range from 0 to 255.\n\
7917 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
7918 in the range from 0 to 255.\n\
7920 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
7921 in the range from 0 to 255.\n\
7923 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
7924 transparency in the range (0.0-1.0).\n\
7931 Set integer plot orientation parameter. This function is identical to\n\
7932 plsdiori except for the type of the argument, and should be used in\n\
7933 the same way. See the documentation of plsdiori for details.\n\
7935 Redacted form: plsori(ori)\n\
7937 This function is used in example 3.\n\
7947 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
7948 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
7952Plot latitude and longitude lines\n\
7956 Displays latitude and longitude on the current plot. The lines are\n\
7957 plotted in the current color and line style.\n\
7959 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
7962 This function is used in example 19.\n\
7968plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
7972 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7973 transform the coordinate longitudes and latitudes to a plot\n\
7974 coordinate system. By using this transform, we can change from a\n\
7975 longitude, latitude coordinate to a polar stereographic project,\n\
7976 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7977 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7978 mapform(), x[] and y[] should be replaced by the corresponding\n\
7979 plot coordinates. If no transform is desired, mapform can be\n\
7980 replaced by NULL.\n\
7982 dlong (PLFLT, input) : The interval in degrees at which the\n\
7983 longitude lines are to be plotted.\n\
7985 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
7986 lines are to be plotted.\n\
7988 minlong (PLFLT, input) : The value of the longitude on the left\n\
7989 side of the plot. The value of minlong must be less than the value\n\
7990 of maxlong, and the quantity maxlong-minlong must be less than or\n\
7993 maxlong (PLFLT, input) : The value of the longitude on the right\n\
7994 side of the plot.\n\
7996 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
7997 background. One can always use -90.0 as the boundary outside the\n\
7998 plot window will be automatically eliminated. However, the\n\
7999 program will be faster if one can reduce the size of the\n\
8000 background plotted.\n\
8002 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
8003 background. One can always use 90.0 as the boundary outside the\n\
8004 plot window will be automatically eliminated.\n\
8007Clear current (sub)page\n\
8011 Clears the current page, effectively erasing everything that have been\n\
8012 drawn. This command only works with interactive drivers; if the\n\
8013 driver does not support this, the page is filled with the background\n\
8014 color in use. If the current page is divided into subpages, only the\n\
8015 current subpage is erased. The nth subpage can be selected with\n\
8018 Redacted form: General: plclear()\n\
8021 This function is not used in any examples.\n\
8034 Initializing the plotting package. The program prompts for the device\n\
8035 keyword or number of the desired output device. Hitting a RETURN in\n\
8036 response to the prompt is the same as selecting the first device. If\n\
8037 only one device is enabled when PLplot is installed, plstar will issue\n\
8038 no prompt. The output device is divided into nx by ny subpages, each\n\
8039 of which may be used independently. The subroutine pladv is used to\n\
8040 advance from one subpage to the next.\n\
8042 Redacted form: plstar(nx, ny)\n\
8044 This function is used in example 1.\n\
8054 nx (PLINT, input) : Number of subpages to divide output page in the\n\
8057 ny (PLINT, input) : Number of subpages to divide output page in the\n\
8061Write text relative to viewport boundaries\n\
8065 Writes text at a specified position relative to the viewport\n\
8066 boundaries. Text may be written inside or outside the viewport, but\n\
8067 is clipped at the subpage boundaries. The reference point of a string\n\
8068 lies along a line passing through the string at half the height of a\n\
8069 capital letter. The position of the reference point along this line\n\
8070 is determined by just, and the position of the reference point\n\
8071 relative to the viewport is set by disp and pos.\n\
8073 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
8076 This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
8083plmtex(side, disp, pos, just, text)\n\
8087 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8088 the side of the viewport along which the text is to be written.\n\
8089 The string must be one of: b: Bottom of viewport, text written\n\
8090 parallel to edge.\n\
8091 bv: Bottom of viewport, text written at right angles to edge.\n\
8092 l: Left of viewport, text written parallel to edge.\n\
8093 lv: Left of viewport, text written at right angles to edge.\n\
8094 r: Right of viewport, text written parallel to edge.\n\
8095 rv: Right of viewport, text written at right angles to edge.\n\
8096 t: Top of viewport, text written parallel to edge.\n\
8097 tv: Top of viewport, text written at right angles to edge.\n\
8100 disp (PLFLT, input) : Position of the reference point of string,\n\
8101 measured outwards from the specified viewport edge in units of the\n\
8102 current character height. Use negative disp to write within the\n\
8105 pos (PLFLT, input) : Position of the reference point of string\n\
8106 along the specified edge, expressed as a fraction of the length of\n\
8109 just (PLFLT, input) : Specifies the position of the string relative\n\
8110 to its reference point. If just=0. , the reference point is at\n\
8111 the left and if just=1. , it is at the right of the string. Other\n\
8112 values of just give intermediate justifications.\n\
8114 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
8118Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
8122 Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
8123 PLFLT alpha transparency value (see the PLplot documentation).\n\
8125 This function is used in example 31.\n\
8131plscolbga(r, g, b, alpha)\n\
8135 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8136 degree of red in the color.\n\
8138 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8139 degree of green in the color.\n\
8141 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8142 degree of blue in the color.\n\
8144 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
8148Replays contents of plot buffer to current device/file\n\
8152 Replays contents of plot buffer to current device/file.\n\
8154 Redacted form: plreplot()\n\
8156 This function is used in example 1,20.\n\
8165Plot a glyph at the specified 3D points\n\
8169 Plot a glyph at the specified 3D points. (This function is largely\n\
8170 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
8171 Set up the call to this function similar to what is done for plline3.\n\
8172 code=-1 means try to just draw a point. Right now it\'s just a move\n\
8173 and a draw at the same place. Not ideal, since a sufficiently\n\
8174 intelligent output device may optimize it away, or there may be faster\n\
8175 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
8176 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
8177 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
8178 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
8179 code <= 127 the corresponding printable ASCII character is plotted.\n\
8181 Redacted form: plpoin3(x, y, z, code)\n\
8183 This function is not used in any example.\n\
8189plpoin3(n, x, y, z, code)\n\
8193 n (PLINT, input) : Number of points in the x and y vectors.\n\
8195 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8198 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8201 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
8204 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
8205 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
8206 each of the n points.\n\
8209Set family, style and weight of the current font\n\
8213 Sets the current font. See the PLplot documentation for more\n\
8214 information on font selection.\n\
8216 Redacted form: plsfont(family, style, weight)\n\
8218 This function is used in example 23.\n\
8224plsfont(family, style, weight)\n\
8228 family (PLINT, input) : Font family to select for the current font.\n\
8229 The available values are given by the PL_FCI_* constants in\n\
8230 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
8231 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
8232 signifies that the font family should not be altered.\n\
8234 style (PLINT, input) : Font style to select for the current font.\n\
8235 The available values are given by the PL_FCI_* constants in\n\
8236 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
8237 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
8238 should not be altered.\n\
8240 weight (PLINT, input) : Font weight to select for the current font.\n\
8241 The available values are given by the PL_FCI_* constants in\n\
8242 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
8243 negative value signifies that the font weight should not be\n\
8247Draw a box with axes, etc. with arbitrary origin\n\
8251 Draws a box around the currently defined viewport with arbitrary\n\
8252 world-coordinate origin specified by x0 and y0 and labels it with\n\
8253 world coordinate values appropriate to the window. Thus plaxes should\n\
8254 only be called after defining both viewport and window. The ascii\n\
8255 character strings xopt and yopt specify how the box should be drawn as\n\
8256 described below. If ticks and/or subticks are to be drawn for a\n\
8257 particular axis, the tick intervals and number of subintervals may be\n\
8258 specified explicitly, or they may be defaulted by setting the\n\
8259 appropriate arguments to zero.\n\
8261 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
8265 This function is not used in any examples.\n\
8271plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8275 x0 (PLFLT, input) : World X coordinate of origin.\n\
8277 y0 (PLFLT, input) : World Y coordinate of origin.\n\
8279 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8280 options for the x axis. The string can include any combination of\n\
8281 the following letters (upper or lower case) in any order: a: Draws\n\
8282 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8284 b: Draws bottom (X) or left (Y) edge of frame.\n\
8285 c: Draws top (X) or right (Y) edge of frame.\n\
8286 d: Plot labels as date / time. Values are assumed to be\n\
8287 seconds since the epoch (as used by gmtime).\n\
8288 f: Always use fixed point numeric labels.\n\
8289 g: Draws a grid at the major tick interval.\n\
8290 h: Draws a grid at the minor tick interval.\n\
8291 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8293 l: Labels axis logarithmically. This only affects the labels,\n\
8294 not the data, and so it is necessary to compute the logarithms\n\
8295 of data points before passing them to any of the drawing\n\
8297 m: Writes numeric labels at major tick intervals in the\n\
8298 unconventional location (above box for X, right of box for Y).\n\
8299 n: Writes numeric labels at major tick intervals in the\n\
8300 conventional location (below box for X, left of box for Y).\n\
8301 o: Use custom labelling function to generate axis label text.\n\
8302 The custom labelling function can be defined with the\n\
8303 plslabelfunc command.\n\
8304 s: Enables subticks between major ticks, only valid if t is\n\
8306 t: Draws major ticks.\n\
8307 u: Exactly like \"b\" except don\'t draw edge line.\n\
8308 w: Exactly like \"c\" except don\'t draw edge line.\n\
8309 x: Exactly like \"t\" (including the side effect of the\n\
8310 numerical labels for the major ticks) except exclude drawing\n\
8311 the major and minor tick marks.\n\
8314 xtick (PLFLT, input) : World coordinate interval between major\n\
8315 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8316 generates a suitable tick interval.\n\
8318 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8319 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8320 generates a suitable minor tick interval.\n\
8322 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8323 options for the y axis. The string can include any combination of\n\
8324 the letters defined above for xopt, and in addition may contain:\n\
8325 v: Write numeric labels for the y axis parallel to the base of the\n\
8326 graph, rather than parallel to the axis.\n\
8329 ytick (PLFLT, input) : World coordinate interval between major\n\
8330 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8331 generates a suitable tick interval.\n\
8333 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8334 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8335 generates a suitable minor tick interval.\n\
8342 Begins a new page. For a file driver, the output file is opened if\n\
8343 necessary. Advancing the page via pleop and plbop is useful when a\n\
8344 page break is desired at a particular point when plotting to subpages.\n\
8345 Another use for pleop and plbop is when plotting pages to different\n\
8346 files, since you can manually set the file name by calling plsfnam\n\
8347 after the call to pleop. (In fact some drivers may only support a\n\
8348 single page per file, making this a necessity.) One way to handle\n\
8349 this case automatically is to page advance via pladv, but enable\n\
8350 familying (see plsfam) with a small limit on the file size so that a\n\
8351 new family member file will be created on each page break.\n\
8353 Redacted form: plbop()\n\
8355 This function is used in examples 2 and 20.\n\
8364Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
8368 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
8369 and PLFLT alpha transparency value. This sets the entire color map --\n\
8370 only as many colors as specified will be allocated.\n\
8372 Redacted form: plscmap0a(r, g, b, alpha)\n\
8374 This function is used in examples 30.\n\
8380plscmap0a(r, g, b, alpha, ncol0)\n\
8384 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8385 integers (0-255) representing the degree of red in the color.\n\
8387 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8388 integers (0-255) representing the degree of green in the color.\n\
8390 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8391 integers (0-255) representing the degree of blue in the color.\n\
8393 alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
8394 representing the alpha transparency of the color.\n\
8396 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
8400Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
8404 This is a variant of plscmap1l that supports alpha channel\n\
8405 transparency. It sets cmap1 colors using a piece-wise linear\n\
8406 relationship between cmap1 intensity index (0.0-1.0) and position in\n\
8407 HLS or RGB color space (see the PLplot documentation) with alpha\n\
8408 transparency value (0.0-1.0). It may be called at any time.\n\
8410 Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
8411 alpha, alt_hue_path)\n\
8413 This function is used in example 30.\n\
8419plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
8423 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
8425 npts (PLINT, input) : number of control points.\n\
8427 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
8428 intensity index (0.0-1.0) in ascending order for each control\n\
8431 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
8432 coordinate (H or R) for each control point.\n\
8434 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
8435 coordinate (L or G) for each control point.\n\
8437 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
8438 coordinate (S or B) for each control point.\n\
8440 alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
8441 transparency value (0.0-1.0) for each control point.\n\
8443 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
8444 npts - 1 elements) containing the alternative interpolation method\n\
8445 Boolean value for each control point interval. (alt_hue_path[i]\n\
8446 refers to the interpolation interval between the i and i + 1\n\
8450Enter or leave xor mode\n\
8454 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
8455 those drivers (e.g., the xwin driver) that support it. Enables\n\
8456 erasing plots by drawing twice the same line, symbol, etc. If driver\n\
8457 is not capable of xor operation it returns a status of false.\n\
8459 Redacted form: plxormod(mode, status)\n\
8461 This function is used in examples 1 and 20.\n\
8467plxormod(mode, status)\n\
8471 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
8472 is false means leave xor mode.\n\
8474 status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
8475 modestatus of true (false) means driver is capable (incapable) of\n\
8479Eject current page\n\
8483 Clears the graphics screen of an interactive device, or ejects a page\n\
8484 on a plotter. See plbop for more information.\n\
8486 Redacted form: pleop()\n\
8488 This function is used in example 2,14.\n\
8497Draw a box with axes, etc\n\
8501 Draws a box around the currently defined viewport, and labels it with\n\
8502 world coordinate values appropriate to the window. Thus plbox should\n\
8503 only be called after defining both viewport and window. The ascii\n\
8504 character strings xopt and yopt specify how the box should be drawn as\n\
8505 described below. If ticks and/or subticks are to be drawn for a\n\
8506 particular axis, the tick intervals and number of subintervals may be\n\
8507 specified explicitly, or they may be defaulted by setting the\n\
8508 appropriate arguments to zero.\n\
8510 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8513 This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
8520plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8524 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8525 options for the x axis. The string can include any combination of\n\
8526 the following letters (upper or lower case) in any order: a: Draws\n\
8527 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8529 b: Draws bottom (X) or left (Y) edge of frame.\n\
8530 c: Draws top (X) or right (Y) edge of frame.\n\
8531 d: Plot labels as date / time. Values are assumed to be\n\
8532 seconds since the epoch (as used by gmtime).\n\
8533 f: Always use fixed point numeric labels.\n\
8534 g: Draws a grid at the major tick interval.\n\
8535 h: Draws a grid at the minor tick interval.\n\
8536 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8538 l: Labels axis logarithmically. This only affects the labels,\n\
8539 not the data, and so it is necessary to compute the logarithms\n\
8540 of data points before passing them to any of the drawing\n\
8542 m: Writes numeric labels at major tick intervals in the\n\
8543 unconventional location (above box for X, right of box for Y).\n\
8544 n: Writes numeric labels at major tick intervals in the\n\
8545 conventional location (below box for X, left of box for Y).\n\
8546 o: Use custom labelling function to generate axis label text.\n\
8547 The custom labelling function can be defined with the\n\
8548 plslabelfunc command.\n\
8549 s: Enables subticks between major ticks, only valid if t is\n\
8551 t: Draws major ticks.\n\
8552 u: Exactly like \"b\" except don\'t draw edge line.\n\
8553 w: Exactly like \"c\" except don\'t draw edge line.\n\
8554 x: Exactly like \"t\" (including the side effect of the\n\
8555 numerical labels for the major ticks) except exclude drawing\n\
8556 the major and minor tick marks.\n\
8559 xtick (PLFLT, input) : World coordinate interval between major\n\
8560 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8561 generates a suitable tick interval.\n\
8563 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8564 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8565 generates a suitable minor tick interval.\n\
8567 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8568 options for the y axis. The string can include any combination of\n\
8569 the letters defined above for xopt, and in addition may contain:\n\
8570 v: Write numeric labels for the y axis parallel to the base of the\n\
8571 graph, rather than parallel to the axis.\n\
8574 ytick (PLFLT, input) : World coordinate interval between major\n\
8575 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8576 generates a suitable tick interval.\n\
8578 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8579 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8580 generates a suitable minor tick interval.\n\
8583Get x axis parameters\n\
8587 Returns current values of the p_digmax and p_digits flags for the x\n\
8588 axis. p_digits is updated after the plot is drawn, so this routine\n\
8589 should only be called after the call to plbox (or plbox3) is complete.\n\
8590 See the PLplot documentation for more information.\n\
8592 Redacted form: plgxax(p_digmax, p_digits)\n\
8594 This function is used in example 31.\n\
8600plgxax(p_digmax, p_digits)\n\
8604 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
8605 number of digits for the x axis. If nonzero, the printed label\n\
8606 has been switched to a floating-point representation when the\n\
8607 number of digits exceeds this value.\n\
8609 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
8610 number of digits for the numeric labels (x axis) from the last\n\
8618 Sets the font used for subsequent text and symbols. For devices that\n\
8619 still use Hershey fonts this routine has no effect unless the Hershey\n\
8620 fonts with extended character set are loaded (see plfontld). For\n\
8621 unicode-aware devices that use system fonts instead of Hershey fonts,\n\
8622 this routine calls the plsfci routine with argument set up\n\
8623 appropriately for the various cases below. However, this method of\n\
8624 specifying the font for unicode-aware devices is deprecated, and the\n\
8625 much more flexible method of calling plsfont directly is recommended\n\
8626 instead (where plsfont provides a user-friendly interface to plsfci),\n\
8628 Redacted form: plfont(ifont)\n\
8630 This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
8640 ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
8641 (simplest and fastest)\n\
8647Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
8651 Routine for creating a discrete plot legend with a plotted filled box,\n\
8652 line, and/or line of symbols for each annotated legend entry. (See\n\
8653 plcolorbar for similar functionality for creating continuous color\n\
8654 bars.) The arguments of pllegend provide control over the location\n\
8655 and size of the legend as well as the location and characteristics of\n\
8656 the elements (most of which are optional) within that legend. The\n\
8657 resulting legend is clipped at the boundaries of the current subpage.\n\
8658 (N.B. the adopted coordinate system used for some of the parameters is\n\
8659 defined in the documentation of the position parameter.)\n\
8661 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
8662 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
8663 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
8664 test_justification, text_colors, text, box_colors, box_patterns,\n\
8665 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
8666 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
8668 This function is used in examples 4, 26, and 33.\n\
8674pllegend(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\
8678 p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8679 legend width in adopted coordinates. This quantity is calculated\n\
8680 from plot_width, text_offset, ncolumn (possibly modified inside\n\
8681 the routine depending on nlegend and nrow), and the length\n\
8682 (calculated internally) of the longest text string.\n\
8684 p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8685 legend height in adopted coordinates. This quantity is calculated\n\
8686 from text_scale, text_spacing, and nrow (possibly modified inside\n\
8687 the routine depending on nlegend and nrow).\n\
8689 opt (PLINT, input) : opt contains bits controlling the overall\n\
8690 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
8691 on the left of the legend and the plotted area on the right.\n\
8692 Otherwise, put the text area on the right of the legend and the\n\
8693 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
8694 plot a (semitransparent) background for the legend. If the\n\
8695 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8696 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
8697 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
8698 plot the resulting array of legend entries in row-major order.\n\
8699 Otherwise, plot the legend entries in column-major order.\n\
8701 position (PLINT, input) : position contains bits which control the\n\
8702 overall position of the legend and the definition of the adopted\n\
8703 coordinates used for positions just like what is done for the\n\
8704 position argument for plcolorbar. However, note that the defaults\n\
8705 for the position bits (see below) are different than the\n\
8706 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
8707 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8708 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8709 the 16 possible standard positions (the 4 corners and centers of\n\
8710 the 4 sides for both the inside and outside cases) of the legend\n\
8711 relative to the adopted coordinate system. The corner positions\n\
8712 are specified by the appropriate combination of two of the\n\
8713 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8714 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8715 value of one of those bits. The adopted coordinates are\n\
8716 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8717 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8718 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8719 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8720 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
8721 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
8722 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
8723 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
8725 x (PLFLT, input) : X offset of the legend position in adopted\n\
8726 coordinates from the specified standard position of the legend.\n\
8727 For positive x, the direction of motion away from the standard\n\
8728 position is inward/outward from the standard corner positions or\n\
8729 standard left or right positions if the\n\
8730 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8731 For the standard top or bottom positions, the direction of motion\n\
8732 is toward positive X.\n\
8734 y (PLFLT, input) : Y offset of the legend position in adopted\n\
8735 coordinates from the specified standard position of the legend.\n\
8736 For positive y, the direction of motion away from the standard\n\
8737 position is inward/outward from the standard corner positions or\n\
8738 standard top or bottom positions if the\n\
8739 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
8740 the standard left or right positions, the direction of motion is\n\
8741 toward positive Y.\n\
8743 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
8744 of the plot area (where the colored boxes, lines, and/or lines of\n\
8745 symbols are drawn) of the legend.\n\
8747 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8748 legend (PL_LEGEND_BACKGROUND).\n\
8750 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8751 for the legend (PL_LEGEND_BOUNDING_BOX).\n\
8753 bb_style (PLINT, input) : The pllsty style number for the\n\
8754 bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
8756 nrow (PLINT, input) : The number of rows in the matrix used to\n\
8758 nlegend legend entries. For internal transformations of\n\
8759 nrow, see further remarks under\n\
8762 ncolumn (PLINT, input) : The number of columns in the matrix used\n\
8764 nlegend legend entries. For internal transformations of\n\
8765 ncolumn, see further remarks under\n\
8768 nlegend (PLINT, input) : Number of legend entries. The above\n\
8770 ncolumn values are transformed internally to be consistent with\n\
8771 nlegend. If either\n\
8773 ncolumn is non-positive it is replaced by 1. If the resulting product\n\
8776 ncolumn is less than\n\
8777 nlegend, the smaller of the two (or\n\
8780 ncolumn) is increased so the product is >=\n\
8781 nlegend. Thus, for example, the common\n\
8783 ncolumn = 0 case is transformed internally to\n\
8786 ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
8789 opt_array (PLINT_VECTOR, input) : A vector of\n\
8790 nlegend values of options to control each individual plotted area\n\
8791 corresponding to a legend entry. If the\n\
8792 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
8794 PL_LEGEND_COLOR_BOX,\n\
8795 PL_LEGEND_LINE, and/or\n\
8796 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
8797 entry is plotted with a colored box; a line; and/or a line of\n\
8800 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
8801 area in units of character width.\n\
8803 text_scale (PLFLT, input) : Character height scale for text\n\
8806 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
8807 character height from one legend entry to the next.\n\
8809 text_justification (PLFLT, input) : Justification parameter used\n\
8810 for text justification. The most common values of\n\
8811 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
8812 is left justified, centred, or right justified within the text\n\
8813 area, but other values are allowed as well.\n\
8815 text_colors (PLINT_VECTOR, input) : A vector containing\n\
8816 nlegend cmap0 text colors.\n\
8818 text (PLCHAR_MATRIX, input) : A vector of\n\
8819 nlegend UTF-8 character strings containing the legend annotations.\n\
8821 box_colors (PLINT_VECTOR, input) : A vector containing\n\
8822 nlegend cmap0 colors for the discrete colored boxes (\n\
8823 PL_LEGEND_COLOR_BOX).\n\
8825 box_patterns (PLINT_VECTOR, input) : A vector containing\n\
8826 nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
8827 PL_LEGEND_COLOR_BOX).\n\
8829 box_scales (PLFLT_VECTOR, input) : A vector containing\n\
8830 nlegend scales (units of fraction of character height) for the height\n\
8831 of the discrete colored boxes (\n\
8832 PL_LEGEND_COLOR_BOX).\n\
8834 box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8835 nlegend line widths for the patterns specified by box_patterns (\n\
8836 PL_LEGEND_COLOR_BOX).\n\
8838 line_colors (PLINT_VECTOR, input) : A vector containing\n\
8839 nlegend cmap0 line colors (\n\
8842 line_styles (PLINT_VECTOR, input) : A vector containing\n\
8843 nlegend line styles (plsty indices) (\n\
8846 line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8847 nlegend line widths (\n\
8850 symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
8851 nlegend cmap0 symbol colors (\n\
8852 PL_LEGEND_SYMBOL).\n\
8854 symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
8855 nlegend scale values for the symbol height (\n\
8856 PL_LEGEND_SYMBOL).\n\
8858 symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
8859 nlegend numbers of symbols to be drawn across the width of the plotted\n\
8861 PL_LEGEND_SYMBOL).\n\
8863 symbols (PLCHAR_MATRIX, input) : A vector of\n\
8864 nlegend UTF-8 character strings containing the legend symbols. (\n\
8865 PL_LEGEND_SYMBOL).\n\
8868Set the background color by 8-bit RGB value\n\
8872 Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
8873 the PLplot documentation).\n\
8875 Redacted form: plscolbg(r, g, b)\n\
8877 This function is used in examples 15 and 31.\n\
8887 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8888 degree of red in the color.\n\
8890 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8891 degree of green in the color.\n\
8893 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8894 degree of blue in the color.\n\
8897Set parameters that define current device-space window\n\
8901 Set relative margin width, aspect ratio, and relative justification\n\
8902 that define current device-space window. If you want to just use the\n\
8903 previous value for any of these, just pass in the magic value\n\
8904 PL_NOTSET. It is unlikely that one should ever need to change the\n\
8905 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
8906 called the default values of mar, jx, and jy are all 0. aspect is set\n\
8907 to a device-specific value.\n\
8909 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
8911 This function is used in example 31.\n\
8917plsdidev(mar, aspect, jx, jy)\n\
8921 mar (PLFLT, input) : Relative margin width.\n\
8923 aspect (PLFLT, input) : Aspect ratio.\n\
8925 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
8926 the range -0.5 to 0.5.\n\
8928 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
8929 the range -0.5 to 0.5.\n\
8932Specify viewport using aspect ratio only\n\
8936 Selects the largest viewport with the given aspect ratio within the\n\
8937 subpage that leaves a standard margin (left-hand margin of eight\n\
8938 character heights, and a margin around the other three sides of five\n\
8939 character heights).\n\
8941 Redacted form: plvasp(aspect)\n\
8943 This function is used in example 13.\n\
8953 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
8954 axis of resulting viewport.\n\
8957Configure the transformations required for projecting a 3D surface on a 2D window\n\
8961 Configure the transformations required for projecting a 3D surface on\n\
8962 an existing 2D window. Those transformations (see the PLplot\n\
8963 documentation) are done to a rectangular cuboid enclosing the 3D\n\
8964 surface which has its limits expressed in 3D world coordinates and\n\
8965 also normalized 3D coordinates (used for interpreting the altitude and\n\
8966 azimuth of the viewing angle). The transformations consist of the\n\
8967 linear transform from 3D world coordinates to normalized 3D\n\
8968 coordinates, and the 3D rotation of normalized coordinates required to\n\
8969 align the pole of the new 3D coordinate system with the viewing\n\
8970 direction specified by altitude and azimuth so that x and y of the\n\
8971 surface elements in that transformed coordinate system are the\n\
8972 projection of the 3D surface with given viewing direction on the 2D\n\
8975 The enclosing rectangular cuboid for the surface plot is defined by\n\
8976 xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
8977 mapped into the same rectangular cuboid with normalized 3D coordinate\n\
8978 sizes of basex by basey by height so that xmin maps to -\n\
8979 basex/2, xmax maps to basex/2, ymin maps to -\n\
8980 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
8981 The resulting rectangular cuboid in normalized coordinates is then\n\
8982 viewed by an observer at altitude alt and azimuth az. This routine\n\
8983 must be called before plbox3 or any of the 3D surface plotting\n\
8984 routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
8985 plsurf3dl or plfill3.\n\
8987 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
8988 zmin, zmax, alt, az)\n\
8990 This function is examples 8, 11, 18, and 21.\n\
8996plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
9000 basex (PLFLT, input) : The normalized x coordinate size of the\n\
9001 rectangular cuboid.\n\
9003 basey (PLFLT, input) : The normalized y coordinate size of the\n\
9004 rectangular cuboid.\n\
9006 height (PLFLT, input) : The normalized z coordinate size of the\n\
9007 rectangular cuboid.\n\
9009 xmin (PLFLT, input) : The minimum x world coordinate of the\n\
9010 rectangular cuboid.\n\
9012 xmax (PLFLT, input) : The maximum x world coordinate of the\n\
9013 rectangular cuboid.\n\
9015 ymin (PLFLT, input) : The minimum y world coordinate of the\n\
9016 rectangular cuboid.\n\
9018 ymax (PLFLT, input) : The maximum y world coordinate of the\n\
9019 rectangular cuboid.\n\
9021 zmin (PLFLT, input) : The minimum z world coordinate of the\n\
9022 rectangular cuboid.\n\
9024 zmax (PLFLT, input) : The maximum z world coordinate of the\n\
9025 rectangular cuboid.\n\
9027 alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
9028 plane of the rectangular cuboid in normalized coordinates.\n\
9030 az (PLFLT, input) : The viewing azimuth in degrees of the\n\
9031 rectangular cuboid in normalized coordinates. When az=0, the\n\
9032 observer is looking face onto the zx plane of the rectangular\n\
9033 cuboid in normalized coordinates, and as az is increased, the\n\
9034 observer moves clockwise around that cuboid when viewed from above\n\
9038Wait for graphics input event and translate to world coordinates.\n\
9042 Wait for graphics input event and translate to world coordinates.\n\
9043 Returns 0 if no translation to world coordinates is possible.\n\
9045 This function returns 1 on success and 0 if no translation to world\n\
9046 coordinates is possible.\n\
9048 Redacted form: plGetCursor(gin)\n\
9050 This function is used in examples 1 and 20.\n\
9056PLINT plGetCursor(gin)\n\
9060 gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
9061 which will contain the output. The structure is not allocated by\n\
9062 the routine and must exist before the function is called.\n\
9065Set number of colors in cmap0\n\
9069 Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9070 (or reallocate) cmap0, and fill with default values for those colors\n\
9071 not previously allocated. The first 16 default colors are given in\n\
9072 the plcol0 documentation. For larger indices the default color is\n\
9075 The drivers are not guaranteed to support more than 16 colors.\n\
9077 Redacted form: plscmap0n(ncol0)\n\
9079 This function is used in examples 15, 16, and 24.\n\
9089 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9090 the cmap0 palette. If this number is zero or less, then the value\n\
9091 from the previous call to plscmap0n is used and if there is no\n\
9092 previous call, then a default value is used.\n\
9095Set z axis parameters\n\
9099 Identical to plsxax, except that arguments are flags for z axis. See\n\
9100 the description of plsxax for more detail.\n\
9102 Redacted form: plszax(digmax, digits)\n\
9104 This function is used in example 31.\n\
9110plszax(digmax, digits)\n\
9114 digmax (PLINT, input) : Variable to set the maximum number of\n\
9115 digits for the z axis. If nonzero, the printed label will be\n\
9116 switched to a floating-point representation when the number of\n\
9117 digits exceeds digmax.\n\
9119 digits (PLINT, input) : Field digits value. Currently, changing\n\
9120 its value here has no effect since it is set only by plbox or\n\
9121 plbox3. However, the user may obtain its value after a call to\n\
9122 either of these functions by calling plgzax.\n\
9125Get FCI (font characterization integer)\n\
9129 Gets information about the current font using the FCI approach. See\n\
9130 the PLplot documentation for more information.\n\
9132 Redacted form: plgfci(p_fci)\n\
9134 This function is used in example 23.\n\
9144 p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
9148Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
9152 Sets up plotter environment for simple graphs by calling pladv and\n\
9153 setting up viewport and window to sensible default values. plenv0\n\
9154 leaves a standard margin (left-hand margin of eight character heights,\n\
9155 and a margin around the other three sides of five character heights)\n\
9156 around most graphs for axis labels and a title. When these defaults\n\
9157 are not suitable, use the individual routines plvpas, plvpor, or\n\
9158 plvasp for setting up the viewport, plwind for defining the window,\n\
9159 and plbox for drawing the box.\n\
9161 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9163 This function is used in example 21.\n\
9169plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9173 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
9174 world coordinates).\n\
9176 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
9177 world coordinates).\n\
9179 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
9182 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
9185 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
9186 scales will not be set, the user must set up the scale before\n\
9187 calling plenv0 using plsvpa, plvasp or other.\n\
9188 0: the x and y axes are scaled independently to use as much of\n\
9189 the screen as possible.\n\
9190 1: the scales of the x and y axes are made equal.\n\
9191 2: the axis of the x and y axes are made equal, and the plot\n\
9192 box will be square.\n\
9195 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
9196 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
9197 -1: draw box only.\n\
9198 0: draw box, ticks, and numeric tick labels.\n\
9199 1: also draw coordinate axes at x=0 and y=0.\n\
9200 2: also draw a grid at major tick positions in both\n\
9202 3: also draw a grid at minor tick positions in both\n\
9204 10: same as 0 except logarithmic x tick marks. (The x data\n\
9205 have to be converted to logarithms separately.)\n\
9206 11: same as 1 except logarithmic x tick marks. (The x data\n\
9207 have to be converted to logarithms separately.)\n\
9208 12: same as 2 except logarithmic x tick marks. (The x data\n\
9209 have to be converted to logarithms separately.)\n\
9210 13: same as 3 except logarithmic x tick marks. (The x data\n\
9211 have to be converted to logarithms separately.)\n\
9212 20: same as 0 except logarithmic y tick marks. (The y data\n\
9213 have to be converted to logarithms separately.)\n\
9214 21: same as 1 except logarithmic y tick marks. (The y data\n\
9215 have to be converted to logarithms separately.)\n\
9216 22: same as 2 except logarithmic y tick marks. (The y data\n\
9217 have to be converted to logarithms separately.)\n\
9218 23: same as 3 except logarithmic y tick marks. (The y data\n\
9219 have to be converted to logarithms separately.)\n\
9220 30: same as 0 except logarithmic x and y tick marks. (The x\n\
9221 and y data have to be converted to logarithms separately.)\n\
9222 31: same as 1 except logarithmic x and y tick marks. (The x\n\
9223 and y data have to be converted to logarithms separately.)\n\
9224 32: same as 2 except logarithmic x and y tick marks. (The x\n\
9225 and y data have to be converted to logarithms separately.)\n\
9226 33: same as 3 except logarithmic x and y tick marks. (The x\n\
9227 and y data have to be converted to logarithms separately.)\n\
9228 40: same as 0 except date / time x labels.\n\
9229 41: same as 1 except date / time x labels.\n\
9230 42: same as 2 except date / time x labels.\n\
9231 43: same as 3 except date / time x labels.\n\
9232 50: same as 0 except date / time y labels.\n\
9233 51: same as 1 except date / time y labels.\n\
9234 52: same as 2 except date / time y labels.\n\
9235 53: same as 3 except date / time y labels.\n\
9236 60: same as 0 except date / time x and y labels.\n\
9237 61: same as 1 except date / time x and y labels.\n\
9238 62: same as 2 except date / time x and y labels.\n\
9239 63: same as 3 except date / time x and y labels.\n\
9240 70: same as 0 except custom x and y labels.\n\
9241 71: same as 1 except custom x and y labels.\n\
9242 72: same as 2 except custom x and y labels.\n\
9243 73: same as 3 except custom x and y labels.\n\
9250 This sets up the size of all subsequent symbols drawn by plpoin and\n\
9251 plsym. The actual height of a symbol is the product of the default\n\
9252 symbol size and a scaling factor as for the character height.\n\
9254 Redacted form: plssym(def, scale)\n\
9256 This function is used in example 29.\n\
9262plssym(def, scale)\n\
9266 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
9267 should be set to zero if the default height is to remain\n\
9270 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9271 actual symbol height.\n\
9274Set plot orientation\n\
9278 Set plot orientation parameter which is multiplied by 90 degrees to\n\
9279 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
9280 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
9281 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
9282 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
9283 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
9284 not called the default value of rot is 0.\n\
9286 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
9287 probably want to change the aspect ratio to a value suitable for the\n\
9288 plot orientation using a call to plsdidev or the command-line options\n\
9289 -a or -freeaspect. For more documentation of those options see the\n\
9290 PLplot documentation. Such command-line options can be set internally\n\
9291 using plsetopt or set directly using the command line and parsed using\n\
9292 a call to plparseopts.\n\
9294 Redacted form: plsdiori(rot)\n\
9296 This function is not used in any examples.\n\
9306 rot (PLFLT, input) : Plot orientation parameter.\n\
9309Advance the (sub-)page\n\
9313 Advances to the next subpage if sub=0, performing a page advance if\n\
9314 there are no remaining subpages on the current page. If subpages\n\
9315 aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
9316 PLplot switches to the specified subpage. Note that this allows you\n\
9317 to overwrite a plot on the specified subpage; if this is not what you\n\
9318 intended, use pleop followed by plbop to first advance the page. This\n\
9319 routine is called automatically (with page=0) by plenv, but if plenv\n\
9320 is not used, pladv must be called after initializing PLplot but before\n\
9321 defining the viewport.\n\
9323 Redacted form: pladv(page)\n\
9325 This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
9336 page (PLINT, input) : Specifies the subpage number (starting from 1\n\
9337 in the top left corner and increasing along the rows) to which to\n\
9338 advance. Set to zero to advance to the next subpage (or to the\n\
9339 next page if subpages are not being used).\n\
9342Set cmap0 colors by 8-bit RGB values\n\
9346 Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
9347 documentation). This sets the entire color map -- only as many colors\n\
9348 as specified will be allocated.\n\
9350 Redacted form: plscmap0(r, g, b)\n\
9352 This function is used in examples 2 and 24.\n\
9358plscmap0(r, g, b, ncol0)\n\
9362 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9363 integers (0-255) representing the degree of red in the color.\n\
9365 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9366 integers (0-255) representing the degree of green in the color.\n\
9368 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9369 integers (0-255) representing the degree of blue in the color.\n\
9371 ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9374Get character default height and current (scaled) height\n\
9378 Get character default height and current (scaled) height.\n\
9380 Redacted form: plgchr(p_def, p_ht)\n\
9382 This function is used in example 23.\n\
9388plgchr(p_def, p_ht)\n\
9392 p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
9393 character height (mm).\n\
9395 p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
9396 character height (mm).\n\
9399Set opaque RGB cmap1 colors values\n\
9403 Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
9404 vector values. This function also sets the number of cmap1 colors.\n\
9405 N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
9406 in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
9407 plcol1) to an integer index of these RGB vectors in the range from 0\n\
9409 ncol1-1. So in order for this continuous color model to work\n\
9410 properly, it is the responsibility of the user of plscmap1 to insure\n\
9411 that these RGB vectors are continuous functions of their integer\n\
9414 Redacted form: plscmap1(r, g, b)\n\
9416 This function is used in example 31.\n\
9422plscmap1(r, g, b, ncol1)\n\
9426 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9427 8-bit integers in the range from 0-255) the degree of red in the\n\
9428 color as a continuous function of the integer index of the vector.\n\
9430 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9431 8-bit integers in the range from 0-255) the degree of green in the\n\
9432 color as a continuous function of the integer index of the vector.\n\
9434 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9435 8-bit integers in the range from 0-255) the degree of blue in the\n\
9436 color as a continuous function of the integer index of the vector.\n\
9438 ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9441Set any command-line option\n\
9445 Set any command-line option internally from a program before it\n\
9446 invokes plinit. opt is the name of the command-line option and optarg\n\
9447 is the corresponding command-line option argument.\n\
9449 This function returns 0 on success.\n\
9451 Redacted form: plsetopt(opt, optarg)\n\
9453 This function is used in example 14.\n\
9459PLINT plsetopt(opt, optarg)\n\
9463 opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9464 the command-line option.\n\
9466 optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
9467 containing the argument of the command-line option.\n\
9470Draw linear gradient inside polygon\n\
9474 Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
9477 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
9478 polygon coordinates and the gradient angle are all expressed in world\n\
9479 coordinates. The angle from the x axis for both the rotated\n\
9480 coordinate system and the gradient vector is specified by angle. The\n\
9481 magnitude of the gradient vector is the difference between the maximum\n\
9482 and minimum values of x for the vertices in the rotated coordinate\n\
9483 system. The origin of the gradient vector can be interpreted as being\n\
9484 anywhere on the line corresponding to the minimum x value for the\n\
9485 vertices in the rotated coordinate system. The distance along the\n\
9486 gradient vector is linearly transformed to the independent variable of\n\
9487 color map 1 which ranges from 0. at the tail of the gradient vector to\n\
9488 1. at the head of the gradient vector. What is drawn is the RGBA\n\
9489 color corresponding to the independent variable of cmap1. For more\n\
9490 information about cmap1 (see the PLplot documentation).\n\
9492 Redacted form: plgradient(x,y,angle)\n\
9494 This function is used in examples 25 and 30.\n\
9500plgradient(n, x, y, angle)\n\
9504 n (PLINT, input) : Number of vertices in polygon.\n\
9506 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9509 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9512 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
9516Set length of major ticks\n\
9520 This sets up the length of the major ticks. The actual length is the\n\
9521 product of the default length and a scaling factor as for character\n\
9524 Redacted form: plsmaj(def, scale)\n\
9526 This function is used in example 29.\n\
9532plsmaj(def, scale)\n\
9536 def (PLFLT, input) : The default length of a major tick in\n\
9537 millimeters, should be set to zero if the default length is to\n\
9538 remain unchanged.\n\
9540 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9541 actual tick length.\n\
9544Set a global coordinate transform function\n\
9548 This function can be used to define a coordinate transformation which\n\
9549 affects all elements drawn within the current plot window. The\n\
9550 coordinate_transform callback function is similar to that provided for\n\
9551 the plmap and plmeridians functions. The coordinate_transform_data\n\
9552 parameter may be used to pass extra data to coordinate_transform.\n\
9554 Redacted form: General: plstransform(coordinate_transform,\n\
9555 coordinate_transform_data)\n\
9558 This function is used in examples 19 and 22.\n\
9564plstransform(coordinate_transform, coordinate_transform_data)\n\
9568 coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
9569 function that defines the transformation from the input (x, y)\n\
9570 world coordinates to new PLplot world coordinates. If\n\
9571 coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
9572 case), then no transform is applied.\n\
9574 coordinate_transform_data (PLPointer, input) : Optional extra data\n\
9576 coordinate_transform.\n\
9579Configure the transformation between continuous and broken-down time for the current stream\n\
9583 Configure the transformation between continuous and broken-down time\n\
9584 for the current stream. This transformation is used by both plbtime\n\
9587 Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
9588 ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9591 This function is used in example 29.\n\
9597plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9601 scale (PLFLT, input) : The number of days per continuous time unit.\n\
9602 As a special case, if\n\
9603 scale is 0., then all other arguments are ignored, and the result (the\n\
9604 default used by PLplot) is the equivalent of a call to\n\
9605 plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
9606 That is, for this special case broken-down time is calculated with\n\
9607 the proleptic Gregorian calendar with no leap seconds inserted,\n\
9608 and the continuous time is defined as the number of seconds since\n\
9609 the Unix epoch of 1970-01-01T00:00:00Z.\n\
9611 offset1 (PLFLT, input) : If\n\
9612 ifbtime_offset is true, the parameters\n\
9614 offset2 are completely ignored. Otherwise, the sum of these parameters\n\
9615 (with units in days) specify the epoch of the continuous time\n\
9616 relative to the MJD epoch corresponding to the Gregorian calendar\n\
9617 date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
9618 are used to specify the origin to allow users (by specifying\n\
9619 offset1 as an integer that can be exactly represented by a\n\
9620 floating-point variable and specifying\n\
9621 offset2 as a number in the range from 0. to 1) the chance to minimize\n\
9622 the numerical errors of the continuous time representation.\n\
9624 offset2 (PLFLT, input) : See documentation of\n\
9627 ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
9628 transformation. If the 0x1 bit is set, then the proleptic Julian\n\
9629 calendar is used for broken-down time rather than the proleptic\n\
9630 Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
9631 have been historically used to define UTC are inserted into the\n\
9632 broken-down time. Other possibilities for additional control bits\n\
9633 for ccontrol exist such as making the historical time corrections\n\
9634 in the broken-down time corresponding to ET (ephemeris time) or\n\
9635 making the (slightly non-constant) corrections from international\n\
9636 atomic time (TAI) to what astronomers define as terrestrial time\n\
9637 (TT). But those additional possibilities have not been\n\
9638 implemented yet in the qsastime library (one of the PLplot utility\n\
9641 ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
9642 epoch of the continuous time scale is specified by the user. If\n\
9643 ifbtime_offset is false, then\n\
9645 offset2 are used to specify the epoch, and the following broken-down\n\
9646 time parameters are completely ignored. If\n\
9647 ifbtime_offset is true, then\n\
9649 offset2 are completely ignored, and the following broken-down time\n\
9650 parameters are used to specify the epoch.\n\
9652 year (PLINT, input) : Year of epoch.\n\
9654 month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
9657 day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
9659 hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
9661 min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
9663 sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
9666Flushes the output stream\n\
9670 Flushes the output stream. Use sparingly, if at all.\n\
9672 Redacted form: plflush()\n\
9674 This function is used in examples 1 and 14.\n\
9683Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
9687 This variant of plsurf3d (see that function\'s documentation for more\n\
9688 details) should be suitable for the case where the area of the x, y\n\
9689 coordinate grid where z is defined can be non-rectangular. The limits\n\
9690 of that grid are provided by the parameters indexxmin, indexxmax,\n\
9691 indexymin, and indexymax.\n\
9693 Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
9696 This function is used in example 8.\n\
9702plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
9706 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
9707 which the function is evaluated.\n\
9709 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
9710 which the function is evaluated.\n\
9712 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
9713 plot. Should have dimensions of\n\
9717 nx (PLINT, input) : Number of x values at which function is\n\
9720 ny (PLINT, input) : Number of y values at which function is\n\
9723 opt (PLINT, input) : Determines the way in which the surface is\n\
9724 represented. To specify more than one option just add the options,\n\
9725 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
9726 connecting points at which function is defined.\n\
9727 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
9731 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
9735 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
9736 the borders of the plotted function.\n\
9737 opt=MAG_COLOR : the surface is colored according to the value\n\
9738 of Z; if MAG_COLOR is not used, then the surface is colored\n\
9739 according to the intensity of the reflected light in the\n\
9740 surface from a light source whose position is set using\n\
9744 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
9747 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
9749 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
9750 corresponds to the first x index where z is defined.\n\
9752 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
9753 which corresponds (by convention) to one more than the last x\n\
9754 index value where z is defined.\n\
9756 indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
9757 values which all must be ≥ 0. These values are the first y index\n\
9758 where z is defined for a particular x index in the range from\n\
9759 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
9762 indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
9763 values which all must be ≤ ny. These values correspond (by\n\
9764 convention) to one more than the last y index where z is defined\n\
9765 for a particular x index in the range from indexxmin to indexxmax\n\
9766 - 1. The dimension of indexymax is indexxmax.\n\
9769Set semitransparent cmap1 RGBA colors.\n\
9773 Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
9774 RGBA vector values. This function also sets the number of cmap1\n\
9775 colors. N.B. Continuous cmap1 colors are indexed with a\n\
9776 floating-point index in the range from 0.0-1.0 which is linearly\n\
9777 transformed (e.g., by plcol1) to an integer index of these RGBA\n\
9778 vectors in the range from 0 to\n\
9779 ncol1-1. So in order for this continuous color model to work\n\
9780 properly, it is the responsibility of the user of plscmap1 to insure\n\
9781 that these RGBA vectors are continuous functions of their integer\n\
9784 Redacted form: plscmap1a(r, g, b, alpha)\n\
9786 This function is used in example 31.\n\
9792plscmap1a(r, g, b, alpha, ncol1)\n\
9796 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9797 8-bit integers in the range from 0-255) the degree of red in the\n\
9798 color as a continuous function of the integer index of the vector.\n\
9800 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9801 8-bit integers in the range from 0-255) the degree of green in the\n\
9802 color as a continuous function of the integer index of the vector.\n\
9804 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9805 8-bit integers in the range from 0-255) the degree of blue in the\n\
9806 color as a continuous function of the integer index of the vector.\n\
9808 alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
9809 values in the range from 0.0-1.0 where 0.0 corresponds to\n\
9810 completely transparent and 1.0 corresponds to completely opaque)\n\
9811 the alpha transparency of the color as a continuous function of\n\
9812 the integer index of the vector.\n\
9814 ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9818Calculate broken-down time from continuous time for the current stream\n\
9822 Calculate broken-down time; year, month, day, hour, min, sec; from\n\
9823 continuous time, ctime for the current stream. This function is the\n\
9824 inverse of plctime.\n\
9826 The PLplot definition of broken-down time is a calendar time that\n\
9827 completely ignores all time zone offsets, i.e., it is the user\'s\n\
9828 responsibility to apply those offsets (if so desired) before using the\n\
9829 PLplot time API. By default broken-down time is defined using the\n\
9830 proleptic Gregorian calendar without the insertion of leap seconds and\n\
9831 continuous time is defined as the number of seconds since the Unix\n\
9832 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
9833 broken-down and continuous time are possible, see plconfigtime.\n\
9835 Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
9839 This function is used in example 29.\n\
9845plbtime(year, month, day, hour, min, sec, ctime)\n\
9849 year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
9850 positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
9851 non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
9854 month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
9855 the year in the range from 0 (January) to 11 (December).\n\
9857 day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
9858 month in the range from 1 to 31.\n\
9860 hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
9861 day in the range from 0 to 23.\n\
9863 min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
9864 hour in the range from 0 to 59\n\
9866 sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
9867 minute in range from 0. to 60.\n\
9869 ctime (PLFLT, input) : Continuous time from which the broken-down\n\
9870 time is calculated.\n\
9873Convert RGB color to HLS\n\
9877 Convert RGB color coordinates to HLS\n\
9879 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9882 This function is used in example 2.\n\
9888plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9892 r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9894 g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9896 b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9898 p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9899 degrees (0.0-360.0) on the color cylinder.\n\
9901 p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9902 expressed as a fraction (0.0-1.0) of the axis of the color\n\
9905 p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9906 expressed as a fraction (0.0-1.0) of the radius of the color\n\
9910Get the current device (keyword) name\n\
9914 Get the current device (keyword) name. Note: you must have allocated\n\
9915 space for this (80 characters is safe).\n\
9917 Redacted form: plgdev(p_dev)\n\
9919 This function is used in example 14.\n\
9929 p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
9930 (with preallocated length of 80 characters or more) containing the\n\
9931 device (keyword) name.\n\
9934Set the number of subpages in x and y\n\
9938 Set the number of subpages in x and y.\n\
9940 Redacted form: plssub(nx, ny)\n\
9942 This function is examples 1,2,14,21,25,27.\n\
9952 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
9953 of window columns).\n\
9955 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
9959Get current stream number\n\
9963 Gets the number of the current output stream. See also plsstrm.\n\
9965 Redacted form: plgstrm(p_strm)\n\
9967 This function is used in example 1,20.\n\
9977 p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
9981Random number generator returning a real random number in the range [0,1]\n\
9985 Random number generator returning a real random number in the range\n\
9986 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
9987 / compilers provide their own random number generator, and so this is\n\
9988 provided purely for convenience and to give a consistent random number\n\
9989 generator across all languages supported by PLplot. This is\n\
9990 particularly useful for comparing results from the test suite of\n\
9993 Redacted form: plrandd()\n\
9995 This function is used in examples 17 and 21.\n\
10004Add a point to a strip chart\n\
10008 Add a point to a given pen of a given strip chart. There is no need\n\
10009 for all pens to have the same number of points or to be equally\n\
10010 sampled in the x coordinate. Allocates memory and rescales as\n\
10013 Redacted form: plstripa(id, pen, x, y)\n\
10015 This function is used in example 17.\n\
10021plstripa(id, pen, x, y)\n\
10025 id (PLINT, input) : Identification number of the strip chart (set\n\
10026 up in plstripc).\n\
10028 pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
10030 x (PLFLT, input) : X coordinate of point to plot.\n\
10032 y (PLFLT, input) : Y coordinate of point to plot.\n\
10035Set device-compression level\n\
10039 Set device-compression level. Only used for drivers that provide\n\
10040 compression. This function, if used, should be invoked before a call\n\
10043 Redacted form: plscompression(compression)\n\
10045 This function is used in example 31.\n\
10051plscompression(compression)\n\
10055 compression (PLINT, input) : The desired compression level. This is\n\
10056 a device-dependent value. Currently only the jpeg and png devices\n\
10057 use these values. For jpeg value is the jpeg quality which should\n\
10058 normally be in the range 0-95. Higher values denote higher quality\n\
10059 and hence larger image sizes. For png values are in the range -1\n\
10060 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
10061 A value of -1 denotes the default zlib compression level. Values\n\
10062 in the range 10-99 are divided by 10 and then used as the zlib\n\
10063 compression level. Higher compression levels correspond to greater\n\
10064 compression and small file sizes at the expense of more\n\
10068Specify viewport in absolute coordinates\n\
10072 Alternate routine to plvpor for setting up the viewport. This routine\n\
10073 should be used only if the viewport is required to have a definite\n\
10074 size in millimeters. The routine plgspa is useful for finding out the\n\
10075 size of the current subpage.\n\
10077 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
10079 This function is used in example 10.\n\
10085plsvpa(xmin, xmax, ymin, ymax)\n\
10089 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
10090 viewport from the left-hand edge of the subpage in millimeters.\n\
10092 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
10093 viewport from the left-hand edge of the subpage in millimeters.\n\
10095 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
10096 viewport from the bottom edge of the subpage in millimeters.\n\
10098 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
10099 from the bottom edge of the subpage in millimeters.\n\
10102Draw a polygon in 3 space\n\
10106 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10107 like plline3, but differs from that function in that plpoly3 attempts\n\
10108 to determine if the polygon is viewable depending on the order of the\n\
10109 points within the vector and the value of ifcc. If the back of\n\
10110 polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10111 you want, then use plline3 instead.\n\
10113 The points are assumed to be in a plane, and the directionality of the\n\
10114 plane is determined from the first three points. Additional points do\n\
10115 not have to lie on the plane defined by the first three, but if they\n\
10116 do not, then the determination of visibility obviously can\'t be 100%\n\
10117 accurate... So if you\'re 3 space polygons are too far from planar,\n\
10118 consider breaking them into smaller polygons. 3 points define a plane\n\
10121 Bugs: If one of the first two segments is of zero length, or if they\n\
10122 are co-linear, the calculation of visibility has a 50/50 chance of\n\
10123 being correct. Avoid such situations :-). See x18c.c for an example\n\
10124 of this problem. (Search for 20.1).\n\
10126 Redacted form: plpoly3(x, y, z, code)\n\
10128 This function is used in example 18.\n\
10134plpoly3(n, x, y, z, draw, ifcc)\n\
10138 n (PLINT, input) : Number of points defining line.\n\
10140 x (PLFLT_VECTOR, input) : A vector containing\n\
10141 n x coordinates of points.\n\
10143 y (PLFLT_VECTOR, input) : A vector containing\n\
10144 n y coordinates of points.\n\
10146 z (PLFLT_VECTOR, input) : A vector containing\n\
10147 n z coordinates of points.\n\
10149 draw (PLBOOL_VECTOR, input) : A vector containing\n\
10150 n-1 Boolean values which control drawing the segments of the polygon.\n\
10151 If draw[i] is true, then the polygon segment from index [i] to\n\
10152 [i+1] is drawn, otherwise, not.\n\
10154 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10155 polygon is determined by assuming the points are laid out in a\n\
10156 counter-clockwise order. Otherwise, the directionality of the\n\
10157 polygon is determined by assuming the points are laid out in a\n\
10158 clockwise order.\n\
10161Magnitude colored plot surface with contour\n\
10165 Aside from dropping the\n\
10166 side functionality this is a more powerful form of plot3d: the surface\n\
10167 mesh can be colored accordingly to the current z value being plotted,\n\
10168 a contour plot can be drawn at the base XY plane, and a curtain can be\n\
10169 drawn between the plotted function border and the base XY plane. The\n\
10170 arguments are identical to those of plmeshc. The only difference\n\
10171 between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
10172 the surface, while plot3dc only draws the surface as viewed from the\n\
10175 Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
10178 This function is used in example 21.\n\
10184plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
10188 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
10189 which the function is evaluated.\n\
10191 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
10192 which the function is evaluated.\n\
10194 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10195 plot. Should have dimensions of\n\
10199 nx (PLINT, input) : Number of x values at which function is\n\
10202 ny (PLINT, input) : Number of y values at which function is\n\
10205 opt (PLINT, input) : Determines the way in which the surface is\n\
10206 represented. To specify more than one option just add the options,\n\
10207 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
10208 showing z as a function of x for each value of y[j] .\n\
10209 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
10210 for each value of x[i] .\n\
10211 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
10212 at which function is defined.\n\
10213 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
10214 the z value being plotted. The color is used from the current\n\
10216 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
10217 using parameters\n\
10220 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
10221 the borders of the plotted function.\n\
10224 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
10227 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
10230Create a 4-pen strip chart\n\
10234 Create a 4-pen strip chart, to be used afterwards by plstripa\n\
10236 Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
10237 ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
10238 styline, legline, labx, laby, labz)\n\
10241 This function is used in example 17.\n\
10247plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
10251 id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
10252 number of the strip chart to use on plstripa and plstripd.\n\
10254 xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10255 the x-axis specification as in plbox.\n\
10257 yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10258 the y-axis specification as in plbox.\n\
10260 xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10261 change as data are added.\n\
10263 xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10264 change as data are added.\n\
10266 xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
10267 is multiplied by the factor (1 +\n\
10270 ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10271 change as data are added.\n\
10273 ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10274 change as data are added.\n\
10276 xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
10278 ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
10280 y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
10281 true, otherwise not.\n\
10283 acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
10284 otherwise slide display.\n\
10286 colbox (PLINT, input) : Plot box color index (cmap0).\n\
10288 collab (PLINT, input) : Legend color index (cmap0).\n\
10290 colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
10291 indices for the 4 pens.\n\
10293 styline (PLINT_VECTOR, input) : A vector containing the line style\n\
10294 indices for the 4 pens.\n\
10296 legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
10297 strings containing legends for the 4 pens.\n\
10299 labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10300 the label for the x axis.\n\
10302 laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10303 the label for the y axis.\n\
10305 labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10309Deletes and releases memory used by a strip chart\n\
10313 Deletes and releases memory used by a strip chart.\n\
10315 Redacted form: plstripd(id)\n\
10317 This function is used in example 17.\n\
10327 id (PLINT, input) : Identification number of strip chart to delete.\n\
10330Set cmap1 colors using a piece-wise linear relationship\n\
10334 Set cmap1 colors using a piece-wise linear relationship between the\n\
10335 cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
10336 (see the PLplot documentation). May be called at any time.\n\
10338 The idea here is to specify a number of control points that define the\n\
10339 mapping between input cmap1 intensity indices and HLS or RGB. Between\n\
10340 these points, linear interpolation is used which gives a smooth\n\
10341 variation of color with intensity index. Any number of control points\n\
10342 may be specified, located at arbitrary positions, although typically 2\n\
10343 - 4 are enough. Another way of stating this is that we are traversing\n\
10344 a given number of lines through HLS or RGB space as we move through\n\
10345 cmap1 intensity indices. The control points at the minimum and\n\
10346 maximum position (0 and 1) must always be specified. By adding more\n\
10347 control points you can get more variation. One good technique for\n\
10348 plotting functions that vary about some expected average is to use an\n\
10349 additional 2 control points in the center (position ~= 0.5) that are\n\
10350 the same lightness as the background (typically white for paper\n\
10351 output, black for crt), and same hue as the boundary control points.\n\
10352 This allows the highs and lows to be very easily distinguished.\n\
10354 Each control point must specify the cmap1 intensity index and the\n\
10355 associated three coordinates in HLS or RGB space. The first point\n\
10356 must correspond to position = 0, and the last to position = 1.\n\
10358 If RGB colors are provided then the interpolation takes place in RGB\n\
10359 space and is trivial. However if HLS colors are provided then, because\n\
10360 of the circular nature of the color wheel for the hue coordinate, the\n\
10361 interpolation could be performed in either direction around the color\n\
10362 wheel. The default behaviour is for the hue to be linearly\n\
10363 interpolated ignoring this circular property of hue. So for example,\n\
10364 the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\
10365 green and cyan. If instead you wish to interpolate the other way\n\
10366 around the color wheel you have two options. You may provide hues\n\
10367 outside the range [0, 360), so by using a hue of -120 for blue or 360\n\
10368 for red the interpolation will proceed via magenta. Alternatively you\n\
10369 can utilise the alt_hue_path variable to reverse the direction of\n\
10370 interpolation if you need to provide hues within the [0-360) range.\n\
10372 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
10373 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
10374 -120]falsegreen-yellow-red-magenta-blue[240\n\
10375 480]falseblue-magenta-red-yellow-green[120\n\
10376 240]truegreen-yellow-red-magenta-blue[240\n\
10377 120]trueblue-magenta-red-yellow-green\n\
10379 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
10380 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
10381 1]magnitudeHLSsaturation[0, 1]magnitude\n\
10383 Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
10386 This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
10392plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
10396 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
10398 npts (PLINT, input) : number of control points\n\
10400 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
10401 intensity index (0.0-1.0) in ascending order for each control\n\
10404 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
10405 coordinate (H or R) for each control point.\n\
10407 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
10408 coordinate (L or G) for each control point.\n\
10410 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
10411 coordinate (S or B) for each control point.\n\
10413 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
10414 npts - 1 elements), each containing either true to use the reversed\n\
10415 HLS interpolation or false to use the regular HLS interpolation.\n\
10416 (alt_hue_path[i] refers to the interpolation interval between the\n\
10417 i and i + 1 control points). This parameter is not used for RGB\n\
10422Shade individual region on the basis of value\n\
10426 Shade individual region on the basis of value. Use plshades if you\n\
10427 want to shade a number of contiguous regions using continuous colors.\n\
10428 In particular the edge contours are treated properly in plshades. If\n\
10429 you attempt to do contiguous regions with plshade the contours at the\n\
10430 edge of the shade are partially obliterated by subsequent plots of\n\
10431 contiguous shaded regions.\n\
10433 Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
10434 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
10435 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
10438 This function is used in example 15.\n\
10444plshade(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\
10448 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10449 plot. Should have dimensions of\n\
10453 nx (PLINT, input) : First dimension of the matrix \"a\".\n\
10455 ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
10457 defined (PLDEFINED_callback, input) : Callback function specifying\n\
10458 the region that should be plotted in the shade plot. This\n\
10459 function accepts x and y coordinates as input arguments and must\n\
10460 return 1 if the point is to be included in the shade plot and 0\n\
10461 otherwise. If you want to plot the entire shade plot (the usual\n\
10462 case), this argument should be set to NULL.\n\
10464 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
10465 pltr below for how these arguments are used (only for the special case\n\
10466 when the callback function\n\
10467 pltr is not supplied).\n\
10469 shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
10470 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10472 shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
10473 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10475 sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
10476 sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
10477 then sh_color is interpreted as a cmap1 argument in the range\n\
10480 sh_color (PLFLT, input) : Defines color map index with integer\n\
10481 value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
10483 sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
10485 min_color (PLINT, input) : Defines pen color, width used by the\n\
10486 boundary of shaded region. The min values are used for the\n\
10487 shade_min boundary, and the max values are used on the shade_max\n\
10488 boundary. Set color and width to zero for no plotted boundaries.\n\
10490 min_width (PLFLT, input) : Defines pen color, width used by the\n\
10491 boundary of shaded region. The min values are used for the\n\
10492 shade_min boundary, and the max values are used on the shade_max\n\
10493 boundary. Set color and width to zero for no plotted boundaries.\n\
10495 max_color (PLINT, input) : Defines pen color, width used by the\n\
10496 boundary of shaded region. The min values are used for the\n\
10497 shade_min boundary, and the max values are used on the shade_max\n\
10498 boundary. Set color and width to zero for no plotted boundaries.\n\
10500 max_width (PLFLT, input) : Defines pen color, width used by the\n\
10501 boundary of shaded region. The min values are used for the\n\
10502 shade_min boundary, and the max values are used on the shade_max\n\
10503 boundary. Set color and width to zero for no plotted boundaries.\n\
10505 fill (PLFILL_callback, input) : Routine used to fill the region.\n\
10506 Use plfill. Future version of PLplot may have other fill\n\
10509 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
10510 map to rectangles after coordinate transformation with pltrl.\n\
10511 Otherwise, set rectangular to false. If rectangular is set to\n\
10512 true, plshade tries to save time by filling large rectangles.\n\
10513 This optimization fails if the coordinate transformation distorts\n\
10514 the shape of rectangles. For example a plot in polar coordinates\n\
10515 has to have rectangular set to false.\n\
10517 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
10518 defines the transformation between the zero-based indices of the\n\
10519 matrix a and world coordinates. If\n\
10520 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
10521 indices of a are mapped to the range\n\
10523 xmax and the y indices of a are mapped to the range\n\
10525 ymax.For the C case, transformation functions are provided in the\n\
10526 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
10527 pltr2 for arbitrary mappings respectively defined by vectors and\n\
10528 matrices. In addition, C callback routines for the transformation\n\
10529 can be supplied by the user such as the mypltr function in\n\
10530 examples/c/x09c.c which provides a general linear transformation\n\
10531 between index coordinates and world coordinates.For languages\n\
10532 other than C you should consult the PLplot documentation for the\n\
10533 details concerning how PLTRANSFORM_callback arguments are\n\
10534 interfaced. However, in general, a particular pattern of\n\
10535 callback-associated arguments such as a tr vector with 6 elements;\n\
10536 xg and yg vectors; or xg and yg matrices are respectively\n\
10537 interfaced to a linear-transformation routine similar to the above\n\
10538 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
10539 sophisticated bindings (see, e.g., the PLplot documentation)\n\
10540 support native language callbacks for handling index to\n\
10541 world-coordinate transformations. Examples of these various\n\
10542 approaches are given in examples/<language>x09*,\n\
10543 examples/<language>x16*, examples/<language>x20*,\n\
10544 examples/<language>x21*, and examples/<language>x22*, for all our\n\
10545 supported languages.\n\
10547 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
10548 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
10549 externally supplied.\n\
10552Set number of colors in cmap1\n\
10556 Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
10557 values if this is the first allocation (see the PLplot documentation).\n\
10559 Redacted form: plscmap1n(ncol1)\n\
10561 This function is used in examples 8, 11, 20, and 21.\n\
10571 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
10572 the cmap1 palette. If this number is zero or less, then the value\n\
10573 from the previous call to plscmap1n is used and if there is no\n\
10574 previous call, then a default value is used.\n\
10577Advance to the next family file on the next new page\n\
10581 Advance to the next family file on the next new page.\n\
10583 Redacted form: plfamadv()\n\
10585 This function is not used in any examples.\n\
10594Set the escape character for text strings\n\
10598 Set the escape character for text strings. From C (in contrast to\n\
10599 Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
10600 characters are allowed to prevent the user from shooting himself in\n\
10601 the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
10602 use of backslash as a character escape). Here are the allowed escape\n\
10603 characters and their corresponding decimal ASCII values: !, ASCII 33\n\
10614 Redacted form: General: plsesc(esc)\n\
10617 This function is used in example 29.\n\
10627 esc (char, input) : Escape character.\n\
10629static const char* _wrap_plcolorbar_texinfo =
"-*- texinfo -*-\n\
10630Plot color bar for image, shade or gradient plots\n\
10634 Routine for creating a continuous color bar for image, shade, or\n\
10635 gradient plots. (See pllegend for similar functionality for creating\n\
10636 legends with discrete elements). The arguments of plcolorbar provide\n\
10637 control over the location and size of the color bar as well as the\n\
10638 location and characteristics of the elements (most of which are\n\
10639 optional) within that color bar. The resulting color bar is clipped\n\
10640 at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
10641 system used for some of the parameters is defined in the documentation\n\
10642 of the position parameter.)\n\
10644 Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
10645 position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
10646 low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
10647 labels, axis_opts, ticks, sub_ticks, values)\n\
10649 This function is used in examples 16 and 33.\n\
10655plcolorbar(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\
10659 p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10660 labelled and decorated color bar width in adopted coordinates.\n\
10662 p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10663 labelled and decorated color bar height in adopted coordinates.\n\
10665 opt (PLINT, input) : opt contains bits controlling the overall\n\
10666 color bar. The orientation (direction of the maximum value) of\n\
10667 the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
10668 PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
10669 specified, the default orientation is toward the top if the\n\
10670 colorbar is placed on the left or right of the viewport or toward\n\
10671 the right if the colorbar is placed on the top or bottom of the\n\
10672 viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
10673 (semitransparent) background for the color bar. If the\n\
10674 PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
10675 color bar. The type of color bar must be specified with one of\n\
10676 PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
10677 more than one of those bits is set only the first one in the above\n\
10678 list is honored. The position of the (optional) label/title can be\n\
10679 specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
10680 PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
10681 will be drawn. If more than one of this list of bits is specified,\n\
10682 only the first one on the list is honored. End-caps for the color\n\
10683 bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
10684 If a particular color bar cap option is not specified then no cap\n\
10685 will be drawn for that end. As a special case for\n\
10686 PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
10687 specified. If this option is provided then any tick marks and tick\n\
10688 labels will be placed at the breaks between shaded segments. TODO:\n\
10689 This should be expanded to support custom placement of tick marks\n\
10690 and tick labels at custom value locations for any color bar type.\n\
10692 position (PLINT, input) : position contains bits which control the\n\
10693 overall position of the color bar and the definition of the\n\
10694 adopted coordinates used for positions just like what is done for\n\
10695 the position argument for pllegend. However, note that the\n\
10696 defaults for the position bits (see below) are different than the\n\
10697 pllegend case. The combination of the PL_POSITION_LEFT,\n\
10698 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
10699 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
10700 the 16 possible standard positions (the 4 corners and centers of\n\
10701 the 4 sides for both the inside and outside cases) of the color\n\
10702 bar relative to the adopted coordinate system. The corner\n\
10703 positions are specified by the appropriate combination of two of\n\
10704 the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
10705 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
10706 value of one of those bits. The adopted coordinates are\n\
10707 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
10708 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
10709 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
10710 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
10711 then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
10712 PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
10713 PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
10714 PL_POSITION_VIEWPORT.\n\
10716 x (PLFLT, input) : X offset of the color bar position in adopted\n\
10717 coordinates from the specified standard position of the color bar.\n\
10718 For positive x, the direction of motion away from the standard\n\
10719 position is inward/outward from the standard corner positions or\n\
10720 standard left or right positions if the\n\
10721 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10722 For the standard top or bottom positions, the direction of motion\n\
10723 is toward positive X.\n\
10725 y (PLFLT, input) : Y offset of the color bar position in adopted\n\
10726 coordinates from the specified standard position of the color bar.\n\
10727 For positive y, the direction of motion away from the standard\n\
10728 position is inward/outward from the standard corner positions or\n\
10729 standard top or bottom positions if the\n\
10730 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10731 For the standard left or right positions, the direction of motion\n\
10732 is toward positive Y.\n\
10734 x_length (PLFLT, input) : Length of the body of the color bar in\n\
10735 the X direction in adopted coordinates.\n\
10737 y_length (PLFLT, input) : Length of the body of the color bar in\n\
10738 the Y direction in adopted coordinates.\n\
10740 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
10741 color bar (PL_COLORBAR_BACKGROUND).\n\
10743 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
10744 for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
10746 bb_style (PLINT, input) : The pllsty style number for the\n\
10747 bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
10749 low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
10750 bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
10752 high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
10753 color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
10755 cont_color (PLINT, input) : The cmap0 contour color for\n\
10756 PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
10757 it will be interpreted according to the design of plshades.\n\
10759 cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
10760 plots. This is passed directly to plshades, so it will be\n\
10761 interpreted according to the design of plshades.\n\
10763 n_labels (PLINT, input) : Number of labels to place around the\n\
10766 label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
10767 n_labels labels.\n\
10769 labels (PLCHAR_MATRIX, input) : A vector of\n\
10770 n_labels UTF-8 character strings containing the labels for the color\n\
10771 bar. Ignored if no label position is specified with one of the\n\
10772 PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
10773 PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
10774 corresponding label_opts field.\n\
10776 n_axes (PLINT, input) : Number of axis definitions provided. This\n\
10777 value must be greater than 0. It is typically 1 (numerical axis\n\
10778 labels are provided for one of the long edges of the color bar),\n\
10779 but it can be larger if multiple numerical axis labels for the\n\
10780 long edges of the color bar are desired.\n\
10782 axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
10783 n_axes ascii character strings containing options (interpreted as for\n\
10784 plbox) for the color bar\'s axis definitions.\n\
10786 ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
10787 spacing of the major tick marks (interpreted as for plbox) for the\n\
10788 color bar\'s axis definitions.\n\
10790 sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
10791 number of subticks (interpreted as for plbox) for the color bar\'s\n\
10792 axis definitions.\n\
10794 n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
10795 elements in each of the n_axes rows of the values matrix.\n\
10797 values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
10798 values for the data range represented by the color bar. For a row\n\
10799 index of i_axis (where 0 < i_axis < n_axes), the number of\n\
10800 elements in the row is specified by n_values[i_axis]. For\n\
10801 PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
10802 is 2, and the corresponding row elements of the values matrix are\n\
10803 the minimum and maximum value represented by the colorbar. For\n\
10804 PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
10805 of the values matrix is interpreted the same as the nlevel and\n\
10806 clevel arguments of plshades.\n\
10808static const char* _wrap_plsstrm_texinfo =
"-*- texinfo -*-\n\
10809Set current output stream\n\
10813 Sets the number of the current output stream. The stream number\n\
10814 defaults to 0 unless changed by this routine. The first use of this\n\
10815 routine must be followed by a call initializing PLplot (e.g. plstar).\n\
10817 Redacted form: plsstrm(strm)\n\
10819 This function is examples 1,14,20.\n\
10829 strm (PLINT, input) : The current stream number.\n\
10831static const char* _wrap_plgcompression_texinfo =
"-*- texinfo -*-\n\
10832Get the current device-compression setting\n\
10836 Get the current device-compression setting. This parameter is only\n\
10837 used for drivers that provide compression.\n\
10839 Redacted form: plgcompression(compression)\n\
10841 This function is used in example 31.\n\
10847plgcompression(compression)\n\
10851 compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
10852 compression setting for the current device.\n\
10854static const char* _wrap_plgriddata_texinfo =
"-*- texinfo -*-\n\
10855Grid data from irregularly sampled data\n\
10859 Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
10860 require data organized as a grid, i.e., with x sample point values\n\
10861 independent of y coordinate and vice versa. This function takes\n\
10862 irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
10863 vectors; reads the desired grid location from the input vectors\n\
10864 xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
10865 grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
10866 interpolate the data to the grid is specified with the argument type\n\
10867 which can have one parameter specified in argument data.\n\
10869 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
10870 Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
10873 This function is used in example 21.\n\
10879plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
10883 x (PLFLT_VECTOR, input) : The input x vector.\n\
10885 y (PLFLT_VECTOR, input) : The input y vector.\n\
10887 z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
10888 y[i], z[i] represents one data sample coordinate.\n\
10890 npts (PLINT, input) : The number of data samples in the x, y and z\n\
10893 xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10894 in the x direction. Usually xg has nptsx equally spaced values\n\
10895 from the minimum to the maximum values of the x input vector.\n\
10897 nptsx (PLINT, input) : The number of points in the xg vector.\n\
10899 yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10900 in the y direction. Similar to the xg parameter.\n\
10902 nptsy (PLINT, input) : The number of points in the yg vector.\n\
10904 zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
10905 where data lies in the grid specified by xg and yg. Therefore the\n\
10906 zg matrix must be dimensioned\n\
10910 type (PLINT, input) : The type of grid interpolation algorithm to\n\
10911 use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
10912 GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
10913 GRID_NNI: Natural Neighbors Interpolation\n\
10914 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
10915 GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
10916 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
10918 For details of the algorithms read the source file plgridd.c.\n\
10920 data (PLFLT, input) : Some gridding algorithms require extra data,\n\
10921 which can be specified through this argument. Currently, for\n\
10922 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
10923 use, the lower the value, the noisier (more local) the\n\
10924 approximation is.\n\
10925 GRID_NNLI, data specifies what a thin triangle is, in the\n\
10926 range [1. .. 2.]. High values enable the usage of very thin\n\
10927 triangles for interpolation, possibly resulting in error in\n\
10928 the approximation.\n\
10929 GRID_NNI, only weights greater than data will be accepted. If\n\
10930 0, all weights will be accepted.\n\
10936 char **arg3 = (
char **) 0 ;
10938 octave_value_list _out;
10939 octave_value_list *_outp=&_out;
10940 octave_value _outv;
10947 if (
_n_dims( args(0) ) > 1 )
10953 temp1 = args(0).matrix_value();
10957 charMatrix temp_matrix;
10961 size_t max_length = 0, non_blank_length;
10963 if (
_n_dims( args(1) ) > 2 )
10965 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
10967#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10968 if ( !args(1).isempty() )
10970 if ( !args(1).is_empty() )
10975 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
10977 arg3 =
new char*[
Alen];
10978#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10979 ifcell = args(1).iscell();
10981 ifcell = args(1).is_cell();
10985 temp_cell = args(1).cell_value();
10989 temp_matrix = args(1).char_matrix_value();
10991 max_length =
_dim( args(1), 1 ) + 1;
10994 for ( i = 0; i <
Alen; i++ )
11001 if ( temp_cell.elem( i ).is_string() )
11003 str = temp_cell.elem( i ).string_value();
11005 max_length = str.size() + 1;
11006 tmp_cstring = (
char *) str.c_str();
11016 tmp_cstring = (
char *)
"";
11021 str = temp_matrix.row_as_string( i );
11022 tmp_cstring = (
char *) str.c_str();
11024 arg3[i] =
new char[max_length];
11025 strncpy( arg3[i], tmp_cstring, max_length - 1 );
11026 arg3[i][max_length - 1] =
'\0';
11041 non_blank_length = max_length - 2;
11042 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
'\0' )
11044 non_blank_length--;
11046 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
' ' )
11048 non_blank_length--;
11050 arg3[i][non_blank_length + 1] =
'\0';
11059 testppchar(arg1,(
int const *)arg2,(
char const **)arg3);
11060 _outv = octave_value();
11067 if ( arg3 != NULL )
11069 for ( i = 0; i <
Alen; i++ )
11083 if ( arg3 != NULL )
11085 for ( i = 0; i <
Alen; i++ )
11092 return octave_value_list();
11100 if ( arg3 != NULL )
11102 for ( i = 0; i <
Alen; i++ )
11115 int *arg1 = (
int *) 0 ;
11116 int *arg2 = (
int *) 0 ;
11117 int *arg3 = (
int *) 0 ;
11118 char *arg4 = (
char *) 0 ;
11119 int *arg5 = (
int *) 0 ;
11120 int *arg6 = (
int *) 0 ;
11125 int *arg11 = (
int *) 0 ;
11132 char local_string4[80] ;
11147 size_t local_string_length4 ;
11148 charMatrix local_charMatrix4 ;
11149 octave_value_list retval4 ;
11150 octave_value_list _out;
11151 octave_value_list *_outp=&_out;
11152 octave_value _outv;
11160 arg4 = local_string4;
11172 result = (int)
my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11194 local_string_length4 = strlen( local_string4 );
11195 local_charMatrix4 = charMatrix( 1, local_string_length4 );
11196 local_charMatrix4.insert( local_string4, 0, 0 );
11197 retval4( 0 ) = octave_value( local_charMatrix4 );
11244 return octave_value_list();
11265 octave_value_list _out;
11266 octave_value_list *_outp=&_out;
11267 octave_value _outv;
11280 arg3 =
static_cast< PLFLT >(val3);
11285 arg4 =
static_cast< PLFLT >(val4);
11303 return octave_value_list();
11313 char *arg2 = (
char *) 0 ;
11314 char *arg3 = (
char *) 0 ;
11328 char *arg17 = (
char *) 0 ;
11329 char *arg18 = (
char *) 0 ;
11330 char *arg19 = (
char *) 0 ;
11331 char *arg20 = (
char *) 0 ;
11332 char *arg21 = (
char *) 0 ;
11333 char *arg22 = (
char *) 0 ;
11334 char *arg23 = (
char *) 0 ;
11388 octave_value_list _out;
11389 octave_value_list *_outp=&_out;
11390 octave_value _outv;
11401 arg2 =
reinterpret_cast< char *
>(buf2);
11406 arg3 =
reinterpret_cast< char *
>(buf3);
11411 arg4 =
static_cast< PLFLT >(val4);
11416 arg5 =
static_cast< PLFLT >(val5);
11421 arg6 =
static_cast< PLFLT >(val6);
11426 arg7 =
static_cast< PLFLT >(val7);
11431 arg8 =
static_cast< PLFLT >(val8);
11436 arg9 =
static_cast< PLFLT >(val9);
11441 arg10 =
static_cast< PLFLT >(val10);
11446 arg11 =
static_cast< PLBOOL >(val11);
11451 arg12 =
static_cast< PLBOOL >(val12);
11456 arg13 =
static_cast< PLINT >(val13);
11461 arg14 =
static_cast< PLINT >(val14);
11463 if (
_n_dims( args(13) ) > 1 )
11468 temp15 = args(13).matrix_value();
11473 if (
_n_dims( args(14) ) > 1 )
11477 if (
_dim( args(14), 0 ) !=
Alen )
11481 temp16 = args(14).matrix_value();
11489 arg17 =
reinterpret_cast< char *
>(buf17);
11494 arg18 =
reinterpret_cast< char *
>(buf18);
11499 arg19 =
reinterpret_cast< char *
>(buf19);
11504 arg20 =
reinterpret_cast< char *
>(buf20);
11509 arg21 =
reinterpret_cast< char *
>(buf21);
11514 arg22 =
reinterpret_cast< char *
>(buf22);
11519 arg23 =
reinterpret_cast< char *
>(buf23);
11520 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);
11521 _outv = octave_value();
11561 return octave_value_list();
11606 octave_value_list _out;
11607 octave_value_list *_outp=&_out;
11608 octave_value _outv;
11615 if (
_n_dims( args(0) ) > 2 )
11617 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11619 temp1 = args(0).matrix_value();
11620 arg1 = &temp1( 0, 0 );
11628 arg4 =
static_cast< PLINT >(val4);
11633 arg5 =
static_cast< PLINT >(val5);
11638 arg6 =
static_cast< PLINT >(val6);
11643 arg7 =
static_cast< PLINT >(val7);
11645 if (
_n_dims( args(5) ) > 1 )
11649 temp8 = args(5).matrix_value();
11650 arg8 = &temp8( 0, 0 );
11654 if (
_n_dims( args(6) ) > 1 )
11658 if (
_dim( args(6), 0 ) != 6 )
11662 temp10 = args(6).matrix_value();
11663 arg10 = &temp10( 0, 0 );
11665 my_plcont((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10);
11666 _outv = octave_value();
11688 return octave_value_list();
11725 octave_value_list _out;
11726 octave_value_list *_outp=&_out;
11727 octave_value _outv;
11734 if (
_n_dims( args(0) ) > 2 )
11736 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11738 temp1 = args(0).matrix_value();
11739 arg1 = &temp1( 0, 0 );
11747 arg4 =
static_cast< PLINT >(val4);
11752 arg5 =
static_cast< PLINT >(val5);
11757 arg6 =
static_cast< PLINT >(val6);
11762 arg7 =
static_cast< PLINT >(val7);
11764 if (
_n_dims( args(5) ) > 1 )
11768 temp8 = args(5).matrix_value();
11769 arg8 = &temp8( 0, 0 );
11772 my_plcont0((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9);
11773 _outv = octave_value();
11789 return octave_value_list();
11827 octave_value_list _out;
11828 octave_value_list *_outp=&_out;
11829 octave_value _outv;
11836 if (
_n_dims( args(0) ) > 2 )
11838 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11840 temp1 = args(0).matrix_value();
11841 arg1 = &temp1( 0, 0 );
11849 arg4 =
static_cast< PLINT >(val4);
11854 arg5 =
static_cast< PLINT >(val5);
11859 arg6 =
static_cast< PLINT >(val6);
11864 arg7 =
static_cast< PLINT >(val7);
11866 if (
_n_dims( args(5) ) > 1 )
11870 temp8 = args(5).matrix_value();
11871 arg8 = &temp8( 0, 0 );
11875 if (
_n_dims( args(6) ) > 1 )
11883 temp10 = args(6).matrix_value();
11884 arg10 = &temp10( 0, 0 );
11887 if (
_n_dims( args(7) ) > 1 )
11895 temp11 = args(7).matrix_value();
11896 arg11 = &temp11( 0, 0 );
11898 my_plcont1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11899 _outv = octave_value();
11927 return octave_value_list();
11971 octave_value_list _out;
11972 octave_value_list *_outp=&_out;
11973 octave_value _outv;
11980 if (
_n_dims( args(0) ) > 2 )
11982 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11984 temp1 = args(0).matrix_value();
11985 arg1 = &temp1( 0, 0 );
11993 arg4 =
static_cast< PLINT >(val4);
11998 arg5 =
static_cast< PLINT >(val5);
12003 arg6 =
static_cast< PLINT >(val6);
12008 arg7 =
static_cast< PLINT >(val7);
12010 if (
_n_dims( args(5) ) > 1 )
12014 temp8 = args(5).matrix_value();
12015 arg8 = &temp8( 0, 0 );
12019 if (
_n_dims( args(6) ) > 2 )
12021 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12025 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12029 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12031 temp10 = args(6).matrix_value();
12032 arg10 = &temp10( 0, 0 );
12035 if (
_n_dims( args(7) ) > 2 )
12037 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12041 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12045 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12047 temp11 = args(7).matrix_value();
12048 arg11 = &temp11( 0, 0 );
12050 my_plcont2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
12051 _outv = octave_value();
12079 return octave_value_list();
12123 octave_value_list _out;
12124 octave_value_list *_outp=&_out;
12125 octave_value _outv;
12132 if (
_n_dims( args(0) ) > 2 )
12134 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12136 temp1 = args(0).matrix_value();
12137 arg1 = &temp1( 0, 0 );
12145 arg4 =
static_cast< PLINT >(val4);
12150 arg5 =
static_cast< PLINT >(val5);
12155 arg6 =
static_cast< PLINT >(val6);
12160 arg7 =
static_cast< PLINT >(val7);
12162 if (
_n_dims( args(5) ) > 1 )
12166 temp8 = args(5).matrix_value();
12167 arg8 = &temp8( 0, 0 );
12171 if (
_n_dims( args(6) ) > 2 )
12173 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12177 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12181 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12183 temp10 = args(6).matrix_value();
12184 arg10 = &temp10( 0, 0 );
12187 if (
_n_dims( args(7) ) > 2 )
12189 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12193 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12197 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12199 temp11 = args(7).matrix_value();
12200 arg11 = &temp11( 0, 0 );
12202 my_plcont2p((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
12203 _outv = octave_value();
12231 return octave_value_list();
12268 octave_value_list retval7 ;
12273 octave_value_list _out;
12274 octave_value_list *_outp=&_out;
12275 octave_value _outv;
12282 if (
_n_dims( args(0) ) > 1 )
12287 temp1 = args(0).matrix_value();
12288 arg1 = &temp1( 0, 0 );
12291 if (
_n_dims( args(1) ) > 1 )
12299 temp2 = args(1).matrix_value();
12300 arg2 = &temp2( 0, 0 );
12303 if (
_n_dims( args(2) ) > 1 )
12311 temp3 = args(2).matrix_value();
12312 arg3 = &temp3( 0, 0 );
12316 if (
_n_dims( args(3) ) > 1 )
12320 temp5 = args(3).matrix_value();
12321 arg5 = &temp5( 0, 0 );
12325 if (
_n_dims( args(4) ) > 1 )
12329 temp7 = args(4).matrix_value();
12330 arg7 = &temp7( 0, 0 );
12332 retval7( 0 ) = octave_value( Matrix(
Xlen,
Ylen ) );
12333 arg9 = (
PLFLT *) retval7( 0 ).matrix_value().data();
12339 arg10 =
static_cast< PLINT >(val10);
12344 arg11 =
static_cast< PLFLT >(val11);
12345 my_plgriddata((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,(
double const *)arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,arg11);
12346 _outv = octave_value();
12383 return octave_value_list();
12418 octave_value_list _out;
12419 octave_value_list *_outp=&_out;
12420 octave_value _outv;
12427 if (
_n_dims( args(0) ) > 1 )
12431 temp1 = args(0).matrix_value();
12432 arg1 = &temp1( 0, 0 );
12436 if (
_n_dims( args(1) ) > 1 )
12440 temp2 = args(1).matrix_value();
12441 arg2 = &temp2( 0, 0 );
12445 if (
_n_dims( args(2) ) > 2 )
12447 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12451 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12455 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12457 temp3 = args(2).matrix_value();
12458 arg3 = &temp3( 0, 0 );
12466 arg6 =
static_cast< PLINT >(val6);
12467 my_plmesh((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6);
12468 _outv = octave_value();
12490 return octave_value_list();
12522 octave_value_list _out;
12523 octave_value_list *_outp=&_out;
12524 octave_value _outv;
12531 if (
_n_dims( args(0) ) > 1 )
12535 temp1 = args(0).matrix_value();
12536 arg1 = &temp1( 0, 0 );
12540 if (
_n_dims( args(1) ) > 1 )
12544 temp2 = args(1).matrix_value();
12545 arg2 = &temp2( 0, 0 );
12549 if (
_n_dims( args(2) ) > 2 )
12551 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12555 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12559 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12561 temp3 = args(2).matrix_value();
12562 arg3 = &temp3( 0, 0 );
12570 arg6 =
static_cast< PLINT >(val6);
12572 if (
_n_dims( args(4) ) > 1 )
12576 temp7 = args(4).matrix_value();
12577 arg7 = &temp7( 0, 0 );
12580 my_plmeshc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12581 _outv = octave_value();
12609 return octave_value_list();
12644 octave_value_list _out;
12645 octave_value_list *_outp=&_out;
12646 octave_value _outv;
12653 if (
_n_dims( args(0) ) > 1 )
12657 temp1 = args(0).matrix_value();
12658 arg1 = &temp1( 0, 0 );
12662 if (
_n_dims( args(1) ) > 1 )
12666 temp2 = args(1).matrix_value();
12667 arg2 = &temp2( 0, 0 );
12671 if (
_n_dims( args(2) ) > 2 )
12673 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12677 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12681 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12683 temp3 = args(2).matrix_value();
12684 arg3 = &temp3( 0, 0 );
12692 arg6 =
static_cast< PLINT >(val6);
12697 arg7 =
static_cast< PLBOOL >(val7);
12698 my_plot3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,arg7);
12699 _outv = octave_value();
12721 return octave_value_list();
12753 octave_value_list _out;
12754 octave_value_list *_outp=&_out;
12755 octave_value _outv;
12762 if (
_n_dims( args(0) ) > 1 )
12766 temp1 = args(0).matrix_value();
12767 arg1 = &temp1( 0, 0 );
12771 if (
_n_dims( args(1) ) > 1 )
12775 temp2 = args(1).matrix_value();
12776 arg2 = &temp2( 0, 0 );
12780 if (
_n_dims( args(2) ) > 2 )
12782 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12786 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12790 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12792 temp3 = args(2).matrix_value();
12793 arg3 = &temp3( 0, 0 );
12801 arg6 =
static_cast< PLINT >(val6);
12803 if (
_n_dims( args(4) ) > 1 )
12807 temp7 = args(4).matrix_value();
12808 arg7 = &temp7( 0, 0 );
12811 my_plot3dc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12812 _outv = octave_value();
12840 return octave_value_list();
12883 octave_value_list _out;
12884 octave_value_list *_outp=&_out;
12885 octave_value _outv;
12892 if (
_n_dims( args(0) ) > 1 )
12896 temp1 = args(0).matrix_value();
12897 arg1 = &temp1( 0, 0 );
12901 if (
_n_dims( args(1) ) > 1 )
12905 temp2 = args(1).matrix_value();
12906 arg2 = &temp2( 0, 0 );
12910 if (
_n_dims( args(2) ) > 2 )
12912 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12916 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12920 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12922 temp3 = args(2).matrix_value();
12923 arg3 = &temp3( 0, 0 );
12931 arg6 =
static_cast< PLINT >(val6);
12933 if (
_n_dims( args(4) ) > 1 )
12937 temp7 = args(4).matrix_value();
12938 arg7 = &temp7( 0, 0 );
12945 arg9 =
static_cast< PLINT >(val9);
12947 if (
_n_dims( args(6) ) > 1 )
12953 temp10 = args(6).matrix_value();
12957 if (
_n_dims( args(7) ) > 1 )
12965 temp12 = args(7).matrix_value();
12969 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);
12970 _outv = octave_value();
13010 return octave_value_list();
13051 octave_value_list _out;
13052 octave_value_list *_outp=&_out;
13053 octave_value _outv;
13060 if (
_n_dims( args(0) ) > 1 )
13064 temp1 = args(0).matrix_value();
13065 arg1 = &temp1( 0, 0 );
13069 if (
_n_dims( args(1) ) > 1 )
13073 temp2 = args(1).matrix_value();
13074 arg2 = &temp2( 0, 0 );
13078 if (
_n_dims( args(2) ) > 2 )
13080 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13084 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13088 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13090 temp3 = args(2).matrix_value();
13091 arg3 = &temp3( 0, 0 );
13099 arg6 =
static_cast< PLINT >(val6);
13101 if (
_n_dims( args(4) ) > 1 )
13105 temp7 = args(4).matrix_value();
13106 arg7 = &temp7( 0, 0 );
13109 my_plsurf3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
13110 _outv = octave_value();
13138 return octave_value_list();
13181 octave_value_list _out;
13182 octave_value_list *_outp=&_out;
13183 octave_value _outv;
13190 if (
_n_dims( args(0) ) > 1 )
13194 temp1 = args(0).matrix_value();
13195 arg1 = &temp1( 0, 0 );
13199 if (
_n_dims( args(1) ) > 1 )
13203 temp2 = args(1).matrix_value();
13204 arg2 = &temp2( 0, 0 );
13208 if (
_n_dims( args(2) ) > 2 )
13210 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13214 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13218 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13220 temp3 = args(2).matrix_value();
13221 arg3 = &temp3( 0, 0 );
13229 arg6 =
static_cast< PLINT >(val6);
13231 if (
_n_dims( args(4) ) > 1 )
13235 temp7 = args(4).matrix_value();
13236 arg7 = &temp7( 0, 0 );
13243 arg9 =
static_cast< PLINT >(val9);
13245 if (
_n_dims( args(6) ) > 1 )
13251 temp10 = args(6).matrix_value();
13255 if (
_n_dims( args(7) ) > 1 )
13263 temp12 = args(7).matrix_value();
13267 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);
13268 _outv = octave_value();
13308 return octave_value_list();
13385 octave_value_list _out;
13386 octave_value_list *_outp=&_out;
13387 octave_value _outv;
13394 if (
_n_dims( args(0) ) > 2 )
13396 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13398 temp1 = args(0).matrix_value();
13399 arg1 = &temp1( 0, 0 );
13404 if (
_n_dims( args(1) ) > 1 )
13409 temp4 = args(1).matrix_value();
13410 arg4 = &temp4( 0, 0 );
13416 arg5 =
static_cast< PLFLT >(val5);
13421 arg6 =
static_cast< PLFLT >(val6);
13426 arg7 =
static_cast< PLFLT >(val7);
13431 arg8 =
static_cast< PLFLT >(val8);
13436 arg9 =
static_cast< PLFLT >(val9);
13441 arg10 =
static_cast< PLFLT >(val10);
13446 arg11 =
static_cast< PLINT >(val11);
13451 arg12 =
static_cast< PLFLT >(val12);
13456 arg13 =
static_cast< PLINT >(val13);
13461 arg14 =
static_cast< PLINT >(val14);
13466 arg15 =
static_cast< PLINT >(val15);
13471 arg16 =
static_cast< PLINT >(val16);
13476 arg17 =
static_cast< PLINT >(val17);
13481 arg18 =
static_cast< PLBOOL >(val18);
13483 if (
_n_dims( args(16) ) > 1 )
13487 if (
_dim( args(16), 0 ) != 6 )
13491 temp19 = args(16).matrix_value();
13492 arg19 = &temp19( 0, 0 );
13494 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);
13495 _outv = octave_value();
13517 return octave_value_list();
13538 char *arg4 = (
char *) 0 ;
13589 octave_value_list _out;
13590 octave_value_list *_outp=&_out;
13591 octave_value _outv;
13598 if (
_n_dims( args(0) ) > 2 )
13600 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13602 temp1 = args(0).matrix_value();
13603 arg1 = &temp1( 0, 0 );
13611 arg4 =
reinterpret_cast< char *
>(buf4);
13616 arg5 =
static_cast< PLFLT >(val5);
13621 arg6 =
static_cast< PLFLT >(val6);
13626 arg7 =
static_cast< PLFLT >(val7);
13631 arg8 =
static_cast< PLFLT >(val8);
13636 arg9 =
static_cast< PLFLT >(val9);
13641 arg10 =
static_cast< PLFLT >(val10);
13646 arg11 =
static_cast< PLINT >(val11);
13651 arg12 =
static_cast< PLFLT >(val12);
13656 arg13 =
static_cast< PLINT >(val13);
13661 arg14 =
static_cast< PLINT >(val14);
13666 arg15 =
static_cast< PLINT >(val15);
13671 arg16 =
static_cast< PLINT >(val16);
13676 arg17 =
static_cast< PLINT >(val17);
13681 arg18 =
static_cast< PLBOOL >(val18);
13683 if (
_n_dims( args(16) ) > 1 )
13687 if (
_dim( args(16), 0 ) !=
Xlen )
13691 temp19 = args(16).matrix_value();
13692 arg19 = &temp19( 0, 0 );
13695 if (
_n_dims( args(17) ) > 1 )
13699 if (
_dim( args(17), 0 ) !=
Ylen )
13703 temp20 = args(17).matrix_value();
13704 arg20 = &temp20( 0, 0 );
13706 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);
13707 _outv = octave_value();
13731 return octave_value_list();
13753 char *arg4 = (
char *) 0 ;
13804 octave_value_list _out;
13805 octave_value_list *_outp=&_out;
13806 octave_value _outv;
13813 if (
_n_dims( args(0) ) > 2 )
13815 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13817 temp1 = args(0).matrix_value();
13818 arg1 = &temp1( 0, 0 );
13826 arg4 =
reinterpret_cast< char *
>(buf4);
13831 arg5 =
static_cast< PLFLT >(val5);
13836 arg6 =
static_cast< PLFLT >(val6);
13841 arg7 =
static_cast< PLFLT >(val7);
13846 arg8 =
static_cast< PLFLT >(val8);
13851 arg9 =
static_cast< PLFLT >(val9);
13856 arg10 =
static_cast< PLFLT >(val10);
13861 arg11 =
static_cast< PLINT >(val11);
13866 arg12 =
static_cast< PLFLT >(val12);
13871 arg13 =
static_cast< PLINT >(val13);
13876 arg14 =
static_cast< PLINT >(val14);
13881 arg15 =
static_cast< PLINT >(val15);
13886 arg16 =
static_cast< PLINT >(val16);
13891 arg17 =
static_cast< PLINT >(val17);
13896 arg18 =
static_cast< PLBOOL >(val18);
13898 if (
_n_dims( args(16) ) > 2 )
13900 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13902 temp19 = args(16).matrix_value();
13903 arg19 = &temp19( 0, 0 );
13908 if (
_n_dims( args(17) ) > 2 )
13910 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13912 temp20 = args(17).matrix_value();
13913 arg20 = &temp20( 0, 0 );
13917 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);
13918 _outv = octave_value();
13942 return octave_value_list();
13992 octave_value_list _out;
13993 octave_value_list *_outp=&_out;
13994 octave_value _outv;
14001 if (
_n_dims( args(0) ) > 2 )
14003 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14005 temp1 = args(0).matrix_value();
14006 arg1 = &temp1( 0, 0 );
14014 arg4 =
static_cast< PLFLT >(val4);
14019 arg5 =
static_cast< PLFLT >(val5);
14024 arg6 =
static_cast< PLFLT >(val6);
14029 arg7 =
static_cast< PLFLT >(val7);
14031 if (
_n_dims( args(5) ) > 1 )
14035 temp8 = args(5).matrix_value();
14036 arg8 = &temp8( 0, 0 );
14043 arg10 =
static_cast< PLINT >(val10);
14048 arg11 =
static_cast< PLINT >(val11);
14053 arg12 =
static_cast< PLINT >(val12);
14058 arg13 =
static_cast< PLBOOL >(val13);
14059 my_plshades((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13);
14060 _outv = octave_value();
14076 return octave_value_list();
14124 octave_value_list _out;
14125 octave_value_list *_outp=&_out;
14126 octave_value _outv;
14133 if (
_n_dims( args(0) ) > 2 )
14135 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14137 temp1 = args(0).matrix_value();
14138 arg1 = &temp1( 0, 0 );
14146 arg4 =
static_cast< PLFLT >(val4);
14151 arg5 =
static_cast< PLFLT >(val5);
14156 arg6 =
static_cast< PLFLT >(val6);
14161 arg7 =
static_cast< PLFLT >(val7);
14163 if (
_n_dims( args(5) ) > 1 )
14167 temp8 = args(5).matrix_value();
14168 arg8 = &temp8( 0, 0 );
14175 arg10 =
static_cast< PLINT >(val10);
14180 arg11 =
static_cast< PLINT >(val11);
14185 arg12 =
static_cast< PLINT >(val12);
14190 arg13 =
static_cast< PLBOOL >(val13);
14192 if (
_n_dims( args(10) ) > 1 )
14196 if (
_dim( args(10), 0 ) != 6 )
14200 temp14 = args(10).matrix_value();
14201 arg14 = &temp14( 0, 0 );
14203 my_plshadesx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
14204 _outv = octave_value();
14226 return octave_value_list();
14279 octave_value_list _out;
14280 octave_value_list *_outp=&_out;
14281 octave_value _outv;
14288 if (
_n_dims( args(0) ) > 2 )
14290 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14292 temp1 = args(0).matrix_value();
14293 arg1 = &temp1( 0, 0 );
14301 arg4 =
static_cast< PLFLT >(val4);
14306 arg5 =
static_cast< PLFLT >(val5);
14311 arg6 =
static_cast< PLFLT >(val6);
14316 arg7 =
static_cast< PLFLT >(val7);
14318 if (
_n_dims( args(5) ) > 1 )
14322 temp8 = args(5).matrix_value();
14323 arg8 = &temp8( 0, 0 );
14330 arg10 =
static_cast< PLINT >(val10);
14335 arg11 =
static_cast< PLINT >(val11);
14340 arg12 =
static_cast< PLINT >(val12);
14345 arg13 =
static_cast< PLBOOL >(val13);
14347 if (
_n_dims( args(10) ) > 1 )
14351 if (
_dim( args(10), 0 ) !=
Xlen )
14355 temp14 = args(10).matrix_value();
14356 arg14 = &temp14( 0, 0 );
14359 if (
_n_dims( args(11) ) > 1 )
14363 if (
_dim( args(11), 0 ) !=
Ylen )
14367 temp15 = args(11).matrix_value();
14368 arg15 = &temp15( 0, 0 );
14370 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);
14371 _outv = octave_value();
14399 return octave_value_list();
14455 octave_value_list _out;
14456 octave_value_list *_outp=&_out;
14457 octave_value _outv;
14464 if (
_n_dims( args(0) ) > 2 )
14466 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14468 temp1 = args(0).matrix_value();
14469 arg1 = &temp1( 0, 0 );
14477 arg4 =
static_cast< PLFLT >(val4);
14482 arg5 =
static_cast< PLFLT >(val5);
14487 arg6 =
static_cast< PLFLT >(val6);
14492 arg7 =
static_cast< PLFLT >(val7);
14494 if (
_n_dims( args(5) ) > 1 )
14498 temp8 = args(5).matrix_value();
14499 arg8 = &temp8( 0, 0 );
14506 arg10 =
static_cast< PLINT >(val10);
14511 arg11 =
static_cast< PLINT >(val11);
14516 arg12 =
static_cast< PLINT >(val12);
14521 arg13 =
static_cast< PLBOOL >(val13);
14523 if (
_n_dims( args(10) ) > 2 )
14525 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14527 temp14 = args(10).matrix_value();
14528 arg14 = &temp14( 0, 0 );
14533 if (
_n_dims( args(11) ) > 2 )
14535 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14537 temp15 = args(11).matrix_value();
14538 arg15 = &temp15( 0, 0 );
14542 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);
14543 _outv = octave_value();
14571 return octave_value_list();
14603 octave_value_list _out;
14604 octave_value_list *_outp=&_out;
14605 octave_value _outv;
14612 if (
_n_dims( args(0) ) > 2 )
14614 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14616 temp1 = args(0).matrix_value();
14617 arg1 = &temp1( 0, 0 );
14622 if (
_n_dims( args(1) ) > 2 )
14624 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14628 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14632 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14634 temp2 = args(1).matrix_value();
14635 arg2 = &temp2( 0, 0 );
14643 arg5 =
static_cast< PLFLT >(val5);
14645 if (
_n_dims( args(3) ) > 1 )
14649 if (
_dim( args(3), 0 ) != 6 )
14653 temp6 = args(3).matrix_value();
14654 arg6 = &temp6( 0, 0 );
14656 my_plvect((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
14657 _outv = octave_value();
14679 return octave_value_list();
14710 octave_value_list _out;
14711 octave_value_list *_outp=&_out;
14712 octave_value _outv;
14719 if (
_n_dims( args(0) ) > 2 )
14721 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14723 temp1 = args(0).matrix_value();
14724 arg1 = &temp1( 0, 0 );
14729 if (
_n_dims( args(1) ) > 2 )
14731 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14735 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14739 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14741 temp2 = args(1).matrix_value();
14742 arg2 = &temp2( 0, 0 );
14750 arg5 =
static_cast< PLFLT >(val5);
14752 if (
_n_dims( args(3) ) > 1 )
14760 temp6 = args(3).matrix_value();
14761 arg6 = &temp6( 0, 0 );
14764 if (
_n_dims( args(4) ) > 1 )
14772 temp7 = args(4).matrix_value();
14773 arg7 = &temp7( 0, 0 );
14775 my_plvect1((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14776 _outv = octave_value();
14804 return octave_value_list();
14838 octave_value_list _out;
14839 octave_value_list *_outp=&_out;
14840 octave_value _outv;
14847 if (
_n_dims( args(0) ) > 2 )
14849 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14851 temp1 = args(0).matrix_value();
14852 arg1 = &temp1( 0, 0 );
14857 if (
_n_dims( args(1) ) > 2 )
14859 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14863 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14867 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14869 temp2 = args(1).matrix_value();
14870 arg2 = &temp2( 0, 0 );
14878 arg5 =
static_cast< PLFLT >(val5);
14880 if (
_n_dims( args(3) ) > 2 )
14882 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14884 temp6 = args(3).matrix_value();
14885 arg6 = &temp6( 0, 0 );
14890 if (
_n_dims( args(4) ) > 2 )
14892 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14894 temp7 = args(4).matrix_value();
14895 arg7 = &temp7( 0, 0 );
14899 my_plvect2((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14900 _outv = octave_value();
14928 return octave_value_list();
14983 octave_value_list _out;
14984 octave_value_list *_outp=&_out;
14985 octave_value _outv;
14992 if (
_n_dims( args(0) ) > 2 )
14994 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14996 temp1 = args(0).matrix_value();
14997 arg1 = &temp1( 0, 0 );
15005 arg4 =
static_cast< PLFLT >(val4);
15010 arg5 =
static_cast< PLFLT >(val5);
15015 arg6 =
static_cast< PLFLT >(val6);
15020 arg7 =
static_cast< PLFLT >(val7);
15025 arg8 =
static_cast< PLFLT >(val8);
15030 arg9 =
static_cast< PLFLT >(val9);
15035 arg10 =
static_cast< PLFLT >(val10);
15040 arg11 =
static_cast< PLFLT >(val11);
15045 arg12 =
static_cast< PLFLT >(val12);
15050 arg13 =
static_cast< PLFLT >(val13);
15051 my_plimage((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15052 _outv = octave_value();
15062 return octave_value_list();
15102 octave_value_list _out;
15103 octave_value_list *_outp=&_out;
15104 octave_value _outv;
15111 if (
_n_dims( args(0) ) > 2 )
15113 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15115 temp1 = args(0).matrix_value();
15116 arg1 = &temp1( 0, 0 );
15124 arg4 =
static_cast< PLFLT >(val4);
15129 arg5 =
static_cast< PLFLT >(val5);
15134 arg6 =
static_cast< PLFLT >(val6);
15139 arg7 =
static_cast< PLFLT >(val7);
15144 arg8 =
static_cast< PLFLT >(val8);
15149 arg9 =
static_cast< PLFLT >(val9);
15154 arg10 =
static_cast< PLFLT >(val10);
15159 arg11 =
static_cast< PLFLT >(val11);
15160 my_plimagefr((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
15161 _outv = octave_value();
15171 return octave_value_list();
15213 octave_value_list _out;
15214 octave_value_list *_outp=&_out;
15215 octave_value _outv;
15222 if (
_n_dims( args(0) ) > 2 )
15224 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15226 temp1 = args(0).matrix_value();
15227 arg1 = &temp1( 0, 0 );
15235 arg4 =
static_cast< PLFLT >(val4);
15240 arg5 =
static_cast< PLFLT >(val5);
15245 arg6 =
static_cast< PLFLT >(val6);
15250 arg7 =
static_cast< PLFLT >(val7);
15255 arg8 =
static_cast< PLFLT >(val8);
15260 arg9 =
static_cast< PLFLT >(val9);
15265 arg10 =
static_cast< PLFLT >(val10);
15270 arg11 =
static_cast< PLFLT >(val11);
15272 if (
_n_dims( args(9) ) > 1 )
15276 if (
_dim( args(9), 0 ) != 6 )
15280 temp12 = args(9).matrix_value();
15281 arg12 = &temp12( 0, 0 );
15283 my_plimagefrx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
15284 _outv = octave_value();
15300 return octave_value_list();
15347 octave_value_list _out;
15348 octave_value_list *_outp=&_out;
15349 octave_value _outv;
15356 if (
_n_dims( args(0) ) > 2 )
15358 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15360 temp1 = args(0).matrix_value();
15361 arg1 = &temp1( 0, 0 );
15369 arg4 =
static_cast< PLFLT >(val4);
15374 arg5 =
static_cast< PLFLT >(val5);
15379 arg6 =
static_cast< PLFLT >(val6);
15384 arg7 =
static_cast< PLFLT >(val7);
15389 arg8 =
static_cast< PLFLT >(val8);
15394 arg9 =
static_cast< PLFLT >(val9);
15399 arg10 =
static_cast< PLFLT >(val10);
15404 arg11 =
static_cast< PLFLT >(val11);
15406 if (
_n_dims( args(9) ) > 1 )
15414 temp12 = args(9).matrix_value();
15415 arg12 = &temp12( 0, 0 );
15418 if (
_n_dims( args(10) ) > 1 )
15422 if (
_dim( args(10), 0 ) !=
Ylen )
15426 temp13 = args(10).matrix_value();
15427 arg13 = &temp13( 0, 0 );
15429 my_plimagefr1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
15430 _outv = octave_value();
15452 return octave_value_list();
15502 octave_value_list _out;
15503 octave_value_list *_outp=&_out;
15504 octave_value _outv;
15511 if (
_n_dims( args(0) ) > 2 )
15513 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15515 temp1 = args(0).matrix_value();
15516 arg1 = &temp1( 0, 0 );
15524 arg4 =
static_cast< PLFLT >(val4);
15529 arg5 =
static_cast< PLFLT >(val5);
15534 arg6 =
static_cast< PLFLT >(val6);
15539 arg7 =
static_cast< PLFLT >(val7);
15544 arg8 =
static_cast< PLFLT >(val8);
15549 arg9 =
static_cast< PLFLT >(val9);
15554 arg10 =
static_cast< PLFLT >(val10);
15559 arg11 =
static_cast< PLFLT >(val11);
15561 if (
_n_dims( args(9) ) > 2 )
15563 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15565 temp12 = args(9).matrix_value();
15566 arg12 = &temp12( 0, 0 );
15571 if (
_n_dims( args(10) ) > 2 )
15573 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15575 temp13 = args(10).matrix_value();
15576 arg13 = &temp13( 0, 0 );
15580 my_plimagefr2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
15581 _outv = octave_value();
15603 return octave_value_list();
15638 char **arg18 = (
char **) 0 ;
15640 char **arg20 = (
char **) 0 ;
15680 octave_value_list _out;
15681 octave_value_list *_outp=&_out;
15682 octave_value _outv;
15694 arg3 =
static_cast< PLINT >(val3);
15699 arg4 =
static_cast< PLINT >(val4);
15704 arg5 =
static_cast< PLFLT >(val5);
15709 arg6 =
static_cast< PLFLT >(val6);
15714 arg7 =
static_cast< PLFLT >(val7);
15719 arg8 =
static_cast< PLFLT >(val8);
15724 arg9 =
static_cast< PLINT >(val9);
15729 arg10 =
static_cast< PLINT >(val10);
15734 arg11 =
static_cast< PLINT >(val11);
15739 arg12 =
static_cast< PLFLT >(val12);
15744 arg13 =
static_cast< PLFLT >(val13);
15749 arg14 =
static_cast< PLINT >(val14);
15754 arg15 =
static_cast< PLFLT >(val15);
15756 if (
_n_dims( args(13) ) > 1 )
15762 temp16 = args(13).matrix_value();
15766 charMatrix temp_matrix;
15770 size_t max_length = 0, non_blank_length;
15772 if (
_n_dims( args(14) ) > 2 )
15774 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
15776#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15777 if ( !args(14).isempty() )
15779 if ( !args(14).is_empty() )
15782 if (
_dim( args(14), 0 ) !=
Alen )
15784 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
15786 arg18 =
new char*[
Alen];
15787#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15788 ifcell = args(14).iscell();
15790 ifcell = args(14).is_cell();
15794 temp_cell = args(14).cell_value();
15798 temp_matrix = args(14).char_matrix_value();
15800 max_length =
_dim( args(14), 1 ) + 1;
15803 for ( i = 0; i <
Alen; i++ )
15810 if ( temp_cell.elem( i ).is_string() )
15812 str = temp_cell.elem( i ).string_value();
15814 max_length = str.size() + 1;
15815 tmp_cstring = (
char *) str.c_str();
15825 tmp_cstring = (
char *)
"";
15830 str = temp_matrix.row_as_string( i );
15831 tmp_cstring = (
char *) str.c_str();
15833 arg18[i] =
new char[max_length];
15834 strncpy( arg18[i], tmp_cstring, max_length - 1 );
15835 arg18[i][max_length - 1] =
'\0';
15850 non_blank_length = max_length - 2;
15851 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
'\0' )
15853 non_blank_length--;
15855 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
' ' )
15857 non_blank_length--;
15859 arg18[i][non_blank_length + 1] =
'\0';
15869 charMatrix temp_matrix;
15873 size_t max_length = 0, non_blank_length;
15875 if (
_n_dims( args(15) ) > 2 )
15877 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
15879#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15880 if ( !args(15).isempty() )
15882 if ( !args(15).is_empty() )
15887 arg20 =
new char*[
Alen];
15888#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15889 ifcell = args(15).iscell();
15891 ifcell = args(15).is_cell();
15895 temp_cell = args(15).cell_value();
15899 temp_matrix = args(15).char_matrix_value();
15901 max_length =
_dim( args(15), 1 ) + 1;
15904 for ( i = 0; i <
Alen; i++ )
15911 if ( temp_cell.elem( i ).is_string() )
15913 str = temp_cell.elem( i ).string_value();
15915 max_length = str.size() + 1;
15916 tmp_cstring = (
char *) str.c_str();
15926 tmp_cstring = (
char *)
"";
15931 str = temp_matrix.row_as_string( i );
15932 tmp_cstring = (
char *) str.c_str();
15934 arg20[i] =
new char[max_length];
15935 strncpy( arg20[i], tmp_cstring, max_length - 1 );
15936 arg20[i][max_length - 1] =
'\0';
15951 non_blank_length = max_length - 2;
15952 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
15954 non_blank_length--;
15956 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
15958 non_blank_length--;
15960 arg20[i][non_blank_length + 1] =
'\0';
15971 if (
_n_dims( args(16) ) > 1 )
15975 if (
_dim( args(16), 0 ) !=
Alen )
15979 temp21 = args(16).matrix_value();
15980 arg21 = &temp21( 0, 0 );
15983 if (
_n_dims( args(17) ) > 1 )
15987 if (
_dim( args(17), 0 ) !=
Alen )
15991 temp22 = args(17).matrix_value();
15997 if (
_n_dims( args(18) ) > 1 )
16001 if (
_dim( args(18), 0 ) !=
Alen )
16006 temp23 = args(18).matrix_value();
16010 for ( i = 0; i <
Xlen; i++ )
16011 if ( arg23[i] >
Ylen )
16015 if (
_n_dims( args(19) ) > 2 )
16017 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
16019 if (
_dim( args(19), 0 ) !=
Xlen )
16021 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
16023 if (
_dim( args(19), 1 ) !=
Ylen )
16025 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
16027 temp24 = args(19).matrix_value();
16028 arg24 = &temp24( 0, 0 );
16030 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);
16031 _outv = octave_value();
16050 if ( arg18 != NULL )
16052 for ( i = 0; i <
Alen; i++ )
16061 if ( arg20 != NULL )
16063 for ( i = 0; i <
Alen; i++ )
16089 if ( arg18 != NULL )
16091 for ( i = 0; i <
Alen; i++ )
16100 if ( arg20 != NULL )
16102 for ( i = 0; i <
Alen; i++ )
16121 return octave_value_list();
16129 if ( arg18 != NULL )
16131 for ( i = 0; i <
Alen; i++ )
16140 if ( arg20 != NULL )
16142 for ( i = 0; i <
Alen; i++ )
16173 octave_value_list _out;
16174 octave_value_list *_outp=&_out;
16175 octave_value _outv;
16190 arg2 =
static_cast< int >(val2);
16191 if (arg1) (arg1)->type = arg2;
16192 _outv = octave_value();
16196 return octave_value_list();
16208 octave_value_list _out;
16209 octave_value_list *_outp=&_out;
16210 octave_value _outv;
16222 result = (int) ((arg1)->type);
16227 return octave_value_list();
16237 unsigned int arg2 ;
16240 unsigned int val2 ;
16242 octave_value_list _out;
16243 octave_value_list *_outp=&_out;
16244 octave_value _outv;
16259 arg2 =
static_cast< unsigned int >(val2);
16260 if (arg1) (arg1)->state = arg2;
16261 _outv = octave_value();
16265 return octave_value_list();
16277 octave_value_list _out;
16278 octave_value_list *_outp=&_out;
16279 octave_value _outv;
16280 unsigned int result;
16291 result = (
unsigned int) ((arg1)->state);
16296 return octave_value_list();
16306 unsigned int arg2 ;
16309 unsigned int val2 ;
16311 octave_value_list _out;
16312 octave_value_list *_outp=&_out;
16313 octave_value _outv;
16328 arg2 =
static_cast< unsigned int >(val2);
16329 if (arg1) (arg1)->keysym = arg2;
16330 _outv = octave_value();
16334 return octave_value_list();
16346 octave_value_list _out;
16347 octave_value_list *_outp=&_out;
16348 octave_value _outv;
16349 unsigned int result;
16360 result = (
unsigned int) ((arg1)->keysym);
16365 return octave_value_list();
16375 unsigned int arg2 ;
16378 unsigned int val2 ;
16380 octave_value_list _out;
16381 octave_value_list *_outp=&_out;
16382 octave_value _outv;
16397 arg2 =
static_cast< unsigned int >(val2);
16398 if (arg1) (arg1)->button = arg2;
16399 _outv = octave_value();
16403 return octave_value_list();
16415 octave_value_list _out;
16416 octave_value_list *_outp=&_out;
16417 octave_value _outv;
16418 unsigned int result;
16429 result = (
unsigned int) ((arg1)->button);
16434 return octave_value_list();
16449 octave_value_list _out;
16450 octave_value_list *_outp=&_out;
16451 octave_value _outv;
16466 arg2 =
static_cast< PLINT >(val2);
16467 if (arg1) (arg1)->subwindow = arg2;
16468 _outv = octave_value();
16472 return octave_value_list();
16484 octave_value_list _out;
16485 octave_value_list *_outp=&_out;
16486 octave_value _outv;
16498 result = (
PLINT) ((arg1)->subwindow);
16503 return octave_value_list();
16518 octave_value_list _out;
16519 octave_value_list *_outp=&_out;
16520 octave_value _outv;
16535 arg2 =
reinterpret_cast< char *
>(temp2);
16536 if (arg2) memcpy(arg1->
string,arg2,16*
sizeof(
char));
16537 else memset(arg1->
string,0,16*
sizeof(
char));
16538 _outv = octave_value();
16542 return octave_value_list();
16554 octave_value_list _out;
16555 octave_value_list *_outp=&_out;
16556 octave_value _outv;
16568 result = (
char *)(
char *) ((arg1)->
string);
16579 return octave_value_list();
16594 octave_value_list _out;
16595 octave_value_list *_outp=&_out;
16596 octave_value _outv;
16611 arg2 =
static_cast< int >(val2);
16612 if (arg1) (arg1)->pX = arg2;
16613 _outv = octave_value();
16617 return octave_value_list();
16629 octave_value_list _out;
16630 octave_value_list *_outp=&_out;
16631 octave_value _outv;
16643 result = (int) ((arg1)->pX);
16648 return octave_value_list();
16663 octave_value_list _out;
16664 octave_value_list *_outp=&_out;
16665 octave_value _outv;
16680 arg2 =
static_cast< int >(val2);
16681 if (arg1) (arg1)->pY = arg2;
16682 _outv = octave_value();
16686 return octave_value_list();
16698 octave_value_list _out;
16699 octave_value_list *_outp=&_out;
16700 octave_value _outv;
16712 result = (int) ((arg1)->pY);
16717 return octave_value_list();
16732 octave_value_list _out;
16733 octave_value_list *_outp=&_out;
16734 octave_value _outv;
16749 arg2 =
static_cast< PLFLT >(val2);
16750 if (arg1) (arg1)->dX = arg2;
16751 _outv = octave_value();
16755 return octave_value_list();
16767 octave_value_list _out;
16768 octave_value_list *_outp=&_out;
16769 octave_value _outv;
16781 result = (
PLFLT) ((arg1)->dX);
16786 return octave_value_list();
16801 octave_value_list _out;
16802 octave_value_list *_outp=&_out;
16803 octave_value _outv;
16818 arg2 =
static_cast< PLFLT >(val2);
16819 if (arg1) (arg1)->dY = arg2;
16820 _outv = octave_value();
16824 return octave_value_list();
16836 octave_value_list _out;
16837 octave_value_list *_outp=&_out;
16838 octave_value _outv;
16850 result = (
PLFLT) ((arg1)->dY);
16855 return octave_value_list();
16870 octave_value_list _out;
16871 octave_value_list *_outp=&_out;
16872 octave_value _outv;
16887 arg2 =
static_cast< PLFLT >(val2);
16888 if (arg1) (arg1)->wX = arg2;
16889 _outv = octave_value();
16893 return octave_value_list();
16905 octave_value_list _out;
16906 octave_value_list *_outp=&_out;
16907 octave_value _outv;
16919 result = (
PLFLT) ((arg1)->wX);
16924 return octave_value_list();
16939 octave_value_list _out;
16940 octave_value_list *_outp=&_out;
16941 octave_value _outv;
16956 arg2 =
static_cast< PLFLT >(val2);
16957 if (arg1) (arg1)->wY = arg2;
16958 _outv = octave_value();
16962 return octave_value_list();
16974 octave_value_list _out;
16975 octave_value_list *_outp=&_out;
16976 octave_value _outv;
16988 result = (
PLFLT) ((arg1)->wY);
16993 return octave_value_list();
17002 octave_value_list _out;
17003 octave_value_list *_outp=&_out;
17004 octave_value _outv;
17016 return octave_value_list();
17028 octave_value_list _out;
17029 octave_value_list *_outp=&_out;
17030 octave_value _outv;
17042 _outv = octave_value();
17046 return octave_value_list();
17080 octave_value_list _out;
17081 octave_value_list *_outp=&_out;
17082 octave_value _outv;
17092 arg1 =
static_cast< PLINT >(val1);
17097 arg2 =
static_cast< PLINT >(val2);
17099 _outv = octave_value();
17103 return octave_value_list();
17124 octave_value_list _out;
17125 octave_value_list *_outp=&_out;
17126 octave_value _outv;
17136 arg1 =
static_cast< PLFLT >(val1);
17141 arg2 =
static_cast< PLFLT >(val2);
17146 arg3 =
static_cast< PLFLT >(val3);
17151 arg4 =
static_cast< PLINT >(val4);
17153 _outv = octave_value();
17157 return octave_value_list();
17169 octave_value_list _out;
17170 octave_value_list *_outp=&_out;
17171 octave_value _outv;
17181 arg1 =
static_cast< PLINT >(val1);
17183 _outv = octave_value();
17187 return octave_value_list();
17220 octave_value_list _out;
17221 octave_value_list *_outp=&_out;
17222 octave_value _outv;
17232 arg1 =
static_cast< PLFLT >(val1);
17237 arg2 =
static_cast< PLFLT >(val2);
17242 arg3 =
static_cast< PLFLT >(val3);
17247 arg4 =
static_cast< PLFLT >(val4);
17252 arg5 =
static_cast< PLFLT >(val5);
17257 arg6 =
static_cast< PLFLT >(val6);
17262 arg7 =
static_cast< PLFLT >(val7);
17267 arg8 =
static_cast< PLBOOL >(val8);
17268 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
17269 _outv = octave_value();
17273 return octave_value_list();
17284 char *arg3 = (
char *) 0 ;
17287 char *arg6 = (
char *) 0 ;
17308 octave_value_list _out;
17309 octave_value_list *_outp=&_out;
17310 octave_value _outv;
17320 arg1 =
static_cast< PLFLT >(val1);
17325 arg2 =
static_cast< PLFLT >(val2);
17330 arg3 =
reinterpret_cast< char *
>(buf3);
17335 arg4 =
static_cast< PLFLT >(val4);
17340 arg5 =
static_cast< PLINT >(val5);
17345 arg6 =
reinterpret_cast< char *
>(buf6);
17350 arg7 =
static_cast< PLFLT >(val7);
17355 arg8 =
static_cast< PLINT >(val8);
17356 plaxes(arg1,arg2,(
char const *)arg3,arg4,arg5,(
char const *)arg6,arg7,arg8);
17357 _outv = octave_value();
17365 return octave_value_list();
17384 octave_value_list _out;
17385 octave_value_list *_outp=&_out;
17386 octave_value _outv;
17393 if (
_n_dims( args(0) ) > 1 )
17398 temp1 = args(0).matrix_value();
17399 arg2 = &temp1( 0, 0 );
17402 if (
_n_dims( args(1) ) > 1 )
17410 temp3 = args(1).matrix_value();
17411 arg3 = &temp3( 0, 0 );
17417 arg4 =
static_cast< PLINT >(val4);
17418 plbin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
17419 _outv = octave_value();
17435 return octave_value_list();
17471 octave_value_list _out;
17472 octave_value_list *_outp=&_out;
17473 octave_value _outv;
17489 arg7 =
static_cast< PLFLT >(val7);
17490 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17491 _outv = octave_value();
17531 return octave_value_list();
17540 octave_value_list _out;
17541 octave_value_list *_outp=&_out;
17542 octave_value _outv;
17549 _outv = octave_value();
17553 return octave_value_list();
17562 char *arg1 = (
char *) 0 ;
17565 char *arg4 = (
char *) 0 ;
17582 octave_value_list _out;
17583 octave_value_list *_outp=&_out;
17584 octave_value _outv;
17594 arg1 =
reinterpret_cast< char *
>(buf1);
17599 arg2 =
static_cast< PLFLT >(val2);
17604 arg3 =
static_cast< PLINT >(val3);
17609 arg4 =
reinterpret_cast< char *
>(buf4);
17614 arg5 =
static_cast< PLFLT >(val5);
17619 arg6 =
static_cast< PLINT >(val6);
17620 plbox((
char const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6);
17621 _outv = octave_value();
17629 return octave_value_list();
17640 char *arg1 = (
char *) 0 ;
17641 char *arg2 = (
char *) 0 ;
17644 char *arg5 = (
char *) 0 ;
17645 char *arg6 = (
char *) 0 ;
17648 char *arg9 = (
char *) 0 ;
17649 char *arg10 = (
char *) 0 ;
17682 octave_value_list _out;
17683 octave_value_list *_outp=&_out;
17684 octave_value _outv;
17694 arg1 =
reinterpret_cast< char *
>(buf1);
17699 arg2 =
reinterpret_cast< char *
>(buf2);
17704 arg3 =
static_cast< PLFLT >(val3);
17709 arg4 =
static_cast< PLINT >(val4);
17714 arg5 =
reinterpret_cast< char *
>(buf5);
17719 arg6 =
reinterpret_cast< char *
>(buf6);
17724 arg7 =
static_cast< PLFLT >(val7);
17729 arg8 =
static_cast< PLINT >(val8);
17734 arg9 =
reinterpret_cast< char *
>(buf9);
17739 arg10 =
reinterpret_cast< char *
>(buf10);
17744 arg11 =
static_cast< PLFLT >(val11);
17749 arg12 =
static_cast< PLINT >(val12);
17750 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);
17751 _outv = octave_value();
17767 return octave_value_list();
17797 octave_value_list _out;
17798 octave_value_list *_outp=&_out;
17799 octave_value _outv;
17812 arg1 =
static_cast< PLFLT >(val1);
17817 arg2 =
static_cast< PLFLT >(val2);
17819 _outv = octave_value();
17841 return octave_value_list();
17850 octave_value_list _out;
17851 octave_value_list *_outp=&_out;
17852 octave_value _outv;
17859 _outv = octave_value();
17863 return octave_value_list();
17875 octave_value_list _out;
17876 octave_value_list *_outp=&_out;
17877 octave_value _outv;
17887 arg1 =
static_cast< PLINT >(val1);
17889 _outv = octave_value();
17893 return octave_value_list();
17905 octave_value_list _out;
17906 octave_value_list *_outp=&_out;
17907 octave_value _outv;
17917 arg1 =
static_cast< PLFLT >(val1);
17919 _outv = octave_value();
17923 return octave_value_list();
17965 octave_value_list _out;
17966 octave_value_list *_outp=&_out;
17967 octave_value _outv;
17977 arg1 =
static_cast< PLFLT >(val1);
17982 arg2 =
static_cast< PLFLT >(val2);
17987 arg3 =
static_cast< PLFLT >(val3);
17992 arg4 =
static_cast< PLINT >(val4);
17997 arg5 =
static_cast< PLBOOL >(val5);
18002 arg6 =
static_cast< PLINT >(val6);
18007 arg7 =
static_cast< PLINT >(val7);
18012 arg8 =
static_cast< PLINT >(val8);
18017 arg9 =
static_cast< PLINT >(val9);
18022 arg10 =
static_cast< PLINT >(val10);
18027 arg11 =
static_cast< PLFLT >(val11);
18028 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
18029 _outv = octave_value();
18033 return octave_value_list();
18063 octave_value_list _out;
18064 octave_value_list *_outp=&_out;
18065 octave_value _outv;
18076 arg1 =
static_cast< PLINT >(val1);
18081 arg2 =
static_cast< PLINT >(val2);
18086 arg3 =
static_cast< PLINT >(val3);
18091 arg4 =
static_cast< PLINT >(val4);
18096 arg5 =
static_cast< PLINT >(val5);
18101 arg6 =
static_cast< PLFLT >(val6);
18102 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
18103 _outv = octave_value();
18113 return octave_value_list();
18128 octave_value_list _out;
18129 octave_value_list *_outp=&_out;
18130 octave_value _outv;
18140 arg1 =
static_cast< PLINT >(val1);
18145 arg2 =
static_cast< PLBOOL >(val2);
18147 _outv = octave_value();
18151 return octave_value_list();
18160 octave_value_list _out;
18161 octave_value_list *_outp=&_out;
18162 octave_value _outv;
18169 _outv = octave_value();
18173 return octave_value_list();
18182 octave_value_list _out;
18183 octave_value_list *_outp=&_out;
18184 octave_value _outv;
18191 _outv = octave_value();
18195 return octave_value_list();
18222 octave_value_list _out;
18223 octave_value_list *_outp=&_out;
18224 octave_value _outv;
18234 arg1 =
static_cast< PLFLT >(val1);
18239 arg2 =
static_cast< PLFLT >(val2);
18244 arg3 =
static_cast< PLFLT >(val3);
18249 arg4 =
static_cast< PLFLT >(val4);
18254 arg5 =
static_cast< PLINT >(val5);
18259 arg6 =
static_cast< PLINT >(val6);
18260 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
18261 _outv = octave_value();
18265 return octave_value_list();
18292 octave_value_list _out;
18293 octave_value_list *_outp=&_out;
18294 octave_value _outv;
18304 arg1 =
static_cast< PLFLT >(val1);
18309 arg2 =
static_cast< PLFLT >(val2);
18314 arg3 =
static_cast< PLFLT >(val3);
18319 arg4 =
static_cast< PLFLT >(val4);
18324 arg5 =
static_cast< PLINT >(val5);
18329 arg6 =
static_cast< PLINT >(val6);
18330 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
18331 _outv = octave_value();
18335 return octave_value_list();
18344 octave_value_list _out;
18345 octave_value_list *_outp=&_out;
18346 octave_value _outv;
18353 _outv = octave_value();
18357 return octave_value_list();
18373 octave_value_list _out;
18374 octave_value_list *_outp=&_out;
18375 octave_value _outv;
18382 if (
_n_dims( args(0) ) > 1 )
18387 temp1 = args(0).matrix_value();
18388 arg2 = &temp1( 0, 0 );
18391 if (
_n_dims( args(1) ) > 1 )
18399 temp3 = args(1).matrix_value();
18400 arg3 = &temp3( 0, 0 );
18403 if (
_n_dims( args(2) ) > 1 )
18411 temp4 = args(2).matrix_value();
18412 arg4 = &temp4( 0, 0 );
18414 plerrx(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18415 _outv = octave_value();
18437 return octave_value_list();
18462 octave_value_list _out;
18463 octave_value_list *_outp=&_out;
18464 octave_value _outv;
18471 if (
_n_dims( args(0) ) > 1 )
18476 temp1 = args(0).matrix_value();
18477 arg2 = &temp1( 0, 0 );
18480 if (
_n_dims( args(1) ) > 1 )
18488 temp3 = args(1).matrix_value();
18489 arg3 = &temp3( 0, 0 );
18492 if (
_n_dims( args(2) ) > 1 )
18500 temp4 = args(2).matrix_value();
18501 arg4 = &temp4( 0, 0 );
18503 plerry(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18504 _outv = octave_value();
18526 return octave_value_list();
18544 octave_value_list _out;
18545 octave_value_list *_outp=&_out;
18546 octave_value _outv;
18553 _outv = octave_value();
18557 return octave_value_list();
18571 octave_value_list _out;
18572 octave_value_list *_outp=&_out;
18573 octave_value _outv;
18580 if (
_n_dims( args(0) ) > 1 )
18585 temp1 = args(0).matrix_value();
18586 arg2 = &temp1( 0, 0 );
18589 if (
_n_dims( args(1) ) > 1 )
18597 temp3 = args(1).matrix_value();
18598 arg3 = &temp3( 0, 0 );
18600 plfill(arg1,(
double const *)arg2,(
double const *)arg3);
18601 _outv = octave_value();
18617 return octave_value_list();
18639 octave_value_list _out;
18640 octave_value_list *_outp=&_out;
18641 octave_value _outv;
18648 if (
_n_dims( args(0) ) > 1 )
18653 temp1 = args(0).matrix_value();
18654 arg2 = &temp1( 0, 0 );
18657 if (
_n_dims( args(1) ) > 1 )
18665 temp3 = args(1).matrix_value();
18666 arg3 = &temp3( 0, 0 );
18669 if (
_n_dims( args(2) ) > 1 )
18677 temp4 = args(2).matrix_value();
18678 arg4 = &temp4( 0, 0 );
18680 plfill3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18681 _outv = octave_value();
18703 return octave_value_list();
18729 octave_value_list _out;
18730 octave_value_list *_outp=&_out;
18731 octave_value _outv;
18738 if (
_n_dims( args(0) ) > 1 )
18743 temp1 = args(0).matrix_value();
18744 arg2 = &temp1( 0, 0 );
18747 if (
_n_dims( args(1) ) > 1 )
18755 temp3 = args(1).matrix_value();
18756 arg3 = &temp3( 0, 0 );
18762 arg4 =
static_cast< PLFLT >(val4);
18763 plgradient(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
18764 _outv = octave_value();
18780 return octave_value_list();
18795 octave_value_list _out;
18796 octave_value_list *_outp=&_out;
18797 octave_value _outv;
18804 _outv = octave_value();
18808 return octave_value_list();
18820 octave_value_list _out;
18821 octave_value_list *_outp=&_out;
18822 octave_value _outv;
18832 arg1 =
static_cast< PLINT >(val1);
18834 _outv = octave_value();
18838 return octave_value_list();
18850 octave_value_list _out;
18851 octave_value_list *_outp=&_out;
18852 octave_value _outv;
18862 arg1 =
static_cast< PLINT >(val1);
18864 _outv = octave_value();
18868 return octave_value_list();
18883 octave_value_list _out;
18884 octave_value_list *_outp=&_out;
18885 octave_value _outv;
18894 _outv = octave_value();
18910 return octave_value_list();
18931 octave_value_list _out;
18932 octave_value_list *_outp=&_out;
18933 octave_value _outv;
18946 arg1 =
static_cast< PLINT >(val1);
18947 plgcol0(arg1,arg2,arg3,arg4);
18948 _outv = octave_value();
18970 return octave_value_list();
18994 octave_value_list _out;
18995 octave_value_list *_outp=&_out;
18996 octave_value _outv;
19010 arg1 =
static_cast< PLINT >(val1);
19011 plgcol0a(arg1,arg2,arg3,arg4,arg5);
19012 _outv = octave_value();
19040 return octave_value_list();
19058 octave_value_list _out;
19059 octave_value_list *_outp=&_out;
19060 octave_value _outv;
19070 _outv = octave_value();
19092 return octave_value_list();
19113 octave_value_list _out;
19114 octave_value_list *_outp=&_out;
19115 octave_value _outv;
19126 _outv = octave_value();
19154 return octave_value_list();
19166 octave_value_list _out;
19167 octave_value_list *_outp=&_out;
19168 octave_value _outv;
19176 _outv = octave_value();
19186 return octave_value_list();
19195 char *arg1 = (
char *) 0 ;
19196 char local_string1[80] ;
19197 size_t local_string_length1 ;
19198 charMatrix local_charMatrix1 ;
19199 octave_value_list retval1 ;
19200 octave_value_list _out;
19201 octave_value_list *_outp=&_out;
19202 octave_value _outv;
19206 arg1 = local_string1;
19212 _outv = octave_value();
19215 local_string_length1 = strlen( local_string1 );
19216 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19217 local_charMatrix1.insert( local_string1, 0, 0 );
19218 retval1( 0 ) = octave_value( local_charMatrix1 );
19223 return octave_value_list();
19244 octave_value_list _out;
19245 octave_value_list *_outp=&_out;
19246 octave_value _outv;
19257 _outv = octave_value();
19285 return octave_value_list();
19297 octave_value_list _out;
19298 octave_value_list *_outp=&_out;
19299 octave_value _outv;
19307 _outv = octave_value();
19317 return octave_value_list();
19338 octave_value_list _out;
19339 octave_value_list *_outp=&_out;
19340 octave_value _outv;
19351 _outv = octave_value();
19379 return octave_value_list();
19397 octave_value_list _out;
19398 octave_value_list *_outp=&_out;
19399 octave_value _outv;
19409 _outv = octave_value();
19431 return octave_value_list();
19443 octave_value_list _out;
19444 octave_value_list *_outp=&_out;
19445 octave_value _outv;
19453 _outv = octave_value();
19463 return octave_value_list();
19472 char *arg1 = (
char *) 0 ;
19473 char local_string1[80] ;
19474 size_t local_string_length1 ;
19475 charMatrix local_charMatrix1 ;
19476 octave_value_list retval1 ;
19477 octave_value_list _out;
19478 octave_value_list *_outp=&_out;
19479 octave_value _outv;
19483 arg1 = local_string1;
19489 _outv = octave_value();
19492 local_string_length1 = strlen( local_string1 );
19493 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19494 local_charMatrix1.insert( local_string1, 0, 0 );
19495 retval1( 0 ) = octave_value( local_charMatrix1 );
19500 return octave_value_list();
19518 octave_value_list _out;
19519 octave_value_list *_outp=&_out;
19520 octave_value _outv;
19530 _outv = octave_value();
19552 return octave_value_list();
19564 octave_value_list _out;
19565 octave_value_list *_outp=&_out;
19566 octave_value _outv;
19574 _outv = octave_value();
19584 return octave_value_list();
19611 octave_value_list _out;
19612 octave_value_list *_outp=&_out;
19613 octave_value _outv;
19625 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
19626 _outv = octave_value();
19666 return octave_value_list();
19675 octave_value_list _out;
19676 octave_value_list *_outp=&_out;
19677 octave_value _outv;
19684 _outv = octave_value();
19688 return octave_value_list();
19709 octave_value_list _out;
19710 octave_value_list *_outp=&_out;
19711 octave_value _outv;
19721 plgspa(arg1,arg2,arg3,arg4);
19722 _outv = octave_value();
19750 return octave_value_list();
19762 octave_value_list _out;
19763 octave_value_list *_outp=&_out;
19764 octave_value _outv;
19772 _outv = octave_value();
19782 return octave_value_list();
19791 char *arg1 = (
char *) 0 ;
19792 char local_string1[80] ;
19793 size_t local_string_length1 ;
19794 charMatrix local_charMatrix1 ;
19795 octave_value_list retval1 ;
19796 octave_value_list _out;
19797 octave_value_list *_outp=&_out;
19798 octave_value _outv;
19802 arg1 = local_string1;
19808 _outv = octave_value();
19811 local_string_length1 = strlen( local_string1 );
19812 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19813 local_charMatrix1.insert( local_string1, 0, 0 );
19814 retval1( 0 ) = octave_value( local_charMatrix1 );
19819 return octave_value_list();
19840 octave_value_list _out;
19841 octave_value_list *_outp=&_out;
19842 octave_value _outv;
19852 plgvpd(arg1,arg2,arg3,arg4);
19853 _outv = octave_value();
19881 return octave_value_list();
19902 octave_value_list _out;
19903 octave_value_list *_outp=&_out;
19904 octave_value _outv;
19914 plgvpw(arg1,arg2,arg3,arg4);
19915 _outv = octave_value();
19943 return octave_value_list();
19958 octave_value_list _out;
19959 octave_value_list *_outp=&_out;
19960 octave_value _outv;
19969 _outv = octave_value();
19985 return octave_value_list();
20000 octave_value_list _out;
20001 octave_value_list *_outp=&_out;
20002 octave_value _outv;
20011 _outv = octave_value();
20027 return octave_value_list();
20042 octave_value_list _out;
20043 octave_value_list *_outp=&_out;
20044 octave_value _outv;
20053 _outv = octave_value();
20069 return octave_value_list();
20093 octave_value_list _out;
20094 octave_value_list *_outp=&_out;
20095 octave_value _outv;
20102 if (
_n_dims( args(0) ) > 1 )
20107 temp1 = args(0).matrix_value();
20108 arg2 = &temp1( 0, 0 );
20114 arg3 =
static_cast< PLFLT >(val3);
20119 arg4 =
static_cast< PLFLT >(val4);
20124 arg5 =
static_cast< PLINT >(val5);
20129 arg6 =
static_cast< PLINT >(val6);
20130 plhist(arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
20131 _outv = octave_value();
20141 return octave_value_list();
20171 octave_value_list _out;
20172 octave_value_list *_outp=&_out;
20173 octave_value _outv;
20186 arg1 =
static_cast< PLFLT >(val1);
20191 arg2 =
static_cast< PLFLT >(val2);
20196 arg3 =
static_cast< PLFLT >(val3);
20197 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
20198 _outv = octave_value();
20220 return octave_value_list();
20229 octave_value_list _out;
20230 octave_value_list *_outp=&_out;
20231 octave_value _outv;
20238 _outv = octave_value();
20242 return octave_value_list();
20263 octave_value_list _out;
20264 octave_value_list *_outp=&_out;
20265 octave_value _outv;
20275 arg1 =
static_cast< PLFLT >(val1);
20280 arg2 =
static_cast< PLFLT >(val2);
20285 arg3 =
static_cast< PLFLT >(val3);
20290 arg4 =
static_cast< PLFLT >(val4);
20291 pljoin(arg1,arg2,arg3,arg4);
20292 _outv = octave_value();
20296 return octave_value_list();
20305 char *arg1 = (
char *) 0 ;
20306 char *arg2 = (
char *) 0 ;
20307 char *arg3 = (
char *) 0 ;
20317 octave_value_list _out;
20318 octave_value_list *_outp=&_out;
20319 octave_value _outv;
20329 arg1 =
reinterpret_cast< char *
>(buf1);
20334 arg2 =
reinterpret_cast< char *
>(buf2);
20339 arg3 =
reinterpret_cast< char *
>(buf3);
20340 pllab((
char const *)arg1,(
char const *)arg2,(
char const *)arg3);
20341 _outv = octave_value();
20351 return octave_value_list();
20382 char **arg20 = (
char **) 0 ;
20393 char **arg31 = (
char **) 0 ;
20438 octave_value_list _out;
20439 octave_value_list *_outp=&_out;
20440 octave_value _outv;
20452 arg3 =
static_cast< PLINT >(val3);
20457 arg4 =
static_cast< PLINT >(val4);
20462 arg5 =
static_cast< PLFLT >(val5);
20467 arg6 =
static_cast< PLFLT >(val6);
20472 arg7 =
static_cast< PLFLT >(val7);
20477 arg8 =
static_cast< PLINT >(val8);
20482 arg9 =
static_cast< PLINT >(val9);
20487 arg10 =
static_cast< PLINT >(val10);
20492 arg11 =
static_cast< PLINT >(val11);
20497 arg12 =
static_cast< PLINT >(val12);
20499 if (
_n_dims( args(10) ) > 1 )
20505 temp13 = args(10).matrix_value();
20512 arg15 =
static_cast< PLFLT >(val15);
20517 arg16 =
static_cast< PLFLT >(val16);
20522 arg17 =
static_cast< PLFLT >(val17);
20527 arg18 =
static_cast< PLFLT >(val18);
20529 if (
_n_dims( args(15) ) > 1 )
20533 if (
_dim( args(15), 0 ) !=
Alen )
20537 temp19 = args(15).matrix_value();
20542 charMatrix temp_matrix;
20546 size_t max_length = 0, non_blank_length;
20548 if (
_n_dims( args(16) ) > 2 )
20550 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
20552#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20553 if ( !args(16).isempty() )
20555 if ( !args(16).is_empty() )
20558 if (
_dim( args(16), 0 ) !=
Alen )
20560 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
20562 arg20 =
new char*[
Alen];
20563#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20564 ifcell = args(16).iscell();
20566 ifcell = args(16).is_cell();
20570 temp_cell = args(16).cell_value();
20574 temp_matrix = args(16).char_matrix_value();
20576 max_length =
_dim( args(16), 1 ) + 1;
20579 for ( i = 0; i <
Alen; i++ )
20586 if ( temp_cell.elem( i ).is_string() )
20588 str = temp_cell.elem( i ).string_value();
20590 max_length = str.size() + 1;
20591 tmp_cstring = (
char *) str.c_str();
20601 tmp_cstring = (
char *)
"";
20606 str = temp_matrix.row_as_string( i );
20607 tmp_cstring = (
char *) str.c_str();
20609 arg20[i] =
new char[max_length];
20610 strncpy( arg20[i], tmp_cstring, max_length - 1 );
20611 arg20[i][max_length - 1] =
'\0';
20626 non_blank_length = max_length - 2;
20627 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
20629 non_blank_length--;
20631 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
20633 non_blank_length--;
20635 arg20[i][non_blank_length + 1] =
'\0';
20645 if (
_n_dims( args(17) ) > 1 )
20649#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20650 if ( !args(17).isempty() )
20652 if ( !args(17).is_empty() )
20655 if (
_dim( args(17), 0 ) !=
Alen )
20659 temp21 = args(17).matrix_value();
20669 if (
_n_dims( args(18) ) > 1 )
20673#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20674 if ( !args(18).isempty() )
20676 if ( !args(18).is_empty() )
20679 if (
_dim( args(18), 0 ) !=
Alen )
20683 temp22 = args(18).matrix_value();
20693 if (
_n_dims( args(19) ) > 1 )
20697#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20698 if ( !args(19).isempty() )
20700 if ( !args(19).is_empty() )
20703 if (
_dim( args(19), 0 ) !=
Alen )
20707 temp23 = args(19).matrix_value();
20708 arg23 = &temp23( 0, 0 );
20716 if (
_n_dims( args(20) ) > 1 )
20720#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20721 if ( !args(20).isempty() )
20723 if ( !args(20).is_empty() )
20726 if (
_dim( args(20), 0 ) !=
Alen )
20730 temp24 = args(20).matrix_value();
20731 arg24 = &temp24( 0, 0 );
20739 if (
_n_dims( args(21) ) > 1 )
20743#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20744 if ( !args(21).isempty() )
20746 if ( !args(21).is_empty() )
20749 if (
_dim( args(21), 0 ) !=
Alen )
20753 temp25 = args(21).matrix_value();
20763 if (
_n_dims( args(22) ) > 1 )
20767#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20768 if ( !args(22).isempty() )
20770 if ( !args(22).is_empty() )
20773 if (
_dim( args(22), 0 ) !=
Alen )
20777 temp26 = args(22).matrix_value();
20787 if (
_n_dims( args(23) ) > 1 )
20791#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20792 if ( !args(23).isempty() )
20794 if ( !args(23).is_empty() )
20797 if (
_dim( args(23), 0 ) !=
Alen )
20801 temp27 = args(23).matrix_value();
20802 arg27 = &temp27( 0, 0 );
20810 if (
_n_dims( args(24) ) > 1 )
20814#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20815 if ( !args(24).isempty() )
20817 if ( !args(24).is_empty() )
20820 if (
_dim( args(24), 0 ) !=
Alen )
20824 temp28 = args(24).matrix_value();
20834 if (
_n_dims( args(25) ) > 1 )
20838#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20839 if ( !args(25).isempty() )
20841 if ( !args(25).is_empty() )
20844 if (
_dim( args(25), 0 ) !=
Alen )
20848 temp29 = args(25).matrix_value();
20849 arg29 = &temp29( 0, 0 );
20857 if (
_n_dims( args(26) ) > 1 )
20861#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20862 if ( !args(26).isempty() )
20864 if ( !args(26).is_empty() )
20867 if (
_dim( args(26), 0 ) !=
Alen )
20871 temp30 = args(26).matrix_value();
20881 charMatrix temp_matrix;
20885 size_t max_length = 0, non_blank_length;
20887 if (
_n_dims( args(27) ) > 2 )
20889 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
20891#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20892 if ( !args(27).isempty() )
20894 if ( !args(27).is_empty() )
20897 if (
_dim( args(27), 0 ) !=
Alen )
20899 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
20901 arg31 =
new char*[
Alen];
20902#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20903 ifcell = args(27).iscell();
20905 ifcell = args(27).is_cell();
20909 temp_cell = args(27).cell_value();
20913 temp_matrix = args(27).char_matrix_value();
20915 max_length =
_dim( args(27), 1 ) + 1;
20918 for ( i = 0; i <
Alen; i++ )
20925 if ( temp_cell.elem( i ).is_string() )
20927 str = temp_cell.elem( i ).string_value();
20929 max_length = str.size() + 1;
20930 tmp_cstring = (
char *) str.c_str();
20940 tmp_cstring = (
char *)
"";
20945 str = temp_matrix.row_as_string( i );
20946 tmp_cstring = (
char *) str.c_str();
20948 arg31[i] =
new char[max_length];
20949 strncpy( arg31[i], tmp_cstring, max_length - 1 );
20950 arg31[i][max_length - 1] =
'\0';
20965 non_blank_length = max_length - 2;
20966 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
'\0' )
20968 non_blank_length--;
20970 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
' ' )
20972 non_blank_length--;
20974 arg31[i][non_blank_length + 1] =
'\0';
20983 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);
20984 _outv = octave_value();
21006 if ( arg20 != NULL )
21008 for ( i = 0; i <
Alen; i++ )
21016 if ( arg21 != NULL )
21020 if ( arg22 != NULL )
21030 if ( arg25 != NULL )
21034 if ( arg26 != NULL )
21041 if ( arg28 != NULL )
21048 if ( arg30 != NULL )
21053 if ( arg31 != NULL )
21055 for ( i = 0; i <
Alen; i++ )
21072 if ( arg20 != NULL )
21074 for ( i = 0; i <
Alen; i++ )
21082 if ( arg21 != NULL )
21086 if ( arg22 != NULL )
21096 if ( arg25 != NULL )
21100 if ( arg26 != NULL )
21107 if ( arg28 != NULL )
21114 if ( arg30 != NULL )
21119 if ( arg31 != NULL )
21121 for ( i = 0; i <
Alen; i++ )
21128 return octave_value_list();
21139 if ( arg20 != NULL )
21141 for ( i = 0; i <
Alen; i++ )
21149 if ( arg21 != NULL )
21153 if ( arg22 != NULL )
21163 if ( arg25 != NULL )
21167 if ( arg26 != NULL )
21174 if ( arg28 != NULL )
21181 if ( arg30 != NULL )
21186 if ( arg31 != NULL )
21188 for ( i = 0; i <
Alen; i++ )
21210 octave_value_list _out;
21211 octave_value_list *_outp=&_out;
21212 octave_value _outv;
21222 arg1 =
static_cast< PLFLT >(val1);
21227 arg2 =
static_cast< PLFLT >(val2);
21232 arg3 =
static_cast< PLFLT >(val3);
21234 _outv = octave_value();
21238 return octave_value_list();
21252 octave_value_list _out;
21253 octave_value_list *_outp=&_out;
21254 octave_value _outv;
21261 if (
_n_dims( args(0) ) > 1 )
21266 temp1 = args(0).matrix_value();
21267 arg2 = &temp1( 0, 0 );
21270 if (
_n_dims( args(1) ) > 1 )
21278 temp3 = args(1).matrix_value();
21279 arg3 = &temp3( 0, 0 );
21281 plline(arg1,(
double const *)arg2,(
double const *)arg3);
21282 _outv = octave_value();
21298 return octave_value_list();
21320 octave_value_list _out;
21321 octave_value_list *_outp=&_out;
21322 octave_value _outv;
21329 if (
_n_dims( args(0) ) > 1 )
21334 temp1 = args(0).matrix_value();
21335 arg2 = &temp1( 0, 0 );
21338 if (
_n_dims( args(1) ) > 1 )
21346 temp3 = args(1).matrix_value();
21347 arg3 = &temp3( 0, 0 );
21350 if (
_n_dims( args(2) ) > 1 )
21358 temp4 = args(2).matrix_value();
21359 arg4 = &temp4( 0, 0 );
21361 plline3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
21362 _outv = octave_value();
21384 return octave_value_list();
21405 octave_value_list _out;
21406 octave_value_list *_outp=&_out;
21407 octave_value _outv;
21417 arg1 =
static_cast< PLINT >(val1);
21419 _outv = octave_value();
21423 return octave_value_list();
21435 octave_value_list _out;
21436 octave_value_list *_outp=&_out;
21437 octave_value _outv;
21445 _outv = octave_value();
21455 return octave_value_list();
21464 char *arg1 = (
char *) 0 ;
21468 char *arg5 = (
char *) 0 ;
21481 octave_value_list _out;
21482 octave_value_list *_outp=&_out;
21483 octave_value _outv;
21493 arg1 =
reinterpret_cast< char *
>(buf1);
21498 arg2 =
static_cast< PLFLT >(val2);
21503 arg3 =
static_cast< PLFLT >(val3);
21508 arg4 =
static_cast< PLFLT >(val4);
21513 arg5 =
reinterpret_cast< char *
>(buf5);
21514 plmtex((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
21515 _outv = octave_value();
21523 return octave_value_list();
21534 char *arg1 = (
char *) 0 ;
21538 char *arg5 = (
char *) 0 ;
21551 octave_value_list _out;
21552 octave_value_list *_outp=&_out;
21553 octave_value _outv;
21563 arg1 =
reinterpret_cast< char *
>(buf1);
21568 arg2 =
static_cast< PLFLT >(val2);
21573 arg3 =
static_cast< PLFLT >(val3);
21578 arg4 =
static_cast< PLFLT >(val4);
21583 arg5 =
reinterpret_cast< char *
>(buf5);
21584 plmtex3((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
21585 _outv = octave_value();
21593 return octave_value_list();
21604 int *arg1 = (
int *) 0 ;
21605 char **arg2 = (
char **) 0 ;
21613 octave_value_list _out;
21614 octave_value_list *_outp=&_out;
21615 octave_value _outv;
21626 arg1 =
reinterpret_cast< int *
>(argp1);
21631 arg2 =
reinterpret_cast< char **
>(argp2);
21636 arg3 =
static_cast< PLINT >(val3);
21642 return octave_value_list();
21656 octave_value_list _out;
21657 octave_value_list *_outp=&_out;
21658 octave_value _outv;
21665 if (
_n_dims( args(0) ) > 1 )
21671 temp1 = args(0).matrix_value();
21675 if (
_n_dims( args(1) ) > 1 )
21683 temp3 = args(1).matrix_value();
21687 plpat(arg1,(
int const *)arg2,(
int const *)arg3);
21688 _outv = octave_value();
21704 return octave_value_list();
21734 octave_value_list _out;
21735 octave_value_list *_outp=&_out;
21736 octave_value _outv;
21746 arg1 =
static_cast< PLINT >(val1);
21751 arg2 =
static_cast< PLFLT >(val2);
21756 arg3 =
static_cast< PLFLT >(val3);
21761 arg4 =
static_cast< PLFLT >(val4);
21766 arg5 =
static_cast< PLFLT >(val5);
21767 plpath(arg1,arg2,arg3,arg4,arg5);
21768 _outv = octave_value();
21772 return octave_value_list();
21789 octave_value_list _out;
21790 octave_value_list *_outp=&_out;
21791 octave_value _outv;
21798 if (
_n_dims( args(0) ) > 1 )
21803 temp1 = args(0).matrix_value();
21804 arg2 = &temp1( 0, 0 );
21807 if (
_n_dims( args(1) ) > 1 )
21815 temp3 = args(1).matrix_value();
21816 arg3 = &temp3( 0, 0 );
21822 arg4 =
static_cast< PLINT >(val4);
21823 plpoin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
21824 _outv = octave_value();
21840 return octave_value_list();
21865 octave_value_list _out;
21866 octave_value_list *_outp=&_out;
21867 octave_value _outv;
21874 if (
_n_dims( args(0) ) > 1 )
21879 temp1 = args(0).matrix_value();
21880 arg2 = &temp1( 0, 0 );
21883 if (
_n_dims( args(1) ) > 1 )
21891 temp3 = args(1).matrix_value();
21892 arg3 = &temp3( 0, 0 );
21895 if (
_n_dims( args(2) ) > 1 )
21903 temp4 = args(2).matrix_value();
21904 arg4 = &temp4( 0, 0 );
21910 arg5 =
static_cast< PLINT >(val5);
21911 plpoin3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,arg5);
21912 _outv = octave_value();
21934 return octave_value_list();
21964 octave_value_list _out;
21965 octave_value_list *_outp=&_out;
21966 octave_value _outv;
21973 if (
_n_dims( args(0) ) > 1 )
21978 temp1 = args(0).matrix_value();
21979 arg2 = &temp1( 0, 0 );
21982 if (
_n_dims( args(1) ) > 1 )
21990 temp3 = args(1).matrix_value();
21991 arg3 = &temp3( 0, 0 );
21994 if (
_n_dims( args(2) ) > 1 )
22002 temp4 = args(2).matrix_value();
22003 arg4 = &temp4( 0, 0 );
22006 if (
_n_dims( args(3) ) > 1 )
22012 error(
"argument vector must be same length or one less" );
SWIG_fail;
22014 temp5 = args(3).matrix_value();
22022 arg6 =
static_cast< PLBOOL >(val6);
22023 plpoly3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
int const *)arg5,arg6);
22024 _outv = octave_value();
22052 return octave_value_list();
22079 octave_value_list _out;
22080 octave_value_list *_outp=&_out;
22081 octave_value _outv;
22091 arg1 =
static_cast< PLINT >(val1);
22096 arg2 =
static_cast< PLINT >(val2);
22098 _outv = octave_value();
22102 return octave_value_list();
22114 octave_value_list _out;
22115 octave_value_list *_outp=&_out;
22116 octave_value _outv;
22126 arg1 =
static_cast< PLINT >(val1);
22128 _outv = octave_value();
22132 return octave_value_list();
22146 char *arg6 = (
char *) 0 ;
22160 octave_value_list _out;
22161 octave_value_list *_outp=&_out;
22162 octave_value _outv;
22172 arg1 =
static_cast< PLFLT >(val1);
22177 arg2 =
static_cast< PLFLT >(val2);
22182 arg3 =
static_cast< PLFLT >(val3);
22187 arg4 =
static_cast< PLFLT >(val4);
22192 arg5 =
static_cast< PLFLT >(val5);
22197 arg6 =
reinterpret_cast< char *
>(buf6);
22198 plptex(arg1,arg2,arg3,arg4,arg5,(
char const *)arg6);
22199 _outv = octave_value();
22205 return octave_value_list();
22225 char *arg11 = (
char *) 0 ;
22249 octave_value_list _out;
22250 octave_value_list *_outp=&_out;
22251 octave_value _outv;
22261 arg1 =
static_cast< PLFLT >(val1);
22266 arg2 =
static_cast< PLFLT >(val2);
22271 arg3 =
static_cast< PLFLT >(val3);
22276 arg4 =
static_cast< PLFLT >(val4);
22281 arg5 =
static_cast< PLFLT >(val5);
22286 arg6 =
static_cast< PLFLT >(val6);
22291 arg7 =
static_cast< PLFLT >(val7);
22296 arg8 =
static_cast< PLFLT >(val8);
22301 arg9 =
static_cast< PLFLT >(val9);
22306 arg10 =
static_cast< PLFLT >(val10);
22311 arg11 =
reinterpret_cast< char *
>(buf11);
22312 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(
char const *)arg11);
22313 _outv = octave_value();
22319 return octave_value_list();
22329 octave_value_list _out;
22330 octave_value_list *_outp=&_out;
22331 octave_value _outv;
22343 return octave_value_list();
22352 octave_value_list _out;
22353 octave_value_list *_outp=&_out;
22354 octave_value _outv;
22361 _outv = octave_value();
22365 return octave_value_list();
22392 octave_value_list _out;
22393 octave_value_list *_outp=&_out;
22394 octave_value _outv;
22407 arg1 =
static_cast< PLFLT >(val1);
22412 arg2 =
static_cast< PLFLT >(val2);
22417 arg3 =
static_cast< PLFLT >(val3);
22418 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
22419 _outv = octave_value();
22441 return octave_value_list();
22456 octave_value_list _out;
22457 octave_value_list *_outp=&_out;
22458 octave_value _outv;
22468 arg1 =
static_cast< PLFLT >(val1);
22473 arg2 =
static_cast< PLFLT >(val2);
22475 _outv = octave_value();
22479 return octave_value_list();
22495 octave_value_list _out;
22496 octave_value_list *_outp=&_out;
22497 octave_value _outv;
22504 if (
_n_dims( args(0) ) > 1 )
22509 temp1 = args(0).matrix_value();
22514 if (
_n_dims( args(1) ) > 1 )
22522 temp2 = args(1).matrix_value();
22527 if (
_n_dims( args(2) ) > 1 )
22535 temp3 = args(2).matrix_value();
22540 plscmap0((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
22541 _outv = octave_value();
22563 return octave_value_list();
22590 octave_value_list _out;
22591 octave_value_list *_outp=&_out;
22592 octave_value _outv;
22599 if (
_n_dims( args(0) ) > 1 )
22604 temp1 = args(0).matrix_value();
22609 if (
_n_dims( args(1) ) > 1 )
22617 temp2 = args(1).matrix_value();
22622 if (
_n_dims( args(2) ) > 1 )
22630 temp3 = args(2).matrix_value();
22635 if (
_n_dims( args(3) ) > 1 )
22643 temp4 = args(3).matrix_value();
22644 arg4 = &temp4( 0, 0 );
22647 plscmap0a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
22648 _outv = octave_value();
22676 return octave_value_list();
22700 octave_value_list _out;
22701 octave_value_list *_outp=&_out;
22702 octave_value _outv;
22712 arg1 =
static_cast< PLINT >(val1);
22714 _outv = octave_value();
22718 return octave_value_list();
22734 octave_value_list _out;
22735 octave_value_list *_outp=&_out;
22736 octave_value _outv;
22743 if (
_n_dims( args(0) ) > 1 )
22748 temp1 = args(0).matrix_value();
22753 if (
_n_dims( args(1) ) > 1 )
22761 temp2 = args(1).matrix_value();
22766 if (
_n_dims( args(2) ) > 1 )
22774 temp3 = args(2).matrix_value();
22779 plscmap1((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
22780 _outv = octave_value();
22802 return octave_value_list();
22829 octave_value_list _out;
22830 octave_value_list *_outp=&_out;
22831 octave_value _outv;
22838 if (
_n_dims( args(0) ) > 1 )
22843 temp1 = args(0).matrix_value();
22848 if (
_n_dims( args(1) ) > 1 )
22856 temp2 = args(1).matrix_value();
22861 if (
_n_dims( args(2) ) > 1 )
22869 temp3 = args(2).matrix_value();
22874 if (
_n_dims( args(3) ) > 1 )
22882 temp4 = args(3).matrix_value();
22883 arg4 = &temp4( 0, 0 );
22886 plscmap1a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
22887 _outv = octave_value();
22915 return octave_value_list();
22950 octave_value_list _out;
22951 octave_value_list *_outp=&_out;
22952 octave_value _outv;
22962 arg1 =
static_cast< PLBOOL >(val1);
22964 if (
_n_dims( args(1) ) > 1 )
22969 temp2 = args(1).matrix_value();
22970 arg3 = &temp2( 0, 0 );
22973 if (
_n_dims( args(2) ) > 1 )
22981 temp4 = args(2).matrix_value();
22982 arg4 = &temp4( 0, 0 );
22985 if (
_n_dims( args(3) ) > 1 )
22993 temp5 = args(3).matrix_value();
22994 arg5 = &temp5( 0, 0 );
22997 if (
_n_dims( args(4) ) > 1 )
23005 temp6 = args(4).matrix_value();
23006 arg6 = &temp6( 0, 0 );
23009 if (
_n_dims( args(5) ) > 1 )
23015 error(
"argument vector must be same length or one less" );
SWIG_fail;
23017 temp7 = args(5).matrix_value();
23021 plscmap1l(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
int const *)arg7);
23022 _outv = octave_value();
23056 return octave_value_list();
23096 octave_value_list _out;
23097 octave_value_list *_outp=&_out;
23098 octave_value _outv;
23108 arg1 =
static_cast< PLBOOL >(val1);
23110 if (
_n_dims( args(1) ) > 1 )
23115 temp2 = args(1).matrix_value();
23116 arg3 = &temp2( 0, 0 );
23119 if (
_n_dims( args(2) ) > 1 )
23127 temp4 = args(2).matrix_value();
23128 arg4 = &temp4( 0, 0 );
23131 if (
_n_dims( args(3) ) > 1 )
23139 temp5 = args(3).matrix_value();
23140 arg5 = &temp5( 0, 0 );
23143 if (
_n_dims( args(4) ) > 1 )
23151 temp6 = args(4).matrix_value();
23152 arg6 = &temp6( 0, 0 );
23155 if (
_n_dims( args(5) ) > 1 )
23163 temp7 = args(5).matrix_value();
23164 arg7 = &temp7( 0, 0 );
23167 if (
_n_dims( args(6) ) > 1 )
23173 error(
"argument vector must be same length or one less" );
SWIG_fail;
23175 temp8 = args(6).matrix_value();
23179 plscmap1la(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
double const *)arg7,(
int const *)arg8);
23180 _outv = octave_value();
23220 return octave_value_list();
23250 octave_value_list _out;
23251 octave_value_list *_outp=&_out;
23252 octave_value _outv;
23262 arg1 =
static_cast< PLINT >(val1);
23264 _outv = octave_value();
23268 return octave_value_list();
23283 octave_value_list _out;
23284 octave_value_list *_outp=&_out;
23285 octave_value _outv;
23295 arg1 =
static_cast< PLFLT >(val1);
23300 arg2 =
static_cast< PLFLT >(val2);
23302 _outv = octave_value();
23306 return octave_value_list();
23321 octave_value_list _out;
23322 octave_value_list *_outp=&_out;
23323 octave_value _outv;
23332 _outv = octave_value();
23348 return octave_value_list();
23369 octave_value_list _out;
23370 octave_value_list *_outp=&_out;
23371 octave_value _outv;
23381 arg1 =
static_cast< PLINT >(val1);
23386 arg2 =
static_cast< PLINT >(val2);
23391 arg3 =
static_cast< PLINT >(val3);
23396 arg4 =
static_cast< PLINT >(val4);
23397 plscol0(arg1,arg2,arg3,arg4);
23398 _outv = octave_value();
23402 return octave_value_list();
23426 octave_value_list _out;
23427 octave_value_list *_outp=&_out;
23428 octave_value _outv;
23438 arg1 =
static_cast< PLINT >(val1);
23443 arg2 =
static_cast< PLINT >(val2);
23448 arg3 =
static_cast< PLINT >(val3);
23453 arg4 =
static_cast< PLINT >(val4);
23458 arg5 =
static_cast< PLFLT >(val5);
23459 plscol0a(arg1,arg2,arg3,arg4,arg5);
23460 _outv = octave_value();
23464 return octave_value_list();
23482 octave_value_list _out;
23483 octave_value_list *_outp=&_out;
23484 octave_value _outv;
23494 arg1 =
static_cast< PLINT >(val1);
23499 arg2 =
static_cast< PLINT >(val2);
23504 arg3 =
static_cast< PLINT >(val3);
23506 _outv = octave_value();
23510 return octave_value_list();
23531 octave_value_list _out;
23532 octave_value_list *_outp=&_out;
23533 octave_value _outv;
23543 arg1 =
static_cast< PLINT >(val1);
23548 arg2 =
static_cast< PLINT >(val2);
23553 arg3 =
static_cast< PLINT >(val3);
23558 arg4 =
static_cast< PLFLT >(val4);
23560 _outv = octave_value();
23564 return octave_value_list();
23576 octave_value_list _out;
23577 octave_value_list *_outp=&_out;
23578 octave_value _outv;
23588 arg1 =
static_cast< PLINT >(val1);
23590 _outv = octave_value();
23594 return octave_value_list();
23606 octave_value_list _out;
23607 octave_value_list *_outp=&_out;
23608 octave_value _outv;
23618 arg1 =
static_cast< PLINT >(val1);
23620 _outv = octave_value();
23624 return octave_value_list();
23633 char *arg1 = (
char *) 0 ;
23637 octave_value_list _out;
23638 octave_value_list *_outp=&_out;
23639 octave_value _outv;
23649 arg1 =
reinterpret_cast< char *
>(buf1);
23650 plsdev((
char const *)arg1);
23651 _outv = octave_value();
23657 return octave_value_list();
23679 octave_value_list _out;
23680 octave_value_list *_outp=&_out;
23681 octave_value _outv;
23691 arg1 =
static_cast< PLFLT >(val1);
23696 arg2 =
static_cast< PLFLT >(val2);
23701 arg3 =
static_cast< PLFLT >(val3);
23706 arg4 =
static_cast< PLFLT >(val4);
23708 _outv = octave_value();
23712 return octave_value_list();
23739 octave_value_list _out;
23740 octave_value_list *_outp=&_out;
23741 octave_value _outv;
23751 arg1 =
static_cast< PLINT >(val1);
23756 arg2 =
static_cast< PLINT >(val2);
23761 arg3 =
static_cast< PLINT >(val3);
23766 arg4 =
static_cast< PLINT >(val4);
23771 arg5 =
static_cast< PLFLT >(val5);
23776 arg6 =
static_cast< PLFLT >(val6);
23777 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
23778 _outv = octave_value();
23782 return octave_value_list();
23794 octave_value_list _out;
23795 octave_value_list *_outp=&_out;
23796 octave_value _outv;
23806 arg1 =
static_cast< PLFLT >(val1);
23808 _outv = octave_value();
23812 return octave_value_list();
23833 octave_value_list _out;
23834 octave_value_list *_outp=&_out;
23835 octave_value _outv;
23845 arg1 =
static_cast< PLFLT >(val1);
23850 arg2 =
static_cast< PLFLT >(val2);
23855 arg3 =
static_cast< PLFLT >(val3);
23860 arg4 =
static_cast< PLFLT >(val4);
23862 _outv = octave_value();
23866 return octave_value_list();
23887 octave_value_list _out;
23888 octave_value_list *_outp=&_out;
23889 octave_value _outv;
23899 arg1 =
static_cast< PLFLT >(val1);
23904 arg2 =
static_cast< PLFLT >(val2);
23909 arg3 =
static_cast< PLFLT >(val3);
23914 arg4 =
static_cast< PLFLT >(val4);
23916 _outv = octave_value();
23920 return octave_value_list();
23929 unsigned int arg1 ;
23930 unsigned int val1 ;
23932 octave_value_list _out;
23933 octave_value_list *_outp=&_out;
23934 octave_value _outv;
23944 arg1 =
static_cast< unsigned int >(val1);
23946 _outv = octave_value();
23950 return octave_value_list();
23962 octave_value_list _out;
23963 octave_value_list *_outp=&_out;
23964 octave_value _outv;
23974 arg1 =
static_cast< char >(val1);
23976 _outv = octave_value();
23980 return octave_value_list();
23989 char *arg1 = (
char *) 0 ;
23990 char *arg2 = (
char *) 0 ;
23997 octave_value_list _out;
23998 octave_value_list *_outp=&_out;
23999 octave_value _outv;
24010 arg1 =
reinterpret_cast< char *
>(buf1);
24015 arg2 =
reinterpret_cast< char *
>(buf2);
24016 result = (
PLINT)
plsetopt((
char const *)arg1,(
char const *)arg2);
24025 return octave_value_list();
24045 octave_value_list _out;
24046 octave_value_list *_outp=&_out;
24047 octave_value _outv;
24057 arg1 =
static_cast< PLINT >(val1);
24062 arg2 =
static_cast< PLINT >(val2);
24067 arg3 =
static_cast< PLINT >(val3);
24069 _outv = octave_value();
24073 return octave_value_list();
24083 unsigned int val1 ;
24085 octave_value_list _out;
24086 octave_value_list *_outp=&_out;
24087 octave_value _outv;
24099 _outv = octave_value();
24103 return octave_value_list();
24112 char *arg1 = (
char *) 0 ;
24116 octave_value_list _out;
24117 octave_value_list *_outp=&_out;
24118 octave_value _outv;
24128 arg1 =
reinterpret_cast< char *
>(buf1);
24130 _outv = octave_value();
24136 return octave_value_list();
24155 octave_value_list _out;
24156 octave_value_list *_outp=&_out;
24157 octave_value _outv;
24167 arg1 =
static_cast< PLINT >(val1);
24172 arg2 =
static_cast< PLINT >(val2);
24177 arg3 =
static_cast< PLINT >(val3);
24179 _outv = octave_value();
24183 return octave_value_list();
24195 octave_value_list _out;
24196 octave_value_list *_outp=&_out;
24197 octave_value _outv;
24204 octave_value obj = args(0);
24205#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24206 if ( !obj.isempty() )
24208 if ( !obj.is_empty() )
24211 if ( obj.is_function_handle() || obj.is_inline_function() )
24215 else if ( obj.is_string() )
24232 _outv = octave_value();
24236 return octave_value_list();
24251 octave_value_list _out;
24252 octave_value_list *_outp=&_out;
24253 octave_value _outv;
24263 arg1 =
static_cast< PLFLT >(val1);
24268 arg2 =
static_cast< PLFLT >(val2);
24270 _outv = octave_value();
24274 return octave_value_list();
24289 octave_value_list _out;
24290 octave_value_list *_outp=&_out;
24291 octave_value _outv;
24301 arg1 =
static_cast< PLFLT >(val1);
24306 arg2 =
static_cast< PLFLT >(val2);
24308 _outv = octave_value();
24312 return octave_value_list();
24324 octave_value_list _out;
24325 octave_value_list *_outp=&_out;
24326 octave_value _outv;
24336 arg1 =
static_cast< PLINT >(val1);
24338 _outv = octave_value();
24342 return octave_value_list();
24369 octave_value_list _out;
24370 octave_value_list *_outp=&_out;
24371 octave_value _outv;
24381 arg1 =
static_cast< PLFLT >(val1);
24386 arg2 =
static_cast< PLFLT >(val2);
24391 arg3 =
static_cast< PLINT >(val3);
24396 arg4 =
static_cast< PLINT >(val4);
24401 arg5 =
static_cast< PLINT >(val5);
24406 arg6 =
static_cast< PLINT >(val6);
24407 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
24408 _outv = octave_value();
24412 return octave_value_list();
24421 char *arg1 = (
char *) 0 ;
24425 octave_value_list _out;
24426 octave_value_list *_outp=&_out;
24427 octave_value _outv;
24437 arg1 =
reinterpret_cast< char *
>(buf1);
24439 _outv = octave_value();
24445 return octave_value_list();
24455 char *arg1 = (
char *) 0 ;
24462 octave_value_list _out;
24463 octave_value_list *_outp=&_out;
24464 octave_value _outv;
24474 arg1 =
reinterpret_cast< char *
>(buf1);
24479 arg2 =
static_cast< PLBOOL >(val2);
24480 plspal1((
char const *)arg1,arg2);
24481 _outv = octave_value();
24487 return octave_value_list();
24500 octave_value_list _out;
24501 octave_value_list *_outp=&_out;
24502 octave_value _outv;
24512 arg1 =
static_cast< PLBOOL >(val1);
24514 _outv = octave_value();
24518 return octave_value_list();
24530 octave_value_list _out;
24531 octave_value_list *_outp=&_out;
24532 octave_value _outv;
24542 arg1 =
static_cast< PLINT >(val1);
24544 _outv = octave_value();
24548 return octave_value_list();
24563 octave_value_list _out;
24564 octave_value_list *_outp=&_out;
24565 octave_value _outv;
24575 arg1 =
static_cast< PLINT >(val1);
24580 arg2 =
static_cast< PLINT >(val2);
24582 _outv = octave_value();
24586 return octave_value_list();
24601 octave_value_list _out;
24602 octave_value_list *_outp=&_out;
24603 octave_value _outv;
24613 arg1 =
static_cast< PLFLT >(val1);
24618 arg2 =
static_cast< PLFLT >(val2);
24620 _outv = octave_value();
24624 return octave_value_list();
24639 octave_value_list _out;
24640 octave_value_list *_outp=&_out;
24641 octave_value _outv;
24651 arg1 =
static_cast< PLINT >(val1);
24656 arg2 =
static_cast< PLINT >(val2);
24658 _outv = octave_value();
24662 return octave_value_list();
24671 char *arg1 = (
char *) 0 ;
24681 octave_value_list _out;
24682 octave_value_list *_outp=&_out;
24683 octave_value _outv;
24693 arg1 =
reinterpret_cast< char *
>(buf1);
24698 arg2 =
static_cast< PLINT >(val2);
24703 arg3 =
static_cast< PLINT >(val3);
24704 plstart((
char const *)arg1,arg2,arg3);
24705 _outv = octave_value();
24711 return octave_value_list();
24724 octave_value_list _out;
24725 octave_value_list *_outp=&_out;
24726 octave_value _outv;
24733 octave_value obj = args(0);
24734#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24735 if ( !obj.isempty() )
24737 if ( !obj.is_empty() )
24740 if ( obj.is_function_handle() || obj.is_inline_function() )
24744 else if ( obj.is_string() )
24761 _outv = octave_value();
24765 return octave_value_list();
24777 char *arg4 = (
char *) 0 ;
24783 octave_value_list _out;
24784 octave_value_list *_outp=&_out;
24785 octave_value _outv;
24792 if (
_n_dims( args(0) ) > 1 )
24797 temp1 = args(0).matrix_value();
24798 arg2 = &temp1( 0, 0 );
24801 if (
_n_dims( args(1) ) > 1 )
24809 temp3 = args(1).matrix_value();
24810 arg3 = &temp3( 0, 0 );
24816 arg4 =
reinterpret_cast< char *
>(buf4);
24817 plstring(arg1,(
double const *)arg2,(
double const *)arg3,(
char const *)arg4);
24818 _outv = octave_value();
24836 return octave_value_list();
24856 char *arg5 = (
char *) 0 ;
24863 octave_value_list _out;
24864 octave_value_list *_outp=&_out;
24865 octave_value _outv;
24872 if (
_n_dims( args(0) ) > 1 )
24877 temp1 = args(0).matrix_value();
24878 arg2 = &temp1( 0, 0 );
24881 if (
_n_dims( args(1) ) > 1 )
24889 temp3 = args(1).matrix_value();
24890 arg3 = &temp3( 0, 0 );
24893 if (
_n_dims( args(2) ) > 1 )
24901 temp4 = args(2).matrix_value();
24902 arg4 = &temp4( 0, 0 );
24908 arg5 =
reinterpret_cast< char *
>(buf5);
24909 plstring3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
char const *)arg5);
24910 _outv = octave_value();
24934 return octave_value_list();
24965 octave_value_list _out;
24966 octave_value_list *_outp=&_out;
24967 octave_value _outv;
24977 arg1 =
static_cast< PLINT >(val1);
24982 arg2 =
static_cast< PLINT >(val2);
24987 arg3 =
static_cast< PLFLT >(val3);
24992 arg4 =
static_cast< PLFLT >(val4);
24994 _outv = octave_value();
24998 return octave_value_list();
25010 octave_value_list _out;
25011 octave_value_list *_outp=&_out;
25012 octave_value _outv;
25022 arg1 =
static_cast< PLINT >(val1);
25024 _outv = octave_value();
25028 return octave_value_list();
25042 octave_value_list _out;
25043 octave_value_list *_outp=&_out;
25044 octave_value _outv;
25051 if (
_n_dims( args(0) ) > 1 )
25057 temp1 = args(0).matrix_value();
25061 if (
_n_dims( args(1) ) > 1 )
25069 temp3 = args(1).matrix_value();
25073 plstyl(arg1,(
int const *)arg2,(
int const *)arg3);
25074 _outv = octave_value();
25090 return octave_value_list();
25113 octave_value_list _out;
25114 octave_value_list *_outp=&_out;
25115 octave_value _outv;
25122 if (
_n_dims( args(0) ) > 1 )
25126#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25127 if ( !args(0).isempty() )
25129 if ( !args(0).is_empty() )
25133 temp1 = args(0).matrix_value();
25134 arg1 = &temp1( 0, 0 );
25143 if (
_n_dims( args(1) ) > 1 )
25147#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25148 if ( !args(1).isempty() )
25150 if ( !args(1).is_empty() )
25157 temp2 = args(1).matrix_value();
25158 arg2 = &temp2( 0, 0 );
25171 arg4 =
static_cast< PLBOOL >(val4);
25172 plsvect((
double const *)arg1,(
double const *)arg2,arg3,arg4);
25173 _outv = octave_value();
25189 return octave_value_list();
25216 octave_value_list _out;
25217 octave_value_list *_outp=&_out;
25218 octave_value _outv;
25228 arg1 =
static_cast< PLFLT >(val1);
25233 arg2 =
static_cast< PLFLT >(val2);
25238 arg3 =
static_cast< PLFLT >(val3);
25243 arg4 =
static_cast< PLFLT >(val4);
25244 plsvpa(arg1,arg2,arg3,arg4);
25245 _outv = octave_value();
25249 return octave_value_list();
25264 octave_value_list _out;
25265 octave_value_list *_outp=&_out;
25266 octave_value _outv;
25276 arg1 =
static_cast< PLINT >(val1);
25281 arg2 =
static_cast< PLINT >(val2);
25283 _outv = octave_value();
25287 return octave_value_list();
25302 octave_value_list _out;
25303 octave_value_list *_outp=&_out;
25304 octave_value _outv;
25314 arg1 =
static_cast< PLINT >(val1);
25319 arg2 =
static_cast< PLINT >(val2);
25321 _outv = octave_value();
25325 return octave_value_list();
25342 octave_value_list _out;
25343 octave_value_list *_outp=&_out;
25344 octave_value _outv;
25351 if (
_n_dims( args(0) ) > 1 )
25356 temp1 = args(0).matrix_value();
25357 arg2 = &temp1( 0, 0 );
25360 if (
_n_dims( args(1) ) > 1 )
25368 temp3 = args(1).matrix_value();
25369 arg3 = &temp3( 0, 0 );
25375 arg4 =
static_cast< PLINT >(val4);
25376 plsym(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
25377 _outv = octave_value();
25393 return octave_value_list();
25414 octave_value_list _out;
25415 octave_value_list *_outp=&_out;
25416 octave_value _outv;
25426 arg1 =
static_cast< PLINT >(val1);
25431 arg2 =
static_cast< PLINT >(val2);
25433 _outv = octave_value();
25437 return octave_value_list();
25446 octave_value_list _out;
25447 octave_value_list *_outp=&_out;
25448 octave_value _outv;
25455 _outv = octave_value();
25459 return octave_value_list();
25468 char *arg1 = (
char *) 0 ;
25472 octave_value_list _out;
25473 octave_value_list *_outp=&_out;
25474 octave_value _outv;
25484 arg1 =
reinterpret_cast< char *
>(buf1);
25486 _outv = octave_value();
25492 return octave_value_list();
25505 octave_value_list _out;
25506 octave_value_list *_outp=&_out;
25507 octave_value _outv;
25517 arg1 =
static_cast< PLFLT >(val1);
25519 _outv = octave_value();
25523 return octave_value_list();
25547 octave_value_list _out;
25548 octave_value_list *_outp=&_out;
25549 octave_value _outv;
25559 arg1 =
static_cast< PLFLT >(val1);
25564 arg2 =
static_cast< PLFLT >(val2);
25569 arg3 =
static_cast< PLFLT >(val3);
25574 arg4 =
static_cast< PLFLT >(val4);
25579 arg5 =
static_cast< PLFLT >(val5);
25580 plvpas(arg1,arg2,arg3,arg4,arg5);
25581 _outv = octave_value();
25585 return octave_value_list();
25606 octave_value_list _out;
25607 octave_value_list *_outp=&_out;
25608 octave_value _outv;
25618 arg1 =
static_cast< PLFLT >(val1);
25623 arg2 =
static_cast< PLFLT >(val2);
25628 arg3 =
static_cast< PLFLT >(val3);
25633 arg4 =
static_cast< PLFLT >(val4);
25634 plvpor(arg1,arg2,arg3,arg4);
25635 _outv = octave_value();
25639 return octave_value_list();
25648 octave_value_list _out;
25649 octave_value_list *_outp=&_out;
25650 octave_value _outv;
25657 _outv = octave_value();
25661 return octave_value_list();
25703 octave_value_list _out;
25704 octave_value_list *_outp=&_out;
25705 octave_value _outv;
25715 arg1 =
static_cast< PLFLT >(val1);
25720 arg2 =
static_cast< PLFLT >(val2);
25725 arg3 =
static_cast< PLFLT >(val3);
25730 arg4 =
static_cast< PLFLT >(val4);
25735 arg5 =
static_cast< PLFLT >(val5);
25740 arg6 =
static_cast< PLFLT >(val6);
25745 arg7 =
static_cast< PLFLT >(val7);
25750 arg8 =
static_cast< PLFLT >(val8);
25755 arg9 =
static_cast< PLFLT >(val9);
25760 arg10 =
static_cast< PLFLT >(val10);
25765 arg11 =
static_cast< PLFLT >(val11);
25766 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25767 _outv = octave_value();
25771 return octave_value_list();
25783 octave_value_list _out;
25784 octave_value_list *_outp=&_out;
25785 octave_value _outv;
25795 arg1 =
static_cast< PLFLT >(val1);
25797 _outv = octave_value();
25801 return octave_value_list();
25822 octave_value_list _out;
25823 octave_value_list *_outp=&_out;
25824 octave_value _outv;
25834 arg1 =
static_cast< PLFLT >(val1);
25839 arg2 =
static_cast< PLFLT >(val2);
25844 arg3 =
static_cast< PLFLT >(val3);
25849 arg4 =
static_cast< PLFLT >(val4);
25850 plwind(arg1,arg2,arg3,arg4);
25851 _outv = octave_value();
25855 return octave_value_list();
25870 octave_value_list _out;
25871 octave_value_list *_outp=&_out;
25872 octave_value _outv;
25883 arg1 =
static_cast< PLBOOL >(val1);
25885 _outv = octave_value();
25895 return octave_value_list();
25905 char *arg2 = (
char *) 0 ;
25921 octave_value_list _out;
25922 octave_value_list *_outp=&_out;
25923 octave_value _outv;
25930 octave_value obj = args(0);
25931#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25932 if ( !obj.isempty() )
25934 if ( !obj.is_empty() )
25937 if ( obj.is_function_handle() || obj.is_inline_function() )
25941 else if ( obj.is_string() )
25957 arg2 =
reinterpret_cast< char *
>(buf2);
25962 arg3 =
static_cast< PLFLT >(val3);
25967 arg4 =
static_cast< PLFLT >(val4);
25972 arg5 =
static_cast< PLFLT >(val5);
25977 arg6 =
static_cast< PLFLT >(val6);
25978 plmap(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6);
25979 _outv = octave_value();
25985 return octave_value_list();
25996 char *arg2 = (
char *) 0 ;
26015 octave_value_list _out;
26016 octave_value_list *_outp=&_out;
26017 octave_value _outv;
26024 octave_value obj = args(0);
26025#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26026 if ( !obj.isempty() )
26028 if ( !obj.is_empty() )
26031 if ( obj.is_function_handle() || obj.is_inline_function() )
26035 else if ( obj.is_string() )
26051 arg2 =
reinterpret_cast< char *
>(buf2);
26056 arg3 =
static_cast< PLFLT >(val3);
26061 arg4 =
static_cast< PLFLT >(val4);
26066 arg5 =
static_cast< PLFLT >(val5);
26071 arg6 =
static_cast< PLFLT >(val6);
26073 if (
_n_dims( args(6) ) > 1 )
26077#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26078 if ( !args(6).isempty() )
26080 if ( !args(6).is_empty() )
26084 temp7 = args(6).matrix_value();
26085 arg7 =
new PLINT[arg8];
26094 plmapline(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
26095 _outv = octave_value();
26107 return octave_value_list();
26121 char *arg2 = (
char *) 0 ;
26122 char *arg3 = (
char *) 0 ;
26144 octave_value_list _out;
26145 octave_value_list *_outp=&_out;
26146 octave_value _outv;
26153 octave_value obj = args(0);
26154#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26155 if ( !obj.isempty() )
26157 if ( !obj.is_empty() )
26160 if ( obj.is_function_handle() || obj.is_inline_function() )
26164 else if ( obj.is_string() )
26180 arg2 =
reinterpret_cast< char *
>(buf2);
26185 arg3 =
reinterpret_cast< char *
>(buf3);
26190 arg4 =
static_cast< PLFLT >(val4);
26195 arg5 =
static_cast< PLFLT >(val5);
26200 arg6 =
static_cast< PLFLT >(val6);
26205 arg7 =
static_cast< PLFLT >(val7);
26207 if (
_n_dims( args(7) ) > 1 )
26211#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26212 if ( !args(7).isempty() )
26214 if ( !args(7).is_empty() )
26218 temp8 = args(7).matrix_value();
26219 arg8 =
new PLINT[arg9];
26228 plmapstring(arg1,(
char const *)arg2,(
char const *)arg3,arg4,arg5,arg6,arg7,(
int const *)arg8,arg9);
26229 _outv = octave_value();
26243 return octave_value_list();
26258 char *arg2 = (
char *) 0 ;
26262 char *arg6 = (
char *) 0 ;
26290 octave_value_list _out;
26291 octave_value_list *_outp=&_out;
26292 octave_value _outv;
26299 octave_value obj = args(0);
26300#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26301 if ( !obj.isempty() )
26303 if ( !obj.is_empty() )
26306 if ( obj.is_function_handle() || obj.is_inline_function() )
26310 else if ( obj.is_string() )
26326 arg2 =
reinterpret_cast< char *
>(buf2);
26331 arg3 =
static_cast< PLFLT >(val3);
26336 arg4 =
static_cast< PLFLT >(val4);
26341 arg5 =
static_cast< PLFLT >(val5);
26346 arg6 =
reinterpret_cast< char *
>(buf6);
26351 arg7 =
static_cast< PLFLT >(val7);
26356 arg8 =
static_cast< PLFLT >(val8);
26361 arg9 =
static_cast< PLFLT >(val9);
26366 arg10 =
static_cast< PLFLT >(val10);
26371 arg11 =
static_cast< PLINT >(val11);
26372 plmaptex(arg1,(
char const *)arg2,arg3,arg4,arg5,(
char const *)arg6,arg7,arg8,arg9,arg10,arg11);
26373 _outv = octave_value();
26381 return octave_value_list();
26393 char *arg2 = (
char *) 0 ;
26412 octave_value_list _out;
26413 octave_value_list *_outp=&_out;
26414 octave_value _outv;
26421 octave_value obj = args(0);
26422#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26423 if ( !obj.isempty() )
26425 if ( !obj.is_empty() )
26428 if ( obj.is_function_handle() || obj.is_inline_function() )
26432 else if ( obj.is_string() )
26448 arg2 =
reinterpret_cast< char *
>(buf2);
26453 arg3 =
static_cast< PLFLT >(val3);
26458 arg4 =
static_cast< PLFLT >(val4);
26463 arg5 =
static_cast< PLFLT >(val5);
26468 arg6 =
static_cast< PLFLT >(val6);
26470 if (
_n_dims( args(6) ) > 1 )
26474#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26475 if ( !args(6).isempty() )
26477 if ( !args(6).is_empty() )
26481 temp7 = args(6).matrix_value();
26482 arg7 =
new PLINT[arg8];
26491 plmapfill(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
26492 _outv = octave_value();
26504 return octave_value_list();
26536 octave_value_list _out;
26537 octave_value_list *_outp=&_out;
26538 octave_value _outv;
26545 octave_value obj = args(0);
26546#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26547 if ( !obj.isempty() )
26549 if ( !obj.is_empty() )
26552 if ( obj.is_function_handle() || obj.is_inline_function() )
26556 else if ( obj.is_string() )
26572 arg2 =
static_cast< PLFLT >(val2);
26577 arg3 =
static_cast< PLFLT >(val3);
26582 arg4 =
static_cast< PLFLT >(val4);
26587 arg5 =
static_cast< PLFLT >(val5);
26592 arg6 =
static_cast< PLFLT >(val6);
26597 arg7 =
static_cast< PLFLT >(val7);
26599 _outv = octave_value();
26603 return octave_value_list();
26612 octave_value_list _out;
26613 octave_value_list *_outp=&_out;
26614 octave_value _outv;
26621 _outv = octave_value();
26625 return octave_value_list();
26634 octave_value_list _out;
26635 octave_value_list *_outp=&_out;
26636 octave_value _outv;
26643 _outv = octave_value();
26647 return octave_value_list();
26656 char *arg1 = (
char *) 0 ;
26657 char *arg2 = (
char *) 0 ;
26664 octave_value_list _out;
26665 octave_value_list *_outp=&_out;
26666 octave_value _outv;
26676 arg1 =
reinterpret_cast< char *
>(buf1);
26681 arg2 =
reinterpret_cast< char *
>(buf2);
26682 plSetUsage((
char const *)arg1,(
char const *)arg2);
26683 _outv = octave_value();
26691 return octave_value_list();
26702 octave_value_list _out;
26703 octave_value_list *_outp=&_out;
26704 octave_value _outv;
26711 _outv = octave_value();
26715 return octave_value_list();
26725{
"testppchar",_wrap_testppchar,0,0,2,0},
26727{
"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
26730{
"plcont0",_wrap_plcont0,0,0,2,0},
26731{
"plcont1",_wrap_plcont1,0,0,2,0},
26732{
"plcont2",_wrap_plcont2,0,0,2,0},
26733{
"plcont2p",_wrap_plcont2p,0,0,2,0},
26743{
"plshade1",_wrap_plshade1,0,0,2,0},
26744{
"plshade2",_wrap_plshade2,0,0,2,0},
26746{
"plshadesx",_wrap_plshadesx,0,0,2,0},
26747{
"plshades1",_wrap_plshades1,0,0,2,0},
26748{
"plshades2",_wrap_plshades2,0,0,2,0},
26750{
"plvect1",_wrap_plvect1,0,0,2,0},
26751{
"plvect2",_wrap_plvect2,0,0,2,0},
26752{
"pplimage",_wrap_pplimage,0,0,2,0},
26754{
"plimagefrx",_wrap_plimagefrx,0,0,2,0},
26755{
"plimagefr1",_wrap_plimagefr1,0,0,2,0},
26756{
"plimagefr2",_wrap_plimagefr2,0,0,2,0},
27042#define SWIGRUNTIME_DEBUG
27045#ifndef SWIG_INIT_CLIENT_DATA_TYPE
27046#define SWIG_INIT_CLIENT_DATA_TYPE void *
27068 if (!module_head) {
27081 }
while (iter!= module_head);
27092 if (init == 0)
return;
27095#ifdef SWIGRUNTIME_DEBUG
27096 printf(
"SWIG_InitializeModule: size %lu\n", (
unsigned long)
swig_module.
size);
27103#ifdef SWIGRUNTIME_DEBUG
27113#ifdef SWIGRUNTIME_DEBUG
27114 printf(
"SWIG_InitializeModule: found type %s\n", type->
name);
27118#ifdef SWIGRUNTIME_DEBUG
27119 printf(
"SWIG_InitializeModule: found and overwrite type %s \n", type->
name);
27128 while (cast->
type) {
27132#ifdef SWIGRUNTIME_DEBUG
27133 printf(
"SWIG_InitializeModule: look cast %s\n", cast->
type->
name);
27137#ifdef SWIGRUNTIME_DEBUG
27138 if (ret) printf(
"SWIG_InitializeModule: found cast %s\n", ret->
name);
27143#ifdef SWIGRUNTIME_DEBUG
27144 printf(
"SWIG_InitializeModule: skip old type %s\n", ret->
name);
27151#ifdef SWIGRUNTIME_DEBUG
27152 if (ocast) printf(
"SWIG_InitializeModule: skip old cast %s\n", ret->
name);
27154 if (!ocast) ret = 0;
27159#ifdef SWIGRUNTIME_DEBUG
27160 printf(
"SWIG_InitializeModule: adding cast %s\n", cast->
type->
name);
27175#ifdef SWIGRUNTIME_DEBUG
27176 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
27181 while (cast->
type) {
27182 printf(
"SWIG_InitializeModule: cast type %s\n", cast->
type->
name);
27186 printf(
"---- Total casts: %d\n",j);
27188 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
27201 static int init_run = 0;
27203 if (init_run)
return;
27214 equiv = equiv->
next;
27234#if SWIG_OCTAVE_PREREQ(6,0,0)
27235#elif SWIG_OCTAVE_PREREQ(4,2,0)
27236 octave::unwind_protect frame;
27237 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27238 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27239#elif SWIG_OCTAVE_PREREQ(3,3,50)
27240 unwind_protect frame;
27241 frame.protect_var(error_state); error_state = 0;
27242 frame.protect_var(warning_state); warning_state = 0;
27243 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27244 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27246 unwind_protect::begin_frame(
"SWIG_Octave_LoadModule");
27247 unwind_protect_int(error_state); error_state = 0;
27248 unwind_protect_int(warning_state); warning_state = 0;
27249 unwind_protect_bool(discard_error_messages); discard_error_messages =
true;
27250 unwind_protect_bool(discard_warning_messages); discard_warning_messages =
true;
27252#if SWIG_OCTAVE_PREREQ(4,2,0)
27254#if SWIG_OCTAVE_PREREQ(4,4,0)
27255 octave::feval(
name, octave_value_list(), 0);
27257 feval(
name, octave_value_list(), 0);
27260 }
catch (octave::execution_exception&) { }
27262 feval(
name, octave_value_list(), 0);
27263 retn = (error_state == 0);
27265#if !SWIG_OCTAVE_PREREQ(3,3,50)
27266 unwind_protect::run_frame(
"SWIG_Octave_LoadModule");
27278#if SWIG_OCTAVE_PREREQ(6,0,0)
27279#elif SWIG_OCTAVE_PREREQ(4,2,0)
27280 octave::unwind_protect frame;
27281 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27282 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27283#elif SWIG_OCTAVE_PREREQ(3,3,50)
27284 unwind_protect frame;
27285 frame.protect_var(error_state); error_state = 0;
27286 frame.protect_var(warning_state); warning_state = 0;
27287 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27288 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27290 unwind_protect::begin_frame(
"SWIG_Octave_InstallFunction");
27291 unwind_protect_int(error_state); error_state = 0;
27292 unwind_protect_int(warning_state); warning_state = 0;
27293 unwind_protect_bool(discard_error_messages); discard_error_messages =
true;
27294 unwind_protect_bool(discard_warning_messages); discard_warning_messages =
true;
27296 octave_value_list args;
27298 args.append(octloadfcn->fcn_file_name());
27299#if SWIG_OCTAVE_PREREQ(4,2,0)
27301#if SWIG_OCTAVE_PREREQ(4,4,0)
27302 octave::feval(
"autoload", args, 0);
27304 feval(
"autoload", args, 0);
27307 }
catch (octave::execution_exception&) { }
27309 feval(
"autoload", args, 0);
27310 retn = (error_state == 0);
27312#if !SWIG_OCTAVE_PREREQ(3,3,50)
27313 unwind_protect::run_frame(
"SWIG_Octave_InstallFunction");
27323@deftypefn {Loadable Function} {} subclass()\n\
27324@deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
27325Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
27327See the SWIG manual for usage examples.\n\
27332 for (
int j = 0; j < args.length(); ++j) {
27333 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
27337 error(
"subclass: cannot subclass object not constructed on octave side");
27338 return octave_value_list();
27341 }
else if (args(j).is_function_handle()) {
27342 top->
assign(args(j).fcn_handle_value()->fcn_name(), args(j));
27343 }
else if (args(j).is_string()) {
27344 if (j + 1 >= args.length()) {
27345 error(
"subclass: member assignments must be of string,value form");
27346 return octave_value_list();
27348 top->
assign(args(j).string_value(), args(j + 1));
27351 error(
"subclass: invalid arguments to subclass()");
27352 return octave_value_list();
27359@deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
27360Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
27364 if (args.length() != 1) {
27365 error(
"swig_type: must be called with only a single object");
27366 return octave_value_list();
27370 error(
"swig_type: object is not a swig_ref");
27371 return octave_value_list();
27377@deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
27378Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
27379otherwise return `<unknown>'.\n\
27383 if (args.length() != 1 || !args(0).is_string()) {
27384 error(
"swig_typequery: must be called with single string argument");
27385 return octave_value_list();
27390 return octave_value(
"<unknown>");
27391 return octave_value(type->
name);
27395@deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
27396Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
27400 if (args.length() != 1) {
27401 error(
"swig_this: must be called with only a single object");
27402 return octave_value_list();
27404 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
27405 return octave_value(octave_uint64(0));
27408 error(
"swig_this: object is not a swig_ref");
27409 return octave_value_list();
27411 return octave_value(octave_uint64((
unsigned long long) ost->
swig_this()));
27415@deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
27416Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
27420 if (args.length() != 3) {
27421 error(
"swig_octave_prereq: must be called with 3 arguments");
27422 return octave_value_list();
27424 const int major = args(0).int_value();
27425 const int minor = args(1).int_value();
27426 const int patch = args(2).int_value();
27428 return octave_value(prereq);
27432@deftypefn {Loadable Function} {} swig_exit([@var{exit_status}])\n\
27433Exit Octave without performing any memory cleanup.\n\
27437 if (args.length() > 1) {
27438 error(
"swig_exit: must be called with at most one arguments");
27439 return octave_value_list();
27441 int exit_status = 0;
27442 if (args.length() == 1) {
27443 exit_status = args(0).int_value();
27445 ::_Exit(exit_status);
27446 return octave_value();
27450@deftypefn {Loadable Module} {} " SWIG_name_d "\n\
27451Loads the SWIG-generated module `" SWIG_name_d "'.\n\
27464#ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
27465#if !SWIG_OCTAVE_PREREQ(4,4,0)
27466#if SWIG_OCTAVE_PREREQ(3,2,0)
27467 octave_exit = ::_Exit;
27473 if (args.length() != 0 || nargout != 0) {
27475 return octave_value_list();
27483#if SWIG_OCTAVE_PREREQ(3,2,0)
27484 octave_value_list eval_args;
27485 eval_args.append(
"base");
27486 eval_args.append(
"function __swig_atexit__; "
27493 "__swig_atexit__; "
27494 "atexit(\"__swig_atexit__\", false); "
27495 "atexit(\"__swig_atexit__\")");
27496#if SWIG_OCTAVE_PREREQ(4,4,0)
27497 octave::feval(
"evalin", eval_args, 0);
27499 feval(
"evalin", eval_args, 0);
27503#if SWIG_OCTAVE_PREREQ(4,4,0)
27505 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
27506 string_vector types = typeinfo.installed_type_names();
27507 bool register_octave_swig_ref =
true;
27508 bool register_octave_swig_packed =
true;
27509 for (
int i = 0; i < types.numel(); ++i) {
27510 if (types(i) == octave_swig_ref::static_type_name()) {
27511 register_octave_swig_ref =
false;
27512 octave_swig_ref::set_type_id(i);
27514 if (types(i) == octave_swig_packed::static_type_name()) {
27515 register_octave_swig_packed =
false;
27516 octave_swig_packed::set_type_id(i);
27519 if (register_octave_swig_ref) {
27520 octave_swig_ref::register_type();
27522 if (register_octave_swig_packed) {
27523 octave_swig_packed::register_type();
27527 octave_swig_ref::register_type();
27528 octave_swig_packed::register_type();
27533#if SWIG_OCTAVE_PREREQ(8,0,0)
27534 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27535 octave_function *me = tree_eval.current_function();
27536#elif SWIG_OCTAVE_PREREQ(6,0,0)
27537 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27538 octave::call_stack& stack = tree_eval.get_call_stack();
27539 octave_function *me = stack.current_function();
27540#elif SWIG_OCTAVE_PREREQ(4,4,0)
27541 octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
27542 octave_function *me = stack.current();
27544 octave_function *me = octave_call_stack::current();
27548 return octave_value_list();
27551 return octave_value_list();
27554 return octave_value_list();
27557 return octave_value_list();
27560 return octave_value_list();
27563 return octave_value_list();
27601 return octave_value_list();
27608 if (mb->second.first && mb->second.first->method) {
27610 return octave_value_list();
27615#if SWIG_OCTAVE_PREREQ(4,4,0)
27616 octave::interpreter::the_interpreter()->mlock();
27617#elif SWIG_OCTAVE_PREREQ(3,2,0)
27627 if (mb->second.second.is_defined()) {
27636 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