Updates for MOI 0.6 (#64)

* Updates for MOI 0.6

* updated MOI version lowerbound

* A few more fixes

* updated a test primal status and removed a duplicate function

Author: IssamT

REQUIRE

@@ -1,3 +1,3 @@
 julia 0.6
-MathOptInterface 0.5 0.6
+MathOptInterface 0.6 0.7
 Compat 0.59

src/LinQuadOptInterface.jl

@@ -245,7 +245,7 @@ macro LinQuadOptimizerBase(inner_model_type=Any)
 end
 
 
-function MOI.isempty(m::LinQuadOptimizer)
+function MOI.is_empty(m::LinQuadOptimizer)
     ret = true
     ret = ret && m.name == ""
     ret = ret && m.obj_type == AffineObjective
@@ -321,17 +321,16 @@ function MOI.empty!(m::M, env = nothing) where M<:LinQuadOptimizer
     nothing
 end
 
-MOI.canget(::LinQuadOptimizer, ::MOI.Name) = true
 function MOI.get(m::LinQuadOptimizer, ::MOI.Name)
     m.name
 end
 
 MOI.supports(::LinQuadOptimizer, ::MOI.Name) = true
-function MOI.set!(m::LinQuadOptimizer, ::MOI.Name, name::String)
+function MOI.set(m::LinQuadOptimizer, ::MOI.Name, name::String)
     m.name = name
 end
 
-function MOI.supportsconstraint(m::LinQuadOptimizer, ft::Type{F}, st::Type{S}) where F <: MOI.AbstractFunction where S <: MOI.AbstractSet
+function MOI.supports_constraint(m::LinQuadOptimizer, ft::Type{F}, st::Type{S}) where F <: MOI.AbstractFunction where S <: MOI.AbstractSet
     (ft,st) in supported_constraints(m)
 end
 function MOI.supports(m::LinQuadOptimizer, ::MOI.ObjectiveFunction{F}) where F <: MOI.AbstractFunction

src/constraints.jl

@@ -35,21 +35,21 @@ function has_integer(model::LinQuadOptimizer)
 end
 
 #=
-    MOI.isvalid
+    MOI.is_valid
 =#
 
-function MOI.isvalid(model::LinQuadOptimizer, index::CI{F,S}) where F where S
+function MOI.is_valid(model::LinQuadOptimizer, index::CI{F,S}) where F where S
     dict = constrdict(model, index)
     return haskey(dict, index)
 end
 
 """
     __assert_valid__(model::LinQuadOptimizer, index::MOI.Index)
 
-Throw an MOI.InvalidIndex error if `MOI.isvalid(model, index) == false`.
+Throw an MOI.InvalidIndex error if `MOI.is_valid(model, index) == false`.
 """
 function __assert_valid__(model::LinQuadOptimizer, index::MOI.Index)
-    if !MOI.isvalid(model, index)
+    if !MOI.is_valid(model, index)
         throw(MOI.InvalidIndex(index))
     end
 end
@@ -69,9 +69,6 @@ end
 #=
     Get number of constraints
 =#
-function MOI.canget(model::LinQuadOptimizer, ::MOI.NumberOfConstraints{F, S}) where F where S
-    return (F,S) in supported_constraints(model)
-end
 
 function MOI.get(model::LinQuadOptimizer, attribute::MOI.NumberOfConstraints{F, S}) where F where S
     __assert_supported_constraint__(model, F, S)
@@ -81,9 +78,6 @@ end
 #=
     Get list of constraint references
 =#
-function MOI.canget(model::LinQuadOptimizer, ::MOI.ListOfConstraintIndices{F, S}) where F where S
-    return (F,S) in supported_constraints(model)
-end
 
 function MOI.get(model::LinQuadOptimizer, attribute::MOI.ListOfConstraintIndices{F, S}) where F where S
     __assert_supported_constraint__(model, F, S)
@@ -95,9 +89,7 @@ end
 #=
     Get list of constraint types in model
 =#
-function MOI.canget(::LinQuadOptimizer, ::MOI.ListOfConstraints)
-    return true
-end
+
 function MOI.get(model::LinQuadOptimizer, ::MOI.ListOfConstraints)
     return [(F, S) for (F, S) in supported_constraints(model) if
         MOI.get(model, MOI.NumberOfConstraints{F,S}()) > 0]
@@ -106,9 +98,7 @@ end
 #=
     Get constraint names
 =#
-function MOI.canget(::LinQuadOptimizer, ::MOI.ConstraintName, ::Type{<:MOI.ConstraintIndex})
-    return true
-end
+
 function MOI.get(model::LinQuadOptimizer, ::MOI.ConstraintName, index::MOI.ConstraintIndex)
     if haskey(model.constraint_names, index)
         return model.constraint_names[index]
@@ -119,7 +109,7 @@ end
 function MOI.supports(::LinQuadOptimizer, ::MOI.ConstraintName, ::Type{<:MOI.ConstraintIndex})
     return true
 end
-function MOI.set!(model::LinQuadOptimizer, ::MOI.ConstraintName,
+function MOI.set(model::LinQuadOptimizer, ::MOI.ConstraintName,
                   index::MOI.ConstraintIndex, name::String)
     if haskey(model.constraint_names_rev, name)
         if model.constraint_names_rev[name] != index
@@ -141,20 +131,24 @@ end
     Get constraint by name
 =#
 
-# this covers the non-type-stable get(m, ConstraintIndex) case
-function MOI.canget(model::LinQuadOptimizer, ::Type{MOI.ConstraintIndex}, name::String)
-    return haskey(model.constraint_names_rev, name)
-end
-function MOI.get(model::LinQuadOptimizer, ::Type{<:MOI.ConstraintIndex}, name::String)
-    return model.constraint_names_rev[name]
+function MOI.get(model::LinQuadOptimizer, ::Type{<:MOI.ConstraintIndex}, 
+                 name::String)
+    if haskey(model.constraint_names_rev, name)
+        return model.constraint_names_rev[name]
+    else
+        return nothing
+    end
 end
 
 # this covers the type-stable get(m, ConstraintIndex{F,S}, name)::CI{F,S} case
-function MOI.canget(model::LinQuadOptimizer, ::Type{FS}, name::String) where FS <: MOI.ConstraintIndex
-    return haskey(model.constraint_names_rev, name) && typeof(model.constraint_names_rev[name]) == FS
-end
-function MOI.get(model::LinQuadOptimizer, ::Type{MOI.ConstraintIndex{F,S}}, name::String) where F where S
-    model.constraint_names_rev[name]::MOI.ConstraintIndex{F,S}
+function MOI.get(model::LinQuadOptimizer, ::Type{MOI.ConstraintIndex{F,S}}, 
+                 name::String) where F where S
+    if haskey(model.constraint_names_rev, name) && 
+            isa(model.constraint_names_rev[name], MOI.ConstraintIndex{F,S})
+        return model.constraint_names_rev[name]::MOI.ConstraintIndex{F,S}
+    else
+        return nothing
+    end
 end
 
 

src/constraints/scalaraffine.jl

@@ -9,7 +9,7 @@ constrdict(model::LinQuadOptimizer, ::LCI{GE})  = cmap(model).greater_than
 constrdict(model::LinQuadOptimizer, ::LCI{EQ})  = cmap(model).equal_to
 constrdict(model::LinQuadOptimizer, ::LCI{IV})  = cmap(model).interval
 
-function MOI.addconstraint!(model::LinQuadOptimizer, func::Linear, set::T) where T <: LinSets
+function MOI.add_constraint(model::LinQuadOptimizer, func::Linear, set::T) where T <: LinSets
     __assert_supported_constraint__(model, Linear, T)
     canonicalized_func = MOIU.canonical(func)
     add_linear_constraint(model, canonicalized_func, set)
@@ -53,7 +53,7 @@ end
     Add linear constraints (plural)
 =#
 
-function MOI.addconstraints!(model::LinQuadOptimizer, func::Vector{Linear},
+function MOI.add_constraints(model::LinQuadOptimizer, func::Vector{Linear},
                              set::Vector{S}) where S <: LinSets
     __assert_supported_constraint__(model, Linear, S)
     @assert length(func) == length(set)
@@ -155,14 +155,13 @@ end
 #=
     Constraint set of Linear function
 =#
-MOI.canget(::LinQuadOptimizer, ::MOI.ConstraintSet, ::Type{LCI{S}}) where S <: Union{LE, GE, EQ} = true
+
 function MOI.get(model::LinQuadOptimizer, ::MOI.ConstraintSet, index::LCI{S}) where S <: Union{LE, GE, EQ}
     row = model[index]
     rhs = get_rhs(model, row)
     S(rhs + model.constraint_constant[row])
 end
 
-MOI.canget(::LinQuadOptimizer, ::MOI.ConstraintSet, ::Type{LCI{IV}}) = true
 function MOI.get(model::LinQuadOptimizer, ::MOI.ConstraintSet, index::LCI{IV})
     row = model[index]
     lowerbound, upperbound = get_range(model, row)
@@ -174,7 +173,6 @@ end
     Constraint function of Linear function
 =#
 
-MOI.canget(::LinQuadOptimizer, ::MOI.ConstraintFunction, ::Type{<:LCI{<: LinSets}}) = true
 function MOI.get(model::LinQuadOptimizer, ::MOI.ConstraintFunction, index::LCI{<: LinSets})
     row = model[index]
     columns, coefficients = get_linear_constraint(model, row)
@@ -190,7 +188,7 @@ end
     Scalar Coefficient Change of Linear Constraint
 =#
 
-function MOI.modify!(model::LinQuadOptimizer, index::LCI{S}, change::MOI.ScalarCoefficientChange{Float64}) where S <: LinSets
+function MOI.modify(model::LinQuadOptimizer, index::LCI{S}, change::MOI.ScalarCoefficientChange{Float64}) where S <: LinSets
     row = model[index]
     column = get_column(model, change.variable)
     change_matrix_coefficient!(model, row, column, change.new_coefficient)
@@ -212,7 +210,7 @@ of this function.
 function _replace_with_matching_sparsity!(model::LinQuadOptimizer, previous::Linear, replacement::Linear, row)
     rows = fill(row, length(replacement.terms))
     cols = [model.variable_mapping[t.variable_index] for t in replacement.terms]
-    coefs = MOIU.coefficient.(replacement.terms)
+    coefs = MOI.coefficient.(replacement.terms)
     change_matrix_coefficients!(model, rows, cols, coefs)
 end
 
@@ -243,12 +241,12 @@ function _replace_with_different_sparsity!(model::LinQuadOptimizer, previous::Li
     # Next, set the new constraint function terms
     rows = fill(row, length(replacement.terms))
     cols = [model.variable_mapping[t.variable_index] for t in replacement.terms]
-    coefs = MOIU.coefficient.(replacement.terms)
+    coefs = MOI.coefficient.(replacement.terms)
     change_matrix_coefficients!(model, rows, cols, coefs)
 end
 
 MOI.supports(::LinQuadOptimizer, ::MOI.ConstraintFunction, ::Type{LCI{S}}) where {S <: Union{LE, GE, EQ}} = true
-function MOI.set!(model::LinQuadOptimizer, attr::MOI.ConstraintFunction, CI::LCI{S}, replacement::Linear) where {S <: Union{LE, GE, EQ}}
+function MOI.set(model::LinQuadOptimizer, attr::MOI.ConstraintFunction, CI::LCI{S}, replacement::Linear) where {S <: Union{LE, GE, EQ}}
     previous = MOI.get(model, attr, CI)
     MOIU.canonicalize!(previous)
     replacement = MOIU.canonical(replacement)
@@ -272,14 +270,14 @@ end
     Change RHS of linear constraint without modifying sense
 =#
 MOI.supports(::LinQuadOptimizer, ::MOI.ConstraintSet, ::Type{LCI{S}}) where S <: LinSets = true
-function MOI.set!(model::LinQuadOptimizer, ::MOI.ConstraintSet, index::LCI{S},
+function MOI.set(model::LinQuadOptimizer, ::MOI.ConstraintSet, index::LCI{S},
                   new_set::S) where S <: Union{LE, GE, EQ}
     row = model[index]
     rhs = MOIU.getconstant(new_set) - model.constraint_constant[row]
     change_rhs_coefficient!(model, model[index], rhs)
 end
 
-function MOI.set!(model::LinQuadOptimizer, ::MOI.ConstraintSet, index::LCI{IV},
+function MOI.set(model::LinQuadOptimizer, ::MOI.ConstraintSet, index::LCI{IV},
                   new_set::IV)
     row = model[index]
     constant = model.constraint_constant[row]
@@ -291,7 +289,7 @@ end
     Delete a linear constraint
 =#
 
-function MOI.delete!(model::LinQuadOptimizer, index::LCI{<: LinSets})
+function MOI.delete(model::LinQuadOptimizer, index::LCI{<: LinSets})
     __assert_valid__(model, index)
     delete_constraint_name(model, index)
     dict = constrdict(model, index)
@@ -309,7 +307,7 @@ end
     Transform scalar constraint
 =#
 
-function MOI.transform!(model::LinQuadOptimizer, index::LCI{S1}, new_set::S2) where S1 where S2 <: Union{LE, GE, EQ}
+function MOI.transform(model::LinQuadOptimizer, index::LCI{S1}, new_set::S2) where S1 where S2 <: Union{LE, GE, EQ}
     __assert_supported_constraint__(model, Linear, S2)
     dict = constrdict(model, index)
     row = dict[index]

src/constraints/scalarquadratic.jl

@@ -66,7 +66,7 @@ function canonical_reduction(model::LinQuadOptimizer, func::Quad)
     return affine_columns, affine_coefficients, quad_columns_1, quad_columns_2, quad_coefficients
 end
 
-function MOI.addconstraint!(model::LinQuadOptimizer, func::Quad, set::S) where S <: Union{LE, GE, EQ}
+function MOI.add_constraint(model::LinQuadOptimizer, func::Quad, set::S) where S <: Union{LE, GE, EQ}
     add_quadratic_constraint(model, func, set)
     model.last_constraint_reference += 1
     index = QCI{S}(model.last_constraint_reference)
@@ -91,7 +91,7 @@ function add_quadratic_constraint(model::LinQuadOptimizer, func::Quad, sense, rh
                               sense, I, J, V)
 end
 
-function MOI.delete!(model::LinQuadOptimizer, index::QCI{<: LinSets})
+function MOI.delete(model::LinQuadOptimizer, index::QCI{<: LinSets})
     __assert_valid__(model, index)
     delete_constraint_name(model, index)
     dict = constrdict(model, index)
@@ -108,18 +108,15 @@ end
     Constraint set of Linear function
 =#
 
-MOI.canget(::LinQuadOptimizer, ::MOI.ConstraintSet, ::Type{QCI{S}}) where S <: Union{LE, GE, EQ} = true
 function MOI.get(model::LinQuadOptimizer, ::MOI.ConstraintSet, index::QCI{S}) where S <: Union{LE, GE, EQ}
     rhs = get_quadratic_rhs(model, model[index])
     S(rhs)
 end
-MOI.canget(::LinQuadOptimizer, ::MOI.ConstraintSet, ::Type{QCI{IV}}) = false
 
 #=
     Constraint function of Linear function
 =#
 
-MOI.canget(::LinQuadOptimizer, ::MOI.ConstraintFunction, ::Type{<:QCI{<: LinSets}}) = true
 function MOI.get(model::LinQuadOptimizer, ::MOI.ConstraintFunction, index::QCI{<: LinSets})
     aff_cols, aff_coeffs, Q = get_quadratic_constraint(model, model[index])
     affine_terms = map(