//============================================================================

// Name : Celulas.cpp

// Author : Ruben Girela Castellón

// Version : 0.0

// Copyright : Ruben Girela Castellón

// Description : Cells Algotihm in C++, Ansi-style

// Created : 13 jun. 2021

//============================================================================

#include <iostream>

#include <vector>

#include <random> // generación de valores aleatorios

#include <cmath> // calculos matematicos

#include <stdlib.h> //necesario para los includes de abajo

#include <algorithm>// para barajar el vector

#include <ctime>// libreria de time para el shuffle aleatorio de vectores

extern "C"{

#include "cec17.h"

}

using namespace std;

//algoritmo Solis-Wet

void clip(vector<double> &sol, int lower, int upper) {

for (auto &val : sol) {

if (val < lower) {

val = lower;

}

else if (val > upper) {

val = upper;

}

}

}

void increm_bias(vector<double> &bias, vector<double> dif) {

for (unsigned i = 0; i < bias.size(); i++) {

bias[i] = 0.2*bias[i]+0.4*(dif[i]+bias[i]);

}

}

void decrement_bias(vector<double> &bias, vector<double> dif) {

for (unsigned i = 0; i < bias.size(); i++) {

bias[i] = bias[i]-0.4*(dif[i]+bias[i]);

}

}

/**

* Aplica el Solis Wets

*

* @param sol solucion a mejorar.

* @param fitness fitness de la solución.

*/

template <class Random>

void soliswets(vector<double> &sol, double &fitness, double delta, int maxevals, int lower, int upper, Random &random, int &eval_actual, int max_global) {

const size_t dim = sol.size();

vector<double> bias (dim), dif (dim), newsol (dim);

double newfit;

size_t i;

int evals = 0;

int num_success = 0;

int num_failed = 0;

while (evals < maxevals && eval_actual < max_global) {

std::uniform_real_distribution<double> distribution(0.0, delta);

for (i = 0; i < dim; i++) {

dif[i] = distribution(random);

newsol[i] = sol[i] + dif[i] + bias[i];

}

clip(newsol, lower, upper);

newfit = cec17_fitness(&newsol[0]);

evals += 1;

++eval_actual;

if (newfit < fitness) {

sol = newsol;

fitness = newfit;

increm_bias(bias, dif);

num_success += 1;

num_failed = 0;

}

else if (evals < maxevals && eval_actual < max_global) {

for (i = 0; i < dim; i++) {

newsol[i] = sol[i] - dif[i] - bias[i];

}

clip(newsol, lower, upper);

newfit = cec17_fitness(&newsol[0]);

evals += 1;

++eval_actual;

if (newfit < fitness) {

sol = newsol;

fitness = newfit;

decrement_bias(bias, dif);

num_success += 1;

num_failed = 0;

}

else {

for (i = 0; i < dim; i++) {

bias[i] /= 2;

}

num_success = 0;

num_failed += 1;

}

}

if (num_success >= 5) {

num_success = 0;

delta *= 2;

}

else if (num_failed >= 3) {

num_failed = 0;

delta /= 2;

}

}

}

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

//hace una explotación suave

vector<pair<double, vector<double>>> explotacion(vector<pair<double, vector<double>>> cells, int dim, int &eval, int max_eval){

vector<pair<double,vector<double>>> new_cells=cells;

vector<pair<double,vector<double>>> actual_cells=cells;

int max_nodo=2, n_nodo=0, cell=0, nodo=0;

double val, fitness;

//mientras no supere el numero máximo de evaluaciones

for(int i=0; i<(1000*dim) && eval < max_eval; ++i){

//calculo el nuevo valor del nodo de esa celula

val = new_cells[cell].second[nodo] * (rand() % 10 + 2);

//lo modularizo entre -100 y 100

if(val < 0){

val = (-1)*fmod(abs(val),100.000000001);

}else{

val = fmod(val,100.000000001);

}

//y si el valor aleatorio es > a 5 cambia de signo el valor

if((rand() % 10 + 1) > 5)

val = val *(-1);

//reemplazamos el valor

new_cells[cell].second[nodo] = val;

//calculamos su fitness

fitness = cec17_fitness(&new_cells[cell].second[0]);

++eval;

//cout << fitness << endl;

//si es mejor que la que tiene actualmente actualiza

if(fitness < actual_cells[cell].first){

actual_cells[cell].first = fitness;

actual_cells[cell].second[nodo] = new_cells[cell].second[nodo];

new_cells[cell].first = fitness;

//pasamos al siguiente nodo o nodo de la siguiente celula si hemos

//recorrido todos los nodos de esa celula

++nodo;

n_nodo = 0;

//si hemos recorrido todos los nodos de esa celula pasamos a la siguiente celula

if(nodo >= dim){

nodo = 0;

++cell;

//si hemos recorrido todas las celulas hace otra pasada

if(cell >= cells.size())

cell = 0;

}

}else{

//restauramos el valor

new_cells[cell].second[nodo] = actual_cells[cell].second[nodo];

++n_nodo;

//si supera el numero maximo de cambios de cada nodo

if(n_nodo>=max_nodo){

//pasamos al siguiente nodo o nodo de la siguiente celula si hemos

//recorrido todos los nodos de esa celula

++nodo;

n_nodo = 0;

//si hemos recorrido todos los nodos de esa celula pasamos a la siguiente celula

if(nodo >= dim){

nodo = 0;

++cell;

//si hemos recorrido todas las celulas hace otra pasada

if(cell >= cells.size())

cell = 0;

}

}

}

}

return actual_cells;

}

