NativePolytope.h

Go to the documentation of this file.

#ifndef STORM_STORAGE_GEOMETRY_NATIVEPOLYTOPE_H_
#define STORM_STORAGE_GEOMETRY_NATIVEPOLYTOPE_H_
 
#include <memory>
#include "storm/adapters/EigenAdapter.h"
#include "storm/storage/expressions/Expression.h"
#include "storm/storage/geometry/Polytope.h"
 
namespace storm {
namespace storage {
namespace geometry {
 
template<typename ValueType>
class NativePolytope : public Polytope<ValueType> {
   public:
    typedef Eigen::Matrix<ValueType, Eigen::Dynamic, Eigen::Dynamic> EigenMatrix;
    typedef Eigen::Matrix<ValueType, Eigen::Dynamic, 1> EigenVector;
 
    enum class EmptyStatus {
        Unknown,  // It is unknown whether the polytope is empty or not
        Empty,    // The polytope is empty
        Nonempty  // the polytope is not empty
    };
 
    typedef typename Polytope<ValueType>::Point Point;
 
    static std::shared_ptr<Polytope<ValueType>> create(boost::optional<std::vector<Halfspace<ValueType>>> const& halfspaces,
                                                       boost::optional<std::vector<Point>> const& points);
 
    NativePolytope(std::vector<Halfspace<ValueType>> const& halfspaces);
 
    NativePolytope(std::vector<Point> const& points);
 
    NativePolytope(NativePolytope<ValueType> const& other);
    NativePolytope(NativePolytope<ValueType>&& other);
 
    NativePolytope(EmptyStatus const& emptyStatus, EigenMatrix const& halfspaceMatrix, EigenVector const& halfspaceVector);
    NativePolytope(EmptyStatus&& emptyStatus, EigenMatrix&& halfspaceMatrix, EigenVector&& halfspaceVector);
 
    virtual ~NativePolytope();
 
    virtual std::vector<Point> getVertices() const override;
 
    virtual std::vector<Halfspace<ValueType>> getHalfspaces() const override;
 
    virtual bool isEmpty() const override;
 
    virtual bool isUniversal() const override;
 
    virtual bool contains(Point const& point) const override;
 
    virtual bool contains(std::shared_ptr<Polytope<ValueType>> const& other) const override;
 
    virtual std::shared_ptr<Polytope<ValueType>> intersection(std::shared_ptr<Polytope<ValueType>> const& rhs) const override;
    virtual std::shared_ptr<Polytope<ValueType>> intersection(Halfspace<ValueType> const& halfspace) const override;
 
    virtual std::shared_ptr<Polytope<ValueType>> convexUnion(std::shared_ptr<Polytope<ValueType>> const& rhs) const override;
 
    virtual std::shared_ptr<Polytope<ValueType>> minkowskiSum(std::shared_ptr<Polytope<ValueType>> const& rhs) const override;
 
    virtual std::shared_ptr<Polytope<ValueType>> affineTransformation(std::vector<Point> const& matrix, Point const& vector) const override;
 
    virtual std::pair<Point, bool> optimize(Point const& direction) const override;
 
    virtual std::vector<storm::expressions::Variable> declareVariables(storm::expressions::ExpressionManager& manager,
                                                                       std::string const& namePrefix) const override;
 
    virtual std::vector<storm::expressions::Expression> getConstraints(storm::expressions::ExpressionManager const& manager,
                                                                       std::vector<storm::expressions::Variable> const& variables) const override;
 
    virtual bool isNativePolytope() const override;
 
    virtual std::shared_ptr<Polytope<ValueType>> clean() override;
 
   private:
    // returns the vertices of this polytope as EigenVectors
    std::vector<EigenVector> getEigenVertices() const;
 
    // As optimize(..) but with EigenVectors
    std::pair<EigenVector, bool> optimize(EigenVector const& direction) const;
 
    // Stores whether the polytope is empty or not
    mutable EmptyStatus emptyStatus;
 
    // Intern representation of the polytope as { x | Ax<=b }
    EigenMatrix A;
    EigenVector b;
};
 
}  // namespace geometry
}  // namespace storage
}  // namespace storm
 
#endif /* STORM_STORAGE_GEOMETRY_NATIVEPOLYTOPE_H_ */