Updated CI and tests. Ambiguities left in Aqua

Author: Azzaare

.github/workflows/CompatHelper.yml

@@ -1,7 +1,7 @@
 name = "CompositionalNetworks"
 uuid = "4b67e4b5-442d-4ef5-b760-3f5df3a57537"
 authors = ["Jean-François Baffier"]
-version = "0.5.5"
+version = "0.5.6"
 
 [deps]
 ConstraintCommons = "e37357d9-0691-492f-a822-e5ea6a920954"
@@ -21,16 +21,21 @@ ConstraintCommons = "0.2"
 ConstraintDomains = "0.3"
 Dictionaries = "0.4"
 Distances = "0.10"
-JuliaFormatter = "0.22, 1"
+JuliaFormatter = "1"
 OrderedCollections = "1"
+Random = "1"
 TestItemRunner = "0.2"
 TestItems = "0.1"
 ThreadSafeDicts = "0.1"
 Unrolled = "0.1"
 julia = "1.8"
 
 [extras]
+Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
+Evolutionary = "86b6b26d-c046-49b6-aa0b-5f0f74682bd6"
+Memoization = "6fafb56a-5788-4b4e-91ca-c0cea6611c73"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+ThreadPools = "b189fb0b-2eb5-4ed4-bc0c-d34c51242431"
 
 [targets]
-test = ["Test"]
+test = ["Aqua", "Evolutionary", "Memoization", "Test", "ThreadPools"]

.github/workflows/TagBot.yml

