OneDT.h

#ifndef OneDT_H
#define OneDT_H
#include "TopologyImp.h"


#include <string>
#include <iomanip.h>
#include <fstream.h>
#include <stdio.h>
#include <string>

#include "Som.h"
#include "defs.h"
#include "util.h"
#include "TopolParams.h"

class OneDT : public TopologyImp {
public:
        Value_Type distance(int bmu, int i, int dimensions[MaxDimension], int type);    

        int Coord( int pos, int axis, int dimensions[MaxDimension] );

        TMatrix LinInitCoords(int mapsize, int dimensions[MaxDimension]);

        TMatrix CreateDelta( int dimensions[MaxDimension], int lattice, int mapsize );

        Value_Type H( const Value_Type delta, Value_Type radius,  int neighboor );

        vector<int> getNeighbors( int i, int neighbor, int dimensions[]  );

        OneDT(const TopolParams& par):TopologyImp(par) {};
        
        void Save(TMatrix tsp_result , string nick , int number_of_neurons );   

        void OneDT::Order_Labels(Value_Type city_x , Value_Type city_y , TvecLabel& cities_labels , int begin_city , int end_city , TMatrix cities_xy) ;

        TMatrix OneDT::Extract_Path(TLabel neurons_labels , TMatrix cities , int number_of_neurons) ;
        


private:
        Value_Type hexa_dist(int bx, int by, int tx, int ty);

        Value_Type rect_dist(int bx, int by, int tx, int ty);
};

vector<int> OneDT::getNeighbors( int i, int neighbor, int dimensions[] ) {
  
        int L = dimensions[0] - 1;
        int C = dimensions[1] - 1;
        int y = Coord( i, 0, dimensions );
        int x = Coord( i, 1, dimensions );
        vector<int> neighbors;
        

        int last_node = dimensions[0]-1 ;
        int first_node = 0 ;  // <-- which is the initial index ?? 0 or 1 ??


        
        switch ( neighbor ) {
        
        case HEXA : {   if ( fmod( y, 2 ) != 0) {
  
                                if ( ( x - 1 >= 0 ) )
                                        neighbors.push_back( ( (x-1)*(L+1) +y +1 ) );
  
                                if ( (y + 1) <= L )
                                        neighbors.push_back(  (x)*(L+1) + y + 2 );
  
                                if ( ((x + 1) <= C ) && ((y + 1) <= L) )
                                        neighbors.push_back( ( (x+1)*(L+1) + y + 2) );
                                                
                                if ( (x + 1) <= C ) 
                                        neighbors.push_back(  ( (x+1)*(L+1) + y + 1) );
  
                                if ( ( (y - 1) >= 0 ) && ( x + 1 <= C ) )
                                        neighbors.push_back( ((x+1)*(L+1) + y ) );
  
                                if ( (y - 1) >= 0 )
                                        neighbors.push_back( ( (x)*(L+1)+y ) );
                        }
                        else {
  
                                if ( x - 1 >= 0)
                                        neighbors.push_back( (x-1)*(L+1) + y + 1 );
  
                                if ((x-1>=0) && (y+1 <= L))
                                        neighbors.push_back( (x-1)*(L+1) + y + 2 );

                                if ( y + 1 <= L )
                                        neighbors.push_back( x*(L+1) + y + 2 );
        
                                if ( x + 1 <= C )
                                        neighbors.push_back( (x+1)*(L+1) + y + 1 );

                                if ( y - 1 >= 0 )
                                        neighbors.push_back(  x*(L+1) + y );

                                if ((x-1 >= 0) && (y-1) >= 0)
                                        neighbors.push_back( (x-1)*(L+1) + y );
                        }
                        break;
                }
                
        case RECT : {   if ( (y - 1) >= 0 )
                                neighbors.push_back( ( (x-1)*L+y ) );
                
                        if ( ( x - 1 >= 0 ) )
                                neighbors.push_back( ( (x-2)*L +y +1 ) );

                        if ( (x + 1) <= C ) 
                                neighbors.push_back( ( x*L + y + 1) );

                        if ( (y + 1) <= L )
                                neighbors.push_back( (x-1)*L + y + 2 );
                        break;
                        }
                        

        case TORO : {
                // left neighbor on the toros
                if ( i != first_node )  // <--- Check the initial index of neurons on toros
                        {neighbors.push_back(i-1);}
                else
                        neighbors.push_back(last_node) ;
                // right neighbor on the toros
                if ( i != last_node )
                        {neighbors.push_back(i+1);}
                else
                        neighbors.push_back(first_node) ;

                break;
                }
        } // end of switch


        return neighbors;

};

