From dfcc663d4c8e7e83cb334a12ce3d1f737951a173 Mon Sep 17 00:00:00 2001
From: Mahmoud Bentriou <mahmoud.bentriou@centralesupelec.fr>
Date: Thu, 10 Dec 2020 14:34:13 +0100
Subject: [PATCH] Speed up performance for LHA core files.
Change of signatures of unit functions update_state!, check_constraints
of the automata edges. Use getfield instead of getproperty.
Now the execution of statistical estimation of the distance G is of the
order of Cosmos !
---
automata/automaton_F.jl | 82 ++++++-------
automata/automaton_G.jl | 136 ++++++++++-----------
automata/automaton_G_and_F.jl | 216 +++++++++++++++++-----------------
core/lha.jl | 36 +++---
4 files changed, 237 insertions(+), 233 deletions(-)
diff --git a/automata/automaton_F.jl b/automata/automaton_F.jl
index ec0106e..e0ff0e5 100644
--- a/automata/automaton_F.jl
+++ b/automata/automaton_F.jl
@@ -15,7 +15,7 @@ function create_automaton_F(m::ContinuousTimeModel, x1::Float64, x2::Float64, t1
#S.n <=> S.values[A.map_var_automaton_idx[:n]]
#P <=> xn[map_var_model_idx[constants[str_O]] with str_O = :P. On stock str_O dans constants
- # P = get_value(A, x, sym_obs)
+ # P = get_value(S, x, sym_obs)
## Map of automaton variables
map_var_automaton_idx = Dict{VariableAutomaton,Int}(:n => 1, :d => 2, :isabs => 3)
@@ -35,89 +35,89 @@ function create_automaton_F(m::ContinuousTimeModel, x1::Float64, x2::Float64, t1
# l0 loc : we construct the edges of the form l0 => (..)
# "cc" as check_constraints
tuple = (:l0, :l1)
- cc_aut_F_l0l1_1(A::LHA, S::StateLHA) = true
- us_aut_F_l0l1_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_F_l0l1_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) = true
+ us_aut_F_l0l1_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l1;
- S[:n] = get_value(A, x, sym_obs);
+ S[:n] = get_value(S, x, sym_obs);
S[:d] = Inf;
- S[:isabs] = m.isabsorbing(m.p,x))
+ S[:isabs] = getfield(m, :isabsorbing)(getfield(m, :p),x))
edge1 = Edge([nothing], cc_aut_F_l0l1_1, us_aut_F_l0l1_1!)
map_edges[:l0][:l1] = [edge1]
# l1 loc : we construct the edges of the form l1 => (..)
tuple = (:l1, :l2)
- cc_aut_F_l1l2_1(A::LHA, S::StateLHA) =
- S.time >= A.constants[:t1] &&
- (A.constants[:x1] <= S[:n] <= A.constants[:x2])
- us_aut_F_l1l2_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_F_l1l2_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ getfield(S, :time) >= constants[:t1] &&
+ (constants[:x1] <= S[:n] <= constants[:x2])
+ us_aut_F_l1l2_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2;
S[:d] = 0)
edge1 = Edge([nothing], cc_aut_F_l1l2_1, us_aut_F_l1l2_1!)
- cc_aut_F_l1l2_4(A::LHA, S::StateLHA) =
- S.time >= A.constants[:t1] &&
+ cc_aut_F_l1l2_4(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ getfield(S, :time) >= constants[:t1] &&
S[:d] == 0
- us_aut_F_l1l2_4!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ us_aut_F_l1l2_4!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2)
edge4 = Edge([nothing], cc_aut_F_l1l2_4, us_aut_F_l1l2_4!)
- cc_aut_F_l1l2_2(A::LHA, S::StateLHA) =
- (S.time >= A.constants[:t2]) &&
- (S[:n] < A.constants[:x1] || S[:n] > A.constants[:x2])
- us_aut_F_l1l2_2!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_F_l1l2_2(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ (getfield(S, :time) >= constants[:t2]) &&
+ (S[:n] < constants[:x1] || S[:n] > constants[:x2])
+ us_aut_F_l1l2_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2;
- S[:d] = min(abs(S[:n] - A.constants[:x1]), abs(S[:n] - A.constants[:x2])))
+ S[:d] = min(abs(S[:n] - constants[:x1]), abs(S[:n] - constants[:x2])))
edge2 = Edge([nothing], cc_aut_F_l1l2_2, us_aut_F_l1l2_2!)
- cc_aut_F_l1l2_3(A::LHA, S::StateLHA) =
- istrue(S[:isabs]) && S.time <= A.constants[:t2]
- us_aut_F_l1l2_3!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_F_l1l2_3(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ istrue(S[:isabs]) && getfield(S, :time) <= constants[:t2]
+ us_aut_F_l1l2_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2)
edge3 = Edge([nothing], cc_aut_F_l1l2_3, us_aut_F_l1l2_3!)
map_edges[:l1][:l2] = [edge1, edge2, edge3, edge4]
tuple = (:l1, :l3)
- cc_aut_F_l1l3_1(A::LHA, S::StateLHA) =
- (A.constants[:x1] <= S[:n] <= A.constants[:x2])
- us_aut_F_l1l3_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_F_l1l3_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ (constants[:x1] <= S[:n] <= constants[:x2])
+ us_aut_F_l1l3_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l3;
S[:d] = 0;)
edge1 = Edge([nothing], cc_aut_F_l1l3_1, us_aut_F_l1l3_1!)
- cc_aut_F_l1l3_2(A::LHA, S::StateLHA) =
- (S[:n] < A.constants[:x1] || S[:n] > A.constants[:x2]) &&
- (S.time <= A.constants[:t1])
- us_aut_F_l1l3_2!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_F_l1l3_2(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ (S[:n] < constants[:x1] || S[:n] > constants[:x2]) &&
+ (getfield(S, :time) <= constants[:t1])
+ us_aut_F_l1l3_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l3;
- S[:d] = min(sqrt((S.time - A.constants[:t1])^2 + (S[:n] - A.constants[:x2])^2),
- sqrt((S.time - A.constants[:t1])^2 + (S[:n] - A.constants[:x1])^2)))
+ S[:d] = min(sqrt((getfield(S, :time) - constants[:t1])^2 + (S[:n] - constants[:x2])^2),
+ sqrt((getfield(S, :time) - constants[:t1])^2 + (S[:n] - constants[:x1])^2)))
edge2 = Edge([nothing], cc_aut_F_l1l3_2, us_aut_F_l1l3_2!)
- cc_aut_F_l1l3_3(A::LHA, S::StateLHA) =
- (S[:n] < A.constants[:x1] || S[:n] > A.constants[:x2]) &&
- (A.constants[:t1] <= S.time <= A.constants[:t2])
- us_aut_F_l1l3_3!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_F_l1l3_3(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ (S[:n] < constants[:x1] || S[:n] > constants[:x2]) &&
+ (constants[:t1] <= getfield(S, :time) <= constants[:t2])
+ us_aut_F_l1l3_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l3;
- S[:d] = min(S[:d], min(abs(S[:n] - A.constants[:x1]), abs(S[:n] - A.constants[:x2]))))
+ S[:d] = min(S[:d], min(abs(S[:n] - constants[:x1]), abs(S[:n] - constants[:x2]))))
edge3 = Edge([nothing], cc_aut_F_l1l3_3, us_aut_F_l1l3_3!)
map_edges[:l1][:l3] = [edge1, edge2, edge3]
# l3 loc
tuple = (:l3, :l1)
- cc_aut_F_l3l1_1(A::LHA, S::StateLHA) = true
- us_aut_F_l3l1_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_F_l3l1_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) = true
+ us_aut_F_l3l1_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l1;
- S[:n] = get_value(A, x, sym_obs);
- S[:isabs] = m.isabsorbing(m.p,x))
+ S[:n] = get_value(S, x, sym_obs);
+ S[:isabs] = getfield(m, :isabsorbing)(getfield(m, :p),x))
edge1 = Edge([:ALL], cc_aut_F_l3l1_1, us_aut_F_l3l1_1!)
map_edges[:l3][:l1] = [edge1]
tuple = (:l3, :l2)
- cc_aut_F_l3l2_1(A::LHA, S::StateLHA) =
- (S.time >= A.constants[:t2])
- us_aut_F_l3l2_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_F_l3l2_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ (getfield(S, :time) >= constants[:t2])
+ us_aut_F_l3l2_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2)
edge1 = Edge([nothing], cc_aut_F_l3l2_1, us_aut_F_l3l2_1!)
map_edges[:l3][:l2] = [edge1]
diff --git a/automata/automaton_G.jl b/automata/automaton_G.jl
index d53fcb1..007d714 100644
--- a/automata/automaton_G.jl
+++ b/automata/automaton_G.jl
@@ -34,51 +34,51 @@ function create_automaton_G(m::ContinuousTimeModel, x1::Float64, x2::Float64, t1
# l0 loc
tuple = (:l0, :l1)
- cc_aut_G_l0l1_1(A::LHA, S::StateLHA) = true
- us_aut_G_l0l1_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_G_l0l1_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) = true
+ us_aut_G_l0l1_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l1;
S[:d] = 0;
- S[:n] = get_value(A, x, sym_obs);
+ S[:n] = get_value(S, x, sym_obs);
S[:in] = true;
- S[:isabs] = m.isabsorbing(m.p,x))
+ S[:isabs] = getfield(m, :isabsorbing)(getfield(m, :p),x))
edge1 = Edge([nothing], cc_aut_G_l0l1_1, us_aut_G_l0l1_1!)
map_edges[:l0][:l1] = [edge1]
# l1 loc
tuple = (:l1, :l3)
- cc_aut_G_l1l3_1(A::LHA, S::StateLHA) =
- S.time <= A.constants[:t1] &&
- S[:n] < A.constants[:x1] || S[:n] > A.constants[:x2]
- us_aut_G_l1l3_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_G_l1l3_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ getfield(S, :time) <= constants[:t1] &&
+ S[:n] < constants[:x1] || S[:n] > constants[:x2]
+ us_aut_G_l1l3_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l3;
- S[:d] = min(abs(A.constants[:x1] - S[:n]), abs(A.constants[:x2] - S[:n]));
+ S[:d] = min(abs(constants[:x1] - S[:n]), abs(constants[:x2] - S[:n]));
S[:in] = false)
edge1 = Edge([nothing], cc_aut_G_l1l3_1, us_aut_G_l1l3_1!)
- cc_aut_G_l1l3_3(A::LHA, S::StateLHA) =
+ cc_aut_G_l1l3_3(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
!istrue(S[:in]) &&
- (A.constants[:t1] <= S.time <= A.constants[:t2]) &&
- (A.constants[:x1] <= S[:n] <= A.constants[:x2])
- us_aut_G_l1l3_3!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ (constants[:t1] <= getfield(S, :time) <= constants[:t2]) &&
+ (constants[:x1] <= S[:n] <= constants[:x2])
+ us_aut_G_l1l3_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l3;
- S[:d] = S[:d] * (S.time - A.constants[:t1]);
+ S[:d] = S[:d] * (getfield(S, :time) - constants[:t1]);
S[:tprime] = 0.0)
edge3 = Edge([nothing], cc_aut_G_l1l3_3, us_aut_G_l1l3_3!)
- cc_aut_G_l1l3_2(A::LHA, S::StateLHA) =
- (S.time <= A.constants[:t1]) &&
- (A.constants[:x1] <= S[:n] <= A.constants[:x2])
- us_aut_G_l1l3_2!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_G_l1l3_2(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ (getfield(S, :time) <= constants[:t1]) &&
+ (constants[:x1] <= S[:n] <= constants[:x2])
+ us_aut_G_l1l3_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l3;
S[:d] = 0;
S[:in] = false)
edge2 = Edge([nothing], cc_aut_G_l1l3_2, us_aut_G_l1l3_2!)
- cc_aut_G_l1l3_4(A::LHA, S::StateLHA) =
+ cc_aut_G_l1l3_4(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
istrue(S[:in]) &&
- (A.constants[:t1] <= S.time <= A.constants[:t2]) &&
- (A.constants[:x1] <= S[:n] <= A.constants[:x2])
- us_aut_G_l1l3_4!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ (constants[:t1] <= getfield(S, :time) <= constants[:t2]) &&
+ (constants[:x1] <= S[:n] <= constants[:x2])
+ us_aut_G_l1l3_4!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l3;
S[:tprime] = 0.0)
edge4 = Edge([nothing], cc_aut_G_l1l3_4, us_aut_G_l1l3_4!)
@@ -86,80 +86,80 @@ function create_automaton_G(m::ContinuousTimeModel, x1::Float64, x2::Float64, t1
map_edges[:l1][:l3] = [edge1, edge2, edge3, edge4]
tuple = (:l1, :l4)
- cc_aut_G_l1l4_1(A::LHA, S::StateLHA) =
+ cc_aut_G_l1l4_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
!istrue(S[:in]) &&
- (A.constants[:t1] <= S.time <= A.constants[:t2]) &&
- (S[:n] < A.constants[:x1] || S[:n] > A.constants[:x2])
- us_aut_G_l1l4_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ (constants[:t1] <= getfield(S, :time) <= constants[:t2]) &&
+ (S[:n] < constants[:x1] || S[:n] > constants[:x2])
+ us_aut_G_l1l4_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l4;
- S[:d] += S[:d] * (S.time - A.constants[:t1]))
+ S[:d] += S[:d] * (getfield(S, :time) - constants[:t1]))
edge1 = Edge([nothing], cc_aut_G_l1l4_1, us_aut_G_l1l4_1!)
- cc_aut_G_l1l4_2(A::LHA, S::StateLHA) =
+ cc_aut_G_l1l4_2(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
istrue(S[:in]) &&
- (A.constants[:t1] <= S.time <= A.constants[:t2]) &&
- (S[:n] < A.constants[:x1] || S[:n] > A.constants[:x2])
- us_aut_G_l1l4_2!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ (constants[:t1] <= getfield(S, :time) <= constants[:t2]) &&
+ (S[:n] < constants[:x1] || S[:n] > constants[:x2])
+ us_aut_G_l1l4_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l4)
edge2 = Edge([nothing], cc_aut_G_l1l4_2, us_aut_G_l1l4_2!)
map_edges[:l1][:l4] = [edge1, edge2]
tuple = (:l1, :l2)
- cc_aut_G_l1l2_1(A::LHA, S::StateLHA) =
+ cc_aut_G_l1l2_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
istrue(S[:in]) &&
- S.time >= A.constants[:t2]
- us_aut_G_l1l2_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ getfield(S, :time) >= constants[:t2]
+ us_aut_G_l1l2_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2)
edge1 = Edge([nothing], cc_aut_G_l1l2_1, us_aut_G_l1l2_1!)
- cc_aut_G_l1l2_2(A::LHA, S::StateLHA) =
+ cc_aut_G_l1l2_2(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
!istrue(S[:in]) &&
- S.time >= A.constants[:t2]
- us_aut_G_l1l2_2!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ getfield(S, :time) >= constants[:t2]
+ us_aut_G_l1l2_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2;
- S[:d] = S[:d] * (A.constants[:t2] - A.constants[:t1]))
+ S[:d] = S[:d] * (constants[:t2] - constants[:t1]))
edge2 = Edge([nothing], cc_aut_G_l1l2_2, us_aut_G_l1l2_2!)
- cc_aut_G_l1l2_3(A::LHA, S::StateLHA) =
+ cc_aut_G_l1l2_3(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
istrue(S[:isabs]) &&
- S.time <= A.constants[:t1]
- us_aut_G_l1l2_3!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ getfield(S, :time) <= constants[:t1]
+ us_aut_G_l1l2_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2;
- S[:d] = (A.constants[:t2] - A.constants[:t1]) *
- min(abs(A.constants[:x1] - S[:n]), abs(A.constants[:x2] - S[:n])))
+ S[:d] = (constants[:t2] - constants[:t1]) *
+ min(abs(constants[:x1] - S[:n]), abs(constants[:x2] - S[:n])))
edge3 = Edge([nothing], cc_aut_G_l1l2_3, us_aut_G_l1l2_3!)
- cc_aut_G_l1l2_4(A::LHA, S::StateLHA) =
+ cc_aut_G_l1l2_4(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
istrue(S[:isabs]) &&
- (A.constants[:t1] <= S.time <= A.constants[:t2])
- us_aut_G_l1l2_4!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ (constants[:t1] <= getfield(S, :time) <= constants[:t2])
+ us_aut_G_l1l2_4!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2;
- S[:d] += (A.constants[:t2] - S.time) *
- min(abs(A.constants[:x1] - S[:n]), abs(A.constants[:x2] - S[:n])))
+ S[:d] += (constants[:t2] - getfield(S, :time)) *
+ min(abs(constants[:x1] - S[:n]), abs(constants[:x2] - S[:n])))
edge4 = Edge([nothing], cc_aut_G_l1l2_4, us_aut_G_l1l2_4!)
map_edges[:l1][:l2] = [edge1, edge2, edge3, edge4]
# l3 loc
tuple = (:l3, :l1)
- cc_aut_G_l3l1_1(A::LHA, S::StateLHA) = true
- us_aut_G_l3l1_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_G_l3l1_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) = true
+ us_aut_G_l3l1_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l1;
- S[:n] = get_value(A, x, sym_obs);
- S[:isabs] = m.isabsorbing(m.p,x))
+ S[:n] = get_value(S, x, sym_obs);
+ S[:isabs] = getfield(m, :isabsorbing)(getfield(m, :p),x))
edge1 = Edge([:ALL], cc_aut_G_l3l1_1, us_aut_G_l3l1_1!)
map_edges[:l3][:l1] = [edge1]
tuple = (:l3, :l2)
- cc_aut_G_l3l2_2(A::LHA, S::StateLHA) =
+ cc_aut_G_l3l2_2(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
istrue(S[:in]) &&
- S.time >= A.constants[:t2]
- us_aut_G_l3l2_2!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ getfield(S, :time) >= constants[:t2]
+ us_aut_G_l3l2_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2;
- S[:d] = S[:d] * (A.constants[:t2] - A.constants[:t1]))
+ S[:d] = S[:d] * (constants[:t2] - constants[:t1]))
edge2 = Edge([nothing], cc_aut_G_l3l2_2, us_aut_G_l3l2_2!)
- cc_aut_G_l3l2_1(A::LHA, S::StateLHA) =
+ cc_aut_G_l3l2_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
!istrue(S[:in]) &&
- S.time >= A.constants[:t2]
- us_aut_G_l3l2_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ getfield(S, :time) >= constants[:t2]
+ us_aut_G_l3l2_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2)
edge1 = Edge([nothing], cc_aut_G_l3l2_1, us_aut_G_l3l2_1!)
@@ -167,24 +167,24 @@ function create_automaton_G(m::ContinuousTimeModel, x1::Float64, x2::Float64, t1
# l4 loc
tuple = (:l4, :l1)
- cc_aut_G_l4l1_1(A::LHA, S::StateLHA) = true
- us_aut_G_l4l1_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_G_l4l1_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) = true
+ us_aut_G_l4l1_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l1;
- S[:d] += S[:tprime] * min(abs(A.constants[:x1] - S[:n]), abs(A.constants[:x2] - S[:n]));
+ S[:d] += S[:tprime] * min(abs(constants[:x1] - S[:n]), abs(constants[:x2] - S[:n]));
S[:tprime] = 0.0;
- S[:n] = get_value(A, x, sym_obs);
+ S[:n] = get_value(S, x, sym_obs);
S[:in] = true;
- S[:isabs] = m.isabsorbing(m.p,x))
+ S[:isabs] = getfield(m, :isabsorbing)(getfield(m, :p),x))
edge1 = Edge([:ALL], cc_aut_G_l4l1_1, us_aut_G_l4l1_1!)
map_edges[:l4][:l1] = [edge1]
tuple = (:l4, :l2)
- cc_aut_G_l4l2_1(A::LHA, S::StateLHA) =
- (S.time >= A.constants[:t2])
- us_aut_G_l4l2_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_G_l4l2_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ (getfield(S, :time) >= constants[:t2])
+ us_aut_G_l4l2_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2;
- S[:d] += S[:tprime] * min(abs(A.constants[:x1] - S[:n]), abs(A.constants[:x2] - S[:n]));
+ S[:d] += S[:tprime] * min(abs(constants[:x1] - S[:n]), abs(constants[:x2] - S[:n]));
S[:tprime] = 0.0)
edge1 = Edge([nothing], cc_aut_G_l4l2_1, us_aut_G_l4l2_1!)
diff --git a/automata/automaton_G_and_F.jl b/automata/automaton_G_and_F.jl
index 2e05a94..f8b1c2b 100644
--- a/automata/automaton_G_and_F.jl
+++ b/automata/automaton_G_and_F.jl
@@ -45,51 +45,51 @@ function create_automaton_G_and_F(m::ContinuousTimeModel, x1::Float64, x2::Float
# l0G loc
tuple = (:l0G, :l1G)
- cc_aut_G_l0Gl1G_1(A::LHA, S::StateLHA) = true
- us_aut_G_l0Gl1G_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_G_l0Gl1G_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) = true
+ us_aut_G_l0Gl1G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l1G;
S[:d] = 0;
- S[:n] = get_value(A, x, sym_obs_G);
+ S[:n] = get_value(S, x, sym_obs_G);
S[:in] = true;
- S[:isabs] = m.isabsorbing(m.p,x))
+ S[:isabs] = getfield(m, :isabsorbing)(getfield(m, :p),x))
edge1 = Edge([nothing], cc_aut_G_l0Gl1G_1, us_aut_G_l0Gl1G_1!)
map_edges[:l0G][:l1G] = [edge1]
# l1G loc
tuple = (:l1G, :l3G)
- cc_aut_G_l1Gl3G_1(A::LHA, S::StateLHA) =
- S.time <= A.constants[:t1] &&
- S[:n] < A.constants[:x1] || S[:n] > A.constants[:x2]
- us_aut_G_l1Gl3G_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_G_l1Gl3G_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ getfield(S, :time) <= constants[:t1] &&
+ S[:n] < constants[:x1] || S[:n] > constants[:x2]
+ us_aut_G_l1Gl3G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l3G;
- S[:d] = min(abs(A.constants[:x1] - S[:n]), abs(A.constants[:x2] - S[:n]));
+ S[:d] = min(abs(constants[:x1] - S[:n]), abs(constants[:x2] - S[:n]));
S[:in] = false)
edge1 = Edge([nothing], cc_aut_G_l1Gl3G_1, us_aut_G_l1Gl3G_1!)
- cc_aut_G_l1Gl3G_3(A::LHA, S::StateLHA) =
+ cc_aut_G_l1Gl3G_3(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
!istrue(S[:in]) &&
- (A.constants[:t1] <= S.time <= A.constants[:t2]) &&
- (A.constants[:x1] <= S[:n] <= A.constants[:x2])
- us_aut_G_l1Gl3G_3!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ (constants[:t1] <= getfield(S, :time) <= constants[:t2]) &&
+ (constants[:x1] <= S[:n] <= constants[:x2])
+ us_aut_G_l1Gl3G_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l3G;
- S[:d] = S[:d] * (S.time - A.constants[:t1]);
+ S[:d] = S[:d] * (getfield(S, :time) - constants[:t1]);
S[:tprime] = 0.0)
edge3 = Edge([nothing], cc_aut_G_l1Gl3G_3, us_aut_G_l1Gl3G_3!)
- cc_aut_G_l1Gl3G_2(A::LHA, S::StateLHA) =
- (S.time <= A.constants[:t1]) &&
- (A.constants[:x1] <= S[:n] <= A.constants[:x2])
- us_aut_G_l1Gl3G_2!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_G_l1Gl3G_2(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ (getfield(S, :time) <= constants[:t1]) &&
+ (constants[:x1] <= S[:n] <= constants[:x2])
+ us_aut_G_l1Gl3G_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l3G;
S[:d] = 0;
S[:in] = false)
edge2 = Edge([nothing], cc_aut_G_l1Gl3G_2, us_aut_G_l1Gl3G_2!)
- cc_aut_G_l1Gl3G_4(A::LHA, S::StateLHA) =
+ cc_aut_G_l1Gl3G_4(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
istrue(S[:in]) &&
- (A.constants[:t1] <= S.time <= A.constants[:t2]) &&
- (A.constants[:x1] <= S[:n] <= A.constants[:x2])
- us_aut_G_l1Gl3G_4!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ (constants[:t1] <= getfield(S, :time) <= constants[:t2]) &&
+ (constants[:x1] <= S[:n] <= constants[:x2])
+ us_aut_G_l1Gl3G_4!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l3G;
S[:tprime] = 0.0)
edge4 = Edge([nothing], cc_aut_G_l1Gl3G_4, us_aut_G_l1Gl3G_4!)
@@ -97,81 +97,81 @@ function create_automaton_G_and_F(m::ContinuousTimeModel, x1::Float64, x2::Float
map_edges[:l1G][:l3G] = [edge1, edge2, edge3, edge4]
tuple = (:l1G, :l4G)
- cc_aut_G_l1Gl4G_1(A::LHA, S::StateLHA) =
+ cc_aut_G_l1Gl4G_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
!istrue(S[:in]) &&
- (A.constants[:t1] <= S.time <= A.constants[:t2]) &&
- (S[:n] < A.constants[:x1] || S[:n] > A.constants[:x2])
- us_aut_G_l1Gl4G_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ (constants[:t1] <= getfield(S, :time) <= constants[:t2]) &&
+ (S[:n] < constants[:x1] || S[:n] > constants[:x2])
+ us_aut_G_l1Gl4G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l4G;
- S[:d] += S[:d] * (S.time - A.constants[:t1]))
+ S[:d] += S[:d] * (getfield(S, :time) - constants[:t1]))
edge1 = Edge([nothing], cc_aut_G_l1Gl4G_1, us_aut_G_l1Gl4G_1!)
- cc_aut_G_l1Gl4G_2(A::LHA, S::StateLHA) =
+ cc_aut_G_l1Gl4G_2(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
istrue(S[:in]) &&
- (A.constants[:t1] <= S.time <= A.constants[:t2]) &&
- (S[:n] < A.constants[:x1] || S[:n] > A.constants[:x2])
- us_aut_G_l1Gl4G_2!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ (constants[:t1] <= getfield(S, :time) <= constants[:t2]) &&
+ (S[:n] < constants[:x1] || S[:n] > constants[:x2])
+ us_aut_G_l1Gl4G_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l4G)
edge2 = Edge([nothing], cc_aut_G_l1Gl4G_2, us_aut_G_l1Gl4G_2!)
map_edges[:l1G][:l4G] = [edge1, edge2]
tuple = (:l1G, :l2G)
- cc_aut_G_l1Gl2G_3(A::LHA, S::StateLHA) =
+ cc_aut_G_l1Gl2G_3(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
istrue(S[:isabs]) &&
- S.time <= A.constants[:t1]
- us_aut_G_l1Gl2G_3!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ getfield(S, :time) <= constants[:t1]
+ us_aut_G_l1Gl2G_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2G;
- S[:d] = (A.constants[:t2] - A.constants[:t1]) *
- min(abs(A.constants[:x1] - S[:n]), abs(A.constants[:x2] - S[:n])))
+ S[:d] = (constants[:t2] - constants[:t1]) *
+ min(abs(constants[:x1] - S[:n]), abs(constants[:x2] - S[:n])))
edge3 = Edge([nothing], cc_aut_G_l1Gl2G_3, us_aut_G_l1Gl2G_3!)
- cc_aut_G_l1Gl2G_4(A::LHA, S::StateLHA) =
+ cc_aut_G_l1Gl2G_4(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
istrue(S[:isabs]) &&
- (A.constants[:t1] <= S.time <= A.constants[:t2])
- us_aut_G_l1Gl2G_4!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ (constants[:t1] <= getfield(S, :time) <= constants[:t2])
+ us_aut_G_l1Gl2G_4!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2G;
- S[:d] += (A.constants[:t2] - S.time) *
- min(abs(A.constants[:x1] - S[:n]), abs(A.constants[:x2] - S[:n])))
+ S[:d] += (constants[:t2] - getfield(S, :time)) *
+ min(abs(constants[:x1] - S[:n]), abs(constants[:x2] - S[:n])))
edge4 = Edge([nothing], cc_aut_G_l1Gl2G_4, us_aut_G_l1Gl2G_4!)
- cc_aut_G_l1Gl2G_1(A::LHA, S::StateLHA) =
+ cc_aut_G_l1Gl2G_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
istrue(S[:in]) &&
- S.time >= A.constants[:t2]
- us_aut_G_l1Gl2G_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ getfield(S, :time) >= constants[:t2]
+ us_aut_G_l1Gl2G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2G)
edge1 = Edge([nothing], cc_aut_G_l1Gl2G_1, us_aut_G_l1Gl2G_1!)
- cc_aut_G_l1Gl2G_2(A::LHA, S::StateLHA) =
+ cc_aut_G_l1Gl2G_2(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
!istrue(S[:in]) &&
- S.time >= A.constants[:t2]
- us_aut_G_l1Gl2G_2!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ getfield(S, :time) >= constants[:t2]
+ us_aut_G_l1Gl2G_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2G;
- S[:d] = S[:d] * (A.constants[:t2] - A.constants[:t1]))
+ S[:d] = S[:d] * (constants[:t2] - constants[:t1]))
edge2 = Edge([nothing], cc_aut_G_l1Gl2G_2, us_aut_G_l1Gl2G_2!)
map_edges[:l1G][:l2G] = [edge3, edge4, edge1, edge2]
# l3G loc
tuple = (:l3G, :l1G)
- cc_aut_G_l3Gl1G_1(A::LHA, S::StateLHA) = true
- us_aut_G_l3Gl1G_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_G_l3Gl1G_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) = true
+ us_aut_G_l3Gl1G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l1G;
- S[:n] = get_value(A, x, sym_obs_G);
- S[:isabs] = m.isabsorbing(m.p,x))
+ S[:n] = get_value(S, x, sym_obs_G);
+ S[:isabs] = getfield(m, :isabsorbing)(getfield(m, :p),x))
edge1 = Edge([:ALL], cc_aut_G_l3Gl1G_1, us_aut_G_l3Gl1G_1!)
map_edges[:l3G][:l1G] = [edge1]
tuple = (:l3G, :l2G)
- cc_aut_G_l3Gl2G_2(A::LHA, S::StateLHA) =
+ cc_aut_G_l3Gl2G_2(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
istrue(S[:in]) &&
- S.time >= A.constants[:t2]
- us_aut_G_l3Gl2G_2!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ getfield(S, :time) >= constants[:t2]
+ us_aut_G_l3Gl2G_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2G;
- S[:d] = S[:d] * (A.constants[:t2] - A.constants[:t1]))
+ S[:d] = S[:d] * (constants[:t2] - constants[:t1]))
edge2 = Edge([nothing], cc_aut_G_l3Gl2G_2, us_aut_G_l3Gl2G_2!)
- cc_aut_G_l3Gl2G_1(A::LHA, S::StateLHA) =
+ cc_aut_G_l3Gl2G_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
!istrue(S[:in]) &&
- S.time >= A.constants[:t2]
- us_aut_G_l3Gl2G_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ getfield(S, :time) >= constants[:t2]
+ us_aut_G_l3Gl2G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2G)
edge1 = Edge([nothing], cc_aut_G_l3Gl2G_1, us_aut_G_l3Gl2G_1!)
@@ -179,24 +179,24 @@ function create_automaton_G_and_F(m::ContinuousTimeModel, x1::Float64, x2::Float
# l4G loc
tuple = (:l4G, :l1G)
- cc_aut_G_l4Gl1G_1(A::LHA, S::StateLHA) = true
- us_aut_G_l4Gl1G_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_G_l4Gl1G_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) = true
+ us_aut_G_l4Gl1G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l1G;
- S[:d] += S[:tprime] * min(abs(A.constants[:x1] - S[:n]), abs(A.constants[:x2] - S[:n]));
+ S[:d] += S[:tprime] * min(abs(constants[:x1] - S[:n]), abs(constants[:x2] - S[:n]));
S[:tprime] = 0.0;
- S[:n] = get_value(A, x, sym_obs_G);
+ S[:n] = get_value(S, x, sym_obs_G);
S[:in] = true;
- S[:isabs] = m.isabsorbing(m.p,x))
+ S[:isabs] = getfield(m, :isabsorbing)(getfield(m, :p),x))
edge1 = Edge([:ALL], cc_aut_G_l4Gl1G_1, us_aut_G_l4Gl1G_1!)
map_edges[:l4G][:l1G] = [edge1]
tuple = (:l4G, :l2G)
- cc_aut_G_l4Gl2G_1(A::LHA, S::StateLHA) =
- (S.time >= A.constants[:t2])
- us_aut_G_l4Gl2G_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_G_l4Gl2G_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ (getfield(S, :time) >= constants[:t2])
+ us_aut_G_l4Gl2G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2G;
- S[:d] += S[:tprime] * min(abs(A.constants[:x1] - S[:n]), abs(A.constants[:x2] - S[:n]));
+ S[:d] += S[:tprime] * min(abs(constants[:x1] - S[:n]), abs(constants[:x2] - S[:n]));
S[:tprime] = 0.0)
edge1 = Edge([nothing], cc_aut_G_l4Gl2G_1, us_aut_G_l4Gl2G_1!)
@@ -204,44 +204,44 @@ function create_automaton_G_and_F(m::ContinuousTimeModel, x1::Float64, x2::Float
# Connection between the two automata: l2G => l1F
tuple = (:l2G, :l1F)
- cc_aut_F_l2Gl1F_1(A::LHA, S::StateLHA) = true
- us_aut_F_l2Gl1F_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_F_l2Gl1F_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) = true
+ us_aut_F_l2Gl1F_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l1F;
- S[:n] = get_value(A, x, sym_obs_F);
+ S[:n] = get_value(S, x, sym_obs_F);
S[:dprime] = Inf;
- S[:isabs] = m.isabsorbing(m.p,x))
+ S[:isabs] = getfield(m, :isabsorbing)(getfield(m, :p),x))
edge1 = Edge([nothing], cc_aut_F_l2Gl1F_1, us_aut_F_l2Gl1F_1!)
map_edges[:l2G][:l1F] = [edge1]
# l1F loc : we construct the edges of the form l1F => (..)
tuple = (:l1F, :l2F)
- cc_aut_F_l1Fl2F_1(A::LHA, S::StateLHA) =
- S.time >= A.constants[:t3] &&
- (A.constants[:x3] <= S[:n] <= A.constants[:x4])
- us_aut_F_l1Fl2F_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_F_l1Fl2F_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ getfield(S, :time) >= constants[:t3] &&
+ (constants[:x3] <= S[:n] <= constants[:x4])
+ us_aut_F_l1Fl2F_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2F;
S[:dprime] = 0)
edge1 = Edge([nothing], cc_aut_F_l1Fl2F_1, us_aut_F_l1Fl2F_1!)
- cc_aut_F_l1Fl2F_4(A::LHA, S::StateLHA) =
- S.time >= A.constants[:t3] &&
+ cc_aut_F_l1Fl2F_4(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ getfield(S, :time) >= constants[:t3] &&
S[:dprime] == 0
- us_aut_F_l1Fl2F_4!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ us_aut_F_l1Fl2F_4!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2F)
edge4 = Edge([nothing], cc_aut_F_l1Fl2F_4, us_aut_F_l1Fl2F_4!)
- cc_aut_F_l1Fl2F_2(A::LHA, S::StateLHA) =
- (S.time >= A.constants[:t4]) &&
- (S[:n] < A.constants[:x3] || S[:n] > A.constants[:x4])
- us_aut_F_l1Fl2F_2!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_F_l1Fl2F_2(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ (getfield(S, :time) >= constants[:t4]) &&
+ (S[:n] < constants[:x3] || S[:n] > constants[:x4])
+ us_aut_F_l1Fl2F_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2F;
- S[:dprime] = min(abs(S[:n] - A.constants[:x3]), abs(S[:n] - A.constants[:x4]));
+ S[:dprime] = min(abs(S[:n] - constants[:x3]), abs(S[:n] - constants[:x4]));
S[:d] += S[:dprime])
edge2 = Edge([nothing], cc_aut_F_l1Fl2F_2, us_aut_F_l1Fl2F_2!)
- cc_aut_F_l1Fl2F_3(A::LHA, S::StateLHA) =
- istrue(S[:isabs]) && S.time <= A.constants[:t4]
- us_aut_F_l1Fl2F_3!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_F_l1Fl2F_3(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ istrue(S[:isabs]) && getfield(S, :time) <= constants[:t4]
+ us_aut_F_l1Fl2F_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2F;
S[:d] += S[:dprime])
edge3 = Edge([nothing], cc_aut_F_l1Fl2F_3, us_aut_F_l1Fl2F_3!)
@@ -249,47 +249,47 @@ function create_automaton_G_and_F(m::ContinuousTimeModel, x1::Float64, x2::Float
map_edges[:l1F][:l2F] = [edge1, edge4, edge3, edge2]
tuple = (:l1F, :l3F)
- cc_aut_F_l1Fl3F_1(A::LHA, S::StateLHA) =
- (A.constants[:x3] <= S[:n] <= A.constants[:x4])
- us_aut_F_l1Fl3F_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_F_l1Fl3F_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ (constants[:x3] <= S[:n] <= constants[:x4])
+ us_aut_F_l1Fl3F_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l3F;
S[:dprime] = 0;)
edge1 = Edge([nothing], cc_aut_F_l1Fl3F_1, us_aut_F_l1Fl3F_1!)
- cc_aut_F_l1Fl3F_2(A::LHA, S::StateLHA) =
- (S[:n] < A.constants[:x3] || S[:n] > A.constants[:x4]) &&
- (S.time <= A.constants[:t3])
- us_aut_F_l1Fl3F_2!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_F_l1Fl3F_2(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ (S[:n] < constants[:x3] || S[:n] > constants[:x4]) &&
+ (getfield(S, :time) <= constants[:t3])
+ us_aut_F_l1Fl3F_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l3F;
- S[:dprime] = min(sqrt((S.time - A.constants[:t3])^2 + (S[:n] - A.constants[:x4])^2),
- sqrt((S.time - A.constants[:t3])^2 + (S[:n] - A.constants[:x3])^2)))
+ S[:dprime] = min(sqrt((getfield(S, :time) - constants[:t3])^2 + (S[:n] - constants[:x4])^2),
+ sqrt((getfield(S, :time) - constants[:t3])^2 + (S[:n] - constants[:x3])^2)))
edge2 = Edge([nothing], cc_aut_F_l1Fl3F_2, us_aut_F_l1Fl3F_2!)
- cc_aut_F_l1Fl3F_3(A::LHA, S::StateLHA) =
- (S[:n] < A.constants[:x3] || S[:n] > A.constants[:x4]) &&
- (A.constants[:t3] <= S.time <= A.constants[:t4])
- us_aut_F_l1Fl3F_3!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_F_l1Fl3F_3(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ (S[:n] < constants[:x3] || S[:n] > constants[:x4]) &&
+ (constants[:t3] <= getfield(S, :time) <= constants[:t4])
+ us_aut_F_l1Fl3F_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l3F;
- S[:dprime] = min(S[:dprime], min(abs(S[:n] - A.constants[:x3]), abs(S[:n] - A.constants[:x4]))))
+ S[:dprime] = min(S[:dprime], min(abs(S[:n] - constants[:x3]), abs(S[:n] - constants[:x4]))))
edge3 = Edge([nothing], cc_aut_F_l1Fl3F_3, us_aut_F_l1Fl3F_3!)
map_edges[:l1F][:l3F] = [edge1, edge2, edge3]
# l3F loc
tuple = (:l3F, :l1F)
- cc_aut_F_l3Fl1F_1(A::LHA, S::StateLHA) = true
- us_aut_F_l3Fl1F_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_F_l3Fl1F_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) = true
+ us_aut_F_l3Fl1F_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l1F;
- S[:n] = get_value(A, x, sym_obs_F);
- S[:isabs] = m.isabsorbing(m.p,x))
+ S[:n] = get_value(S, x, sym_obs_F);
+ S[:isabs] = getfield(m, :isabsorbing)(getfield(m, :p),x))
edge1 = Edge([:ALL], cc_aut_F_l3Fl1F_1, us_aut_F_l3Fl1F_1!)
map_edges[:l3F][:l1F] = [edge1]
tuple = (:l3F, :l2F)
- cc_aut_F_l3Fl2F_1(A::LHA, S::StateLHA) =
- (S.time >= A.constants[:t4])
- us_aut_F_l3Fl2F_1!(A::LHA, S::StateLHA, x::Vector{Int}) =
+ cc_aut_F_l3Fl2F_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ (getfield(S, :time) >= constants[:t4])
+ us_aut_F_l3Fl2F_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
(S.loc = :l2F)
edge1 = Edge([nothing], cc_aut_F_l3Fl2F_1, us_aut_F_l3Fl2F_1!)
diff --git a/core/lha.jl b/core/lha.jl
index dd2f312..777f197 100644
--- a/core/lha.jl
+++ b/core/lha.jl
@@ -1,5 +1,6 @@
length_var(A::LHA) = length(getfield(A, :map_var_automaton_idx))
+get_value(S::StateLHA, x::Vector{Int}, var::VariableModel) = x[getfield(getfield(S, :A), :map_var_model_idx)[var]]
get_value(A::LHA, x::Vector{Int}, var::VariableModel) = x[getfield(A, :map_var_model_idx)[var]]
copy(S::StateLHA) = StateLHA(getfield(S, :A), getfield(S, :loc), getfield(S, :values), getfield(S, :time))
@@ -51,7 +52,7 @@ isaccepted(S::StateLHA) = (getfield(S, :loc) in getfield(getfield(S, :A), :locat
# Methods for synchronize / read the trajectory
function init_state(A::LHA, x0::Vector{Int}, t0::Float64)
S0 = StateLHA(A, :init, zeros(length_var(A)), t0)
- for loc in A.locations_init
+ for loc in getfield(A, :locations_init)
if A.Λ[loc](A,S0)
S0.loc = loc
break
@@ -59,7 +60,8 @@ function init_state(A::LHA, x0::Vector{Int}, t0::Float64)
end
return S0
end
-
+# A push! method implementend by myself because I know in most cases the edge candidates
+# are not greater than 2
function _push_edge!(edge_candidates::Vector{Edge}, edge::Edge, nbr_candidates::Int)
if nbr_candidates < 2
edge_candidates[nbr_candidates+1] = edge
@@ -68,13 +70,14 @@ function _push_edge!(edge_candidates::Vector{Edge}, edge::Edge, nbr_candidates::
end
end
-function _find_edge_candidates!(edge_candidates::Vector{Edge}, current_loc::Location,
- A::LHA, Snplus1::StateLHA, only_asynchronous::Bool)
+function _find_edge_candidates!(edge_candidates::Vector{Edge},
+ edges_from_current_loc::Dict{Location,Vector{Edge}},
+ Snplus1::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int},
+ only_asynchronous::Bool)
nbr_candidates = 0
- edges_from_current_loc = A.map_edges[current_loc]
for target_loc in keys(edges_from_current_loc)
for edge in edges_from_current_loc[target_loc]
- if edge.check_constraints(A, Snplus1)
+ if getfield(edge, :check_constraints)(Snplus1, constants, x)
if edge.transitions[1] == nothing
_push_edge!(edge_candidates, edge, nbr_candidates)
nbr_candidates += 1
@@ -127,22 +130,23 @@ function next_state!(Snplus1::StateLHA, A::LHA,
@show Sn
@show Snplus1
end
-
+ constants = getfield(A, :constants)
# In terms of values not reference, Snplus1 == Sn
# First, we check the asynchronous transitions
while first_round || length(edge_candidates) > 0
turns += 1
#edge_candidates = empty!(edge_candidates)
- current_loc = Snplus1.loc
+ current_loc = getfield(Snplus1, :loc)
+ edges_from_current_loc = getfield(A, :map_edges)[current_loc]
# Save all edges that satisfies transition predicate (asynchronous ones)
- nbr_candidates = _find_edge_candidates!(edge_candidates, current_loc, A, Snplus1, true)
+ nbr_candidates = _find_edge_candidates!(edge_candidates, edges_from_current_loc, Snplus1, constants, xnplus1, true)
# Search the one we must chose, here the event is nothing because
# we're not processing yet the next event
ind_edge, detected_event = _get_edge_index(edge_candidates, nbr_candidates, detected_event, nothing)
# Update the state with the chosen one (if it exists)
# Should be xn here
if ind_edge > 0
- edge_candidates[ind_edge].update_state!(A, Snplus1, xnplus1)
+ getfield(edge_candidates[ind_edge], :update_state!)(Snplus1, constants, xnplus1)
end
first_round = false
if verbose
@@ -163,7 +167,7 @@ function next_state!(Snplus1::StateLHA, A::LHA,
@show tnplus1, tr_nplus1, xnplus1
@show edge_candidates
for edge in edge_candidates
- @show edge.check_constraints(A, Snplus1)
+ @show getfield(edge, :check_constraints)(Snplus1, constants, x)
end
error("Unpredicted behavior automaton")
end
@@ -187,10 +191,10 @@ function next_state!(Snplus1::StateLHA, A::LHA,
first_round = true
while first_round || length(edge_candidates) > 0
turns += 1
- #edge_candidates = empty!(edge_candidates)
- current_loc = Snplus1.loc
+ current_loc = getfield(Snplus1, :loc)
+ edges_from_current_loc = getfield(A, :map_edges)[current_loc]
# Save all edges that satisfies transition predicate (synchronous ones)
- nbr_candidates =_find_edge_candidates!(edge_candidates, current_loc, A, Snplus1, false)
+ nbr_candidates = _find_edge_candidates!(edge_candidates, edges_from_current_loc, Snplus1, constants, xnplus1, false)
# Search the one we must chose
ind_edge, detected_event = _get_edge_index(edge_candidates, nbr_candidates, detected_event, tr_nplus1)
# Update the state with the chosen one (if it exists)
@@ -200,7 +204,7 @@ function next_state!(Snplus1::StateLHA, A::LHA,
@show ind_edge, detected_event, nbr_candidates
end
if ind_edge > 0
- edge_candidates[ind_edge].update_state!(A, Snplus1, xnplus1)
+ getfield(edge_candidates[ind_edge], :update_state!)(Snplus1, constants, xnplus1)
end
first_round = false
if verbose
@@ -219,7 +223,7 @@ function next_state!(Snplus1::StateLHA, A::LHA,
@show tnplus1, tr_nplus1, xnplus1
@show edge_candidates
for edge in edge_candidates
- @show edge.check_constraints(A, Snplus1)
+ @show getfield(edge, :check_constraints)(Snplus1, constants, x)
end
error("Unpredicted behavior automaton")
end
--
GitLab