//en la mejora solo he cambiado el numero de evaluaciones a evaluar el resto es igual

vector<pair<double, vector<double>>> explotacionMejorado(vector<pair<double, vector<double>>> cells, int dim, int &eval, int max_eval, int seed){

vector<pair<double,vector<double>>> new_cells=cells;

vector<pair<double,vector<double>>> actual_cells=cells;

int max_nodo=2, n_nodo=0, cell=0, nodo=0;

double val, fitness;

uniform_real_distribution<> dis(-100.0, 100.0);

mt19937 gen(seed);

//mientras no supere el numero máximo de evaluaciones

for(int i=0; i<(1000*dim) && eval < max_eval; ++i){

//reemplazamos el valor por un valor aleatorio entre [-100, 100]

new_cells[cell].second[nodo] = dis(gen);

//calculamos su fitness

fitness = cec17_fitness(&new_cells[cell].second[0]);

++eval;

//cout << fitness << endl;

//si es mejor que la que tiene actualmente actualiza

if(fitness < actual_cells[cell].first){

actual_cells[cell].first = fitness;

actual_cells[cell].second[nodo] = new_cells[cell].second[nodo];

new_cells[cell].first = fitness;

//pasamos al siguiente nodo o nodo de la siguiente celula si hemos

//recorrido todos los nodos de esa celula

++nodo;

n_nodo = 0;

//si hemos recorrido todos los nodos de esa celula pasamos a la siguiente celula

if(nodo >= dim){

nodo = 0;

++cell;

//si hemos recorrido todas las celulas hace otra pasada

if(cell >= cells.size())

cell = 0;

}

}else{

//restauramos el valor

new_cells[cell].second[nodo] = actual_cells[cell].second[nodo];

++n_nodo;

//si supera el numero maximo de cambios de cada nodo

if(n_nodo>=max_nodo){

//pasamos al siguiente nodo o nodo de la siguiente celula si hemos

//recorrido todos los nodos de esa celula

++nodo;

n_nodo = 0;

//si hemos recorrido todos los nodos de esa celula pasamos a la siguiente celula

if(nodo >= dim){

nodo = 0;

++cell;

//si hemos recorrido todas las celulas hace otra pasada

if(cell >= cells.size())

cell = 0;

}

}

}

}

return actual_cells;

}

