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