Add tests

Author: blegat

src/Utilities/sparse_matrix.jl

@@ -183,19 +183,27 @@ function Base.convert(
     )
 end
 
+_indexing(A::MutableSparseMatrixCSC) = A.indexing
+_indexing(::SparseArrays.SparseMatrixCSC) = OneBasedIndexing()
+
+const _SparseMatrixCSC{Tv,Ti} = Union{
+    MutableSparseMatrixCSC{Tv,Ti},
+    SparseArrays.SparseMatrixCSC{Tv,Ti}
+}
+
 function _first_in_column(
-    A::MutableSparseMatrixCSC,
+    A::_SparseMatrixCSC,
     row::Integer,
     col::Integer,
 )
     range = SparseArrays.nzrange(A, col)
-    row = _shift(row, OneBasedIndexing(), A.indexing)
+    row = _shift(row, OneBasedIndexing(), _indexing(A))
     idx = searchsortedfirst(view(A.rowval, range), row)
     return get(range, idx, last(range) + 1)
 end
 
 function extract_function(
-    A::MutableSparseMatrixCSC{T},
+    A::_SparseMatrixCSC{T},
     row::Integer,
     constant::T,
 ) where {T}
@@ -205,7 +213,7 @@ function extract_function(
         if idx > last(SparseArrays.nzrange(A, col))
             continue
         end
-        r = _shift(A.rowval[idx], A.indexing, OneBasedIndexing())
+        r = _shift(A.rowval[idx], _indexing(A), OneBasedIndexing())
         if r == row
             push!(
                 func.terms,
@@ -217,7 +225,7 @@ function extract_function(
 end
 
 function extract_function(
-    A::MutableSparseMatrixCSC{T},
+    A::_SparseMatrixCSC{T},
     rows::UnitRange,
     constants::Vector{T},
 ) where {T}
@@ -231,7 +239,7 @@ function extract_function(
             if idx[col] > last(SparseArrays.nzrange(A, col))
                 continue
             end
-            row = _shift(A.rowval[idx[col]], A.indexing, OneBasedIndexing())
+            row = _shift(A.rowval[idx[col]], _indexing(A), OneBasedIndexing())
             if row != rows[output_index]
                 continue
             end

test/Utilities/matrix_of_constraints.jl

@@ -714,6 +714,82 @@ function test_unsupported_constraint()
     return
 end
 
+MOI.Utilities.@product_of_sets(
+    _EqualTos,
+    MOI.EqualTo{T},
+)
+
+function _equality_constraints(A::AbstractMatrix{T}, b::AbstractVector{T}) where {T}
+    sets = _EqualTos{T}()
+    for _ in eachindex(b)
+        MOI.Utilities.add_set(sets, MOI.Utilities.set_index(sets, MOI.EqualTo{T}))
+    end
+    MOI.Utilities.final_touch(sets)
+    constants = MOI.Utilities.Hyperrectangle(b, b)
+    model = MOI.Utilities.MatrixOfConstraints{T}(A, constants, sets)
+    model.final_touch = true
+    return model
+end
+
+
+# Inspired from MatrixOfConstraints
+function test_lp_standard_form()
+    s = """
+    variables: x1, x2
+    cx1: x1 >= 0.0
+    cx2: x2 >= 0.0
+    c1: 1x1       == 5.0
+    c2: 3x1 + 4x2 == 6.0
+    minobjective: 7x1 + 8x2
+    """
+    expected = MOI.Utilities.Model{Float64}()
+    MOI.Utilities.loadfromstring!(expected, s)
+
+    var_names = ["x1", "x2"]
+    con_names = ["c1", "c2"]
+
+    A = SparseArrays.sparse([
+        1.0 0.0
+        3.0 4.0
+    ])
+    b = [5.0, 6.0]
+    form = MOI.Utilities.GenericModel{Float16}(
+        expected.objective,
+        expected.variables,
+        _equality_constraints(A, b),
+    )
+
+    model = MOI.Utilities.Model{Float64}()
+    MOI.copy_to(
+        MOI.Bridges.Constraint.Scalarize{Float64}(model),
+        form,
+    )
+    MOI.set(
+        model,
+        MOI.VariableName(),
+        MOI.VariableIndex.(eachindex(var_names)),
+        var_names,
+    )
+    MOI.set(
+        model,
+        MOI.ConstraintName(),
+        MOI.ConstraintIndex{
+            MOI.ScalarAffineFunction{Float64},
+            MOI.EqualTo{Float64},
+        }.(eachindex(con_names)),
+        con_names,
+    )
+
+    MOI.Test.util_test_models_equal(
+        model,
+        expected,
+        var_names,
+        con_names,
+    )
+
+    return
+end
+
 end
 
 TestMatrixOfConstraints.runtests()