1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2 /* */ 3 /* This file is part of the program and library */ 4 /* SCIP --- Solving Constraint Integer Programs */ 5 /* */ 6 /* Copyright (c) 2002-2023 Zuse Institute Berlin (ZIB) */ 7 /* */ 8 /* Licensed under the Apache License, Version 2.0 (the "License"); */ 9 /* you may not use this file except in compliance with the License. */ 10 /* You may obtain a copy of the License at */ 11 /* */ 12 /* http://www.apache.org/licenses/LICENSE-2.0 */ 13 /* */ 14 /* Unless required by applicable law or agreed to in writing, software */ 15 /* distributed under the License is distributed on an "AS IS" BASIS, */ 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 */ 93 struct SCIP_ColSolVals 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 */ 105 struct SCIP_RowSolVals 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 */ 116 struct SCIP_LpSolVals 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 133 * (col->linkpos[j] == -1). 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 199 * (row->linkpos[j] == -1). 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 */ 347 int lpithreads; /**< current THREADS 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 410