Scippy

SCIP

Solving Constraint Integer Programs

struct_lp.h
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (C) 2002-2014 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not email to scip@zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file struct_lp.h
17  * @brief datastructures for LP management
18  * @author Tobias Achterberg
19  *
20  * In SCIP, the LP is defined as follows:
21  *
22  * min obj * x
23  * lhs <= A * x + const <= rhs
24  * lb <= x <= ub
25  *
26  * The row activities are defined as activity = A * x + const and must
27  * therefore be in the range of [lhs,rhs].
28  *
29  * Mathematically, each range constraint would account for two dual
30  * variables, one for each inequality. Since in an optimal solution (at
31  * least) one of them may be chosen to be zero, we may define one dual
32  * multiplier for each row as the difference of those two.
33  *
34  * Let y be the vector of dual multipliers for the rows, then the reduced
35  * costs are defined as
36  *
37  * redcost = obj - A^T * y.
38  *
39  * In an optimal solution, y must be
40  *
41  * - nonnegative, if the corresponding row activity is not tight at its rhs
42  * - nonpositive, if the corresponding row activity is not tight at its lhs
43  * - zero, if the corresponding row activity is not at any of its sides
44  *
45  * and the reduced costs must be
46  *
47  * - nonnegative, if the corresponding variable is not tight at its ub
48  * - nonpositive, if the corresponding variable is not tight at its lb
49  * - zero, if the corresponding variable is not at any of its bounds.
50  *
51  * The main datastructures for storing an LP are the rows and the columns.
52  * A row can live on its own (if it was created by a separator), or as SCIP_LP
53  * relaxation of a constraint. Thus, it has a nuses-counter, and is
54  * deleted, if not needed any more.
55  * A column cannot live on its own. It is always connected to a problem
56  * variable. Because pricing is always problem specific, it cannot create
57  * LP columns without introducing new variables. Thus, each column is
58  * connected to exactly one variable, and is deleted, if the variable
59  * is deleted.
60  */
61 
62 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
63 
64 #ifndef __SCIP_STRUCT_LP_H__
65 #define __SCIP_STRUCT_LP_H__
66 
67 
68 #include "scip/def.h"
69 #include "scip/type_lp.h"
70 #include "scip/type_var.h"
71 #include "scip/type_event.h"
72 #include "lpi/type_lpi.h"
73 
74 #ifdef __cplusplus
75 extern "C" {
76 #endif
77 
78 /** collected values of a column which depend on the LP solution
79  * We store these values in each column to recover the LP solution at start of diving or probing mode, say, without
80  * having to resolve the LP. Note that we do not store the farkascoef value since we do expect a node with infeasible
81  * LP to be pruned anyway.
82  */
83 struct SCIP_ColSolVals
84 {
85  SCIP_Real primsol; /**< primal solution value in LP, is 0 if col is not in LP */
86  SCIP_Real redcost; /**< reduced cost value in LP, or SCIP_INVALID if not yet calculated */
87  unsigned int basisstatus:2; /**< basis status of column in last LP solution, invalid for non-LP columns */
88 };
89 
90 /** collected values of a row which depend on the LP solution
91  * We store these values in each row to recover the LP solution at start of diving or probing mode, say, without having
92  * to resolve the LP. We do not store the dualfarkas value since we expect a node with infeasible LP to be pruned
93  * anyway. In this unlikely case, we have to resolve the LP.
94  */
95 struct SCIP_RowSolVals
96 {
97  SCIP_Real dualsol; /**< dual solution value in LP, is 0 if row is not in LP */
98  SCIP_Real activity; /**< row activity value in LP, or SCIP_INVALID if not yet calculated */
99  unsigned int basisstatus:2; /**< basis status of row in last LP solution, invalid for non-LP rows */
100 };
101 
102 /** collected values of the LP data which depend on the LP solution
103  * We store these values to recover the LP solution at start of diving or probing mode, say, without having to resolve
104  * the LP.
105  */
106 struct SCIP_LpSolVals
107 {
108  SCIP_LPSOLSTAT lpsolstat; /**< solution status of last LP solution */
109  SCIP_Real lpobjval; /**< objective value of LP without loose variables, or SCIP_INVALID */
110  SCIP_Bool primalfeasible; /**< is current LP solution primal feasible? */
111  SCIP_Bool dualfeasible; /**< is current LP solution dual feasible? */
112  SCIP_Bool solisbasic; /**< is current LP solution a basic solution? */
113  SCIP_Bool lpissolved; /**< is current LP solved? */
114 };
115 
116 /** LP column;
117  * The row vector of the LP column is partitioned into two parts: The first col->nlprows rows in the rows array
118  * are the ones that belong to the current LP (col->rows[j]->lppos >= 0) and that are linked to the column
119  * (col->linkpos[j] >= 0). The remaining col->len - col->nlprows rows in the rows array are the ones that
120  * don't belong to the current LP (col->rows[j]->lppos == -1) or that are not linked to the column
121  * (col->linkpos[j] == -1).
122  */
123 struct SCIP_Col
124 {
125  SCIP_Real obj; /**< current objective value of column in LP */
126  SCIP_Real lb; /**< current lower bound of column in LP */
127  SCIP_Real ub; /**< current upper bound of column in LP */
128  SCIP_Real lazylb; /**< lazy lower bound of the column; if the current lower bound is not greater than
129  * the lazy lower bound, then the lower bound has not to be added to the LP */
130  SCIP_Real lazyub; /**< lazy upper bound of the column; if the current upper bound is not smaller than
131  * the lazy upper bound, then the upper bound has not to be added to the LP */
132  SCIP_Real flushedobj; /**< objective value of column already flushed to the LP solver */
133  SCIP_Real flushedlb; /**< lower bound of column already flushed to the LP solver */
134  SCIP_Real flushedub; /**< upper bound of column already flushed to the LP solver */
135  SCIP_Real primsol; /**< primal solution value in LP, is 0 if col is not in LP */
136  SCIP_Real redcost; /**< reduced cost value in LP, or SCIP_INVALID if not yet calculated */
137  SCIP_Real farkascoef; /**< coefficient in dual Farkas infeasibility proof (== dualfarkas^T A_c) */
138  SCIP_Real minprimsol; /**< minimal LP solution value, this column ever assumed */
139  SCIP_Real maxprimsol; /**< maximal LP solution value, this column ever assumed */
140  SCIP_Real sbdown; /**< strong branching information for downwards branching */
141  SCIP_Real sbup; /**< strong branching information for upwards branching */
142  SCIP_Real sbsolval; /**< LP solution value of column at last strong branching call */
143  SCIP_Real sblpobjval; /**< LP objective value at last strong branching call on the column */
144  SCIP_Longint sbnode; /**< node number of the last strong branching call on this column */
145  SCIP_Longint obsoletenode; /**< last node where this column was removed due to aging */
146  SCIP_COLSOLVALS* storedsolvals; /**< values stored before entering diving or probing mode */
147  SCIP_VAR* var; /**< variable, this column represents; there cannot be a column without variable */
148  SCIP_ROW** rows; /**< rows of column entries, that may have a nonzero dual solution value */
149  SCIP_Real* vals; /**< coefficients of column entries */
150  SCIP_Longint validredcostlp; /**< LP number for which reduced cost value is valid */
151  SCIP_Longint validfarkaslp; /**< LP number for which Farkas coefficient is valid */
152  SCIP_Longint validsblp; /**< LP number for which strong branching values are valid */
153  int* linkpos; /**< position of col in col vector of the row, or -1 if not yet linked */
154  int index; /**< consecutively numbered column identifier */
155  int size; /**< size of the row- and val-arrays */
156  int len; /**< number of nonzeros in column */
157  int nlprows; /**< number of linked rows in column, that belong to the current LP */
158  int nunlinked; /**< number of column entries, where the rows don't know about the column */
159  int lppos; /**< column position number in current LP, or -1 if not in current LP */
160  int lpipos; /**< column position number in LP solver, or -1 if not in LP solver */
161  int lpdepth; /**< depth level at which column entered the LP, or -1 if not in current LP */
162  int sbitlim; /**< strong branching iteration limit used to get strong branching values, or -1 */
163  int nsbcalls; /**< number of times, strong branching was applied on the column */
164  int age; /**< number of successive times this variable was in LP and was 0.0 in solution */
165  int var_probindex; /**< copy of var->probindex for avoiding expensive dereferencing */
166  unsigned int basisstatus:2; /**< basis status of column in last LP solution, invalid for non-LP columns */
167  unsigned int lprowssorted:1; /**< are the linked LP rows in the rows array sorted by non-decreasing index? */
168  unsigned int nonlprowssorted:1; /**< are the non-LP/not linked rows sorted by non-decreasing index? */
169  unsigned int objchanged:1; /**< has objective value changed, and has data of LP solver to be updated? */
170  unsigned int lbchanged:1; /**< has lower bound changed, and has data of LP solver to be updated? */
171  unsigned int ubchanged:1; /**< has upper bound changed, and has data of LP solver to be updated? */
172  unsigned int coefchanged:1; /**< has the coefficient vector changed, and has LP solver to be updated? */
173  unsigned int integral:1; /**< is associated variable of integral type? */
174  unsigned int removable:1; /**< is column removable from the LP (due to aging or cleanup)? */
175  unsigned int sbdownvalid:1; /**< stores whether the stored strong branching down value is a valid dual bound;
176  * otherwise, it can only be used as an estimate value */
177  unsigned int sbupvalid:1; /**< stores whether the stored strong branching up value is a valid dual bound;
178  * otherwise, it can only be used as an estimate value */
179 };
180 
181 /** LP row
182  * The column vector of the LP row is partitioned into two parts: The first row->nlpcols columns in the cols array
183  * are the ones that belong to the current LP (row->cols[j]->lppos >= 0) and that are linked to the row
184  * (row->linkpos[j] >= 0). The remaining row->len - row->nlpcols columns in the cols array are the ones that
185  * don't belong to the current LP (row->cols[j]->lppos == -1) or that are not linked to the row
186  * (row->linkpos[j] == -1).
187  */
188 struct SCIP_Row
189 {
190  SCIP_Real constant; /**< constant shift c in row lhs <= ax + c <= rhs */
191  SCIP_Real lhs; /**< left hand side of row */
192  SCIP_Real rhs; /**< right hand side of row */
193  SCIP_Real flushedlhs; /**< left hand side minus constant of row already flushed to the LP solver */
194  SCIP_Real flushedrhs; /**< right hand side minus constant of row already flushed to the LP solver */
195  SCIP_Real sqrnorm; /**< squared Euclidean norm of row vector */
196  SCIP_Real sumnorm; /**< sum norm of row vector (sum of absolute values of coefficients) */
197  SCIP_Real objprod; /**< scalar product of row vector with objective function */
198  SCIP_Real maxval; /**< maximal absolute value of row vector, only valid if nummaxval > 0 */
199  SCIP_Real minval; /**< minimal absolute non-zero value of row vector, only valid if numminval > 0 */
200  SCIP_Real dualsol; /**< dual solution value in LP, is 0 if row is not in LP */
201  SCIP_Real activity; /**< row activity value in LP, or SCIP_INVALID if not yet calculated */
202  SCIP_Real dualfarkas; /**< multiplier value in dual Farkas infeasibility proof */
203  SCIP_Real pseudoactivity; /**< row activity value in pseudo solution, or SCIP_INVALID if not yet calculated */
204  SCIP_Real minactivity; /**< minimal activity value w.r.t. the column's bounds, or SCIP_INVALID */
205  SCIP_Real maxactivity; /**< maximal activity value w.r.t. the column's bounds, or SCIP_INVALID */
206  SCIP_Longint validpsactivitydomchg; /**< domain change number for which pseudo activity value is valid */
207  SCIP_Longint validactivitybdsdomchg;/**< domain change number for which activity bound values are valid */
208  SCIP_Longint obsoletenode; /**< last node where this row was removed due to aging */
209  SCIP_ROWSOLVALS* storedsolvals; /**< values stored before entering diving or probing mode */
210  void* origin; /**< pointer to constraint handler or separator who created the row (NULL if unkown) */
211  char* name; /**< name of the row */
212  SCIP_COL** cols; /**< columns of row entries, that may have a nonzero primal solution value */
213  int* cols_index; /**< copy of cols[i]->index for avoiding expensive dereferencing */
214  SCIP_Real* vals; /**< coefficients of row entries */
215  int* linkpos; /**< position of row in row vector of the column, or -1 if not yet linked */
216  SCIP_EVENTFILTER* eventfilter; /**< event filter for events concerning this row */
217  SCIP_Longint validactivitylp; /**< LP number for which activity value is valid */
218  int index; /**< consecutively numbered row identifier */
219  int size; /**< size of the col- and val-arrays */
220  int len; /**< number of nonzeros in row */
221  int nlpcols; /**< number of linked columns in row, that belong to the current LP */
222  int nunlinked; /**< number of row entries, where the columns don't know about the row */
223  int nuses; /**< number of times, this row is referenced */
224  int lppos; /**< row position number in current LP, or -1 if not in current LP */
225  int lpipos; /**< row position number in LP solver, or -1 if not in LP solver */
226  int lpdepth; /**< depth level at which row entered the LP, or -1 if not in current LP */
227  int minidx; /**< minimal column index of row entries */
228  int maxidx; /**< maximal column index of row entries */
229  int nummaxval; /**< number of coefs with absolute value equal to maxval, zero if maxval invalid */
230  int numminval; /**< number of coefs with absolute value equal to minval, zero if minval invalid */
231  int age; /**< number of successive times this row was in LP and was not sharp in solution */
232  int rank; /**< rank of the row (upper bound, to be precise) */
233  unsigned int basisstatus:2; /**< basis status of row in last LP solution, invalid for non-LP rows */
234  unsigned int lpcolssorted:1; /**< are the linked LP columns in the cols array sorted by non-decreasing index? */
235  unsigned int nonlpcolssorted:1; /**< are the non-LP/not linked columns sorted by non-decreasing index? */
236  unsigned int delaysort:1; /**< should the row sorting be delayed and done in a lazy fashion? */
237  unsigned int validminmaxidx:1; /**< are minimal and maximal column index valid? */
238  unsigned int lhschanged:1; /**< was left hand side or constant changed, and has LP solver to be updated? */
239  unsigned int rhschanged:1; /**< was right hand side or constant changed, and has LP solver to be updated? */
240  unsigned int coefchanged:1; /**< was the coefficient vector changed, and has LP solver to be updated? */
241  unsigned int integral:1; /**< is activity (without constant) of row always integral in feasible solution? */
242  unsigned int local:1; /**< is row only valid locally? */
243  unsigned int modifiable:1; /**< is row modifiable during node processing (subject to column generation)? */
244  unsigned int removable:1; /**< is row removable from the LP (due to aging or cleanup)? */
245  unsigned int inglobalcutpool:1; /**< is row contained in the global cut pool? */
246  unsigned int nlocks:16; /**< number of sealed locks of an unmodifiable row */
247  unsigned int origintype:2; /**< origin of row (0: unkown, 1: constraint handler, 2: separator) */
248 };
249 
250 /** current LP data */
251 struct SCIP_Lp
252 {
253  SCIP_Real lpobjval; /**< objective value of LP without loose variables, or SCIP_INVALID */
254  SCIP_Real looseobjval; /**< current solution value of all loose variables set to their best bounds,
255  * ignoring variables, with infinite best bound */
256  SCIP_Real rellooseobjval; /**< last reliable solution value of all loose variables set to their best bounds,
257  * ignoring variables, with infinite best bound */
258  SCIP_Real glbpseudoobjval; /**< global pseudo solution value with all variables set to their best global bounds,
259  * ignoring variables, with infinite best bound */
260  SCIP_Real relglbpseudoobjval; /**< last reliable global pseudo solution value */
261  SCIP_Real pseudoobjval; /**< current pseudo solution value with all variables set to their best bounds,
262  * ignoring variables, with infinite best bound */
263  SCIP_Real relpseudoobjval; /**< last reliable pseudo solution value */
264  SCIP_Real rootlpobjval; /**< objective value of root LP without loose variables, or SCIP_INVALID */
265  SCIP_Real rootlooseobjval; /**< objective value of loose variables in root node, or SCIP_INVALID */
266  SCIP_Real cutoffbound; /**< upper objective limit of LP (copy of primal->cutoffbound) */
267  SCIP_Real lpiuobjlim; /**< current upper objective limit in LPI */
268  SCIP_Real lpifeastol; /**< current feasibility tolerance in LPI */
269  SCIP_Real lpidualfeastol; /**< current reduced costs feasibility tolerance in LPI */
270  SCIP_Real lpibarrierconvtol; /**< current convergence tolerance used in barrier algorithm in LPI */
271  SCIP_Real lpiconditionlimit; /**< current condition number limit in LPI */
272  SCIP_Real objsqrnorm; /**< squared Euclidean norm of objective function vector of problem variables */
273  SCIP_Real objsumnorm; /**< sum norm of objective function vector of problem variables */
274  SCIP_LPI* lpi; /**< LP solver interface */
275  SCIP_COL** lpicols; /**< array with columns currently stored in the LP solver */
276  SCIP_ROW** lpirows; /**< array with rows currently stored in the LP solver */
277  SCIP_COL** chgcols; /**< array of changed columns not yet applied to the LP solver */
278  SCIP_ROW** chgrows; /**< array of changed rows not yet applied to the LP solver */
279  SCIP_COL** cols; /**< array with current LP columns in correct order */
280  SCIP_COL** lazycols; /**< array with current LP lazy columns */
281  SCIP_ROW** rows; /**< array with current LP rows in correct order */
282  SCIP_LPISTATE* divelpistate; /**< stores LPI state (basis information) before diving starts */
283  SCIP_Real* divechgsides; /**< stores the lhs/rhs changed in the current diving */
284  SCIP_SIDETYPE* divechgsidetypes; /**< stores the side type of the changes done in the current diving */
285  SCIP_ROW** divechgrows; /**< stores the rows changed in the current diving */
286  SCIP_LPSOLVALS* storedsolvals; /**< collected values of the LP data which depend on the LP solution */
287  SCIP_Longint validsollp; /**< LP number for which the currently stored solution values are valid */
288  SCIP_Longint validfarkaslp; /**< LP number for which the currently stored Farkas row multipliers are valid */
289  int lpicolssize; /**< available slots in lpicols vector */
290  int nlpicols; /**< number of columns in the LP solver */
291  int lpifirstchgcol; /**< first column of the LP which differs from the column in the LP solver */
292  int lpirowssize; /**< available slots in lpirows vector */
293  int nlpirows; /**< number of rows in the LP solver */
294  int lpifirstchgrow; /**< first row of the LP which differs from the row in the LP solver */
295  int chgcolssize; /**< available slots in chgcols vector */
296  int nchgcols; /**< current number of chgcols (number of used slots in chgcols vector) */
297  int chgrowssize; /**< available slots in chgrows vector */
298  int nchgrows; /**< current number of chgrows (number of used slots in chgrows vector) */
299  int colssize; /**< available slots in cols vector */
300  int ncols; /**< current number of LP columns (number of used slots in cols vector) */
301  int lazycolssize; /**< available slots in lazycols vector */
302  int nlazycols; /**< current number of LP lazy columns (number of used slots in lazycols vector) */
303  int nremovablecols; /**< number of removable columns in the LP */
304  int firstnewcol; /**< first column added at the current node */
305  int rowssize; /**< available slots in rows vector */
306  int nrows; /**< current number of LP rows (number of used slots in rows vector) */
307  int nremovablerows; /**< number of removable rows in the LP */
308  int firstnewrow; /**< first row added at the current node */
309  int looseobjvalinf; /**< number of loose variables with infinite best bound in current solution */
310  int nloosevars; /**< number of loose variables in LP */
311  int glbpseudoobjvalinf; /**< number of variables with infinite best bound in global pseudo solution */
312  int pseudoobjvalinf; /**< number of variables with infinite best bound in current pseudo solution */
313  int ndivingrows; /**< number of rows when entering diving mode */
314  int ndivechgsides; /**< number of side changes in current diving */
315  int divechgsidessize; /**< size of the arrays */
316  int divinglpiitlim; /**< LPI iteration limit when entering diving mode */
317  int lpiitlim; /**< current iteration limit setting in LPI */
318  int lpifastmip; /**< current FASTMIP setting in LPI */
319  int lpithreads; /**< current THREADS setting in LPI */
320  SCIP_PRICING lpipricing; /**< current pricing setting in LPI */
321  SCIP_LPSOLSTAT lpsolstat; /**< solution status of last LP solution */
322  SCIP_LPALGO lastlpalgo; /**< algorithm used for last LP solve */
323  SCIP_Bool objsqrnormunreliable;/**< is squared Euclidean norm of objective function vector of problem
324  * variables unreliable and need recalculation? */
325  SCIP_Bool looseobjvalid; /**< is the loose objective value valid or should it be recomputed from scratch? */
326  SCIP_Bool glbpseudoobjvalid; /**< is the global pseudo solution value valid or should it be recomputed from scratch? */
327  SCIP_Bool pseudoobjvalid; /**< is the pseudo solution value valid or should it be recomputed from scratch? */
328  SCIP_Bool flushdeletedcols; /**< have LPI-columns been deleted in the last lpFlush() call? */
329  SCIP_Bool flushaddedcols; /**< have LPI-columns been added in the last lpFlush() call? */
330  SCIP_Bool flushdeletedrows; /**< have LPI-rows been deleted in the last lpFlush() call? */
331  SCIP_Bool flushaddedrows; /**< have LPI-rows been added in the last lpFlush() call? */
332  SCIP_Bool flushed; /**< are all cached changes applied to the LP solver? */
333  SCIP_Bool solved; /**< is current LP solved? */
334  SCIP_Bool primalfeasible; /**< is current LP solution (rather LPI state) primal feasible? */
335  SCIP_Bool dualfeasible; /**< is current LP solution (rather LPI state) dual feasible? */
336  SCIP_Bool solisbasic; /**< is current LP solution a basic solution? */
337  SCIP_Bool rootlpisrelax; /**< is root LP a relaxation of the problem and its solution value a valid global lower bound? */
338  SCIP_Bool isrelax; /**< is the current LP a relaxation of the problem for which it has been solved and its
339  * solution value a valid local lower bound? */
340  SCIP_Bool installing; /**< whether the solution process is in stalling */
341  SCIP_Bool strongbranching; /**< whether the lp is used for strong branching */
342  SCIP_Bool probing; /**< are we currently in probing mode? */
343  SCIP_Bool strongbranchprobing;/**< are we currently in probing mode for strong branching? */
344  SCIP_Bool diving; /**< LP is used for diving: col bounds and obj don't correspond to variables */
345  SCIP_Bool divingobjchg; /**< objective values were changed in diving: LP objective is invalid */
346  SCIP_Bool divinglazyapplied; /**< lazy bounds were applied to the LP during diving */
347  SCIP_Bool resolvelperror; /**< an error occured during resolving the LP after diving or probing */
348  SCIP_Bool lpifromscratch; /**< current FROMSCRATCH setting in LPI */
349  SCIP_Bool lpiscaling; /**< current SCALING setting in LPI */
350  SCIP_Bool lpipresolving; /**< current PRESOLVING setting in LPI */
351  SCIP_Bool lpilpinfo; /**< current LPINFO setting in LPI */
352  SCIP_Bool lpihasfeastol; /**< does the LPI support the FEASTOL parameter? */
353  SCIP_Bool lpihasdualfeastol; /**< does the LPI support the DUALFEASTOL parameter? */
354  SCIP_Bool lpihasbarrierconvtol;/**< does the LPI support the BARRIERCONVTOL parameter? */
355  SCIP_Bool lpihasfastmip; /**< does the LPI support the FASTMIP parameter? */
356  SCIP_Bool lpihasscaling; /**< does the LPI support the SCALING parameter? */
357  SCIP_Bool lpihaspresolving; /**< does the LPI support the PRESOLVING parameter? */
358  SCIP_Bool lpihasrowrep; /**< does the LPI support row representation of a simplex basis? */
359  SCIP_Real lpirowrepswitch; /**< simplex algorithm shall use row representation of the basis
360  * if number of rows divided by number of columns exceeds this value */
361  SCIP_Bool divelpwasprimfeas; /**< primal feasibility when diving started */
362  SCIP_Bool divelpwasdualfeas; /**< dual feasibility when diving started */
363 };
364 
365 #ifdef __cplusplus
366 }
367 #endif
368 
369 #endif
370