Add a function enum to enumerate parameter values (#70)

* Add a function `enum` to enumerate parameter values

Author: tmigot

.github/workflows/CI.yml

@@ -23,7 +23,7 @@ jobs:
         with:
           version: ${{ matrix.version }}
           arch: ${{ matrix.arch }}
-      - uses: actions/cache@v1
+      - uses: actions/cache@v3
         env:
           cache-name: cache-artifacts
         with:

src/SolverParameters.jl

@@ -9,6 +9,8 @@ import Base.values
 import Base.names
 import Base.convert
 
+export enum
+
 include("default-parameter.jl")
 include("domains.jl")
 include("parameters.jl")

src/domains.jl

@@ -24,6 +24,13 @@ See [`RealInterval`](@ref), [`IntegerRange`](@ref), [`IntegerSet`](@ref), [`Bina
 """
 abstract type AbstractDomain{T} end
 
+"""
+    enum(::AbstractDomain{T}; step, kwargs...)
+
+Return an iterable object of values in the domain `d` with step `step`.
+"""
+function enum end
+
 ∈(::T, ::AbstractDomain{T}) where {T} = false
 lower(::AbstractDomain{T}) where {T} =
   throw(DomainError("Lower bound is undefined for this domain."))
@@ -94,6 +101,29 @@ function Base.rand(rng::Random.AbstractRNG, d::RealInterval{T}) where {T <: Inte
   return r * (upp - low) + low
 end
 
+function enum(d::RealInterval{T}; step = sqrt(eps(T)), kwargs...) where {T <: AbstractFloat}
+  bnd = 1 / sqrt(eps(T))
+  low = if lower(d) == -Inf || !d.lower_open
+    lower(d)
+  else
+    lower(d) + eps(T)
+  end
+  low = max(low, -bnd)
+  upp = if upper(d) == -Inf || !d.lower_open
+    upper(d)
+  else
+    upper(d) - eps(T)
+  end
+  upp = min(upp, bnd)
+  return range(low, upp, step	= step)
+end
+
+function enum(d::RealInterval{T}; step = 1, kwargs...) where {T <: Integer}
+  low = d.lower_open ? lower(d) + 1 : lower(d)
+  upp = d.upper_open ? upper(d) - 1 : upper(d)
+  return range(low, upp, step = step)
+end
+
 """
 Integer domain for discrete variables:
   - Integer range;
@@ -129,6 +159,7 @@ upper(D::IntegerRange) = D.upper
 ∈(x::T, D::IntegerRange{T}) where {T <: Integer} = lower(D) ≤ x ≤ upper(D)
 
 Base.rand(rng::Random.AbstractRNG, d::IntegerRange) = rand(rng, (d.lower):(d.upper))
+enum(d::IntegerRange; step = 1) = range(d.lower, d.upper, step = step)
 
 """
     BinaryRange{T <: Bool} <: IntegerDomain{T}
@@ -150,6 +181,7 @@ lower(D::BinaryRange{Bool}) = false
 upper(D::BinaryRange{Bool}) = true
 ∈(x::T, D::BinaryRange{T}) where {T <: Bool} = true
 Base.rand(rng::Random.AbstractRNG, ::BinaryRange) = rand(rng, Bool)
+enum(::BinaryRange; kwargs...) = (false, true)
 
 """
     IntegerSet{T} <: IntegerDomain{T}
@@ -175,7 +207,8 @@ end
 lower(D::IntegerSet{T}) where {T <: Integer} = min(D.set...)
 upper(D::IntegerSet{T}) where {T <: Integer} = max(D.set...)
 
-Base.rand(rng::Random.AbstractRNG, d::IntegerSet) = rand(rng, d.set)
+Base.rand(rng::Random.AbstractRNG, D::IntegerSet) = rand(rng, D.set)
+enum(D::IntegerSet; kwargs...) = D.set
 
 """
 Categorical domain for categorical variables.
@@ -209,3 +242,4 @@ end
 CategoricalSet() = CategoricalSet(Vector{String}())
 ∈(x::T, D::CategoricalSet{T}) where {T} = x in D.categories
 Base.rand(rng::Random.AbstractRNG, d::CategoricalSet) = rand(rng, Set(d.categories))
+enum(d::CategoricalSet) = d.categories

src/parameters.jl

@@ -143,3 +143,12 @@ function set_value!(parameter::Parameter{T}, new_value::T) where {T}
   check_value(domain(parameter), new_value)
   parameter.value = new_value
 end
+
+"""
+    enum(::Parameter{T}; step, kwargs...)
+
+Return an iterable object of values in the domain `d` with step `step`.
+"""
+function enum(parameter::Parameter{T}; kwargs...) where {T}
+  return enum(domain(parameter); kwargs...)
+end

src/parameterset.jl

@@ -73,6 +73,25 @@ function Base.rand(
   return values
 end
 
+"""
+    enum(::AbstractParameterSet; step, kwargs...)
+    enum(subset::NTuple{N, Symbol}, ::AbstractParameterSet; step, kwargs...)
+
+Return an iterable object of values in the AbstractParameterSet with step `step`.
+"""
+function enum(subset::NTuple{N, Symbol}, param_set::AbstractParameterSet; kwargs...) where {N}
+  vec = Vector{Any}(undef, length(subset))
+  for (i, field) in enumerate(subset)
+    param = getfield(param_set, field)
+    vec[i] = (field, enum(param; kwargs...))
+  end
+  return vec
+end
+
+function enum(param_set::P; kwargs...) where {P <: AbstractParameterSet}
+  return enum(fieldnames(P), param_set; kwargs...)
+end
+
 function fieldnames_num(parameter_set::T) where {T <: AbstractParameterSet}
   nn = collect(fieldnames(T))
   for (i, param_name) in enumerate(nn)

test/test_domains.jl

@@ -57,6 +57,16 @@ end
       @test rand(d_lopen) ∈ d_lopen
       @test rand(d_ropen) ∈ d_ropen
       @test rand(d_open) ∈ d_open
+      @testset "enum" verbose = true for d in [d_closed, d_lopen, d_ropen, d_open]
+        i = 0
+        for elt in enum(d)
+          @test eltype(elt) == T
+          i += 1
+          if i == 3
+            break
+          end
+        end
+      end
     end
   end
   @testset "IntegerRange $T" verbose = true for T in (Int32, Int64)
@@ -71,19 +81,26 @@ end
       @test_throws ErrorException IntegerRange(max, min)
     end
     @test rand(d) ∈ d
+    @test enum(d) == typemin(T):1:typemax(T)
+    @test enum(d, step = 2) == typemin(T):2:typemax(T)
   end
   @testset "Binary range" begin
     b = BinaryRange()
     @test lower(b) == false
     @test upper(b) == true
     @test rand(b) ∈ b
+    for elt in enum(b)
+      @test eltype(elt) == Bool
+    end
   end
   @testset "IntegerSet" verbose = true begin
-    d = IntegerSet([2, 4, 5, 1, 3, 7])
+    vecset = [2, 4, 5, 1, 3, 7]
+    d = IntegerSet(vecset)
     @test lower(d) == 1
     @test upper(d) == 7
     @test (4 ∈ d) == true
     @test (6 ∈ d) == false
     @test rand(d) ∈ d
+    enum(d) == Set(vecset)
   end
 end

test/test_parameters.jl

@@ -214,3 +214,12 @@ end
   @test upper_bounds!(subset, param_set, b) == [Inf]
   @test eltype(b) == Float64
 end
+
+@testset "Enum parameters in ParameterSet" begin
+  param_set = CatMockSolverParamSet()
+  enum(param_set) == [
+    (:real_inf, -6.7108864e7:1.4901161193847656e-8:6.7108864e7),
+    (:real, ["A", "B", "C", "D"]),
+    (:int_r, 5:1:20)
+  ]
+end