IterativeAlgorithm.hpp

Go to the documentation of this file.

// This file is part of GQCG-GQCP.
//
// Copyright (C) 2017-2020  the GQCG developers
//
// GQCG-GQCP is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GQCG-GQCP is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with GQCG-GQCP.  If not, see <http://www.gnu.org/licenses/>.
 
#pragma once
 
 
#include "Mathematical/Algorithm/ConvergenceCriterion.hpp"
#include "Mathematical/Algorithm/StepCollection.hpp"
 
#include <boost/format.hpp>
 
#include <cstddef>
 
 
namespace GQCP {
 
 
template <typename _Environment>
class IterativeAlgorithm {
public:
    using Environment = _Environment;
 
 
private:
    size_t maximum_number_of_iterations;
    size_t iteration = 0;  // the number of iterations that have been performed
 
    StepCollection<Environment> steps;  // the collection of algorithm steps that is performed in-between convergence checks
    std::shared_ptr<ConvergenceCriterion<Environment>> convergence_criterion;
 
 
public:
    /*
     *  CONSTRUCTORS
     */
 
    template <typename Criterion>
    IterativeAlgorithm(const StepCollection<Environment>& steps, const Criterion& convergence_criterion, const size_t maximum_number_of_iterations = 128) :
        maximum_number_of_iterations {maximum_number_of_iterations},
        steps {steps},
        convergence_criterion {std::make_shared<Criterion>(convergence_criterion)} {}
 
 
    /*
     *  PUBLIC METHODS
     */
 
 
    std::string description() const {
 
        std::string description_string = (boost::format("An iterative algorithm (with a maximum of %s iterations) consisting of the following steps:\n") % this->maximumNumberOfIterations()).str();
        description_string += steps.description();
 
        description_string += "\nWith the following convergence criterion:\n";
        description_string += convergence_criterion->description();
 
        return description_string;
    }
 
 
    template <typename Z = Step<Environment>>
    enable_if_t<std::is_same<Environment, typename Z::Environment>::value, void> insert(const Z& step, const size_t index) { this->steps.insert(step, index); }
 
 
    size_t maximumNumberOfIterations() const { return this->maximum_number_of_iterations; }
 
    size_t numberOfIterations() const { return this->iteration; }
 
 
    void perform(Environment& environment) {
 
        for (this->iteration = 0; this->iteration <= this->maximum_number_of_iterations; this->iteration++) {  // do at maximum the maximum allowed number of iterations
 
            // Every iteration consists of two parts:
            //      - the convergence check, which checks if the iterations may stop
            //      - the iteration cycle, i.e. what happens in-between the convergence checks
            if (this->convergence_criterion->isFulfilled(environment)) {
                return;  // exit the loop and function early
            }
 
            this->steps.execute(environment);
        }
 
        // Since we will exit the function early if convergence is achieved, the algorithm is considered non-converging if the loop is done.
        throw std::runtime_error("IterativeAlgorithm<Environment>::perform(Environment&): The algorithm didn't find a solution within the maximum number of iterations.");
    }
 
 
    void remove(const size_t index) { this->steps.remove(index); }
 
 
    template <typename Z = Step<Environment>>
    enable_if_t<std::is_same<Environment, typename Z::Environment>::value, void> replace(const Z& step, const size_t index) { this->steps.replace(step, index); }
};
 
 
}  // namespace GQCP