/*
 * This file was automatically generated for octave by wrap_octave on
 * Wed Dec  9 11:31:43 1998
 * from cpgplot.h.
 */

#include "cpgplot.h"


#include "oct.h"

#ifndef __GNUC__
#include <alloca.h>
#endif

inline int max(int a, int b) { return a >= b ? a : b; }
inline int min(int a, int b) { return a >= b ? a : b; }

//
// Function to get the total length (rows*columns) of an octave object of
// arbitrary type.
// Arguments:
// 1) The octave object.
//
// If the object is a scalar, the array length is 1.
//
static int
_arraylen(const octave_value &o_obj)
{
  return max(o_obj.rows(),1) * max(o_obj.columns(),1); // Return the size.
				// max is necessary because sometimes
				// rows() or columns() return -1 or 0 for
				// scalars.
}

//
// Function to get the number of dimensions of an object.
//
static int
_n_dims(const octave_value &o_obj)
{
  if (max(o_obj.columns(),1) > 1)
    return 2;
				// max is necessary because sometimes
				// rows() or columns() return -1 or 0 for
				// scalars.
  else if (max(o_obj.rows(),1) > 1)
    return 1;
  else
    return 0;
}

//
// Return the n'th dimension of an object.  Dimension 0 is the 1st dimension.
//
static inline int
_dim(const octave_value &o_obj, int dim_idx)
{
  if (dim_idx == 0)
    return max(o_obj.rows(), 1);
				// max is necessary because sometimes
				// rows() or columns() return -1 or 0 for
				// scalars.
  else if (dim_idx == 1)
    return max(o_obj.columns(), 1);
  else
    return 1;
}

//
// The following function converts an array of doubles into some other
// numeric type.  Arguments:
// 1) Where to store the result.  The type is determined from the type of
//    this pointer.
// 2) A vector of doubles to convert.
// 3) The number of doubles.
//
template <class FLOAT>
static inline void
_cvt_double_to(FLOAT *out_arr, double *in_arr, unsigned n_el)
{
  while (n_el-- > 0)
    *out_arr++ = (FLOAT)(*in_arr++);
}

template void _cvt_double_to(int *, double *, unsigned);
template void _cvt_double_to(unsigned *, double *, unsigned);
template void _cvt_double_to(short *, double *, unsigned);
template void _cvt_double_to(unsigned short *, double *, unsigned);
template void _cvt_double_to(float *, double *, unsigned);
				// Instantiate our templates.  Octave uses
				// manual template instantiation.

//
// Convert an array of some other type into an array of doubles.  Arguments:
// 1) The array of objects of other type.
// 2) The output array of doubles.
// 3) The number of elements to convert.
//
template <class FLOAT>
static inline void
_cvt_to_double(FLOAT *arr, double *d_arr, unsigned n_el)
{
  while (n_el-- > 0)
    *d_arr++ = double(*arr++);
}

template void _cvt_to_double(int *, double *, unsigned);
template void _cvt_to_double(unsigned *, double *, unsigned);
template void _cvt_to_double(short *, double *, unsigned);
template void _cvt_to_double(unsigned short *, double *, unsigned);
template void _cvt_to_double(float *, double *, unsigned);
				// Instantiate our templates.  Octave uses
				// manual template instantiation.


/*
 * Check to see if the vectorizing dimensions on an input argument are
 * ok.  Arguments:
 * 1) The input argument.
 * 2) The number of vectorizing dimensions we have so far.  This is updated
 *    if we add more vectorizing dimensions.
 * 3) An array containing the existing vectorizing dimensions.
 * 4) The number of explicitly declared dimensions, i.e., 0 if this was
 *    declared as a scalar, 1 if a vector.  We vectorize only the dimensions
 *    higher than the explicitly declared ones.
 * 5) A value which is set to 0 if this argument is not vectorized.  This
 *    value is left unaltered if the argument is vectorized.
 *
 * Returns 0 if there was a problem, 1 if the dimensions were ok.
 */
int
_check_input_vectorize(const octave_value &arg,
                       int *n_vec_dim,
		       int _d[2],
		       int explicit_dims,
		       int *vec_stride)
{
  int v_idx;

  int n_dims = _n_dims(arg);

  if (n_dims > explicit_dims)	/* Any additional dimensions? */
  {
    if (*n_vec_dim == 0)	/* No vectorizing dimensions seen yet? */
    {				/* This defines the vectorizing dimensions. */
      *n_vec_dim = n_dims - explicit_dims; /* Remember the # of dims. */
      for (v_idx = 0; v_idx < 2-explicit_dims; ++v_idx)
        _d[v_idx] = _dim(arg, v_idx+explicit_dims); /* Remember this dim. */
    } 
    else			/* Already had some vectorizing dimensions. */
    {				/* These must match exactly. */
      for (v_idx = 0; v_idx < 2-explicit_dims; ++v_idx)
        if (_d[v_idx] != _dim(arg, v_idx+explicit_dims)) /* Wrong size? */
          return 0;		/* Error! */
    }
  }  
/*  else if (n_dims < explicit_dims) */ /* Too few dimensions? */
/*    return 0; */ /* We don't do this check because there's no way to
		    * distinguish between a vector and a 3x1 matrix. */
  else
    *vec_stride = 0;		/* Vectorization not required. */

  return 1;
}

/*
 * Same thing except for modify variables.  Arguments:
 * 1) The input argument.
 * 2) The number of vectorizing dimensions we have so far.
 * 3) An array containing the existing vectorizing dimensions.
 * 4) The number of explicitly declared dimensions, i.e., 0 if this was
 *    declared as a scalar, 1 if a vector.  We vectorize only the dimensions
 *    higher than the explicitly declared ones.
 * 5) A flag indicating whether this is the first modify variable.  This
 *    flag is passed by reference and updated by this subroutine.
 *
 * The vectorizing dimensions of modify arguments must exactly match those
 * specified for input variables.  The difference between this subroutine
 * and _check_input_vectorize is that only the first modify variable may
 * specify additional vectorizing dimensions.
 *
 * Returns 0 if there was a problem, 1 if the dimensions were ok.
 */
int
_check_modify_vectorize(const octave_value &arg,
		        int *n_vec_dim,
		        int _d[2],
		        int explicit_dims,
			int *first_modify_flag)
{
  int v_idx;

  int n_dims = _n_dims(arg);

  if (n_dims > explicit_dims)	/* Any additional dimensions? */
  {
    if (*n_vec_dim == 0 && *first_modify_flag)	/* No vectorizing dimensions seen yet? */
    {				/* This defines the vectorizing dimensions. */
      *n_vec_dim = n_dims - explicit_dims; /* Remember the # of dims. */
      for (v_idx = 0; v_idx < 2-explicit_dims; ++v_idx)
        _d[v_idx] = _dim(arg, v_idx+explicit_dims); /* Remember this dim. */
    } 
    else			/* Already had some vectorizing dimensions. */
    {				/* These must match exactly. */
      for (v_idx = 0; v_idx < 2-explicit_dims; ++v_idx)
        if (_d[v_idx] != _dim(arg, v_idx+explicit_dims)) /* Wrong size? */
          return 0;		/* Error! */
    }
  }  
/*  else if (n_dims < explicit_dims) */ /* Too few dimensions? */
/*    return 0; */ /* We don't do this check because there's no way to
		    * distinguish between a vector and a 3x1 matrix. */

  *first_modify_flag = 0;	/* Next modify variable will not be first. */
  return 1;
}

octave_value_list _wrap_pgarro(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 4)
  {
    print_usage("pgarro");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  float *_arg_x1;
  float *_arg_y1;
  float *_arg_x2;
  float *_arg_y2;
  int _vecstride_x1 = 1;
  int _vecstride_y1 = 1;
  int _vecstride_x2 = 1;
  int _vecstride_y2 = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_x1))
    { error("dimension mismatch in argument x1"); return retval; }
  Matrix _x1 = args(1).matrix_value();
  _arg_x1 = (float *)alloca(_x1.dim1() * _x1.dim2() * sizeof (float));
  _cvt_double_to(_arg_x1, &_x1(0,0), _x1.dim1()*_x1.dim2());

  if (!_check_input_vectorize(args(2), &_vec_n, _d, 0, &_vecstride_y1))
    { error("dimension mismatch in argument y1"); return retval; }
  Matrix _y1 = args(2).matrix_value();
  _arg_y1 = (float *)alloca(_y1.dim1() * _y1.dim2() * sizeof (float));
  _cvt_double_to(_arg_y1, &_y1(0,0), _y1.dim1()*_y1.dim2());

  if (!_check_input_vectorize(args(3), &_vec_n, _d, 0, &_vecstride_x2))
    { error("dimension mismatch in argument x2"); return retval; }
  Matrix _x2 = args(3).matrix_value();
  _arg_x2 = (float *)alloca(_x2.dim1() * _x2.dim2() * sizeof (float));
  _cvt_double_to(_arg_x2, &_x2(0,0), _x2.dim1()*_x2.dim2());

  if (!_check_input_vectorize(args(4), &_vec_n, _d, 0, &_vecstride_y2))
    { error("dimension mismatch in argument y2"); return retval; }
  Matrix _y2 = args(4).matrix_value();
  _arg_y2 = (float *)alloca(_y2.dim1() * _y2.dim2() * sizeof (float));
  _cvt_double_to(_arg_y2, &_y2(0,0), _y2.dim1()*_y2.dim2());

  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgarro(_arg_x1[_vecstride_x1*_vidx], _arg_y1[_vecstride_y1*_vidx], _arg_x2[_vecstride_x2*_vidx], _arg_y2[_vecstride_y2*_vidx]);
  }
  return retval;
}

octave_value_list _wrap_pgask(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 1)
  {
    print_usage("pgask");
    return retval;
  }

  int _arg_flag;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument flag"); return retval; }
  _arg_flag = (int)args(1).double_value();

    cpgask(_arg_flag);
  return retval;
}

octave_value_list _wrap_pgaxis(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 14)
  {
    print_usage("pgaxis");
    return retval;
  }

  char * _arg_opt;
  float _arg_x1;
  float _arg_y1;
  float _arg_x2;
  float _arg_y2;
  float _arg_v1;
  float _arg_v2;
  float _arg_step;
  int _arg_nsub;
  float _arg_dmajl;
  float _arg_dmajr;
  float _arg_fmin;
  float _arg_disp;
  float _arg_orient;
  if (0 > 0)
    { error("dimension mismatch in argument opt"); return retval; }
  string _opt = args(1).string_value();
  _opt += '\0';
  _arg_opt = (char *)_opt.data();

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument x1"); return retval; }
  _arg_x1 = (float)args(2).double_value();

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument y1"); return retval; }
  _arg_y1 = (float)args(3).double_value();

  if (_n_dims(args(4)) > 0)
    { error("dimension mismatch in argument x2"); return retval; }
  _arg_x2 = (float)args(4).double_value();

  if (_n_dims(args(5)) > 0)
    { error("dimension mismatch in argument y2"); return retval; }
  _arg_y2 = (float)args(5).double_value();

  if (_n_dims(args(6)) > 0)
    { error("dimension mismatch in argument v1"); return retval; }
  _arg_v1 = (float)args(6).double_value();

  if (_n_dims(args(7)) > 0)
    { error("dimension mismatch in argument v2"); return retval; }
  _arg_v2 = (float)args(7).double_value();

  if (_n_dims(args(8)) > 0)
    { error("dimension mismatch in argument step"); return retval; }
  _arg_step = (float)args(8).double_value();

  if (_n_dims(args(9)) > 0)
    { error("dimension mismatch in argument nsub"); return retval; }
  _arg_nsub = (int)args(9).double_value();

  if (_n_dims(args(10)) > 0)
    { error("dimension mismatch in argument dmajl"); return retval; }
  _arg_dmajl = (float)args(10).double_value();

  if (_n_dims(args(11)) > 0)
    { error("dimension mismatch in argument dmajr"); return retval; }
  _arg_dmajr = (float)args(11).double_value();

  if (_n_dims(args(12)) > 0)
    { error("dimension mismatch in argument fmin"); return retval; }
  _arg_fmin = (float)args(12).double_value();

  if (_n_dims(args(13)) > 0)
    { error("dimension mismatch in argument disp"); return retval; }
  _arg_disp = (float)args(13).double_value();

  if (_n_dims(args(14)) > 0)
    { error("dimension mismatch in argument orient"); return retval; }
  _arg_orient = (float)args(14).double_value();

    cpgaxis(_arg_opt, _arg_x1, _arg_y1, _arg_x2, _arg_y2, _arg_v1, _arg_v2, _arg_step, _arg_nsub, _arg_dmajl, _arg_dmajr, _arg_fmin, _arg_disp, _arg_orient);
  return retval;
}

octave_value_list _wrap_pgband(const octave_value_list &args, int nargout)
{
  octave_value_list retval(2, octave_value());
  if (args.length()-1 != 6 ||
      nargout != 4)
  {
    print_usage("pgband");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int first_modify_flag = 1;
  int *_arg_mode;
  int *_arg_posn;
  float *_arg_xref;
  float *_arg_yref;
  float *_arg_x;
  float *_arg_y;
  char *_arg_ch_scalar;
  int *_arg_retval;
  int _vecstride_mode = 1;
  int _vecstride_posn = 1;
  int _vecstride_xref = 1;
  int _vecstride_yref = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_mode))
    { error("dimension mismatch in argument mode"); return retval; }
  Matrix _mode = args(1).matrix_value();
  _arg_mode = (int *)alloca(_mode.dim1() * _mode.dim2() * sizeof (int));
  _cvt_double_to(_arg_mode, &_mode(0,0), _mode.dim1()*_mode.dim2());

  if (!_check_input_vectorize(args(2), &_vec_n, _d, 0, &_vecstride_posn))
    { error("dimension mismatch in argument posn"); return retval; }
  Matrix _posn = args(2).matrix_value();
  _arg_posn = (int *)alloca(_posn.dim1() * _posn.dim2() * sizeof (int));
  _cvt_double_to(_arg_posn, &_posn(0,0), _posn.dim1()*_posn.dim2());

  if (!_check_input_vectorize(args(3), &_vec_n, _d, 0, &_vecstride_xref))
    { error("dimension mismatch in argument xref"); return retval; }
  Matrix _xref = args(3).matrix_value();
  _arg_xref = (float *)alloca(_xref.dim1() * _xref.dim2() * sizeof (float));
  _cvt_double_to(_arg_xref, &_xref(0,0), _xref.dim1()*_xref.dim2());

  if (!_check_input_vectorize(args(4), &_vec_n, _d, 0, &_vecstride_yref))
    { error("dimension mismatch in argument yref"); return retval; }
  Matrix _yref = args(4).matrix_value();
  _arg_yref = (float *)alloca(_yref.dim1() * _yref.dim2() * sizeof (float));
  _cvt_double_to(_arg_yref, &_yref(0,0), _yref.dim1()*_yref.dim2());

  if (!_check_modify_vectorize(args(5), &_vec_n, _d, 0, &first_modify_flag))
    { error("dimension mismatch in argument x"); return retval; }
  Matrix _x = args(5).matrix_value();
  _arg_x = (float *)alloca(_x.dim1() * _x.dim2() * sizeof (float));
  _cvt_double_to(_arg_x, &_x(0,0), _x.dim1()*_x.dim2());
  retval(2) = octave_value(Matrix(_dim(_x, 0), _dim(_x, 1)));

  if (!_check_modify_vectorize(args(6), &_vec_n, _d, 0, &first_modify_flag))
    { error("dimension mismatch in argument y"); return retval; }
  Matrix _y = args(6).matrix_value();
  _arg_y = (float *)alloca(_y.dim1() * _y.dim2() * sizeof (float));
  _cvt_double_to(_arg_y, &_y(0,0), _y.dim1()*_y.dim2());
  retval(3) = octave_value(Matrix(_dim(_y, 0), _dim(_y, 1)));

  if (_d[0]  != 1 || _d[1]  != 1)
    retval(0) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_retval = (int *)alloca(_d[0]  * _d[1]  * sizeof (int));
  retval(1) = octave_value(charMatrix(_d[0] , _d[1] ), true);
  _arg_ch_scalar = (char *)retval(1).char_matrix_value().data();
  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    _arg_retval[_vidx] = (int)
      cpgband(_arg_mode[_vecstride_mode*_vidx], _arg_posn[_vecstride_posn*_vidx], _arg_xref[_vecstride_xref*_vidx], _arg_yref[_vecstride_yref*_vidx], &_arg_x[_vidx], &_arg_y[_vidx], &_arg_ch_scalar[_vidx]);
  }
  if (_arraylen(retval(2)) == 1)
    retval(2) = octave_value(double(*_arg_x));
  else
    _cvt_to_double(_arg_x, (double *)retval(2).matrix_value().data(), _arraylen(retval(2)));
  if (_arraylen(retval(3)) == 1)
    retval(3) = octave_value(double(*_arg_y));
  else
    _cvt_to_double(_arg_y, (double *)retval(3).matrix_value().data(), _arraylen(retval(3)));
  if (_arraylen(retval(0)) == 1)
    retval(0) = octave_value(double(*_arg_retval));
  else
    _cvt_to_double(_arg_retval, (double *)retval(0).matrix_value().data(), _arraylen(retval(0)));
  return retval;
}

octave_value_list _wrap_pgbbuf(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgbbuf");
    return retval;
  }

    cpgbbuf();
  return retval;
}

