10#define SWIG_VERSION 0x040400
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
142#if defined(__cplusplus) && __cplusplus >=201103L
143# define SWIG_NULLPTR nullptr
145# define SWIG_NULLPTR NULL
161#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
162 (defined __cplusplus && __cplusplus >= 201103L) || \
163 defined SWIG_HAVE_SNPRINTF) && \
164 !defined SWIG_NO_SNPRINTF
165# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
166# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
172# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
173# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
187#if !defined(SWIG_OCTAVE_OCTHEADERS_HPP)
188#define SWIG_OCTAVE_OCTHEADERS_HPP
205#include <octave/oct.h>
206#include <octave/version.h>
210#define SWIG_OCTAVE_PREREQ(major, minor, patch) \
211 ( (OCTAVE_MAJOR_VERSION<<16) + (OCTAVE_MINOR_VERSION<<8) + (OCTAVE_PATCH_VERSION + 0) >= ((major)<<16) + ((minor)<<8) + (patch) )
214#if !defined(OCTAVE_MAJOR_VERSION)
216# if !defined(OCTAVE_API_VERSION_NUMBER)
220# include <octave/ov.h>
221# if defined(octave_ov_h)
222# define OCTAVE_MAJOR_VERSION 3
223# define OCTAVE_MINOR_VERSION 8
224# define OCTAVE_PATCH_VERSION 0
228# define ComplexLU __ignore
229# include <octave/CmplxLU.h>
231# if defined(octave_Complex_LU_h)
234# define OCTAVE_MAJOR_VERSION 3
235# define OCTAVE_MINOR_VERSION 1
236# define OCTAVE_PATCH_VERSION 99
241# define OCTAVE_MAJOR_VERSION 3
242# define OCTAVE_MINOR_VERSION 2
243# define OCTAVE_PATCH_VERSION 0
251# elif OCTAVE_API_VERSION_NUMBER >= 48
252# define OCTAVE_MAJOR_VERSION 3
253# define OCTAVE_MINOR_VERSION 6
254# define OCTAVE_PATCH_VERSION 0
256# elif OCTAVE_API_VERSION_NUMBER >= 45
257# define OCTAVE_MAJOR_VERSION 3
258# define OCTAVE_MINOR_VERSION 4
259# define OCTAVE_PATCH_VERSION 1
261# elif OCTAVE_API_VERSION_NUMBER >= 42
262# define OCTAVE_MAJOR_VERSION 3
263# define OCTAVE_MINOR_VERSION 3
264# define OCTAVE_PATCH_VERSION 54
266# elif OCTAVE_API_VERSION_NUMBER >= 41
267# define OCTAVE_MAJOR_VERSION 3
268# define OCTAVE_MINOR_VERSION 3
269# define OCTAVE_PATCH_VERSION 53
271# elif OCTAVE_API_VERSION_NUMBER >= 40
272# define OCTAVE_MAJOR_VERSION 3
273# define OCTAVE_MINOR_VERSION 3
274# define OCTAVE_PATCH_VERSION 52
276# elif OCTAVE_API_VERSION_NUMBER >= 39
277# define OCTAVE_MAJOR_VERSION 3
278# define OCTAVE_MINOR_VERSION 3
279# define OCTAVE_PATCH_VERSION 51
282# define OCTAVE_MAJOR_VERSION 3
283# define OCTAVE_MINOR_VERSION 3
284# define OCTAVE_PATCH_VERSION 50
291#include <octave/Cell.h>
292#include <octave/dynamic-ld.h>
293#include <octave/oct-env.h>
294#include <octave/oct-map.h>
295#include <octave/ov-scalar.h>
296#include <octave/ov-fcn-handle.h>
297#include <octave/parse.h>
298#if SWIG_OCTAVE_PREREQ(4,2,0)
299#include <octave/interpreter.h>
301#include <octave/toplev.h>
303#include <octave/unwind-prot.h>
304#if SWIG_OCTAVE_PREREQ(4,2,0)
305#include <octave/call-stack.h>
319#define SWIG_RUNTIME_VERSION "4"
322#ifdef SWIG_TYPE_TABLE
323# define SWIG_QUOTE_STRING(x) #x
324# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
325# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
327# define SWIG_TYPE_TABLE_NAME
340# define SWIGRUNTIME SWIGINTERN
343#ifndef SWIGRUNTIMEINLINE
344# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
348#ifndef SWIG_BUFFER_SIZE
349# define SWIG_BUFFER_SIZE 1024
353#define SWIG_POINTER_DISOWN 0x1
354#define SWIG_CAST_NEW_MEMORY 0x2
355#define SWIG_POINTER_NO_NULL 0x4
356#define SWIG_POINTER_CLEAR 0x8
357#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
360#define SWIG_POINTER_OWN 0x1
444#define SWIG_ERROR (-1)
448#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
450#define SWIG_IsOK(r) (r >= 0)
451#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
454#define SWIG_CASTRANKLIMIT (1 << 8)
456#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
458#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
460#define SWIG_BADOBJ (SWIG_ERROR)
461#define SWIG_OLDOBJ (SWIG_OK)
462#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
463#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
465#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
466#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
467#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
468#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
469#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
470#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
473#if defined(SWIG_CASTRANK_MODE)
474# ifndef SWIG_TypeRank
475# define SWIG_TypeRank unsigned long
477# ifndef SWIG_MAXCASTRANK
478# define SWIG_MAXCASTRANK (2)
480# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
481# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
486 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
489# define SWIG_AddCast(r) (r)
490# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
500typedef void *(*swig_converter_func)(
void *,
int *);
542 const char *f2,
const char *l2) {
543 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
544 while ((*f1 ==
' ') && (f1 != l1)) ++f1;
545 while ((*f2 ==
' ') && (f2 != l2)) ++f2;
546 if (*f1 != *f2)
return (*f1 > *f2) ? 1 : -1;
548 return (
int)((l1 - f1) - (l2 - f2));
558 const char* te = tb + strlen(tb);
560 while (equiv != 0 && *ne) {
561 for (nb = ne; *ne; ++ne) {
562 if (*ne ==
'|')
break;
587 if (strcmp(iter->
type->
name, c) == 0) {
588 if (iter == ty->
cast)
614 if (iter->
type == from) {
615 if (iter == ty->
cast)
647 if (!ty || !ty->
dcast)
return ty;
648 while (ty && (ty->
dcast)) {
649 ty = (*ty->
dcast)(ptr);
673 if (!type)
return NULL;
674 if (type->str != NULL) {
675 const char *last_name = type->str;
677 for (s = type->str; *s; s++)
678 if (*s ==
'|') last_name = s+1;
726 size_t r = iter->
size - 1;
729 size_t i = (l + r) >> 1;
730 const char *iname = iter->
types[i]->
name;
732 int compare = strcmp(
name, iname);
734 return iter->
types[i];
735 }
else if (compare < 0) {
741 }
else if (compare > 0) {
750 }
while (iter != end);
777 for (; i < iter->
size; ++i) {
779 return iter->
types[i];
782 }
while (iter != end);
794 static const char hex[17] =
"0123456789abcdef";
795 const unsigned char *u = (
unsigned char *) ptr;
796 const unsigned char *eu = u + sz;
797 for (; u != eu; ++u) {
798 unsigned char uu = *u;
799 *(c++) = hex[(uu & 0xf0) >> 4];
800 *(c++) = hex[uu & 0xf];
810 unsigned char *u = (
unsigned char *) ptr;
811 const unsigned char *eu = u + sz;
812 for (; u != eu; ++u) {
815 if ((d >=
'0') && (d <=
'9'))
816 uu = (
unsigned char)((d -
'0') << 4);
817 else if ((d >=
'a') && (d <=
'f'))
818 uu = (
unsigned char)((d - (
'a'-10)) << 4);
822 if ((d >=
'0') && (d <=
'9'))
823 uu |= (
unsigned char)(d -
'0');
824 else if ((d >=
'a') && (d <=
'f'))
825 uu |= (
unsigned char)(d - (
'a'-10));
839 if ((2*
sizeof(
void *) + 2) > bsz)
return 0;
842 if (strlen(
name) + 1 > (bsz - (r - buff)))
return 0;
850 if (strcmp(c,
"NULL") == 0) {
863 size_t lname = (
name ? strlen(
name) : 0);
864 if ((2*sz + 2 + lname) > bsz)
return 0;
868 strncpy(r,
name,lname+1);
878 if (strcmp(c,
"NULL") == 0) {
893#define SWIG_UnknownError -1
894#define SWIG_IOError -2
895#define SWIG_RuntimeError -3
896#define SWIG_IndexError -4
897#define SWIG_TypeError -5
898#define SWIG_DivisionByZero -6
899#define SWIG_OverflowError -7
900#define SWIG_SyntaxError -8
901#define SWIG_ValueError -9
902#define SWIG_SystemError -10
903#define SWIG_AttributeError -11
904#define SWIG_MemoryError -12
905#define SWIG_NullReferenceError -13
908#if !SWIG_OCTAVE_PREREQ(3,2,0)
909#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
911#define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
915 if (num_args > max_args && !varargs)
916 error(
"function %s takes at most %i arguments", func_name, max_args);
917 else if (num_args < min_args)
918 error(
"function %s requires at least %i arguments", func_name, min_args);
932 return "SWIG_MemoryError";
934 return "SWIG_IOError";
936 return "SWIG_RuntimeError";
938 return "SWIG_IndexError";
940 return "SWIG_TypeError";
942 return "SWIG_DivisionByZero";
944 return "SWIG_OverflowError";
946 return "SWIG_SyntaxError";
948 return "SWIG_ValueError";
950 return "SWIG_SystemError";
952 return "SWIG_AttributeError";
954 return "SWIG_NullReferenceError";
956 return "SWIG unknown error";
962 r +=
" (" + type.string_value() +
")";
963 error(
"%s", r.c_str());
964 return octave_value(r);
967#define SWIG_fail goto fail
969#define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
970#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
971#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
972#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
973#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
974#define swig_owntype int
976#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
977#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
979#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
980#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
982#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
983#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
985#define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
986#define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
987#define SWIG_MODULE_CLIENTDATA_TYPE void*
989#define Octave_Error_Occurred() 0
990#define SWIG_Octave_AddErrorMsg(msg) {;}
996#define SWIG_POINTER_EXCEPTION 0
997#define SWIG_arg_fail(arg) 0
1001typedef octave_value_list(*
octave_func) (
const octave_value_list &, int);
1006#ifdef SWIG_DIRECTORS
1010 typedef std::map < void *, Director * > rtdir_map;
1027#ifdef SWIG_DIRECTORS
1028SWIGRUNTIME void swig_acquire_ownership(
void *vptr);
1029SWIGRUNTIME void swig_acquire_ownership_array(
void *vptr);
1030SWIGRUNTIME void swig_acquire_ownership_obj(
void *vptr,
int own);
1059#if SWIG_OCTAVE_PREREQ(4,4,0)
1062#define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(new octave_swig_bound_func(func, args))
1063 class octave_swig_bound_func :
public octave_function {
1066 octave_swig_bound_func(
void) : octave_function(), method(0), first_args()
1069 octave_swig_bound_func(octave_function* _method, octave_value_list _first_args)
1070 : octave_function(
"",
""), method(_method), first_args(_first_args)
1073 octave_swig_bound_func(
const octave_swig_bound_func& f) =
delete;
1075 octave_swig_bound_func& operator= (
const octave_swig_bound_func& f) =
delete;
1077 ~octave_swig_bound_func(
void) =
default;
1079 bool is_function(
void)
const {
return true; }
1081 octave_function* function_value(
bool =
false) {
return this; }
1083#if SWIG_OCTAVE_PREREQ(6,0,0)
1084 octave_value_list call(octave::tree_evaluator& tw,
int nargout = 0,
const octave_value_list& args = octave_value_list()) {
1085 return execute(tw,nargout,args);
1088#if SWIG_OCTAVE_PREREQ(6,0,0)
1089 octave_value_list execute(octave::tree_evaluator& tw,
int nargout = 0,
const octave_value_list& args = octave_value_list()) {
1091 octave_value_list call(octave::tree_evaluator& tw,
int nargout = 0,
const octave_value_list& args = octave_value_list()) {
1093 octave_value_list all_args;
1094 all_args.append(first_args);
1095 all_args.append(args);
1096 return method->call(tw, nargout, all_args);
1099 octave_value subsref(
const std::string &ops,
const std::list < octave_value_list > &idx) {
1100 octave_value_list ovl = subsref(ops, idx, 1);
1101 return ovl.length() ? ovl(0) : octave_value();
1104 octave_value_list subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout) {
1105 assert(ops.size() > 0);
1106 assert(ops.size() == idx.size());
1108 error(
"invalid function call");
1109 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1110 return call(tw, nargout, *idx.begin());
1115 octave_function* method;
1116 octave_value_list first_args;
1118 std::set<std::string> dispatch_classes;
1122#define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(func)
1152 if (!type->clientdata)
1162 module = SWIG_GetModule(0);
1179 for (
unsigned int j = 0; j <
types.size(); ++j)
1181 return &
members.insert(std::make_pair(
name, std::make_pair(m, octave_value()))).first->second;
1182 if (!insert_if_not_found)
1189 for (
unsigned int j = 0; j <
types.size(); ++j) {
1190 assert(
types[j].first->clientdata);
1193 return types[j].first;
1202 module = SWIG_GetModule(0);
1218 if (out.find(m->name) == out.end())
1219 out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1224 module = SWIG_GetModule(0);
1239 for (
unsigned int j = 0; j <
types.size(); ++j)
1240 if (
types[j].first->clientdata)
1245 if (m->second.is_defined())
1246 return m->second.subsref(
"(", std::list < octave_value_list > (1, args), nargout);
1247 else if (m->first && m->first->method)
1248 return m->first->method(args, nargout);
1249 error(
"member not defined or not invocable");
1250 return octave_value_list();
1256 if (!m || m->first->is_static() || m->first->is_global())
1258 octave_value_list args;
1260 octave_value_list argout(nc_this->
member_invoke(m, args, 1));
1261 if (argout.length() < 1)
1267 bool dispatch_binary_op(
const std::string &symbol,
const octave_base_value &rhs, octave_value &ret)
const {
1270 if (!m || m->first->is_static() || m->first->is_global())
1272 octave_value_list args;
1275 octave_value_list argout(nc_this->
member_invoke(m, args, 1));
1276 if (argout.length() < 1)
1282 bool dispatch_index_op(
const std::string &symbol,
const octave_value_list &rhs, octave_value_list &ret)
const {
1285 if (!m || m->first->is_static() || m->first->is_global())
1287 octave_value_list args;
1290 octave_value_list argout(nc_this->
member_invoke(m, args, 1));
1291 if (argout.length() >= 1)
1297 if (m->second.is_defined()) {
1298 if (m->second.is_function() || m->second.is_function_handle()) {
1303 }
else if (m->first) {
1304 if (m->first->get_method)
1305 return m->first->get_method(args, 1);
1306 else if (m->first->method)
1309 error(
"undefined member");
1310 return octave_value_list();
1314#if SWIG_OCTAVE_PREREQ(9,0,0)
1319 return octave_value((octave_base_value *) &x);
1327 bool _always_static =
false)
1331 types.push_back(std::make_pair(_type, _ptr));
1332#ifdef SWIG_DIRECTORS
1334 Swig::Director *d = Swig::get_rtdir(_ptr);
1336 Swig::swig_director_set_self(d,
this);
1343#if SWIG_OCTAVE_PREREQ(9,0,0)
1348 for (
unsigned int j = 0; j <
types.size(); ++j) {
1349 if (!
types[j].first || !
types[j].first->clientdata)
1357#ifdef SWIG_DIRECTORS
1358 for (
unsigned int j = 0; j <
types.size(); ++j)
1359 Swig::erase_rtdir(
types[j].second.ptr);
1366 return dim_vector(1,1);
1369#if SWIG_OCTAVE_PREREQ(4,4,0)
1372 if (out.is_cell()) {
1374 const Cell & c=out.cell_value();
1375 int ndim = c.rows();
1376 if (ndim==1 && c.columns()!=1) ndim = c.columns();
1379 d.resize(ndim < 2 ? 2 : ndim);
1383 for (
int k=0;k<ndim;k++) {
1384 const octave_value& obj = c(k);
1385#if SWIG_OCTAVE_PREREQ(6,0,0)
1387 d.elem(k) = obj.int_value();
1389 catch (octave::execution_exception& oee) {
1391 return dim_vector(1,1);
1394 d.elem(k) = obj.int_value();
1397 if (error_state)
return dim_vector(1,1);
1401#if SWIG_OCTAVE_PREREQ(4,4,0)
1402 }
else if (out.is_matrix_type() || out.isnumeric() ) {
1404 }
else if (out.is_matrix_type() || out.is_numeric_type() ) {
1406 if (out.rows()==1 || out.columns()==1) {
1407#if SWIG_OCTAVE_PREREQ(6,0,0)
1410 a = out.int_vector_value();
1412 catch (octave::execution_exception& oee) {
1413 return dim_vector(1,1);
1416 Array<int> a = out.int_vector_value();
1417 if (error_state)
return dim_vector(1,1);
1420 d.resize(a.numel() < 2 ? 2 : a.numel());
1422 for (
int k=0;k<a.numel();k++) {
1427 return dim_vector(1,1);
1430 return dim_vector(1,1);
1435#if SWIG_OCTAVE_PREREQ(9,0,0)
1444#if SWIG_OCTAVE_PREREQ(9,0,0)
1452#if SWIG_OCTAVE_PREREQ(9,0,0)
1462 return (
size_t)
this;
1463 return (
size_t)
types[0].second.ptr;
1468 if (!
types[0].first->clientdata)
1478 for (
unsigned int j = 0; j <
types.size(); ++j) {
1481 if (
types[j].first->clientdata) {
1485 ret +=
types[j].first->name;
1492 for (
unsigned int j = 0; j < rhs.
types.size(); ++j) {
1493 assert(!rhs.
types[j].second.destroyed);
1494#ifdef SWIG_DIRECTORS
1495 Swig::Director *d = Swig::get_rtdir(rhs.
types[j].second.ptr);
1497 Swig::swig_director_set_self(d,
this);
1502#if SWIG_OCTAVE_PREREQ(4,4,0)
1516 int clear_pointer = 0;
1533 if (!type &&
types.size()) {
1535 *vptr =
types[0].second.ptr;
1537 types[0].second.ptr = 0;
1541 for (
unsigned int j = 0; j <
types.size(); ++j)
1542 if (type ==
types[j].first) {
1544 *vptr =
types[j].second.ptr;
1546 types[j].second.ptr = 0;
1550 for (
unsigned int j = 0; j <
types.size(); ++j) {
1563 types[j].second.ptr = 0;
1575#ifdef SWIG_DIRECTORS
1576 void director_destroyed(Swig::Director *d) {
1578 for (
unsigned int j = 0; j < types.size(); ++j) {
1579 Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1581 types[j].second.destroyed =
true;
1594 members[
name] = std::make_pair(m, octave_value());
1613#if SWIG_OCTAVE_PREREQ(6,0,0)
1614 virtual bool isstruct()
const {
1621 virtual octave_value
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx) {
1622 octave_value_list ovl =
subsref(ops, idx, 1);
1623 return ovl.length()? ovl(0) : octave_value();
1626 virtual octave_value_list
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout) {
1627 assert(ops.size() > 0);
1628 assert(ops.size() == idx.size());
1630 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1632 octave_value_list sub_ovl;
1639 error(
"cannot create instance");
1640 return octave_value_list();
1642 octave_value_list args;
1645 args.append(*idx_it++);
1650 else if (ops[skip] ==
'.') {
1651 std::string subname;
1654 octave_value_list subname_ovl(*idx_it++);
1656 assert(subname_ovl.length() == 1 && subname_ovl(0).
is_string());
1657 subname = subname_ovl(0).string_value();
1660 if (!next_base || skip >= (
int) ops.size() || ops[skip] !=
'.')
1666 if (!base || !(m->first =
find_member(base, subname)))
1669 error(
"member not found");
1670 return octave_value_list();
1673 octave_value_list args;
1675 (!m->first || (!m->first->is_static() && !m->first->is_global())))
1677 if (skip < (
int) ops.size() && ops[skip] ==
'(' &&
1678 ((m->first && m->first->method) || m->second.is_function() ||
1679 m->second.is_function_handle())) {
1680 args.append(*idx_it++);
1689 if (ops[skip] ==
'(' || ops[skip] ==
'{') {
1690 const char *op_name = ops[skip] ==
'(' ?
"__paren__" :
"__brace__";
1691 octave_value_list args;
1692 args.append(*idx_it++);
1695 error(
"error evaluating index operator");
1696 return octave_value_list();
1699 error(
"unsupported subsref");
1700 return octave_value_list();
1704 if (skip >= (
int) ops.size())
1706 if (sub_ovl.length() < 1) {
1707 error(
"bad subs ref");
1708 return octave_value_list();
1710 return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1713 octave_value
subsasgn(
const std::string &ops,
const std::list < octave_value_list > &idx,
const octave_value &rhs) {
1714 assert(ops.size() > 0);
1715 assert(ops.size() == idx.size());
1717 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1720 if (ops.size() > 1) {
1721 std::list < octave_value_list >::const_iterator last = idx.end();
1723 std::list < octave_value_list > next_idx(idx.begin(), last);
1724 octave_value next_ov =
subsref(ops.substr(0, ops.size() - 1), next_idx);
1725 next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1728 else if (ops[skip] ==
'(' || ops[skip] ==
'{') {
1729 const char *op_name = ops[skip] ==
'(' ?
"__paren_asgn__" :
"__brace_asgn__";
1732 octave_value_list args;
1734 args.append(*idx_it);
1738 error(
"%s member not found", op_name);
1741 else if (ops[skip] ==
'.') {
1742 octave_value_list subname_ovl(*idx_it++);
1744 assert(subname_ovl.length() == 1 &&subname_ovl(0).
is_string());
1745 std::string subname = subname_ovl(0).string_value();
1748 if (!m->first || !m->first->set_method) {
1751 }
else if (m->first->set_method) {
1752 octave_value_list args;
1753 if (!m->first->is_static() && !m->first->is_global())
1756 m->first->set_method(args, 1);
1758 error(
"member not assignable");
1760 error(
"unsupported subsasgn");
1765#if SWIG_OCTAVE_PREREQ(4,4,0)
1766 virtual bool isobject()
const {
1781 error(
"__str__ method not defined");
1782 return std::string();
1784 if (!ret.is_string()) {
1785 error(
"__str__ method did not return a string");
1786 return std::string();
1788 return ret.string_value();
1794 error(
"__float__ method not defined");
1796 return ret.scalar_value();
1799#if SWIG_OCTAVE_PREREQ(4,2,0)
1800 virtual octave_value as_double(
void)
const {
1802 if (!dispatch_unary_op(
"__float__", ret)) {
1803 error(
"__float__ method not defined");
1805 return ret.as_double();
1808 virtual octave_value as_single(
void)
const {
1810 if (!dispatch_unary_op(
"__float__", ret)) {
1811 error(
"__float__ method not defined");
1813 return ret.as_single();
1817#if SWIG_OCTAVE_PREREQ(3,8,0)
1818 virtual octave_value map(octave_base_value::unary_mapper_t umap)
const {
1819 const std::string opname = std::string(
"__") + octave_base_value::get_umap_name(umap) + std::string(
"__");
1821 if (!dispatch_unary_op(opname, ret)) {
1822 error(
"%s", (opname + std::string(
" method not found")).c_str());
1823 return octave_value();
1829#if SWIG_OCTAVE_PREREQ(3,3,52)
1830 virtual octave_map map_value()
const {
1831 return octave_map();
1835 return Octave_map();
1843 string_vector keys(tmp.size());
1845 for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1846 keys(k++) = it->first;
1865 octave::mach_info::float_format fmt) {
1867 oct_mach_info::float_format fmt) {
1872#if defined (HAVE_HDF5)
1873# if SWIG_OCTAVE_PREREQ(4,0,0)
1875 save_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool save_as_floats) {
1880 load_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool have_h5giterate_bug) {
1885 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats) {
1890 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug) {
1896 virtual octave_value
convert_to_str(
bool pad =
false,
bool force =
false,
char type =
'"')
const {
1904 static bool dispatch_global_op(
const std::string &symbol,
const octave_value_list &args, octave_value &ret) {
1908 octave_function *fcn = is_valid_function(symbol, std::string(),
false);
1911#if SWIG_OCTAVE_PREREQ(4,4,0)
1912 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1913 octave_value_list retval = fcn->call(tw, 1, args);
1914 if (retval.length() == 1)
1917 ret = fcn->do_multi_index_op(1, args)(0);
1927 if (ost->
dispatch_unary_op(std::string(
"__") + op_name + std::string(
"__"), ret))
1930 octave_value_list args;
1935 error(
"could not dispatch unary operator");
1936 return octave_value();
1939 static octave_value
dispatch_binary_op(
const octave_base_value &lhs,
const octave_base_value &rhs,
const char *op_name) {
1944 if (lhs_ost && lhs_ost->
dispatch_binary_op(std::string(
"__") + op_name + std::string(
"__"), rhs, ret))
1947 if (strlen(op_name) == 2 && (op_name[1] ==
't' || op_name[1] ==
'e')) {
1948 if (op_name[0] ==
'l' && rhs_ost->
dispatch_binary_op(std::string(
"__g") + op_name[1] + std::string(
"__"), lhs, ret))
1950 if (op_name[0] ==
'g' && rhs_ost->
dispatch_binary_op(std::string(
"__l") + op_name[1] + std::string(
"__"), lhs, ret))
1953 if (rhs_ost->
dispatch_binary_op(std::string(
"__r") + op_name + std::string(
"__"), lhs, ret))
1958 octave_value_list args;
1989 error(
"could not dispatch binary operator");
1990 return octave_value();
1993#if SWIG_OCTAVE_PREREQ(4,0,0)
1994 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
1996 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
2008 os <<
"{"; newline(os);
2009 increment_indent_level();
2010 for (
unsigned int j = 0; j <
types.size(); ++j) {
2012 if (
types[j].first->clientdata) {
2014 os << c->
name <<
", ptr = " <<
types[j].second.ptr; newline(os);
2016 os <<
types[j].first->name <<
", ptr = " <<
types[j].second.ptr; newline(os);
2019 for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
2021 if (it->second.first) {
2022 const char *objtype = it->second.first->method ?
"method" :
"variable";
2023 const char *modifier = (it->second.first->flags &1) ?
"static " : (it->second.first->flags &2) ?
"global " :
"";
2024 os << it->second.first->name <<
" (" << modifier << objtype <<
")"; newline(os);
2025 assert(it->second.first->name == it->first);
2027 os << it->first; newline(os);
2030 decrement_indent_level();
2032 os <<
"}"; newline(os);
2055#if SWIG_OCTAVE_PREREQ(9,0,0)
2057 s_t_id = octave_swig_ref::static_type_id();
2060 t_id = octave_swig_ref::static_type_id();
2066 {
if (
ptr)
ptr->decref(); }
2078 {
return ptr->dims(); }
2081 {
return ptr->is_defined(); }
2083#if SWIG_OCTAVE_PREREQ(6,0,0)
2084 virtual bool isstruct()
const
2085 {
return ptr->isstruct(); }
2088 {
return ptr->is_map(); }
2091 virtual octave_value
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx)
2092 {
return ptr->subsref(ops, idx); }
2094 virtual octave_value_list
subsref(
const std::string &ops,
const std::list < octave_value_list > &idx,
int nargout)
2095 {
return ptr->subsref(ops, idx, nargout); }
2097 octave_value
subsasgn(
const std::string &ops,
const std::list < octave_value_list > &idx,
const octave_value &rhs)
2098 {
return ptr->subsasgn(ops, idx, rhs); }
2100#if SWIG_OCTAVE_PREREQ(4,4,0)
2101 virtual bool isobject()
const
2102 {
return ptr->isobject(); }
2105 {
return ptr->is_object(); }
2109 {
return ptr->is_string(); }
2112 {
return ptr->string_value(force); }
2115 {
return ptr->scalar_value(frc_str_conv); }
2117#if SWIG_OCTAVE_PREREQ(4,2,0)
2118 virtual octave_value as_double(
void)
const
2119 {
return ptr->as_double(); }
2121 virtual octave_value as_single(
void)
const
2122 {
return ptr->as_single(); }
2125#if SWIG_OCTAVE_PREREQ(3,8,0)
2126 virtual octave_value map(octave_base_value::unary_mapper_t umap)
const
2127 {
return ptr->map(umap); }
2130#if SWIG_OCTAVE_PREREQ(3,3,52)
2131 virtual octave_map map_value()
const
2135 {
return ptr->map_value(); }
2139 {
return ptr->map_keys(); }
2142 {
return ptr->save_ascii(os); }
2145 {
return ptr->load_ascii(is); }
2148 {
return ptr->save_binary(os, save_as_floats); }
2152 octave::mach_info::float_format fmt)
2154 oct_mach_info::float_format fmt)
2156 {
return ptr->load_binary(is, swap, fmt); }
2158#if defined (HAVE_HDF5)
2159# if SWIG_OCTAVE_PREREQ(4,0,0)
2161 save_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool save_as_floats)
2162 {
return ptr->save_hdf5(loc_id,
name, save_as_floats); }
2165 load_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool have_h5giterate_bug)
2166 {
return ptr->load_hdf5(loc_id,
name, have_h5giterate_bug); }
2169 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats)
2170 {
return ptr->save_hdf5(loc_id,
name, save_as_floats); }
2173 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug)
2174 {
return ptr->load_hdf5(loc_id,
name, have_h5giterate_bug); }
2178 virtual octave_value
convert_to_str(
bool pad =
false,
bool force =
false,
char type =
'"')
const
2179 {
return ptr->convert_to_str(pad, force, type); }
2182 {
return ptr->convert_to_str_internal(pad, force, type); }
2184#if SWIG_OCTAVE_PREREQ(4,0,0)
2185 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
2187 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
2189 {
return ptr->print(os, pr_as_read_syntax); }
2191#if SWIG_OCTAVE_PREREQ(9,0,0)
2192 static void set_type_id(
int type_id) { s_t_id=type_id; }
2194# if SWIG_OCTAVE_PREREQ(4,4,0)
2195 static void set_type_id(
int type_id) { t_id=type_id; }
2201 octave_scalar::static_type_id ());
2210#if !SWIG_OCTAVE_PREREQ(4,0,0)
2215#if !SWIG_OCTAVE_PREREQ(4,0,0)
2226 :
type(_type),
buf((const char*)_buf, (const char*)_buf + _buf_len)
2229#if SWIG_OCTAVE_PREREQ(9,0,0)
2231 s_t_id = octave_swig_packed::static_type_id();
2234 t_id = octave_swig_packed::static_type_id();
2240 if (outtype && outtype !=
type)
2242 assert(sz <=
buf.size());
2243 std::copy(
buf.begin(),
buf.begin()+sz, (
char*)ptr);
2259#if SWIG_OCTAVE_PREREQ(4,0,0)
2260 void print(std::ostream &os,
bool pr_as_read_syntax =
false)
2262 void print(std::ostream &os,
bool pr_as_read_syntax =
false) const
2266 os <<
"swig packed type: name = " << (
type ?
type->name : std::string()) <<
", len = " <<
buf.size(); newline(os);
2284 octave::mach_info::float_format fmt) {
2286 oct_mach_info::float_format fmt) {
2291#if defined (HAVE_HDF5)
2292# if SWIG_OCTAVE_PREREQ(4,0,0)
2294 save_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool save_as_floats) {
2299 load_hdf5 (octave_hdf5_id loc_id,
const char *
name,
bool have_h5giterate_bug) {
2304 save_hdf5 (hid_t loc_id,
const char *
name,
bool save_as_floats) {
2309 load_hdf5 (hid_t loc_id,
const char *
name,
bool have_h5giterate_bug) {
2315#if SWIG_OCTAVE_PREREQ(9,0,0)
2316 static void set_type_id(
int type_id) { s_t_id=type_id; }
2318# if SWIG_OCTAVE_PREREQ(4,4,0)
2319 static void set_type_id(
int type_id) { t_id=type_id; }
2324#if !SWIG_OCTAVE_PREREQ(4,0,0)
2329#if !SWIG_OCTAVE_PREREQ(4,0,0)
2335 error(
"attempt to set immutable member variable");
2336 return octave_value_list();
2344 :
ovl(_ovl),
j(_j) { }
2346 operator octave_value()
const {
2369 && ov.rows() == 1 && ov.columns() == 1)
2370 ov = ov.cell_value()(0);
2375 if (ov.type_id() != octave_swig_ref::static_type_id())
2384#define swig_unary_op(name) \
2385SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
2386 return octave_swig_type::dispatch_unary_op(x,#name); \
2388#define swig_binary_op(name) \
2389SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
2390 return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
2392#if SWIG_OCTAVE_PREREQ(4,4,0)
2393#define swigreg_unary_op(name) \
2394if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2395typeinfo.register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2397#define swigreg_unary_op(name) \
2398if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2399octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2401#if SWIG_OCTAVE_PREREQ(4,4,0)
2402#define swigreg_binary_op(name) \
2403if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2404typeinfo.register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2406#define swigreg_binary_op(name) \
2407if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2408octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2425#if !SWIG_OCTAVE_PREREQ(4,2,0)
2443#if SWIG_OCTAVE_PREREQ(4,4,0)
2444 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2455#if SWIG_OCTAVE_PREREQ(4,4,0)
2456 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2464#if !SWIG_OCTAVE_PREREQ(4,2,0)
2488 for (
int j = 0; j < tid; ++j) {
2498#ifdef SWIG_DIRECTORS
2499 Swig::Director *d = Swig::get_rtdir(ptr);
2500 if (d && Swig::swig_director_get_self(d))
2501 return Swig::swig_director_get_self(d)->as_value();
2505 return octave_value(Matrix());
2515 && ov.rows() == 1 && ov.columns() == 1)
2516 ov = ov.cell_value()(0);
2517 if (!ov.is_defined() ||
2518 (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2523 if (ov.type_id() != octave_swig_ref::static_type_id())
2527 return ost->
cast(ptr, type, own, flags);
2535 if (!ov.is_defined())
2537 if (ov.type_id() != octave_swig_packed::static_type_id())
2548#if SWIG_OCTAVE_PREREQ(6,0,0)
2549 octave::interpreter *
interp = octave::interpreter::the_interpreter ();
2552#if SWIG_OCTAVE_PREREQ(4,4,0)
2553 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2554 return symtab.global_varval(
name);
2556 return get_global_value(
name,
true);
2562#if SWIG_OCTAVE_PREREQ(6,0,0)
2563 octave::interpreter *
interp = octave::interpreter::the_interpreter ();
2565#elif SWIG_OCTAVE_PREREQ(4,4,0)
2566 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2574#if SWIG_OCTAVE_PREREQ(4,4,0)
2575 octave::symbol_scope symscope = octave::interpreter::the_interpreter()->get_current_scope();
2576#if SWIG_OCTAVE_PREREQ(6,0,0)
2577 octave::interpreter *
interp = octave::interpreter::the_interpreter ();
2579 octave::tree_evaluator& tree_eval =
interp->get_evaluator();
2580#if SWIG_OCTAVE_PREREQ(8,0,0)
2581 std::shared_ptr<octave::stack_frame> stackFrame = tree_eval.get_current_stack_frame();
2583 octave::call_stack& callStack = tree_eval.get_call_stack();
2584 std::shared_ptr<octave::stack_frame> stackFrame = tree_eval.get_current_stack_frame();
2586 octave::symbol_record sym=symscope.lookup_symbol(
name);
2587 stackFrame->mark_global(sym);
2589 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2590 symscope.assign(
name, symtab.global_varval(
name));
2591 symscope.mark_global(
name);
2594#if !SWIG_OCTAVE_PREREQ(3,2,0)
2595 link_to_global_variable(curr_sym_tab->lookup(
name,
true));
2597#if !SWIG_OCTAVE_PREREQ(3,8,0)
2598 symbol_table::varref(
name);
2600 symbol_table::mark_global(
name);
2607 if (!ov.is_defined() ||
2608 ov.type_id() != octave_swig_packed::static_type_id())
2624 if (obj.is_string())
2625 error(
"%s", obj.string_value().c_str());
2627 error(
"C++ side threw an exception of type %s", type);
2632#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2634#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
2640#define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2641#define SWIGTYPE_p_char swig_types[1]
2642#define SWIGTYPE_p_double swig_types[2]
2643#define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2644#define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2645#define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2646#define SWIGTYPE_p_int swig_types[6]
2647#define SWIGTYPE_p_p_char swig_types[7]
2648#define SWIGTYPE_p_unsigned_int swig_types[8]
2651#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2652#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2660template<
typename T>
class SwigValueWrapper {
2661 struct SwigSmartPointer {
2663 SwigSmartPointer(T *p) : ptr(p) { }
2664 ~SwigSmartPointer() {
delete ptr; }
2665 SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0;
delete oldptr; ptr = rhs.ptr; rhs.ptr = 0;
return *
this; }
2666 void reset(T *p) { T* oldptr = ptr; ptr = 0;
delete oldptr; ptr = p; }
2668 SwigValueWrapper& operator=(
const SwigValueWrapper<T>& rhs);
2669 SwigValueWrapper(
const SwigValueWrapper<T>& rhs);
2671 SwigValueWrapper() : pointer(0) { }
2672 SwigValueWrapper& operator=(
const T& t) { SwigSmartPointer tmp(
new T(t)); pointer = tmp;
return *
this; }
2673#if __cplusplus >=201103L
2674 SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(
new T(std::move(t))); pointer = tmp;
return *
this; }
2675 operator T&&()
const {
return std::move(*pointer.ptr); }
2677 operator T&()
const {
return *pointer.ptr; }
2679 T *operator&()
const {
return pointer.ptr; }
2680 static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
2692template <
typename T> T SwigValueInit() {
2696#if __cplusplus >=201103L
2697# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
2699# define SWIG_STD_MOVE(OBJ) OBJ
2705#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2706#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2720 #if defined ( __GNUC__ ) && __GNUC__ > 3
2721 #undef OCTAVE_EXPORT
2722 #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2740 inline int max(
int a,
int b )
2742 return a >= b ? a : b;
2744 inline int min(
int a,
int b )
2746 return a >= b ? a : b;
2760 return max( o_obj.rows(), 1 ) *
max( o_obj.columns(), 1 );
2772 if (
max( o_obj.columns(), 1 ) > 1 )
2777 else if (
max( o_obj.rows(), 1 ) > 1 )
2787 _dim(
const octave_value &o_obj,
int dim_idx )
2790 return max( o_obj.rows(), 0 );
2794 else if ( dim_idx == 1 )
2795 return max( o_obj.columns(), 0 );
2808 template <
class FLOAT>
2812 while ( n_el-- > 0 )
2813 *out_arr++ = (FLOAT) ( *in_arr++ );
2832 template <
class FLOAT>
2836 while ( n_el-- > 0 )
2837 *d_arr++ = double(*arr++);
2868 octave_value_list functionArguments;
2869 octave_value_list retval;
2876 for ( i = 0; i < n; i++ )
2882 functionArguments( 0 ) = xin;
2883 functionArguments( 1 ) = yin;
2886#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2887 retval = octave::feval(
fcnMapForm, functionArguments, 1 );
2889 retval = feval(
fcnMapForm, functionArguments, 1 );
2892#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2893 retval = octave::feval(
nameMapForm, functionArguments, 1 );
2895 retval = feval(
nameMapForm, functionArguments, 1 );
2898 if ( retval.length() >= 2 )
2900 xout = retval( 0 ).matrix_value();
2901 yout = retval( 1 ).matrix_value();
2903 for ( i = 0; i < n; i++ )
2905 x[i] = xout( i, 0 );
2906 y[i] = yout( i, 0 );
2918 octave_value_list functionArguments;
2919 octave_value_list retval;
2921 Matrix inAxis( 1, 1 );
2922 Matrix inValue( 1, 1 );
2923 inAxis( 0, 0 ) = axis;
2924 inValue( 0, 0 ) =
value;
2926 functionArguments( 0 ) = inAxis;
2927 functionArguments( 1 ) = inValue;
2930#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2931 retval = octave::feval(
fcnLabelFunc, functionArguments, 1 );
2936#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2937 retval = octave::feval(
nameLabelFunc, functionArguments, 1 );
2942 strncpy( label, retval( 0 ).string_value().c_str(), length );
2952 octave_value_list functionArguments;
2953 octave_value_list retval;
2963 functionArguments( 0 ) = xin;
2964 functionArguments( 1 ) = yin;
2967#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2968 retval = octave::feval(
fcnCoordTrans, functionArguments, 1 );
2973#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2979 if ( retval.length() >= 2 )
2981 xout = retval( 0 ).matrix_value();
2982 yout = retval( 1 ).matrix_value();
2993 printf(
"nlegend =%d\n", nlegend );
2994 for ( i = 0; i < nlegend; i++ )
2996 printf(
"opt_array[%d] =%d\n", i, opt_array[i] );
2997 printf(
"strlen(text[%d]) =%d\n", i, (
int) strlen(
text[i] ) );
2998 printf(
"text[%d] =%s\n", i,
text[i] );
3004#if !defined(SWIG_NO_LLONG_MAX)
3005# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3006# define LLONG_MAX __LONG_LONG_MAX__
3007# define LLONG_MIN (-LLONG_MAX - 1LL)
3008# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3015 if (!ov.is_scalar_type())
3017 if (ov.is_complex_scalar())
3019 if (ov.is_double_type()||ov.is_single_type()) {
3020 double v=ov.double_value();
3025 *val = ov.long_value();
3036 if ((v < INT_MIN || v > INT_MAX)) {
3039 if (val) *val =
static_cast< int >(v);
3046 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 )
3054 *pX = gin.
pX; *pY = gin.
pY; *dX = gin.
dX; *dY = gin.
dY; *wX = gin.
wX; *wY = gin.
wY;
3068 && ov.rows() == 1 && ov.columns() == 1)
3069 ov = ov.cell_value()(0);
3071 if (ov.is_string()) {
3072 std::string str=ov.string_value();
3073 size_t len=str.size();
3074 char* cstr=(
char*)str.c_str();
3076 *cptr =
reinterpret_cast< char*
>(memcpy(
new char[len + 1], cstr,
sizeof(
char)*(len + 1)));
3082 }
else if (!ov.is_defined() || (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
3097 return octave_value(
value);
3110 return octave_value(
value);
3119 gin.
dX = x_in; gin.
dY = y_in;
3121 *x = gin.
wX; *y = gin.
wY;
3128 if (!ov.is_scalar_type())
3130 if (ov.is_complex_scalar())
3133 *val = ov.double_value();
3146 const char *legline1,
const char *legline2,
const char *legline3,
const char *legline4,
3147 const char *labx,
const char *laby,
const char *labtop )
3149 const char *legline[4];
3150 legline[0] = legline1; legline[1] = legline2;
3151 legline[2] = legline3; legline[3] = legline4;
3152 c_plstripc(
id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
3153 xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
3154 labx, laby, labtop );
3172 *tx = *( (
PLFLT *) pltr_data + 0 ) * x + *( (
PLFLT *) pltr_data + 1 ) * y + *( (
PLFLT *) pltr_data + 2 );
3173 *ty = *( (
PLFLT *) pltr_data + 3 ) * x + *( (
PLFLT *) pltr_data + 4 ) * y + *( (
PLFLT *) pltr_data + 5 );
3178#define f2c( f, ff, nx, ny ) \
3180 ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
3181 for ( int i = 0; i < nx; i++ ) { \
3182 ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
3183 for ( int j = 0; j < ny; j++ ) \
3184 *( ff[i] + j ) = *( f + nx * j + i );}
3191 f2c( f, ff, nx, ny );
3192 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
xform, tr );
3200 f2c( f, ff, nx, ny );
3201 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr0, NULL );
3210 grid1.
nx = nx; grid1.
ny = ny;
3212 f2c( f, ff, nx, ny );
3213 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr1, &grid1 );
3221 f2c( xg, xgg, nx, ny );
3222 f2c(
yg, ygg, nx, ny );
3223 grid2.
nx = nx; grid2.
ny = ny;
3224 grid2.
xg = xgg; grid2.
yg = ygg;
3225 f2c( f, ff, nx, ny );
3226 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
3235 f2c( xg, xgg, nx, ny );
3236 f2c(
yg, ygg, nx, ny );
3237 grid2.
nx = nx; grid2.
ny = ny;
3238 grid2.
xg = xgg; grid2.
yg = ygg;
3239 f2c( f, ff, nx, ny );
3240 c_plcont( (
const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel,
pltr2, &grid2 );
3245 const PLFLT *xg,
int nptsx,
const PLFLT *
yg,
int nptsy,
3248 f2c(
zg, zgg, nptsx, nptsy );
3249 plgriddata( x, y, z, npts, xg, nptsx,
yg, nptsy, zgg, type, data );
3250 for (
int i = 0; i < nptsx; i++ )
3251 for (
int j = 0; j < nptsy; j++ )
3252 *(
zg + nptsx * j + i ) = zgg[i][j];
3260 f2c( z, zz, nx, ny );
3268 f2c( z, zz, nx, ny );
3269 c_plmeshc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3277 f2c( z, zz, nx, ny );
3286 f2c( z, zz, nx, ny );
3287 c_plot3dc( x, y, (
const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3296 f2c( z, zz, nx, ny );
3298 indexxmin, indexxmax, indexymin, indexymax );
3305 f2c( z, zz, nx, ny );
3313 f2c( z, zz, nx, ny );
3315 indexxmin, indexxmax, indexymin, indexymax );
3333 f2c( a, aa, nx, ny );
3334 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3335 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3336 min_color, min_width, max_color, max_width,
3350 grid1.
nx = nx; grid1.
ny = ny;
3352 f2c( a, aa, nx, ny );
3353 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3354 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3355 min_color, min_width, max_color, max_width,
3369 f2c( xg, xgg, nx, ny );
3370 f2c(
yg, ygg, nx, ny );
3371 grid2.
nx = nx; grid2.
ny = ny;
3372 grid2.
xg = xgg; grid2.
yg = ygg;
3373 f2c( a, aa, nx, ny );
3374 c_plshade( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3375 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3376 min_color, min_width, max_color, max_width,
3388 f2c( a, aa, nx, ny );
3389 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3390 clevel, nlevel, fill_width, cont_color, cont_width,
3391 plfill, rectangular, NULL, NULL );
3400 f2c( a, aa, nx, ny );
3401 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3402 clevel, nlevel, fill_width, cont_color, cont_width,
3413 grid1.
nx = nx; grid1.
ny = ny;
3416 f2c( a, aa, nx, ny );
3417 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3418 clevel, nlevel, fill_width, cont_color, cont_width,
3429 f2c( xg, xgg, nx, ny );
3430 f2c(
yg, ygg, nx, ny );
3431 grid2.
nx = nx; grid2.
ny = ny;
3432 grid2.
xg = xgg; grid2.
yg = ygg;
3433 f2c( a, aa, nx, ny );
3434 c_plshades( (
const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3435 clevel, nlevel, fill_width, cont_color, cont_width,
3445 f2c( u, uu, nx, ny );
3446 f2c( v, vv, nx, ny );
3454 grid1.
nx = nx; grid1.
ny = ny;
3456 f2c( u, uu, nx, ny );
3457 f2c( v, vv, nx, ny );
3465 f2c( xg, xgg, nx, ny );
3466 f2c(
yg, ygg, nx, ny );
3467 grid2.
nx = nx; grid2.
ny = ny;
3468 grid2.
xg = xgg; grid2.
yg = ygg;
3469 f2c( u, uu, nx, ny );
3470 f2c( v, vv, nx, ny );
3481 f2c( a, aa, nx, ny );
3482 plimage( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
3492 f2c( a, aa, nx, ny );
3493 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
3501 f2c( a, aa, nx, ny );
3502 plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
xform, tr );
3512 grid1.
nx = nx + 1; grid1.
ny = ny + 1;
3514 f2c( a, aa, nx, ny );
3515 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr1, &grid1 );
3525 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
3526 f2c(
yg, ygg, ( nx + 1 ), ( ny + 1 ) );
3527 grid2.
nx = nx + 1; grid2.
ny = ny + 1;
3528 grid2.
xg = xgg; grid2.
yg = ygg;
3529 f2c( a, aa, nx, ny );
3530 c_plimagefr( (
const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax,
pltr2, &grid2 );
3541 PLINT n_labels,
const PLINT *label_opts,
const char **label,
3542 PLINT n_axes,
const char ** axis_opts,
3549 for ( i = 0; i < nx; i++ )
3550 if ( n_values[i] > ny )
3552 f2c( a, aa, nx, ny );
3554 opt, position, x, y,
3556 bg_color, bb_color, bb_style,
3557 low_cap_color, high_cap_color,
3558 cont_color, cont_width,
3559 n_labels, label_opts, label,
3569 if (!ov.is_scalar_type())
3571 if (ov.is_complex_scalar())
3573 if (ov.is_double_type()||ov.is_single_type()) {
3574 double v=ov.double_value();
3580 if (ov.is_int8_type()||ov.is_int16_type()||
3581 ov.is_int32_type()) {
3582 long v=ov.long_value();
3586 if (ov.is_int64_type()) {
3587 long long v=ov.int64_scalar_value().value();
3592 *val = ov.ulong_value();
3603 if ((v > UINT_MAX)) {
3606 if (val) *val =
static_cast< unsigned int >(v);
3615 return octave_value(
value);
3629 char* cptr = 0;
size_t csize = 0;
int alloc =
SWIG_OLDOBJ;
3633 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3634 if (csize <= size) {
3636 if (csize) memcpy(val, cptr, csize*
sizeof(
char));
3637 if (csize < size) memset(val + csize, 0, (size - csize)*
sizeof(
char));
3665 return std::string(carray,carray+size);
3673 for (p = s; maxlen-- && *p; p++)
3687 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3688 if (val) *val =
static_cast< char >(v);
3698Set up transformation from metafile coordinates\n\
3702 Set up transformation from metafile coordinates. The size of the plot\n\
3703 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
3704 general-purpose facility just yet (not sure why the user would need\n\
3707 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
3710 This function is not used in any examples.\n\
3716plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
3720 dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
3722 dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
3724 dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
3726 dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
3728 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3730 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
3733Set the cmap0 palette using the specified cmap0*.pal format file\n\
3737 Set the cmap0 palette using the specified cmap0*.pal format file.\n\
3739 Redacted form: plspal0(filename)\n\
3741 This function is in example 16.\n\
3751 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3752 containing the name of the cmap0*.pal file. If this string is\n\
3753 empty, use the default cmap0*.pal file.\n\
3756Set the cmap1 palette using the specified cmap1*.pal format file\n\
3760 Set the cmap1 palette using the specified cmap1*.pal format file.\n\
3762 Redacted form: plspal1(filename, interpolate)\n\
3764 This function is used in example 16.\n\
3770plspal1(filename, interpolate)\n\
3774 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
3775 containing the name of the cmap1*.pal file. If this string is\n\
3776 empty, use the default cmap1*.pal file.\n\
3778 interpolate (PLBOOL, input) : If this parameter is true, the\n\
3779 columns containing the intensity index, r, g, b, alpha and\n\
3780 alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
3781 palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
3782 a flag which controls whether the r, g, b data sent to plscmap1la\n\
3783 are interpreted as HLS or RGB.) If this parameter is false, the\n\
3784 intensity index and alt_hue_path columns are ignored and the r, g,\n\
3785 b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
3786 are used instead to set the cmap1 palette directly with a call to\n\
3790Draw a line in 3 space\n\
3794 Draws line in 3 space defined by n points in x, y, and z. You must\n\
3795 first set up the viewport, the 2d viewing window (in world\n\
3796 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
3799 Redacted form: plline3(x, y, z)\n\
3801 This function is used in example 18.\n\
3807plline3(n, x, y, z)\n\
3811 n (PLINT, input) : Number of points defining line.\n\
3813 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
3816 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
3819 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
3823Magnitude colored plot surface mesh with contour\n\
3827 A more powerful form of plmesh: the surface mesh can be colored\n\
3828 accordingly to the current z value being plotted, a contour plot can\n\
3829 be drawn at the base XY plane, and a curtain can be drawn between the\n\
3830 plotted function border and the base XY plane.\n\
3832 Redacted form: plmeshc(x, y, z, opt, clevel)\n\
3834 This function is used in example 11.\n\
3840plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
3844 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3845 which the function is evaluated.\n\
3847 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3848 which the function is evaluated.\n\
3850 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3851 plot. Should have dimensions of\n\
3855 nx (PLINT, input) : Number of x values at which function is\n\
3858 ny (PLINT, input) : Number of y values at which function is\n\
3861 opt (PLINT, input) : Determines the way in which the surface is\n\
3862 represented. To specify more than one option just add the options,\n\
3863 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3864 showing z as a function of x for each value of y[j] .\n\
3865 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3866 for each value of x[i] .\n\
3867 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3868 at which function is defined.\n\
3869 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3870 the z value being plotted. The color is used from the current\n\
3872 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3876 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3877 the borders of the plotted function.\n\
3880 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3883 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3886Draw a line between two points, accounting for coordinate transforms\n\
3890 Joins the point (\n\
3894 y2) . If a global coordinate transform is defined then the line is\n\
3895 broken in to n segments to approximate the path. If no transform is\n\
3896 defined then this simply acts like a call to pljoin.\n\
3898 Redacted form: plpath(n,x1,y1,x2,y2)\n\
3900 This function is used in example 22.\n\
3906plpath(n, x1, y1, x2, y2)\n\
3910 n (PLINT, input) : number of points to use to approximate the path.\n\
3912 x1 (PLFLT, input) : x coordinate of first point.\n\
3914 y1 (PLFLT, input) : y coordinate of first point.\n\
3916 x2 (PLFLT, input) : x coordinate of second point.\n\
3918 y2 (PLFLT, input) : y coordinate of second point.\n\
3921Write text inside the viewport\n\
3925 Writes text at a specified position and inclination within the\n\
3926 viewport. Text is clipped at the viewport boundaries. The reference\n\
3927 point of a string lies along a line passing through the string at half\n\
3928 the height of a capital letter. The position of the reference point\n\
3929 along this line is determined by just, the reference point is placed\n\
3930 at world coordinates (\n\
3932 y) within the viewport. The inclination of the string is specified\n\
3933 in terms of differences of world coordinates making it easy to write\n\
3934 text parallel to a line in a graph.\n\
3936 Redacted form: plptex(x, y, dx, dy, just, text)\n\
3938 This function is used in example 2-4,10,12-14,20,23,24,26.\n\
3944plptex(x, y, dx, dy, just, text)\n\
3948 x (PLFLT, input) : x coordinate of reference point of string.\n\
3950 y (PLFLT, input) : y coordinate of reference point of string.\n\
3952 dx (PLFLT, input) : Together with dy, this specifies the\n\
3953 inclination of the string. The baseline of the string is parallel\n\
3954 to a line joining (\n\
3962 dy (PLFLT, input) : Together with dx, this specifies the\n\
3963 inclination of the string.\n\
3965 just (PLFLT, input) : Specifies the position of the string relative\n\
3966 to its reference point. If just=0. , the reference point is at\n\
3967 the left and if just=1. , it is at the right of the string. Other\n\
3968 values of just give intermediate justifications.\n\
3970 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3974Set family file parameters\n\
3978 Sets variables dealing with output file familying. Does nothing if\n\
3979 familying not supported by the driver. This routine, if used, must be\n\
3980 called before initializing PLplot. See the PLplot documentation for\n\
3981 more information.\n\
3983 Redacted form: plsfam(fam, num, bmax)\n\
3985 This function is used in examples 14 and 31.\n\
3991plsfam(fam, num, bmax)\n\
3995 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
3998 num (PLINT, input) : Current family file number.\n\
4000 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
4004Set y axis parameters\n\
4008 Identical to plsxax, except that arguments are flags for y axis. See\n\
4009 the description of plsxax for more detail.\n\
4011 Redacted form: plsyax(digmax, digits)\n\
4013 This function is used in examples 1, 14, and 31.\n\
4019plsyax(digmax, digits)\n\
4023 digmax (PLINT, input) : Variable to set the maximum number of\n\
4024 digits for the y axis. If nonzero, the printed label will be\n\
4025 switched to a floating-point representation when the number of\n\
4026 digits exceeds digmax.\n\
4028 digits (PLINT, input) : Field digits value. Currently, changing\n\
4029 its value here has no effect since it is set only by plbox or\n\
4030 plbox3. However, the user may obtain its value after a call to\n\
4031 either of these functions by calling plgyax.\n\
4034Get z axis parameters\n\
4038 Identical to plgxax, except that arguments are flags for z axis. See\n\
4039 the description of plgxax for more detail.\n\
4041 Redacted form: plgzax(p_digmax, p_digits)\n\
4043 This function is used in example 31.\n\
4049plgzax(p_digmax, p_digits)\n\
4053 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
4054 number of digits for the z axis. If nonzero, the printed label\n\
4055 has been switched to a floating-point representation when the\n\
4056 number of digits exceeds this value.\n\
4058 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
4059 number of digits for the numeric labels (z axis) from the last\n\
4063Set format of numerical label for contours\n\
4067 Set format of numerical label for contours.\n\
4069 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
4071 This function is used example 9.\n\
4077pl_setcontlabelformat(lexp, sigdig)\n\
4081 lexp (PLINT, input) : If the contour numerical label is greater\n\
4082 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
4083 format is used. Default value of lexp is 4.\n\
4085 sigdig (PLINT, input) : Number of significant digits. Default\n\
4093 Sets the pen width.\n\
4095 Redacted form: plwidth(width)\n\
4097 This function is used in examples 1 and 2.\n\
4107 width (PLFLT, input) : The desired pen width. If width is negative\n\
4108 or the same as the previous value no action is taken. width = 0.\n\
4109 should be interpreted as as the minimum valid pen width for the\n\
4110 device. The interpretation of positive width values is also\n\
4111 device dependent.\n\
4114Get parameters that define current plot-space window\n\
4118 Get relative minima and maxima that define current plot-space window.\n\
4119 If plsdiplt has not been called the default values pointed to by\n\
4120 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
4122 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4124 This function is used in example 31.\n\
4130plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
4134 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4137 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4140 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4143 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4147Set the cmap1 argument range for continuous color plots\n\
4151 Set the cmap1 argument range for continuous color plots that\n\
4152 corresponds to the range of data values. The maximum range\n\
4153 corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
4154 the cmap1 argument range that is specified with this routine, the\n\
4155 smaller the subset of the cmap1 color palette that is used to\n\
4156 represent the continuous data being plotted. If\n\
4157 min_color is greater than\n\
4159 max_color is greater than 1.0 or\n\
4160 min_color is less than 0.0 then no change is made to the cmap1\n\
4161 argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
4163 Redacted form: plscmap1_range(min_color, max_color)\n\
4165 This function is currently used in example 33.\n\
4171plscmap1_range(min_color, max_color)\n\
4175 min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
4176 than 0.0, then 0.0 is used instead.\n\
4178 max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
4179 than 1.0, then 1.0 is used instead.\n\
4182Select standard viewport\n\
4186 Selects the largest viewport within the subpage that leaves a standard\n\
4187 margin (left-hand margin of eight character heights, and a margin\n\
4188 around the other three sides of five character heights).\n\
4190 Redacted form: plvsta()\n\
4192 This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
4201Load Hershey fonts\n\
4205 Loads the Hershey fonts used for text and symbols. This routine may\n\
4206 be called before or after initializing PLplot. If not explicitly\n\
4207 called before PLplot initialization, then by default that\n\
4208 initialization loads Hershey fonts with the extended character set.\n\
4209 This routine only has a practical effect for devices that still use\n\
4210 Hershey fonts (as opposed to modern devices that use unicode-aware\n\
4211 system fonts instead of Hershey fonts).\n\
4213 Redacted form: plfontld(fnt)\n\
4215 This function is used in examples 1 and 7.\n\
4225 fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
4226 A zero value specifies Hershey fonts with the standard character\n\
4227 set and a non-zero value (the default assumed if plfontld is never\n\
4228 called) specifies Hershey fonts with the extended character set.\n\
4231Draw error bars in x direction\n\
4235 Draws a set of n error bars in x direction, the i\'th error bar\n\
4236 extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
4237 of the error bars are of length equal to the minor tick length\n\
4238 (settable using plsmin).\n\
4240 Redacted form: General: plerrx(xmin, ymax, y)\n\
4243 This function is used in example 29.\n\
4249plerrx(n, xmin, xmax, y)\n\
4253 n (PLINT, input) : Number of error bars to draw.\n\
4255 xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4256 of the left-hand endpoints of the error bars.\n\
4258 xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
4259 of the right-hand endpoints of the error bars.\n\
4261 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4265Plot shaded 3-d surface plot\n\
4269 Plots a three-dimensional shaded surface plot within the environment\n\
4270 set up by plw3d. The surface is defined by the two-dimensional matrix\n\
4273 ny], the point z[i][j] being the value of the function at (\n\
4275 y[j]). Note that the points in vectors x and y do not need to be\n\
4276 equally spaced, but must be stored in ascending order. For further\n\
4277 details see the PLplot documentation.\n\
4279 Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
4281 This function is not used in any examples.\n\
4287plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
4291 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4292 which the function is evaluated.\n\
4294 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4295 which the function is evaluated.\n\
4297 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4298 plot. Should have dimensions of\n\
4302 nx (PLINT, input) : Number of x values at which function is\n\
4305 ny (PLINT, input) : Number of y values at which function is\n\
4308 opt (PLINT, input) : Determines the way in which the surface is\n\
4309 represented. To specify more than one option just add the options,\n\
4310 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
4311 connecting points at which function is defined.\n\
4312 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
4316 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
4320 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
4321 the borders of the plotted function.\n\
4322 opt=MAG_COLOR : the surface is colored according to the value\n\
4323 of Z; if MAG_COLOR is not used, then the surface is colored\n\
4324 according to the intensity of the reflected light in the\n\
4325 surface from a light source whose position is set using\n\
4329 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
4332 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
4335Get the current library version number\n\
4339 Get the current library version number. Note: you must have allocated\n\
4340 space for this (80 characters is safe).\n\
4342 Redacted form: plgver(p_ver)\n\
4344 This function is used in example 1.\n\
4354 p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4355 (with preallocated length of 80 characters or more) containing the\n\
4356 PLplot version number.\n\
4359End plotting session for current stream\n\
4363 Ends a plotting session for the current output stream only. See\n\
4364 plsstrm for more info.\n\
4366 Redacted form: plend1()\n\
4368 This function is used in examples 1 and 20.\n\
4377Draw error bars in the y direction\n\
4381 Draws a set of n error bars in the y direction, the i\'th error bar\n\
4382 extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
4383 of the error bars are of length equal to the minor tick length\n\
4384 (settable using plsmin).\n\
4386 Redacted form: General: plerry(x, ymin, ymax)\n\
4389 This function is used in example 29.\n\
4395plerry(n, x, ymin, ymax)\n\
4399 n (PLINT, input) : Number of error bars to draw.\n\
4401 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4404 ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4405 of the lower endpoints of the error bars.\n\
4407 ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
4408 of the upper endpoints of the error bars.\n\
4411Set seed for internal random number generator.\n\
4415 Set the seed for the internal random number generator. See plrandd for\n\
4418 Redacted form: plseed(seed)\n\
4420 This function is used in example 21.\n\
4430 seed (unsigned int, input) : Seed for random number generator.\n\
4433Specify viewport using normalized subpage coordinates\n\
4437 Device-independent routine for setting up the viewport. This defines\n\
4438 the viewport in terms of normalized subpage coordinates which run from\n\
4439 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
4440 current subpage. Use the alternate routine plsvpa in order to create\n\
4441 a viewport of a definite size.\n\
4443 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
4445 This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
4446 24, 26, 27, and 31.\n\
4452plvpor(xmin, xmax, ymin, ymax)\n\
4456 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
4457 left-hand edge of the viewport.\n\
4459 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
4460 right-hand edge of the viewport.\n\
4462 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
4463 bottom edge of the viewport.\n\
4465 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
4466 edge of the viewport.\n\
4473 Plots a surface mesh within the environment set up by plw3d. The\n\
4474 surface is defined by the matrix z[\n\
4476 ny] , the point z[i][j] being the value of the function at (\n\
4478 y[j]). Note that the points in vectors x and y do not need to be\n\
4479 equally spaced, but must be stored in ascending order. The parameter\n\
4480 opt controls the way in which the surface is displayed. For further\n\
4481 details see the PLplot documentation.\n\
4483 Redacted form: plmesh(x, y, z, opt)\n\
4485 This function is used in example 11.\n\
4491plmesh(x, y, z, nx, ny, opt)\n\
4495 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
4496 which the function is evaluated.\n\
4498 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
4499 which the function is evaluated.\n\
4501 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
4502 plot. Should have dimensions of\n\
4506 nx (PLINT, input) : Number of x values at which function has been\n\
4509 ny (PLINT, input) : Number of y values at which function has been\n\
4512 opt (PLINT, input) : Determines the way in which the surface is\n\
4513 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
4514 function of x for each value of y[j] .\n\
4515 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
4516 for each value of x[i] .\n\
4517 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
4518 at which function is defined.\n\
4521Get the cmap1 argument range for continuous color plots\n\
4525 Get the cmap1 argument range for continuous color plots. (Use\n\
4526 plscmap1_range to set the cmap1 argument range.)\n\
4528 Redacted form: plgcmap1_range(min_color, max_color)\n\
4530 This function is currently not used in any example.\n\
4536plgcmap1_range(min_color, max_color)\n\
4540 min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4541 minimum cmap1 argument.\n\
4543 max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
4544 maximum cmap1 argument.\n\
4547Set arrow style for vector plots\n\
4551 Set the style for the arrow used by plvect to plot vectors.\n\
4553 Redacted form: plsvect(arrowx, arrowy, fill)\n\
4555 This function is used in example 22.\n\
4561plsvect(arrowx, arrowy, npts, fill)\n\
4565 arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
4566 the x and y points which make up the arrow. The arrow is plotted\n\
4567 by joining these points to form a polygon. The scaling assumes\n\
4568 that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
4569 <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
4570 will be reset to its default.\n\
4572 npts (PLINT, input) : Number of points in the vectors arrowx and\n\
4575 fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
4576 fill is false then the arrow is open.\n\
4579Draw filled polygon\n\
4583 Fills the polygon defined by the n points (\n\
4585 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4586 style is a solid fill. The routine will automatically close the\n\
4587 polygon between the last and first vertices. If multiple closed\n\
4588 polygons are passed in x and y then plfill will fill in between them.\n\
4590 Redacted form: plfill(x,y)\n\
4592 This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
4602 n (PLINT, input) : Number of vertices in polygon.\n\
4604 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4607 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4611Convert HLS color to RGB\n\
4615 Convert HLS color coordinates to RGB.\n\
4617 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4620 This function is used in example 2.\n\
4626plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
4630 h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
4633 l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
4634 the axis of the color cylinder.\n\
4636 s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
4637 the radius of the color cylinder.\n\
4639 p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
4640 (0.0-1.0) of the color.\n\
4642 p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
4643 intensity (0.0-1.0) of the color.\n\
4645 p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
4646 intensity (0.0-1.0) of the color.\n\
4649Set format for date / time labels\n\
4653 Sets the format for date / time labels. To enable date / time format\n\
4654 labels see the options to plbox, plbox3, and plenv.\n\
4656 Redacted form: pltimefmt(fmt)\n\
4658 This function is used in example 29.\n\
4668 fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
4669 interpreted similarly to the format specifier of typical system\n\
4670 strftime routines except that PLplot ignores locale and also\n\
4671 supplies some useful extensions in the context of plotting. All\n\
4672 text in the string is printed as-is other than conversion\n\
4673 specifications which take the form of a \'%\' character followed by\n\
4674 further conversion specification character. The conversion\n\
4675 specifications which are similar to those provided by system\n\
4676 strftime routines are the following: %a: The abbreviated (English)\n\
4678 %A: The full (English) weekday name.\n\
4679 %b: The abbreviated (English) month name.\n\
4680 %B: The full (English) month name.\n\
4681 %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
4682 %C: The century number (year/100) as a 2-digit integer.\n\
4683 %d: The day of the month as a decimal number (range 01 to 31).\n\
4684 %D: Equivalent to %m/%d/%y (non-ISO).\n\
4685 %e: Like %d, but a leading zero is replaced by a space.\n\
4686 %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
4687 %h: Equivalent to %b.\n\
4688 %H: The hour as a decimal number using a 24-hour clock (range\n\
4690 %I: The hour as a decimal number using a 12-hour clock (range\n\
4692 %j: The day of the year as a decimal number (range 001 to\n\
4694 %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
4695 23); single digits are preceded by a blank. (See also %H.)\n\
4696 %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
4697 12); single digits are preceded by a blank. (See also %I.)\n\
4698 %m: The month as a decimal number (range 01 to 12).\n\
4699 %M: The minute as a decimal number (range 00 to 59).\n\
4700 %n: A newline character.\n\
4701 %p: Either \"AM\" or \"PM\" according to the given time value.\n\
4702 Noon is treated as \"PM\" and midnight as \"AM\".\n\
4703 %r: Equivalent to %I:%M:%S %p.\n\
4704 %R: The time in 24-hour notation (%H:%M). For a version\n\
4705 including the seconds, see %T below.\n\
4706 %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
4708 %S: The second as a decimal number (range 00 to 60). (The\n\
4709 range is up to 60 to allow for occasional leap seconds.)\n\
4710 %t: A tab character.\n\
4711 %T: The time in 24-hour notation (%H:%M:%S).\n\
4712 %u: The day of the week as a decimal, range 1 to 7, Monday\n\
4713 being 1. See also %w.\n\
4714 %U: The week number of the current year as a decimal number,\n\
4715 range 00 to 53, starting with the first Sunday as the first\n\
4716 day of week 01. See also %V and %W.\n\
4717 %v: Equivalent to %e-%b-%Y.\n\
4718 %V: The ISO 8601 week number of the current year as a decimal\n\
4719 number, range 01 to 53, where week 1 is the first week that\n\
4720 has at least 4 days in the new year. See also %U and %W.\n\
4721 %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
4722 being 0. See also %u.\n\
4723 %W: The week number of the current year as a decimal number,\n\
4724 range 00 to 53, starting with the first Monday as the first\n\
4726 %x: Equivalent to %a %b %d %Y.\n\
4727 %X: Equivalent to %T.\n\
4728 %y: The year as a decimal number without a century (range 00\n\
4730 %Y: The year as a decimal number including a century.\n\
4731 %z: The UTC time-zone string = \"+0000\".\n\
4732 %Z: The UTC time-zone abbreviation = \"UTC\".\n\
4733 %+: The UTC date and time in default format of the Unix date\n\
4734 command which is equivalent to %a %b %d %T %Z %Y.\n\
4735 %%: A literal \"%\" character.\n\
4736 The conversion specifications which are extensions to those normally\n\
4737 provided by system strftime routines are the following: %(0-9):\n\
4738 The fractional part of the seconds field (including leading\n\
4739 decimal point) to the specified accuracy. Thus %S%3 would give\n\
4740 seconds to millisecond accuracy (00.000).\n\
4741 %.: The fractional part of the seconds field (including\n\
4742 leading decimal point) to the maximum available accuracy. Thus\n\
4743 %S%. would give seconds with fractional part up to 9 decimal\n\
4744 places if available.\n\
4747Get current subpage parameters\n\
4751 Gets the size of the current subpage in millimeters measured from the\n\
4752 bottom left hand corner of the output device page or screen. Can be\n\
4753 used in conjunction with plsvpa for setting the size of a viewport in\n\
4754 absolute coordinates (millimeters).\n\
4756 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
4758 This function is used in example 23.\n\
4764plgspa(xmin, xmax, ymin, ymax)\n\
4768 xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4769 the left hand edge of the subpage in millimeters.\n\
4771 xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4772 the right hand edge of the subpage in millimeters.\n\
4774 ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4775 the bottom edge of the subpage in millimeters.\n\
4777 ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
4778 the top edge of the subpage in millimeters.\n\
4781Calculate world coordinates and corresponding window index from relative device coordinates\n\
4785 Calculate world coordinates, wx and wy, and corresponding window index\n\
4786 from relative device coordinates, rx and ry.\n\
4788 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
4791 This function is used in example 31.\n\
4797plcalc_world(rx, ry, wx, wy, window)\n\
4801 rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4802 the x coordinate.\n\
4804 ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
4805 the y coordinate.\n\
4807 wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
4808 coordinate corresponding to the relative device coordinates rx and\n\
4811 wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
4812 coordinate corresponding to the relative device coordinates rx and\n\
4815 window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
4816 defined window index that corresponds to the input relative device\n\
4817 coordinates (and the returned world coordinates). To give some\n\
4818 background on the window index, for each page the initial window\n\
4819 index is set to zero, and each time plwind is called within the\n\
4820 page, world and device coordinates are stored for the window and\n\
4821 the window index is incremented. Thus, for a simple page layout\n\
4822 with non-overlapping viewports and one window per viewport, window\n\
4823 corresponds to the viewport index (in the order which the\n\
4824 viewport/windows were created) of the only viewport/window\n\
4825 corresponding to rx and ry. However, for more complicated layouts\n\
4826 with potentially overlapping viewports and possibly more than one\n\
4827 window (set of world coordinates) per viewport, window and the\n\
4828 corresponding output world coordinates corresponds to the last\n\
4829 window created that fulfills the criterion that the relative\n\
4830 device coordinates are inside it. Finally, in all cases where the\n\
4831 input relative device coordinates are not inside any\n\
4832 viewport/window, then the returned value of the last defined\n\
4833 window index is set to -1.\n\
4836Get output file name\n\
4840 Gets the current output file name, if applicable.\n\
4842 Redacted form: plgfnam(fnam)\n\
4844 This function is used in example 31.\n\
4854 fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
4855 (with preallocated length of 80 characters or more) containing the\n\
4863 Draws a plot of vector data contained in the matrices (\n\
4869 ny]) . The scaling factor for the vectors is given by scale. A\n\
4870 transformation routine pointed to by pltr with a pointer pltr_data for\n\
4871 additional data required by the transformation routine to map indices\n\
4872 within the matrices to the world coordinates. The style of the vector\n\
4873 arrow may be set using plsvect.\n\
4875 Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
4876 discussion) the pltr, pltr_data callback arguments are sometimes\n\
4877 replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
4878 with either one or two dimensions.\n\
4880 This function is used in example 22.\n\
4886plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
4890 u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
4891 and y components of the vector data to be plotted.\n\
4893 nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
4895 scale (PLFLT, input) : Parameter to control the scaling factor of\n\
4896 the vectors for plotting. If scale = 0 then the scaling factor is\n\
4897 automatically calculated for the data. If scale < 0 then the\n\
4898 scaling factor is automatically calculated for the data and then\n\
4900 scale. If scale > 0 then the scaling factor is set to scale.\n\
4902 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
4903 defines the transformation between the zero-based indices of the\n\
4904 matrices u and v and world coordinates.For the C case,\n\
4905 transformation functions are provided in the PLplot library: pltr0\n\
4906 for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
4907 mappings respectively defined by vectors and matrices. In\n\
4908 addition, C callback routines for the transformation can be\n\
4909 supplied by the user such as the mypltr function in\n\
4910 examples/c/x09c.c which provides a general linear transformation\n\
4911 between index coordinates and world coordinates.For languages\n\
4912 other than C you should consult the PLplot documentation for the\n\
4913 details concerning how PLTRANSFORM_callback arguments are\n\
4914 interfaced. However, in general, a particular pattern of\n\
4915 callback-associated arguments such as a tr vector with 6 elements;\n\
4916 xg and yg vectors; or xg and yg matrices are respectively\n\
4917 interfaced to a linear-transformation routine similar to the above\n\
4918 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
4919 sophisticated bindings (see, e.g., the PLplot documentation)\n\
4920 support native language callbacks for handling index to\n\
4921 world-coordinate transformations. Examples of these various\n\
4922 approaches are given in examples/<language>x09*,\n\
4923 examples/<language>x16*, examples/<language>x20*,\n\
4924 examples/<language>x21*, and examples/<language>x22*, for all our\n\
4925 supported languages.\n\
4927 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
4928 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
4929 that is externally supplied.\n\
4932Plot a glyph at the specified points\n\
4936 Plot a glyph at the specified points. (This function is largely\n\
4937 superseded by plstring which gives access to many[!] more glyphs.)\n\
4939 Redacted form: plsym(x, y, code)\n\
4941 This function is used in example 7.\n\
4947plsym(n, x, y, code)\n\
4951 n (PLINT, input) : Number of points in the x and y vectors.\n\
4953 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4956 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4959 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
4960 to be plotted at each of the n points.\n\
4963Get viewport limits in normalized device coordinates\n\
4967 Get viewport limits in normalized device coordinates.\n\
4969 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4972 This function is used in example 31.\n\
4978plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
4982 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4983 viewport limit of the normalized device coordinate in x.\n\
4985 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4986 viewport limit of the normalized device coordinate in x.\n\
4988 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
4989 viewport limit of the normalized device coordinate in y.\n\
4991 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
4992 viewport limit of the normalized device coordinate in y.\n\
4995Get page parameters\n\
4999 Gets the current page configuration. The length and offset values are\n\
5000 expressed in units that are specific to the current driver. For\n\
5001 instance: screen drivers will usually interpret them as number of\n\
5002 pixels, whereas printer drivers will usually use mm.\n\
5004 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
5006 This function is used in examples 14 and 31.\n\
5012plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
5016 p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
5017 pixels/inch (DPI) in x.\n\
5019 p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
5020 pixels/inch (DPI) in y.\n\
5022 p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
5025 p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
5028 p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
5031 p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
5035Plot a glyph at the specified 3D points\n\
5039 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
5040 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
5041 this function similar to what is done for plline3. The glyph is\n\
5042 specified with a PLplot user string. Note that the user string is not\n\
5043 actually limited to one glyph so it is possible (but not normally\n\
5044 useful) to plot more than one glyph at the specified points with this\n\
5045 function. As with plmtex and plptex, the user string can contain FCI\n\
5046 escapes to determine the font, UTF-8 code to determine the glyph or\n\
5047 else PLplot escapes for Hershey or unicode text to determine the\n\
5050 Redacted form: plstring3(x, y, z, string)\n\
5052 This function is used in example 18.\n\
5058plstring3(n, x, y, z, string)\n\
5062 n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
5064 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5067 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5070 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
5073 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
5074 the glyph(s) to be plotted at each of the n points. points.\n\
5077Shade regions on the basis of value\n\
5081 Shade regions on the basis of value. This is the high-level routine\n\
5082 for making continuous color shaded plots with cmap1 while plshade\n\
5083 should be used to plot individual shaded regions using either cmap0 or\n\
5084 cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
5085 our supported languages.\n\
5087 Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
5088 clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
5092 This function is used in examples 16, 21, and 22.\n\
5098plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
5102 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5103 plot. Should have dimensions of\n\
5107 nx (PLINT, input) : First dimension of matrix \"a\".\n\
5109 ny (PLINT, input) : Second dimension of matrix \"a\".\n\
5111 defined (PLDEFINED_callback, input) : Callback function specifying\n\
5112 the region that should be plotted in the shade plot. This\n\
5113 function accepts x and y coordinates as input arguments and must\n\
5114 return 1 if the point is to be included in the shade plot and 0\n\
5115 otherwise. If you want to plot the entire shade plot (the usual\n\
5116 case), this argument should be set to NULL.\n\
5118 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
5119 pltr below for how these arguments are used (only for the special case\n\
5120 when the callback function\n\
5121 pltr is not supplied).\n\
5123 clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
5124 corresponding to the edges of each shaded region that will be\n\
5125 plotted by this function. To work properly the levels should be\n\
5128 nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
5129 of shade edge values in clevel).\n\
5131 fill_width (PLFLT, input) : Defines the line width used by the fill\n\
5134 cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
5135 contours defining edges of shaded regions. The pen color is only\n\
5136 temporary set for the contour drawing. Set this value to zero or\n\
5137 less if no shade edge contours are wanted.\n\
5139 cont_width (PLFLT, input) : Defines line width used for contours\n\
5140 defining edges of shaded regions. This value may not be honored\n\
5141 by all drivers. The pen width is only temporary set for the\n\
5142 contour drawing. Set this value to zero or less if no shade edge\n\
5143 contours are wanted.\n\
5145 fill (PLFILL_callback, input) : Callback routine used to fill the\n\
5146 region. Use plfill for this purpose.\n\
5148 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
5149 map to rectangles after coordinate transformation with pltrl.\n\
5150 Otherwise, set rectangular to false. If rectangular is set to\n\
5151 true, plshade tries to save time by filling large rectangles.\n\
5152 This optimization fails if the coordinate transformation distorts\n\
5153 the shape of rectangles. For example a plot in polar coordinates\n\
5154 has to have rectangular set to false.\n\
5156 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5157 defines the transformation between the zero-based indices of the\n\
5158 matrix a and world coordinates. If\n\
5159 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
5160 indices of a are mapped to the range\n\
5162 xmax and the y indices of a are mapped to the range\n\
5164 ymax.For the C case, transformation functions are provided in the\n\
5165 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
5166 pltr2 for arbitrary mappings respectively defined by vectors and\n\
5167 matrices. In addition, C callback routines for the transformation\n\
5168 can be supplied by the user such as the mypltr function in\n\
5169 examples/c/x09c.c which provides a general linear transformation\n\
5170 between index coordinates and world coordinates.For languages\n\
5171 other than C you should consult the PLplot documentation for the\n\
5172 details concerning how PLTRANSFORM_callback arguments are\n\
5173 interfaced. However, in general, a particular pattern of\n\
5174 callback-associated arguments such as a tr vector with 6 elements;\n\
5175 xg and yg vectors; or xg and yg matrices are respectively\n\
5176 interfaced to a linear-transformation routine similar to the above\n\
5177 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
5178 sophisticated bindings (see, e.g., the PLplot documentation)\n\
5179 support native language callbacks for handling index to\n\
5180 world-coordinate transformations. Examples of these various\n\
5181 approaches are given in examples/<language>x09*,\n\
5182 examples/<language>x16*, examples/<language>x20*,\n\
5183 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5184 supported languages.\n\
5186 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5187 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
5188 externally supplied.\n\
5191Set output file name\n\
5195 Sets the current output file name, if applicable. If the file name\n\
5196 has not been specified and is required by the driver, the user will be\n\
5197 prompted for it. If using the X-windows output driver, this sets the\n\
5198 display name. This routine, if used, must be called before\n\
5199 initializing PLplot.\n\
5201 Redacted form: plsfnam(fnam)\n\
5203 This function is used in examples 1 and 20.\n\
5213 fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
5221 Draws a contour plot of the data in f[\n\
5223 ny], using the nlevel contour levels specified by clevel. Only the\n\
5224 region of the matrix from kx to lx and from ky to ly is plotted out\n\
5225 where all these index ranges are interpreted as one-based for\n\
5226 historical reasons. A transformation routine pointed to by pltr with\n\
5227 a generic pointer pltr_data for additional data required by the\n\
5228 transformation routine is used to map indices within the matrix to the\n\
5229 world coordinates.\n\
5231 Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5232 where (see above discussion) the pltr, pltr_data callback arguments\n\
5233 are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5234 vectors; or xg and yg matrices.\n\
5236 This function is used in examples 9, 14, 16, and 22.\n\
5242plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5246 f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5248 nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5250 kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5251 kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5252 zero-based for historical backwards-compatibility reasons.\n\
5254 ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5255 ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5256 zero-based for historical backwards-compatibility reasons.\n\
5258 clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5259 which to draw contours.\n\
5261 nlevel (PLINT, input) : Number of contour levels to draw.\n\
5263 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5264 defines the transformation between the zero-based indices of the\n\
5265 matrix f and the world coordinates.For the C case, transformation\n\
5266 functions are provided in the PLplot library: pltr0 for the\n\
5267 identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5268 respectively defined by vectors and matrices. In addition, C\n\
5269 callback routines for the transformation can be supplied by the\n\
5270 user such as the mypltr function in examples/c/x09c.c which\n\
5271 provides a general linear transformation between index coordinates\n\
5272 and world coordinates.For languages other than C you should\n\
5273 consult the PLplot documentation for the details concerning how\n\
5274 PLTRANSFORM_callback arguments are interfaced. However, in\n\
5275 general, a particular pattern of callback-associated arguments\n\
5276 such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5277 yg matrices are respectively interfaced to a linear-transformation\n\
5278 routine similar to the above mypltr function; pltr1; and pltr2.\n\
5279 Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5280 the PLplot documentation) support native language callbacks for\n\
5281 handling index to world-coordinate transformations. Examples of\n\
5282 these various approaches are given in examples/<language>x09*,\n\
5283 examples/<language>x16*, examples/<language>x20*,\n\
5284 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5285 supported languages.\n\
5287 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5288 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5289 that is externally supplied.\n\
5292Set parameters that define current plot-space window\n\
5296 Set relative minima and maxima that define the current plot-space\n\
5297 window. If plsdiplt is not called the default values of xmin, ymin,\n\
5298 xmax, and ymax are 0., 0., 1., and 1.\n\
5300 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
5302 This function is used in example 31.\n\
5308plsdiplt(xmin, ymin, xmax, ymax)\n\
5312 xmin (PLFLT, input) : Relative minimum in x.\n\
5314 ymin (PLFLT, input) : Relative minimum in y.\n\
5316 xmax (PLFLT, input) : Relative maximum in x.\n\
5318 ymax (PLFLT, input) : Relative maximum in y.\n\
5321Write text inside the viewport of a 3D plot\n\
5325 Writes text at a specified position and inclination and with a\n\
5326 specified shear within the viewport. Text is clipped at the viewport\n\
5327 boundaries. The reference point of a string lies along a line passing\n\
5328 through the string at half the height of a capital letter. The\n\
5329 position of the reference point along this line is determined by just,\n\
5330 and the reference point is placed at world coordinates (\n\
5333 wz) within the viewport. The inclination and shear of the string is\n\
5334 specified in terms of differences of world coordinates making it easy\n\
5335 to write text parallel to a line in a graph.\n\
5337 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
5339 This function is used in example 28.\n\
5345plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
5349 wx (PLFLT, input) : x world coordinate of reference point of\n\
5352 wy (PLFLT, input) : y world coordinate of reference point of\n\
5355 wz (PLFLT, input) : z world coordinate of reference point of\n\
5358 dx (PLFLT, input) : Together with dy and\n\
5359 dz , this specifies the inclination of the string. The baseline of\n\
5360 the string is parallel to a line joining (\n\
5371 dy (PLFLT, input) : Together with dx and\n\
5372 dz, this specifies the inclination of the string.\n\
5374 dz (PLFLT, input) : Together with dx and\n\
5375 dy, this specifies the inclination of the string.\n\
5377 sx (PLFLT, input) : Together with sy and\n\
5378 sz , this specifies the shear of the string. The string is sheared so\n\
5379 that the characters are vertically parallel to a line joining (\n\
5390 sz = 0.) then the text is not sheared.\n\
5392 sy (PLFLT, input) : Together with sx and\n\
5393 sz, this specifies shear of the string.\n\
5395 sz (PLFLT, input) : Together with sx and\n\
5396 sy, this specifies shear of the string.\n\
5398 just (PLFLT, input) : Specifies the position of the string relative\n\
5399 to its reference point. If just=0. , the reference point is at\n\
5400 the left and if just=1. , it is at the right of the string. Other\n\
5401 values of just give intermediate justifications.\n\
5403 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5407Plot continental outline or shapefile data in world coordinates\n\
5411 Plots continental outlines or shapefile data in world coordinates. A\n\
5412 demonstration of how to use this function to create different\n\
5413 projections can be found in examples/c/x19c. PLplot is provided with\n\
5414 basic coastal outlines and USA state borders. To use the map\n\
5415 functionality PLplot must be compiled with the shapelib library.\n\
5416 Shapefiles have become a popular standard for geographical data and\n\
5417 data in this format can be easily found from a number of online\n\
5418 sources. Shapefile data is actually provided as three or more files\n\
5419 with the same filename, but different extensions. The .shp and .shx\n\
5420 files are required for plotting Shapefile data with PLplot.\n\
5422 PLplot currently supports the point, multipoint, polyline and polygon\n\
5423 objects within shapefiles. However holes in polygons are not\n\
5424 supported. When plmap is used the type of object is derived from the\n\
5425 shapefile, if you wish to override the type then use one of the other\n\
5426 plmap variants. The built in maps have line data only.\n\
5428 Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
5430 This function is used in example 19.\n\
5436plmap(mapform, name, minx, maxx, miny, maxy)\n\
5440 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5441 transform the original map data coordinates to a new coordinate\n\
5442 system. The PLplot-supplied map data is provided as latitudes and\n\
5443 longitudes; other Shapefile data may be provided in other\n\
5444 coordinate systems as can be found in their .prj plain text files.\n\
5445 For example, by using this transform we can change from a\n\
5446 longitude, latitude coordinate to a polar stereographic\n\
5447 projection. Initially, x[0]..[n-1] are the original x coordinates\n\
5448 (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
5449 corresponding y coordinates (latitudes for the PLplot supplied\n\
5450 data). After the call to mapform(), x[] and y[] should be\n\
5451 replaced by the corresponding plot coordinates. If no transform is\n\
5452 desired, mapform can be replaced by NULL.\n\
5454 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5455 the type of map plotted. This is either one of the PLplot built-in\n\
5456 maps or the file name of a set of Shapefile files without the file\n\
5457 extensions. For the PLplot built-in maps the possible values are:\n\
5458 \"globe\" -- continental outlines\n\
5459 \"usa\" -- USA and state boundaries\n\
5460 \"cglobe\" -- continental outlines and countries\n\
5461 \"usaglobe\" -- USA, state boundaries and continental outlines\n\
5464 minx (PLFLT, input) : The minimum x value of map elements to be\n\
5465 drawn. The units must match the shapefile (built in maps are\n\
5466 degrees lat/lon). Objects in the file which do not encroach on the\n\
5467 box defined by minx, maxx, miny, maxy will not be rendered. But\n\
5468 note this is simply an optimisation, not a clipping so for objects\n\
5469 with some points inside the box and some points outside the box\n\
5470 all the points will be rendered. These parameters also define\n\
5471 latitude and longitude wrapping for shapefiles using these units.\n\
5472 Longitude points will be wrapped by integer multiples of 360\n\
5473 degrees to place them in the box. This allows the same data to be\n\
5474 used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
5475 you plot from -180-540 you will get two cycles of data drawn. The\n\
5476 value of minx must be less than the value of maxx. Passing in a\n\
5477 nan, max/-max floating point number or +/-infinity will case the\n\
5478 bounding box from the shapefile to be used.\n\
5480 maxx (PLFLT, input) : The maximum x value of map elements to be\n\
5481 drawn - see minx.\n\
5483 miny (PLFLT, input) : The minimum y value of map elements to be\n\
5484 drawn - see minx.\n\
5486 maxy (PLFLT, input) : The maximum y value of map elements to be\n\
5487 drawn - see minx.\n\
5490Specify viewport using coordinates and aspect ratio\n\
5494 Device-independent routine for setting up the viewport. The viewport\n\
5495 is chosen to be the largest with the given aspect ratio that fits\n\
5496 within the specified region (in terms of normalized subpage\n\
5497 coordinates). This routine is functionally equivalent to plvpor when\n\
5498 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
5499 routine reserves no extra space at the edges for labels.\n\
5501 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5503 This function is used in example 9.\n\
5509plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5513 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5514 left-hand edge of the viewport.\n\
5516 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5517 right-hand edge of the viewport.\n\
5519 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5520 bottom edge of the viewport.\n\
5522 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5523 edge of the viewport.\n\
5525 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
5529Set the pause (on end-of-page) status\n\
5533 Set the pause (on end-of-page) status.\n\
5535 Redacted form: plspause(pause)\n\
5537 This function is in examples 14,20.\n\
5547 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
5548 end-of-page for those drivers which support this. Otherwise there\n\
5552Plot 3-d surface plot\n\
5556 Plots a three-dimensional surface plot within the environment set up\n\
5557 by plw3d. The surface is defined by the matrix z[\n\
5559 ny] , the point z[i][j] being the value of the function at (\n\
5561 y[j]). Note that the points in vectors x and y do not need to be\n\
5562 equally spaced, but must be stored in ascending order. The parameter\n\
5563 opt controls the way in which the surface is displayed. For further\n\
5564 details see the PLplot documentation. The only difference between\n\
5565 plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5566 while plot3d only draws the surface as viewed from the top.\n\
5568 Redacted form: plot3d(x, y, z, opt, side)\n\
5570 This function is used in examples 11 and 21.\n\
5576plot3d(x, y, z, nx, ny, opt, side)\n\
5580 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5581 which the function is evaluated.\n\
5583 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5584 which the function is evaluated.\n\
5586 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5587 plot. Should have dimensions of\n\
5591 nx (PLINT, input) : Number of x values at which function is\n\
5594 ny (PLINT, input) : Number of y values at which function is\n\
5597 opt (PLINT, input) : Determines the way in which the surface is\n\
5598 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5599 function of x for each value of y[j] .\n\
5600 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5601 for each value of x[i] .\n\
5602 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5603 at which function is defined.\n\
5606 side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5607 should be draw on the figure. If side is true sides are drawn,\n\
5608 otherwise no sides are drawn.\n\
5611Copy state parameters from the reference stream to the current stream\n\
5615 Copies state parameters from the reference stream to the current\n\
5616 stream. Tell driver interface to map device coordinates unless flags\n\
5619 This function is used for making save files of selected plots (e.g.\n\
5620 from the TK driver). After initializing, you can get a copy of the\n\
5621 current plot to the specified device by switching to this stream and\n\
5622 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
5623 appropriate. The plot buffer must have previously been enabled (done\n\
5624 automatically by some display drivers, such as X).\n\
5626 Redacted form: plcpstrm(iplsr, flags)\n\
5628 This function is used in example 1,20.\n\
5634plcpstrm(iplsr, flags)\n\
5638 iplsr (PLINT, input) : Number of reference stream.\n\
5640 flags (PLBOOL, input) : If flags is set to true the device\n\
5641 coordinates are not copied from the reference to current stream.\n\
5644Set page parameters\n\
5648 Sets the page configuration (optional). If an individual parameter is\n\
5649 zero then that parameter value is not updated. Not all parameters are\n\
5650 recognized by all drivers and the interpretation is device-dependent.\n\
5651 The X-window driver uses the length and offset parameters to determine\n\
5652 the window size and location. The length and offset values are\n\
5653 expressed in units that are specific to the current driver. For\n\
5654 instance: screen drivers will usually interpret them as number of\n\
5655 pixels, whereas printer drivers will usually use mm.\n\
5657 This routine, if used, must be called before initializing PLplot. It\n\
5658 may be called at later times for interactive drivers to change only\n\
5659 the dpi for subsequent redraws which you can force via a call to\n\
5660 plreplot. If this function is not called then the page size defaults\n\
5661 to landscape A4 for drivers which use real world page sizes and 744\n\
5662 pixels wide by 538 pixels high for raster drivers. The default value\n\
5663 for dx and dy is 90 pixels per inch for raster drivers.\n\
5667 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5669 This function is used in examples 14 and 31.\n\
5675plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5679 xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
5680 by raster drivers, ignored by drivers which use \"real world\" units\n\
5683 yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
5684 by raster drivers, ignored by drivers which use \"real world\" units\n\
5687 xleng (PLINT, input) : Page length, x.\n\
5689 yleng (PLINT, input) : Page length, y.\n\
5691 xoff (PLINT, input) : Page offset, x.\n\
5693 yoff (PLINT, input) : Page offset, y.\n\
5696Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
5700 Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
5701 (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
5702 Values are negative if an invalid color id is given.\n\
5704 Redacted form: plgcola(r, g, b)\n\
5706 This function is used in example 30.\n\
5712plgcol0a(icol0, r, g, b, alpha)\n\
5716 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5718 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
5719 in the range from 0 to 255.\n\
5721 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
5722 in the range from 0 to 255.\n\
5724 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
5725 in the range from 0 to 255.\n\
5727 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
5728 transparency in the range from (0.0-1.0).\n\
5731Returns 8-bit RGB values for given color index from cmap0\n\
5735 Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
5736 PLplot documentation). Values are negative if an invalid color id is\n\
5739 Redacted form: plgcol0(icol0, r, g, b)\n\
5741 This function is used in example 2.\n\
5747plgcol0(icol0, r, g, b)\n\
5751 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
5753 r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
5756 g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
5759 b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
5763Set parameters incrementally (zoom mode) that define current plot-space window\n\
5767 Set relative minima and maxima incrementally (zoom mode) that define\n\
5768 the current plot-space window. This function has the same effect as\n\
5769 plsdiplt if that function has not been previously called. Otherwise,\n\
5770 this function implements zoom mode using the transformation min_used =\n\
5771 old_min + old_length*min and max_used = old_min + old_length*max for\n\
5772 each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
5773 repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
5775 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
5777 This function is used in example 31.\n\
5783plsdiplz(xmin, ymin, xmax, ymax)\n\
5787 xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
5789 ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
5791 xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
5793 ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
5796Plot all or a subset of Shapefile data, filling the polygons\n\
5800 As per plmapline, however the items are filled in the same way as\n\
5803 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
5806 This function is used in example 19.\n\
5812plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
5816 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
5817 transform the coordinates given in the shapefile into a plot\n\
5818 coordinate system. By using this transform, we can change from a\n\
5819 longitude, latitude coordinate to a polar stereographic project,\n\
5820 for example. Initially, x[0]..[n-1] are the longitudes and\n\
5821 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
5822 mapform(), x[] and y[] should be replaced by the corresponding\n\
5823 plot coordinates. If no transform is desired, mapform can be\n\
5824 replaced by NULL.\n\
5826 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5827 the file name of a set of Shapefile files without the file\n\
5830 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
5831 be in the same units as used by the Shapefile. You could use a\n\
5832 very large negative number to plot everything, but you can improve\n\
5833 performance by limiting the area drawn. The units must match those\n\
5834 of the Shapefile projection, which may be for example longitude or\n\
5835 distance. The value of minx must be less than the value of maxx.\n\
5837 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
5838 use a very large number to plot everything, but you can improve\n\
5839 performance by limiting the area drawn.\n\
5841 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
5842 be in the same units as used by the Shapefile. You could use a\n\
5843 very large negative number to plot everything, but you can improve\n\
5844 performance by limiting the area drawn. The units must match those\n\
5845 of the Shapefile projection, which may be for example latitude or\n\
5846 distance. The value of miny must be less than the value of maxy.\n\
5848 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
5849 use a very large number to plot everything, but you can improve\n\
5850 performance by limiting the area drawn.\n\
5852 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
5853 zero-based indices of the Shapefile elements which will be drawn.\n\
5855 plotentries to NULL will plot all elements of the Shapefile.\n\
5857 nplotentries (PLINT, input) : The number of items in\n\
5858 plotentries. Ignored if\n\
5859 plotentries is NULL.\n\
5866 Draws line defined by n points in x and y.\n\
5868 Redacted form: plline(x, y)\n\
5870 This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
5881 n (PLINT, input) : Number of points defining line.\n\
5883 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5886 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5890Get viewport limits in world coordinates\n\
5894 Get viewport limits in world coordinates.\n\
5896 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5899 This function is used in example 31.\n\
5905plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5909 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5910 viewport limit of the world coordinate in x.\n\
5912 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5913 viewport limit of the world coordinate in x.\n\
5915 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
5916 viewport limit of the world coordinate in y.\n\
5918 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
5919 viewport limit of the world coordinate in y.\n\
5922Set area line fill pattern\n\
5926 Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
5927 The pattern consists of 1 or 2 sets of parallel lines with specified\n\
5928 inclinations and spacings. The arguments to this routine are the\n\
5929 number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
5930 elements) specifying the inclinations in tenths of a degree and the\n\
5931 spacing in micrometers. (See also plpsty)\n\
5933 Redacted form: General: plpat(inc, del)\n\
5936 This function is used in example 15.\n\
5942plpat(nlin, inc, del)\n\
5946 nlin (PLINT, input) : Number of sets of lines making up the\n\
5947 pattern, either 1 or 2.\n\
5949 inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5950 inclination in tenths of a degree. (Should be between -900 and\n\
5953 del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5954 spacing in micrometers between the lines making up the pattern.\n\
5957Set x axis parameters\n\
5961 Sets values of the digmax and digits flags for the x axis. See the\n\
5962 PLplot documentation for more information.\n\
5964 Redacted form: plsxax(digmax, digits)\n\
5966 This function is used in example 31.\n\
5972plsxax(digmax, digits)\n\
5976 digmax (PLINT, input) : Variable to set the maximum number of\n\
5977 digits for the x axis. If nonzero, the printed label will be\n\
5978 switched to a floating-point representation when the number of\n\
5979 digits exceeds digmax.\n\
5981 digits (PLINT, input) : Field digits value. Currently, changing\n\
5982 its value here has no effect since it is set only by plbox or\n\
5983 plbox3. However, the user may obtain its value after a call to\n\
5984 either of these functions by calling plgxax.\n\
5987Get family file parameters\n\
5991 Gets information about current family file, if familying is enabled.\n\
5992 See the PLplot documentation for more information.\n\
5994 Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5996 This function is used in examples 14 and 31.\n\
6002plgfam(p_fam, p_num, p_bmax)\n\
6006 p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6007 family flag value. If nonzero, familying is enabled for the\n\
6010 p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6011 family file number.\n\
6013 p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6014 file size (in bytes) for a family file.\n\
6017Get y axis parameters\n\
6021 Identical to plgxax, except that arguments are flags for y axis. See\n\
6022 the description of plgxax for more detail.\n\
6024 Redacted form: plgyax(p_digmax, p_digits)\n\
6026 This function is used in example 31.\n\
6032plgyax(p_digmax, p_digits)\n\
6036 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6037 number of digits for the y axis. If nonzero, the printed label\n\
6038 has been switched to a floating-point representation when the\n\
6039 number of digits exceeds this value.\n\
6041 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
6042 number of digits for the numeric labels (y axis) from the last\n\
6046Plot a glyph at the specified points\n\
6050 Plot a glyph at the specified points. (This function is largely\n\
6051 superseded by plstring which gives access to many[!] more glyphs.)\n\
6052 code=-1 means try to just draw a point. Right now it\'s just a move\n\
6053 and a draw at the same place. Not ideal, since a sufficiently\n\
6054 intelligent output device may optimize it away, or there may be faster\n\
6055 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
6056 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
6057 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
6058 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
6059 code <= 127 the corresponding printable ASCII character is plotted.\n\
6061 Redacted form: plpoin(x, y, code)\n\
6063 This function is used in examples 1, 6, 14, and 29.\n\
6069plpoin(n, x, y, code)\n\
6073 n (PLINT, input) : Number of points in the x and y vectors.\n\
6075 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6078 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6081 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
6082 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
6083 each of the n points.\n\
6086Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
6090 As per plmapline, however the items are plotted as strings or points\n\
6091 in the same way as plstring.\n\
6093 Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
6094 maxy, plotentries)\n\
6096 This function is not used in any examples.\n\
6102plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6106 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6107 transform the coordinates given in the shapefile into a plot\n\
6108 coordinate system. By using this transform, we can change from a\n\
6109 longitude, latitude coordinate to a polar stereographic project,\n\
6110 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6111 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6112 mapform(), x[] and y[] should be replaced by the corresponding\n\
6113 plot coordinates. If no transform is desired, mapform can be\n\
6114 replaced by NULL.\n\
6116 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6117 the file name of a set of Shapefile files without the file\n\
6120 string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
6123 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6124 be in the same units as used by the Shapefile. You could use a\n\
6125 very large negative number to plot everything, but you can improve\n\
6126 performance by limiting the area drawn. The units must match those\n\
6127 of the Shapefile projection, which may be for example longitude or\n\
6128 distance. The value of minx must be less than the value of maxx.\n\
6130 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6131 use a very large number to plot everything, but you can improve\n\
6132 performance by limiting the area drawn.\n\
6134 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6135 be in the same units as used by the Shapefile. You could use a\n\
6136 very large negative number to plot everything, but you can improve\n\
6137 performance by limiting the area drawn. The units must match those\n\
6138 of the Shapefile projection, which may be for example latitude or\n\
6139 distance. The value of miny must be less than the value of maxy.\n\
6141 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6142 use a very large number to plot everything, but you can improve\n\
6143 performance by limiting the area drawn.\n\
6145 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6146 zero-based indices of the Shapefile elements which will be drawn.\n\
6148 plotentries to NULL will plot all elements of the Shapefile.\n\
6150 nplotentries (PLINT, input) : The number of items in\n\
6151 plotentries. Ignored if\n\
6152 plotentries is NULL.\n\
6155Select area fill pattern\n\
6160 patt is zero or less use either a hardware solid fill if the drivers\n\
6161 have that capability (virtually all do) or fall back to a software\n\
6162 emulation of a solid fill using the eighth area line fill pattern. If\n\
6164 patt <= 8, then select one of eight predefined area line fill patterns\n\
6165 to use (see plpat if you desire other patterns).\n\
6167 Redacted form: plpsty(patt)\n\
6169 This function is used in examples 12, 13, 15, 16, and 25.\n\
6179 patt (PLINT, input) : The desired pattern index. If\n\
6180 patt is zero or less, then a solid fill is (normally, see qualifiers\n\
6182 patt in the range from 1 to 8 and assuming the driver has not supplied\n\
6183 line fill capability itself (most deliberately do not so that line\n\
6184 fill patterns look identical for those drivers), the patterns\n\
6185 consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
6186 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
6187 lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
6188 (8) lines at both 45 degrees and -45 degrees.\n\
6191Set 8-bit RGB values for given cmap0 color index\n\
6195 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
6196 index. Overwrites the previous color value for the given index and,\n\
6197 thus, does not result in any additional allocation of space for\n\
6200 Redacted form: plscol0(icol0, r, g, b)\n\
6202 This function is used in any example 31.\n\
6208plscol0(icol0, r, g, b)\n\
6212 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
6213 number of colors (which is set by default, by plscmap0n, or even\n\
6216 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6217 degree of red in the color.\n\
6219 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6220 degree of green in the color.\n\
6222 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6223 degree of blue in the color.\n\
6226Used to globally turn color output on/off\n\
6230 Used to globally turn color output on/off for those drivers/devices\n\
6233 Redacted form: plscolor(color)\n\
6235 This function is used in example 31.\n\
6245 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6246 turned off. If non-zero, color is turned on.\n\
6249End plotting session\n\
6253 Ends a plotting session, tidies up all the output files, switches\n\
6254 interactive devices back into text mode and frees up any memory that\n\
6255 was allocated. Must be called before end of program.\n\
6257 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
6258 wait state after a call to plend or other functions which trigger the\n\
6259 end of a plot page. To avoid this, use the plspause function.\n\
6261 Redacted form: plend()\n\
6263 This function is used in all of the examples.\n\
6272Plot a histogram from binned data\n\
6276 Plots a histogram consisting of nbin bins. The value associated with\n\
6277 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
6278 placed in y[i]. For proper operation, the values in x[i] must form a\n\
6279 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
6280 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
6281 placed midway between the values in the x vector. Also see plhist for\n\
6282 drawing histograms from unbinned data.\n\
6284 Redacted form: General: plbin(x, y, opt)\n\
6285 Python: plbin(nbin, x, y, opt)\n\
6288 This function is not used in any examples.\n\
6294plbin(nbin, x, y, opt)\n\
6298 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
6301 x (PLFLT_VECTOR, input) : A vector containing values associated\n\
6302 with bins. These must form a strictly increasing sequence.\n\
6304 y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
6305 proportional to the number of points in each bin. This is a PLFLT\n\
6306 (instead of PLINT) vector so as to allow histograms of\n\
6307 probabilities, etc.\n\
6309 opt (PLINT, input) : Is a combination of several flags:\n\
6310 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
6311 outer bins are expanded to fill up the entire x-axis and bins of\n\
6312 zero height are simply drawn.\n\
6313 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
6314 between the x values. If the values in x are equally spaced,\n\
6315 the values are the center values of the bins.\n\
6316 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
6317 size as the ones inside.\n\
6318 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
6319 (there is a gap for such bins).\n\
6322Plot a 2D matrix using cmap1\n\
6326 Plot a 2D matrix using cmap1.\n\
6328 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
6329 zmax, valuemin, valuemax, pltr, pltr_data)\n\
6332 This function is used in example 20.\n\
6338plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
6342 idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
6343 plot. Should have dimensions of\n\
6347 nx, ny (PLINT, input) : Dimensions of idata\n\
6349 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
6350 pltr below for how these arguments are used (only for the special case\n\
6351 when the callback function\n\
6352 pltr is not supplied).\n\
6354 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
6355 (inclusive) will be plotted.\n\
6357 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
6358 values to use for value to color mappings. A datum equal to or\n\
6359 less than valuemin will be plotted with color 0.0, while a datum\n\
6360 equal to or greater than valuemax will be plotted with color 1.0.\n\
6361 Data between valuemin and valuemax map linearly to colors in the\n\
6364 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
6365 defines the transformation between the zero-based indices of the\n\
6366 matrix idata and world coordinates. If\n\
6367 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
6368 indices of idata are mapped to the range\n\
6370 xmax and the y indices of idata are mapped to the range\n\
6372 ymax.For the C case, transformation functions are provided in the\n\
6373 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
6374 pltr2 for arbitrary mappings respectively defined by vectors and\n\
6375 matrices. In addition, C callback routines for the transformation\n\
6376 can be supplied by the user such as the mypltr function in\n\
6377 examples/c/x09c.c which provides a general linear transformation\n\
6378 between index coordinates and world coordinates.For languages\n\
6379 other than C you should consult the PLplot documentation for the\n\
6380 details concerning how PLTRANSFORM_callback arguments are\n\
6381 interfaced. However, in general, a particular pattern of\n\
6382 callback-associated arguments such as a tr vector with 6 elements;\n\
6383 xg and yg vectors; or xg and yg matrices are respectively\n\
6384 interfaced to a linear-transformation routine similar to the above\n\
6385 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
6386 sophisticated bindings (see, e.g., the PLplot documentation)\n\
6387 support native language callbacks for handling index to\n\
6388 world-coordinate transformations. Examples of these various\n\
6389 approaches are given in examples/<language>x09*,\n\
6390 examples/<language>x16*, examples/<language>x20*,\n\
6391 examples/<language>x21*, and examples/<language>x22*, for all our\n\
6392 supported languages.\n\
6394 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
6395 information to pltr0, pltr1, pltr2, or whatever routine is\n\
6396 externally supplied.\n\
6399Sets the 3D position of the light source\n\
6403 Sets the 3D position of the light source for use with plsurf3d and\n\
6406 Redacted form: pllightsource(x, y, z)\n\
6408 This function is used in example 8.\n\
6414pllightsource(x, y, z)\n\
6418 x (PLFLT, input) : X-coordinate of the light source.\n\
6420 y (PLFLT, input) : Y-coordinate of the light source.\n\
6422 z (PLFLT, input) : Z-coordinate of the light source.\n\
6425Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
6429 When the implementation is completed this variant of plot3dc (see that\n\
6430 function\'s documentation for more details) should be suitable for the\n\
6431 case where the area of the x, y coordinate grid where z is defined can\n\
6432 be non-rectangular. The implementation is incomplete so the last 4\n\
6433 parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
6434 indexymax; are currently ignored and the functionality is otherwise\n\
6435 identical to that of plot3dc.\n\
6437 Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
6438 indexymin, indexymax)\n\
6441 This function is not used in any example.\n\
6447plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
6451 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
6452 which the function is evaluated.\n\
6454 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
6455 which the function is evaluated.\n\
6457 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
6458 plot. Should have dimensions of\n\
6462 nx (PLINT, input) : Number of x values at which the function is\n\
6465 ny (PLINT, input) : Number of y values at which the function is\n\
6468 opt (PLINT, input) : Determines the way in which the surface is\n\
6469 represented. To specify more than one option just add the options,\n\
6470 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
6471 showing z as a function of x for each value of y[j] .\n\
6472 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
6473 for each value of x[i] .\n\
6474 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
6475 at which function is defined.\n\
6476 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
6477 the z value being plotted. The color is used from the current\n\
6479 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
6483 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
6484 the borders of the plotted function.\n\
6487 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
6490 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
6492 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
6493 corresponds to the first x index where z is defined.\n\
6495 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
6496 which corresponds (by convention) to one more than the last x\n\
6497 index value where z is defined.\n\
6499 indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
6500 values which all must be ≥ 0. These values are the first y index\n\
6501 where z is defined for a particular x index in the range from\n\
6502 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
6505 indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
6506 values which all must be ≤ ny. These values correspond (by\n\
6507 convention) to one more than the last y index where z is defined\n\
6508 for a particular x index in the range from indexxmin to indexxmax\n\
6509 - 1. The dimension of indexymax is indexxmax.\n\
6512Creates a new stream and makes it the default\n\
6516 Creates a new stream and makes it the default. Differs from using\n\
6517 plsstrm, in that a free stream number is found, and returned.\n\
6518 Unfortunately, I have to start at stream 1 and work upward, since\n\
6519 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
6520 that no initial, library-opening call is required. So stream 0 must\n\
6521 be preallocated, and there is no simple way of determining whether it\n\
6522 is already in use or not.\n\
6524 Redacted form: plmkstrm(p_strm)\n\
6526 This function is used in examples 1 and 20.\n\
6536 p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
6537 number of the created stream.\n\
6540Set FCI (font characterization integer)\n\
6544 Sets font characteristics to be used at the start of the next string\n\
6545 using the FCI approach. See the PLplot documentation for more\n\
6546 information. Note, plsfont (which calls plsfci internally) provides a\n\
6547 more user-friendly API for setting the font characterisitics.\n\
6549 Redacted form: General: plsfci(fci)\n\
6552 This function is used in example 23.\n\
6562 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
6570 Initializing the plotting package. The program prompts for the device\n\
6571 keyword or number of the desired output device. Hitting a RETURN in\n\
6572 response to the prompt is the same as selecting the first device.\n\
6573 plinit will issue no prompt if either the device was specified\n\
6574 previously (via command line flag, the plsetopt function, or the\n\
6575 plsdev function), or if only one device is enabled when PLplot is\n\
6576 installed. If subpages have been specified, the output device is\n\
6577 divided into nx by ny subpages, each of which may be used\n\
6578 independently. If plinit is called again during a program, the\n\
6579 previously opened file will be closed. The subroutine pladv is used\n\
6580 to advance from one subpage to the next.\n\
6582 Redacted form: plinit()\n\
6584 This function is used in all of the examples.\n\
6597 This sets up the line style for all lines subsequently drawn. A line\n\
6598 consists of segments in which the pen is alternately down and up. The\n\
6599 lengths of these segments are passed in the vectors mark and space\n\
6600 respectively. The number of mark-space pairs is specified by nms. In\n\
6601 order to return the line style to the default continuous line, plstyl\n\
6602 should be called with nms =0 .(see also pllsty)\n\
6604 Redacted form: plstyl(mark, space)\n\
6606 This function is used in examples 1, 9, and 14.\n\
6612plstyl(nms, mark, space)\n\
6616 nms (PLINT, input) : The number of mark and space elements in a\n\
6617 line. Thus a simple broken line can be obtained by setting nms=1\n\
6618 . A continuous line is specified by setting nms=0 .\n\
6620 mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
6621 segments during which the pen is down, measured in micrometers.\n\
6623 space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
6624 the segments during which the pen is up, measured in micrometers.\n\
6627Set length of minor ticks\n\
6631 This sets up the length of the minor ticks and the length of the\n\
6632 terminals on error bars. The actual length is the product of the\n\
6633 default length and a scaling factor as for character height.\n\
6635 Redacted form: plsmin(def, scale)\n\
6637 This function is used in example 29.\n\
6643plsmin(def, scale)\n\
6647 def (PLFLT, input) : The default length of a minor tick in\n\
6648 millimeters, should be set to zero if the default length is to\n\
6649 remain unchanged.\n\
6651 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6652 actual tick length.\n\
6655Draw a box with axes, etc, in 3-d\n\
6659 Draws axes, numeric and text labels for a three-dimensional surface\n\
6660 plot. For a more complete description of three-dimensional plotting\n\
6661 see the PLplot documentation.\n\
6663 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
6664 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6667 This function is used in examples 8, 11, 18, and 21.\n\
6673plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6677 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6678 options for the x axis. The string can include any combination of\n\
6679 the following letters (upper or lower case) in any order: b: Draws\n\
6680 axis at base, at height z=\n\
6681 zmin where zmin is defined by call to plw3d. This character must be\n\
6682 specified in order to use any of the other options.\n\
6683 d: Plot labels as date / time. Values are assumed to be\n\
6684 seconds since the epoch (as used by gmtime).\n\
6685 f: Always use fixed point numeric labels.\n\
6686 i: Inverts tick marks, so they are drawn downwards, rather\n\
6688 l: Labels axis logarithmically. This only affects the labels,\n\
6689 not the data, and so it is necessary to compute the logarithms\n\
6690 of data points before passing them to any of the drawing\n\
6692 n: Writes numeric labels at major tick intervals.\n\
6693 o: Use custom labelling function to generate axis label text.\n\
6694 The custom labelling function can be defined with the\n\
6695 plslabelfunc command.\n\
6696 s: Enables subticks between major ticks, only valid if t is\n\
6698 t: Draws major ticks.\n\
6699 u: If this is specified, the text label for the axis is\n\
6700 written under the axis.\n\
6703 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6704 the text label for the x axis. It is only drawn if u is in the\n\
6707 xtick (PLFLT, input) : World coordinate interval between major\n\
6708 ticks on the x axis. If it is set to zero, PLplot automatically\n\
6709 generates a suitable tick interval.\n\
6711 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
6712 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6713 generates a suitable minor tick interval.\n\
6715 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6716 options for the y axis. The string is interpreted in the same way\n\
6719 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6720 the text label for the y axis. It is only drawn if u is in the\n\
6723 ytick (PLFLT, input) : World coordinate interval between major\n\
6724 ticks on the y axis. If it is set to zero, PLplot automatically\n\
6725 generates a suitable tick interval.\n\
6727 nysub (PLINT, input) : Number of subintervals between major y axis\n\
6728 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6729 generates a suitable minor tick interval.\n\
6731 zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6732 options for the z axis. The string can include any combination of\n\
6733 the following letters (upper or lower case) in any order: b: Draws\n\
6734 z axis to the left of the surface plot.\n\
6735 c: Draws z axis to the right of the surface plot.\n\
6736 d: Draws grid lines parallel to the x-y plane behind the\n\
6737 figure. These lines are not drawn until after plot3d or\n\
6738 plmesh are called because of the need for hidden line removal.\n\
6739 e: Plot labels as date / time. Values are assumed to be\n\
6740 seconds since the epoch (as used by gmtime). Note this\n\
6741 suboption is interpreted the same as the d suboption for xopt\n\
6742 and yopt, but it has to be identified as e for zopt since d\n\
6743 has already been used for the different purpose above.\n\
6744 f: Always use fixed point numeric labels.\n\
6745 i: Inverts tick marks, so they are drawn away from the center.\n\
6746 l: Labels axis logarithmically. This only affects the labels,\n\
6747 not the data, and so it is necessary to compute the logarithms\n\
6748 of data points before passing them to any of the drawing\n\
6750 m: Writes numeric labels at major tick intervals on the\n\
6751 right-hand z axis.\n\
6752 n: Writes numeric labels at major tick intervals on the\n\
6753 left-hand z axis.\n\
6754 o: Use custom labelling function to generate axis label text.\n\
6755 The custom labelling function can be defined with the\n\
6756 plslabelfunc command.\n\
6757 s: Enables subticks between major ticks, only valid if t is\n\
6759 t: Draws major ticks.\n\
6760 u: If this is specified, the text label is written beside the\n\
6762 v: If this is specified, the text label is written beside the\n\
6766 zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
6767 the text label for the z axis. It is only drawn if u or v are in\n\
6770 ztick (PLFLT, input) : World coordinate interval between major\n\
6771 ticks on the z axis. If it is set to zero, PLplot automatically\n\
6772 generates a suitable tick interval.\n\
6774 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
6775 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6776 generates a suitable minor tick interval.\n\
6779Set character size\n\
6783 This sets up the size of all subsequent characters drawn. The actual\n\
6784 height of a character is the product of the default character size and\n\
6785 a scaling factor.\n\
6787 Redacted form: plschr(def, scale)\n\
6789 This function is used in examples 2, 13, 23, and 24.\n\
6795plschr(def, scale)\n\
6799 def (PLFLT, input) : The default height of a character in\n\
6800 millimeters, should be set to zero if the default height is to\n\
6801 remain unchanged. For rasterized drivers the dx and dy values\n\
6802 specified in plspage are used to convert from mm to pixels (note\n\
6803 the different unit systems used). This dpi aware scaling is not\n\
6804 implemented for all drivers yet.\n\
6806 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6807 actual character height.\n\
6810Calculate continuous time from broken-down time for the current stream\n\
6814 Calculate continuous time, ctime, from broken-down time for the\n\
6815 current stream. The broken-down\n\
6816 time is specified by the following parameters: year, month, day, hour,\n\
6817 min, and sec. This function is the inverse of plbtime.\n\
6819 The PLplot definition of broken-down time is a calendar time that\n\
6820 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6821 responsibility to apply those offsets (if so desired) before using the\n\
6822 PLplot time API. By default broken-down time is defined using the\n\
6823 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6824 continuous time is defined as the number of seconds since the Unix\n\
6825 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6826 broken-down and continuous time are possible, see plconfigtime which\n\
6827 specifies that transformation for the current stream.\n\
6829 Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6833 This function is used in example 29.\n\
6839plctime(year, month, day, hour, min, sec, ctime)\n\
6843 year (PLINT, input) : Input year.\n\
6845 month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6848 day (PLINT, input) : Input day in range from 1 to 31.\n\
6850 hour (PLINT, input) : Input hour in range from 0 to 23\n\
6852 min (PLINT, input) : Input minute in range from 0 to 59.\n\
6854 sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6856 ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6857 time calculated from the broken-down time specified by the\n\
6858 previous parameters.\n\
6865 Sets the color index for cmap0 (see the PLplot documentation).\n\
6867 Redacted form: plcol0(icol0)\n\
6869 This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6879 icol0 (PLINT, input) : Integer representing the color. The\n\
6880 defaults at present are (these may change):\n\
6881 0 black (default background)\n\
6882 1 red (default foreground)\n\
6898 Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6899 change an individual color in the cmap0 color palette.\n\
6906 Sets the color for cmap1 (see the PLplot documentation).\n\
6908 Redacted form: plcol1(col1)\n\
6910 This function is used in examples 12 and 21.\n\
6920 col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6921 is mapped to color using the continuous cmap1 palette which by\n\
6922 default ranges from blue to the background color to red. The\n\
6923 cmap1 palette can also be straightforwardly changed by the user\n\
6924 with plscmap1 or plscmap1l.\n\
6927Returns the background color (cmap0[0]) by 8-bit RGB value\n\
6931 Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
6933 Redacted form: plgcolbg(r, g, b)\n\
6935 This function is used in example 31.\n\
6945 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
6946 in the range from 0 to 255.\n\
6948 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
6949 in the range from 0 to 255.\n\
6951 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
6952 in the range from 0 to 255.\n\
6955Draw a circular or elliptical arc\n\
6959 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
6960 semiminor axis b, starting at angle1 and ending at angle2.\n\
6962 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
6966 This function is used in examples 3 and 27.\n\
6972plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
6976 x (PLFLT, input) : X coordinate of arc center.\n\
6978 y (PLFLT, input) : Y coordinate of arc center.\n\
6980 a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
6982 b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
6984 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
6987 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
6990 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
6993 fill (PLBOOL, input) : Draw a filled arc.\n\
6996Parse command-line arguments\n\
7000 Parse command-line arguments.\n\
7002 plparseopts removes all recognized flags (decreasing argc\n\
7003 accordingly), so that invalid input may be readily detected. It can\n\
7004 also be used to process user command line flags. The user can merge\n\
7005 an option table of type PLOptionTable into the internal option table\n\
7006 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
7007 the external table(s) be parsed by calling plClearOpts before\n\
7010 The default action taken by plparseopts is as follows:\n\
7011 Returns with an error if an unrecognized option or badly formed\n\
7012 option-value pair are encountered.\n\
7013 Returns immediately (return code 0) when the first non-option command\n\
7014 line argument is found.\n\
7015 Returns with the return code of the option handler, if one was called.\n\
7017 Deletes command line arguments from argv list as they are found, and\n\
7018 decrements argc accordingly.\n\
7019 Does not show \"invisible\" options in usage or help messages.\n\
7020 Assumes the program name is contained in argv[0].\n\
7022 These behaviors may be controlled through the\n\
7025 Redacted form: General: plparseopts(argv, mode)\n\
7028 This function is used in all of the examples.\n\
7034PLINT plparseopts(p_argc, argv, mode)\n\
7038 p_argc (int *, input/output) : Number of arguments.\n\
7040 argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
7041 strings containing *p_argc command-line arguments.\n\
7043 mode (PLINT, input) : Parsing mode with the following\n\
7044 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
7045 and all error messages enabled, including program exit when an\n\
7046 error occurs. Anything on the command line that isn\'t recognized\n\
7047 as a valid option or option argument is flagged as an error.\n\
7048 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
7050 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
7052 PL_PARSE_SHOWALL (8) -- Show invisible options\n\
7053 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
7054 pointer to the program name.\n\
7055 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
7056 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
7057 unrecognized arguments.\n\
7060Get parameters that define current device-space window\n\
7064 Get relative margin width, aspect ratio, and relative justification\n\
7065 that define current device-space window. If plsdidev has not been\n\
7066 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
7067 p_jy will all be 0.\n\
7069 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
7071 This function is used in example 31.\n\
7077plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
7081 p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7084 p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
7087 p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7088 justification in x.\n\
7090 p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
7091 justification in y.\n\
7094Assign a function to use for generating custom axis labels\n\
7098 This function allows a user to provide their own function to provide\n\
7099 axis label text. The user function is given the numeric value for a\n\
7100 point on an axis and returns a string label to correspond with that\n\
7101 value. Custom axis labels can be enabled by passing appropriate\n\
7102 arguments to plenv, plbox, plbox3 and similar functions.\n\
7104 This function is used in example 19.\n\
7110plslabelfunc(label_func, label_data)\n\
7114 label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
7115 label function. In order to reset to the default labelling, set\n\
7116 this to NULL. The labelling function parameters are, in order:\n\
7117 axis: This indicates which axis a label is being requested for.\n\
7118 The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
7120 value: This is the value along the axis which is being labelled.\n\
7122 label_text: The string representation of the label value.\n\
7124 length: The maximum length in characters allowed for label_text.\n\
7127 label_data (PLPointer, input) : This parameter may be used to pass\n\
7128 data to the label_func function.\n\
7131Get the (current) run level\n\
7135 Get the (current) run level. Valid settings are: 0, uninitialized\n\
7137 2, viewport defined\n\
7138 3, world coordinates defined\n\
7141 Redacted form: plglevel(p_level)\n\
7143 This function is used in example 31.\n\
7153 p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
7161 This sets the line style according to one of eight predefined patterns\n\
7162 (also see plstyl).\n\
7164 Redacted form: pllsty(lin)\n\
7166 This function is used in examples 9, 12, 22, and 25.\n\
7176 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
7177 a continuous line, line style 2 is a line with short dashes and\n\
7178 gaps, line style 3 is a line with long dashes and gaps, line style\n\
7179 4 has long dashes and short gaps and so on.\n\
7182Set up standard window and draw box\n\
7186 Sets up plotter environment for simple graphs by calling pladv and\n\
7187 setting up viewport and window to sensible default values. plenv\n\
7188 leaves a standard margin (left-hand margin of eight character heights,\n\
7189 and a margin around the other three sides of five character heights)\n\
7190 around most graphs for axis labels and a title. When these defaults\n\
7191 are not suitable, use the individual routines plvpas, plvpor, or\n\
7192 plvasp for setting up the viewport, plwind for defining the window,\n\
7193 and plbox for drawing the box.\n\
7195 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7197 This function is used in example 1,3,9,13,14,19-22,29.\n\
7203plenv(xmin, xmax, ymin, ymax, just, axis)\n\
7207 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
7208 world coordinates).\n\
7210 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
7211 world coordinates).\n\
7213 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
7216 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
7219 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
7220 scales will not be set, the user must set up the scale before\n\
7221 calling plenv using plsvpa, plvasp or other.\n\
7222 0: the x and y axes are scaled independently to use as much of\n\
7223 the screen as possible.\n\
7224 1: the scales of the x and y axes are made equal.\n\
7225 2: the axis of the x and y axes are made equal, and the plot\n\
7226 box will be square.\n\
7229 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
7230 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
7231 -1: draw box only.\n\
7232 0: draw box, ticks, and numeric tick labels.\n\
7233 1: also draw coordinate axes at x=0 and y=0.\n\
7234 2: also draw a grid at major tick positions in both\n\
7236 3: also draw a grid at minor tick positions in both\n\
7238 10: same as 0 except logarithmic x tick marks. (The x data\n\
7239 have to be converted to logarithms separately.)\n\
7240 11: same as 1 except logarithmic x tick marks. (The x data\n\
7241 have to be converted to logarithms separately.)\n\
7242 12: same as 2 except logarithmic x tick marks. (The x data\n\
7243 have to be converted to logarithms separately.)\n\
7244 13: same as 3 except logarithmic x tick marks. (The x data\n\
7245 have to be converted to logarithms separately.)\n\
7246 20: same as 0 except logarithmic y tick marks. (The y data\n\
7247 have to be converted to logarithms separately.)\n\
7248 21: same as 1 except logarithmic y tick marks. (The y data\n\
7249 have to be converted to logarithms separately.)\n\
7250 22: same as 2 except logarithmic y tick marks. (The y data\n\
7251 have to be converted to logarithms separately.)\n\
7252 23: same as 3 except logarithmic y tick marks. (The y data\n\
7253 have to be converted to logarithms separately.)\n\
7254 30: same as 0 except logarithmic x and y tick marks. (The x\n\
7255 and y data have to be converted to logarithms separately.)\n\
7256 31: same as 1 except logarithmic x and y tick marks. (The x\n\
7257 and y data have to be converted to logarithms separately.)\n\
7258 32: same as 2 except logarithmic x and y tick marks. (The x\n\
7259 and y data have to be converted to logarithms separately.)\n\
7260 33: same as 3 except logarithmic x and y tick marks. (The x\n\
7261 and y data have to be converted to logarithms separately.)\n\
7262 40: same as 0 except date / time x labels.\n\
7263 41: same as 1 except date / time x labels.\n\
7264 42: same as 2 except date / time x labels.\n\
7265 43: same as 3 except date / time x labels.\n\
7266 50: same as 0 except date / time y labels.\n\
7267 51: same as 1 except date / time y labels.\n\
7268 52: same as 2 except date / time y labels.\n\
7269 53: same as 3 except date / time y labels.\n\
7270 60: same as 0 except date / time x and y labels.\n\
7271 61: same as 1 except date / time x and y labels.\n\
7272 62: same as 2 except date / time x and y labels.\n\
7273 63: same as 3 except date / time x and y labels.\n\
7274 70: same as 0 except custom x and y labels.\n\
7275 71: same as 1 except custom x and y labels.\n\
7276 72: same as 2 except custom x and y labels.\n\
7277 73: same as 3 except custom x and y labels.\n\
7284 Alternative to plstar for initializing the plotting package. The\n\
7285 device name keyword for the desired output device must be supplied as\n\
7286 an argument. These keywords are the same as those printed out by\n\
7287 plstar. If the requested device is not available, or if the input\n\
7288 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
7289 is used. This routine also divides the output device page into nx by\n\
7290 ny subpages, each of which may be used independently. The subroutine\n\
7291 pladv is used to advance from one subpage to the next.\n\
7293 Redacted form: General: plstart(devname, nx, ny)\n\
7296 This function is not used in any examples.\n\
7302plstart(devname, nx, ny)\n\
7306 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7307 containing the device name keyword of the required output device.\n\
7309 devname is NULL or if the first character of the string is a ``?\'\',\n\
7310 the normal (prompted) start up is used.\n\
7312 nx (PLINT, input) : Number of subpages to divide output page in the\n\
7315 ny (PLINT, input) : Number of subpages to divide output page in the\n\
7319Plot a glyph at the specified points\n\
7323 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
7324 because many[!] more glyphs are accessible with plstring.) The glyph\n\
7325 is specified with a PLplot user string. Note that the user string is\n\
7326 not actually limited to one glyph so it is possible (but not normally\n\
7327 useful) to plot more than one glyph at the specified points with this\n\
7328 function. As with plmtex and plptex, the user string can contain FCI\n\
7329 escapes to determine the font, UTF-8 code to determine the glyph or\n\
7330 else PLplot escapes for Hershey or unicode text to determine the\n\
7333 Redacted form: plstring(x, y, string)\n\
7335 This function is used in examples 4, 21 and 26.\n\
7341plstring(n, x, y, string)\n\
7345 n (PLINT, input) : Number of points in the x and y vectors.\n\
7347 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7350 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7353 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
7354 the glyph(s) to be plotted at each of the n points.\n\
7357Write text relative to viewport boundaries in 3D plots\n\
7361 Writes text at a specified position relative to the viewport\n\
7362 boundaries. Text may be written inside or outside the viewport, but\n\
7363 is clipped at the subpage boundaries. The reference point of a string\n\
7364 lies along a line passing through the string at half the height of a\n\
7365 capital letter. The position of the reference point along this line\n\
7366 is determined by just, and the position of the reference point\n\
7367 relative to the viewport is set by disp and pos.\n\
7369 Redacted form: plmtex3(side, disp, pos, just, text)\n\
7371 This function is used in example 28.\n\
7377plmtex3(side, disp, pos, just, text)\n\
7381 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7382 the side of the viewport along which the text is to be written.\n\
7383 The string should contain one or more of the following characters:\n\
7384 [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
7385 only label the X axis, not both the X and Y axes. x: Label the X\n\
7387 y: Label the Y axis.\n\
7388 z: Label the Z axis.\n\
7389 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
7390 For X it is the axis that starts at y-min. For Y it is the\n\
7391 axis that starts at x-min.\n\
7392 s: Label the secondary axis.\n\
7393 v: Draw the text perpendicular to the axis.\n\
7396 disp (PLFLT, input) : Position of the reference point of string,\n\
7397 measured outwards from the specified viewport edge in units of the\n\
7398 current character height. Use negative disp to write within the\n\
7401 pos (PLFLT, input) : Position of the reference point of string\n\
7402 along the specified edge, expressed as a fraction of the length of\n\
7405 just (PLFLT, input) : Specifies the position of the string relative\n\
7406 to its reference point. If just=0. , the reference point is at\n\
7407 the left and if just=1. , it is at the right of the string. Other\n\
7408 values of just give intermediate justifications.\n\
7410 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
7414Get plot orientation\n\
7418 Get plot orientation parameter which is multiplied by 90 degrees to\n\
7419 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7420 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7421 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7422 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7423 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
7424 not been called the default value pointed to by p_rot will be 0.\n\
7426 Redacted form: plgdiori(p_rot)\n\
7428 This function is not used in any examples.\n\
7438 p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
7442Simple routine to write labels\n\
7446 Routine for writing simple labels. Use plmtex for more complex labels.\n\
7448 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
7450 This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
7456pllab(xlabel, ylabel, tlabel)\n\
7460 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7461 the label for the x axis.\n\
7463 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7464 the label for the y axis.\n\
7466 tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
7467 the title of the plot.\n\
7470Switch to text screen\n\
7474 Sets an interactive device to text mode, used in conjunction with\n\
7475 plgra to allow graphics and text to be interspersed. On a device\n\
7476 which supports separate text and graphics windows, this command causes\n\
7477 control to be switched to the text window. This can be useful for\n\
7478 printing diagnostic messages or getting user input, which would\n\
7479 otherwise interfere with the plots. The program must switch back to\n\
7480 the graphics window before issuing plot commands, as the text (or\n\
7481 console) device will probably become quite confused otherwise. If\n\
7482 already in text mode, this command is ignored. It is also ignored on\n\
7483 devices which only support a single window or use a different method\n\
7484 for shifting focus (see also plgra).\n\
7486 Redacted form: pltext()\n\
7488 This function is used in example 1.\n\
7497Plot all or a subset of Shapefile data using lines in world coordinates\n\
7501 Plot all or a subset of Shapefile data using lines in world\n\
7502 coordinates. Our 19th standard example demonstrates how to use this\n\
7503 function. This function plots data from a Shapefile using lines as in\n\
7504 plmap, however it also has the option of also only drawing specified\n\
7505 elements from the Shapefile. The vector of indices of the required\n\
7506 elements are passed as a function argument. The Shapefile data should\n\
7507 include a metadata file (extension.dbf) listing all items within the\n\
7508 Shapefile. This file can be opened by most popular spreadsheet\n\
7509 programs and can be used to decide which indices to pass to this\n\
7512 Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
7515 This function is used in example 19.\n\
7521plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
7525 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7526 transform the coordinates given in the shapefile into a plot\n\
7527 coordinate system. By using this transform, we can change from a\n\
7528 longitude, latitude coordinate to a polar stereographic project,\n\
7529 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7530 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7531 mapform(), x[] and y[] should be replaced by the corresponding\n\
7532 plot coordinates. If no transform is desired, mapform can be\n\
7533 replaced by NULL.\n\
7535 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7536 the file name of a set of Shapefile files without the file\n\
7539 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7540 be in the same units as used by the Shapefile. You could use a\n\
7541 very large negative number to plot everything, but you can improve\n\
7542 performance by limiting the area drawn. The units must match those\n\
7543 of the Shapefile projection, which may be for example longitude or\n\
7544 distance. The value of minx must be less than the value of maxx.\n\
7546 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7547 use a very large number to plot everything, but you can improve\n\
7548 performance by limiting the area drawn.\n\
7550 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7551 be in the same units as used by the Shapefile. You could use a\n\
7552 very large negative number to plot everything, but you can improve\n\
7553 performance by limiting the area drawn. The units must match those\n\
7554 of the Shapefile projection, which may be for example latitude or\n\
7555 distance. The value of miny must be less than the value of maxy.\n\
7557 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7558 use a very large number to plot everything, but you can improve\n\
7559 performance by limiting the area drawn.\n\
7561 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
7562 zero-based indices of the Shapefile elements which will be drawn.\n\
7564 plotentries to NULL will plot all elements of the Shapefile.\n\
7566 nplotentries (PLINT, input) : The number of items in\n\
7567 plotentries. Ignored if\n\
7568 plotentries is NULL.\n\
7571Set precision in numeric labels\n\
7575 Sets the number of places after the decimal point in numeric labels.\n\
7577 Redacted form: plprec(setp, prec)\n\
7579 This function is used in example 29.\n\
7585plprec(setp, prec)\n\
7589 setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7590 automatically determines the number of places to use after the\n\
7591 decimal point in numeric labels (like those used to label axes).\n\
7592 If setp is 1 then prec sets the number of places.\n\
7594 prec (PLINT, input) : The number of characters to draw after the\n\
7595 decimal point in numeric labels.\n\
7598Draw a line between two points\n\
7602 Joins the point (\n\
7608 Redacted form: pljoin(x1,y1,x2,y2)\n\
7610 This function is used in examples 3 and 14.\n\
7616pljoin(x1, y1, x2, y2)\n\
7620 x1 (PLFLT, input) : x coordinate of first point.\n\
7622 y1 (PLFLT, input) : y coordinate of first point.\n\
7624 x2 (PLFLT, input) : x coordinate of second point.\n\
7626 y2 (PLFLT, input) : y coordinate of second point.\n\
7629Set the device (keyword) name\n\
7633 Set the device (keyword) name.\n\
7635 Redacted form: plsdev(devname)\n\
7637 This function is used in examples 1, 14, and 20.\n\
7647 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
7648 containing the device name keyword of the required output device.\n\
7650 devname is NULL or if the first character of the string is a ``?\'\',\n\
7651 the normal (prompted) start up is used.\n\
7654Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
7658 Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
7659 (see the PLplot documentation) index. Overwrites the previous color\n\
7660 value for the given index and, thus, does not result in any additional\n\
7661 allocation of space for colors.\n\
7663 This function is used in example 30.\n\
7669plscol0a(icol0, r, g, b, alpha)\n\
7673 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
7674 number of colors (which is set by default, by plscmap0n, or even\n\
7677 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7678 degree of red in the color.\n\
7680 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7681 degree of green in the color.\n\
7683 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7684 degree of blue in the color.\n\
7686 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
7690Draw filled polygon in 3D\n\
7694 Fills the 3D polygon defined by the n points in the x, y, and z\n\
7695 vectors using the pattern defined by plpsty or plpat. The routine\n\
7696 will automatically close the polygon between the last and first\n\
7697 vertices. If multiple closed polygons are passed in x, y, and z then\n\
7698 plfill3 will fill in between them.\n\
7700 Redacted form: General: plfill3(x, y, z)\n\
7703 This function is used in example 15.\n\
7709plfill3(n, x, y, z)\n\
7713 n (PLINT, input) : Number of vertices in polygon.\n\
7715 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7718 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7721 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
7729 Specify the window, i.e., the world coordinates of the edges of the\n\
7732 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
7734 This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
7741plwind(xmin, xmax, ymin, ymax)\n\
7745 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
7748 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
7751 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
7754 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
7758Draw text at points defined by Shapefile data in world coordinates\n\
7762 As per plmapline, however the items are plotted as text in the same\n\
7765 Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
7766 miny, maxy, plotentry)\n\
7768 This function is used in example 19.\n\
7774plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
7778 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
7779 transform the coordinates given in the shapefile into a plot\n\
7780 coordinate system. By using this transform, we can change from a\n\
7781 longitude, latitude coordinate to a polar stereographic project,\n\
7782 for example. Initially, x[0]..[n-1] are the longitudes and\n\
7783 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
7784 mapform(), x[] and y[] should be replaced by the corresponding\n\
7785 plot coordinates. If no transform is desired, mapform can be\n\
7786 replaced by NULL.\n\
7788 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
7789 the file name of a set of Shapefile files without the file\n\
7792 dx (PLFLT, input) : Used to define the slope of the texts which is\n\
7795 dy (PLFLT, input) : Used to define the slope of the texts which is\n\
7798 just (PLFLT, input) : Set the justification of the text. The value\n\
7799 given will be the fraction of the distance along the string that\n\
7800 sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
7801 centralized text and 1.0 gives right aligned text.\n\
7803 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
7805 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
7806 be in the same units as used by the Shapefile. You could use a\n\
7807 very large negative number to plot everything, but you can improve\n\
7808 performance by limiting the area drawn. The units must match those\n\
7809 of the Shapefile projection, which may be for example longitude or\n\
7810 distance. The value of minx must be less than the value of maxx.\n\
7812 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
7813 use a very large number to plot everything, but you can improve\n\
7814 performance by limiting the area drawn.\n\
7816 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
7817 be in the same units as used by the Shapefile. You could use a\n\
7818 very large negative number to plot everything, but you can improve\n\
7819 performance by limiting the area drawn. The units must match those\n\
7820 of the Shapefile projection, which may be for example latitude or\n\
7821 distance. The value of miny must be less than the value of maxy.\n\
7823 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
7824 use a very large number to plot everything, but you can improve\n\
7825 performance by limiting the area drawn.\n\
7827 plotentry (PLINT, input) : An integer indicating which text string\n\
7828 of the Shapefile (zero indexed) will be drawn.\n\
7831Switch to graphics screen\n\
7835 Sets an interactive device to graphics mode, used in conjunction with\n\
7836 pltext to allow graphics and text to be interspersed. On a device\n\
7837 which supports separate text and graphics windows, this command causes\n\
7838 control to be switched to the graphics window. If already in graphics\n\
7839 mode, this command is ignored. It is also ignored on devices which\n\
7840 only support a single window or use a different method for shifting\n\
7841 focus. See also pltext.\n\
7843 Redacted form: plgra()\n\
7845 This function is used in example 1.\n\
7854Set parameters of contour labelling other than format of numerical label\n\
7858 Set parameters of contour labelling other than those handled by\n\
7859 pl_setcontlabelformat.\n\
7861 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7863 This function is used in example 9.\n\
7869pl_setcontlabelparam(offset, size, spacing, active)\n\
7873 offset (PLFLT, input) : Offset of label from contour line (if set\n\
7874 to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7876 size (PLFLT, input) : Font height for contour labels (normalized).\n\
7877 Default value is 0.3.\n\
7879 spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7880 Default value is 0.1.\n\
7882 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7883 contour labels on. Default is off (0).\n\
7886Get family, style and weight of the current font\n\
7890 Gets information about current font. See the PLplot documentation for\n\
7891 more information on font selection.\n\
7893 Redacted form: plgfont(p_family, p_style, p_weight)\n\
7895 This function is used in example 23.\n\
7901plgfont(p_family, p_style, p_weight)\n\
7905 p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7906 font family. The available values are given by the PL_FCI_*\n\
7907 constants in plplot.h. Current options are PL_FCI_SANS,\n\
7908 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
7909 p_family is NULL then the font family is not returned.\n\
7911 p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7912 font style. The available values are given by the PL_FCI_*\n\
7913 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
7914 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
7915 style is not returned.\n\
7917 p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
7918 font weight. The available values are given by the PL_FCI_*\n\
7919 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
7920 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
7924Plot a histogram from unbinned data\n\
7928 Plots a histogram from n data points stored in the data vector. This\n\
7929 routine bins the data into nbin bins equally spaced between datmin and\n\
7930 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7931 opt allows, among other things, the histogram either to be plotted in\n\
7932 an existing window or causes plhist to call plenv with suitable limits\n\
7933 before plotting the histogram.\n\
7935 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7937 This function is used in example 5.\n\
7943plhist(n, data, datmin, datmax, nbin, opt)\n\
7947 n (PLINT, input) : Number of data points.\n\
7949 data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7952 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7954 datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7956 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7957 divide the interval xmin to xmax.\n\
7959 opt (PLINT, input) : Is a combination of several flags:\n\
7960 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7961 the histogram data, the outer bins are expanded to fill up the\n\
7962 entire x-axis, data outside the given extremes are assigned to the\n\
7963 outer bins and bins of zero height are simply drawn.\n\
7964 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7965 to fit the histogram data, without this flag, plenv is called\n\
7966 to set the world coordinates.\n\
7967 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7968 extremes are not taken into account. This option should\n\
7969 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7970 properly present the data.\n\
7971 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7972 size as the ones inside.\n\
7973 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7974 (there is a gap for such bins).\n\
7977Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
7981 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
7982 alpha transparency value.\n\
7984 This function is used in example 31.\n\
7990plgcolbga(r, g, b, alpha)\n\
7994 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
7995 in the range from 0 to 255.\n\
7997 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
7998 in the range from 0 to 255.\n\
8000 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
8001 in the range from 0 to 255.\n\
8003 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
8004 transparency in the range (0.0-1.0).\n\
8011 Set integer plot orientation parameter. This function is identical to\n\
8012 plsdiori except for the type of the argument, and should be used in\n\
8013 the same way. See the documentation of plsdiori for details.\n\
8015 Redacted form: plsori(ori)\n\
8017 This function is used in example 3.\n\
8027 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
8028 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
8032Plot latitude and longitude lines\n\
8036 Displays latitude and longitude on the current plot. The lines are\n\
8037 plotted in the current color and line style.\n\
8039 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
8042 This function is used in example 19.\n\
8048plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
8052 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
8053 transform the coordinate longitudes and latitudes to a plot\n\
8054 coordinate system. By using this transform, we can change from a\n\
8055 longitude, latitude coordinate to a polar stereographic project,\n\
8056 for example. Initially, x[0]..[n-1] are the longitudes and\n\
8057 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
8058 mapform(), x[] and y[] should be replaced by the corresponding\n\
8059 plot coordinates. If no transform is desired, mapform can be\n\
8060 replaced by NULL.\n\
8062 dlong (PLFLT, input) : The interval in degrees at which the\n\
8063 longitude lines are to be plotted.\n\
8065 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
8066 lines are to be plotted.\n\
8068 minlong (PLFLT, input) : The value of the longitude on the left\n\
8069 side of the plot. The value of minlong must be less than the value\n\
8070 of maxlong, and the quantity maxlong-minlong must be less than or\n\
8073 maxlong (PLFLT, input) : The value of the longitude on the right\n\
8074 side of the plot.\n\
8076 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
8077 background. One can always use -90.0 as the boundary outside the\n\
8078 plot window will be automatically eliminated. However, the\n\
8079 program will be faster if one can reduce the size of the\n\
8080 background plotted.\n\
8082 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
8083 background. One can always use 90.0 as the boundary outside the\n\
8084 plot window will be automatically eliminated.\n\
8087Clear current (sub)page\n\
8091 Clears the current page, effectively erasing everything that have been\n\
8092 drawn. This command only works with interactive drivers; if the\n\
8093 driver does not support this, the page is filled with the background\n\
8094 color in use. If the current page is divided into subpages, only the\n\
8095 current subpage is erased. The nth subpage can be selected with\n\
8098 Redacted form: General: plclear()\n\
8101 This function is not used in any examples.\n\
8114 Initializing the plotting package. The program prompts for the device\n\
8115 keyword or number of the desired output device. Hitting a RETURN in\n\
8116 response to the prompt is the same as selecting the first device. If\n\
8117 only one device is enabled when PLplot is installed, plstar will issue\n\
8118 no prompt. The output device is divided into nx by ny subpages, each\n\
8119 of which may be used independently. The subroutine pladv is used to\n\
8120 advance from one subpage to the next.\n\
8122 Redacted form: plstar(nx, ny)\n\
8124 This function is used in example 1.\n\
8134 nx (PLINT, input) : Number of subpages to divide output page in the\n\
8137 ny (PLINT, input) : Number of subpages to divide output page in the\n\
8141Write text relative to viewport boundaries\n\
8145 Writes text at a specified position relative to the viewport\n\
8146 boundaries. Text may be written inside or outside the viewport, but\n\
8147 is clipped at the subpage boundaries. The reference point of a string\n\
8148 lies along a line passing through the string at half the height of a\n\
8149 capital letter. The position of the reference point along this line\n\
8150 is determined by just, and the position of the reference point\n\
8151 relative to the viewport is set by disp and pos.\n\
8153 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
8156 This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
8163plmtex(side, disp, pos, just, text)\n\
8167 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8168 the side of the viewport along which the text is to be written.\n\
8169 The string must be one of: b: Bottom of viewport, text written\n\
8170 parallel to edge.\n\
8171 bv: Bottom of viewport, text written at right angles to edge.\n\
8172 l: Left of viewport, text written parallel to edge.\n\
8173 lv: Left of viewport, text written at right angles to edge.\n\
8174 r: Right of viewport, text written parallel to edge.\n\
8175 rv: Right of viewport, text written at right angles to edge.\n\
8176 t: Top of viewport, text written parallel to edge.\n\
8177 tv: Top of viewport, text written at right angles to edge.\n\
8180 disp (PLFLT, input) : Position of the reference point of string,\n\
8181 measured outwards from the specified viewport edge in units of the\n\
8182 current character height. Use negative disp to write within the\n\
8185 pos (PLFLT, input) : Position of the reference point of string\n\
8186 along the specified edge, expressed as a fraction of the length of\n\
8189 just (PLFLT, input) : Specifies the position of the string relative\n\
8190 to its reference point. If just=0. , the reference point is at\n\
8191 the left and if just=1. , it is at the right of the string. Other\n\
8192 values of just give intermediate justifications.\n\
8194 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
8198Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
8202 Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
8203 PLFLT alpha transparency value (see the PLplot documentation).\n\
8205 This function is used in example 31.\n\
8211plscolbga(r, g, b, alpha)\n\
8215 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8216 degree of red in the color.\n\
8218 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8219 degree of green in the color.\n\
8221 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8222 degree of blue in the color.\n\
8224 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
8228Replays contents of plot buffer to current device/file\n\
8232 Replays contents of plot buffer to current device/file.\n\
8234 Redacted form: plreplot()\n\
8236 This function is used in example 1,20.\n\
8245Plot a glyph at the specified 3D points\n\
8249 Plot a glyph at the specified 3D points. (This function is largely\n\
8250 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
8251 Set up the call to this function similar to what is done for plline3.\n\
8252 code=-1 means try to just draw a point. Right now it\'s just a move\n\
8253 and a draw at the same place. Not ideal, since a sufficiently\n\
8254 intelligent output device may optimize it away, or there may be faster\n\
8255 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
8256 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
8257 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
8258 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
8259 code <= 127 the corresponding printable ASCII character is plotted.\n\
8261 Redacted form: plpoin3(x, y, z, code)\n\
8263 This function is not used in any example.\n\
8269plpoin3(n, x, y, z, code)\n\
8273 n (PLINT, input) : Number of points in the x and y vectors.\n\
8275 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8278 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8281 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
8284 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
8285 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
8286 each of the n points.\n\
8289Set family, style and weight of the current font\n\
8293 Sets the current font. See the PLplot documentation for more\n\
8294 information on font selection.\n\
8296 Redacted form: plsfont(family, style, weight)\n\
8298 This function is used in example 23.\n\
8304plsfont(family, style, weight)\n\
8308 family (PLINT, input) : Font family to select for the current font.\n\
8309 The available values are given by the PL_FCI_* constants in\n\
8310 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
8311 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
8312 signifies that the font family should not be altered.\n\
8314 style (PLINT, input) : Font style to select for the current font.\n\
8315 The available values are given by the PL_FCI_* constants in\n\
8316 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
8317 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
8318 should not be altered.\n\
8320 weight (PLINT, input) : Font weight to select for the current font.\n\
8321 The available values are given by the PL_FCI_* constants in\n\
8322 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
8323 negative value signifies that the font weight should not be\n\
8327Draw a box with axes, etc. with arbitrary origin\n\
8331 Draws a box around the currently defined viewport with arbitrary\n\
8332 world-coordinate origin specified by x0 and y0 and labels it with\n\
8333 world coordinate values appropriate to the window. Thus plaxes should\n\
8334 only be called after defining both viewport and window. The ascii\n\
8335 character strings xopt and yopt specify how the box should be drawn as\n\
8336 described below. If ticks and/or subticks are to be drawn for a\n\
8337 particular axis, the tick intervals and number of subintervals may be\n\
8338 specified explicitly, or they may be defaulted by setting the\n\
8339 appropriate arguments to zero.\n\
8341 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
8345 This function is not used in any examples.\n\
8351plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8355 x0 (PLFLT, input) : World X coordinate of origin.\n\
8357 y0 (PLFLT, input) : World Y coordinate of origin.\n\
8359 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8360 options for the x axis. The string can include any combination of\n\
8361 the following letters (upper or lower case) in any order: a: Draws\n\
8362 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8364 b: Draws bottom (X) or left (Y) edge of frame.\n\
8365 c: Draws top (X) or right (Y) edge of frame.\n\
8366 d: Plot labels as date / time. Values are assumed to be\n\
8367 seconds since the epoch (as used by gmtime).\n\
8368 f: Always use fixed point numeric labels.\n\
8369 g: Draws a grid at the major tick interval.\n\
8370 h: Draws a grid at the minor tick interval.\n\
8371 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8373 l: Labels axis logarithmically. This only affects the labels,\n\
8374 not the data, and so it is necessary to compute the logarithms\n\
8375 of data points before passing them to any of the drawing\n\
8377 m: Writes numeric labels at major tick intervals in the\n\
8378 unconventional location (above box for X, right of box for Y).\n\
8379 n: Writes numeric labels at major tick intervals in the\n\
8380 conventional location (below box for X, left of box for Y).\n\
8381 o: Use custom labelling function to generate axis label text.\n\
8382 The custom labelling function can be defined with the\n\
8383 plslabelfunc command.\n\
8384 s: Enables subticks between major ticks, only valid if t is\n\
8386 t: Draws major ticks.\n\
8387 u: Exactly like \"b\" except don\'t draw edge line.\n\
8388 w: Exactly like \"c\" except don\'t draw edge line.\n\
8389 x: Exactly like \"t\" (including the side effect of the\n\
8390 numerical labels for the major ticks) except exclude drawing\n\
8391 the major and minor tick marks.\n\
8394 xtick (PLFLT, input) : World coordinate interval between major\n\
8395 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8396 generates a suitable tick interval.\n\
8398 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8399 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8400 generates a suitable minor tick interval.\n\
8402 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8403 options for the y axis. The string can include any combination of\n\
8404 the letters defined above for xopt, and in addition may contain:\n\
8405 v: Write numeric labels for the y axis parallel to the base of the\n\
8406 graph, rather than parallel to the axis.\n\
8409 ytick (PLFLT, input) : World coordinate interval between major\n\
8410 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8411 generates a suitable tick interval.\n\
8413 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8414 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8415 generates a suitable minor tick interval.\n\
8422 Begins a new page. For a file driver, the output file is opened if\n\
8423 necessary. Advancing the page via pleop and plbop is useful when a\n\
8424 page break is desired at a particular point when plotting to subpages.\n\
8425 Another use for pleop and plbop is when plotting pages to different\n\
8426 files, since you can manually set the file name by calling plsfnam\n\
8427 after the call to pleop. (In fact some drivers may only support a\n\
8428 single page per file, making this a necessity.) One way to handle\n\
8429 this case automatically is to page advance via pladv, but enable\n\
8430 familying (see plsfam) with a small limit on the file size so that a\n\
8431 new family member file will be created on each page break.\n\
8433 Redacted form: plbop()\n\
8435 This function is used in examples 2 and 20.\n\
8444Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
8448 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
8449 and PLFLT alpha transparency value. This sets the entire color map --\n\
8450 only as many colors as specified will be allocated.\n\
8452 Redacted form: plscmap0a(r, g, b, alpha)\n\
8454 This function is used in examples 30.\n\
8460plscmap0a(r, g, b, alpha, ncol0)\n\
8464 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8465 integers (0-255) representing the degree of red in the color.\n\
8467 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8468 integers (0-255) representing the degree of green in the color.\n\
8470 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
8471 integers (0-255) representing the degree of blue in the color.\n\
8473 alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
8474 representing the alpha transparency of the color.\n\
8476 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
8480Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
8484 This is a variant of plscmap1l that supports alpha channel\n\
8485 transparency. It sets cmap1 colors using a piece-wise linear\n\
8486 relationship between cmap1 intensity index (0.0-1.0) and position in\n\
8487 HLS or RGB color space (see the PLplot documentation) with alpha\n\
8488 transparency value (0.0-1.0). It may be called at any time.\n\
8490 Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
8491 alpha, alt_hue_path)\n\
8493 This function is used in example 30.\n\
8499plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
8503 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
8505 npts (PLINT, input) : number of control points.\n\
8507 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
8508 intensity index (0.0-1.0) in ascending order for each control\n\
8511 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
8512 coordinate (H or R) for each control point.\n\
8514 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
8515 coordinate (L or G) for each control point.\n\
8517 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
8518 coordinate (S or B) for each control point.\n\
8520 alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
8521 transparency value (0.0-1.0) for each control point.\n\
8523 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
8524 npts - 1 elements) containing the alternative interpolation method\n\
8525 Boolean value for each control point interval. (alt_hue_path[i]\n\
8526 refers to the interpolation interval between the i and i + 1\n\
8530Enter or leave xor mode\n\
8534 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
8535 those drivers (e.g., the xwin driver) that support it. Enables\n\
8536 erasing plots by drawing twice the same line, symbol, etc. If driver\n\
8537 is not capable of xor operation it returns a status of false.\n\
8539 Redacted form: plxormod(mode, status)\n\
8541 This function is used in examples 1 and 20.\n\
8547plxormod(mode, status)\n\
8551 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
8552 is false means leave xor mode.\n\
8554 status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
8555 modestatus of true (false) means driver is capable (incapable) of\n\
8559Eject current page\n\
8563 Clears the graphics screen of an interactive device, or ejects a page\n\
8564 on a plotter. See plbop for more information.\n\
8566 Redacted form: pleop()\n\
8568 This function is used in example 2,14.\n\
8577Draw a box with axes, etc\n\
8581 Draws a box around the currently defined viewport, and labels it with\n\
8582 world coordinate values appropriate to the window. Thus plbox should\n\
8583 only be called after defining both viewport and window. The ascii\n\
8584 character strings xopt and yopt specify how the box should be drawn as\n\
8585 described below. If ticks and/or subticks are to be drawn for a\n\
8586 particular axis, the tick intervals and number of subintervals may be\n\
8587 specified explicitly, or they may be defaulted by setting the\n\
8588 appropriate arguments to zero.\n\
8590 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8593 This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
8600plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
8604 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8605 options for the x axis. The string can include any combination of\n\
8606 the following letters (upper or lower case) in any order: a: Draws\n\
8607 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
8609 b: Draws bottom (X) or left (Y) edge of frame.\n\
8610 c: Draws top (X) or right (Y) edge of frame.\n\
8611 d: Plot labels as date / time. Values are assumed to be\n\
8612 seconds since the epoch (as used by gmtime).\n\
8613 f: Always use fixed point numeric labels.\n\
8614 g: Draws a grid at the major tick interval.\n\
8615 h: Draws a grid at the minor tick interval.\n\
8616 i: Inverts tick marks, so they are drawn outwards, rather than\n\
8618 l: Labels axis logarithmically. This only affects the labels,\n\
8619 not the data, and so it is necessary to compute the logarithms\n\
8620 of data points before passing them to any of the drawing\n\
8622 m: Writes numeric labels at major tick intervals in the\n\
8623 unconventional location (above box for X, right of box for Y).\n\
8624 n: Writes numeric labels at major tick intervals in the\n\
8625 conventional location (below box for X, left of box for Y).\n\
8626 o: Use custom labelling function to generate axis label text.\n\
8627 The custom labelling function can be defined with the\n\
8628 plslabelfunc command.\n\
8629 s: Enables subticks between major ticks, only valid if t is\n\
8631 t: Draws major ticks.\n\
8632 u: Exactly like \"b\" except don\'t draw edge line.\n\
8633 w: Exactly like \"c\" except don\'t draw edge line.\n\
8634 x: Exactly like \"t\" (including the side effect of the\n\
8635 numerical labels for the major ticks) except exclude drawing\n\
8636 the major and minor tick marks.\n\
8639 xtick (PLFLT, input) : World coordinate interval between major\n\
8640 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8641 generates a suitable tick interval.\n\
8643 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8644 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8645 generates a suitable minor tick interval.\n\
8647 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8648 options for the y axis. The string can include any combination of\n\
8649 the letters defined above for xopt, and in addition may contain:\n\
8650 v: Write numeric labels for the y axis parallel to the base of the\n\
8651 graph, rather than parallel to the axis.\n\
8654 ytick (PLFLT, input) : World coordinate interval between major\n\
8655 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8656 generates a suitable tick interval.\n\
8658 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8659 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8660 generates a suitable minor tick interval.\n\
8663Get x axis parameters\n\
8667 Returns current values of the p_digmax and p_digits flags for the x\n\
8668 axis. p_digits is updated after the plot is drawn, so this routine\n\
8669 should only be called after the call to plbox (or plbox3) is complete.\n\
8670 See the PLplot documentation for more information.\n\
8672 Redacted form: plgxax(p_digmax, p_digits)\n\
8674 This function is used in example 31.\n\
8680plgxax(p_digmax, p_digits)\n\
8684 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
8685 number of digits for the x axis. If nonzero, the printed label\n\
8686 has been switched to a floating-point representation when the\n\
8687 number of digits exceeds this value.\n\
8689 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
8690 number of digits for the numeric labels (x axis) from the last\n\
8698 Sets the font used for subsequent text and symbols. For devices that\n\
8699 still use Hershey fonts this routine has no effect unless the Hershey\n\
8700 fonts with extended character set are loaded (see plfontld). For\n\
8701 unicode-aware devices that use system fonts instead of Hershey fonts,\n\
8702 this routine calls the plsfci routine with argument set up\n\
8703 appropriately for the various cases below. However, this method of\n\
8704 specifying the font for unicode-aware devices is deprecated, and the\n\
8705 much more flexible method of calling plsfont directly is recommended\n\
8706 instead (where plsfont provides a user-friendly interface to plsfci),\n\
8708 Redacted form: plfont(ifont)\n\
8710 This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
8720 ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
8721 (simplest and fastest)\n\
8727Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
8731 Routine for creating a discrete plot legend with a plotted filled box,\n\
8732 line, and/or line of symbols for each annotated legend entry. (See\n\
8733 plcolorbar for similar functionality for creating continuous color\n\
8734 bars.) The arguments of pllegend provide control over the location\n\
8735 and size of the legend as well as the location and characteristics of\n\
8736 the elements (most of which are optional) within that legend. The\n\
8737 resulting legend is clipped at the boundaries of the current subpage.\n\
8738 (N.B. the adopted coordinate system used for some of the parameters is\n\
8739 defined in the documentation of the position parameter.)\n\
8741 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
8742 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
8743 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
8744 test_justification, text_colors, text, box_colors, box_patterns,\n\
8745 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
8746 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
8748 This function is used in examples 4, 26, and 33.\n\
8754pllegend(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\
8758 p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8759 legend width in adopted coordinates. This quantity is calculated\n\
8760 from plot_width, text_offset, ncolumn (possibly modified inside\n\
8761 the routine depending on nlegend and nrow), and the length\n\
8762 (calculated internally) of the longest text string.\n\
8764 p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8765 legend height in adopted coordinates. This quantity is calculated\n\
8766 from text_scale, text_spacing, and nrow (possibly modified inside\n\
8767 the routine depending on nlegend and nrow).\n\
8769 opt (PLINT, input) : opt contains bits controlling the overall\n\
8770 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
8771 on the left of the legend and the plotted area on the right.\n\
8772 Otherwise, put the text area on the right of the legend and the\n\
8773 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
8774 plot a (semitransparent) background for the legend. If the\n\
8775 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8776 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
8777 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
8778 plot the resulting array of legend entries in row-major order.\n\
8779 Otherwise, plot the legend entries in column-major order.\n\
8781 position (PLINT, input) : position contains bits which control the\n\
8782 overall position of the legend and the definition of the adopted\n\
8783 coordinates used for positions just like what is done for the\n\
8784 position argument for plcolorbar. However, note that the defaults\n\
8785 for the position bits (see below) are different than the\n\
8786 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
8787 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8788 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8789 the 16 possible standard positions (the 4 corners and centers of\n\
8790 the 4 sides for both the inside and outside cases) of the legend\n\
8791 relative to the adopted coordinate system. The corner positions\n\
8792 are specified by the appropriate combination of two of the\n\
8793 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8794 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8795 value of one of those bits. The adopted coordinates are\n\
8796 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8797 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8798 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8799 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8800 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
8801 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
8802 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
8803 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
8805 x (PLFLT, input) : X offset of the legend position in adopted\n\
8806 coordinates from the specified standard position of the legend.\n\
8807 For positive x, the direction of motion away from the standard\n\
8808 position is inward/outward from the standard corner positions or\n\
8809 standard left or right positions if the\n\
8810 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8811 For the standard top or bottom positions, the direction of motion\n\
8812 is toward positive X.\n\
8814 y (PLFLT, input) : Y offset of the legend position in adopted\n\
8815 coordinates from the specified standard position of the legend.\n\
8816 For positive y, the direction of motion away from the standard\n\
8817 position is inward/outward from the standard corner positions or\n\
8818 standard top or bottom positions if the\n\
8819 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
8820 the standard left or right positions, the direction of motion is\n\
8821 toward positive Y.\n\
8823 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
8824 of the plot area (where the colored boxes, lines, and/or lines of\n\
8825 symbols are drawn) of the legend.\n\
8827 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8828 legend (PL_LEGEND_BACKGROUND).\n\
8830 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8831 for the legend (PL_LEGEND_BOUNDING_BOX).\n\
8833 bb_style (PLINT, input) : The pllsty style number for the\n\
8834 bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
8836 nrow (PLINT, input) : The number of rows in the matrix used to\n\
8838 nlegend legend entries. For internal transformations of\n\
8839 nrow, see further remarks under\n\
8842 ncolumn (PLINT, input) : The number of columns in the matrix used\n\
8844 nlegend legend entries. For internal transformations of\n\
8845 ncolumn, see further remarks under\n\
8848 nlegend (PLINT, input) : Number of legend entries. The above\n\
8850 ncolumn values are transformed internally to be consistent with\n\
8851 nlegend. If either\n\
8853 ncolumn is non-positive it is replaced by 1. If the resulting product\n\
8856 ncolumn is less than\n\
8857 nlegend, the smaller of the two (or\n\
8860 ncolumn) is increased so the product is >=\n\
8861 nlegend. Thus, for example, the common\n\
8863 ncolumn = 0 case is transformed internally to\n\
8866 ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
8869 opt_array (PLINT_VECTOR, input) : A vector of\n\
8870 nlegend values of options to control each individual plotted area\n\
8871 corresponding to a legend entry. If the\n\
8872 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
8874 PL_LEGEND_COLOR_BOX,\n\
8875 PL_LEGEND_LINE, and/or\n\
8876 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
8877 entry is plotted with a colored box; a line; and/or a line of\n\
8880 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
8881 area in units of character width.\n\
8883 text_scale (PLFLT, input) : Character height scale for text\n\
8886 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
8887 character height from one legend entry to the next.\n\
8889 text_justification (PLFLT, input) : Justification parameter used\n\
8890 for text justification. The most common values of\n\
8891 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
8892 is left justified, centred, or right justified within the text\n\
8893 area, but other values are allowed as well.\n\
8895 text_colors (PLINT_VECTOR, input) : A vector containing\n\
8896 nlegend cmap0 text colors.\n\
8898 text (PLCHAR_MATRIX, input) : A vector of\n\
8899 nlegend UTF-8 character strings containing the legend annotations.\n\
8901 box_colors (PLINT_VECTOR, input) : A vector containing\n\
8902 nlegend cmap0 colors for the discrete colored boxes (\n\
8903 PL_LEGEND_COLOR_BOX).\n\
8905 box_patterns (PLINT_VECTOR, input) : A vector containing\n\
8906 nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
8907 PL_LEGEND_COLOR_BOX).\n\
8909 box_scales (PLFLT_VECTOR, input) : A vector containing\n\
8910 nlegend scales (units of fraction of character height) for the height\n\
8911 of the discrete colored boxes (\n\
8912 PL_LEGEND_COLOR_BOX).\n\
8914 box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8915 nlegend line widths for the patterns specified by box_patterns (\n\
8916 PL_LEGEND_COLOR_BOX).\n\
8918 line_colors (PLINT_VECTOR, input) : A vector containing\n\
8919 nlegend cmap0 line colors (\n\
8922 line_styles (PLINT_VECTOR, input) : A vector containing\n\
8923 nlegend line styles (plsty indices) (\n\
8926 line_widths (PLFLT_VECTOR, input) : A vector containing\n\
8927 nlegend line widths (\n\
8930 symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
8931 nlegend cmap0 symbol colors (\n\
8932 PL_LEGEND_SYMBOL).\n\
8934 symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
8935 nlegend scale values for the symbol height (\n\
8936 PL_LEGEND_SYMBOL).\n\
8938 symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
8939 nlegend numbers of symbols to be drawn across the width of the plotted\n\
8941 PL_LEGEND_SYMBOL).\n\
8943 symbols (PLCHAR_MATRIX, input) : A vector of\n\
8944 nlegend UTF-8 character strings containing the legend symbols. (\n\
8945 PL_LEGEND_SYMBOL).\n\
8948Set the background color by 8-bit RGB value\n\
8952 Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
8953 the PLplot documentation).\n\
8955 Redacted form: plscolbg(r, g, b)\n\
8957 This function is used in examples 15 and 31.\n\
8967 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8968 degree of red in the color.\n\
8970 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8971 degree of green in the color.\n\
8973 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
8974 degree of blue in the color.\n\
8977Set parameters that define current device-space window\n\
8981 Set relative margin width, aspect ratio, and relative justification\n\
8982 that define current device-space window. If you want to just use the\n\
8983 previous value for any of these, just pass in the magic value\n\
8984 PL_NOTSET. It is unlikely that one should ever need to change the\n\
8985 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
8986 called the default values of mar, jx, and jy are all 0. aspect is set\n\
8987 to a device-specific value.\n\
8989 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
8991 This function is used in example 31.\n\
8997plsdidev(mar, aspect, jx, jy)\n\
9001 mar (PLFLT, input) : Relative margin width.\n\
9003 aspect (PLFLT, input) : Aspect ratio.\n\
9005 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
9006 the range -0.5 to 0.5.\n\
9008 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
9009 the range -0.5 to 0.5.\n\
9012Specify viewport using aspect ratio only\n\
9016 Selects the largest viewport with the given aspect ratio within the\n\
9017 subpage that leaves a standard margin (left-hand margin of eight\n\
9018 character heights, and a margin around the other three sides of five\n\
9019 character heights).\n\
9021 Redacted form: plvasp(aspect)\n\
9023 This function is used in example 13.\n\
9033 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
9034 axis of resulting viewport.\n\
9037Configure the transformations required for projecting a 3D surface on a 2D window\n\
9041 Configure the transformations required for projecting a 3D surface on\n\
9042 an existing 2D window. Those transformations (see the PLplot\n\
9043 documentation) are done to a rectangular cuboid enclosing the 3D\n\
9044 surface which has its limits expressed in 3D world coordinates and\n\
9045 also normalized 3D coordinates (used for interpreting the altitude and\n\
9046 azimuth of the viewing angle). The transformations consist of the\n\
9047 linear transform from 3D world coordinates to normalized 3D\n\
9048 coordinates, and the 3D rotation of normalized coordinates required to\n\
9049 align the pole of the new 3D coordinate system with the viewing\n\
9050 direction specified by altitude and azimuth so that x and y of the\n\
9051 surface elements in that transformed coordinate system are the\n\
9052 projection of the 3D surface with given viewing direction on the 2D\n\
9055 The enclosing rectangular cuboid for the surface plot is defined by\n\
9056 xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
9057 mapped into the same rectangular cuboid with normalized 3D coordinate\n\
9058 sizes of basex by basey by height so that xmin maps to -\n\
9059 basex/2, xmax maps to basex/2, ymin maps to -\n\
9060 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
9061 The resulting rectangular cuboid in normalized coordinates is then\n\
9062 viewed by an observer at altitude alt and azimuth az. This routine\n\
9063 must be called before plbox3 or any of the 3D surface plotting\n\
9064 routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
9065 plsurf3dl or plfill3.\n\
9067 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
9068 zmin, zmax, alt, az)\n\
9070 This function is examples 8, 11, 18, and 21.\n\
9076plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
9080 basex (PLFLT, input) : The normalized x coordinate size of the\n\
9081 rectangular cuboid.\n\
9083 basey (PLFLT, input) : The normalized y coordinate size of the\n\
9084 rectangular cuboid.\n\
9086 height (PLFLT, input) : The normalized z coordinate size of the\n\
9087 rectangular cuboid.\n\
9089 xmin (PLFLT, input) : The minimum x world coordinate of the\n\
9090 rectangular cuboid.\n\
9092 xmax (PLFLT, input) : The maximum x world coordinate of the\n\
9093 rectangular cuboid.\n\
9095 ymin (PLFLT, input) : The minimum y world coordinate of the\n\
9096 rectangular cuboid.\n\
9098 ymax (PLFLT, input) : The maximum y world coordinate of the\n\
9099 rectangular cuboid.\n\
9101 zmin (PLFLT, input) : The minimum z world coordinate of the\n\
9102 rectangular cuboid.\n\
9104 zmax (PLFLT, input) : The maximum z world coordinate of the\n\
9105 rectangular cuboid.\n\
9107 alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
9108 plane of the rectangular cuboid in normalized coordinates.\n\
9110 az (PLFLT, input) : The viewing azimuth in degrees of the\n\
9111 rectangular cuboid in normalized coordinates. When az=0, the\n\
9112 observer is looking face onto the zx plane of the rectangular\n\
9113 cuboid in normalized coordinates, and as az is increased, the\n\
9114 observer moves clockwise around that cuboid when viewed from above\n\
9118Wait for graphics input event and translate to world coordinates.\n\
9122 Wait for graphics input event and translate to world coordinates.\n\
9123 Returns 0 if no translation to world coordinates is possible.\n\
9125 This function returns 1 on success and 0 if no translation to world\n\
9126 coordinates is possible.\n\
9128 Redacted form: plGetCursor(gin)\n\
9130 This function is used in examples 1 and 20.\n\
9136PLINT plGetCursor(gin)\n\
9140 gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
9141 which will contain the output. The structure is not allocated by\n\
9142 the routine and must exist before the function is called.\n\
9145Set number of colors in cmap0\n\
9149 Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9150 (or reallocate) cmap0, and fill with default values for those colors\n\
9151 not previously allocated. The first 16 default colors are given in\n\
9152 the plcol0 documentation. For larger indices the default color is\n\
9155 The drivers are not guaranteed to support more than 16 colors.\n\
9157 Redacted form: plscmap0n(ncol0)\n\
9159 This function is used in examples 15, 16, and 24.\n\
9169 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9170 the cmap0 palette. If this number is zero or less, then the value\n\
9171 from the previous call to plscmap0n is used and if there is no\n\
9172 previous call, then a default value is used.\n\
9175Set z axis parameters\n\
9179 Identical to plsxax, except that arguments are flags for z axis. See\n\
9180 the description of plsxax for more detail.\n\
9182 Redacted form: plszax(digmax, digits)\n\
9184 This function is used in example 31.\n\
9190plszax(digmax, digits)\n\
9194 digmax (PLINT, input) : Variable to set the maximum number of\n\
9195 digits for the z axis. If nonzero, the printed label will be\n\
9196 switched to a floating-point representation when the number of\n\
9197 digits exceeds digmax.\n\
9199 digits (PLINT, input) : Field digits value. Currently, changing\n\
9200 its value here has no effect since it is set only by plbox or\n\
9201 plbox3. However, the user may obtain its value after a call to\n\
9202 either of these functions by calling plgzax.\n\
9205Get FCI (font characterization integer)\n\
9209 Gets information about the current font using the FCI approach. See\n\
9210 the PLplot documentation for more information.\n\
9212 Redacted form: plgfci(p_fci)\n\
9214 This function is used in example 23.\n\
9224 p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
9228Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
9232 Sets up plotter environment for simple graphs by calling pladv and\n\
9233 setting up viewport and window to sensible default values. plenv0\n\
9234 leaves a standard margin (left-hand margin of eight character heights,\n\
9235 and a margin around the other three sides of five character heights)\n\
9236 around most graphs for axis labels and a title. When these defaults\n\
9237 are not suitable, use the individual routines plvpas, plvpor, or\n\
9238 plvasp for setting up the viewport, plwind for defining the window,\n\
9239 and plbox for drawing the box.\n\
9241 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9243 This function is used in example 21.\n\
9249plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
9253 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
9254 world coordinates).\n\
9256 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
9257 world coordinates).\n\
9259 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
9262 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
9265 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
9266 scales will not be set, the user must set up the scale before\n\
9267 calling plenv0 using plsvpa, plvasp or other.\n\
9268 0: the x and y axes are scaled independently to use as much of\n\
9269 the screen as possible.\n\
9270 1: the scales of the x and y axes are made equal.\n\
9271 2: the axis of the x and y axes are made equal, and the plot\n\
9272 box will be square.\n\
9275 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
9276 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
9277 -1: draw box only.\n\
9278 0: draw box, ticks, and numeric tick labels.\n\
9279 1: also draw coordinate axes at x=0 and y=0.\n\
9280 2: also draw a grid at major tick positions in both\n\
9282 3: also draw a grid at minor tick positions in both\n\
9284 10: same as 0 except logarithmic x tick marks. (The x data\n\
9285 have to be converted to logarithms separately.)\n\
9286 11: same as 1 except logarithmic x tick marks. (The x data\n\
9287 have to be converted to logarithms separately.)\n\
9288 12: same as 2 except logarithmic x tick marks. (The x data\n\
9289 have to be converted to logarithms separately.)\n\
9290 13: same as 3 except logarithmic x tick marks. (The x data\n\
9291 have to be converted to logarithms separately.)\n\
9292 20: same as 0 except logarithmic y tick marks. (The y data\n\
9293 have to be converted to logarithms separately.)\n\
9294 21: same as 1 except logarithmic y tick marks. (The y data\n\
9295 have to be converted to logarithms separately.)\n\
9296 22: same as 2 except logarithmic y tick marks. (The y data\n\
9297 have to be converted to logarithms separately.)\n\
9298 23: same as 3 except logarithmic y tick marks. (The y data\n\
9299 have to be converted to logarithms separately.)\n\
9300 30: same as 0 except logarithmic x and y tick marks. (The x\n\
9301 and y data have to be converted to logarithms separately.)\n\
9302 31: same as 1 except logarithmic x and y tick marks. (The x\n\
9303 and y data have to be converted to logarithms separately.)\n\
9304 32: same as 2 except logarithmic x and y tick marks. (The x\n\
9305 and y data have to be converted to logarithms separately.)\n\
9306 33: same as 3 except logarithmic x and y tick marks. (The x\n\
9307 and y data have to be converted to logarithms separately.)\n\
9308 40: same as 0 except date / time x labels.\n\
9309 41: same as 1 except date / time x labels.\n\
9310 42: same as 2 except date / time x labels.\n\
9311 43: same as 3 except date / time x labels.\n\
9312 50: same as 0 except date / time y labels.\n\
9313 51: same as 1 except date / time y labels.\n\
9314 52: same as 2 except date / time y labels.\n\
9315 53: same as 3 except date / time y labels.\n\
9316 60: same as 0 except date / time x and y labels.\n\
9317 61: same as 1 except date / time x and y labels.\n\
9318 62: same as 2 except date / time x and y labels.\n\
9319 63: same as 3 except date / time x and y labels.\n\
9320 70: same as 0 except custom x and y labels.\n\
9321 71: same as 1 except custom x and y labels.\n\
9322 72: same as 2 except custom x and y labels.\n\
9323 73: same as 3 except custom x and y labels.\n\
9330 This sets up the size of all subsequent symbols drawn by plpoin and\n\
9331 plsym. The actual height of a symbol is the product of the default\n\
9332 symbol size and a scaling factor as for the character height.\n\
9334 Redacted form: plssym(def, scale)\n\
9336 This function is used in example 29.\n\
9342plssym(def, scale)\n\
9346 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
9347 should be set to zero if the default height is to remain\n\
9350 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9351 actual symbol height.\n\
9354Set plot orientation\n\
9358 Set plot orientation parameter which is multiplied by 90 degrees to\n\
9359 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
9360 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
9361 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
9362 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
9363 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
9364 not called the default value of rot is 0.\n\
9366 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
9367 probably want to change the aspect ratio to a value suitable for the\n\
9368 plot orientation using a call to plsdidev or the command-line options\n\
9369 -a or -freeaspect. For more documentation of those options see the\n\
9370 PLplot documentation. Such command-line options can be set internally\n\
9371 using plsetopt or set directly using the command line and parsed using\n\
9372 a call to plparseopts.\n\
9374 Redacted form: plsdiori(rot)\n\
9376 This function is not used in any examples.\n\
9386 rot (PLFLT, input) : Plot orientation parameter.\n\
9389Advance the (sub-)page\n\
9393 Advances to the next subpage if sub=0, performing a page advance if\n\
9394 there are no remaining subpages on the current page. If subpages\n\
9395 aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
9396 PLplot switches to the specified subpage. Note that this allows you\n\
9397 to overwrite a plot on the specified subpage; if this is not what you\n\
9398 intended, use pleop followed by plbop to first advance the page. This\n\
9399 routine is called automatically (with page=0) by plenv, but if plenv\n\
9400 is not used, pladv must be called after initializing PLplot but before\n\
9401 defining the viewport.\n\
9403 Redacted form: pladv(page)\n\
9405 This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
9416 page (PLINT, input) : Specifies the subpage number (starting from 1\n\
9417 in the top left corner and increasing along the rows) to which to\n\
9418 advance. Set to zero to advance to the next subpage (or to the\n\
9419 next page if subpages are not being used).\n\
9422Set cmap0 colors by 8-bit RGB values\n\
9426 Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
9427 documentation). This sets the entire color map -- only as many colors\n\
9428 as specified will be allocated.\n\
9430 Redacted form: plscmap0(r, g, b)\n\
9432 This function is used in examples 2 and 24.\n\
9438plscmap0(r, g, b, ncol0)\n\
9442 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9443 integers (0-255) representing the degree of red in the color.\n\
9445 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9446 integers (0-255) representing the degree of green in the color.\n\
9448 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9449 integers (0-255) representing the degree of blue in the color.\n\
9451 ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9454Get character default height and current (scaled) height\n\
9458 Get character default height and current (scaled) height.\n\
9460 Redacted form: plgchr(p_def, p_ht)\n\
9462 This function is used in example 23.\n\
9468plgchr(p_def, p_ht)\n\
9472 p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
9473 character height (mm).\n\
9475 p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
9476 character height (mm).\n\
9479Set opaque RGB cmap1 colors values\n\
9483 Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
9484 vector values. This function also sets the number of cmap1 colors.\n\
9485 N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
9486 in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
9487 plcol1) to an integer index of these RGB vectors in the range from 0\n\
9489 ncol1-1. So in order for this continuous color model to work\n\
9490 properly, it is the responsibility of the user of plscmap1 to insure\n\
9491 that these RGB vectors are continuous functions of their integer\n\
9494 Redacted form: plscmap1(r, g, b)\n\
9496 This function is used in example 31.\n\
9502plscmap1(r, g, b, ncol1)\n\
9506 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9507 8-bit integers in the range from 0-255) the degree of red in the\n\
9508 color as a continuous function of the integer index of the vector.\n\
9510 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9511 8-bit integers in the range from 0-255) the degree of green in the\n\
9512 color as a continuous function of the integer index of the vector.\n\
9514 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9515 8-bit integers in the range from 0-255) the degree of blue in the\n\
9516 color as a continuous function of the integer index of the vector.\n\
9518 ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
9521Set any command-line option\n\
9525 Set any command-line option internally from a program before it\n\
9526 invokes plinit. opt is the name of the command-line option and optarg\n\
9527 is the corresponding command-line option argument.\n\
9529 This function returns 0 on success.\n\
9531 Redacted form: plsetopt(opt, optarg)\n\
9533 This function is used in example 14.\n\
9539PLINT plsetopt(opt, optarg)\n\
9543 opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9544 the command-line option.\n\
9546 optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
9547 containing the argument of the command-line option.\n\
9550Draw linear gradient inside polygon\n\
9554 Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
9557 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
9558 polygon coordinates and the gradient angle are all expressed in world\n\
9559 coordinates. The angle from the x axis for both the rotated\n\
9560 coordinate system and the gradient vector is specified by angle. The\n\
9561 magnitude of the gradient vector is the difference between the maximum\n\
9562 and minimum values of x for the vertices in the rotated coordinate\n\
9563 system. The origin of the gradient vector can be interpreted as being\n\
9564 anywhere on the line corresponding to the minimum x value for the\n\
9565 vertices in the rotated coordinate system. The distance along the\n\
9566 gradient vector is linearly transformed to the independent variable of\n\
9567 color map 1 which ranges from 0. at the tail of the gradient vector to\n\
9568 1. at the head of the gradient vector. What is drawn is the RGBA\n\
9569 color corresponding to the independent variable of cmap1. For more\n\
9570 information about cmap1 (see the PLplot documentation).\n\
9572 Redacted form: plgradient(x,y,angle)\n\
9574 This function is used in examples 25 and 30.\n\
9580plgradient(n, x, y, angle)\n\
9584 n (PLINT, input) : Number of vertices in polygon.\n\
9586 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9589 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9592 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
9596Set length of major ticks\n\
9600 This sets up the length of the major ticks. The actual length is the\n\
9601 product of the default length and a scaling factor as for character\n\
9604 Redacted form: plsmaj(def, scale)\n\
9606 This function is used in example 29.\n\
9612plsmaj(def, scale)\n\
9616 def (PLFLT, input) : The default length of a major tick in\n\
9617 millimeters, should be set to zero if the default length is to\n\
9618 remain unchanged.\n\
9620 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
9621 actual tick length.\n\
9624Set a global coordinate transform function\n\
9628 This function can be used to define a coordinate transformation which\n\
9629 affects all elements drawn within the current plot window. The\n\
9630 coordinate_transform callback function is similar to that provided for\n\
9631 the plmap and plmeridians functions. The coordinate_transform_data\n\
9632 parameter may be used to pass extra data to coordinate_transform.\n\
9634 Redacted form: General: plstransform(coordinate_transform,\n\
9635 coordinate_transform_data)\n\
9638 This function is used in examples 19 and 22.\n\
9644plstransform(coordinate_transform, coordinate_transform_data)\n\
9648 coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
9649 function that defines the transformation from the input (x, y)\n\
9650 world coordinates to new PLplot world coordinates. If\n\
9651 coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
9652 case), then no transform is applied.\n\
9654 coordinate_transform_data (PLPointer, input) : Optional extra data\n\
9656 coordinate_transform.\n\
9659Configure the transformation between continuous and broken-down time for the current stream\n\
9663 Configure the transformation between continuous and broken-down time\n\
9664 for the current stream. This transformation is used by both plbtime\n\
9667 Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
9668 ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9671 This function is used in example 29.\n\
9677plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
9681 scale (PLFLT, input) : The number of days per continuous time unit.\n\
9682 As a special case, if\n\
9683 scale is 0., then all other arguments are ignored, and the result (the\n\
9684 default used by PLplot) is the equivalent of a call to\n\
9685 plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
9686 That is, for this special case broken-down time is calculated with\n\
9687 the proleptic Gregorian calendar with no leap seconds inserted,\n\
9688 and the continuous time is defined as the number of seconds since\n\
9689 the Unix epoch of 1970-01-01T00:00:00Z.\n\
9691 offset1 (PLFLT, input) : If\n\
9692 ifbtime_offset is true, the parameters\n\
9694 offset2 are completely ignored. Otherwise, the sum of these parameters\n\
9695 (with units in days) specify the epoch of the continuous time\n\
9696 relative to the MJD epoch corresponding to the Gregorian calendar\n\
9697 date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
9698 are used to specify the origin to allow users (by specifying\n\
9699 offset1 as an integer that can be exactly represented by a\n\
9700 floating-point variable and specifying\n\
9701 offset2 as a number in the range from 0. to 1) the chance to minimize\n\
9702 the numerical errors of the continuous time representation.\n\
9704 offset2 (PLFLT, input) : See documentation of\n\
9707 ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
9708 transformation. If the 0x1 bit is set, then the proleptic Julian\n\
9709 calendar is used for broken-down time rather than the proleptic\n\
9710 Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
9711 have been historically used to define UTC are inserted into the\n\
9712 broken-down time. Other possibilities for additional control bits\n\
9713 for ccontrol exist such as making the historical time corrections\n\
9714 in the broken-down time corresponding to ET (ephemeris time) or\n\
9715 making the (slightly non-constant) corrections from international\n\
9716 atomic time (TAI) to what astronomers define as terrestrial time\n\
9717 (TT). But those additional possibilities have not been\n\
9718 implemented yet in the qsastime library (one of the PLplot utility\n\
9721 ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
9722 epoch of the continuous time scale is specified by the user. If\n\
9723 ifbtime_offset is false, then\n\
9725 offset2 are used to specify the epoch, and the following broken-down\n\
9726 time parameters are completely ignored. If\n\
9727 ifbtime_offset is true, then\n\
9729 offset2 are completely ignored, and the following broken-down time\n\
9730 parameters are used to specify the epoch.\n\
9732 year (PLINT, input) : Year of epoch.\n\
9734 month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
9737 day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
9739 hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
9741 min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
9743 sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
9746Flushes the output stream\n\
9750 Flushes the output stream. Use sparingly, if at all.\n\
9752 Redacted form: plflush()\n\
9754 This function is used in examples 1 and 14.\n\
9763Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
9767 This variant of plsurf3d (see that function\'s documentation for more\n\
9768 details) should be suitable for the case where the area of the x, y\n\
9769 coordinate grid where z is defined can be non-rectangular. The limits\n\
9770 of that grid are provided by the parameters indexxmin, indexxmax,\n\
9771 indexymin, and indexymax.\n\
9773 Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
9776 This function is used in example 8.\n\
9782plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
9786 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
9787 which the function is evaluated.\n\
9789 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
9790 which the function is evaluated.\n\
9792 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
9793 plot. Should have dimensions of\n\
9797 nx (PLINT, input) : Number of x values at which function is\n\
9800 ny (PLINT, input) : Number of y values at which function is\n\
9803 opt (PLINT, input) : Determines the way in which the surface is\n\
9804 represented. To specify more than one option just add the options,\n\
9805 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
9806 connecting points at which function is defined.\n\
9807 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
9811 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
9815 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
9816 the borders of the plotted function.\n\
9817 opt=MAG_COLOR : the surface is colored according to the value\n\
9818 of Z; if MAG_COLOR is not used, then the surface is colored\n\
9819 according to the intensity of the reflected light in the\n\
9820 surface from a light source whose position is set using\n\
9824 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
9827 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
9829 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
9830 corresponds to the first x index where z is defined.\n\
9832 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
9833 which corresponds (by convention) to one more than the last x\n\
9834 index value where z is defined.\n\
9836 indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
9837 values which all must be ≥ 0. These values are the first y index\n\
9838 where z is defined for a particular x index in the range from\n\
9839 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
9842 indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
9843 values which all must be ≤ ny. These values correspond (by\n\
9844 convention) to one more than the last y index where z is defined\n\
9845 for a particular x index in the range from indexxmin to indexxmax\n\
9846 - 1. The dimension of indexymax is indexxmax.\n\
9849Set semitransparent cmap1 RGBA colors.\n\
9853 Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
9854 RGBA vector values. This function also sets the number of cmap1\n\
9855 colors. N.B. Continuous cmap1 colors are indexed with a\n\
9856 floating-point index in the range from 0.0-1.0 which is linearly\n\
9857 transformed (e.g., by plcol1) to an integer index of these RGBA\n\
9858 vectors in the range from 0 to\n\
9859 ncol1-1. So in order for this continuous color model to work\n\
9860 properly, it is the responsibility of the user of plscmap1 to insure\n\
9861 that these RGBA vectors are continuous functions of their integer\n\
9864 Redacted form: plscmap1a(r, g, b, alpha)\n\
9866 This function is used in example 31.\n\
9872plscmap1a(r, g, b, alpha, ncol1)\n\
9876 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9877 8-bit integers in the range from 0-255) the degree of red in the\n\
9878 color as a continuous function of the integer index of the vector.\n\
9880 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9881 8-bit integers in the range from 0-255) the degree of green in the\n\
9882 color as a continuous function of the integer index of the vector.\n\
9884 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
9885 8-bit integers in the range from 0-255) the degree of blue in the\n\
9886 color as a continuous function of the integer index of the vector.\n\
9888 alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
9889 values in the range from 0.0-1.0 where 0.0 corresponds to\n\
9890 completely transparent and 1.0 corresponds to completely opaque)\n\
9891 the alpha transparency of the color as a continuous function of\n\
9892 the integer index of the vector.\n\
9894 ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9898Calculate broken-down time from continuous time for the current stream\n\
9902 Calculate broken-down time; year, month, day, hour, min, sec; from\n\
9903 continuous time, ctime for the current stream. This function is the\n\
9904 inverse of plctime.\n\
9906 The PLplot definition of broken-down time is a calendar time that\n\
9907 completely ignores all time zone offsets, i.e., it is the user\'s\n\
9908 responsibility to apply those offsets (if so desired) before using the\n\
9909 PLplot time API. By default broken-down time is defined using the\n\
9910 proleptic Gregorian calendar without the insertion of leap seconds and\n\
9911 continuous time is defined as the number of seconds since the Unix\n\
9912 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
9913 broken-down and continuous time are possible, see plconfigtime.\n\
9915 Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
9919 This function is used in example 29.\n\
9925plbtime(year, month, day, hour, min, sec, ctime)\n\
9929 year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
9930 positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
9931 non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
9934 month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
9935 the year in the range from 0 (January) to 11 (December).\n\
9937 day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
9938 month in the range from 1 to 31.\n\
9940 hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
9941 day in the range from 0 to 23.\n\
9943 min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
9944 hour in the range from 0 to 59\n\
9946 sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
9947 minute in range from 0. to 60.\n\
9949 ctime (PLFLT, input) : Continuous time from which the broken-down\n\
9950 time is calculated.\n\
9953Convert RGB color to HLS\n\
9957 Convert RGB color coordinates to HLS\n\
9959 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9962 This function is used in example 2.\n\
9968plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9972 r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9974 g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9976 b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9978 p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9979 degrees (0.0-360.0) on the color cylinder.\n\
9981 p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9982 expressed as a fraction (0.0-1.0) of the axis of the color\n\
9985 p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9986 expressed as a fraction (0.0-1.0) of the radius of the color\n\
9990Get the current device (keyword) name\n\
9994 Get the current device (keyword) name. Note: you must have allocated\n\
9995 space for this (80 characters is safe).\n\
9997 Redacted form: plgdev(p_dev)\n\
9999 This function is used in example 14.\n\
10009 p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
10010 (with preallocated length of 80 characters or more) containing the\n\
10011 device (keyword) name.\n\
10014Set the number of subpages in x and y\n\
10018 Set the number of subpages in x and y.\n\
10020 Redacted form: plssub(nx, ny)\n\
10022 This function is examples 1,2,14,21,25,27.\n\
10032 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
10033 of window columns).\n\
10035 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
10036 of window rows).\n\
10039Get current stream number\n\
10043 Gets the number of the current output stream. See also plsstrm.\n\
10045 Redacted form: plgstrm(p_strm)\n\
10047 This function is used in example 1,20.\n\
10057 p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10061Random number generator returning a real random number in the range [0,1]\n\
10065 Random number generator returning a real random number in the range\n\
10066 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
10067 / compilers provide their own random number generator, and so this is\n\
10068 provided purely for convenience and to give a consistent random number\n\
10069 generator across all languages supported by PLplot. This is\n\
10070 particularly useful for comparing results from the test suite of\n\
10073 Redacted form: plrandd()\n\
10075 This function is used in examples 17 and 21.\n\
10084Add a point to a strip chart\n\
10088 Add a point to a given pen of a given strip chart. There is no need\n\
10089 for all pens to have the same number of points or to be equally\n\
10090 sampled in the x coordinate. Allocates memory and rescales as\n\
10093 Redacted form: plstripa(id, pen, x, y)\n\
10095 This function is used in example 17.\n\
10101plstripa(id, pen, x, y)\n\
10105 id (PLINT, input) : Identification number of the strip chart (set\n\
10106 up in plstripc).\n\
10108 pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
10110 x (PLFLT, input) : X coordinate of point to plot.\n\
10112 y (PLFLT, input) : Y coordinate of point to plot.\n\
10115Set device-compression level\n\
10119 Set device-compression level. Only used for drivers that provide\n\
10120 compression. This function, if used, should be invoked before a call\n\
10123 Redacted form: plscompression(compression)\n\
10125 This function is used in example 31.\n\
10131plscompression(compression)\n\
10135 compression (PLINT, input) : The desired compression level. This is\n\
10136 a device-dependent value. Currently only the jpeg and png devices\n\
10137 use these values. For jpeg value is the jpeg quality which should\n\
10138 normally be in the range 0-95. Higher values denote higher quality\n\
10139 and hence larger image sizes. For png values are in the range -1\n\
10140 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
10141 A value of -1 denotes the default zlib compression level. Values\n\
10142 in the range 10-99 are divided by 10 and then used as the zlib\n\
10143 compression level. Higher compression levels correspond to greater\n\
10144 compression and small file sizes at the expense of more\n\
10148Specify viewport in absolute coordinates\n\
10152 Alternate routine to plvpor for setting up the viewport. This routine\n\
10153 should be used only if the viewport is required to have a definite\n\
10154 size in millimeters. The routine plgspa is useful for finding out the\n\
10155 size of the current subpage.\n\
10157 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
10159 This function is used in example 10.\n\
10165plsvpa(xmin, xmax, ymin, ymax)\n\
10169 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
10170 viewport from the left-hand edge of the subpage in millimeters.\n\
10172 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
10173 viewport from the left-hand edge of the subpage in millimeters.\n\
10175 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
10176 viewport from the bottom edge of the subpage in millimeters.\n\
10178 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
10179 from the bottom edge of the subpage in millimeters.\n\
10182Draw a polygon in 3 space\n\
10186 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10187 like plline3, but differs from that function in that plpoly3 attempts\n\
10188 to determine if the polygon is viewable depending on the order of the\n\
10189 points within the vector and the value of ifcc. If the back of\n\
10190 polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10191 you want, then use plline3 instead.\n\
10193 The points are assumed to be in a plane, and the directionality of the\n\
10194 plane is determined from the first three points. Additional points do\n\
10195 not have to lie on the plane defined by the first three, but if they\n\
10196 do not, then the determination of visibility obviously can\'t be 100%\n\
10197 accurate... So if you\'re 3 space polygons are too far from planar,\n\
10198 consider breaking them into smaller polygons. 3 points define a plane\n\
10201 Bugs: If one of the first two segments is of zero length, or if they\n\
10202 are co-linear, the calculation of visibility has a 50/50 chance of\n\
10203 being correct. Avoid such situations :-). See x18c.c for an example\n\
10204 of this problem. (Search for 20.1).\n\
10206 Redacted form: plpoly3(x, y, z, code)\n\
10208 This function is used in example 18.\n\
10214plpoly3(n, x, y, z, draw, ifcc)\n\
10218 n (PLINT, input) : Number of points defining line.\n\
10220 x (PLFLT_VECTOR, input) : A vector containing\n\
10221 n x coordinates of points.\n\
10223 y (PLFLT_VECTOR, input) : A vector containing\n\
10224 n y coordinates of points.\n\
10226 z (PLFLT_VECTOR, input) : A vector containing\n\
10227 n z coordinates of points.\n\
10229 draw (PLBOOL_VECTOR, input) : A vector containing\n\
10230 n-1 Boolean values which control drawing the segments of the polygon.\n\
10231 If draw[i] is true, then the polygon segment from index [i] to\n\
10232 [i+1] is drawn, otherwise, not.\n\
10234 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10235 polygon is determined by assuming the points are laid out in a\n\
10236 counter-clockwise order. Otherwise, the directionality of the\n\
10237 polygon is determined by assuming the points are laid out in a\n\
10238 clockwise order.\n\
10241Magnitude colored plot surface with contour\n\
10245 Aside from dropping the\n\
10246 side functionality this is a more powerful form of plot3d: the surface\n\
10247 mesh can be colored accordingly to the current z value being plotted,\n\
10248 a contour plot can be drawn at the base XY plane, and a curtain can be\n\
10249 drawn between the plotted function border and the base XY plane. The\n\
10250 arguments are identical to those of plmeshc. The only difference\n\
10251 between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
10252 the surface, while plot3dc only draws the surface as viewed from the\n\
10255 Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
10258 This function is used in example 21.\n\
10264plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
10268 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
10269 which the function is evaluated.\n\
10271 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
10272 which the function is evaluated.\n\
10274 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10275 plot. Should have dimensions of\n\
10279 nx (PLINT, input) : Number of x values at which function is\n\
10282 ny (PLINT, input) : Number of y values at which function is\n\
10285 opt (PLINT, input) : Determines the way in which the surface is\n\
10286 represented. To specify more than one option just add the options,\n\
10287 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
10288 showing z as a function of x for each value of y[j] .\n\
10289 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
10290 for each value of x[i] .\n\
10291 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
10292 at which function is defined.\n\
10293 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
10294 the z value being plotted. The color is used from the current\n\
10296 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
10297 using parameters\n\
10300 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
10301 the borders of the plotted function.\n\
10304 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
10307 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
10310Create a 4-pen strip chart\n\
10314 Create a 4-pen strip chart, to be used afterwards by plstripa\n\
10316 Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
10317 ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
10318 styline, legline, labx, laby, labz)\n\
10321 This function is used in example 17.\n\
10327plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
10331 id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
10332 number of the strip chart to use on plstripa and plstripd.\n\
10334 xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10335 the x-axis specification as in plbox.\n\
10337 yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
10338 the y-axis specification as in plbox.\n\
10340 xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10341 change as data are added.\n\
10343 xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10344 change as data are added.\n\
10346 xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
10347 is multiplied by the factor (1 +\n\
10350 ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
10351 change as data are added.\n\
10353 ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
10354 change as data are added.\n\
10356 xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
10358 ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
10360 y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
10361 true, otherwise not.\n\
10363 acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
10364 otherwise slide display.\n\
10366 colbox (PLINT, input) : Plot box color index (cmap0).\n\
10368 collab (PLINT, input) : Legend color index (cmap0).\n\
10370 colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
10371 indices for the 4 pens.\n\
10373 styline (PLINT_VECTOR, input) : A vector containing the line style\n\
10374 indices for the 4 pens.\n\
10376 legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
10377 strings containing legends for the 4 pens.\n\
10379 labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10380 the label for the x axis.\n\
10382 laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10383 the label for the y axis.\n\
10385 labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
10389Deletes and releases memory used by a strip chart\n\
10393 Deletes and releases memory used by a strip chart.\n\
10395 Redacted form: plstripd(id)\n\
10397 This function is used in example 17.\n\
10407 id (PLINT, input) : Identification number of strip chart to delete.\n\
10410Set cmap1 colors using a piece-wise linear relationship\n\
10414 Set cmap1 colors using a piece-wise linear relationship between the\n\
10415 cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
10416 (see the PLplot documentation). May be called at any time.\n\
10418 The idea here is to specify a number of control points that define the\n\
10419 mapping between input cmap1 intensity indices and HLS or RGB. Between\n\
10420 these points, linear interpolation is used which gives a smooth\n\
10421 variation of color with intensity index. Any number of control points\n\
10422 may be specified, located at arbitrary positions, although typically 2\n\
10423 - 4 are enough. Another way of stating this is that we are traversing\n\
10424 a given number of lines through HLS or RGB space as we move through\n\
10425 cmap1 intensity indices. The control points at the minimum and\n\
10426 maximum position (0 and 1) must always be specified. By adding more\n\
10427 control points you can get more variation. One good technique for\n\
10428 plotting functions that vary about some expected average is to use an\n\
10429 additional 2 control points in the center (position ~= 0.5) that are\n\
10430 the same lightness as the background (typically white for paper\n\
10431 output, black for crt), and same hue as the boundary control points.\n\
10432 This allows the highs and lows to be very easily distinguished.\n\
10434 Each control point must specify the cmap1 intensity index and the\n\
10435 associated three coordinates in HLS or RGB space. The first point\n\
10436 must correspond to position = 0, and the last to position = 1.\n\
10438 If RGB colors are provided then the interpolation takes place in RGB\n\
10439 space and is trivial. However if HLS colors are provided then, because\n\
10440 of the circular nature of the color wheel for the hue coordinate, the\n\
10441 interpolation could be performed in either direction around the color\n\
10442 wheel. The default behaviour is for the hue to be linearly\n\
10443 interpolated ignoring this circular property of hue. So for example,\n\
10444 the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\
10445 green and cyan. If instead you wish to interpolate the other way\n\
10446 around the color wheel you have two options. You may provide hues\n\
10447 outside the range [0, 360), so by using a hue of -120 for blue or 360\n\
10448 for red the interpolation will proceed via magenta. Alternatively you\n\
10449 can utilise the alt_hue_path variable to reverse the direction of\n\
10450 interpolation if you need to provide hues within the [0-360) range.\n\
10452 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
10453 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
10454 -120]falsegreen-yellow-red-magenta-blue[240\n\
10455 480]falseblue-magenta-red-yellow-green[120\n\
10456 240]truegreen-yellow-red-magenta-blue[240\n\
10457 120]trueblue-magenta-red-yellow-green\n\
10459 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
10460 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
10461 1]magnitudeHLSsaturation[0, 1]magnitude\n\
10463 Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
10466 This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
10472plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
10476 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
10478 npts (PLINT, input) : number of control points\n\
10480 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
10481 intensity index (0.0-1.0) in ascending order for each control\n\
10484 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
10485 coordinate (H or R) for each control point.\n\
10487 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
10488 coordinate (L or G) for each control point.\n\
10490 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
10491 coordinate (S or B) for each control point.\n\
10493 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
10494 npts - 1 elements), each containing either true to use the reversed\n\
10495 HLS interpolation or false to use the regular HLS interpolation.\n\
10496 (alt_hue_path[i] refers to the interpolation interval between the\n\
10497 i and i + 1 control points). This parameter is not used for RGB\n\
10502Shade individual region on the basis of value\n\
10506 Shade individual region on the basis of value. Use plshades if you\n\
10507 want to shade a number of contiguous regions using continuous colors.\n\
10508 In particular the edge contours are treated properly in plshades. If\n\
10509 you attempt to do contiguous regions with plshade the contours at the\n\
10510 edge of the shade are partially obliterated by subsequent plots of\n\
10511 contiguous shaded regions.\n\
10513 Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
10514 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
10515 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
10518 This function is used in example 15.\n\
10524plshade(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\
10528 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
10529 plot. Should have dimensions of\n\
10533 nx (PLINT, input) : First dimension of the matrix \"a\".\n\
10535 ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
10537 defined (PLDEFINED_callback, input) : Callback function specifying\n\
10538 the region that should be plotted in the shade plot. This\n\
10539 function accepts x and y coordinates as input arguments and must\n\
10540 return 1 if the point is to be included in the shade plot and 0\n\
10541 otherwise. If you want to plot the entire shade plot (the usual\n\
10542 case), this argument should be set to NULL.\n\
10544 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
10545 pltr below for how these arguments are used (only for the special case\n\
10546 when the callback function\n\
10547 pltr is not supplied).\n\
10549 shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
10550 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10552 shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
10553 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
10555 sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
10556 sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
10557 then sh_color is interpreted as a cmap1 argument in the range\n\
10560 sh_color (PLFLT, input) : Defines color map index with integer\n\
10561 value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
10563 sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
10565 min_color (PLINT, input) : Defines pen color, width used by the\n\
10566 boundary of shaded region. The min values are used for the\n\
10567 shade_min boundary, and the max values are used on the shade_max\n\
10568 boundary. Set color and width to zero for no plotted boundaries.\n\
10570 min_width (PLFLT, input) : Defines pen color, width used by the\n\
10571 boundary of shaded region. The min values are used for the\n\
10572 shade_min boundary, and the max values are used on the shade_max\n\
10573 boundary. Set color and width to zero for no plotted boundaries.\n\
10575 max_color (PLINT, input) : Defines pen color, width used by the\n\
10576 boundary of shaded region. The min values are used for the\n\
10577 shade_min boundary, and the max values are used on the shade_max\n\
10578 boundary. Set color and width to zero for no plotted boundaries.\n\
10580 max_width (PLFLT, input) : Defines pen color, width used by the\n\
10581 boundary of shaded region. The min values are used for the\n\
10582 shade_min boundary, and the max values are used on the shade_max\n\
10583 boundary. Set color and width to zero for no plotted boundaries.\n\
10585 fill (PLFILL_callback, input) : Routine used to fill the region.\n\
10586 Use plfill. Future version of PLplot may have other fill\n\
10589 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
10590 map to rectangles after coordinate transformation with pltrl.\n\
10591 Otherwise, set rectangular to false. If rectangular is set to\n\
10592 true, plshade tries to save time by filling large rectangles.\n\
10593 This optimization fails if the coordinate transformation distorts\n\
10594 the shape of rectangles. For example a plot in polar coordinates\n\
10595 has to have rectangular set to false.\n\
10597 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
10598 defines the transformation between the zero-based indices of the\n\
10599 matrix a and world coordinates. If\n\
10600 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
10601 indices of a are mapped to the range\n\
10603 xmax and the y indices of a are mapped to the range\n\
10605 ymax.For the C case, transformation functions are provided in the\n\
10606 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
10607 pltr2 for arbitrary mappings respectively defined by vectors and\n\
10608 matrices. In addition, C callback routines for the transformation\n\
10609 can be supplied by the user such as the mypltr function in\n\
10610 examples/c/x09c.c which provides a general linear transformation\n\
10611 between index coordinates and world coordinates.For languages\n\
10612 other than C you should consult the PLplot documentation for the\n\
10613 details concerning how PLTRANSFORM_callback arguments are\n\
10614 interfaced. However, in general, a particular pattern of\n\
10615 callback-associated arguments such as a tr vector with 6 elements;\n\
10616 xg and yg vectors; or xg and yg matrices are respectively\n\
10617 interfaced to a linear-transformation routine similar to the above\n\
10618 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
10619 sophisticated bindings (see, e.g., the PLplot documentation)\n\
10620 support native language callbacks for handling index to\n\
10621 world-coordinate transformations. Examples of these various\n\
10622 approaches are given in examples/<language>x09*,\n\
10623 examples/<language>x16*, examples/<language>x20*,\n\
10624 examples/<language>x21*, and examples/<language>x22*, for all our\n\
10625 supported languages.\n\
10627 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
10628 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
10629 externally supplied.\n\
10632Set number of colors in cmap1\n\
10636 Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
10637 values if this is the first allocation (see the PLplot documentation).\n\
10639 Redacted form: plscmap1n(ncol1)\n\
10641 This function is used in examples 8, 11, 20, and 21.\n\
10651 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
10652 the cmap1 palette. If this number is zero or less, then the value\n\
10653 from the previous call to plscmap1n is used and if there is no\n\
10654 previous call, then a default value is used.\n\
10657Advance to the next family file on the next new page\n\
10661 Advance to the next family file on the next new page.\n\
10663 Redacted form: plfamadv()\n\
10665 This function is not used in any examples.\n\
10674Set the escape character for text strings\n\
10678 Set the escape character for text strings. From C (in contrast to\n\
10679 Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
10680 characters are allowed to prevent the user from shooting himself in\n\
10681 the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
10682 use of backslash as a character escape). Here are the allowed escape\n\
10683 characters and their corresponding decimal ASCII values: !, ASCII 33\n\
10694 Redacted form: General: plsesc(esc)\n\
10697 This function is used in example 29.\n\
10707 esc (char, input) : Escape character.\n\
10709static const char* _wrap_plcolorbar_texinfo =
"-*- texinfo -*-\n\
10710Plot color bar for image, shade or gradient plots\n\
10714 Routine for creating a continuous color bar for image, shade, or\n\
10715 gradient plots. (See pllegend for similar functionality for creating\n\
10716 legends with discrete elements). The arguments of plcolorbar provide\n\
10717 control over the location and size of the color bar as well as the\n\
10718 location and characteristics of the elements (most of which are\n\
10719 optional) within that color bar. The resulting color bar is clipped\n\
10720 at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
10721 system used for some of the parameters is defined in the documentation\n\
10722 of the position parameter.)\n\
10724 Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
10725 position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
10726 low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
10727 labels, axis_opts, ticks, sub_ticks, values)\n\
10729 This function is used in examples 16 and 33.\n\
10735plcolorbar(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\
10739 p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10740 labelled and decorated color bar width in adopted coordinates.\n\
10742 p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
10743 labelled and decorated color bar height in adopted coordinates.\n\
10745 opt (PLINT, input) : opt contains bits controlling the overall\n\
10746 color bar. The orientation (direction of the maximum value) of\n\
10747 the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
10748 PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
10749 specified, the default orientation is toward the top if the\n\
10750 colorbar is placed on the left or right of the viewport or toward\n\
10751 the right if the colorbar is placed on the top or bottom of the\n\
10752 viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
10753 (semitransparent) background for the color bar. If the\n\
10754 PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
10755 color bar. The type of color bar must be specified with one of\n\
10756 PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
10757 more than one of those bits is set only the first one in the above\n\
10758 list is honored. The position of the (optional) label/title can be\n\
10759 specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
10760 PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
10761 will be drawn. If more than one of this list of bits is specified,\n\
10762 only the first one on the list is honored. End-caps for the color\n\
10763 bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
10764 If a particular color bar cap option is not specified then no cap\n\
10765 will be drawn for that end. As a special case for\n\
10766 PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
10767 specified. If this option is provided then any tick marks and tick\n\
10768 labels will be placed at the breaks between shaded segments. TODO:\n\
10769 This should be expanded to support custom placement of tick marks\n\
10770 and tick labels at custom value locations for any color bar type.\n\
10772 position (PLINT, input) : position contains bits which control the\n\
10773 overall position of the color bar and the definition of the\n\
10774 adopted coordinates used for positions just like what is done for\n\
10775 the position argument for pllegend. However, note that the\n\
10776 defaults for the position bits (see below) are different than the\n\
10777 pllegend case. The combination of the PL_POSITION_LEFT,\n\
10778 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
10779 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
10780 the 16 possible standard positions (the 4 corners and centers of\n\
10781 the 4 sides for both the inside and outside cases) of the color\n\
10782 bar relative to the adopted coordinate system. The corner\n\
10783 positions are specified by the appropriate combination of two of\n\
10784 the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
10785 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
10786 value of one of those bits. The adopted coordinates are\n\
10787 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
10788 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
10789 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
10790 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
10791 then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
10792 PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
10793 PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
10794 PL_POSITION_VIEWPORT.\n\
10796 x (PLFLT, input) : X offset of the color bar position in adopted\n\
10797 coordinates from the specified standard position of the color bar.\n\
10798 For positive x, the direction of motion away from the standard\n\
10799 position is inward/outward from the standard corner positions or\n\
10800 standard left or right positions if the\n\
10801 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10802 For the standard top or bottom positions, the direction of motion\n\
10803 is toward positive X.\n\
10805 y (PLFLT, input) : Y offset of the color bar position in adopted\n\
10806 coordinates from the specified standard position of the color bar.\n\
10807 For positive y, the direction of motion away from the standard\n\
10808 position is inward/outward from the standard corner positions or\n\
10809 standard top or bottom positions if the\n\
10810 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
10811 For the standard left or right positions, the direction of motion\n\
10812 is toward positive Y.\n\
10814 x_length (PLFLT, input) : Length of the body of the color bar in\n\
10815 the X direction in adopted coordinates.\n\
10817 y_length (PLFLT, input) : Length of the body of the color bar in\n\
10818 the Y direction in adopted coordinates.\n\
10820 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
10821 color bar (PL_COLORBAR_BACKGROUND).\n\
10823 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
10824 for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
10826 bb_style (PLINT, input) : The pllsty style number for the\n\
10827 bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
10829 low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
10830 bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
10832 high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
10833 color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
10835 cont_color (PLINT, input) : The cmap0 contour color for\n\
10836 PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
10837 it will be interpreted according to the design of plshades.\n\
10839 cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
10840 plots. This is passed directly to plshades, so it will be\n\
10841 interpreted according to the design of plshades.\n\
10843 n_labels (PLINT, input) : Number of labels to place around the\n\
10846 label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
10847 n_labels labels.\n\
10849 labels (PLCHAR_MATRIX, input) : A vector of\n\
10850 n_labels UTF-8 character strings containing the labels for the color\n\
10851 bar. Ignored if no label position is specified with one of the\n\
10852 PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
10853 PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
10854 corresponding label_opts field.\n\
10856 n_axes (PLINT, input) : Number of axis definitions provided. This\n\
10857 value must be greater than 0. It is typically 1 (numerical axis\n\
10858 labels are provided for one of the long edges of the color bar),\n\
10859 but it can be larger if multiple numerical axis labels for the\n\
10860 long edges of the color bar are desired.\n\
10862 axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
10863 n_axes ascii character strings containing options (interpreted as for\n\
10864 plbox) for the color bar\'s axis definitions.\n\
10866 ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
10867 spacing of the major tick marks (interpreted as for plbox) for the\n\
10868 color bar\'s axis definitions.\n\
10870 sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
10871 number of subticks (interpreted as for plbox) for the color bar\'s\n\
10872 axis definitions.\n\
10874 n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
10875 elements in each of the n_axes rows of the values matrix.\n\
10877 values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
10878 values for the data range represented by the color bar. For a row\n\
10879 index of i_axis (where 0 < i_axis < n_axes), the number of\n\
10880 elements in the row is specified by n_values[i_axis]. For\n\
10881 PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
10882 is 2, and the corresponding row elements of the values matrix are\n\
10883 the minimum and maximum value represented by the colorbar. For\n\
10884 PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
10885 of the values matrix is interpreted the same as the nlevel and\n\
10886 clevel arguments of plshades.\n\
10888static const char* _wrap_plsstrm_texinfo =
"-*- texinfo -*-\n\
10889Set current output stream\n\
10893 Sets the number of the current output stream. The stream number\n\
10894 defaults to 0 unless changed by this routine. The first use of this\n\
10895 routine must be followed by a call initializing PLplot (e.g. plstar).\n\
10897 Redacted form: plsstrm(strm)\n\
10899 This function is examples 1,14,20.\n\
10909 strm (PLINT, input) : The current stream number.\n\
10911static const char* _wrap_plgcompression_texinfo =
"-*- texinfo -*-\n\
10912Get the current device-compression setting\n\
10916 Get the current device-compression setting. This parameter is only\n\
10917 used for drivers that provide compression.\n\
10919 Redacted form: plgcompression(compression)\n\
10921 This function is used in example 31.\n\
10927plgcompression(compression)\n\
10931 compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
10932 compression setting for the current device.\n\
10934static const char* _wrap_plgriddata_texinfo =
"-*- texinfo -*-\n\
10935Grid data from irregularly sampled data\n\
10939 Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
10940 require data organized as a grid, i.e., with x sample point values\n\
10941 independent of y coordinate and vice versa. This function takes\n\
10942 irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
10943 vectors; reads the desired grid location from the input vectors\n\
10944 xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
10945 grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
10946 interpolate the data to the grid is specified with the argument type\n\
10947 which can have one parameter specified in argument data.\n\
10949 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
10950 Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
10953 This function is used in example 21.\n\
10959plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
10963 x (PLFLT_VECTOR, input) : The input x vector.\n\
10965 y (PLFLT_VECTOR, input) : The input y vector.\n\
10967 z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
10968 y[i], z[i] represents one data sample coordinate.\n\
10970 npts (PLINT, input) : The number of data samples in the x, y and z\n\
10973 xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10974 in the x direction. Usually xg has nptsx equally spaced values\n\
10975 from the minimum to the maximum values of the x input vector.\n\
10977 nptsx (PLINT, input) : The number of points in the xg vector.\n\
10979 yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
10980 in the y direction. Similar to the xg parameter.\n\
10982 nptsy (PLINT, input) : The number of points in the yg vector.\n\
10984 zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
10985 where data lies in the grid specified by xg and yg. Therefore the\n\
10986 zg matrix must be dimensioned\n\
10990 type (PLINT, input) : The type of grid interpolation algorithm to\n\
10991 use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
10992 GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
10993 GRID_NNI: Natural Neighbors Interpolation\n\
10994 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
10995 GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
10996 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
10998 For details of the algorithms read the source file plgridd.c.\n\
11000 data (PLFLT, input) : Some gridding algorithms require extra data,\n\
11001 which can be specified through this argument. Currently, for\n\
11002 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
11003 use, the lower the value, the noisier (more local) the\n\
11004 approximation is.\n\
11005 GRID_NNLI, data specifies what a thin triangle is, in the\n\
11006 range [1. .. 2.]. High values enable the usage of very thin\n\
11007 triangles for interpolation, possibly resulting in error in\n\
11008 the approximation.\n\
11009 GRID_NNI, only weights greater than data will be accepted. If\n\
11010 0, all weights will be accepted.\n\
11018 octave_value_list _out;
11019 octave_value_list *_outp=&_out;
11020 octave_value _outv;
11027 if (
_n_dims( args(0) ) > 1 )
11033 temp1 = args(0).matrix_value();
11037 charMatrix temp_matrix;
11041 size_t max_length = 0, non_blank_length;
11043 if (
_n_dims( args(1) ) > 2 )
11045 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
11047#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
11048 if ( !args(1).isempty() )
11050 if ( !args(1).is_empty() )
11055 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
11057 arg3 =
new char*[
Alen];
11058#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
11059 ifcell = args(1).iscell();
11061 ifcell = args(1).is_cell();
11065 temp_cell = args(1).cell_value();
11069 temp_matrix = args(1).char_matrix_value();
11071 max_length =
_dim( args(1), 1 ) + 1;
11074 for ( i = 0; i <
Alen; i++ )
11081 if ( temp_cell.elem( i ).is_string() )
11083 str = temp_cell.elem( i ).string_value();
11085 max_length = str.size() + 1;
11086 tmp_cstring = (
char *) str.c_str();
11096 tmp_cstring = (
char *)
"";
11101 str = temp_matrix.row_as_string( i );
11102 tmp_cstring = (
char *) str.c_str();
11104 arg3[i] =
new char[max_length];
11105 strncpy( arg3[i], tmp_cstring, max_length - 1 );
11106 arg3[i][max_length - 1] =
'\0';
11121 non_blank_length = max_length - 2;
11122 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
'\0' )
11124 non_blank_length--;
11126 while ( non_blank_length >= 0 && arg3[i][non_blank_length] ==
' ' )
11128 non_blank_length--;
11130 arg3[i][non_blank_length + 1] =
'\0';
11139 testppchar(arg1,(
int const *)arg2,(
char const **)arg3);
11140 _outv = octave_value();
11147 if ( arg3 != NULL )
11149 for ( i = 0; i <
Alen; i++ )
11163 if ( arg3 != NULL )
11165 for ( i = 0; i <
Alen; i++ )
11172 return octave_value_list();
11180 if ( arg3 != NULL )
11182 for ( i = 0; i <
Alen; i++ )
11212 char local_string4[80] ;
11227 size_t local_string_length4 ;
11228 charMatrix local_charMatrix4 ;
11229 octave_value_list retval4 ;
11230 octave_value_list _out;
11231 octave_value_list *_outp=&_out;
11232 octave_value _outv;
11240 arg4 = local_string4;
11252 result = (int)
my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11274 local_string_length4 = strlen( local_string4 );
11275 local_charMatrix4 = charMatrix( 1, local_string_length4 );
11276 local_charMatrix4.insert( local_string4, 0, 0 );
11277 retval4( 0 ) = octave_value( local_charMatrix4 );
11324 return octave_value_list();
11345 octave_value_list _out;
11346 octave_value_list *_outp=&_out;
11347 octave_value _outv;
11360 arg3 =
static_cast< PLFLT >(val3);
11365 arg4 =
static_cast< PLFLT >(val4);
11383 return octave_value_list();
11468 octave_value_list _out;
11469 octave_value_list *_outp=&_out;
11470 octave_value _outv;
11481 arg2 =
reinterpret_cast< char *
>(buf2);
11486 arg3 =
reinterpret_cast< char *
>(buf3);
11491 arg4 =
static_cast< PLFLT >(val4);
11496 arg5 =
static_cast< PLFLT >(val5);
11501 arg6 =
static_cast< PLFLT >(val6);
11506 arg7 =
static_cast< PLFLT >(val7);
11511 arg8 =
static_cast< PLFLT >(val8);
11516 arg9 =
static_cast< PLFLT >(val9);
11521 arg10 =
static_cast< PLFLT >(val10);
11526 arg11 =
static_cast< PLBOOL >(val11);
11531 arg12 =
static_cast< PLBOOL >(val12);
11536 arg13 =
static_cast< PLINT >(val13);
11541 arg14 =
static_cast< PLINT >(val14);
11543 if (
_n_dims( args(13) ) > 1 )
11548 temp15 = args(13).matrix_value();
11553 if (
_n_dims( args(14) ) > 1 )
11557 if (
_dim( args(14), 0 ) !=
Alen )
11561 temp16 = args(14).matrix_value();
11569 arg17 =
reinterpret_cast< char *
>(buf17);
11574 arg18 =
reinterpret_cast< char *
>(buf18);
11579 arg19 =
reinterpret_cast< char *
>(buf19);
11584 arg20 =
reinterpret_cast< char *
>(buf20);
11589 arg21 =
reinterpret_cast< char *
>(buf21);
11594 arg22 =
reinterpret_cast< char *
>(buf22);
11599 arg23 =
reinterpret_cast< char *
>(buf23);
11600 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);
11601 _outv = octave_value();
11641 return octave_value_list();
11686 octave_value_list _out;
11687 octave_value_list *_outp=&_out;
11688 octave_value _outv;
11695 if (
_n_dims( args(0) ) > 2 )
11697 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11699 temp1 = args(0).matrix_value();
11700 arg1 = &temp1( 0, 0 );
11708 arg4 =
static_cast< PLINT >(val4);
11713 arg5 =
static_cast< PLINT >(val5);
11718 arg6 =
static_cast< PLINT >(val6);
11723 arg7 =
static_cast< PLINT >(val7);
11725 if (
_n_dims( args(5) ) > 1 )
11729 temp8 = args(5).matrix_value();
11730 arg8 = &temp8( 0, 0 );
11734 if (
_n_dims( args(6) ) > 1 )
11738 if (
_dim( args(6), 0 ) != 6 )
11742 temp10 = args(6).matrix_value();
11743 arg10 = &temp10( 0, 0 );
11745 my_plcont((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10);
11746 _outv = octave_value();
11768 return octave_value_list();
11805 octave_value_list _out;
11806 octave_value_list *_outp=&_out;
11807 octave_value _outv;
11814 if (
_n_dims( args(0) ) > 2 )
11816 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11818 temp1 = args(0).matrix_value();
11819 arg1 = &temp1( 0, 0 );
11827 arg4 =
static_cast< PLINT >(val4);
11832 arg5 =
static_cast< PLINT >(val5);
11837 arg6 =
static_cast< PLINT >(val6);
11842 arg7 =
static_cast< PLINT >(val7);
11844 if (
_n_dims( args(5) ) > 1 )
11848 temp8 = args(5).matrix_value();
11849 arg8 = &temp8( 0, 0 );
11852 my_plcont0((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9);
11853 _outv = octave_value();
11869 return octave_value_list();
11907 octave_value_list _out;
11908 octave_value_list *_outp=&_out;
11909 octave_value _outv;
11916 if (
_n_dims( args(0) ) > 2 )
11918 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
11920 temp1 = args(0).matrix_value();
11921 arg1 = &temp1( 0, 0 );
11929 arg4 =
static_cast< PLINT >(val4);
11934 arg5 =
static_cast< PLINT >(val5);
11939 arg6 =
static_cast< PLINT >(val6);
11944 arg7 =
static_cast< PLINT >(val7);
11946 if (
_n_dims( args(5) ) > 1 )
11950 temp8 = args(5).matrix_value();
11951 arg8 = &temp8( 0, 0 );
11955 if (
_n_dims( args(6) ) > 1 )
11963 temp10 = args(6).matrix_value();
11964 arg10 = &temp10( 0, 0 );
11967 if (
_n_dims( args(7) ) > 1 )
11975 temp11 = args(7).matrix_value();
11976 arg11 = &temp11( 0, 0 );
11978 my_plcont1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
11979 _outv = octave_value();
12007 return octave_value_list();
12051 octave_value_list _out;
12052 octave_value_list *_outp=&_out;
12053 octave_value _outv;
12060 if (
_n_dims( args(0) ) > 2 )
12062 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12064 temp1 = args(0).matrix_value();
12065 arg1 = &temp1( 0, 0 );
12073 arg4 =
static_cast< PLINT >(val4);
12078 arg5 =
static_cast< PLINT >(val5);
12083 arg6 =
static_cast< PLINT >(val6);
12088 arg7 =
static_cast< PLINT >(val7);
12090 if (
_n_dims( args(5) ) > 1 )
12094 temp8 = args(5).matrix_value();
12095 arg8 = &temp8( 0, 0 );
12099 if (
_n_dims( args(6) ) > 2 )
12101 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12105 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12109 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12111 temp10 = args(6).matrix_value();
12112 arg10 = &temp10( 0, 0 );
12115 if (
_n_dims( args(7) ) > 2 )
12117 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12121 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12125 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12127 temp11 = args(7).matrix_value();
12128 arg11 = &temp11( 0, 0 );
12130 my_plcont2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
12131 _outv = octave_value();
12159 return octave_value_list();
12203 octave_value_list _out;
12204 octave_value_list *_outp=&_out;
12205 octave_value _outv;
12212 if (
_n_dims( args(0) ) > 2 )
12214 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12216 temp1 = args(0).matrix_value();
12217 arg1 = &temp1( 0, 0 );
12225 arg4 =
static_cast< PLINT >(val4);
12230 arg5 =
static_cast< PLINT >(val5);
12235 arg6 =
static_cast< PLINT >(val6);
12240 arg7 =
static_cast< PLINT >(val7);
12242 if (
_n_dims( args(5) ) > 1 )
12246 temp8 = args(5).matrix_value();
12247 arg8 = &temp8( 0, 0 );
12251 if (
_n_dims( args(6) ) > 2 )
12253 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12257 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12261 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12263 temp10 = args(6).matrix_value();
12264 arg10 = &temp10( 0, 0 );
12267 if (
_n_dims( args(7) ) > 2 )
12269 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12273 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12277 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12279 temp11 = args(7).matrix_value();
12280 arg11 = &temp11( 0, 0 );
12282 my_plcont2p((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,(
double const *)arg10,(
double const *)arg11);
12283 _outv = octave_value();
12311 return octave_value_list();
12348 octave_value_list retval7 ;
12353 octave_value_list _out;
12354 octave_value_list *_outp=&_out;
12355 octave_value _outv;
12362 if (
_n_dims( args(0) ) > 1 )
12367 temp1 = args(0).matrix_value();
12368 arg1 = &temp1( 0, 0 );
12371 if (
_n_dims( args(1) ) > 1 )
12379 temp2 = args(1).matrix_value();
12380 arg2 = &temp2( 0, 0 );
12383 if (
_n_dims( args(2) ) > 1 )
12391 temp3 = args(2).matrix_value();
12392 arg3 = &temp3( 0, 0 );
12396 if (
_n_dims( args(3) ) > 1 )
12400 temp5 = args(3).matrix_value();
12401 arg5 = &temp5( 0, 0 );
12405 if (
_n_dims( args(4) ) > 1 )
12409 temp7 = args(4).matrix_value();
12410 arg7 = &temp7( 0, 0 );
12412 retval7( 0 ) = octave_value( Matrix(
Xlen,
Ylen ) );
12413 arg9 = (
PLFLT *) retval7( 0 ).matrix_value().data();
12419 arg10 =
static_cast< PLINT >(val10);
12424 arg11 =
static_cast< PLFLT >(val11);
12425 my_plgriddata((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,(
double const *)arg5,arg6,(
double const *)arg7,arg8,arg9,arg10,arg11);
12426 _outv = octave_value();
12463 return octave_value_list();
12498 octave_value_list _out;
12499 octave_value_list *_outp=&_out;
12500 octave_value _outv;
12507 if (
_n_dims( args(0) ) > 1 )
12511 temp1 = args(0).matrix_value();
12512 arg1 = &temp1( 0, 0 );
12516 if (
_n_dims( args(1) ) > 1 )
12520 temp2 = args(1).matrix_value();
12521 arg2 = &temp2( 0, 0 );
12525 if (
_n_dims( args(2) ) > 2 )
12527 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12531 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12535 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12537 temp3 = args(2).matrix_value();
12538 arg3 = &temp3( 0, 0 );
12546 arg6 =
static_cast< PLINT >(val6);
12547 my_plmesh((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6);
12548 _outv = octave_value();
12570 return octave_value_list();
12602 octave_value_list _out;
12603 octave_value_list *_outp=&_out;
12604 octave_value _outv;
12611 if (
_n_dims( args(0) ) > 1 )
12615 temp1 = args(0).matrix_value();
12616 arg1 = &temp1( 0, 0 );
12620 if (
_n_dims( args(1) ) > 1 )
12624 temp2 = args(1).matrix_value();
12625 arg2 = &temp2( 0, 0 );
12629 if (
_n_dims( args(2) ) > 2 )
12631 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12635 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12639 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12641 temp3 = args(2).matrix_value();
12642 arg3 = &temp3( 0, 0 );
12650 arg6 =
static_cast< PLINT >(val6);
12652 if (
_n_dims( args(4) ) > 1 )
12656 temp7 = args(4).matrix_value();
12657 arg7 = &temp7( 0, 0 );
12660 my_plmeshc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12661 _outv = octave_value();
12689 return octave_value_list();
12724 octave_value_list _out;
12725 octave_value_list *_outp=&_out;
12726 octave_value _outv;
12733 if (
_n_dims( args(0) ) > 1 )
12737 temp1 = args(0).matrix_value();
12738 arg1 = &temp1( 0, 0 );
12742 if (
_n_dims( args(1) ) > 1 )
12746 temp2 = args(1).matrix_value();
12747 arg2 = &temp2( 0, 0 );
12751 if (
_n_dims( args(2) ) > 2 )
12753 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12757 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12761 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12763 temp3 = args(2).matrix_value();
12764 arg3 = &temp3( 0, 0 );
12772 arg6 =
static_cast< PLINT >(val6);
12777 arg7 =
static_cast< PLBOOL >(val7);
12778 my_plot3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,arg7);
12779 _outv = octave_value();
12801 return octave_value_list();
12833 octave_value_list _out;
12834 octave_value_list *_outp=&_out;
12835 octave_value _outv;
12842 if (
_n_dims( args(0) ) > 1 )
12846 temp1 = args(0).matrix_value();
12847 arg1 = &temp1( 0, 0 );
12851 if (
_n_dims( args(1) ) > 1 )
12855 temp2 = args(1).matrix_value();
12856 arg2 = &temp2( 0, 0 );
12860 if (
_n_dims( args(2) ) > 2 )
12862 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12866 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
12870 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
12872 temp3 = args(2).matrix_value();
12873 arg3 = &temp3( 0, 0 );
12881 arg6 =
static_cast< PLINT >(val6);
12883 if (
_n_dims( args(4) ) > 1 )
12887 temp7 = args(4).matrix_value();
12888 arg7 = &temp7( 0, 0 );
12891 my_plot3dc((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
12892 _outv = octave_value();
12920 return octave_value_list();
12963 octave_value_list _out;
12964 octave_value_list *_outp=&_out;
12965 octave_value _outv;
12972 if (
_n_dims( args(0) ) > 1 )
12976 temp1 = args(0).matrix_value();
12977 arg1 = &temp1( 0, 0 );
12981 if (
_n_dims( args(1) ) > 1 )
12985 temp2 = args(1).matrix_value();
12986 arg2 = &temp2( 0, 0 );
12990 if (
_n_dims( args(2) ) > 2 )
12992 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
12996 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13000 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13002 temp3 = args(2).matrix_value();
13003 arg3 = &temp3( 0, 0 );
13011 arg6 =
static_cast< PLINT >(val6);
13013 if (
_n_dims( args(4) ) > 1 )
13017 temp7 = args(4).matrix_value();
13018 arg7 = &temp7( 0, 0 );
13025 arg9 =
static_cast< PLINT >(val9);
13027 if (
_n_dims( args(6) ) > 1 )
13033 temp10 = args(6).matrix_value();
13037 if (
_n_dims( args(7) ) > 1 )
13045 temp12 = args(7).matrix_value();
13049 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);
13050 _outv = octave_value();
13090 return octave_value_list();
13131 octave_value_list _out;
13132 octave_value_list *_outp=&_out;
13133 octave_value _outv;
13140 if (
_n_dims( args(0) ) > 1 )
13144 temp1 = args(0).matrix_value();
13145 arg1 = &temp1( 0, 0 );
13149 if (
_n_dims( args(1) ) > 1 )
13153 temp2 = args(1).matrix_value();
13154 arg2 = &temp2( 0, 0 );
13158 if (
_n_dims( args(2) ) > 2 )
13160 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13164 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13168 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13170 temp3 = args(2).matrix_value();
13171 arg3 = &temp3( 0, 0 );
13179 arg6 =
static_cast< PLINT >(val6);
13181 if (
_n_dims( args(4) ) > 1 )
13185 temp7 = args(4).matrix_value();
13186 arg7 = &temp7( 0, 0 );
13189 my_plsurf3d((
double const *)arg1,(
double const *)arg2,(
double const *)arg3,arg4,arg5,arg6,(
double const *)arg7,arg8);
13190 _outv = octave_value();
13218 return octave_value_list();
13261 octave_value_list _out;
13262 octave_value_list *_outp=&_out;
13263 octave_value _outv;
13270 if (
_n_dims( args(0) ) > 1 )
13274 temp1 = args(0).matrix_value();
13275 arg1 = &temp1( 0, 0 );
13279 if (
_n_dims( args(1) ) > 1 )
13283 temp2 = args(1).matrix_value();
13284 arg2 = &temp2( 0, 0 );
13288 if (
_n_dims( args(2) ) > 2 )
13290 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13294 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
13298 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
13300 temp3 = args(2).matrix_value();
13301 arg3 = &temp3( 0, 0 );
13309 arg6 =
static_cast< PLINT >(val6);
13311 if (
_n_dims( args(4) ) > 1 )
13315 temp7 = args(4).matrix_value();
13316 arg7 = &temp7( 0, 0 );
13323 arg9 =
static_cast< PLINT >(val9);
13325 if (
_n_dims( args(6) ) > 1 )
13331 temp10 = args(6).matrix_value();
13335 if (
_n_dims( args(7) ) > 1 )
13343 temp12 = args(7).matrix_value();
13347 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);
13348 _outv = octave_value();
13388 return octave_value_list();
13465 octave_value_list _out;
13466 octave_value_list *_outp=&_out;
13467 octave_value _outv;
13474 if (
_n_dims( args(0) ) > 2 )
13476 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13478 temp1 = args(0).matrix_value();
13479 arg1 = &temp1( 0, 0 );
13484 if (
_n_dims( args(1) ) > 1 )
13489 temp4 = args(1).matrix_value();
13490 arg4 = &temp4( 0, 0 );
13496 arg5 =
static_cast< PLFLT >(val5);
13501 arg6 =
static_cast< PLFLT >(val6);
13506 arg7 =
static_cast< PLFLT >(val7);
13511 arg8 =
static_cast< PLFLT >(val8);
13516 arg9 =
static_cast< PLFLT >(val9);
13521 arg10 =
static_cast< PLFLT >(val10);
13526 arg11 =
static_cast< PLINT >(val11);
13531 arg12 =
static_cast< PLFLT >(val12);
13536 arg13 =
static_cast< PLINT >(val13);
13541 arg14 =
static_cast< PLINT >(val14);
13546 arg15 =
static_cast< PLINT >(val15);
13551 arg16 =
static_cast< PLINT >(val16);
13556 arg17 =
static_cast< PLINT >(val17);
13561 arg18 =
static_cast< PLBOOL >(val18);
13563 if (
_n_dims( args(16) ) > 1 )
13567 if (
_dim( args(16), 0 ) != 6 )
13571 temp19 = args(16).matrix_value();
13572 arg19 = &temp19( 0, 0 );
13574 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);
13575 _outv = octave_value();
13597 return octave_value_list();
13669 octave_value_list _out;
13670 octave_value_list *_outp=&_out;
13671 octave_value _outv;
13678 if (
_n_dims( args(0) ) > 2 )
13680 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13682 temp1 = args(0).matrix_value();
13683 arg1 = &temp1( 0, 0 );
13691 arg4 =
reinterpret_cast< char *
>(buf4);
13696 arg5 =
static_cast< PLFLT >(val5);
13701 arg6 =
static_cast< PLFLT >(val6);
13706 arg7 =
static_cast< PLFLT >(val7);
13711 arg8 =
static_cast< PLFLT >(val8);
13716 arg9 =
static_cast< PLFLT >(val9);
13721 arg10 =
static_cast< PLFLT >(val10);
13726 arg11 =
static_cast< PLINT >(val11);
13731 arg12 =
static_cast< PLFLT >(val12);
13736 arg13 =
static_cast< PLINT >(val13);
13741 arg14 =
static_cast< PLINT >(val14);
13746 arg15 =
static_cast< PLINT >(val15);
13751 arg16 =
static_cast< PLINT >(val16);
13756 arg17 =
static_cast< PLINT >(val17);
13761 arg18 =
static_cast< PLBOOL >(val18);
13763 if (
_n_dims( args(16) ) > 1 )
13767 if (
_dim( args(16), 0 ) !=
Xlen )
13771 temp19 = args(16).matrix_value();
13772 arg19 = &temp19( 0, 0 );
13775 if (
_n_dims( args(17) ) > 1 )
13779 if (
_dim( args(17), 0 ) !=
Ylen )
13783 temp20 = args(17).matrix_value();
13784 arg20 = &temp20( 0, 0 );
13786 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);
13787 _outv = octave_value();
13811 return octave_value_list();
13884 octave_value_list _out;
13885 octave_value_list *_outp=&_out;
13886 octave_value _outv;
13893 if (
_n_dims( args(0) ) > 2 )
13895 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13897 temp1 = args(0).matrix_value();
13898 arg1 = &temp1( 0, 0 );
13906 arg4 =
reinterpret_cast< char *
>(buf4);
13911 arg5 =
static_cast< PLFLT >(val5);
13916 arg6 =
static_cast< PLFLT >(val6);
13921 arg7 =
static_cast< PLFLT >(val7);
13926 arg8 =
static_cast< PLFLT >(val8);
13931 arg9 =
static_cast< PLFLT >(val9);
13936 arg10 =
static_cast< PLFLT >(val10);
13941 arg11 =
static_cast< PLINT >(val11);
13946 arg12 =
static_cast< PLFLT >(val12);
13951 arg13 =
static_cast< PLINT >(val13);
13956 arg14 =
static_cast< PLINT >(val14);
13961 arg15 =
static_cast< PLINT >(val15);
13966 arg16 =
static_cast< PLINT >(val16);
13971 arg17 =
static_cast< PLINT >(val17);
13976 arg18 =
static_cast< PLBOOL >(val18);
13978 if (
_n_dims( args(16) ) > 2 )
13980 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13982 temp19 = args(16).matrix_value();
13983 arg19 = &temp19( 0, 0 );
13988 if (
_n_dims( args(17) ) > 2 )
13990 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
13992 temp20 = args(17).matrix_value();
13993 arg20 = &temp20( 0, 0 );
13997 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);
13998 _outv = octave_value();
14022 return octave_value_list();
14072 octave_value_list _out;
14073 octave_value_list *_outp=&_out;
14074 octave_value _outv;
14081 if (
_n_dims( args(0) ) > 2 )
14083 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14085 temp1 = args(0).matrix_value();
14086 arg1 = &temp1( 0, 0 );
14094 arg4 =
static_cast< PLFLT >(val4);
14099 arg5 =
static_cast< PLFLT >(val5);
14104 arg6 =
static_cast< PLFLT >(val6);
14109 arg7 =
static_cast< PLFLT >(val7);
14111 if (
_n_dims( args(5) ) > 1 )
14115 temp8 = args(5).matrix_value();
14116 arg8 = &temp8( 0, 0 );
14123 arg10 =
static_cast< PLINT >(val10);
14128 arg11 =
static_cast< PLINT >(val11);
14133 arg12 =
static_cast< PLINT >(val12);
14138 arg13 =
static_cast< PLBOOL >(val13);
14139 my_plshades((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13);
14140 _outv = octave_value();
14156 return octave_value_list();
14204 octave_value_list _out;
14205 octave_value_list *_outp=&_out;
14206 octave_value _outv;
14213 if (
_n_dims( args(0) ) > 2 )
14215 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14217 temp1 = args(0).matrix_value();
14218 arg1 = &temp1( 0, 0 );
14226 arg4 =
static_cast< PLFLT >(val4);
14231 arg5 =
static_cast< PLFLT >(val5);
14236 arg6 =
static_cast< PLFLT >(val6);
14241 arg7 =
static_cast< PLFLT >(val7);
14243 if (
_n_dims( args(5) ) > 1 )
14247 temp8 = args(5).matrix_value();
14248 arg8 = &temp8( 0, 0 );
14255 arg10 =
static_cast< PLINT >(val10);
14260 arg11 =
static_cast< PLINT >(val11);
14265 arg12 =
static_cast< PLINT >(val12);
14270 arg13 =
static_cast< PLBOOL >(val13);
14272 if (
_n_dims( args(10) ) > 1 )
14276 if (
_dim( args(10), 0 ) != 6 )
14280 temp14 = args(10).matrix_value();
14281 arg14 = &temp14( 0, 0 );
14283 my_plshadesx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(
double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
14284 _outv = octave_value();
14306 return octave_value_list();
14359 octave_value_list _out;
14360 octave_value_list *_outp=&_out;
14361 octave_value _outv;
14368 if (
_n_dims( args(0) ) > 2 )
14370 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14372 temp1 = args(0).matrix_value();
14373 arg1 = &temp1( 0, 0 );
14381 arg4 =
static_cast< PLFLT >(val4);
14386 arg5 =
static_cast< PLFLT >(val5);
14391 arg6 =
static_cast< PLFLT >(val6);
14396 arg7 =
static_cast< PLFLT >(val7);
14398 if (
_n_dims( args(5) ) > 1 )
14402 temp8 = args(5).matrix_value();
14403 arg8 = &temp8( 0, 0 );
14410 arg10 =
static_cast< PLINT >(val10);
14415 arg11 =
static_cast< PLINT >(val11);
14420 arg12 =
static_cast< PLINT >(val12);
14425 arg13 =
static_cast< PLBOOL >(val13);
14427 if (
_n_dims( args(10) ) > 1 )
14431 if (
_dim( args(10), 0 ) !=
Xlen )
14435 temp14 = args(10).matrix_value();
14436 arg14 = &temp14( 0, 0 );
14439 if (
_n_dims( args(11) ) > 1 )
14443 if (
_dim( args(11), 0 ) !=
Ylen )
14447 temp15 = args(11).matrix_value();
14448 arg15 = &temp15( 0, 0 );
14450 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);
14451 _outv = octave_value();
14479 return octave_value_list();
14535 octave_value_list _out;
14536 octave_value_list *_outp=&_out;
14537 octave_value _outv;
14544 if (
_n_dims( args(0) ) > 2 )
14546 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14548 temp1 = args(0).matrix_value();
14549 arg1 = &temp1( 0, 0 );
14557 arg4 =
static_cast< PLFLT >(val4);
14562 arg5 =
static_cast< PLFLT >(val5);
14567 arg6 =
static_cast< PLFLT >(val6);
14572 arg7 =
static_cast< PLFLT >(val7);
14574 if (
_n_dims( args(5) ) > 1 )
14578 temp8 = args(5).matrix_value();
14579 arg8 = &temp8( 0, 0 );
14586 arg10 =
static_cast< PLINT >(val10);
14591 arg11 =
static_cast< PLINT >(val11);
14596 arg12 =
static_cast< PLINT >(val12);
14601 arg13 =
static_cast< PLBOOL >(val13);
14603 if (
_n_dims( args(10) ) > 2 )
14605 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14607 temp14 = args(10).matrix_value();
14608 arg14 = &temp14( 0, 0 );
14613 if (
_n_dims( args(11) ) > 2 )
14615 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14617 temp15 = args(11).matrix_value();
14618 arg15 = &temp15( 0, 0 );
14622 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);
14623 _outv = octave_value();
14651 return octave_value_list();
14683 octave_value_list _out;
14684 octave_value_list *_outp=&_out;
14685 octave_value _outv;
14692 if (
_n_dims( args(0) ) > 2 )
14694 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14696 temp1 = args(0).matrix_value();
14697 arg1 = &temp1( 0, 0 );
14702 if (
_n_dims( args(1) ) > 2 )
14704 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14708 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14712 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14714 temp2 = args(1).matrix_value();
14715 arg2 = &temp2( 0, 0 );
14723 arg5 =
static_cast< PLFLT >(val5);
14725 if (
_n_dims( args(3) ) > 1 )
14729 if (
_dim( args(3), 0 ) != 6 )
14733 temp6 = args(3).matrix_value();
14734 arg6 = &temp6( 0, 0 );
14736 my_plvect((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
14737 _outv = octave_value();
14759 return octave_value_list();
14790 octave_value_list _out;
14791 octave_value_list *_outp=&_out;
14792 octave_value _outv;
14799 if (
_n_dims( args(0) ) > 2 )
14801 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14803 temp1 = args(0).matrix_value();
14804 arg1 = &temp1( 0, 0 );
14809 if (
_n_dims( args(1) ) > 2 )
14811 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14815 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14819 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14821 temp2 = args(1).matrix_value();
14822 arg2 = &temp2( 0, 0 );
14830 arg5 =
static_cast< PLFLT >(val5);
14832 if (
_n_dims( args(3) ) > 1 )
14840 temp6 = args(3).matrix_value();
14841 arg6 = &temp6( 0, 0 );
14844 if (
_n_dims( args(4) ) > 1 )
14852 temp7 = args(4).matrix_value();
14853 arg7 = &temp7( 0, 0 );
14855 my_plvect1((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14856 _outv = octave_value();
14884 return octave_value_list();
14918 octave_value_list _out;
14919 octave_value_list *_outp=&_out;
14920 octave_value _outv;
14927 if (
_n_dims( args(0) ) > 2 )
14929 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14931 temp1 = args(0).matrix_value();
14932 arg1 = &temp1( 0, 0 );
14937 if (
_n_dims( args(1) ) > 2 )
14939 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14943 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
14947 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
14949 temp2 = args(1).matrix_value();
14950 arg2 = &temp2( 0, 0 );
14958 arg5 =
static_cast< PLFLT >(val5);
14960 if (
_n_dims( args(3) ) > 2 )
14962 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14964 temp6 = args(3).matrix_value();
14965 arg6 = &temp6( 0, 0 );
14970 if (
_n_dims( args(4) ) > 2 )
14972 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
14974 temp7 = args(4).matrix_value();
14975 arg7 = &temp7( 0, 0 );
14979 my_plvect2((
double const *)arg1,(
double const *)arg2,arg3,arg4,arg5,(
double const *)arg6,(
double const *)arg7);
14980 _outv = octave_value();
15008 return octave_value_list();
15063 octave_value_list _out;
15064 octave_value_list *_outp=&_out;
15065 octave_value _outv;
15072 if (
_n_dims( args(0) ) > 2 )
15074 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15076 temp1 = args(0).matrix_value();
15077 arg1 = &temp1( 0, 0 );
15085 arg4 =
static_cast< PLFLT >(val4);
15090 arg5 =
static_cast< PLFLT >(val5);
15095 arg6 =
static_cast< PLFLT >(val6);
15100 arg7 =
static_cast< PLFLT >(val7);
15105 arg8 =
static_cast< PLFLT >(val8);
15110 arg9 =
static_cast< PLFLT >(val9);
15115 arg10 =
static_cast< PLFLT >(val10);
15120 arg11 =
static_cast< PLFLT >(val11);
15125 arg12 =
static_cast< PLFLT >(val12);
15130 arg13 =
static_cast< PLFLT >(val13);
15131 my_plimage((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15132 _outv = octave_value();
15142 return octave_value_list();
15182 octave_value_list _out;
15183 octave_value_list *_outp=&_out;
15184 octave_value _outv;
15191 if (
_n_dims( args(0) ) > 2 )
15193 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15195 temp1 = args(0).matrix_value();
15196 arg1 = &temp1( 0, 0 );
15204 arg4 =
static_cast< PLFLT >(val4);
15209 arg5 =
static_cast< PLFLT >(val5);
15214 arg6 =
static_cast< PLFLT >(val6);
15219 arg7 =
static_cast< PLFLT >(val7);
15224 arg8 =
static_cast< PLFLT >(val8);
15229 arg9 =
static_cast< PLFLT >(val9);
15234 arg10 =
static_cast< PLFLT >(val10);
15239 arg11 =
static_cast< PLFLT >(val11);
15240 my_plimagefr((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
15241 _outv = octave_value();
15251 return octave_value_list();
15293 octave_value_list _out;
15294 octave_value_list *_outp=&_out;
15295 octave_value _outv;
15302 if (
_n_dims( args(0) ) > 2 )
15304 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15306 temp1 = args(0).matrix_value();
15307 arg1 = &temp1( 0, 0 );
15315 arg4 =
static_cast< PLFLT >(val4);
15320 arg5 =
static_cast< PLFLT >(val5);
15325 arg6 =
static_cast< PLFLT >(val6);
15330 arg7 =
static_cast< PLFLT >(val7);
15335 arg8 =
static_cast< PLFLT >(val8);
15340 arg9 =
static_cast< PLFLT >(val9);
15345 arg10 =
static_cast< PLFLT >(val10);
15350 arg11 =
static_cast< PLFLT >(val11);
15352 if (
_n_dims( args(9) ) > 1 )
15356 if (
_dim( args(9), 0 ) != 6 )
15360 temp12 = args(9).matrix_value();
15361 arg12 = &temp12( 0, 0 );
15363 my_plimagefrx((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
15364 _outv = octave_value();
15380 return octave_value_list();
15427 octave_value_list _out;
15428 octave_value_list *_outp=&_out;
15429 octave_value _outv;
15436 if (
_n_dims( args(0) ) > 2 )
15438 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15440 temp1 = args(0).matrix_value();
15441 arg1 = &temp1( 0, 0 );
15449 arg4 =
static_cast< PLFLT >(val4);
15454 arg5 =
static_cast< PLFLT >(val5);
15459 arg6 =
static_cast< PLFLT >(val6);
15464 arg7 =
static_cast< PLFLT >(val7);
15469 arg8 =
static_cast< PLFLT >(val8);
15474 arg9 =
static_cast< PLFLT >(val9);
15479 arg10 =
static_cast< PLFLT >(val10);
15484 arg11 =
static_cast< PLFLT >(val11);
15486 if (
_n_dims( args(9) ) > 1 )
15494 temp12 = args(9).matrix_value();
15495 arg12 = &temp12( 0, 0 );
15498 if (
_n_dims( args(10) ) > 1 )
15502 if (
_dim( args(10), 0 ) !=
Ylen )
15506 temp13 = args(10).matrix_value();
15507 arg13 = &temp13( 0, 0 );
15509 my_plimagefr1((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
15510 _outv = octave_value();
15532 return octave_value_list();
15582 octave_value_list _out;
15583 octave_value_list *_outp=&_out;
15584 octave_value _outv;
15591 if (
_n_dims( args(0) ) > 2 )
15593 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15595 temp1 = args(0).matrix_value();
15596 arg1 = &temp1( 0, 0 );
15604 arg4 =
static_cast< PLFLT >(val4);
15609 arg5 =
static_cast< PLFLT >(val5);
15614 arg6 =
static_cast< PLFLT >(val6);
15619 arg7 =
static_cast< PLFLT >(val7);
15624 arg8 =
static_cast< PLFLT >(val8);
15629 arg9 =
static_cast< PLFLT >(val9);
15634 arg10 =
static_cast< PLFLT >(val10);
15639 arg11 =
static_cast< PLFLT >(val11);
15641 if (
_n_dims( args(9) ) > 2 )
15643 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15645 temp12 = args(9).matrix_value();
15646 arg12 = &temp12( 0, 0 );
15651 if (
_n_dims( args(10) ) > 2 )
15653 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
15655 temp13 = args(10).matrix_value();
15656 arg13 = &temp13( 0, 0 );
15660 my_plimagefr2((
double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(
double const *)arg12,(
double const *)arg13);
15661 _outv = octave_value();
15683 return octave_value_list();
15760 octave_value_list _out;
15761 octave_value_list *_outp=&_out;
15762 octave_value _outv;
15774 arg3 =
static_cast< PLINT >(val3);
15779 arg4 =
static_cast< PLINT >(val4);
15784 arg5 =
static_cast< PLFLT >(val5);
15789 arg6 =
static_cast< PLFLT >(val6);
15794 arg7 =
static_cast< PLFLT >(val7);
15799 arg8 =
static_cast< PLFLT >(val8);
15804 arg9 =
static_cast< PLINT >(val9);
15809 arg10 =
static_cast< PLINT >(val10);
15814 arg11 =
static_cast< PLINT >(val11);
15819 arg12 =
static_cast< PLFLT >(val12);
15824 arg13 =
static_cast< PLFLT >(val13);
15829 arg14 =
static_cast< PLINT >(val14);
15834 arg15 =
static_cast< PLFLT >(val15);
15836 if (
_n_dims( args(13) ) > 1 )
15842 temp16 = args(13).matrix_value();
15846 charMatrix temp_matrix;
15850 size_t max_length = 0, non_blank_length;
15852 if (
_n_dims( args(14) ) > 2 )
15854 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
15856#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15857 if ( !args(14).isempty() )
15859 if ( !args(14).is_empty() )
15862 if (
_dim( args(14), 0 ) !=
Alen )
15864 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
15866 arg18 =
new char*[
Alen];
15867#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15868 ifcell = args(14).iscell();
15870 ifcell = args(14).is_cell();
15874 temp_cell = args(14).cell_value();
15878 temp_matrix = args(14).char_matrix_value();
15880 max_length =
_dim( args(14), 1 ) + 1;
15883 for ( i = 0; i <
Alen; i++ )
15890 if ( temp_cell.elem( i ).is_string() )
15892 str = temp_cell.elem( i ).string_value();
15894 max_length = str.size() + 1;
15895 tmp_cstring = (
char *) str.c_str();
15905 tmp_cstring = (
char *)
"";
15910 str = temp_matrix.row_as_string( i );
15911 tmp_cstring = (
char *) str.c_str();
15913 arg18[i] =
new char[max_length];
15914 strncpy( arg18[i], tmp_cstring, max_length - 1 );
15915 arg18[i][max_length - 1] =
'\0';
15930 non_blank_length = max_length - 2;
15931 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
'\0' )
15933 non_blank_length--;
15935 while ( non_blank_length >= 0 && arg18[i][non_blank_length] ==
' ' )
15937 non_blank_length--;
15939 arg18[i][non_blank_length + 1] =
'\0';
15949 charMatrix temp_matrix;
15953 size_t max_length = 0, non_blank_length;
15955 if (
_n_dims( args(15) ) > 2 )
15957 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
15959#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15960 if ( !args(15).isempty() )
15962 if ( !args(15).is_empty() )
15967 arg20 =
new char*[
Alen];
15968#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15969 ifcell = args(15).iscell();
15971 ifcell = args(15).is_cell();
15975 temp_cell = args(15).cell_value();
15979 temp_matrix = args(15).char_matrix_value();
15981 max_length =
_dim( args(15), 1 ) + 1;
15984 for ( i = 0; i <
Alen; i++ )
15991 if ( temp_cell.elem( i ).is_string() )
15993 str = temp_cell.elem( i ).string_value();
15995 max_length = str.size() + 1;
15996 tmp_cstring = (
char *) str.c_str();
16006 tmp_cstring = (
char *)
"";
16011 str = temp_matrix.row_as_string( i );
16012 tmp_cstring = (
char *) str.c_str();
16014 arg20[i] =
new char[max_length];
16015 strncpy( arg20[i], tmp_cstring, max_length - 1 );
16016 arg20[i][max_length - 1] =
'\0';
16031 non_blank_length = max_length - 2;
16032 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
16034 non_blank_length--;
16036 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
16038 non_blank_length--;
16040 arg20[i][non_blank_length + 1] =
'\0';
16051 if (
_n_dims( args(16) ) > 1 )
16055 if (
_dim( args(16), 0 ) !=
Alen )
16059 temp21 = args(16).matrix_value();
16060 arg21 = &temp21( 0, 0 );
16063 if (
_n_dims( args(17) ) > 1 )
16067 if (
_dim( args(17), 0 ) !=
Alen )
16071 temp22 = args(17).matrix_value();
16077 if (
_n_dims( args(18) ) > 1 )
16081 if (
_dim( args(18), 0 ) !=
Alen )
16086 temp23 = args(18).matrix_value();
16090 for ( i = 0; i <
Xlen; i++ )
16091 if ( arg23[i] >
Ylen )
16095 if (
_n_dims( args(19) ) > 2 )
16097 error(
"argument must be a scalar, vector, or 2D matrix." );
SWIG_fail;
16099 if (
_dim( args(19), 0 ) !=
Xlen )
16101 error(
"argument matrix must have same X length as X vector" );
SWIG_fail;
16103 if (
_dim( args(19), 1 ) !=
Ylen )
16105 error(
"argument matrix must have same Y length as Y vector" );
SWIG_fail;
16107 temp24 = args(19).matrix_value();
16108 arg24 = &temp24( 0, 0 );
16110 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);
16111 _outv = octave_value();
16130 if ( arg18 != NULL )
16132 for ( i = 0; i <
Alen; i++ )
16141 if ( arg20 != NULL )
16143 for ( i = 0; i <
Alen; i++ )
16169 if ( arg18 != NULL )
16171 for ( i = 0; i <
Alen; i++ )
16180 if ( arg20 != NULL )
16182 for ( i = 0; i <
Alen; i++ )
16201 return octave_value_list();
16209 if ( arg18 != NULL )
16211 for ( i = 0; i <
Alen; i++ )
16220 if ( arg20 != NULL )
16222 for ( i = 0; i <
Alen; i++ )
16253 octave_value_list _out;
16254 octave_value_list *_outp=&_out;
16255 octave_value _outv;
16270 arg2 =
static_cast< int >(val2);
16271 if (arg1) (arg1)->type = arg2;
16272 _outv = octave_value();
16276 return octave_value_list();
16288 octave_value_list _out;
16289 octave_value_list *_outp=&_out;
16290 octave_value _outv;
16302 result = (int) ((arg1)->type);
16307 return octave_value_list();
16317 unsigned int arg2 ;
16320 unsigned int val2 ;
16322 octave_value_list _out;
16323 octave_value_list *_outp=&_out;
16324 octave_value _outv;
16339 arg2 =
static_cast< unsigned int >(val2);
16340 if (arg1) (arg1)->state = arg2;
16341 _outv = octave_value();
16345 return octave_value_list();
16357 octave_value_list _out;
16358 octave_value_list *_outp=&_out;
16359 octave_value _outv;
16360 unsigned int result;
16371 result = (
unsigned int) ((arg1)->state);
16376 return octave_value_list();
16386 unsigned int arg2 ;
16389 unsigned int val2 ;
16391 octave_value_list _out;
16392 octave_value_list *_outp=&_out;
16393 octave_value _outv;
16408 arg2 =
static_cast< unsigned int >(val2);
16409 if (arg1) (arg1)->keysym = arg2;
16410 _outv = octave_value();
16414 return octave_value_list();
16426 octave_value_list _out;
16427 octave_value_list *_outp=&_out;
16428 octave_value _outv;
16429 unsigned int result;
16440 result = (
unsigned int) ((arg1)->keysym);
16445 return octave_value_list();
16455 unsigned int arg2 ;
16458 unsigned int val2 ;
16460 octave_value_list _out;
16461 octave_value_list *_outp=&_out;
16462 octave_value _outv;
16477 arg2 =
static_cast< unsigned int >(val2);
16478 if (arg1) (arg1)->button = arg2;
16479 _outv = octave_value();
16483 return octave_value_list();
16495 octave_value_list _out;
16496 octave_value_list *_outp=&_out;
16497 octave_value _outv;
16498 unsigned int result;
16509 result = (
unsigned int) ((arg1)->button);
16514 return octave_value_list();
16529 octave_value_list _out;
16530 octave_value_list *_outp=&_out;
16531 octave_value _outv;
16546 arg2 =
static_cast< PLINT >(val2);
16547 if (arg1) (arg1)->subwindow = arg2;
16548 _outv = octave_value();
16552 return octave_value_list();
16564 octave_value_list _out;
16565 octave_value_list *_outp=&_out;
16566 octave_value _outv;
16578 result = (
PLINT) ((arg1)->subwindow);
16583 return octave_value_list();
16593 char *arg2 = (
char *)0 ;
16598 octave_value_list _out;
16599 octave_value_list *_outp=&_out;
16600 octave_value _outv;
16615 arg2 =
reinterpret_cast< char *
>(temp2);
16616 if (arg2) memcpy(arg1->
string,arg2,16*
sizeof(
char));
16617 else memset(arg1->
string,0,16*
sizeof(
char));
16618 _outv = octave_value();
16622 return octave_value_list();
16634 octave_value_list _out;
16635 octave_value_list *_outp=&_out;
16636 octave_value _outv;
16648 result = (
char *)(
char *) ((arg1)->string);
16659 return octave_value_list();
16674 octave_value_list _out;
16675 octave_value_list *_outp=&_out;
16676 octave_value _outv;
16691 arg2 =
static_cast< int >(val2);
16692 if (arg1) (arg1)->pX = arg2;
16693 _outv = octave_value();
16697 return octave_value_list();
16709 octave_value_list _out;
16710 octave_value_list *_outp=&_out;
16711 octave_value _outv;
16723 result = (int) ((arg1)->pX);
16728 return octave_value_list();
16743 octave_value_list _out;
16744 octave_value_list *_outp=&_out;
16745 octave_value _outv;
16760 arg2 =
static_cast< int >(val2);
16761 if (arg1) (arg1)->pY = arg2;
16762 _outv = octave_value();
16766 return octave_value_list();
16778 octave_value_list _out;
16779 octave_value_list *_outp=&_out;
16780 octave_value _outv;
16792 result = (int) ((arg1)->pY);
16797 return octave_value_list();
16812 octave_value_list _out;
16813 octave_value_list *_outp=&_out;
16814 octave_value _outv;
16829 arg2 =
static_cast< PLFLT >(val2);
16830 if (arg1) (arg1)->dX = arg2;
16831 _outv = octave_value();
16835 return octave_value_list();
16847 octave_value_list _out;
16848 octave_value_list *_outp=&_out;
16849 octave_value _outv;
16861 result = (
PLFLT) ((arg1)->dX);
16866 return octave_value_list();
16881 octave_value_list _out;
16882 octave_value_list *_outp=&_out;
16883 octave_value _outv;
16898 arg2 =
static_cast< PLFLT >(val2);
16899 if (arg1) (arg1)->dY = arg2;
16900 _outv = octave_value();
16904 return octave_value_list();
16916 octave_value_list _out;
16917 octave_value_list *_outp=&_out;
16918 octave_value _outv;
16930 result = (
PLFLT) ((arg1)->dY);
16935 return octave_value_list();
16950 octave_value_list _out;
16951 octave_value_list *_outp=&_out;
16952 octave_value _outv;
16967 arg2 =
static_cast< PLFLT >(val2);
16968 if (arg1) (arg1)->wX = arg2;
16969 _outv = octave_value();
16973 return octave_value_list();
16985 octave_value_list _out;
16986 octave_value_list *_outp=&_out;
16987 octave_value _outv;
16999 result = (
PLFLT) ((arg1)->wX);
17004 return octave_value_list();
17019 octave_value_list _out;
17020 octave_value_list *_outp=&_out;
17021 octave_value _outv;
17036 arg2 =
static_cast< PLFLT >(val2);
17037 if (arg1) (arg1)->wY = arg2;
17038 _outv = octave_value();
17042 return octave_value_list();
17054 octave_value_list _out;
17055 octave_value_list *_outp=&_out;
17056 octave_value _outv;
17068 result = (
PLFLT) ((arg1)->wY);
17073 return octave_value_list();
17082 octave_value_list _out;
17083 octave_value_list *_outp=&_out;
17084 octave_value _outv;
17096 return octave_value_list();
17108 octave_value_list _out;
17109 octave_value_list *_outp=&_out;
17110 octave_value _outv;
17122 _outv = octave_value();
17126 return octave_value_list();
17160 octave_value_list _out;
17161 octave_value_list *_outp=&_out;
17162 octave_value _outv;
17172 arg1 =
static_cast< PLINT >(val1);
17177 arg2 =
static_cast< PLINT >(val2);
17179 _outv = octave_value();
17183 return octave_value_list();
17204 octave_value_list _out;
17205 octave_value_list *_outp=&_out;
17206 octave_value _outv;
17216 arg1 =
static_cast< PLFLT >(val1);
17221 arg2 =
static_cast< PLFLT >(val2);
17226 arg3 =
static_cast< PLFLT >(val3);
17231 arg4 =
static_cast< PLINT >(val4);
17233 _outv = octave_value();
17237 return octave_value_list();
17249 octave_value_list _out;
17250 octave_value_list *_outp=&_out;
17251 octave_value _outv;
17261 arg1 =
static_cast< PLINT >(val1);
17263 _outv = octave_value();
17267 return octave_value_list();
17300 octave_value_list _out;
17301 octave_value_list *_outp=&_out;
17302 octave_value _outv;
17312 arg1 =
static_cast< PLFLT >(val1);
17317 arg2 =
static_cast< PLFLT >(val2);
17322 arg3 =
static_cast< PLFLT >(val3);
17327 arg4 =
static_cast< PLFLT >(val4);
17332 arg5 =
static_cast< PLFLT >(val5);
17337 arg6 =
static_cast< PLFLT >(val6);
17342 arg7 =
static_cast< PLFLT >(val7);
17347 arg8 =
static_cast< PLBOOL >(val8);
17348 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
17349 _outv = octave_value();
17353 return octave_value_list();
17388 octave_value_list _out;
17389 octave_value_list *_outp=&_out;
17390 octave_value _outv;
17400 arg1 =
static_cast< PLFLT >(val1);
17405 arg2 =
static_cast< PLFLT >(val2);
17410 arg3 =
reinterpret_cast< char *
>(buf3);
17415 arg4 =
static_cast< PLFLT >(val4);
17420 arg5 =
static_cast< PLINT >(val5);
17425 arg6 =
reinterpret_cast< char *
>(buf6);
17430 arg7 =
static_cast< PLFLT >(val7);
17435 arg8 =
static_cast< PLINT >(val8);
17436 plaxes(arg1,arg2,(
char const *)arg3,arg4,arg5,(
char const *)arg6,arg7,arg8);
17437 _outv = octave_value();
17445 return octave_value_list();
17464 octave_value_list _out;
17465 octave_value_list *_outp=&_out;
17466 octave_value _outv;
17473 if (
_n_dims( args(0) ) > 1 )
17478 temp1 = args(0).matrix_value();
17479 arg2 = &temp1( 0, 0 );
17482 if (
_n_dims( args(1) ) > 1 )
17490 temp3 = args(1).matrix_value();
17491 arg3 = &temp3( 0, 0 );
17497 arg4 =
static_cast< PLINT >(val4);
17498 plbin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
17499 _outv = octave_value();
17515 return octave_value_list();
17551 octave_value_list _out;
17552 octave_value_list *_outp=&_out;
17553 octave_value _outv;
17569 arg7 =
static_cast< PLFLT >(val7);
17570 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17571 _outv = octave_value();
17611 return octave_value_list();
17620 octave_value_list _out;
17621 octave_value_list *_outp=&_out;
17622 octave_value _outv;
17629 _outv = octave_value();
17633 return octave_value_list();
17662 octave_value_list _out;
17663 octave_value_list *_outp=&_out;
17664 octave_value _outv;
17674 arg1 =
reinterpret_cast< char *
>(buf1);
17679 arg2 =
static_cast< PLFLT >(val2);
17684 arg3 =
static_cast< PLINT >(val3);
17689 arg4 =
reinterpret_cast< char *
>(buf4);
17694 arg5 =
static_cast< PLFLT >(val5);
17699 arg6 =
static_cast< PLINT >(val6);
17700 plbox((
char const *)arg1,arg2,arg3,(
char const *)arg4,arg5,arg6);
17701 _outv = octave_value();
17709 return octave_value_list();
17762 octave_value_list _out;
17763 octave_value_list *_outp=&_out;
17764 octave_value _outv;
17774 arg1 =
reinterpret_cast< char *
>(buf1);
17779 arg2 =
reinterpret_cast< char *
>(buf2);
17784 arg3 =
static_cast< PLFLT >(val3);
17789 arg4 =
static_cast< PLINT >(val4);
17794 arg5 =
reinterpret_cast< char *
>(buf5);
17799 arg6 =
reinterpret_cast< char *
>(buf6);
17804 arg7 =
static_cast< PLFLT >(val7);
17809 arg8 =
static_cast< PLINT >(val8);
17814 arg9 =
reinterpret_cast< char *
>(buf9);
17819 arg10 =
reinterpret_cast< char *
>(buf10);
17824 arg11 =
static_cast< PLFLT >(val11);
17829 arg12 =
static_cast< PLINT >(val12);
17830 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);
17831 _outv = octave_value();
17847 return octave_value_list();
17877 octave_value_list _out;
17878 octave_value_list *_outp=&_out;
17879 octave_value _outv;
17892 arg1 =
static_cast< PLFLT >(val1);
17897 arg2 =
static_cast< PLFLT >(val2);
17899 _outv = octave_value();
17921 return octave_value_list();
17930 octave_value_list _out;
17931 octave_value_list *_outp=&_out;
17932 octave_value _outv;
17939 _outv = octave_value();
17943 return octave_value_list();
17955 octave_value_list _out;
17956 octave_value_list *_outp=&_out;
17957 octave_value _outv;
17967 arg1 =
static_cast< PLINT >(val1);
17969 _outv = octave_value();
17973 return octave_value_list();
17985 octave_value_list _out;
17986 octave_value_list *_outp=&_out;
17987 octave_value _outv;
17997 arg1 =
static_cast< PLFLT >(val1);
17999 _outv = octave_value();
18003 return octave_value_list();
18045 octave_value_list _out;
18046 octave_value_list *_outp=&_out;
18047 octave_value _outv;
18057 arg1 =
static_cast< PLFLT >(val1);
18062 arg2 =
static_cast< PLFLT >(val2);
18067 arg3 =
static_cast< PLFLT >(val3);
18072 arg4 =
static_cast< PLINT >(val4);
18077 arg5 =
static_cast< PLBOOL >(val5);
18082 arg6 =
static_cast< PLINT >(val6);
18087 arg7 =
static_cast< PLINT >(val7);
18092 arg8 =
static_cast< PLINT >(val8);
18097 arg9 =
static_cast< PLINT >(val9);
18102 arg10 =
static_cast< PLINT >(val10);
18107 arg11 =
static_cast< PLFLT >(val11);
18108 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
18109 _outv = octave_value();
18113 return octave_value_list();
18143 octave_value_list _out;
18144 octave_value_list *_outp=&_out;
18145 octave_value _outv;
18156 arg1 =
static_cast< PLINT >(val1);
18161 arg2 =
static_cast< PLINT >(val2);
18166 arg3 =
static_cast< PLINT >(val3);
18171 arg4 =
static_cast< PLINT >(val4);
18176 arg5 =
static_cast< PLINT >(val5);
18181 arg6 =
static_cast< PLFLT >(val6);
18182 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
18183 _outv = octave_value();
18193 return octave_value_list();
18208 octave_value_list _out;
18209 octave_value_list *_outp=&_out;
18210 octave_value _outv;
18220 arg1 =
static_cast< PLINT >(val1);
18225 arg2 =
static_cast< PLBOOL >(val2);
18227 _outv = octave_value();
18231 return octave_value_list();
18240 octave_value_list _out;
18241 octave_value_list *_outp=&_out;
18242 octave_value _outv;
18249 _outv = octave_value();
18253 return octave_value_list();
18262 octave_value_list _out;
18263 octave_value_list *_outp=&_out;
18264 octave_value _outv;
18271 _outv = octave_value();
18275 return octave_value_list();
18302 octave_value_list _out;
18303 octave_value_list *_outp=&_out;
18304 octave_value _outv;
18314 arg1 =
static_cast< PLFLT >(val1);
18319 arg2 =
static_cast< PLFLT >(val2);
18324 arg3 =
static_cast< PLFLT >(val3);
18329 arg4 =
static_cast< PLFLT >(val4);
18334 arg5 =
static_cast< PLINT >(val5);
18339 arg6 =
static_cast< PLINT >(val6);
18340 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
18341 _outv = octave_value();
18345 return octave_value_list();
18372 octave_value_list _out;
18373 octave_value_list *_outp=&_out;
18374 octave_value _outv;
18384 arg1 =
static_cast< PLFLT >(val1);
18389 arg2 =
static_cast< PLFLT >(val2);
18394 arg3 =
static_cast< PLFLT >(val3);
18399 arg4 =
static_cast< PLFLT >(val4);
18404 arg5 =
static_cast< PLINT >(val5);
18409 arg6 =
static_cast< PLINT >(val6);
18410 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
18411 _outv = octave_value();
18415 return octave_value_list();
18424 octave_value_list _out;
18425 octave_value_list *_outp=&_out;
18426 octave_value _outv;
18433 _outv = octave_value();
18437 return octave_value_list();
18453 octave_value_list _out;
18454 octave_value_list *_outp=&_out;
18455 octave_value _outv;
18462 if (
_n_dims( args(0) ) > 1 )
18467 temp1 = args(0).matrix_value();
18468 arg2 = &temp1( 0, 0 );
18471 if (
_n_dims( args(1) ) > 1 )
18479 temp3 = args(1).matrix_value();
18480 arg3 = &temp3( 0, 0 );
18483 if (
_n_dims( args(2) ) > 1 )
18491 temp4 = args(2).matrix_value();
18492 arg4 = &temp4( 0, 0 );
18494 plerrx(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18495 _outv = octave_value();
18517 return octave_value_list();
18542 octave_value_list _out;
18543 octave_value_list *_outp=&_out;
18544 octave_value _outv;
18551 if (
_n_dims( args(0) ) > 1 )
18556 temp1 = args(0).matrix_value();
18557 arg2 = &temp1( 0, 0 );
18560 if (
_n_dims( args(1) ) > 1 )
18568 temp3 = args(1).matrix_value();
18569 arg3 = &temp3( 0, 0 );
18572 if (
_n_dims( args(2) ) > 1 )
18580 temp4 = args(2).matrix_value();
18581 arg4 = &temp4( 0, 0 );
18583 plerry(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18584 _outv = octave_value();
18606 return octave_value_list();
18624 octave_value_list _out;
18625 octave_value_list *_outp=&_out;
18626 octave_value _outv;
18633 _outv = octave_value();
18637 return octave_value_list();
18651 octave_value_list _out;
18652 octave_value_list *_outp=&_out;
18653 octave_value _outv;
18660 if (
_n_dims( args(0) ) > 1 )
18665 temp1 = args(0).matrix_value();
18666 arg2 = &temp1( 0, 0 );
18669 if (
_n_dims( args(1) ) > 1 )
18677 temp3 = args(1).matrix_value();
18678 arg3 = &temp3( 0, 0 );
18680 plfill(arg1,(
double const *)arg2,(
double const *)arg3);
18681 _outv = octave_value();
18697 return octave_value_list();
18719 octave_value_list _out;
18720 octave_value_list *_outp=&_out;
18721 octave_value _outv;
18728 if (
_n_dims( args(0) ) > 1 )
18733 temp1 = args(0).matrix_value();
18734 arg2 = &temp1( 0, 0 );
18737 if (
_n_dims( args(1) ) > 1 )
18745 temp3 = args(1).matrix_value();
18746 arg3 = &temp3( 0, 0 );
18749 if (
_n_dims( args(2) ) > 1 )
18757 temp4 = args(2).matrix_value();
18758 arg4 = &temp4( 0, 0 );
18760 plfill3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
18761 _outv = octave_value();
18783 return octave_value_list();
18809 octave_value_list _out;
18810 octave_value_list *_outp=&_out;
18811 octave_value _outv;
18818 if (
_n_dims( args(0) ) > 1 )
18823 temp1 = args(0).matrix_value();
18824 arg2 = &temp1( 0, 0 );
18827 if (
_n_dims( args(1) ) > 1 )
18835 temp3 = args(1).matrix_value();
18836 arg3 = &temp3( 0, 0 );
18842 arg4 =
static_cast< PLFLT >(val4);
18843 plgradient(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
18844 _outv = octave_value();
18860 return octave_value_list();
18875 octave_value_list _out;
18876 octave_value_list *_outp=&_out;
18877 octave_value _outv;
18884 _outv = octave_value();
18888 return octave_value_list();
18900 octave_value_list _out;
18901 octave_value_list *_outp=&_out;
18902 octave_value _outv;
18912 arg1 =
static_cast< PLINT >(val1);
18914 _outv = octave_value();
18918 return octave_value_list();
18930 octave_value_list _out;
18931 octave_value_list *_outp=&_out;
18932 octave_value _outv;
18942 arg1 =
static_cast< PLINT >(val1);
18944 _outv = octave_value();
18948 return octave_value_list();
18963 octave_value_list _out;
18964 octave_value_list *_outp=&_out;
18965 octave_value _outv;
18974 _outv = octave_value();
18990 return octave_value_list();
19011 octave_value_list _out;
19012 octave_value_list *_outp=&_out;
19013 octave_value _outv;
19026 arg1 =
static_cast< PLINT >(val1);
19027 plgcol0(arg1,arg2,arg3,arg4);
19028 _outv = octave_value();
19050 return octave_value_list();
19074 octave_value_list _out;
19075 octave_value_list *_outp=&_out;
19076 octave_value _outv;
19090 arg1 =
static_cast< PLINT >(val1);
19091 plgcol0a(arg1,arg2,arg3,arg4,arg5);
19092 _outv = octave_value();
19120 return octave_value_list();
19138 octave_value_list _out;
19139 octave_value_list *_outp=&_out;
19140 octave_value _outv;
19150 _outv = octave_value();
19172 return octave_value_list();
19193 octave_value_list _out;
19194 octave_value_list *_outp=&_out;
19195 octave_value _outv;
19206 _outv = octave_value();
19234 return octave_value_list();
19246 octave_value_list _out;
19247 octave_value_list *_outp=&_out;
19248 octave_value _outv;
19256 _outv = octave_value();
19266 return octave_value_list();
19276 char local_string1[80] ;
19277 size_t local_string_length1 ;
19278 charMatrix local_charMatrix1 ;
19279 octave_value_list retval1 ;
19280 octave_value_list _out;
19281 octave_value_list *_outp=&_out;
19282 octave_value _outv;
19286 arg1 = local_string1;
19292 _outv = octave_value();
19295 local_string_length1 = strlen( local_string1 );
19296 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19297 local_charMatrix1.insert( local_string1, 0, 0 );
19298 retval1( 0 ) = octave_value( local_charMatrix1 );
19303 return octave_value_list();
19324 octave_value_list _out;
19325 octave_value_list *_outp=&_out;
19326 octave_value _outv;
19337 _outv = octave_value();
19365 return octave_value_list();
19377 octave_value_list _out;
19378 octave_value_list *_outp=&_out;
19379 octave_value _outv;
19387 _outv = octave_value();
19397 return octave_value_list();
19418 octave_value_list _out;
19419 octave_value_list *_outp=&_out;
19420 octave_value _outv;
19431 _outv = octave_value();
19459 return octave_value_list();
19477 octave_value_list _out;
19478 octave_value_list *_outp=&_out;
19479 octave_value _outv;
19489 _outv = octave_value();
19511 return octave_value_list();
19523 octave_value_list _out;
19524 octave_value_list *_outp=&_out;
19525 octave_value _outv;
19533 _outv = octave_value();
19543 return octave_value_list();
19553 char local_string1[80] ;
19554 size_t local_string_length1 ;
19555 charMatrix local_charMatrix1 ;
19556 octave_value_list retval1 ;
19557 octave_value_list _out;
19558 octave_value_list *_outp=&_out;
19559 octave_value _outv;
19563 arg1 = local_string1;
19569 _outv = octave_value();
19572 local_string_length1 = strlen( local_string1 );
19573 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19574 local_charMatrix1.insert( local_string1, 0, 0 );
19575 retval1( 0 ) = octave_value( local_charMatrix1 );
19580 return octave_value_list();
19598 octave_value_list _out;
19599 octave_value_list *_outp=&_out;
19600 octave_value _outv;
19610 _outv = octave_value();
19632 return octave_value_list();
19644 octave_value_list _out;
19645 octave_value_list *_outp=&_out;
19646 octave_value _outv;
19654 _outv = octave_value();
19664 return octave_value_list();
19691 octave_value_list _out;
19692 octave_value_list *_outp=&_out;
19693 octave_value _outv;
19705 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
19706 _outv = octave_value();
19746 return octave_value_list();
19755 octave_value_list _out;
19756 octave_value_list *_outp=&_out;
19757 octave_value _outv;
19764 _outv = octave_value();
19768 return octave_value_list();
19789 octave_value_list _out;
19790 octave_value_list *_outp=&_out;
19791 octave_value _outv;
19801 plgspa(arg1,arg2,arg3,arg4);
19802 _outv = octave_value();
19830 return octave_value_list();
19842 octave_value_list _out;
19843 octave_value_list *_outp=&_out;
19844 octave_value _outv;
19852 _outv = octave_value();
19862 return octave_value_list();
19872 char local_string1[80] ;
19873 size_t local_string_length1 ;
19874 charMatrix local_charMatrix1 ;
19875 octave_value_list retval1 ;
19876 octave_value_list _out;
19877 octave_value_list *_outp=&_out;
19878 octave_value _outv;
19882 arg1 = local_string1;
19888 _outv = octave_value();
19891 local_string_length1 = strlen( local_string1 );
19892 local_charMatrix1 = charMatrix( 1, local_string_length1 );
19893 local_charMatrix1.insert( local_string1, 0, 0 );
19894 retval1( 0 ) = octave_value( local_charMatrix1 );
19899 return octave_value_list();
19920 octave_value_list _out;
19921 octave_value_list *_outp=&_out;
19922 octave_value _outv;
19932 plgvpd(arg1,arg2,arg3,arg4);
19933 _outv = octave_value();
19961 return octave_value_list();
19982 octave_value_list _out;
19983 octave_value_list *_outp=&_out;
19984 octave_value _outv;
19994 plgvpw(arg1,arg2,arg3,arg4);
19995 _outv = octave_value();
20023 return octave_value_list();
20038 octave_value_list _out;
20039 octave_value_list *_outp=&_out;
20040 octave_value _outv;
20049 _outv = octave_value();
20065 return octave_value_list();
20080 octave_value_list _out;
20081 octave_value_list *_outp=&_out;
20082 octave_value _outv;
20091 _outv = octave_value();
20107 return octave_value_list();
20122 octave_value_list _out;
20123 octave_value_list *_outp=&_out;
20124 octave_value _outv;
20133 _outv = octave_value();
20149 return octave_value_list();
20173 octave_value_list _out;
20174 octave_value_list *_outp=&_out;
20175 octave_value _outv;
20182 if (
_n_dims( args(0) ) > 1 )
20187 temp1 = args(0).matrix_value();
20188 arg2 = &temp1( 0, 0 );
20194 arg3 =
static_cast< PLFLT >(val3);
20199 arg4 =
static_cast< PLFLT >(val4);
20204 arg5 =
static_cast< PLINT >(val5);
20209 arg6 =
static_cast< PLINT >(val6);
20210 plhist(arg1,(
double const *)arg2,arg3,arg4,arg5,arg6);
20211 _outv = octave_value();
20221 return octave_value_list();
20251 octave_value_list _out;
20252 octave_value_list *_outp=&_out;
20253 octave_value _outv;
20266 arg1 =
static_cast< PLFLT >(val1);
20271 arg2 =
static_cast< PLFLT >(val2);
20276 arg3 =
static_cast< PLFLT >(val3);
20277 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
20278 _outv = octave_value();
20300 return octave_value_list();
20309 octave_value_list _out;
20310 octave_value_list *_outp=&_out;
20311 octave_value _outv;
20318 _outv = octave_value();
20322 return octave_value_list();
20343 octave_value_list _out;
20344 octave_value_list *_outp=&_out;
20345 octave_value _outv;
20355 arg1 =
static_cast< PLFLT >(val1);
20360 arg2 =
static_cast< PLFLT >(val2);
20365 arg3 =
static_cast< PLFLT >(val3);
20370 arg4 =
static_cast< PLFLT >(val4);
20371 pljoin(arg1,arg2,arg3,arg4);
20372 _outv = octave_value();
20376 return octave_value_list();
20397 octave_value_list _out;
20398 octave_value_list *_outp=&_out;
20399 octave_value _outv;
20409 arg1 =
reinterpret_cast< char *
>(buf1);
20414 arg2 =
reinterpret_cast< char *
>(buf2);
20419 arg3 =
reinterpret_cast< char *
>(buf3);
20420 pllab((
char const *)arg1,(
char const *)arg2,(
char const *)arg3);
20421 _outv = octave_value();
20431 return octave_value_list();
20518 octave_value_list _out;
20519 octave_value_list *_outp=&_out;
20520 octave_value _outv;
20532 arg3 =
static_cast< PLINT >(val3);
20537 arg4 =
static_cast< PLINT >(val4);
20542 arg5 =
static_cast< PLFLT >(val5);
20547 arg6 =
static_cast< PLFLT >(val6);
20552 arg7 =
static_cast< PLFLT >(val7);
20557 arg8 =
static_cast< PLINT >(val8);
20562 arg9 =
static_cast< PLINT >(val9);
20567 arg10 =
static_cast< PLINT >(val10);
20572 arg11 =
static_cast< PLINT >(val11);
20577 arg12 =
static_cast< PLINT >(val12);
20579 if (
_n_dims( args(10) ) > 1 )
20585 temp13 = args(10).matrix_value();
20592 arg15 =
static_cast< PLFLT >(val15);
20597 arg16 =
static_cast< PLFLT >(val16);
20602 arg17 =
static_cast< PLFLT >(val17);
20607 arg18 =
static_cast< PLFLT >(val18);
20609 if (
_n_dims( args(15) ) > 1 )
20613 if (
_dim( args(15), 0 ) !=
Alen )
20617 temp19 = args(15).matrix_value();
20622 charMatrix temp_matrix;
20626 size_t max_length = 0, non_blank_length;
20628 if (
_n_dims( args(16) ) > 2 )
20630 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
20632#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20633 if ( !args(16).isempty() )
20635 if ( !args(16).is_empty() )
20638 if (
_dim( args(16), 0 ) !=
Alen )
20640 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
20642 arg20 =
new char*[
Alen];
20643#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20644 ifcell = args(16).iscell();
20646 ifcell = args(16).is_cell();
20650 temp_cell = args(16).cell_value();
20654 temp_matrix = args(16).char_matrix_value();
20656 max_length =
_dim( args(16), 1 ) + 1;
20659 for ( i = 0; i <
Alen; i++ )
20666 if ( temp_cell.elem( i ).is_string() )
20668 str = temp_cell.elem( i ).string_value();
20670 max_length = str.size() + 1;
20671 tmp_cstring = (
char *) str.c_str();
20681 tmp_cstring = (
char *)
"";
20686 str = temp_matrix.row_as_string( i );
20687 tmp_cstring = (
char *) str.c_str();
20689 arg20[i] =
new char[max_length];
20690 strncpy( arg20[i], tmp_cstring, max_length - 1 );
20691 arg20[i][max_length - 1] =
'\0';
20706 non_blank_length = max_length - 2;
20707 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
'\0' )
20709 non_blank_length--;
20711 while ( non_blank_length >= 0 && arg20[i][non_blank_length] ==
' ' )
20713 non_blank_length--;
20715 arg20[i][non_blank_length + 1] =
'\0';
20725 if (
_n_dims( args(17) ) > 1 )
20729#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20730 if ( !args(17).isempty() )
20732 if ( !args(17).is_empty() )
20735 if (
_dim( args(17), 0 ) !=
Alen )
20739 temp21 = args(17).matrix_value();
20749 if (
_n_dims( args(18) ) > 1 )
20753#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20754 if ( !args(18).isempty() )
20756 if ( !args(18).is_empty() )
20759 if (
_dim( args(18), 0 ) !=
Alen )
20763 temp22 = args(18).matrix_value();
20773 if (
_n_dims( args(19) ) > 1 )
20777#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20778 if ( !args(19).isempty() )
20780 if ( !args(19).is_empty() )
20783 if (
_dim( args(19), 0 ) !=
Alen )
20787 temp23 = args(19).matrix_value();
20788 arg23 = &temp23( 0, 0 );
20796 if (
_n_dims( args(20) ) > 1 )
20800#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20801 if ( !args(20).isempty() )
20803 if ( !args(20).is_empty() )
20806 if (
_dim( args(20), 0 ) !=
Alen )
20810 temp24 = args(20).matrix_value();
20811 arg24 = &temp24( 0, 0 );
20819 if (
_n_dims( args(21) ) > 1 )
20823#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20824 if ( !args(21).isempty() )
20826 if ( !args(21).is_empty() )
20829 if (
_dim( args(21), 0 ) !=
Alen )
20833 temp25 = args(21).matrix_value();
20843 if (
_n_dims( args(22) ) > 1 )
20847#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20848 if ( !args(22).isempty() )
20850 if ( !args(22).is_empty() )
20853 if (
_dim( args(22), 0 ) !=
Alen )
20857 temp26 = args(22).matrix_value();
20867 if (
_n_dims( args(23) ) > 1 )
20871#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20872 if ( !args(23).isempty() )
20874 if ( !args(23).is_empty() )
20877 if (
_dim( args(23), 0 ) !=
Alen )
20881 temp27 = args(23).matrix_value();
20882 arg27 = &temp27( 0, 0 );
20890 if (
_n_dims( args(24) ) > 1 )
20894#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20895 if ( !args(24).isempty() )
20897 if ( !args(24).is_empty() )
20900 if (
_dim( args(24), 0 ) !=
Alen )
20904 temp28 = args(24).matrix_value();
20914 if (
_n_dims( args(25) ) > 1 )
20918#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20919 if ( !args(25).isempty() )
20921 if ( !args(25).is_empty() )
20924 if (
_dim( args(25), 0 ) !=
Alen )
20928 temp29 = args(25).matrix_value();
20929 arg29 = &temp29( 0, 0 );
20937 if (
_n_dims( args(26) ) > 1 )
20941#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20942 if ( !args(26).isempty() )
20944 if ( !args(26).is_empty() )
20947 if (
_dim( args(26), 0 ) !=
Alen )
20951 temp30 = args(26).matrix_value();
20961 charMatrix temp_matrix;
20965 size_t max_length = 0, non_blank_length;
20967 if (
_n_dims( args(27) ) > 2 )
20969 error(
"argument must be a scalar or vector or matrix" );
SWIG_fail;
20971#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20972 if ( !args(27).isempty() )
20974 if ( !args(27).is_empty() )
20977 if (
_dim( args(27), 0 ) !=
Alen )
20979 error(
"first dimension must be same length as previous vector" );
SWIG_fail;
20981 arg31 =
new char*[
Alen];
20982#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20983 ifcell = args(27).iscell();
20985 ifcell = args(27).is_cell();
20989 temp_cell = args(27).cell_value();
20993 temp_matrix = args(27).char_matrix_value();
20995 max_length =
_dim( args(27), 1 ) + 1;
20998 for ( i = 0; i <
Alen; i++ )
21005 if ( temp_cell.elem( i ).is_string() )
21007 str = temp_cell.elem( i ).string_value();
21009 max_length = str.size() + 1;
21010 tmp_cstring = (
char *) str.c_str();
21020 tmp_cstring = (
char *)
"";
21025 str = temp_matrix.row_as_string( i );
21026 tmp_cstring = (
char *) str.c_str();
21028 arg31[i] =
new char[max_length];
21029 strncpy( arg31[i], tmp_cstring, max_length - 1 );
21030 arg31[i][max_length - 1] =
'\0';
21045 non_blank_length = max_length - 2;
21046 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
'\0' )
21048 non_blank_length--;
21050 while ( non_blank_length >= 0 && arg31[i][non_blank_length] ==
' ' )
21052 non_blank_length--;
21054 arg31[i][non_blank_length + 1] =
'\0';
21063 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);
21064 _outv = octave_value();
21086 if ( arg20 != NULL )
21088 for ( i = 0; i <
Alen; i++ )
21096 if ( arg21 != NULL )
21100 if ( arg22 != NULL )
21110 if ( arg25 != NULL )
21114 if ( arg26 != NULL )
21121 if ( arg28 != NULL )
21128 if ( arg30 != NULL )
21133 if ( arg31 != NULL )
21135 for ( i = 0; i <
Alen; i++ )
21152 if ( arg20 != NULL )
21154 for ( i = 0; i <
Alen; i++ )
21162 if ( arg21 != NULL )
21166 if ( arg22 != NULL )
21176 if ( arg25 != NULL )
21180 if ( arg26 != NULL )
21187 if ( arg28 != NULL )
21194 if ( arg30 != NULL )
21199 if ( arg31 != NULL )
21201 for ( i = 0; i <
Alen; i++ )
21208 return octave_value_list();
21219 if ( arg20 != NULL )
21221 for ( i = 0; i <
Alen; i++ )
21229 if ( arg21 != NULL )
21233 if ( arg22 != NULL )
21243 if ( arg25 != NULL )
21247 if ( arg26 != NULL )
21254 if ( arg28 != NULL )
21261 if ( arg30 != NULL )
21266 if ( arg31 != NULL )
21268 for ( i = 0; i <
Alen; i++ )
21290 octave_value_list _out;
21291 octave_value_list *_outp=&_out;
21292 octave_value _outv;
21302 arg1 =
static_cast< PLFLT >(val1);
21307 arg2 =
static_cast< PLFLT >(val2);
21312 arg3 =
static_cast< PLFLT >(val3);
21314 _outv = octave_value();
21318 return octave_value_list();
21332 octave_value_list _out;
21333 octave_value_list *_outp=&_out;
21334 octave_value _outv;
21341 if (
_n_dims( args(0) ) > 1 )
21346 temp1 = args(0).matrix_value();
21347 arg2 = &temp1( 0, 0 );
21350 if (
_n_dims( args(1) ) > 1 )
21358 temp3 = args(1).matrix_value();
21359 arg3 = &temp3( 0, 0 );
21361 plline(arg1,(
double const *)arg2,(
double const *)arg3);
21362 _outv = octave_value();
21378 return octave_value_list();
21400 octave_value_list _out;
21401 octave_value_list *_outp=&_out;
21402 octave_value _outv;
21409 if (
_n_dims( args(0) ) > 1 )
21414 temp1 = args(0).matrix_value();
21415 arg2 = &temp1( 0, 0 );
21418 if (
_n_dims( args(1) ) > 1 )
21426 temp3 = args(1).matrix_value();
21427 arg3 = &temp3( 0, 0 );
21430 if (
_n_dims( args(2) ) > 1 )
21438 temp4 = args(2).matrix_value();
21439 arg4 = &temp4( 0, 0 );
21441 plline3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4);
21442 _outv = octave_value();
21464 return octave_value_list();
21485 octave_value_list _out;
21486 octave_value_list *_outp=&_out;
21487 octave_value _outv;
21497 arg1 =
static_cast< PLINT >(val1);
21499 _outv = octave_value();
21503 return octave_value_list();
21515 octave_value_list _out;
21516 octave_value_list *_outp=&_out;
21517 octave_value _outv;
21525 _outv = octave_value();
21535 return octave_value_list();
21561 octave_value_list _out;
21562 octave_value_list *_outp=&_out;
21563 octave_value _outv;
21573 arg1 =
reinterpret_cast< char *
>(buf1);
21578 arg2 =
static_cast< PLFLT >(val2);
21583 arg3 =
static_cast< PLFLT >(val3);
21588 arg4 =
static_cast< PLFLT >(val4);
21593 arg5 =
reinterpret_cast< char *
>(buf5);
21594 plmtex((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
21595 _outv = octave_value();
21603 return octave_value_list();
21631 octave_value_list _out;
21632 octave_value_list *_outp=&_out;
21633 octave_value _outv;
21643 arg1 =
reinterpret_cast< char *
>(buf1);
21648 arg2 =
static_cast< PLFLT >(val2);
21653 arg3 =
static_cast< PLFLT >(val3);
21658 arg4 =
static_cast< PLFLT >(val4);
21663 arg5 =
reinterpret_cast< char *
>(buf5);
21664 plmtex3((
char const *)arg1,arg2,arg3,arg4,(
char const *)arg5);
21665 _outv = octave_value();
21673 return octave_value_list();
21693 octave_value_list _out;
21694 octave_value_list *_outp=&_out;
21695 octave_value _outv;
21706 arg1 =
reinterpret_cast< int *
>(argp1);
21711 arg2 =
reinterpret_cast< char **
>(argp2);
21716 arg3 =
static_cast< PLINT >(val3);
21722 return octave_value_list();
21736 octave_value_list _out;
21737 octave_value_list *_outp=&_out;
21738 octave_value _outv;
21745 if (
_n_dims( args(0) ) > 1 )
21751 temp1 = args(0).matrix_value();
21755 if (
_n_dims( args(1) ) > 1 )
21763 temp3 = args(1).matrix_value();
21767 plpat(arg1,(
int const *)arg2,(
int const *)arg3);
21768 _outv = octave_value();
21784 return octave_value_list();
21814 octave_value_list _out;
21815 octave_value_list *_outp=&_out;
21816 octave_value _outv;
21826 arg1 =
static_cast< PLINT >(val1);
21831 arg2 =
static_cast< PLFLT >(val2);
21836 arg3 =
static_cast< PLFLT >(val3);
21841 arg4 =
static_cast< PLFLT >(val4);
21846 arg5 =
static_cast< PLFLT >(val5);
21847 plpath(arg1,arg2,arg3,arg4,arg5);
21848 _outv = octave_value();
21852 return octave_value_list();
21869 octave_value_list _out;
21870 octave_value_list *_outp=&_out;
21871 octave_value _outv;
21878 if (
_n_dims( args(0) ) > 1 )
21883 temp1 = args(0).matrix_value();
21884 arg2 = &temp1( 0, 0 );
21887 if (
_n_dims( args(1) ) > 1 )
21895 temp3 = args(1).matrix_value();
21896 arg3 = &temp3( 0, 0 );
21902 arg4 =
static_cast< PLINT >(val4);
21903 plpoin(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
21904 _outv = octave_value();
21920 return octave_value_list();
21945 octave_value_list _out;
21946 octave_value_list *_outp=&_out;
21947 octave_value _outv;
21954 if (
_n_dims( args(0) ) > 1 )
21959 temp1 = args(0).matrix_value();
21960 arg2 = &temp1( 0, 0 );
21963 if (
_n_dims( args(1) ) > 1 )
21971 temp3 = args(1).matrix_value();
21972 arg3 = &temp3( 0, 0 );
21975 if (
_n_dims( args(2) ) > 1 )
21983 temp4 = args(2).matrix_value();
21984 arg4 = &temp4( 0, 0 );
21990 arg5 =
static_cast< PLINT >(val5);
21991 plpoin3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,arg5);
21992 _outv = octave_value();
22014 return octave_value_list();
22044 octave_value_list _out;
22045 octave_value_list *_outp=&_out;
22046 octave_value _outv;
22053 if (
_n_dims( args(0) ) > 1 )
22058 temp1 = args(0).matrix_value();
22059 arg2 = &temp1( 0, 0 );
22062 if (
_n_dims( args(1) ) > 1 )
22070 temp3 = args(1).matrix_value();
22071 arg3 = &temp3( 0, 0 );
22074 if (
_n_dims( args(2) ) > 1 )
22082 temp4 = args(2).matrix_value();
22083 arg4 = &temp4( 0, 0 );
22086 if (
_n_dims( args(3) ) > 1 )
22092 error(
"argument vector must be same length or one less" );
SWIG_fail;
22094 temp5 = args(3).matrix_value();
22102 arg6 =
static_cast< PLBOOL >(val6);
22103 plpoly3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
int const *)arg5,arg6);
22104 _outv = octave_value();
22132 return octave_value_list();
22159 octave_value_list _out;
22160 octave_value_list *_outp=&_out;
22161 octave_value _outv;
22171 arg1 =
static_cast< PLINT >(val1);
22176 arg2 =
static_cast< PLINT >(val2);
22178 _outv = octave_value();
22182 return octave_value_list();
22194 octave_value_list _out;
22195 octave_value_list *_outp=&_out;
22196 octave_value _outv;
22206 arg1 =
static_cast< PLINT >(val1);
22208 _outv = octave_value();
22212 return octave_value_list();
22240 octave_value_list _out;
22241 octave_value_list *_outp=&_out;
22242 octave_value _outv;
22252 arg1 =
static_cast< PLFLT >(val1);
22257 arg2 =
static_cast< PLFLT >(val2);
22262 arg3 =
static_cast< PLFLT >(val3);
22267 arg4 =
static_cast< PLFLT >(val4);
22272 arg5 =
static_cast< PLFLT >(val5);
22277 arg6 =
reinterpret_cast< char *
>(buf6);
22278 plptex(arg1,arg2,arg3,arg4,arg5,(
char const *)arg6);
22279 _outv = octave_value();
22285 return octave_value_list();
22329 octave_value_list _out;
22330 octave_value_list *_outp=&_out;
22331 octave_value _outv;
22341 arg1 =
static_cast< PLFLT >(val1);
22346 arg2 =
static_cast< PLFLT >(val2);
22351 arg3 =
static_cast< PLFLT >(val3);
22356 arg4 =
static_cast< PLFLT >(val4);
22361 arg5 =
static_cast< PLFLT >(val5);
22366 arg6 =
static_cast< PLFLT >(val6);
22371 arg7 =
static_cast< PLFLT >(val7);
22376 arg8 =
static_cast< PLFLT >(val8);
22381 arg9 =
static_cast< PLFLT >(val9);
22386 arg10 =
static_cast< PLFLT >(val10);
22391 arg11 =
reinterpret_cast< char *
>(buf11);
22392 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(
char const *)arg11);
22393 _outv = octave_value();
22399 return octave_value_list();
22409 octave_value_list _out;
22410 octave_value_list *_outp=&_out;
22411 octave_value _outv;
22423 return octave_value_list();
22432 octave_value_list _out;
22433 octave_value_list *_outp=&_out;
22434 octave_value _outv;
22441 _outv = octave_value();
22445 return octave_value_list();
22472 octave_value_list _out;
22473 octave_value_list *_outp=&_out;
22474 octave_value _outv;
22487 arg1 =
static_cast< PLFLT >(val1);
22492 arg2 =
static_cast< PLFLT >(val2);
22497 arg3 =
static_cast< PLFLT >(val3);
22498 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
22499 _outv = octave_value();
22521 return octave_value_list();
22536 octave_value_list _out;
22537 octave_value_list *_outp=&_out;
22538 octave_value _outv;
22548 arg1 =
static_cast< PLFLT >(val1);
22553 arg2 =
static_cast< PLFLT >(val2);
22555 _outv = octave_value();
22559 return octave_value_list();
22575 octave_value_list _out;
22576 octave_value_list *_outp=&_out;
22577 octave_value _outv;
22584 if (
_n_dims( args(0) ) > 1 )
22589 temp1 = args(0).matrix_value();
22594 if (
_n_dims( args(1) ) > 1 )
22602 temp2 = args(1).matrix_value();
22607 if (
_n_dims( args(2) ) > 1 )
22615 temp3 = args(2).matrix_value();
22620 plscmap0((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
22621 _outv = octave_value();
22643 return octave_value_list();
22670 octave_value_list _out;
22671 octave_value_list *_outp=&_out;
22672 octave_value _outv;
22679 if (
_n_dims( args(0) ) > 1 )
22684 temp1 = args(0).matrix_value();
22689 if (
_n_dims( args(1) ) > 1 )
22697 temp2 = args(1).matrix_value();
22702 if (
_n_dims( args(2) ) > 1 )
22710 temp3 = args(2).matrix_value();
22715 if (
_n_dims( args(3) ) > 1 )
22723 temp4 = args(3).matrix_value();
22724 arg4 = &temp4( 0, 0 );
22727 plscmap0a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
22728 _outv = octave_value();
22756 return octave_value_list();
22780 octave_value_list _out;
22781 octave_value_list *_outp=&_out;
22782 octave_value _outv;
22792 arg1 =
static_cast< PLINT >(val1);
22794 _outv = octave_value();
22798 return octave_value_list();
22814 octave_value_list _out;
22815 octave_value_list *_outp=&_out;
22816 octave_value _outv;
22823 if (
_n_dims( args(0) ) > 1 )
22828 temp1 = args(0).matrix_value();
22833 if (
_n_dims( args(1) ) > 1 )
22841 temp2 = args(1).matrix_value();
22846 if (
_n_dims( args(2) ) > 1 )
22854 temp3 = args(2).matrix_value();
22859 plscmap1((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,arg4);
22860 _outv = octave_value();
22882 return octave_value_list();
22909 octave_value_list _out;
22910 octave_value_list *_outp=&_out;
22911 octave_value _outv;
22918 if (
_n_dims( args(0) ) > 1 )
22923 temp1 = args(0).matrix_value();
22928 if (
_n_dims( args(1) ) > 1 )
22936 temp2 = args(1).matrix_value();
22941 if (
_n_dims( args(2) ) > 1 )
22949 temp3 = args(2).matrix_value();
22954 if (
_n_dims( args(3) ) > 1 )
22962 temp4 = args(3).matrix_value();
22963 arg4 = &temp4( 0, 0 );
22966 plscmap1a((
int const *)arg1,(
int const *)arg2,(
int const *)arg3,(
double const *)arg4,arg5);
22967 _outv = octave_value();
22995 return octave_value_list();
23030 octave_value_list _out;
23031 octave_value_list *_outp=&_out;
23032 octave_value _outv;
23042 arg1 =
static_cast< PLBOOL >(val1);
23044 if (
_n_dims( args(1) ) > 1 )
23049 temp2 = args(1).matrix_value();
23050 arg3 = &temp2( 0, 0 );
23053 if (
_n_dims( args(2) ) > 1 )
23061 temp4 = args(2).matrix_value();
23062 arg4 = &temp4( 0, 0 );
23065 if (
_n_dims( args(3) ) > 1 )
23073 temp5 = args(3).matrix_value();
23074 arg5 = &temp5( 0, 0 );
23077 if (
_n_dims( args(4) ) > 1 )
23085 temp6 = args(4).matrix_value();
23086 arg6 = &temp6( 0, 0 );
23089 if (
_n_dims( args(5) ) > 1 )
23095 error(
"argument vector must be same length or one less" );
SWIG_fail;
23097 temp7 = args(5).matrix_value();
23101 plscmap1l(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
int const *)arg7);
23102 _outv = octave_value();
23136 return octave_value_list();
23176 octave_value_list _out;
23177 octave_value_list *_outp=&_out;
23178 octave_value _outv;
23188 arg1 =
static_cast< PLBOOL >(val1);
23190 if (
_n_dims( args(1) ) > 1 )
23195 temp2 = args(1).matrix_value();
23196 arg3 = &temp2( 0, 0 );
23199 if (
_n_dims( args(2) ) > 1 )
23207 temp4 = args(2).matrix_value();
23208 arg4 = &temp4( 0, 0 );
23211 if (
_n_dims( args(3) ) > 1 )
23219 temp5 = args(3).matrix_value();
23220 arg5 = &temp5( 0, 0 );
23223 if (
_n_dims( args(4) ) > 1 )
23231 temp6 = args(4).matrix_value();
23232 arg6 = &temp6( 0, 0 );
23235 if (
_n_dims( args(5) ) > 1 )
23243 temp7 = args(5).matrix_value();
23244 arg7 = &temp7( 0, 0 );
23247 if (
_n_dims( args(6) ) > 1 )
23253 error(
"argument vector must be same length or one less" );
SWIG_fail;
23255 temp8 = args(6).matrix_value();
23259 plscmap1la(arg1,arg2,(
double const *)arg3,(
double const *)arg4,(
double const *)arg5,(
double const *)arg6,(
double const *)arg7,(
int const *)arg8);
23260 _outv = octave_value();
23300 return octave_value_list();
23330 octave_value_list _out;
23331 octave_value_list *_outp=&_out;
23332 octave_value _outv;
23342 arg1 =
static_cast< PLINT >(val1);
23344 _outv = octave_value();
23348 return octave_value_list();
23363 octave_value_list _out;
23364 octave_value_list *_outp=&_out;
23365 octave_value _outv;
23375 arg1 =
static_cast< PLFLT >(val1);
23380 arg2 =
static_cast< PLFLT >(val2);
23382 _outv = octave_value();
23386 return octave_value_list();
23401 octave_value_list _out;
23402 octave_value_list *_outp=&_out;
23403 octave_value _outv;
23412 _outv = octave_value();
23428 return octave_value_list();
23449 octave_value_list _out;
23450 octave_value_list *_outp=&_out;
23451 octave_value _outv;
23461 arg1 =
static_cast< PLINT >(val1);
23466 arg2 =
static_cast< PLINT >(val2);
23471 arg3 =
static_cast< PLINT >(val3);
23476 arg4 =
static_cast< PLINT >(val4);
23477 plscol0(arg1,arg2,arg3,arg4);
23478 _outv = octave_value();
23482 return octave_value_list();
23506 octave_value_list _out;
23507 octave_value_list *_outp=&_out;
23508 octave_value _outv;
23518 arg1 =
static_cast< PLINT >(val1);
23523 arg2 =
static_cast< PLINT >(val2);
23528 arg3 =
static_cast< PLINT >(val3);
23533 arg4 =
static_cast< PLINT >(val4);
23538 arg5 =
static_cast< PLFLT >(val5);
23539 plscol0a(arg1,arg2,arg3,arg4,arg5);
23540 _outv = octave_value();
23544 return octave_value_list();
23562 octave_value_list _out;
23563 octave_value_list *_outp=&_out;
23564 octave_value _outv;
23574 arg1 =
static_cast< PLINT >(val1);
23579 arg2 =
static_cast< PLINT >(val2);
23584 arg3 =
static_cast< PLINT >(val3);
23586 _outv = octave_value();
23590 return octave_value_list();
23611 octave_value_list _out;
23612 octave_value_list *_outp=&_out;
23613 octave_value _outv;
23623 arg1 =
static_cast< PLINT >(val1);
23628 arg2 =
static_cast< PLINT >(val2);
23633 arg3 =
static_cast< PLINT >(val3);
23638 arg4 =
static_cast< PLFLT >(val4);
23640 _outv = octave_value();
23644 return octave_value_list();
23656 octave_value_list _out;
23657 octave_value_list *_outp=&_out;
23658 octave_value _outv;
23668 arg1 =
static_cast< PLINT >(val1);
23670 _outv = octave_value();
23674 return octave_value_list();
23686 octave_value_list _out;
23687 octave_value_list *_outp=&_out;
23688 octave_value _outv;
23698 arg1 =
static_cast< PLINT >(val1);
23700 _outv = octave_value();
23704 return octave_value_list();
23717 octave_value_list _out;
23718 octave_value_list *_outp=&_out;
23719 octave_value _outv;
23729 arg1 =
reinterpret_cast< char *
>(buf1);
23730 plsdev((
char const *)arg1);
23731 _outv = octave_value();
23737 return octave_value_list();
23759 octave_value_list _out;
23760 octave_value_list *_outp=&_out;
23761 octave_value _outv;
23771 arg1 =
static_cast< PLFLT >(val1);
23776 arg2 =
static_cast< PLFLT >(val2);
23781 arg3 =
static_cast< PLFLT >(val3);
23786 arg4 =
static_cast< PLFLT >(val4);
23788 _outv = octave_value();
23792 return octave_value_list();
23819 octave_value_list _out;
23820 octave_value_list *_outp=&_out;
23821 octave_value _outv;
23831 arg1 =
static_cast< PLINT >(val1);
23836 arg2 =
static_cast< PLINT >(val2);
23841 arg3 =
static_cast< PLINT >(val3);
23846 arg4 =
static_cast< PLINT >(val4);
23851 arg5 =
static_cast< PLFLT >(val5);
23856 arg6 =
static_cast< PLFLT >(val6);
23857 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
23858 _outv = octave_value();
23862 return octave_value_list();
23874 octave_value_list _out;
23875 octave_value_list *_outp=&_out;
23876 octave_value _outv;
23886 arg1 =
static_cast< PLFLT >(val1);
23888 _outv = octave_value();
23892 return octave_value_list();
23913 octave_value_list _out;
23914 octave_value_list *_outp=&_out;
23915 octave_value _outv;
23925 arg1 =
static_cast< PLFLT >(val1);
23930 arg2 =
static_cast< PLFLT >(val2);
23935 arg3 =
static_cast< PLFLT >(val3);
23940 arg4 =
static_cast< PLFLT >(val4);
23942 _outv = octave_value();
23946 return octave_value_list();
23967 octave_value_list _out;
23968 octave_value_list *_outp=&_out;
23969 octave_value _outv;
23979 arg1 =
static_cast< PLFLT >(val1);
23984 arg2 =
static_cast< PLFLT >(val2);
23989 arg3 =
static_cast< PLFLT >(val3);
23994 arg4 =
static_cast< PLFLT >(val4);
23996 _outv = octave_value();
24000 return octave_value_list();
24009 unsigned int arg1 ;
24010 unsigned int val1 ;
24012 octave_value_list _out;
24013 octave_value_list *_outp=&_out;
24014 octave_value _outv;
24024 arg1 =
static_cast< unsigned int >(val1);
24026 _outv = octave_value();
24030 return octave_value_list();
24042 octave_value_list _out;
24043 octave_value_list *_outp=&_out;
24044 octave_value _outv;
24054 arg1 =
static_cast< char >(val1);
24056 _outv = octave_value();
24060 return octave_value_list();
24077 octave_value_list _out;
24078 octave_value_list *_outp=&_out;
24079 octave_value _outv;
24090 arg1 =
reinterpret_cast< char *
>(buf1);
24095 arg2 =
reinterpret_cast< char *
>(buf2);
24096 result = (
PLINT)
plsetopt((
char const *)arg1,(
char const *)arg2);
24105 return octave_value_list();
24125 octave_value_list _out;
24126 octave_value_list *_outp=&_out;
24127 octave_value _outv;
24137 arg1 =
static_cast< PLINT >(val1);
24142 arg2 =
static_cast< PLINT >(val2);
24147 arg3 =
static_cast< PLINT >(val3);
24149 _outv = octave_value();
24153 return octave_value_list();
24163 unsigned int val1 ;
24165 octave_value_list _out;
24166 octave_value_list *_outp=&_out;
24167 octave_value _outv;
24179 _outv = octave_value();
24183 return octave_value_list();
24196 octave_value_list _out;
24197 octave_value_list *_outp=&_out;
24198 octave_value _outv;
24208 arg1 =
reinterpret_cast< char *
>(buf1);
24210 _outv = octave_value();
24216 return octave_value_list();
24235 octave_value_list _out;
24236 octave_value_list *_outp=&_out;
24237 octave_value _outv;
24247 arg1 =
static_cast< PLINT >(val1);
24252 arg2 =
static_cast< PLINT >(val2);
24257 arg3 =
static_cast< PLINT >(val3);
24259 _outv = octave_value();
24263 return octave_value_list();
24275 octave_value_list _out;
24276 octave_value_list *_outp=&_out;
24277 octave_value _outv;
24284 octave_value obj = args(0);
24285#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24286 if ( !obj.isempty() )
24288 if ( !obj.is_empty() )
24291 if ( obj.is_function_handle() || obj.is_inline_function() )
24295 else if ( obj.is_string() )
24312 _outv = octave_value();
24316 return octave_value_list();
24331 octave_value_list _out;
24332 octave_value_list *_outp=&_out;
24333 octave_value _outv;
24343 arg1 =
static_cast< PLFLT >(val1);
24348 arg2 =
static_cast< PLFLT >(val2);
24350 _outv = octave_value();
24354 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);
24388 _outv = octave_value();
24392 return octave_value_list();
24404 octave_value_list _out;
24405 octave_value_list *_outp=&_out;
24406 octave_value _outv;
24416 arg1 =
static_cast< PLINT >(val1);
24418 _outv = octave_value();
24422 return octave_value_list();
24449 octave_value_list _out;
24450 octave_value_list *_outp=&_out;
24451 octave_value _outv;
24461 arg1 =
static_cast< PLFLT >(val1);
24466 arg2 =
static_cast< PLFLT >(val2);
24471 arg3 =
static_cast< PLINT >(val3);
24476 arg4 =
static_cast< PLINT >(val4);
24481 arg5 =
static_cast< PLINT >(val5);
24486 arg6 =
static_cast< PLINT >(val6);
24487 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
24488 _outv = octave_value();
24492 return octave_value_list();
24505 octave_value_list _out;
24506 octave_value_list *_outp=&_out;
24507 octave_value _outv;
24517 arg1 =
reinterpret_cast< char *
>(buf1);
24519 _outv = octave_value();
24525 return octave_value_list();
24542 octave_value_list _out;
24543 octave_value_list *_outp=&_out;
24544 octave_value _outv;
24554 arg1 =
reinterpret_cast< char *
>(buf1);
24559 arg2 =
static_cast< PLBOOL >(val2);
24560 plspal1((
char const *)arg1,arg2);
24561 _outv = octave_value();
24567 return octave_value_list();
24580 octave_value_list _out;
24581 octave_value_list *_outp=&_out;
24582 octave_value _outv;
24592 arg1 =
static_cast< PLBOOL >(val1);
24594 _outv = octave_value();
24598 return octave_value_list();
24610 octave_value_list _out;
24611 octave_value_list *_outp=&_out;
24612 octave_value _outv;
24622 arg1 =
static_cast< PLINT >(val1);
24624 _outv = octave_value();
24628 return octave_value_list();
24643 octave_value_list _out;
24644 octave_value_list *_outp=&_out;
24645 octave_value _outv;
24655 arg1 =
static_cast< PLINT >(val1);
24660 arg2 =
static_cast< PLINT >(val2);
24662 _outv = octave_value();
24666 return octave_value_list();
24681 octave_value_list _out;
24682 octave_value_list *_outp=&_out;
24683 octave_value _outv;
24693 arg1 =
static_cast< PLFLT >(val1);
24698 arg2 =
static_cast< PLFLT >(val2);
24700 _outv = octave_value();
24704 return octave_value_list();
24719 octave_value_list _out;
24720 octave_value_list *_outp=&_out;
24721 octave_value _outv;
24731 arg1 =
static_cast< PLINT >(val1);
24736 arg2 =
static_cast< PLINT >(val2);
24738 _outv = octave_value();
24742 return octave_value_list();
24761 octave_value_list _out;
24762 octave_value_list *_outp=&_out;
24763 octave_value _outv;
24773 arg1 =
reinterpret_cast< char *
>(buf1);
24778 arg2 =
static_cast< PLINT >(val2);
24783 arg3 =
static_cast< PLINT >(val3);
24784 plstart((
char const *)arg1,arg2,arg3);
24785 _outv = octave_value();
24791 return octave_value_list();
24804 octave_value_list _out;
24805 octave_value_list *_outp=&_out;
24806 octave_value _outv;
24813 octave_value obj = args(0);
24814#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24815 if ( !obj.isempty() )
24817 if ( !obj.is_empty() )
24820 if ( obj.is_function_handle() || obj.is_inline_function() )
24824 else if ( obj.is_string() )
24841 _outv = octave_value();
24845 return octave_value_list();
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 );
24896 arg4 =
reinterpret_cast< char *
>(buf4);
24897 plstring(arg1,(
double const *)arg2,(
double const *)arg3,(
char const *)arg4);
24898 _outv = octave_value();
24916 return octave_value_list();
24943 octave_value_list _out;
24944 octave_value_list *_outp=&_out;
24945 octave_value _outv;
24952 if (
_n_dims( args(0) ) > 1 )
24957 temp1 = args(0).matrix_value();
24958 arg2 = &temp1( 0, 0 );
24961 if (
_n_dims( args(1) ) > 1 )
24969 temp3 = args(1).matrix_value();
24970 arg3 = &temp3( 0, 0 );
24973 if (
_n_dims( args(2) ) > 1 )
24981 temp4 = args(2).matrix_value();
24982 arg4 = &temp4( 0, 0 );
24988 arg5 =
reinterpret_cast< char *
>(buf5);
24989 plstring3(arg1,(
double const *)arg2,(
double const *)arg3,(
double const *)arg4,(
char const *)arg5);
24990 _outv = octave_value();
25014 return octave_value_list();
25045 octave_value_list _out;
25046 octave_value_list *_outp=&_out;
25047 octave_value _outv;
25057 arg1 =
static_cast< PLINT >(val1);
25062 arg2 =
static_cast< PLINT >(val2);
25067 arg3 =
static_cast< PLFLT >(val3);
25072 arg4 =
static_cast< PLFLT >(val4);
25074 _outv = octave_value();
25078 return octave_value_list();
25090 octave_value_list _out;
25091 octave_value_list *_outp=&_out;
25092 octave_value _outv;
25102 arg1 =
static_cast< PLINT >(val1);
25104 _outv = octave_value();
25108 return octave_value_list();
25122 octave_value_list _out;
25123 octave_value_list *_outp=&_out;
25124 octave_value _outv;
25131 if (
_n_dims( args(0) ) > 1 )
25137 temp1 = args(0).matrix_value();
25141 if (
_n_dims( args(1) ) > 1 )
25149 temp3 = args(1).matrix_value();
25153 plstyl(arg1,(
int const *)arg2,(
int const *)arg3);
25154 _outv = octave_value();
25170 return octave_value_list();
25193 octave_value_list _out;
25194 octave_value_list *_outp=&_out;
25195 octave_value _outv;
25202 if (
_n_dims( args(0) ) > 1 )
25206#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25207 if ( !args(0).isempty() )
25209 if ( !args(0).is_empty() )
25213 temp1 = args(0).matrix_value();
25214 arg1 = &temp1( 0, 0 );
25223 if (
_n_dims( args(1) ) > 1 )
25227#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25228 if ( !args(1).isempty() )
25230 if ( !args(1).is_empty() )
25237 temp2 = args(1).matrix_value();
25238 arg2 = &temp2( 0, 0 );
25251 arg4 =
static_cast< PLBOOL >(val4);
25252 plsvect((
double const *)arg1,(
double const *)arg2,arg3,arg4);
25253 _outv = octave_value();
25269 return octave_value_list();
25296 octave_value_list _out;
25297 octave_value_list *_outp=&_out;
25298 octave_value _outv;
25308 arg1 =
static_cast< PLFLT >(val1);
25313 arg2 =
static_cast< PLFLT >(val2);
25318 arg3 =
static_cast< PLFLT >(val3);
25323 arg4 =
static_cast< PLFLT >(val4);
25324 plsvpa(arg1,arg2,arg3,arg4);
25325 _outv = octave_value();
25329 return octave_value_list();
25344 octave_value_list _out;
25345 octave_value_list *_outp=&_out;
25346 octave_value _outv;
25356 arg1 =
static_cast< PLINT >(val1);
25361 arg2 =
static_cast< PLINT >(val2);
25363 _outv = octave_value();
25367 return octave_value_list();
25382 octave_value_list _out;
25383 octave_value_list *_outp=&_out;
25384 octave_value _outv;
25394 arg1 =
static_cast< PLINT >(val1);
25399 arg2 =
static_cast< PLINT >(val2);
25401 _outv = octave_value();
25405 return octave_value_list();
25422 octave_value_list _out;
25423 octave_value_list *_outp=&_out;
25424 octave_value _outv;
25431 if (
_n_dims( args(0) ) > 1 )
25436 temp1 = args(0).matrix_value();
25437 arg2 = &temp1( 0, 0 );
25440 if (
_n_dims( args(1) ) > 1 )
25448 temp3 = args(1).matrix_value();
25449 arg3 = &temp3( 0, 0 );
25455 arg4 =
static_cast< PLINT >(val4);
25456 plsym(arg1,(
double const *)arg2,(
double const *)arg3,arg4);
25457 _outv = octave_value();
25473 return octave_value_list();
25494 octave_value_list _out;
25495 octave_value_list *_outp=&_out;
25496 octave_value _outv;
25506 arg1 =
static_cast< PLINT >(val1);
25511 arg2 =
static_cast< PLINT >(val2);
25513 _outv = octave_value();
25517 return octave_value_list();
25526 octave_value_list _out;
25527 octave_value_list *_outp=&_out;
25528 octave_value _outv;
25535 _outv = octave_value();
25539 return octave_value_list();
25552 octave_value_list _out;
25553 octave_value_list *_outp=&_out;
25554 octave_value _outv;
25564 arg1 =
reinterpret_cast< char *
>(buf1);
25566 _outv = octave_value();
25572 return octave_value_list();
25585 octave_value_list _out;
25586 octave_value_list *_outp=&_out;
25587 octave_value _outv;
25597 arg1 =
static_cast< PLFLT >(val1);
25599 _outv = octave_value();
25603 return octave_value_list();
25627 octave_value_list _out;
25628 octave_value_list *_outp=&_out;
25629 octave_value _outv;
25639 arg1 =
static_cast< PLFLT >(val1);
25644 arg2 =
static_cast< PLFLT >(val2);
25649 arg3 =
static_cast< PLFLT >(val3);
25654 arg4 =
static_cast< PLFLT >(val4);
25659 arg5 =
static_cast< PLFLT >(val5);
25660 plvpas(arg1,arg2,arg3,arg4,arg5);
25661 _outv = octave_value();
25665 return octave_value_list();
25686 octave_value_list _out;
25687 octave_value_list *_outp=&_out;
25688 octave_value _outv;
25698 arg1 =
static_cast< PLFLT >(val1);
25703 arg2 =
static_cast< PLFLT >(val2);
25708 arg3 =
static_cast< PLFLT >(val3);
25713 arg4 =
static_cast< PLFLT >(val4);
25714 plvpor(arg1,arg2,arg3,arg4);
25715 _outv = octave_value();
25719 return octave_value_list();
25728 octave_value_list _out;
25729 octave_value_list *_outp=&_out;
25730 octave_value _outv;
25737 _outv = octave_value();
25741 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);
25800 arg2 =
static_cast< PLFLT >(val2);
25805 arg3 =
static_cast< PLFLT >(val3);
25810 arg4 =
static_cast< PLFLT >(val4);
25815 arg5 =
static_cast< PLFLT >(val5);
25820 arg6 =
static_cast< PLFLT >(val6);
25825 arg7 =
static_cast< PLFLT >(val7);
25830 arg8 =
static_cast< PLFLT >(val8);
25835 arg9 =
static_cast< PLFLT >(val9);
25840 arg10 =
static_cast< PLFLT >(val10);
25845 arg11 =
static_cast< PLFLT >(val11);
25846 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25847 _outv = octave_value();
25851 return octave_value_list();
25863 octave_value_list _out;
25864 octave_value_list *_outp=&_out;
25865 octave_value _outv;
25875 arg1 =
static_cast< PLFLT >(val1);
25877 _outv = octave_value();
25881 return octave_value_list();
25902 octave_value_list _out;
25903 octave_value_list *_outp=&_out;
25904 octave_value _outv;
25914 arg1 =
static_cast< PLFLT >(val1);
25919 arg2 =
static_cast< PLFLT >(val2);
25924 arg3 =
static_cast< PLFLT >(val3);
25929 arg4 =
static_cast< PLFLT >(val4);
25930 plwind(arg1,arg2,arg3,arg4);
25931 _outv = octave_value();
25935 return octave_value_list();
25950 octave_value_list _out;
25951 octave_value_list *_outp=&_out;
25952 octave_value _outv;
25963 arg1 =
static_cast< PLBOOL >(val1);
25965 _outv = octave_value();
25975 return octave_value_list();
26001 octave_value_list _out;
26002 octave_value_list *_outp=&_out;
26003 octave_value _outv;
26010 octave_value obj = args(0);
26011#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26012 if ( !obj.isempty() )
26014 if ( !obj.is_empty() )
26017 if ( obj.is_function_handle() || obj.is_inline_function() )
26021 else if ( obj.is_string() )
26037 arg2 =
reinterpret_cast< char *
>(buf2);
26042 arg3 =
static_cast< PLFLT >(val3);
26047 arg4 =
static_cast< PLFLT >(val4);
26052 arg5 =
static_cast< PLFLT >(val5);
26057 arg6 =
static_cast< PLFLT >(val6);
26058 plmap(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6);
26059 _outv = octave_value();
26065 return octave_value_list();
26095 octave_value_list _out;
26096 octave_value_list *_outp=&_out;
26097 octave_value _outv;
26104 octave_value obj = args(0);
26105#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26106 if ( !obj.isempty() )
26108 if ( !obj.is_empty() )
26111 if ( obj.is_function_handle() || obj.is_inline_function() )
26115 else if ( obj.is_string() )
26131 arg2 =
reinterpret_cast< char *
>(buf2);
26136 arg3 =
static_cast< PLFLT >(val3);
26141 arg4 =
static_cast< PLFLT >(val4);
26146 arg5 =
static_cast< PLFLT >(val5);
26151 arg6 =
static_cast< PLFLT >(val6);
26153 if (
_n_dims( args(6) ) > 1 )
26157#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26158 if ( !args(6).isempty() )
26160 if ( !args(6).is_empty() )
26164 temp7 = args(6).matrix_value();
26165 arg7 =
new PLINT[arg8];
26174 plmapline(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
26175 _outv = octave_value();
26187 return octave_value_list();
26224 octave_value_list _out;
26225 octave_value_list *_outp=&_out;
26226 octave_value _outv;
26233 octave_value obj = args(0);
26234#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26235 if ( !obj.isempty() )
26237 if ( !obj.is_empty() )
26240 if ( obj.is_function_handle() || obj.is_inline_function() )
26244 else if ( obj.is_string() )
26260 arg2 =
reinterpret_cast< char *
>(buf2);
26265 arg3 =
reinterpret_cast< char *
>(buf3);
26270 arg4 =
static_cast< PLFLT >(val4);
26275 arg5 =
static_cast< PLFLT >(val5);
26280 arg6 =
static_cast< PLFLT >(val6);
26285 arg7 =
static_cast< PLFLT >(val7);
26287 if (
_n_dims( args(7) ) > 1 )
26291#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26292 if ( !args(7).isempty() )
26294 if ( !args(7).is_empty() )
26298 temp8 = args(7).matrix_value();
26299 arg8 =
new PLINT[arg9];
26308 plmapstring(arg1,(
char const *)arg2,(
char const *)arg3,arg4,arg5,arg6,arg7,(
int const *)arg8,arg9);
26309 _outv = octave_value();
26323 return octave_value_list();
26370 octave_value_list _out;
26371 octave_value_list *_outp=&_out;
26372 octave_value _outv;
26379 octave_value obj = args(0);
26380#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26381 if ( !obj.isempty() )
26383 if ( !obj.is_empty() )
26386 if ( obj.is_function_handle() || obj.is_inline_function() )
26390 else if ( obj.is_string() )
26406 arg2 =
reinterpret_cast< char *
>(buf2);
26411 arg3 =
static_cast< PLFLT >(val3);
26416 arg4 =
static_cast< PLFLT >(val4);
26421 arg5 =
static_cast< PLFLT >(val5);
26426 arg6 =
reinterpret_cast< char *
>(buf6);
26431 arg7 =
static_cast< PLFLT >(val7);
26436 arg8 =
static_cast< PLFLT >(val8);
26441 arg9 =
static_cast< PLFLT >(val9);
26446 arg10 =
static_cast< PLFLT >(val10);
26451 arg11 =
static_cast< PLINT >(val11);
26452 plmaptex(arg1,(
char const *)arg2,arg3,arg4,arg5,(
char const *)arg6,arg7,arg8,arg9,arg10,arg11);
26453 _outv = octave_value();
26461 return octave_value_list();
26492 octave_value_list _out;
26493 octave_value_list *_outp=&_out;
26494 octave_value _outv;
26501 octave_value obj = args(0);
26502#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26503 if ( !obj.isempty() )
26505 if ( !obj.is_empty() )
26508 if ( obj.is_function_handle() || obj.is_inline_function() )
26512 else if ( obj.is_string() )
26528 arg2 =
reinterpret_cast< char *
>(buf2);
26533 arg3 =
static_cast< PLFLT >(val3);
26538 arg4 =
static_cast< PLFLT >(val4);
26543 arg5 =
static_cast< PLFLT >(val5);
26548 arg6 =
static_cast< PLFLT >(val6);
26550 if (
_n_dims( args(6) ) > 1 )
26554#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26555 if ( !args(6).isempty() )
26557 if ( !args(6).is_empty() )
26561 temp7 = args(6).matrix_value();
26562 arg7 =
new PLINT[arg8];
26571 plmapfill(arg1,(
char const *)arg2,arg3,arg4,arg5,arg6,(
int const *)arg7,arg8);
26572 _outv = octave_value();
26584 return octave_value_list();
26616 octave_value_list _out;
26617 octave_value_list *_outp=&_out;
26618 octave_value _outv;
26625 octave_value obj = args(0);
26626#if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26627 if ( !obj.isempty() )
26629 if ( !obj.is_empty() )
26632 if ( obj.is_function_handle() || obj.is_inline_function() )
26636 else if ( obj.is_string() )
26652 arg2 =
static_cast< PLFLT >(val2);
26657 arg3 =
static_cast< PLFLT >(val3);
26662 arg4 =
static_cast< PLFLT >(val4);
26667 arg5 =
static_cast< PLFLT >(val5);
26672 arg6 =
static_cast< PLFLT >(val6);
26677 arg7 =
static_cast< PLFLT >(val7);
26679 _outv = octave_value();
26683 return octave_value_list();
26692 octave_value_list _out;
26693 octave_value_list *_outp=&_out;
26694 octave_value _outv;
26701 _outv = octave_value();
26705 return octave_value_list();
26714 octave_value_list _out;
26715 octave_value_list *_outp=&_out;
26716 octave_value _outv;
26723 _outv = octave_value();
26727 return octave_value_list();
26744 octave_value_list _out;
26745 octave_value_list *_outp=&_out;
26746 octave_value _outv;
26756 arg1 =
reinterpret_cast< char *
>(buf1);
26761 arg2 =
reinterpret_cast< char *
>(buf2);
26762 plSetUsage((
char const *)arg1,(
char const *)arg2);
26763 _outv = octave_value();
26771 return octave_value_list();
26782 octave_value_list _out;
26783 octave_value_list *_outp=&_out;
26784 octave_value _outv;
26791 _outv = octave_value();
26795 return octave_value_list();
26805{
"testppchar",_wrap_testppchar,0,0,2,0},
26807{
"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
26810{
"plcont0",_wrap_plcont0,0,0,2,0},
26811{
"plcont1",_wrap_plcont1,0,0,2,0},
26812{
"plcont2",_wrap_plcont2,0,0,2,0},
26813{
"plcont2p",_wrap_plcont2p,0,0,2,0},
26823{
"plshade1",_wrap_plshade1,0,0,2,0},
26824{
"plshade2",_wrap_plshade2,0,0,2,0},
26826{
"plshadesx",_wrap_plshadesx,0,0,2,0},
26827{
"plshades1",_wrap_plshades1,0,0,2,0},
26828{
"plshades2",_wrap_plshades2,0,0,2,0},
26830{
"plvect1",_wrap_plvect1,0,0,2,0},
26831{
"plvect2",_wrap_plvect2,0,0,2,0},
26832{
"pplimage",_wrap_pplimage,0,0,2,0},
26834{
"plimagefrx",_wrap_plimagefrx,0,0,2,0},
26835{
"plimagefr1",_wrap_plimagefr1,0,0,2,0},
26836{
"plimagefr2",_wrap_plimagefr2,0,0,2,0},
27122#define SWIGRUNTIME_DEBUG
27125#ifndef SWIG_INIT_CLIENT_DATA_TYPE
27126#define SWIG_INIT_CLIENT_DATA_TYPE void *
27148 if (!module_head) {
27161 }
while (iter!= module_head);
27172 if (init == 0)
return;
27175#ifdef SWIGRUNTIME_DEBUG
27176 printf(
"SWIG_InitializeModule: size %lu\n", (
unsigned long)
swig_module.size);
27183#ifdef SWIGRUNTIME_DEBUG
27184 printf(
"SWIG_InitializeModule: type %lu %s\n", (
unsigned long)i,
swig_module.type_initial[i]->name);
27193#ifdef SWIGRUNTIME_DEBUG
27194 printf(
"SWIG_InitializeModule: found type %s\n", type->name);
27197 type->clientdata =
swig_module.type_initial[i]->clientdata;
27198#ifdef SWIGRUNTIME_DEBUG
27199 printf(
"SWIG_InitializeModule: found and overwrite type %s \n", type->name);
27208 while (cast->
type) {
27212#ifdef SWIGRUNTIME_DEBUG
27213 printf(
"SWIG_InitializeModule: look cast %s\n", cast->
type->
name);
27217#ifdef SWIGRUNTIME_DEBUG
27218 if (ret) printf(
"SWIG_InitializeModule: found cast %s\n", ret->
name);
27223#ifdef SWIGRUNTIME_DEBUG
27224 printf(
"SWIG_InitializeModule: skip old type %s\n", ret->
name);
27231#ifdef SWIGRUNTIME_DEBUG
27232 if (ocast) printf(
"SWIG_InitializeModule: skip old cast %s\n", ret->
name);
27234 if (!ocast) ret = 0;
27239#ifdef SWIGRUNTIME_DEBUG
27240 printf(
"SWIG_InitializeModule: adding cast %s\n", cast->
type->
name);
27243 type->cast->prev = cast;
27244 cast->
next = type->cast;
27255#ifdef SWIGRUNTIME_DEBUG
27256 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
27260 printf(
"SWIG_InitializeModule: type %lu %s\n", (
unsigned long)i,
swig_module.type_initial[i]->name);
27261 while (cast->
type) {
27262 printf(
"SWIG_InitializeModule: cast type %s\n", cast->
type->
name);
27266 printf(
"---- Total casts: %d\n",j);
27268 printf(
"**** SWIG_InitializeModule: Cast List ******\n");
27281 static int init_run = 0;
27283 if (init_run)
return;
27294 equiv = equiv->
next;
27314#if SWIG_OCTAVE_PREREQ(6,0,0)
27315#elif SWIG_OCTAVE_PREREQ(4,2,0)
27316 octave::unwind_protect frame;
27317 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27318 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27319#elif SWIG_OCTAVE_PREREQ(3,3,50)
27320 unwind_protect frame;
27321 frame.protect_var(error_state); error_state = 0;
27322 frame.protect_var(warning_state); warning_state = 0;
27323 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27324 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27326 unwind_protect::begin_frame(
"SWIG_Octave_LoadModule");
27327 unwind_protect_int(error_state); error_state = 0;
27328 unwind_protect_int(warning_state); warning_state = 0;
27329 unwind_protect_bool(discard_error_messages); discard_error_messages =
true;
27330 unwind_protect_bool(discard_warning_messages); discard_warning_messages =
true;
27332#if SWIG_OCTAVE_PREREQ(4,2,0)
27334#if SWIG_OCTAVE_PREREQ(4,4,0)
27335 octave::feval(
name, octave_value_list(), 0);
27337 feval(
name, octave_value_list(), 0);
27340 }
catch (octave::execution_exception&) { }
27342 feval(
name, octave_value_list(), 0);
27343 retn = (error_state == 0);
27345#if !SWIG_OCTAVE_PREREQ(3,3,50)
27346 unwind_protect::run_frame(
"SWIG_Octave_LoadModule");
27358#if SWIG_OCTAVE_PREREQ(6,0,0)
27359#elif SWIG_OCTAVE_PREREQ(4,2,0)
27360 octave::unwind_protect frame;
27361 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27362 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27363#elif SWIG_OCTAVE_PREREQ(3,3,50)
27364 unwind_protect frame;
27365 frame.protect_var(error_state); error_state = 0;
27366 frame.protect_var(warning_state); warning_state = 0;
27367 frame.protect_var(discard_error_messages); discard_error_messages =
true;
27368 frame.protect_var(discard_warning_messages); discard_warning_messages =
true;
27370 unwind_protect::begin_frame(
"SWIG_Octave_InstallFunction");
27371 unwind_protect_int(error_state); error_state = 0;
27372 unwind_protect_int(warning_state); warning_state = 0;
27373 unwind_protect_bool(discard_error_messages); discard_error_messages =
true;
27374 unwind_protect_bool(discard_warning_messages); discard_warning_messages =
true;
27376 octave_value_list args;
27378 args.append(octloadfcn->fcn_file_name());
27379#if SWIG_OCTAVE_PREREQ(4,2,0)
27381#if SWIG_OCTAVE_PREREQ(4,4,0)
27382 octave::feval(
"autoload", args, 0);
27384 feval(
"autoload", args, 0);
27387 }
catch (octave::execution_exception&) { }
27389 feval(
"autoload", args, 0);
27390 retn = (error_state == 0);
27392#if !SWIG_OCTAVE_PREREQ(3,3,50)
27393 unwind_protect::run_frame(
"SWIG_Octave_InstallFunction");
27403@deftypefn {Loadable Function} {} subclass()\n\
27404@deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
27405Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
27407See the SWIG manual for usage examples.\n\
27412 for (
int j = 0; j < args.length(); ++j) {
27413 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
27417 error(
"subclass: cannot subclass object not constructed on octave side");
27418 return octave_value_list();
27421 }
else if (args(j).is_function_handle()) {
27422 top->
assign(args(j).fcn_handle_value()->fcn_name(), args(j));
27423 }
else if (args(j).is_string()) {
27424 if (j + 1 >= args.length()) {
27425 error(
"subclass: member assignments must be of string,value form");
27426 return octave_value_list();
27428 top->
assign(args(j).string_value(), args(j + 1));
27431 error(
"subclass: invalid arguments to subclass()");
27432 return octave_value_list();
27439@deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
27440Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
27444 if (args.length() != 1) {
27445 error(
"swig_type: must be called with only a single object");
27446 return octave_value_list();
27450 error(
"swig_type: object is not a swig_ref");
27451 return octave_value_list();
27457@deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
27458Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
27459otherwise return `<unknown>'.\n\
27463 if (args.length() != 1 || !args(0).is_string()) {
27464 error(
"swig_typequery: must be called with single string argument");
27465 return octave_value_list();
27470 return octave_value(
"<unknown>");
27471 return octave_value(type->name);
27475@deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
27476Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
27480 if (args.length() != 1) {
27481 error(
"swig_this: must be called with only a single object");
27482 return octave_value_list();
27484 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
27485 return octave_value(octave_uint64(0));
27488 error(
"swig_this: object is not a swig_ref");
27489 return octave_value_list();
27491 return octave_value(octave_uint64((
unsigned long long) ost->
swig_this()));
27495@deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
27496Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
27500 if (args.length() != 3) {
27501 error(
"swig_octave_prereq: must be called with 3 arguments");
27502 return octave_value_list();
27504 const int major = args(0).int_value();
27505 const int minor = args(1).int_value();
27506 const int patch = args(2).int_value();
27508 return octave_value(prereq);
27512@deftypefn {Loadable Function} {} swig_exit([@var{exit_status}])\n\
27513Exit Octave without performing any memory cleanup.\n\
27517 if (args.length() > 1) {
27518 error(
"swig_exit: must be called with at most one arguments");
27519 return octave_value_list();
27521 int exit_status = 0;
27522 if (args.length() == 1) {
27523 exit_status = args(0).int_value();
27525 ::_Exit(exit_status);
27526 return octave_value();
27530@deftypefn {Loadable Module} {} " SWIG_name_d "\n\
27531Loads the SWIG-generated module `" SWIG_name_d "'.\n\
27544#ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
27545#if !SWIG_OCTAVE_PREREQ(4,4,0)
27546#if SWIG_OCTAVE_PREREQ(3,2,0)
27547 octave_exit = ::_Exit;
27553 if (args.length() != 0 || nargout != 0) {
27555 return octave_value_list();
27563#if SWIG_OCTAVE_PREREQ(3,2,0)
27564 octave_value_list eval_args;
27565 eval_args.append(
"base");
27566 eval_args.append(
"function __swig_atexit__; "
27573 "__swig_atexit__; "
27574 "atexit(\"__swig_atexit__\", false); "
27575 "atexit(\"__swig_atexit__\")");
27576#if SWIG_OCTAVE_PREREQ(4,4,0)
27577 octave::feval(
"evalin", eval_args, 0);
27579 feval(
"evalin", eval_args, 0);
27583#if SWIG_OCTAVE_PREREQ(4,4,0)
27585 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
27586 string_vector types = typeinfo.installed_type_names();
27587 bool register_octave_swig_ref =
true;
27588 bool register_octave_swig_packed =
true;
27589 for (
int i = 0; i < types.numel(); ++i) {
27590 if (types(i) == octave_swig_ref::static_type_name()) {
27591 register_octave_swig_ref =
false;
27592 octave_swig_ref::set_type_id(i);
27594 if (types(i) == octave_swig_packed::static_type_name()) {
27595 register_octave_swig_packed =
false;
27596 octave_swig_packed::set_type_id(i);
27599 if (register_octave_swig_ref) {
27600 octave_swig_ref::register_type();
27602 if (register_octave_swig_packed) {
27603 octave_swig_packed::register_type();
27607 octave_swig_ref::register_type();
27608 octave_swig_packed::register_type();
27613#if SWIG_OCTAVE_PREREQ(8,0,0)
27614 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27615 octave_function *me = tree_eval.current_function();
27616#elif SWIG_OCTAVE_PREREQ(6,0,0)
27617 octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27618 octave::call_stack& stack = tree_eval.get_call_stack();
27619 octave_function *me = stack.current_function();
27620#elif SWIG_OCTAVE_PREREQ(4,4,0)
27621 octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
27622 octave_function *me = stack.current();
27624 octave_function *me = octave_call_stack::current();
27628 return octave_value_list();
27631 return octave_value_list();
27634 return octave_value_list();
27637 return octave_value_list();
27640 return octave_value_list();
27643 return octave_value_list();
27681 return octave_value_list();
27688 if (mb->second.first && mb->second.first->method) {
27690 return octave_value_list();
27695#if SWIG_OCTAVE_PREREQ(4,4,0)
27696 octave::interpreter::the_interpreter()->mlock();
27697#elif SWIG_OCTAVE_PREREQ(3,2,0)
27707 if (mb->second.second.is_defined()) {
27716 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
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
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
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
#define SWIG_POINTER_RELEASE
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
#define SWIG_POINTER_CLEAR
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
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_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
#define SWIG_POINTER_DISOWN
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)
#define SWIG_ERROR_RELEASE_NOT_OWNED
static const char * _wrap_plclear_texinfo
#define SWIG_CAST_NEW_MEMORY
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
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)
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
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)
struct swig_cast_info swig_cast_info
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)
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)
struct swig_type_info swig_type_info
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)
struct swig_module_info swig_module_info
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[]
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
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)
#define SWIG_RuntimeError
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[]
#define SWIG_AttributeError
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
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_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)
struct swig_type_info *(* swig_dycast_func)(void **)
#define SWIG_NullReferenceError
static int _wrap_PLGraphicsIn_type_set(lua_State *L)
#define SWIG_POINTER_DISOWN
struct swig_type_info swig_type_info
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_TYPE_TABLE_NAME
static swig_type_info _swigt__p_unsigned_int
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 SWIG_DivisionByZero
#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