vector<pair<double, vector<double>>> Meiosis(vector<pair<double, vector<double>>> cells, int &eval, int max_eval, vector<int> indice, int dim, int decrece, int n_cells, int seed){

//para los valores aleatorios

uniform_real_distribution<> dis(-100.0, 100.0);

mt19937 gen(seed);

//guarda el nuevo conjunto de celulas

vector<pair<double, vector<double>>> new_cells;

//vector de indices de las celulas para elegir las parejas aleatoriamente y sin repetir

vector<int> select_cell;

for(unsigned int i=0; i< cells.size(); ++i){

select_cell.push_back(i);

}

//cada pareja se fragmenta en 4 partes

vector<vector<double>> fragmentos;

vector<double> frag;

vector<double> frag2;

vector<double> cell;

//contador de celulas creadas por cada pareja

int count=0;

//calculamos el numero maximo de nodos por fragmento

int max = ceil((float)dim/4);

//creamos el vector de indices para seleccionar los fragmentos aleatorios

vector<int> ind_frag(8);

for(int i=0; i<8; ++i){

ind_frag[i]=i;

}

random_shuffle(ind_frag.begin(), ind_frag.end());//barajo el vector

random_shuffle(select_cell.begin(), select_cell.end());//barajo el vector

int l = 0;

//si no decrementa el conjunto de celulas, sino que aumenta

if(decrece == 0){

//recorre cada 2 celulas

for(unsigned int i=0; i < select_cell.size() && eval < max_eval; ++i){

++l;

if(l>=select_cell.size()) l = 0;

//y de cada pareja fragmentamos cada celula en 4 fragmentos, en total 8

for(int e=0; e<dim; ++e){

frag.push_back(cells[select_cell[i]].second[e]);

frag2.push_back(cells[select_cell[l]].second[e]);

++count;

//si ya tiene un fragmento lo añade

if(count == max || e+1==dim){

//añado los fragmentos y limpio esos fragmentos

fragmentos.push_back(frag);

frag.clear();

fragmentos.push_back(frag2);

frag2.clear();

//reseteo el contador

count = 0;

}

}

//una vez fragmentados elegimos 3 fragmentos aleatorios y que no sean del mismo padre los 3

for(int e = 0; e < n_cells && eval < max_eval; ++e){

//añadimos los 3 fragmentos aleatoriamente a la celula

cell = fragmentos[ind_frag[1]];

cell.insert(cell.end(), fragmentos[ind_frag[2]].begin(),fragmentos[ind_frag[2]].end());

cell.insert(cell.end(), fragmentos[ind_frag[3]].begin(),fragmentos[ind_frag[3]].end());

unsigned int size = cell.size();

//el resto de nodos faltantes se generan aleatoriamente

do{

cell.push_back(dis(gen));

++size;

}while(size < dim);

//añadimos la nueva celula con su fitness

new_cells.push_back(pair<double,vector<double>>(cec17_fitness(&cell[0]),cell));

++eval;

cell.clear();

//rebarajamos la lista de indices

random_shuffle(ind_frag.begin(), ind_frag.end());//barajo el vector

}

//y limpiamos la lista de fragmentos

for(unsigned int e = 0; e < fragmentos.size(); ++e)

fragmentos[e].clear();

fragmentos.clear();

}

}else{

//recorre cada 2 celulas

for(unsigned int i=0; i < (select_cell.size()/n_cells) && eval < max_eval; ++i){

++l;

if(l>=select_cell.size()) l = 0;

//y de cada pareja fragmentamos cada celula en 4 fragmentos, en total 8

for(int e=0; e<dim; ++e){

frag.push_back(cells[select_cell[i]].second[e]);

frag2.push_back(cells[select_cell[l]].second[e]);

++count;

if(count == max){

//añado los fragmentos y limpio esos fragmentos

fragmentos.push_back(frag);

frag.clear();

fragmentos.push_back(frag2);

frag2.clear();

//reseteo el contador

count = 0;

}

}

//una vez fragmentados elegimos 3 fragmentos aleatorios

cell = fragmentos[ind_frag[1]];

cell.insert(cell.end(), fragmentos[ind_frag[2]].begin(),fragmentos[ind_frag[2]].end());

cell.insert(cell.end(), fragmentos[ind_frag[3]].begin(),fragmentos[ind_frag[3]].end());

unsigned int size = cell.size();

//el resto de nodos faltantes se generan aleatoriamente

do{

cell.push_back(dis(gen));

++size;

}while(size < dim);

new_cells.push_back(pair<double,vector<double>>(cec17_fitness(&cell[0]),cell));

++eval;

cell.clear();

random_shuffle(ind_frag.begin(), ind_frag.end());//barajo el vector

//y limpiamos la lista de fragmentos

for(unsigned int e = 0; e < fragmentos.size(); ++e)

fragmentos[e].clear();

fragmentos.clear();

}

}

return new_cells;

}

