🚀 go-pugleaf

BUG REPORT 12

BEHAVIOR:

compiler failed to match required function when built-in conversion
(int to double) needed. when explicit conversion operator ``double()''
is used to force the conversion, no error is generated.

COMPILER VERSION: GNU C++ compiler driver, version 1.25.0

INPUT FILES:

pis.cc
doubleVec.h
nr.h
error.h
overload.h
type.h

COMMAND LINE: g++ -v -g -c pis.cc 

GNU C++ version 1.25.0 (vax) compiled by GNU C version 1.25.
g++ version 1.25.0
 /usr/local/lib/gcc-cpp+ -v -I . -I ./include -I /dsp/mcclellan/baud/c++/include -I /usr/local/lib/g++-include -undef -D__GNU__ -D__GNUG__ -Dvax -Dunix pis.cc /tmp/cc007442.cpp
GNU CPP version 1.25.0
 /usr/local/lib/gcc-c++ /tmp/cc007442.cpp -quiet -dumpbase pis.cc -noreg -version -G -o /tmp/cc007442.s
In function mcov (struct doubleMat &):
pis.cc:39: bad argument 1 for function `operator / (struct doubleVec &, double &)' (type was struct doubleMat )
pis.cc:39: type conversion required for type `doubleMat'

FILE NAMES:

tm.h = tm-vax.h
md = vax.md

MACHINE: vax 11/780 with BRL UNIX (4.2 BSD)

SOURCE FILES:
----------------------------------------------------------------------------
//
// pis.cc : pisarenko's method using vectors and matrices
//

#include <doubleVec.h>
#include <nr.h>

//
// mean: matrix mean
//

double mean(doubleMat& M) {
  double m = 0.;
  for ( int i=0; i < csize(M); i++ )
    m += sum(M(i));
  return m / (rsize(M) * csize(M));
}

//
// mpad: pad out doubleVec to yield transposed convolution matrix
//

doubleMat mpad(int p, doubleVec& v) {
  doubleMat Z(p,size(v)+p-1,0.);
  for ( int i=0; i < p; i++ )
    Z(i)(i,i+size(v)-1) = v;
  return doubleMat_t(Z);
}

//
// mcov: construct covariance matrix from transposed convolution matrix
//

doubleMat mcov(doubleMat& M) {
  int s = csize(M);
  doubleMat N = M - doubleMat(s,s,mean(M));
  return doubleMat_t((N ^ N) / s);
}

//
// eig: compute eigen-value and -vectors of a doubleMat
//
//	note:	rows of E are e-values corresponding to e-vector
//		elements of e.
//

void eig(doubleMat& M, doubleMat& Ev, doubleVec& ev) {
  int i, j;					// counters
  int s = rsize(M);				// matrix sizes

  // check input vector sizes
  if ( !square(M) || !square(Ev) || s != rsize(Ev) || s != size(ev) )
    error("eig: illegal vector/matrix size");

  float **a = matrix(1,s,1,s); 			// data of input matrix
  float *d = vector(1,s),			// diagonal elements
    *e = vector(1,s);				// off-diagonal elements

  for ( i=0; i < s; i++ )			// copy input data
    for ( j=0; j < s; j++ )
      a[1+i][1+j] = M(i,j);

  tred2(a,s,d,e);				// tri-diagonalize matrix
  tqli(d,e,s,a);				// find e's by ql algorithm

  for ( i=0; i < s; i++ )			// copy output data
    for ( j=0; j < s; j++ )
      Ev(i,j) = a[1+j][1+i];
  for ( i=0; i < s; i++ )
    ev(i) = e[1+i];

  free_vector(d,1,s);				// deallocate storage
  free_vector(e,1,s);
  free_matrix(a,1,s,1,s);
}

//
// pisarenko: 
//
//	use pisarenko's method to perform p-th order harmonic
//	decomposition of input complex data doubleVec.
//
//	note: line splitting can occur if wrong order polynomial
//	      is requested.
//
//	a = solution polynomial: A(z) = SUM a_i * z^(-1)
//	    (order of input vector `a' determines solution order)
//	x = input data vector
//

