Merge pull request #109 from SCIP-Interfaces/rs/conshdlr

add support for constraint handlers

Author: rschwarz

NEWS.md

@@ -1,5 +1,9 @@
 # News
 
+## v0.9.1
+
+- Add a Julia wrapper for constraint handlers. [109](https://github.com/SCIP-Interfaces/SCIP.jl/pull/109)
+
 ## v0.9.0
 
 - support MOI v0.9 [#126](https://github.com/SCIP-Interfaces/SCIP.jl/pull/126)

README.md

@@ -20,7 +20,8 @@ The goal is to support [JuMP](https://github.com/JuliaOpt/JuMP.jl) (from version
 Currently, we support LP, MIP and QCP problems, as well as some nonlinear constraints, both through `MOI` sets
 (e.g., for second-order cones) as well as for expression graphs (see below).
 
-We still have feature loss in the area of callbacks compared to previous versions.
+It is now possible to implement SCIP constraint handlers in Julia. Other plugin
+types are not yet supported.
 
 ## Getting Started
 

src/MOI_wrapper.jl

@@ -91,7 +91,7 @@ end
 
 "Go back from solved stage to problem modification stage, invalidating results."
 function allow_modification(o::Optimizer)
-    if SCIPgetStage(o) != SCIP_STAGE_PROBLEM
+    if !(SCIPgetStage(o) in (SCIP_STAGE_PROBLEM, SCIP_STAGE_SOLVING))
         @SC SCIPfreeTransform(o)
     end
     return nothing
@@ -202,3 +202,4 @@ include(joinpath("MOI_wrapper", "indicator_constraints.jl"))
 include(joinpath("MOI_wrapper", "nonlinear_constraints.jl"))
 include(joinpath("MOI_wrapper", "objective.jl"))
 include(joinpath("MOI_wrapper", "results.jl"))
+include(joinpath("MOI_wrapper", "conshdlr.jl"))

src/MOI_wrapper/conshdlr.jl

@@ -0,0 +1,69 @@
+#
+# Adding constraint handlers and constraints to SCIP.Optimizer.
+#
+
+"""
+    include_conshdlr(
+        o::Optimizer,
+        ch::CH;
+        name::String,
+        description::String,
+        enforce_priority::Int,
+        check_priority::Int,
+        eager_frequency::Int,
+        needs_constraints::Bool
+    )
+
+Include a user defined constraint handler `ch` to SCIP optimizer instance `o`.
+
+All parameters have default values that can be set as keyword arguments.
+In particular, note the boolean `needs_constraints`:
+* If set to `true`, then the callbacks are only called for the constraints that
+  were added explicitly using `add_constraint`.
+* If set to `false`, the callback functions will always be called, even if no
+  corresponding constraint was added. It probably makes sense to set
+  `misc/allowdualreds` to `FALSE` in this case.
+"""
+function include_conshdlr(o::Optimizer, ch::CH;
+                          name="", description="", enforce_priority=-15,
+                          check_priority=-7000000, eager_frequency=100,
+                          needs_constraints=true) where CH <: AbstractConstraintHandler
+    include_conshdlr(o.mscip, ch, name=name, description=description,
+                     enforce_priority=enforce_priority,
+                     check_priority=check_priority,
+                     eager_frequency=eager_frequency,
+                     needs_constraints=needs_constraints)
+end
+
+"""
+    add_constraint(
+        o::Optimizer,
+        ch::CH,
+        c::C;
+        initial=true,
+        separate=true,
+        enforce=true,
+        check=true,
+        propagate=true,
+        _local=false,
+        modifiable=false,
+        dynamic=false,
+        removable=false,
+        stickingatnode=false
+    )::ConsRef
+
+
+Add constraint `c` belonging to user-defined constraint handler `ch` to model.
+Returns constraint reference.
+
+All keyword arguments are passed to the `SCIPcreateCons` call.
+"""
+function add_constraint(o::Optimizer, ch::CH, c::C;
+                        initial=true, separate=true, enforce=true, check=true,
+                        propagate=true, _local=false, modifiable=false,
+                        dynamic=false, removable=false, stickingatnode=false) where {CH <:AbstractConstraintHandler, C <: AbstractConstraint{CH}}
+    return add_constraint(o.mscip, ch, c, initial=initial, separate=separate,
+                          enforce=enforce, check=check, propagate=propagate,
+                          _local=_local, modifiable=modifiable, dynamic=dynamic,
+                          removable=removable, stickingatnode=stickingatnode)
+end

src/MOI_wrapper/results.jl

@@ -41,13 +41,25 @@ end
 
 "Make sure that SCIP is currently in one of the allowed stages."
 function assert_stage(o::Optimizer, stages)
-    if !(SCIPgetStage(o) in stages)
-        error("SCIP is wrong stage, can not query results!")
+    stage = SCIPgetStage(o)
+    if !(stage in stages)
+        error("SCIP is wrong stage ($stage, need $stages), can not query results!")
     end
 end
 
 "Make sure that the problem was solved (SCIP is in SOLVED stage)."
-assert_solved(o::Optimizer) = assert_stage(o, [SCIP_STAGE_SOLVED])
+function assert_solved(o::Optimizer)
+    # SCIP's stage is SOLVING when stopped by user limit!
+    assert_stage(o, [SCIP_STAGE_SOLVING, SCIP_STAGE_SOLVED])
+
+    # Check for invalid status (when stage is SOLVING).
+    status = SCIPgetStage(o)
+    if status in (SCIP_STATUS_UNKNOWN,
+                  SCIP_STATUS_USERINTERRUPT,
+                  SCIP_STATUS_TERMINATE)
+        error("SCIP's solving was interrupted, but not by a user-given limit!")
+    end
+end
 
 "Make sure that: TRANSFORMED ≤ stage ≤ SOLVED."
 assert_after_prob(o::Optimizer) = assert_stage(o, SCIP_Stage.(3:10))

src/MOI_wrapper/variable.jl

@@ -13,8 +13,8 @@ MOI.get(o::Optimizer, ::MOI.NumberOfVariables) = length(o.mscip.vars)
 MOI.get(o::Optimizer, ::MOI.ListOfVariableIndices) = [VI(k.val) for k in keys(o.mscip.vars)]
 MOI.is_valid(o::Optimizer, vi::VI) = haskey(o.mscip.vars, VarRef(vi.value))
 
-function MOI.get(o::Optimizer, ::MOI.VariableName, vi::VI)
-    return GC.@preserve o SCIPvarGetName(var(o, vi))
+function MOI.get(o::Optimizer, ::MOI.VariableName, vi::VI)::String
+    return GC.@preserve o unsafe_string(SCIPvarGetName(var(o, vi)))
 end
 
 function MOI.set(o::Optimizer, ::MOI.VariableName, vi::VI, name::String)

src/SCIP.jl

@@ -15,9 +15,15 @@ include("managed_scip.jl")
 # constraints from nonlinear expressions
 include("nonlinear.jl")
 
+# constraint handlers
+include("conshdlr.jl")
+
 # implementation of MOI
 include("MOI_wrapper.jl")
 
+# convenience functions
+include("convenience.jl")
+
 # warn about rewrite
 include("compat.jl")