Add support for Julia v0.7 and fix #17

Author: blegat

REQUIRE

@@ -1,3 +1,3 @@
 julia 0.6
 MathOptInterface 0.5 0.6
-Compat 0.69
+Compat 1.0.1

src/SemidefiniteOptInterface.jl

@@ -4,6 +4,9 @@ using MathOptInterface
 const MOI = MathOptInterface
 const MOIU = MOI.Utilities
 
+using Compat
+using Compat.LinearAlgebra # for diag
+
 abstract type AbstractSDOptimizer <: MOI.AbstractOptimizer end
 
 include("interface.jl")
@@ -36,8 +39,8 @@ mutable struct SOItoMOIBridge{T, SIT <: AbstractSDOptimizer} <: MOI.AbstractOpti
     nconstrs::Int
     nblocks::Int
     blockdims::Vector{Int}
-    free::IntSet
-    varmap::Vector{Vector{Tuple{Int, Int, Int, T, T}}} # Variable Index vi -> blk, i, j, coef, shift # x = sum coef * X[blk][i, j] + shift
+    free::BitSet
+    varmap::Vector{Vector{Tuple{Int, Int, Int, T, T}}} # Variable Index vi -> blk, i, j, coef, shift # x = sum coef * block(X, blk)[i, j] + shift
     zeroblock::Dict{CI, Int}
     constrmap::Dict{CI, UnitRange{Int}} # Constraint Index ci -> cs
     slackmap::Vector{Tuple{Int, Int, Int, T}} # c -> blk, i, j, coef