void pisarenko(doubleVec& a, doubleVec& x) {
  int	p = size(a) - 1,		// polynomial order
	n = size(x);			// number of input points

  a = 0.;				// initialize a

  if ( n < 2 * p ) 
    error("pisarenko: more data required for given model order");

  doubleMat A = mpad(p+1,x),		// convolution doubleMat
	 B = mcov(A),			// covariance doubleMat
	 E(p+1,p+1);			// e-doubleVecs

  doubleVec e(p+1);			// e-values
  eig(B,E,e);
  a = E(min(e));			// e-doubleVec of min e-value
}

// main function to test pisarenko
main(int argc, char **argv) {
  int p,				// polynomial order
    n;					// number of data points

  if ( argc != 3 
    || sscanf(*++argv,"%d",&p) != 1 || p < 1 
    || sscanf(*++argv,"%d",&n) != 1 || n < 1 )
    error("usage: pis model-order number-of-input-points");

  doubleVec a(p+1);			// polynomial
  doubleVec x(n);			// input data

  cin >> x;
  pisarenko(a,x);
  cout << "solution polynomial: " << a << "\n";
}
----------------------------------------------------------------------------
//
// doubleVec.h : vector and matrix class definitions
//

//	the `vector' and `matrix' classes provide the c++ programmer
//	with a complete set of matrix/vector operations:
//
//	vector:
//	- constructor: specify size, size & value to be replicated,
//	  size & an array of values to load, or another vector.
//	- assignment =: from a vector, an array, or a value to be
//	  replicated.
//	- subscripting (): direct element and sub-vector access (lvalue).
//	- scaling operators: *, /.
//	- scaling update operators: *=, /=.
//	- vector arithmetic operators: unary +-, binary +-,
//	  * (correlation), ^ (convolution), and % (outer product).
//	- vector arithmetic update operators: +=, -=.
//	- matrix multiplication *: vector-matrix & matrix-vector.
//	- vector reverse operator: ~.
//	- vector rotation operators: <<, >>.
//	- equality operator: ==, !=.
//	- stream output operator: <<.
//	- elemental utility functions: size, min, max, sum, mse.
//
//	matrix:
//	- constructor: specify size, size & value to be replicated,
//	  size & an array of values to load, or another vector.
//	- assignment =: from a matrix, an array, or a value to be
//	  replicated.
//	- subscripting (): direct element access -- lvalue.
//	- scaling operators: *, /.
//	- scaling update operators: *=, /=.
//	- matrix arithmetic operators: binary +-, unary +-, *, ^.
//	- matrix arithmetic update operators: +=, -=, *=, ^=.
//	- transpose operator: ~.
//	- equality operator: ==, !=.
//	- stream output operator: <<.
//	- elemental utility functions: rsize, csize, eye, trace, square.
//
//	note:	`a ^ b' is equivalent to `a * ~b', but more efficient.
//

#ifndef _doubleVec_h
#define _doubleVec_h

#include <stream.h>
#include <std.h>
#include <type.h>
#include <error.h>

class doubleVec;
class doubleVec_t;
class doubleMat;
class doubleMat_t;

//
// doubleVec: vector class
//

enum doubleVec_type { 
  doubleVec_type_plain, 
  doubleVec_type_temp, 
  doubleVec_type_reference };

struct doubleVec_ {
  doubleVec_type t;		// vector type
  uint s;			// vector size
  double *p;			// ptr to vector values

  uint del()			{ return t != doubleVec_type_reference; }
  uint copy_from()		{ return t == doubleVec_type_temp; }
  uint copy_to()		{ return t == doubleVec_type_plain; }
  uint subvec()			{ return t == doubleVec_type_reference; }
};

class doubleVec_t : doubleVec_ { 
  friend class doubleVec;
  friend class doubleMat;

  doubleVec_t(doubleVec_type T, uint S, double* P)
    { t = T, s = S, p = P; }
public:
  doubleVec_t(doubleVec& v);
};

class doubleVec : doubleVec_ {
  friend class doubleVec_t;

