make noisetype field a namedtuple

Author: oameye

src/core_systems/characterise_sde.jl

@@ -11,8 +11,7 @@ function is_time_independent(g, u, p)
     val = map(t -> g(u, p, t), trange) |> unique |> length == 1
     length(unique(val)) == 1
 end
-# isinvertible(x) = applicable(inv, x) && isone(inv(x) * x)
-isinvertible(x) = issuccess(lu(x, check = false))
+is_invertible(x) = issuccess(lu(x, check = false))
 
 function is_linear(f, x, y, c)
     check1 = f(x + y) == f(x) + f(y)
@@ -29,7 +28,10 @@ function find_noise_type(prob::SDEProblem, IIP)
     u0 = prob.u0
     D = length(u0)
 
-    properties = Symbol[]
+    isadditive = false
+    isautonomous = false
+    islinear = false
+    isinvertible = false
 
     function g(u, p, t)
         if IIP
@@ -44,38 +46,24 @@ function find_noise_type(prob::SDEProblem, IIP)
     state_independent = is_state_independent(g, u0, param, 1.0)
 
     # additive noise is equal to state independent noise
-    push!(properties, state_independent ? :additive : :multiplicative)
-    push!(properties, time_independent ? :autonomous : :non_autonomous)
-    if !state_independent
-        linear = is_linear(u -> g(u, param, 1.0), rand(D), rand(D), 2.0)
-        push!(properties, linear ? :linear : :non_linear)
-    else
-        push!(properties, :linear)
-    end
+    isadditive = state_independent
+    isautonomous = time_independent
+    islinear = !state_independent ?
+               is_linear(u -> g(u, param, 1.0), rand(D), rand(D), 2.0) : true
 
     if time_independent && state_independent
         if noise_rate_size == (D, D) && !isnothing(covariance)
-            error(
-                "The diffusion function `g` acts as an covariance matrix but
-                the noise process W also has a covariance matrix. This is ambiguous.")
+            error("The diffusion function `g` acts as an covariance matrix but the noise process W also has a covariance matrix. This is ambiguous.")
         elseif noise_rate_size == (D, D) && isnothing(covariance)
             covariance = g(zeros(D), param, 0.0)
-            if !isinvertible(covariance)
-                push!(properties, :non_invertible)
-            else
-                push!(properties, :invertible)
-            end
-        elseif !isnothing(covariance) && !isinvertible(covariance)
-            push!(properties, :non_invertible)
+            isinvertible = is_invertible(covariance)
         elseif !isnothing(noise_rate_size) && noise_rate_size != (D, D)
-            push!(properties, :non_invertible)
+            isinvertible = false
         else
-            push!(properties, :invertible)
+            isinvertible = isnothing(covariance) || is_invertible(covariance)
         end
     end
 
-    if !isnothing(noise) && D != length(noise.dW) && length(noise.dW) == 1
-        push!(properties, :scalar)
-    end
-    return properties
+    return (additive = isadditive, autonomous = isautonomous,
+        linear = islinear, invertible = isinvertible)
 end # function

src/core_systems/continuous_time_sde.jl

@@ -78,7 +78,7 @@ struct CoupledSDEs{IIP,D,I,P,S} <: ContinuousTimeDynamicalSystem
     p0::P
     noise_strength
     diffeq # isn't parameterized because it is only used for display
-    noise_type::Vector{Symbol}
+    noise_type::NamedTuple
 end
 
 function CoupledSDEs(

test/stochastic_characterisation.jl

@@ -9,57 +9,57 @@ IIP = true
 W = WienerProcess(0.0, zeros(2), zeros(2))
 addit_autom_inv = CoupledSDEs(f!, idfunc!, zeros(2), nothing, σ; noise = W)
 types = addit_autom_inv.noise_type
-@test issetequal(types, [:additive, :autonomous, :linear, :invertible])
+@test values(types) == (true, true, true, true)
 
 # Scalar Wiener noise
 W = WienerProcess(0.0, 0.0, 0.0)
 scalar_a = CoupledSDEs(f!, idfunc!, zeros(2), nothing, σ; noise = W)
 types = scalar_a.noise_type
-@test issetequal(types, [:scalar, :additive, :autonomous, :linear, :invertible])
+@test values(types) == (true, true, true, true)
 
 # invertible correlated Wiener noise
 W = CorrelatedWienerProcess([1 0.3; 0.3 1], 0.0, zeros(2), zeros(2))
 corr_a = CoupledSDEs(f!, idfunc!, zeros(2), nothing, σ; noise = W)
 types = corr_a.noise_type
-@test issetequal(types, [:additive, :autonomous, :linear, :invertible])
+@test values(types) == (true, true, true, true)
 
 # invertible correlated Wiener noise
 g!(du, u, p, t) = (du .= [1 0.3; 0.3 1]; return nothing)
 corr_alt = CoupledSDEs(
     f!, g!, zeros(2), nothing, σ, noise_rate_prototype = zeros(2, 2),
     diffeq = (alg = EM(), dt = 0.1))
 types = corr_alt.noise_type
-@test issetequal(types, [:additive, :autonomous, :linear, :invertible])
+@test values(types) == (true, true, true, true)
 
 # non-invertible correlated Wiener noise
 W = CorrelatedWienerProcess([1 2; 2 4], 0.0, zeros(2), zeros(2))
 corr_noninv = CoupledSDEs(f!, idfunc!, zeros(2), nothing, σ; noise = W)
 types = corr_noninv.noise_type
-@test issetequal(types, [:additive, :autonomous, :linear, :non_invertible])
+@test values(types) == (true, true, true, false)
 
 # non-invertible correlated Wiener noise
 g!(du, u, p, t) = (du .= [1 0.3 1; 0.3 1 1]; return nothing)
 corr_alt = CoupledSDEs(
     f!, g!, zeros(2), nothing, σ, noise_rate_prototype = zeros(2, 3),
     diffeq = (alg = EM(), dt = 0.1))
 types = corr_alt.noise_type
-@test issetequal(types, [:additive, :autonomous, :linear, :non_invertible])
+@test values(types) == (true, true, true, false)
 
 # multiplicative linear Wiener noise
 g!(du, u, p, t) = (du .= u; return nothing)
 linear_multipli = CoupledSDEs(f!, g!, rand(2) ./ 10, (), σ)
 types = linear_multipli.noise_type
-@test issetequal(types, [:multiplicative, :autonomous, :linear])
+@test values(types) == (false, true, true, false)
 
 # non-diagonal multiplicative linear Wiener noise
 lin_multipli_alt = CoupledSDEs(
     f!, g!, rand(2), (), σ, noise_rate_prototype = zeros(2, 3),
     diffeq = (alg = EM(), dt = 0.1))
 types = lin_multipli_alt.noise_type
-@test issetequal(types, [:multiplicative, :autonomous, :linear])
+@test values(types) == (false, true, true, false)
 
 # multiplicative nonlinear Wiener noise
 g!(du, u, p, t) = (du .= u .^ 2; return nothing)
 nonlinear_multiplicative = CoupledSDEs(f!, g!, rand(2), (), σ)
 types = nonlinear_multiplicative.noise_type
-@test issetequal(types, [:multiplicative, :autonomous, :non_linear])
+@test values(types) == (false, true, false, false)