GA.h

Go to the documentation of this file.

#ifndef CGACLASS
#define CGACLASS
#pragma once
 
#include "Individual.h"
#include "GADistribution.h"
#include "math.h"
#include <string>
#include <vector>
#include <map>
 
#ifndef mac_version
#endif
 
// Forward declaration for GUI support
class ProgressWindow;
 
struct GA_Tweaking_parameters
{
    int totnumparams;
 
    int maxpop = 2;
 
    int nParam;
 
    int numenhancements;
 
    int num_enh;
 
    int nGen;
 
    int cross_over_type;
 
    int no_bins;
 
    bool sens_out = false;
 
    bool RCGA = false;
 
    bool readfromgafile;
 
    bool Steepest_Descent = false;
 
    double N;
 
    double pcross = 1;
 
    double pmute = 0.02;
 
    double exponentcoeff = 1;
 
    double shakescale = 0.05;
 
    double shakescalered = 0.75;
 
    char fitnesstype;
};
 
struct _filenames
{
    std::string initialpopfilemame;
 
    std::string pathname;
 
    std::string getfromfilename;
 
    std::string outputfilename;
};
 
template<class T>
class CGA
{
public:
    double sumfitness;
 
    double MaxFitness;
 
    GA_Tweaking_parameters GA_params;
 
    _filenames filenames;
 
    std::vector<double> calc_output_percentiles;
 
    std::vector<std::vector<double>> initial_pop;
 
    std::vector<double> final_params;
 
    std::vector<int> params;
 
    std::vector<int> loged;
 
    std::vector<int> to_ts;
 
    std::vector<double> fixedinputvale;
 
    std::vector<double> minval;
 
    std::vector<double> maxval;
 
    std::vector<bool> apply_to_all;
 
    std::vector<std::vector<int>> outcompare;
 
    std::vector<CIndividual> Ind;
 
    std::vector<CIndividual> Ind_old;
 
    std::vector<std::string> paramname;
 
    std::vector<T> Models;
 
    T Model_out;
 
    T *Model;
 
    CGA();
 
    virtual ~CGA();
 
    CGA(const CGA &C);
 
    CGA operator=(CGA &C);
 
    CGA(std::string filename, const T& model);
 
    CGA(T* model);
 
    void initialize();
 
    double getfromoutput(std::string filename);
 
    void getinifromoutput(std::string filename);
 
    void getinitialpop(std::string filename);
 
    int optimize();
 
    bool SetProperty(const std::string &varname, const std::string &value);
 
    bool SetProperties(const std::map<std::string,std::string> &arguments);
 
    void InitiatePopulation();
 
    std::string last_error;
 
#ifdef Q_GUI_SUPPORT
    void SetRunTimeWindow(ProgressWindow *_rtw) {
        rtw = _rtw;
    }
#endif
 
private:
    void Setminmax(int a, double minrange, double maxrange, int prec);
 
    void fitnessdistini();
 
    void crossover();
 
    double avgfitness();
 
    void mutate(double mu);
 
    void assignfitnesses();
 
    int maxfitness();
 
    double variancefitness();
 
    double stdfitness();
 
    double avg_actual_fitness();
 
    void write_to_detailed_GA(std::string s);
 
    void setnumpop(int n);
 
    double avg_inv_actual_fitness();
 
    int optimize(int nGens, char DefOutPutFileName[]);
 
    void setnparams(int n);
 
    void assignfixedvalues();
 
    void assignrank();
 
    void assignfitness_rank(double N);
 
    void shake();
 
    void crossoverRC();
 
    void getfromfile(char filename[]);
 
    void fillfitdist();
 
    double assignfitnesses(std::vector<double> inp);
 
    double Gradient_Descent(std::vector<double> inp);
 
    int getparamno(int i, int ts);
 
    int get_act_paramno(int i);
 
    int get_time_series(int i);
 
    double evaluateforward();
 
    double evaluateforward_mixed(std::vector<double> v);
 
    int current_generation = 0;
 
    GADistribution fitdist;
 
    int numberOfThreads;
 
#ifdef Q_GUI_SUPPORT
    ProgressWindow *rtw = nullptr;
#endif
};
 
#include "GA.hpp"
 
#endif // CGACLASS