<a href="nr.h.html">nr.h</a>.html

    #ifndef _NR_H_
    #define _NR_H_

    #ifndef _FCOMPLEX_DECLARE_T_
    typedef struct FCOMPLEX {float r,i;} fcomplex;
    #define _FCOMPLEX_DECLARE_T_
    #endif /* _FCOMPLEX_DECLARE_T_ */

    #ifndef _ARITHCODE_DECLARE_T_
    typedef struct {
        unsigned long *ilob,*iupb,*ncumfq,jdif,nc,minint,nch,ncum,nrad;
    } arithcode;
    #define _ARITHCODE_DECLARE_T_
    #endif /* _ARITHCODE_DECLARE_T_ */

    #ifndef _HUFFCODE_DECLARE_T_
    typedef struct {
        unsigned long *icod,*ncod,*left,*right,nch,nodemax;
    } huffcode;
    #define _HUFFCODE_DECLARE_T_
    #endif /* _HUFFCODE_DECLARE_T_ */

    #include <stdio.h>

    #if defined(__STDC__) || defined(ANSI) || defined(NRANSI) /* ANSI */

    void addint(double **uf, double **uc, double **res, int nf);
    void airy(float x, float *ai, float *bi, float *aip, float *bip);
    void amebsa(float **p, float y[], int ndim, float pb[], float *yb,
        float ftol, float (*funk)(float []), int *iter, float temptr);
    void amoeba(float **p, float y[], int ndim, float ftol,
        float (*funk)(float []), int *iter);
    float amotry(float **p, float y[], float psum[], int ndim,
        float (*funk)(float []), int ihi, float fac);
    float amotsa(float **p, float y[], float psum[], int ndim, float pb[],
        float *yb, float (*funk)(float []), int ihi, float *yhi, float fac);
    void anneal(float x[], float y[], int iorder[], int ncity);
    double anorm2(double **a, int n);
    void arcmak(unsigned long nfreq[], unsigned long nchh, unsigned long nradd,
        arithcode *acode);
    void arcode(unsigned long *ich, unsigned char **codep, unsigned long *lcode,
        unsigned long *lcd, int isign, arithcode *acode);
    void arcsum(unsigned long iin[], unsigned long iout[], unsigned long ja,
        int nwk, unsigned long nrad, unsigned long nc);
    void asolve(unsigned long n, double b[], double x[], int itrnsp);
    void atimes(unsigned long n, double x[], double r[], int itrnsp);
    void avevar(float data[], unsigned long n, float *ave, float *var);
    void balanc(float **a, int n);
    void banbks(float **a, unsigned long n, int m1, int m2, float **al,
        unsigned long indx[], float b[]);
    void bandec(float **a, unsigned long n, int m1, int m2, float **al,
        unsigned long indx[], float *d);
    void banmul(float **a, unsigned long n, int m1, int m2, float x[], float b[]);
    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);
    void beschb(double x, double *gam1, double *gam2, double *gampl,
        double *gammi);
    float bessi(int n, float x);
    float bessi0(float x);
    float bessi1(float x);
    void bessik(float x, float xnu, float *ri, float *rk, float *rip,
        float *rkp);
    float bessj(int n, float x);
    float bessj0(float x);
    float bessj1(float x);
    void bessjy(float x, float xnu, float *rj, float *ry, float *rjp,
        float *ryp);
    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, long *idum);
    float brent(float ax, float bx, float cx,
        float (*f)(float), float tol, float *xmin);
    void broydn(float x[], int n, int *check,
        void (*vecfunc)(int, float [], float []));
    void bsstep(float y[], float dydx[], int nv, float *xx, float htry,
        float eps, float yscal[], float *hdid, float *hnext,
        void (*derivs)(float, float [], float []));
    void caldat(long julian, int *mm, int *id, int *iyyy);
    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 chebft(float a, float b, float c[], int n, float (*func)(float));
    void chebpc(float c[], float d[], int n);
    void chint(float a, float b, float c[], float cint[], int n);
    float chixy(float bang);
    void choldc(float **a, int n, float p[]);
    void cholsl(float **a, int n, float p[], float b[], float x[]);
    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 cisi(float x, float *ci, float *si);
    void cntab1(int **nn, int ni, 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[], unsigned long n, float respns[], unsigned long m,
        int isign, float ans[]);
    void copy(double **aout, double **ain, int n);
    void correl(float data1[], float data2[], unsigned long n, float ans[]);
    void cosft(float y[], int n, int isign);
    void cosft1(float y[], int n);
    void cosft2(float y[], int n, int isign);
    void covsrt(float **covar, int ma, int ia[], int mfit);
    void crank(unsigned long n, float w[], float *s);
    void cyclic(float a[], float b[], float c[], float alpha, float beta,
        float r[], float x[], unsigned long n);
    void daub4(float a[], unsigned long n, int isign);
    float dawson(float x);
    float dbrent(float ax, float bx, float cx,
        float (*f)(float), float (*df)(float), float tol, float *xmin);
    void ddpoly(float c[], int nc, float x, float pd[], int nd);
    int decchk(char string[], int n, char *ch);
    void derivs(float x, float y[], float dydx[]);
    float det(float **a,int n);
    double det3(double **a);
    float df1dim(float x);
    void dfour1(double data[], unsigned long nn, int isign);
    void dfpmin(float p[], int n, float gtol, int *iter, float *fret,
        float (*func)(float []), void (*dfunc)(float [], float []));
    float dfridr(float (*func)(float), float x, float h, float *err);
    void dftcor(float w, float delta, float a, float b, float endpts[],
        float *corre, float *corim, float *corfac);
    void dftint(float (*func)(float), float a, float b, float w,
        float *cosint, float *sinint);
    void difeq(int k, int k1, int k2, int jsf, int is1, int isf,
        int indexv[], int ne, float **s, float **y);
    void dlinmin(float p[], float xi[], int n, float *fret,
        float (*func)(float []), void (*dfunc)(float [], float[]));
    double dpythag(double a, double b);
    void drealft(double data[], unsigned long n, int isign);
    void dsprsax(double sa[], unsigned long ija[], double x[], double b[],
        unsigned long n);
    void dsprstx(double sa[], unsigned long ija[], double x[], double b[],
        unsigned long n);
    void dsvbksb(double **u, double w[], double **v, int m, int n, double b[],
        double x[]);
    void dsvdcmp(double **a, int m, int n, double w[], double **v);
    void eclass(int nf[], int n, int lista[], int listb[], int m);
    void eclazz(int nf[], int n, int (*equiv)(int, int));
    float ei(float x);
    void eigsrt(double d[], double **v, int n);
    float elle(float phi, float ak);
    float ellf(float phi, float ak);
    float ellpi(float phi, float en, float ak);
    void elmhes(float **a, int n);
    float erfcc(float x);
    float erff(float x);
    float erffc(float x);
    void eulsum(float *sum, float term, int jterm, float wksp[]);
    float evlmem(float fdt, float d[], int m, float xms);
    float expdev(long *idum);
    float expint(int n, float x);
    float f1(float x);
    float f1dim(float x);
    float f2(float y);
    float f3(float z);
    float factln(int n);
    float factrl(int n);
    void fasper(float x[], float y[], unsigned long n, float ofac, float hifac,
        float wk1[], float wk2[], unsigned long nwk, unsigned long *nout,
        unsigned long *jmax, float *prob);
    void fdjac(int n, float x[], float fvec[], float **df,
        void (*vecfunc)(int, float [], float []));
    void fgauss(float x, float a[], float *y, float dyda[], int na);
    void fill0(double **u, int n);
    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 fitexy(float x[], float y[], int ndat, float sigx[], float sigy[],
        float *a, float *b, float *siga, float *sigb, float *chi2, float *q);
    void fixrts(float d[], int m);
    void fleg(float x, float pl[], int nl);
    void flmoon(int n, int nph, long *jd, float *frac);
    float fmin(float x[]);
    void four1(float data[], unsigned long nn, int isign);
    void fourew(FILE *file[5], int *na, int *nb, int *nc, int *nd);
    void fourfs(FILE *file[5], unsigned long nn[], int ndim, int isign);
    void fourn(float data[], unsigned long nn[], int ndim, int isign);
    void fpoly(float x, float p[], int np);
    void fred2(int n, float a, float b, float t[], float f[], float w[],
        float (*g)(float), float (*ak)(float, float));
    float fredin(float x, int n, float a, float b, float t[], float f[], float w[],
        float (*g)(float), float (*ak)(float, float));
    void frenel(float x, float *s, float *c);
    void frprmn(float p[], int n, float ftol, int *iter, float *fret,
        float (*func)(float []), void (*dfunc)(float [], float []));
    void ftest(float data1[], unsigned long n1, float data2[], unsigned long n2,
        float *f, float *prob);
    float gamdev(int ia, long *idum);
    float gammln(float xx);
    float gammp(float a, float x);
    float gammq(float a, float x);
    float gasdev(long *idum);
    void gaucof(int n, float a[], float b[], float amu0, float x[], float w[]);
    void gauher(float x[], float w[], int n);
    void gaujac(float x[], float w[], int n, float alf, float bet);
    void gaulag(float x[], float w[], int n, float alf);
    void gauleg(float x1, float x2, float x[], float w[], int n);
    void gaussj(float **a, int n, float **b, int m);
    void gcf(float *gammcf, float a, float x, float *gln);
    float golden(float ax, float bx, float cx, float (*f)(float), float tol,
        float *xmin);
    void gser(float *gamser, float a, float x, float *gln);
    void hpsel(unsigned long m, unsigned long n, float arr[], float heap[]);
    void hpsort(unsigned long n, float ra[]);
    void hqr(float **a, int n, float wr[], float wi[]);
    void hufapp(unsigned long index[], unsigned long nprob[], unsigned long n,
        unsigned long i);
    void hufdec(unsigned long *ich, unsigned char *code, unsigned long lcode,
        unsigned long *nb, huffcode *hcode);
    void hufenc(unsigned long ich, unsigned char **codep, unsigned long *lcode,
        unsigned long *nb, huffcode *hcode);
    void hufmak(unsigned long nfreq[], unsigned long nchin, unsigned long *ilong,
        unsigned long *nlong, huffcode *hcode);
    void hunt(float xx[], unsigned long n, float x, unsigned long *jlo);
    void hypdrv(float s, float yy[], float dyyds[]);
    fcomplex hypgeo(fcomplex a, fcomplex b, fcomplex c, fcomplex z);
    void hypser(fcomplex a, fcomplex b, fcomplex c, fcomplex z,
        fcomplex *series, fcomplex *deriv);
    unsigned short icrc(unsigned short crc, unsigned char *bufptr,
        unsigned long len, short jinit, int jrev);
    unsigned short icrc1(unsigned short crc, unsigned char onech);
    unsigned long igray(unsigned long n, int is);
    void iindexx(unsigned long n, long arr[], unsigned long indx[]);
    void indexx(unsigned long n, float arr[], unsigned long indx[]);
    void interp(double **uf, double **uc, int nf);
    int irbit1(unsigned long *iseed);
    int irbit2(unsigned long *iseed);
    void jacobi(double **a, int n, double d[], double **v, int *nrot);
    void jacobn(float x, float y[], float dfdx[], float **dfdy, int n);
    long julday(int mm, int id, int iyyy);
    void kendl1(float data1[], float data2[], unsigned long n, float *tau, float *z,
        float *prob);
    void kendl2(float **tab, int i, int j, float *tau, float *z, float *prob);
    void kermom(double w[], double y, int m);
    void ks2d1s(float x1[], float y1[], unsigned long n1,
        void (*quadvl)(float, float, float *, float *, float *, float *),
        float *d1, float *prob);
    void ks2d2s(float x1[], float y1[], unsigned long n1, float x2[], float y2[],
        unsigned long n2, float *d, float *prob);
    void ksone(float data[], unsigned long n, float (*func)(float), float *d,
        float *prob);
    void kstwo(float data1[], unsigned long n1, float data2[], unsigned long n2,
        float *d, float *prob);
    void laguer(fcomplex a[], int m, fcomplex *x, int *its);
    void lfit(float x[], float y[], float sig[], int ndat, float a[], int ia[],
        int ma, float **covar, float *chisq, void (*funcs)(float, float [], int));
    void linbcg(unsigned long n, double b[], double x[], int itol, double tol,
         int itmax, int *iter, double *err);
    void linmin(float p[], float xi[], int n, float *fret,
        float (*func)(float []));
    void lnsrch(int n, float xold[], float fold, float g[], float p[], float x[],
         float *f, float stpmax, int *check, float (*func)(float []));
    void load(float x1, float v[], float y[]);
    void load1(float x1, float v1[], float y[]);
    void load2(float x2, float v2[], float y[]);
    void locate(float xx[], unsigned long n, float x, unsigned long *j);
    void lop(double **out, double **u, int n);
    void lubksb(float **a, int n, int *indx, float b[]);
    void ludcmp(float **a, int n, int *indx, float *d);
    void machar(int *ibeta, int *it, int *irnd, int *ngrd,
        int *machep, int *negep, int *iexp, int *minexp, int *maxexp,
        float *eps, float *epsneg, float *xmin, float *xmax);
    void matadd(double **a, double **b, double **c, int n);
    void matsub(double **a, double **b, double **c, int n);
    void medfit(float x[], float y[], int ndata, float *a, float *b, float *abdev);
    void memcof(float data[], int n, int m, float *xms, float d[]);
    int metrop(float de, float t);
    void mgfas(double **u, int n, int maxcyc);
    void mglin(double **u, int n, int ncycle);
    float midexp(float (*funk)(float), float aa, float bb, int n);
    float midinf(float (*funk)(float), float aa, float bb, int n);
    float midpnt(float (*func)(float), float a, float b, int n);
    float midsql(float (*funk)(float), float aa, float bb, int n);
    float midsqu(float (*funk)(float), float aa, float bb, int n);
    void miser(float (*func)(float []), float regn[], int ndim, unsigned long npts,
        float dith, float *ave, float *var);
    void mmid(float y[], float dydx[], int nvar, float xs, float htot,
        int nstep, float yout[], void (*derivs)(float, float[], float[]));
    void mnbrak(float *ax, float *bx, float *cx, float *fa, float *fb,
        float *fc, float (*func)(float));
    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 *var, float *skew, float *curt);
    void mp2dfr(unsigned char a[], unsigned char s[], int n, int *m);
    void mpadd(unsigned char w[], unsigned char u[], unsigned char v[], int n);
    void mpdiv(unsigned char q[], unsigned char r[], unsigned char u[],
        unsigned char v[], int n, int m);
    void mpinv(unsigned char u[], unsigned char v[], int n, int m);
    void mplsh(unsigned char u[], int n);
    void mpmov(unsigned char u[], unsigned char v[], int n);
    void mpmul(unsigned char w[], unsigned char u[], unsigned char v[], int n,
        int m);
    void mpneg(unsigned char u[], int n);
    void mppi(int n);
    void mprove(float **a, float **alud, int n, int indx[], float b[],
        float x[]);
    void mpsad(unsigned char w[], unsigned char u[], int n, int iv);
    void mpsdv(unsigned char w[], unsigned char u[], int n, int iv, int *ir);
    void mpsmu(unsigned char w[], unsigned char u[], int n, int iv);
    void mpsqrt(unsigned char w[], unsigned char u[], unsigned char v[], int n,
        int m);
    void mpsub(int *is, unsigned char w[], unsigned char u[], unsigned char v[],
        int n);
    void mrqcof(float x[], float y[], float sig[], int ndata, float a[],
        int ia[], int ma, float **alpha, float beta[], float *chisq,
        void (*funcs)(float, float [], float *, float [], int));
    void mrqmin(float x[], float y[], float sig[], int ndata, float a[],
        int ia[], int ma, float **covar, float **alpha, float *chisq,
        void (*funcs)(float, float [], float *, float [], int), float *alamda);
    void newt(float x[], int n, int *check,
        void (*vecfunc)(int, float [], float []));
    void odeint(float ystart[], int nvar, float x1, float x2,
        float eps, float h1, float hmin, int *nok, int *nbad,
        void (*derivs)(float, float [], float []),
        void (*rkqs)(float [], float [], int, float *, float, float,
        float [], float *, float *, void (*)(float, float [], float [])));
    void orthog(int n, float anu[], float alpha[], float beta[], float a[],
        float b[]);
    void pade(double cof[], int n, float *resid);
    void pccheb(float d[], float c[], int n);
    void pcshft(float a, float b, float d[], int n);
    void pearsn(float x[], float y[], unsigned long n, float *r, float *prob,
        float *z);
    void period(float x[], float y[], int n, float ofac, float hifac,
        float px[], float py[], int np, int *nout, int *jmax, float *prob);
    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, long *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 powell(float p[], float **xi, int n, float ftol, int *iter, float *fret,
        float (*func)(float []));
    void predic(float data[], int ndata, float d[], int m, float future[], int nfut);
    float probks(float alam);
    void psdes(unsigned long *lword, unsigned long *irword);
    void pwt(float a[], unsigned long n, int isign);
    void pwtset(int n);
    float pythag(float a, float b);
    void pzextr(int iest, float xest, float yest[], float yz[], float dy[],
        int nv);
    float qgaus(float (*func)(float), float a, float b);
    void qrdcmp(float **a, int n, float *c, float *d, int *sing);
    float qromb(float (*func)(float), float a, float b);
    float qromo(float (*func)(float), float a, float b,
        float (*choose)(float (*)(float), float, float, int));
    void qroot(float p[], int n, float *b, float *c, float eps);
    void qrsolv(float **a, int n, float c[], float d[], float b[]);
    void qrupdt(float **r, float **qt, int n, float u[], float v[]);
    float qsimp(float (*func)(float), float a, float b);
    float qtrap(float (*func)(float), float a, float b);
    float quad3d(float (*func)(float, float, float), float x1, float x2);
    void quadct(float x, float y, float xx[], float yy[], unsigned long nn,
        float *fa, float *fb, float *fc, float *fd);
    void quadmx(float **a, int n);
    void quadvl(float x, float y, float *fa, float *fb, float *fc, float *fd);
    float ran0(long *idum);
    float ran1(long *idum);
    float ran2(long *idum);
    float ran3(long *idum);
    float ran4(long *idum);
    void rank(unsigned long n, unsigned long indx[], unsigned long irank[]);
    void ranpt(float pt[], float regn[], int n);
    void ratint(float xa[], float ya[], int n, float x, float *y, float *dy);
    void ratlsq(double (*fn)(double), double a, double b, int mm, int kk,
        double cof[], double *dev);
    double ratval(double x, double cof[], int mm, int kk);
    float rc(float x, float y);
    float rd(float x, float y, float z);
    void realft(float data[], unsigned long n, int isign);
    void rebin(float rc, int nd, float r[], float xin[], float xi[]);
    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);
    void relax(double **u, double **rhs, int n);
    void relax2(double **u, double **rhs, int n);
    void resid(double **res, double **u, double **rhs, int n);
    float revcst(float x[], float y[], int iorder[], int ncity, int n[]);
    void reverse(int iorder[], int ncity, int n[]);
    float rf(float x, float y, float z);
    float rj(float x, float y, float z, float p);
    void rk4(float y[], float dydx[], int n, float x, float h, float yout[],
        void (*derivs)(float, float [], float []));
    void rkck(float y[], float dydx[], int n, float x, float h,
        float yout[], float yerr[], void (*derivs)(float, float [], float []));
    void rkdumb(float vstart[], int nvar, float x1, float x2, int nstep,
        void (*derivs)(float, float [], float []));
    void rkqs(float y[], float dydx[], int n, float *x,
        float htry, float eps, float yscal[], float *hdid, float *hnext,
        void (*derivs)(float, float [], float []));
    void rlft3(float ***data, float **speq, unsigned long nn1,
        unsigned long nn2, unsigned long nn3, int isign);
    float rofunc(float b);
    void rotate(float **r, float **qt, int n, int i, float a, float b);
    void rsolv(float **a, int n, float d[], float b[]);
    void rstrct(double **uc, double **uf, int nc);
    float rtbis(float (*func)(float), float x1, float x2, float xacc);
    float rtflsp(float (*func)(float), float x1, float x2, float xacc);
    float rtnewt(void (*funcd)(float, float *, float *), float x1, float x2,
        float xacc);
    float rtsafe(void (*funcd)(float, float *, float *), float x1, float x2,
        float xacc);
    float rtsec(float (*func)(float), float x1, float x2, float xacc);
    void rzextr(int iest, float xest, float yest[], float yz[], float dy[], int nv);
    void savgol(float c[], int np, int nl, int nr, int ld, int m);
    void score(float xf, float y[], float f[]);
    void scrsho(float (*fx)(float));
    float select(unsigned long k, unsigned long n, float arr[]);
    float selip(unsigned long k, unsigned long n, float arr[]);
    void shell(unsigned long n, float a[]);
    void shoot(int n, float v[], float f[]);
    void shootf(int n, float v[], float f[]);
    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 simpr(float y[], float dydx[], float dfdx[], float **dfdy,
        int n, float xs, float htot, int nstep, float yout[],
        void (*derivs)(float, float [], float []));
    void sinft(float y[], int n);
    void slvsm2(double **u, double **rhs);
    void slvsml(double **u, double **rhs);
    void sncndn(float uu, float emmc, float *sn, float *cn, float *dn);
    double snrm(unsigned long n, double sx[], int itol);
    void sobseq(int *n, float x[]);
    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(unsigned long n, float arr[]);
    void sort2(unsigned long n, float arr[], float brr[]);
    void sort3(unsigned long n, float ra[], float rb[], float rc[]);
    void spctrm(FILE *fp, float p[], int m, int k, int ovrlap);
    void spear(float data1[], float data2[], unsigned long n, float *d, float *zd,
        float *probd, float *rs, float *probrs);
    void sphbes(int n, float x, float *sj, float *sy, float *sjp, float *syp);
    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 spread(float y, float yy[], unsigned long n, float x, int m);
    void sprsax(float sa[], unsigned long ija[], float x[], float b[],
        unsigned long n);
    void sprsin(float **a, int n, float thresh, unsigned long nmax, float sa[],
        unsigned long ija[]);
    void sprspm(float sa[], unsigned long ija[], float sb[], unsigned long ijb[],
        float sc[], unsigned long ijc[]);
    void sprstm(float sa[], unsigned long ija[], float sb[], unsigned long ijb[],
        float thresh, unsigned long nmax, float sc[], unsigned long ijc[]);
    void sprstp(float sa[], unsigned long ija[], float sb[], unsigned long ijb[]);
    void sprstx(float sa[], unsigned long ija[], float x[], float b[],
        unsigned long n);
    void stifbs(float y[], float dydx[], int nv, float *xx,
        float htry, float eps, float yscal[], float *hdid, float *hnext,
        void (*derivs)(float, float [], float []));
    void stiff(float y[], float dydx[], int n, float *x,
        float htry, float eps, float yscal[], float *hdid, float *hnext,
        void (*derivs)(float, float [], float []));
    void stoerm(float y[], float d2y[], int nv, float xs,
        float htot, int nstep, float yout[],
        void (*derivs)(float, float [], float []));
    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 svdfit(float x[], float y[], float sig[], int ndata, float a[],
        int ma, float **u, float **v, float w[], float *chisq,
        void (*funcs)(float, float [], int));
    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[], unsigned long n, float *t, float *prob);
    void tqli(float d[], float e[], int n, float **z);
    float trapzd(float (*func)(float), float a, float b, int n);
    void tred2(float **a, int n, float d[], float e[]);
    void tridag(float a[], float b[], float c[], float r[], float u[],
        unsigned long n);
    float trncst(float x[], float y[], int iorder[], int ncity, int n[]);
    void trnspt(int iorder[], int ncity, int n[]);
    void ttest(float data1[], unsigned long n1, float data2[], unsigned long n2,
        float *t, float *prob);
    void tutest(float data1[], unsigned long n1, float data2[], unsigned long n2,
        float *t, float *prob);
    void twofft(float data1[], float data2[], float fft1[], float fft2[],
        unsigned long n);
    void vander(double x[], double w[], double q[], int n);
    void vegas(float regn[], int ndim, float (*fxn)(float [], float), int init,
        unsigned long ncall, int itmx, int nprn, float *tgral, float *sd,
        float *chi2a);
    void voltra(int n, int m, float t0, float h, float *t, float **f,
        float (*g)(int, float), float (*ak)(int, int, float, float));
    void wt1(float a[], unsigned long n, int isign,
        void (*wtstep)(float [], unsigned long, int));
    void wtn(float a[], unsigned long nn[], int ndim, int isign,
        void (*wtstep)(float [], unsigned long, int));
    void wwghts(float wghts[], int n, float h,
        void (*kermom)(double [], double ,int));
    int zbrac(float (*func)(float), float *x1, float *x2);
    void zbrak(float (*fx)(float), float x1, float x2, int n, float xb1[],
        float xb2[], int *nb);
    float zbrent(float (*func)(float), float x1, float x2, float tol);
    void zrhqr(float a[], int m, float rtr[], float rti[]);
    float zriddr(float (*func)(float), float x1, float x2, float xacc);
    void zroots(fcomplex a[], int m, fcomplex roots[], int polish);

    #else /* ANSI */
    /* traditional - K&R */

    void addint();
    void airy();
    void amebsa();
    void amoeba();
    float amotry();
    float amotsa();
    void anneal();
    double anorm2();
    void arcmak();
    void arcode();
    void arcsum();
    void asolve();
    void atimes();
    void avevar();
    void balanc();
    void banbks();
    void bandec();
    void banmul();
    void bcucof();
    void bcuint();
    void beschb();
    float bessi();
    float bessi0();
    float bessi1();
    void bessik();
    float bessj();
    float bessj0();
    float bessj1();
    void bessjy();
    float bessk();
    float bessk0();
    float bessk1();
    float bessy();
    float bessy0();
    float bessy1();
    float beta();
    float betacf();
    float betai();
    float bico();
    void bksub();
    float bnldev();
    float brent();
    void broydn();
    void bsstep();
    void caldat();
    void chder();
    float chebev();
    void chebft();
    void chebpc();
    void chint();
    float chixy();
    void choldc();
    void cholsl();
    void chsone();
    void chstwo();
    void cisi();
    void cntab1();
    void cntab2();
    void convlv();
    void copy();
    void correl();
    void cosft();
    void cosft1();
    void cosft2();
    void covsrt();
    void crank();
    void cyclic();
    void daub4();
    float dawson();
    float dbrent();
    void ddpoly();
    int decchk();
    void derivs();
    float df1dim();
    void dfour1();
    void dfpmin();
    float dfridr();
    void dftcor();
    void dftint();
    void difeq();
    void dlinmin();
    double dpythag();
    void drealft();
    void dsprsax();
    void dsprstx();
    void dsvbksb();
    void dsvdcmp();
    void eclass();
    void eclazz();
    float ei();
    void eigsrt();
    float elle();
    float ellf();
    float ellpi();
    void elmhes();
    float erfcc();
    float erff();
    float erffc();
    void eulsum();
    float evlmem();
    float expdev();
    float expint();
    float f1();
    float f1dim();
    float f2();
    float f3();
    float factln();
    float factrl();
    void fasper();
    void fdjac();
    void fgauss();
    void fill0();
    void fit();
    void fitexy();
    void fixrts();
    void fleg();
    void flmoon();
    float fmin();
    void four1();
    void fourew();
    void fourfs();
    void fourn();
    void fpoly();
    void fred2();
    float fredin();
    void frenel();
    void frprmn();
    void ftest();
    float gamdev();
    float gammln();
    float gammp();
    float gammq();
    float gasdev();
    void gaucof();
    void gauher();
    void gaujac();
    void gaulag();
    void gauleg();
    void gaussj();
    void gcf();
    float golden();
    void gser();
    void hpsel();
    void hpsort();
    void hqr();
    void hufapp();
    void hufdec();
    void hufenc();
    void hufmak();
    void hunt();
    void hypdrv();
    fcomplex hypgeo();
    void hypser();
    unsigned short icrc();
    unsigned short icrc1();
    unsigned long igray();
    void iindexx();
    void indexx();
    void interp();
    int irbit1();
    int irbit2();
    void jacobi();
    void jacobn();
    long julday();
    void kendl1();
    void kendl2();
    void kermom();
    void ks2d1s();
    void ks2d2s();
    void ksone();
    void kstwo();
    void laguer();
    void lfit();
    void linbcg();
    void linmin();
    void lnsrch();
    void load();
    void load1();
    void load2();
    void locate();
    void lop();
    void lubksb();
    void ludcmp();
    void machar();
    void matadd();
    void matsub();
    void medfit();
    void memcof();
    int metrop();
    void mgfas();
    void mglin();
    float midexp();
    float midinf();
    float midpnt();
    float midsql();
    float midsqu();
    void miser();
    void mmid();
    void mnbrak();
    void mnewt();
    void moment();
    void mp2dfr();
    void mpadd();
    void mpdiv();
    void mpinv();
    void mplsh();
    void mpmov();
    void mpmul();
    void mpneg();
    void mppi();
    void mprove();
    void mpsad();
    void mpsdv();
    void mpsmu();
    void mpsqrt();
    void mpsub();
    void mrqcof();
    void mrqmin();
    void newt();
    void odeint();
    void orthog();
    void pade();
    void pccheb();
    void pcshft();
    void pearsn();
    void period();
    void piksr2();
    void piksrt();
    void pinvs();
    float plgndr();
    float poidev();
    void polcoe();
    void polcof();
    void poldiv();
    void polin2();
    void polint();
    void powell();
    void predic();
    float probks();
    void psdes();
    void pwt();
    void pwtset();
    float pythag();
    void pzextr();
    float qgaus();
    void qrdcmp();
    float qromb();
    float qromo();
    void qroot();
    void qrsolv();
    void qrupdt();
    float qsimp();
    float qtrap();
    float quad3d();
    void quadct();
    void quadmx();
    void quadvl();
    float ran0();
    float ran1();
    float ran2();
    float ran3();
    float ran4();
    void rank();
    void ranpt();
    void ratint();
    void ratlsq();
    double ratval();
    float rc();
    float rd();
    void realft();
    void rebin();
    void red();
    void relax();
    void relax2();
    void resid();
    float revcst();
    void reverse();
    float rf();
    float rj();
    void rk4();
    void rkck();
    void rkdumb();
    void rkqs();
    void rlft3();
    float rofunc();
    void rotate();
    void rsolv();
    void rstrct();
    float rtbis();
    float rtflsp();
    float rtnewt();
    float rtsafe();
    float rtsec();
    void rzextr();
    void savgol();
    void score();
    void scrsho();
    float select();
    float selip();
    void shell();
    void shoot();
    void shootf();
    void simp1();
    void simp2();
    void simp3();
    void simplx();
    void simpr();
    void sinft();
    void slvsm2();
    void slvsml();
    void sncndn();
    double snrm();
    void sobseq();
    void solvde();
    void sor();
    void sort();
    void sort2();
    void sort3();
    void spctrm();
    void spear();
    void sphbes();
    void splie2();
    void splin2();
    void spline();
    void splint();
    void spread();
    void sprsax();
    void sprsin();
    void sprspm();
    void sprstm();
    void sprstp();
    void sprstx();
    void stifbs();
    void stiff();
    void stoerm();
    void svbksb();
    void svdcmp();
    void svdfit();
    void svdvar();
    void toeplz();
    void tptest();
    void tqli();
    float trapzd();
    void tred2();
    void tridag();
    float trncst();
    void trnspt();
    void ttest();
    void tutest();
    void twofft();
    void vander();
    void vegas();
    void voltra();
    void wt1();
    void wtn();
    void wwghts();
    int zbrac();
    void zbrak();
    float zbrent();
    void zrhqr();
    float zriddr();
    void zroots();

    #endif /* ANSI */

    #endif /* _NR_H_ */