vector<pair<double, vector<double>>> Mitosis(vector<pair<double, vector<double>>> cells, int &eval, int max_eval, vector<int> indice, int dim, int decrece, int seed){

//para los valores aleatorios

uniform_real_distribution<> dis(-100.0, 100.0);

mt19937 gen(seed);

vector<pair<double, vector<double>>> new_cells;

vector<double> cell1(dim);

vector<double> cell2(dim);

//crece el numero de celulas

if(decrece == 0){

//recorro cada celula

for(unsigned int i=0; i < cells.size() && eval < max_eval; ++i){

//para cada celula se recorre en orden distinto

random_shuffle(indice.begin(), indice.end());//barajo el vector

//recorro cada nodo de la celula

for(unsigned int e = 0; e < indice.size(); ++e){

//copio la mitad de los datos de la celula en la nueva celula

if(e < indice.size()/2){

cell1[indice[e]] = cells[i].second[indice[e]];

cell2[indice[e]] = dis(gen);

//y el resto se generan aleatoriamente

}else{

cell1[indice[e]] = dis(gen);

cell2[indice[e]] = cells[i].second[indice[e]];

}

}

//evaluo el fitness y las guardo

new_cells.push_back(pair<double,vector<double>>(cec17_fitness(&cell1[0]),cell1));

new_cells.push_back(pair<double,vector<double>>(cec17_fitness(&cell2[0]),cell2));

eval += 2;

}

//decrece el numero de celulas

}else{

//celulas que se seleccionaran aleatoriamente

vector<int> select_cell;

for(unsigned int i=0; i< cells.size(); ++i){

select_cell.push_back(i);

}

random_shuffle(select_cell.begin(), select_cell.end());//barajo el vector

//recorro cada celula

for(unsigned int i=0; i < select_cell.size()/2 && eval < max_eval; ++i){

//para cada celula se recorre en orden distinto

random_shuffle(indice.begin(), indice.end());//barajo el vector

//recorro cada nodo de la celula

for(unsigned int e = 0; e < indice.size(); ++e){

//copio la mitad de los datos de la celula en la nueva celula

if(e < indice.size()/2){

cell1[indice[e]] = cells[select_cell[i]].second[indice[e]];

//y el resto se generan aleatoriamente

}else{

cell1[indice[e]] = dis(gen);

}

}

//evaluo el fitness y las guardo

new_cells.push_back(pair<double,vector<double>>(cec17_fitness(&cell1[0]),cell1));

++eval;

}

}

return new_cells;

}

double Cells(vector<vector<double>> celulas, int dim, int max_eval, int seed){

double best_f=-1, f=-1;

vector<double> queen_cell;

vector<pair<double,vector<double>>> cells1;

vector<pair<double,vector<double>>> cells2;

int eval=0, grupo = -1;

int max_size = 0;

int decrece = 0, decrece2 = 0;

int constant_meiosis = 4;

vector<int> indice(dim);

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

indice[i]=i;

//creamos los 2 grupos de celulas

for(unsigned int i=0; i < celulas.size(); i+=2){

cells1.push_back(pair<double,vector<double>>(cec17_fitness(&celulas[i][0]),celulas[i]));

cells2.push_back(pair<double,vector<double>>(cec17_fitness(&celulas[i][0]),celulas[i+1]));

eval +=2;

}

while(eval < max_eval){

//aplicamos la explotación

cells1 = explotacion(cells1, dim, eval, max_eval);

cells2 = explotacion(cells2, dim, eval, max_eval);

//calculamos el tamaño maximo de los 2 grupos para ahorrar iteraciones inecesarias

max_size=cells1.size();

if(cells2.size() > max_size)

max_size=cells2.size();

//guardamos el que tenga mejor fitness

for(unsigned int i=0; i<max_size; ++i){

//para el grupo 1 de celulas

if(i < cells1.size()){

if(cells1[i].first < best_f || best_f==-1){

best_f = cells1[i].first;

queen_cell = cells1[i].second;

grupo = 1;

}

}

//para el grupo 2 de celulas

if(i < cells2.size()){

if(cells2[i].first < best_f || best_f==-1){

best_f = cells2[i].first;

queen_cell = cells2[i].second;

grupo = 2;

}

}

}

//Propagación o reproducción

//cells1 = Meiosis(cells1, eval, max_eval, indice, dim, decrece2, constant_meiosis, seed);

cells1 = Mitosis(cells1, eval, max_eval, indice, dim, decrece, seed);

cells2 = Meiosis(cells2, eval, max_eval, indice, dim, decrece2, constant_meiosis, seed);

//controlo que la constante este entre 4 y 2

if(decrece2==0){

--constant_meiosis;

}else{

++constant_meiosis;

}

//controlo que los rangos en la Meiosis este entre [5 y 120]

if(constant_meiosis == 1){

decrece2 = 1;

++constant_meiosis;

}

else if(constant_meiosis == 5){

decrece2 = 0;

--constant_meiosis;

}

//controlo que los rangos en la Mitosis este entre [10 y 160]

if(cells1.size() >= 160)

decrece = 1;

else if(cells1.size() <= 10)

decrece = 0;

//guardamos el que tenga mejor fitness

for(unsigned int i=0; i<max_size; ++i){

if(i < cells1.size()){

if(cells1[i].first < best_f || best_f==-1){

best_f = cells1[i].first;

queen_cell = cells1[i].second;

grupo = 1;

}

}

if(i < cells2.size()){

if(cells2[i].first < best_f || best_f==-1){

best_f = cells2[i].first;

queen_cell = cells2[i].second;

grupo = 2;

}

}

}

}

return best_f;

}

