void GAStuff() { GARandomSeed(1); genome = new GAListGenome<int>(Objective); genome->initializer(::Initializer); genome->mutator(::Mutator); genome->comparator(::Comparator); genome->crossover(XOVER); dbg<<"inicijalizovao genom\n"; ga = new GASteadyStateGA(*genome); dbg<<"napravio ga\n"; ga->minimize(); ga->pReplacement(1.0); ga->populationSize(100); ga->nGenerations(100); ga->pMutation(0.1); ga->pCrossover(1.0); ga->pMutation(0.3); ga->terminator(Terminator); //ga->pConvergence(1); ga->selectScores(GAStatistics::AllScores); //ga->terminator(GAGeneticAlgorithm::TerminateUponPopConvergence); //ga.parameters(argc, argv); ga->initialize(seed); dbg<<"inicijalozovao GA\n"; }
// To initialize this genetic algorithm, we make sure all of our spawns are // not evolving then we tell them all to initialize themselves. Then we wait // and copy their populations into our own. Update our stats based upon the // harvested populations. void PVMDemeGA::initialize(unsigned int seed) { GARandomSeed(seed); if(_mid == 0) return; #ifdef DEBUG cerr << "sending initialize command to slaves...\n"; #endif for(int j=0; j<_ntid; j++) { _status = pvm_initsend(PvmDataDefault); _status = pvm_send(_tid[j], MSG_INITIALIZE); } collect(); for(int i=0; i<_ntid; i++) { pstats[i].reset(*deme[i]); pop->individual(i).copy(deme[i]->best()); } pop->touch(); stats.reset(*pop); }
int main(int argc, char **argv) { cout << "Example 4\n\n"; cout << "This program tries to fill a 3DBinaryStringGenome with\n"; cout << "alternating 1s and 0s using a SteadyStateGA\n\n"; cout.flush(); // See if we've been given a seed to use (for testing purposes). When you // specify a random seed, the evolution will be exactly the same each time // you use that seed number. for(int ii=1; ii<argc; ii++) { if(strcmp(argv[ii++],"seed") == 0) { GARandomSeed((unsigned int)atoi(argv[ii])); } } int depth = 3; int width = 10; int height = 5; // Now create the GA and run it. First we create a genome of the type that // we want to use in the GA. The ga doesn't use this genome in the // optimization - it just uses it to clone a population of genomes. GA3DBinaryStringGenome genome(width, height, depth, objective); // Now that we have the genome, we create the genetic algorithm and set // its parameters - number of generations, mutation probability, and crossover // probability. By default the GA keeps track of the best of generation scores // and also keeps one genome as the 'best of all' - the best genome // that it encounters from all of the generations. Here we tell the GA to // keep track of all scores, not just the best-of-generation. GASteadyStateGA ga(genome); ga.populationSize(100); ga.pReplacement(0.50); // replace 50% of population each generation // ga.nReplacement(4); // number of individuals to replace each gen ga.nGenerations(200); ga.pMutation(0.001); ga.pCrossover(0.9); ga.scoreFilename("bog.dat"); // name of file for scores ga.scoreFrequency(10); // keep the scores of every 10th generation ga.flushFrequency(50); // specify how often to write the score to disk ga.selectScores(GAStatistics::AllScores); ga.evolve(); // Now we print out the best genome. cout << "the ga generated:\n" << ga.statistics().bestIndividual() << "\n"; cout << "best of generation data are in 'bog.dat'\n"; // That's it! return 0; }
// Do some basic stupidity checks then initialize the population. We must // also initialize our temporary genomes, but we don't have to evaluate // them. Finally, reset the statistics. void GAIncrementalGA::initialize(unsigned int seed) { GARandomSeed(seed); pop->initialize(); pop->evaluate(gaTrue); stats.reset(*pop); if(!scross) GAErr(GA_LOC, className(), "initialize", gaErrNoSexualMating); }
// Initialize the population, set the random seed as needed, do a few stupidity // checks, reset the stats. We must initialize the old pop because there is no // guarantee that each individual will get initialized during the course of our // operator++ operations. We do not evaluate the old pop because that will // happen as-needed later on. void GASimpleGA::initialize(unsigned int seed) { GARandomSeed(seed); pop->initialize(); pop->evaluate(gaTrue); // the old pop will get it when the pops switch // oldPop->initialize(); stats.reset(*pop); if(!scross) GAErr(GA_LOC, className(), "initialize", gaErrNoSexualMating); }
int main(int argc, char **argv) { // a seed to use (for testing purposes). When you // specify a random seed, the evolution will be exactly the same each time // you use that seed number. for(int ii=1; ii<argc; ii++) { if(strcmp(argv[ii++],"seed") == 0) { GARandomSeed((unsigned int)atoi(argv[ii])); } } // Declare variables for the GA parameters and set them to some default values. //int width = 50; //int height = 41; int length=730; int popsize = 100; int ngen = 4000; float pmut = 0.001; float pcross = 0.9; // Now create the GA and run it. Fist we create a genome of the type that // we want to use in the GA. The ga doesn't operate on this genome in the // optimization - it just uses it to clone a population of genomes. GA1DBinaryStringGenome genome(length, Objective); // Now that we have the genome, we create the genetic algorithm and set // its parameters - number of generations, mutation probability, and crossover // probability. And finally we tell it to evolve itself. GASteadyStateGA ga(genome); ga.populationSize(popsize); ga.nGenerations(ngen); ga.pMutation(pmut); ga.pCrossover(pcross); ga.nBestGenomes(90); ga.evolve(); // Now we print out the best genome that the GA found. cout << "The GA found:\n" << ga.statistics().bestPopulation() << "\n"; // That's it! fclose(fp); return 0; }
float Objective(GAGenome &); // This is the declaration of our obj function. // The definition comes later in the file. int main(int argc, char **argv) { cout << "Example 1\n\n"; cout << "This program tries to fill a 2DBinaryStringGenome with\n"; cout << "alternating 1s and 0s using a SimpleGA\n\n"; cout.flush(); // See if we've been given a seed to use (for testing purposes). When you // specify a random seed, the evolution will be exactly the same each time // you use that seed number. for (int ii = 1; ii < argc; ii++) { if (strcmp(argv[ii++], "seed") == 0) { GARandomSeed((unsigned int) atoi(argv[ii])); } } // Declare variables for the GA parameters and set them to some default values. int width = 10; int height = 5; int popsize = 30; int ngen = 400; float pmut = 0.001; float pcross = 0.9; // Now create the GA and run it. First we create a genome of the type that // we want to use in the GA. The ga doesn't operate on this genome in the // optimization - it just uses it to clone a population of genomes. GA2DBinaryStringGenome genome(width, height, Objective); // Now that we have the genome, we create the genetic algorithm and set // its parameters - number of generations, mutation probability, and crossover // probability. And finally we tell it to evolve itself. GASimpleGA ga(genome); ga.populationSize(popsize); ga.nGenerations(ngen); ga.pMutation(pmut); ga.pCrossover(pcross); ga.evolve(); // Now we print out the best genome that the GA found. cout << "The GA found:\n" << ga.statistics().bestIndividual() << "\n";
// We only use the sexual mating, so only check for that one. Initialize each // of the popultions and set stats appropriately. void GADemeGA::initialize(unsigned int seed) { GARandomSeed(seed); for(unsigned int i=0; i<npop; i++) { deme[i]->initialize(); deme[i]->evaluate(gaTrue); pstats[i].reset(*deme[i]); pop->individual(i).copy(deme[i]->best()); } pop->touch(); stats.reset(*pop); if(!scross) GAErr(GA_LOC, className(), "initialize", gaErrNoSexualMating); }
int main(int argc, char *argv[]) { cout << "Example 11\n\n"; cout << "This program illustrates the use of order-based lists. The\n"; cout << "list in this problem contains 25 numbers, 0 to 24. It tries\n"; cout << "to put them in descending order from 24 to 0.\n\n"; cout.flush(); // See if we've been given a seed to use (for testing purposes). When you // specify a random seed, the evolution will be exactly the same each time // you use that seed number. for(int ii=1; ii<argc; ii++) { if(strcmp(argv[ii++],"seed") == 0) { GARandomSeed((unsigned int)atoi(argv[ii])); } } // Set the default values of the parameters. GAParameterList params; GASteadyStateGA::registerDefaultParameters(params); params.set(gaNpopulationSize, 30); // population size params.set(gaNpCrossover, 0.6); // probability of crossover params.set(gaNpMutation, 0.01); // probability of mutation params.set(gaNnGenerations, 1000); // number of generations params.set(gaNpReplacement, 0.5); // how much of pop to replace each gen params.set(gaNscoreFrequency, 10); // how often to record scores params.set(gaNnReplacement, 4); // how much of pop to replace each gen params.set(gaNflushFrequency, 10); // how often to dump scores to file params.set(gaNscoreFilename, "bog.dat"); // params.read("settings.txt"); // grab values from file first params.parse(argc, argv, gaFalse); // parse command line for GAlib args // Now create the GA and run it. We first create a genome with the // operators we want. Since we're using a template genome, we must assign // all three operators. We use the order-based crossover site when we assign // the crossover operator. GAListGenome<int> genome(objective); genome.initializer(ListInitializer); genome.mutator(GAListGenome<int>::SwapMutator); // Now that we have our genome, we create the GA (it clones the genome to // make all of the individuals for its populations). Set the parameters on // the GA then let it evolve. GASteadyStateGA ga(genome); ga.crossover(GAListGenome<int>::PartialMatchCrossover); ga.parameters(params); ga.evolve(); // Assign the best that the GA found to our genome then print out the results. genome = ga.statistics().bestIndividual(); cout << "the ga generated the following list (objective score is "; cout << genome.score() << "):\n" << genome << "\n"; cout << "best of generation data are in '" << ga.scoreFilename() << "'\n"; cout << ga.parameters() << "\n"; // char *fn; // ga.get(gaNscoreFilename, &fn); // cout << "filename is '" << fn << "'\n"; return 0; }
int main(int argc, char **argv) { srand(time(NULL)); GARandomSeed(); bool gameIsRunning = false; // SDL SDL_Window* window = nullptr; SDL_Event sdlEvent; SDL_Renderer* renderer = nullptr; TextureManager* textureManager = nullptr; MyB2DebugDraw* debugDraw = nullptr; MyB2ContactListener* contactListener = nullptr; // Fonts TTF_Font* font = nullptr; if (SDL_Init(SDL_INIT_VIDEO) < 0) { return -1; } window = SDL_CreateWindow("GA Test", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_SHOWN); if (!window) { return -1; } renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC); if (!renderer) { return -1; } SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF); // Initialize SDL PNG loading int imgFlags = IMG_INIT_PNG; if (!(IMG_Init(imgFlags) & imgFlags)) { printf("SDL_image could not initialize! SDL_image Error: %s\n", IMG_GetError()); return -1; } // Initialize SDL ttf if (TTF_Init() == -1) { printf("SDL_ttf could not initialize! SDL_ttf Error: %s\n", TTF_GetError()); return -1; } // Open ttf font font = TTF_OpenFont((dir_fonts + "OpenSans-Regular.ttf").c_str(), 12); textureManager = TextureManager::GetInstance(); textureManager->Init(renderer, dir_assets); // Game variables //float dt = 1.0f / 10.0f; double dt_fixed = 1.0 / 60.0; float t = 0.0f; auto currentTime = std::chrono::system_clock::now(); debugDraw = new MyB2DebugDraw(renderer); debugDraw->SetFlags(b2Draw::e_shapeBit //| b2Draw::e_aabbBit | b2Draw::e_jointBit | b2Draw::e_centerOfMassBit); contactListener = new MyB2ContactListener(); // Box2D b2Vec2 gravity(0.0f, 0.0f); b2World* box2Dworld = new b2World(gravity); //box2Dworld->SetDebugDraw(debugDraw); box2Dworld->SetContactListener(contactListener); Game* game = new Game(window, renderer, WINDOW_WIDTH, WINDOW_HEIGHT, box2Dworld, textureManager, font); game->Init(dir_assets, dir_fonts, dir_textures, dt_fixed); gameIsRunning = true; vec2 curMouseClickPos; while (gameIsRunning) { while (SDL_PollEvent(&sdlEvent) != 0) { if (SDL_GetMouseState(NULL, NULL) & SDL_BUTTON(SDL_BUTTON_LEFT)) { SDL_GetMouseState(&curMouseClickPos.x, &curMouseClickPos.y); } if (sdlEvent.type == SDL_QUIT) { gameIsRunning = false; } else if (sdlEvent.type == SDL_KEYDOWN) { switch (sdlEvent.key.keysym.sym) { case SDLK_w: game->GetPlayerShip()->ActivateEventTrigger(Ship::THRUST_FORWARD, true); break; case SDLK_s: game->GetPlayerShip()->ActivateEventTrigger(Ship::THRUST_BACKWARD, true); break; case SDLK_a: game->GetPlayerShip()->ActivateEventTrigger(Ship::TORQUE_LEFT, true); break; case SDLK_d: game->GetPlayerShip()->ActivateEventTrigger(Ship::TORQUE_RIGHT, true); break; case SDLK_r: if (game->GetPlayerShip()) game->GetPlayerShip()->Reset(); break; case SDLK_e: game->GetPlayerShip()->ActivateEventTrigger(Ship::STRAFE_RIGHT, true); break; case SDLK_q: game->GetPlayerShip()->ActivateEventTrigger(Ship::STRAFE_LEFT, true); break; case SDLK_SPACE: game->GetPlayerShip()->ActivateEventTrigger(Ship::SHOOT, true); break; case SDLK_LSHIFT: game->GetPlayerShip()->ActivateEventTrigger(Ship::STABILIZE, true); break; case SDLK_ESCAPE: gameIsRunning = false; break; } } else if (sdlEvent.type == SDL_KEYUP) { switch (sdlEvent.key.keysym.sym) { case SDLK_w: game->GetPlayerShip()->ActivateEventTrigger(Ship::THRUST_FORWARD, false); break; case SDLK_s: game->GetPlayerShip()->ActivateEventTrigger(Ship::THRUST_BACKWARD, false); break; case SDLK_a: game->GetPlayerShip()->ActivateEventTrigger(Ship::TORQUE_LEFT, false); break; case SDLK_d: game->GetPlayerShip()->ActivateEventTrigger(Ship::TORQUE_RIGHT, false); break; case SDLK_e: game->GetPlayerShip()->ActivateEventTrigger(Ship::STRAFE_RIGHT, false); break; case SDLK_q: game->GetPlayerShip()->ActivateEventTrigger(Ship::STRAFE_LEFT, false); break; case SDLK_SPACE: game->GetPlayerShip()->ActivateEventTrigger(Ship::SHOOT, false); break; case SDLK_LSHIFT: game->GetPlayerShip()->ActivateEventTrigger(Ship::STABILIZE, false); break; } } } // Update game //game->Update(dt); // Draw game //game->Draw(); // Present final canvas //SDL_RenderPresent(renderer); } if (game) { delete game; game = nullptr; } if (debugDraw) { delete debugDraw; debugDraw = nullptr; } if (contactListener) { delete contactListener; contactListener = nullptr; } TextureManager::Destroy(); textureManager = nullptr; TTF_CloseFont(font); font = nullptr; SDL_DestroyWindow(window); window = nullptr; SDL_DestroyRenderer(renderer); renderer = nullptr; TTF_Quit(); IMG_Quit(); SDL_Quit(); _CrtDumpMemoryLeaks(); return 0; }
int main(int argc, char *argv[]) { cout << "Example 8\n\n"; cout << "This program runs a steady-state GA whose objective function\n"; cout << "tries to maximize the size of the list and tries to make lists\n"; cout << "that contain the number 101 in the nodes. The lists contain\n"; cout << "ints in the nodes.\n\n"; cout.flush(); // See if we've been given a seed to use (for testing purposes). When you // specify a random seed, the evolution will be exactly the same each time // you use that seed number. for(int i=1; i<argc; i++) { if(strcmp(argv[i++],"seed") == 0) GARandomSeed((unsigned int)atoi(argv[i])); } // Create the initial genome for the genetic algorithm to use. Set the // initializer and mutation before we make the genetic algorithm. GAListGenome<int> genome(objective); genome.initializer(ListInitializer); // genome.mutator(GAListGenome<int>::SwapMutator); genome.mutator(GAListGenome<int>::DestructiveMutator); // Now that we have a genome, we use it to create our GA. After creating the // GA we set the parameters and tell the GA to use sigma truncation scaling // rather than the default (linear scaling). Set the crossover to single // point crossover. The genetic algorithm handles crossover since genomes // don't know about other genomes. We could set the crossover on the genome // if we wanted - either way will work. GASteadyStateGA ga(genome); GASigmaTruncationScaling scale; ga.scaling(scale); ga.crossover(GAListGenome<int>::OnePointCrossover); // Set the default parameters we want to use, then check the command line for // other arguments that might modify these. ga.set(gaNpopulationSize, 40); // population size ga.set(gaNpCrossover, 0.6); // probability of crossover ga.set(gaNpMutation, 0.05); // probability of mutation ga.set(gaNnGenerations, 50); // number of generations ga.set(gaNscoreFrequency, 1); // how often to record scores ga.set(gaNflushFrequency, 10); // how often to dump scores to file ga.set(gaNselectScores, // which scores should we track? GAStatistics::Maximum|GAStatistics::Minimum|GAStatistics::Mean); ga.set(gaNscoreFilename, "bog.dat"); ga.parameters(argc, argv); // Evolve the genetic algorithm then dump out the results of the run. ga.evolve(); genome = ga.statistics().bestIndividual(); // cout << "the ga generated the list:\n" << genome << "\n"; cout << "the list contains " << genome.size() << " nodes\n"; cout << "the ga used the parameters:\n" << ga.parameters() << "\n"; return 0; }