Esempio n. 1
0
void Source::reproduction(const gsl_rng *rand){
        
        assign_fitness();

        gsl_ran_multinomial(rand, pop_size, pop_size, fitness, off_numbers);

        next_generation(rand);
        mutate_population(rand);
}
Esempio n. 2
0
void
APG::ConstraintSolver::run()
{
    if ( !m_readyToRun ) {
        error() << "DANGER WILL ROBINSON!  A ConstraintSolver (serial no:" << m_serialNumber << ") tried to run before its QueryMaker finished!";
        m_abortRequested = true;
        return;
    }

    if ( m_domain.empty() ) {
        debug() << "The QueryMaker returned no tracks";
        return;
    } else {
        debug() << "Domain has" << m_domain.size() << "tracks";
    }

    debug() << "Running ConstraintSolver" << m_serialNumber;

    emit totalSteps( m_maxGenerations );

    // GENETIC ALGORITHM LOOP
    Population population;
    quint32 generation = 0;
    Meta::TrackList* best = NULL;
    while ( !m_abortRequested && ( generation < m_maxGenerations ) ) {
        quint32 s = m_constraintTreeRoot->suggestPlaylistSize();
        m_suggestedPlaylistSize = (s > 0) ? s : m_suggestedPlaylistSize;
        fill_population( population );
        best = find_best( population );
        if ( population.value( best ) < m_satisfactionThreshold ) {
            select_population( population, best );
            mutate_population( population );
            generation++;
            emit incrementProgress();
        } else {
            break;
        }
    }
    debug() << "solution at" << (void*)(best);
    
    m_solvedPlaylist = best->mid( 0 );
    m_finalSatisfaction = m_constraintTreeRoot->satisfaction( m_solvedPlaylist );

    /* clean up */
    Population::iterator it = population.begin();
    while ( it != population.end() ) {
        delete it.key();
        it = population.erase( it );
    }

    emit endProgressOperation( this );
}
Esempio n. 3
0
void generate_new_generation(void *arg)
{
    struct thread_arguments_info *info = arg;
    int population_size = info->population_size;
    GeneWrapper * population = info->population;
    GeneWrapper * next_population = info->next_population;
    int i, num_iterations = NUM_ITERATIONS;

    GeneWrapper combined_populaton[population_size * 2];

    for (i = 0; i < population_size * 2; i++) {
        GeneWrapper * unitialized_gene = &combined_populaton[i];
        unitialized_gene->gene = malloc(sizeof(PacGene));
        unitialized_gene->score = 0;
    }

    char buffer[51];
    bzero(buffer, 51);
    while (num_iterations--  > 0) {

        for (i = 0; i < population_size * 2; i++) {
            NewStringFromGene(population[i % population_size].gene, buffer);
            SetGeneFromString(buffer, combined_populaton[i].gene);
        }
        printf("crossover_population \n");
        crossover_population(combined_populaton + population_size, population_size, population, population_size);
        mutate_population(combined_populaton, population_size, 0.1); // high mutation

        printf("reduce_population_through_ranking \n");
        int reduced_size = population_size * 2;
        remove_duplicates(combined_populaton, &reduced_size);
        reduce_population_through_ranking(combined_populaton, population_size, combined_populaton, max(reduced_size, population_size),
                                          population, population_size);
        for (i = 0; i < population_size; i++) {
            NewStringFromGene(combined_populaton[i].gene, buffer);
            SetGeneFromString(buffer, population[i].gene);
        }
    }
    
    for (i = 0; i < population_size * 2; i++) {
        free(combined_populaton[i].gene);
    }
    
    for (i = 0; i < population_size; i++) {
        NewStringFromGene(population[i].gene, buffer);
        SetGeneFromString(buffer, next_population[i].gene);
    }
}
Esempio n. 4
0
void Colony::reproduction(const gsl_rng *rand){
        int k,j,new_pop_size;
        double pop_fitness;
        assign_fitness();

        pop_fitness = 0.;
        for(j=0;j<pop_size;j++)
            {
            pop_fitness += fitness[j];
            }
        pop_fitness = pop_fitness*max_fitness;
        new_pop_size = gsl_ran_poisson(rand,pop_fitness);
//	printf("fitness: %lf\tnew pop size: %i\n", pop_fitness, new_pop_size);

        if (new_pop_size==0)
            {
             printf("extinct\n");
            exit(0);
            }
        if (new_pop_size>limit)
            {
            printf("established\n");
            exit(0);
            }

        gsl_ran_multinomial(rand, pop_size, new_pop_size, fitness, off_numbers);

        next_generation(rand);
        pop_size = new_pop_size;
        mutate_population(rand);

        for(j=pop_size;j<limit;j++)
            {
            for(k=0; k<n_del; k++)
                {
                del_matrix[j][k] = 0;
                }
            for(k=0; k<n_env; k++)
                {
                env_matrix[j][k] = 0;
                }
            }
};
Esempio n. 5
0
void crossover_population_helper(bool * flags, int index, int flag_array_size,
                                 GeneWrapper * unitialize_genes, GeneWrapper* p1, GeneWrapper* p2,
                                 int * first_uninitialized_gene) {
    // printf("%d %d \n", index, flag_array_size);
    int i;
    if (index == flag_array_size) {
        char buffer[51];
        char p1buffer[51];
        char p2buffer[51];

        int offsets[NUM_CROSS_OVERS]  = {0, 4, 7, 12, 16, 21, 26, 33, 38, 44};
        int sizes[NUM_CROSS_OVERS]  =      {4, 3,  5,  4,  5,  5,  7,  5,  6, 6};

        bzero(buffer, 51);
        bzero(p1buffer, 51);
        bzero(p2buffer, 51);
        GeneWrapper * unitialized_gene = &(unitialize_genes[*first_uninitialized_gene]);
        
        NewStringFromGene(p2->gene, buffer);
        NewStringFromGene(p1->gene, p1buffer);
        NewStringFromGene(p2->gene, p2buffer);
        for (i = 0; i < flag_array_size; i++) {
            if (flags[i]) {
                memcpy(buffer+offsets[i], p1buffer+offsets[i], sizes[i]);
            }
        }
        unitialized_gene->gene = malloc(sizeof(PacGene));
        unitialized_gene->score = 0;
 
        SetGeneFromString(buffer, unitialized_gene->gene);
        mutate_population(unitialized_gene, 1, 0.09);
        *first_uninitialized_gene = (*first_uninitialized_gene) + 1;
    } else {
        bool options[2] = {true, false};
        for (i = 0; i < 2; i++) {
            flags[index] = options[i];
            crossover_population_helper(flags, index+1, flag_array_size, unitialize_genes, p1, p2, first_uninitialized_gene);
        }
    }
}
Esempio n. 6
0
int main(void) {
	int n;
	FILE* fptr = fopen("input.in", "r");
	assert(fptr != NULL);
	
	n =	count_lines(fptr);
	printf("\nNumber of cities: %i\n",n);
	
	/*Init cities*/
	City* cities[n];
	read_cities(fptr, cities);
	printf("Init cities succesful... \n");
	
	/*Init distances*/
	double** distances;
	distances=calculate_distances(distances,cities, n);
	printf("Init distances succesful... \n");
	
	/*Init GA config*/
	Config config;
	config.populationSize=1000;
	config.mutationRate=0.2;
	config.numGenerations=6000;
	config.numElitism=1;
	config.mutationSize=1;
	config.maxBreeding=10;
	config.numGenes=n;
	printf("Init GA config succesful... \n");
	
	/*Init random seed*/
	srand ( time(NULL) );
	printf("Init random seed succesful... \n");
	
	/*Init population*/
    Population population;
	generate_random_population(&population, distances, &config);
	printf("Init population succesful... \n");

    int numGenerations = 0;
	
	/*Start evolution*/
	while(numGenerations < config.numGenerations){
		numGenerations++;
		
		if (numGenerations%1000==0) 
		printf("Shortest path of %ith generation: %i\n", numGenerations, population.path[0].fitness);
		
		/*Sort population*/
		qsort(population.path, population.numPaths, sizeof(Path), compare_population);
			
		/*Breed population*/
		simple_breed_population(&population, config.numGenes, distances);
		
		/*Mutate population*/
		mutate_population(&population, distances, &config);
		
		
	}
	/*Sort population*/
	qsort(population.path, population.numPaths, sizeof(Path), compare_population);
	
	printf("Shortest path is %i\n", population.path[0].fitness);
	
	int i;
	for(i=0;i<config.numGenes;i++){
		
		print_city(cities[population.path[0].combination[i]]);
		
	}
	
	
return 0;
}