octave_value_list _wrap_pgbeg(const octave_value_list &args, int )
{
  octave_value_list retval(1, octave_value());
  if (args.length()-1 != 4)
  {
    print_usage("pgbeg");
    return retval;
  }

  int _arg_unit;
  char * _arg_file;
  int _arg_nxsub;
  int _arg_nysub;
  int _arg_retval;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument unit"); return retval; }
  _arg_unit = (int)args(1).double_value();

  if (0 > 0)
    { error("dimension mismatch in argument file"); return retval; }
  string _file = args(2).string_value();
  _file += '\0';
  _arg_file = (char *)_file.data();

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument nxsub"); return retval; }
  _arg_nxsub = (int)args(3).double_value();

  if (_n_dims(args(4)) > 0)
    { error("dimension mismatch in argument nysub"); return retval; }
  _arg_nysub = (int)args(4).double_value();

    _arg_retval = (int)
      cpgbeg(_arg_unit, _arg_file, _arg_nxsub, _arg_nysub);
  retval(0) = octave_value((double)_arg_retval);
  return retval;
}

octave_value_list _wrap_pgbin(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 3)
  {
    print_usage("pgbin");
    return retval;
  }

  int _arg_nbin;
  float *_arg_x;
  float *_arg_data;
  int _arg_center;
  _arg_nbin = (_dim(args(2), 0));
  if (  (int)(_dim(args(1), 0)) != (int)(_arg_nbin) ||
      _n_dims(args(1)) > 1)
    { error("dimension mismatch in argument x"); return retval; }
  Matrix _x = args(1).matrix_value();
  _arg_x = (float *)alloca(_x.dim1() * _x.dim2() * sizeof (float));
  _cvt_double_to(_arg_x, &_x(0,0), _x.dim1()*_x.dim2());

  if (_n_dims(args(2)) > 1)
    { error("dimension mismatch in argument data"); return retval; }
  Matrix _data = args(2).matrix_value();
  _arg_data = (float *)alloca(_data.dim1() * _data.dim2() * sizeof (float));
  _cvt_double_to(_arg_data, &_data(0,0), _data.dim1()*_data.dim2());

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument center"); return retval; }
  _arg_center = (int)args(3).double_value();

    cpgbin(_arg_nbin, _arg_x, _arg_data, _arg_center);
  return retval;
}

octave_value_list _wrap_pgbox(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 6)
  {
    print_usage("pgbox");
    return retval;
  }

  char * _arg_xopt;
  float _arg_xtick;
  int _arg_nxsub;
  char * _arg_yopt;
  float _arg_ytick;
  int _arg_nysub;
  if (0 > 0)
    { error("dimension mismatch in argument xopt"); return retval; }
  string _xopt = args(1).string_value();
  _xopt += '\0';
  _arg_xopt = (char *)_xopt.data();

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument xtick"); return retval; }
  _arg_xtick = (float)args(2).double_value();

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument nxsub"); return retval; }
  _arg_nxsub = (int)args(3).double_value();

  if (0 > 0)
    { error("dimension mismatch in argument yopt"); return retval; }
  string _yopt = args(4).string_value();
  _yopt += '\0';
  _arg_yopt = (char *)_yopt.data();

  if (_n_dims(args(5)) > 0)
    { error("dimension mismatch in argument ytick"); return retval; }
  _arg_ytick = (float)args(5).double_value();

  if (_n_dims(args(6)) > 0)
    { error("dimension mismatch in argument nysub"); return retval; }
  _arg_nysub = (int)args(6).double_value();

    cpgbox(_arg_xopt, _arg_xtick, _arg_nxsub, _arg_yopt, _arg_ytick, _arg_nysub);
  return retval;
}

octave_value_list _wrap_pgcirc(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 3)
  {
    print_usage("pgcirc");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  float *_arg_xcent;
  float *_arg_ycent;
  float *_arg_radius;
  int _vecstride_xcent = 1;
  int _vecstride_ycent = 1;
  int _vecstride_radius = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_xcent))
    { error("dimension mismatch in argument xcent"); return retval; }
  Matrix _xcent = args(1).matrix_value();
  _arg_xcent = (float *)alloca(_xcent.dim1() * _xcent.dim2() * sizeof (float));
  _cvt_double_to(_arg_xcent, &_xcent(0,0), _xcent.dim1()*_xcent.dim2());

  if (!_check_input_vectorize(args(2), &_vec_n, _d, 0, &_vecstride_ycent))
    { error("dimension mismatch in argument ycent"); return retval; }
  Matrix _ycent = args(2).matrix_value();
  _arg_ycent = (float *)alloca(_ycent.dim1() * _ycent.dim2() * sizeof (float));
  _cvt_double_to(_arg_ycent, &_ycent(0,0), _ycent.dim1()*_ycent.dim2());

  if (!_check_input_vectorize(args(3), &_vec_n, _d, 0, &_vecstride_radius))
    { error("dimension mismatch in argument radius"); return retval; }
  Matrix _radius = args(3).matrix_value();
  _arg_radius = (float *)alloca(_radius.dim1() * _radius.dim2() * sizeof (float));
  _cvt_double_to(_arg_radius, &_radius(0,0), _radius.dim1()*_radius.dim2());

  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgcirc(_arg_xcent[_vecstride_xcent*_vidx], _arg_ycent[_vecstride_ycent*_vidx], _arg_radius[_vecstride_radius*_vidx]);
  }
  return retval;
}

octave_value_list _wrap_pgclos(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgclos");
    return retval;
  }

    cpgclos();
  return retval;
}

octave_value_list _wrap_pgconb(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 8)
  {
    print_usage("pgconb");
    return retval;
  }

  float *_arg_a;
  int _arg_idim;
  int _arg_jdim;
  int _arg_i1;
  int _arg_i2;
  int _arg_j1;
  int _arg_j2;
  float *_arg_c;
  int _arg_nc;
  float *_arg_tr;
  float _arg_blank;
  _arg_nc = (_dim(args(6), 0));
  _arg_idim = (_dim(args(1), 0));
  _arg_jdim = (_dim(args(1), 1));
  if (_n_dims(args(1)) > 2)
    { error("dimension mismatch in argument a"); return retval; }
  Matrix _a = args(1).matrix_value();
  _arg_a = (float *)alloca(_a.dim1() * _a.dim2() * sizeof (float));
  _cvt_double_to(_arg_a, &_a(0,0), _a.dim1()*_a.dim2());

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument i1"); return retval; }
  _arg_i1 = (int)args(2).double_value();

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument i2"); return retval; }
  _arg_i2 = (int)args(3).double_value();

  if (_n_dims(args(4)) > 0)
    { error("dimension mismatch in argument j1"); return retval; }
  _arg_j1 = (int)args(4).double_value();

  if (_n_dims(args(5)) > 0)
    { error("dimension mismatch in argument j2"); return retval; }
  _arg_j2 = (int)args(5).double_value();

  if (_n_dims(args(6)) > 1)
    { error("dimension mismatch in argument c"); return retval; }
  Matrix _c = args(6).matrix_value();
  _arg_c = (float *)alloca(_c.dim1() * _c.dim2() * sizeof (float));
  _cvt_double_to(_arg_c, &_c(0,0), _c.dim1()*_c.dim2());

  if (  (int)(_dim(args(7), 0)) != (int)(6) ||
      _n_dims(args(7)) > 1)
    { error("dimension mismatch in argument tr"); return retval; }
  Matrix _tr = args(7).matrix_value();
  _arg_tr = (float *)alloca(_tr.dim1() * _tr.dim2() * sizeof (float));
  _cvt_double_to(_arg_tr, &_tr(0,0), _tr.dim1()*_tr.dim2());

  if (_n_dims(args(8)) > 0)
    { error("dimension mismatch in argument blank"); return retval; }
  _arg_blank = (float)args(8).double_value();

    cpgconb(_arg_a, _arg_idim, _arg_jdim, _arg_i1, _arg_i2, _arg_j1, _arg_j2, _arg_c, _arg_nc, _arg_tr, _arg_blank);
  return retval;
}

octave_value_list _wrap_pgconf(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 8)
  {
    print_usage("pgconf");
    return retval;
  }

  float *_arg_a;
  int _arg_idim;
  int _arg_jdim;
  int _arg_i1;
  int _arg_i2;
  int _arg_j1;
  int _arg_j2;
  float _arg_c1;
  float _arg_c2;
  float *_arg_tr;
  _arg_idim = (_dim(args(1), 0));
  _arg_jdim = (_dim(args(1), 1));
  if (_n_dims(args(1)) > 2)
    { error("dimension mismatch in argument a"); return retval; }
  Matrix _a = args(1).matrix_value();
  _arg_a = (float *)alloca(_a.dim1() * _a.dim2() * sizeof (float));
  _cvt_double_to(_arg_a, &_a(0,0), _a.dim1()*_a.dim2());

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument i1"); return retval; }
  _arg_i1 = (int)args(2).double_value();

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument i2"); return retval; }
  _arg_i2 = (int)args(3).double_value();

  if (_n_dims(args(4)) > 0)
    { error("dimension mismatch in argument j1"); return retval; }
  _arg_j1 = (int)args(4).double_value();

  if (_n_dims(args(5)) > 0)
    { error("dimension mismatch in argument j2"); return retval; }
  _arg_j2 = (int)args(5).double_value();

  if (_n_dims(args(6)) > 0)
    { error("dimension mismatch in argument c1"); return retval; }
  _arg_c1 = (float)args(6).double_value();

  if (_n_dims(args(7)) > 0)
    { error("dimension mismatch in argument c2"); return retval; }
  _arg_c2 = (float)args(7).double_value();

  if (  (int)(_dim(args(8), 0)) != (int)(6) ||
      _n_dims(args(8)) > 1)
    { error("dimension mismatch in argument tr"); return retval; }
  Matrix _tr = args(8).matrix_value();
  _arg_tr = (float *)alloca(_tr.dim1() * _tr.dim2() * sizeof (float));
  _cvt_double_to(_arg_tr, &_tr(0,0), _tr.dim1()*_tr.dim2());

    cpgconf(_arg_a, _arg_idim, _arg_jdim, _arg_i1, _arg_i2, _arg_j1, _arg_j2, _arg_c1, _arg_c2, _arg_tr);
  return retval;
}

octave_value_list _wrap_pgconl(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 10)
  {
    print_usage("pgconl");
    return retval;
  }

  float *_arg_a;
  int _arg_idim;
  int _arg_jdim;
  int _arg_i1;
  int _arg_i2;
  int _arg_j1;
  int _arg_j2;
  float _arg_c;
  float *_arg_tr;
  char * _arg_label;
  int _arg_intval;
  int _arg_minint;
  _arg_idim = (_dim(args(1), 0));
  _arg_jdim = (_dim(args(1), 1));
  if (_n_dims(args(1)) > 2)
    { error("dimension mismatch in argument a"); return retval; }
  Matrix _a = args(1).matrix_value();
  _arg_a = (float *)alloca(_a.dim1() * _a.dim2() * sizeof (float));
  _cvt_double_to(_arg_a, &_a(0,0), _a.dim1()*_a.dim2());

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument i1"); return retval; }
  _arg_i1 = (int)args(2).double_value();

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument i2"); return retval; }
  _arg_i2 = (int)args(3).double_value();

  if (_n_dims(args(4)) > 0)
    { error("dimension mismatch in argument j1"); return retval; }
  _arg_j1 = (int)args(4).double_value();

  if (_n_dims(args(5)) > 0)
    { error("dimension mismatch in argument j2"); return retval; }
  _arg_j2 = (int)args(5).double_value();

  if (_n_dims(args(6)) > 0)
    { error("dimension mismatch in argument c"); return retval; }
  _arg_c = (float)args(6).double_value();

  if (  (int)(_dim(args(7), 0)) != (int)(6) ||
      _n_dims(args(7)) > 1)
    { error("dimension mismatch in argument tr"); return retval; }
  Matrix _tr = args(7).matrix_value();
  _arg_tr = (float *)alloca(_tr.dim1() * _tr.dim2() * sizeof (float));
  _cvt_double_to(_arg_tr, &_tr(0,0), _tr.dim1()*_tr.dim2());

  if (0 > 0)
    { error("dimension mismatch in argument label"); return retval; }
  string _label = args(8).string_value();
  _label += '\0';
  _arg_label = (char *)_label.data();

  if (_n_dims(args(9)) > 0)
    { error("dimension mismatch in argument intval"); return retval; }
  _arg_intval = (int)args(9).double_value();

  if (_n_dims(args(10)) > 0)
    { error("dimension mismatch in argument minint"); return retval; }
  _arg_minint = (int)args(10).double_value();

    cpgconl(_arg_a, _arg_idim, _arg_jdim, _arg_i1, _arg_i2, _arg_j1, _arg_j2, _arg_c, _arg_tr, _arg_label, _arg_intval, _arg_minint);
  return retval;
}

octave_value_list _wrap_pgcons(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 7)
  {
    print_usage("pgcons");
    return retval;
  }

  float *_arg_a;
  int _arg_idim;
  int _arg_jdim;
  int _arg_i1;
  int _arg_i2;
  int _arg_j1;
  int _arg_j2;
  float *_arg_c;
  int _arg_nc;
  float *_arg_tr;
  _arg_nc = (_dim(args(6), 0));
  _arg_idim = (_dim(args(1), 0));
  _arg_jdim = (_dim(args(1), 1));
  if (_n_dims(args(1)) > 2)
    { error("dimension mismatch in argument a"); return retval; }
  Matrix _a = args(1).matrix_value();
  _arg_a = (float *)alloca(_a.dim1() * _a.dim2() * sizeof (float));
  _cvt_double_to(_arg_a, &_a(0,0), _a.dim1()*_a.dim2());

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument i1"); return retval; }
  _arg_i1 = (int)args(2).double_value();

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument i2"); return retval; }
  _arg_i2 = (int)args(3).double_value();

  if (_n_dims(args(4)) > 0)
    { error("dimension mismatch in argument j1"); return retval; }
  _arg_j1 = (int)args(4).double_value();

  if (_n_dims(args(5)) > 0)
    { error("dimension mismatch in argument j2"); return retval; }
  _arg_j2 = (int)args(5).double_value();

  if (_n_dims(args(6)) > 1)
    { error("dimension mismatch in argument c"); return retval; }
  Matrix _c = args(6).matrix_value();
  _arg_c = (float *)alloca(_c.dim1() * _c.dim2() * sizeof (float));
  _cvt_double_to(_arg_c, &_c(0,0), _c.dim1()*_c.dim2());

  if (  (int)(_dim(args(7), 0)) != (int)(6) ||
      _n_dims(args(7)) > 1)
    { error("dimension mismatch in argument tr"); return retval; }
  Matrix _tr = args(7).matrix_value();
  _arg_tr = (float *)alloca(_tr.dim1() * _tr.dim2() * sizeof (float));
  _cvt_double_to(_arg_tr, &_tr(0,0), _tr.dim1()*_tr.dim2());

    cpgcons(_arg_a, _arg_idim, _arg_jdim, _arg_i1, _arg_i2, _arg_j1, _arg_j2, _arg_c, _arg_nc, _arg_tr);
  return retval;
}

octave_value_list _wrap_pgcont(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 8)
  {
    print_usage("pgcont");
    return retval;
  }

  float *_arg_a;
  int _arg_idim;
  int _arg_jdim;
  int _arg_i1;
  int _arg_i2;
  int _arg_j1;
  int _arg_j2;
  float *_arg_c;
  int _arg_nc;
  float *_arg_tr;
  _arg_idim = (_dim(args(1), 0));
  _arg_jdim = (_dim(args(1), 1));
  _arg_nc = (int)args(7).double_value();
  if (_n_dims(args(1)) > 2)
    { error("dimension mismatch in argument a"); return retval; }
  Matrix _a = args(1).matrix_value();
  _arg_a = (float *)alloca(_a.dim1() * _a.dim2() * sizeof (float));
  _cvt_double_to(_arg_a, &_a(0,0), _a.dim1()*_a.dim2());

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument i1"); return retval; }
  _arg_i1 = (int)args(2).double_value();

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument i2"); return retval; }
  _arg_i2 = (int)args(3).double_value();

  if (_n_dims(args(4)) > 0)
    { error("dimension mismatch in argument j1"); return retval; }
  _arg_j1 = (int)args(4).double_value();

  if (_n_dims(args(5)) > 0)
    { error("dimension mismatch in argument j2"); return retval; }
  _arg_j2 = (int)args(5).double_value();

  if (  (int)(_dim(args(6), 0)) != (int)(((_arg_nc > 0 ? _arg_nc : -_arg_nc))) ||
      _n_dims(args(6)) > 1)
    { error("dimension mismatch in argument c"); return retval; }
  Matrix _c = args(6).matrix_value();
  _arg_c = (float *)alloca(_c.dim1() * _c.dim2() * sizeof (float));
  _cvt_double_to(_arg_c, &_c(0,0), _c.dim1()*_c.dim2());

  if (_n_dims(args(7)) > 0)
    { error("dimension mismatch in argument nc"); return retval; }

  if (  (int)(_dim(args(8), 0)) != (int)(6) ||
      _n_dims(args(8)) > 1)
    { error("dimension mismatch in argument tr"); return retval; }
  Matrix _tr = args(8).matrix_value();
  _arg_tr = (float *)alloca(_tr.dim1() * _tr.dim2() * sizeof (float));
  _cvt_double_to(_arg_tr, &_tr(0,0), _tr.dim1()*_tr.dim2());

    cpgcont(_arg_a, _arg_idim, _arg_jdim, _arg_i1, _arg_i2, _arg_j1, _arg_j2, _arg_c, _arg_nc, _arg_tr);
  return retval;
}

