struct_lp.h
Go to the documentation of this file.
63 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
80 * We store these values in each column to recover the LP solution at start of diving or probing mode, say, without
81 * having to resolve the LP. Note that we do not store the farkascoef value since we do expect a node with infeasible
88 unsigned int basisstatus:2; /**< basis status of column in last LP solution, invalid for non-LP columns */
92 * We store these values in each row to recover the LP solution at start of diving or probing mode, say, without having
93 * to resolve the LP. We do not store the dualfarkas value since we expect a node with infeasible LP to be pruned
100 unsigned int basisstatus:2; /**< basis status of row in last LP solution, invalid for non-LP rows */
104 * We store these values to recover the LP solution at start of diving or probing mode, say, without having to resolve
120 * The row vector of the LP column is partitioned into two parts: The first col->nlprows rows in the rows array
121 * are the ones that belong to the current LP (col->rows[j]->lppos >= 0) and that are linked to the column
122 * (col->linkpos[j] >= 0). The remaining col->len - col->nlprows rows in the rows array are the ones that
123 * don't belong to the current LP (col->rows[j]->lppos == -1) or that are not linked to the column
128 SCIP_Real obj; /**< current objective value of column in LP (might be changed in diving or probing) */
131 SCIP_Real unchangedobj; /**< unchanged objective value of column (ignoring diving or probing changes) */
132 SCIP_Real lazylb; /**< lazy lower bound of the column; if the current lower bound is not greater than
134 SCIP_Real lazyub; /**< lazy upper bound of the column; if the current upper bound is not smaller than
141 SCIP_Real farkascoef; /**< coefficient in dual Farkas infeasibility proof (== dualfarkas^T A_c) */
151 SCIP_VAR* var; /**< variable, this column represents; there cannot be a column without variable */
166 int sbitlim; /**< strong branching iteration limit used to get strong branching values, or -1 */
170 unsigned int basisstatus:2; /**< basis status of column in last LP solution, invalid for non-LP columns */
171 unsigned int lprowssorted:1; /**< are the linked LP rows in the rows array sorted by non-decreasing index? */
172 unsigned int nonlprowssorted:1; /**< are the non-LP/not linked rows sorted by non-decreasing index? */
173 unsigned int objchanged:1; /**< has objective value changed, and has data of LP solver to be updated? */
174 unsigned int lbchanged:1; /**< has lower bound changed, and has data of LP solver to be updated? */
175 unsigned int ubchanged:1; /**< has upper bound changed, and has data of LP solver to be updated? */
176 unsigned int coefchanged:1; /**< has the coefficient vector changed, and has LP solver to be updated? */
179 unsigned int sbdownvalid:1; /**< stores whether the stored strong branching down value is a valid dual bound;
181 unsigned int sbupvalid:1; /**< stores whether the stored strong branching up value is a valid dual bound;
186 * The column vector of the LP row is partitioned into two parts: The first row->nlpcols columns in the cols array
187 * are the ones that belong to the current LP (row->cols[j]->lppos >= 0) and that are linked to the row
188 * (row->linkpos[j] >= 0). The remaining row->len - row->nlpcols columns in the cols array are the ones that
197 SCIP_Real flushedlhs; /**< left hand side minus constant of row already flushed to the LP solver */
198 SCIP_Real flushedrhs; /**< right hand side minus constant of row already flushed to the LP solver */
203 SCIP_Real minval; /**< minimal absolute non-zero value of row vector, only valid if numminval > 0 */
207 SCIP_Real pseudoactivity; /**< row activity value in pseudo solution, or SCIP_INVALID if not yet calculated */
208 SCIP_Real minactivity; /**< minimal activity value w.r.t. the column's bounds, or SCIP_INVALID */
209 SCIP_Real maxactivity; /**< maximal activity value w.r.t. the column's bounds, or SCIP_INVALID */
210 SCIP_Longint validpsactivitydomchg; /**< domain change number for which pseudo activity value is valid */
211 SCIP_Longint validactivitybdsdomchg;/**< domain change number for which activity bound values are valid */
213 SCIP_Longint activeinlpcounter; /**< counter for the number of times this row was active in an optimal LP solution */
214 SCIP_Longint nlpsaftercreation; /**< counter for the number of LPs after the row has been created */
216 void* origin; /**< pointer to constraint handler or separator who created the row (NULL if unknown) */
236 int nummaxval; /**< number of coefs with absolute value equal to maxval, zero if maxval invalid */
237 int numminval; /**< number of coefs with absolute value equal to minval, zero if minval invalid */
240 unsigned int basisstatus:2; /**< basis status of row in last LP solution, invalid for non-LP rows */
241 unsigned int lpcolssorted:1; /**< are the linked LP columns in the cols array sorted by non-decreasing index? */
242 unsigned int nonlpcolssorted:1; /**< are the non-LP/not linked columns sorted by non-decreasing index? */
245 unsigned int lhschanged:1; /**< was left hand side or constant changed, and has LP solver to be updated? */
246 unsigned int rhschanged:1; /**< was right hand side or constant changed, and has LP solver to be updated? */
247 unsigned int coefchanged:1; /**< was the coefficient vector changed, and has LP solver to be updated? */
248 unsigned int integral:1; /**< is activity (without constant) of row always integral in feasible solution? */
250 unsigned int modifiable:1; /**< is row modifiable during node processing (subject to column generation)? */
255 unsigned int origintype:3; /**< origin of row (0: unknown, 1: constraint handler, 2: constraint, 3: separator, 4: reoptimization) */
262 SCIP_Real looseobjval; /**< current solution value of all loose variables set to their best bounds,
264 SCIP_Real rellooseobjval; /**< last reliable solution value of all loose variables set to their best bounds,
266 SCIP_Real glbpseudoobjval; /**< global pseudo solution value with all variables set to their best global bounds,
269 SCIP_Real pseudoobjval; /**< current pseudo solution value with all variables set to their best bounds,
272 SCIP_Real rootlpobjval; /**< objective value of root LP without loose variables, or SCIP_INVALID */
273 SCIP_Real rootlooseobjval; /**< objective value of loose variables in root node, or SCIP_INVALID */
279 SCIP_Real lpibarrierconvtol; /**< current convergence tolerance used in barrier algorithm in LPI */
282 SCIP_Real objsqrnorm; /**< squared Euclidean norm of objective function vector of problem variables */
294 SCIP_Real* soldirection; /**< normalized vector in direction of primal solution from current LP solution */
297 SCIP_SIDETYPE* divechgsidetypes; /**< stores the side type of the changes done in the current diving */
299 SCIP_LPSOLVALS* storedsolvals; /**< collected values of the LP data which depend on the LP solution */
300 SCIP_SOL* validsoldirsol; /**< primal solution for which the currently stored solution direction vector is valid */
301 SCIP_Longint validsollp; /**< LP number for which the currently stored solution values are valid */
302 SCIP_Longint validfarkaslp; /**< LP number for which the currently stored Farkas row multipliers are valid */
303 SCIP_Longint validsoldirlp; /**< LP number for which the currently stored solution direction vector is valid */
304 SCIP_Longint validdegeneracylp; /**< LP number for which the currently stored degeneracy information is valid */
308 int lpifirstchgcol; /**< first column of the LP which differs from the column in the LP solver */
320 int nlazycols; /**< current number of LP lazy columns (number of used slots in lazycols vector) */
327 int looseobjvalinf; /**< number of loose variables with infinite best bound in current solution */
329 int glbpseudoobjvalinf; /**< number of variables with infinite best bound in global pseudo solution */
330 int pseudoobjvalinf; /**< number of variables with infinite best bound in current pseudo solution */
345 SCIP_Bool objsqrnormunreliable;/**< is squared Euclidean norm of objective function vector of problem
348 SCIP_Bool looseobjvalid; /**< is the loose objective value valid or should it be recomputed from scratch? */
349 SCIP_Bool glbpseudoobjvalid; /**< is the global pseudo solution value valid or should it be recomputed from scratch? */
350 SCIP_Bool pseudoobjvalid; /**< is the pseudo solution value valid or should it be recomputed from scratch? */
363 SCIP_Bool rootlpisrelax; /**< is root LP a relaxation of the problem and its solution value a valid global lower bound? */
364 SCIP_Bool isrelax; /**< is the current LP a relaxation of the problem for which it has been solved and its
370 SCIP_Bool diving; /**< LP is used for diving: col bounds and obj don't correspond to variables */
371 SCIP_Bool divingobjchg; /**< objective values were changed in diving or probing: LP objective is invalid */
373 SCIP_Bool resolvelperror; /**< an error occurred during resolving the LP after diving or probing */
Definition: struct_var.h:198
Definition: struct_event.h:179
Definition: struct_lp.h:107
Definition: struct_lp.h:126
type definitions for LP management
Definition: struct_sol.h:64
Definition: struct_lp.h:96
type definitions for specific LP solvers interface
type definitions for problem variables
type definitions for managing events
Definition: struct_lp.h:192
Definition: lpi_clp.cpp:123
Definition: struct_lp.h:259
Definition: lpi_clp.cpp:95
common defines and data types used in all packages of SCIP
Definition: struct_lp.h:84