AbstractParameter Bounded implemented (#4)

* Bounded added

* version updated

* docstring changed to calling signiture

* tests for checking boundaries for Positive and Bounded

Co-authored-by: Letif Mones <[email protected]>

Project.toml

@@ -1,7 +1,7 @@
 name = "ParameterHandling"
 uuid = "2412ca09-6db7-441c-8e3a-88d5709968c5"
 authors = ["Invenia Technical Computing Corporation"]
-version = "0.1.1"
+version = "0.1.2"
 
 [deps]
 Bijectors = "76274a88-744f-5084-9051-94815aaf08c4"

src/ParameterHandling.jl

@@ -3,7 +3,7 @@ module ParameterHandling
 using Bijectors
 using Compat: only
 
-export flatten, Positive, Fixed, Deferred
+export flatten, Positive, Bounded, Fixed, Deferred
 
 include("flatten.jl")
 include("parameters.jl")

src/parameters.jl

@@ -21,7 +21,7 @@ value(x::Dict) = Dict(k => value(v) for (k, v) in x)
 
 
 """
-    Positive{T<:Real, V}
+    Positive(value::Real)
 
 The `value` of a `Positive` is a `Real` number that is constrained to be positive. This is
 represented in terms of an `unconstrained_value` and a `transform` that maps any value
@@ -48,7 +48,43 @@ function flatten(x::Positive)
 end
 
 """
-    Fixed{T}    
+    Bounded(value::Real, lower_bound::Real, upper_bound::Real)
+
+The `value` of a `Bounded` is a `Real` number that is constrained to be within the interval
+(`lower_bound`, `upper_bound`). This is represented in terms of an `unconstrained_value` and 
+a `transform` that maps any value to reals included by (`lower_bound`, `upper_bound`).
+"""
+struct Bounded{T<:Real, V<:Bijector, Tε<:Real} <: AbstractParameter
+    unconstrained_value::T
+    lower_bound::T
+    upper_bound::T
+    transform::V
+    ε::Tε
+end
+
+function Bounded(value::Real, lower_bound::Real, upper_bound::Real)
+    lb = convert(typeof(value), lower_bound)
+    ub = convert(typeof(value), upper_bound)
+    ε = convert(typeof(value), 1e-12)
+
+    # Bijectors defines only Logit struct so we use Logistic as the inverse of Logit
+    return Bounded(value, lb, ub, inv(Bijectors.Logit(lb + ε, ub - ε)), ε)
+end
+
+value(x::Bounded) = x.transform(x.unconstrained_value)
+
+function flatten(x::Bounded)
+    v, unflatten_to_Real = flatten(x.unconstrained_value)
+
+    function unflatten_Bounded(v_new::Vector{<:Real})
+        return Bounded(unflatten_to_Real(v_new), x.lower_bound, x.upper_bound, x.transform, x.ε)
+    end
+
+    return v, unflatten_Bounded
+end
+
+"""
+    Fixed{T}
 
 Represents a parameter whose value is required to stay constant. The `value` of a `Fixed` is
 simply its value -- that constantness of the parameter is enforced by returning an empty

test/parameters.jl

@@ -2,7 +2,22 @@
 
     @testset "Postive" begin
         test_parameter_interface(Positive(5.0))
-        test_parameter_interface(Positive(5.0))
+        p = Positive(-10.0)
+        @test value(p) > p.ε
+        p = Positive(-Inf)
+        @test value(p) == p.ε
+    end
+
+    @testset "Bounded" begin
+        test_parameter_interface(Bounded(-1.0, -0.1, 2.0))
+        p = Bounded(-10.0, -0.1, 2.0)
+        @test value(p) > p.lower_bound
+        p = Bounded(-Inf, -0.1, 2.0)
+        @test value(p) == p.lower_bound + p.ε
+        p = Bounded(10.0, -0.1, 2.0)
+        @test value(p) < p.upper_bound
+        p = Bounded(Inf, -0.1, 2.0)
+        @test value(p) == p.upper_bound - p.ε
     end
 
     @testset "Fixed" begin