octave_value_list _wrap_pgctab(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 6)
  {
    print_usage("pgctab");
    return retval;
  }

  float *_arg_l;
  float *_arg_r;
  float *_arg_g;
  float *_arg_b;
  int _arg_nc;
  float _arg_contra;
  float _arg_bright;
  _arg_nc = (_dim(args(4), 0));
  if (  (int)(_dim(args(1), 0)) != (int)(_arg_nc) ||
      _n_dims(args(1)) > 1)
    { error("dimension mismatch in argument l"); return retval; }
  Matrix _l = args(1).matrix_value();
  _arg_l = (float *)alloca(_l.dim1() * _l.dim2() * sizeof (float));
  _cvt_double_to(_arg_l, &_l(0,0), _l.dim1()*_l.dim2());

  if (  (int)(_dim(args(2), 0)) != (int)(_arg_nc) ||
      _n_dims(args(2)) > 1)
    { error("dimension mismatch in argument r"); return retval; }
  Matrix _r = args(2).matrix_value();
  _arg_r = (float *)alloca(_r.dim1() * _r.dim2() * sizeof (float));
  _cvt_double_to(_arg_r, &_r(0,0), _r.dim1()*_r.dim2());

  if (  (int)(_dim(args(3), 0)) != (int)(_arg_nc) ||
      _n_dims(args(3)) > 1)
    { error("dimension mismatch in argument g"); return retval; }
  Matrix _g = args(3).matrix_value();
  _arg_g = (float *)alloca(_g.dim1() * _g.dim2() * sizeof (float));
  _cvt_double_to(_arg_g, &_g(0,0), _g.dim1()*_g.dim2());

  if (_n_dims(args(4)) > 1)
    { error("dimension mismatch in argument b"); return retval; }
  Matrix _b = args(4).matrix_value();
  _arg_b = (float *)alloca(_b.dim1() * _b.dim2() * sizeof (float));
  _cvt_double_to(_arg_b, &_b(0,0), _b.dim1()*_b.dim2());

  if (_n_dims(args(5)) > 0)
    { error("dimension mismatch in argument contra"); return retval; }
  _arg_contra = (float)args(5).double_value();

  if (_n_dims(args(6)) > 0)
    { error("dimension mismatch in argument bright"); return retval; }
  _arg_bright = (float)args(6).double_value();

    cpgctab(_arg_l, _arg_r, _arg_g, _arg_b, _arg_nc, _arg_contra, _arg_bright);
  return retval;
}

octave_value_list _wrap_pgcurs(const octave_value_list &args, int nargout)
{
  octave_value_list retval(2, octave_value());
  if (args.length()-1 != 2 ||
      nargout != 4)
  {
    print_usage("pgcurs");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int first_modify_flag = 1;
  float *_arg_x;
  float *_arg_y;
  char *_arg_ch_scalar;
  int *_arg_retval;
  if (!_check_modify_vectorize(args(1), &_vec_n, _d, 0, &first_modify_flag))
    { error("dimension mismatch in argument x"); return retval; }
  Matrix _x = args(1).matrix_value();
  _arg_x = (float *)alloca(_x.dim1() * _x.dim2() * sizeof (float));
  _cvt_double_to(_arg_x, &_x(0,0), _x.dim1()*_x.dim2());
  retval(2) = octave_value(Matrix(_dim(_x, 0), _dim(_x, 1)));

  if (!_check_modify_vectorize(args(2), &_vec_n, _d, 0, &first_modify_flag))
    { error("dimension mismatch in argument y"); return retval; }
  Matrix _y = args(2).matrix_value();
  _arg_y = (float *)alloca(_y.dim1() * _y.dim2() * sizeof (float));
  _cvt_double_to(_arg_y, &_y(0,0), _y.dim1()*_y.dim2());
  retval(3) = octave_value(Matrix(_dim(_y, 0), _dim(_y, 1)));

  if (_d[0]  != 1 || _d[1]  != 1)
    retval(0) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_retval = (int *)alloca(_d[0]  * _d[1]  * sizeof (int));
  retval(1) = octave_value(charMatrix(_d[0] , _d[1] ), true);
  _arg_ch_scalar = (char *)retval(1).char_matrix_value().data();
  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    _arg_retval[_vidx] = (int)
      cpgcurs(&_arg_x[_vidx], &_arg_y[_vidx], &_arg_ch_scalar[_vidx]);
  }
  if (_arraylen(retval(2)) == 1)
    retval(2) = octave_value(double(*_arg_x));
  else
    _cvt_to_double(_arg_x, (double *)retval(2).matrix_value().data(), _arraylen(retval(2)));
  if (_arraylen(retval(3)) == 1)
    retval(3) = octave_value(double(*_arg_y));
  else
    _cvt_to_double(_arg_y, (double *)retval(3).matrix_value().data(), _arraylen(retval(3)));
  if (_arraylen(retval(0)) == 1)
    retval(0) = octave_value(double(*_arg_retval));
  else
    _cvt_to_double(_arg_retval, (double *)retval(0).matrix_value().data(), _arraylen(retval(0)));
  return retval;
}

octave_value_list _wrap_pgdraw(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 2)
  {
    print_usage("pgdraw");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  float *_arg_x;
  float *_arg_y;
  int _vecstride_x = 1;
  int _vecstride_y = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_x))
    { error("dimension mismatch in argument x"); return retval; }
  Matrix _x = args(1).matrix_value();
  _arg_x = (float *)alloca(_x.dim1() * _x.dim2() * sizeof (float));
  _cvt_double_to(_arg_x, &_x(0,0), _x.dim1()*_x.dim2());

  if (!_check_input_vectorize(args(2), &_vec_n, _d, 0, &_vecstride_y))
    { error("dimension mismatch in argument y"); return retval; }
  Matrix _y = args(2).matrix_value();
  _arg_y = (float *)alloca(_y.dim1() * _y.dim2() * sizeof (float));
  _cvt_double_to(_arg_y, &_y(0,0), _y.dim1()*_y.dim2());

  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgdraw(_arg_x[_vecstride_x*_vidx], _arg_y[_vecstride_y*_vidx]);
  }
  return retval;
}

octave_value_list _wrap_pgebuf(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgebuf");
    return retval;
  }

    cpgebuf();
  return retval;
}

octave_value_list _wrap_pgend(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgend");
    return retval;
  }

    cpgend();
  return retval;
}

octave_value_list _wrap_pgenv(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 6)
  {
    print_usage("pgenv");
    return retval;
  }

  float _arg_xmin;
  float _arg_xmax;
  float _arg_ymin;
  float _arg_ymax;
  int _arg_just;
  int _arg_axis;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument xmin"); return retval; }
  _arg_xmin = (float)args(1).double_value();

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument xmax"); return retval; }
  _arg_xmax = (float)args(2).double_value();

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument ymin"); return retval; }
  _arg_ymin = (float)args(3).double_value();

  if (_n_dims(args(4)) > 0)
    { error("dimension mismatch in argument ymax"); return retval; }
  _arg_ymax = (float)args(4).double_value();

  if (_n_dims(args(5)) > 0)
    { error("dimension mismatch in argument just"); return retval; }
  _arg_just = (int)args(5).double_value();

  if (_n_dims(args(6)) > 0)
    { error("dimension mismatch in argument axis"); return retval; }
  _arg_axis = (int)args(6).double_value();

    cpgenv(_arg_xmin, _arg_xmax, _arg_ymin, _arg_ymax, _arg_just, _arg_axis);
  return retval;
}

octave_value_list _wrap_pgeras(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgeras");
    return retval;
  }

    cpgeras();
  return retval;
}

octave_value_list _wrap_pgerr1(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 5)
  {
    print_usage("pgerr1");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int *_arg_dir;
  float *_arg_x;
  float *_arg_y;
  float *_arg_e;
  float *_arg_t;
  int _vecstride_dir = 1;
  int _vecstride_x = 1;
  int _vecstride_y = 1;
  int _vecstride_e = 1;
  int _vecstride_t = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_dir))
    { error("dimension mismatch in argument dir"); return retval; }
  Matrix _dir = args(1).matrix_value();
  _arg_dir = (int *)alloca(_dir.dim1() * _dir.dim2() * sizeof (int));
  _cvt_double_to(_arg_dir, &_dir(0,0), _dir.dim1()*_dir.dim2());

  if (!_check_input_vectorize(args(2), &_vec_n, _d, 0, &_vecstride_x))
    { error("dimension mismatch in argument x"); return retval; }
  Matrix _x = args(2).matrix_value();
  _arg_x = (float *)alloca(_x.dim1() * _x.dim2() * sizeof (float));
  _cvt_double_to(_arg_x, &_x(0,0), _x.dim1()*_x.dim2());

  if (!_check_input_vectorize(args(3), &_vec_n, _d, 0, &_vecstride_y))
    { error("dimension mismatch in argument y"); return retval; }
  Matrix _y = args(3).matrix_value();
  _arg_y = (float *)alloca(_y.dim1() * _y.dim2() * sizeof (float));
  _cvt_double_to(_arg_y, &_y(0,0), _y.dim1()*_y.dim2());

  if (!_check_input_vectorize(args(4), &_vec_n, _d, 0, &_vecstride_e))
    { error("dimension mismatch in argument e"); return retval; }
  Matrix _e = args(4).matrix_value();
  _arg_e = (float *)alloca(_e.dim1() * _e.dim2() * sizeof (float));
  _cvt_double_to(_arg_e, &_e(0,0), _e.dim1()*_e.dim2());

  if (!_check_input_vectorize(args(5), &_vec_n, _d, 0, &_vecstride_t))
    { error("dimension mismatch in argument t"); return retval; }
  Matrix _t = args(5).matrix_value();
  _arg_t = (float *)alloca(_t.dim1() * _t.dim2() * sizeof (float));
  _cvt_double_to(_arg_t, &_t(0,0), _t.dim1()*_t.dim2());

  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgerr1(_arg_dir[_vecstride_dir*_vidx], _arg_x[_vecstride_x*_vidx], _arg_y[_vecstride_y*_vidx], _arg_e[_vecstride_e*_vidx], _arg_t[_vecstride_t*_vidx]);
  }
  return retval;
}

octave_value_list _wrap_pgerrb(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 5)
  {
    print_usage("pgerrb");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int *_arg_dir;
  int _arg_n;
  float *_arg_x;
  float *_arg_y;
  float *_arg_e;
  float *_arg_t;
  _arg_n = (_dim(args(4), 0));
  int _vecstride_dir = 1;
  int _vecstride_x = _arg_n;
  int _vecstride_y = _arg_n;
  int _vecstride_e = _arg_n;
  int _vecstride_t = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_dir))
    { error("dimension mismatch in argument dir"); return retval; }
  Matrix _dir = args(1).matrix_value();
  _arg_dir = (int *)alloca(_dir.dim1() * _dir.dim2() * sizeof (int));
  _cvt_double_to(_arg_dir, &_dir(0,0), _dir.dim1()*_dir.dim2());

  if (  (int)(_dim(args(2), 0)) != (int)(_arg_n) ||
      !_check_input_vectorize(args(2), &_vec_n, _d, 1, &_vecstride_x))
    { error("dimension mismatch in argument x"); return retval; }
  Matrix _x = args(2).matrix_value();
  _arg_x = (float *)alloca(_x.dim1() * _x.dim2() * sizeof (float));
  _cvt_double_to(_arg_x, &_x(0,0), _x.dim1()*_x.dim2());

  if (  (int)(_dim(args(3), 0)) != (int)(_arg_n) ||
      !_check_input_vectorize(args(3), &_vec_n, _d, 1, &_vecstride_y))
    { error("dimension mismatch in argument y"); return retval; }
  Matrix _y = args(3).matrix_value();
  _arg_y = (float *)alloca(_y.dim1() * _y.dim2() * sizeof (float));
  _cvt_double_to(_arg_y, &_y(0,0), _y.dim1()*_y.dim2());

  if (!_check_input_vectorize(args(4), &_vec_n, _d, 1, &_vecstride_e))
    { error("dimension mismatch in argument e"); return retval; }
  Matrix _e = args(4).matrix_value();
  _arg_e = (float *)alloca(_e.dim1() * _e.dim2() * sizeof (float));
  _cvt_double_to(_arg_e, &_e(0,0), _e.dim1()*_e.dim2());

  if (!_check_input_vectorize(args(5), &_vec_n, _d, 0, &_vecstride_t))
    { error("dimension mismatch in argument t"); return retval; }
  Matrix _t = args(5).matrix_value();
  _arg_t = (float *)alloca(_t.dim1() * _t.dim2() * sizeof (float));
  _cvt_double_to(_arg_t, &_t(0,0), _t.dim1()*_t.dim2());

  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgerrb(_arg_dir[_vecstride_dir*_vidx], _arg_n, &_arg_x[_vecstride_x*_vidx], &_arg_y[_vecstride_y*_vidx], &_arg_e[_vecstride_e*_vidx], _arg_t[_vecstride_t*_vidx]);
  }
  return retval;
}

octave_value_list _wrap_pgerrx(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 4)
  {
    print_usage("pgerrx");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int _arg_n;
  float *_arg_x1;
  float *_arg_x2;
  float *_arg_y;
  float *_arg_t;
  _arg_n = (_dim(args(3), 0));
  int _vecstride_x1 = _arg_n;
  int _vecstride_x2 = _arg_n;
  int _vecstride_y = _arg_n;
  int _vecstride_t = 1;
  if (  (int)(_dim(args(1), 0)) != (int)(_arg_n) ||
      !_check_input_vectorize(args(1), &_vec_n, _d, 1, &_vecstride_x1))
    { error("dimension mismatch in argument x1"); return retval; }
  Matrix _x1 = args(1).matrix_value();
  _arg_x1 = (float *)alloca(_x1.dim1() * _x1.dim2() * sizeof (float));
  _cvt_double_to(_arg_x1, &_x1(0,0), _x1.dim1()*_x1.dim2());

  if (  (int)(_dim(args(2), 0)) != (int)(_arg_n) ||
      !_check_input_vectorize(args(2), &_vec_n, _d, 1, &_vecstride_x2))
    { error("dimension mismatch in argument x2"); return retval; }
  Matrix _x2 = args(2).matrix_value();
  _arg_x2 = (float *)alloca(_x2.dim1() * _x2.dim2() * sizeof (float));
  _cvt_double_to(_arg_x2, &_x2(0,0), _x2.dim1()*_x2.dim2());

  if (!_check_input_vectorize(args(3), &_vec_n, _d, 1, &_vecstride_y))
    { error("dimension mismatch in argument y"); return retval; }
  Matrix _y = args(3).matrix_value();
  _arg_y = (float *)alloca(_y.dim1() * _y.dim2() * sizeof (float));
  _cvt_double_to(_arg_y, &_y(0,0), _y.dim1()*_y.dim2());

  if (!_check_input_vectorize(args(4), &_vec_n, _d, 0, &_vecstride_t))
    { error("dimension mismatch in argument t"); return retval; }
  Matrix _t = args(4).matrix_value();
  _arg_t = (float *)alloca(_t.dim1() * _t.dim2() * sizeof (float));
  _cvt_double_to(_arg_t, &_t(0,0), _t.dim1()*_t.dim2());

  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgerrx(_arg_n, &_arg_x1[_vecstride_x1*_vidx], &_arg_x2[_vecstride_x2*_vidx], &_arg_y[_vecstride_y*_vidx], _arg_t[_vecstride_t*_vidx]);
  }
  return retval;
}

octave_value_list _wrap_pgerry(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 4)
  {
    print_usage("pgerry");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int _arg_n;
  float *_arg_x;
  float *_arg_y1;
  float *_arg_y2;
  float *_arg_t;
  _arg_n = (_dim(args(3), 0));
  int _vecstride_x = _arg_n;
  int _vecstride_y1 = _arg_n;
  int _vecstride_y2 = _arg_n;
  int _vecstride_t = 1;
  if (  (int)(_dim(args(1), 0)) != (int)(_arg_n) ||
      !_check_input_vectorize(args(1), &_vec_n, _d, 1, &_vecstride_x))
    { error("dimension mismatch in argument x"); return retval; }
  Matrix _x = args(1).matrix_value();
  _arg_x = (float *)alloca(_x.dim1() * _x.dim2() * sizeof (float));
  _cvt_double_to(_arg_x, &_x(0,0), _x.dim1()*_x.dim2());

  if (  (int)(_dim(args(2), 0)) != (int)(_arg_n) ||
      !_check_input_vectorize(args(2), &_vec_n, _d, 1, &_vecstride_y1))
    { error("dimension mismatch in argument y1"); return retval; }
  Matrix _y1 = args(2).matrix_value();
  _arg_y1 = (float *)alloca(_y1.dim1() * _y1.dim2() * sizeof (float));
  _cvt_double_to(_arg_y1, &_y1(0,0), _y1.dim1()*_y1.dim2());

  if (!_check_input_vectorize(args(3), &_vec_n, _d, 1, &_vecstride_y2))
    { error("dimension mismatch in argument y2"); return retval; }
  Matrix _y2 = args(3).matrix_value();
  _arg_y2 = (float *)alloca(_y2.dim1() * _y2.dim2() * sizeof (float));
  _cvt_double_to(_arg_y2, &_y2(0,0), _y2.dim1()*_y2.dim2());

  if (!_check_input_vectorize(args(4), &_vec_n, _d, 0, &_vecstride_t))
    { error("dimension mismatch in argument t"); return retval; }
  Matrix _t = args(4).matrix_value();
  _arg_t = (float *)alloca(_t.dim1() * _t.dim2() * sizeof (float));
  _cvt_double_to(_arg_t, &_t(0,0), _t.dim1()*_t.dim2());

  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgerry(_arg_n, &_arg_x[_vecstride_x*_vidx], &_arg_y1[_vecstride_y1*_vidx], &_arg_y2[_vecstride_y2*_vidx], _arg_t[_vecstride_t*_vidx]);
  }
  return retval;
}

