src/Population.hpp

/***
 * @file Population.hpp
 *
 * This is based on what we did with A. Kornilov for his Master Thesis
 * work, but I ended up removing the Hadoop-connectivity, because it
 * made this a bit cluttered and dependent on the Hadoop platform. I
 * suppose it could be re-implemented here, should we return to those
 * issues later on. For my PhD, I'll be dealing with datasets that fit
 * in memory.
 */
#include <iostream>
#include <vector>
#include <memory>
#include <random>

#include "Individual.hpp"

using namespace std;

#ifndef POPULATION_HPP_
#define POPULATION_HPP_

class Population {

    // -------------------- Internals ---------------------
protected:
    vector<unique_ptr<Individual> > _individuals;

    size_t _nobj;

public:
    // Means of creation and destroying
    Population(int nobj);
    Population() = delete;

    /* Become the merger of two populations; invalidates parents. */
    //Population(Population &p1, Population &p2);
    virtual ~Population();
    
    // -------------- read and write ------------------

    void fromStream(istream & ist, const IndividualReader * rdr);
    void toStream (ostream & ost) const;

    double getObjectiveValue (int individualIndex, int objectiveIndex) const;

    vector<double> getTrace (int individualIndex) const;    

    int getIndividualID (int individualIndex) const;

    void setIndividualID (int individualIndex, int newID);
    
    size_t size() const;

    void adopt(unique_ptr<Individual> indiv);

    void clear();

    void adoptFrom(Population & p1);

    void adoptFromTwo(Population & p1, Population & p2);

    void deepCopyFrom(Population & p1);

    // -------------- operations delegated to individuals ------------------

    void evaluate();

    void mutate();

    void improve(mt19937 * mt);

    int binaryTournament(int ii1, int ii2, mt19937 * mt);

    // -------------- operations partially delegated to individuals ----

#if 1 //----------------- FIXME: NOT YET (RE-) IMPLEMENTED PROPERLY
public:
    // ----- Public interface for Nondominated sorting:
    void assignRankAndCrowdingDistance();

    void fillNondominatedSortFrom(Population &parent);

    // Interface for tournament selection and crossover:
    // Nah.. wouldn't we want a separate selector (friend) class?
    void selectAndCrossFrom(Population &parent, mt19937 *mt);

    // ----- Routines for Nondominated sorting, with protected helpers:

protected:
    void quicksortFrontObj(int objcount, int *obj_array, int front_size) const;
    void quicksortDist(int *dist, int front_size) const;
    void crowdingFillFrom(Population &mixed, int count, int front_size, void *plstelite);
    void assignCrowdingDistance (int *dist, int **obj_array, int front_size);
    void assignCrowdingDistanceList (void *plst, int front_size);
    void assignCrowdingDistanceIndices (int c1, int c2);
    int binaryTournament (int a, int b, mt19937 *mt) const;
    
#endif // ---------------------------- end of unimplemented part.

};

#endif

---