Outsource HPolyhedron to its own module

docs/src/lib/interfaces/AbstractPolyhedron.md

@@ -42,6 +42,13 @@ LazySets._isbounded_stiemke
 LazySets._linear_map_polyhedron
 ```
 
+Some common functions implemented by several subtypes:
+
+```@docs
+addconstraint!(::AbstractPolyhedron, ::HalfSpace)
+is_hyperplanar(::AbstractPolyhedron)
+```
+
 Some common functions to work with linear constraints:
 
 ```@docs

docs/src/lib/sets/HPolyhedron.md

@@ -1,5 +1,5 @@
 ```@meta
-CurrentModule = LazySets
+CurrentModule = LazySets.HPolyhedronModule
 ```
 
 # [Polyhedron in constraint representation (HPolyhedron)](@id def_HPolyhedron)
@@ -8,44 +8,49 @@ CurrentModule = LazySets
 HPolyhedron
 ```
 
+## Operations
+
 The following methods are shared between `HPolytope` and `HPolyhedron`.
 
 ```@docs
-dim(::HPoly)
-ρ(::AbstractVector{M}, ::HPoly{N}) where {M, N}
-σ(::AbstractVector{M}, ::HPoly{N}) where {M, N}
-addconstraint!(::HPoly, ::HalfSpace)
 constraints_list(::HPoly)
-tohrep(::HPoly)
-tovrep(::HPoly)
+dim(::HPoly)
 normalize(::HPoly{N}, p::Real=N(2)) where {N}
-translate(::HPoly, ::AbstractVector)
 remove_redundant_constraints(::HPoly)
 remove_redundant_constraints!(::HPoly)
+tohrep(::HPoly)
+tovrep(::HPoly)
+addconstraint!(::HPoly, ::HalfSpace)
+ρ(::AbstractVector{M}, ::HPoly{N}) where {M, N}
+σ(::AbstractVector{M}, ::HPoly{N}) where {M, N}
+translate(::HPoly, ::AbstractVector)
+```
+
+The following methods are specific to `HPolyhedron`.
+
+```@docs
+rand(::Type{HPolyhedron})
 ```
+
+```@meta
+CurrentModule = LazySets
+```
+
 Inherited from [`LazySet`](@ref):
+* [`diameter`](@ref diameter(::LazySet, ::Real))
 * [`high`](@ref high(::LazySet))
+* [`isempty`](@ref isempty(::LazySet{N}, ::Bool=false) where {N})
 * [`low`](@ref low(::LazySet))
 * [`norm`](@ref norm(::LazySet, ::Real))
 * [`radius`](@ref radius(::LazySet, ::Real))
-* [`diameter`](@ref diameter(::LazySet, ::Real))
+* [`reflect`](@ref reflect(::LazySet))
 * [`singleton_list`](@ref singleton_list(::LazySet))
-* [`isempty`](@ref isempty(::LazySet{N}, ::Bool=false) where {N})
 * [`linear_map`](@ref linear_map(::AbstractMatrix, ::LazySet)
-* [`reflect`](@ref reflect(::LazySet))
 
 Inherited from [`AbstractPolyhedron`](@ref):
-* [`∈`](@ref ∈(::AbstractVector, ::AbstractPolyhedron))
 * [`an_element`](@ref an_element(::AbstractPolyhedron))
 * [`constrained_dimensions`](@ref constrained_dimensions(::AbstractPolyhedron))
-
-The following methods are specific to `HPolyhedron`.
-
-```@docs
-rand(::Type{HPolyhedron})
-```
-
-Inherited from [`AbstractPolyhedron`](@ref):
 * [`isbounded`](@ref isbounded(::AbstractPolyhedron{N}) where {N})
 * [`isuniversal`](@ref isuniversal(::AbstractPolyhedron{N}, ::Bool=false) where {N})
 * [`vertices_list`](@ref vertices_list(::AbstractPolyhedron, ::Bool=false))
+* [`∈`](@ref ∈(::AbstractVector, ::AbstractPolyhedron))

src/Initialization/init_Polyhedra.jl

@@ -37,6 +37,5 @@ function _is_polyhedra_backend(backend::Polyhedra.Library)
     return true
 end
 
-eval(load_polyhedra_hpolyhedron())
 eval(load_polyhedra_mesh())
 eval(load_polyhedra_lazyset())

src/Initialization/init_Symbolics.jl

@@ -1,5 +1,4 @@
-using .Symbolics: gradient,
-                  simplify,
+using .Symbolics: simplify,
                   Num,  # variable like, e.g. x[1]
                   Term, # term like, eg. x[1] + x[2] == 1
                   Symbolic,
@@ -20,4 +19,3 @@ end
 
 eval(load_symbolics_hyperplane())
 eval(load_symbolics_halfspace())
-eval(load_symbolics_hpolyhedron())

src/Interfaces/AbstractPolyhedron_functions.jl

@@ -2,7 +2,9 @@ export constrained_dimensions,
        tosimplehrep,
        remove_redundant_constraints,
        remove_redundant_constraints!,
-       isfeasible
+       isfeasible,
+       addconstraint!,
+       is_hyperplanar
 
 isconvextype(::Type{<:AbstractPolyhedron}) = true
 
@@ -1254,3 +1256,42 @@ function isfeasible(constraints::AbstractVector{<:HalfSpace},
         return !_isempty_polyhedron_lp(constraints, witness; solver=solver)
     end
 end
+
+"""
+    addconstraint!(P::AbstractPolyhedron, constraint::HalfSpace)
+
+Add a linear constraint to a set in constraint representation in-place.
+
+### Input
+
+- `P`          -- set in constraint representation
+- `constraint` -- linear constraint to add
+
+### Notes
+
+It is left to the user to guarantee that the dimension of all linear constraints
+is the same.
+"""
+function addconstraint!(::AbstractPolyhedron, ::HalfSpace) end
+
+"""
+    is_hyperplanar(P::AbstractPolyhedron)
+
+Determine whether a polyhedron is equivalent to a hyperplane.
+
+### Input
+
+- `P` -- polyhedron
+
+### Output
+
+`true` iff `P` is hyperplanar, i.e., consists of two linear constraints
+``a·x ≤ b`` and ``-a·x ≤ -b``.
+"""
+function is_hyperplanar(::AbstractPolyhedron) end
+
+# internal function; defined here due to dependency SymEngine and submodules
+function _is_halfspace() end
+
+# internal function; defined here due to dependency SymEngine and submodules
+function _is_hyperplane() end

src/LazySets.jl

@@ -126,7 +126,9 @@ include("Sets/HPolygonOpt.jl")
 include("Sets/HPolytope/HPolytopeModule.jl")
 @reexport using ..HPolytopeModule: HPolytope
 
-include("Sets/HPolyhedron.jl")
+include("Sets/HPolyhedron/HPolyhedronModule.jl")
+@reexport using ..HPolyhedronModule: HPolyhedron
+using ..HPolyhedronModule: HPoly
 
 include("Sets/HParallelotope/HParallelotopeModule.jl")
 @reexport using ..HParallelotopeModule: HParallelotope,