  copy(double* from ) {
    double* to = p;
    for ( uint i=s; i--; ) *to++ = *from++; }

public:
  doubleVec(uint i)
    { t = doubleVec_type_plain, p = new double[s=i]; }
  doubleVec(doubleVec& v) {
    t = doubleVec_type_plain, s = v.s;
    if ( v.copy_from() )
      p = v.p, v.t = doubleVec_type_reference;
    else
      p = new double[s], copy(v.p); }
  doubleVec(uint i, double *pd)
    { t = doubleVec_type_plain, p = new double[s=i], copy(pd); }
  doubleVec(uint i, double d) {
    t = doubleVec_type_plain, p = new double[s=i];
    for ( double *pp = p; i--; ) *pp++ = d; }
  doubleVec(doubleVec_t& v)
    { t = v.t, v.t = doubleVec_type_reference, s = v.s, p = v.p; }

  ~doubleVec()				
    { if ( del() ) delete p; }

  double& operator()(uint i);
  doubleVec operator()(uint, uint);

  doubleVec& operator=(doubleVec&);
  doubleVec& operator=(double*);
  doubleVec& operator=(double);

  doubleVec& operator+()				
    { return *this; }
  friend doubleVec operator-(doubleVec&);
  friend doubleVec operator~(doubleVec&);

  friend doubleVec operator+(doubleVec&, doubleVec&);
  friend doubleVec operator-(doubleVec&, doubleVec&);

  friend double operator*(doubleVec&, doubleVec&);
  friend double operator^(doubleVec&, doubleVec&);

  friend doubleVec operator*(doubleVec&, double&);
  friend doubleVec operator*(double&, doubleVec&);

  friend doubleVec doubleMat::operator*(doubleVec&);
  friend doubleVec operator*(doubleVec&, doubleMat&);

  friend doubleVec operator/(doubleVec&, double&);

  friend doubleMat operator%(doubleVec&, doubleVec&);

  friend doubleVec operator>>(doubleVec&, uint );
  friend doubleVec operator<<(doubleVec&, uint );

  friend int operator==(doubleVec&, doubleVec&);
  friend int operator!=(doubleVec&, doubleVec&);

  doubleVec& operator+=(doubleVec&);
  doubleVec& operator-=(doubleVec&);

  doubleVec& operator*=(double&);
  doubleVec& operator/=(double&);

  doubleVec& operator>>=(uint);
  doubleVec& operator<<=(uint);

  friend uint size(doubleVec& v)		
    { return v.s; }
  friend double* contents(doubleVec& v)
    { return v.p; }

  friend uint min(doubleVec&);
  friend uint max(doubleVec&);
  friend double sum(doubleVec&);

  friend double mse(doubleVec&, doubleVec&);

  friend istream& operator>>(istream&, doubleVec&);
  friend ostream& operator<<(ostream&, doubleVec&);
};

inline doubleVec_t::doubleVec_t(doubleVec& v)	
  { t = doubleVec_type_temp, v.t = doubleVec_type_reference, s = v.s, p = v.p; }

inline double& doubleVec::operator()(uint i) {
  if ( i >= s ) crash("doubleVec::operator() : subscript range error");
  return p[i];
}

inline doubleVec doubleVec::operator()(uint i, uint j) {
  if ( j < i || j >= s ) 
    crash("doubleVec::operator() : sub-vector range error");
  return doubleVec_t(doubleVec_type_reference,j-i+1,p+i);
}

inline doubleVec operator*(double& d, doubleVec& v) 
  { return doubleVec_t(v * d); }

inline int operator!=(doubleVec& u, doubleVec& v)
  { return !(u == v); }

inline doubleVec& doubleVec::operator>>=(uint i)
  { *this = *this >> i; return *this; }
inline doubleVec& doubleVec::operator<<=(uint i)
  { *this = *this << i; return *this; }

//
// doubleMat: doubleMat class
//

struct doubleMat_ {
  doubleVec_type t;		// vector type
  uint l,			// total matrix size
    m,				// number of rows
    n;				// number of columns
  double *p;			// ptr to matrix values

  uint del()			{ return t != doubleVec_type_reference; }
  uint copy_from()		{ return t == doubleVec_type_temp; }
  uint copy_to()		{ return t == doubleVec_type_plain; }
  uint subvec()			{ return t == doubleVec_type_reference; }
};

class doubleMat_t : doubleMat_ { 
  friend class doubleMat;

