Perf regressino debug

Author: Azzaare

Project.toml

@@ -11,7 +11,7 @@ StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
 TestItems = "1c621080-faea-4a02-84b6-bbd5e436b8fe"
 
 [compat]
-ConstraintCommons = "0.2"
+ConstraintCommons = "0.2, 0.3"
 Intervals = "1"
 PatternFolds = "0.2"
 StatsBase = "0.34"

src/old_explore.jl

@@ -0,0 +1,90 @@
+struct ExploreSettings
+    complete_search_limit::Int
+    max_samplings::Int
+    search::Symbol
+    solutions_limit::Int
+end
+
+"""
+    ExploreSettings(
+        domains;
+        complete_search_limit = 10^6,
+        max_samplings = sum(domain_size, domains),
+        search = :flexible,
+        solutions_limit = floor(Int, sqrt(max_samplings)),
+    )
+
+Settings for the exploration of a search space composed by a collection of domains.
+"""
+function ExploreSettings(
+    domains;
+    complete_search_limit=10^6,
+    max_samplings=sum(domain_size, domains),
+    search=:flexible,
+    solutions_limit=floor(Int, sqrt(max_samplings)),
+)
+    return ExploreSettings(complete_search_limit, max_samplings, search, solutions_limit)
+end
+
+"""
+    _explore(args...)
+
+Internals of the `explore` function. Behavior is automatically adjusted on the kind of exploration: `:flexible`, `:complete`, `:partial`.
+"""
+function _explore(domains, f, s, ::Val{:partial})
+    solutions = Set{Vector{Int}}()
+    non_sltns = Set{Vector{Int}}()
+
+    sl = s.solutions_limit
+
+    for _ = 1:s.max_samplings
+        length(solutions) ≥ sl && length(non_sltns) ≥ sl && break
+        config = map(rand, domains)
+        c = f(config) ? solutions : non_sltns
+        length(c) < sl && push!(c, config)
+    end
+    return solutions, non_sltns
+end
+
+function _explore(domains, f, ::ExploreSettings, ::Val{:complete})
+    solutions = Set{Vector{Int}}()
+    non_sltns = Set{Vector{Int}}()
+
+    configurations = Base.Iterators.product(map(d -> get_domain(d), domains)...)
+    foreach(
+        c -> (cv = collect(c); push!(f(cv) ? solutions : non_sltns, cv)),
+        configurations,
+    )
+    return solutions, non_sltns
+end
+
+function _explore(domains, f, s, ::Val{:flexible})
+    search = s.max_samplings < s.complete_search_limit ? :complete : :partial
+    return _explore(domains, f, s, Val(search))
+end
+
+"""
+    explore(domains, concept, param = nothing; search_limit = 1000, solutions_limit = 100)
+
+Search (a part of) a search space and returns a pair of vector of configurations: `(solutions, non_solutions)`. If the search space size is over `search_limit`, then both `solutions` and `non_solutions` are limited to `solutions_limit`.
+
+Beware that if the density of the solutions in the search space is low, `solutions_limit` needs to be reduced. This process will be automatic in the future (simple reinforcement learning).
+
+# Arguments:
+- `domains`: a collection of domains
+- `concept`: the concept of the targeted constraint
+- `param`: an optional parameter of the constraint
+- `sol_number`: the required number of solutions (half of the number of configurations), default to `100`
+"""
+function explore(domains, concept; settings=ExploreSettings(domains), parameters...)
+    f = x -> concept(x; parameters...)
+    return _explore(domains, f, settings, Val(settings.search))
+end
+
+## SECTION - Test Items
+@testitem "Exploration" tags = [:exploration] begin
+    domains = [domain([1, 2, 3, 4]) for i = 1:4]
+    X, X̅ = explore(domains, allunique)
+    @test length(X) == factorial(4)
+    @test length(X̅) == 4^4 - factorial(4)
+end