1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* 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