//mejora de celulas

//en la mejora solo he cambiado el numero de evaluaciones a evaluar en la explotación el resto es igual

double CellsMejorado(vector<vector<double>> celulas, int dim, int max_eval, int seed){

double best_f=-1, f=-1;

vector<double> queen_cell;

vector<pair<double,vector<double>>> cells1;

int eval=0, decrece = 0, constant_meiosis = 4;

vector<int> indice(dim);

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

indice[i]=i;

//creamos los 2 grupos de celulas

for(unsigned int i=0; i < celulas.size(); ++i){

cells1.push_back(pair<double,vector<double>>(cec17_fitness(&celulas[i][0]),celulas[i]));

++eval;

}

while(eval < max_eval){

//aplicamos la explotación

cells1 = explotacionMejorado(cells1, dim, eval, max_eval, seed);

//guardamos el que tenga mejor fitness

for(unsigned int i=0; i<cells1.size(); ++i){

//para el grupo 1 de celulas

if(i < cells1.size()){

if(cells1[i].first < best_f || best_f==-1){

best_f = cells1[i].first;

queen_cell = cells1[i].second;

}

}

}

//Propagación o reproducción

cells1 = Meiosis(cells1, eval, max_eval, indice, dim, decrece, constant_meiosis, seed);

//controlo que la constante este entre 4 y 2

if(decrece==0){

--constant_meiosis;

}else{

++constant_meiosis;

}

//controlo que los rangos en la Meiosis este entre [5 y 120]

if(constant_meiosis == 1){

decrece = 1;

++constant_meiosis;

}

else if(constant_meiosis == 5){

decrece = 0;

--constant_meiosis;

}

//guardamos el que tenga mejor fitness

for(unsigned int i=0; i<max_size; ++i){

if(i < cells1.size()){

if(cells1[i].first < best_f || best_f==-1){

best_f = cells1[i].first;

queen_cell = cells1[i].second;

}

}

}

}

return best_f;

}

//hibridación entre el algoritmo de las celulas y Solis-Wet

double CellsWithSW(vector<vector<double>> celulas, int dim, int max_eval, int seed){

double best_f=-1, f=-1;

vector<double> queen_cell;

vector<pair<double,vector<double>>> cells1;

vector<pair<double,vector<double>>> cells2;

int eval=0, grupo = -1;

int max_size = 0;

int decrece = 0, decrece2 = 0;

int constant_meiosis = 4, maxtimes=5;

vector<int> indice(dim);

mt19937 gen(seed);

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

indice[i]=i;

//creamos los 2 grupos de celulas

for(unsigned int i=0; i < celulas.size(); i+=2){

cells1.push_back(pair<double,vector<double>>(cec17_fitness(&celulas[i][0]),celulas[i]));

cells2.push_back(pair<double,vector<double>>(cec17_fitness(&celulas[i][0]),celulas[i+1]));

eval +=2;

}

while(eval < max_eval){

//calculamos el tamaño maximo de los 2 grupos para ahorrar iteraciones inecesarias

max_size=cells1.size();

if(cells2.size() > max_size)

max_size=cells2.size();

//guardamos el que tenga mejor fitness

for(unsigned int i=0; i<max_size; ++i){

//para el grupo 1 de celulas

if(i < cells1.size()){

//aplicamos la explotación

soliswets(cells1[i].second, cells1[i].first, 0.2, 100000/maxtimes-1, -100, 100, gen, eval, max_eval);

if(cells1[i].first < best_f || best_f==-1){

best_f = cells1[i].first;

queen_cell = cells1[i].second;

grupo = 1;

}

}

//para el grupo 2 de celulas

if(i < cells2.size()){

//aplicamos la explotacíón

soliswets(cells2[i].second, cells2[i].first, 0.2, 100000/maxtimes-1, -100, 100, gen, eval, max_eval);

if(cells2[i].first < best_f || best_f==-1){

best_f = cells2[i].first;

queen_cell = cells2[i].second;

grupo = 2;

}

}

}

//Propagación o reproducción

//cells1 = Meiosis(cells1, eval, max_eval, indice, dim, decrece2, constant_meiosis);

cells1 = Mitosis(cells1, eval, max_eval, indice, dim, decrece, seed);

cells2 = Meiosis(cells2, eval, max_eval, indice, dim, decrece2, constant_meiosis, seed);

//controlo que la constante este entre 4 y 2

if(decrece2==0){

--constant_meiosis;

}else{

++constant_meiosis;

}

//controlo que los rangos en la Meiosis este entre [5 y 120]

if(constant_meiosis == 1){

decrece2 = 1;

++constant_meiosis;

}

else if(constant_meiosis == 5){

decrece2 = 0;

--constant_meiosis;

}

//controlo que los rangos en la Mitosis este entre [10 y 160]

if(cells1.size() >= 160)

decrece = 1;

else if(cells1.size() <= 10)

decrece = 0;

//guardamos el que tenga mejor fitness

for(unsigned int i=0; i<max_size; ++i){

if(i < cells1.size()){

if(cells1[i].first < best_f || best_f==-1){

best_f = cells1[i].first;

queen_cell = cells1[i].second;

grupo = 1;

}

}

if(i < cells2.size()){

if(cells2[i].first < best_f || best_f==-1){

best_f = cells2[i].first;

queen_cell = cells2[i].second;

grupo = 2;

}

}

}

}

return best_f;

}

