#1
  1. No Profile Picture
    Registered User
    Devshed Newbie (0 - 499 posts)

    Join Date
    Sep 2012
    Posts
    4
    Rep Power
    0

    Problem in compilation


    Hello.
    I'm getting a problem in compilating a "Numerical Recipes" C program.
    The compilation error is:
    C:\Users\COMPUTER_NAME\AppData\Local\Temp\ccghPw6W.o:jacobi.C:(.text+0x16): undefined reference to `vector(long, long)'
    C:\Users\COMPUTER_NAME\AppData\Local\Temp\ccghPw6W.o:jacobi.C:(.text+0x2c): undefined reference to `vector(long, long)'
    C:\Users\COMPUTER_NAME\AppData\Local\Temp\ccghPw6W.o:jacobi.C:(.text+0x189): undefined reference to `free_vector(float*, long, long)'
    C:\Users\COMPUTER_NAME\AppData\Local\Temp\ccghPw6W.o:jacobi.C:(.text+0x1a3): undefined reference to `free_vector(float*, long, long)'
    c:/mingw/bin/../lib/gcc/mingw32/4.6.2/../../../libmingw32.a(main.o): In function `main':
    C:\MinGW\msys\1.0\src\mingwrt/../mingw/main.c:73: undefined reference to `WinMain@16'
    collect2: ld returned 1 exit status
    Compilation failed.


    I'm using MingW compilator on windows 7 and:
    gcc -Wall -o jacobi jacobi.C

    The codes are:

    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_ */
    Regards.
  2. #2
  3. Contributing User
    Devshed Demi-God (4500 - 4999 posts)

    Join Date
    Aug 2011
    Posts
    4,709
    Rep Power
    480
    Without testing (my initial tests almost always fail...) I'd say you're missing the nrutil library. In other words, I expect you can make the object file:

    gcc -Wall -o jacobi.o jacobi.C


    And you can also

    gcc -Wall -o jacobi jacobi.C nrutil.c -lm


    something like that. Anyway, the link step is failing. Compilation's working fine. If you already have compiled nrutil into an object use that, or a library use that, your names might be system dependent. When I had to use windows I installed cygwin/x making the system look a lot like unix.

    I'd expect you can find the nrutils source on the internet, rather than have me rewrite their (dumb) vector allocation and freeing routines.
    [code]Code tags[/code] are essential for python code and Makefiles!
  4. #3
  5. Contributing User

    Join Date
    Aug 2003
    Location
    UK
    Posts
    5,074
    Rep Power
    1802
    What b49P23TIvg says - you need to link nrutil.

    However you may in fact be doing that (posting the complete build log including the invoking command line would help diagnosis), but you have made the mistake of naming your files with the extension .C rather than .c; gcc assumes that such files are C++ sources. If the code were compiled as C++, but nrutil were compiled as C code without a suitable extern"C" declaration in the header, the code would not successfully link.

    So rename your files with the conventional lower-case .c extension to ensure C compilation.

    You can tell that this code has been compiled as C++ because the function signatures in the error messages include the parameter types - C compilation does not retain that information since it is only required for C++ function overloading.

    Also jacobi.c on its own is not a complete program; you have not linked any object file containing a main() function.

    If you actually intended to compile as C++ I would suggest the rather more obvious .cpp, and you would either have to modify nrutil.h to make it C++ compatable:

    Code:
    #if defined __cplusplus
    extern "C"
    {
    #endif
    
      // ...header content here
    
    #if defined __cplusplus
    }
    #endif
    or simply wrap the inclusion:
    Code:
    extern "C"
    {
        #include "nrutil.h"
    }
    Last edited by clifford; September 1st, 2012 at 08:49 AM.
  6. #4
  7. No Profile Picture
    Registered User
    Devshed Newbie (0 - 499 posts)

    Join Date
    Sep 2012
    Posts
    4
    Rep Power
    0
    Thanks for the unswers. Excuse my lack of knowledge, but what is the procedure to link nrutil ?

    Originally Posted by b49P23TIvg
    Without testing..
    Originally Posted by clifford
    What b49P23TIvg says - you need to link nrutil.

    However you may in fact be doing that (posting the complete build log including the invoking command line would help diagnosis), but you have made the mistake of naming your files with the extension .C rather than .c; gcc assumes that such files are C++ sources. If the code were compiled as C++, but nrutil were compiled as C code without a suitable extern"C" declaration in the header, the code would not successfully link.

    So rename your files with the conventional lower-case .c extension to ensure C compilation.

    You can tell that this code has been compiled as C++ because the function signatures in the error messages include the parameter types - C compilation does not retain that information since it is only required for C++ function overloading.

    Also jacobi.c on its own is not a complete program; you have not linked any object file containing a main() function.
  8. #5
  9. Contributing User

    Join Date
    Aug 2003
    Location
    UK
    Posts
    5,074
    Rep Power
    1802
    Originally Posted by mvww
    what is the procedure to link nrutil ?
    You can invoke the linker through gcc as suggested by b49P23TIvg or you can compile each module separately and invoke the linker directly (ld,exe).

    However the exact procedure will depend on whether you have nrutil as a library file (libnrutil.a would be the most likley name for such a file), or as source, or as an object file (nrutil.o perhaps). It is possible that the nrutil library comprises of multiple sources; you need to tell us exactly what you have in order to get a precise answer, but your best bet is to figure it out for yourself from the compiler/linker documentation in order that understand how it works so you can generalise for other projects.

    The documentation for gcc is at http://gcc.gnu.org/onlinedocs/ while the linker is documented at http://sourceware.org/binutils/docs-2.22/

    For simple builds you need not know too much about the linker since it can be driven from gcc. Here are some very terse but simple notes on the basics; most material I found on this was either inaccurate, C++ specific, or over complicated, this is less bad that most of what I found!

    You can automate the whole process including generating makefiles suitable for larger projects by using an IDE such as Eclipse for C/C++, Code::Blocks or MinGW Developer Studio. Of these I's recommend Code::Blocks - Eclipse is too heavyweight and unconventional for my liking, and MinGW Devloper Studio appears to be struggling to be maintained - being modelled on VC 6.0 makes it a bit old fashioned too! Avoid Dev-C++, it has not been maintained since 2005 and its debugger sucks.

    If you do not specifically need to use MinGW/GCC you might also consider Visual C++ 2010 Express Edition - this is a very capable IDE and compiler with the best debugger available. Despite its name is entirely capable of compiling C code, albeit with incomplete C99 support; Numerical Recipes in C is old enough however not to need C99 support.

    Note if you reply to this there really is no need to re-quote the entirety of this message - only quote parts you are directly referring to.
    Last edited by clifford; September 1st, 2012 at 09:30 AM.
  10. #6
  11. No Profile Picture
    Registered User
    Devshed Newbie (0 - 499 posts)

    Join Date
    Sep 2012
    Posts
    4
    Rep Power
    0
    Originally Posted by b49P23TIvg
    In other words, I expect you can make the object file:

    gcc -Wall -o jacobi.o jacobi.c
    I got the same error when i use this command:
    (now using "c" instead "C")
    Code:
    C:\Users\mvww\AppData\Local\Temp\ccgiP5L5.o:jacobii.c:(.text+0x16): undefined reference to `vector'
    C:\Users\mvww\AppData\Local\Temp\ccgiP5L5.o:jacobii.c:(.text+0x2c): undefined reference to `vector'
    C:\Users\mvww\AppData\Local\Temp\ccgiP5L5.o:jacobii.c:(.text+0x170): undefined reference to `free_vector'
    C:\Users\mvww\AppData\Local\Temp\ccgiP5L5.o:jacobii.c:(.text+0x18a): undefined reference to `free_vector'
    c:/mingw/bin/../lib/gcc/mingw32/4.6.2/../../../libmingw32.a(main.o): In function `main':
    C:\MinGW\msys\1.0\src\mingwrt/../mingw/main.c:73: undefined reference to `WinMain@16'
    collect2: ld returned 1 exit status
    Compilation failed.
  12. #7
  13. No Profile Picture
    Registered User
    Devshed Newbie (0 - 499 posts)

    Join Date
    Sep 2012
    Posts
    4
    Rep Power
    0
    Originally Posted by clifford
    you need to tell us exactly what you have in order to get a precise answer
    I have a file with the main function, main.c, and a file with the Numerical Recipes function, jacobi.c.
    In addition, I have 2 header files, that are standard for all Numerical Recipes routines: nrutil.h and nr.h.

    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_ */
    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)
  14. #8
  15. Contributing User
    Devshed Demi-God (4500 - 4999 posts)

    Join Date
    Aug 2011
    Posts
    4,709
    Rep Power
    480
    First, in your post 6 of this thread you did NOT use the command I showed. I can tell because the loader failed. Compilation only doesn't invoke the loader to link your program.

    second, you need nrutil.c which is here.
    [code]Code tags[/code] are essential for python code and Makefiles!

IMN logo majestic logo threadwatch logo seochat tools logo