util.h

#ifndef Util_H
#define Util_H

#include "defs.h"
#include <math.h>
#include <stdexcept>
#include <vector>
#include <ctime>

using std::vector;
using std::string;

typedef unsigned char _uint8;


void printClusters(int* clusters, int dimL, int dimC){

   for( int i = 1; i <= dimL; i++) {
     for (int j = 1; j <= dimC; j++)
       printf("%i ",clusters[(j - 1)*dimL + i]);
     printf("\n");
   }
}

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];
        sprintf(buffer,"%d",i);
        //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 ) {
_uint8 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;
                        };
        };
};



//included by marcio
Value_Type manhattan(const Value_Type* v1, const Value_Type* v2, const int& dimension) {
  
  register Value_Type sum = 0;

  for(register int i  = 0 ; i < dimension ; i++) 
    sum += fabs(v1[i] - v2[i]); //warning, estava sendo usada a funcao abs, que retornava um int e n um float. perda de precisao

  return sum;

};



//included by marcio
Value_Type euclideanDistance(const Value_Type* v1, const Value_Type* v2, const int& dimension) {
  
  register Value_Type sum = 0;
  register Value_Type diff;


  for(register int i  = 0 ; i < dimension ; i++) {
    diff = v1[i] - v2[i];
    sum += diff * diff;
  }

  return sqrt(sum);
}



//included by marcio
void randomVector(Value_Type* vec, const int& dimension) {

  // Set initial seed
  srand( (unsigned)time( NULL ) );

  for(register int i = 0 ; i < dimension ; i++) 
    vec[i] = rand() / (RAND_MAX + 1.0);
};



//included by marcio
void zeroVector(Value_Type* vec, const int& dimension) {

  for(register int i = 0 ; i < dimension ; i++) 
    vec[i] = 0.0;
};



//included by marcio
void sumVectors(Value_Type* v1, const Value_Type* v2, const int& dimension) {
  
  for(register int i  = 0 ; i < dimension ; i++) 
    v1[i] += v2[i];

};



//included by marcio
void subtractVectors(Value_Type* v1, const Value_Type* v2, const int& dimension) {
  
  for(register int i  = 0 ; i < dimension ; i++) 
    v1[i] -= v2[i];

};



//included by marcio
void multiplyVector(Value_Type* vec, const Value_Type value, const int& dimension) {
  
  for(register int i  = 0 ; i < dimension ; i++) 
    vec[i] = value * vec[i];

};



//included by marcio
void copyVectors(Value_Type* dest, const Value_Type* source, const int& dimension) {
  
  for(register int i  = 0 ; i < dimension ; i++) 
    dest[i] = source[i];

};



template<class T>
void insertVector(vector<T>& dst, vector<T> src) {
  
  int size = src.size();

  for(register int i = 0 ; i < size ; i++)
    dst.push_back(src[i]);

};

string rem_id(string label)
{
string result = "" ;
for (int i = 2 ; i<label.length(); i++ )
        result += label[i];
return result ;
}

#endif

---