text: # include <c_iraf.h>
  
  void c_arbpix(float *datain, float *dataout, int *npts, int *interp_type, int *boundary_type);
  /* real	datain[ARB]		# input data array */
  /* real	dataout[ARB]		# output data array - cannot be same as datain */
  /* int	npts			# no. of data points */
  /* int	interp_type		# interpolator type */
  /* int	boundary_type		# boundary type, at present must be BOUNDARY_EXT */
  
  float c_ii_badpix(float *datain, int *npix, int *index, int *interp_type);
  /* real	datain[ARB]	# datain array, y[1] and y[n] guaranteed to be good */
  /* int	npix		# length of y array */
  /* int	index		# index of bad point to replace */
  /* int	interp_type	# interpolator type */
  
  float c_ii_newpix(float *x, float *xarray, float *data, int *npts, int *index, int *interp_type);
  /* real	x		# point to interpolate */
  /* real	xarray[ARB]	# x values */
  /* real	data[ARB]	# data values */
  /* int 	npts		# size of data array */
  /* int	index		# index such that xarray[index] < x < xarray[index+1] */
  /* int 	interp_type	# interpolator type */
  
  void c_ii_badsinc(float *datain, float *dataout, int *npts, int *nsinc, int *ntaper, float *staper, float *min_bdx);
  /* real	datain[ARB]	# input data including bad pixels with INDEF values */
  /* real	dataout[ARB]	# output data  */
  /* int	npts		# number of data values */
  /* int	nsinc		# sinc truncation length */
  /* int	ntaper		# start of triangular taper */
  /* real	staper		# slope of triangular taper */
  /* real	min_bdx		# minimum  distance from interpolation point */
  
  void c_arider(float *x, float *datain, int *npix, float *derivs, int *nder, int *interp_type);
  /* real	x		# need 1 <= x <= n */
  /* real	datain[ARB]	# data values */
  /* int	npix		# number of data values */
  /* real	derivs[ARB]	# derivatives out -- derivs[1] is function value */
  /* int	nder		# total number of values returned in derivs */
  /* int	interp_type	# type of interpolator */
  
  float c_arieval(float *x, float *datain, int *npts, int *interp_type);
  /* real	x		# x value, 1 <= x <= n */
  /* real	datain[ARB]	# array of data values */
  /* int	npts		# number of data values */
  /* int	interp_type	# interpolant type */
  
  void c_asider(IRAFPointer *asi, float *x, float *der, int *nder);
  /* pointer	asi		# interpolant descriptor */
  /* real	x		# x value */
  /* real	der[ARB]	# derivatives, der[1] is value der[2] is f prime  */
  /* int	nder		# number items returned = 1 + number of derivatives */
  
  float c_asieval(IRAFPointer *asi, float *x);
  /* pointer	asi		# interpolator descriptor */
  /* real x			# x value */
  
  void c_asifit(IRAFPointer *asi, float *datain, int *npix);
  /* pointer	asi		# interpolant descriptor */
  /* real	datain[ARB]	# data array */
  /* int	npix		# nunber of data points */
  
  void c_asifree(IRAFPointer *asi);
  /* pointer	asi	# interpolant descriptor */
  
  int c_asigeti(IRAFPointer *asi, int *param);
  /* pointer	asi		# interpolant descriptor */
  /* int	param		# parameter to be fetched */
  
  float c_asigrl(IRAFPointer *asi, float *a, float *b);
  /* pointer	asi		# interpolant descriptor */
  /* real	a		# lower limit for integral */
  /* real	b		# upper limit for integral */
  
  void c_asiinit(IRAFPointer *asi, int *interp_type);
  /* pointer	asi		# interpolant descriptor */
  /* int	interp_type	# interpolant type */
  
  void c_asirestore(IRAFPointer *asi, float *interpolant);
  /* pointer	asi			# interpolant descriptor */
  /* real	interpolant[ARB]	# array containing the interpolant */
  
  void c_asisave(IRAFPointer *asi, float *interpolant);
  /* pointer	asi			# interpolant descriptor */
  /* real	interpolant[ARB]	# array containing the interpolant */
  
  void c_asivector(IRAFPointer *asi, float *x, float *y, int *npix);
  /* pointer	asi		# interpolator descriptor */
  /* real	x[ARB]		# ordered x array */
  /* real	y[ARB]		# interpolated values */
  /* int	npix		# no. of points in x */
  
  float c_ii_1dinteg(float *coeff, float *a, float *b, int *interp_type);
  /* real	coeff[ARB]	# 1D array of coefficients */
  /* real	a		# lower limit for integral */
  /* real	b		# upper limit for integral */
  /* int	interp_type	# type of 1D interpolant */
  
  void c_ii_getpcoeff(float *coeff, int *index, float *pcoeff, int *interp_type);
  /* real	coeff[ARB]	# coefficient array */
  /* int	index		# coefficients wanted for index < x < index + 1 */
  /* real	pcoeff[ARB]	# polynomial coefficients */
  /* int	interp_type	# type of interpolant */
  
  void c_ii_sincigrl(float *a, float *b, float *sum, float *data, int *npix, int *nsinc, int *ntaper, float *staper, float *mindx);
  /* real	a, b			# integral limits */
  /* real	sum			# output integral value */
  /* real	data[npix]		# input data array */
  /* int	npix			# number of pixels */
  /* int	nsinc			# sinc truncation length */
  /* int	ntaper			# start of triangular taper */
  /* real	staper			# slope of triangular taper */
  /* real	mindx			# interpolation minimum */
  
  void c_ii_binearest(float *coeff, int *first_point, int *len_coeff, float *x, float *y, float *zfit, int *npts);
  /* real	coeff[ARB]	# 1D coefficient array */
  /* int	first_point	# offset of first data point */
  /* int	len_coeff	# row length of coeff */
  /* real	x[npts]		# array of x values */
  /* real	y[npts]		# array of y values */
  /* real	zfit[npts]	# array of interpolated values */
  /* int	npts		# number of points to be evaluated */
  
  void c_ii_bilinear(float *coeff, int *first_point, int *len_coeff, float *x, float *y, float *zfit, int *npts);
  /* real	coeff[ARB]	# 1D array of coefficients */
  /* int	first_point	# offset of first data point */
  /* int	len_coeff	# row length of coeff */
  /* real	x[npts]		# array of x values */
  /* real	y[npts]		# array of y values */
  /* real	zfit[npts]	# array of interpolated values */
  /* int	npts		# number of data points */
  
  void c_ii_bipoly3(float *coeff, int *first_point, int *len_coeff, float *x, float *y, float *zfit, int *npts);
  /* real	coeff[ARB]	# 1D array of coefficients */
  /* int	first_point	# offset first point */
  /* int	len_coeff	# row length of the coefficient array */
  /* real	x[npts]		# array of x values */
  /* real	y[npts]		# array of y values */
  /* real	zfit[npts]	# array of fitted values */
  /* int	npts		# number of points to be evaluated */
  
  void c_ii_bipoly5(float *coeff, int *first_point, int *len_coeff, float *x, float *y, float *zfit, int *npts);
  /* real	coeff[ARB]	# 1D array of coefficients */
  /* int	first_point	# offset to first data point */
  /* int	len_coeff	# row length of coeff */
  /* real	x[npts]		# array of x values */
  /* real	y[npts]		# array of y values */
  /* real	zfit[npts]	# array of fitted values */
  /* int	npts		# number of points */
  
  void c_ii_bispline3(float *coeff, int *first_point, int *len_coeff, float *x, float *y, float *zfit, int *npts);
  /* real	coeff[ARB]	# 1D array of coefficients */
  /* int	first_point	# offset to first data point */
  /* int	len_coeff	# row length of coeff */
  /* real	x[npts]		# array of x values */
  /* real	y[npts]		# array of y values */
  /* real	zfit[npts]	# array of interpolated values */
  /* int	npts		# number of points to be evaluated */
  
  void c_ii_nearest(float *x, float *y, int *npts, float *data);
  /* real	x[ARB]		# x values, must be within [1,npts] */
  /* real	y[ARB]		# interpolated values returned to user */
  /* int	npts		# number of x values */
  /* real	data[ARB]	# data to be interpolated */
  
  void c_ii_linear(float *x, float *y, int *npts, float *data);
  /* real	x[ARB]		# x values, must be within [1,npts] */
  /* real	y[ARB]		# interpolated values returned to user */
  /* int	npts		# number of x values */
  /* real	data[ARB]	# data to be interpolated */
  
  void c_ii_poly3(float *x, float *y, int *npts, float *data);
  /* real	x[ARB]		# x values, must be within [1,npts] */
  /* real	y[ARB]		# interpolated values returned to user */
  /* int	npts		# number of x values */
  /* real	data[ARB]	# data to be interpolated from a[0] to a[npts+2] */
  
  void c_ii_poly5(float *x, float *y, int *npts, float *data);
  /* real	x[ARB]		# x values, must be within [1,npts] */
  /* real	y[ARB]		# interpolated values returned to user */
  /* int	npts		# number of x values */
  /* real	data[ARB]	# data to be interpolated - from a[-1] to a[npts+3] */
  
  void c_ii_spline3(float *x, float *y, int *npts, float *bcoeff);
  /* real	x[ARB]		# x values, must be within [1,npts] */
  /* real	y[ARB]		# interpolated values returned to user */
  /* int	npts		# number of x values */
  /* real	bcoeff[ARB]	# basis spline coefficients - from a[0] to a[npts+1] */
  
  void c_ii_sinc(float *x, float *y, int *npts, float *data, int *npix, int *nsinc, int *ntaper, float *staper, float *mindx);
  /* real	x[ARB]		# x values, must be within [1,npts] */
  /* real	y[ARB]		# interpolated values returned to user */
  /* int	npts		# number of x values */
  /* real	data[ARB]	# data to be interpolated */
  /* int	npix		# number of data pixels */
  /* int	nsinc		# sinc truncation length */
  /* int	ntaper		# start of triangular taper */
  /* real	staper		# slope of triangular taper */
  /* real	mindx		# interpolation minimum */
  
  void c_ii_grnearest(float *coeff, int *first_point, int *len_coeff, float *x, float *y, float *zfit, int *nxpts, int *nypts, int *len_zfit);
  /* real	coeff[ARB]		# 1D coefficient array */
  /* int	first_point		# offset of first data point */
  /* int	len_coeff		# row length of coeff  */
  /* real	x[nxpts]		# array of x values */
  /* real	y[nypts]		# array of y values */
  /* real	zfit[len_zfit,ARB]	# array of interpolatedvalues */
  /* int	nxpts			# number of x values */
  /* int	nypts			# number of y values */
  /* int	len_zfit		# row length of zfit */
  
  void c_ii_grlinear(float *coeff, int *first_point, int *len_coeff, float *x, float *y, float *zfit, int *nxpts, int *nypts, int *len_zfit);
  /* real	coeff[ARB]		# 1D array of coefficients */
  /* int	first_point		# offset of first data point */
  /* int	len_coeff		# row length of coeff */
  /* real	x[nxpts]		# array of x values */
  /* real	y[nypts]		# array of y values */
  /* real	zfit[len_zfit,ARB]	# array of interpolated values */
  /* int	nxpts			# number of x values */
  /* int	nypts			# number of y values */
  /* int	len_zfit		# row length of zfit */
  
  void c_ii_grpoly3(float *coeff, int *first_point, int *len_coeff, float *x, float *y, float *zfit, int *nxpts, int *nypts, int *len_zfit);
  /* real	coeff[ARB]		# 1D array of coefficients */
  /* int	first_point		# offset of first data point */
  /* int	len_coeff		# length of row of coeffcient */
  /* real	x[nxpts]		# array of x values */
  /* real	y[nypts]		# array of y values */
  /* real	zfit[len_zfit,ARB]	# array of interpolatedvalues */
  /* int	nxpts			# number of x points */
  /* int	nypts			# number of y points */
  /* int	len_zfit		# row length of zfit */
  
  void c_ii_grpoly5(float *coeff, int *first_point, int *len_coeff, float *x, float *y, float *zfit, int *nxpts, int *nypts, int *len_zfit);
  /* real	coeff[ARB]		# 1D array of coefficients */
  /* int	first_point		# offset of first data point */
  /* int	len_coeff		# row length of coeff */
  /* real	x[nxpts]		# array of x values */
  /* real	y[nypts]		# array of y values */
  /* real	zfit[len_zfit,ARB]	# array of fitted values */
  /* int	nxpts			# number of x points */
  /* int	nypts			# number of y points */
  /* int	len_zfit		# row length of zfit */
  
  void c_ii_grspline3(float *coeff, int *first_point, int *len_coeff, float *x, float *y, float *zfit, int *nxpts, int *nypts, int *len_zfit);
  /* real	coeff[ARB]		# 1D array of coefficients */
  /* int	first_point		# offset of first data point */
  /* int	len_coeff		# row length of coeff */
  /* real	x[nxpts]		# array of x values */
  /* real	y[nypts]		# array of y values */
  /* real	zfit[len_zfit,ARB]	# array of interpolated values */
  /* int	nxpts			# number of x values */
  /* int	nypts			# number of y values */
  /* int	len_zfit		# row length of zfit */
  
  void c_ia_pcpoly3(float *x, float *datain, int *npts, float *pcoeff);
  /* real	x		# x value */
  /* real	datain[ARB]	# array of input data */
  /* int	npts		# number of data points */
  /* real	pcoeff[ARB]	# array of polynomial coefficients */
  
  void c_ia_pcpoly5(float *x, float *datain, int *npts, float *pcoeff);
  /* real	x		# x value */
  /* real	datain[ARB]	# array of input data */
  /* int	npts		# number of data points */
  /* real	pcoeff[ARB]	# array of polynomial coefficients */
  
  void c_ia_pcspline3(float *x, float *datain, int *npts, float *pcoeff);
  /* real	x		# x value */
  /* real	datain[ARB]	# data array */
  /* int	npts		# number of data points */
  /* real	pcoeff[ARB]	# array of polynomial coefficients */
  
  void c_ii_sincder(float *x, float *der, int *nder, float *data, int *npix, int *nsinc, int *ntaper, float *staper, float *mindx);
  /* real	x		# x value */
  /* real	der[ARB]	# derivatives to return */
  /* int	nder		# number of derivatives */
  /* real	data[npix]	# data to be interpolated */
  /* int	npix		# number of pixels */
  /* int	nsinc		# sinc truncation length */
  /* int	ntaper		# start of triangular taper */
  /* real	staper		# slope of triangular taper */
  /* real	mindx		# interpolation minimum */
  
  void c_ii_pcpoly3(float *coeff, int *index, int *len_coeff, float *pcoeff, int *len_pcoeff);
  /* real	coeff[ARB]		# 1D array of interpolant coeffcients */
  /* int	index			# pointer into coeff array */
  /* int	len_coeff		# row length of coeffcients */
  /* real	pcoeff[len_pcoeff,ARB]	# polynomial coefficients */
  /* int	len_pcoeff		# row length of pcoeff */
  
  void c_ii_pcpoly5(float *coeff, int *index, int *len_coeff, float *pcoeff, int *len_pcoeff);
  /* real	coeff[ARB]		# 1D array of interpolant coeffcients */
  /* int	index			# pointer into coeff array */
  /* int	len_coeff		# row length of coeffcients */
  /* real	pcoeff[len_pcoeff,ARB]	# polynomial coefficients */
  /* int	len_pcoeff		# row length of pcoeff array */
  
  void c_ii_pcspline3(float *coeff, int *index, int *len_coeff, float *pcoeff, int *len_pcoeff);
  /* real	coeff[ARB]		# 1D array of interpolant coeffcients */
  /* int	index			# pointer into coeff array */
  /* int	len_coeff		# row length of coeffcients */
  /* real	pcoeff[len_pcoeff,ARB]	# polynomial coefficients */
  /* int	len_pcoeff		# row length of pcoeff */
  
  float c_ii_polterp(float *x, float *y, int *n, float *x0);
  /* real	x[ARB],y[ARB]	# x and y array */
  /* real	x0		# desired x */
  /* int	n		# number of points in x and y = number of */
  
  void c_ii_spline(float *bcoeff, float *diag, int *npts);
  /* real	bcoeff[ARB]	# data in and also bspline coefficients out */
  /* real	diag[ARB]	# needed for offdiagnol matrix elements */
  /* int	npts		# number of data points */
  
  void c_ii_spline2d(float *data, float *coeff, int *nxpix, int *nvectors, int *len_data, int *len_coeff);
  /* real	data[len_data,ARB]	# input data array */
  /* real	coeff[len_coeff,ARB]	# output array of univariate coefficients in x */
  /* int	nxpix			# number of x data points */
  /* int	nvectors		# number of univariate splines to calculate */
  /* int	len_data		# row dimension of data */
  /* int	len_coeff		# row dimension of coeff */
  
  void c_mrider(float *x, float *y, float *datain, int *nxpix, int *nypix, int *len_datain, float *der, int *nxder, int *nyder, int *len_der, int *interp_type);
  /* real	x				# x value */
  /* real	y				# y value */
  /* real	datain[len_datain,ARB]		# data array */
  /* int	nxpix				# number of x data points */
  /* int	nypix				# number of y data points */
  /* int	len_datain			# row length of datain */
  /* real	der[len_der, ARB]		# array of derivatives */
  /* int	nxder				# number of derivatives in x */
  /* int	nyder				# number of derivatives in y */
  /* int	len_der				# row length of der, len_der >= nxder */
  /* int	interp_type			# interpolant type */
  
  float c_mrieval(float *x, float *y, float *datain, int *nxpix, int *nypix, int *len_datain, int *interp_type);
  /* real	x				# x value */
  /* real	y				# y value */
  /* real	datain[len_datain,ARB]		# data array */
  /* int	nxpix				# number of x data points */
  /* int	nypix				# number of y data points */
  /* int	len_datain			# row length of datain */
  /* int	interp_type			# interpolant type */
  
  void c_msider(IRAFPointer *msi, float *x, float *y, float *der, int *nxder, int *nyder, int *len_der);
  /* pointer	msi			# pointer to interpolant descriptor structure */
  /* real	x			# x value */
  /* real	y			# y value */
  /* real	der[len_der,ARB]	# derivative array */
  /* int	nxder			# number of x derivatives */
  /* int	nyder			# number of y derivatives */
  /* int	len_der			# row length of der, len_der >= nxder */
  
  float c_msieval(IRAFPointer *msi, float *x, float *y);
  /* pointer	msi		# pointer to the interpolant descriptor */
  /* real	x		# x data value */
  /* real	y		# y data value */
  
  void c_msifit(IRAFPointer *msi, float *datain, int *nxpix, int *nypix, int *len_datain);
  /* pointer	msi			# pointer to interpolant descriptor structure */
  /* real	datain[len_datain,ARB]	# data array */
  /* int	nxpix			# number of points in the x dimension */
  /* int	nypix			# number of points in the y dimension */
  /* int	len_datain			# row length of datain */
  
  void c_msifree(IRAFPointer *msi);
  /* pointer	msi		# pointer to the interpolant descriptor structure */
  
  int c_msigeti(IRAFPointer *msi, int *param);
  /* pointer	msi		# interpolant descriptor */
  /* int	param		# parameter to be fetched */
  
  void c_msigrid(IRAFPointer *msi, float *x, float *y, float *zfit, int *nx, int *ny, int *len_zfit);
  /* pointer	msi 			# pointer to interpolant descriptor structure */
  /* real	x[nx]			# array of x values */
  /* real	y[ny]			# array of y values */
  /* real	zfit[len_zfit,ARB]	# array of fitted values */
  /* int	nx			# number of x points */
  /* int	ny			# number of y points */
  /* int	len_zfit		# row length of zfit */
  
  float c_msigrl(IRAFPointer *msi, float *x, float *y, int *npts);
  /* pointer	msi		# pointer to the interpolant descriptor structure */
  /* real	x[npts]		# array of x values */
  /* real	y[npts]		# array of y values */
  /* int	npts		# number of points which describe the boundary */
  
  void c_ii_find_limits(float *x, float *y, int *npts, float *x1lim, float *x2lim, float *ymin, float *ymax, int *nylmin, int *nylmax);
  /* real	x[npts]		# array of x values */
  /* real	y[npts]		# array of y values */
  /* int	npts		# number of data points */
  /* real	x1lim[ARB]	# array of x1 limits */
  /* real	x2lim[ARB]	# array of x2 limits */
  /* real	ymin		# minimum y value for integration */
  /* real	ymax		# maximum y value for integration */
  /* int	nylmin		# minimum line number for x integration */
  /* int	nylmax		# maximum line number for x integration */
  
  int c_ii_pyclip(float *xver, float *yver, float *xintr, float *yintr, int *nver, float *lx, float *ld);
  /* real	xver[ARB]		# x vertex coords */
  /* real	yver[ARB]		# y vertex coords */
  /* real	xintr[ARB]		# x intersection coords */
  /* real	yintr[ARB]		# y intersection coords */
  /* int	nver			# number of vertices */
  /* real	lx, ld 			# equation of image line */
  
  void c_ii_alimrix(float *x, int *npts, float *xmin, int *nxmin, float *xmax, int *nxmax);
  /* real	x[npts]		# data */
  /* int	npts		# number of data points */
  /* real	xmin		# data minimum */
  /* int	nxmin		# index of data minimum */
  /* real	xmax		# data maximum */
  /* int	nxmax		# index of data maximum */
  
  void c_msiinit(IRAFPointer *msi, int *interp_type);
  /* pointer	msi		# pointer to the interpolant descriptor structure */
  /* int	interp_type	# interpolant type */
  
  void c_msirestore(IRAFPointer *msi, float *interpolant);
  /* pointer	msi			# interpolant descriptor */
  /* real	interpolant[ARB]	# array containing the interpolant */
  
  void c_msisave(IRAFPointer *msi, float *interpolant);
  /* pointer	msi			# interpolant descriptor */
  /* real	interpolant[ARB]	# array containing the interpolant */
  
  float c_msisqgrl(IRAFPointer *msi, float *x1, float *x2, float *y1, float *y2);
  /* pointer	msi		# pointer to the interpolant descriptor structure */
  /* real	x1, x2		# x integration limits */
  /* real	y1, y2		# y integration limits */
  
  void c_msivector(IRAFPointer *msi, float *x, float *y, float *zfit, int *npts);
  /* pointer	msi		# pointer to the interpolant descriptor structure */
  /* real	x[npts]		# array of x values */
  /* real	y[npts]		# array of y values */
  /* real	zfit[npts]	# array of interpolated values */
  /* int	npts		# number of points to be evaluated */
  
  