Value_Type OneDT::H( const Value_Type delta, Value_Type radius, int neighboor ) {
                
        switch(neighboor) {
                case GAUSSIAN :         return exp( -delta*delta/2*radius*radius); break;
                                                        
                case BUBBLE :           if (delta <= radius ) 
                                                                return 1; 
                                                        else 
                                                                return 0;
                                                        break;
                case CUTGAUSS :         if (delta <= radius )
                                                                return exp( -delta*delta/2*radius*radius);
                                                        else
                                                                return 0;                                                       
                                                        break;
                case EP :                       if (delta <= radius )
                                                                return (1 - delta*delta/radius*radius);
                                                        else
                                                                return 0;                                                       
                                                        break;
                }       
        return 0;
};

TMatrix OneDT::CreateDelta(int dimensions[MaxDimension], int lattice, int mapsize ) {
        int i, j;
        TMatrix delta = create_matrix(1, mapsize, 1, mapsize);
        for (i=1; i<=mapsize ; i++) for (j=i; j<= mapsize; j++)  
                delta[i][j] = delta[j][i] = distance( i, j, dimensions, lattice );              
        return delta;
}

TMatrix OneDT::LinInitCoords(int mapsize, int dimensions[MaxDimension]) {
        int i,k;
        int dimension = 2; 
        TMatrix LinInitCoords = create_matrix(1,mapsize,1,dimension);
        TVector Max = create_vector(1,2);
        TVector Min = create_vector(1,2);

        for (i=1;i<=2;i++) {Max[i] = 0.0; Min[i] = 100000.0;};

        for (i=1;i<=mapsize;i++) {              
                LinInitCoords[i][1] = Coord(i, 2, dimensions );
                LinInitCoords[i][2] = Coord(i, 1, dimensions );
                if ( LinInitCoords[i][1] > Max[1] ) Max[1] = LinInitCoords[i][1];
                if ( LinInitCoords[i][2] > Max[2] ) Max[2] = LinInitCoords[i][2];
                if ( LinInitCoords[i][1] < Min[1] ) Min[1] = LinInitCoords[i][1];
                if ( LinInitCoords[i][2] < Min[2] ) Min[2] = LinInitCoords[i][2];
        }
        for (i=1;i<=mapsize;i++)
                for (k=1;k<=dimension;k++)
                        if (Max[k] > Min[k])
                                LinInitCoords[i][k] = ((LinInitCoords[i][k] - Min[k])/(Max[k] - Min[k]) - 0.5)*2.0;
                        else
                                LinInitCoords[i][k] = 0.0;
                
        return LinInitCoords;
};

int OneDT::Coord( int pos, int axis, int dimensions[MaxDimension] ) {
Value_Type x, y, tmp1, tmp2, N, M;

        N = dimensions[0];
        M = dimensions[1];

        tmp1 = pos % (int)N;
        tmp2 = floor(pos/(int)N);

        if (pos <= N) { x = 0; y = pos - 1; }
        else            
                if (tmp1 == 0) { y = N - 1; x = tmp2 - 1; }                             
                else {  y = tmp1 - 1;   x = tmp2; };

        if ( axis ==1 )
          return (int)x;//warning
        else
          return (int)y;//warning       
};

Value_Type OneDT::hexa_dist(int bx, int by, int tx, int ty){
  Value_Type ret, diff;

  diff = bx - tx;

  if (((by - ty) % 2) != 0) {
    if ((by % 2) == 0) {
      diff -= 0.5;
    }
    else {
      diff += 0.5;
    }
  }
  
  ret = diff * diff;
  diff = by - ty;
  ret += 0.75 * diff * diff;
  ret = (Value_Type) sqrt((Value_Type) ret);

  return(ret);
}

Value_Type OneDT::rect_dist(int bx, int by, int tx, int ty) {
  Value_Type ret, diff;

  diff = bx - tx;
  ret = diff * diff;
  diff = by - ty;
  ret += diff * diff;
  ret = (Value_Type) sqrt((Value_Type) ret);

  return(ret);
}

Value_Type OneDT::distance(int bmu, int i, int dimensions[MaxDimension], int type) {
        Value_Type x1, y1, x2, y2;
        
        x1 = Coord( bmu, 1, dimensions );
        y1 = Coord( bmu, 2, dimensions );
        x2 = Coord( i, 1, dimensions );
        y2 = Coord( i, 2, dimensions );
        if (type == HEXA) 
          return hexa_dist( (int)x1, (int)y1, (int)x2, (int)y2 );//warning
        else 
          return rect_dist( (int)x1, (int)y1, (int)x2, (int)y2 );//warning                      
};


