fix conflict

Author: matbesancon

.travis.yml

@@ -4,7 +4,6 @@ os:
   - linux
 #  - osx
 julia:
-  - 0.7
   - 1.0
   - 1.1
 notifications:

Project.toml

@@ -10,6 +10,9 @@ SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 Unicode = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
+[compat]
+julia = "1"
+
 [extras]
 
 [targets]

appveyor.yml

@@ -1,6 +1,5 @@
 environment:
   matrix:
-# - julia_version: 0.7 # tested on Linux with Travis
   - julia_version: 1.0
 
 platform:

src/Bridges/bridgeoptimizer.jl

@@ -227,18 +227,42 @@ function MOI.get(b::AbstractBridgeOptimizer,
                  attr::MOI.AbstractConstraintAttribute,
                  ci::CI)
     if is_bridged(b, typeof(ci))
-        if MOI.is_set_by_optimize(attr)
-            MOI.get(b, attr, bridge(b, ci))
-        else
-            MOI.get(b.bridged, attr, ci)
-        end
+        return MOI.get(b, attr, bridge(b, ci))
+    else
+        return MOI.get(b.model, attr, ci)
+    end
+end
+function MOI.supports(b::AbstractBridgeOptimizer,
+                      attr::MOI.AbstractConstraintAttribute,
+                      IndexType::Type{CI{F, S}}) where {F,S}
+    if is_bridged(b, IndexType)
+        return MOI.supports(b, attr, concrete_bridge_type(b, F, S))
+    else
+        return MOI.supports(b.model, attr, IndexType)
+    end
+end
+
+function MOI.set(b::AbstractBridgeOptimizer,
+                 attr::MOI.AbstractConstraintAttribute,
+                 index::CI, value)
+    if is_bridged(b, typeof(index))
+        return MOI.set(b, attr, bridge(b, index), value)
+    else
+        return MOI.set(b.model, attr, index, value)
+    end
+end
+## Getting and Setting names
+function MOI.get(b::AbstractBridgeOptimizer, attr::MOI.ConstraintName,
+                 constraint_index::CI)
+    if is_bridged(b, typeof(constraint_index))
+        return MOI.get(b.bridged, attr, constraint_index)
     else
-        MOI.get(b.model, attr, ci)
+        return MOI.get(b.model, attr, constraint_index)
     end
 end
-## Setting names
+
 function MOI.supports(b::AbstractBridgeOptimizer, attr::MOI.ConstraintName,
-                      Index::Type{<:CI})
+                      Index::Type{CI{F,S}}) where {F,S}
     if is_bridged(b, Index)
         return MOI.supports(b.bridged, attr, Index)
     else