octave_value_list _wrap_pgetxt(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgetxt");
    return retval;
  }

    cpgetxt();
  return retval;
}

octave_value_list _wrap_pggray(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 8)
  {
    print_usage("pggray");
    return retval;
  }

  float *_arg_a;
  int _arg_idim;
  int _arg_jdim;
  int _arg_i1;
  int _arg_i2;
  int _arg_j1;
  int _arg_j2;
  float _arg_fg;
  float _arg_bg;
  float *_arg_tr;
  _arg_idim = (_dim(args(1), 0));
  _arg_jdim = (_dim(args(1), 1));
  if (_n_dims(args(1)) > 2)
    { error("dimension mismatch in argument a"); return retval; }
  Matrix _a = args(1).matrix_value();
  _arg_a = (float *)alloca(_a.dim1() * _a.dim2() * sizeof (float));
  _cvt_double_to(_arg_a, &_a(0,0), _a.dim1()*_a.dim2());

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument i1"); return retval; }
  _arg_i1 = (int)args(2).double_value();

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument i2"); return retval; }
  _arg_i2 = (int)args(3).double_value();

  if (_n_dims(args(4)) > 0)
    { error("dimension mismatch in argument j1"); return retval; }
  _arg_j1 = (int)args(4).double_value();

  if (_n_dims(args(5)) > 0)
    { error("dimension mismatch in argument j2"); return retval; }
  _arg_j2 = (int)args(5).double_value();

  if (_n_dims(args(6)) > 0)
    { error("dimension mismatch in argument fg"); return retval; }
  _arg_fg = (float)args(6).double_value();

  if (_n_dims(args(7)) > 0)
    { error("dimension mismatch in argument bg"); return retval; }
  _arg_bg = (float)args(7).double_value();

  if (  (int)(_dim(args(8), 0)) != (int)(6) ||
      _n_dims(args(8)) > 1)
    { error("dimension mismatch in argument tr"); return retval; }
  Matrix _tr = args(8).matrix_value();
  _arg_tr = (float *)alloca(_tr.dim1() * _tr.dim2() * sizeof (float));
  _cvt_double_to(_arg_tr, &_tr(0,0), _tr.dim1()*_tr.dim2());

    cpggray(_arg_a, _arg_idim, _arg_jdim, _arg_i1, _arg_i2, _arg_j1, _arg_j2, _arg_fg, _arg_bg, _arg_tr);
  return retval;
}

octave_value_list _wrap_pghi2d(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 10)
  {
    print_usage("pghi2d");
    return retval;
  }

  float *_arg_data;
  int _arg_nxv;
  int _arg_nyv;
  int _arg_ix1;
  int _arg_ix2;
  int _arg_iy1;
  int _arg_iy2;
  float *_arg_x;
  int _arg_ioff;
  float _arg_bias;
  int _arg_center;
  float *_arg_ylims;
  _arg_nxv = (_dim(args(1), 0));
  _arg_nyv = (_dim(args(1), 1));
  _arg_ix1 = (int)args(2).double_value();
  _arg_ix2 = (int)args(3).double_value();
  if (_n_dims(args(1)) > 2)
    { error("dimension mismatch in argument data"); return retval; }
  Matrix _data = args(1).matrix_value();
  _arg_data = (float *)alloca(_data.dim1() * _data.dim2() * sizeof (float));
  _cvt_double_to(_arg_data, &_data(0,0), _data.dim1()*_data.dim2());

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument ix1"); return retval; }

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument ix2"); return retval; }

  if (_n_dims(args(4)) > 0)
    { error("dimension mismatch in argument iy1"); return retval; }
  _arg_iy1 = (int)args(4).double_value();

  if (_n_dims(args(5)) > 0)
    { error("dimension mismatch in argument iy2"); return retval; }
  _arg_iy2 = (int)args(5).double_value();

  if (  (int)(_dim(args(6), 0)) != (int)((_arg_ix2-_arg_ix1+1)) ||
      _n_dims(args(6)) > 1)
    { error("dimension mismatch in argument x"); return retval; }
  Matrix _x = args(6).matrix_value();
  _arg_x = (float *)alloca(_x.dim1() * _x.dim2() * sizeof (float));
  _cvt_double_to(_arg_x, &_x(0,0), _x.dim1()*_x.dim2());

  if (_n_dims(args(7)) > 0)
    { error("dimension mismatch in argument ioff"); return retval; }
  _arg_ioff = (int)args(7).double_value();

  if (_n_dims(args(8)) > 0)
    { error("dimension mismatch in argument bias"); return retval; }
  _arg_bias = (float)args(8).double_value();

  if (_n_dims(args(9)) > 0)
    { error("dimension mismatch in argument center"); return retval; }
  _arg_center = (int)args(9).double_value();

  if (  (int)(_dim(args(10), 0)) != (int)((_arg_ix2-_arg_ix1+1)) ||
      _n_dims(args(10)) > 1)
    { error("dimension mismatch in argument ylims"); return retval; }
  Matrix _ylims = args(10).matrix_value();
  _arg_ylims = (float *)alloca(_ylims.dim1() * _ylims.dim2() * sizeof (float));
  _cvt_double_to(_arg_ylims, &_ylims(0,0), _ylims.dim1()*_ylims.dim2());

    cpghi2d(_arg_data, _arg_nxv, _arg_nyv, _arg_ix1, _arg_ix2, _arg_iy1, _arg_iy2, _arg_x, _arg_ioff, _arg_bias, _arg_center, _arg_ylims);
  return retval;
}

octave_value_list _wrap_pghist(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 5)
  {
    print_usage("pghist");
    return retval;
  }

  int _arg_n;
  float *_arg_data;
  float _arg_datmin;
  float _arg_datmax;
  int _arg_nbin;
  int _arg_pgflag;
  _arg_n = (_dim(args(1), 0));
  if (_n_dims(args(1)) > 1)
    { error("dimension mismatch in argument data"); return retval; }
  Matrix _data = args(1).matrix_value();
  _arg_data = (float *)alloca(_data.dim1() * _data.dim2() * sizeof (float));
  _cvt_double_to(_arg_data, &_data(0,0), _data.dim1()*_data.dim2());

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument datmin"); return retval; }
  _arg_datmin = (float)args(2).double_value();

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument datmax"); return retval; }
  _arg_datmax = (float)args(3).double_value();

  if (_n_dims(args(4)) > 0)
    { error("dimension mismatch in argument nbin"); return retval; }
  _arg_nbin = (int)args(4).double_value();

  if (_n_dims(args(5)) > 0)
    { error("dimension mismatch in argument pgflag"); return retval; }
  _arg_pgflag = (int)args(5).double_value();

    cpghist(_arg_n, _arg_data, _arg_datmin, _arg_datmax, _arg_nbin, _arg_pgflag);
  return retval;
}

octave_value_list _wrap_pgiden(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgiden");
    return retval;
  }

    cpgiden();
  return retval;
}

octave_value_list _wrap_pgimag(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 8)
  {
    print_usage("pgimag");
    return retval;
  }

  float *_arg_a;
  int _arg_idim;
  int _arg_jdim;
  int _arg_i1;
  int _arg_i2;
  int _arg_j1;
  int _arg_j2;
  float _arg_a1;
  float _arg_a2;
  float *_arg_tr;
  _arg_idim = (_dim(args(1), 0));
  _arg_jdim = (_dim(args(1), 1));
  if (_n_dims(args(1)) > 2)
    { error("dimension mismatch in argument a"); return retval; }
  Matrix _a = args(1).matrix_value();
  _arg_a = (float *)alloca(_a.dim1() * _a.dim2() * sizeof (float));
  _cvt_double_to(_arg_a, &_a(0,0), _a.dim1()*_a.dim2());

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument i1"); return retval; }
  _arg_i1 = (int)args(2).double_value();

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument i2"); return retval; }
  _arg_i2 = (int)args(3).double_value();

  if (_n_dims(args(4)) > 0)
    { error("dimension mismatch in argument j1"); return retval; }
  _arg_j1 = (int)args(4).double_value();

  if (_n_dims(args(5)) > 0)
    { error("dimension mismatch in argument j2"); return retval; }
  _arg_j2 = (int)args(5).double_value();

  if (_n_dims(args(6)) > 0)
    { error("dimension mismatch in argument a1"); return retval; }
  _arg_a1 = (float)args(6).double_value();

  if (_n_dims(args(7)) > 0)
    { error("dimension mismatch in argument a2"); return retval; }
  _arg_a2 = (float)args(7).double_value();

  if (  (int)(_dim(args(8), 0)) != (int)(6) ||
      _n_dims(args(8)) > 1)
    { error("dimension mismatch in argument tr"); return retval; }
  Matrix _tr = args(8).matrix_value();
  _arg_tr = (float *)alloca(_tr.dim1() * _tr.dim2() * sizeof (float));
  _cvt_double_to(_arg_tr, &_tr(0,0), _tr.dim1()*_tr.dim2());

    cpgimag(_arg_a, _arg_idim, _arg_jdim, _arg_i1, _arg_i2, _arg_j1, _arg_j2, _arg_a1, _arg_a2, _arg_tr);
  return retval;
}

octave_value_list _wrap_pglab(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 3)
  {
    print_usage("pglab");
    return retval;
  }

  char * _arg_xlbl;
  char * _arg_ylbl;
  char * _arg_toplbl;
  if (0 > 0)
    { error("dimension mismatch in argument xlbl"); return retval; }
  string _xlbl = args(1).string_value();
  _xlbl += '\0';
  _arg_xlbl = (char *)_xlbl.data();

  if (0 > 0)
    { error("dimension mismatch in argument ylbl"); return retval; }
  string _ylbl = args(2).string_value();
  _ylbl += '\0';
  _arg_ylbl = (char *)_ylbl.data();

  if (0 > 0)
    { error("dimension mismatch in argument toplbl"); return retval; }
  string _toplbl = args(3).string_value();
  _toplbl += '\0';
  _arg_toplbl = (char *)_toplbl.data();

    cpglab(_arg_xlbl, _arg_ylbl, _arg_toplbl);
  return retval;
}

octave_value_list _wrap_pglcur(const octave_value_list &args, int nargout)
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 3 ||
      nargout != 3)
  {
    print_usage("pglcur");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int first_modify_flag = 1;
  int _arg_maxpt;
  int *_arg_npt;
  float *_arg_x;
  float *_arg_y;
  _arg_maxpt = (_dim(args(3), 0));
  if (!_check_modify_vectorize(args(1), &_vec_n, _d, 0, &first_modify_flag))
    { error("dimension mismatch in argument npt"); return retval; }
  Matrix _npt = args(1).matrix_value();
  _arg_npt = (int *)alloca(_npt.dim1() * _npt.dim2() * sizeof (int));
  _cvt_double_to(_arg_npt, &_npt(0,0), _npt.dim1()*_npt.dim2());
  retval(0) = octave_value(Matrix(_dim(_npt, 0), _dim(_npt, 1)));

  if (  (int)(_dim(args(2), 0)) != (int)(_arg_maxpt) ||
      !_check_modify_vectorize(args(2), &_vec_n, _d, 1, &first_modify_flag))
    { error("dimension mismatch in argument x"); return retval; }
  Matrix _x = args(2).matrix_value();
  _arg_x = (float *)alloca(_x.dim1() * _x.dim2() * sizeof (float));
  _cvt_double_to(_arg_x, &_x(0,0), _x.dim1()*_x.dim2());
  retval(1) = octave_value(Matrix(_dim(_x, 0), _dim(_x, 1)));

  if (!_check_modify_vectorize(args(3), &_vec_n, _d, 1, &first_modify_flag))
    { error("dimension mismatch in argument y"); return retval; }
  Matrix _y = args(3).matrix_value();
  _arg_y = (float *)alloca(_y.dim1() * _y.dim2() * sizeof (float));
  _cvt_double_to(_arg_y, &_y(0,0), _y.dim1()*_y.dim2());
  retval(2) = octave_value(Matrix(_dim(_y, 0), _dim(_y, 1)));

  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpglcur(_arg_maxpt, &_arg_npt[_vidx], &_arg_x[_arg_maxpt*_vidx], &_arg_y[_arg_maxpt*_vidx]);
  }
  if (_arraylen(retval(0)) == 1)
    retval(0) = octave_value(double(*_arg_npt));
  else
    _cvt_to_double(_arg_npt, (double *)retval(0).matrix_value().data(), _arraylen(retval(0)));
  if (_arraylen(retval(1)) == 1)
    retval(1) = octave_value(double(*_arg_x));
  else
    _cvt_to_double(_arg_x, (double *)retval(1).matrix_value().data(), _arraylen(retval(1)));
  if (_arraylen(retval(2)) == 1)
    retval(2) = octave_value(double(*_arg_y));
  else
    _cvt_to_double(_arg_y, (double *)retval(2).matrix_value().data(), _arraylen(retval(2)));
  return retval;
}

octave_value_list _wrap_pgldev(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgldev");
    return retval;
  }

    cpgldev();
  return retval;
}

octave_value_list _wrap_pglen(const octave_value_list &args, int nargout)
{
  octave_value_list retval(2, octave_value());
  if (args.length()-1 != 2 ||
      nargout != 2)
  {
    print_usage("pglen");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int *_arg_units;
  char * _arg_string;
  float *_arg_xl;
  float *_arg_yl;
  int _vecstride_units = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_units))
    { error("dimension mismatch in argument units"); return retval; }
  Matrix _units = args(1).matrix_value();
  _arg_units = (int *)alloca(_units.dim1() * _units.dim2() * sizeof (int));
  _cvt_double_to(_arg_units, &_units(0,0), _units.dim1()*_units.dim2());

  if (0 > 0)
    { error("dimension mismatch in argument string"); return retval; }
  string _string = args(2).string_value();
  _string += '\0';
  _arg_string = (char *)_string.data();

  if (_d[0]  != 1 || _d[1]  != 1)
    retval(0) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_xl = (float *)alloca(_d[0]  * _d[1]  * sizeof (float));
  if (_d[0]  != 1 || _d[1]  != 1)
    retval(1) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_yl = (float *)alloca(_d[0]  * _d[1]  * sizeof (float));
  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpglen(_arg_units[_vecstride_units*_vidx], _arg_string, &_arg_xl[_vidx], &_arg_yl[_vidx]);
  }
  if (_arraylen(retval(0)) == 1)
    retval(0) = octave_value(double(*_arg_xl));
  else
    _cvt_to_double(_arg_xl, (double *)retval(0).matrix_value().data(), _arraylen(retval(0)));
  if (_arraylen(retval(1)) == 1)
    retval(1) = octave_value(double(*_arg_yl));
  else
    _cvt_to_double(_arg_yl, (double *)retval(1).matrix_value().data(), _arraylen(retval(1)));
  return retval;
}

octave_value_list _wrap_pgline(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 2)
  {
    print_usage("pgline");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int _arg_n;
  float *_arg_xpts;
  float *_arg_ypts;
  _arg_n = (_dim(args(2), 0));
  int _vecstride_xpts = _arg_n;
  int _vecstride_ypts = _arg_n;
  if (  (int)(_dim(args(1), 0)) != (int)(_arg_n) ||
      !_check_input_vectorize(args(1), &_vec_n, _d, 1, &_vecstride_xpts))
    { error("dimension mismatch in argument xpts"); return retval; }
  Matrix _xpts = args(1).matrix_value();
  _arg_xpts = (float *)alloca(_xpts.dim1() * _xpts.dim2() * sizeof (float));
  _cvt_double_to(_arg_xpts, &_xpts(0,0), _xpts.dim1()*_xpts.dim2());

  if (!_check_input_vectorize(args(2), &_vec_n, _d, 1, &_vecstride_ypts))
    { error("dimension mismatch in argument ypts"); return retval; }
  Matrix _ypts = args(2).matrix_value();
  _arg_ypts = (float *)alloca(_ypts.dim1() * _ypts.dim2() * sizeof (float));
  _cvt_double_to(_arg_ypts, &_ypts(0,0), _ypts.dim1()*_ypts.dim2());

  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgline(_arg_n, &_arg_xpts[_vecstride_xpts*_vidx], &_arg_ypts[_vecstride_ypts*_vidx]);
  }
  return retval;
}

octave_value_list _wrap_pgmove(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 2)
  {
    print_usage("pgmove");
    return retval;
  }

  float _arg_x;
  float _arg_y;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument x"); return retval; }
  _arg_x = (float)args(1).double_value();

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument y"); return retval; }
  _arg_y = (float)args(2).double_value();

    cpgmove(_arg_x, _arg_y);
  return retval;
}

