Map finite parameters to JuMP.Parameters (#387)

* Map finite parameters to JuMP.Parameters + update tests accordingly

* Simplify code in transcribe_finite_parameters!()

* Update TranscriptionOpt documentation about finite parameter mapping

* Add transcribe_finite_parameters! to technical API manual docs

* Fix typo in transcribe_finite_parameters docstring

Author: wenwen0231

docs/src/guide/transcribe.md

@@ -469,3 +469,13 @@ julia> supports(y^2 + z - 42)
 julia> parameter_refs(y^2 + z - 42)
 (t,)
 ```
+For finite parameters, we can also retrieve their corresponding `JuMP` parameter with `transformation_variable`.
+```jldoctest transcribe
+julia> param = @finite_parameter(inf_model, p == 42)
+p
+
+julia> build_transformation_backend!(inf_model)
+
+julia> transformation_variable(p)
+p
+```

docs/src/manual/transcribe.md

@@ -8,6 +8,7 @@ InfiniteOpt.TranscriptionOpt.TranscriptionBackend
 InfiniteOpt.TranscriptionOpt.TranscriptionData
 InfiniteOpt.TranscriptionOpt.Transcription
 InfiniteOpt.TranscriptionOpt.set_parameter_supports
+InfiniteOpt.TranscriptionOpt.transcribe_finite_parameters!
 InfiniteOpt.TranscriptionOpt.transcribe_finite_variables!
 InfiniteOpt.TranscriptionOpt.transcribe_infinite_variables!
 InfiniteOpt.TranscriptionOpt.transcribe_derivative_variables!

src/TranscriptionOpt/model.jl

@@ -337,13 +337,13 @@ const FinVarIndex = Union{
     }
 
 ## Define the variable mapping functions
-# FinVarIndex
+# FinVarIndex & FiniteParameterIndex
 function transcription_variable(
     vref::InfiniteOpt.GeneralVariableRef,
     ::Type{V},
     backend::TranscriptionBackend,
     label::Type{<:InfiniteOpt.AbstractSupportLabel}
-    ) where {V <: FinVarIndex}
+    ) where {V <: Union{FinVarIndex, InfiniteOpt.FiniteParameterIndex}}
     var = get(transcription_data(backend).finvar_mappings, vref, nothing)
     if isnothing(var)
         error("Variable reference $vref not used in transcription backend.")
@@ -551,7 +551,7 @@ function lookup_by_support(
     ::Type{V},
     backend::TranscriptionBackend,
     support::Vector
-    ) where {V <: FinVarIndex}
+    ) where {V <: Union{FinVarIndex, InfiniteOpt.FiniteParameterIndex}}
     if !haskey(transcription_data(backend).finvar_mappings, vref)
         error("Variable reference $vref not used in transcription backend.")
     end

src/TranscriptionOpt/transcribe.jl

@@ -54,6 +54,34 @@ end
 ################################################################################
 #                        VARIABLE INITIALIZATION METHODS
 ################################################################################
+"""
+    transcribe_finite_parameters!(
+        backend::TranscriptionBackend,
+        model::InfiniteOpt.InfiniteModel
+        )::Nothing
+
+Create a transcription variable (i.e., a JuMP Parameter) for each `FiniteParameter`
+stored in `model` and add it to `backend`. The variable mapping is
+also stored in `TranscriptionData.finvar_mappings` which enables
+[`transcription_variable`](@ref) and [`lookup_by_support`](@ref).
+"""
+function transcribe_finite_parameters!(
+    backend::TranscriptionBackend,
+    model::InfiniteOpt.InfiniteModel
+    )
+    for (idx, object) in InfiniteOpt._data_dictionary(model, InfiniteOpt.FiniteParameter)
+        fpref = InfiniteOpt.GeneralVariableRef(model, idx)
+
+        # Prepare arguments for building JuMP parameter
+        name = object.name
+        pValue = object.parameter.value
+        
+        # Build the JuMP variable and add it to the backend
+        pref = JuMP.@variable(backend.model, base_name = name, set = MOI.Parameter(pValue))
+        transcription_data(backend).finvar_mappings[fpref] = pref
+    end
+    return
+end
 """
     transcribe_finite_variables!(
         backend::TranscriptionBackend,
@@ -459,13 +487,13 @@ function transcription_expression(
     end
 end
 
-# Point variables and finite variables
+# Point variables, finite variables and finite parameters
 function transcription_expression(
     vref::InfiniteOpt.GeneralVariableRef,
     index_type::Type{V},
     backend::TranscriptionBackend,
     support::Vector{Float64}
-    ) where {V <: FinVarIndex}
+    ) where {V <: Union{FinVarIndex, InfiniteOpt.FiniteParameterIndex}}
     return lookup_by_support(vref, index_type, backend, support)
 end
 
@@ -480,15 +508,6 @@ function transcription_expression(
     return support[param_num]
 end
 
-# Finite parameters
-function transcription_expression(
-    vref::InfiniteOpt.GeneralVariableRef,
-    index_type::Type{InfiniteOpt.FiniteParameterIndex},
-    backend::TranscriptionBackend,
-    support::Vector{Float64}
-    )
-    return InfiniteOpt.parameter_value(vref)
-end
 
 # AffExpr and QuadExpr and NonlinearExpr
 function transcription_expression(
@@ -957,6 +976,7 @@ function build_transcription_backend!(
     # add nonlinear operators as needed 
     InfiniteOpt.add_operators_to_jump(backend.model, model)
     # define the variables
+    transcribe_finite_parameters!(backend, model)
     transcribe_finite_variables!(backend, model)
     transcribe_infinite_variables!(backend, model)
     transcribe_derivative_variables!(backend, model)

test/TranscriptionOpt/model.jl

@@ -404,10 +404,12 @@ end
     @variable(tb.model, b)
     @variable(tb.model, c)
     @variable(tb.model, d)
+    @variable(tb.model, e in Parameter(42))
     # 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[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]
@@ -450,7 +452,7 @@ end
     end
     # test transcription expression for finite parameters with 3 args
     @testset "IOTO.transcription_expression (Finite Parameter)" begin
-        @test IOTO.transcription_expression(finpar, tb, [0.5, 1., 0.]) == 42
+        @test IOTO.transcription_expression(finpar, tb, [0.5, 1., 0.]) == e
     end
     # test transcription expression for AffExprs with 3 args
     @testset "IOTO.transcription_expression (AffExpr)" begin

test/TranscriptionOpt/transcribe.jl

@@ -535,7 +535,7 @@ end
     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(c2)).func == zt + xt[1]
-    expected = IOTO.transcription_variable(meas2)[2] - 2 * IOTO.transcription_variable(y0) + xt[2]
+    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 constraint_object(IOTO.transcription_constraint(c3)).func == xt[1] - 2wt + xt[2] + zt - d2t[1] - d2t[2]
     @test constraint_object(IOTO.transcription_constraint(c6)).func == [zt, wt]