LpSolver.h

Go to the documentation of this file.

#ifndef STORM_SOLVER_LPSOLVER
#define STORM_SOLVER_LPSOLVER
 
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <vector>
#include "OptimizationDirection.h"
 
namespace storm {
namespace expressions {
class ExpressionManager;
class Variable;
class Expression;
enum class RelationType;
}  // namespace expressions
 
namespace solver {
 
template<typename ValueType>
struct RawLpConstraint {
    using VariableIndexType = uint64_t;
 
    RawLpConstraint(storm::expressions::RelationType relationType, ValueType const& rhs = {}, uint64_t reservedSize = 0);
 
    void addToLhs(VariableIndexType const& variable, ValueType const& coefficient);
 
    std::vector<VariableIndexType> lhsVariableIndices;
    std::vector<ValueType> lhsCoefficients;
    storm::expressions::RelationType relationType;
    ValueType rhs;
};
 
template<typename ValueType, bool RawMode = false>
class LpSolver {
   public:
    using Variable = std::conditional_t<RawMode, typename RawLpConstraint<ValueType>::VariableIndexType, storm::expressions::Variable>;
    using Constant = std::conditional_t<RawMode, ValueType, storm::expressions::Expression>;
    using Constraint = std::conditional_t<RawMode, RawLpConstraint<ValueType>, storm::expressions::Expression>;
 
    enum class VariableType { Continuous, Integer, Binary };
 
    LpSolver();
    LpSolver(OptimizationDirection const& optDir);
 
    virtual ~LpSolver() = default;
 
    Variable addBoundedContinuousVariable(std::string const& name, ValueType lowerBound, ValueType upperBound, ValueType objectiveFunctionCoefficient = 0);
 
    Variable addLowerBoundedContinuousVariable(std::string const& name, ValueType lowerBound, ValueType objectiveFunctionCoefficient = 0);
 
    Variable addUpperBoundedContinuousVariable(std::string const& name, ValueType upperBound, ValueType objectiveFunctionCoefficient = 0);
 
    Variable addUnboundedContinuousVariable(std::string const& name, ValueType objectiveFunctionCoefficient = 0);
 
    Variable addContinuousVariable(std::string const& name, std::optional<ValueType> const& lowerBound = std::nullopt,
                                   std::optional<ValueType> const& upperBound = std::nullopt, ValueType objectiveFunctionCoefficient = 0);
 
    Variable addBoundedIntegerVariable(std::string const& name, ValueType lowerBound, ValueType upperBound, ValueType objectiveFunctionCoefficient = 0);
 
    Variable addLowerBoundedIntegerVariable(std::string const& name, ValueType lowerBound, ValueType objectiveFunctionCoefficient = 0);
 
    Variable addUpperBoundedIntegerVariable(std::string const& name, ValueType upperBound, ValueType objectiveFunctionCoefficient = 0);
 
    Variable addUnboundedIntegerVariable(std::string const& name, ValueType objectiveFunctionCoefficient = 0);
 
    Variable addIntegerVariable(std::string const& name, std::optional<ValueType> const& lowerBound = std::nullopt,
                                std::optional<ValueType> const& upperBound = std::nullopt, ValueType objectiveFunctionCoefficient = 0);
 
    Variable addBinaryVariable(std::string const& name, ValueType objectiveFunctionCoefficient = 0);
 
    virtual Variable addVariable(std::string const& name, VariableType const& type, std::optional<ValueType> const& lowerBound = std::nullopt,
                                 std::optional<ValueType> const& upperBound = std::nullopt, ValueType objectiveFunctionCoefficient = 0) = 0;
 
    Constant getConstant(ValueType value) const;
 
    virtual void update() const = 0;
 
    virtual void addConstraint(std::string const& name, Constraint const& constraint) = 0;
 
    virtual void addIndicatorConstraint(std::string const& name, Variable indicatorVariable, bool indicatorValue, Constraint const& constraint) = 0;
 
    virtual void optimize() const = 0;
 
    virtual bool isInfeasible() const = 0;
 
    virtual bool isUnbounded() const = 0;
 
    virtual bool isOptimal() const = 0;
 
    virtual int_fast64_t getIntegerValue(Variable const& variable) const = 0;
 
    virtual bool getBinaryValue(Variable const& variable) const = 0;
 
    virtual ValueType getContinuousValue(Variable const& variable) const = 0;
 
    virtual ValueType getObjectiveValue() const = 0;
 
    virtual void writeModelToFile(std::string const& filename) const = 0;
 
    void setOptimizationDirection(OptimizationDirection const& optimizationDirection);
 
    OptimizationDirection getOptimizationDirection() const;
 
    storm::expressions::ExpressionManager const& getManager() const;
 
    virtual void push() = 0;
 
    virtual void pop() = 0;
 
    virtual void setMaximalMILPGap(ValueType const& gap, bool relative) = 0;
 
    virtual ValueType getMILPGap(bool relative) const = 0;
 
   protected:
    storm::expressions::Variable declareOrGetExpressionVariable(std::string const& name, VariableType const& type);
 
    // The manager responsible for the variables.
    std::shared_ptr<storm::expressions::ExpressionManager> manager;
 
    // A flag indicating whether the current model has been optimized and not changed afterwards.
    mutable bool currentModelHasBeenOptimized;
 
   private:
    // A flag that indicates the model sense.
    OptimizationDirection optimizationDirection;
};
}  // namespace solver
}  // namespace storm
 
#endif /* STORM_SOLVER_LPSOLVER */