shared_ptr<ioh::logger::Analyzer> logger,

const unsigned long long eval_budget)

{

// check input variables

if (eval_budget <= 1)

throw "eval_budget must be > 1";

if (!problem)

throw "problem must not be null";

if (!logger)

throw "logger must not be null";

// n be the number of variables

const int n = problem->meta_data().n_variables;

if (n <= 0)

throw "number of variables must be positive";

// the bit flip probability

const double p = 1.0 / ((double)n);

if ((!isfinite(p)) || (p <= 0.0) || (p >= 1.0))

throw "p must be from (0,1)";

// xcur is the current best candidate solution (based on frequency fitness)

std::vector<int> xcur;

// xnew is the new candidate solution generated in each step

std::vector<int> xnew;

// ycur is the objective value of the current solution

double ycur = std::numeric_limits<double>::infinity();

// ynew is the objective value of the new solution

double ynew = std::numeric_limits<double>::infinity();

// H is the frequency table, storing the encounter frequency of objective values

std::tr1::unordered_map<double, unsigned long long> H;

// first we generate the random initial solution

xcur.reserve(n);

for (int i = 0; i < n; i++)

{

xcur.push_back((int)(2 * uniform_random()));

}

// we evaluate the random initial solution

ycur = (*problem)(xcur);

H[ycur] = 0; // and initialize its frequency

// we perform iterations until either the optimum is discovered or the budget has been exhausted

unsigned long long int step = 1;

while (((++step) <= eval_budget) && (!problem->state().optimum_found))

{

// copy the current solution to the new solution

xnew = xcur;

bool unchanged = true;

// until the solution changes, repeat

do

{

// flip each bit with the independent probability of 1/n

for (int i = n; (--i) >= 0;)

{

if (uniform_random() < p)

{

unchanged = false; // there was a change

xnew[i] ^= 1; // flip the bit

}

}

} while (unchanged); // repeat until at least one change

// evaluate the new candidate solution

ynew = (*problem)(xnew);

// is it completely new?

if (H.find(ynew) == H.end())

{

H[ynew] = 0; // store frequency 0

}

// update the frequencies of both solutions

++H[ycur];

++H[ynew];

// if the new solution has a lower or equal frequency, take it

if (H[ynew] <= H[ycur])

{

ycur = ynew;

xcur = xnew;

}

}

shared_ptr<ioh::suite::Suite<ioh::problem::Integer> > suite,

const unsigned long long eval_budget,

const unsigned long long independent_runs,

const unsigned long long rand_seed)

{

if (folder_path.empty())

throw "folder path cannot be empty";

if (!suite)

throw "suite cannot be null";

if (eval_budget <= 1)

throw "eval_budget must be > 1";

if (independent_runs < 1)

throw "independent_runs must be > 0";

const string algorithm_name = "opofea";

std::shared_ptr<ioh::logger::Analyzer> logger(

new ioh::logger::Analyzer(

{ioh::trigger::on_improvement}, // trigger when the objective value improves

{}, // no additional properties

folder_path, // path to store data

algorithm_name, // name of the folder in path, which will be newly created

algorithm_name, // name of the algoritm

algorithm_name, // additional info about the algorithm

false // where to store x positions in the data files

));

random_gen.seed(rand_seed);

shared_ptr<ioh::problem::Integer> problem;

for (auto &problem : *suite)

{

problem->attach_logger(*logger);

for (unsigned long long i = 0; i < independent_runs; i++)

{

fea1p1(problem, logger, eval_budget);

problem->reset();

}

}