A struct for CSRMatrix (#17)

Add a new CSRMatrix{T} struct to overcome ambiguity relating to the
lots of different length vector inputs to the solver facing methods.

It is not intended to be a fully-fledged matrix type so it is not a 
subtype of AbstractSparseMatrix.

Author: odow

src/constraints.jl

@@ -152,14 +152,37 @@ function MOI.get(m::LinQuadOptimizer, ::Type{MOI.ConstraintIndex{F,S}}, name::St
     m.constraint_names_rev[name]::MOI.ConstraintIndex{F,S}
 end
 
+
+"""
+    CSRMatrix{T}
+
+Matrix given in compressed sparse row (CSR) format.
+
+`CSRMatrix` is analgous to the structure in Julia's `SparseMatrixCSC` but with
+the rows and columns flipped. It contains three vectors:
+ - `row_pointers` is a vector pointing to the start of each row in
+    `columns` and `coefficients`;
+ - `columns` is a vector of column numbers; and
+ - `coefficients` is a vector of corresponding nonzero values.
+
+The length of `row_pointers` is the number of rows in the matrix.
+
+This struct is not a subtype of `AbstractSparseMatrix` as it is intended to be a
+collection of the three vectors as they are required by solvers such as Gurobi.
+It is not intended to be used for general computation.
+"""
+struct CSRMatrix{T}
+    row_pointers::Vector{Int}
+    columns::Vector{Int}
+    coefficients::Vector{T}
+    function CSRMatrix{T}(row_pointers, columns, coefficients) where T
+        @assert length(columns) == length(coefficients)
+        new(row_pointers, columns, coefficients)
+    end
+end
+
 #=
     Below we add constraints.
-
-    - addconstraint!
-    - delete!
-    - get(m, ConstraintSet(), c)
-    - get(m, ConstraintFunction(), c)
-    - modifyconstraint!
 =#
 
 include("constraints/singlevariable.jl")

src/constraints/scalaraffine.jl

@@ -29,7 +29,8 @@ end
 function addlinearconstraint!(m::LinQuadOptimizer, func::Linear, set::IV)
     columns = [getcol(m, term.variable_index) for term in func.terms]
     coefficients = [term.coefficient for term in func.terms]
-    add_ranged_constraints!(m, [1], columns, coefficients, [set.lower], [set.upper])
+    A = CSRMatrix{Float64}([1], columns, coefficients)
+    add_ranged_constraints!(m, A, [set.lower], [set.upper])
 end
 
 function addlinearconstraint!(m::LinQuadOptimizer, func::Linear, sense::Cchar, rhs)
@@ -38,7 +39,8 @@ function addlinearconstraint!(m::LinQuadOptimizer, func::Linear, sense::Cchar, r
     end
     columns = [getcol(m, term.variable_index) for term in func.terms]
     coefficients = [term.coefficient for term in func.terms]
-    add_linear_constraints!(m, [1], columns, coefficients, [sense], [rhs - func.constant])
+    A = CSRMatrix{Float64}([1], columns, coefficients)
+    add_linear_constraints!(m, A, [sense], [rhs - func.constant])
 end
 
 #=
@@ -83,19 +85,20 @@ function addlinearconstraints!(m::LinQuadOptimizer, func::Vector{Linear}, set::V
         end
         nnz += length(f.terms)
     end
-    row_starts     = Vector{Int}(length(func))  # index of start of each row
-    column_indices = Vector{Int}(nnz)           # flattened columns for each function
-    coefficients   = Vector{Float64}(nnz)       # corresponding non-zeros
+    row_pointers = Vector{Int}(length(func))  # index of start of each row
+    columns = Vector{Int}(nnz)                # flattened columns for each function
+    coefficients  = Vector{Float64}(nnz)      # corresponding non-zeros
     i = 1
     for (fi, f) in enumerate(func)
-        row_starts[fi] = i
+        row_pointers[fi] = i
         for term in f.terms
-            column_indices[i] = getcol(m, term.variable_index)
-            coefficients[i]   = term.coefficient
+            columns[i] = getcol(m, term.variable_index)
+            coefficients[i] = term.coefficient
             i += 1
         end
     end
-    add_ranged_constraints!(m, row_starts, column_indices, coefficients, lowerbounds, upperbounds)
+    A = CSRMatrix{Float64}(row_pointers, columns, coefficients)
+    add_ranged_constraints!(m, A, lowerbounds, upperbounds)
 end
 
 function addlinearconstraints!(m::LinQuadOptimizer, func::Vector{Linear}, sense::Vector{Cchar}, rhs::Vector{Float64})
@@ -108,19 +111,20 @@ function addlinearconstraints!(m::LinQuadOptimizer, func::Vector{Linear}, sense:
         end
         nnz += length(f.terms)
     end
-    rowbegins = Vector{Int}(length(func))   # index of start of each row
-    column_indices = Vector{Int}(nnz)       # flattened columns for each function
-    nnz_vals = Vector{Float64}(nnz)         # corresponding non-zeros
-    cnt = 1
-    for (fi, f) in enumerate(func)
-        rowbegins[fi] = cnt
+    row_pointers = Vector{Int}(length(func))  # index of start of each row
+    columns = Vector{Int}(nnz)                # flattened columns for each function
+    coefficients = Vector{Float64}(nnz)       # corresponding non-zeros
+    i = 1
+    for (row, f) in enumerate(func)
+        row_pointers[row] = i
         for term in f.terms
-            column_indices[cnt] = getcol(m, term.variable_index)
-            nnz_vals[cnt] = term.coefficient
-            cnt += 1
+            columns[i] = getcol(m, term.variable_index)
+            coefficients[i] = term.coefficient
+            i += 1
         end
     end
-    add_linear_constraints!(m, rowbegins, column_indices, nnz_vals, sense, rhs)
+    A = CSRMatrix{Float64}(row_pointers, columns, coefficients)
+    add_linear_constraints!(m, A, sense, rhs)
 end
 
 #=

src/constraints/vectoraffine.jl

@@ -26,9 +26,9 @@ function MOI.addconstraint!(m::LinQuadOptimizer, func::VecLin, set::S) where S <
 end
 
 function addlinearconstraint!(m::LinQuadOptimizer, func::VecLin, sense::Cchar)
-    outputindex = [term.output_index for term in func.terms]
-    columns = [getcol(m, term.scalar_term.variable_index) for term in func.terms]
-    coefficients = [term.scalar_term.coefficient for term in func.terms]
+    outputindex   = [term.output_index for term in func.terms]
+    columns       = [getcol(m, term.scalar_term.variable_index) for term in func.terms]
+    coefficients  = [term.scalar_term.coefficient for term in func.terms]
     # sort into row order
     pidx = sortperm(outputindex)
     permute!(columns, pidx)
@@ -37,16 +37,17 @@ function addlinearconstraint!(m::LinQuadOptimizer, func::VecLin, sense::Cchar)
     # check that there is at least a RHS for each row
     @assert maximum(outputindex) <= length(func.constants)
     # loop through to get starting position of each row
-    rowbegins = Vector{Int}(length(func.constants))
-    rowbegins[1] = 1
-    cnt = 1
+    row_pointers = Vector{Int}(length(func.constants))
+    row_pointers[1] = 1
+    row = 1
     for i in 2:length(pidx)
         if outputindex[pidx[i]] != outputindex[pidx[i-1]]
-            cnt += 1
-            rowbegins[cnt] = i
+            row += 1
+            row_pointers[row] = i
         end
     end
-    add_linear_constraints!(m, rowbegins, columns, coefficients, fill(sense, length(func.constants)), -func.constants)
+    A = CSRMatrix{Float64}(row_pointers, columns, coefficients)
+    add_linear_constraints!(m, A, fill(sense, length(func.constants)), -func.constants)
 end
 
 MOI.canmodifyconstraint(m::LinQuadOptimizer, ::VLCI{<: VecLinSets}, ::Type{MOI.VectorConstantChange{Float64}}) = true

src/constraints/vectorofvariables.jl

@@ -21,7 +21,11 @@ function MOI.addconstraint!(m::LinQuadOptimizer, func::VecVar, set::S) where S <
     ref = VVCI{S}(m.last_constraint_reference)
     rows = get_number_linear_constraints(m)
     n = MOI.dimension(set)
-    add_linear_constraints!(m, collect(1:n), getcol.(m, func.variables), ones(n), fill(backend_type(m, set),n), zeros(n))
+    add_linear_constraints!(m,
+        CSRMatrix{Float64}(collect(1:n), getcol.(m, func.variables), ones(n)),
+        fill(backend_type(m, set),n),
+        zeros(n)
+    )
     dict = constrdict(m, ref)
     dict[ref] = collect(rows+1:rows+n)
     append!(m.constraint_primal_solution, fill(NaN,n))

src/mockoptimizer.jl

@@ -5,9 +5,9 @@ mutable struct LinQuadSOS
 end
 
 mutable struct MockLinQuadModel # <: LinQuadOptInterface.LinQuadOptimizer
-    
+
     sense::Symbol
-    
+
     A::Matrix{Float64}
     b::Vector{Float64}
     c::Vector{Float64}
@@ -20,14 +20,14 @@ mutable struct MockLinQuadModel # <: LinQuadOptInterface.LinQuadOptimizer
     ub::Vector{Float64}
 
     vartype::Vector{Cchar} # :Bin, :Int, :Con
-    contype::Vector{Cchar} # :LEQ :GEQ, :EQ, :RANGE 
+    contype::Vector{Cchar} # :LEQ :GEQ, :EQ, :RANGE
 
     # sos::LinQuadSOS{LinQuadSOS}
 
     termination_status::MOI.TerminationStatusCode
     primal_status::MOI.ResultStatusCode
     dual_status::MOI.ResultStatusCode
- 
+
     variable_primal_solution::Vector{Float64}
     variable_dual_solution::Vector{Float64}
 
@@ -212,12 +212,13 @@ function LQOI.get_number_linear_constraints(instance::MockLinQuadOptimizer)
     size(instance.inner.A)[1]
 end
 
-function LQOI.add_linear_constraints!(instance::MockLinQuadOptimizer, rowvec, colvec, coefvec, sensevec, rhsvec)
+function LQOI.add_linear_constraints!(instance::MockLinQuadOptimizer, A::CSRMatrix{Float64}, sensevec, rhsvec)
+    rowvec, colvec, coefvec = A.row_pointers, A.columns, A.coefficients
 
     rows = length(rhsvec)
     cols = size(instance.inner.A)[2]
     push!(rowvec,length(colvec)+1)
-    
+
     # An = full(sparse(rowvec,colvec,coefvec,rows,cols))
     # @show cols,rows,rowvec,colvec,coefvec
     An = full(SparseMatrixCSC(cols,rows,rowvec,colvec,coefvec)')
@@ -231,11 +232,12 @@ function LQOI.add_linear_constraints!(instance::MockLinQuadOptimizer, rowvec, co
     nothing
 end
 
-function LQOI.add_ranged_constraints!(instance::MockLinQuadOptimizer, rowvec, colvec, coefvec, rhsvec, ubvec)
+function LQOI.add_ranged_constraints!(instance::MockLinQuadOptimizer, A::CSRMatrix{Float64}, rhsvec, ubvec)
+    rowvec, colvec, coefvec = A.row_pointers, A.columns, A.coefficients
     rows = length(rhsvec)
     cols = size(instance.inner.A)[2]
     push!(rowvec,length(colvec)+1)
-    
+
     # An = full(sparse(rowvec,colvec,coefvec,rows,cols))
     # @show cols,rows,rowvec,colvec,coefvec
     An = full(SparseMatrixCSC(cols,rows,rowvec,colvec,coefvec)')
@@ -565,4 +567,4 @@ function hasprimalray(instance::MockLinQuadOptimizer)
     end
 end
 =#
-MOI.free!(m::MockLinQuadOptimizer) = nothing
+MOI.free!(m::MockLinQuadOptimizer) = nothing

src/solver_interface.jl

@@ -143,33 +143,29 @@ function get_number_linear_constraints end
 @deprecate lqs_getnumrows get_number_linear_constraints
 
 """
-    add_linear_constraints!(m, rows::Vector{Int}, cols::Vector{Int},
-        coefs::Vector{Float64},
+    add_linear_constraints!(m, A::CSRMatrix{Float64},
         sense::Vector{Cchar}, rhs::Vector{Float64})::Void
 
 Adds linear constraints of the form `Ax (sense) rhs` to the model `m`.
 
-The A matrix is given in triplet form `A[rows[i], cols[i]] = coef[i]` for all
-`i`, and `length(rows) == length(cols) == length(coefs)`.
-
+`sense` and `rhs` contain one element for each row in `A`.
 The `sense` is given by `backend_type(m, set)`.
 
 Ranged constraints (`set=MOI.Interval`) should be added via `add_ranged_constraint!`
 instead.
+
+See also: `LinQuadOptInterface.CSRMatrix`.
 """
 function add_linear_constraints! end
 @deprecate lqs_addrows! add_linear_constraints!
 
 """
-    add_ranged_constraints!(m, rows::Vector{Int}, cols::Vector{Int},
-        coefs::Vector{Float64}, lowerbound::Vector{Float64}, upperbound::Vector{Float64})
+    add_ranged_constraints!(m, A::CSRMatrix{Float64},
+        lowerbound::Vector{Float64}, upperbound::Vector{Float64})
 
 Adds linear constraints of the form `lowerbound <= Ax <= upperbound` to the
 model `m`.
 
-The A matrix is given in triplet form `A[rows[i], cols[i]] = coef[i]` for all
-`i`,
-
 This is a special case compared to standard `add_linear_constraints!` since it
 is often implemented via multiple API calls.
 """