@@ -46,7 +49,7 @@ mutable struct SOItoMOIBridge{T, SIT <: AbstractSDOptimizer} <: MOI.AbstractOpti
         new{T, SIT}(sdoptimizer, Dict{Int64, T}(), Dict{Int, T}(),
             zero(T), 1, zero(T), 0, 0,
             Int[],
-            IntSet(),
+            BitSet(),
             Vector{Tuple{Int, Int, Int, T}}[],
             Dict{CI, Int}(),
             Dict{CI, UnitRange{Int}}(),
@@ -95,7 +98,7 @@ function MOI.empty!(optimizer::SOItoMOIBridge{T}) where T
     optimizer.nconstrs = 0
     optimizer.nblocks = 0
     optimizer.blockdims = Int[]
-    optimizer.free = IntSet()
+    optimizer.free = BitSet()
     optimizer.varmap = Vector{Tuple{Int, Int, Int, T}}[]
     optimizer.zeroblock = Dict{CI, Int}()
     optimizer.constrmap = Dict{CI, UnitRange{Int}}()
@@ -114,7 +117,7 @@ function addsetconstant(optimizer::SOItoMOIBridge, ci::CI, x)
 end
 function addblkconstant(optimizer::SOItoMOIBridge, ci::CI{<:Any, <:Union{NS, PS}}, x)
     blk = -ci.value
-    x + optimizer.blkconstant[blk]
+    x .+ optimizer.blkconstant[blk]
 end
 function addblkconstant(optimizer::SOItoMOIBridge, ci::CI, x)
     x
@@ -186,18 +189,18 @@ MOI.canget(m::SOItoMOIBridge, ::Union{MOI.VariablePrimal,
                                       MOI.ConstraintDual}, ::Type{<:MOI.Index}) = true
 
 function _getblock(M, blk::Int, s::Type{<:Union{NS, ZS}})
-    diag(M[blk])
+    diag(block(M, blk))
 end
 function _getblock(M, blk::Int, s::Type{<:PS})
-    -diag(M[blk])
+    -diag(block(M, blk))
 end
 # Vectorized length for matrix dimension d
 sympackedlen(d::Integer) = (d*(d+1)) >> 1
 function _getblock(M::AbstractMatrix{T}, blk::Int, s::Type{<:DS}) where T
-    B = M[blk]
-    d = Base.LinAlg.checksquare(B)
+    B = block(M, blk)
+    d = Compat.LinearAlgebra.checksquare(B)
     n = sympackedlen(d)
-    v = Vector{T}(n)
+    v = Vector{T}(undef, n)
     k = 0
     for j in 1:d
         for i in 1:j
@@ -228,7 +231,7 @@ function MOI.get(m::SOItoMOIBridge{T}, ::MOI.VariablePrimal, vi::VI) where T
     for (blk, i, j, coef, shift) in varmap(m, vi)
         x += shift
         if blk != 0
-            x += X[blk][i, j] * sign(coef)
+            x += block(X, blk)[i, j] * sign(coef)
         end
     end
     x
@@ -253,9 +256,9 @@ function getslack(m::SOItoMOIBridge{T}, c::Int) where T
         zero(T)
     else
         if i != j
-            coef *= 2 # We should take X[blk][i, j] + X[blk][j, i] but they are equal
+            coef *= 2 # We should take block(X, blk)[i, j] + block(X, blk)[j, i] but they are equal
         end
-        coef * X[blk][i, j]
+        coef * block(X, blk)[i, j]
     end
 end
 
@@ -274,7 +277,7 @@ function getvardual(m::SOItoMOIBridge{T}, vi::VI) where T
     z = zero(T)
     for (blk, i, j, coef) in varmap(m, vi)
         if blk != 0
-            z += Z[blk][i, j] * sign(coef)
+            z += block(Z, blk)[i, j] * sign(coef)
         end
     end
     z
@@ -319,7 +322,8 @@ function scalevec!(v, c)
     end
     v
 end
-function MOI.get(m::SOItoMOIBridge{T}, ::MOI.ConstraintDual, ci::CI{F, DS}) where {T,F}
+function MOI.get(m::SOItoMOIBridge{T}, ::MOI.ConstraintDual,
+                 ci::CI{<:AF{T}, DS}) where T
     scalevec!(_getattribute(m, ci, getdual), one(T)/2)
 end
 

src/constraint.jl

@@ -1,5 +1,5 @@
 function createslack!(m::SOItoMOIBridge{T}, cs, ::ZS) where T
-    m.slackmap[cs] = (0, 0, 0, zero(T))
+    m.slackmap[cs] .= ((0, 0, 0, zero(T)),)
 end
 function createslack!(m::SOItoMOIBridge, cs, ::S) where S <: Union{NS, PS}
     blk = newblock(m, -length(cs))
@@ -31,7 +31,7 @@ nconstraints(f::VAF, s) = MOI.output_dimension(f)
 function _allocateconstraint!(m::SOItoMOIBridge, f, s)
     ci = CI{typeof(f), typeof(s)}(m.nconstrs)
     n = nconstraints(f, s)
-    m.constrmap[ci] = m.nconstrs + (1:n)
+    m.constrmap[ci] = m.nconstrs .+ (1:n)
     m.nconstrs += n
     resize!(m.slackmap, m.nconstrs)
     createslack!(m, ci, f, s)
@@ -65,7 +65,7 @@ _getconstant(m::SOItoMOIBridge{T}, s::MOI.AbstractSet) where T = zero(T)
 function loadcoefficients!(m::SOItoMOIBridge, cs::UnitRange, f::AF, s)
     f = MOIU.canonical(f) # sum terms with same variables and same outputindex
     if !isempty(cs)
-        rhs = _getconstant(m, s) - MOIU._constant(f)
+        rhs = _getconstant(m, s) .- MOIU._constant(f)
         for t in f.terms
             st = scalar_term(t)
             if !iszero(st.coefficient)

src/load.jl

@@ -32,8 +32,8 @@ function MOIU.load!(optimizer::SOItoMOIBridge{T}, ::MOI.ObjectiveFunction, f::MO
 end
 
 function MOIU.allocatevariables!(optimizer::SOItoMOIBridge{T}, nvars) where T
-    optimizer.free = IntSet(1:nvars)
-    optimizer.varmap = Vector{Vector{Tuple{Int, Int, Int, T, T}}}(nvars)
+    optimizer.free = BitSet(1:nvars)
+    optimizer.varmap = Vector{Vector{Tuple{Int, Int, Int, T, T}}}(undef, nvars)
     VI.(1:nvars)
 end
 

src/mock.jl

@@ -1,7 +1,34 @@
-struct BlockMatrix{T} <: AbstractMatrix{T}
+abstract type AbstractBlockMatrix{T} <: AbstractMatrix{T} end
+struct BlockMatrix{T} <: AbstractBlockMatrix{T}
     blocks::Vector{Matrix{T}}
 end
-Base.getindex(BM::BlockMatrix, i::Integer) = BM.blocks[i]
+nblocks(bm::BlockMatrix) = length(bm.blocks)
+block(bm::BlockMatrix, i::Integer) = bm.blocks[i]
+
+function Base.size(bm::AbstractBlockMatrix)
+    n = sum(blk -> Compat.LinearAlgebra.checksquare(block(bm, blk)),
+            1:nblocks(bm))
+    return (n, n)
+end
+function Base.getindex(bm::AbstractBlockMatrix, i::Integer, j::Integer)
+    (i < 0 || j < 0) && throw(BoundsError(i, j))
+    for k in 1:nblocks(bm)
+        blk = block(bm, k)
+        n = size(blk, 1)
+        if i <= n && j <= n
+            return blk[i, j]
+        elseif i <= n || j <= n
+            return 0
+        else
+            i -= n
+            j -= n
+        end
+    end
+    i, j = (i, j) .+ size(bm)
+    throw(BoundsError(i, j))
+end
+Base.getindex(A::AbstractBlockMatrix, I::Tuple) = getindex(A, I...)
+
 mutable struct MockSDOptimizer{T} <: AbstractSDOptimizer
     nconstrs::Int
     blkdims::Vector{Int}
@@ -76,9 +103,9 @@ gety(mock::MockSDOptimizer) = mock.y
 function getprimalobjectivevalue(mock::MockSDOptimizer{T}) where T
     v = zero(T)
     for (α, blk, i, j) in mock.objective_coefficients
-        v += α * mock.X[blk][i, j]
+        v += α * block(mock.X, blk)[i, j]
         if i != j
-            v += α * mock.X[blk][j, i]
+            v += α * block(mock.X, blk)[j, i]
         end
     end
     v
@@ -174,17 +201,17 @@ function MOIU.mock_condual!(mock::MockSDOptimizer{T}, y::Vector{T}) where T
         # Infeasibility certificate is a ray so we only take the homogeneous part
         # FIXME:check that this is also done IN MOIU.MockOptimizer
         for (α, blk, i, j) in mock.objective_coefficients
-            mock.Z[blk][i, j] -= α
+            block(mock.Z, blk)[i, j] -= α
             if i != j
-                mock.Z[blk][j, i] -= α
+                block(mock.Z, blk)[j, i] -= α
             end
         end
     end
     for (c, constraint_coefficients) in enumerate(mock.constraint_coefficients)
         for (α, blk, i, j) in constraint_coefficients
-            mock.Z[blk][i, j] += α * y[c]
+            block(mock.Z, blk)[i, j] += α * y[c]
             if i != j
-                mock.Z[blk][j, i] += α * y[c]
+                block(mock.Z, blk)[j, i] += α * y[c]
             end
         end
     end