  doubleMat_t(doubleVec_type T, uint L, uint M, uint N, double* P)
    { t = T, l = L, m = M, n = N, p = P; }
public:
  doubleMat_t(doubleMat& v);
};

class doubleMat : doubleMat_ {
  friend doubleMat_t;

  copy(double* from ) {
    double* to = p;
    for ( uint i=l; i--; ) *to++ = *from++; }

  doubleMat(uint i, uint j, uint k)
    { t=doubleVec_type_plain, l=i, m=j, n=k, p = new double[l]; }

public:
  doubleMat(uint i, uint j)		
    { t=doubleVec_type_plain, l=i*j, m=i, n=j, p = new double[l]; }
  doubleMat(doubleMat& v) {
    t=doubleVec_type_plain, l=v.l, m=v.m, n=v.n;
    if ( v.copy_from() )
      p = v.p, v.t = doubleVec_type_reference;
    else
      p = new double[l], copy(v.p); }
  doubleMat(uint i, uint j, double *pd) {
    t=doubleVec_type_plain, l=i*j, m=i, n=j, p=new double[l];
    copy(pd); }
  doubleMat(uint i, uint j, double d) {
    t=doubleVec_type_plain, l=i*j, m=i, n=j, p=new double[l];
    double *pp = p;
    for ( uint k=l; k--; ) *pp++ = d; }
  doubleMat(doubleMat_t& v)
    { t=v.t, v.t=doubleVec_type_reference, l=v.l, m=v.m, n=v.n, p=v.p; }

  ~doubleMat()				
    { if ( del() ) delete p; }

  doubleVec operator()(uint i);
  double& operator()(uint i, uint j);

  doubleMat& operator=(doubleMat&);
  doubleMat& operator=(double*);
  doubleMat& operator=(double);

  doubleMat& operator+()
    { return *this; }
  friend doubleMat operator-(doubleMat&);
  friend doubleMat operator~(doubleMat&);

  friend doubleMat operator+(doubleMat&, doubleMat&);
  friend doubleMat operator-(doubleMat&, doubleMat&);

  friend doubleMat operator*(doubleMat&, doubleMat&);
  friend doubleVec operator*(doubleMat&, doubleVec&);
  friend doubleVec operator*(doubleVec&, doubleMat&);
  friend doubleMat operator*(doubleMat&, double&);
  friend doubleMat operator*(double&, doubleMat&);

  friend doubleMat operator^(doubleMat&, doubleMat&);

  friend doubleMat operator/(doubleMat&, double&);

  friend doubleMat operator%(doubleVec&, doubleVec&);

  friend int operator==(doubleMat&, doubleMat&);

  doubleMat& operator+=(doubleMat&);
  doubleMat& operator-=(doubleMat&);
  doubleMat& operator*=(doubleMat&);
  doubleMat& operator^=(doubleMat&);

  doubleMat& operator*=(double&);
  doubleMat& operator/=(double&);

  friend uint csize(doubleMat& M)		{ return M.m; }
  friend uint rsize(doubleMat& M)		{ return M.n; }

  friend double trace(doubleMat&);
  friend doubleMat eye(uint, double =1.);

  friend istream& operator>>(istream&, doubleMat&);
  friend ostream& operator<<(ostream&, doubleMat&);
};

inline doubleMat_t::doubleMat_t(doubleMat& v) {
  t = doubleVec_type_temp, v.t = doubleVec_type_reference;
  l = v.l, m = v.m, n = v.n, p = v.p;
}

inline doubleVec doubleMat::operator()(uint i) {
  if ( i >= m ) crash("doubleMat::operator() : row subscript range error");
  return doubleVec_t(doubleVec_type_reference,n,p+i*n);
}

inline double& doubleMat::operator()(uint i, uint j) {
  if ( i >= m || j >= n ) 
    crash("doubleMat::operator() : subscript range error");
  return p[i*n+j];
}

inline doubleMat operator*(double& d, doubleMat& m)
  { return doubleMat_t(m * d); }

inline int operator!=(doubleMat& M, doubleMat& N)
  { return !(M == N); }

inline int square(doubleMat& M)
  { return rsize(M) == csize(M); }

