main_tsp.cpp

/*
        This example finds a solution for the travelling salesman problem by using a SOM network with one dimension. 

        This program takes as parameters:
                - the path to a data file;
                - the neighbor radius (given as a percentage);
                - the number of iterations;
                - the type of learning;
        
        ./somcode <file path> <neighbor radius> <numIte> <type of learning>

        Example of how to execute this program: ./somcode ./data/cities.txt 10 1000 batch

        This is just an example. The values of the parameters must be adjusted to each situation.
        
*/

#pragma warning(disable: 4786)

#include <cstdlib>
#include <iostream>
#include <vector>

//inclusion of the libraries from somcode needed to compile this example correctly

#include "Som.h"
#include "SOMDataCadastre.h"
#include "MapcodeCadastre.h"

#include "BatchFactory.h"
#include <string>


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

#include "RepositorySOMDataFile.h"

#include "OneDTFactory.h"
#include "OneDT.h"

#include "Data.h"  
#include "util.h"
#include "defs.h"


using std::cout;

//creates the object constructors from abstract factory pattern

static BatchFactory fact_batch("Batch");
static OneDTFactory fact_twoD("Two");


int main(int argc, char *argv[]) {

  try {         
          clock_t c0 = clock();
  

          std::vector<std::string> params;
          params.push_back(argv[1]);    

          //creates an object of the concrete class that implements the way to access data through file systems
          RepositorySOMDataFile repD;
          repD.load(params,0);

          //instantiates an object of the concrete class SOMDataCadastre, which is used to isolate data from storing details
          SOMDataCadastre cadD(repD);

          
          OneDT* tsp;


          cout << "Starting SOMCode-1.0 ...\n";

          //reads the file through the concrete class SOMDataCadastre
          SOMData* data = cadD.load( std::vector<std::string>() );

          clock_t c1 = clock();

          clock_t c2 = clock();

          SOM* mysom = new SOM();
          mysom->setData(data);


          int dimL, dimC, neig, iter; 
         
          dimL = data->getDataSize();   // neural network with number of neurons equal to the number
                                        // of entry cities
          dimC = 1;                     // due to it has only one dimension 
          neig = strtoint(argv[2]);
          iter = strtoint(argv[3]);

          mysom->getMapcode()->setNumVar( mysom->getData()->getDimension() );
          mysom->getMapcode()->setDimensions( 0, dimL );
          mysom->getMapcode()->setDimensions( 1, dimC );

          // kind of neighborhood for travelling salesman problem
          mysom->getMapcode()->setLattice( "toro" );   
          mysom->getMapcode()->setNeighborType( "bubble" );
          mysom->getMapcode()->CreateCodebook( dimL*dimC, mysom->getData()->getDimension() );   

          // in TSP , this must to be equal to (number_of_cities / 4)
          mysom->setInitNeighbor( dimL*(neig*0.01) );  

          // initialization , disposing the nodes on a frame around all the cities
          mysom->setInitType( WINDOW );  

          mysom->setNumIterations( iter );

          if ( strcmp(argv[4],"online") == 0 ){
             mysom->setLearningType( ONLINE );
             mysom->setLearnType( "Online" );
          }

          if ( strcmp(argv[4],"batch") == 0 ) {
            mysom->setLearningType( BATCH );
            mysom->setLearnType( "Batch" );
          }

         mysom->InitMapcode();  

         string SOM       = "Som" ;
         string PATH      = "Path" ;
         string INIT_ARRG = "InitialArrangement" ;
         string txt       = ".txt" ;
        
         // name of the generated files (initial arrangement, final coordenates of neurons and           // generated path) following this pattern: 
         // <generated file> N <n# of neurons> P <neighboorhood percentage> I <n# of iterations>

         string nick1 = INIT_ARRG + 'N' + inttostr(dimL) + 'P' + argv[2] + 'I' + argv[3] + txt ;

         tsp = new OneDT(mysom->getMapcode()->getTopolParams());

         // generate a file with the initial arrangement of the neurons (before the training)
         cout << "\nFile containing the initial arragement : \n\t" ;
         tsp->Save(mysom->getMapcode()->getCodebook() , nick1 , dimL); 
         cout << "\n" ;

         mysom->Learning();             
         mysom->Quality();

          
          clock_t c3 = clock();
          cout << "Quantization error = " << mysom->getQuantizationError() << std::endl;
          cout << "Topological error = " << mysom->getTopologicalError() << std::endl;
          cout << "Time elapsed Loading Data = " << (float) (c1 - c0)/CLOCKS_PER_SEC << std::endl;
          cout << "Time elapsed Computing Data = " << (float) (c3 - c2)/CLOCKS_PER_SEC << std::endl;


          mysom->Labeling();

          TLabel label = mysom->getMapcode()->getLabel();

        // cities' coordinates impression. 
        // uncomment if necessary
        /*
          int tsp_count = 1 ;
          for (int i = 0; i < label.size() ; i++) {
             cout << i+1 << ": " ;
             for (int j = 0; j < label[i].size(); j++){
                cout << mysom->getCities()[strtoint(rem_id(label[i][j]))][1] ;
                cout << "," << mysom->getCities()[strtoint(rem_id(label[i][j]))][2] << " " ;
                tsp_count++ ;
                }
             cout << "\n";
          }
         */
        
         string nick2, nick3 ;
         
         // name of the generated files (initial arrangement, final coordenates of neurons and           // generated path) following this pattern: 
         // <generated file> N <n# of neurons> P <neighboorhood percentage> I <n# of iterations>
         
         nick2 = PATH + 'N' + inttostr(dimL) + 'P' + argv[2] + 'I' + argv[3] + txt ;
         nick3 = SOM + 'N' + inttostr(dimL) + 'P' + argv[2] + 'I' + argv[3] + txt ;


         TMatrix path = tsp->Extract_Path(mysom->getMapcode()->getLabel() , mysom->getCities() , dimL) ;

         cout << "\nFile containing the generated path : \n\t" ;
         tsp->Save(path , nick2 , dimL);
         cout << "\nFile containing the neurons coordenates : \n\t" ;
         tsp->Save(mysom->getMapcode()->getCodebook() , nick3 , dimL);


  } catch(std::exception& ex) {
    cout << ex.what() << std::endl;
  }
      
  return EXIT_SUCCESS;
  
};

---