Individual.h

Go to the documentation of this file.

//
// Class Individual
//   Structure for an individual in the population holding genes and objective
//   values.
//
//   @see Types.h
//
// Copyright (c) 2010 - 2013, Yves Ineichen, ETH Zürich
// All rights reserved
//
// Implemented as part of the PhD thesis
// "Toward massively parallel multi-objective optimization with application to
// particle accelerators" (https://doi.org/10.3929/ethz-a-009792359)
//
// This file is part of OPAL.
//
// OPAL is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// You should have received a copy of the GNU General Public License
// along with OPAL. If not, see <https://www.gnu.org/licenses/>.
//
#ifndef __INDIVIDUAL_H__
#define __INDIVIDUAL_H__
 
#include <algorithm>
#include <cmath>
#include <iostream>
#include <utility>
#include <vector>
 
#include "Expression/Expression.h"
 
class Individual {
 
public:

    typedef std::vector<double> genes_t;
    typedef std::vector<std::string> names_t;
    typedef std::vector<double> objectives_t;
    typedef std::vector< std::pair<double, double> > bounds_t;
    typedef Expressions::Named_t constraints_t;
 
    Individual()
    {}

    Individual(bounds_t gene_bounds, names_t names, constraints_t constraints)
        : bounds_m(gene_bounds)
        , names_m(names)
        , constraints_m(constraints)
    {
        genes_m.resize(bounds_m.size(), 0.0);
        objectives_m.resize(bounds_m.size(), 0.0);
 
        // names should be equal length to bounds
        if (names_m.size() != bounds_m.size()) {
            // shouldn't happen
            std::cerr << "Individual::Individual(): names not equal length to bounds, shouldn't happen exiting" << std::endl;
            exit(1);
        }
 
        int iter = 0;
        while (iter < 100) { // somewhat arbitrary limit
            for (size_t i=0; i < bounds_m.size(); i++) {
                new_gene(i);
            }
            // check constraints
            bool allSatisfied = checkConstraints();
            if (allSatisfied == true) break;
            // else next try
            iter++;
        }
    }

    Individual(std::shared_ptr<Individual> individual) {
        genes_m       =       genes_t(individual->genes_m);
        objectives_m  =  objectives_t(individual->objectives_m);
        bounds_m      =      bounds_t(individual->bounds_m);
        names_m       =       names_t(individual->names_m);
        constraints_m = constraints_t(individual->constraints_m);
        id_m          = individual->id_m;
    }

    template<class Archive>
    void serialize(Archive & ar, const unsigned int /*version*/) {
        ar & genes_m;
        ar & objectives_m;
        ar & id_m;
    }

    double new_gene(size_t gene_idx) {
        double max = std::max(bounds_m[gene_idx].first, bounds_m[gene_idx].second);
        double min = std::min(bounds_m[gene_idx].first, bounds_m[gene_idx].second);
        double delta = std::abs(max - min);
        genes_m[gene_idx] = rand() / (RAND_MAX + 1.0) * delta + min;
        return genes_m[gene_idx];
    }

    bool viable() {
        return checkBounds() && checkConstraints();
    }

    genes_t      genes_m;
    objectives_t objectives_m;
    unsigned int id_m = 0;
 
private:
    bool checkBounds() {
        for (size_t i=0; i < bounds_m.size(); i++) {
             double value = genes_m[i];
             double max = std::max(bounds_m[i].first, bounds_m[i].second);
             double min = std::min(bounds_m[i].first, bounds_m[i].second);
             bool is_valid = (value >= min && value<= max);
             if (is_valid == false) {
                 return false;
             }
        }
        return true;
    }

    bool checkConstraints() {
        for (auto namedConstraint : constraints_m) {
            Expressions::Expr_t *constraint = namedConstraint.second;
            std::set<std::string> req_vars = constraint->getReqVars();
            variableDictionary_t variable_dictionary;
            // fill variable dictionary. all required variables should be genes.
            for (std::string req_var : req_vars) {
                auto it = std::find(names_m.begin(),names_m.end(),req_var);
                if (it==names_m.end()) {
                    // should not happen
                    std::cerr << "Individual::checkConstraints(): " << req_var << " is not a design variable" << std::endl;
                    exit(1);
                }
                size_t gene_idx = std::distance(names_m.begin(),it);
                double value    = genes_m[gene_idx];
                variable_dictionary.insert(std::pair<std::string, double>(req_var, value));
            }
            Expressions::Result_t result =
                constraint->evaluate(variable_dictionary);
 
            double evaluation = boost::get<0>(result);
            bool   is_valid   = boost::get<1>(result);
 
            if (is_valid==false || evaluation==0) {
                return false;
            }
        }
        return true;
    }

    bounds_t bounds_m;
    names_t names_m;
    constraints_t constraints_m;
};
 
#endif