Add bounds

src/QCQP/MOI_wrapper.jl

@@ -22,6 +22,16 @@ end
 MOI.is_empty(model::Optimizer) = MOI.is_empty(model.model)
 MOI.empty!(model::Optimizer) = MOI.empty!(model.model)
 
+MOI.is_valid(model::Optimizer, i::MOI.Index) = MOI.is_valid(model.model, i)
+
+function MOI.get(
+    model::Optimizer,
+    attr::MOI.AbstractConstraintAttribute,
+    ci::MOI.ConstraintIndex,
+)
+    return MOI.get(model.model, attr, ci)
+end
+
 MOI.add_variable(model::Optimizer) = MOI.add_variable(model.model)
 
 function MOI.supports_add_constrained_variable(
@@ -100,31 +110,20 @@ end
 
 MOI.optimize!(model::Optimizer) = MOI.optimize!(model.model)
 
-function _quad_convert(index, p::MP.AbstractPolynomialLike{T}, div) where {T}
+function _quad_convert(p::MP.AbstractPolynomialLike{T}, index, div) where {T}
     q = zero(MOI.ScalarQuadraticFunction{T})
     for t in MP.terms(p)
         α = MP.coefficient(t)
         mono = MP.monomial(t)
         if MP.degree(mono) == 0
             MA.operate!(+, q, α)
         else
-            vars = MP.effective_variables(mono)
-            if MP.degree(mono) == 1
-                @assert length(vars) == 1
-                MA.operate!(MA.add_mul, q, α, index(first(vars)))
-            elseif MP.degree(mono) == 2
-                x = first(vars)
-                if length(vars) == 1
-                    y = x
-                else
-                    @assert length(vars) == 2
-                    y = vars[2]
-                end
-                MA.operate!(MA.add_mul, q, α, index(x), index(y))
+            if haskey(index, mono)
+                MA.operate!(MA.add_mul, q, α, index[mono])
             else
                 x = div[mono]
                 y = MP.div_multiple(mono, x)
-                MA.operate!(MA.add_mul, q, α, index(x), index(y))
+                MA.operate!(MA.add_mul, q, α, index[x], index[y])
             end
         end
     end
@@ -140,11 +139,19 @@ end
 
 function monomial_variable_index(model::Optimizer{T}, d::Dict, div, mono::MP.AbstractMonomialLike) where {T}
     if !haskey(d, mono)
-        d[mono] = MOI.add_variable(model.model)
         x = div[mono]
         vx = monomial_variable_index(model, d, div, x)
         y = MP.div_multiple(mono, x)
         vy = monomial_variable_index(model, d, div, y)
+        lx, ux = MOI.Utilities.get_bounds(model, T, vx)
+        ly, uy = MOI.Utilities.get_bounds(model, T, vy)
+        bounds = (lx * ly, lx * uy, ux * ly, ux * uy)
+        l = min(bounds...)
+        if vx == vy
+            l = max(l, zero(T))
+        end
+        u = max(bounds...)
+        d[mono], _ = MOI.add_constrained_variable(model.model, MOI.Interval(l, u))
         MOI.add_constraint(model,
             MA.@rewrite(one(T) * d[mono] - one(T) * vx * vy),
             MOI.EqualTo(zero(T)),
@@ -159,10 +166,16 @@ function MOI.Utilities.final_touch(model::Optimizer{T}, _) where {T}
         p = model.objective.polynomial
         monos = MP.monomials(p)
         div = decompose(monos)
-        function index(mono)
-            return monomial_variable_index(model, d, div, mono)
+        for mono in sort(collect(keys(div)))
+            if haskey(d, mono)
+                continue
+            end
+            a = div[mono]
+            monomial_variable_index(model, d, div, a)
+            b = MP.div_multiple(mono, a)
+            monomial_variable_index(model, d, div, b)
         end
-        obj = _quad_convert(index, p, div)
+        obj = _quad_convert(p, d, div)
         MOI.set(model.model, MOI.ObjectiveFunction{typeof(obj)}(), obj)
     end
     return

src/nl_to_polynomial.jl

@@ -102,7 +102,7 @@ end
 
 function _scalar_polynomial(d::Dict{K,V}, ::Type{T}, poly) where {T,K,V}
     variable_map = collect(d)
-    sort!(variable_map, by = x -> x[2])
+    sort!(variable_map, by = x -> x[2], rev = true)
     variables = [x[1] for x in variable_map]
     P = MP.polynomial_type(V, T)
     return ScalarPolynomialFunction{T,P}(poly, variables)

test/qcqp.jl

@@ -50,17 +50,30 @@ function test_objective(x, y, T)
     inner = Model{T}()
     optimizer = MOI.Utilities.MockOptimizer(inner)
     model = PolyJuMP.JuMP.GenericModel{T}(() -> PolyJuMP.QCQP.Optimizer(optimizer))
-    PolyJuMP.@variable(model, 0 <= a)
-    PolyJuMP.@variable(model, 0 <= b)
+    PolyJuMP.@variable(model, 1 <= a <= 2)
+    PolyJuMP.@variable(model, -5 <= b <= 3)
     PolyJuMP.@constraint(model, a + b >= 1)
     PolyJuMP.@objective(model, Min, a^3 - a^2 + 2a*b - b^2 + b^3)
     PolyJuMP.optimize!(model)
     vis = MOI.get(inner, MOI.ListOfVariableIndices())
     @test length(vis) == 4
+    a, b, b2, a2 = vis
+    @test MOI.Utilities.get_bounds(inner, T, a) == (1, 2)
+    @test MOI.Utilities.get_bounds(inner, T, b) == (-5, 3)
+    @test MOI.Utilities.get_bounds(inner, T, a2) == (1, 4)
+    @test MOI.Utilities.get_bounds(inner, T, b2) == (0, 25)
     F = MOI.ScalarQuadraticFunction{T}
     S = MOI.EqualTo{T}
     cis = MOI.get(inner, MOI.ListOfConstraintIndices{F,S}())
     @test length(cis) == 2
+    o = one(T)
+    @test MOI.get(inner, MOI.ConstraintFunction(), cis[1]) ≈ b2 - o * b * b
+    @test MOI.get(inner, MOI.ConstraintFunction(), cis[2]) ≈ a2 - o * a * a
+    for ci in cis
+        @test MOI.get(inner, MOI.ConstraintSet(), ci) == MOI.EqualTo(zero(T))
+    end
+    @test MOI.get(inner, MOI.ObjectiveFunction{F}()) ≈
+        -o * a2 + 2o * a * b - o * b2 + o * a * a2 + o * b * b2
 end
 
 function runtests(x, y, T)