octave_value_list _wrap_pgmtxt(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 5)
  {
    print_usage("pgmtxt");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  char * _arg_side;
  float *_arg_disp;
  float *_arg_coord;
  float *_arg_fjust;
  char * _arg_text;
  int _vecstride_disp = 1;
  int _vecstride_coord = 1;
  int _vecstride_fjust = 1;
  if (0 > 0)
    { error("dimension mismatch in argument side"); return retval; }
  string _side = args(1).string_value();
  _side += '\0';
  _arg_side = (char *)_side.data();

  if (!_check_input_vectorize(args(2), &_vec_n, _d, 0, &_vecstride_disp))
    { error("dimension mismatch in argument disp"); return retval; }
  Matrix _disp = args(2).matrix_value();
  _arg_disp = (float *)alloca(_disp.dim1() * _disp.dim2() * sizeof (float));
  _cvt_double_to(_arg_disp, &_disp(0,0), _disp.dim1()*_disp.dim2());

  if (!_check_input_vectorize(args(3), &_vec_n, _d, 0, &_vecstride_coord))
    { error("dimension mismatch in argument coord"); return retval; }
  Matrix _coord = args(3).matrix_value();
  _arg_coord = (float *)alloca(_coord.dim1() * _coord.dim2() * sizeof (float));
  _cvt_double_to(_arg_coord, &_coord(0,0), _coord.dim1()*_coord.dim2());

  if (!_check_input_vectorize(args(4), &_vec_n, _d, 0, &_vecstride_fjust))
    { error("dimension mismatch in argument fjust"); return retval; }
  Matrix _fjust = args(4).matrix_value();
  _arg_fjust = (float *)alloca(_fjust.dim1() * _fjust.dim2() * sizeof (float));
  _cvt_double_to(_arg_fjust, &_fjust(0,0), _fjust.dim1()*_fjust.dim2());

  if (0 > 0)
    { error("dimension mismatch in argument text"); return retval; }
  string _text = args(5).string_value();
  _text += '\0';
  _arg_text = (char *)_text.data();

  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgmtxt(_arg_side, _arg_disp[_vecstride_disp*_vidx], _arg_coord[_vecstride_coord*_vidx], _arg_fjust[_vecstride_fjust*_vidx], _arg_text);
  }
  return retval;
}

octave_value_list _wrap_pgncur(const octave_value_list &args, int nargout)
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 4 ||
      nargout != 3)
  {
    print_usage("pgncur");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int first_modify_flag = 1;
  int _arg_maxpt;
  int *_arg_npt;
  float *_arg_x;
  float *_arg_y;
  int *_arg_symbol;
  _arg_maxpt = (_dim(args(4), 0));
  int _vecstride_symbol = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_symbol))
    { error("dimension mismatch in argument symbol"); return retval; }
  Matrix _symbol = args(1).matrix_value();
  _arg_symbol = (int *)alloca(_symbol.dim1() * _symbol.dim2() * sizeof (int));
  _cvt_double_to(_arg_symbol, &_symbol(0,0), _symbol.dim1()*_symbol.dim2());

  if (!_check_modify_vectorize(args(2), &_vec_n, _d, 0, &first_modify_flag))
    { error("dimension mismatch in argument npt"); return retval; }
  Matrix _npt = args(2).matrix_value();
  _arg_npt = (int *)alloca(_npt.dim1() * _npt.dim2() * sizeof (int));
  _cvt_double_to(_arg_npt, &_npt(0,0), _npt.dim1()*_npt.dim2());
  retval(0) = octave_value(Matrix(_dim(_npt, 0), _dim(_npt, 1)));

  if (  (int)(_dim(args(3), 0)) != (int)(_arg_maxpt) ||
      !_check_modify_vectorize(args(3), &_vec_n, _d, 1, &first_modify_flag))
    { error("dimension mismatch in argument x"); return retval; }
  Matrix _x = args(3).matrix_value();
  _arg_x = (float *)alloca(_x.dim1() * _x.dim2() * sizeof (float));
  _cvt_double_to(_arg_x, &_x(0,0), _x.dim1()*_x.dim2());
  retval(1) = octave_value(Matrix(_dim(_x, 0), _dim(_x, 1)));

  if (!_check_modify_vectorize(args(4), &_vec_n, _d, 1, &first_modify_flag))
    { error("dimension mismatch in argument y"); return retval; }
  Matrix _y = args(4).matrix_value();
  _arg_y = (float *)alloca(_y.dim1() * _y.dim2() * sizeof (float));
  _cvt_double_to(_arg_y, &_y(0,0), _y.dim1()*_y.dim2());
  retval(2) = octave_value(Matrix(_dim(_y, 0), _dim(_y, 1)));

  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgncur(_arg_maxpt, &_arg_npt[_vidx], &_arg_x[_arg_maxpt*_vidx], &_arg_y[_arg_maxpt*_vidx], _arg_symbol[_vecstride_symbol*_vidx]);
  }
  if (_arraylen(retval(0)) == 1)
    retval(0) = octave_value(double(*_arg_npt));
  else
    _cvt_to_double(_arg_npt, (double *)retval(0).matrix_value().data(), _arraylen(retval(0)));
  if (_arraylen(retval(1)) == 1)
    retval(1) = octave_value(double(*_arg_x));
  else
    _cvt_to_double(_arg_x, (double *)retval(1).matrix_value().data(), _arraylen(retval(1)));
  if (_arraylen(retval(2)) == 1)
    retval(2) = octave_value(double(*_arg_y));
  else
    _cvt_to_double(_arg_y, (double *)retval(2).matrix_value().data(), _arraylen(retval(2)));
  return retval;
}

octave_value_list _wrap_pgnumb(const octave_value_list &args, int nargout)
{
  octave_value_list retval(2, octave_value());
  if (args.length()-1 != 3 ||
      nargout != 2)
  {
    print_usage("pgnumb");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int *_arg_mm;
  int *_arg_pp;
  int *_arg_form;
  char *_arg_string;
  int *_arg_string_length;
  int _vecstride_mm = 1;
  int _vecstride_pp = 1;
  int _vecstride_form = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_mm))
    { error("dimension mismatch in argument mm"); return retval; }
  Matrix _mm = args(1).matrix_value();
  _arg_mm = (int *)alloca(_mm.dim1() * _mm.dim2() * sizeof (int));
  _cvt_double_to(_arg_mm, &_mm(0,0), _mm.dim1()*_mm.dim2());

  if (!_check_input_vectorize(args(2), &_vec_n, _d, 0, &_vecstride_pp))
    { error("dimension mismatch in argument pp"); return retval; }
  Matrix _pp = args(2).matrix_value();
  _arg_pp = (int *)alloca(_pp.dim1() * _pp.dim2() * sizeof (int));
  _cvt_double_to(_arg_pp, &_pp(0,0), _pp.dim1()*_pp.dim2());

  if (!_check_input_vectorize(args(3), &_vec_n, _d, 0, &_vecstride_form))
    { error("dimension mismatch in argument form"); return retval; }
  Matrix _form = args(3).matrix_value();
  _arg_form = (int *)alloca(_form.dim1() * _form.dim2() * sizeof (int));
  _cvt_double_to(_arg_form, &_form(0,0), _form.dim1()*_form.dim2());

  retval(0) = octave_value(charMatrix(_d[0] , _d[1] ), true);
  _arg_string = (char *)retval(0).char_matrix_value().data();
  if (_d[0]  != 1 || _d[1]  != 1)
    retval(1) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_string_length = (int *)alloca(_d[0]  * _d[1]  * sizeof (int));
  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgnumb(_arg_mm[_vecstride_mm*_vidx], _arg_pp[_vecstride_pp*_vidx], _arg_form[_vecstride_form*_vidx], &_arg_string[_vidx], &_arg_string_length[_vidx]);
  }
  if (_arraylen(retval(1)) == 1)
    retval(1) = octave_value(double(*_arg_string_length));
  else
    _cvt_to_double(_arg_string_length, (double *)retval(1).matrix_value().data(), _arraylen(retval(1)));
  return retval;
}

octave_value_list _wrap_pgolin(const octave_value_list &args, int nargout)
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 4 ||
      nargout != 3)
  {
    print_usage("pgolin");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int first_modify_flag = 1;
  int _arg_maxpt;
  int *_arg_npt;
  float *_arg_x;
  float *_arg_y;
  int *_arg_symbol;
  _arg_maxpt = (_dim(args(4), 0));
  int _vecstride_symbol = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_symbol))
    { error("dimension mismatch in argument symbol"); return retval; }
  Matrix _symbol = args(1).matrix_value();
  _arg_symbol = (int *)alloca(_symbol.dim1() * _symbol.dim2() * sizeof (int));
  _cvt_double_to(_arg_symbol, &_symbol(0,0), _symbol.dim1()*_symbol.dim2());

  if (!_check_modify_vectorize(args(2), &_vec_n, _d, 0, &first_modify_flag))
    { error("dimension mismatch in argument npt"); return retval; }
  Matrix _npt = args(2).matrix_value();
  _arg_npt = (int *)alloca(_npt.dim1() * _npt.dim2() * sizeof (int));
  _cvt_double_to(_arg_npt, &_npt(0,0), _npt.dim1()*_npt.dim2());
  retval(0) = octave_value(Matrix(_dim(_npt, 0), _dim(_npt, 1)));

  if (  (int)(_dim(args(3), 0)) != (int)(_arg_maxpt) ||
      !_check_modify_vectorize(args(3), &_vec_n, _d, 1, &first_modify_flag))
    { error("dimension mismatch in argument x"); return retval; }
  Matrix _x = args(3).matrix_value();
  _arg_x = (float *)alloca(_x.dim1() * _x.dim2() * sizeof (float));
  _cvt_double_to(_arg_x, &_x(0,0), _x.dim1()*_x.dim2());
  retval(1) = octave_value(Matrix(_dim(_x, 0), _dim(_x, 1)));

  if (!_check_modify_vectorize(args(4), &_vec_n, _d, 1, &first_modify_flag))
    { error("dimension mismatch in argument y"); return retval; }
  Matrix _y = args(4).matrix_value();
  _arg_y = (float *)alloca(_y.dim1() * _y.dim2() * sizeof (float));
  _cvt_double_to(_arg_y, &_y(0,0), _y.dim1()*_y.dim2());
  retval(2) = octave_value(Matrix(_dim(_y, 0), _dim(_y, 1)));

  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgolin(_arg_maxpt, &_arg_npt[_vidx], &_arg_x[_arg_maxpt*_vidx], &_arg_y[_arg_maxpt*_vidx], _arg_symbol[_vecstride_symbol*_vidx]);
  }
  if (_arraylen(retval(0)) == 1)
    retval(0) = octave_value(double(*_arg_npt));
  else
    _cvt_to_double(_arg_npt, (double *)retval(0).matrix_value().data(), _arraylen(retval(0)));
  if (_arraylen(retval(1)) == 1)
    retval(1) = octave_value(double(*_arg_x));
  else
    _cvt_to_double(_arg_x, (double *)retval(1).matrix_value().data(), _arraylen(retval(1)));
  if (_arraylen(retval(2)) == 1)
    retval(2) = octave_value(double(*_arg_y));
  else
    _cvt_to_double(_arg_y, (double *)retval(2).matrix_value().data(), _arraylen(retval(2)));
  return retval;
}

octave_value_list _wrap_pgopen(const octave_value_list &args, int )
{
  octave_value_list retval(1, octave_value());
  if (args.length()-1 != 1)
  {
    print_usage("pgopen");
    return retval;
  }

  char * _arg_device;
  int _arg_retval;
  if (0 > 0)
    { error("dimension mismatch in argument device"); return retval; }
  string _device = args(1).string_value();
  _device += '\0';
  _arg_device = (char *)_device.data();

    _arg_retval = (int)
      cpgopen(_arg_device);
  retval(0) = octave_value((double)_arg_retval);
  return retval;
}

octave_value_list _wrap_pgpage(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgpage");
    return retval;
  }

    cpgpage();
  return retval;
}

octave_value_list _wrap_pgpanl(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 2)
  {
    print_usage("pgpanl");
    return retval;
  }

  int _arg_nxc;
  int _arg_nyc;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument nxc"); return retval; }
  _arg_nxc = (int)args(1).double_value();

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument nyc"); return retval; }
  _arg_nyc = (int)args(2).double_value();

    cpgpanl(_arg_nxc, _arg_nyc);
  return retval;
}

octave_value_list _wrap_pgpap(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 2)
  {
    print_usage("pgpap");
    return retval;
  }

  float _arg_width;
  float _arg_aspect;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument width"); return retval; }
  _arg_width = (float)args(1).double_value();

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument aspect"); return retval; }
  _arg_aspect = (float)args(2).double_value();

    cpgpap(_arg_width, _arg_aspect);
  return retval;
}

octave_value_list _wrap_pgpixl(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 9)
  {
    print_usage("pgpixl");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int *_arg_ia;
  int _arg_idim;
  int _arg_jdim;
  int *_arg_i1;
  int *_arg_i2;
  int *_arg_j1;
  int *_arg_j2;
  float *_arg_x1;
  float *_arg_x2;
  float *_arg_y1;
  float *_arg_y2;
  _arg_idim = (_dim(args(1), 0));
  _arg_jdim = (_dim(args(1), 1));
  int _vecstride_ia = _arg_idim*_arg_jdim;
  int _vecstride_i1 = 1;
  int _vecstride_i2 = 1;
  int _vecstride_j1 = 1;
  int _vecstride_j2 = 1;
  int _vecstride_x1 = 1;
  int _vecstride_x2 = 1;
  int _vecstride_y1 = 1;
  int _vecstride_y2 = 1;
  if (_n_dims(args(1)) > 2)
    { error("dimension mismatch in argument ia"); return retval; }
  Matrix _ia = args(1).matrix_value();
  _arg_ia = (int *)alloca(_ia.dim1() * _ia.dim2() * sizeof (int));
  _cvt_double_to(_arg_ia, &_ia(0,0), _ia.dim1()*_ia.dim2());

  if (!_check_input_vectorize(args(2), &_vec_n, _d, 0, &_vecstride_i1))
    { error("dimension mismatch in argument i1"); return retval; }
  Matrix _i1 = args(2).matrix_value();
  _arg_i1 = (int *)alloca(_i1.dim1() * _i1.dim2() * sizeof (int));
  _cvt_double_to(_arg_i1, &_i1(0,0), _i1.dim1()*_i1.dim2());

  if (!_check_input_vectorize(args(3), &_vec_n, _d, 0, &_vecstride_i2))
    { error("dimension mismatch in argument i2"); return retval; }
  Matrix _i2 = args(3).matrix_value();
  _arg_i2 = (int *)alloca(_i2.dim1() * _i2.dim2() * sizeof (int));
  _cvt_double_to(_arg_i2, &_i2(0,0), _i2.dim1()*_i2.dim2());

  if (!_check_input_vectorize(args(4), &_vec_n, _d, 0, &_vecstride_j1))
    { error("dimension mismatch in argument j1"); return retval; }
  Matrix _j1 = args(4).matrix_value();
  _arg_j1 = (int *)alloca(_j1.dim1() * _j1.dim2() * sizeof (int));
  _cvt_double_to(_arg_j1, &_j1(0,0), _j1.dim1()*_j1.dim2());

  if (!_check_input_vectorize(args(5), &_vec_n, _d, 0, &_vecstride_j2))
    { error("dimension mismatch in argument j2"); return retval; }
  Matrix _j2 = args(5).matrix_value();
  _arg_j2 = (int *)alloca(_j2.dim1() * _j2.dim2() * sizeof (int));
  _cvt_double_to(_arg_j2, &_j2(0,0), _j2.dim1()*_j2.dim2());

  if (!_check_input_vectorize(args(6), &_vec_n, _d, 0, &_vecstride_x1))
    { error("dimension mismatch in argument x1"); return retval; }
  Matrix _x1 = args(6).matrix_value();
  _arg_x1 = (float *)alloca(_x1.dim1() * _x1.dim2() * sizeof (float));
  _cvt_double_to(_arg_x1, &_x1(0,0), _x1.dim1()*_x1.dim2());

  if (!_check_input_vectorize(args(7), &_vec_n, _d, 0, &_vecstride_x2))
    { error("dimension mismatch in argument x2"); return retval; }
  Matrix _x2 = args(7).matrix_value();
  _arg_x2 = (float *)alloca(_x2.dim1() * _x2.dim2() * sizeof (float));
  _cvt_double_to(_arg_x2, &_x2(0,0), _x2.dim1()*_x2.dim2());

  if (!_check_input_vectorize(args(8), &_vec_n, _d, 0, &_vecstride_y1))
    { error("dimension mismatch in argument y1"); return retval; }
  Matrix _y1 = args(8).matrix_value();
  _arg_y1 = (float *)alloca(_y1.dim1() * _y1.dim2() * sizeof (float));
  _cvt_double_to(_arg_y1, &_y1(0,0), _y1.dim1()*_y1.dim2());

  if (!_check_input_vectorize(args(9), &_vec_n, _d, 0, &_vecstride_y2))
    { error("dimension mismatch in argument y2"); return retval; }
  Matrix _y2 = args(9).matrix_value();
  _arg_y2 = (float *)alloca(_y2.dim1() * _y2.dim2() * sizeof (float));
  _cvt_double_to(_arg_y2, &_y2(0,0), _y2.dim1()*_y2.dim2());

  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgpixl(&_arg_ia[_vecstride_ia*_vidx], _arg_idim, _arg_jdim, _arg_i1[_vecstride_i1*_vidx], _arg_i2[_vecstride_i2*_vidx], _arg_j1[_vecstride_j1*_vidx], _arg_j2[_vecstride_j2*_vidx], _arg_x1[_vecstride_x1*_vidx], _arg_x2[_vecstride_x2*_vidx], _arg_y1[_vecstride_y1*_vidx], _arg_y2[_vecstride_y2*_vidx]);
  }
  return retval;
}