@@ -253,6 +277,22 @@ function MOI.set(b::AbstractBridgeOptimizer, attr::MOI.ConstraintName,
         MOI.set(b.model, attr, constraint_index, name)
     end
 end
+## Getting functions and sets
+function MOI.get(b::AbstractBridgeOptimizer, attr::MOI.ConstraintSet, ci::CI)
+    if is_bridged(b, typeof(ci))
+        return MOI.get(b.bridged, attr, ci)
+    else
+        return MOI.get(b.model, attr, ci)
+    end
+end
+function MOI.get(b::AbstractBridgeOptimizer, attr::MOI.ConstraintFunction, 
+                 ci::CI)
+    if is_bridged(b, typeof(ci))
+        return MOI.get(b.bridged, attr, ci)
+    else
+        return MOI.get(b.model, attr, ci)
+    end
+end    
 ## Setting functions and sets
 function MOI.set(b::AbstractBridgeOptimizer, ::MOI.ConstraintSet,
                   constraint_index::CI{F, S}, set::S) where {F, S}

src/constraints.jl

@@ -22,7 +22,7 @@ struct UnsupportedConstraint{F<:AbstractFunction, S<:AbstractSet} <: Unsupported
 end
 UnsupportedConstraint{F, S}() where {F, S} = UnsupportedConstraint{F, S}("")
 
-element_name(::UnsupportedConstraint{F, S}) where {F, S} = "`$F`-in-`$S` constraints"
+element_name(::UnsupportedConstraint{F, S}) where {F, S} = "`$F`-in-`$S` constraint"
 
 """
     struct AddConstraintNotAllowed{F<:AbstractFunction, S<:AbstractSet} <: NotAllowedError

test/Bridges/Bridges.jl

@@ -0,0 +1,23 @@
+using Test
+
+@testset "BridgeOptimizer" begin
+    include("bridgeoptimizer.jl")
+end
+@testset "LazyBridgeOptimizer" begin
+    include("lazybridgeoptimizer.jl")
+end
+@testset "Separate bridges" begin
+    include("flip_sign_bridge.jl")
+    include("vectorizebridge.jl")
+    include("scalarizebridge.jl")
+    include("slackbridge.jl")
+    include("functionize_bridge.jl")
+    include("intervalbridge.jl")
+    include("rsocbridge.jl")
+    include("quadtosocbridge.jl")
+    include("geomeanbridge.jl")
+    include("squarepsdbridge.jl")
+    include("detbridge.jl")
+    include("soctopsdbridge.jl")
+end
+include("external.jl")

test/Bridges/bridgeoptimizer.jl

@@ -0,0 +1,99 @@
+using Test
+
+using MathOptInterface
+const MOI = MathOptInterface
+const MOIT = MathOptInterface.Test
+const MOIU = MathOptInterface.Utilities
+const MOIB = MathOptInterface.Bridges
+
+include("simple_model.jl")
+include("utilities.jl")
+
+struct UnknownConstraintAttribute <: MOI.AbstractConstraintAttribute end
+MOI.is_set_by_optimize(::UnknownConstraintAttribute) = true
+
+mock = MOIU.MockOptimizer(SimpleModel{Float64}())
+bridged_mock = MOIB.SplitInterval{Float64}(mock)
+
+@testset "Unsupported constraint attribute" begin
+    attr = UnknownConstraintAttribute()
+    err = ArgumentError(
+        "Constraint bridge of type `MathOptInterface.Bridges.SplitIntervalBridge{Float64,MathOptInterface.SingleVariable}` " *
+        "does not support accessing the attribute `$attr`.")
+    x = MOI.add_variable(bridged_mock)
+    ci = MOI.add_constraint(bridged_mock, MOI.SingleVariable(x),
+                            MOI.Interval(0.0, 1.0))
+    @test_throws err MOI.get(bridged_mock, attr, ci)
+end
+
+@testset "Issue #453" begin
+    MOI.empty!(bridged_mock)
+    MOIU.loadfromstring!(bridged_mock, """
+        variables: x
+        maxobjective: 3.0x
+        c: 2.0x in Interval(1.0, 4.0)
+        d: x in LessThan(1.5)
+    """)
+    x = MOI.get(bridged_mock, MOI.VariableIndex, "x")
+    @test isa(x, MOI.VariableIndex)
+    c1 = MOI.get(bridged_mock, MOI.ConstraintIndex{MOI.ScalarAffineFunction{Float64}, MOI.Interval{Float64}}, "c")
+    @test isa(c1, MOI.ConstraintIndex{MOI.ScalarAffineFunction{Float64}, MOI.Interval{Float64}})
+    c2 = MOI.get(bridged_mock, MOI.ConstraintIndex, "c")
+    @test c1 == c2
+    d1 = MOI.get(bridged_mock, MOI.ConstraintIndex{MOI.SingleVariable, MOI.LessThan{Float64}}, "d")
+    @test isa(d1, MOI.ConstraintIndex{MOI.SingleVariable, MOI.LessThan{Float64}})
+    d2 = MOI.get(bridged_mock, MOI.ConstraintIndex, "d")
+    @test d1 == d2
+end
+
+MOI.empty!(bridged_mock)
+
+@testset "Name test" begin
+    MOIT.nametest(bridged_mock)
+end
+
+@testset "Copy test" begin
+    MOIT.failcopytestc(bridged_mock)
+    MOIT.failcopytestia(bridged_mock)
+    MOIT.failcopytestva(bridged_mock)
+    MOIT.failcopytestca(bridged_mock)
+    MOIT.copytest(bridged_mock, SimpleModel{Float64}())
+end
+
+@testset "Custom test" begin
+    model = MOIB.SplitInterval{Int}(SimpleModel{Int}())
+    @test !MOIB.supports_bridging_constraint(model, MOI.VectorAffineFunction{Float64}, MOI.Interval{Float64})
+
+    x, y = MOI.add_variables(model, 2)
+    @test MOI.get(model, MOI.NumberOfVariables()) == 2
+
+    f1 = MOI.ScalarAffineFunction([MOI.ScalarAffineTerm(3, x)], 7)
+    c1 = MOI.add_constraint(model, f1, MOI.Interval(-1, 1))
+
+    @test MOI.get(model, MOI.ListOfConstraints()) == [(MOI.ScalarAffineFunction{Int},MOI.Interval{Int})]
+    test_noc(model, MOI.ScalarAffineFunction{Int}, MOI.GreaterThan{Int}, 0)
+    test_noc(model, MOI.ScalarAffineFunction{Int}, MOI.Interval{Int}, 1)
+    @test (@inferred MOI.get(model, MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{Int},MOI.Interval{Int}}())) == [c1]
+
+    f2 = MOI.ScalarAffineFunction(MOI.ScalarAffineTerm.([2, -1], [x, y]), 2)
+    c2 = MOI.add_constraint(model, f1, MOI.GreaterThan(-2))
+
+    @test MOI.get(model, MOI.ListOfConstraints()) == [(MOI.ScalarAffineFunction{Int},MOI.GreaterThan{Int}), (MOI.ScalarAffineFunction{Int},MOI.Interval{Int})]
+    test_noc(model, MOI.ScalarAffineFunction{Int}, MOI.GreaterThan{Int}, 1)
+    test_noc(model, MOI.ScalarAffineFunction{Int}, MOI.Interval{Int}, 1)
+    @test (@inferred MOI.get(model, MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{Int},MOI.Interval{Int}}())) == [c1]
+    @test (@inferred MOI.get(model, MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{Int},MOI.GreaterThan{Int}}())) == [c2]
+
+    @test MOI.is_valid(model, c2)
+    MOI.delete(model, c2)
+
+    @test MOI.get(model, MOI.ListOfConstraints()) == [(MOI.ScalarAffineFunction{Int},MOI.Interval{Int})]
+    test_noc(model, MOI.ScalarAffineFunction{Int}, MOI.GreaterThan{Int}, 0)
+    test_noc(model, MOI.ScalarAffineFunction{Int}, MOI.Interval{Int}, 1)
+    @test (@inferred MOI.get(model, MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{Int},MOI.Interval{Int}}())) == [c1]
+end
+
+@testset "Continuous Linear" begin
+    exclude = ["partial_start"] # VariablePrimalStart not supported.
+    MOIT.contlineartest(bridged_mock, MOIT.TestConfig(solve=false), exclude)
+end

test/Bridges/detbridge.jl

@@ -0,0 +1,21 @@
+@testset "LogDet" begin
+    bridged_mock = MOIB.LogDet{Float64}(mock)
+    mock.optimize! = (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [0, 1, 0, 1, 1, 0, 1, 0, 0, 1])
+    MOIT.logdett1vtest(bridged_mock, config)
+    MOIT.logdett1ftest(bridged_mock, config)
+    # Dual is not yet implemented for LogDet bridge
+    ci = first(MOI.get(bridged_mock, MOI.ListOfConstraintIndices{MOI.VectorAffineFunction{Float64}, MOI.LogDetConeTriangle}()))
+    test_delete_bridge(bridged_mock, ci, 5, ((MOI.VectorAffineFunction{Float64}, MOI.ExponentialCone, 0), (MOI.VectorAffineFunction{Float64}, MOI.PositiveSemidefiniteConeTriangle, 0)))
+end
+
+@testset "RootDet" begin
+    bridged_mock = MOIB.RootDet{Float64}(mock)
+    mock.optimize! = (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(mock, [1, 1, 0, 1, 1, 0, 1])
+    MOIT.rootdett1vtest(bridged_mock, config)
+    MOIT.rootdett1ftest(bridged_mock, config)
+    # Dual is not yet implemented for RootDet bridge
+    ci = first(MOI.get(bridged_mock, MOI.ListOfConstraintIndices{MOI.VectorAffineFunction{Float64}, MOI.RootDetConeTriangle}()))
+    test_delete_bridge(bridged_mock, ci, 4, ((MOI.VectorAffineFunction{Float64}, MOI.RotatedSecondOrderCone, 0),
+                                            (MOI.VectorAffineFunction{Float64}, MOI.GeometricMeanCone, 0),
+                                            (MOI.VectorAffineFunction{Float64}, MOI.PositiveSemidefiniteConeTriangle, 0)))
+end

test/Bridges/external.jl

@@ -0,0 +1,61 @@
+using Test
+
+using MathOptInterface
+const MOI = MathOptInterface
+const MOIU = MathOptInterface.Utilities
+
+include("simple_model.jl")
+
+# We need to test this in a module at the top level because it can't be defined
+# in a testset. If it runs without error, then we're okay.
+module TestExternalBridge
+    using MathOptInterface
+
+    struct StrictlyGreaterThan <: MathOptInterface.AbstractScalarSet end
+    struct StrictlyGreaterBridge{T} <: MathOptInterface.Bridges.AbstractBridge end
+
+    function StrictlyGreaterBridge(
+            model,
+            func::MathOptInterface.SingleVariable,
+            set::StrictlyGreaterThan)
+        return StrictlyGreaterBridge{Float64}()
+    end
+
+    function MathOptInterface.supports_constraint(
+            ::Type{StrictlyGreaterBridge{T}},
+            ::Type{MathOptInterface.SingleVariable},
+            ::Type{StrictlyGreaterThan}) where {T}
+        return true
+    end
+
+    function MathOptInterface.Bridges.added_constraint_types(
+            ::Type{StrictlyGreaterBridge{T}},
+            ::Type{MathOptInterface.SingleVariable},
+            ::Type{StrictlyGreaterThan}) where {T}
+        return [(
+            MathOptInterface.SingleVariable,
+            MathOptInterface.GreaterThan{T}
+        )]
+    end
+
+    MathOptInterface.Bridges.@bridge(StrictlyGreater, StrictlyGreaterBridge,
+        (StrictlyGreaterThan, ),
+        (),
+        (),
+        (),
+        (MathOptInterface.SingleVariable, ),
+        (),
+        (),
+        ()
+    )
+end
+
+@testset "@bridge with external components" begin
+    model = SimpleModel{Float64}();
+    @test MOI.supports_constraint(model, MOI.SingleVariable, MOI.GreaterThan{Float64})
+    @test !MOI.supports_constraint(model, MOI.SingleVariable, TestExternalBridge.StrictlyGreaterThan)
+
+    bridge = TestExternalBridge.StrictlyGreater{Float64}(model);
+    @test MOI.supports_constraint(bridge, MOI.SingleVariable, MOI.GreaterThan{Float64})
+    @test MOI.supports_constraint(bridge, MOI.SingleVariable, TestExternalBridge.StrictlyGreaterThan)
+end