WIP: add more interface methods and call them from the C callbacks

Author: rschwarz

src/conshdlr.jl

@@ -25,16 +25,73 @@ abstract type AbstractConstraintHandler end
 # (also: CONSDATA)
 abstract type AbstractConstraint{Handler} end
 
-# Example implementation
-mutable struct ExampleConstraintHandler <: AbstractConstraintHandler
-end
+# Parameters:
+
+abstract type AbstractConstraintHandlerParameter end
+struct Name <: AbstractConstraintHandlerParameter end
+struct Description <: AbstractConstraintHandlerParameter end
+struct EnforcePriority <: AbstractConstraintHandlerParameter end
+struct CheckPriority <: AbstractConstraintHandlerParameter end
+
+# Interface methods
+
+# Parameters have default values
+get(ch::AbstractConstraintHandler, ::Name) = ""
+get(ch::AbstractConstraintHandler, ::Description) = ""
+# enfoprio: integral has 0, nonlinear: -30 or less
+get(ch::AbstractConstraintHandler, ::EnforcePriority) = -15
+# checkprio: integral has 0, SCIP's plugins have -6000000 or more
+get(ch::AbstractConstraintHandler, ::CheckPriority) = -7000000
+
+# For semantics of callback methods, see SCIP documentation at:
+# https://scip.zib.de/doc-6.0.1/html/CONS.php#CONS_FUNDAMENTALCALLBACKS
+
+function check end
+
+# possible return values:
+# SCIP_CUTOFF: stating that the current subproblem is infeasible
+# SCIP_CONSADDED: adding constraint that resolves the infeasibility
+# SCIP_REDUCEDDOM: reducing the domain of a variable
+# SCIP_SEPARATED: adding a cutting plane
+# SCIP_BRANCHED: performing a branching
+function enforce_lp_sol end
+
+# possible return values:
+# SCIP_CUTOFF: stating that the current subproblem is infeasible
+# SCIP_CONSADDED: adding constraint that resolves the infeasibility
+# SCIP_REDUCEDDOM: reducing the domain of a variable
+# SCIP_BRANCHED: performing a branching
+# SCIP_SOLVELP: force solving of LP
+function enforce_pseudo_sol end
+
+function lock end
 
-### ^ above: what it will look like to Julia users
-### = here: sketches for the translation
+# Methods
 
-### v below: what it will look like to SCIP
+# CONSCHECK
+# (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss,
+#  SCIP_SOL* sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows,
+#  SCIP_Bool printreason, SCIP_Bool completely, SCIP_RESULT* result
+function _conscheck(scip::Ptr{SCIP_}, conshdlr::{SCIP_CONSHDLR},
+                    conss::Ptr{Ptr{SCIP_CONS}}, nconss::Cint,
+                    sol::Ptr{SCIP_SOL}, checkintegrality::SCIP_Bool,
+                    checklprows::SCIP_Bool, printreason::SCIP_Bool,
+                    completely::SCIP_Bool, result::Ptr{SCIP_RESULT})
+    # get Julia object out of constraint handler data
+    conshdlrdata = SCIPconshdlrGetData(conshdlr)
+    constraint_handler = unsafe_objref_from_pointer(conshdlrdata)
 
-# Methods
+    # get Julia array from C pointer
+    constraint_pointers = unsafe_wrap(Array{Ptr{SCIP_CONS}}, conss, nconss)
+
+    # TODO: fetch solution values
+    # TODO: document meaning of all parameters
+
+    # call user method via dispatch
+    result[] = check(constraint_handler, constraints)
+
+    return SCIP_OKAY
+end
 
 # CONSENFOLP
 # (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss,
@@ -44,6 +101,19 @@ function _consenfolp(scip::Ptr{SCIP_}, conshdlr::Ptr{SCIP_CONSHDLR},
                      conss::Ptr{Ptr{SCIP_CONS}}, nconss::Cint,
                      nusefulconss::Cint, solinfeasible::SCIP_Bool,
                      result::Ptr{SCIP_RESULT})
+    # get Julia object out of constraint handler data
+    conshdlrdata = SCIPconshdlrGetData(conshdlr)
+    constraint_handler = unsafe_objref_from_pointer(conshdlrdata)
+
+    # get Julia array from C pointer
+    constraint_pointers = unsafe_wrap(Array{Ptr{SCIP_CONS}}, conss, nconss)
+
+    # TODO: fetch solution values?
+    # TODO: document meaning of all parameters
+
+    # call user method via dispatch
+    result[] = enforce_lp_sol(constraint_handler, constraints, solinfeasible)
+
     return SCIP_OKAY
 end
 
