Merge pull request #436 from JuliaReach/schillic/docs_restructure

#159, #72 - Restructuring of docs

docs/make.jl

@@ -20,15 +20,18 @@ makedocs(
         "Operations on Sets" => "man/set_operations.md",
         "A Reachability Algorithm" => "man/reach_zonotopes.md",
         "A Hybrid Reachability Algorithm" => "man/reach_zonotopes_hybrid.md",
-        "Concrete Polyhedra" => "man/concrete_polyhedra.md"],
+        "Concrete Polyhedra" => "man/concrete_polyhedra.md",
+        ],
         "Library" => Any[
         "Set Interfaces" => "lib/interfaces.md",
         "Common Set Representations" => "lib/representations.md",
         "Common Set Operations" => "lib/operations.md",
         "Conversion between set representations" => "lib/conversion.md",
         "Binary Functions on Sets" => "lib/binary_functions.md",
         "Approximations" => "lib/approximations.md",
-        "Utility Functions" => "lib/utils.md"],
+        "Utility Functions" => "lib/utils.md",
+#         "Methods Collection" => "lib/methods_fix.md",
+        ],
         "About" => "about.md"
     ]
 )

docs/src/lib/approximations.md

@@ -44,14 +44,6 @@ symmetric_interval_hull
 box_approximation_helper
 ```
 
-### Metric properties of sets
-
-```@docs
-norm(::LazySet, ::Real)
-radius(::LazySet, ::Real)
-diameter(::LazySet, ::Real)
-```
-
 ## Iterative refinement
 
 ```@docs

docs/src/lib/binary_functions.md

