891 lines
31 KiB
C
891 lines
31 KiB
C
#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 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(float d[], float **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(float **a, int n, float d[], float **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 m, int n, int *ip, int kp);
|
|
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_ */
|