@@ -3,16 +3,16 @@ using ConstraintDomains
 using Documenter
 
 makedocs(;
-    modules=[CompositionalNetworks, ConstraintDomains],
-    authors="Jean-François Baffier",
-    repo="https://github.com/JuliaConstraints/CompositionalNetworks.jl/blob/{commit}{path}#L{line}",
-    sitename="CompositionalNetworks.jl",
-    format=Documenter.HTML(;
-        prettyurls=get(ENV, "CI", nothing) == "true",
-        canonical="https://JuliaConstraints.github.io/CompositionalNetworks.jl",
+    modules = [CompositionalNetworks, ConstraintDomains],
+    authors = "Jean-François Baffier",
+    repo = "https://github.com/JuliaConstraints/CompositionalNetworks.jl/blob/{commit}{path}#L{line}",
+    sitename = "CompositionalNetworks.jl",
+    format = Documenter.HTML(;
+        prettyurls = get(ENV, "CI", nothing) == "true",
+        canonical = "https://JuliaConstraints.github.io/CompositionalNetworks.jl",
         assets = ["assets/favicon.ico"; "assets/github_buttons.js"; "assets/custom.css"],
     ),
-    pages=[
+    pages = [
         "Home" => "index.md",
         "ICNs" => "icn.md",
         "Layers" => [
@@ -21,18 +21,12 @@ makedocs(;
             "Aggregation" => "aggregation.md",
             "Comparison" => "comparison.md",
         ],
-        "Dependencies" => [
-            "ConstraintDomains.jl" => "domain.md",
-        ],
-        "Library" => [
-            "public.md",
-            "internal.md",
-        ],
+        "Dependencies" => ["ConstraintDomains.jl" => "domain.md"],
+        "Library" => ["public.md", "internal.md"],
     ],
 )
 
 deploydocs(;
-    repo="github.com/JuliaConstraints/CompositionalNetworks.jl.git",
-    devbranch="main",
+    repo = "github.com/JuliaConstraints/CompositionalNetworks.jl.git",
+    devbranch = "main",
 )
-

.github/workflows/ci.yml

@@ -24,5 +24,13 @@ using ConstraintDomains
     alloc() = explore_learn_compose(domains, allunique)
 
     # Actual call to PerfChecker
-    alloc_check(title, dependencies, targets, pre_alloc, alloc; path=@__DIR__, threads=10)
+    alloc_check(
+        title,
+        dependencies,
+        targets,
+        pre_alloc,
+        alloc;
+        path = @__DIR__,
+        threads = 10,
+    )
 end

Project.toml

@@ -14,7 +14,8 @@ domains = fill(domain([1, 2, 3, 4]), 4)
 foreach(_ -> explore_learn_compose(domains, allunique), 1:10)
 
 # Code being benchmarked
-t = @benchmark explore_learn_compose(domains, allunique) evals=1 samples=10 seconds=3600
+t = @benchmark explore_learn_compose(domains, allunique) evals = 1 samples = 10 seconds =
+    3600
 
 # Store the bench results
-store_benchmark(t, target; path=@__DIR__)
+store_benchmark(t, target; path = @__DIR__)

docs/make.jl

@@ -24,7 +24,7 @@ end
 
 Access the code of a composition `c` in a given language `lang`. The name of the generated method is optional.
 """
-function code(c::Composition, lang=:maths; name="composition")
+function code(c::Composition, lang = :maths; name = "composition")
     return get!(c.code, lang, generate(c, name, Val(lang)))
 end
 
@@ -46,7 +46,7 @@ symbols(c::Composition) = c.symbols
     compose(icn, weigths=nothing)
 Return a function composed by some of the operations of a given ICN. Can be applied to any vector of variables. If `weigths` are given, will assign to `icn`.
 """
-function compose(icn::ICN, weigths::BitVector=BitVector())
+function compose(icn::ICN, weigths::BitVector = BitVector())
     !isempty(weigths) && weigths!(icn, weigths)
     composition, symbols = _compose(icn)
     return Composition(composition, symbols)
@@ -69,10 +69,10 @@ function generate(c::Composition, name, ::Val{:Julia})
     tr_length = length(symbs[1])
 
     CN = "CompositionalNetworks."
-    tr = reduce_symbols(symbs[1], ", "; prefix=CN * "tr_")
-    ar = reduce_symbols(symbs[2], ", ", false; prefix=CN * "ar_")
-    ag = reduce_symbols(symbs[3], ", ", false; prefix=CN * "ag_")
-    co = reduce_symbols(symbs[4], ", ", false; prefix=CN * "co_")
+    tr = reduce_symbols(symbs[1], ", "; prefix = CN * "tr_")
+    ar = reduce_symbols(symbs[2], ", ", false; prefix = CN * "ar_")
+    ag = reduce_symbols(symbs[3], ", ", false; prefix = CN * "ag_")
+    co = reduce_symbols(symbs[4], ", ", false; prefix = CN * "co_")
 
     documentation = """\"\"\"
         $name(x; X = zeros(length(x), $tr_length), param=nothing, dom_size)
@@ -91,15 +91,15 @@ function generate(c::Composition, name, ::Val{:Julia})
         return $ag(@view X[:, 1]) |> (y -> $co(y; param, dom_size, nvars=length(x)))
     end
     """
-    return documentation * format_text(output, BlueStyle(); pipe_to_function_call=false)
+    return documentation * format_text(output, BlueStyle(); pipe_to_function_call = false)
 end
 
 """
     composition_to_file!(c::Composition, path, name, language=:Julia)
 
 Write the composition code in a given `language` into a file at `path`.
 """
-function composition_to_file!(c::Composition, path, name, language=:Julia)
+function composition_to_file!(c::Composition, path, name, language = :Julia)
     output = code(c, language; name)
     write(path, output)
     return nothing

perf/allocs.jl

@@ -17,11 +17,11 @@ mutable struct ICN
     weigths::BitVector
 
     function ICN(;
-        param=Vector{Symbol}(),
-        tr_layer=transformation_layer(param),
-        ar_layer=arithmetic_layer(),
-        ag_layer=aggregation_layer(),
-        co_layer=comparison_layer(param)
+        param = Vector{Symbol}(),
+        tr_layer = transformation_layer(param),
+        ar_layer = arithmetic_layer(),
+        ag_layer = aggregation_layer(),
+        co_layer = comparison_layer(param),
     )
         w = generate_weigths([tr_layer, ar_layer, ag_layer, co_layer])
         return new(tr_layer, ar_layer, ag_layer, co_layer, w)
@@ -107,7 +107,7 @@ function regularization(icn)
     return Σop / (Σmax + 1)
 end
 
-max_icn_length(icn=ICN(; param=[:val])) = length(icn.transformation)
+max_icn_length(icn = ICN(; param = [:val])) = length(icn.transformation)
 
 """
     _compose(icn)
@@ -116,8 +116,7 @@ Internal function called by `compose` and `show_composition`.
 function _compose(icn::ICN)
     !is_viable(icn) && (
         return (
-            (x; X=zeros(length(x), max_icn_length()), param=nothing, dom_size=0) ->
-                typemax(Float64)
+            (x; X = zeros(length(x), max_icn_length()), param = nothing, dom_size = 0) -> typemax(Float64)
         ),
         []
     )
@@ -152,11 +151,17 @@ function _compose(icn::ICN)
         end
     end
 
-    function composition(x; X=zeros(length(x), length(funcs[1])), param=nothing, dom_size)
+    function composition(
+        x;
+        X = zeros(length(x), length(funcs[1])),
+        param = nothing,
+        dom_size,
+    )
         tr_in(Tuple(funcs[1]), X, x, param)
-        X[1:length(x), 1] .= 1:length(x) .|> (i -> funcs[2][1](@view X[i, 1:length(funcs[1])]))
-        return (y -> funcs[4][1](y; param, dom_size, nvars=length(x)))(
-            funcs[3][1](@view X[:, 1])
+        X[1:length(x), 1] .=
+            1:length(x) .|> (i -> funcs[2][1](@view X[i, 1:length(funcs[1])]))
+        return (y -> funcs[4][1](y; param, dom_size, nvars = length(x)))(
+            funcs[3][1](@view X[:, 1]),
         )
     end
 

perf/bench.jl

@@ -4,7 +4,7 @@ A structure to store a `LittleDict` of operations that can be selected during th
 """
 struct Layer
     exclusive::Bool
-    functions::LittleDict{Symbol, Function}
+    functions::LittleDict{Symbol,Function}
     parameters::Vector{Symbol}
 end
 
@@ -83,10 +83,11 @@ end
 Generate the weigths of a collection of layers or of an ICN.
 """
 function generate_weigths(layers)
-    bitvecs = map(l -> exclu(l) ?
-            generate_exclusive_operation(length(l)) :
+    bitvecs = map(
+        l ->
+            exclu(l) ? generate_exclusive_operation(length(l)) :
             generate_inclusive_operations(any, length(l)),
-            layers
+        layers,
     )
     return vcat(bitvecs...)
 end

src/composition.jl

@@ -15,10 +15,8 @@ ag_count_positive(x) = count(y -> y > 0.0, x)
 Generate the layer of aggregations of the ICN. The operations are mutually exclusive, that is only one will be selected.
 """
 function aggregation_layer()
-    aggregations = LittleDict{Symbol, Function}(
-        :sum => ag_sum,
-        :count_positive => ag_count_positive,
-    )
+    aggregations =
+        LittleDict{Symbol,Function}(:sum => ag_sum, :count_positive => ag_count_positive)
 
     return Layer(true, aggregations, Vector{Symbol}())
 end
@@ -27,10 +25,7 @@ end
 @testitem "Aggregation Layer" tags = [:aggregation, :layer] begin
     CN = CompositionalNetworks
 
-    data = [
-        [1, 5, 2, 4, 3] => 2,
-        [1, 2, 3, 2, 1] => 2,
-    ]
+    data = [[1, 5, 2, 4, 3] => 2, [1, 2, 3, 2, 1] => 2]
 
     @test CN.ag_sum(data[1].first) == 15
     @test CN.ag_sum(data[2].first) == 9