void OneDT::Save( TMatrix tsp_result , string nick , int number_of_neurons ) {
        ofstream fout(nick.c_str()); // convert nick to the string used in c pure , and 
                                     // uses in function ofstream fout(c string);
        Value_Type ret, diff , dist = 0.0 ;
        int neurons = number_of_neurons ;
        cout << setiosflags(ios::fixed) << setprecision(2) ;
        fout << setiosflags(ios::fixed) << setprecision(2) ;
        for (int i = 1 ; i<neurons; i++)
                {
                fout << tsp_result[i][1] << " " << tsp_result[i][2] << "\n" ;
                dist += rect_dist((int)tsp_result[i][1],(int)tsp_result[i][2],(int)tsp_result[i+1][1],(int)tsp_result[i+1][2]);//warning
                }
        fout << tsp_result[neurons][1] << " " << tsp_result[neurons][2] << "\n" ;
        dist += rect_dist((int)tsp_result[neurons][1],(int)tsp_result[neurons][2],(int)tsp_result[1][1],(int)tsp_result[1][2]);//warning
        cout << nick << " -> length of the path : " << dist << "\n" ;
        fout << "% length of the path : " << dist << "\n" ;
        fout.close();
}



void OneDT::Order_Labels(Value_Type city_x , Value_Type city_y , TvecLabel& cities_labels , int begin_city , int end_city , TMatrix cities_xy) {
        TvecLabel new_order ;
        if (begin_city == end_city) {
        //end of recursive function
        } 
        else {
                Value_Type min = 999999 ;
                Value_Type min2 ;
                int nearest = begin_city ;
                if (city_x == city_y == -1){
                        city_x = cities_xy[strtoint(rem_id(cities_labels[begin_city]))][1] ;
                        city_y = cities_xy[strtoint(rem_id(cities_labels[begin_city]))][2] ;
                }
                for (int i = begin_city ; i <= end_city ; i++){
                  min2 = rect_dist( (int)city_x , (int)city_y , (int)cities_xy[strtoint(rem_id(cities_labels[i]))][1] , (int)cities_xy[strtoint(rem_id(cities_labels[i]))][2] );//warning
                        if (min2 < min) {
                                nearest = i ;
                                min = min2 ;
                                }
                        }
                Value_Type new_city_x = cities_xy[strtoint(rem_id(cities_labels[nearest]))][1];
                Value_Type new_city_y = cities_xy[strtoint(rem_id(cities_labels[nearest]))][2];
                string temp = cities_labels[begin_city] ;
                cities_labels[begin_city] = cities_labels[nearest] ;
                cities_labels[nearest] = temp ;
                begin_city++ ;
                Order_Labels(new_city_x , new_city_y , cities_labels , begin_city , end_city , cities_xy);
                }
}

TMatrix OneDT::Extract_Path(TLabel neurons_labels , TMatrix cities , int number_of_neurons) {
        int tsp_count = 1 ;       
        TMatrix result_path = create_matrix(1,number_of_neurons,1,2);
        Value_Type begin_x = -1 ;
        Value_Type begin_y = -1 ;                       
          for (int i = 0; i < neurons_labels.size() ; i++) {
             int number_of_labels = neurons_labels[i].size() ;
             if (number_of_labels > 1) { // neuron labeled to more than 1 city
                Order_Labels(begin_x , begin_y , neurons_labels[i] , 0 , neurons_labels[i].size()-1 , cities);
                for (int j = 0; j < neurons_labels[i].size(); j++){
                        //cout << tsp_count << ": " << cities[strtoint(rem_id(neurons_labels[i][j]))][1] ;
                        result_path[tsp_count][1] = cities[strtoint(rem_id(neurons_labels[i][j]))][1] ;
                        //cout << "," << cities[strtoint(rem_id(neurons_labels[i][j]))][2] << " " ;
                        result_path[tsp_count][2] = cities[strtoint(rem_id(neurons_labels[i][j]))][2] ;
                        //cout << "\n";
                        tsp_count++ ;
                }
             }
             else {
                  if (number_of_labels == 1) { // neuron labeled to more than 1 city
                  //cout << tsp_count << ": " << cities[strtoint(rem_id(neurons_labels[i][0]))][1] ;
                  result_path[tsp_count][1] = cities[strtoint(rem_id(neurons_labels[i][0]))][1] ;
                  //cout << "," << cities[strtoint(rem_id(neurons_labels[i][0]))][2] << " " ;
                  result_path[tsp_count][2] = cities[strtoint(rem_id(neurons_labels[i][0]))][2] ;
                  //cout << "\n";
                  begin_x = cities[strtoint(rem_id(neurons_labels[i][0]))][1] ;
                  begin_y = cities[strtoint(rem_id(neurons_labels[i][0]))][2] ;
                  tsp_count++ ;
                  }
             }

          }
        return result_path ;
};

#endif

---