C++ Population::end方法代码示例

void GeneticAlgorithm::createOffspring(Population& newPopulation,
                                       bool doMutation) {
    Image& targetImage = *TargetImage::Instance();
    Population tmpResult;
    while (m_population.size() > 1) {

        m_inputLock.lock();

        if (m_population.size() <= 1) {
            m_inputLock.unlock();
            break;
        }
        std::pair<Organism*, Organism*> couple =
            m_pairGenerator.removeRandomPair(m_population);

        m_inputLock.unlock();

        Organism* child = new Organism(*couple.first, *couple.second, doMutation);
        double score = averagePixelDistance(targetImage, child->getPhenotype());
        child->setScore(score);

        tmpResult.push_back(child);
        tmpResult.push_back(couple.first);
        tmpResult.push_back(couple.second);
    }

    m_outputLock.lock();

    newPopulation.insert(newPopulation.end(), tmpResult.begin(),
                         tmpResult.end());

    m_outputLock.unlock();
}

void Crossover::do_crossover(Population& population) {
  shuffle(population.begin(), population.end(), rng);
  for (int index = 0; index + 1 < int(population.size()); index += 2)
    if (decide_to_do_crossover()) {
      auto crossed = do_crossover(population[index], population[index + 1]);
      show_crossing(crossed);
    }
}

        void Merge(const Population& population) {
            samples.resize(children_start + population.size());
            copy(population.begin(), population.end(), samples.begin()+children_start);
            sort(samples.begin(), samples.end());
            samples.resize(capacity());

            children_start = capacity();
        }

void PerPointStopCriterion<TFunction>::update(const Population& population) {
  for (Population::Iterator it = population.begin();
       it != population.end();
       ++it) {
    typename OnePointStopCriterion<TFunction>::Ptr one_point_stop_criterion =
      stop_criterion_info_->getInfoById(it.point_id());
    one_point_stop_criterion->update(it.point());
  }
}

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 );
}

Population run_island(Configuration conf, Individual initial_individual){
    // Random Number Generation
    std::default_random_engine eng(std::random_device{}());
    std::uniform_real_distribution<> dist(-5, 5);
    
    // population generation
    Population population;
    population.push_back(initial_individual);    // push the initial as it is.
    for (int i=1; i<conf.pop_size; i++) {
        Individual indi = mutate(conf, initial_individual);
        population.push_back(indi);
    }
    
    int generations = conf.num_generations;
    for (int g=0; g<generations; g++) {
        // first fitness calculation
        for (int i=0; i<conf.pop_size; i++) {
            population[i].score = fitness(population[i]);
        }
        
        // do sorting according to score
        std::sort(population.begin(), population.end(), compare);
        
        if (g != (conf.num_generations - 1)) {
            // crossover
            for (int i=0; i<(conf.pop_size / 2); i++) {
                crossover(conf, population[2*i], population[2*i+1]);
            }
            
            // mutate
            for (int i=0; i<conf.pop_size; i++) {
                population[i] = mutate(conf, population[i]);
            }
        }
    }
    
    return population;
}

/*
 * Use the genetic algorithm to construct a new population from the old
 */
Population GeneticPool::epoch(Population& old_pop, const BattleFieldLayout& bfl) {
  if (!initialized_ || old_pop.size() == 1) {
    Population new_pop = old_pop;
    new_pop.clear();
    old_pop.stats_.reset();

    for (Ship& t : old_pop) {
      t.calculateFitness(bfl, old_pop.facilities_.front(), old_pop.winner_);
      t.isElite = false;
    }

    //sort the population (for scaling and elitism)
    sort(old_pop.begin(), old_pop.end());

    //calculate best, worst, average and total fitness
    calculateStatistics(old_pop);

    for (Ship& t : old_pop) {
      new_pop.push_back(t.makeChild());
    }
    new_pop.stats_ = old_pop.stats_;
    return new_pop;
  }

  Population new_pop = old_pop;
  new_pop.clear();
  old_pop.stats_.reset();

  for (Ship& t : old_pop) {
    t.calculateFitness(bfl, old_pop.facilities_.front(), old_pop.winner_);
    t.isElite = false;
  }

  //sort the population (for scaling and elitism)
  sort(old_pop.begin(), old_pop.end());

  //calculate best, worst, average and total fitness
  calculateStatistics(old_pop);

  /*
   * Only winning teams get to have an elite by copying
   * some of the fittest genomes without any mutation/crossover.
   * Make sure we add an EVEN number or the roulette wheel sampling will crash
   * NOTE: we don't dont copy elites if we use perf descriptors since that is already a form of elitism
   */
  if (old_pop.winner_ && !layout_.usePerfDesc_ && layout_.numElite_ < old_pop.size()) {
    if (!(layout_.numEliteCopies_ * (layout_.numElite_ % 2))) {
      copyNBest(layout_.numElite_, layout_.numEliteCopies_, old_pop, new_pop);
    }
  }

  CHECK(old_pop.layout_.sl_.numPerfDesc_ == 4);
  PerfDescBsp<4, Ship> pdb;
  if (layout_.usePerfDesc_) {
    for (Ship& t : old_pop) {
      CHECK(t.perfDesc_.size() == 4);
      pdb.insert(&t);
    }
  }
  //now we enter the GA loop
  //repeat until a new population is generated
  while (new_pop.size() < old_pop.size()) {
    //grab two chromosones
    Ship& mum = pickSpecimen(old_pop);
    Ship* dad;
    if (layout_.usePerfDesc_) {
      CHECK(old_pop.size() > 2);
      auto pair = pdb.findClosestMate(&mum);
      Ship* closest = *pair.first;
      Coord dist = pair.second;
      if (dist == 0.0)
        dist = 0.01;

      vector<Ship*> result;

      Coord range = dist * 1.5;

      do {
        result = pdb.findInRange(&mum, range);
        range *= 1.5;
      } while (result.size() < 2);

      /*for(Ship* s : result) {
       std::cerr << s->perfDesc_[0] << '\t' << s->perfDesc_[2] << '\t' << s->perfDesc_[3] << '\t' << s->perfDesc_[4] << std::endl;
       }*/

      if (result.empty()) {
        dad = closest;
      } else {
        //std::cerr << "dist/range:" << dist << "\t" << range << std::endl;
        std::sort(result.begin(), result.end(), [&](const Ship* s1, const Ship* s2) {
          return s1->fitness_ < s2->fitness_;
        });

        dad = pickSpecimen(result);
      }
    } else
//.........这里部分代码省略.........