@@ -17,36 +17,38 @@ end
 ## Subset check
 
 ```@docs
-⊆(::LazySet{Float64}, ::AbstractHyperrectangle{Float64})
-⊆(::AbstractPolytope{Float64}, ::AbstractHyperrectangle{Float64})
-⊆(::AbstractHyperrectangle{Float64}, ::AbstractHyperrectangle{Float64})
-⊆(::AbstractPolytope{Float64}, ::LazySet{Float64})
-⊆(::AbstractSingleton{Float64}, ::LazySet{Float64})
-⊆(::AbstractSingleton{Float64}, ::AbstractHyperrectangle{Float64})
-⊆(::AbstractSingleton{Float64}, ::AbstractSingleton{Float64})
-⊆(::Ball2{Float64}, ::Ball2{Float64})
-⊆(::Ball2{Float64}, ::AbstractSingleton{Float64})
+⊆(::LazySet{N}, ::AbstractHyperrectangle{N}, ::Bool=false) where {N<:Real}
+⊆(::AbstractPolytope{N}, ::LazySet{N}, ::Bool=false) where {N<:Real}
+⊆(::AbstractPolytope{N}, ::AbstractHyperrectangle, ::Bool=false) where {N<:Real}
+⊆(::AbstractHyperrectangle{N}, ::AbstractHyperrectangle{N}, ::Bool=false) where {N<:Real}
+⊆(::AbstractSingleton{N}, ::LazySet{N}, ::Bool=false) where {N<:Real}
+⊆(::AbstractSingleton{N}, ::AbstractHyperrectangle{N}, ::Bool=false) where {N<:Real}
+⊆(::AbstractSingleton{N}, ::AbstractSingleton{N}, ::Bool=false) where {N<:Real}
+⊆(::Ball2{AbstractFloat}, ::Ball2{AbstractFloat}, ::Bool=false) where {N<:AbstractFloat}
+	⊆(::Union{Ball2{N}, Ballp{N}}, ::AbstractSingleton{N}, ::Bool=false) where {N<:Real}
+⊆(::LineSegment{N}, ::LazySet{N}, ::Bool=false) where {N<:Real}
+⊆(::LineSegment{N}, ::Hyperrectangle{N}, ::Bool=false) where {N<:Real}
 ⊆(::Interval, ::Interval)
 ```
 
 ## Check for emptiness of intersection
 
 ```@docs
-is_intersection_empty(::AbstractHyperrectangle{Float64}, ::AbstractHyperrectangle{Float64})
-is_intersection_empty(::AbstractSingleton{Float64}, ::AbstractHyperrectangle{Float64})
-is_intersection_empty(::AbstractHyperrectangle{Float64}, ::AbstractSingleton{Float64})
-is_intersection_empty(::AbstractSingleton{Float64}, ::LazySet{Float64})
-is_intersection_empty(::LazySet{Float64}, ::AbstractSingleton{Float64})
-is_intersection_empty(::AbstractSingleton{Float64}, ::AbstractSingleton{Float64})
-is_intersection_empty(::Zonotope{Float64}, ::Hyperplane{Float64})
-is_intersection_empty(::Hyperplane{Float64}, ::Zonotope{Float64})
-is_intersection_empty(::Ball2{Float64}, ::Ball2{Float64})
-is_intersection_empty(::LineSegment{Float64}, ::LineSegment{Float64})
+is_intersection_empty(::AbstractHyperrectangle{N}, ::AbstractHyperrectangle{N}, ::Bool=false) where {N<:Real}
+is_intersection_empty(::AbstractHyperrectangle{N}, ::AbstractSingleton{N}, ::Bool=false) where {N<:Real}
+is_intersection_empty(::AbstractSingleton{N}, ::LazySet{N}, ::Bool=false) where {N<:Real}
+is_intersection_empty(::AbstractSingleton{N}, ::AbstractHyperrectangle{N}, ::Bool=false) where {N<:Real}
+is_intersection_empty(::AbstractSingleton{N}, ::AbstractSingleton{N}, ::Bool=false) where {N<:Real}
+is_intersection_empty(::LazySet{N}, ::AbstractSingleton{N}, ::Bool=false) where {N<:Real}
+is_intersection_empty(::Zonotope{N}, ::Hyperplane{N}, ::Bool=false) where {N<:Real}
+is_intersection_empty(::Hyperplane{N}, ::Zonotope{N}, ::Bool=false) where {N<:Real}
+is_intersection_empty(::Ball2{N}, ::Ball2{N}, ::Bool=false) where {N<:AbstractFloat}
+is_intersection_empty(::LineSegment{N}, ::LineSegment{N}, ::Bool=false) where {N<:Real}
 ```
 
 ## Intersection of two sets
 
 ```@docs
-intersection(::Line{Float64}, ::Line{Float64})
-intersection(::Hyperrectangle{Float64}, ::Hyperrectangle{Float64})
+intersection(::Line{N}, ::Line{N}) where {N<:Real}
+intersection(::Hyperrectangle{N}, ::Hyperrectangle{N}) where {N<:Real}
 ```

docs/src/lib/interfaces.md

@@ -44,14 +44,17 @@ Every `LazySet` type must define a function `σ` to compute the support vector.
 
 ```@docs
 support_vector
-ρ
+ρ(::AbstractVector{Real}, ::LazySet{Real})
 support_function
 ```
 
 ### Other globally defined set functions
 
 ```@docs
-an_element(S::LazySet{Float64})
+norm(::LazySet, ::Real)
+radius(::LazySet, ::Real)
+diameter(::LazySet, ::Real)
+an_element(::LazySet{Real})
 ```
 
 ## Point symmetric set
@@ -65,6 +68,13 @@ Note that there is a special interface combination
 AbstractPointSymmetric
 ```
 
+This interface defines the following functions:
+
+```@docs
+dim(::AbstractPointSymmetric)
+an_element(::AbstractPointSymmetric{N}) where {N<:Real}
+```
+
 ## Polytope
 
 A polytope has finitely many vertices (*V-representation*) resp. facets
@@ -79,7 +89,8 @@ AbstractPolytope
 This interface defines the following functions:
 
 ```@docs
