Avoid using .Symbolics; depend on Random directly; simpler init functions

Project.toml

@@ -13,6 +13,7 @@ LazySets = "b4f0291d-fe17-52bc-9479-3d1a343d9043"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 MathematicalSystems = "d14a8603-c872-5ed3-9ece-53e0e82e39da"
 Parameters = "d96e819e-fc66-5662-9728-84c9c7592b0a"
+Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 ReachabilityBase = "379f33d0-9447-4353-bd03-d664070e549f"
 RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
 RecursiveArrayTools = "731186ca-8d62-57ce-b412-fbd966d074cd"

src/Continuous/symbolics.jl

@@ -1,4 +1,4 @@
-using .Symbolics: jacobian, hessian
+using .Symbolics: jacobian, hessian, build_function
 
 # ===========================================================================
 # Functionalities for Jacobian matrices

src/Initialization/init.jl

@@ -27,14 +27,11 @@ using LazySets: AffineMap, ResetMap
 # required to avoid conflicts with IntervalMatrices
 using LazySets: Interval, radius, sample, ∅, dim, scale, scale!
 
-# in-place set operations
-using LazySets: linear_map!
-
-# LazySets internal functions frequently used
+# JuliaReach internal functions
 using ReachabilityBase.Arrays: projection_matrix, SingleEntryVector,
                                isinvertible, vector_type
 using LazySets.Approximations: AbstractDirections
-using LazySets: @commutative, AbstractReductionMethod
+using LazySets: @commutative, AbstractReductionMethod, linear_map!
 
 # aliases for intervals
 const IM = IntervalMatrices

src/Initialization/init_DifferentialEquations.jl

@@ -1,10 +1,6 @@
 import .DifferentialEquations
 const DE = DifferentialEquations
-
-# resolve namespace conflicts
-# using MathematicalSystems: islinear
-# using LazySets: concretize
-# using HybridSystems: states
+import Random
 
 const DEFAULT_TRAJECTORIES = 10
 
@@ -70,7 +66,7 @@ end
 
 function _sample_initial(X0, trajectories; kwargs...)
     sampler = get(kwargs, :sampler, LazySets._default_sampler(X0))
