fix: default fn saving to BMA, add sync step

Author: ReubenJ

src/qualitative_networks.jl

@@ -598,27 +598,32 @@ function limit_change(
     return limited_value
 end
 
-"""
-    $(TYPEDSIGNATURES)
-"""
-function async_qn_step!(qn::QN)
-    entity_labels = entities(qn)
-    entity = rand(entity_labels)
+function _compute_next_state!(qn::QN, entity)
     (min_level, max_level) = extrema(get_domain(qn, entity))
     t = target_functions(qn)[entity]
     old_state = get_state(qn, entity)
     new_state = interpret(t, qn)
     new_state = isnan(new_state) ? min_level : new_state
     new_state = isinf(new_state) ? max_level : new_state
     limited_state = limit_change(old_state, floor(Int, new_state), min_level, max_level)
-    set_state!(qn, entity, limited_state)
+end
+
+"""
+    $(TYPEDSIGNATURES)
+"""
+function async_qn_step!(qn::QN)
+    entity_labels = entities(qn)
+    entity = rand(entity_labels)
+    next_state = _compute_next_state!(qn, entity)
+    set_state!(qn, entity, next_state)
 end
 
 """
     $(TYPEDSIGNATURES)
 """
 function sync_qn_step!(qn::QN)
-    throw(ErrorException("Synchronous step function not yet implemented"))
+    next_states = _compute_next_state!.((qn,), entities(qn))
+    set_state!.((qn,), entities(qn), next_states)
 end
 
 extract_state(model::QN) = model.state
@@ -706,7 +711,7 @@ function bma_dict_to_qn(bma_model::JSONModel)
         ) for e in bma_entities
     ]
 
-    return QualitativeNetwork(entities_with_functions; schedule = Asynchronous)
+    return QualitativeNetwork(entities_with_functions; schedule = Synchronous)
 end
 
 """
@@ -753,6 +758,47 @@ function swap_entity_names_to_var_ids(ex)
     end
 end
 
+"""
+    stringify_fn(ex, lower_bound, upper_bound)
+
+Take an `ex` and if it's of the form of a default function, return "".
+"""
+function stringify_fn(ex, lower_bound, upper_bound)
+    if is_default_function(ex, lower_bound, upper_bound)
+        return ""
+    else
+        string(ex)
+    end
+end
+
+function is_default_function(ex, lower_bound, upper_bound)
+    @match ex begin
+        # single activator
+        :(var($id)) => true
+
+        # multiple activators
+        Expr(:call, :/, Expr(:call, :+, vars...), denom) && (
+            if length(vars) == denom
+            end
+        ) => true
+
+        # only inhibitor(s)
+        :($bound - $inh) && (
+            if bound == upper_bound
+            end
+        ) => is_default_function(inh, lower_bound, upper_bound)
+
+        # both inhibitor(s) and activator(s)
+        :(max($bound, $act - $inh)) && (
+            if bound == lower_bound
+            end
+        ) =>
+            is_default_function(@show(act), lower_bound, upper_bound) &&
+            is_default_function(@show(inh), lower_bound, upper_bound)
+        _ => false
+    end
+end
+
 """
     $(SIGNATURES)
 
@@ -767,13 +813,14 @@ function qn_to_bma_dict(qn::QN{N,S,M}) where {N,S,C,G,L<:EntityIdName,M<:MetaGra
     functions = [target_functions(qn)[e] for e in entities(qn)]
     activator_inhibitor_pairs = classify_activators_inhibitors(target_functions(qn))
     functions = swap_entity_names_to_var_ids.(functions)
+    functions = stringify_fn.(functions, first.(lower_upper), last.(lower_upper))
 
     variables = [
         Dict(
             "RangeFrom" => d[1],
             "RangeTo" => d[2],
             "Id" => i,
-            "Formula" => string(f),
+            "Formula" => f,
             "Name" => n,
         ) for (d, i, n, f) in zip(lower_upper, ids, entity_names, functions)
     ]

test/Project.toml

@@ -4,6 +4,7 @@ Attractors = "f3fd9213-ca85-4dba-9dfd-7fc91308fec7"
 DynamicalSystemsBase = "6e36e845-645a-534a-86f2-f5d4aa5a06b4"
 Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
 HerbCore = "2b23ba43-8213-43cb-b5ea-38c12b45bd45"
+IterTools = "c8e1da08-722c-5040-9ed9-7db0dc04731e"
 JET = "c3a54625-cd67-489e-a8e7-0a5a0ff4e31b"
 JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
 MetaGraphsNext = "fa8bd995-216d-47f1-8a91-f3b68fbeb377"

test/qn_test.jl

@@ -179,6 +179,7 @@ end
 
 @testitem "Save to BMA" begin
     import MetaGraphsNext: edge_labels, labels
+    import GraphDynamicalSystems: is_default_function
     using JSON
 
     function test_json_roundtrip(model_path::AbstractString)
@@ -201,6 +202,16 @@ end
 
         @test haskey(model_dict, "Variables")
         variables = model_dict["Variables"]
+        for (orig_v, v) in zip(orig_dict["Model"]["Variables"], variables)
+            orig_f = Meta.parse(orig_v["Formula"])
+            f = Meta.parse(v["Formula"])
+
+            if is_default_function(orig_f, orig_v["RangeFrom"], orig_v["RangeTo"])
+                @test isnothing(f)
+            else
+                @test orig_f == f
+            end
+        end
         orig_variables_no_f = [
             Dict(k => v for (k, v) in var if k != "Formula") for
             var in orig_dict["Model"]["Variables"]
@@ -222,15 +233,27 @@ end
     bma_models_path = joinpath(@__DIR__, "resources", "bma_models")
     good_models = joinpath(bma_models_path, "well_formed_examples")
 
+    # just another reminder that the "Skin1D" example isn't working with this test
+    @test_broken false
+
     for model_path in filter(!contains(r"Skin1D"), readdir(good_models; join = true))
         test_json_roundtrip(model_path)
     end
-    # toy_model = joinpath(
-    #     @__DIR__,
-    #     "resources",
-    #     "bma_models",
-    #     "well_formed_examples",
-    #     "ToyModelStable.json",
-    # )
+end
 
+@testitem "is default function" begin
+    import IterTools: subsets
+    import GraphDynamicalSystems:
+        is_default_function, default_target_function, swap_entity_names_to_var_ids
+    combinations = Iterators.filter(
+        x -> !all(isempty.(x)),
+        Iterators.product(subsets([:A_1, :B_2, :X_5, :Y_6]), subsets([:C_3, :D_4, :Z_7])),
+    )
+    activators = first.(combinations)
+    inhibitors = last.(combinations)
+
+    fns = default_target_function.(0, 4, activators, inhibitors)
+    for f in swap_entity_names_to_var_ids.(fns)
+        @test is_default_function(f, 0, 4)
+    end
 end