Revise discretize

docs/src/lib/discretize.md

@@ -12,16 +12,3 @@ CurrentModule = Reachability.ReachSets
 ```@docs
 discretize
 ```
-
-## Dense-time reachability
-
-```@docs
-discr_bloat_firstorder
-discr_bloat_interpolation
-```
-
-## Discrete-time reachability
-
-```@docs
-discr_no_bloat
-```

src/ReachSets/ContinuousPost/BFFPSV18/BFFPSV18.jl

@@ -24,7 +24,7 @@ end
 function options_BFFPSV18()
     return OptionSpec[
         # general options
-        OptionSpec(:approx_model, "forward", domain=String, domain_check=(
+        OptionSpec(:approximation, "forward", domain=String, domain_check=(
             v  ->  v in ["forward", "backward", "firstorder", "nobloating"]),
             info="model for bloating/continuous time analysis"),
         OptionSpec(:algorithm, "explicit", domain=String, domain_check=(
@@ -41,16 +41,10 @@ function options_BFFPSV18()
                  "containing its indices"),
 
         # discretization options
-        OptionSpec(:lazy_sih, false, domain=Bool,
+        OptionSpec(:sih_method, "concrete", domain=String,
             info="use a lazy symmetric interval hull in discretization?"),
-        OptionSpec(:lazy_expm, false, domain=Bool,
-            info="use a lazy matrix exponential all the time?"),
-        OptionSpec(:lazy_expm_discretize, false, domain=Bool,
-            info="use a lazy matrix exponential in discretization?"),
-        OptionSpec(:pade_expm, false, domain=Bool,
-            info="use the Padé approximant method (instead of Julia's " *
-                 " built-in 'exp') to compute the lazy matrix exponential " *
-                 "in discretization?"),
+        OptionSpec(:exp_method, "base", domain=String,
+            info="method to compute the matrix exponential"),
         OptionSpec(:assume_sparse, false, domain=Bool,
             info="use an analysis for sparse discretized matrices?"),
 
@@ -208,12 +202,6 @@ function normalization_BFFPSV18!(𝑂::TwoLayerOptions)
 end
 
 function validation_BFFPSV18(𝑂)
-    # lazy_expm_discretize & lazy_expm
-    if !𝑂[:lazy_expm_discretize] && 𝑂[:lazy_expm]
-        throw(DomainError(𝑂[:lazy_expm_discretize], "cannot use option " *
-            "':lazy_expm' with deactivated option ':lazy_expm_discretize'"))
-    end
-
     # block_types
     if haskey_specified(𝑂, :block_types)
         for (key, value) in 𝑂[:block_types]

src/ReachSets/ContinuousPost/BFFPSV18/check_property.jl

@@ -182,16 +182,10 @@ function check_property(S::IVP{<:AbstractContinuousSystem},
     # Time discretization
     # ===================
     info("Time discretization...")
-    Δ = @timing begin
-        discretize(
-            S,
-            options[:δ],
-            approx_model=options[:approx_model],
-            pade_expm=options[:pade_expm],
-            lazy_expm=options[:lazy_expm_discretize],
-            lazy_sih=options[:lazy_sih]
-        )
-    end
+    Δ = @timing discretize(S, options[:δ], approximation=options[:approximation],
+                                                exp_method=options[:exp_method],
+                                                sih_method=options[:sih_method])
+    # TODO: remove this conversion and the option assume_sparse ?
     Δ = matrix_conversion_lazy_explicit(Δ, options)
     return check_property(Δ, property, options)
 end

src/ReachSets/ContinuousPost/BFFPSV18/reach.jl

@@ -227,16 +227,11 @@ function reach(system::IVP{<:AbstractContinuousSystem},
     # Time discretization
     # ===================
     info("Time discretization...")
-    Δ = @timing begin
-        discretize(
-            system,
-            options[:δ],
-            approx_model=options[:approx_model],
-            pade_expm=options[:pade_expm],
-            lazy_expm=options[:lazy_expm_discretize],
-            lazy_sih=options[:lazy_sih]
-        )
-    end
+    Δ = @timing discretize(system, options[:δ], approximation=options[:approximation],
+                                                exp_method=options[:exp_method],
+                                                sih_method=options[:sih_method])
+
+    # TODO: remove this conversion and the option assume_sparse ?
     Δ = matrix_conversion_lazy_explicit(Δ, options)
     return reach(Δ, invariant, options)
 end