Simplify with MatrixOfConstraints

Author: blegat

src/matrix_input.jl

@@ -79,66 +79,63 @@ function MOI.get(
     return _dot(model.A[ci.value, :])
 end
 
-"""
-    LPStandardForm{T, AT<:AbstractMatrix{T}, VT <: AbstractVector{T}} <: AbstractLPForm{T}
+MOI.Utilities.@product_of_sets(
+    Equalities,
+    MOI.EqualTo{T},
+)
 
-Represents a problem of the form:
-```
-sense ⟨c, x⟩
-s.t.  A x == b
-      x ≥ 0
-```
-"""
-struct LPStandardForm{T,AT<:AbstractMatrix{T},VT<:AbstractVector{T}} <:
-       AbstractLPForm{T}
-    sense::MOI.OptimizationSense
-    c::VT
-    A::AT
-    b::VT
-end
 
-function MOI.get(
-    ::LPStandardForm{T},
-    ::MOI.ListOfConstraintTypesPresent,
-) where {T}
-    return [
-        (MOI.ScalarAffineFunction{T}, MOI.EqualTo{T}),
-        (MOI.VectorOfVariables, MOI.Nonnegatives),
-    ]
+# TODO specialize for SparseVector
+function linear_function(c::AbstractVector{T}) where {T}
+    return MOI.ScalarAffineFunction(
+        [MOI.ScalarAffineTerm(c[i], MOI.VariableIndex(i)) for i in eachindex(c)],
+        zero(T),
+    )
 end
 
-const EQ{T} = MOI.ConstraintIndex{MOI.ScalarAffineFunction{T},MOI.EqualTo{T}}
-
-function MOI.get(
-    model::LPStandardForm{T},
-    ::MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{T},MOI.EqualTo{T}},
-) where {T}
-    # TODO return `collect` with MOI v0.9.15 (see https://github.com/jump-dev/MathOptInterface.jl/pull/1110)
-    return collect(MOIU.LazyMap{EQ{T}}(
-        i -> EQ{T}(i), # FIXME `LazyMap` needs a `Function` so cannot just give `EQ{T}`
-        1:size(model.A, 1),
-    ))
+function linear_objective(sense::MOI.OptimizationSense, c::AbstractVector{T})
+    model = MOI.Utilities.ObjectiveContainer{T}()
+    MOI.set(model, MOI.ObjectiveSense(), sense)
+    func = linear_function(c)
+    MOI.set(model, MOI.ObjectiveFunction{typeof(func)}(), func)
+    return model
 end
 
-function MOI.get(model::LPStandardForm, ::MOI.ConstraintSet, ci::EQ)
-    return MOI.EqualTo(model.b[ci.value])
+function nonnegative_variables(n)
+    model = MOI.Utilities.VariablesContainer{T}()
+    for _ in 1:n
+        MOI.add_constrained_variable(model, MOI.GreaterThan(zero(T)))
+    end
+    return model
 end
 
-const NONNEG = MOI.ConstraintIndex{MOI.VectorOfVariables,MOI.Nonnegatives}
-
-function MOI.get(
-    ::LPStandardForm,
-    ::MOI.ListOfConstraintIndices{MOI.VectorOfVariables,MOI.Nonnegatives},
-)
-    return [NONNEG(1)]
+function equality_constraints(A::AbstractMatrix{T}, b::AbstractVector{T}) where {T}
+    return MOI.Utilities.MatrixOfConstraint{T}(
+        A,
+        b,
+        Equalities{T}(), # TODO
+    )
 end
 
-function MOI.get(model::LPStandardForm, ::MOI.ConstraintFunction, ci::NONNEG)
-    return MOI.VectorOfVariables(MOI.get(model, MOI.ListOfVariableIndices()))
-end
+"""
+    lp_standard_form(sense::MOI.OptimizationSense, c::AbtractVector, A::AbstractMatrix, b::AbstractVector)
 
-function MOI.get(model::LPStandardForm, ::MOI.ConstraintSet, ci::NONNEG)
-    return MOI.Nonnegatives(MOI.get(model, MOI.NumberOfVariables()))
+Represents a problem of the form:
+```
+sense ⟨c, x⟩
+s.t.  A x == b
+      x ≥ 0
+```
+"""
+function lp_standard_form(sense::MOI.OptimizationSense, c::AbtractVector{T}, A::AbstractMatrix{T}, b::AbstractVector{T}) where {T}
+    m, n = size(A)
+    @assert length(c) == n
+    @assert length(b) == m
+    return MOI.Utilities.GenericModel{T}(
+        linear_objective(sense, c),
+        nonnegative_variables(n),
+        equality_constraints(A, b),
+    )
 end
 
 """