---

util.h

#ifndef Util_H
#define Util_H

#include "defs.h"
#include <math.h>

void printmatrix( TMatrix m, int li, int lf, int ci, int cf ) {
   int i, j;
   for (i=li; i<=lf; i++) { 
           printf("\n");
           for (j=ci; j<=cf; j++) printf(" %4.5f ", m[i][j]);
   };
   printf("\n");

};


Value_Type *create_vector( long nl, long nh )
/* allocate a Value_Type vector with subscript range v[nl..nh] */
{
        Value_Type *v;
        v = (Value_Type *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(Value_Type)));
        if (!v) printf( "allocation failure in vector()");
        return v-nl+NR_END;
};


int *create_intvector( long nl, long nh )
/* allocate a Value_Type vector with subscript range v[nl..nh] */
{
        int *v;
        v = (int *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(int)));
        if (!v) printf( "allocation failure in vector()");
        return v-nl+NR_END;
};


void free_vector( Value_Type *v, long nl, long nh )
/* free a Value_Type vector allocated with vector() */
{
        free((FREE_ARG)(v+nl-NR_END));
};

void free_intvector( int *v, long nl, long nh )
/* free a Value_Type vector allocated with vector() */
{
        free((FREE_ARG)(v+nl-NR_END));
};


Value_Type **create_matrix( long nrl, long nrh, long ncl, long nch ) {
        long i, nrow=nrh-nrl+1, ncol=nch-ncl+1;
        Value_Type **m;

        /* allocate pointers to rows */
        m = (Value_Type**) malloc((size_t) ((nrow+NR_END)*sizeof(Value_Type*)));

        if (!m) { exit(1); };
        m += NR_END;
        m -= nrl;

        /* allocate rows an set pointers to them */
        m[nrl] = (Value_Type*) malloc((size_t) ((nrow*ncol+NR_END)*sizeof(Value_Type)));
        if (!m[nrl]) { exit(1); };

        m[nrl] += NR_END;
        m[nrl] -= ncl;
    
        for (i=nrl+1; i<=nrh; i++) m[i]=m[i-1]+ncol;

        /* return ponter to array of pointers to rows */


        return m;
    
};


void free_matrix( Value_Type **m, long nrl, long nrh, long ncl, long nch )
/* free a Value_Type matrix allocated by matrix() */
{
        free((FREE_ARG) (m[nrl]+ncl-NR_END));
        free((FREE_ARG) (m+nrl-NR_END));
};

int strtoint( const string str ) 
{       
        return atoi(str.c_str());
}

float strtofloat( const string str ) 
{
        return atof( str.c_str() );
}


string inttostr( int i ) 
{
        char buffer[5];
        itoa( i, buffer, 10 );
        return buffer;
}

string flttostr( Value_Type f ) 
{
        string str;
        char *buffer;
        int precision = 5;
        int decimal, sign;
        
        buffer = fcvt (f, precision, &decimal, &sign);

        str = sign?'-':'+';
        str += buffer[0];
        str += '.';
        str += buffer+1;
        str += 'e';
        str += inttostr( decimal - 1 );

        return str;
}


bool isNumeric( const string str ) 
{       
    string alpha( "_abcdefghikjlmnopqrstuvxwyzABCDEFGHKIJLMNOPQRSTUVWXZ" );
        if (strchr( alpha.c_str(), str[0]) == NULL) 
                return true; 
        else 
                return false;   
}

bool isValid( string str ) {
unsigned _int8 num;
int i;

        if ( str == "#" )
                return false;

        if ( str.empty() )
                return false;

        for (i=0; i< str.length(); i++ )
                if ( (num = str[i]) == 205 )
                        return false;

    return true;
}

string inttolattice( int i ) {
        switch(i) {
        case 1 : return HEXA_STR; break;
        case 2 : return RECT_STR; break;
        default: return UNKNOWN; 
        }
}


string inttoneigh( int i ) {
        switch(i) {
        case 1 : return GAUSSIAN_STR;  break;
        case 2 : return BUBBLE_STR;    break;
        case 3 : return CUTGAUSS_STR;  break;
        case 4 : return EP_STR;            break;
        default: return UNKNOWN;
        }
}

Value_Type dist( Value_Type* vec1, Value_Type* vec2, int d ) {
        int i;
        Value_Type diff = 0.0;
        for (i=1; i<= d; i++)
                diff += (vec1[i] - vec2[i])*(vec1[i] - vec2[i]);
        return sqrt( diff );
};


void vec_sort( int d[], int s[], int n )
/* Given the eigenvalues d[1..n] and eigenvectors v[1..n][1..n] as output from
   jacobi, this routine sorts the eigenvalues into descendenting order, and 
   rearranges the columns of v correspondingly. */
{
        int k, j, i;
        int p, q;

        for (i=1; i<n; i++) {
                p = d[k=i];
                for (j=i+1; j<=n; j++ )
                        if ( d[j] >= p) p = d[k=j];
                        if (k != i ) {
                                d[k] = d[i];
                                d[i] = p;       
                            q = s[i];
                                s[i] = s[k];
                                s[k] = q;
                        };
        };
};

#endif

---