#endif
----------------------------------------------------------------------------
/* moved to vax [9/88 kbg] */
#ifndef _nr_h_
#define _nr_h_

typedef struct FCOMPLEX {float r,i;} fcomplex;
typedef struct IMMENSE {unsigned long l,r;} immense;
typedef struct GREAT {unsigned short l,c,r;} great;

void  adi(double **a, double **b, double **c, double **d, double **e,
	double **f, double **g, double **u, int jmax, int k,
	double alpha, double beta, double eps);
void  anneal(float *x, float *y, int *iorder, int ncity);
void  avevar(float *data, int n, float *ave, float *svar);
void  balanc(float **a, int n);
void  bcucof(float *y, float *y1, float *y2, float *y12, float d1,
	float d2, float **c);
void  bcuint(float *y, float *y1, float *y2, float *y12, float x1l, 
	float x1u, float x2l, float x2u, float x1, float x2, 
	float *ansy, float *ansy1, float *ansy2);
float bessi(int n, float x);
float bessi0(float x);
float bessi1(float x);
float bessj(int n, float x);
float bessj0(float x);
float bessj1(float x);
float bessk(int n, float x);
float bessk0(float x);
float bessk1(float x);
float bessy(int n, float x);
float bessy0(float x);
float bessy1(float x);
float beta(float z, float w);
float betacf(float a, float b, float x);
float betai(float a, float b, float x);
float bico(int n, int k);
void  bksub(int ne, int nb, int jf, int k1, int k2, float ***c);
float bnldev(float pp, int n, int *idum);
void  caldat(long julian, int *mm, int *id, int *iyyy);
float cel(float qqc, float pp, float aa, float bb);
void  chder(float a, float b, float *c, float *cder, int n);
float chebev(float a, float b, float *c, int m, float x);
void  chebpc(float *c, float *d, int n);
void  chint(float a, float b, float *c, float *cint, int n);
void  chsone(float *bins, float *ebins, int nbins, int knstrn, 
	float *df, float *chsq, float *prob);
void  chstwo(float *bins1, float *bins2, int nbins, int knstrn, 
	float *df, float *chsq, float *prob);
void  cntab1(int **nn, int n1, int nj, float *chisq, float *df, 
	float *prob, float *cramrv, float *ccc);
void  cntab2(int **nn, int ni, int nj, float *h, float *hx, float *hy, 
	float *hygx, float *hxgy, float *uygx, float *uxgy,
	float *uxy);
void  convlv(float *data, int n, float *respns, int m, int isign, 
	float *ans);
void  correl(float *data1, float *data2, int n, float *ans);
void  cosft(float *y, int n, int isign);
void  covsrt(float **covar, int ma, int *lista, int mfit);
void  crank(int n, float *w, float *s);
void  ddpoly(float *c, int nc, float x, float *pd, int nd);
void  des(immense inp, immense key, int *newkey, int isw, immense *out);
void  ks(immense key, int n, great *kn);
void  cyfun(unsigned long ir, great k, unsigned long *iout);
float df1dim(float x);
void  difeq(int k, int k1, int k2, int jsf, int is1, int isf, 
	int *indexv, int ne, float **s, float **y);
void  eclass(int *nf, int n, int *lista, int *listb, int m);
void  eclazz(int *nf, int n, int (*equiv)(int,int));
void  eigsrt(float *d, float **v, int n);
float el2(float x, float qqc, float aa, float bb);
void  elmhes(float **a, int n);
float erfcc(float x);
void  eulsum(float *sum, float term, int jterm, float *wksp);
float evlmem(float fdt, float *cof, int m, float pm);
float expdev(int *idum);
float f1dim(float x);
float factln(int n);
float factrl(int n);
void  fgauss(float x, float *a, float *y, float *dyda, int na);
void  fit(float *x, float *y, int ndata, float *sig, int mwt, float *a, 
	float *b, float *siga, float *sigb, float *chi2, float *q);
void  fixrts(float *d, int npoles);
void  fleg(float x, float *pl, int nl);
void  flmoon(int n, int nph, long *jd, float *frac);
void  four1(float *data, int nn, int isign);
void  fourn(float *data, int *nn, int ndim, int isign);
void  fpoly(float x, float *p, int np);
void  ftest(float *data1, int n1, float *data2, int n2, float *f, 
	float *prob);