-    rng = get(kwargs, :rng, LazySets.GLOBAL_RNG)
+    rng = get(kwargs, :rng, Random.GLOBAL_RNG)
     seed = get(kwargs, :seed, nothing)
     include_vertices = get(kwargs, :include_vertices, false)
     return sample(X0, trajectories; sampler=sampler, rng=rng,
@@ -254,7 +250,7 @@ function _sample_initial(ivp::IVP{<:AbstractHybridSystem,
         # samples (some regions may be empty), so we reduce to a random
         # collection of `trajectories` samples
         rng = get(kwargs, :rng, LazySets.GLOBAL_RNG)
-        all_samples = LazySets.Random.shuffle!(rng, all_samples)[1:trajectories]
+        all_samples = Random.shuffle!(rng, all_samples)[1:trajectories]
     end
 
     return all_samples

src/Initialization/init_DynamicPolynomials.jl

@@ -1,5 +1,3 @@
-eval(quote
-         using .DynamicPolynomials: @polyvar
-     end)
+using .DynamicPolynomials: @polyvar
 
 eval(load_kron_dynamicpolynomials())

src/Initialization/init_ExponentialUtilities.jl

@@ -1,33 +1,31 @@
-eval(quote
-         using .ExponentialUtilities: expv!, phiv!, arnoldi!, KrylovSubspace
+using .ExponentialUtilities: expv!, phiv!, arnoldi!, KrylovSubspace
 
-         # Compute out <- exp(A * NSTEPS * dt) * b
-         function _expv(A, b, NSTEPS, dt; hermitian=false, m=min(30, size(A, 1)), tol=1e-7)
-             # initialization of the krylov subspace
-             TA, Tb = eltype(A), eltype(b)
-             T = promote_type(TA, Tb)
-             Ks = KrylovSubspace{T,real(T)}(length(b), m)
-             arnoldi!(Ks, A, b; m=m, ishermitian=hermitian, tol=tol)
+# Compute out <- exp(A * NSTEPS * dt) * b
+function _expv(A, b, NSTEPS, dt; hermitian=false, m=min(30, size(A, 1)), tol=1e-7)
+    # initialization of the krylov subspace
+    TA, Tb = eltype(A), eltype(b)
+    T = promote_type(TA, Tb)
+    Ks = KrylovSubspace{T,real(T)}(length(b), m)
+    arnoldi!(Ks, A, b; m=m, ishermitian=hermitian, tol=tol)
 
-             out = similar(b)
-             expv!(out, NSTEPS * dt, Ks)
+    out = similar(b)
+    expv!(out, NSTEPS * dt, Ks)
 
-             return out
-         end
+    return out
+end
 
-         function _phiv(A, b, NSTEPS, dt; hermitian=false, m=min(30, size(A, 1)), tol=1e-7)
-             # initialization of the krylov subspace
-             TA, Tb = eltype(A), eltype(b)
-             T = promote_type(TA, Tb)
-             Ks = KrylovSubspace{T,real(T)}(length(b), m)
-             arnoldi!(Ks, A, b; m=m, ishermitian=hermitian, tol=tol)
+function _phiv(A, b, NSTEPS, dt; hermitian=false, m=min(30, size(A, 1)), tol=1e-7)
+    # initialization of the krylov subspace
+    TA, Tb = eltype(A), eltype(b)
+    T = promote_type(TA, Tb)
+    Ks = KrylovSubspace{T,real(T)}(length(b), m)
+    arnoldi!(Ks, A, b; m=m, ishermitian=hermitian, tol=tol)
 
-             out = Matrix{Float64}(undef, size(A, 1), 3)
-             phiv!(out, NSTEPS * dt, Ks, 2)
+    out = Matrix{Float64}(undef, size(A, 1), 3)
+    phiv!(out, NSTEPS * dt, Ks, 2)
 
-             return view(out, :, 3) .* dt^2
-         end
-     end)
+    return view(out, :, 3) .* dt^2
+end
 
 eval(load_krylov_LGG09_homog())
 eval(load_krylov_LGG09_inhomog())

src/Initialization/init_FastExpm.jl

@@ -1,3 +1 @@
-eval(quote
-         using .FastExpm: fastExpm
-     end)
+using .FastExpm: fastExpm

src/Initialization/init_MultivariatePolynomials.jl

@@ -1,6 +1,4 @@
-eval(quote
-         using .MultivariatePolynomials: AbstractVariable, AbstractMonomialLike,
-                                         exponents, variables, powers
-     end)
+using .MultivariatePolynomials: AbstractVariable, AbstractMonomialLike,
+                                exponents, variables, powers
 
 eval(load_kron_multivariate())

src/Initialization/init_Symbolics.jl

@@ -1,7 +1,5 @@
-using .Symbolics
-
-# required to avoid conflicts with IntervalMatrices
-using IntervalMatrices: infimum, supremum
+import .Symbolics
+using .Symbolics: Num
 
 include("../Continuous/symbolics.jl")
 
@@ -14,14 +12,14 @@ function Base.convert(::Type{Vector{Tuple{String,String}}}, s::BlackBoxContinuou
 
     # get right-hand side symbolic expression then turn it into a vector of strings
     Symbolics.@variables x[1:n]
-    dx = Vector{Symbolics.Num}(undef, n)
+    dx = Vector{Num}(undef, n)
     f!(dx, x, params, t)
     rhs = string.(dx)
 
     # make implicit times operators explicit, eg. 2x into 2*x
     rhs = string.(Meta.parse.(rhs))
 
-    # remove square brackets, eg. turning x[1] into x1 
+    # remove square brackets, eg. turning x[1] into x1
     pat = ["x[$i]" => "x$i" for i in 1:n]
     rhs = [Symbolics.replace(fi, pat...) for fi in rhs]
 

test/continuous/symbolics.jl

@@ -1,4 +1,4 @@
-using Symbolics
+using Symbolics: @variables, Num
 using ReachabilityAnalysis: _jacobian_function,
                             _jacobian_expression,
                             _hessian_function,