Remove unneeded module prefixes

src/LibSCIP.jl

@@ -63974,7 +63974,7 @@ const ARTIFICIALVARNAMEPREFIX = "andresultant_"
 const SCIPisFinite = isfinite
 
 # exports
-const PREFIXES = ["SCIP_", "SCIP", "BMS_"]
+const PREFIXES = ["SCIP", "BMS_"]
 for name in names(@__MODULE__; all=true), prefix in PREFIXES
     if startswith(string(name), prefix)
         @eval export $name

src/MOI_wrapper/HeuristicCallback.jl

@@ -84,25 +84,25 @@ function MOI.submit(
     heur_ = o.inner.heuristic_storage[heuristic]
     sol = create_empty_scipsol(o.inner.scip[], heur_)
     for idx in eachindex(x)
-        SCIP.@SCIP_CALL SCIP.SCIPsetSolVal(
+        @SCIP_CALL SCIPsetSolVal(
             o.inner.scip[],
             sol,
             var(o, x[idx]),
             values[idx],
         )
     end
-    stored = Ref{SCIP_Bool}(SCIP.FALSE)
+    stored = Ref{SCIP_Bool}(FALSE)
     @SCIP_CALL SCIPtrySolFree(
         o.inner.scip[],
         Ref(sol),
-        SCIP.FALSE,
-        SCIP.FALSE,
-        SCIP.TRUE,
-        SCIP.TRUE,
-        SCIP.TRUE,
+        FALSE,
+        FALSE,
+        TRUE,
+        TRUE,
+        TRUE,
         stored,
     )
-    if stored[] == SCIP.TRUE
+    if stored[] == TRUE
         callback_data.submit_called = true
     end
     return

src/MOI_wrapper/conflict.jl

@@ -29,8 +29,8 @@ function compute_minimum_unsatisfied_constraints!(o::Optimizer)
         )
     end
     # free the transformed problem first
-    if LibSCIP.SCIPgetStage(o) != LibSCIP.SCIP_STAGE_PROBLEM
-        @SCIP_CALL LibSCIP.SCIPfreeTransform(o)
+    if SCIPgetStage(o) != SCIP_STAGE_PROBLEM
+        @SCIP_CALL SCIPfreeTransform(o)
     end
     # first transform all variable bound constraints to constraint bounds
     for (F, S) in MOI.get(o, MOI.ListOfConstraintTypesPresent())
@@ -68,9 +68,9 @@ function compute_minimum_unsatisfied_constraints!(o::Optimizer)
             end
         end
     end
-    success = Ref{LibSCIP.SCIP_Bool}(SCIP.FALSE)
-    @SCIP_CALL LibSCIP.SCIPtransformMinUC(o, success)
-    if success[] != SCIP.TRUE
+    success = Ref{SCIP_Bool}(FALSE)
+    @SCIP_CALL SCIPtransformMinUC(o, success)
+    if success[] != TRUE
         error(
             "Failed to compute the minimum unsatisfied constraints system.\nSome constraint types may not support the required transformations",
         )

src/MOI_wrapper/constraints.jl

@@ -120,5 +120,5 @@ function MOI.is_valid(o::Optimizer, c::MOI.ConstraintIndex{F,S}) where {F,S}
     if !in(ConsRef(c.value), cons_set)
         return false
     end
-    return haskey(o.inner.conss, SCIP.ConsRef(c.value))
+    return haskey(o.inner.conss, ConsRef(c.value))
 end

src/MOI_wrapper/linear_constraints.jl

@@ -31,7 +31,7 @@ function MOI.add_constraint(
 end
 
 function MOI.set(
-    o::SCIP.Optimizer,
+    o::Optimizer,
     ::MOI.ConstraintSet,
     ci::MOI.ConstraintIndex{<:MOI.ScalarAffineFunction{Float64},S},
     set::S,

src/MOI_wrapper/quadratic_constraints.jl

@@ -60,15 +60,15 @@ function MOI.get(
     expr_ref = SCIPgetExprNonlinear(c)
     # This call is required to get quaddata computed in the expression
     isq = Ref{UInt32}(100)
-    @SCIP_CALL LibSCIP.SCIPcheckExprQuadratic(o, expr_ref, isq)
+    @SCIP_CALL SCIPcheckExprQuadratic(o, expr_ref, isq)
     @assert isq[] == 1
     constant_ref = Ref{Cdouble}(-1.0)
     n_linear_terms_ref = Ref{Cint}(-1)
-    linear_exprs = Ref{Ptr{Ptr{LibSCIP.SCIP_EXPR}}}()
+    linear_exprs = Ref{Ptr{Ptr{SCIP_EXPR}}}()
     lincoefs = Ref{Ptr{Cdouble}}()
     n_quad_terms_ref = Ref{Cint}(-1)
     n_bilinear_terms_ref = Ref{Cint}(-1)
-    LibSCIP.SCIPexprGetQuadraticData(
+    SCIPexprGetQuadraticData(
         expr_ref,
         constant_ref,
         n_linear_terms_ref,
@@ -83,16 +83,16 @@ function MOI.get(
         unsafe_wrap(Vector{Ptr{Cvoid}}, linear_exprs[], n_linear_terms_ref[])
     lin_coeff_vec =
         unsafe_wrap(Vector{Cdouble}, lincoefs[], n_linear_terms_ref[])
-    func = SCIP.MOI.ScalarQuadraticFunction{Float64}([], [], constant_ref[])
+    func = MOI.ScalarQuadraticFunction{Float64}([], [], constant_ref[])
     for idx in 1:n_linear_terms_ref[]
-        var_ptr = LibSCIP.SCIPgetVarExprVar(lin_expr_vec[idx])
+        var_ptr = SCIPgetVarExprVar(lin_expr_vec[idx])
         func += lin_coeff_vec[idx] * MOI.VariableIndex(o.reference[var_ptr].val)
     end
     for term_idx in 1:n_quad_terms_ref[]
         var_expr = Ref{Ptr{Cvoid}}()
         lin_coef_ref = Ref{Cdouble}()
         sqr_coef_ref = Ref{Cdouble}()
-        LibSCIP.SCIPexprGetQuadraticQuadTerm(
+        SCIPexprGetQuadraticQuadTerm(
             expr_ref,
             term_idx - 1, # 0-indexed terms
             var_expr,
@@ -104,7 +104,7 @@ function MOI.get(
         )
         @assert lin_coef_ref[] == 0.0
         if sqr_coef_ref[] != 0.0
-            var_ptr = LibSCIP.SCIPgetVarExprVar(var_expr[])
+            var_ptr = SCIPgetVarExprVar(var_expr[])
             var_idx = MOI.VariableIndex(o.reference[var_ptr].val)
             MOI.Utilities.operate!(
                 +,
@@ -118,7 +118,7 @@ function MOI.get(
         var_expr1 = Ref{Ptr{Cvoid}}()
         var_expr2 = Ref{Ptr{Cvoid}}()
         coef_ref = Ref{Cdouble}()
-        LibSCIP.SCIPexprGetQuadraticBilinTerm(
+        SCIPexprGetQuadraticBilinTerm(
             expr_ref,
             term_idx - 1,
             var_expr1,
@@ -128,9 +128,9 @@ function MOI.get(
             C_NULL,
         )
         if coef_ref[] != 0.0
-            var_ptr1 = LibSCIP.SCIPgetVarExprVar(var_expr1[])
+            var_ptr1 = SCIPgetVarExprVar(var_expr1[])
             var_idx1 = MOI.VariableIndex(o.reference[var_ptr1].val)
-            var_ptr2 = LibSCIP.SCIPgetVarExprVar(var_expr2[])
+            var_ptr2 = SCIPgetVarExprVar(var_expr2[])
             var_idx2 = MOI.VariableIndex(o.reference[var_ptr2].val)
             MOI.Utilities.operate!(
                 +,
@@ -164,7 +164,7 @@ function MOI.get(
     c = cons(o, ci)
     expr_ref = SCIPgetExprNonlinear(c)
     isq = Ref{UInt32}(100)
-    @SCIP_CALL LibSCIP.SCIPcheckExprQuadratic(o, expr_ref, isq)
+    @SCIP_CALL SCIPcheckExprQuadratic(o, expr_ref, isq)
     @assert isq[] == 1
     sol = SCIPgetBestSol(o)
     @SCIP_CALL SCIPevalExpr(o, expr_ref, sol, Clonglong(0))

src/branching_rule.jl

@@ -42,7 +42,7 @@
 `allow_additional_constraints` is a Boolean indicating if the branching rule
 is allowed to add constraints to the current node in order to cut off the current solution instead of creating a branching.
 
-That method must return a tuple (return_code::LibSCIP.SCIP_RETCODE, result::SCIP.LibSCIP.SCIP_RESULT).
+That method must return a tuple (return_code::SCIP_RETCODE, result::SCIP_RESULT).
 If no branching was performed, use `SCIP_DIDNOTRUN` as a result to pass on to the following branching rule.
 
 `type` is the `BranchingType` to branch on, i.e. on LP solution, pseudo-solution or external candidate.
@@ -53,7 +53,7 @@
     allow_additional_constraints,
     type::BranchingType,
 )
-    return (LibSCIP.SCIP_OKAY, LibSCIP.SCIP_DIDNOTRUN)
+    return (SCIP_OKAY, SCIP_DIDNOTRUN)
 end
 
 """
@@ -104,7 +104,7 @@
 end
 
 function branch_on_candidate!(scip, var)
-    @SCIP_CALL LibSCIP.SCIPbranchVar(scip, var, C_NULL, C_NULL, C_NULL)
+    @SCIP_CALL SCIPbranchVar(scip, var, C_NULL, C_NULL, C_NULL)
     return nothing
 end
 

src/convenience.jl

@@ -10,7 +10,7 @@ Recover Julia object which is attached to user constraint (via constraint data).
 """
 function user_constraint(cons_::Ptr{SCIP_CONS})
     @assert cons_ != C_NULL
-    consdata_::Ptr{SCIP.SCIP_CONSDATA} = SCIPconsGetData(cons_)
+    consdata_::Ptr{SCIP_CONSDATA} = SCIPconsGetData(cons_)
     return unsafe_pointer_to_objref(consdata_)
 end
 

src/cut_selector.jl

@@ -48,7 +48,7 @@ function _select_cut_callback(
     @assert length(cuts) == ncuts
     forced_cuts = unsafe_wrap(Vector{Ptr{SCIP_ROW}}, forced_cuts_, nforced_cuts)
     @assert length(forced_cuts) == nforced_cuts
-    root = root_ == SCIP.TRUE
+    root = root_ == TRUE
     (retcode, nselectedcuts, result) = select_cuts(
         cutsel,
         scip,
@@ -260,7 +260,7 @@ function select_cuts(
     nselected_cuts = Ref{Cint}(-1)
     maxparalellism = root ? cutsel.max_parallelism_root : cutsel.max_parallelism
     max_good_parallelism = max(maxparalellism, 0.5)
-    retcode = LibSCIP.SCIPselectCutsHybrid(
+    retcode = SCIPselectCutsHybrid(
         scip,
         cuts,
         forced_cuts,

src/event_handler.jl

@@ -85,19 +85,19 @@ function _eventexit(
     return SCIP_OKAY
 end
 """
-    include_event_handler(scipd::SCIP.SCIPData, event_handler::EVENTHDLR; name="", desc="")
+    include_event_handler(scipd::SCIPData, event_handler::EVENTHDLR; name="", desc="")
 
 Include the event handler in SCIP. WARNING! In contrast to the separator wrapper you only need to
 pass the SCIPData rather than the SCIP pointer and dictionary.
 
 # Arguments
-- scipd::SCIP.SCIPData: The SCIPData object
+- scipd::SCIPData: The SCIPData object
 - event_handler::EVENTHDLR: The event handler object
 - name::String: The name of the event handler
 - desc::String: The description of the event handler
 """
 function include_event_handler(
-    scipd::SCIP.SCIPData,
+    scipd::SCIPData,
     event_handler::EVENTHDLR;
     name="",
     desc="",
@@ -135,14 +135,14 @@ function include_event_handler(
 end
 
 """
-    catch_event(scipd::SCIP.SCIPData, eventtype::SCIP_EVENTTYPE, eventhdlr::EVENTHDLR)
+    catch_event(scipd::SCIPData, eventtype::SCIP_EVENTTYPE, eventhdlr::EVENTHDLR)
 
 Catch an event in SCIP. This function is a wrapper around the SCIPcatchEvent function.
 Warning! This function should only be called after the SCIP has been transformed.
 Use this instead of calling SCIPcatchEvent directly.
 """
 function catch_event(
-    scipd::SCIP.SCIPData,
+    scipd::SCIPData,
     eventtype::SCIP_EVENTTYPE,
     eventhdlr::EVENTHDLR,
 ) where {EVENTHDLR<:AbstractEventhdlr}
@@ -153,14 +153,14 @@ function catch_event(
 end
 
 """
-    drop_event(scipd::SCIP.SCIPData, eventtype::SCIP_EVENTTYPE, eventhdlr::EVENTHDLR)
+    drop_event(scipd::SCIPData, eventtype::SCIP_EVENTTYPE, eventhdlr::EVENTHDLR)
 
 Drop an event in SCIP. This function is a wrapper around the SCIPdropEvent function.
 Warning! This function should only be called after the SCIP has been transformed.
 Use this instead of calling SCIPdropEvent directly.
 """
 function drop_event(
-    scipd::SCIP.SCIPData,
+    scipd::SCIPData,
     eventtype::SCIP_EVENTTYPE,
     eventhdlr::EVENTHDLR,
 ) where {EVENTHDLR<:AbstractEventhdlr}

src/heuristic.jl

@@ -39,7 +39,7 @@ function _find_primal_solution_callback(
 )
     heurdata::Ptr{SCIP_HEURDATA} = SCIPheurGetData(heur_)
     heur = unsafe_pointer_to_objref(heurdata)
-    nodeinfeasible = nodeinfeasible_ == SCIP.TRUE
+    nodeinfeasible = nodeinfeasible_ == TRUE
     (retcode, result) = find_primal_solution(
         scip,
         heur,

src/scip_data.jl

@@ -66,7 +66,7 @@ mutable struct SCIPData
         @SCIP_CALL SCIPcreate(scip)
         @assert scip[] != C_NULL
         @SCIP_CALL SCIPincludeDefaultPlugins(scip[])
-        @SCIP_CALL SCIP.SCIPcreateProbBasic(scip[], "")
+        @SCIP_CALL SCIPcreateProbBasic(scip[], "")
         scip_data = new(
             scip,
             Dict{VarRef,Ref{Ptr{SCIP_VAR}}}(),