AbstractEquationSolver.h

Go to the documentation of this file.

#pragma once
 
#include <boost/optional.hpp>
#include <chrono>
#include <iostream>
#include <memory>
 
#include "storm/solver/SolverStatus.h"
#include "storm/solver/TerminationCondition.h"
#include "storm/utility/ProgressMeasurement.h"
 
namespace storm {
namespace solver {
 
template<typename ValueType>
class AbstractEquationSolver {
   public:
    AbstractEquationSolver();

    void setTerminationCondition(std::unique_ptr<TerminationCondition<ValueType>> terminationCondition);

    void resetTerminationCondition();

    bool hasCustomTerminationCondition() const;

    bool terminateNow(std::vector<ValueType> const& values, SolverGuarantee const& guarantee) const;

    bool hasRelevantValues() const;

    storm::storage::BitVector const& getRelevantValues() const;
    boost::optional<storm::storage::BitVector> const& getOptionalRelevantValues() const;

    void setRelevantValues(storm::storage::BitVector&& valuesOfInterest);

    void setRelevantValues(storm::storage::BitVector const& valuesOfInterest);

    void clearRelevantValues();
 
    enum class BoundType { Global, Local, Any };

    bool hasLowerBound(BoundType const& type = BoundType::Any) const;

    bool hasUpperBound(BoundType const& type = BoundType::Any) const;

    void setLowerBound(ValueType const& value);

    void setUpperBound(ValueType const& value);

    void setBounds(ValueType const& lower, ValueType const& upper);

    ValueType const& getLowerBound() const;

    ValueType const& getLowerBound(uint64_t const& index) const;

    ValueType getLowerBound(bool convertLocalBounds) const;

    ValueType const& getUpperBound() const;

    ValueType const& getUpperBound(uint64_t const& index) const;

    ValueType getUpperBound(bool convertLocalBounds) const;

    std::vector<ValueType> const& getLowerBounds() const;

    std::vector<ValueType> const& getUpperBounds() const;

    void setLowerBounds(std::vector<ValueType> const& values);

    void setLowerBounds(std::vector<ValueType>&& values);

    void setUpperBounds(std::vector<ValueType> const& values);

    void setUpperBounds(std::vector<ValueType>&& values);

    void setBounds(std::vector<ValueType> const& lower, std::vector<ValueType> const& upper);
 
    void setBoundsFromOtherSolver(AbstractEquationSolver<ValueType> const& other);

    void clearBounds();

    bool isShowProgressSet() const;

    uint64_t getShowProgressDelay() const;

    void startMeasureProgress(uint64_t startingIteration = 0) const;

    void showProgressIterative(uint64_t iterations, boost::optional<uint64_t> const& bound = boost::none) const;
 
   protected:
    TerminationCondition<ValueType> const& getTerminationCondition() const;
    std::unique_ptr<TerminationCondition<ValueType>> const& getTerminationConditionPointer() const;
 
    void createUpperBoundsVector(std::vector<ValueType>& upperBoundsVector) const;
    void createUpperBoundsVector(std::unique_ptr<std::vector<ValueType>>& upperBoundsVector, uint64_t length) const;
    void createLowerBoundsVector(std::vector<ValueType>& lowerBoundsVector) const;

    void reportStatus(SolverStatus status, boost::optional<uint64_t> const& iterations = boost::none) const;

    SolverStatus updateStatus(SolverStatus status, std::vector<ValueType> const& x, SolverGuarantee const& guarantee, uint64_t iterations,
                              uint64_t maximalNumberOfIterations) const;

    SolverStatus updateStatus(SolverStatus status, bool earlyTermination, uint64_t iterations, uint64_t maximalNumberOfIterations) const;
 
    // A termination condition to be used (can be unset).
    std::unique_ptr<TerminationCondition<ValueType>> terminationCondition;
 
    // A bit vector containing the indices of the relevant values if they were set.
    boost::optional<storm::storage::BitVector> relevantValues;
 
    // A lower bound if one was set.
    boost::optional<ValueType> lowerBound;
 
    // An upper bound if one was set.
    boost::optional<ValueType> upperBound;
 
    // Lower bounds if they were set.
    boost::optional<std::vector<ValueType>> lowerBounds;
 
    // Lower bounds if they were set.
    boost::optional<std::vector<ValueType>> upperBounds;
 
   private:
    // Indicates the progress of this solver.
    mutable boost::optional<storm::utility::ProgressMeasurement> progressMeasurement;
};
 
}  // namespace solver
}  // namespace storm