@@ -55,18 +125,20 @@ function _consenfops(scip::Ptr{SCIP_}, conshdlr::Ptr{SCIP_CONSHDLR},
                      conss::Ptr{Ptr{SCIP_CONS}}, nconss::Cint,
                      nusefulconss::Cint, solinfeasible::SCIP_Bool,
                      objinfeasible::SCIP_Bool, result::Ptr{SCIP_RESULT})
-    return SCIP_OKAY
-end
+    # get Julia object out of constraint handler data
+    conshdlrdata = SCIPconshdlrGetData(conshdlr)
+    constraint_handler = unsafe_objref_from_pointer(conshdlrdata)
+
+    # get Julia array from C pointer
+    constraint_pointers = unsafe_wrap(Array{Ptr{SCIP_CONS}}, conss, nconss)
+
+    # TODO: fetch solution values?
+    # TODO: document meaning of all parameters
+
+    # call user method via dispatch
+    result[] = enforce_pseudo_sol(constraint_handler, constraints,
+                                  solinfeasible, objinfeasible)
 
-# CONSCHECK
-# (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss,
-#  SCIP_SOL* sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows,
-#  SCIP_Bool printreason, SCIP_Bool completely, SCIP_RESULT* result
-function _conscheck(scip::Ptr{SCIP_}, conshdlr::{SCIP_CONSHDLR},
-                    conss::Ptr{Ptr{SCIP_CONS}}, nconss::Cint,
-                    sol::Ptr{SCIP_SOL}, checkintegrality::SCIP_Bool,
-                    checklprows::SCIP_Bool, printreason::SCIP_Bool,
-                    completely::SCIP_Bool, result::Ptr{SCIP_RESULT})
     return SCIP_OKAY
 end
 
@@ -76,6 +148,15 @@ end
 function _conslock(scip::Ptr{SCIP_}, conshdlr::Ptr{SCIP_CONSHDLR},
                    cons::Ptr{SCIP_CONS}, locktype::Ptr{SCIP_LOCKTYPE},
                    nlockspos::Cint, nlocksneg::Cint)
+    # get Julia object out of constraint handler data
+    conshdlrdata = SCIPconshdlrGetData(conshdlr)
+    constraint_handler = unsafe_objref_from_pointer(conshdlrdata)
+
+    # TODO: document meaning of all parameters
+
+    # call user method via dispatch
+    result[] = lock(constraint_handler, cons, locktype, nlockspos, nlocksneg)
+
     return SCIP_OKAY
 end
 
@@ -85,9 +166,8 @@ end
 # - set properties (NAME, DESC, ENFOPRIORITY, CHECKPRIORITY).
 # - initialize conshdlrdata (== Julia object)
 # - could be called from the constructor to constraint handler?
-function include_conshdlr(mscip::ManagedSCIP, constraint_handler::CH) where CH <: AbstractConstraintHandler
+function include_conshdlr(mscip::ManagedSCIP, ch::CH) where CH <: AbstractConstraintHandler
     # get C function pointers from Julia functions
-    # TODO: need specific methods? ask users to specify as function arguments?
     _enfolp = @cfunction(_consenfolp, SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Ptr{SCIP_CONS}}, Cint, Cint, SCIP_Bool, SCIP_Bool, Ptr{SCIP_RESULT}))
     _enfops = @cfunction(_consenfops, SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Ptr{SCIP_CONS}}, Cint, Cint, SCIP_Bool, SCIP_Bool, SCIP_Bool, Ptr{SCIP_RESULT}))
     _check = @cfunction(_conscheck, SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_CONSHDLR}, Ptr{Ptr{SCIP_CONS}}, Cint, Ptr{SCIP_SOL}, SCIP_Bool, SCIP_Bool, SCIP_Bool, SCIP_Bool, Ptr{SCIP_RESULT}))
@@ -102,16 +182,16 @@ function include_conshdlr(mscip::ManagedSCIP, constraint_handler::CH) where CH <
     NEEDSCONS = TRUE
 
     # Get other values from methods:
-    name = get(constraint_handler, Name())
-    desc = get(constraint_handler, Description())
-    enfoprio = get(constraint_handler, EnforcePriority())
-    checkprio = get(constraint_handler, CheckPriority())
+    name = get(ch, Name())
+    desc = get(ch, Description())
+    enfoprio = get(ch, EnforcePriority())
+    checkprio = get(ch, CheckPriority())
 
     # Register constraint handler with SCIP instance.
     @SC SCIPincludeConshdlrBasic(mscip, conshdlr__, name, desc, enfopriority,
                                  chckpriority, EAGERFREQ, NEEDSCONS,
                                  _enfolp, _enfops, _check, _lock,
-                                 constraint_handler)
+                                 ch)
 
     # Sanity checks
     @assert conshdlr__[] != C_NULL