Map parameter functions to JuMP.Parameters (#389)

* Map parameter functions to JuMP params in infvar mapping dicts

* Add parameter funcs to infinite var transcription methods + update relevant unit tests

* Add docstring to transcribe_parameter_functions! + include in technical manual

* Fix typo in transcribe_parameter_functions! docstring

* Add unit test to test value func with real value argument

Author: wenwen0231

docs/src/manual/transcribe.md

@@ -11,6 +11,7 @@ InfiniteOpt.TranscriptionOpt.set_parameter_supports
 InfiniteOpt.TranscriptionOpt.transcribe_finite_parameters!
 InfiniteOpt.TranscriptionOpt.transcribe_finite_variables!
 InfiniteOpt.TranscriptionOpt.transcribe_infinite_variables!
+InfiniteOpt.TranscriptionOpt.transcribe_parameter_functions!
 InfiniteOpt.TranscriptionOpt.transcribe_derivative_variables!
 InfiniteOpt.TranscriptionOpt.transcribe_semi_infinite_variables!
 InfiniteOpt.TranscriptionOpt.transcribe_point_variables!

src/TranscriptionOpt/model.jl

@@ -351,13 +351,13 @@ function transcription_variable(
     return var
 end
 
-# InfVarIndex
+# InfVarIndex & ParameterFunctionIndex
 function transcription_variable(
     vref::InfiniteOpt.GeneralVariableRef,
     ::Type{V},
     backend::TranscriptionBackend,
     label::Type{<:InfiniteOpt.AbstractSupportLabel}
-    ) where {V <: InfVarIndex}
+    ) where {V <: Union{InfVarIndex, InfiniteOpt.ParameterFunctionIndex}}
     vars = get(transcription_data(backend).infvar_mappings, vref, nothing)
     if isnothing(vars)
         error("Variable reference $vref not used in transcription backend.")
@@ -370,32 +370,6 @@ function transcription_variable(
     end
 end
 
-# ParameterFunctionIndex
-function transcription_variable(
-    fref::InfiniteOpt.GeneralVariableRef,
-    ::Type{InfiniteOpt.ParameterFunctionIndex},
-    backend::TranscriptionBackend,
-    label::Type{<:InfiniteOpt.AbstractSupportLabel}
-    )
-    # get the parameter group integer indices of the expression and form the support iterator
-    group_idxs = InfiniteOpt.parameter_group_int_indices(fref)
-    support_indices = support_index_iterator(backend, group_idxs)
-    dims = size(support_indices)[group_idxs]
-    vals = Array{Float64, length(dims)}(undef, dims...)
-    # iterate over the indices and compute the values
-    for idx in support_indices
-        supp = index_to_support(backend, idx)
-        val_idx = idx.I[group_idxs]
-        @inbounds vals[val_idx...] = transcription_expression(fref, backend, supp)
-    end
-    # return the values
-    if _ignore_label(backend, label)
-        return vals
-    else
-        return _truncate_by_label(vals, fref, label, group_idxs, backend)
-    end
-end
-
 # Fallback
 function transcription_variable(
     vref::InfiniteOpt.GeneralVariableRef,
@@ -521,30 +495,19 @@ _supp_error() = error("""
     parameters.
     """)
 
-# InfiniteIndex
+# InfiniteIndex & ParameterFunctionIndex
 function lookup_by_support(
     vref::InfiniteOpt.GeneralVariableRef,
     ::Type{V},
     backend::TranscriptionBackend,
     support::Vector
-    ) where {V <: InfVarIndex}
+    ) where {V <: Union{InfVarIndex, InfiniteOpt.ParameterFunctionIndex}}
     if !haskey(transcription_data(backend).infvar_lookup, vref)
         error("Variable reference $vref not used in transcription backend.")
     end
     return get(_supp_error, transcription_data(backend).infvar_lookup[vref], support)
 end
 
-# ParameterFunctionIndex
-function lookup_by_support(
-    fref::InfiniteOpt.GeneralVariableRef,
-    ::Type{InfiniteOpt.ParameterFunctionIndex},
-    backend::TranscriptionBackend,
-    support::Vector
-    )
-    prefs = InfiniteOpt.raw_parameter_refs(fref)
-    return InfiniteOpt.call_function(fref, Tuple(support, prefs)...)
-end
-
 # FiniteIndex
 function lookup_by_support(
     vref::InfiniteOpt.GeneralVariableRef,

src/TranscriptionOpt/transcribe.jl

@@ -136,6 +136,62 @@ function _make_var_name(base_name, param_nums, tuple_supp, var_idx)
     end
 end
 
+"""
+    transcribe_parameter_functions!(
+        backend::TranscriptionBackend,
+        model::InfiniteOpt.InfiniteModel
+        )::Nothing
+
+Create transcription variables (i.e., JuMP Parameters) corresponding to 
+all supports of each `Parameter Function` stored in `model` and add them to 
+`backend`. The variable mappings are also stored in 
+`TranscriptionData.infvar_mappings` in accordance with 
+`TranscriptionData.infvar_lookup` which enable [`transcription_variable`](@ref)
+and [`lookup_by_support`](@ref). Note that the supports will not be generated
+until `InfiniteOpt.variable_supports` is invoked via `InfiniteOpt.supports`. 
+Note that `TranscriptionData.infvar_support_labels` is also populated.
+"""
+function transcribe_parameter_functions!(
+    backend::TranscriptionBackend,
+    model::InfiniteOpt.InfiniteModel,
+    )
+    for (idx, object) in model.param_functions
+        # get the basic parameter function information
+        pf = object.func
+        base_name = object.name
+        func = pf.func
+        param_nums = pf.parameter_nums
+        group_idxs = pf.group_int_idxs
+        prefs = pf.parameter_refs
+        # prepare for iterating over its supports
+        supp_indices = support_index_iterator(backend, group_idxs)
+        dims = size(supp_indices)[group_idxs]
+        vrefs = Array{JuMP.VariableRef, length(dims)}(undef, dims...)
+        supp_type = typeof(Tuple(ones(length(prefs)), prefs))
+        supps = Array{supp_type, length(dims)}(undef, dims...)
+        lookup_dict = sizehint!(Dict{Vector{Float64}, JuMP.VariableRef}(), length(vrefs))
+        # Create a parameter for each support
+        for i in supp_indices
+            supp = index_to_support(backend, i)[param_nums]
+            var_idx = i.I[group_idxs]
+            tuple_supp = Tuple(supp, prefs)
+            p_name = _make_var_name(base_name, param_nums, tuple_supp, var_idx)
+            pValue = func(tuple_supp...)
+            jump_pref = JuMP.@variable(backend.model, base_name = p_name, set = MOI.Parameter(pValue))
+            vrefs[var_idx...] = jump_pref
+            lookup_dict[supp] = jump_pref
+            supps[var_idx...] = tuple_supp
+        end
+        # save the transcription information
+        pfref = InfiniteOpt.GeneralVariableRef(model, idx)
+        data = transcription_data(backend)
+        data.infvar_lookup[pfref] = lookup_dict
+        data.infvar_mappings[pfref] = vrefs
+        data.infvar_supports[pfref] = supps
+    end
+    return
+end
+
 """
     transcribe_infinite_variables!(
         backend::TranscriptionBackend,
@@ -475,16 +531,8 @@ function transcription_expression(
     backend::TranscriptionBackend,
     support::Vector{Float64}
     )
-    ivref = InfiniteOpt.infinite_variable_ref(vref)
-    if InfiniteOpt._index_type(ivref) == InfiniteOpt.ParameterFunctionIndex 
-        prefs = InfiniteOpt.raw_parameter_refs(ivref)
-        param_nums = InfiniteOpt._parameter_numbers(ivref)
-        func = InfiniteOpt.raw_function(ivref)
-        return func(Tuple(support[param_nums], prefs)...)
-    else 
-        param_nums = InfiniteOpt._parameter_numbers(vref)
-        return lookup_by_support(vref, index_type, backend, support[param_nums])
-    end
+    param_nums = InfiniteOpt._parameter_numbers(vref)
+    return lookup_by_support(vref, index_type, backend, support[param_nums])
 end
 
 # Point variables, finite variables and finite parameters
@@ -979,6 +1027,7 @@ function build_transcription_backend!(
     transcribe_finite_parameters!(backend, model)
     transcribe_finite_variables!(backend, model)
     transcribe_infinite_variables!(backend, model)
+    transcribe_parameter_functions!(backend, model)
     transcribe_derivative_variables!(backend, model)
     transcribe_semi_infinite_variables!(backend, model)
     transcribe_point_variables!(backend, model)

test/TranscriptionOpt/model.jl

@@ -121,6 +121,15 @@ end
     @variable(tb.model, d)
     @variable(tb.model, e)
     @variable(tb.model, f)
+    @variable(tb.model, p1a in Parameter(sin(0)))
+    @variable(tb.model, p1b in Parameter(sin(0.5)))
+    @variable(tb.model, p1c in Parameter(sin(1)))
+    @variable(tb.model, p2a in Parameter(1))
+    @variable(tb.model, p2b in Parameter(1))
+    @variable(tb.model, p2c in Parameter(1))
+    @variable(tb.model, p2d in Parameter(1))
+    @variable(tb.model, p2e in Parameter(1))
+    @variable(tb.model, p2f in Parameter(1))
     # test _ignore_label
     @testset "_ignore_label" begin
         @test IOTO._ignore_label(tb, All)
@@ -156,10 +165,20 @@ end
     end
     # test IOTO.transcription_variable (Parameter Function)
     @testset "IOTO.transcription_variable (Parameter Function)" begin
+        # test error
+        @test_throws ErrorException IOTO.transcription_variable(f1, tb)
+        @test_throws ErrorException IOTO.transcription_variable(f2, tb)
         # test normal
-        @test IOTO.transcription_variable(f1, tb) == [sin(0), sin(1)]
-        @test IOTO.transcription_variable(f1, tb, label = All) == sin.([0, 0.5, 1])
-        @test IOTO.transcription_variable(f2, tb) == ones(2, 2)
+        data.infvar_mappings[f1] = [p1a, p1b, p1c]
+        data.infvar_mappings[f2] = [p2a p2b; p2c p2d; p2e p2f]
+        @test JuMP.parameter_value.([p1a, p1b, p1c]) == sin.([0., 0.5, 1.])
+        @test JuMP.parameter_value.([p2a p2b; p2c p2d; p2e p2f]) == ones(3, 2)
+        @test IOTO.transcription_variable(f1, tb) isa Vector{JuMP.VariableRef}
+        @test IOTO.transcription_variable(f1, tb) == [p1a, p1c]
+        @test IOTO.transcription_variable(f1, tb, label = All) == [p1a, p1b, p1c]
+        @test IOTO.transcription_variable(f2, tb) isa Matrix{JuMP.VariableRef}
+        @test IOTO.transcription_variable(f2, tb) == [p2a p2b; p2e p2f]
+        @test IOTO.transcription_variable(f2, tb, label = All) == [p2a p2b; p2c p2d; p2e p2f]
     end
     # test IOTO.transcription_variable (Fallback)
     @testset "IOTO.transcription_variable (Fallback)" begin
@@ -170,7 +189,7 @@ end
         @test IOTO.transcription_variable(y) == a
         @test IOTO.transcription_variable(x, label = All) == [a b; c d; e f]
         @test IOTO.transcription_variable(x0) == a
-        @test IOTO.transcription_variable(f2) == ones(2, 2)
+        @test IOTO.transcription_variable(f2) == [p2a p2b; p2e p2f]
     end
     # test transformation_variable extension
     @testset "transformation_variable" begin
@@ -247,8 +266,30 @@ end
     end
     # test lookup_by_support (infinite parameter functions)
     @testset "lookup_by_support (Parameter Function)" begin
-        @test IOTO.lookup_by_support(f1, tb, [0.]) == 0
-        @test IOTO.lookup_by_support(f2, tb, [0., 0., 1.]) == 1
+        lookups = Dict{Vector{Float64}, VariableRef}(
+            [0.] => p1a,
+            [0.5] => p1b,
+            [1.] => p1c
+            )
+        data.infvar_lookup[f1] = lookups
+        lookups = Dict{Vector{Float64}, VariableRef}(
+            [0., 0., 0.] => p2a,
+            [0.5, 0., 0.] => p2b,
+            [1., 0., 0.] => p2c,
+            [0., 1., 1.] => p2d,
+            [0.5, 1., 1.] => p2e,
+            [1., 1., 1.] => p2f
+            )
+        data.infvar_lookup[f2] = lookups
+        # test errors
+                @test_throws ErrorException IOTO.lookup_by_support(f1, tb, [0.75])
+        @test_throws ErrorException IOTO.lookup_by_support(f2, tb, [0., 0., 1.])
+        # test normal
+        @test IOTO.lookup_by_support(f1, tb, [0.]) == p1a
+        @test IOTO.lookup_by_support(f1, tb, [0.5]) == p1b
+        @test IOTO.lookup_by_support(f1, tb, [1.]) == p1c
+        @test IOTO.lookup_by_support(f2, tb, [0.5, 0., 0.]) == p2b
+        @test IOTO.lookup_by_support(f2, tb, [0.5, 1., 1.]) == p2e
     end
     # test lookup_by_support (finite vars)
     @testset "lookup_by_support (Finite)" begin
@@ -405,15 +446,19 @@ end
     @variable(tb.model, c)
     @variable(tb.model, d)
     @variable(tb.model, e in Parameter(42))
+    @variable(tb.model, pf1 in Parameter(1))
+    @variable(tb.model, pf2 in Parameter(1))
     # transcribe the variables and measures
     data = IOTO.transcription_data(tb)
     data.finvar_mappings[y] = a
     data.finvar_mappings[x0] = a
     data.finvar_mappings[finpar] = e
+    data.infvar_mappings[f] = [pf1, pf2]
     data.infvar_mappings[x] = reshape([a, b], :, 1)
     data.measure_mappings[meas1] = fill(-2 * zero(AffExpr))
     data.measure_mappings[meas2] = [a^2 + c^2 - 2a, b^2 + d^2 - 2a]
     data.infvar_lookup[x] = Dict([0, 0, 0] => a, [1, 0, 0] => b)
+    data.infvar_lookup[f] = Dict([0, 0, 0] => pf1, [1, 0, 0] => pf2)
     data.measure_lookup[meas1] = Dict(Float64[] => 1)
     data.measure_lookup[meas2] = Dict([0] => 1, [1] => 2)
     @test IOTO.set_parameter_supports(tb, m) isa Nothing
@@ -425,14 +470,16 @@ end
     @testset "IOTO.transcription_expression (Infinite Variable)" begin
         @test IOTO.transcription_expression(x, tb, [0., 0., 0.]) == a
         @test IOTO.transcription_expression(meas1, tb, [0., 0., 1.]) == -2 * zero(AffExpr)
-        @test IOTO.transcription_expression(f, tb, [0., 0., 1.]) == 1
+        @test IOTO.transcription_expression(f, tb, [0., 0., 1.]) == pf2
     end
     # test transcription expression for semi_infinite variables with 3 args
     @testset "IOTO.transcription_expression (Semi-Infinite Variable)" begin
         # semi_infinite of parameter function
         rv = add_variable(m, build_variable(error, f, Dict(1=>1.)),
                           add_support = false)
-        @test IOTO.transcription_expression(rv, tb, [0., 0., 1.]) == 1
+        data.infvar_mappings[rv] = [pf2]
+        data.infvar_lookup[rv] = Dict([0, 0] => pf2)
+        @test IOTO.transcription_expression(rv, tb, [0., 0., 1.]) == pf2
         # semi_infinite of infinite variable
         rv = add_variable(m, build_variable(error, x, Dict(1=>1.)),
                           add_support = false)

test/TranscriptionOpt/transcribe.jl

@@ -532,8 +532,9 @@ end
     @test objective_sense(tb.model) == MOI.MIN_SENSE
     # test constraints
     yt = IOTO.transcription_variable(y)
+    ft = IOTO.transformation_variable(f)
     dt_c1 = IOTO.lookup_by_support(d1, tb, zeros(3))
-    @test constraint_object(IOTO.transcription_constraint(c1)).func == -zt + xt[1] + dt_c1
+    @test constraint_object(IOTO.transcription_constraint(c1)).func == -zt + xt[1] + dt_c1 + ft[1]
     @test constraint_object(IOTO.transcription_constraint(c2)).func == zt + xt[1]
     expected = IOTO.transcription_variable(meas2)[2] - 2 * IOTO.transcription_variable(y0) + xt[2] + IOTO.transcription_variable(fin)
     @test constraint_object(IOTO.transcription_constraint(c4)).func == expected

test/backend_mappings.jl

@@ -59,14 +59,16 @@ end
     build_transformation_backend!(m)
     tb = m.backend
     tdata = IOTO.transcription_data(tb)
+    ft = transformation_variable(f, tb)
     # Test transformation_variable
     @testset "transformation_variable" begin
         # test normal usage
         @test transformation_variable(x, label = All) == IOTO.transcription_variable(x, label = All)
         @test transformation_variable(x0) == IOTO.transcription_variable(x0)
         @test transformation_variable(z) == IOTO.transcription_variable(z)
         @test transformation_variable(d1, label = InternalLabel) == IOTO.transcription_variable(d1, label = InternalLabel)
-        @test transformation_variable(f) == [0, sin(1)]
+        @test ft isa Array{JuMP.VariableRef}
+        @test JuMP.parameter_value.(ft) == [0, sin(1)]
         # test deprecation 
         @test (@test_deprecated optimizer_model_variable(z)) == transformation_variable(z)
         # test fallback
@@ -104,7 +106,7 @@ end
         @test transformation_expression(x^2 + z) == [xt[1]^2 + zt, xt[3]^2 + zt]
         @test transformation_expression(x^2 + z, label = All) == [xt[1]^2 + zt, xt[2]^2 + zt, xt[3]^2 + zt]
         @test transformation_expression(2z - 3) == 2zt - 3
-        @test transformation_expression(2 * f) == [zero(AffExpr), zero(AffExpr) + sin(1) * 2]
+        @test transformation_expression(2 * f) == [2 * ft[1], 2* ft[2]]
         # test deprecation
         @test (@test_deprecated optimizer_model_expression(2z-4)) == 2zt - 4
         # test fallback

test/results.jl

@@ -190,6 +190,7 @@ end
     inf2t = transformation_variable(inf2, label = All)
     d1t = transformation_variable(d1, label = All)
     rvt = transformation_variable(rv, label = All)
+    at = transformation_variable(a, label = All)
     cref = UpperBoundRef(g)
     creft = transformation_constraint(cref, label = All)
     # setup the optimizer
@@ -213,6 +214,9 @@ end
     MOI.set(mockoptimizer, MOI.VariablePrimal(1), JuMP.optimizer_index(d1t[1]), 2.0)
     MOI.set(mockoptimizer, MOI.VariablePrimal(1), JuMP.optimizer_index(d1t[2]), 1.0)
     MOI.set(mockoptimizer, MOI.VariablePrimal(1), JuMP.optimizer_index(d1t[3]), 2.0)
+    MOI.set(mockoptimizer, MOI.VariablePrimal(1), JuMP.optimizer_index(at[1]), sin(0.0))
+    MOI.set(mockoptimizer, MOI.VariablePrimal(1), JuMP.optimizer_index(at[2]), sin(0.5))
+    MOI.set(mockoptimizer, MOI.VariablePrimal(1), JuMP.optimizer_index(at[3]), sin(1.0))
     # test has_values
     @testset "JuMP.has_values" begin
         @test has_values(m)
@@ -242,8 +246,9 @@ end
         @test value(par, label = All) == [0., 0.5, 1.]
         @test value(fin) == 42
         @test value(fin, label = All) == 42
-        @test value(a) == [sin(0.), sin(1.)]
-        @test value(a, label = All) == [sin(0.), sin(0.5), sin(1.)]
+        @test value(a) == sin.([0., 1.])
+        @test value(a, label = All) == sin.([0., 0.5, 1.])
+        @test value(sin(0.0)) == sin(0.0)
     end
     #test Reduced Cost
     @testset "map_reduced_cost" begin