Update for regression

Author: Azzaare

Project.toml

@@ -1,7 +1,7 @@
 name = "ConstraintDomains"
 uuid = "5800fd60-8556-4464-8d61-84ebf7a0bedb"
 authors = ["Jean-François Baffier"]
-version = "0.3.15"
+version = "0.4.0"
 
 [deps]
 ConstraintCommons = "e37357d9-0691-492f-a822-e5ea6a920954"

src/explore.jl

@@ -1,4 +1,4 @@
-struct ExploreSettings
+mutable struct ExploreSettings
     complete_search_limit::Int
     max_samplings::Int
     search::Symbol
@@ -42,22 +42,45 @@ function ExploreSettings(
     return ExploreSettings(complete_search_limit, max_samplings, search, solutions_limit)
 end
 
-struct ExplorerState{T}
+abstract type AbstractExplorerState end
+
+struct CompleteExplorerState{N,T} <: AbstractExplorerState
     best::Vector{T}
-    solutions::Vector{Vector{T}}
-    non_solutions::Vector{Vector{T}}
+    solutions::Vector{NTuple{N,T}}
+    non_solutions::Vector{NTuple{N,T}}
+
+    CompleteExplorerState{N,T}() where {N,T} = new{N,T}(Vector{T}(), Vector{NTuple{N,T}}(), Vector{NTuple{N,T}}())
+end
 
-    ExplorerState{T}() where {T} = new{T}(Vector{T}(), Vector{Vector{T}}(), Vector{Vector{T}}())
+function explorer_state(domains, ::Val{:complete})
+    return CompleteExplorerState{length(domains),Union{map(eltype, domains)...}}()
 end
 
-ExplorerState(domains) = ExplorerState{Union{map(eltype, domains)...}}()
+struct PartialExplorerState{T} <: AbstractExplorerState
+    best::Vector{T}
+    solutions::Set{Vector{T}}
+    non_solutions::Set{Vector{T}}
+
+    PartialExplorerState{T}() where {T} = new{T}(Vector{T}(), Set{Vector{T}}(), Set{Vector{T}}())
+end
+function explorer_state(domains, ::Val{:partial})
+    return PartialExplorerState{Union{map(eltype, domains)...}}()
+end
 
-mutable struct Explorer{F1<:Function,D<:AbstractDomain,F2<:Union{Function,Nothing},T}
+mutable struct Explorer{F1<:Function,D<:AbstractDomain,F2<:Union{Function,Nothing},S<:AbstractExplorerState}
     concepts::Dict{Int,Tuple{F1,Vector{Int}}}
     domains::Dict{Int,D}
     objective::F2
     settings::ExploreSettings
-    state::ExplorerState{T}
+    state::S
+
+    function Explorer(concepts, domains, objective, settings, state)
+        F1 = isempty(concepts) ? Function : typeof(concepts).parameters[2].parameters[1]
+        D = isempty(domains) ? AbstractDomain : typeof(domains).parameters[2]
+        F2 = typeof(objective)
+        S = typeof(state)
+        return new{F1,D,F2,S}(concepts, domains, objective, settings, state)
+    end
 end
 
 """
@@ -88,13 +111,13 @@ function Explorer(
     objective=nothing;
     settings=ExploreSettings(domains),
 )
-    F1 = isempty(concepts) ? Function : Union{map(c -> typeof(c[1]), concepts)...}
-    D = isempty(domains) ? AbstractDomain : Union{map(typeof, domains)...}
-    F2 = typeof(objective)
-    T = isempty(domains) ? Real : Union{map(eltype, domains)...}
+    if settings.search == :flexible
+        settings.search = settings.max_samplings < settings.complete_search_limit ? :complete : :partial
+    end
+    state = explorer_state(domains, Val(settings.search))
     d_c = Dict(enumerate(concepts))
     d_d = Dict(enumerate(domains))
-    return Explorer{F1,D,F2,T}(d_c, d_d, objective, settings, ExplorerState{T}())
+    return Explorer(d_c, d_d, objective, settings, state)
 end
 
 function Explorer()
@@ -225,15 +248,14 @@ function update_exploration!(explorer, f, c, search=explorer.settings.search)
     obj = explorer.objective
     sl = search == :complete ? Inf : explorer.settings.solutions_limit
 
-    cv = collect(c)
-    if f(cv)
+    if f(c)
         if length(solutions) < sl
-            push!(solutions, cv)
+            push!(solutions, c)
             obj !== nothing && (explorer.state.best = argmin(obj, solutions))
         end
     else
         if length(non_sltns) < sl
-            push!(non_sltns, cv)
+            push!(non_sltns, c)
         end
     end
     return nothing
@@ -257,8 +279,6 @@ function _explore!(explorer, f, ::Val{:partial};)
         config = map(rand, domains)
         update_exploration!(explorer, f, config)
     end
-    unique!(explorer.state.solutions)
-    unique!(explorer.state.non_solutions)
     return nothing
 end
 
@@ -295,12 +315,7 @@ function explore!(explorer::Explorer)
             f(isempty(vars) ? x : @view x[vars]) for
             (f, vars) in explorer.concepts |> values
         ])
-    s = explorer.settings
-    search = s.search
-    if search == :flexible
-        search = s.max_samplings < s.complete_search_limit ? :complete : :partial
-    end
-    return _explore!(explorer, c, Val(search))
+    return _explore!(explorer, c, Val(explorer.settings.search))
 end