/*
 * Simulovane zihanie pre vseobecnu optimalizacnu ulohu specifikovanu
 * stavovym vektorom a ucelovou funkciou
 * (Simulated annealing)
 */

#ifndef SA_H
#define SA_H

#include <vector>
#include <set>
#include <iostream>
#include <iomanip>

inline double rnd();		      // pseudonahodne cislo z <0,1)
inline int rnd(int lessThan);// pseudonahodne cele cislo <0,lessThan)

// Ciara v LaTeX2e-ovom prostredi picture
void LaTeXLine(double x0, double y0, double x1, double y1, ostream &s);

///////////////////////////////////////////////////////////////////////////
// Vseobecny optimalizovany vektor

class Vect
{
  public:
// mal by obsahovat, ale nezadeklarujeme:
//    Vect(){cerr<<"Not to be called";}
//    Vect(Vect &src){cerr<<"Not to be called";}		// kopirovaci konstruktor
    
//    void copyFrom(Vect &src);	// modifikuje seba na obraz src
//    void randomInit();		// nahodne sa inicializuje
//    void becomeMutationOf(Vect &other);	// zmeni sa na mutaciu other
//    void cross(Vect &with, Vect &child1, Vect &child2);	//zmodifikuje
    			// child1, child2 tak, aby boli detmi self a with
//    double purpFun();		// urci hodnotu ucelovej funkcie

// toto jedine budeme deklarovat kvoli reportovaniu
    void print(ostream &s);
};

///////////////////////////////////////////////////////////////////////////
// Report

#define mvAVG_VAL 0
#define mvAVG_VAL_SQ 1
#define mvDISPER 2
#define mvENTROPY 3
#define mvSPEC_HEAT 4
#define mvCNT mvSPEC_HEAT+1

#ifndef NOVARS
extern char *(mvName[]);
#endif

// spolocna baza pre vsetky reporty
class GenerReport
{
  public:
    GenerReport(){}
    virtual int numOfRecords()=0;
    virtual double getMacroVal(int recNr, int valNr)=0;
    virtual double getTemp(int recNr)=0;
    virtual double getPurpFVal(int recNr)=0;
    
    virtual void printVector(int recNr, ostream &s)=0;
  // jedina definovana metoda:
    void printGraph(ostream &s, double xSize, double ySize);
};

template<class OptVect> class Report: public GenerReport
{
  private:
    struct ReportElem
    {
      int stepNr;
      double t;
      OptVect *xOpt;
      vector<double> *macroVals;
    };
    
    vector<ReportElem> trace;
    
    int newStepNr;
    multiset<double> *valRecord;
  public:
    Report()
    {
      newStepNr = 0;
      valRecord = new multiset<double>;
    }
    ~Report();
    
    // zaznamenavanie udajov pocas jedneho kroku simulovaneho zihania, t.j.
    // jedneho volania Metropolisovho algoritmu
    void beginNewStep(int stepNr)    // zaciatok zaznamenavania
    {
      newStepNr = stepNr;
      valRecord->clear();
    }
    inline void record(double val)   // zaznamenanie funkc. hodnoty purpFun
    {
      valRecord->insert(val);
    }
    void endNewStep(const OptVect &optim, double t);	// vypocet hodnot
    						// makroskopickych velicin
    // vystup
    virtual int numOfRecords();
    virtual double getMacroVal(int recNr, int valNr);
    virtual double getTemp(int recNr);
    OptVect &getVector(int recNr);
    virtual double getPurpFVal(int recNr);

    virtual void printVector(int recNr, ostream &s);
};

///////////////////////////////////////////////////////////////////////////
// Zakladne simulovane zihanie

template<class OptVect> class SimulatedAnnealing
{
  protected:
    int repPer;
    int kmax;
    double annFact, tMin, tMax;
    Report<OptVect> *rep;
    
    virtual void metropolis(OptVect &x, double t, bool doRep);
    
  public:
    // ak report period == 0, vygeneruje sa len jedna polozka
    // reportu -- na konci
    SimulatedAnnealing(double aTmin, double aTmax, int aKmax,
	double annealingFactor, int reportPeriod)
    {
      repPer = reportPeriod;
      kmax = aKmax; annFact = annealingFactor;
      tMin = aTmin; tMax = aTmax;
      rep = new Report<OptVect>();
    }
    
    ~SimulatedAnnealing()
    {
      delete rep;
      rep = NULL;
    };
    
    OptVect &anneal(OptVect &x);
    // potrebujeme vytvorenu instanciu pre parametrizovane problemy, napr.
    // obchodny cestujuci na rozne velkych mriezkach
    
    Report<OptVect> *getReport() { return rep; };
};

///////////////////////////////////////////////////////////////////////////
// Elitarske simulovane zihanie

template<class OptVect> class ElitSimulAnnealing:
					public SimulatedAnnealing<OptVect>
{
  protected:
    virtual void metropolis(OptVect &x, double t, bool doRep);
  public:
    ElitSimulAnnealing(double aTmin, double aTmax, int aKmax,
	double annealingFactor, int reportPeriod):
      SimulatedAnnealing<OptVect>(aTmin,aTmax,aKmax,annealingFactor,reportPeriod)
      {}
};

///////////////////////////////////////////////////////////////////////////
// Paralelne simulovane zihanie

template<class OptVect> class ParallelSimulAnnealing:
					public SimulatedAnnealing<OptVect>
{
  protected:
    double pCross;
    int poolSize;
    
    void metropolis(vector<OptVect> &pool, double t, bool doRep);
  public:
    ParallelSimulAnnealing(double aTmin, double aTmax, int aKmax,
	double annealingFactor, int reportPeriod,
	double aPCross, int aPoolSize):
      SimulatedAnnealing<OptVect>(aTmin, aTmax, aKmax, annealingFactor, reportPeriod)
    {
      pCross = aPCross;
      poolSize = aPoolSize;
    }
    
    OptVect &anneal(OptVect &x);
};

#include "sa_implement.h"

#endif