/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* This file is part of the program and library */ /* SCIP --- Solving Constraint Integer Programs */ /* */ /* Copyright 2002-2022 Zuse Institute Berlin */ /* */ /* Licensed under the Apache License, Version 2.0 (the "License"); */ /* you may not use this file except in compliance with the License. */ /* You may obtain a copy of the License at */ /* */ /* http://www.apache.org/licenses/LICENSE-2.0 */ /* */ /* Unless required by applicable law or agreed to in writing, software */ /* distributed under the License is distributed on an "AS IS" BASIS, */ /* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */ /* See the License for the specific language governing permissions and */ /* limitations under the License. */ /* */ /* You should have received a copy of the Apache-2.0 license */ /* along with SCIP; see the file LICENSE. If not visit scipopt.org. */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /**@file solve.h * @ingroup INTERNALAPI * @brief internal methods for main solving loop and node processing * @author Tobias Achterberg */ /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/ #ifndef __SCIP_SOLVE_H__ #define __SCIP_SOLVE_H__ #include "blockmemshell/memory.h" #include "scip/def.h" #include "scip/type_conflict.h" #include "scip/type_conflictstore.h" #include "scip/type_cutpool.h" #include "scip/type_event.h" #include "scip/type_lp.h" #include "scip/type_mem.h" #include "scip/type_message.h" #include "scip/type_pricestore.h" #include "scip/type_primal.h" #include "scip/type_prob.h" #include "scip/type_reopt.h" #include "scip/type_retcode.h" #include "scip/type_sepastore.h" #include "scip/type_set.h" #include "scip/type_stat.h" #include "scip/type_tree.h" #ifdef __cplusplus extern "C" { #endif /** returns whether the solving process will be / was stopped before proving optimality; * if the solving process was stopped, stores the reason as status in stat */ SCIP_EXPORT SCIP_Bool SCIPsolveIsStopped( SCIP_SET* set, /**< global SCIP settings */ SCIP_STAT* stat, /**< dynamic problem statistics */ SCIP_Bool checknodelimits /**< should the node limits be involved in the check? */ ); /** applies domain propagation on current node and flushes the conflict store afterwards */ SCIP_RETCODE SCIPpropagateDomains( BMS_BLKMEM* blkmem, /**< block memory buffers */ SCIP_SET* set, /**< global SCIP settings */ SCIP_STAT* stat, /**< dynamic problem statistics */ SCIP_PROB* transprob, /**< transformed problem */ SCIP_PROB* origprob, /**< original problem */ SCIP_TREE* tree, /**< branch and bound tree */ SCIP_REOPT* reopt, /**< reoptimization data structure */ SCIP_LP* lp, /**< LP data */ SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */ SCIP_EVENTQUEUE* eventqueue, /**< event queue */ SCIP_CONFLICT* conflict, /**< conflict analysis data */ SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */ int depth, /**< depth level to use for propagator frequency checks */ int maxrounds, /**< maximal number of propagation rounds (-1: no limit, 0: parameter settings) */ SCIP_PROPTIMING timingmask, /**< timing mask to decide which propagators are executed */ SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */ ); /** puts all constraints with initial flag TRUE into the LP */ SCIP_RETCODE SCIPinitConssLP( BMS_BLKMEM* blkmem, /**< block memory buffers */ SCIP_SET* set, /**< global SCIP settings */ SCIP_SEPASTORE* sepastore, /**< separation storage */ SCIP_CUTPOOL* cutpool, /**< global cutpool */ SCIP_STAT* stat, /**< dynamic problem statistics */ SCIP_PROB* transprob, /**< transformed problem */ SCIP_PROB* origprob, /**< original problem */ SCIP_TREE* tree, /**< branch and bound tree */ SCIP_REOPT* reopt, /**< reoptimization data structure */ SCIP_LP* lp, /**< LP data */ SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */ SCIP_EVENTQUEUE* eventqueue, /**< event queue */ SCIP_EVENTFILTER* eventfilter, /**< global event filter */ SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */ SCIP_Bool root, /**< is this the initial root LP? */ SCIP_Bool firstsubtreeinit, /**< is this the first call in the current subtree after jumping through the tree? */ SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */ ); /** constructs the LP of the current node, but does not load the LP state and warmstart information */ SCIP_RETCODE SCIPconstructCurrentLP( BMS_BLKMEM* blkmem, /**< block memory buffers */ SCIP_SET* set, /**< global SCIP settings */ SCIP_STAT* stat, /**< dynamic problem statistics */ SCIP_PROB* transprob, /**< transformed problem */ SCIP_PROB* origprob, /**< original problem */ SCIP_TREE* tree, /**< branch and bound tree */ SCIP_REOPT* reopt, /**< reoptimization data structure */ SCIP_LP* lp, /**< LP data */ SCIP_PRICESTORE* pricestore, /**< pricing storage */ SCIP_SEPASTORE* sepastore, /**< separation storage */ SCIP_CUTPOOL* cutpool, /**< global cutpool */ SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */ SCIP_EVENTQUEUE* eventqueue, /**< event queue */ SCIP_EVENTFILTER* eventfilter, /**< global event filter */ SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */ SCIP_Bool newinitconss, /**< do we have to add new initial constraints? */ SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */ ); /** calls primal heuristics */ SCIP_RETCODE SCIPprimalHeuristics( SCIP_SET* set, /**< global SCIP settings */ SCIP_STAT* stat, /**< dynamic problem statistics */ SCIP_PROB* prob, /**< transformed problem after presolve */ SCIP_PRIMAL* primal, /**< primal data */ SCIP_TREE* tree, /**< branch and bound tree */ SCIP_LP* lp, /**< LP data */ SCIP_NODE* nextnode, /**< next node that will be processed, or NULL if no more nodes left * (only needed when calling after node heuristics) */ SCIP_HEURTIMING heurtiming, /**< current point in the node solving process */ SCIP_Bool nodeinfeasible, /**< was the current node already detected to be infeasible? */ SCIP_Bool* foundsol, /**< pointer to store whether a solution has been found */ SCIP_Bool* unbounded /**< pointer to store whether an unbounded ray was found in the LP */ ); /** applies one round of separation on the given primal solution or on the LP solution */ SCIP_RETCODE SCIPseparationRound( BMS_BLKMEM* blkmem, /**< block memory buffers */ SCIP_SET* set, /**< global SCIP settings */ SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ SCIP_STAT* stat, /**< dynamic problem statistics */ SCIP_EVENTQUEUE* eventqueue, /**< event queue */ SCIP_EVENTFILTER* eventfilter, /**< global event filter */ SCIP_PROB* prob, /**< transformed problem after presolve */ SCIP_PRIMAL* primal, /**< primal data */ SCIP_TREE* tree, /**< branch and bound tree */ SCIP_LP* lp, /**< LP data */ SCIP_SEPASTORE* sepastore, /**< separation storage */ SCIP_SOL* sol, /**< primal solution that should be separated, or NULL for LP solution */ int actdepth, /**< current depth in the tree */ SCIP_Bool allowlocal, /**< should the separator be asked to separate local cuts */ SCIP_Bool onlydelayed, /**< should only delayed separators be called? */ SCIP_Bool* delayed, /**< pointer to store whether a separator was delayed */ SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */ ); /** solves the current LP completely with pricing in new variables */ SCIP_RETCODE SCIPpriceLoop( BMS_BLKMEM* blkmem, /**< block memory buffers */ SCIP_SET* set, /**< global SCIP settings */ SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ SCIP_STAT* stat, /**< dynamic problem statistics */ SCIP_PROB* transprob, /**< transformed problem */ SCIP_PROB* origprob, /**< original problem */ SCIP_PRIMAL* primal, /**< primal data */ SCIP_TREE* tree, /**< branch and bound tree */ SCIP_REOPT* reopt, /**< reoptimization data structure */ SCIP_LP* lp, /**< LP data */ SCIP_PRICESTORE* pricestore, /**< pricing storage */ SCIP_SEPASTORE* sepastore, /**< separation storage */ SCIP_CUTPOOL* cutpool, /**< global cutpool */ SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */ SCIP_EVENTQUEUE* eventqueue, /**< event queue */ SCIP_EVENTFILTER* eventfilter, /**< global event filter */ SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */ SCIP_Bool pretendroot, /**< should the pricers be called as if we are at the root node? */ SCIP_Bool displayinfo, /**< should info lines be displayed after each pricing round? */ int maxpricerounds, /**< maximal number of pricing rounds (-1: no limit); * a finite limit means that the LP might not be solved to optimality! */ int* npricedcolvars, /**< pointer to store number of column variables after problem vars were priced */ SCIP_Bool* mustsepa, /**< pointer to store TRUE if a separation round should follow */ SCIP_Bool* lperror, /**< pointer to store whether an unresolved error in LP solving occured */ SCIP_Bool* aborted /**< pointer to store whether the pricing was aborted and the lower bound must * not be used */ ); /** main solving loop */ SCIP_RETCODE SCIPsolveCIP( BMS_BLKMEM* blkmem, /**< block memory buffers */ SCIP_SET* set, /**< global SCIP settings */ SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ SCIP_STAT* stat, /**< dynamic problem statistics */ SCIP_MEM* mem, /**< block memory pools */ SCIP_PROB* origprob, /**< original problem */ SCIP_PROB* transprob, /**< transformed problem after presolve */ SCIP_PRIMAL* primal, /**< primal data */ SCIP_TREE* tree, /**< branch and bound tree */ SCIP_REOPT* reopt, /**< reoptimization data structure */ SCIP_LP* lp, /**< LP data */ SCIP_RELAXATION* relaxation, /**< global relaxation data */ SCIP_PRICESTORE* pricestore, /**< pricing storage */ SCIP_SEPASTORE* sepastore, /**< separation storage */ SCIP_CUTPOOL* cutpool, /**< global cut pool */ SCIP_CUTPOOL* delayedcutpool, /**< global delayed cut pool */ SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */ SCIP_CONFLICT* conflict, /**< conflict analysis data */ SCIP_CONFLICTSTORE* conflictstore, /**< conflict store */ SCIP_EVENTFILTER* eventfilter, /**< event filter for global (not variable dependent) events */ SCIP_EVENTQUEUE* eventqueue, /**< event queue */ SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */ SCIP_Bool* restart /**< should solving process be started again with presolving? */ ); #ifdef __cplusplus } #endif #endif