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 lp.h 17 * @ingroup INTERNALAPI 18 * @brief internal methods for LP management 19 * @author Tobias Achterberg 20 * @author Marc Pfetsch 21 * @author Kati Wolter 22 * @author Gerald Gamrath 23 */ 24 25 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/ 26 27 #ifndef __SCIP_LP_H__ 28 #define __SCIP_LP_H__ 29 30 31 #include <stdio.h> 32 33 #include "scip/def.h" 34 #include "blockmemshell/memory.h" 35 #include "scip/type_set.h" 36 #include "scip/type_stat.h" 37 #include "scip/type_misc.h" 38 #include "scip/type_lp.h" 39 #include "scip/type_var.h" 40 #include "scip/type_prob.h" 41 #include "scip/type_sol.h" 42 #include "scip/type_branch.h" 43 #include "scip/pub_lp.h" 44 45 #include "scip/struct_lp.h" 46 47 #ifdef __cplusplus 48 extern "C" { 49 #endif 50 51 /* 52 * Column methods 53 */ 54 55 /** creates an LP column */ 56 SCIP_RETCODE SCIPcolCreate( 57 SCIP_COL** col, /**< pointer to column data */ 58 BMS_BLKMEM* blkmem, /**< block memory */ 59 SCIP_SET* set, /**< global SCIP settings */ 60 SCIP_STAT* stat, /**< problem statistics */ 61 SCIP_VAR* var, /**< variable, this column represents */ 62 int len, /**< number of nonzeros in the column */ 63 SCIP_ROW** rows, /**< array with rows of column entries */ 64 SCIP_Real* vals, /**< array with coefficients of column entries */ 65 SCIP_Bool removable /**< should the column be removed from the LP due to aging or cleanup? */ 66 ); 67 68 /** frees an LP column */ 69 SCIP_RETCODE SCIPcolFree( 70 SCIP_COL** col, /**< pointer to LP column */ 71 BMS_BLKMEM* blkmem, /**< block memory */ 72 SCIP_SET* set, /**< global SCIP settings */ 73 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 74 SCIP_LP* lp /**< current LP data */ 75 ); 76 77 /** output column to file stream */ 78 void SCIPcolPrint( 79 SCIP_COL* col, /**< LP column */ 80 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 81 FILE* file /**< output file (or NULL for standard output) */ 82 ); 83 84 /** adds a previously non existing coefficient to an LP column */ 85 SCIP_RETCODE SCIPcolAddCoef( 86 SCIP_COL* col, /**< LP column */ 87 BMS_BLKMEM* blkmem, /**< block memory */ 88 SCIP_SET* set, /**< global SCIP settings */ 89 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 90 SCIP_LP* lp, /**< current LP data */ 91 SCIP_ROW* row, /**< LP row */ 92 SCIP_Real val /**< value of coefficient */ 93 ); 94 95 /** deletes coefficient from column */ 96 SCIP_RETCODE SCIPcolDelCoef( 97 SCIP_COL* col, /**< column to be changed */ 98 BMS_BLKMEM* blkmem, /**< block memory */ 99 SCIP_SET* set, /**< global SCIP settings */ 100 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 101 SCIP_LP* lp, /**< current LP data */ 102 SCIP_ROW* row /**< coefficient to be deleted */ 103 ); 104 105 /** changes or adds a coefficient to an LP column */ 106 SCIP_RETCODE SCIPcolChgCoef( 107 SCIP_COL* col, /**< LP column */ 108 BMS_BLKMEM* blkmem, /**< block memory */ 109 SCIP_SET* set, /**< global SCIP settings */ 110 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 111 SCIP_LP* lp, /**< current LP data */ 112 SCIP_ROW* row, /**< LP row */ 113 SCIP_Real val /**< value of coefficient */ 114 ); 115 116 /** increases value of an existing or nonexisting coefficient in an LP column */ 117 SCIP_RETCODE SCIPcolIncCoef( 118 SCIP_COL* col, /**< LP column */ 119 BMS_BLKMEM* blkmem, /**< block memory */ 120 SCIP_SET* set, /**< global SCIP settings */ 121 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 122 SCIP_LP* lp, /**< current LP data */ 123 SCIP_ROW* row, /**< LP row */ 124 SCIP_Real incval /**< value to add to the coefficient */ 125 ); 126 127 /** changes objective value of column */ 128 SCIP_RETCODE SCIPcolChgObj( 129 SCIP_COL* col, /**< LP column to change */ 130 SCIP_SET* set, /**< global SCIP settings */ 131 SCIP_LP* lp, /**< current LP data */ 132 SCIP_Real newobj /**< new objective value */ 133 ); 134 135 /** changes lower bound of column */ 136 SCIP_RETCODE SCIPcolChgLb( 137 SCIP_COL* col, /**< LP column to change */ 138 SCIP_SET* set, /**< global SCIP settings */ 139 SCIP_LP* lp, /**< current LP data */ 140 SCIP_Real newlb /**< new lower bound value */ 141 ); 142 143 /** changes upper bound of column */ 144 SCIP_RETCODE SCIPcolChgUb( 145 SCIP_COL* col, /**< LP column to change */ 146 SCIP_SET* set, /**< global SCIP settings */ 147 SCIP_LP* lp, /**< current LP data */ 148 SCIP_Real newub /**< new upper bound value */ 149 ); 150 151 /** calculates the reduced costs of a column using the given dual solution vector */ 152 SCIP_Real SCIPcolCalcRedcost( 153 SCIP_COL* col, /**< LP column */ 154 SCIP_Real* dualsol /**< dual solution vector for current LP rows */ 155 ); 156 157 /** gets the reduced costs of a column in last LP or after recalculation */ 158 SCIP_Real SCIPcolGetRedcost( 159 SCIP_COL* col, /**< LP column */ 160 SCIP_STAT* stat, /**< problem statistics */ 161 SCIP_LP* lp /**< current LP data */ 162 ); 163 164 /** gets the feasibility of (the dual row of) a column in last LP or after recalculation */ 165 SCIP_Real SCIPcolGetFeasibility( 166 SCIP_COL* col, /**< LP column */ 167 SCIP_SET* set, /**< global SCIP settings */ 168 SCIP_STAT* stat, /**< problem statistics */ 169 SCIP_LP* lp /**< current LP data */ 170 ); 171 172 /** calculates the Farkas coefficient y^T A_i of a column i using the given dual Farkas vector y */ 173 SCIP_Real SCIPcolCalcFarkasCoef( 174 SCIP_COL* col, /**< LP column */ 175 SCIP_Real* dualfarkas /**< dense dual Farkas vector for current LP rows */ 176 ); 177 178 /** gets the Farkas coefficient y^T A_i of a column i in last LP (which must be infeasible) */ 179 SCIP_Real SCIPcolGetFarkasCoef( 180 SCIP_COL* col, /**< LP column */ 181 SCIP_STAT* stat, /**< problem statistics */ 182 SCIP_LP* lp /**< current LP data */ 183 ); 184 185 /** gets the Farkas value of a column in last LP (which must be infeasible), i.e. the Farkas coefficient y^T A_i times 186 * the best bound for this coefficient, i.e. max{y^T A_i x_i | lb <= x_i <= ub} 187 */ 188 SCIP_Real SCIPcolGetFarkasValue( 189 SCIP_COL* col, /**< LP column */ 190 SCIP_STAT* stat, /**< problem statistics */ 191 SCIP_LP* lp /**< current LP data */ 192 ); 193 194 /** start strong branching - call before any strong branching */ 195 SCIP_RETCODE SCIPlpStartStrongbranch( 196 SCIP_LP* lp /**< LP data */ 197 ); 198 199 /** end strong branching - call after any strong branching */ 200 SCIP_RETCODE SCIPlpEndStrongbranch( 201 SCIP_LP* lp /**< LP data */ 202 ); 203 204 /** sets strong branching information for a column variable */ 205 void SCIPcolSetStrongbranchData( 206 SCIP_COL* col, /**< LP column */ 207 SCIP_SET* set, /**< global SCIP settings */ 208 SCIP_STAT* stat, /**< dynamic problem statistics */ 209 SCIP_LP* lp, /**< LP data */ 210 SCIP_Real lpobjval, /**< objective value of the current LP */ 211 SCIP_Real primsol, /**< primal solution value of the column in the current LP */ 212 SCIP_Real sbdown, /**< dual bound after branching column down */ 213 SCIP_Real sbup, /**< dual bound after branching column up */ 214 SCIP_Bool sbdownvalid, /**< is the returned down value a valid dual bound? */ 215 SCIP_Bool sbupvalid, /**< is the returned up value a valid dual bound? */ 216 SCIP_Longint iter, /**< total number of strong branching iterations */ 217 int itlim /**< iteration limit applied to the strong branching call */ 218 ); 219 220 /** invalidates strong branching information for a column variable */ 221 void SCIPcolInvalidateStrongbranchData( 222 SCIP_COL* col, /**< LP column */ 223 SCIP_SET* set, /**< global SCIP settings */ 224 SCIP_STAT* stat, /**< dynamic problem statistics */ 225 SCIP_LP* lp /**< LP data */ 226 ); 227 228 /** gets strong branching information on a column variable */ 229 SCIP_RETCODE SCIPcolGetStrongbranch( 230 SCIP_COL* col, /**< LP column */ 231 SCIP_Bool integral, /**< should integral strong branching be performed? */ 232 SCIP_SET* set, /**< global SCIP settings */ 233 SCIP_STAT* stat, /**< dynamic problem statistics */ 234 SCIP_PROB* prob, /**< problem data */ 235 SCIP_LP* lp, /**< LP data */ 236 int itlim, /**< iteration limit for strong branchings */ 237 SCIP_Bool updatecol, /**< should col be updated, or should it stay in its current state ? */ 238 SCIP_Bool updatestat, /**< should stat be updated, or should it stay in its current state ? */ 239 SCIP_Real* down, /**< stores dual bound after branching column down */ 240 SCIP_Real* up, /**< stores dual bound after branching column up */ 241 SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL; 242 * otherwise, it can only be used as an estimate value */ 243 SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL; 244 * otherwise, it can only be used as an estimate value */ 245 SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred */ 246 ); 247 248 /** gets strong branching information on column variables */ 249 SCIP_RETCODE SCIPcolGetStrongbranches( 250 SCIP_COL** cols, /**< LP columns */ 251 int ncols, /**< number of columns */ 252 SCIP_Bool integral, /**< should integral strong branching be performed? */ 253 SCIP_SET* set, /**< global SCIP settings */ 254 SCIP_STAT* stat, /**< dynamic problem statistics */ 255 SCIP_PROB* prob, /**< problem data */ 256 SCIP_LP* lp, /**< LP data */ 257 int itlim, /**< iteration limit for strong branchings */ 258 SCIP_Real* down, /**< stores dual bounds after branching columns down */ 259 SCIP_Real* up, /**< stores dual bounds after branching columns up */ 260 SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL; 261 * otherwise, they can only be used as an estimate value */ 262 SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL; 263 * otherwise, they can only be used as an estimate value */ 264 SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred */ 265 ); 266 267 /** gets last strong branching information available for a column variable; 268 * returns values of SCIP_INVALID, if strong branching was not yet called on the given column; 269 * keep in mind, that the returned old values may have nothing to do with the current LP solution 270 */ 271 void SCIPcolGetStrongbranchLast( 272 SCIP_COL* col, /**< LP column */ 273 SCIP_Real* down, /**< stores dual bound after branching column down, or NULL */ 274 SCIP_Real* up, /**< stores dual bound after branching column up, or NULL */ 275 SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL; 276 * otherwise, it can only be used as an estimate value */ 277 SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL; 278 * otherwise, it can only be used as an estimate value */ 279 SCIP_Real* solval, /**< stores LP solution value of column at last strong branching call, or NULL */ 280 SCIP_Real* lpobjval /**< stores LP objective value at last strong branching call, or NULL */ 281 ); 282 283 /** if strong branching was already applied on the column at the current node, returns the number of LPs solved after 284 * the LP where the strong branching on this column was applied; 285 * if strong branching was not yet applied on the column at the current node, returns INT_MAX 286 */ 287 SCIP_Longint SCIPcolGetStrongbranchLPAge( 288 SCIP_COL* col, /**< LP column */ 289 SCIP_STAT* stat /**< dynamic problem statistics */ 290 ); 291 292 /** marks a column to be not removable from the LP in the current node because it became obsolete */ 293 void SCIPcolMarkNotRemovableLocal( 294 SCIP_COL* col, /**< LP column */ 295 SCIP_STAT* stat /**< problem statistics */ 296 ); 297 298 299 /* 300 * Row methods 301 */ 302 303 /** creates and captures an LP row */ 304 SCIP_RETCODE SCIProwCreate( 305 SCIP_ROW** row, /**< pointer to LP row data */ 306 BMS_BLKMEM* blkmem, /**< block memory */ 307 SCIP_SET* set, /**< global SCIP settings */ 308 SCIP_STAT* stat, /**< problem statistics */ 309 const char* name, /**< name of row */ 310 int len, /**< number of nonzeros in the row */ 311 SCIP_COL** cols, /**< array with columns of row entries */ 312 SCIP_Real* vals, /**< array with coefficients of row entries */ 313 SCIP_Real lhs, /**< left hand side of row */ 314 SCIP_Real rhs, /**< right hand side of row */ 315 SCIP_ROWORIGINTYPE origintype, /**< type of origin of row */ 316 void* origin, /**< pointer to constraint handler or separator who created the row (NULL if unkown) */ 317 SCIP_Bool local, /**< is row only valid locally? */ 318 SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */ 319 SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */ 320 ); 321 322 /** frees an LP row */ 323 SCIP_RETCODE SCIProwFree( 324 SCIP_ROW** row, /**< pointer to LP row */ 325 BMS_BLKMEM* blkmem, /**< block memory */ 326 SCIP_SET* set, /**< global SCIP settings */ 327 SCIP_LP* lp /**< current LP data */ 328 ); 329 330 /** output row to file stream */ 331 void SCIProwPrint( 332 SCIP_ROW* row, /**< LP row */ 333 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 334 FILE* file /**< output file (or NULL for standard output) */ 335 ); 336 337 /** ensures, that column array of row can store at least num entries */ 338 SCIP_RETCODE SCIProwEnsureSize( 339 SCIP_ROW* row, /**< LP row */ 340 BMS_BLKMEM* blkmem, /**< block memory */ 341 SCIP_SET* set, /**< global SCIP settings */ 342 int num /**< minimum number of entries to store */ 343 ); 344 345 /** increases usage counter of LP row */ 346 void SCIProwCapture( 347 SCIP_ROW* row /**< LP row */ 348 ); 349 350 /** decreases usage counter of LP row, and frees memory if necessary */ 351 SCIP_RETCODE SCIProwRelease( 352 SCIP_ROW** row, /**< pointer to LP row */ 353 BMS_BLKMEM* blkmem, /**< block memory */ 354 SCIP_SET* set, /**< global SCIP settings */ 355 SCIP_LP* lp /**< current LP data */ 356 ); 357 358 /** enables delaying of row sorting */ 359 void SCIProwDelaySort( 360 SCIP_ROW* row /**< LP row */ 361 ); 362 363 /** disables delaying of row sorting, sorts row and merges coefficients with equal columns */ 364 void SCIProwForceSort( 365 SCIP_ROW* row, /**< LP row */ 366 SCIP_SET* set /**< global SCIP settings */ 367 ); 368 369 /** adds a previously non existing coefficient to an LP row */ 370 SCIP_RETCODE SCIProwAddCoef( 371 SCIP_ROW* row, /**< LP row */ 372 BMS_BLKMEM* blkmem, /**< block memory */ 373 SCIP_SET* set, /**< global SCIP settings */ 374 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 375 SCIP_LP* lp, /**< current LP data */ 376 SCIP_COL* col, /**< LP column */ 377 SCIP_Real val /**< value of coefficient */ 378 ); 379 380 /** deletes coefficient from row */ 381 SCIP_RETCODE SCIProwDelCoef( 382 SCIP_ROW* row, /**< LP row */ 383 BMS_BLKMEM* blkmem, /**< block memory */ 384 SCIP_SET* set, /**< global SCIP settings */ 385 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 386 SCIP_LP* lp, /**< current LP data */ 387 SCIP_COL* col /**< coefficient to be deleted */ 388 ); 389 390 /** changes or adds a coefficient to an LP row */ 391 SCIP_RETCODE SCIProwChgCoef( 392 SCIP_ROW* row, /**< LP row */ 393 BMS_BLKMEM* blkmem, /**< block memory */ 394 SCIP_SET* set, /**< global SCIP settings */ 395 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 396 SCIP_LP* lp, /**< current LP data */ 397 SCIP_COL* col, /**< LP column */ 398 SCIP_Real val /**< value of coefficient */ 399 ); 400 401 /** increases value of an existing or nonexisting coefficient in an LP column */ 402 SCIP_RETCODE SCIProwIncCoef( 403 SCIP_ROW* row, /**< LP row */ 404 BMS_BLKMEM* blkmem, /**< block memory */ 405 SCIP_SET* set, /**< global SCIP settings */ 406 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 407 SCIP_LP* lp, /**< current LP data */ 408 SCIP_COL* col, /**< LP column */ 409 SCIP_Real incval /**< value to add to the coefficient */ 410 ); 411 412 /** changes constant value of a row */ 413 SCIP_RETCODE SCIProwChgConstant( 414 SCIP_ROW* row, /**< LP row */ 415 BMS_BLKMEM* blkmem, /**< block memory */ 416 SCIP_SET* set, /**< global SCIP settings */ 417 SCIP_STAT* stat, /**< problem statistics */ 418 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 419 SCIP_LP* lp, /**< current LP data */ 420 SCIP_Real constant /**< new constant value */ 421 ); 422 423 /** add constant value to a row */ 424 SCIP_RETCODE SCIProwAddConstant( 425 SCIP_ROW* row, /**< LP row */ 426 BMS_BLKMEM* blkmem, /**< block memory */ 427 SCIP_SET* set, /**< global SCIP settings */ 428 SCIP_STAT* stat, /**< problem statistics */ 429 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 430 SCIP_LP* lp, /**< current LP data */ 431 SCIP_Real addval /**< constant value to add to the row */ 432 ); 433 434 /** changes left hand side of LP row */ 435 SCIP_RETCODE SCIProwChgLhs( 436 SCIP_ROW* row, /**< LP row */ 437 BMS_BLKMEM* blkmem, /**< block memory */ 438 SCIP_SET* set, /**< global SCIP settings */ 439 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 440 SCIP_LP* lp, /**< current LP data */ 441 SCIP_Real lhs /**< new left hand side */ 442 ); 443 444 /** changes right hand side of LP row */ 445 SCIP_RETCODE SCIProwChgRhs( 446 SCIP_ROW* row, /**< LP row */ 447 BMS_BLKMEM* blkmem, /**< block memory */ 448 SCIP_SET* set, /**< global SCIP settings */ 449 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 450 SCIP_LP* lp, /**< current LP data */ 451 SCIP_Real rhs /**< new right hand side */ 452 ); 453 454 /** changes the local flag of LP row */ 455 SCIP_RETCODE SCIProwChgLocal( 456 SCIP_ROW* row, /**< LP row */ 457 SCIP_Bool local /**< new value for local flag */ 458 ); 459 460 /** tries to find a value, such that all row coefficients, if scaled with this value become integral */ 461 SCIP_RETCODE SCIProwCalcIntegralScalar( 462 SCIP_ROW* row, /**< LP row */ 463 SCIP_SET* set, /**< global SCIP settings */ 464 SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */ 465 SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */ 466 SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */ 467 SCIP_Real maxscale, /**< maximal allowed scalar */ 468 SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */ 469 SCIP_Real* intscalar, /**< pointer to store scalar that would make the coefficients integral */ 470 SCIP_Bool* success /**< stores whether returned value is valid */ 471 ); 472 473 /** tries to scale row, s.t. all coefficients become integral */ 474 SCIP_RETCODE SCIProwMakeIntegral( 475 SCIP_ROW* row, /**< LP row */ 476 BMS_BLKMEM* blkmem, /**< block memory */ 477 SCIP_SET* set, /**< global SCIP settings */ 478 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 479 SCIP_STAT* stat, /**< problem statistics */ 480 SCIP_LP* lp, /**< current LP data */ 481 SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */ 482 SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */ 483 SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */ 484 SCIP_Real maxscale, /**< maximal value to scale row with */ 485 SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */ 486 SCIP_Bool* success /**< stores whether row could be made rational */ 487 ); 488 489 /** recalculates the current activity of a row */ 490 void SCIProwRecalcLPActivity( 491 SCIP_ROW* row, /**< LP row */ 492 SCIP_STAT* stat /**< problem statistics */ 493 ); 494 495 /** returns the activity of a row in the current LP solution */ 496 SCIP_Real SCIProwGetLPActivity( 497 SCIP_ROW* row, /**< LP row */ 498 SCIP_SET* set, /**< global SCIP settings */ 499 SCIP_STAT* stat, /**< problem statistics */ 500 SCIP_LP* lp /**< current LP data */ 501 ); 502 503 /** returns the feasibility of a row in the current LP solution: negative value means infeasibility */ 504 SCIP_Real SCIProwGetLPFeasibility( 505 SCIP_ROW* row, /**< LP row */ 506 SCIP_SET* set, /**< global SCIP settings */ 507 SCIP_STAT* stat, /**< problem statistics */ 508 SCIP_LP* lp /**< current LP data */ 509 ); 510 511 /** returns the feasibility of a row in the current relaxed solution: negative value means infeasibility */ 512 SCIP_Real SCIProwGetRelaxFeasibility( 513 SCIP_ROW* row, /**< LP row */ 514 SCIP_SET* set, /**< global SCIP settings */ 515 SCIP_STAT* stat /**< problem statistics */ 516 ); 517 518 /** returns the feasibility of a row in the current NLP solution: negative value means infeasibility */ 519 SCIP_Real SCIProwGetNLPFeasibility( 520 SCIP_ROW* row, /**< LP row */ 521 SCIP_SET* set, /**< global SCIP settings */ 522 SCIP_STAT* stat /**< problem statistics */ 523 ); 524 525 /** calculates the current pseudo activity of a row */ 526 void SCIProwRecalcPseudoActivity( 527 SCIP_ROW* row, /**< row data */ 528 SCIP_STAT* stat /**< problem statistics */ 529 ); 530 531 /** returns the pseudo activity of a row in the current pseudo solution */ 532 SCIP_Real SCIProwGetPseudoActivity( 533 SCIP_ROW* row, /**< LP row */ 534 SCIP_SET* set, /**< global SCIP settings */ 535 SCIP_STAT* stat /**< problem statistics */ 536 ); 537 538 /** returns the pseudo feasibility of a row in the current pseudo solution: negative value means infeasibility */ 539 SCIP_Real SCIProwGetPseudoFeasibility( 540 SCIP_ROW* row, /**< LP row */ 541 SCIP_SET* set, /**< global SCIP settings */ 542 SCIP_STAT* stat /**< problem statistics */ 543 ); 544 545 /** returns the activity of a row for a given solution */ 546 SCIP_Real SCIProwGetSolActivity( 547 SCIP_ROW* row, /**< LP row */ 548 SCIP_SET* set, /**< global SCIP settings */ 549 SCIP_STAT* stat, /**< problem statistics data */ 550 SCIP_SOL* sol /**< primal CIP solution */ 551 ); 552 553 /** returns the feasibility of a row for the given solution */ 554 SCIP_Real SCIProwGetSolFeasibility( 555 SCIP_ROW* row, /**< LP row */ 556 SCIP_SET* set, /**< global SCIP settings */ 557 SCIP_STAT* stat, /**< problem statistics data */ 558 SCIP_SOL* sol /**< primal CIP solution */ 559 ); 560 561 /** returns the minimal activity of a row w.r.t. the columns' bounds */ 562 SCIP_Real SCIProwGetMinActivity( 563 SCIP_ROW* row, /**< LP row */ 564 SCIP_SET* set, /**< global SCIP settings */ 565 SCIP_STAT* stat /**< problem statistics data */ 566 ); 567 568 /** returns the maximal activity of a row w.r.t. the columns' bounds */ 569 SCIP_Real SCIProwGetMaxActivity( 570 SCIP_ROW* row, /**< LP row */ 571 SCIP_SET* set, /**< global SCIP settings */ 572 SCIP_STAT* stat /**< problem statistics data */ 573 ); 574 575 /** returns whether the row is unmodifiable and redundant w.r.t. the columns' bounds */ 576 SCIP_Bool SCIProwIsRedundant( 577 SCIP_ROW* row, /**< LP row */ 578 SCIP_SET* set, /**< global SCIP settings */ 579 SCIP_STAT* stat /**< problem statistics data */ 580 ); 581 582 /** gets maximal absolute value of row vector coefficients */ 583 SCIP_Real SCIProwGetMaxval( 584 SCIP_ROW* row, /**< LP row */ 585 SCIP_SET* set /**< global SCIP settings */ 586 ); 587 588 /** gets minimal absolute value of row vector's non-zero coefficients */ 589 SCIP_Real SCIProwGetMinval( 590 SCIP_ROW* row, /**< LP row */ 591 SCIP_SET* set /**< global SCIP settings */ 592 ); 593 594 /** gets maximal column index of row entries */ 595 int SCIProwGetMaxidx( 596 SCIP_ROW* row, /**< LP row */ 597 SCIP_SET* set /**< global SCIP settings */ 598 ); 599 600 /** gets minimal column index of row entries */ 601 int SCIProwGetMinidx( 602 SCIP_ROW* row, /**< LP row */ 603 SCIP_SET* set /**< global SCIP settings */ 604 ); 605 606 /** gets number of integral columns in row */ 607 int SCIProwGetNumIntCols( 608 SCIP_ROW* row, /**< LP row */ 609 SCIP_SET* set /**< global SCIP settings */ 610 ); 611 612 /** returns row's cutoff distance in the direction of the given primal solution */ 613 SCIP_Real SCIProwGetLPSolCutoffDistance( 614 SCIP_ROW* row, /**< LP row */ 615 SCIP_SET* set, /**< global SCIP settings */ 616 SCIP_STAT* stat, /**< problem statistics data */ 617 SCIP_SOL* sol, /**< solution to compute direction for cutoff distance; must not be NULL */ 618 SCIP_LP* lp /**< current LP data */ 619 ); 620 621 /** returns row's efficacy with respect to the current LP solution: e = -feasibility/norm */ 622 SCIP_Real SCIProwGetLPEfficacy( 623 SCIP_ROW* row, /**< LP row */ 624 SCIP_SET* set, /**< global SCIP settings */ 625 SCIP_STAT* stat, /**< problem statistics data */ 626 SCIP_LP* lp /**< current LP data */ 627 ); 628 629 /** returns whether the row's efficacy with respect to the current LP solution is greater than the minimal cut efficacy */ 630 SCIP_Bool SCIProwIsLPEfficacious( 631 SCIP_ROW* row, /**< LP row */ 632 SCIP_SET* set, /**< global SCIP settings */ 633 SCIP_STAT* stat, /**< problem statistics data */ 634 SCIP_LP* lp, /**< current LP data */ 635 SCIP_Bool root /**< should the root's minimal cut efficacy be used? */ 636 ); 637 638 /** returns row's efficacy with respect to the given primal solution: e = -feasibility/norm */ 639 SCIP_Real SCIProwGetSolEfficacy( 640 SCIP_ROW* row, /**< LP row */ 641 SCIP_SET* set, /**< global SCIP settings */ 642 SCIP_STAT* stat, /**< problem statistics data */ 643 SCIP_SOL* sol /**< primal CIP solution */ 644 ); 645 646 /** returns whether the row's efficacy with respect to the given primal solution is greater than the minimal cut 647 * efficacy 648 */ 649 SCIP_Bool SCIProwIsSolEfficacious( 650 SCIP_ROW* row, /**< LP row */ 651 SCIP_SET* set, /**< global SCIP settings */ 652 SCIP_STAT* stat, /**< problem statistics data */ 653 SCIP_SOL* sol, /**< primal CIP solution */ 654 SCIP_Bool root /**< should the root's minimal cut efficacy be used? */ 655 ); 656 657 /** returns row's efficacy with respect to the relaxed solution: e = -feasibility/norm */ 658 SCIP_Real SCIProwGetRelaxEfficacy( 659 SCIP_ROW* row, /**< LP row */ 660 SCIP_SET* set, /**< global SCIP settings */ 661 SCIP_STAT* stat /**< problem statistics data */ 662 ); 663 664 /** returns row's efficacy with respect to the NLP solution: e = -feasibility/norm */ 665 SCIP_Real SCIProwGetNLPEfficacy( 666 SCIP_ROW* row, /**< LP row */ 667 SCIP_SET* set, /**< global SCIP settings */ 668 SCIP_STAT* stat /**< problem statistics data */ 669 ); 670 671 /** gets parallelism of row with objective function: if the returned value is 1, the row is parallel to the objective 672 * function, if the value is 0, it is orthogonal to the objective function 673 */ 674 SCIP_Real SCIProwGetObjParallelism( 675 SCIP_ROW* row, /**< LP row */ 676 SCIP_SET* set, /**< global SCIP settings */ 677 SCIP_LP* lp /**< current LP data */ 678 ); 679 680 /** includes event handler with given data in row's event filter */ 681 SCIP_RETCODE SCIProwCatchEvent( 682 SCIP_ROW* row, /**< row */ 683 BMS_BLKMEM* blkmem, /**< block memory */ 684 SCIP_SET* set, /**< global SCIP settings */ 685 SCIP_EVENTTYPE eventtype, /**< event type to catch */ 686 SCIP_EVENTHDLR* eventhdlr, /**< event handler to call for the event processing */ 687 SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler for the event processing */ 688 int* filterpos /**< pointer to store position of event filter entry, or NULL */ 689 ); 690 691 /** deletes event handler with given data from row's event filter */ 692 SCIP_RETCODE SCIProwDropEvent( 693 SCIP_ROW* row, /**< row */ 694 BMS_BLKMEM* blkmem, /**< block memory */ 695 SCIP_SET* set, /**< global SCIP settings */ 696 SCIP_EVENTTYPE eventtype, /**< event type mask of dropped event */ 697 SCIP_EVENTHDLR* eventhdlr, /**< event handler to call for the event processing */ 698 SCIP_EVENTDATA* eventdata, /**< event data to pass to the event handler for the event processing */ 699 int filterpos /**< position of event filter entry returned by SCIPvarCatchEvent(), or -1 */ 700 ); 701 702 /** marks a row to be not removable from the LP in the current node */ 703 void SCIProwMarkNotRemovableLocal( 704 SCIP_ROW* row, /**< LP row */ 705 SCIP_STAT* stat /**< problem statistics */ 706 ); 707 708 709 /* 710 * LP methods 711 */ 712 713 /** creates empty LP data object */ 714 SCIP_RETCODE SCIPlpCreate( 715 SCIP_LP** lp, /**< pointer to LP data object */ 716 SCIP_SET* set, /**< global SCIP settings */ 717 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 718 SCIP_STAT* stat, /**< problem statistics */ 719 const char* name /**< problem name */ 720 ); 721 722 /** frees LP data object */ 723 SCIP_RETCODE SCIPlpFree( 724 SCIP_LP** lp, /**< pointer to LP data object */ 725 BMS_BLKMEM* blkmem, /**< block memory */ 726 SCIP_SET* set, /**< global SCIP settings */ 727 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 728 SCIP_EVENTFILTER* eventfilter /**< global event filter */ 729 ); 730 731 /** resets the LP to the empty LP by removing all columns and rows from LP, releasing all rows, and flushing the 732 * changes to the LP solver 733 */ 734 SCIP_RETCODE SCIPlpReset( 735 SCIP_LP* lp, /**< LP data */ 736 BMS_BLKMEM* blkmem, /**< block memory */ 737 SCIP_SET* set, /**< global SCIP settings */ 738 SCIP_STAT* stat, /**< problem statistics */ 739 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 740 SCIP_EVENTFILTER* eventfilter /**< global event filter */ 741 ); 742 743 /** adds a column to the LP and captures the variable */ 744 SCIP_RETCODE SCIPlpAddCol( 745 SCIP_LP* lp, /**< LP data */ 746 SCIP_SET* set, /**< global SCIP settings */ 747 SCIP_COL* col, /**< LP column */ 748 int depth /**< depth in the tree where the column addition is performed */ 749 ); 750 751 /** adds a row to the LP and captures it */ 752 SCIP_RETCODE SCIPlpAddRow( 753 SCIP_LP* lp, /**< LP data */ 754 BMS_BLKMEM* blkmem, /**< block memory buffers */ 755 SCIP_SET* set, /**< global SCIP settings */ 756 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 757 SCIP_EVENTFILTER* eventfilter, /**< global event filter */ 758 SCIP_ROW* row, /**< LP row */ 759 int depth /**< depth in the tree where the row addition is performed */ 760 ); 761 762 /** removes all columns after the given number of columns from the LP */ 763 SCIP_RETCODE SCIPlpShrinkCols( 764 SCIP_LP* lp, /**< LP data */ 765 SCIP_SET* set, /**< global SCIP settings */ 766 int newncols /**< new number of columns in the LP */ 767 ); 768 769 /** removes and releases all rows after the given number of rows from the LP */ 770 SCIP_RETCODE SCIPlpShrinkRows( 771 SCIP_LP* lp, /**< LP data */ 772 BMS_BLKMEM* blkmem, /**< block memory */ 773 SCIP_SET* set, /**< global SCIP settings */ 774 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 775 SCIP_EVENTFILTER* eventfilter, /**< global event filter */ 776 int newnrows /**< new number of rows in the LP */ 777 ); 778 779 /** removes all columns and rows from LP, releases all rows */ 780 SCIP_RETCODE SCIPlpClear( 781 SCIP_LP* lp, /**< LP data */ 782 BMS_BLKMEM* blkmem, /**< block memory */ 783 SCIP_SET* set, /**< global SCIP settings */ 784 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 785 SCIP_EVENTFILTER* eventfilter /**< global event filter */ 786 ); 787 788 /** remembers number of columns and rows to track the newly added ones */ 789 void SCIPlpMarkSize( 790 SCIP_LP* lp /**< current LP data */ 791 ); 792 793 /** sets the remembered number of columns and rows to the given values */ 794 void SCIPlpSetSizeMark( 795 SCIP_LP* lp, /**< current LP data */ 796 int nrows, /**< number of rows to set the size marker to */ 797 int ncols /**< number of columns to set the size marker to */ 798 ); 799 800 /** gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1 */ 801 SCIP_RETCODE SCIPlpGetBasisInd( 802 SCIP_LP* lp, /**< LP data */ 803 int* basisind /**< pointer to store basis indices ready to keep number of rows entries */ 804 ); 805 806 /** gets current basis status for columns and rows; arrays must be large enough to store the basis status */ 807 SCIP_RETCODE SCIPlpGetBase( 808 SCIP_LP* lp, /**< LP data */ 809 int* cstat, /**< array to store column basis status, or NULL */ 810 int* rstat /**< array to store row basis status, or NULL */ 811 ); 812 813 /** gets a row from the inverse basis matrix B^-1 */ 814 SCIP_RETCODE SCIPlpGetBInvRow( 815 SCIP_LP* lp, /**< LP data */ 816 int r, /**< row number */ 817 SCIP_Real* coef, /**< pointer to store the coefficients of the row */ 818 int* inds, /**< array to store the non-zero indices, or NULL */ 819 int* ninds /**< pointer to store the number of non-zero indices, or NULL 820 * (-1: if we do not store sparsity informations) */ 821 ); 822 823 /** gets a column from the inverse basis matrix B^-1 */ 824 SCIP_RETCODE SCIPlpGetBInvCol( 825 SCIP_LP* lp, /**< LP data */ 826 int c, /**< column number of B^-1; this is NOT the number of the column in the LP 827 * returned by SCIPcolGetLPPos(); you have to call SCIPgetBasisInd() 828 * to get the array which links the B^-1 column numbers to the row and 829 * column numbers of the LP! c must be between 0 and nrows-1, since the 830 * basis has the size nrows * nrows */ 831 SCIP_Real* coef, /**< pointer to store the coefficients of the column */ 832 int* inds, /**< array to store the non-zero indices, or NULL */ 833 int* ninds /**< pointer to store the number of non-zero indices, or NULL 834 * (-1: if we do not store sparsity informations) */ 835 ); 836 837 /** gets a row from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A) */ 838 SCIP_RETCODE SCIPlpGetBInvARow( 839 SCIP_LP* lp, /**< LP data */ 840 int r, /**< row number */ 841 SCIP_Real* binvrow, /**< row in B^-1 from prior call to SCIPlpGetBInvRow(), or NULL */ 842 SCIP_Real* coef, /**< pointer to store the coefficients of the row */ 843 int* inds, /**< array to store the non-zero indices, or NULL */ 844 int* ninds /**< pointer to store the number of non-zero indices, or NULL 845 * (-1: if we do not store sparsity informations) */ 846 ); 847 848 /** gets a column from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A), 849 * i.e., it computes B^-1 * A_c with A_c being the c'th column of A 850 */ 851 SCIP_RETCODE SCIPlpGetBInvACol( 852 SCIP_LP* lp, /**< LP data */ 853 int c, /**< column number which can be accessed by SCIPcolGetLPPos() */ 854 SCIP_Real* coef, /**< pointer to store the coefficients of the column */ 855 int* inds, /**< array to store the non-zero indices, or NULL */ 856 int* ninds /**< pointer to store the number of non-zero indices, or NULL 857 * (-1: if we do not store sparsity informations) */ 858 ); 859 860 /** calculates a weighted sum of all LP rows; for negative weights, the left and right hand side of the corresponding 861 * LP row are swapped in the summation 862 */ 863 SCIP_RETCODE SCIPlpSumRows( 864 SCIP_LP* lp, /**< LP data */ 865 SCIP_SET* set, /**< global SCIP settings */ 866 SCIP_PROB* prob, /**< problem data */ 867 SCIP_Real* weights, /**< row weights in row summation */ 868 SCIP_REALARRAY* sumcoef, /**< array to store sum coefficients indexed by variables' probindex */ 869 SCIP_Real* sumlhs, /**< pointer to store the left hand side of the row summation */ 870 SCIP_Real* sumrhs /**< pointer to store the right hand side of the row summation */ 871 ); 872 873 /* calculates a MIR cut out of the weighted sum of LP rows; The weights of modifiable rows are set to 0.0, because these 874 * rows cannot participate in a MIR cut. 875 */ 876 SCIP_RETCODE SCIPlpCalcMIR( 877 SCIP_LP* lp, /**< LP data */ 878 SCIP_SET* set, /**< global SCIP settings */ 879 SCIP_STAT* stat, /**< problem statistics */ 880 SCIP_PROB* prob, /**< problem data */ 881 SCIP_SOL* sol, /**< the solution that should be separated, or NULL for LP solution */ 882 SCIP_Real boundswitch, /**< fraction of domain up to which lower bound is used in transformation */ 883 SCIP_Bool usevbds, /**< should variable bounds be used in bound transformation? */ 884 SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */ 885 SCIP_Bool fixintegralrhs, /**< should complementation tried to be adjusted such that rhs gets fractional? */ 886 int* boundsfortrans, /**< bounds that should be used for transformed variables: vlb_idx/vub_idx, 887 * -1 for global lb/ub, -2 for local lb/ub, or -3 for using closest bound; 888 * NULL for using closest bound for all variables */ 889 SCIP_BOUNDTYPE* boundtypesfortrans, /**< type of bounds that should be used for transformed variables; 890 * NULL for using closest bound for all variables */ 891 int maxmksetcoefs, /**< maximal number of nonzeros allowed in aggregated base inequality */ 892 SCIP_Real maxweightrange, /**< maximal valid range max(|weights|)/min(|weights|) of row weights */ 893 SCIP_Real minfrac, /**< minimal fractionality of rhs to produce MIR cut for */ 894 SCIP_Real maxfrac, /**< maximal fractionality of rhs to produce MIR cut for */ 895 SCIP_Real* weights, /**< row weights in row summation */ 896 SCIP_Real maxweight, /**< largest magnitude of weights; set to -1 if sparsity information is unknown */ 897 int* weightinds, /**< sparsity pattern of weights; size nrowinds; NULL if sparsity info is unknown */ 898 int nweightinds, /**< number of nonzeros in weights; -1 if rowinds is NULL */ 899 int rowlensum, /**< total number of non-zeros in used rows (row associated with nonzero weight coefficient); -1 if unknown */ 900 int* sidetypes, /**< specify row side type (-1 = lhs, 0 = unkown, 1 = rhs) or NULL for automatic choices */ 901 SCIP_Real scale, /**< additional scaling factor multiplied to all rows */ 902 SCIP_Real* mksetcoefs, /**< array to store mixed knapsack set coefficients: size nvars; or NULL */ 903 SCIP_Bool* mksetcoefsvalid, /**< pointer to store whether mixed knapsack set coefficients are valid; or NULL */ 904 SCIP_Real* mircoef, /**< array to store MIR coefficients: must be of size nvars */ 905 SCIP_Real* mirrhs, /**< pointer to store the right hand side of the MIR row */ 906 SCIP_Real* cutactivity, /**< pointer to store the activity of the resulting cut */ 907 SCIP_Bool* success, /**< pointer to store whether the returned coefficients are a valid MIR cut */ 908 SCIP_Bool* cutislocal, /**< pointer to store whether the returned cut is only valid locally */ 909 int* cutrank /**< pointer to store the rank of the returned cut; or NULL */ 910 ); 911 912 /* calculates a strong CG cut out of the weighted sum of LP rows; The weights of modifiable rows are set to 0.0, because 913 * these rows cannot participate in a strong CG cut. 914 */ 915 SCIP_RETCODE SCIPlpCalcStrongCG( 916 SCIP_LP* lp, /**< LP data */ 917 SCIP_SET* set, /**< global SCIP settings */ 918 SCIP_STAT* stat, /**< problem statistics */ 919 SCIP_PROB* prob, /**< problem data */ 920 SCIP_Real boundswitch, /**< fraction of domain up to which lower bound is used in transformation */ 921 SCIP_Bool usevbds, /**< should variable bounds be used in bound transformation? */ 922 SCIP_Bool allowlocal, /**< should local information allowed to be used, resulting in a local cut? */ 923 int maxmksetcoefs, /**< maximal number of nonzeros allowed in aggregated base inequality */ 924 SCIP_Real maxweightrange, /**< maximal valid range max(|weights|)/min(|weights|) of row weights */ 925 SCIP_Real minfrac, /**< minimal fractionality of rhs to produce strong CG cut for */ 926 SCIP_Real maxfrac, /**< maximal fractionality of rhs to produce strong CG cut for */ 927 SCIP_Real* weights, /**< row weights in row summation */ 928 int* rowinds, /**< array to store indices of non-zero entries of the weights array, or 929 * NULL */ 930 int nrowinds, /**< number of non-zero entries in weights array, -1 if rowinds is NULL */ 931 SCIP_Real scale, /**< additional scaling factor multiplied to all rows */ 932 SCIP_Real* strongcgcoef, /**< array to store strong CG coefficients: must be of size nvars */ 933 SCIP_Real* strongcgrhs, /**< pointer to store the right hand side of the strong CG row */ 934 SCIP_Real* cutactivity, /**< pointer to store the activity of the resulting cut */ 935 SCIP_Bool* success, /**< pointer to store whether the returned coefficients are a valid strong CG cut */ 936 SCIP_Bool* cutislocal, /**< pointer to store whether the returned cut is only valid locally */ 937 int* cutrank /**< pointer to store the rank of the returned cut; or NULL */ 938 ); 939 940 /** stores LP state (like basis information) into LP state object */ 941 SCIP_RETCODE SCIPlpGetState( 942 SCIP_LP* lp, /**< LP data */ 943 BMS_BLKMEM* blkmem, /**< block memory */ 944 SCIP_LPISTATE** lpistate /**< pointer to LP state information (like basis information) */ 945 ); 946 947 /** loads LP state (like basis information) into solver */ 948 SCIP_RETCODE SCIPlpSetState( 949 SCIP_LP* lp, /**< LP data */ 950 BMS_BLKMEM* blkmem, /**< block memory */ 951 SCIP_SET* set, /**< global SCIP settings */ 952 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 953 SCIP_LPISTATE* lpistate, /**< LP state information (like basis information) */ 954 SCIP_Bool wasprimfeas, /**< primal feasibility when LP state information was stored */ 955 SCIP_Bool wasprimchecked, /**< true if the LP solution has passed the primal feasibility check */ 956 SCIP_Bool wasdualfeas, /**< dual feasibility when LP state information was stored */ 957 SCIP_Bool wasdualchecked /**< true if the LP solution has passed the dual feasibility check */ 958 ); 959 960 /** frees LP state information */ 961 SCIP_RETCODE SCIPlpFreeState( 962 SCIP_LP* lp, /**< LP data */ 963 BMS_BLKMEM* blkmem, /**< block memory */ 964 SCIP_LPISTATE** lpistate /**< pointer to LP state information (like basis information) */ 965 ); 966 967 /** stores pricing norms into LP norms object */ 968 SCIP_RETCODE SCIPlpGetNorms( 969 SCIP_LP* lp, /**< LP data */ 970 BMS_BLKMEM* blkmem, /**< block memory */ 971 SCIP_LPINORMS** lpinorms /**< pointer to LP pricing norms information */ 972 ); 973 974 /** loads pricing norms from LP norms object into solver */ 975 SCIP_RETCODE SCIPlpSetNorms( 976 SCIP_LP* lp, /**< LP data */ 977 BMS_BLKMEM* blkmem, /**< block memory */ 978 SCIP_LPINORMS* lpinorms /**< LP pricing norms information */ 979 ); 980 981 /** frees pricing norms information */ 982 SCIP_RETCODE SCIPlpFreeNorms( 983 SCIP_LP* lp, /**< LP data */ 984 BMS_BLKMEM* blkmem, /**< block memory */ 985 SCIP_LPINORMS** lpinorms /**< pointer to LP pricing norms information */ 986 ); 987 988 /** return the current cutoff bound of the lp */ 989 SCIP_Real SCIPlpGetCutoffbound( 990 SCIP_LP* lp /**< current LP data */ 991 ); 992 993 /** sets the upper objective limit of the LP solver */ 994 SCIP_RETCODE SCIPlpSetCutoffbound( 995 SCIP_LP* lp, /**< current LP data */ 996 SCIP_SET* set, /**< global SCIP settings */ 997 SCIP_PROB* prob, /**< problem data */ 998 SCIP_Real cutoffbound /**< new upper objective limit */ 999 ); 1000 1001 /** gets current primal feasibility tolerance of LP solver */ 1002 SCIP_Real SCIPlpGetFeastol( 1003 SCIP_LP* lp /**< current LP data */ 1004 ); 1005 1006 /** sets primal feasibility tolerance of LP solver */ 1007 void SCIPlpSetFeastol( 1008 SCIP_LP* lp, /**< current LP data */ 1009 SCIP_SET* set, /**< global SCIP settings */ 1010 SCIP_Real newfeastol /**< new primal feasibility tolerance for LP */ 1011 ); 1012 1013 /** resets primal feasibility tolerance of LP solver 1014 * 1015 * Sets primal feasibility tolerance to min of numerics/lpfeastolfactor * numerics/feastol and relaxfeastol. 1016 */ 1017 void SCIPlpResetFeastol( 1018 SCIP_LP* lp, /**< current LP data */ 1019 SCIP_SET* set /**< global SCIP settings */ 1020 ); 1021 1022 /** applies all cached changes to the LP solver */ 1023 SCIP_RETCODE SCIPlpFlush( 1024 SCIP_LP* lp, /**< current LP data */ 1025 BMS_BLKMEM* blkmem, /**< block memory */ 1026 SCIP_SET* set, /**< global SCIP settings */ 1027 SCIP_EVENTQUEUE* eventqueue /**< event queue */ 1028 ); 1029 1030 /** marks the LP to be flushed, even if the LP thinks it is not flushed */ 1031 SCIP_RETCODE SCIPlpMarkFlushed( 1032 SCIP_LP* lp, /**< current LP data */ 1033 SCIP_SET* set /**< global SCIP settings */ 1034 ); 1035 1036 /** solves the LP with simplex algorithm, and copy the solution into the column's data */ 1037 SCIP_RETCODE SCIPlpSolveAndEval( 1038 SCIP_LP* lp, /**< LP data */ 1039 SCIP_SET* set, /**< global SCIP settings */ 1040 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 1041 BMS_BLKMEM* blkmem, /**< block memory buffers */ 1042 SCIP_STAT* stat, /**< problem statistics */ 1043 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 1044 SCIP_EVENTFILTER* eventfilter, /**< global event filter */ 1045 SCIP_PROB* prob, /**< problem data */ 1046 SCIP_Longint itlim, /**< maximal number of LP iterations to perform, or -1 for no limit */ 1047 SCIP_Bool limitresolveiters, /**< should LP iterations for resolving calls be limited? 1048 * (limit is computed within the method w.r.t. the average LP iterations) */ 1049 SCIP_Bool aging, /**< should aging and removal of obsolete cols/rows be applied? */ 1050 SCIP_Bool keepsol, /**< should the old LP solution be kept if no iterations were performed? */ 1051 SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred */ 1052 ); 1053 1054 /** gets solution status of current LP */ 1055 SCIP_LPSOLSTAT SCIPlpGetSolstat( 1056 SCIP_LP* lp /**< current LP data */ 1057 ); 1058 1059 /** sets whether the root LP is a relaxation of the problem and its optimal objective value is a global lower bound */ 1060 void SCIPlpSetRootLPIsRelax( 1061 SCIP_LP* lp, /**< LP data */ 1062 SCIP_Bool isrelax /**< is the root lp a relaxation of the problem? */ 1063 ); 1064 1065 /** returns whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound */ 1066 SCIP_Bool SCIPlpIsRootLPRelax( 1067 SCIP_LP* lp /**< LP data */ 1068 ); 1069 1070 /** gets objective value of current LP 1071 * 1072 * @note This method returns the objective value of the current LP solution, which might be primal or dual infeasible 1073 * if a limit was hit during solving. It must not be used as a dual bound if the LP solution status is 1074 * SCIP_LPSOLSTAT_ITERLIMIT or SCIP_LPSOLSTAT_TIMELIMIT. 1075 */ 1076 SCIP_Real SCIPlpGetObjval( 1077 SCIP_LP* lp, /**< current LP data */ 1078 SCIP_SET* set, /**< global SCIP settings */ 1079 SCIP_PROB* prob /**< problem data */ 1080 ); 1081 1082 /** gets part of objective value of current LP that results from COLUMN variables only */ 1083 SCIP_Real SCIPlpGetColumnObjval( 1084 SCIP_LP* lp /**< current LP data */ 1085 ); 1086 1087 /** gets part of objective value of current LP that results from LOOSE variables only */ 1088 SCIP_Real SCIPlpGetLooseObjval( 1089 SCIP_LP* lp, /**< current LP data */ 1090 SCIP_SET* set, /**< global SCIP settings */ 1091 SCIP_PROB* prob /**< problem data */ 1092 ); 1093 1094 /** remembers the current LP objective value as root solution value */ 1095 void SCIPlpStoreRootObjval( 1096 SCIP_LP* lp, /**< current LP data */ 1097 SCIP_SET* set, /**< global SCIP settings */ 1098 SCIP_PROB* prob /**< problem data */ 1099 ); 1100 1101 /** invalidates the root LP solution value */ 1102 void SCIPlpInvalidateRootObjval( 1103 SCIP_LP* lp /**< current LP data */ 1104 ); 1105 1106 /** gets the global pseudo objective value; that is all variables set to their best (w.r.t. the objective function) 1107 * global bound 1108 */ 1109 SCIP_Real SCIPlpGetGlobalPseudoObjval( 1110 SCIP_LP* lp, /**< current LP data */ 1111 SCIP_SET* set, /**< global SCIP settings */ 1112 SCIP_PROB* prob /**< problem data */ 1113 ); 1114 1115 /** recomputes local and global pseudo objective values */ 1116 void SCIPlpRecomputeLocalAndGlobalPseudoObjval( 1117 SCIP_LP* lp, /**< current LP data */ 1118 SCIP_SET* set, /**< global SCIP settings */ 1119 SCIP_PROB* prob /**< problem data */ 1120 ); 1121 1122 /** gets the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the 1123 * objective function) local bound 1124 */ 1125 SCIP_Real SCIPlpGetPseudoObjval( 1126 SCIP_LP* lp, /**< current LP data */ 1127 SCIP_SET* set, /**< global SCIP settings */ 1128 SCIP_PROB* prob /**< problem data */ 1129 ); 1130 1131 /** gets pseudo objective value, if a bound of the given variable would be modified in the given way */ 1132 SCIP_Real SCIPlpGetModifiedPseudoObjval( 1133 SCIP_LP* lp, /**< current LP data */ 1134 SCIP_SET* set, /**< global SCIP settings */ 1135 SCIP_PROB* prob, /**< problem data */ 1136 SCIP_VAR* var, /**< problem variable */ 1137 SCIP_Real oldbound, /**< old value for bound */ 1138 SCIP_Real newbound, /**< new value for bound */ 1139 SCIP_BOUNDTYPE boundtype /**< type of bound: lower or upper bound */ 1140 ); 1141 1142 /** gets pseudo objective value, if a bound of the given variable would be modified in the given way; 1143 * perform calculations with interval arithmetic to get an exact lower bound 1144 */ 1145 SCIP_Real SCIPlpGetModifiedProvedPseudoObjval( 1146 SCIP_LP* lp, /**< current LP data */ 1147 SCIP_SET* set, /**< global SCIP settings */ 1148 SCIP_VAR* var, /**< problem variable */ 1149 SCIP_Real oldbound, /**< old value for bound */ 1150 SCIP_Real newbound, /**< new value for bound */ 1151 SCIP_BOUNDTYPE boundtype /**< type of bound: lower or upper bound */ 1152 ); 1153 1154 /** updates current pseudo and loose objective value for a change in a variable's objective coefficient */ 1155 SCIP_RETCODE SCIPlpUpdateVarObj( 1156 SCIP_LP* lp, /**< current LP data */ 1157 SCIP_SET* set, /**< global SCIP settings */ 1158 SCIP_VAR* var, /**< problem variable that changed */ 1159 SCIP_Real oldobj, /**< old objective coefficient of variable */ 1160 SCIP_Real newobj /**< new objective coefficient of variable */ 1161 ); 1162 1163 /** updates current root pseudo objective value for a global change in a variable's lower bound */ 1164 SCIP_RETCODE SCIPlpUpdateVarLbGlobal( 1165 SCIP_LP* lp, /**< current LP data */ 1166 SCIP_SET* set, /**< global SCIP settings */ 1167 SCIP_VAR* var, /**< problem variable that changed */ 1168 SCIP_Real oldlb, /**< old lower bound of variable */ 1169 SCIP_Real newlb /**< new lower bound of variable */ 1170 ); 1171 1172 /** updates current pseudo and loose objective value for a change in a variable's lower bound */ 1173 SCIP_RETCODE SCIPlpUpdateVarLb( 1174 SCIP_LP* lp, /**< current LP data */ 1175 SCIP_SET* set, /**< global SCIP settings */ 1176 SCIP_VAR* var, /**< problem variable that changed */ 1177 SCIP_Real oldlb, /**< old lower bound of variable */ 1178 SCIP_Real newlb /**< new lower bound of variable */ 1179 ); 1180 1181 /** updates current root pseudo objective value for a global change in a variable's upper bound */ 1182 SCIP_RETCODE SCIPlpUpdateVarUbGlobal( 1183 SCIP_LP* lp, /**< current LP data */ 1184 SCIP_SET* set, /**< global SCIP settings */ 1185 SCIP_VAR* var, /**< problem variable that changed */ 1186 SCIP_Real oldub, /**< old upper bound of variable */ 1187 SCIP_Real newub /**< new upper bound of variable */ 1188 ); 1189 1190 /** updates current pseudo objective value for a change in a variable's upper bound */ 1191 SCIP_RETCODE SCIPlpUpdateVarUb( 1192 SCIP_LP* lp, /**< current LP data */ 1193 SCIP_SET* set, /**< global SCIP settings */ 1194 SCIP_VAR* var, /**< problem variable that changed */ 1195 SCIP_Real oldub, /**< old upper bound of variable */ 1196 SCIP_Real newub /**< new upper bound of variable */ 1197 ); 1198 1199 /** informs LP, that given variable was added to the problem */ 1200 SCIP_RETCODE SCIPlpUpdateAddVar( 1201 SCIP_LP* lp, /**< current LP data */ 1202 SCIP_SET* set, /**< global SCIP settings */ 1203 SCIP_VAR* var /**< variable that is now a LOOSE problem variable */ 1204 ); 1205 1206 /** informs LP, that given variable is to be deleted from the problem */ 1207 SCIP_RETCODE SCIPlpUpdateDelVar( 1208 SCIP_LP* lp, /**< current LP data */ 1209 SCIP_SET* set, /**< global SCIP settings */ 1210 SCIP_VAR* var /**< variable that will be deleted from the problem */ 1211 ); 1212 1213 /** informs LP, that given formerly loose problem variable is now a column variable */ 1214 SCIP_RETCODE SCIPlpUpdateVarColumn( 1215 SCIP_LP* lp, /**< current LP data */ 1216 SCIP_SET* set, /**< global SCIP settings */ 1217 SCIP_VAR* var /**< problem variable that changed from LOOSE to COLUMN */ 1218 ); 1219 1220 /** informs LP, that given formerly column problem variable is now again a loose variable */ 1221 SCIP_RETCODE SCIPlpUpdateVarLoose( 1222 SCIP_LP* lp, /**< current LP data */ 1223 SCIP_SET* set, /**< global SCIP settings */ 1224 SCIP_VAR* var /**< problem variable that changed from COLUMN to LOOSE */ 1225 ); 1226 1227 /** decrease the number of loose variables by one */ 1228 void SCIPlpDecNLoosevars( 1229 SCIP_LP* lp /**< current LP data */ 1230 ); 1231 1232 /** stores the LP solution in the columns and rows */ 1233 SCIP_RETCODE SCIPlpGetSol( 1234 SCIP_LP* lp, /**< current LP data */ 1235 SCIP_SET* set, /**< global SCIP settings */ 1236 SCIP_STAT* stat, /**< problem statistics */ 1237 SCIP_Bool* primalfeasible, /**< pointer to store whether the solution is primal feasible, or NULL */ 1238 SCIP_Bool* dualfeasible /**< pointer to store whether the solution is dual feasible, or NULL */ 1239 ); 1240 1241 /** stores LP solution with infinite objective value in the columns and rows */ 1242 SCIP_RETCODE SCIPlpGetUnboundedSol( 1243 SCIP_LP* lp, /**< current LP data */ 1244 SCIP_SET* set, /**< global SCIP settings */ 1245 SCIP_STAT* stat, /**< problem statistics */ 1246 SCIP_Bool* primalfeasible, /**< pointer to store whether the solution is primal feasible, or NULL */ 1247 SCIP_Bool* rayfeasible /**< pointer to store whether the primal ray is a feasible unboundedness proof, or NULL */ 1248 ); 1249 1250 /** returns primal ray proving the unboundedness of the current LP */ 1251 SCIP_RETCODE SCIPlpGetPrimalRay( 1252 SCIP_LP* lp, /**< current LP data */ 1253 SCIP_SET* set, /**< global SCIP settings */ 1254 SCIP_Real* ray /**< array for storing primal ray values, they are stored w.r.t. the problem index of the variables, 1255 * so the size of this array should be at least number of active variables 1256 * (all entries have to be initialized to 0 before) */ 1257 ); 1258 1259 /** stores the dual Farkas multipliers for infeasibility proof in rows. besides, the proof is checked for validity if 1260 * lp/checkfarkas = TRUE. 1261 * 1262 * @note the check will not be performed if @p valid is NULL. 1263 */ 1264 SCIP_RETCODE SCIPlpGetDualfarkas( 1265 SCIP_LP* lp, /**< current LP data */ 1266 SCIP_SET* set, /**< global SCIP settings */ 1267 SCIP_STAT* stat, /**< problem statistics */ 1268 SCIP_Bool* valid /**< pointer to store whether the Farkas proof is valid or NULL */ 1269 ); 1270 1271 /** get number of iterations used in last LP solve */ 1272 SCIP_RETCODE SCIPlpGetIterations( 1273 SCIP_LP* lp, /**< current LP data */ 1274 int* iterations /**< pointer to store the iteration count */ 1275 ); 1276 1277 /** increases age of columns with solution value 0.0 and rows with activity not at its bounds, 1278 * resets age of non-zero columns and sharp rows 1279 */ 1280 SCIP_RETCODE SCIPlpUpdateAges( 1281 SCIP_LP* lp, /**< current LP data */ 1282 SCIP_STAT* stat /**< problem statistics */ 1283 ); 1284 1285 /** removes all non-basic columns and basic rows in the part of the LP created at the current node, that are too old */ 1286 SCIP_RETCODE SCIPlpRemoveNewObsoletes( 1287 SCIP_LP* lp, /**< current LP data */ 1288 BMS_BLKMEM* blkmem, /**< block memory buffers */ 1289 SCIP_SET* set, /**< global SCIP settings */ 1290 SCIP_STAT* stat, /**< problem statistics */ 1291 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 1292 SCIP_EVENTFILTER* eventfilter /**< global event filter */ 1293 ); 1294 1295 /** removes all non-basic columns and basic rows in whole LP, that are too old */ 1296 SCIP_RETCODE SCIPlpRemoveAllObsoletes( 1297 SCIP_LP* lp, /**< current LP data */ 1298 BMS_BLKMEM* blkmem, /**< block memory buffers */ 1299 SCIP_SET* set, /**< global SCIP settings */ 1300 SCIP_STAT* stat, /**< problem statistics */ 1301 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 1302 SCIP_EVENTFILTER* eventfilter /**< global event filter */ 1303 ); 1304 1305 /** removes all non-basic columns at 0.0 and basic rows in the part of the LP created at the current node */ 1306 SCIP_RETCODE SCIPlpCleanupNew( 1307 SCIP_LP* lp, /**< current LP data */ 1308 BMS_BLKMEM* blkmem, /**< block memory buffers */ 1309 SCIP_SET* set, /**< global SCIP settings */ 1310 SCIP_STAT* stat, /**< problem statistics */ 1311 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 1312 SCIP_EVENTFILTER* eventfilter, /**< global event filter */ 1313 SCIP_Bool root /**< are we at the root node? */ 1314 ); 1315 1316 /** removes all non-basic columns at 0.0 and basic rows in the whole LP */ 1317 SCIP_RETCODE SCIPlpCleanupAll( 1318 SCIP_LP* lp, /**< current LP data */ 1319 BMS_BLKMEM* blkmem, /**< block memory buffers */ 1320 SCIP_SET* set, /**< global SCIP settings */ 1321 SCIP_STAT* stat, /**< problem statistics */ 1322 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 1323 SCIP_EVENTFILTER* eventfilter, /**< global event filter */ 1324 SCIP_Bool root /**< are we at the root node? */ 1325 ); 1326 1327 /** removes all redundant rows that were added at the current node */ 1328 SCIP_RETCODE SCIPlpRemoveRedundantRows( 1329 SCIP_LP* lp, /**< current LP data */ 1330 BMS_BLKMEM* blkmem, /**< block memory buffers */ 1331 SCIP_SET* set, /**< global SCIP settings */ 1332 SCIP_STAT* stat, /**< problem statistics */ 1333 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 1334 SCIP_EVENTFILTER* eventfilter /**< global event filter */ 1335 ); 1336 1337 /** initiates LP diving */ 1338 SCIP_RETCODE SCIPlpStartDive( 1339 SCIP_LP* lp, /**< current LP data */ 1340 BMS_BLKMEM* blkmem, /**< block memory */ 1341 SCIP_SET* set, /**< global SCIP settings */ 1342 SCIP_STAT* stat /**< problem statistics */ 1343 ); 1344 1345 /** quits LP diving and resets bounds and objective values of columns to the current node's values */ 1346 SCIP_RETCODE SCIPlpEndDive( 1347 SCIP_LP* lp, /**< current LP data */ 1348 BMS_BLKMEM* blkmem, /**< block memory */ 1349 SCIP_SET* set, /**< global SCIP settings */ 1350 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 1351 SCIP_STAT* stat, /**< problem statistics */ 1352 SCIP_EVENTQUEUE* eventqueue, /**< event queue */ 1353 SCIP_EVENTFILTER* eventfilter, /**< global event filter */ 1354 SCIP_PROB* prob, /**< problem data */ 1355 SCIP_VAR** vars, /**< array with all active variables */ 1356 int nvars /**< number of active variables */ 1357 ); 1358 1359 /** records a current row side such that any change will be undone after diving */ 1360 SCIP_RETCODE SCIPlpRecordOldRowSideDive( 1361 SCIP_LP* lp, /**< LP data object */ 1362 SCIP_ROW* row, /**< row affected by the change */ 1363 SCIP_SIDETYPE sidetype /**< side type */ 1364 ); 1365 1366 /** informs the LP that probing mode was initiated */ 1367 SCIP_RETCODE SCIPlpStartProbing( 1368 SCIP_LP* lp /**< current LP data */ 1369 ); 1370 1371 /** informs the LP that probing mode was finished */ 1372 SCIP_RETCODE SCIPlpEndProbing( 1373 SCIP_LP* lp /**< current LP data */ 1374 ); 1375 1376 /** informs the LP that the probing mode is now used for strongbranching */ 1377 void SCIPlpStartStrongbranchProbing( 1378 SCIP_LP* lp /**< current LP data */ 1379 ); 1380 1381 /** informs the LP that the probing mode is not used for strongbranching anymore */ 1382 void SCIPlpEndStrongbranchProbing( 1383 SCIP_LP* lp /**< current LP data */ 1384 ); 1385 1386 /** gets proven lower (dual) bound of last LP solution */ 1387 SCIP_RETCODE SCIPlpGetProvedLowerbound( 1388 SCIP_LP* lp, /**< current LP data */ 1389 SCIP_SET* set, /**< global SCIP settings */ 1390 SCIP_Real* bound /**< pointer to store proven dual bound */ 1391 ); 1392 1393 /** gets proven dual bound of last LP solution */ 1394 SCIP_RETCODE SCIPlpIsInfeasibilityProved( 1395 SCIP_LP* lp, /**< current LP data */ 1396 SCIP_SET* set, /**< global SCIP settings */ 1397 SCIP_Bool* proved /**< pointer to store whether infeasibility is proven */ 1398 ); 1399 1400 /** writes LP to a file */ 1401 SCIP_RETCODE SCIPlpWrite( 1402 SCIP_LP* lp, /**< current LP data */ 1403 const char* fname /**< file name */ 1404 ); 1405 1406 /** writes MIP to a file */ 1407 SCIP_RETCODE SCIPlpWriteMip( 1408 SCIP_LP* lp, /**< current LP data */ 1409 SCIP_SET* set, /**< global SCIP settings */ 1410 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 1411 const char* fname, /**< file name */ 1412 SCIP_Bool genericnames, /**< should generic names like x_i and row_j be used in order to avoid 1413 * troubles with reserved symbols? */ 1414 SCIP_Bool origobj, /**< should the original objective function be used? */ 1415 SCIP_OBJSENSE objsense, /**< objective sense */ 1416 SCIP_Real objscale, /**< objective scaling factor */ 1417 SCIP_Real objoffset, /**< objective offset, e.g., caused by variable fixings in presolving */ 1418 SCIP_Bool lazyconss /**< output removable rows as lazy constraints? */ 1419 ); 1420 1421 /** recalculates Euclidean norm of objective function vector of column variables if it have gotten unreliable during calculation */ 1422 void SCIPlpRecalculateObjSqrNorm( 1423 SCIP_SET* set, /**< global SCIP settings */ 1424 SCIP_LP* lp /**< LP data */ 1425 ); 1426 1427 /** compute relative interior point */ 1428 SCIP_RETCODE SCIPlpComputeRelIntPoint( 1429 SCIP_SET* set, /**< global SCIP settings */ 1430 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */ 1431 SCIP_LP* lp, /**< LP data */ 1432 SCIP_PROB* prob, /**< problem data */ 1433 SCIP_Bool relaxrows, /**< should the rows be relaxed */ 1434 SCIP_Bool inclobjcutoff, /**< should a row for the objective cutoff be included */ 1435 SCIP_Real timelimit, /**< time limit for LP solver */ 1436 int iterlimit, /**< iteration limit for LP solver */ 1437 SCIP_Real* point, /**< array to store relative interior point on exit */ 1438 SCIP_Bool* success /**< buffer to indicate whether interior point was successfully computed */ 1439 ); 1440 1441 /** computes the changes to the problem when fixing to the optimal face 1442 * 1443 * returns the degeneracy rate, i.e., the number of nonbasic variables with reduced cost 0 1444 * and the variable constraint ratio, i.e., the number of unfixed variables in relation to the basis size 1445 */ 1446 SCIP_RETCODE SCIPlpGetDegeneracy( 1447 SCIP_LP* lp, /**< LP data */ 1448 SCIP_SET* set, /**< global SCIP settings */ 1449 SCIP_STAT* stat, /**< problem statistics */ 1450 SCIP_Real* degeneracy, /**< pointer to store degeneracy share */ 1451 SCIP_Real* varconsratio /**< pointer to store variable constraint ratio */ 1452 ); 1453 1454 /** gets array with columns of the LP */ 1455 SCIP_COL** SCIPlpGetCols( 1456 SCIP_LP* lp /**< current LP data */ 1457 ); 1458 1459 /** gets current number of columns in LP */ 1460 int SCIPlpGetNCols( 1461 SCIP_LP* lp /**< current LP data */ 1462 ); 1463 1464 /** gets array with rows of the LP */ 1465 SCIP_ROW** SCIPlpGetRows( 1466 SCIP_LP* lp /**< current LP data */ 1467 ); 1468 1469 /** gets current number of rows in LP */ 1470 int SCIPlpGetNRows( 1471 SCIP_LP* lp /**< current LP data */ 1472 ); 1473 1474 /** gets array with newly added columns after the last mark */ 1475 SCIP_COL** SCIPlpGetNewcols( 1476 SCIP_LP* lp /**< current LP data */ 1477 ); 1478 1479 /** gets number of newly added columns after the last mark */ 1480 int SCIPlpGetNNewcols( 1481 SCIP_LP* lp /**< current LP data */ 1482 ); 1483 1484 /** gets array with newly added rows after the last mark */ 1485 SCIP_ROW** SCIPlpGetNewrows( 1486 SCIP_LP* lp /**< current LP data */ 1487 ); 1488 1489 /** gets number of newly added rows after the last mark */ 1490 int SCIPlpGetNNewrows( 1491 SCIP_LP* lp /**< current LP data */ 1492 ); 1493 1494 /** gets Euclidean norm of objective function vector of column variables, only use this method if 1495 * lp->objsqrnormunreliable == FALSE, so probably you have to call SCIPlpRecalculateObjSqrNorm before */ 1496 SCIP_Real SCIPlpGetObjNorm( 1497 SCIP_LP* lp /**< LP data */ 1498 ); 1499 1500 /** gets the objective value of the root node LP; returns SCIP_INVALID if the root node LP was not (yet) solved */ 1501 SCIP_Real SCIPlpGetRootObjval( 1502 SCIP_LP* lp /**< LP data */ 1503 ); 1504 1505 /** gets part of the objective value of the root node LP that results from COLUMN variables only; 1506 * returns SCIP_INVALID if the root node LP was not (yet) solved 1507 */ 1508 SCIP_Real SCIPlpGetRootColumnObjval( 1509 SCIP_LP* lp /**< LP data */ 1510 ); 1511 1512 /** gets part of the objective value of the root node LP that results from LOOSE variables only; 1513 * returns SCIP_INVALID if the root node LP was not (yet) solved 1514 */ 1515 SCIP_Real SCIPlpGetRootLooseObjval( 1516 SCIP_LP* lp /**< LP data */ 1517 ); 1518 1519 /** gets the LP solver interface */ 1520 SCIP_LPI* SCIPlpGetLPI( 1521 SCIP_LP* lp /**< current LP data */ 1522 ); 1523 1524 /** sets whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound */ 1525 void SCIPlpSetIsRelax( 1526 SCIP_LP* lp, /**< LP data */ 1527 SCIP_Bool relax /**< is the current lp a relaxation? */ 1528 ); 1529 1530 /** returns whether the current LP is a relaxation of the problem for which it has been solved and its 1531 * solution value a valid local lower bound? 1532 */ 1533 SCIP_Bool SCIPlpIsRelax( 1534 SCIP_LP* lp /**< LP data */ 1535 ); 1536 1537 /** returns whether the current LP is flushed and solved */ 1538 SCIP_Bool SCIPlpIsSolved( 1539 SCIP_LP* lp /**< current LP data */ 1540 ); 1541 1542 /** return whether the current LP solution passed the primal feasibility check */ 1543 SCIP_Bool SCIPlpIsPrimalReliable( 1544 SCIP_LP* lp /**< current LP data */ 1545 ); 1546 1547 /** return whether the current LP solution passed the dual feasibility check */ 1548 SCIP_Bool SCIPlpIsDualReliable( 1549 SCIP_LP* lp /**< current LP data */ 1550 ); 1551 1552 /** returns whether the current LP solution is a basic solution */ 1553 SCIP_Bool SCIPlpIsSolBasic( 1554 SCIP_LP* lp /**< current LP data */ 1555 ); 1556 1557 /** returns whether the LP is in diving mode */ 1558 SCIP_Bool SCIPlpDiving( 1559 SCIP_LP* lp /**< current LP data */ 1560 ); 1561 1562 /** returns whether the LP is in diving mode and the objective value of at least one column was changed */ 1563 SCIP_Bool SCIPlpDivingObjChanged( 1564 SCIP_LP* lp /**< current LP data */ 1565 ); 1566 1567 /** marks the diving LP to have a changed objective function */ 1568 void SCIPlpMarkDivingObjChanged( 1569 SCIP_LP* lp /**< current LP data */ 1570 ); 1571 1572 /** marks the diving LP to not have a changed objective function anymore */ 1573 void SCIPlpUnmarkDivingObjChanged( 1574 SCIP_LP* lp /**< current LP data */ 1575 ); 1576 1577 /* returns TRUE if at least one left/right hand side of an LP row was changed during diving mode */ 1578 SCIP_Bool SCIPlpDivingRowsChanged( 1579 SCIP_LP* lp /**< current LP data */ 1580 ); 1581 1582 1583 #ifdef NDEBUG 1584 1585 /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and 1586 * speed up the algorithms. 1587 */ 1588 1589 #define SCIPlpGetCols(lp) ((lp)->cols) 1590 #define SCIPlpGetNCols(lp) ((lp)->ncols) 1591 #define SCIPlpGetRows(lp) ((lp)->rows) 1592 #define SCIPlpGetNRows(lp) ((lp)->nrows) 1593 #define SCIPlpGetNewcols(lp) (&((lp)->cols[(lp)->firstnewcol])) 1594 #define SCIPlpGetNNewcols(lp) ((lp)->ncols - (lp)->firstnewcol) 1595 #define SCIPlpGetNewrows(lp) (&((lp)->rows[(lp)->firstnewrow])) 1596 #define SCIPlpGetNNewrows(lp) ((lp)->nrows - (lp)->firstnewrow) 1597 #define SCIPlpGetObjNorm(lp) (SQRT((lp)->objsqrnorm)) 1598 #define SCIPlpGetRootObjval(lp) (MIN((lp)->rootlpobjval + (lp)->rootlooseobjval, SCIP_INVALID)) 1599 #define SCIPlpGetRootColumnObjval(lp) ((lp)->rootlpobjval) 1600 #define SCIPlpGetRootLooseObjval(lp) ((lp)->rootlooseobjval) 1601 #define SCIPlpGetLPI(lp) (lp)->lpi 1602 #define SCIPlpSetIsRelax(lp,relax) ((lp)->isrelax = relax) 1603 #define SCIPlpIsRelax(lp) (lp)->isrelax 1604 #define SCIPlpIsSolved(lp) ((lp)->flushed && (lp)->solved) 1605 #define SCIPlpIsSolBasic(lp) ((lp)->solisbasic) 1606 #define SCIPlpDiving(lp) (lp)->diving 1607 #define SCIPlpDivingObjChanged(lp) (lp)->divingobjchg 1608 #define SCIPlpMarkDivingObjChanged(lp) ((lp)->divingobjchg = TRUE) 1609 #define SCIPlpUnmarkDivingObjChanged(lp) ((lp)->divingobjchg = FALSE) 1610 #define SCIPlpDivingRowsChanged(lp) ((lp)->ndivechgsides > 0) 1611 1612 #endif 1613 1614 #ifdef __cplusplus 1615 } 1616 #endif 1617 1618 #endif 1619