octave_value_list _wrap_pgpnts(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 3)
  {
    print_usage("pgpnts");
    return retval;
  }

  int _arg_n;
  float *_arg_x;
  float *_arg_y;
  int *_arg_symbol;
  int _arg_ns;
  _arg_ns = (_dim(args(3), 0));
  _arg_n = (_dim(args(2), 0));
  if (  (int)(_dim(args(1), 0)) != (int)(_arg_n) ||
      _n_dims(args(1)) > 1)
    { error("dimension mismatch in argument x"); return retval; }
  Matrix _x = args(1).matrix_value();
  _arg_x = (float *)alloca(_x.dim1() * _x.dim2() * sizeof (float));
  _cvt_double_to(_arg_x, &_x(0,0), _x.dim1()*_x.dim2());

  if (_n_dims(args(2)) > 1)
    { error("dimension mismatch in argument y"); return retval; }
  Matrix _y = args(2).matrix_value();
  _arg_y = (float *)alloca(_y.dim1() * _y.dim2() * sizeof (float));
  _cvt_double_to(_arg_y, &_y(0,0), _y.dim1()*_y.dim2());

  if (_n_dims(args(3)) > 1)
    { error("dimension mismatch in argument symbol"); return retval; }
  Matrix _symbol = args(3).matrix_value();
  _arg_symbol = (int *)alloca(_symbol.dim1() * _symbol.dim2() * sizeof (int));
  _cvt_double_to(_arg_symbol, &_symbol(0,0), _symbol.dim1()*_symbol.dim2());

    cpgpnts(_arg_n, _arg_x, _arg_y, _arg_symbol, _arg_ns);
  return retval;
}

octave_value_list _wrap_pgpoly(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 2)
  {
    print_usage("pgpoly");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int _arg_n;
  float *_arg_xpts;
  float *_arg_ypts;
  _arg_n = (_dim(args(2), 0));
  int _vecstride_xpts = _arg_n;
  int _vecstride_ypts = _arg_n;
  if (  (int)(_dim(args(1), 0)) != (int)(_arg_n) ||
      !_check_input_vectorize(args(1), &_vec_n, _d, 1, &_vecstride_xpts))
    { error("dimension mismatch in argument xpts"); return retval; }
  Matrix _xpts = args(1).matrix_value();
  _arg_xpts = (float *)alloca(_xpts.dim1() * _xpts.dim2() * sizeof (float));
  _cvt_double_to(_arg_xpts, &_xpts(0,0), _xpts.dim1()*_xpts.dim2());

  if (!_check_input_vectorize(args(2), &_vec_n, _d, 1, &_vecstride_ypts))
    { error("dimension mismatch in argument ypts"); return retval; }
  Matrix _ypts = args(2).matrix_value();
  _arg_ypts = (float *)alloca(_ypts.dim1() * _ypts.dim2() * sizeof (float));
  _cvt_double_to(_arg_ypts, &_ypts(0,0), _ypts.dim1()*_ypts.dim2());

  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgpoly(_arg_n, &_arg_xpts[_vecstride_xpts*_vidx], &_arg_ypts[_vecstride_ypts*_vidx]);
  }
  return retval;
}

octave_value_list _wrap_pgpt(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 3)
  {
    print_usage("pgpt");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int _arg_n;
  float *_arg_xpts;
  float *_arg_ypts;
  int *_arg_symbol;
  _arg_n = (_dim(args(2), 0));
  int _vecstride_xpts = _arg_n;
  int _vecstride_ypts = _arg_n;
  int _vecstride_symbol = 1;
  if (  (int)(_dim(args(1), 0)) != (int)(_arg_n) ||
      !_check_input_vectorize(args(1), &_vec_n, _d, 1, &_vecstride_xpts))
    { error("dimension mismatch in argument xpts"); return retval; }
  Matrix _xpts = args(1).matrix_value();
  _arg_xpts = (float *)alloca(_xpts.dim1() * _xpts.dim2() * sizeof (float));
  _cvt_double_to(_arg_xpts, &_xpts(0,0), _xpts.dim1()*_xpts.dim2());

  if (!_check_input_vectorize(args(2), &_vec_n, _d, 1, &_vecstride_ypts))
    { error("dimension mismatch in argument ypts"); return retval; }
  Matrix _ypts = args(2).matrix_value();
  _arg_ypts = (float *)alloca(_ypts.dim1() * _ypts.dim2() * sizeof (float));
  _cvt_double_to(_arg_ypts, &_ypts(0,0), _ypts.dim1()*_ypts.dim2());

  if (!_check_input_vectorize(args(3), &_vec_n, _d, 0, &_vecstride_symbol))
    { error("dimension mismatch in argument symbol"); return retval; }
  Matrix _symbol = args(3).matrix_value();
  _arg_symbol = (int *)alloca(_symbol.dim1() * _symbol.dim2() * sizeof (int));
  _cvt_double_to(_arg_symbol, &_symbol(0,0), _symbol.dim1()*_symbol.dim2());

  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgpt(_arg_n, &_arg_xpts[_vecstride_xpts*_vidx], &_arg_ypts[_vecstride_ypts*_vidx], _arg_symbol[_vecstride_symbol*_vidx]);
  }
  return retval;
}

octave_value_list _wrap_pgpt1(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 3)
  {
    print_usage("pgpt1");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  float *_arg_xpt;
  float *_arg_ypt;
  int *_arg_symbol;
  int _vecstride_xpt = 1;
  int _vecstride_ypt = 1;
  int _vecstride_symbol = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_xpt))
    { error("dimension mismatch in argument xpt"); return retval; }
  Matrix _xpt = args(1).matrix_value();
  _arg_xpt = (float *)alloca(_xpt.dim1() * _xpt.dim2() * sizeof (float));
  _cvt_double_to(_arg_xpt, &_xpt(0,0), _xpt.dim1()*_xpt.dim2());

  if (!_check_input_vectorize(args(2), &_vec_n, _d, 0, &_vecstride_ypt))
    { error("dimension mismatch in argument ypt"); return retval; }
  Matrix _ypt = args(2).matrix_value();
  _arg_ypt = (float *)alloca(_ypt.dim1() * _ypt.dim2() * sizeof (float));
  _cvt_double_to(_arg_ypt, &_ypt(0,0), _ypt.dim1()*_ypt.dim2());

  if (!_check_input_vectorize(args(3), &_vec_n, _d, 0, &_vecstride_symbol))
    { error("dimension mismatch in argument symbol"); return retval; }
  Matrix _symbol = args(3).matrix_value();
  _arg_symbol = (int *)alloca(_symbol.dim1() * _symbol.dim2() * sizeof (int));
  _cvt_double_to(_arg_symbol, &_symbol(0,0), _symbol.dim1()*_symbol.dim2());

  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgpt1(_arg_xpt[_vecstride_xpt*_vidx], _arg_ypt[_vecstride_ypt*_vidx], _arg_symbol[_vecstride_symbol*_vidx]);
  }
  return retval;
}

octave_value_list _wrap_pgptxt(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 5)
  {
    print_usage("pgptxt");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  float *_arg_x;
  float *_arg_y;
  float *_arg_angle;
  float *_arg_fjust;
  char * _arg_text;
  int _vecstride_x = 1;
  int _vecstride_y = 1;
  int _vecstride_angle = 1;
  int _vecstride_fjust = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_x))
    { error("dimension mismatch in argument x"); return retval; }
  Matrix _x = args(1).matrix_value();
  _arg_x = (float *)alloca(_x.dim1() * _x.dim2() * sizeof (float));
  _cvt_double_to(_arg_x, &_x(0,0), _x.dim1()*_x.dim2());

  if (!_check_input_vectorize(args(2), &_vec_n, _d, 0, &_vecstride_y))
    { error("dimension mismatch in argument y"); return retval; }
  Matrix _y = args(2).matrix_value();
  _arg_y = (float *)alloca(_y.dim1() * _y.dim2() * sizeof (float));
  _cvt_double_to(_arg_y, &_y(0,0), _y.dim1()*_y.dim2());

  if (!_check_input_vectorize(args(3), &_vec_n, _d, 0, &_vecstride_angle))
    { error("dimension mismatch in argument angle"); return retval; }
  Matrix _angle = args(3).matrix_value();
  _arg_angle = (float *)alloca(_angle.dim1() * _angle.dim2() * sizeof (float));
  _cvt_double_to(_arg_angle, &_angle(0,0), _angle.dim1()*_angle.dim2());

  if (!_check_input_vectorize(args(4), &_vec_n, _d, 0, &_vecstride_fjust))
    { error("dimension mismatch in argument fjust"); return retval; }
  Matrix _fjust = args(4).matrix_value();
  _arg_fjust = (float *)alloca(_fjust.dim1() * _fjust.dim2() * sizeof (float));
  _cvt_double_to(_arg_fjust, &_fjust(0,0), _fjust.dim1()*_fjust.dim2());

  if (0 > 0)
    { error("dimension mismatch in argument text"); return retval; }
  string _text = args(5).string_value();
  _text += '\0';
  _arg_text = (char *)_text.data();

  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgptxt(_arg_x[_vecstride_x*_vidx], _arg_y[_vecstride_y*_vidx], _arg_angle[_vecstride_angle*_vidx], _arg_fjust[_vecstride_fjust*_vidx], _arg_text);
  }
  return retval;
}

octave_value_list _wrap_pgqah(const octave_value_list &args, int nargout)
{
  octave_value_list retval(3, octave_value());
  if (args.length()-1 != 0 ||
      nargout != 3)
  {
    print_usage("pgqah");
    return retval;
  }

  int _arg_fs;
  float _arg_angle;
  float _arg_barb;
    cpgqah(&_arg_fs, &_arg_angle, &_arg_barb);
  retval(0) = octave_value((double)_arg_fs);
  retval(1) = octave_value((double)_arg_angle);
  retval(2) = octave_value((double)_arg_barb);
  return retval;
}

octave_value_list _wrap_pgqcf(const octave_value_list &args, int )
{
  octave_value_list retval(1, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgqcf");
    return retval;
  }

  int _arg_font;
    cpgqcf(&_arg_font);
  retval(0) = octave_value((double)_arg_font);
  return retval;
}

octave_value_list _wrap_pgqch(const octave_value_list &args, int )
{
  octave_value_list retval(1, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgqch");
    return retval;
  }

  float _arg_size;
    cpgqch(&_arg_size);
  retval(0) = octave_value((double)_arg_size);
  return retval;
}

octave_value_list _wrap_pgqci(const octave_value_list &args, int )
{
  octave_value_list retval(1, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgqci");
    return retval;
  }

  int _arg_ci;
    cpgqci(&_arg_ci);
  retval(0) = octave_value((double)_arg_ci);
  return retval;
}

octave_value_list _wrap_pgqcir(const octave_value_list &args, int nargout)
{
  octave_value_list retval(2, octave_value());
  if (args.length()-1 != 0 ||
      nargout != 2)
  {
    print_usage("pgqcir");
    return retval;
  }

  int _arg_icilo;
  int _arg_icihi;
    cpgqcir(&_arg_icilo, &_arg_icihi);
  retval(0) = octave_value((double)_arg_icilo);
  retval(1) = octave_value((double)_arg_icihi);
  return retval;
}

octave_value_list _wrap_pgqclp(const octave_value_list &args, int )
{
  octave_value_list retval(1, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgqclp");
    return retval;
  }

  int _arg_state;
    cpgqclp(&_arg_state);
  retval(0) = octave_value((double)_arg_state);
  return retval;
}

octave_value_list _wrap_pgqcol(const octave_value_list &args, int nargout)
{
  octave_value_list retval(2, octave_value());
  if (args.length()-1 != 0 ||
      nargout != 2)
  {
    print_usage("pgqcol");
    return retval;
  }

  int _arg_ci1;
  int _arg_ci2;
    cpgqcol(&_arg_ci1, &_arg_ci2);
  retval(0) = octave_value((double)_arg_ci1);
  retval(1) = octave_value((double)_arg_ci2);
  return retval;
}

octave_value_list _wrap_pgqcr(const octave_value_list &args, int nargout)
{
  octave_value_list retval(3, octave_value());
  if (args.length()-1 != 1 ||
      nargout != 3)
  {
    print_usage("pgqcr");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int *_arg_ci;
  float *_arg_cr;
  float *_arg_cg;
  float *_arg_cb;
  int _vecstride_ci = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_ci))
    { error("dimension mismatch in argument ci"); return retval; }
  Matrix _ci = args(1).matrix_value();
  _arg_ci = (int *)alloca(_ci.dim1() * _ci.dim2() * sizeof (int));
  _cvt_double_to(_arg_ci, &_ci(0,0), _ci.dim1()*_ci.dim2());

  if (_d[0]  != 1 || _d[1]  != 1)
    retval(0) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_cr = (float *)alloca(_d[0]  * _d[1]  * sizeof (float));
  if (_d[0]  != 1 || _d[1]  != 1)
    retval(1) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_cg = (float *)alloca(_d[0]  * _d[1]  * sizeof (float));
  if (_d[0]  != 1 || _d[1]  != 1)
    retval(2) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_cb = (float *)alloca(_d[0]  * _d[1]  * sizeof (float));
  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgqcr(_arg_ci[_vecstride_ci*_vidx], &_arg_cr[_vidx], &_arg_cg[_vidx], &_arg_cb[_vidx]);
  }
  if (_arraylen(retval(0)) == 1)
    retval(0) = octave_value(double(*_arg_cr));
  else
    _cvt_to_double(_arg_cr, (double *)retval(0).matrix_value().data(), _arraylen(retval(0)));
  if (_arraylen(retval(1)) == 1)
    retval(1) = octave_value(double(*_arg_cg));
  else
    _cvt_to_double(_arg_cg, (double *)retval(1).matrix_value().data(), _arraylen(retval(1)));
  if (_arraylen(retval(2)) == 1)
    retval(2) = octave_value(double(*_arg_cb));
  else
    _cvt_to_double(_arg_cb, (double *)retval(2).matrix_value().data(), _arraylen(retval(2)));
  return retval;
}

octave_value_list _wrap_pgqcs(const octave_value_list &args, int nargout)
{
  octave_value_list retval(2, octave_value());
  if (args.length()-1 != 1 ||
      nargout != 2)
  {
    print_usage("pgqcs");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int *_arg_units;
  float *_arg_xch;
  float *_arg_ych;
  int _vecstride_units = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_units))
    { error("dimension mismatch in argument units"); return retval; }
  Matrix _units = args(1).matrix_value();
  _arg_units = (int *)alloca(_units.dim1() * _units.dim2() * sizeof (int));
  _cvt_double_to(_arg_units, &_units(0,0), _units.dim1()*_units.dim2());

  if (_d[0]  != 1 || _d[1]  != 1)
    retval(0) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_xch = (float *)alloca(_d[0]  * _d[1]  * sizeof (float));
  if (_d[0]  != 1 || _d[1]  != 1)
    retval(1) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_ych = (float *)alloca(_d[0]  * _d[1]  * sizeof (float));
  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgqcs(_arg_units[_vecstride_units*_vidx], &_arg_xch[_vidx], &_arg_ych[_vidx]);
  }
  if (_arraylen(retval(0)) == 1)
    retval(0) = octave_value(double(*_arg_xch));
  else
    _cvt_to_double(_arg_xch, (double *)retval(0).matrix_value().data(), _arraylen(retval(0)));
  if (_arraylen(retval(1)) == 1)
    retval(1) = octave_value(double(*_arg_ych));
  else
    _cvt_to_double(_arg_ych, (double *)retval(1).matrix_value().data(), _arraylen(retval(1)));
  return retval;
}

octave_value_list _wrap_pgqdt(const octave_value_list &args, int nargout)
{
  octave_value_list retval(5, octave_value());
  if (args.length()-1 != 1 ||
      nargout != 5)
  {
    print_usage("pgqdt");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int *_arg_n;
  char *_arg_type;
  int *_arg_type_length;
  char *_arg_descr;
  int *_arg_descr_length;
  int *_arg_inter;
  int _vecstride_n = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_n))
    { error("dimension mismatch in argument n"); return retval; }
  Matrix _n = args(1).matrix_value();
  _arg_n = (int *)alloca(_n.dim1() * _n.dim2() * sizeof (int));
  _cvt_double_to(_arg_n, &_n(0,0), _n.dim1()*_n.dim2());

  retval(0) = octave_value(charMatrix(8, _d[0] ), true);
  _arg_type = (char *)retval(0).char_matrix_value().data();
  if (_d[0]  != 1 || _d[1]  != 1)
    retval(1) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_type_length = (int *)alloca(_d[0]  * _d[1]  * sizeof (int));
  retval(2) = octave_value(charMatrix(64, _d[0] ), true);
  _arg_descr = (char *)retval(2).char_matrix_value().data();
  if (_d[0]  != 1 || _d[1]  != 1)
    retval(3) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_descr_length = (int *)alloca(_d[0]  * _d[1]  * sizeof (int));
  if (_d[0]  != 1 || _d[1]  != 1)
    retval(4) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_inter = (int *)alloca(_d[0]  * _d[1]  * sizeof (int));
  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgqdt(_arg_n[_vecstride_n*_vidx], &_arg_type[8*_vidx], &_arg_type_length[_vidx], &_arg_descr[64*_vidx], &_arg_descr_length[_vidx], &_arg_inter[_vidx]);
  }
  if (_arraylen(retval(1)) == 1)
    retval(1) = octave_value(double(*_arg_type_length));
  else
    _cvt_to_double(_arg_type_length, (double *)retval(1).matrix_value().data(), _arraylen(retval(1)));
  if (_arraylen(retval(3)) == 1)
    retval(3) = octave_value(double(*_arg_descr_length));
  else
    _cvt_to_double(_arg_descr_length, (double *)retval(3).matrix_value().data(), _arraylen(retval(3)));
  if (_arraylen(retval(4)) == 1)
    retval(4) = octave_value(double(*_arg_inter));
  else
    _cvt_to_double(_arg_inter, (double *)retval(4).matrix_value().data(), _arraylen(retval(4)));
  return retval;
}

octave_value_list _wrap_pgqfs(const octave_value_list &args, int )
{
  octave_value_list retval(1, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgqfs");
    return retval;
  }

  int _arg_fs;
    cpgqfs(&_arg_fs);
  retval(0) = octave_value((double)_arg_fs);
  return retval;
}

