AbstractEquationSolver.h

Go to the documentation of this file.

#ifndef STORM_SOLVER_ABSTRACTEQUATIONSOLVER_H_
#define STORM_SOLVER_ABSTRACTEQUATIONSOLVER_H_
 
#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
 
#endif /* STORM_SOLVER_ABSTRACTEQUATIONSOLVER_H_ */