Updates for MOI v0.3 (#16)

Author: odow

REQUIRE

@@ -1,2 +1,2 @@
 julia 0.6
-MathOptInterface 0.2 0.3
+MathOptInterface 0.3 0.4

src/constraints/scalaraffine.jl

@@ -27,14 +27,18 @@ function addlinearconstraint!(m::LinQuadOptimizer, func::Linear, set::S) where S
 end
 
 function addlinearconstraint!(m::LinQuadOptimizer, func::Linear, set::IV)
-    add_ranged_constraints!(m, [1], getcol.(m, func.variables), func.coefficients, [set.lower], [set.upper])
+    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])
 end
 
 function addlinearconstraint!(m::LinQuadOptimizer, func::Linear, sense::Cchar, rhs)
     if abs(func.constant) > eps(Float64)
         warn("Constant in scalar function moved into set.")
     end
-    add_linear_constraints!(m, [1], getcol.(m, func.variables), func.coefficients, [sense], [rhs - func.constant])
+    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])
 end
 
 #=
@@ -77,17 +81,17 @@ function addlinearconstraints!(m::LinQuadOptimizer, func::Vector{Linear}, set::V
             lowerbounds[i] -= f.constant
             upperbounds[i] -= f.constant
         end
-        nnz += length(f.coefficients)
+        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
     i = 1
     for (fi, f) in enumerate(func)
         row_starts[fi] = i
-        for (var, coef) in zip(f.variables, f.coefficients)
-            column_indices[i] = getcol(m, var)
-            coefficients[i]   = coef
+        for term in f.terms
+            column_indices[i] = getcol(m, term.variable_index)
+            coefficients[i]   = term.coefficient
             i += 1
         end
     end
@@ -102,17 +106,17 @@ function addlinearconstraints!(m::LinQuadOptimizer, func::Vector{Linear}, sense:
             warn("Constant in scalar function moved into set.")
             rhs[i] -= f.constant
         end
-        nnz += length(f.coefficients)
+        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
-        for (var, coef) in zip(f.variables, f.coefficients)
-            column_indices[cnt] = getcol(m, var)
-            nnz_vals[cnt] = coef
+        for term in f.terms
+            column_indices[cnt] = getcol(m, term.variable_index)
+            nnz_vals[cnt] = term.coefficient
             cnt += 1
         end
     end
@@ -144,7 +148,12 @@ MOI.canget(m::LinQuadOptimizer, ::MOI.ConstraintFunction, ::Type{<:LCI{<: LinSet
 function MOI.get(m::LinQuadOptimizer, ::MOI.ConstraintFunction, c::LCI{<: LinSets})
     # TODO more efficiently
     colidx, coefs = get_linear_constraint(m, m[c])
-    Linear(m.variable_references[colidx+1], coefs, -m.constraint_constant[m[c]])
+    terms = map(
+        (v,c)->MOI.ScalarAffineTerm{Float64}(c,v),
+        m.variable_references[colidx+1],
+        coefs
+    )
+    Linear(terms, -m.constraint_constant[m[c]])
 end
 
 #=

src/constraints/scalarquadratic.jl

@@ -32,14 +32,19 @@ function addquadraticconstraint!(m::LinQuadOptimizer, f::Quad, sense::Cchar, rhs
     if abs(f.constant) > 0
         warn("Constant in quadratic function. Moving into set")
     end
+    quadratic_columns_1 = [getcol(m, term.variable_index_1) for term in f.quadratic_terms]
+    quadratic_columns_2 = [getcol(m, term.variable_index_2) for term in f.quadratic_terms]
+    quadratic_coefficients = [term.coefficient for term in f.quadratic_terms]
     ri, ci, vi = reduceduplicates(
-        getcol.(m, f.quadratic_rowvariables),
-        getcol.(m, f.quadratic_colvariables),
-        f.quadratic_coefficients
+        quadratic_columns_1,
+        quadratic_columns_2,
+        quadratic_coefficients
     )
+    affine_columns = [getcol(m, term.variable_index) for term in f.affine_terms]
+    affine_coefficients = [term.coefficient for term in f.affine_terms]
     add_quadratic_constraint!(m,
-        getcol.(m, f.affine_variables),
-        f.affine_coefficients,
+        affine_columns,
+        affine_coefficients,
         rhs - f.constant,
         sense,
         ri, ci, vi

src/constraints/vectoraffine.jl

@@ -6,7 +6,7 @@ constrdict(m::LinQuadOptimizer, ::VLCI{MOI.Nonpositives}) = cmap(m).nonpositives
 constrdict(m::LinQuadOptimizer, ::VLCI{MOI.Zeros})        = cmap(m).zeros
 
 function MOI.addconstraint!(m::LinQuadOptimizer, func::VecLin, set::S) where S <: VecLinSets
-    @assert MOI.dimension(set) == length(func.constant)
+    @assert MOI.dimension(set) == length(func.constants)
 
     nrows = get_number_linear_constraints(m)
     addlinearconstraint!(m, func, backend_type(m,set))
@@ -20,31 +20,33 @@ function MOI.addconstraint!(m::LinQuadOptimizer, func::VecLin, set::S) where S <
     for i in 1:MOI.dimension(set)
         push!(m.constraint_primal_solution, NaN)
         push!(m.constraint_dual_solution, NaN)
-        push!(m.constraint_constant, func.constant[i])
+        push!(m.constraint_constant, func.constants[i])
     end
     ref
 end
 
 function addlinearconstraint!(m::LinQuadOptimizer, func::VecLin, sense::Cchar)
-    @assert length(func.outputindex) == length(func.variables) == length(func.coefficients)
-    # get list of unique rows
-    rows = unique(func.outputindex)
-    @assert length(rows) == length(func.constant)
+    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(func.outputindex)
-    cols = getcol.(m, func.variables)[pidx]
-    vals = func.coefficients[pidx]
-    # loop through to gte starting position of each row
-    rowbegins = Vector{Int}(length(rows))
+    pidx = sortperm(outputindex)
+    permute!(columns, pidx)
+    permute!(coefficients, pidx)
+
+    # 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
     for i in 2:length(pidx)
-        if func.outputindex[pidx[i]] != func.outputindex[pidx[i-1]]
+        if outputindex[pidx[i]] != outputindex[pidx[i-1]]
             cnt += 1
             rowbegins[cnt] = i
         end
     end
-    add_linear_constraints!(m, rowbegins, cols, vals, fill(sense, length(rows)), -func.constant)
+    add_linear_constraints!(m, rowbegins, columns, coefficients, fill(sense, length(func.constants)), -func.constants)
 end
 
 MOI.canmodifyconstraint(m::LinQuadOptimizer, ::VLCI{<: VecLinSets}, ::Type{MOI.VectorConstantChange{Float64}}) = true
@@ -93,16 +95,22 @@ MOI.canget(m::LinQuadOptimizer, ::MOI.ConstraintFunction, ::Type{VLCI{S}}) where
 function MOI.get(m::LinQuadOptimizer, ::MOI.ConstraintFunction, c::VLCI{<: VecLinSets})
     ctrs = m[c]
     n = length(ctrs)
-    out = MOI.VectorAffineFunction(Int[],VarInd[],Float64[],Float64[])
+    constants = Float64[]
+    terms = MOI.VectorAffineTerm{Float64}[]
     for i in 1:n
         rhs = get_rhs(m, ctrs[i])
-        push!(out.constant, -rhs)
-
+        push!(constants, -rhs)
         # TODO more efficiently
         colidx, coefs = get_linear_constraint(m, ctrs[i])
-        append!(out.variables, m.variable_references[colidx+1])
-        append!(out.coefficients, coefs)
-        append!(out.outputindex, i*ones(Int,length(coefs)))
+        for (column, coefficient) in zip(colidx, coefs)
+            push!(terms, MOI.VectorAffineTerm{Float64}(
+                    i,
+                    MOI.ScalarAffineTerm{Float64}(
+                        coefficient, m.variable_references[column+1]
+                    )
+                )
+            )
+        end
     end
-    return out
+    return MOI.VectorAffineFunction(terms, constants)
 end

src/objective.jl

@@ -16,7 +16,7 @@ function MOI.set!(m::LinQuadOptimizer, ::MOI.ObjectiveSense, sense::MOI.Optimiza
     elseif sense == MOI.FeasibilitySense
         # we set the objective sense to :min, and the objective to 0.0
         change_objective_sense!(m, :min)
-        unsafe_set!(m, MOI.ObjectiveFunction{Linear}(), MOI.ScalarAffineFunction(VarInd[],Float64[],0.0))
+        unsafe_set!(m, MOI.ObjectiveFunction{Linear}(), MOI.ScalarAffineFunction(MOI.ScalarAffineTerm{Float64}[],0.0))
         m.obj_type = AffineObjective
         m.obj_sense = MOI.FeasibilitySense
     else
@@ -64,28 +64,29 @@ function unsafe_set!(m::LinQuadOptimizer, ::MOI.ObjectiveFunction{F}, objf::Line
     end
     m.obj_type = AffineObjective
     m.single_obj_var = nothing
-    set_linear_objective!(m, getcol.(m, objf.variables), objf.coefficients)
+    columns = [getcol(m, term.variable_index) for term in objf.terms]
+    coefficients = [term.coefficient for term in objf.terms]
+    set_linear_objective!(m, columns, coefficients)
     m.objective_constant = objf.constant
     nothing
 end
 
 function MOI.set!(m::LinQuadOptimizer, ::MOI.ObjectiveFunction, objf::Quad)
     m.obj_type = QuadraticObjective
     m.single_obj_var = nothing
-    set_linear_objective!(m,
-        getcol.(m, objf.affine_variables),
-        objf.affine_coefficients
-    )
+    columns = [getcol(m, term.variable_index) for term in objf.affine_terms]
+    coefficients = [term.coefficient for term in objf.affine_terms]
+    set_linear_objective!(m, columns, coefficients)
+
+    quadratic_columns_1 = [getcol(m, term.variable_index_1) for term in objf.quadratic_terms]
+    quadratic_columns_2 = [getcol(m, term.variable_index_2) for term in objf.quadratic_terms]
+    quadratic_coefficients = [term.coefficient for term in objf.quadratic_terms]
     ri, ci, vi = reduceduplicates(
-        getcol.(m, objf.quadratic_rowvariables),
-        getcol.(m, objf.quadratic_colvariables),
-        objf.quadratic_coefficients
-    )
-    set_quadratic_objective!(m,
-        ri,
-        ci,
-        vi
+        quadratic_columns_1,
+        quadratic_columns_2,
+        quadratic_coefficients
     )
+    set_quadratic_objective!(m, ri, ci, vi)
     m.objective_constant = objf.constant
     nothing
 end
@@ -103,7 +104,12 @@ MOI.canget(m::LinQuadOptimizer, ::MOI.ObjectiveFunction{Linear}) = m.obj_type !=
 function MOI.get(m::LinQuadOptimizer, ::MOI.ObjectiveFunction{Linear})
     variable_coefficients = zeros(length(m.variable_references))
     get_linear_objective!(m, variable_coefficients)
-    Linear(m.variable_references, variable_coefficients, m.objective_constant)
+    terms = map(
+        (v,c)->MOI.ScalarAffineTerm{Float64}(c,v),
+        m.variable_references,
+        variable_coefficients
+    )
+    Linear(terms, m.objective_constant)
 end
 
 #=