/*

    This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 2 of the License, or

    (at your option) any later version.



    This library is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Lesser General Public License for more details.



    You should have received a copy of the GNU General Public License

    along with this library; if not, write to the Free Software

    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA



    Contact: todos@geneura.ugr.es, http://geneura.ugr.es

	     jeggermo@liacs.nl

*/



#ifdef _MSC_VER

#pragma warning(disable:4786)

#endif



#ifdef HAVE_CONFIG_H

#include <config.h>

#endif



#include <iostream>

#include "gp/eoParseTree.h"

#include "eo"



using namespace gp_parse_tree;

using namespace std;



//-----------------------------------------------------------------------------



#include "node.h"

#include "parameters.h"

#include "fitness.h"





// TYPE DECLARATIONS FOR GP





typedef eoParseTree<FitnessType, Node > EoType;

typedef eoPop<EoType> Pop;



//-----------------------------------------------------------------------------



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

{



	// the vector containing the possible nodes

	vector<Node> initSequence;



	// initialise parameters

	Parameters parameter(argc, argv);



	// set the randomseed

	rng.reseed(parameter.randomseed);



	 // Create a generation counter

    	eoValueParam<unsigned> generationCounter(0, "Gen.");



    	// Create an incrementor (sub-class of eoUpdater). Note that the

    	// parameter's value is passed by reference,

    	// so every time the incrementer is updated (every generation),

    	// the data in generationCounter will change.

    	eoIncrementor<unsigned> increment(generationCounter.value());





	// create an instantiation of the fitness/evaluation function

	// it initializes the initSequence vector

	// the parameters are passed on as well

	RegFitness eval(generationCounter, initSequence, parameter);



	// Depth Initializor, set for Ramped Half and Half Initialization

	eoParseTreeDepthInit<FitnessType, Node> initializer(parameter.InitMaxDepth, initSequence, true, true);



	// create the initial population

	Pop pop(parameter.population_size, initializer);



	// and evaluate the individuals

	apply<EoType>(eval, pop);



	generationCounter.value()++; // set the generationCounter to 1





    	// define X-OVER



	eoSubtreeXOver<FitnessType, Node>   xover(parameter.MaxSize);



	// define MUTATION

      eoBranchMutation<FitnessType, Node> mutation(initializer, parameter.MaxSize);

//      eoExpansionMutation<FitnessType, Node> mutation(initializer, parameter.MaxSize);

//	eoCollapseSubtreeMutation<FitnessType, Node> mutation(initializer, parameter.MaxSize);

//	eoPointMutation<FitnessType, Node> mutation(initSequence);

//	eoHoistMutation<FitnessType, Node> mutation;



	// The operators are  encapsulated into an eoTRansform object,

    	// that performs sequentially crossover and mutation

	eoSGATransform<EoType> transform(xover, parameter.xover_rate, mutation, parameter.mutation_rate);



	// The robust tournament selection

	// in our case 5-tournament selection

    	eoDetTournamentSelect<EoType> selectOne(parameter.tournamentsize);

	// is now encapsulated in a eoSelectMany

	eoSelectMany<EoType> select(selectOne, parameter.offspring_size, eo_is_an_integer);



	// and the generational replacement

    	//eoGenerationalReplacement<EoType> replace;

	// or the SteadtState replacment

	//eoSSGAWorseReplacement<EoType> replace;

	// or comma selection

	eoCommaReplacement<EoType> replace;



    	// Terminators

    	eoGenContinue<EoType> term(parameter.nGenerations);



    	eoCheckPoint<EoType> checkPoint(term);



	// STATISTICS

    	eoAverageStat<EoType>     avg;

    	eoBestFitnessStat<EoType> best;





    	// Add it to the checkpoint,

    	// so the counter is updated (here, incremented) every generation

    	checkPoint.add(increment);

	checkPoint.add(avg);

	checkPoint.add(best);



#ifdef HAVE_GNUPLOT

	eoGnuplot1DMonitor gnuplotmonitor("gnuplotBestStats");

  	gnuplotmonitor.add(generationCounter);

	gnuplotmonitor.add(best);

	// we need to add a empty string variable if we want to seed the second fitness value

	eoValueParam<string> dummy1("", "Smallest Tree Size");

	gnuplotmonitor.add(dummy1);



	eoGnuplot1DMonitor gnuplotAvgmonitor("gnuplotAvgStats");

	gnuplotAvgmonitor.add(generationCounter);

	gnuplotAvgmonitor.add(avg);

	// we need to add a empty string variable if we want to seed the second fitness value

	eoValueParam<string> dummy2("", "Average Tree Size");

	gnuplotAvgmonitor.add(dummy2);



	checkPoint.add(gnuplotmonitor);

  	checkPoint.add(gnuplotAvgmonitor);

#endif

	// GP Generation

	eoEasyEA<EoType> gp(checkPoint, eval, select, transform, replace);



    	cout << "Initialization done" << endl;





    	try

    	{

      		gp(pop);

    	}

    	catch (exception& e)

    	{

	    cout << "exception: " << e.what() << endl;;

	    exit(EXIT_FAILURE);

    	}



    	return 1;



}