int main(int argc, char** argv) {

if(argc>1){

string alg = argv[1];

if(alg == "cells" or alg == "cellsSW" or alg == "cellsMejorado"){

//int dim = 10;

vector<int> seed(10);

seed.push_back(42);

seed.push_back(5);

seed.push_back(100);

seed.push_back(-1);

seed.push_back(50);

seed.push_back(1995);

seed.push_back(19);

seed.push_back(21);

seed.push_back(80);

seed.push_back(7);

double fitness;

double fitness_best=-1;

vector<vector<double>> solutions;

double f=0;

clock_t end_part;

float elapsed_part;

clock_t start_part;

if(alg == "cells")

cout << "USANDO EL ALGORITMO CELLS" << endl;

else if (alg == "cellsMejorado")

cout << "USANDO EL ALGORITMO CELLS MEJORADO" << endl;

else

cout << "USANDO EL ALGORITMO CELLS CON SOLIS-WET" << endl;

clock_t start = clock();

//recorre las dimensiones 10 30 50

for(int dim=10; dim <=50; dim+=20){

vector<double> sol(dim);

vector<double> best(dim);

start_part = clock();

//recorre cada problema

for(int j=0; j < 30; ++j){

//repite el problema 10 veces

for(int k=0; k<10; ++k){

uniform_real_distribution<> dis(-100.0, 100.0);

mt19937 gen(seed[k]);

cec17_init(alg.c_str(), j+1, dim);

for(int e = 0; e < 10; ++e){

for(int i=0; i < dim; ++i){

sol[i] = dis(gen);

}

solutions.push_back(sol);

}

if(alg == "cells")

f += Cells(solutions, dim, 10000*dim, seed[k]);

else if(alg == "cellsMejorado")

f += CellsMejorado(solutions, dim, 10000*dim, seed[k]);

else

f += CellsWithSW(solutions, dim, 10000*dim, seed[k]);

for(unsigned int i =0; i < solutions.size(); ++i)

solutions[i].clear();

solutions.clear();

}

f = f/10;

cout << "Media Best cell[" << j+1 << "] con dimension (" << dim << "): " << scientific << cec17_error(f) << endl;

f =0;

}

end_part = clock();

elapsed_part = float(end_part - start_part)/CLOCKS_PER_SEC;

cout << "Elapse con dimensión (" << dim << "): " << (elapsed_part/60.0) << " (minutos)" << endl;

}

clock_t end = clock();

float elapsed = float(end - start)/CLOCKS_PER_SEC;

cout << "En total tarda: " << (elapsed/60.0) << " (minutos)" << endl;

}else{

cout << "Error solo usa los algoritmos (cells, cellsSW o cellsMejorado), escriba bien los algoritomos" << endl;

}

}else{

cout << "Error necesita especificar el nombre del algotitmo ./cells <cells, cellsSW o cellsMejorado>" << endl;

}

return 0;

}