Allocation-free range

Author: blegat

src/iis.jl

@@ -53,7 +53,7 @@ Base.@kwdef mutable struct Optimizer
     #
     # iis attributes
     time_limit::Float64 = Inf
-    verbose::Bool = false
+    verbose::Bool = true
     skip_feasibility_check::Bool = false
     stop_if_infeasible_bounds::Bool = true
     stop_if_infeasible_ranges::Bool = true
@@ -287,7 +287,7 @@ function MOI.compute_conflict!(optimizer::Optimizer)
         println("Starting bound analysis.")
     end
     bounds_consistent, variables, lb_con, ub_con =
-        _bound_infeasibility!(optimizer, T)
+        @time _bound_infeasibility!(optimizer, T)
     bound_infeasibilities = length(optimizer.results)
     if optimizer.verbose
         println(
@@ -310,7 +310,7 @@ function MOI.compute_conflict!(optimizer::Optimizer)
         println("Starting range analysis.")
     end
     range_consistent =
-        _range_infeasibility!(optimizer, T, variables, lb_con, ub_con)
+        @time _range_infeasibility!(optimizer, T, variables, lb_con, ub_con)
     range_infeasibilities = length(optimizer.results) - bound_infeasibilities
     if optimizer.verbose
         println(
@@ -320,6 +320,7 @@ function MOI.compute_conflict!(optimizer::Optimizer)
     if length(optimizer.results) > 0
         optimizer.status = MOI.CONFLICT_FOUND
     end
+    return
 
     if (!range_consistent && optimizer.stop_if_infeasible_ranges) ||
        !_in_time(optimizer)

src/range.jl

@@ -9,57 +9,33 @@ function _range_infeasibility!(
     variables,
     lb_con::Dict{MOI.VariableIndex,MOI.ConstraintIndex},
     ub_con::Dict{MOI.VariableIndex,MOI.ConstraintIndex},
-) where {T}
+    ::Type{S},
+) where {T,S}
     range_consistent = true
-
-    affine_cons = vcat(
-        MOI.get(
-            optimizer.original_model,
-            MOI.ListOfConstraintIndices{
-                MOI.ScalarAffineFunction{T},
-                MOI.EqualTo{T},
-            }(),
-        ),
-        MOI.get(
-            optimizer.original_model,
-            MOI.ListOfConstraintIndices{
-                MOI.ScalarAffineFunction{T},
-                MOI.LessThan{T},
-            }(),
-        ),
-        MOI.get(
-            optimizer.original_model,
-            MOI.ListOfConstraintIndices{
-                MOI.ScalarAffineFunction{T},
-                MOI.GreaterThan{T},
-            }(),
-        ),
+    for con in MOI.get(
+        optimizer.original_model,
+        MOI.ListOfConstraintIndices{
+            MOI.ScalarAffineFunction{T},
+            S,
+        }(),
     )
-
-    for con in affine_cons
         if !_in_time(optimizer)
             return range_consistent
         end
         func = MOI.get(optimizer.original_model, MOI.ConstraintFunction(), con)
-        failed = false
-        list_of_variables = MOI.VariableIndex[]
-        interval = _eval_variables(func) do var_idx
-            push!(list_of_variables, var_idx)
-            # this only fails if we allow continuing after bounds issues
-            if !haskey(variables, var_idx)
-                failed = true
-                return Interval(-Inf, Inf)
-            end
-            return variables[var_idx]
-        end
-        if failed
+        interval = @time _eval_variables(variables, func)::Union{Nothing,Interval{T}}
+        if isnothing(interval)
             continue
         end
         set = MOI.get(optimizer.original_model, MOI.ConstraintSet(), con)
         if _invalid_range(set, interval)
+            if optimizer.verbose
+                println("Found one inconsistent range")
+            end
             cons = Set{MOI.ConstraintIndex}()
             push!(cons, con)
-            for var in list_of_variables
+            for t in func.terms
+                var = t.variable
                 if haskey(lb_con, var)
                     push!(cons, lb_con[var])
                 end
@@ -81,6 +57,20 @@ function _range_infeasibility!(
     return range_consistent
 end
 
+function _range_infeasibility!(
+    optimizer::Optimizer,
+    ::Type{T},
+    variables,
+    lb_con::Dict{MOI.VariableIndex,MOI.ConstraintIndex},
+    ub_con::Dict{MOI.VariableIndex,MOI.ConstraintIndex},
+) where {T}
+    range_consistent = true
+    range_consistent &= _range_infeasibility!(optimizer, T, variables, lb_con, ub_con, MOI.EqualTo{T})
+    range_consistent &= _range_infeasibility!(optimizer, T, variables, lb_con, ub_con, MOI.LessThan{T})
+    range_consistent &= _range_infeasibility!(optimizer, T, variables, lb_con, ub_con, MOI.GreaterThan{T})
+    return range_consistent
+end
+
 function _invalid_range(set::MOI.EqualTo, interval)
     rhs = set.value
     return interval.lo > rhs || interval.hi < rhs
@@ -135,20 +125,17 @@ end
 # This type and the associated function were inspired by JuMP.jl and
 # MathOptInterface.jl
 
-function _eval_variables(value_fn::Function, t::MOI.ScalarAffineTerm)
-    return t.coefficient * value_fn(t.variable)
-end
-
 function _eval_variables(
-    value_fn::Function,
+    map::AbstractDict{MOI.VariableIndex,U},
     f::MOI.ScalarAffineFunction{T},
-) where {T}
-    # TODO: this conversion exists in JuMP, but not in MOI
-    S = Base.promote_op(value_fn, MOI.VariableIndex)
-    U = MOI.MA.promote_operation(*, T, S)
+) where {T,U}
     out = convert(U, f.constant)
-    for t in f.terms
-        out += _eval_variables(value_fn, t)
+    @time for t in f.terms
+        if haskey(map, t.variable)
+            out += t.coefficient * map[t.variable]
+        else
+            return
+        end
     end
     return out
 end

src/solver.jl

@@ -84,24 +84,30 @@ function _elastic_filter(optimizer::Optimizer)
 
     de_elastisized = []
 
-    changed_obj = false
-
     # all (affine, non-bound) constraints are relaxed at this point
-    # we will try to set positive slacks to zero until the model infeasible
-    # the constraints of the fixed slacks are a IIS candidate
+    # we will try to set positive slacks to zero until the model becomes
+    # infeasible. The constraints of the fixed slacks then form a IIS candidate.
 
     for i in 1:max_iterations
         if !_in_time(optimizer)
             return nothing
         end
+        if optimizer.verbose
+            println("Solving iteration $i...")
+        end
         MOI.optimize!(model)
+        if optimizer.verbose
+            println("Iteration $i solved.")
+        end
         status = MOI.get(model, MOI.TerminationStatus())
         if status in ( # possibily primal unbounded statuses
             MOI.INFEASIBLE_OR_UNBOUNDED,
             MOI.DUAL_INFEASIBLE,
             MOI.ALMOST_DUAL_INFEASIBLE,
         )
-            #
+            if optimizer.verbose
+                @warn("Termination status is $status")
+            end
         end
         if status in
            (MOI.INFEASIBLE, MOI.ALMOST_INFEASIBLE, MOI.LOCALLY_INFEASIBLE)
@@ -143,8 +149,6 @@ function _elastic_filter(optimizer::Optimizer)
     # consider deleting all no iis constraints
     # be careful with intervals
 
-    obj_type = MOI.get(model, MOI.ObjectiveFunctionType())
-    obj_func = MOI.get(model, MOI.ObjectiveFunction{obj_type}())
     obj_sense = MOI.get(model, MOI.ObjectiveSense())
 
     candidates = MOI.ConstraintIndex[]