apparently linker problem

This is a discussion on apparently linker problem within the C Programming forums, part of the General Programming Boards category; Hello. I'm trying to use a "Numerical Recipes in C" routine for the first time. I got a file with ...

  1. #1
    Registered User
    Join Date
    Sep 2012
    Posts
    3

    apparently linker problem

    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. #2
    Programming Wraith GReaper's Avatar
    Join Date
    Apr 2009
    Location
    Greece
    Posts
    1,624
    Where do you define all these functions in nrutil.h?
    Devoted my life to programming...

  3. #3
    Registered User
    Join Date
    Sep 2012
    Posts
    3
    Quote Originally Posted by GReaper View Post
    Where do you define all these functions in nrutil.h?
    In nrutil.h we have, for example,
    Code:
    void free_vector(float*v, longnl, longnh);
    Is that what you mean?

  4. #4
    Programming Wraith GReaper's Avatar
    Join Date
    Apr 2009
    Location
    Greece
    Posts
    1,624
    Well, in nrutil.h you declare/prototype the functions, you don't define them. Where do you provide the body of each of those?
    Devoted my life to programming...

  5. #5
    Registered User
    Join Date
    Sep 2012
    Posts
    3
    Quote Originally Posted by GReaper View Post
    Well, in nrutil.h you declare/prototype the functions, you don't define them. Where do you provide the body of each of those?
    I think I got it. It was missing me to link nrutil.c when compiling:
    Code:
    #if defined(__STDC__) || defined(ANSI) || defined(NRANSI) /* ANSI */#include <stdio.h>#include <stddef.h>#include <stdlib.h>#define NR_END 1#define FREE_ARG char*void nrerror(char error_text[])/* Numerical Recipes standard error handler */{	fprintf(stderr,"Numerical Recipes run-time error...\n");	fprintf(stderr,"%s\n",error_text);	fprintf(stderr,"...now exiting to system...\n");	exit(1);}float *vector(long nl, long nh)/* allocate a float vector with subscript range v[nl..nh] */{	float *v;	v=(float *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(float)));	if (!v) nrerror("allocation failure in vector()");	return v-nl+NR_END;}int *ivector(long nl, long nh)/* allocate an int vector with subscript range v[nl..nh] */{	int *v;	v=(int *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(int)));	if (!v) nrerror("allocation failure in ivector()");	return v-nl+NR_END;}unsigned char *cvector(long nl, long nh)/* allocate an unsigned char vector with subscript range v[nl..nh] */{	unsigned char *v;	v=(unsigned char *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(unsigned char)));	if (!v) nrerror("allocation failure in cvector()");	return v-nl+NR_END;}unsigned long *lvector(long nl, long nh)/* allocate an unsigned long vector with subscript range v[nl..nh] */{	unsigned long *v;	v=(unsigned long *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(long)));	if (!v) nrerror("allocation failure in lvector()");	return v-nl+NR_END;}double *dvector(long nl, long nh)/* allocate a double vector with subscript range v[nl..nh] */{	double *v;	v=(double *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(double)));	if (!v) nrerror("allocation failure in dvector()");	return v-nl+NR_END;}float **matrix(long nrl, long nrh, long ncl, long nch)/* allocate a float matrix with subscript range m[nrl..nrh][ncl..nch] */{	long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;	float **m;	/* allocate pointers to rows */	m=(float **) malloc((size_t)((nrow+NR_END)*sizeof(float*)));	if (!m) nrerror("allocation failure 1 in matrix()");	m += NR_END;	m -= nrl;	/* allocate rows and set pointers to them */	m[nrl]=(float *) malloc((size_t)((nrow*ncol+NR_END)*sizeof(float)));	if (!m[nrl]) nrerror("allocation failure 2 in matrix()");	m[nrl] += NR_END;	m[nrl] -= ncl;	for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;	/* return pointer to array of pointers to rows */	return m;}double **dmatrix(long nrl, long nrh, long ncl, long nch)/* allocate a double matrix with subscript range m[nrl..nrh][ncl..nch] */{	long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;	double **m;	/* allocate pointers to rows */	m=(double **) malloc((size_t)((nrow+NR_END)*sizeof(double*)));	if (!m) nrerror("allocation failure 1 in matrix()");	m += NR_END;	m -= nrl;	/* allocate rows and set pointers to them */	m[nrl]=(double *) malloc((size_t)((nrow*ncol+NR_END)*sizeof(double)));	if (!m[nrl]) nrerror("allocation failure 2 in matrix()");	m[nrl] += NR_END;	m[nrl] -= ncl;	for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;	/* return pointer to array of pointers to rows */	return m;}int **imatrix(long nrl, long nrh, long ncl, long nch)/* allocate a int matrix with subscript range m[nrl..nrh][ncl..nch] */{	long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;	int **m;	/* allocate pointers to rows */	m=(int **) malloc((size_t)((nrow+NR_END)*sizeof(int*)));	if (!m) nrerror("allocation failure 1 in matrix()");	m += NR_END;	m -= nrl;	/* allocate rows and set pointers to them */	m[nrl]=(int *) malloc((size_t)((nrow*ncol+NR_END)*sizeof(int)));	if (!m[nrl]) nrerror("allocation failure 2 in matrix()");	m[nrl] += NR_END;	m[nrl] -= ncl;	for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;	/* return pointer to array of pointers to rows */	return m;}float **submatrix(float **a, long oldrl, long oldrh, long oldcl, long oldch,	long newrl, long newcl)/* point a submatrix [newrl..][newcl..] to a[oldrl..oldrh][oldcl..oldch] */{	long i,j,nrow=oldrh-oldrl+1,ncol=oldcl-newcl;	float **m;	/* allocate array of pointers to rows */	m=(float **) malloc((size_t) ((nrow+NR_END)*sizeof(float*)));	if (!m) nrerror("allocation failure in submatrix()");	m += NR_END;	m -= newrl;	/* set pointers to rows */	for(i=oldrl,j=newrl;i<=oldrh;i++,j++) m[j]=a[i]+ncol;	/* return pointer to array of pointers to rows */	return m;}float **convert_matrix(float *a, long nrl, long nrh, long ncl, long nch)/* allocate a float matrix m[nrl..nrh][ncl..nch] that points to the matrixdeclared in the standard C manner as a[nrow][ncol], where nrow=nrh-nrl+1and ncol=nch-ncl+1. The routine should be called with the address&a[0][0] as the first argument. */{	long i,j,nrow=nrh-nrl+1,ncol=nch-ncl+1;	float **m;	/* allocate pointers to rows */	m=(float **) malloc((size_t) ((nrow+NR_END)*sizeof(float*)));	if (!m) nrerror("allocation failure in convert_matrix()");	m += NR_END;	m -= nrl;	/* set pointers to rows */	m[nrl]=a-ncl;	for(i=1,j=nrl+1;i<nrow;i++,j++) m[j]=m[j-1]+ncol;	/* return pointer to array of pointers to rows */	return m;}float ***f3tensor(long nrl, long nrh, long ncl, long nch, long ndl, long ndh)/* allocate a float 3tensor with range t[nrl..nrh][ncl..nch][ndl..ndh] */{	long i,j,nrow=nrh-nrl+1,ncol=nch-ncl+1,ndep=ndh-ndl+1;	float ***t;	/* allocate pointers to pointers to rows */	t=(float ***) malloc((size_t)((nrow+NR_END)*sizeof(float**)));	if (!t) nrerror("allocation failure 1 in f3tensor()");	t += NR_END;	t -= nrl;	/* allocate pointers to rows and set pointers to them */	t[nrl]=(float **) malloc((size_t)((nrow*ncol+NR_END)*sizeof(float*)));	if (!t[nrl]) nrerror("allocation failure 2 in f3tensor()");	t[nrl] += NR_END;	t[nrl] -= ncl;	/* allocate rows and set pointers to them */	t[nrl][ncl]=(float *) malloc((size_t)((nrow*ncol*ndep+NR_END)*sizeof(float)));	if (!t[nrl][ncl]) nrerror("allocation failure 3 in f3tensor()");	t[nrl][ncl] += NR_END;	t[nrl][ncl] -= ndl;	for(j=ncl+1;j<=nch;j++) t[nrl][j]=t[nrl][j-1]+ndep;	for(i=nrl+1;i<=nrh;i++) {		t[i]=t[i-1]+ncol;		t[i][ncl]=t[i-1][ncl]+ncol*ndep;		for(j=ncl+1;j<=nch;j++) t[i][j]=t[i][j-1]+ndep;	}	/* return pointer to array of pointers to rows */	return t;}void free_vector(float *v, long nl, long nh)/* free a float vector allocated with vector() */{	free((FREE_ARG) (v+nl-NR_END));}void free_ivector(int *v, long nl, long nh)/* free an int vector allocated with ivector() */{	free((FREE_ARG) (v+nl-NR_END));}void free_cvector(unsigned char *v, long nl, long nh)/* free an unsigned char vector allocated with cvector() */{	free((FREE_ARG) (v+nl-NR_END));}void free_lvector(unsigned long *v, long nl, long nh)/* free an unsigned long vector allocated with lvector() */{	free((FREE_ARG) (v+nl-NR_END));}void free_dvector(double *v, long nl, long nh)/* free a double vector allocated with dvector() */{	free((FREE_ARG) (v+nl-NR_END));}void free_matrix(float **m, long nrl, long nrh, long ncl, long nch)/* free a float matrix allocated by matrix() */{	free((FREE_ARG) (m[nrl]+ncl-NR_END));	free((FREE_ARG) (m+nrl-NR_END));}void free_dmatrix(double **m, long nrl, long nrh, long ncl, long nch)/* free a double matrix allocated by dmatrix() */{	free((FREE_ARG) (m[nrl]+ncl-NR_END));	free((FREE_ARG) (m+nrl-NR_END));}void free_imatrix(int **m, long nrl, long nrh, long ncl, long nch)/* free an int matrix allocated by imatrix() */{	free((FREE_ARG) (m[nrl]+ncl-NR_END));	free((FREE_ARG) (m+nrl-NR_END));}void free_submatrix(float **b, long nrl, long nrh, long ncl, long nch)/* free a submatrix allocated by submatrix() */{	free((FREE_ARG) (b+nrl-NR_END));}void free_convert_matrix(float **b, long nrl, long nrh, long ncl, long nch)/* free a matrix allocated by convert_matrix() */{	free((FREE_ARG) (b+nrl-NR_END));}void free_f3tensor(float ***t, long nrl, long nrh, long ncl, long nch,	long ndl, long ndh)/* free a float f3tensor allocated by f3tensor() */{	free((FREE_ARG) (t[nrl][ncl]+ndl-NR_END));	free((FREE_ARG) (t[nrl]+ncl-NR_END));	free((FREE_ARG) (t+nrl-NR_END));}#else /* ANSI *//* traditional - K&R */#include <stdio.h>#define NR_END 1#define FREE_ARG char*void nrerror(error_text)char error_text[];/* Numerical Recipes standard error handler */{	void exit();	fprintf(stderr,"Numerical Recipes run-time error...\n");	fprintf(stderr,"%s\n",error_text);	fprintf(stderr,"...now exiting to system...\n");	exit(1);}float *vector(nl,nh)long nh,nl;/* allocate a float vector with subscript range v[nl..nh] */{	float *v;	v=(float *)malloc((unsigned int) ((nh-nl+1+NR_END)*sizeof(float)));	if (!v) nrerror("allocation failure in vector()");	return v-nl+NR_END;}int *ivector(nl,nh)long nh,nl;/* allocate an int vector with subscript range v[nl..nh] */{	int *v;	v=(int *)malloc((unsigned int) ((nh-nl+1+NR_END)*sizeof(int)));	if (!v) nrerror("allocation failure in ivector()");	return v-nl+NR_END;}unsigned char *cvector(nl,nh)long nh,nl;/* allocate an unsigned char vector with subscript range v[nl..nh] */{	unsigned char *v;	v=(unsigned char *)malloc((unsigned int) ((nh-nl+1+NR_END)*sizeof(unsigned char)));	if (!v) nrerror("allocation failure in cvector()");	return v-nl+NR_END;}unsigned long *lvector(nl,nh)long nh,nl;/* allocate an unsigned long vector with subscript range v[nl..nh] */{	unsigned long *v;	v=(unsigned long *)malloc((unsigned int) ((nh-nl+1+NR_END)*sizeof(long)));	if (!v) nrerror("allocation failure in lvector()");	return v-nl+NR_END;}double *dvector(nl,nh)long nh,nl;/* allocate a double vector with subscript range v[nl..nh] */{	double *v;	v=(double *)malloc((unsigned int) ((nh-nl+1+NR_END)*sizeof(double)));	if (!v) nrerror("allocation failure in dvector()");	return v-nl+NR_END;}float **matrix(nrl,nrh,ncl,nch)long nch,ncl,nrh,nrl;/* allocate a float matrix with subscript range m[nrl..nrh][ncl..nch] */{	long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;	float **m;	/* allocate pointers to rows */	m=(float **) malloc((unsigned int)((nrow+NR_END)*sizeof(float*)));	if (!m) nrerror("allocation failure 1 in matrix()");	m += NR_END;	m -= nrl;	/* allocate rows and set pointers to them */	m[nrl]=(float *) malloc((unsigned int)((nrow*ncol+NR_END)*sizeof(float)));	if (!m[nrl]) nrerror("allocation failure 2 in matrix()");	m[nrl] += NR_END;	m[nrl] -= ncl;	for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;	/* return pointer to array of pointers to rows */	return m;}double **dmatrix(nrl,nrh,ncl,nch)long nch,ncl,nrh,nrl;/* allocate a double matrix with subscript range m[nrl..nrh][ncl..nch] */{	long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;	double **m;	/* allocate pointers to rows */	m=(double **) malloc((unsigned int)((nrow+NR_END)*sizeof(double*)));	if (!m) nrerror("allocation failure 1 in matrix()");	m += NR_END;	m -= nrl;	/* allocate rows and set pointers to them */	m[nrl]=(double *) malloc((unsigned int)((nrow*ncol+NR_END)*sizeof(double)));	if (!m[nrl]) nrerror("allocation failure 2 in matrix()");	m[nrl] += NR_END;	m[nrl] -= ncl;	for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;	/* return pointer to array of pointers to rows */	return m;}int **imatrix(nrl,nrh,ncl,nch)long nch,ncl,nrh,nrl;/* allocate a int matrix with subscript range m[nrl..nrh][ncl..nch] */{	long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;	int **m;	/* allocate pointers to rows */	m=(int **) malloc((unsigned int)((nrow+NR_END)*sizeof(int*)));	if (!m) nrerror("allocation failure 1 in matrix()");	m += NR_END;	m -= nrl;	/* allocate rows and set pointers to them */	m[nrl]=(int *) malloc((unsigned int)((nrow*ncol+NR_END)*sizeof(int)));	if (!m[nrl]) nrerror("allocation failure 2 in matrix()");	m[nrl] += NR_END;	m[nrl] -= ncl;	for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;	/* return pointer to array of pointers to rows */	return m;}float **submatrix(a,oldrl,oldrh,oldcl,oldch,newrl,newcl)float **a;long newcl,newrl,oldch,oldcl,oldrh,oldrl;/* point a submatrix [newrl..][newcl..] to a[oldrl..oldrh][oldcl..oldch] */{	long i,j,nrow=oldrh-oldrl+1,ncol=oldcl-newcl;	float **m;	/* allocate array of pointers to rows */	m=(float **) malloc((unsigned int) ((nrow+NR_END)*sizeof(float*)));	if (!m) nrerror("allocation failure in submatrix()");	m += NR_END;	m -= newrl;	/* set pointers to rows */	for(i=oldrl,j=newrl;i<=oldrh;i++,j++) m[j]=a[i]+ncol;	/* return pointer to array of pointers to rows */	return m;}float **convert_matrix(a,nrl,nrh,ncl,nch)float *a;long nch,ncl,nrh,nrl;/* allocate a float matrix m[nrl..nrh][ncl..nch] that points to the matrixdeclared in the standard C manner as a[nrow][ncol], where nrow=nrh-nrl+1and ncol=nch-ncl+1. The routine should be called with the address&a[0][0] as the first argument. */{	long i,j,nrow=nrh-nrl+1,ncol=nch-ncl+1;	float **m;	/* allocate pointers to rows */	m=(float **) malloc((unsigned int) ((nrow+NR_END)*sizeof(float*)));	if (!m)	nrerror("allocation failure in convert_matrix()");	m += NR_END;	m -= nrl;	/* set pointers to rows */	m[nrl]=a-ncl;	for(i=1,j=nrl+1;i<nrow;i++,j++) m[j]=m[j-1]+ncol;	/* return pointer to array of pointers to rows */	return m;}float ***f3tensor(nrl,nrh,ncl,nch,ndl,ndh)long nch,ncl,ndh,ndl,nrh,nrl;/* allocate a float 3tensor with range t[nrl..nrh][ncl..nch][ndl..ndh] */{	long i,j,nrow=nrh-nrl+1,ncol=nch-ncl+1,ndep=ndh-ndl+1;	float ***t;	/* allocate pointers to pointers to rows */	t=(float ***) malloc((unsigned int)((nrow+NR_END)*sizeof(float**)));	if (!t) nrerror("allocation failure 1 in f3tensor()");	t += NR_END;	t -= nrl;	/* allocate pointers to rows and set pointers to them */	t[nrl]=(float **) malloc((unsigned int)((nrow*ncol+NR_END)*sizeof(float*)));	if (!t[nrl]) nrerror("allocation failure 2 in f3tensor()");	t[nrl] += NR_END;	t[nrl] -= ncl;	/* allocate rows and set pointers to them */	t[nrl][ncl]=(float *) malloc((unsigned int)((nrow*ncol*ndep+NR_END)*sizeof(float)));	if (!t[nrl][ncl]) nrerror("allocation failure 3 in f3tensor()");	t[nrl][ncl] += NR_END;	t[nrl][ncl] -= ndl;	for(j=ncl+1;j<=nch;j++) t[nrl][j]=t[nrl][j-1]+ndep;	for(i=nrl+1;i<=nrh;i++) {		t[i]=t[i-1]+ncol;		t[i][ncl]=t[i-1][ncl]+ncol*ndep;		for(j=ncl+1;j<=nch;j++) t[i][j]=t[i][j-1]+ndep;	}	/* return pointer to array of pointers to rows */	return t;}void free_vector(v,nl,nh)float *v;long nh,nl;/* free a float vector allocated with vector() */{	free((FREE_ARG) (v+nl-NR_END));}void free_ivector(v,nl,nh)int *v;long nh,nl;/* free an int vector allocated with ivector() */{	free((FREE_ARG) (v+nl-NR_END));}void free_cvector(v,nl,nh)long nh,nl;unsigned char *v;/* free an unsigned char vector allocated with cvector() */{	free((FREE_ARG) (v+nl-NR_END));}void free_lvector(v,nl,nh)long nh,nl;unsigned long *v;/* free an unsigned long vector allocated with lvector() */{	free((FREE_ARG) (v+nl-NR_END));}void free_dvector(v,nl,nh)double *v;long nh,nl;/* free a double vector allocated with dvector() */{	free((FREE_ARG) (v+nl-NR_END));}void free_matrix(m,nrl,nrh,ncl,nch)float **m;long nch,ncl,nrh,nrl;/* free a float matrix allocated by matrix() */{	free((FREE_ARG) (m[nrl]+ncl-NR_END));	free((FREE_ARG) (m+nrl-NR_END));}void free_dmatrix(m,nrl,nrh,ncl,nch)double **m;long nch,ncl,nrh,nrl;/* free a double matrix allocated by dmatrix() */{	free((FREE_ARG) (m[nrl]+ncl-NR_END));	free((FREE_ARG) (m+nrl-NR_END));}void free_imatrix(m,nrl,nrh,ncl,nch)int **m;long nch,ncl,nrh,nrl;/* free an int matrix allocated by imatrix() */{	free((FREE_ARG) (m[nrl]+ncl-NR_END));	free((FREE_ARG) (m+nrl-NR_END));}void free_submatrix(b,nrl,nrh,ncl,nch)float **b;long nch,ncl,nrh,nrl;/* free a submatrix allocated by submatrix() */{	free((FREE_ARG) (b+nrl-NR_END));}void free_convert_matrix(b,nrl,nrh,ncl,nch)float **b;long nch,ncl,nrh,nrl;/* free a matrix allocated by convert_matrix() */{	free((FREE_ARG) (b+nrl-NR_END));}void free_f3tensor(t,nrl,nrh,ncl,nch,ndl,ndh)float ***t;long nch,ncl,ndh,ndl,nrh,nrl;/* free a float f3tensor allocated by f3tensor() */{	free((FREE_ARG) (t[nrl][ncl]+ndl-NR_END));	free((FREE_ARG) (t[nrl]+ncl-NR_END));	free((FREE_ARG) (t+nrl-NR_END));} #endif /* ANSI */
    It is where that functions are declared. Thanks.

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. Compilation problems ( apparently )
    By guro in forum C Programming
    Replies: 5
    Last Post: 10-11-2009, 04:59 AM
  2. VC++ 2005 /FC apparently not working
    By Mario F. in forum C++ Programming
    Replies: 2
    Last Post: 06-07-2006, 09:02 AM
  3. Conversion problem, apparently.
    By CSmith in forum C++ Programming
    Replies: 4
    Last Post: 03-09-2004, 01:44 PM
  4. Something about aggregate type, apparently.
    By Helix in forum C++ Programming
    Replies: 2
    Last Post: 08-02-2003, 02:39 PM
  5. lamborghini's are apparently childsplay
    By Shadow in forum A Brief History of Cprogramming.com
    Replies: 12
    Last Post: 11-26-2002, 02:41 PM

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21