int main( ){
	srand( time_seed() );
	individual* i;
	i = create_individual();
	print_individual( i, 0 );
	evaluate_individual( i );
	print_individual( i, 0 );
}
Example #2
0
// extends population size to lambda using mutations based on (lamda/mu) factor
void es::create_pop(unsigned int gen)
{
    try
    {
        boost::format gen_dir(eap::run_directory+"gen%04d");
        boost::format input_path(eap::run_directory + "gen%04d/ind%09d");
        boost::filesystem::create_directory(str(gen_dir % gen));
        std::vector<individual_ptr> new_pop;

        if (gen != 0)
        {
            for (unsigned int i=0; i<m_mu; ++i)
            {
                new_pop.push_back(create_individual(str(input_path % gen % i) + "a%02d.nec", m_pop[i]->m_positions));
            }
        }
        else if (gen == 0)
        {
            for (unsigned int i=0; i<m_mu; ++i)
            {
                new_pop.push_back(m_pop[i]);
            }
        }

        for (unsigned int i=0; i<m_mu; ++i)
        {
            unsigned int counter = 0;
            while (counter<m_mulambda_factor)
            {
                int id = m_mu + i*m_mulambda_factor + counter;
                std::vector<position_ptr> placements = mutate_pos_once(m_pop[i]->m_positions);
                new_pop.push_back(create_individual(str(input_path % gen % id) + "a%02d.nec", placements));
                counter++;
            }
        }
        m_pop = new_pop;
    }
    catch (...)
    {
        throw;
    }
}
population* create_population( ) {
	int x;
	population* pop;

	pop = ( population* ) malloc( sizeof( population ) );
	if( pop == 0 ) { printf( "Malloc Failed\n" ); exit( 1 ); }

	pop->individuals = ( individual** ) malloc( sizeof( individual* ) * POP_SIZE );
	if( pop->individuals == 0 ) { printf( "Malloc Failed\n" ); exit( 1 ); }
	
	for( x = 0; x < POP_SIZE; x++ ) {
		pop->individuals[x] = create_individual( );
	}
	pop->size = POP_SIZE;
	pop->gen = 0;
}
Example #4
0
std::vector<Individual>
read_individuals(std::string dose_path)
{
    gz::igzstream dose_file( dose_path.c_str( ) );
    
    std::vector<Individual> individual_list;
    std::string line;
    while( std::getline( dose_file, line ) )
    {
        std::vector<std::string> splitted_line = split_line( line );
        Individual individual = create_individual( splitted_line );
        individual_list.push_back( individual );
    }

    return individual_list;
}
Example #5
0
/**
 * @desc Implements logic for ES runs
 */
void es::run(unsigned int run_id)
{
    try
    {
        if (m_pop.size() > 1)
            m_pop.erase(m_pop.begin(), m_pop.end());

        if (m_pop.size() != 0)
            throw eap::InvalidStateException("ES: Population size sould be zero");

        boost::filesystem::create_directory(std::string(eap::run_directory+"gen0000"));
        boost::format nec_input(eap::run_directory + "gen%04d/ind%09d");

        for (unsigned int i_id=0; i_id<m_mu; ++i_id)
        {
            std::vector<position_ptr> placements;
            for (ant_config_ptr i_ant : m_ant_configs)
            {
                int pos;
                do 
                {
                    pos = eap::rand(0, i_ant->m_positions.size()-1);
                } while (overlap(placements, i_ant->m_positions[pos]));
                placements.push_back(i_ant->m_positions[pos]);
            }
            m_pop.push_back(create_individual(str(nec_input % 0 % i_id) + "a%02d.nec", placements));
        }

        for (unsigned int i=0; i<m_generations; ++i)
        {
            create_pop(i);
            evaluate_gen(i);
            std::sort(m_pop.begin(), m_pop.end(), eap::fitness_sort);
            save_population(m_pop, run_id, i);
            save_best_nec(m_pop[0], run_id, i);
            std::cout<<"best "<<m_pop[0]->m_fitness<<"\n";
            survivor_selection();
        }
    }

    catch (...)
    {
        throw;
    }
}
vector<Individual> RandomGreedInitialization::run() {
	vector<int> aimed_time;
	vector<int> intersections;
	vector< pair<int, int> > time_intersections;
	vector<Individual> population;
	int num_intersections = problem->getNintersections();
	vector< vector<int> > scene = problem->getTable();
	int num_vehicles = problem->getNvehicles();
	int required_time = problem->getRequiredTime();
	int nones = problem->getNrsu();
	const int INTERSECTION_POOL = (nones*2 <= num_intersections) ? nones*2 : num_intersections;

	int npop = 0;
	int sum = 0;
	int time_vehicle;

	while(npop < this->size/2) {
		intersections.clear();
		aimed_time.clear();
		for(int i = 0; i < num_vehicles; i++) {
			aimed_time.push_back(required_time);
		}

		int genes_count = 0;
		while(genes_count < nones) {
			time_intersections.clear();
			sum = 0;
//			cout << "time_intersections\n";
			for(int i = 0; i < num_intersections; i++) {
				sum = 0;
				for(int j = 0; j < num_vehicles; j++) {
					time_vehicle = scene[i][j];
					if(time_vehicle > aimed_time[j])
						time_vehicle = aimed_time[j];
					sum += time_vehicle;
				}
				time_intersections.push_back(pair<int,int>(i,sum));
			}


			sort(time_intersections.begin(), time_intersections.end(), decreased_pair_sort);
//			cout << "sort\n";

			int chosen;
			if(npop == 0 && add_greed_solution) {
				chosen = time_intersections[0].first;
			} else {
				while(true) {
//					cout << "oi\n";
					chosen = time_intersections[Randomize::generate_long() % INTERSECTION_POOL].first;
					if(!exist(intersections, chosen)) {
						break;
					}
				}
			}

			//					int max = time_intersections[1].first;
//			cout << "aimed_time\n";
			for(int i = 0; i < num_vehicles; i++) {
				if(scene[chosen][i] != 0) {
					if(scene[chosen][i] >= aimed_time[i]) {
						aimed_time[i] = 0;
					} else {
						aimed_time[i] = aimed_time[i] - scene[chosen][i];
					}
				}
				scene[chosen][i] = 0;
			}
			genes_count++;
			intersections.push_back(chosen);
		}

		npop++;
//		cout << "individual creation\n";
		population.push_back(create_individual(intersections));
	}
	vector<Individual> random_population;
	RandomInitialization random_init = RandomInitialization(this->size/2, num_intersections, nones);
	random_population = random_init.run();

	for(unsigned i = 0; i < random_population.size(); i++) {
		population.push_back(random_population[i]);
	}

	return population;
}