1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.

probabily linker problem

Discussion in 'C' started by mvww, Sep 2, 2012.

  1. mvww

    mvww New Member

    Joined:
    Sep 2, 2012
    Messages:
    1
    Likes Received:
    0
    Trophy Points:
    0
    Hello.
    I'm trying to use a "Numerical Recipes in C" routine for the first time.


    I got a file with the main function, main.c, and a file with the routine I wanna use (Jacobi function) jacobi.c.
    In addition, I have 2 header files, that, for what I could see, are standard for all Numerical Recipes routines: nrutil.h and nr.h.


    Here the are the codes:




    main.c:
    Code:
    #include <stdio.h>
    #include "nr.h"
    #include "nrutil.h"
    
    
    int main(void)
    {
        int i, j, nrot;
    
    
        int n = 2;
        /*
           We need a Numerical Recipes-style "matrix" to use
           as an argument to call the jacobi function.
           Here are the matrix values stored in row-major
           order in a 1-D array. This array name will be used
           as an argument for the convert_matrix function.
         */
        float a_array[] = {
             5.0, -2.0, /* First  row */
            -2.0,  2.0  /* Second row */
        };
    
    
        float *d = vector(1, n);
        float *r = vector(1, n);
        float **v = matrix(1, n, 1, n);
        float **a = convert_matrix(&a_array[0], 1, n, 1, n);
    
    
        printf("Matrix:\n");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= n; j++) {
                printf("  %+13.6e", a[i][j]);
            }
            printf("\n");
        }
        printf("\n");
    
    
        jacobi(a, n, d, v, &nrot);
    
    
        printf("Eigenvalues:\n");
        for (i = 1; i <= n; i++) {
            printf("  Number %d:%+14.6e\n", i, d[i]);
        }
        printf("\n");
    
    
        printf("Eigenvectors:\n");
        for (i = 1; i <= n; i++) {
            printf("  Number %d:", i);
            for (j = 1; j <= n; j++) {
                printf("%+14.6e", v[j][i]);
            }
            printf("\n");
        }
        printf("\n");
    
    
        printf("Number of Jacobi rotations = %d\n", nrot);
    
    
        free_convert_matrix(a, 1, n, 1, n);
        free_matrix(v, 1, n, 1, n);
        free_vector(r, 1, n);
        free_vector(d, 1, n);
    
    
        return 0;
    }
    

    jacobi.c:
    Code:
    #include <math.h>
    #include "nrutil.h"
    #define ROTATE(a,i,j,k,l) g=a[i][j];h=a[k][l];a[i][j]=g-s*(h+g*tau);\
    a[k][l]=h+s*(g-h*tau);
    void jacobi(float **a, int n, float d[], float **v, int *nrot)
    {
    int j,iq,ip,i;
    float tresh,theta,tau,t,sm,s,h,g,c,*b,*z;
    b=vector(1,n);
    z=vector(1,n);
    for (ip=1;ip<=n;ip++) {
    for (iq=1;iq<=n;iq++) v[ip][iq]=0.0;
    v[ip][ip]=1.0;
    }
    for (ip=1;ip<=n;ip++) {
    b[ip]=d[ip]=a[ip][ip];
    z[ip]=0.0;
    }
    *nrot=0;
    for (i=1;i<=50;i++) {
    sm=0.0;
    for (ip=1;ip<=n-1;ip++) {
    for (iq=ip+1;iq<=n;iq++)
    sm += fabs(a[ip][iq]);
    }
    if (sm == 0.0) {
    free_vector(z,1,n);
    free_vector(b,1,n);
    return;
    }
    if (i < 4)
    tresh=0.2*sm/(n*n);
    else
    tresh=0.0;
    for (ip=1;ip<=n-1;ip++) {
    for (iq=ip+1;iq<=n;iq++) {
    g=100.0*fabs(a[ip][iq]);
    if (i > 4 && (float)(fabs(d[ip])+g) == (float)fabs(d[ip])
    && (float)(fabs(d[iq])+g) == (float)fabs(d[iq]))
    a[ip][iq]=0.0;
    else if (fabs(a[ip][iq]) > tresh) {
    h=d[iq]-d[ip];
    if ((float)(fabs(h)+g) == (float)fabs(h))
    t=(a[ip][iq])/h;
    else {
    theta=0.5*h/(a[ip][iq]);
    t=1.0/(fabs(theta)+sqrt(1.0+theta*theta));
    if (theta < 0.0) t = -t;
    }
    c=1.0/sqrt(1+t*t);
    s=t*c;
    tau=s/(1.0+c);
    h=t*a[ip][iq];
    z[ip] -= h;
    z[iq] += h;
    d[ip] -= h;
    d[iq] += h;
    a[ip][iq]=0.0;
    for (j=1;j<=ip-1;j++) {
    ROTATE(a,j,ip,j,iq)
    }
    for (j=ip+1;j<=iq-1;j++) {
    ROTATE(a,ip,j,j,iq)
    }
    for (j=iq+1;j<=n;j++) {
    ROTATE(a,ip,j,iq,j)
    }
    for (j=1;j<=n;j++) {
    ROTATE(v,j,ip,j,iq)
    }
    ++(*nrot);
    }
    }
    }
    for (ip=1;ip<=n;ip++) {
    b[ip] += z[ip];
    d[ip]=b[ip];
    z[ip]=0.0;
    }
    }
    /*nrerror("Too many iterations in routine jacobi");*/
    }
    
    nrutil.h:
    Code:
    #ifndef _NR_UTILS_H_
    #define _NR_UTILS_H_
    static float sqrarg;
    #define SQR(a) ((sqrarg=(a)) == 0.0 ? 0.0 : sqrarg*sqrarg)
    static double dsqrarg;
    #define DSQR(a) ((dsqrarg=(a)) == 0.0 ? 0.0 : dsqrarg*dsqrarg)
    static double dmaxarg1,dmaxarg2;
    #define DMAX(a,b) (dmaxarg1=(a),dmaxarg2=(b),(dmaxarg1) > (dmaxarg2) ?\
    (dmaxarg1) : (dmaxarg2))
    static double dminarg1,dminarg2;
    #define DMIN(a,b) (dminarg1=(a),dminarg2=(b),(dminarg1) < (dminarg2) ?\
    (dminarg1) : (dminarg2))
    static float maxarg1,maxarg2;
    #define FMAX(a,b) (maxarg1=(a),maxarg2=(b),(maxarg1) > (maxarg2) ?\
    (maxarg1) : (maxarg2))
    static float minarg1,minarg2;
    #define FMIN(a,b) (minarg1=(a),minarg2=(b),(minarg1) < (minarg2) ?\
    (minarg1) : (minarg2))
    static long lmaxarg1,lmaxarg2;
    #define LMAX(a,b) (lmaxarg1=(a),lmaxarg2=(b),(lmaxarg1) > (lmaxarg2) ?\
    (lmaxarg1) : (lmaxarg2))
    static long lminarg1,lminarg2;
    #define LMIN(a,b) (lminarg1=(a),lminarg2=(b),(lminarg1) < (lminarg2) ?\
    (lminarg1) : (lminarg2))
    static int imaxarg1,imaxarg2;
    #define IMAX(a,b) (imaxarg1=(a),imaxarg2=(b),(imaxarg1) > (imaxarg2) ?\
    (imaxarg1) : (imaxarg2))
    static int iminarg1,iminarg2;
    #define IMIN(a,b) (iminarg1=(a),iminarg2=(b),(iminarg1) < (iminarg2) ?\
    (iminarg1) : (iminarg2))
    #define SIGN(a,b) ((b) >= 0.0 ? fabs(a) : -fabs(a))
    #if defined(__STDC__) || defined(ANSI) || defined(NRANSI) /* ANSI */
    void nrerror(char error_text[]);
    float *vector(long nl, long nh);
    int *ivector(long nl, long nh);
    unsigned char *cvector(long nl, long nh);
    unsigned long *lvector(long nl, long nh);
    double *dvector(long nl, long nh);
    float **matrix(long nrl, long nrh, long ncl, long nch);
    double **dmatrix(long nrl, long nrh, long ncl, long nch);
    int **imatrix(long nrl, long nrh, long ncl, long nch);
    float **submatrix(float **a, long oldrl, long oldrh, long oldcl, long oldch,
    long newrl, long newcl);
    float **convert_matrix(float *a, long nrl, long nrh, long ncl, long nch);
    float ***f3tensor(long nrl, long nrh, long ncl, long nch, long ndl, long ndh);
    void free_vector(float *v, long nl, long nh);
    void free_ivector(int *v, long nl, long nh);
    void free_cvector(unsigned char *v, long nl, long nh);
    void free_lvector(unsigned long *v, long nl, long nh);
    void free_dvector(double *v, long nl, long nh);
    void free_matrix(float **m, long nrl, long nrh, long ncl, long nch);
    void free_dmatrix(double **m, long nrl, long nrh, long ncl, long nch);
    void free_imatrix(int **m, long nrl, long nrh, long ncl, long nch);
    void free_submatrix(float **b, long nrl, long nrh, long ncl, long nch);
    void free_convert_matrix(float **b, long nrl, long nrh, long ncl, long nch);
    void free_f3tensor(float ***t, long nrl, long nrh, long ncl, long nch,
    long ndl, long ndh);
    #else /* ANSI */
    /* traditional - K&R */
    void nrerror();
    float *vector();
    #endif /* ANSI */
    #endif /* _NR_UTILS_H_ */
    
    When I try to compile it (I use gcc 4.6 on Ubuntu) using the command "gcc -Wall -o jacobi.exe main.c jacobi.c", I get the following errors :

    Code:
    /tmp/cc7Pdf5a.o: In function `main':main.c:(.text+0x3d): undefined reference to `vector'
    main.c:(.text+0x53): undefined reference to `vector'
    main.c:(.text+0x77): undefined reference to `matrix'
    main.c:(.text+0xa0): undefined reference to `convert_matrix'
    main.c:(.text+0x26e): undefined reference to `free_convert_matrix'
    main.c:(.text+0x293): undefined reference to `free_matrix'
    main.c:(.text+0x2aa): undefined reference to `free_vector'
    main.c:(.text+0x2c1): undefined reference to `free_vector'
    /tmp/ccaDb4T8.o: In function `jacobi':
    jacobi.c:(.text+0x29): undefined reference to `vector'
    jacobi.c:(.text+0x3f): undefined reference to `vector'
    jacobi.c:(.text+0x1d1): undefined reference to `free_vector'
    jacobi.c:(.text+0x1e8): undefined reference to `free_vector'
    collect2: ld returned 1 exit status
    
    
    
    I was warned that it could be a linker problem. If it is the problem, how can I proceed?

    I'm sorry if I'm commiting a rookie mistake.
    Thanks in advance,
    mvww.

    PS:
    nr.h:
    Code:
    #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[]);
    ETC... (I achieved the maximum character number limit)
    
     
  2. hobbyist

    hobbyist New Member

    Joined:
    Jan 7, 2012
    Messages:
    141
    Likes Received:
    0
    Trophy Points:
    0
    I don't have access to linux, but I tried the code in VC Express. The "undefined reference" errors cleaned up after adding nrutil.c to the project, so you might try adding it when you compile your source.

    HTH
     

Share This Page