-linear_map(M::AbstractMatrix, P::AbstractPolytope{Float64})
+singleton_list(::AbstractPolytope)
+linear_map(::AbstractMatrix, ::AbstractPolytope)
 ```
 
 ### Polygon
@@ -90,6 +101,12 @@ A polygon is a two-dimensional polytope.
 AbstractPolygon
 ```
 
+This interface defines the following functions:
+
+```@docs
+dim(P::AbstractPolygon)
+```
+
 #### HPolygon
 
 An HPolygon is a polygon in H-representation (or constraint representation).
@@ -98,6 +115,18 @@ An HPolygon is a polygon in H-representation (or constraint representation).
 AbstractHPolygon
 ```
 
+This interface defines the following functions:
+
+```@docs
+an_element(::AbstractHPolygon{N}) where {N<:Real}
+∈(::AbstractVector{Real}, ::AbstractHPolygon{Real})
+vertices_list(::AbstractHPolygon{Real})
+tohrep(::AbstractHPolygon{Real})
+tovrep(::AbstractHPolygon{Real})
+addconstraint!(::AbstractHPolygon{Real}, ::LinearConstraint{Real})
+constraints_list(::AbstractHPolygon{Real})
+```
+
 ### Point symmetric polytope
 
 A point symmetric polytope is a combination of two other interfaces:
@@ -107,6 +136,13 @@ A point symmetric polytope is a combination of two other interfaces:
 AbstractPointSymmetricPolytope
 ```
 
+This interface defines the following functions:
+
+```@docs
+dim(::AbstractPointSymmetricPolytope)
+an_element(::AbstractPointSymmetricPolytope{N}) where {N<:Real}
+```
+
 #### Hyperrectangle
 
 A hyperrectangle is a special point symmetric polytope with axis-aligned facets.
@@ -115,6 +151,16 @@ A hyperrectangle is a special point symmetric polytope with axis-aligned facets.
 AbstractHyperrectangle
 ```
 
+This interface defines the following functions:
+
+```@docs
+norm(::AbstractHyperrectangle, ::Real)
+radius(::AbstractHyperrectangle, ::Real)
+σ(::AbstractVector{Real}, ::AbstractHyperrectangle{Real})
+∈(::AbstractVector{Real}, ::AbstractHyperrectangle{Real})
+vertices_list(::AbstractHyperrectangle{Real})
+```
+
 #### Singleton
 
 A singleton is a special hyperrectangle consisting of only one point.
@@ -126,5 +172,12 @@ AbstractSingleton
 This interface defines the following functions:
 
 ```@docs
-linear_map(M::AbstractMatrix, S::AbstractSingleton{Float64})
-```
+σ(::AbstractVector{N}, ::AbstractSingleton{N}) where {N<:Real}
+∈(::AbstractVector{N}, ::AbstractSingleton{N}) where {N<:Real}
+an_element(::AbstractSingleton{N}) where {N<:Real}
+center(::AbstractSingleton{Real})
+vertices_list(::AbstractSingleton{N}) where {N<:Real}
+radius_hyperrectangle(::AbstractSingleton{Real})
+radius_hyperrectangle(::AbstractSingleton{Real}, ::Int)
+linear_map(::AbstractMatrix, ::AbstractSingleton{N}) where {N<:Real}
+```

docs/src/lib/methods_fix.md

@@ -0,0 +1,40 @@
+# Functions with several methods
+
+```@meta
+CurrentModule = LazySets
+DocTestSetup = quote
+    using RecipesBase, LazySets
+end
+```
+
+```@docs
+RecipesBase.apply_recipe
+addconstraint!
+an_element
+array
+center
+constraints_list
+convert
+diameter
+dim
+element
+halfspace_left
+halfspace_right
+high
+intersection
+low
+norm
+is_intersection_empty
+linear_map
+radius
+radius_hyperrectangle
+tohrep
+tovrep
+vertices_list
+*
++
+<=
+σ
+∈
+⊆
+```