/*
 * Popis optimalizovaneho vektora pre problem obchodneho cestujuceho
 * na stvorcovej ortogonalnej mriezke
 */

#ifndef TSP_HEADER
#define TSP_HEADER

#include "sa.h"

// forward deklaracie
class TSPperm;
class TSPvect;

class TSP//: public Vector
{
  public:
    typedef vector<int> vectype;
    
  protected:
    vectype *path;
    
    // vypocet dlzky kruznice reprezentovanej permutaciou
    // pouzitim Hammingovej vzdialenosti (za velkost mriezky
    // je povazovana odmocnina dlzky permutacie)
    double hammingLen(const vectype &permut);
    
    // vystup kruznice reprezentovanej permutaciou
    void printPermut(const vectype &permut, ostream &s);

    double pMut; // pravdepodobnost elementarnej mutacie
    
  public:
    TSP()
    {
      path = new vectype();
      pMut = 0;
    }
    TSP(int aSize, double aPMut)
    {
      path = new vectype(aSize*aSize,0); // stvorcova mriezka
      pMut = aPMut;
    }
    TSP(const TSP &other)
    {
      vectype *op = other.path;
      int i, cnt = op->size();
      
      path = new vectype();
      path->clear();
      for(i = 0; i<cnt; i++)
	path->push_back((*op)[i]);
      
      pMut = other.pMut;
    }
    ~TSP()
    {
      delete path;
    }

    void copyFrom(TSP &src)	// modifikuje seba na obraz src
    {
      vectype *op = src.path;
      int i, cnt = op->size();
      
      delete path;
      path = new vectype();
      
      for(i = 0; i<cnt; i++)
	path->push_back((*op)[i]);
      
      pMut = src.pMut;
    }

    friend TSPperm;
    friend TSPvect;
};

// Hamiltonovska kruznica je reprezentovana priamo permutaciou

class TSPperm: public TSP
{
  public:
    TSPperm(): TSP() {};
    TSPperm(int aSize, double aPMut): TSP(aSize, aPMut) {}
    TSPperm(const TSP &other): TSP(other) {}
    void randomInit();		// nahodne sa inicializuje
    void becomeMutationOf(const TSP &other);	// zmeni sa na mutaciu other
    void cross(const TSP &with, TSP &child1, TSP &child2);	//zmodifikuje
    			// child1, child2 tak, aby boli detmi self a with
    double purpFun();		// urci hodnotu ucelovej funkcie
    void print(ostream &s);
};

// Hamiltonovsku kruznicu bude reprezentovat vektor cisel, permutacia
// zodpovedajuca kruznici usporiada vektor do monotonnej postupnosti
// V skutocnosti by vektor mal byt binarny, usporiadavane cisla maju
// vznikat jeho delenim na useky rovnakej dlzky. Tento sposob bude vsak aj
// bez toho prilis narocny (na najdenie permutacie treba vektor usporiadat),
// preto pouzijeme vektor int-ov.

class TSPvect: public TSP
{
  protected:
    vectype vect2perm(const vectype &v);
    
  public:
    TSPvect(): TSP() {};
    TSPvect(int aSize, double aPMut): TSP(aSize, aPMut) {}
    TSPvect(const TSP &other): TSP(other) {}
    void randomInit();		// nahodne sa inicializuje
    void becomeMutationOf(const TSP &other);	//zmeni sa na mutaciu other
    void cross(const TSP &with, TSP &child1, TSP &child2);	//zmodifikuje
    			// child1, child2 tak, aby boli detmi self a with
    double purpFun();		// urci hodnotu ucelovej funkcie
    void print(ostream &s);
};

typedef SimulatedAnnealing<TSPperm> SATSPperm;
typedef ElitSimulAnnealing<TSPperm> ESATSPperm;
typedef ParallelSimulAnnealing<TSPperm> PSATSPperm;

typedef SimulatedAnnealing<TSPvect> SATSPvect;
typedef ElitSimulAnnealing<TSPvect> ESATSPvect;
typedef ParallelSimulAnnealing<TSPvect> PSATSPvect;

#endif