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