octave_value_list _wrap_pgqhs(const octave_value_list &args, int nargout)
{
  octave_value_list retval(3, octave_value());
  if (args.length()-1 != 0 ||
      nargout != 3)
  {
    print_usage("pgqhs");
    return retval;
  }

  float _arg_angle;
  float _arg_sepn;
  float _arg_phase;
    cpgqhs(&_arg_angle, &_arg_sepn, &_arg_phase);
  retval(0) = octave_value((double)_arg_angle);
  retval(1) = octave_value((double)_arg_sepn);
  retval(2) = octave_value((double)_arg_phase);
  return retval;
}

octave_value_list _wrap_pgqid(const octave_value_list &args, int )
{
  octave_value_list retval(1, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgqid");
    return retval;
  }

  int _arg_id;
    cpgqid(&_arg_id);
  retval(0) = octave_value((double)_arg_id);
  return retval;
}

octave_value_list _wrap_pgqinf(const octave_value_list &args, int )
{
  octave_value_list retval(1, octave_value());
  if (args.length()-1 != 2)
  {
    print_usage("pgqinf");
    return retval;
  }

  char * _arg_item;
  char *_arg_value;
  int _arg_value_length;
  _arg_value_length = (int)args(2).double_value();
  if (0 > 0)
    { error("dimension mismatch in argument item"); return retval; }
  string _item = args(1).string_value();
  _item += '\0';
  _arg_item = (char *)_item.data();

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument value_length"); return retval; }

  retval(0) = octave_value(charMatrix(_arg_value_length, 1), true);
  _arg_value = (char *)retval(0).char_matrix_value().data();
    cpgqinf(_arg_item, _arg_value, &_arg_value_length);
  return retval;
}

octave_value_list _wrap_pgqitf(const octave_value_list &args, int )
{
  octave_value_list retval(1, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgqitf");
    return retval;
  }

  int _arg_itf;
    cpgqitf(&_arg_itf);
  retval(0) = octave_value((double)_arg_itf);
  return retval;
}

octave_value_list _wrap_pgqls(const octave_value_list &args, int )
{
  octave_value_list retval(1, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgqls");
    return retval;
  }

  int _arg_ls;
    cpgqls(&_arg_ls);
  retval(0) = octave_value((double)_arg_ls);
  return retval;
}

octave_value_list _wrap_pgqlw(const octave_value_list &args, int )
{
  octave_value_list retval(1, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgqlw");
    return retval;
  }

  int _arg_lw;
    cpgqlw(&_arg_lw);
  retval(0) = octave_value((double)_arg_lw);
  return retval;
}

octave_value_list _wrap_pgqndt(const octave_value_list &args, int )
{
  octave_value_list retval(1, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgqndt");
    return retval;
  }

  int _arg_n;
    cpgqndt(&_arg_n);
  retval(0) = octave_value((double)_arg_n);
  return retval;
}

octave_value_list _wrap_pgqpos(const octave_value_list &args, int nargout)
{
  octave_value_list retval(2, octave_value());
  if (args.length()-1 != 0 ||
      nargout != 2)
  {
    print_usage("pgqpos");
    return retval;
  }

  float _arg_x;
  float _arg_y;
    cpgqpos(&_arg_x, &_arg_y);
  retval(0) = octave_value((double)_arg_x);
  retval(1) = octave_value((double)_arg_y);
  return retval;
}

octave_value_list _wrap_pgqtbg(const octave_value_list &args, int )
{
  octave_value_list retval(1, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgqtbg");
    return retval;
  }

  int _arg_tbci;
    cpgqtbg(&_arg_tbci);
  retval(0) = octave_value((double)_arg_tbci);
  return retval;
}

octave_value_list _wrap_pgqtxt(const octave_value_list &args, int nargout)
{
  octave_value_list retval(2, octave_value());
  if (args.length()-1 != 5 ||
      nargout != 2)
  {
    print_usage("pgqtxt");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  float *_arg_x;
  float *_arg_y;
  float *_arg_angle;
  float *_arg_fjust;
  char * _arg_text;
  float *_arg_xbox;
  float *_arg_ybox;
  int _vecstride_x = 1;
  int _vecstride_y = 1;
  int _vecstride_angle = 1;
  int _vecstride_fjust = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_x))
    { error("dimension mismatch in argument x"); return retval; }
  Matrix _x = args(1).matrix_value();
  _arg_x = (float *)alloca(_x.dim1() * _x.dim2() * sizeof (float));
  _cvt_double_to(_arg_x, &_x(0,0), _x.dim1()*_x.dim2());

  if (!_check_input_vectorize(args(2), &_vec_n, _d, 0, &_vecstride_y))
    { error("dimension mismatch in argument y"); return retval; }
  Matrix _y = args(2).matrix_value();
  _arg_y = (float *)alloca(_y.dim1() * _y.dim2() * sizeof (float));
  _cvt_double_to(_arg_y, &_y(0,0), _y.dim1()*_y.dim2());

  if (!_check_input_vectorize(args(3), &_vec_n, _d, 0, &_vecstride_angle))
    { error("dimension mismatch in argument angle"); return retval; }
  Matrix _angle = args(3).matrix_value();
  _arg_angle = (float *)alloca(_angle.dim1() * _angle.dim2() * sizeof (float));
  _cvt_double_to(_arg_angle, &_angle(0,0), _angle.dim1()*_angle.dim2());

  if (!_check_input_vectorize(args(4), &_vec_n, _d, 0, &_vecstride_fjust))
    { error("dimension mismatch in argument fjust"); return retval; }
  Matrix _fjust = args(4).matrix_value();
  _arg_fjust = (float *)alloca(_fjust.dim1() * _fjust.dim2() * sizeof (float));
  _cvt_double_to(_arg_fjust, &_fjust(0,0), _fjust.dim1()*_fjust.dim2());

  if (0 > 0)
    { error("dimension mismatch in argument text"); return retval; }
  string _text = args(5).string_value();
  _text += '\0';
  _arg_text = (char *)_text.data();

  if (4 != 1 || _d[0]  != 1)
    retval(0) = octave_value(Matrix(4, _d[0] ));
  _arg_xbox = (float *)alloca(4 * _d[0]  * sizeof (float));
  if (4 != 1 || _d[0]  != 1)
    retval(1) = octave_value(Matrix(4, _d[0] ));
  _arg_ybox = (float *)alloca(4 * _d[0]  * sizeof (float));
  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgqtxt(_arg_x[_vecstride_x*_vidx], _arg_y[_vecstride_y*_vidx], _arg_angle[_vecstride_angle*_vidx], _arg_fjust[_vecstride_fjust*_vidx], _arg_text, &_arg_xbox[4*_vidx], &_arg_ybox[4*_vidx]);
  }
  if (_arraylen(retval(0)) == 1)
    retval(0) = octave_value(double(*_arg_xbox));
  else
    _cvt_to_double(_arg_xbox, (double *)retval(0).matrix_value().data(), _arraylen(retval(0)));
  if (_arraylen(retval(1)) == 1)
    retval(1) = octave_value(double(*_arg_ybox));
  else
    _cvt_to_double(_arg_ybox, (double *)retval(1).matrix_value().data(), _arraylen(retval(1)));
  return retval;
}

octave_value_list _wrap_pgqvp(const octave_value_list &args, int nargout)
{
  octave_value_list retval(4, octave_value());
  if (args.length()-1 != 1 ||
      nargout != 4)
  {
    print_usage("pgqvp");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int *_arg_units;
  float *_arg_x1;
  float *_arg_x2;
  float *_arg_y1;
  float *_arg_y2;
  int _vecstride_units = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_units))
    { error("dimension mismatch in argument units"); return retval; }
  Matrix _units = args(1).matrix_value();
  _arg_units = (int *)alloca(_units.dim1() * _units.dim2() * sizeof (int));
  _cvt_double_to(_arg_units, &_units(0,0), _units.dim1()*_units.dim2());

  if (_d[0]  != 1 || _d[1]  != 1)
    retval(0) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_x1 = (float *)alloca(_d[0]  * _d[1]  * sizeof (float));
  if (_d[0]  != 1 || _d[1]  != 1)
    retval(1) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_x2 = (float *)alloca(_d[0]  * _d[1]  * sizeof (float));
  if (_d[0]  != 1 || _d[1]  != 1)
    retval(2) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_y1 = (float *)alloca(_d[0]  * _d[1]  * sizeof (float));
  if (_d[0]  != 1 || _d[1]  != 1)
    retval(3) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_y2 = (float *)alloca(_d[0]  * _d[1]  * sizeof (float));
  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgqvp(_arg_units[_vecstride_units*_vidx], &_arg_x1[_vidx], &_arg_x2[_vidx], &_arg_y1[_vidx], &_arg_y2[_vidx]);
  }
  if (_arraylen(retval(0)) == 1)
    retval(0) = octave_value(double(*_arg_x1));
  else
    _cvt_to_double(_arg_x1, (double *)retval(0).matrix_value().data(), _arraylen(retval(0)));
  if (_arraylen(retval(1)) == 1)
    retval(1) = octave_value(double(*_arg_x2));
  else
    _cvt_to_double(_arg_x2, (double *)retval(1).matrix_value().data(), _arraylen(retval(1)));
  if (_arraylen(retval(2)) == 1)
    retval(2) = octave_value(double(*_arg_y1));
  else
    _cvt_to_double(_arg_y1, (double *)retval(2).matrix_value().data(), _arraylen(retval(2)));
  if (_arraylen(retval(3)) == 1)
    retval(3) = octave_value(double(*_arg_y2));
  else
    _cvt_to_double(_arg_y2, (double *)retval(3).matrix_value().data(), _arraylen(retval(3)));
  return retval;
}

octave_value_list _wrap_pgqvsz(const octave_value_list &args, int nargout)
{
  octave_value_list retval(4, octave_value());
  if (args.length()-1 != 1 ||
      nargout != 4)
  {
    print_usage("pgqvsz");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int *_arg_units;
  float *_arg_x1;
  float *_arg_x2;
  float *_arg_y1;
  float *_arg_y2;
  int _vecstride_units = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_units))
    { error("dimension mismatch in argument units"); return retval; }
  Matrix _units = args(1).matrix_value();
  _arg_units = (int *)alloca(_units.dim1() * _units.dim2() * sizeof (int));
  _cvt_double_to(_arg_units, &_units(0,0), _units.dim1()*_units.dim2());

  if (_d[0]  != 1 || _d[1]  != 1)
    retval(0) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_x1 = (float *)alloca(_d[0]  * _d[1]  * sizeof (float));
  if (_d[0]  != 1 || _d[1]  != 1)
    retval(1) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_x2 = (float *)alloca(_d[0]  * _d[1]  * sizeof (float));
  if (_d[0]  != 1 || _d[1]  != 1)
    retval(2) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_y1 = (float *)alloca(_d[0]  * _d[1]  * sizeof (float));
  if (_d[0]  != 1 || _d[1]  != 1)
    retval(3) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_y2 = (float *)alloca(_d[0]  * _d[1]  * sizeof (float));
  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgqvsz(_arg_units[_vecstride_units*_vidx], &_arg_x1[_vidx], &_arg_x2[_vidx], &_arg_y1[_vidx], &_arg_y2[_vidx]);
  }
  if (_arraylen(retval(0)) == 1)
    retval(0) = octave_value(double(*_arg_x1));
  else
    _cvt_to_double(_arg_x1, (double *)retval(0).matrix_value().data(), _arraylen(retval(0)));
  if (_arraylen(retval(1)) == 1)
    retval(1) = octave_value(double(*_arg_x2));
  else
    _cvt_to_double(_arg_x2, (double *)retval(1).matrix_value().data(), _arraylen(retval(1)));
  if (_arraylen(retval(2)) == 1)
    retval(2) = octave_value(double(*_arg_y1));
  else
    _cvt_to_double(_arg_y1, (double *)retval(2).matrix_value().data(), _arraylen(retval(2)));
  if (_arraylen(retval(3)) == 1)
    retval(3) = octave_value(double(*_arg_y2));
  else
    _cvt_to_double(_arg_y2, (double *)retval(3).matrix_value().data(), _arraylen(retval(3)));
  return retval;
}

octave_value_list _wrap_pgqwin(const octave_value_list &args, int nargout)
{
  octave_value_list retval(4, octave_value());
  if (args.length()-1 != 0 ||
      nargout != 4)
  {
    print_usage("pgqwin");
    return retval;
  }

  float _arg_x1;
  float _arg_x2;
  float _arg_y1;
  float _arg_y2;
    cpgqwin(&_arg_x1, &_arg_x2, &_arg_y1, &_arg_y2);
  retval(0) = octave_value((double)_arg_x1);
  retval(1) = octave_value((double)_arg_x2);
  retval(2) = octave_value((double)_arg_y1);
  retval(3) = octave_value((double)_arg_y2);
  return retval;
}

octave_value_list _wrap_pgrect(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 4)
  {
    print_usage("pgrect");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  float *_arg_x1;
  float *_arg_x2;
  float *_arg_y1;
  float *_arg_y2;
  int _vecstride_x1 = 1;
  int _vecstride_x2 = 1;
  int _vecstride_y1 = 1;
  int _vecstride_y2 = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_x1))
    { error("dimension mismatch in argument x1"); return retval; }
  Matrix _x1 = args(1).matrix_value();
  _arg_x1 = (float *)alloca(_x1.dim1() * _x1.dim2() * sizeof (float));
  _cvt_double_to(_arg_x1, &_x1(0,0), _x1.dim1()*_x1.dim2());

  if (!_check_input_vectorize(args(2), &_vec_n, _d, 0, &_vecstride_x2))
    { error("dimension mismatch in argument x2"); return retval; }
  Matrix _x2 = args(2).matrix_value();
  _arg_x2 = (float *)alloca(_x2.dim1() * _x2.dim2() * sizeof (float));
  _cvt_double_to(_arg_x2, &_x2(0,0), _x2.dim1()*_x2.dim2());

  if (!_check_input_vectorize(args(3), &_vec_n, _d, 0, &_vecstride_y1))
    { error("dimension mismatch in argument y1"); return retval; }
  Matrix _y1 = args(3).matrix_value();
  _arg_y1 = (float *)alloca(_y1.dim1() * _y1.dim2() * sizeof (float));
  _cvt_double_to(_arg_y1, &_y1(0,0), _y1.dim1()*_y1.dim2());

  if (!_check_input_vectorize(args(4), &_vec_n, _d, 0, &_vecstride_y2))
    { error("dimension mismatch in argument y2"); return retval; }
  Matrix _y2 = args(4).matrix_value();
  _arg_y2 = (float *)alloca(_y2.dim1() * _y2.dim2() * sizeof (float));
  _cvt_double_to(_arg_y2, &_y2(0,0), _y2.dim1()*_y2.dim2());

  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgrect(_arg_x1[_vecstride_x1*_vidx], _arg_x2[_vecstride_x2*_vidx], _arg_y1[_vecstride_y1*_vidx], _arg_y2[_vecstride_y2*_vidx]);
  }
  return retval;
}

octave_value_list _wrap_pgrnd(const octave_value_list &args, int nargout)
{
  octave_value_list retval(2, octave_value());
  if (args.length()-1 != 1 ||
      nargout != 2)
  {
    print_usage("pgrnd");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  float *_arg_x;
  int *_arg_nsub;
  float *_arg_retval;
  int _vecstride_x = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_x))
    { error("dimension mismatch in argument x"); return retval; }
  Matrix _x = args(1).matrix_value();
  _arg_x = (float *)alloca(_x.dim1() * _x.dim2() * sizeof (float));
  _cvt_double_to(_arg_x, &_x(0,0), _x.dim1()*_x.dim2());

  if (_d[0]  != 1 || _d[1]  != 1)
    retval(0) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_retval = (float *)alloca(_d[0]  * _d[1]  * sizeof (float));
  if (_d[0]  != 1 || _d[1]  != 1)
    retval(1) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_nsub = (int *)alloca(_d[0]  * _d[1]  * sizeof (int));
  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    _arg_retval[_vidx] = (float)
      cpgrnd(_arg_x[_vecstride_x*_vidx], &_arg_nsub[_vidx]);
  }
  if (_arraylen(retval(0)) == 1)
    retval(0) = octave_value(double(*_arg_retval));
  else
    _cvt_to_double(_arg_retval, (double *)retval(0).matrix_value().data(), _arraylen(retval(0)));
  if (_arraylen(retval(1)) == 1)
    retval(1) = octave_value(double(*_arg_nsub));
  else
    _cvt_to_double(_arg_nsub, (double *)retval(1).matrix_value().data(), _arraylen(retval(1)));
  return retval;
}

octave_value_list _wrap_pgrnge(const octave_value_list &args, int nargout)
{
  octave_value_list retval(2, octave_value());
  if (args.length()-1 != 2 ||
      nargout != 2)
  {
    print_usage("pgrnge");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  float *_arg_x1;
  float *_arg_x2;
  float *_arg_xlo;
  float *_arg_xhi;
  int _vecstride_x1 = 1;
  int _vecstride_x2 = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_x1))
    { error("dimension mismatch in argument x1"); return retval; }
  Matrix _x1 = args(1).matrix_value();
  _arg_x1 = (float *)alloca(_x1.dim1() * _x1.dim2() * sizeof (float));
  _cvt_double_to(_arg_x1, &_x1(0,0), _x1.dim1()*_x1.dim2());

  if (!_check_input_vectorize(args(2), &_vec_n, _d, 0, &_vecstride_x2))
    { error("dimension mismatch in argument x2"); return retval; }
  Matrix _x2 = args(2).matrix_value();
  _arg_x2 = (float *)alloca(_x2.dim1() * _x2.dim2() * sizeof (float));
  _cvt_double_to(_arg_x2, &_x2(0,0), _x2.dim1()*_x2.dim2());

  if (_d[0]  != 1 || _d[1]  != 1)
    retval(0) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_xlo = (float *)alloca(_d[0]  * _d[1]  * sizeof (float));
  if (_d[0]  != 1 || _d[1]  != 1)
    retval(1) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_xhi = (float *)alloca(_d[0]  * _d[1]  * sizeof (float));
  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgrnge(_arg_x1[_vecstride_x1*_vidx], _arg_x2[_vecstride_x2*_vidx], &_arg_xlo[_vidx], &_arg_xhi[_vidx]);
  }
  if (_arraylen(retval(0)) == 1)
    retval(0) = octave_value(double(*_arg_xlo));
  else
    _cvt_to_double(_arg_xlo, (double *)retval(0).matrix_value().data(), _arraylen(retval(0)));
  if (_arraylen(retval(1)) == 1)
    retval(1) = octave_value(double(*_arg_xhi));
  else
    _cvt_to_double(_arg_xhi, (double *)retval(1).matrix_value().data(), _arraylen(retval(1)));
  return retval;
}