float gamdev(int ia, int *idum);
float gammln(float xx);
float gammp(float a, float x);
float gammq(float a, float x);
float gasdev(int *idum);
void  gauleg(double x1, double x2, double *x, double *w, int n);
void  gaussj(float **a, int n, float **b, int m);
void  gcf(float *gammcf, float a, float x, float *gln);
void  gser(float *gamser, float a, float x, float *gln);
void  hqr(float **a, int n, float *wr, float *wi);
void  hunt(float *xx, int n, float x, int *jlo);
void  indexx(int n, float *arrin, int *indx);
int   irbit1(unsigned long int *iseed);
int   irbit2(unsigned long int *iseed);
void  jacobi(float **a, int n, float *d, float **v, int *nrot);
long  julday(int mm, int id, int iyyy);
void  kendl1(float *data1, float *data2, int n, float *tau, float *z,
	float *prob);
void  kendl2(float **tab, int i, int j, float *tau, float *z,
	float *prob);
void  kstwo(float *data1, int n1, float *data2, int n2, float *d,
	float *prob);
void  laguer(fcomplex *a, int m, fcomplex *x, float eps, int polish);
void  locate(float *xx, int n, float x, int *j);
void  lubksb(float **a, int n, int *indx, float *b);
void  ludcmp(float **a, int n, int *indx, float *d);
void  mdian1(float *x, int n, float *xmed);
void  mdian2(float *x, int n, float *xmed);
void  medfit(float *x, float *y, int ndata, float *a, float *b,
	float *abdev);
void  memcof(float *data, int n, int m, float *pm, float *cof);
void  mnewt(int ntrial, float *x, int n, float tolx, float tolf);
void  moment(float *data, int n, float *ave, float *adev, float *sdev, 
	float *svar, float *skew, float *curt);
void  mprove(float **a, float **alud, int n, int *indx, float *b, 
	float *x);
void  pcshft(float a, float b, float *d, int n);
void  pearsn(float *x, float *y, int n, float *r, float *prob, float *z);
void  piksr2(int n, float *arr, float *brr);
void  piksrt(int n, float *arr);
void  pinvs(int ie1, int ie2, int je1, int jsf, int jc1, int k,
	float ***c, float **s);
float plgndr(int l, int m, float x);
float poidev(float xm, int *idum);
void  polcoe(float *x, float *y, int n, float *cof);
void  polcof(float *xa, float *ya, int n, float *cof);
void  poldiv(float *u, int n, float *v, int nv, float *q, float *r);
void  polin2(float *x1a, float *x2a, float **ya, int m, int n, float x1, 
	float x2, float *y, float *dy);
void  polint(float *xa, float *ya, int n, float x, float *y, float *dy);
void  predic(float *data, int ndata, float *d, int npoles, 
	float *future, int nfut);
float probks(float alam);
void  pzextr(int iest, float xest, float *yest, float *yz, float *dy,
	int nv, int nuse);
void  qcksrt(int n, float *arr);
void  qroot(float *p, int n, float *b, float *c, float eps);
float ran0(int *idum);
float ran1(int *idum);
float ran2(long *idum);
float ran3(int *idum);
float ran4(int *idum);
void  rank(int n, int *indx, int *irank);
void  ratint(float *xa, float *ya, int n, float x, float *y, float *dy);
void  realft(float *data, int n, int isign);
void  red(int iz1, int iz2, int jz1, int jz2, int jm1, int jm2, int jmf,
	int ic1, int jc1, int jcf, int kc, float ***c, float **s);
float rofunc(float b);
void  rzextr(int iest, float xest, float *yest, float *yz, float *dy,
	int nv, int nuse);
void  shell(int n, float *arr);
void  shoot(int nvar, float *v, float *delv, int n2, float x1, float x2,
	float eps, float h1, float hmin, float *f, float *dv);
void  shootf(int nvar, float *v1, float *v2, float *delv1, float *delv2,
	int n1, int n2, float x1, float x2, float xf, float eps, 
	float h1, float hmin, float *f, float *dv1, float *dv2);
