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 lpi_none.c 26 * @ingroup LPIS 27 * @brief dummy interface for the case no LP solver is needed 28 * @author Stefan Heinz 29 */ 30 31 /*--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/ 32 33 #include <assert.h> 34 35 #include "lpi/lpi.h" 36 #include "scip/pub_message.h" 37 38 #define LPINAME "NONE" /**< name of the LPI interface */ 39 #define LPIINFINITY 1e20 /**< infinity value */ 40 41 42 /* globally turn off lint warnings: */ 43 /*lint --e{715}*/ 44 45 /** LP interface 46 * 47 * Store several statistic values about the LP. These values are only needed in order to provide a rudimentary 48 * communication, e.g., there are asserts that check the number of rows and columns. 49 */ 50 struct SCIP_LPi 51 { 52 int nrows; /**< number of rows */ 53 int ncols; /**< number of columns */ 54 }; 55 56 57 /* 58 * Local Methods 59 */ 60 61 /** error handling method */ 62 static 63 void errorMessageAbort( 64 void 65 ) 66 { /*lint --e{2707}*/ 67 SCIPerrorMessage("No LP solver available (LPS=none).\n"); 68 SCIPerrorMessage("Ensure <lp/solvefreq = -1>; note that continuous variables might require an LP-solver.\n"); 69 SCIPABORT(); 70 } 71 72 /** error handling method */ 73 static 74 void errorMessage( 75 void 76 ) 77 { 78 SCIPerrorMessage("No LP solver available (LPS=none).\n"); 79 SCIPerrorMessage("Ensure <lp/solvefreq = -1>; note that continuous variables might require an LP-solver.\n"); 80 } 81 82 /* 83 * LP Interface Methods 84 */ 85 86 87 /* 88 * Miscellaneous Methods 89 */ 90 91 /**@name Miscellaneous Methods */ 92 /**@{ */ 93 94 /** gets name and version of LP solver */ 95 const char* SCIPlpiGetSolverName( 96 void 97 ) 98 { 99 return LPINAME; 100 } 101 102 /** gets description of LP solver (developer, webpage, ...) */ 103 const char* SCIPlpiGetSolverDesc( 104 void 105 ) 106 { 107 return "dummy LP solver interface which solely purpose is to resolve references at linking"; 108 } 109 110 /** gets pointer for LP solver - use only with great care */ 111 void* SCIPlpiGetSolverPointer( 112 SCIP_LPI* lpi /**< pointer to an LP interface structure */ 113 ) 114 { /*lint --e{715}*/ 115 return (void*) NULL; 116 } 117 118 /** pass integrality information to LP solver */ 119 SCIP_RETCODE SCIPlpiSetIntegralityInformation( 120 SCIP_LPI* lpi, /**< pointer to an LP interface structure */ 121 int ncols, /**< length of integrality array */ 122 int* intInfo /**< integrality array (0: continuous, 1: integer). May be NULL iff ncols is 0. */ 123 ) 124 { /*lint --e{715}*/ 125 SCIPerrorMessage("SCIPlpiSetIntegralityInformation() has not been implemented yet.\n"); 126 return SCIP_LPERROR; 127 } 128 129 /** informs about availability of a primal simplex solving method */ 130 SCIP_Bool SCIPlpiHasPrimalSolve( 131 void 132 ) 133 { 134 return FALSE; 135 } 136 137 /** informs about availability of a dual simplex solving method */ 138 SCIP_Bool SCIPlpiHasDualSolve( 139 void 140 ) 141 { 142 return FALSE; 143 } 144 145 /** informs about availability of a barrier solving method */ 146 SCIP_Bool SCIPlpiHasBarrierSolve( 147 void 148 ) 149 { 150 return FALSE; 151 } 152 153 /**@} */ 154 155 156 157 158 /* 159 * LPI Creation and Destruction Methods 160 */ 161 162 /**@name LPI Creation and Destruction Methods */ 163 /**@{ */ 164 165 /** creates an LP problem object */ 166 SCIP_RETCODE SCIPlpiCreate( 167 SCIP_LPI** lpi, /**< pointer to an LP interface structure */ 168 SCIP_MESSAGEHDLR* messagehdlr, /**< message handler to use for printing messages, or NULL */ 169 const char* name, /**< problem name */ 170 SCIP_OBJSEN objsen /**< objective sense */ 171 ) 172 { /*lint --e{715}*/ 173 assert(lpi != NULL); 174 assert(name != NULL); 175 SCIPdebugMessage("SCIPlpiCreate()\n"); 176 SCIPdebugMessage("Note that there is no LP solver linked to the binary\n"); 177 178 /* create empty LPI */ 179 SCIP_ALLOC( BMSallocMemory(lpi) ); 180 (*lpi)->nrows = 0; 181 (*lpi)->ncols = 0; 182 183 return SCIP_OKAY; 184 } 185 186 /** deletes an LP problem object */ 187 SCIP_RETCODE SCIPlpiFree( 188 SCIP_LPI** lpi /**< pointer to an LP interface structure */ 189 ) 190 { /*lint --e{715}*/ 191 assert( lpi != NULL ); 192 SCIPdebugMessage("SCIPlpiFree()\n"); 193 194 BMSfreeMemory(lpi); 195 196 return SCIP_OKAY; 197 } 198 199 /**@} */ 200 201 202 203 204 /* 205 * Modification Methods 206 */ 207 208 /**@name Modification Methods */ 209 /**@{ */ 210 211 /** copies LP data with column matrix into LP solver */ 212 SCIP_RETCODE SCIPlpiLoadColLP( 213 SCIP_LPI* lpi, /**< LP interface structure */ 214 SCIP_OBJSEN objsen, /**< objective sense */ 215 int ncols, /**< number of columns */ 216 const SCIP_Real* obj, /**< objective function values of columns */ 217 const SCIP_Real* lb, /**< lower bounds of columns */ 218 const SCIP_Real* ub, /**< upper bounds of columns */ 219 char** colnames, /**< column names, or NULL */ 220 int nrows, /**< number of rows */ 221 const SCIP_Real* lhs, /**< left hand sides of rows */ 222 const SCIP_Real* rhs, /**< right hand sides of rows */ 223 char** rownames, /**< row names, or NULL */ 224 int nnonz, /**< number of nonzero elements in the constraint matrix */ 225 const int* beg, /**< start index of each column in ind- and val-array */ 226 const int* ind, /**< row indices of constraint matrix entries */ 227 const SCIP_Real* val /**< values of constraint matrix entries */ 228 ) 229 { /*lint --e{715}*/ 230 #ifndef NDEBUG 231 { 232 int j; 233 for( j = 0; j < nnonz; j++ ) 234 assert( val[j] != 0 ); 235 } 236 #endif 237 238 assert( lpi != NULL ); 239 assert(lhs != NULL); 240 assert(rhs != NULL); 241 assert(obj != NULL); 242 assert(lb != NULL); 243 assert(ub != NULL); 244 assert(beg != NULL); 245 assert(ind != NULL); 246 assert(val != NULL); 247 248 lpi->nrows = nrows; 249 lpi->ncols = ncols; 250 assert( lpi->nrows >= 0 ); 251 assert( lpi->ncols >= 0 ); 252 253 return SCIP_OKAY; 254 } 255 256 /** adds columns to the LP */ 257 SCIP_RETCODE SCIPlpiAddCols( 258 SCIP_LPI* lpi, /**< LP interface structure */ 259 int ncols, /**< number of columns to be added */ 260 const SCIP_Real* obj, /**< objective function values of new columns */ 261 const SCIP_Real* lb, /**< lower bounds of new columns */ 262 const SCIP_Real* ub, /**< upper bounds of new columns */ 263 char** colnames, /**< column names, or NULL */ 264 int nnonz, /**< number of nonzero elements to be added to the constraint matrix */ 265 const int* beg, /**< start index of each column in ind- and val-array, or NULL if nnonz == 0 */ 266 const int* ind, /**< row indices of constraint matrix entries, or NULL if nnonz == 0 */ 267 const SCIP_Real* val /**< values of constraint matrix entries, or NULL if nnonz == 0 */ 268 ) 269 { /*lint --e{715}*/ 270 assert( lpi != NULL ); 271 assert( lpi->ncols >= 0 ); 272 assert(obj != NULL); 273 assert(lb != NULL); 274 assert(ub != NULL); 275 assert(nnonz == 0 || beg != NULL); 276 assert(nnonz == 0 || ind != NULL); 277 assert(nnonz == 0 || val != NULL); 278 assert(nnonz >= 0); 279 assert(ncols >= 0); 280 281 #ifndef NDEBUG 282 { 283 int j; 284 for( j = 0; j < nnonz; j++ ) 285 { 286 assert( val[j] != 0.0 ); 287 /* perform check that no new rows are added - this is forbidden */ 288 assert( 0 <= ind[j] && ind[j] < lpi->nrows ); 289 } 290 } 291 #endif 292 293 lpi->ncols += ncols; 294 295 return SCIP_OKAY; 296 } 297 298 /** deletes all columns in the given range from LP */ 299 SCIP_RETCODE SCIPlpiDelCols( 300 SCIP_LPI* lpi, /**< LP interface structure */ 301 int firstcol, /**< first column to be deleted */ 302 int lastcol /**< last column to be deleted */ 303 ) 304 { /*lint --e{715}*/ 305 assert( lpi != NULL ); 306 assert( lpi->ncols >= 0 ); 307 308 lpi->ncols -= lastcol - firstcol + 1; 309 assert( lpi->ncols >= 0 ); 310 311 return SCIP_OKAY; 312 } 313 314 /** deletes columns from SCIP_LP; the new position of a column must not be greater that its old position */ 315 SCIP_RETCODE SCIPlpiDelColset( 316 SCIP_LPI* lpi, /**< LP interface structure */ 317 int* dstat /**< deletion status of columns 318 * input: 1 if column should be deleted, 0 if not 319 * output: new position of column, -1 if column was deleted */ 320 ) 321 { /*lint --e{715}*/ 322 int cnt = 0; 323 int j; 324 325 assert( lpi != NULL ); 326 assert( dstat != NULL ); 327 assert( lpi->ncols >= 0 ); 328 329 for (j = 0; j < lpi->ncols; ++j) 330 { 331 if ( dstat[j] ) 332 { 333 ++cnt; 334 dstat[j] = -1; 335 } 336 else 337 dstat[j] = cnt; 338 } 339 lpi->ncols -= cnt; 340 assert( lpi->ncols >= 0 ); 341 342 return SCIP_OKAY; 343 } 344 345 /** adds rows to the LP */ 346 SCIP_RETCODE SCIPlpiAddRows( 347 SCIP_LPI* lpi, /**< LP interface structure */ 348 int nrows, /**< number of rows to be added */ 349 const SCIP_Real* lhs, /**< left hand sides of new rows */ 350 const SCIP_Real* rhs, /**< right hand sides of new rows */ 351 char** rownames, /**< row names, or NULL */ 352 int nnonz, /**< number of nonzero elements to be added to the constraint matrix */ 353 const int* beg, /**< start index of each row in ind- and val-array, or NULL if nnonz == 0 */ 354 const int* ind, /**< column indices of constraint matrix entries, or NULL if nnonz == 0 */ 355 const SCIP_Real* val /**< values of constraint matrix entries, or NULL if nnonz == 0 */ 356 ) 357 { /*lint --e{715}*/ 358 assert( lpi != NULL ); 359 assert( lpi->nrows >= 0 ); 360 assert(lhs != NULL); 361 assert(rhs != NULL); 362 assert(nnonz == 0 || beg != NULL); 363 assert(nnonz == 0 || ind != NULL); 364 assert(nnonz == 0 || val != NULL); 365 366 #ifndef NDEBUG 367 /* perform check that no new columns are added - this is forbidden */ 368 { 369 int j; 370 for (j = 0; j < nnonz; ++j) 371 { 372 assert( val[j] != 0.0 ); 373 assert( 0 <= ind[j] && ind[j] < lpi->ncols ); 374 } 375 } 376 #endif 377 378 lpi->nrows += nrows; 379 380 return SCIP_OKAY; 381 } 382 383 /** deletes all rows in the given range from LP */ 384 SCIP_RETCODE SCIPlpiDelRows( 385 SCIP_LPI* lpi, /**< LP interface structure */ 386 int firstrow, /**< first row to be deleted */ 387 int lastrow /**< last row to be deleted */ 388 ) 389 { /*lint --e{715}*/ 390 assert( lpi != NULL ); 391 assert( lpi->nrows >= 0 ); 392 393 lpi->nrows -= lastrow - firstrow + 1; 394 assert( lpi->nrows >= 0 ); 395 396 return SCIP_OKAY; 397 } 398 399 /** deletes rows from SCIP_LP; the new position of a row must not be greater that its old position */ 400 SCIP_RETCODE SCIPlpiDelRowset( 401 SCIP_LPI* lpi, /**< LP interface structure */ 402 int* dstat /**< deletion status of rows 403 * input: 1 if row should be deleted, 0 if not 404 * output: new position of row, -1 if row was deleted */ 405 ) 406 { /*lint --e{715}*/ 407 int cnt = 0; 408 int i; 409 410 assert( lpi != NULL ); 411 assert( dstat != NULL ); 412 assert( lpi->nrows >= 0 ); 413 414 for (i = 0; i < lpi->nrows; ++i) 415 { 416 if ( dstat[i] ) 417 { 418 ++cnt; 419 dstat[i] = -1; 420 } 421 else 422 dstat[i] = cnt; 423 } 424 lpi->nrows -= cnt; 425 assert( lpi->nrows >= 0 ); 426 427 return SCIP_OKAY; 428 } 429 430 /** clears the whole LP */ 431 SCIP_RETCODE SCIPlpiClear( 432 SCIP_LPI* lpi /**< LP interface structure */ 433 ) 434 { /*lint --e{715}*/ 435 assert( lpi != NULL ); 436 assert( lpi->nrows >= 0 ); 437 assert( lpi->ncols >= 0 ); 438 439 lpi->nrows = 0; 440 lpi->ncols = 0; 441 442 return SCIP_OKAY; 443 } 444 445 /** changes lower and upper bounds of columns */ 446 SCIP_RETCODE SCIPlpiChgBounds( 447 SCIP_LPI* lpi, /**< LP interface structure */ 448 int ncols, /**< number of columns to change bounds for */ 449 const int* ind, /**< column indices or NULL if ncols is zero */ 450 const SCIP_Real* lb, /**< values for the new lower bounds or NULL if ncols is zero */ 451 const SCIP_Real* ub /**< values for the new upper bounds or NULL if ncols is zero */ 452 ) 453 { /*lint --e{715}*/ 454 int j; 455 456 assert(ncols == 0 || (ind != NULL && lb != NULL && ub != NULL)); 457 458 if( ncols <= 0 ) 459 return SCIP_OKAY; 460 461 for (j = 0; j < ncols; ++j) 462 { 463 if ( SCIPlpiIsInfinity(lpi, lb[j]) ) 464 { 465 SCIPerrorMessage("LP Error: fixing lower bound for variable %d to infinity.\n", ind[j]); 466 return SCIP_LPERROR; 467 } 468 if ( SCIPlpiIsInfinity(lpi, -ub[j]) ) 469 { 470 SCIPerrorMessage("LP Error: fixing upper bound for variable %d to -infinity.\n", ind[j]); 471 return SCIP_LPERROR; 472 } 473 } 474 475 return SCIP_OKAY; 476 } 477 478 /** changes left and right hand sides of rows */ 479 SCIP_RETCODE SCIPlpiChgSides( 480 SCIP_LPI* lpi, /**< LP interface structure */ 481 int nrows, /**< number of rows to change sides for */ 482 const int* ind, /**< row indices */ 483 const SCIP_Real* lhs, /**< new values for left hand sides */ 484 const SCIP_Real* rhs /**< new values for right hand sides */ 485 ) 486 { /*lint --e{715}*/ 487 assert(lpi != NULL); 488 assert(ind != NULL); 489 assert(lhs != NULL); 490 assert(rhs != NULL); 491 return SCIP_OKAY; 492 } 493 494 /** changes a single coefficient */ 495 SCIP_RETCODE SCIPlpiChgCoef( 496 SCIP_LPI* lpi, /**< LP interface structure */ 497 int row, /**< row number of coefficient to change */ 498 int col, /**< column number of coefficient to change */ 499 SCIP_Real newval /**< new value of coefficient */ 500 ) 501 { /*lint --e{715}*/ 502 assert(lpi != NULL); 503 return SCIP_OKAY; 504 } 505 506 /** changes the objective sense */ 507 SCIP_RETCODE SCIPlpiChgObjsen( 508 SCIP_LPI* lpi, /**< LP interface structure */ 509 SCIP_OBJSEN objsen /**< new objective sense */ 510 ) 511 { /*lint --e{715}*/ 512 assert(lpi != NULL); 513 return SCIP_OKAY; 514 } 515 516 /** changes objective values of columns in the LP */ 517 SCIP_RETCODE SCIPlpiChgObj( 518 SCIP_LPI* lpi, /**< LP interface structure */ 519 int ncols, /**< number of columns to change objective value for */ 520 const int* ind, /**< column indices to change objective value for */ 521 const SCIP_Real* obj /**< new objective values for columns */ 522 ) 523 { /*lint --e{715}*/ 524 assert(lpi != NULL); 525 assert(ind != NULL); 526 assert(obj != NULL); 527 return SCIP_OKAY; 528 } 529 530 /** multiplies a row with a non-zero scalar; for negative scalars, the row's sense is switched accordingly */ 531 SCIP_RETCODE SCIPlpiScaleRow( 532 SCIP_LPI* lpi, /**< LP interface structure */ 533 int row, /**< row number to scale */ 534 SCIP_Real scaleval /**< scaling multiplier */ 535 ) 536 { /*lint --e{715}*/ 537 assert(lpi != NULL); 538 return SCIP_OKAY; 539 } 540 541 /** multiplies a column with a non-zero scalar; the objective value is multiplied with the scalar, and the bounds 542 * are divided by the scalar; for negative scalars, the column's bounds are switched 543 */ 544 SCIP_RETCODE SCIPlpiScaleCol( 545 SCIP_LPI* lpi, /**< LP interface structure */ 546 int col, /**< column number to scale */ 547 SCIP_Real scaleval /**< scaling multiplier */ 548 ) 549 { /*lint --e{715}*/ 550 assert(lpi != NULL); 551 return SCIP_OKAY; 552 } 553 554 /**@} */ 555 556 557 558 559 /* 560 * Data Accessing Methods 561 */ 562 563 /**@name Data Accessing Methods */ 564 /**@{ */ 565 566 /** gets the number of rows in the LP */ 567 SCIP_RETCODE SCIPlpiGetNRows( 568 SCIP_LPI* lpi, /**< LP interface structure */ 569 int* nrows /**< pointer to store the number of rows */ 570 ) 571 { /*lint --e{715}*/ 572 assert( lpi != NULL ); 573 assert( nrows != NULL ); 574 assert( lpi->nrows >= 0 ); 575 576 *nrows = lpi->nrows; 577 578 return SCIP_OKAY; 579 } 580 581 /** gets the number of columns in the LP */ 582 SCIP_RETCODE SCIPlpiGetNCols( 583 SCIP_LPI* lpi, /**< LP interface structure */ 584 int* ncols /**< pointer to store the number of cols */ 585 ) 586 { /*lint --e{715}*/ 587 assert( lpi != NULL ); 588 assert( ncols != NULL ); 589 assert( lpi->ncols >= 0 ); 590 591 *ncols = lpi->ncols; 592 593 return SCIP_OKAY; 594 } 595 596 /** gets the number of nonzero elements in the LP constraint matrix */ 597 SCIP_RETCODE SCIPlpiGetNNonz( 598 SCIP_LPI* lpi, /**< LP interface structure */ 599 int* nnonz /**< pointer to store the number of nonzeros */ 600 ) 601 { /*lint --e{715}*/ 602 assert(nnonz != NULL); 603 assert(lpi != NULL); 604 errorMessage(); 605 return SCIP_PLUGINNOTFOUND; 606 } 607 608 /** gets columns from LP problem object; the arrays have to be large enough to store all values 609 * Either both, lb and ub, have to be NULL, or both have to be non-NULL, 610 * either nnonz, beg, ind, and val have to be NULL, or all of them have to be non-NULL. 611 */ 612 SCIP_RETCODE SCIPlpiGetCols( 613 SCIP_LPI* lpi, /**< LP interface structure */ 614 int firstcol, /**< first column to get from LP */ 615 int lastcol, /**< last column to get from LP */ 616 SCIP_Real* lb, /**< buffer to store the lower bound vector, or NULL */ 617 SCIP_Real* ub, /**< buffer to store the upper bound vector, or NULL */ 618 int* nnonz, /**< pointer to store the number of nonzero elements returned, or NULL */ 619 int* beg, /**< buffer to store start index of each column in ind- and val-array, or NULL */ 620 int* ind, /**< buffer to store row indices of constraint matrix entries, or NULL */ 621 SCIP_Real* val /**< buffer to store values of constraint matrix entries, or NULL */ 622 ) 623 { /*lint --e{715}*/ 624 errorMessage(); 625 return SCIP_PLUGINNOTFOUND; 626 } 627 628 /** gets rows from LP problem object; the arrays have to be large enough to store all values. 629 * Either both, lhs and rhs, have to be NULL, or both have to be non-NULL, 630 * either nnonz, beg, ind, and val have to be NULL, or all of them have to be non-NULL. 631 */ 632 SCIP_RETCODE SCIPlpiGetRows( 633 SCIP_LPI* lpi, /**< LP interface structure */ 634 int firstrow, /**< first row to get from LP */ 635 int lastrow, /**< last row to get from LP */ 636 SCIP_Real* lhs, /**< buffer to store left hand side vector, or NULL */ 637 SCIP_Real* rhs, /**< buffer to store right hand side vector, or NULL */ 638 int* nnonz, /**< pointer to store the number of nonzero elements returned, or NULL */ 639 int* beg, /**< buffer to store start index of each row in ind- and val-array, or NULL */ 640 int* ind, /**< buffer to store column indices of constraint matrix entries, or NULL */ 641 SCIP_Real* val /**< buffer to store values of constraint matrix entries, or NULL */ 642 ) 643 { /*lint --e{715}*/ 644 errorMessage(); 645 return SCIP_PLUGINNOTFOUND; 646 } 647 648 /** gets column names */ 649 SCIP_RETCODE SCIPlpiGetColNames( 650 SCIP_LPI* lpi, /**< LP interface structure */ 651 int firstcol, /**< first column to get name from LP */ 652 int lastcol, /**< last column to get name from LP */ 653 char** colnames, /**< pointers to column names (of size at least lastcol-firstcol+1) or NULL if namestoragesize is zero */ 654 char* namestorage, /**< storage for col names or NULL if namestoragesize is zero */ 655 int namestoragesize, /**< size of namestorage (if 0, storageleft returns the storage needed) */ 656 int* storageleft /**< amount of storage left (if < 0 the namestorage was not big enough) or NULL if namestoragesize is zero */ 657 ) 658 { /*lint --e{715}*/ 659 assert(lpi != NULL); 660 assert(colnames != NULL || namestoragesize == 0); 661 assert(namestorage != NULL || namestoragesize == 0); 662 assert(namestoragesize >= 0); 663 assert(storageleft != NULL); 664 errorMessage(); 665 return SCIP_PLUGINNOTFOUND; 666 } 667 668 /** gets row names */ 669 SCIP_RETCODE SCIPlpiGetRowNames( 670 SCIP_LPI* lpi, /**< LP interface structure */ 671 int firstrow, /**< first row to get name from LP */ 672 int lastrow, /**< last row to get name from LP */ 673 char** rownames, /**< pointers to row names (of size at least lastrow-firstrow+1) or NULL if namestoragesize is zero */ 674 char* namestorage, /**< storage for row names or NULL if namestoragesize is zero */ 675 int namestoragesize, /**< size of namestorage (if 0, -storageleft returns the storage needed) */ 676 int* storageleft /**< amount of storage left (if < 0 the namestorage was not big enough) or NULL if namestoragesize is zero */ 677 ) 678 { /*lint --e{715}*/ 679 assert(lpi != NULL); 680 assert(rownames != NULL || namestoragesize == 0); 681 assert(namestorage != NULL || namestoragesize == 0); 682 assert(namestoragesize >= 0); 683 assert(storageleft != NULL); 684 errorMessage(); 685 return SCIP_PLUGINNOTFOUND; 686 } 687 688 /** gets the objective sense of the LP */ 689 SCIP_RETCODE SCIPlpiGetObjsen( 690 SCIP_LPI* lpi, /**< LP interface structure */ 691 SCIP_OBJSEN* objsen /**< pointer to store objective sense */ 692 ) 693 { /*lint --e{715}*/ 694 errorMessage(); 695 return SCIP_PLUGINNOTFOUND; 696 } 697 698 /** gets objective coefficients from LP problem object */ 699 SCIP_RETCODE SCIPlpiGetObj( 700 SCIP_LPI* lpi, /**< LP interface structure */ 701 int firstcol, /**< first column to get objective coefficient for */ 702 int lastcol, /**< last column to get objective coefficient for */ 703 SCIP_Real* vals /**< array to store objective coefficients */ 704 ) 705 { /*lint --e{715}*/ 706 assert(lpi != NULL); 707 assert(firstcol <= lastcol); 708 assert(vals != NULL); 709 errorMessage(); 710 return SCIP_PLUGINNOTFOUND; 711 } 712 713 /** gets current bounds from LP problem object */ 714 SCIP_RETCODE SCIPlpiGetBounds( 715 SCIP_LPI* lpi, /**< LP interface structure */ 716 int firstcol, /**< first column to get bounds for */ 717 int lastcol, /**< last column to get bounds for */ 718 SCIP_Real* lbs, /**< array to store lower bound values, or NULL */ 719 SCIP_Real* ubs /**< array to store upper bound values, or NULL */ 720 ) 721 { /*lint --e{715}*/ 722 assert(lpi != NULL); 723 assert(firstcol <= lastcol); 724 errorMessage(); 725 return SCIP_PLUGINNOTFOUND; 726 } 727 728 /** gets current row sides from LP problem object */ 729 SCIP_RETCODE SCIPlpiGetSides( 730 SCIP_LPI* lpi, /**< LP interface structure */ 731 int firstrow, /**< first row to get sides for */ 732 int lastrow, /**< last row to get sides for */ 733 SCIP_Real* lhss, /**< array to store left hand side values, or NULL */ 734 SCIP_Real* rhss /**< array to store right hand side values, or NULL */ 735 ) 736 { /*lint --e{715}*/ 737 assert(lpi != NULL); 738 assert(firstrow <= lastrow); 739 errorMessage(); 740 return SCIP_PLUGINNOTFOUND; 741 } 742 743 /** gets a single coefficient */ 744 SCIP_RETCODE SCIPlpiGetCoef( 745 SCIP_LPI* lpi, /**< LP interface structure */ 746 int row, /**< row number of coefficient */ 747 int col, /**< column number of coefficient */ 748 SCIP_Real* val /**< pointer to store the value of the coefficient */ 749 ) 750 { /*lint --e{715}*/ 751 assert(lpi != NULL); 752 assert(val != NULL); 753 errorMessage(); 754 return SCIP_PLUGINNOTFOUND; 755 } 756 757 /**@} */ 758 759 760 761 762 /* 763 * Solving Methods 764 */ 765 766 /**@name Solving Methods */ 767 /**@{ */ 768 769 /** calls primal simplex to solve the LP */ 770 SCIP_RETCODE SCIPlpiSolvePrimal( 771 SCIP_LPI* lpi /**< LP interface structure */ 772 ) 773 { /*lint --e{715}*/ 774 assert(lpi != NULL); 775 errorMessage(); 776 return SCIP_PLUGINNOTFOUND; 777 } 778 779 /** calls dual simplex to solve the LP */ 780 SCIP_RETCODE SCIPlpiSolveDual( 781 SCIP_LPI* lpi /**< LP interface structure */ 782 ) 783 { /*lint --e{715}*/ 784 assert(lpi != NULL); 785 errorMessage(); 786 return SCIP_PLUGINNOTFOUND; 787 } 788 789 /** calls barrier or interior point algorithm to solve the LP with crossover to simplex basis */ 790 SCIP_RETCODE SCIPlpiSolveBarrier( 791 SCIP_LPI* lpi, /**< LP interface structure */ 792 SCIP_Bool crossover /**< perform crossover */ 793 ) 794 { /*lint --e{715}*/ 795 assert(lpi != NULL); 796 errorMessage(); 797 return SCIP_PLUGINNOTFOUND; 798 } 799 800 /** start strong branching - call before any strong branching */ 801 SCIP_RETCODE SCIPlpiStartStrongbranch( 802 SCIP_LPI* lpi /**< LP interface structure */ 803 ) 804 { /*lint --e{715}*/ 805 assert(lpi != NULL); 806 return SCIP_OKAY; 807 } 808 809 /** end strong branching - call after any strong branching */ 810 SCIP_RETCODE SCIPlpiEndStrongbranch( 811 SCIP_LPI* lpi /**< LP interface structure */ 812 ) 813 { /*lint --e{715}*/ 814 assert(lpi != NULL); 815 return SCIP_OKAY; 816 } 817 818 /** performs strong branching iterations on one @b fractional candidate */ 819 SCIP_RETCODE SCIPlpiStrongbranchFrac( 820 SCIP_LPI* lpi, /**< LP interface structure */ 821 int col, /**< column to apply strong branching on */ 822 SCIP_Real psol, /**< fractional current primal solution value of column */ 823 int itlim, /**< iteration limit for strong branchings */ 824 SCIP_Real* down, /**< stores dual bound after branching column down */ 825 SCIP_Real* up, /**< stores dual bound after branching column up */ 826 SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound; 827 * otherwise, it can only be used as an estimate value */ 828 SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound; 829 * otherwise, it can only be used as an estimate value */ 830 int* iter /**< stores total number of strong branching iterations, or -1; may be NULL */ 831 ) 832 { /*lint --e{715}*/ 833 assert(lpi != NULL); 834 assert( down != NULL ); 835 assert( up != NULL ); 836 assert( downvalid != NULL ); 837 assert( upvalid != NULL ); 838 errorMessage(); 839 return SCIP_PLUGINNOTFOUND; 840 } 841 842 /** performs strong branching iterations on given @b fractional candidates */ 843 SCIP_RETCODE SCIPlpiStrongbranchesFrac( 844 SCIP_LPI* lpi, /**< LP interface structure */ 845 int* cols, /**< columns to apply strong branching on */ 846 int ncols, /**< number of columns */ 847 SCIP_Real* psols, /**< fractional current primal solution values of columns */ 848 int itlim, /**< iteration limit for strong branchings */ 849 SCIP_Real* down, /**< stores dual bounds after branching columns down */ 850 SCIP_Real* up, /**< stores dual bounds after branching columns up */ 851 SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds; 852 * otherwise, they can only be used as an estimate values */ 853 SCIP_Bool* upvalid, /**< stores whether the returned up values are a valid dual bounds; 854 * otherwise, they can only be used as an estimate values */ 855 int* iter /**< stores total number of strong branching iterations, or -1; may be NULL */ 856 ) 857 { /*lint --e{715}*/ 858 assert(lpi != NULL); 859 assert( cols != NULL ); 860 assert( psols != NULL ); 861 assert( down != NULL ); 862 assert( up != NULL ); 863 assert( downvalid != NULL ); 864 assert( upvalid != NULL ); 865 errorMessage(); 866 return SCIP_PLUGINNOTFOUND; 867 } 868 869 /** performs strong branching iterations on one candidate with @b integral value */ 870 SCIP_RETCODE SCIPlpiStrongbranchInt( 871 SCIP_LPI* lpi, /**< LP interface structure */ 872 int col, /**< column to apply strong branching on */ 873 SCIP_Real psol, /**< current integral primal solution value of column */ 874 int itlim, /**< iteration limit for strong branchings */ 875 SCIP_Real* down, /**< stores dual bound after branching column down */ 876 SCIP_Real* up, /**< stores dual bound after branching column up */ 877 SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound; 878 * otherwise, it can only be used as an estimate value */ 879 SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound; 880 * otherwise, it can only be used as an estimate value */ 881 int* iter /**< stores total number of strong branching iterations, or -1; may be NULL */ 882 ) 883 { /*lint --e{715}*/ 884 assert(lpi != NULL); 885 assert( down != NULL ); 886 assert( up != NULL ); 887 assert( downvalid != NULL ); 888 assert( upvalid != NULL ); 889 errorMessage(); 890 return SCIP_PLUGINNOTFOUND; 891 } 892 893 /** performs strong branching iterations on given candidates with @b integral values */ 894 SCIP_RETCODE SCIPlpiStrongbranchesInt( 895 SCIP_LPI* lpi, /**< LP interface structure */ 896 int* cols, /**< columns to apply strong branching on */ 897 int ncols, /**< number of columns */ 898 SCIP_Real* psols, /**< current integral primal solution values of columns */ 899 int itlim, /**< iteration limit for strong branchings */ 900 SCIP_Real* down, /**< stores dual bounds after branching columns down */ 901 SCIP_Real* up, /**< stores dual bounds after branching columns up */ 902 SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds; 903 * otherwise, they can only be used as an estimate values */ 904 SCIP_Bool* upvalid, /**< stores whether the returned up values are a valid dual bounds; 905 * otherwise, they can only be used as an estimate values */ 906 int* iter /**< stores total number of strong branching iterations, or -1; may be NULL */ 907 ) 908 { /*lint --e{715}*/ 909 assert(lpi != NULL); 910 assert( cols != NULL ); 911 assert( psols != NULL ); 912 assert( down != NULL ); 913 assert( up != NULL ); 914 assert( downvalid != NULL ); 915 assert( upvalid != NULL ); 916 errorMessage(); 917 return SCIP_PLUGINNOTFOUND; 918 } 919 /**@} */ 920 921 922 923 924 /* 925 * Solution Information Methods 926 */ 927 928 /**@name Solution Information Methods */ 929 /**@{ */ 930 931 /** returns whether a solve method was called after the last modification of the LP */ 932 SCIP_Bool SCIPlpiWasSolved( 933 SCIP_LPI* lpi /**< LP interface structure */ 934 ) 935 { /*lint --e{715}*/ 936 assert(lpi != NULL); 937 errorMessageAbort(); 938 return FALSE; 939 } 940 941 /** gets information about primal and dual feasibility of the current LP solution 942 * 943 * The feasibility information is with respect to the last solving call and it is only relevant if SCIPlpiWasSolved() 944 * returns true. If the LP is changed, this information might be invalidated. 945 * 946 * Note that @a primalfeasible and @a dualfeasible should only return true if the solver has proved the respective LP to 947 * be feasible. Thus, the return values should be equal to the values of SCIPlpiIsPrimalFeasible() and 948 * SCIPlpiIsDualFeasible(), respectively. Note that if feasibility cannot be proved, they should return false (even if 949 * the problem might actually be feasible). 950 */ 951 SCIP_RETCODE SCIPlpiGetSolFeasibility( 952 SCIP_LPI* lpi, /**< LP interface structure */ 953 SCIP_Bool* primalfeasible, /**< pointer to store primal feasibility status */ 954 SCIP_Bool* dualfeasible /**< pointer to store dual feasibility status */ 955 ) 956 { /*lint --e{715}*/ 957 assert(lpi != NULL); 958 assert(primalfeasible != NULL); 959 assert(dualfeasible != NULL); 960 errorMessage(); 961 return SCIP_PLUGINNOTFOUND; 962 } 963 964 /** returns TRUE iff LP is proven to have a primal unbounded ray (but not necessary a primal feasible point); 965 * this does not necessarily mean, that the solver knows and can return the primal ray 966 */ 967 SCIP_Bool SCIPlpiExistsPrimalRay( 968 SCIP_LPI* lpi /**< LP interface structure */ 969 ) 970 { /*lint --e{715}*/ 971 assert(lpi != NULL); 972 errorMessageAbort(); 973 return FALSE; 974 } 975 976 /** returns TRUE iff LP is proven to have a primal unbounded ray (but not necessary a primal feasible point), 977 * and the solver knows and can return the primal ray 978 */ 979 SCIP_Bool SCIPlpiHasPrimalRay( 980 SCIP_LPI* lpi /**< LP interface structure */ 981 ) 982 { /*lint --e{715}*/ 983 assert(lpi != NULL); 984 errorMessageAbort(); 985 return FALSE; 986 } 987 988 /** returns TRUE iff LP is proven to be primal unbounded */ 989 SCIP_Bool SCIPlpiIsPrimalUnbounded( 990 SCIP_LPI* lpi /**< LP interface structure */ 991 ) 992 { /*lint --e{715}*/ 993 assert(lpi != NULL); 994 errorMessageAbort(); 995 return FALSE; 996 } 997 998 /** returns TRUE iff LP is proven to be primal infeasible */ 999 SCIP_Bool SCIPlpiIsPrimalInfeasible( 1000 SCIP_LPI* lpi /**< LP interface structure */ 1001 ) 1002 { /*lint --e{715}*/ 1003 assert(lpi != NULL); 1004 errorMessageAbort(); 1005 return FALSE; 1006 } 1007 1008 /** returns TRUE iff LP is proven to be primal feasible */ 1009 SCIP_Bool SCIPlpiIsPrimalFeasible( 1010 SCIP_LPI* lpi /**< LP interface structure */ 1011 ) 1012 { /*lint --e{715}*/ 1013 assert(lpi != NULL); 1014 errorMessageAbort(); 1015 return FALSE; 1016 } 1017 1018 /** returns TRUE iff LP is proven to have a dual unbounded ray (but not necessary a dual feasible point); 1019 * this does not necessarily mean, that the solver knows and can return the dual ray 1020 */ 1021 SCIP_Bool SCIPlpiExistsDualRay( 1022 SCIP_LPI* lpi /**< LP interface structure */ 1023 ) 1024 { /*lint --e{715}*/ 1025 assert(lpi != NULL); 1026 errorMessageAbort(); 1027 return FALSE; 1028 } 1029 1030 /** returns TRUE iff LP is proven to have a dual unbounded ray (but not necessary a dual feasible point), 1031 * and the solver knows and can return the dual ray 1032 */ 1033 SCIP_Bool SCIPlpiHasDualRay( 1034 SCIP_LPI* lpi /**< LP interface structure */ 1035 ) 1036 { /*lint --e{715}*/ 1037 assert(lpi != NULL); 1038 errorMessageAbort(); 1039 return FALSE; 1040 } 1041 1042 /** returns TRUE iff LP is proven to be dual unbounded */ 1043 SCIP_Bool SCIPlpiIsDualUnbounded( 1044 SCIP_LPI* lpi /**< LP interface structure */ 1045 ) 1046 { /*lint --e{715}*/ 1047 assert(lpi != NULL); 1048 errorMessageAbort(); 1049 return FALSE; 1050 } 1051 1052 /** returns TRUE iff LP is proven to be dual infeasible */ 1053 SCIP_Bool SCIPlpiIsDualInfeasible( 1054 SCIP_LPI* lpi /**< LP interface structure */ 1055 ) 1056 { /*lint --e{715}*/ 1057 assert(lpi != NULL); 1058 errorMessageAbort(); 1059 return FALSE; 1060 } 1061 1062 /** returns TRUE iff LP is proven to be dual feasible */ 1063 SCIP_Bool SCIPlpiIsDualFeasible( 1064 SCIP_LPI* lpi /**< LP interface structure */ 1065 ) 1066 { /*lint --e{715}*/ 1067 assert(lpi != NULL); 1068 errorMessageAbort(); 1069 return FALSE; 1070 } 1071 1072 /** returns TRUE iff LP was solved to optimality */ 1073 SCIP_Bool SCIPlpiIsOptimal( 1074 SCIP_LPI* lpi /**< LP interface structure */ 1075 ) 1076 { /*lint --e{715}*/ 1077 assert(lpi != NULL); 1078 errorMessageAbort(); 1079 return FALSE; 1080 } 1081 1082 /** returns TRUE iff current LP solution is stable 1083 * 1084 * This function should return true if the solution is reliable, i.e., feasible and optimal (or proven 1085 * infeasible/unbounded) with respect to the original problem. The optimality status might be with respect to a scaled 1086 * version of the problem, but the solution might not be feasible to the unscaled original problem; in this case, 1087 * SCIPlpiIsStable() should return false. 1088 */ 1089 SCIP_Bool SCIPlpiIsStable( 1090 SCIP_LPI* lpi /**< LP interface structure */ 1091 ) 1092 { /*lint --e{715}*/ 1093 assert(lpi != NULL); 1094 errorMessageAbort(); 1095 return FALSE; 1096 } 1097 1098 /** returns TRUE iff the objective limit was reached */ 1099 SCIP_Bool SCIPlpiIsObjlimExc( 1100 SCIP_LPI* lpi /**< LP interface structure */ 1101 ) 1102 { /*lint --e{715}*/ 1103 assert(lpi != NULL); 1104 errorMessageAbort(); 1105 return FALSE; 1106 } 1107 1108 /** returns TRUE iff the iteration limit was reached */ 1109 SCIP_Bool SCIPlpiIsIterlimExc( 1110 SCIP_LPI* lpi /**< LP interface structure */ 1111 ) 1112 { /*lint --e{715}*/ 1113 assert(lpi != NULL); 1114 errorMessageAbort(); 1115 return FALSE; 1116 } 1117 1118 /** returns TRUE iff the time limit was reached */ 1119 SCIP_Bool SCIPlpiIsTimelimExc( 1120 SCIP_LPI* lpi /**< LP interface structure */ 1121 ) 1122 { /*lint --e{715}*/ 1123 assert(lpi != NULL); 1124 errorMessageAbort(); 1125 return FALSE; 1126 } 1127 1128 /** returns the internal solution status of the solver */ 1129 int SCIPlpiGetInternalStatus( 1130 SCIP_LPI* lpi /**< LP interface structure */ 1131 ) 1132 { /*lint --e{715}*/ 1133 assert(lpi != NULL); 1134 errorMessageAbort(); 1135 return FALSE; 1136 } 1137 1138 /** tries to reset the internal status of the LP solver in order to ignore an instability of the last solving call */ 1139 SCIP_RETCODE SCIPlpiIgnoreInstability( 1140 SCIP_LPI* lpi, /**< LP interface structure */ 1141 SCIP_Bool* success /**< pointer to store, whether the instability could be ignored */ 1142 ) 1143 { /*lint --e{715}*/ 1144 assert(lpi != NULL); 1145 assert(success != NULL); 1146 errorMessage(); 1147 return SCIP_PLUGINNOTFOUND; 1148 } 1149 1150 /** gets objective value of solution */ 1151 SCIP_RETCODE SCIPlpiGetObjval( 1152 SCIP_LPI* lpi, /**< LP interface structure */ 1153 SCIP_Real* objval /**< stores the objective value */ 1154 ) 1155 { /*lint --e{715}*/ 1156 assert(lpi != NULL); 1157 assert(objval != NULL); 1158 errorMessage(); 1159 return SCIP_PLUGINNOTFOUND; 1160 } 1161 1162 /** gets primal and dual solution vectors for feasible LPs 1163 * 1164 * Before calling this function, the caller must ensure that the LP has been solved to optimality, i.e., that 1165 * SCIPlpiIsOptimal() returns true. 1166 */ 1167 SCIP_RETCODE SCIPlpiGetSol( 1168 SCIP_LPI* lpi, /**< LP interface structure */ 1169 SCIP_Real* objval, /**< stores the objective value, may be NULL if not needed */ 1170 SCIP_Real* primsol, /**< primal solution vector, may be NULL if not needed */ 1171 SCIP_Real* dualsol, /**< dual solution vector, may be NULL if not needed */ 1172 SCIP_Real* activity, /**< row activity vector, may be NULL if not needed */ 1173 SCIP_Real* redcost /**< reduced cost vector, may be NULL if not needed */ 1174 ) 1175 { /*lint --e{715}*/ 1176 assert(lpi != NULL); 1177 errorMessage(); 1178 return SCIP_PLUGINNOTFOUND; 1179 } 1180 1181 /** gets primal ray for unbounded LPs */ 1182 SCIP_RETCODE SCIPlpiGetPrimalRay( 1183 SCIP_LPI* lpi, /**< LP interface structure */ 1184 SCIP_Real* ray /**< primal ray */ 1185 ) 1186 { /*lint --e{715}*/ 1187 assert(lpi != NULL); 1188 assert(ray != NULL); 1189 errorMessage(); 1190 return SCIP_PLUGINNOTFOUND; 1191 } 1192 1193 /** gets dual Farkas proof for infeasibility */ 1194 SCIP_RETCODE SCIPlpiGetDualfarkas( 1195 SCIP_LPI* lpi, /**< LP interface structure */ 1196 SCIP_Real* dualfarkas /**< dual Farkas row multipliers */ 1197 ) 1198 { /*lint --e{715}*/ 1199 assert(lpi != NULL); 1200 assert(dualfarkas != NULL); 1201 errorMessage(); 1202 return SCIP_PLUGINNOTFOUND; 1203 } 1204 1205 /** gets the number of LP iterations of the last solve call */ 1206 SCIP_RETCODE SCIPlpiGetIterations( 1207 SCIP_LPI* lpi, /**< LP interface structure */ 1208 int* iterations /**< pointer to store the number of iterations of the last solve call */ 1209 ) 1210 { /*lint --e{715}*/ 1211 assert(lpi != NULL); 1212 assert(iterations != NULL); 1213 errorMessage(); 1214 return SCIP_PLUGINNOTFOUND; 1215 } 1216 1217 /** gets information about the quality of an LP solution 1218 * 1219 * Such information is usually only available, if also a (maybe not optimal) solution is available. 1220 * The LPI should return SCIP_INVALID for @p quality, if the requested quantity is not available. 1221 */ 1222 SCIP_RETCODE SCIPlpiGetRealSolQuality( 1223 SCIP_LPI* lpi, /**< LP interface structure */ 1224 SCIP_LPSOLQUALITY qualityindicator, /**< indicates which quality should be returned */ 1225 SCIP_Real* quality /**< pointer to store quality number */ 1226 ) 1227 { /*lint --e{715}*/ 1228 assert(lpi != NULL); 1229 assert(quality != NULL); 1230 1231 *quality = SCIP_INVALID; 1232 1233 return SCIP_OKAY; 1234 } 1235 1236 /**@} */ 1237 1238 1239 1240 1241 /* 1242 * LP Basis Methods 1243 */ 1244 1245 /**@name LP Basis Methods */ 1246 /**@{ */ 1247 1248 /** gets current basis status for columns and rows; arrays must be large enough to store the basis status */ 1249 SCIP_RETCODE SCIPlpiGetBase( 1250 SCIP_LPI* lpi, /**< LP interface structure */ 1251 int* cstat, /**< array to store column basis status, or NULL */ 1252 int* rstat /**< array to store row basis status, or NULL */ 1253 ) 1254 { /*lint --e{715}*/ 1255 assert(lpi != NULL); 1256 errorMessage(); 1257 return SCIP_PLUGINNOTFOUND; 1258 } 1259 1260 /** sets current basis status for columns and rows */ 1261 SCIP_RETCODE SCIPlpiSetBase( 1262 SCIP_LPI* lpi, /**< LP interface structure */ 1263 const int* cstat, /**< array with column basis status */ 1264 const int* rstat /**< array with row basis status */ 1265 ) 1266 { /*lint --e{715}*/ 1267 assert(lpi != NULL); 1268 assert(cstat != NULL); 1269 assert(rstat != NULL); 1270 errorMessage(); 1271 return SCIP_PLUGINNOTFOUND; 1272 } 1273 1274 /** returns the indices of the basic columns and rows; basic column n gives value n, basic row m gives value -1-m */ 1275 SCIP_RETCODE SCIPlpiGetBasisInd( 1276 SCIP_LPI* lpi, /**< LP interface structure */ 1277 int* bind /**< pointer to store basis indices ready to keep number of rows entries */ 1278 ) 1279 { /*lint --e{715}*/ 1280 assert(lpi != NULL); 1281 assert(bind != NULL); 1282 errorMessage(); 1283 return SCIP_PLUGINNOTFOUND; 1284 } 1285 1286 /** get row of inverse basis matrix B^-1 1287 * 1288 * @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver 1289 * uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated; 1290 * see also the explanation in lpi.h. 1291 */ 1292 SCIP_RETCODE SCIPlpiGetBInvRow( 1293 SCIP_LPI* lpi, /**< LP interface structure */ 1294 int r, /**< row number */ 1295 SCIP_Real* coef, /**< pointer to store the coefficients of the row */ 1296 int* inds, /**< array to store the non-zero indices, or NULL */ 1297 int* ninds /**< pointer to store the number of non-zero indices, or NULL 1298 * (-1: if we do not store sparsity information) */ 1299 ) 1300 { /*lint --e{715}*/ 1301 assert(lpi != NULL); 1302 assert(coef != NULL); 1303 errorMessage(); 1304 return SCIP_PLUGINNOTFOUND; 1305 } 1306 1307 /** get column of inverse basis matrix B^-1 1308 * 1309 * @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver 1310 * uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated; 1311 * see also the explanation in lpi.h. 1312 */ 1313 SCIP_RETCODE SCIPlpiGetBInvCol( 1314 SCIP_LPI* lpi, /**< LP interface structure */ 1315 int c, /**< column number of B^-1; this is NOT the number of the column in the LP; 1316 * you have to call SCIPlpiGetBasisInd() to get the array which links the 1317 * B^-1 column numbers to the row and column numbers of the LP! 1318 * c must be between 0 and nrows-1, since the basis has the size 1319 * nrows * nrows */ 1320 SCIP_Real* coef, /**< pointer to store the coefficients of the column */ 1321 int* inds, /**< array to store the non-zero indices, or NULL */ 1322 int* ninds /**< pointer to store the number of non-zero indices, or NULL 1323 * (-1: if we do not store sparsity information) */ 1324 ) 1325 { /*lint --e{715}*/ 1326 assert(lpi != NULL); 1327 assert(coef != NULL); 1328 errorMessage(); 1329 return SCIP_PLUGINNOTFOUND; 1330 } 1331 1332 /** get row of inverse basis matrix times constraint matrix B^-1 * A 1333 * 1334 * @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver 1335 * uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated; 1336 * see also the explanation in lpi.h. 1337 */ 1338 SCIP_RETCODE SCIPlpiGetBInvARow( 1339 SCIP_LPI* lpi, /**< LP interface structure */ 1340 int r, /**< row number */ 1341 const SCIP_Real* binvrow, /**< row in (A_B)^-1 from prior call to SCIPlpiGetBInvRow(), or NULL */ 1342 SCIP_Real* coef, /**< vector to return coefficients of the row */ 1343 int* inds, /**< array to store the non-zero indices, or NULL */ 1344 int* ninds /**< pointer to store the number of non-zero indices, or NULL 1345 * (-1: if we do not store sparsity information) */ 1346 ) 1347 { /*lint --e{715}*/ 1348 assert(lpi != NULL); 1349 assert(coef != NULL); 1350 errorMessage(); 1351 return SCIP_PLUGINNOTFOUND; 1352 } 1353 1354 /** get column of inverse basis matrix times constraint matrix B^-1 * A 1355 * 1356 * @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver 1357 * uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated; 1358 * see also the explanation in lpi.h. 1359 */ 1360 SCIP_RETCODE SCIPlpiGetBInvACol( 1361 SCIP_LPI* lpi, /**< LP interface structure */ 1362 int c, /**< column number */ 1363 SCIP_Real* coef, /**< vector to return coefficients of the column */ 1364 int* inds, /**< array to store the non-zero indices, or NULL */ 1365 int* ninds /**< pointer to store the number of non-zero indices, or NULL 1366 * (-1: if we do not store sparsity information) */ 1367 ) 1368 { /*lint --e{715}*/ 1369 assert(lpi != NULL); 1370 assert(coef != NULL); 1371 errorMessage(); 1372 return SCIP_PLUGINNOTFOUND; 1373 } 1374 1375 /**@} */ 1376 1377 1378 1379 1380 /* 1381 * LP State Methods 1382 */ 1383 1384 /**@name LP State Methods */ 1385 /**@{ */ 1386 1387 /** stores LPi state (like basis information) into lpistate object */ 1388 SCIP_RETCODE SCIPlpiGetState( 1389 SCIP_LPI* lpi, /**< LP interface structure */ 1390 BMS_BLKMEM* blkmem, /**< block memory */ 1391 SCIP_LPISTATE** lpistate /**< pointer to LPi state information (like basis information) */ 1392 ) 1393 { /*lint --e{715}*/ 1394 assert(lpi != NULL); 1395 assert(blkmem != NULL); 1396 assert(lpistate != NULL); 1397 assert(blkmem != NULL); 1398 errorMessage(); 1399 return SCIP_PLUGINNOTFOUND; 1400 } 1401 1402 /** loads LPi state (like basis information) into solver; note that the LP might have been extended with additional 1403 * columns and rows since the state was stored with SCIPlpiGetState() 1404 */ 1405 SCIP_RETCODE SCIPlpiSetState( 1406 SCIP_LPI* lpi, /**< LP interface structure */ 1407 BMS_BLKMEM* blkmem, /**< block memory */ 1408 const SCIP_LPISTATE* lpistate /**< LPi state information (like basis information), or NULL */ 1409 ) 1410 { /*lint --e{715}*/ 1411 assert(lpi != NULL); 1412 assert(blkmem != NULL); 1413 assert(lpistate != NULL); 1414 errorMessage(); 1415 return SCIP_PLUGINNOTFOUND; 1416 } 1417 1418 /** clears current LPi state (like basis information) of the solver */ 1419 SCIP_RETCODE SCIPlpiClearState( 1420 SCIP_LPI* lpi /**< LP interface structure */ 1421 ) 1422 { /*lint --e{715}*/ 1423 assert(lpi != NULL); 1424 return SCIP_OKAY; 1425 } 1426 1427 /** frees LPi state information */ 1428 SCIP_RETCODE SCIPlpiFreeState( 1429 SCIP_LPI* lpi, /**< LP interface structure */ 1430 BMS_BLKMEM* blkmem, /**< block memory */ 1431 SCIP_LPISTATE** lpistate /**< pointer to LPi state information (like basis information) */ 1432 ) 1433 { /*lint --e{715}*/ 1434 assert(lpi != NULL); 1435 assert(lpistate != NULL); 1436 assert(blkmem != NULL); 1437 return SCIP_OKAY; 1438 } 1439 1440 /** checks, whether the given LP state contains simplex basis information */ 1441 SCIP_Bool SCIPlpiHasStateBasis( 1442 SCIP_LPI* lpi, /**< LP interface structure */ 1443 SCIP_LPISTATE* lpistate /**< LP state information (like basis information), or NULL */ 1444 ) 1445 { /*lint --e{715}*/ 1446 assert(lpi != NULL); 1447 errorMessageAbort(); 1448 return FALSE; 1449 } 1450 1451 /** reads LP state (like basis information from a file */ 1452 SCIP_RETCODE SCIPlpiReadState( 1453 SCIP_LPI* lpi, /**< LP interface structure */ 1454 const char* fname /**< file name */ 1455 ) 1456 { /*lint --e{715}*/ 1457 assert(lpi != NULL); 1458 assert(fname != NULL); 1459 errorMessage(); 1460 return SCIP_PLUGINNOTFOUND; 1461 } 1462 1463 /** writes LPi state (i.e. basis information) to a file */ 1464 SCIP_RETCODE SCIPlpiWriteState( 1465 SCIP_LPI* lpi, /**< LP interface structure */ 1466 const char* fname /**< file name */ 1467 ) 1468 { /*lint --e{715}*/ 1469 assert(lpi != NULL); 1470 assert(fname != NULL); 1471 errorMessage(); 1472 return SCIP_PLUGINNOTFOUND; 1473 } 1474 1475 /**@} */ 1476 1477 1478 1479 1480 /* 1481 * LP Pricing Norms Methods 1482 */ 1483 1484 /**@name LP Pricing Norms Methods */ 1485 /**@{ */ 1486 1487 /** stores LPi pricing norms information 1488 * @todo should we store norm information? 1489 */ 1490 SCIP_RETCODE SCIPlpiGetNorms( 1491 SCIP_LPI* lpi, /**< LP interface structure */ 1492 BMS_BLKMEM* blkmem, /**< block memory */ 1493 SCIP_LPINORMS** lpinorms /**< pointer to LPi pricing norms information */ 1494 ) 1495 { /*lint --e{715}*/ 1496 assert(lpi != NULL); 1497 assert(blkmem != NULL); 1498 assert(lpinorms != NULL); 1499 errorMessage(); 1500 return SCIP_PLUGINNOTFOUND; 1501 } 1502 1503 /** loads LPi pricing norms into solver; note that the LP might have been extended with additional 1504 * columns and rows since the state was stored with SCIPlpiGetNorms() 1505 */ 1506 SCIP_RETCODE SCIPlpiSetNorms( 1507 SCIP_LPI* lpi, /**< LP interface structure */ 1508 BMS_BLKMEM* blkmem, /**< block memory */ 1509 const SCIP_LPINORMS* lpinorms /**< LPi pricing norms information, or NULL */ 1510 ) 1511 { /*lint --e{715}*/ 1512 assert(lpi != NULL); 1513 errorMessage(); 1514 return SCIP_PLUGINNOTFOUND; 1515 } 1516 1517 /** frees pricing norms information */ 1518 SCIP_RETCODE SCIPlpiFreeNorms( 1519 SCIP_LPI* lpi, /**< LP interface structure */ 1520 BMS_BLKMEM* blkmem, /**< block memory */ 1521 SCIP_LPINORMS** lpinorms /**< pointer to LPi pricing norms information, or NULL */ 1522 ) 1523 { /*lint --e{715}*/ 1524 assert(lpi != NULL); 1525 errorMessage(); 1526 return SCIP_PLUGINNOTFOUND; 1527 } 1528 1529 /**@} */ 1530 1531 1532 1533 1534 /* 1535 * Parameter Methods 1536 */ 1537 1538 /**@name Parameter Methods */ 1539 /**@{ */ 1540 1541 /** gets integer parameter of LP */ 1542 SCIP_RETCODE SCIPlpiGetIntpar( 1543 SCIP_LPI* lpi, /**< LP interface structure */ 1544 SCIP_LPPARAM type, /**< parameter number */ 1545 int* ival /**< buffer to store the parameter value */ 1546 ) 1547 { /*lint --e{715}*/ 1548 assert(lpi != NULL); 1549 assert(ival != NULL); 1550 return SCIP_PARAMETERUNKNOWN; 1551 } 1552 1553 /** sets integer parameter of LP */ 1554 SCIP_RETCODE SCIPlpiSetIntpar( 1555 SCIP_LPI* lpi, /**< LP interface structure */ 1556 SCIP_LPPARAM type, /**< parameter number */ 1557 int ival /**< parameter value */ 1558 ) 1559 { /*lint --e{715}*/ 1560 assert(lpi != NULL); 1561 return SCIP_PARAMETERUNKNOWN; 1562 } 1563 1564 /** gets floating point parameter of LP */ 1565 SCIP_RETCODE SCIPlpiGetRealpar( 1566 SCIP_LPI* lpi, /**< LP interface structure */ 1567 SCIP_LPPARAM type, /**< parameter number */ 1568 SCIP_Real* dval /**< buffer to store the parameter value */ 1569 ) 1570 { /*lint --e{715}*/ 1571 assert(lpi != NULL); 1572 assert(dval != NULL); 1573 return SCIP_PARAMETERUNKNOWN; 1574 } 1575 1576 /** sets floating point parameter of LP */ 1577 SCIP_RETCODE SCIPlpiSetRealpar( 1578 SCIP_LPI* lpi, /**< LP interface structure */ 1579 SCIP_LPPARAM type, /**< parameter number */ 1580 SCIP_Real dval /**< parameter value */ 1581 ) 1582 { /*lint --e{715}*/ 1583 assert(lpi != NULL); 1584 return SCIP_PARAMETERUNKNOWN; 1585 } 1586 1587 /** interrupts the currently ongoing lp solve or disables the interrupt */ 1588 SCIP_RETCODE SCIPlpiInterrupt( 1589 SCIP_LPI* lpi, /**< LP interface structure */ 1590 SCIP_Bool interrupt /**< TRUE if interrupt should be set, FALSE if it should be disabled */ 1591 ) 1592 { 1593 /*lint --e{715}*/ 1594 assert(lpi != NULL); 1595 1596 return SCIP_OKAY; 1597 } 1598 1599 /**@} */ 1600 1601 /* 1602 * Numerical Methods 1603 */ 1604 1605 /**@name Numerical Methods */ 1606 /**@{ */ 1607 1608 /** returns value treated as infinity in the LP solver */ 1609 SCIP_Real SCIPlpiInfinity( 1610 SCIP_LPI* lpi /**< LP interface structure */ 1611 ) 1612 { /*lint --e{715}*/ 1613 assert(lpi != NULL); 1614 return LPIINFINITY; 1615 } 1616 1617 /** checks if given value is treated as infinity in the LP solver */ 1618 SCIP_Bool SCIPlpiIsInfinity( 1619 SCIP_LPI* lpi, /**< LP interface structure */ 1620 SCIP_Real val /**< value to be checked for infinity */ 1621 ) 1622 { /*lint --e{715}*/ 1623 assert(lpi != NULL); 1624 if( val >= LPIINFINITY ) 1625 return TRUE; 1626 return FALSE; 1627 } 1628 1629 /**@} */ 1630 1631 1632 1633 1634 /* 1635 * File Interface Methods 1636 */ 1637 1638 /**@name File Interface Methods */ 1639 /**@{ */ 1640 1641 /** reads LP from a file */ 1642 SCIP_RETCODE SCIPlpiReadLP( 1643 SCIP_LPI* lpi, /**< LP interface structure */ 1644 const char* fname /**< file name */ 1645 ) 1646 { /*lint --e{715}*/ 1647 assert(lpi != NULL); 1648 assert(fname != NULL); 1649 errorMessage(); 1650 return SCIP_PLUGINNOTFOUND; 1651 } 1652 1653 /** writes LP to a file */ 1654 SCIP_RETCODE SCIPlpiWriteLP( 1655 SCIP_LPI* lpi, /**< LP interface structure */ 1656 const char* fname /**< file name */ 1657 ) 1658 { /*lint --e{715}*/ 1659 assert(lpi != NULL); 1660 errorMessage(); 1661 return SCIP_PLUGINNOTFOUND; 1662 } 1663 1664 /**@} */ 1665