octave_value_list _wrap_pgsah(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 3)
  {
    print_usage("pgsah");
    return retval;
  }

  int _arg_fs;
  float _arg_angle;
  float _arg_barb;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument fs"); return retval; }
  _arg_fs = (int)args(1).double_value();

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument angle"); return retval; }
  _arg_angle = (float)args(2).double_value();

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument barb"); return retval; }
  _arg_barb = (float)args(3).double_value();

    cpgsah(_arg_fs, _arg_angle, _arg_barb);
  return retval;
}

octave_value_list _wrap_pgsave(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 0)
  {
    print_usage("pgsave");
    return retval;
  }

    cpgsave();
  return retval;
}

octave_value_list _wrap_pgscf(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 1)
  {
    print_usage("pgscf");
    return retval;
  }

  int _arg_font;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument font"); return retval; }
  _arg_font = (int)args(1).double_value();

    cpgscf(_arg_font);
  return retval;
}

octave_value_list _wrap_pgsch(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 1)
  {
    print_usage("pgsch");
    return retval;
  }

  float _arg_size;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument size"); return retval; }
  _arg_size = (float)args(1).double_value();

    cpgsch(_arg_size);
  return retval;
}

octave_value_list _wrap_pgsci(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 1)
  {
    print_usage("pgsci");
    return retval;
  }

  int _arg_ci;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument ci"); return retval; }
  _arg_ci = (int)args(1).double_value();

    cpgsci(_arg_ci);
  return retval;
}

octave_value_list _wrap_pgscir(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 2)
  {
    print_usage("pgscir");
    return retval;
  }

  int _arg_icilo;
  int _arg_icihi;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument icilo"); return retval; }
  _arg_icilo = (int)args(1).double_value();

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument icihi"); return retval; }
  _arg_icihi = (int)args(2).double_value();

    cpgscir(_arg_icilo, _arg_icihi);
  return retval;
}

octave_value_list _wrap_pgsclp(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 1)
  {
    print_usage("pgsclp");
    return retval;
  }

  int _arg_state;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument state"); return retval; }
  _arg_state = (int)args(1).double_value();

    cpgsclp(_arg_state);
  return retval;
}

octave_value_list _wrap_pgscr(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 4)
  {
    print_usage("pgscr");
    return retval;
  }

  int _arg_ci;
  float _arg_cr;
  float _arg_cg;
  float _arg_cb;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument ci"); return retval; }
  _arg_ci = (int)args(1).double_value();

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument cr"); return retval; }
  _arg_cr = (float)args(2).double_value();

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument cg"); return retval; }
  _arg_cg = (float)args(3).double_value();

  if (_n_dims(args(4)) > 0)
    { error("dimension mismatch in argument cb"); return retval; }
  _arg_cb = (float)args(4).double_value();

    cpgscr(_arg_ci, _arg_cr, _arg_cg, _arg_cb);
  return retval;
}

octave_value_list _wrap_pgscrl(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 2)
  {
    print_usage("pgscrl");
    return retval;
  }

  float _arg_dx;
  float _arg_dy;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument dx"); return retval; }
  _arg_dx = (float)args(1).double_value();

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument dy"); return retval; }
  _arg_dy = (float)args(2).double_value();

    cpgscrl(_arg_dx, _arg_dy);
  return retval;
}

octave_value_list _wrap_pgscrn(const octave_value_list &args, int )
{
  octave_value_list retval(1, octave_value());
  if (args.length()-1 != 2)
  {
    print_usage("pgscrn");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  int *_arg_ci;
  char * _arg_name;
  int *_arg_ier;
  int _vecstride_ci = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_ci))
    { error("dimension mismatch in argument ci"); return retval; }
  Matrix _ci = args(1).matrix_value();
  _arg_ci = (int *)alloca(_ci.dim1() * _ci.dim2() * sizeof (int));
  _cvt_double_to(_arg_ci, &_ci(0,0), _ci.dim1()*_ci.dim2());

  if (0 > 0)
    { error("dimension mismatch in argument name"); return retval; }
  string _name = args(2).string_value();
  _name += '\0';
  _arg_name = (char *)_name.data();

  if (_d[0]  != 1 || _d[1]  != 1)
    retval(0) = octave_value(Matrix(_d[0] , _d[1] ));
  _arg_ier = (int *)alloca(_d[0]  * _d[1]  * sizeof (int));
  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgscrn(_arg_ci[_vecstride_ci*_vidx], _arg_name, &_arg_ier[_vidx]);
  }
  if (_arraylen(retval(0)) == 1)
    retval(0) = octave_value(double(*_arg_ier));
  else
    _cvt_to_double(_arg_ier, (double *)retval(0).matrix_value().data(), _arraylen(retval(0)));
  return retval;
}

octave_value_list _wrap_pgsfs(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 1)
  {
    print_usage("pgsfs");
    return retval;
  }

  int _arg_fs;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument fs"); return retval; }
  _arg_fs = (int)args(1).double_value();

    cpgsfs(_arg_fs);
  return retval;
}

octave_value_list _wrap_pgshls(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 4)
  {
    print_usage("pgshls");
    return retval;
  }

  int _arg_ci;
  float _arg_ch;
  float _arg_cl;
  float _arg_cs;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument ci"); return retval; }
  _arg_ci = (int)args(1).double_value();

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument ch"); return retval; }
  _arg_ch = (float)args(2).double_value();

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument cl"); return retval; }
  _arg_cl = (float)args(3).double_value();

  if (_n_dims(args(4)) > 0)
    { error("dimension mismatch in argument cs"); return retval; }
  _arg_cs = (float)args(4).double_value();

    cpgshls(_arg_ci, _arg_ch, _arg_cl, _arg_cs);
  return retval;
}

octave_value_list _wrap_pgshs(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 3)
  {
    print_usage("pgshs");
    return retval;
  }

  float _arg_angle;
  float _arg_sepn;
  float _arg_phase;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument angle"); return retval; }
  _arg_angle = (float)args(1).double_value();

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument sepn"); return retval; }
  _arg_sepn = (float)args(2).double_value();

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument phase"); return retval; }
  _arg_phase = (float)args(3).double_value();

    cpgshs(_arg_angle, _arg_sepn, _arg_phase);
  return retval;
}

octave_value_list _wrap_pgsitf(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 1)
  {
    print_usage("pgsitf");
    return retval;
  }

  int _arg_itf;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument itf"); return retval; }
  _arg_itf = (int)args(1).double_value();

    cpgsitf(_arg_itf);
  return retval;
}

octave_value_list _wrap_pgslct(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 1)
  {
    print_usage("pgslct");
    return retval;
  }

  int _arg_id;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument id"); return retval; }
  _arg_id = (int)args(1).double_value();

    cpgslct(_arg_id);
  return retval;
}

octave_value_list _wrap_pgsls(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 1)
  {
    print_usage("pgsls");
    return retval;
  }

  int _arg_ls;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument ls"); return retval; }
  _arg_ls = (int)args(1).double_value();

    cpgsls(_arg_ls);
  return retval;
}

octave_value_list _wrap_pgslw(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 1)
  {
    print_usage("pgslw");
    return retval;
  }

  int _arg_lw;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument lw"); return retval; }
  _arg_lw = (int)args(1).double_value();

    cpgslw(_arg_lw);
  return retval;
}

octave_value_list _wrap_pgstbg(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 1)
  {
    print_usage("pgstbg");
    return retval;
  }

  int _arg_tbci;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument tbci"); return retval; }
  _arg_tbci = (int)args(1).double_value();

    cpgstbg(_arg_tbci);
  return retval;
}

octave_value_list _wrap_pgsubp(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 2)
  {
    print_usage("pgsubp");
    return retval;
  }

  int _arg_nxsub;
  int _arg_nysub;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument nxsub"); return retval; }
  _arg_nxsub = (int)args(1).double_value();

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument nysub"); return retval; }
  _arg_nysub = (int)args(2).double_value();

    cpgsubp(_arg_nxsub, _arg_nysub);
  return retval;
}

octave_value_list _wrap_pgsvp(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 4)
  {
    print_usage("pgsvp");
    return retval;
  }

  float _arg_xleft;
  float _arg_xright;
  float _arg_ybot;
  float _arg_ytop;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument xleft"); return retval; }
  _arg_xleft = (float)args(1).double_value();

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument xright"); return retval; }
  _arg_xright = (float)args(2).double_value();

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument ybot"); return retval; }
  _arg_ybot = (float)args(3).double_value();

  if (_n_dims(args(4)) > 0)
    { error("dimension mismatch in argument ytop"); return retval; }
  _arg_ytop = (float)args(4).double_value();

    cpgsvp(_arg_xleft, _arg_xright, _arg_ybot, _arg_ytop);
  return retval;
}

octave_value_list _wrap_pgswin(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 4)
  {
    print_usage("pgswin");
    return retval;
  }

  float _arg_x1;
  float _arg_x2;
  float _arg_y1;
  float _arg_y2;
  if (_n_dims(args(1)) > 0)
    { error("dimension mismatch in argument x1"); return retval; }
  _arg_x1 = (float)args(1).double_value();

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument x2"); return retval; }
  _arg_x2 = (float)args(2).double_value();

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument y1"); return retval; }
  _arg_y1 = (float)args(3).double_value();

  if (_n_dims(args(4)) > 0)
    { error("dimension mismatch in argument y2"); return retval; }
  _arg_y2 = (float)args(4).double_value();

    cpgswin(_arg_x1, _arg_x2, _arg_y1, _arg_y2);
  return retval;
}

octave_value_list _wrap_pgtbox(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 6)
  {
    print_usage("pgtbox");
    return retval;
  }

  char * _arg_xopt;
  float _arg_xtick;
  int _arg_nxsub;
  char * _arg_yopt;
  float _arg_ytick;
  int _arg_nysub;
  if (0 > 0)
    { error("dimension mismatch in argument xopt"); return retval; }
  string _xopt = args(1).string_value();
  _xopt += '\0';
  _arg_xopt = (char *)_xopt.data();

  if (_n_dims(args(2)) > 0)
    { error("dimension mismatch in argument xtick"); return retval; }
  _arg_xtick = (float)args(2).double_value();

  if (_n_dims(args(3)) > 0)
    { error("dimension mismatch in argument nxsub"); return retval; }
  _arg_nxsub = (int)args(3).double_value();

  if (0 > 0)
    { error("dimension mismatch in argument yopt"); return retval; }
  string _yopt = args(4).string_value();
  _yopt += '\0';
  _arg_yopt = (char *)_yopt.data();

  if (_n_dims(args(5)) > 0)
    { error("dimension mismatch in argument ytick"); return retval; }
  _arg_ytick = (float)args(5).double_value();

  if (_n_dims(args(6)) > 0)
    { error("dimension mismatch in argument nysub"); return retval; }
  _arg_nysub = (int)args(6).double_value();

    cpgtbox(_arg_xopt, _arg_xtick, _arg_nxsub, _arg_yopt, _arg_ytick, _arg_nysub);
  return retval;
}

octave_value_list _wrap_pgtext(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 3)
  {
    print_usage("pgtext");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  float *_arg_x;
  float *_arg_y;
  char * _arg_text;
  int _vecstride_x = 1;
  int _vecstride_y = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_x))
    { error("dimension mismatch in argument x"); return retval; }
  Matrix _x = args(1).matrix_value();
  _arg_x = (float *)alloca(_x.dim1() * _x.dim2() * sizeof (float));
  _cvt_double_to(_arg_x, &_x(0,0), _x.dim1()*_x.dim2());

  if (!_check_input_vectorize(args(2), &_vec_n, _d, 0, &_vecstride_y))
    { error("dimension mismatch in argument y"); return retval; }
  Matrix _y = args(2).matrix_value();
  _arg_y = (float *)alloca(_y.dim1() * _y.dim2() * sizeof (float));
  _cvt_double_to(_arg_y, &_y(0,0), _y.dim1()*_y.dim2());

  if (0 > 0)
    { error("dimension mismatch in argument text"); return retval; }
  string _text = args(3).string_value();
  _text += '\0';
  _arg_text = (char *)_text.data();

  _vec_sz = _d[0]*_d[1];
  for (_vidx = 0; _vidx < _vec_sz; ++_vidx) {
    cpgtext(_arg_x[_vecstride_x*_vidx], _arg_y[_vecstride_y*_vidx], _arg_text);
  }
  return retval;
}

octave_value_list _wrap_pgtick(const octave_value_list &args, int )
{
  octave_value_list retval(0, octave_value());
  if (args.length()-1 != 10)
  {
    print_usage("pgtick");
    return retval;
  }

  int _d[2] = { 1,1 };
  int _vec_n = 0;
  int _vidx;
  int _vec_sz;
  float *_arg_x1;
  float *_arg_y1;
  float *_arg_x2;
  float *_arg_y2;
  float *_arg_v;
  float *_arg_tikl;
  float *_arg_tikr;
  float *_arg_disp;
  float *_arg_orient;
  char * _arg_str;
  int _vecstride_x1 = 1;
  int _vecstride_y1 = 1;
  int _vecstride_x2 = 1;
  int _vecstride_y2 = 1;
  int _vecstride_v = 1;
  int _vecstride_tikl = 1;
  int _vecstride_tikr = 1;
  int _vecstride_disp = 1;
  int _vecstride_orient = 1;
  if (!_check_input_vectorize(args(1), &_vec_n, _d, 0, &_vecstride_x1))
    { error("dimension mismatch in argument x1"); return retval; }
  Matrix _x1 = args(1).matrix_value();
  _arg_x1 = (float *)alloca(_x1.dim1() * _x1.dim2() * sizeof (float));
  _cvt_double_to(_arg_x1, &_x1(0,0), _x1.dim1()*_x1.dim2());

  if (!_check_input_vectorize(args(2), &_vec_n, _d, 0, &_vecstride_y1))
    { error("dimension mismatch in argument y1"); return retval; }
  Matrix _y1 = args(2).matrix_value();
  _arg_y1 = (float *)alloca(_y1.dim1() * _y1.dim2() * sizeof (float));
  _cvt_double_to(_arg_y1, &_y1(0,0), _y1.dim1()*_y1.dim2());

  if (!_check_input_vectorize(args(3), &_vec_n, _d, 0, &_vecstride_x2))
    { error("dimension mismatch in argument x2"); return retval; }
  Matrix _x2 = args(3).matrix_value();
  _arg_x2 = (float *)alloca(_x2.dim1() * _x2.dim2() * sizeof (float));
  _cvt_double_to(_arg_x2, &_x2(0,0), _x2.dim1()*_x2.dim2());

  if (!_check_input_vectorize(args(4), &_vec_n, _d, 0, &_vecstride_y2))
    { error("dimension mismatch in argument y2"); return retval; }
  Matrix _y2 = args(4).matrix_value();
  _arg_y2 = (float *)alloca(_y2.dim1() * _y2.dim2() * sizeof (float));
  _cvt_double_to(_arg_y2, &_y2(0,0), _y2.dim1()*_y2.dim2());

  if (!_check_input_vectorize(args(5), &_vec_n, _d, 0, &_vecstride_v))
    { error("dimension mismatch in argument v"); return retval; }
  Matrix _v = args(5).matrix_value();
  _arg_v = (float *)alloca(_v.dim1() * _v.dim2() * sizeof (float));
  _cvt_double_to(_arg_v, &_v(0,0), _v.dim1()*_v.dim2());

  if (!_check_input_vectorize(args(6), &_vec_n, _d, 0, &_vecstride_tikl))
    { error("dimension mismatch in argument tikl"); return retval; }
  Matrix _tikl = args(6).matrix_value();
  _arg_tikl = (float *)alloca(_tikl.dim1() * _tikl.dim2() * sizeof (float));
  _cvt_double_to(_arg_tikl, &_tikl(0,0), _tikl.dim1()*_tikl.dim2());

  if (!_check_input_vectorize(args(7), &_vec_n, _d, 0, &_vecstride_tikr))
    { error("dimension mismatch in argument tikr"); return retval; }
  Matrix _tikr = args(7).matrix_value();
  _arg_tikr = (float *)alloca(_tikr.dim1() * _tikr.dim2() * sizeof (float));
  _cvt_double_to(_arg_tikr, &_tikr(0,0), _tikr.dim1()*_tikr.dim2());

  if (!_check_input_vectorize(args(8), &_vec_n, _d, 0, &_vecstride_disp))
    { error("dimension mismatch in argument disp"); return retval; }
  Matrix _disp = args(8).matrix_value();
  _arg_disp = (float *)alloca(_dis