void  simp1(float **a, int mm, int *ll, int nll, int iabf, int *kp,
	float *bmax);
void  simp2(float **a, int n, int *l2, int nl2, int *ip, int kp,
	float *q1);
void  simp3(float **a, int i1, int k1, int ip, int kp);
void  simplx(float **a, int m, int n, int m1, int m2, int m3, 
	int *icase, int *izrov, int *iposv);
void  sinft(float *y, int n);
void  smooft(float *y, int n, float pts);
void  sncndn(float uu, float emmc, float *sn, float *cn, float *dn);
void  solvde(int itmax, float conv, float slowc, float *scalv,
	int *indexv, int ne, int nb, int m, float **y, float ***c,
	float **s);
void  sor(double **a, double **b, double **c, double **d, double **e, 
	double **f, double **u, int jmax, double rjac);
void  sort(int n, float *ra);
void  sort2(int n, float *ra, float *rb);
void  sort3(int n, float *ra, float *rb, float *rc);
void  sparse(float *b, int n, float *x, float *rsq);
void  spctrm(FILE *fp, float *p, int m, int k, int ovrlap);
void  spear(float *data1, float *data2, int n, float *d, float *zd,
	float *probd, float *rs, float *probrs);
void  splie2(float *x1a, float *x2a, float **ya, int m, int n,
	float **y2a);
void  splin2(float *x1a, float *x2a, float **ya, float **y2a, int m,
	int n, float x1, float x2, float *y);
void  spline(float *x, float *y, int n, float yp1, float ypn, float *y2);
void  splint(float *xa, float *ya, float *y2a, int n, float x, float *y);
void  svbksb(float **u, float *w, float **v, int m, int n, float *b,
	float *x);
void  svdcmp(float **a, int m, int n, float *w, float **v);
void  svdvar(float **v, int ma, float *w, float **cvm);
void  toeplz(float *r, float *x, float *y, int n);
void  tptest(float *data1, float *data2, int n, float *t, float *prob);
void  tqli(float *d, float *e, int n, float **z);
void  tred2(float **a, int n, float *d, float *e);
void  tridag(float *a, float *b, float *c, float *r, float *u, int n);
void  ttest(float *data1, int n1, float *data2, int n2, float *t,
	float *prob);
void  tutest(float *data1, int n1, float *data2, int n2, float *t,
	float *prob);
void  twofft(float *data1, float *data2, float *fft1, float *fft2,
	int n);
void  vander(float *x, float *w, float *q, int n);
void  zroots(fcomplex *a, int m, fcomplex *roots, int polish);

float *vector(int, int);
float **matrix(int, int, int, int);
float **convert_matrix(float*, int, int, int, int);
double *dvector(int, int);
double **dmatrix(int, int, int, int);
int *ivector(int, int);
int **imatrix(int, int);
float **submatrix(float**, int, int, int, int, int, int);
void free_vector(float*, int, int);
void free_dvector(float*, int, int);
void free_ivector(float*, int, int);
void free_matrix(float**, int, int, int, int);
void free_dmatrix(float**, int, int, int, int);
void free_imatrix(float**, int, int, int, int);
void free_submatrix(float**, int, int, int, int);
void free_convert_matrix(float**, int, int, int, int);
void nrerror(char*);

#endif
----------------------------------------------------------------------------
//
// type.h : machine type definitions
//

#ifndef TYPEH
#define TYPEH

typedef short int int16;
typedef long int int32;
typedef unsigned short int uint16;
typedef unsigned long int uint32;

typedef unsigned int uint;

typedef unsigned char byte;

#endif
----------------------------------------------------------------------------
//
// error.h : error function header file
//

#ifndef _error_h
#define _error_h

#include <overload.h>
#include <stream.h>
#include <std.h>

void warning(const char*);
void error(const char*);
void crash(const char*);

#endif
----------------------------------------------------------------------------
//
// overload.h : single repository for overload statements
//
//	this single repository avoids warning messages of multiple
//	overloads.
//

#ifndef _overload_h_
#define _overload_h_

overload warning;
overload error;
overload crash;

overload square;

#endif
----------------------------------------------------------------------------