Properly Handle Parameter Functions as JuMP.Parameters in Measures (#391)

* Create make_point_variable_ref in TranscriptionOpt/measures.jl

* Add unit test for make_point_variable_ref for paramFuncs

* Add unit tests for measures w/ semi-infinite + point vars

* Remove transcribe semi inf + point var statements from unit test

* Uncomment unit tests in TranscriptionOpt/transcribe

---------

Co-authored-by: Joshua Pulsipher <[email protected]>

Author: wenwen0231

src/TranscriptionOpt/measures.jl

@@ -74,25 +74,36 @@ function InfiniteOpt.add_semi_infinite_variable(
         # make the reference and map it to a transcription variable
         rvref = InfiniteOpt.GeneralVariableRef(inf_model, raw_index, InfiniteOpt.SemiInfiniteVariableIndex)
         push!(semi_infinite_vars, var)
-        if ivref.index_type != InfiniteOpt.ParameterFunctionIndex
-            ivref_param_nums = InfiniteOpt._parameter_numbers(ivref)
-            param_nums = var.parameter_nums
-            supp_indices = support_index_iterator(backend, var.group_int_idxs)
-            lookup_dict = Dict{Vector{Float64}, JuMP.VariableRef}()
-            sizehint!(lookup_dict, length(supp_indices))
-            for i in supp_indices
-                raw_supp = index_to_support(backend, i)
-                if any(!isnan(raw_supp[ivref_param_nums[k]]) && raw_supp[ivref_param_nums[k]] != v for (k, v) in eval_supps)
-                    continue
-                end
-                ivref_supp = [haskey(eval_supps, j) ? eval_supps[j] : raw_supp[k] 
-                            for (j, k) in enumerate(ivref_param_nums)]
-                supp = raw_supp[param_nums]
-                lookup_dict[supp] = lookup_by_support(ivref, backend, ivref_supp)
+        ivref_param_nums = InfiniteOpt._parameter_numbers(ivref)
+        param_nums = var.parameter_nums
+        supp_indices = support_index_iterator(backend, var.group_int_idxs)
+        lookup_dict = Dict{Vector{Float64}, JuMP.VariableRef}()
+        sizehint!(lookup_dict, length(supp_indices))
+        for i in supp_indices
+            raw_supp = index_to_support(backend, i)
+            if any(!isnan(raw_supp[ivref_param_nums[k]]) && raw_supp[ivref_param_nums[k]] != v for (k, v) in eval_supps)
+                continue
             end
-            data.infvar_lookup[rvref] = lookup_dict
+            ivref_supp = [haskey(eval_supps, j) ? eval_supps[j] : raw_supp[k] 
+                        for (j, k) in enumerate(ivref_param_nums)]
+            supp = raw_supp[param_nums]
+            lookup_dict[supp] = lookup_by_support(ivref, backend, ivref_supp)
         end
+        data.infvar_lookup[rvref] = lookup_dict
         data.semi_lookup[(ivref, eval_supps)] = rvref
         return rvref
     end
 end
+
+function InfiniteOpt.make_point_variable_ref(
+    write_model::TranscriptionBackend, 
+    ivref, 
+    support, 
+    ::Union{Type{InfiniteOpt.ParameterFunctionIndex}}
+    )
+    prefs = parameter_list(ivref)
+    for i in eachindex(support)
+        support[i] = round(support[i], sigdigits = significant_digits(prefs[i]))
+    end 
+    return add_point_variable(write_model, ivref, support)
+end

test/TranscriptionOpt/measure.jl

@@ -4,6 +4,7 @@
     m = InfiniteModel()
     @infinite_parameter(m, par in [0, 1], supports = [0, 1])
     @infinite_parameter(m, pars[1:2] in [0, 1], supports = [0, 1])
+    @parameter_function(m, pf == par -> sin(par))
     @variable(m, x, Infinite(par))
     @variable(m, y, Infinite(par, pars))
     @variable(m, x0, Point(x, 0))
@@ -13,7 +14,12 @@
     @variable(tb.model, b)
     @variable(tb.model, c)
     @variable(tb.model, d)
+    @variable(tb.model, e in Parameter(sin(0)))
+    @variable(tb.model, f in Parameter(sin(1)))
     data = IOTO.transcription_data(tb)
+    data.infvar_mappings[pf] = [e, f]
+    data.infvar_supports[pf] = [(0.,), (1.,)]
+    data.infvar_lookup[pf] = Dict([0] => e, [1] => f)
     data.infvar_mappings[x] = [a, b]
     data.infvar_supports[x] = [(0.,), (1.,)]
     data.infvar_lookup[x] = Dict([0] => a, [1] => b)
@@ -25,13 +31,25 @@
     data.infvar_lookup[y0] = Dict([0, 0, 0] => a, [0, 1, 1] => b)
     data.finvar_mappings[x0] = a
     IOTO.set_parameter_supports(tb, m)
+    # test make_point_variable_ref
+    @testset "make_point_variable_ref" begin
+        # adding a point var from an evaluated paramFunc
+        pfref = GeneralVariableRef(m, -1, PointVariableIndex)
+        testRef = InfiniteOpt.make_point_variable_ref(tb, pf, Float64[1])
+        @test isequal(pfref, testRef)
+        @test IOTO.transcription_variable(pfref) == f
+        # add a point var that was already added internally
+        @test isequal(InfiniteOpt.add_point_variable(tb, pf, Float64[1]), pfref)
+        @test IOTO.transcription_variable(pfref) == f
+
+    end
     # test add_point_variable
     @testset "add_point_variable" begin
         # add one that was already added to the infinite model 
         @test isequal(InfiniteOpt.add_point_variable(tb, x, Float64[0]), x0)
         @test IOTO.transcription_variable(x0) == a
         # add one that hasn't been added
-        vref = GeneralVariableRef(m, -1, PointVariableIndex)
+        vref = GeneralVariableRef(m, -2, PointVariableIndex)
         @test isequal(InfiniteOpt.add_point_variable(tb, x, Float64[1]), vref)
         @test IOTO.transcription_variable(vref) == b
         # add one that has been added internally

test/TranscriptionOpt/transcribe.jl

@@ -182,8 +182,11 @@ end
 @testset "Measure/Objective Transcription" begin 
     # Prepare the model 
     m = InfiniteModel()
-    @infinite_parameter(m, pars[1:2] in [0, 1], supports = [0, 1])
     @infinite_parameter(m, par in [0, 1], supports = [0, 1])
+    @infinite_parameter(m, par2 in [3, 4], supports = [3, 4])
+    @infinite_parameter(m, pars[1:2] in [0, 1], supports = [0, 1])
+    @parameter_function(m, pf1 == par -> sin(par))
+    @parameter_function(m, pf2 == (par, par2) -> sin(par)*cos(par2))
     @variable(m, x >= 0, Infinite(par))
     @variable(m, y == 2, Infinite(par, pars), start = (p, ps) -> p + sum(ps))
     @variable(m, 0 <= z <= 1, Bin)
@@ -192,10 +195,13 @@ end
     meas2 = integral(w, par)
     meas3 = integral(y^2, pars)
     meas4 = integral(pars[1], pars[1])
+    meas5 = integral(pf1, par)
+    meas6 = integral(pf2, par2)
     tb = m.backend
     IOTO.set_parameter_supports(tb, m)
     IOTO.transcribe_finite_variables!(tb, m)
     IOTO.transcribe_infinite_variables!(tb, m)
+    IOTO.transcribe_parameter_functions!(tb, m)
     tx = IOTO.transcription_variable(x)
     ty = IOTO.transcription_variable(y)
     tz = IOTO.transcription_variable(z)
@@ -207,9 +213,16 @@ end
         @test IOTO.transcription_variable(meas2) == tw + 0
         @test IOTO.transcription_variable(meas3) isa Vector
         @test IOTO.transcription_variable(meas4) isa AffExpr
+        meas5Eval = 0.5*sum(IOTO.transcription_variable.(pf1))
+        @test IOTO.transcription_variable(meas5) == meas5Eval
+        tpf2 = IOTO.transcription_variable.(pf2)
+        meas6Eval = 0.5.*[tpf2[1] + tpf2[3], tpf2[2] + tpf2[4]]
+        @test IOTO.transcription_variable(meas6) == meas6Eval
         @test supports(meas1) == ()
         @test supports(meas2) == ()
         @test supports(meas3) == [(0.,), (1., )]
+        @test supports(meas5) == ()
+        @test supports(meas6) == [(0.0,), (1.0,)]
     end
     # test transcribe_objective!
     @testset "transcribe_objective!" begin