42#define COLS_PER_PACKET SCIP_DUALPACKETSIZE
44#define ROWS_PER_PACKET SCIP_DUALPACKETSIZE
105#define __QS_PRINTLOC__ fprintf(stderr,", in (%s:%d)\n", __FILE__, __LINE__)
109#define QS_TESTG(A,B,C) do{{ \
111 fprintf(stderr, C); \
116#define QS_ERROR(A,...) do{{ \
118 fprintf(stderr,__VA_ARGS__); \
120 return SCIP_LPERROR;}}}while(0)
124#define QS_RETURN(A) do{ \
125 const int __RVAL__ = (A); \
127 fprintf(stderr,"LP Error: QSopt returned %d",__RVAL__); \
129 return SCIP_ERROR;} \
130 return SCIP_OKAY;}while(0)
134#define QS_CONDRET(A) do{ \
135 const int __RVAL__ = (A); \
137 fprintf(stderr,"LP Error: QSopt returned %d",__RVAL__); \
139 return SCIP_LPERROR;} \
310 const double*
const lhs,
311 const double*
const rhs
321 for(
i = 0 ;
i < nrows ; ++
i )
323 state = ((lhs[
i] <= -QS_MAXDOUBLE ? 1 : 0) | (rhs[
i] >= QS_MAXDOUBLE ? 2 : 0));
340 lpi->
irng[
i] = rhs[
i] - lhs[
i];
383 vnamelen = strlen(vname);
386 memcpy(__qsstr, vname, vnamelen);
387 __qsstr[vnamelen+1] =
'\0';
397 return "Linear Programming Solver developed by D. Applegate, W. Cook, S. Dash, and M. Mevenkamp (www.isye.gatech.edu/~wcook/qsopt)";
406 return (
void*) lpi->
prob;
420 SCIPerrorMessage(
"SCIPlpiSetIntegralityInformation() has not been implemented yet.\n");
469 assert(
sizeof(SCIP_Real) ==
sizeof(
double));
470 assert(
sizeof(SCIP_Bool) ==
sizeof(
int));
478 memset(*lpi, 0,
sizeof(
struct SCIP_LPi));
480 (*lpi)->prob = QScreate_prob(name, (
int) objsen);
481 if ( (*lpi)->prob ==
NULL )
487 (*lpi)->rowspace = 1024;
494 (*lpi)->colspace = 1024;
502 (*lpi)->messagehdlr = messagehdlr;
519 QSfree_prob((*lpi)->prob);
553 const SCIP_Real*
obj,
558 const SCIP_Real* lhs,
559 const SCIP_Real* rhs,
572 for( j = 0; j < nnonz; j++ )
590 SCIPdebugMessage(
"loading LP in column format into QSopt: %d cols, %d rows\n", ncols, nrows);
618 for(
i = 0;
i < ncols-1; ++
i )
626 lpi->
iccnt[ncols-1] = nnonz - beg[ncols-1];
631 QS_CONDRET( QSadd_cols(lpi->
prob, ncols, lpi->
iccnt, (
int*) beg, (
int*) ind, (SCIP_Real*) val, (SCIP_Real*)
obj,
632 (SCIP_Real*) lb, (SCIP_Real*) ub, (
const char**)colnames) );
642 const SCIP_Real*
obj,
664 SCIPdebugMessage(
"adding %d columns with %d nonzeros to QSopt\n", ncols, nnonz);
681 for(
i = 0;
i < ncols; ++
i )
693 nrows = QSget_rowcount(lpi->
prob);
694 for (
i = 0;
i < nnonz; ++
i)
696 assert( 0 <= ind[
i] && ind[
i] < nrows );
702 for(
i = 0;
i < ncols - 1; ++
i )
708 lpi->
iccnt[ncols-1] = nnonz - beg[ncols-1];
714 QS_CONDRET( QSadd_cols(lpi->
prob, ncols, lpi->
iccnt, (
int*) lbeg, (
int*) ind, (SCIP_Real*) val, (SCIP_Real*)
obj,
715 (SCIP_Real*) lb, (SCIP_Real*) ub, (
const char**)colnames) );
739 len = lastcol - firstcol +1;
742 assert(0 <= firstcol && len > 0 && lastcol < QSget_colcount(lpi->
prob));
747 for(
i = firstcol ;
i <= lastcol ;
i++ )
771 ncols = QSget_colcount(lpi->
prob);
778 for(
i=0, ccnt=0;
i < ncols;
i++ )
794 const SCIP_Real* lhs,
795 const SCIP_Real* rhs,
813 SCIPdebugMessage(
"adding %d rows with %d nonzeros to QSopt\n", nrows, nnonz);
836 ncols = QSget_colcount(lpi->
prob);
837 for (
i = 0;
i < nnonz; ++
i)
840 assert( 0 <= ind[
i] && ind[
i] < ncols );
845 for(
i = 0 ;
i < nrows -1 ;
i++ )
851 lpi->
ircnt[nrows-1] = nnonz - beg[nrows-1];
855 QS_CONDRET( QSadd_ranged_rows(lpi->
prob, nrows, lpi->
ircnt, (
int*) beg, (
int*) ind, (SCIP_Real*) val, lpi->
irhs,
856 lpi->
isen, lpi->
irng, (
const char**)rownames) );
860 for(
i = 0;
i < nrows -1; ++
i )
868 lpi->
isen, lpi->
irng, (
const char**)rownames) );
894 assert(colnames !=
NULL || namestoragesize == 0);
895 assert(namestorage !=
NULL || namestoragesize == 0);
896 assert(namestoragesize >= 0);
898 assert(0 <= firstcol && firstcol <= lastcol && lastcol < QSget_colcount(lpi->
prob));
902 ncols = QSget_colcount(lpi->
prob);
905 rval = QSget_colnames(lpi->
prob, cnames);
906 QS_ERROR(rval,
"failed getting column names");
910 sizeleft = namestoragesize;
911 for( j = firstcol; j <= lastcol; ++j )
918 if( colnames !=
NULL )
919 colnames[j-firstcol] = s;
928 *storageleft = sizeleft;
931 for( j = 0; j < ncols; ++j )
957 assert(rownames !=
NULL || namestoragesize == 0);
958 assert(namestorage !=
NULL || namestoragesize == 0);
959 assert(namestoragesize >= 0);
961 assert(0 <= firstrow && firstrow <= lastrow && lastrow < QSget_rowcount(lpi->
prob));
965 nrows = QSget_rowcount(lpi->
prob);
968 rval = QSget_rownames(lpi->
prob, rnames);
969 QS_ERROR(rval,
"failed getting row names");
972 sizeleft = namestoragesize;
973 for(
i = firstrow;
i <= lastrow; ++
i )
980 if( rownames !=
NULL )
981 rownames[
i-firstrow] = s;
990 *storageleft = sizeleft;
993 for(
i = 0;
i < nrows; ++
i )
1006 const int len = lastrow - firstrow +1;
1014 assert(0 <= firstrow && len > 0 && lastrow < QSget_rowcount (lpi->
prob));
1019 for(
i = firstrow;
i <= lastrow;
i++ )
1043 nrows = QSget_rowcount(lpi->
prob);
1046 for(
i = 0;
i < nrows; ++
i )
1056 for(
i=0, ccnt=0;
i < nrows;
i++ )
1072 char savename[1024];
1085 name = QSget_probname(lpi->
prob);
1086 (void)strncpy(savename, name, 1023);
1089 QSfree_prob(lpi->
prob);
1090 lpi->
prob = QScreate_prob(savename, objsen);
1101 const SCIP_Real* lb,
1117 for (
i = 0;
i < ncols; ++
i)
1123 SCIPerrorMessage(
"LP Error: fixing lower bound for variable %d to infinity.\n", ind[
i]);
1128 SCIPerrorMessage(
"LP Error: fixing upper bound for variable %d to -infinity.\n", ind[
i]);
1134 for(
i = 0;
i < ncols; ++
i )
1139 for(
i = 0;
i < ncols; ++
i )
1152 const SCIP_Real* lhs,
1153 const SCIP_Real* rhs
1174 for(
i = 0;
i < nrows; ++
i )
1180 if( lpi->
isen[
i] ==
'R' )
1202 SCIPdebugMessage(
"changing coefficient row %d, column %d in QSopt to %g\n", row, col, newval);
1239 const SCIP_Real*
obj
1253 for(
i = 0;
i < ncols; ++
i )
1280 SCIPdebugMessage(
"scaling row %d with factor %g in QSopt\n", row, scaleval);
1284 rval = QSget_ranged_rows_list(lpi->
prob, 1, rowlist, &rowcnt, &rowbeg, &rowind, &rowval, &rhs, &sense, &range, 0);
1288 for(
i = 0;
i < rowcnt[0]; ++
i )
1290 rval = QSchange_coef(lpi->
prob, row, rowind[
i], rowval[
i] * scaleval);
1297 rval = QSchange_rhscoef(lpi->
prob, row, rhs[0] * scaleval);
1299 if( sense[0] ==
'R' )
1301 rval = QSchange_range(lpi->
prob, row, range[0] * scaleval);
1311 rval = QSchange_rhscoef(lpi->
prob, row, rhs[0]*scaleval);
1315 rval = QSchange_rhscoef(lpi->
prob, row, rhs[0]*scaleval);
1317 rval = QSchange_sense(lpi->
prob, row,
'G');
1321 rval = QSchange_rhscoef(lpi->
prob, row, rhs[0]*scaleval);
1323 rval = QSchange_sense(lpi->
prob, row,
'L');
1327 rhs[0] = (rhs[0] + range[0]) * scaleval;
1328 range[0] = fabs(scaleval) * range[0];
1329 rval = QSchange_rhscoef(lpi->
prob, row, rhs[0]);
1331 rval = QSchange_range(lpi->
prob, row, range[0]);
1344 if( rowcnt !=
NULL )
1346 if( rowbeg !=
NULL )
1348 if( rowind !=
NULL )
1350 if( rowval !=
NULL )
1387 SCIPdebugMessage(
"scaling column %d with factor %g in QSopt\n", col, scaleval);
1391 rval = QSget_columns_list(lpi->
prob, 1, collist, &colcnt, &colbeg, &colind, &colval, &
obj, &lb, &ub, 0);
1395 for(
i = 0;
i < colcnt[0]; ++
i )
1397 rval = QSchange_coef(lpi->
prob, colind[
i], col, colval[
i]*scaleval);
1402 rval = QSchange_objcoef(lpi->
prob, col,
obj[0]*scaleval);
1408 scaleval = -scaleval;
1413 if( lb[0] > -QS_MAXDOUBLE )
1415 if( ub[0] < QS_MAXDOUBLE )
1418 if( lb[0] < -QS_MAXDOUBLE )
1419 lb[0] = -QS_MAXDOUBLE;
1420 if( ub[0] > QS_MAXDOUBLE )
1421 ub[0] = QS_MAXDOUBLE;
1423 rval = QSchange_bound(lpi->
prob, col,
'L', lb[0]);
1425 rval = QSchange_bound(lpi->
prob, col,
'U', ub[0]);
1430 if( colcnt !=
NULL )
1432 if( colbeg !=
NULL )
1434 if( colind !=
NULL )
1436 if( colval !=
NULL )
1471 *nrows = QSget_rowcount(lpi->
prob);
1488 *ncols = QSget_colcount(lpi->
prob);
1505 *nnonz = QSget_nzcount(lpi->
prob);
1528 double* lval =
NULL;
1538 assert(0 <= firstcol && firstcol <= lastcol && lastcol < QSget_colcount(lpi->
prob));
1545 len = lastcol - firstcol + 1;
1548 for(
i = 0;
i < len; ++
i )
1552 if ( nnonz !=
NULL )
1553 rval = QSget_columns_list(lpi->
prob, len, lpi->
iccnt, &lcnt, &lbeg, &lind, &lval,
NULL, lb ? (&llb) :
NULL, ub ? (&lub) :
NULL,
NULL);
1555 rval = QSget_columns_list(lpi->
prob, len, lpi->
iccnt,
NULL,
NULL,
NULL,
NULL,
NULL, lb ? (&llb) :
NULL, ub ? (&lub) :
NULL,
NULL);
1570 *nnonz = lbeg[len-1] + lcnt[len-1];
1571 for(
i = 0 ;
i < len ;
i++ )
1573 for(
i = 0;
i < *nnonz; ++
i )
1590 for(
i = 0;
i < len; ++
i )
1630 const int len = lastrow - firstrow + 1;
1632 double* lval =
NULL;
1633 double* lrhs =
NULL;
1634 double* lrng =
NULL;
1639 char* lsense =
NULL;
1643 assert(0 <= firstrow && firstrow <= lastrow && lastrow < QSget_rowcount (lpi->
prob));
1651 for(
i = 0;
i < len; ++
i )
1655 if ( nnonz !=
NULL )
1656 rval = QSget_ranged_rows_list(lpi->
prob, len, lpi->
ircnt, &lcnt, &lbeg, &lind, &lval, rhs ? (&lrhs) :
NULL, rhs ? (&lsense) :
NULL, rhs ? (&lrng) :
NULL,
NULL);
1658 rval = QSget_ranged_rows_list(lpi->
prob, len, lpi->
ircnt,
NULL,
NULL,
NULL,
NULL, rhs ? (&lrhs) :
NULL, rhs ? (&lsense) :
NULL, rhs ? (&lrng) :
NULL,
NULL);
1673 *nnonz = lbeg[len-1] + lcnt[len-1];
1674 for(
i = 0 ;
i < len;
i++ )
1676 for(
i = 0;
i < *nnonz; ++
i )
1693 for(
i = 0;
i < len; ++
i )
1699 rhs[
i] = lrhs[
i] + lrng[
i];
1707 lhs[
i] = -QS_MAXDOUBLE;
1711 rhs[
i] = QS_MAXDOUBLE;
1722 if( lsense !=
NULL )
1753 if ( sense == QS_MIN )
1776 assert(0 <= firstcol && firstcol <= lastcol && lastcol < QSget_colcount (lpi->
prob));
1778 SCIPdebugMessage(
"getting objective values %d to %d\n", firstcol, lastcol);
1781 len = lastcol - firstcol + 1;
1783 for(
i = 0;
i < len; ++
i )
1790#ifdef SCIP_DISABLED_CODE
1794 QS_CONDRET( QSget_columns_list(lpi->
prob, len, lpi->
iccnt,
NULL,
NULL,
NULL,
NULL, &qsoptvals,
NULL,
NULL,
NULL) );
1795 for (
i = 0;
i < len; ++
i)
1796 vals[
i] = qsoptvals[
i];
1811 const int len = lastcol - firstcol + 1;
1816 assert(0 <= firstcol && firstcol <= lastcol&& lastcol < QSget_colcount (lpi->
prob));
1822 for(
i = 0;
i < len; ++
i )
1840 const int len = lastrow - firstrow + 1;
1842 double* lrhs=0, *lrng=0;
1848 assert(0 <= firstrow && firstrow <= lastrow && lastrow < QSget_rowcount (lpi->
prob));
1856 for(
i = 0;
i < len; ++
i )
1860 rval = QSget_ranged_rows_list(lpi->
prob, len, lpi->
ircnt, 0, 0, 0, 0, &lrhs, &lsense, &lrng, 0);
1864 for(
i = 0;
i < len; ++
i )
1870 rhss[
i] = lrhs[
i] + lrng[
i];
1873 lhss[
i] = rhss[
i] = lrhs[
i];
1877 lhss[
i] = -QS_MAXDOUBLE;
1881 rhss[
i] = QS_MAXDOUBLE;
1891 if( lsense !=
NULL )
1940 SCIPdebugMessage(
"calling QSopt primal simplex: %d cols, %d rows, %d nz\n", QSget_colcount(lpi->
prob),
1941 QSget_rowcount(lpi->
prob), QSget_nzcount(lpi->
prob));
1957 SCIPdebugMessage(
"calling QSopt dual simplex: %d cols, %d rows, %d nz\n", QSget_colcount(lpi->
prob),
1958 QSget_rowcount(lpi->
prob), QSget_nzcount(lpi->
prob));
2011 SCIP_Bool* downvalid,
2027 SCIPdebugMessage(
"calling QSopt strong branching on variable %d with fractional value (%d it lim)\n", col, itlim);
2036 QS_CONDRET( QSopt_strongbranch(lpi->
prob, 1, &col, &psol, down, up, itlim, QS_MAXDOUBLE) );
2041 *iter = nit - lpi->
previt;
2056 SCIP_Bool* downvalid,
2075 SCIPdebugMessage(
"calling QSopt strong branching on %d variables with fractional value (%d it lim)\n", ncols, itlim);
2078 for( j = 0; j < ncols; ++j )
2080 downvalid[j] =
TRUE;
2086 QS_CONDRET( QSopt_strongbranch(lpi->
prob, ncols, cols, psols, down, up, itlim, QS_MAXDOUBLE) );
2091 *iter = nit - lpi->
previt;
2105 SCIP_Bool* downvalid,
2121 SCIPdebugMessage(
"calling QSopt strong branching on variable %d with integral value (%d it lim)\n", col, itlim);
2150 SCIP_Bool* downvalid,
2168 SCIPdebugMessage(
"calling QSopt strong branching on %d variables with integral value (%d it lim)\n", ncols, itlim);
2174 for( j = 0; j < ncols; ++j )
2179 downvalid[j] =
TRUE;
2223 SCIP_Bool* primalfeasible,
2224 SCIP_Bool* dualfeasible
2236 *primalfeasible =
TRUE;
2238 *primalfeasible =
FALSE;
2241 *dualfeasible =
TRUE;
2243 *dualfeasible =
FALSE;
2260 return (lpi->
solstat == QS_LP_UNBOUNDED);
2304 return (lpi->
solstat == QS_LP_INFEASIBLE);
2317 return (lpi->
solstat == QS_LP_OPTIMAL || lpi->
solstat == QS_LP_UNBOUNDED);
2399 return (lpi->
solstat == QS_LP_OPTIMAL);
2418 return (lpi->
solstat != QS_LP_NUMERR);
2431 return (lpi->
solstat == QS_LP_OBJ_LIMIT);
2444 return (lpi->
solstat == QS_LP_ITER_LIMIT);
2457 return (lpi->
solstat == QS_LP_TIME_LIMIT);
2518 SCIP_Real* activity,
2532 if ( lpi->
solstat != QS_LP_OPTIMAL )
2535 nrows = QSget_rowcount(lpi->
prob);
2546 for(
i = 0;
i < nrows; ++
i )
2548 switch( lpi->
isen[
i] )
2566#ifdef SCIP_DISABLED_CODE
2574 QSget_status(lpi->
prob, &stat);
2575 if( stat == QS_LP_OPTIMAL )
2578 ncols = QSget_colcount(lpi->
prob);
2582 irstat = lpi->
ibas + ncols;
2586 for(
i = ncols ;
i-- ; )
2590 case QS_COL_BSTAT_BASIC:
2591 case QS_COL_BSTAT_FREE:
2594 SCIPerrorMessage(
"stat col[%d] = %c, rd[%d] = %lg sense %d\n",
i, icstat[
i],
i, redcost[
i] * sense, sense);
2599 case QS_COL_BSTAT_UPPER:
2602 SCIPerrorMessage(
"stat col[%d] = %c, rd[%d] = %lg sense %d\n",
i, icstat[
i],
i, redcost[
i] * sense, sense);
2607 case QS_COL_BSTAT_LOWER:
2608 if( redcost[
i] * sense < -
FEASTOL )
2610 SCIPerrorMessage(
"stat col[%d] = %c, rd[%d] = %lg sense %d\n",
i, icstat[
i],
i, redcost[
i] * sense, sense);
2616 SCIPerrorMessage(
"unknown stat col[%d] = %c, rd[%d] = %lg\n",
i, icstat[
i],
i, redcost[
i] * sense);
2646 SCIP_Real* dualfarkas
2653 SCIPdebugMessage(
"calling QSopt dual Farkas: %d cols, %d rows, %d non zeros\n", QSget_colcount (lpi->
prob),
2654 QSget_rowcount(lpi->
prob), QSget_nzcount(lpi->
prob));
2675 *iterations = nit - lpi->
previt;
2729 SCIPdebugMessage(
"saving QSopt basis into %p/%p\n", (
void*)cstat, (
void*)rstat);
2731 ncols = QSget_colcount(lpi->
prob);
2732 nrows = QSget_rowcount(lpi->
prob);
2742 irstat = lpi->
ibas + ncols;
2751 for(
i = 0;
i < nrows; ++
i )
2755 case QS_ROW_BSTAT_LOWER:
2756 if ( lpi->
isen[
i] ==
'L' )
2761 case QS_ROW_BSTAT_BASIC:
2764 case QS_ROW_BSTAT_UPPER:
2773 for(
i = 0;
i < ncols; ++
i )
2777 case QS_COL_BSTAT_LOWER:
2780 case QS_COL_BSTAT_BASIC:
2783 case QS_COL_BSTAT_UPPER:
2786 case QS_COL_BSTAT_FREE:
2820 SCIPdebugMessage(
"loading basis %p/%p into QSopt\n", (
void*)cstat, (
void*)rstat);
2829 irstat = lpi->
ibas + ncols;
2832 for(
i = 0;
i < nrows; ++
i )
2837 irstat[
i] = QS_ROW_BSTAT_LOWER;
2840 irstat[
i] = QS_ROW_BSTAT_BASIC;
2843 if ( lpi->
isen[
i] ==
'L' )
2844 irstat[
i] = QS_ROW_BSTAT_LOWER;
2846 irstat[
i] = QS_ROW_BSTAT_UPPER;
2854 for(
i = 0;
i < ncols; ++
i )
2859 icstat[
i] = QS_COL_BSTAT_LOWER;
2862 icstat[
i] = QS_COL_BSTAT_BASIC;
2865 icstat[
i] = QS_COL_BSTAT_UPPER;
2868 icstat[
i] = QS_COL_BSTAT_FREE;
2900 nrows = QSget_rowcount(lpi->
prob);
2901 ncols = QSget_colcount(lpi->
prob);
2904 if ( stat == QS_LP_UNSOLVED || stat == QS_LP_MODIFIED || stat == QS_LP_NUMERR )
2912 for(
i = 0;
i < nrows; ++
i )
2914 if( bind[
i] >= ncols )
2915 bind[
i] = -(bind[
i] - ncols) - 1;
2946 nrows = QSget_rowcount(lpi->
prob);
2949 SCIPdebugMessage(
"getting binv-row %d from Qsopt %d cols, %d rows, %d nonz\n",
r, QSget_colcount(lpi->
prob),
2950 QSget_rowcount(lpi->
prob), QSget_nzcount(lpi->
prob));
2953 if ( ninds !=
NULL )
2958 for (
i = 0;
i < nrows;
i++)
3009 const SCIP_Real* binvrow,
3029 if ( ninds !=
NULL )
3032 ncols = QSget_colcount(lpi->
prob);
3033 nrows = QSget_rowcount(lpi->
prob);
3042 for (
i = 0;
i < ncols; ++
i)
3104 ncols = QSget_colcount(lpi->
prob);
3105 nrows = QSget_rowcount(lpi->
prob);
3112 SCIPdebugMessage(
"storing QSopt LPI state in %p (%d cols, %d rows)\n", (
void*)*lpistate, ncols, nrows);
3120 (*lpistate)->ncols = ncols;
3121 (*lpistate)->nrows = nrows;
3147 if( lpistate ==
NULL )
3151 ncols = QSget_colcount(lpi->
prob);
3152 nrows = QSget_rowcount(lpi->
prob);
3159 SCIPdebugMessage(
"loading LPI state %p (%d cols, %d rows) into QSopt LP with %d cols and %d rows\n", (
void*)lpistate, lpistate->
ncols,
3160 lpistate->
nrows, ncols, nrows);
3162 if( lpistate->
ncols == 0 || lpistate->
nrows == 0 )
3171 irstat = lpi->
ibas + ncols;
3180 for(
i = lpistate->
ncols;
i < ncols; ++
i )
3198 for(
i = lpistate->
nrows;
i < nrows; ++
i )
3202 for(
i = 0;
i < nrows; ++
i )
3207 irstat[
i] = QS_ROW_BSTAT_LOWER;
3210 irstat[
i] = QS_ROW_BSTAT_BASIC;
3213 if ( lpi->
isen[
i] ==
'L' )
3214 irstat[
i] = QS_ROW_BSTAT_LOWER;
3216 irstat[
i] = QS_ROW_BSTAT_UPPER;
3225 for(
i = 0;
i < ncols; ++
i )
3230 icstat[
i] = QS_COL_BSTAT_LOWER;
3233 icstat[
i] = QS_COL_BSTAT_BASIC;
3236 icstat[
i] = QS_COL_BSTAT_UPPER;
3239 icstat[
i] = QS_COL_BSTAT_FREE;
3270 ncols = QSget_colcount(lpi->
prob);
3271 nrows = QSget_rowcount(lpi->
prob);
3273 if ( ncols == 0 || nrows == 0 )
3279 for (
i = 0;
i < ncols; ++
i)
3281 for (
i = 0;
i < nrows; ++
i)
3303 if( *lpistate !=
NULL )
3316 return (lpistate !=
NULL);
3333 rval = QSread_and_load_basis(lpi->
prob, fname);
3358 bas = QSget_basis(lpi->
prob);
3359 QS_ERROR(bas == 0,
"Could not get basis from problem.");
3362 rval = QSwrite_basis(lpi->
prob, bas, fname);
3402 ncols = QSget_colcount(lpi->
prob);
3403 nrows = QSget_rowcount(lpi->
prob);
3407 (*lpinorms)->ncols = ncols;
3408 (*lpinorms)->nrows = nrows;
3410 if ( QStest_row_norms(lpi->
prob) )
3416 QS_CONDRET( QSget_basis_and_row_norms_array(lpi->
prob, (*lpinorms)->cstat, (*lpinorms)->rstat, (*lpinorms)->norms) );
3420 (*lpinorms)->cstat =
NULL;
3421 (*lpinorms)->rstat =
NULL;
3422 (*lpinorms)->norms =
NULL;
3447 ncols = QSget_colcount(lpi->
prob);
3448 nrows = QSget_rowcount(lpi->
prob);
3449 if ( nrows != lpinorms->
nrows || ncols != lpinorms->
ncols )
3469 if ( (*lpinorms)->norms !=
NULL )
3471 assert( (*lpinorms)->cstat !=
NULL && (*lpinorms)->rstat !=
NULL );
3513 QS_CONDRET( QSget_param(lpi->
prob, QS_PARAM_SIMPLEX_SCALING, ival) );
3514 assert((*ival) == 0 || (*ival) == 1);
3521 QS_CONDRET( QSget_param(lpi->
prob, QS_PARAM_SIMPLEX_DISPLAY, ival) );
3528 QS_CONDRET( QSget_param(lpi->
prob, QS_PARAM_SIMPLEX_MAX_ITERATIONS, ival) );
3553 QS_CONDRET( QSset_param(lpi->
prob, QS_PARAM_SIMPLEX_SCALING, 0) );
3555 QS_CONDRET( QSset_param(lpi->
prob, QS_PARAM_SIMPLEX_SCALING, 1) );
3566 QS_CONDRET( QSset_param(lpi->
prob, QS_PARAM_PRIMAL_PRICING, QS_PRICE_PSTEEP) );
3567 QS_CONDRET( QSset_param(lpi->
prob, QS_PARAM_DUAL_PRICING, QS_PRICE_DSTEEP) );
3570 QS_CONDRET( QSset_param(lpi->
prob,QS_PARAM_PRIMAL_PRICING,QS_PRICE_PMULTPARTIAL) );
3571 QS_CONDRET( QSset_param(lpi->
prob,QS_PARAM_DUAL_PRICING,QS_PRICE_DMULTPARTIAL) );
3574 QS_CONDRET( QSset_param(lpi->
prob,QS_PARAM_PRIMAL_PRICING,QS_PRICE_PDEVEX) );
3575 QS_CONDRET( QSset_param(lpi->
prob,QS_PARAM_DUAL_PRICING,QS_PRICE_DDEVEX) );
3583 QS_CONDRET( QSset_param(lpi->
prob, QS_PARAM_SIMPLEX_DISPLAY, 1) );
3585 QS_CONDRET( QSset_param(lpi->
prob, QS_PARAM_SIMPLEX_DISPLAY, 0) );
3591 QS_CONDRET( QSset_param(lpi->
prob, QS_PARAM_SIMPLEX_MAX_ITERATIONS, ival) );
3619 if ( sense == QS_MIN )
3621 QS_CONDRET( QSget_param_double(lpi->
prob, QS_PARAM_OBJULIM, dval) );
3625 QS_CONDRET( QSget_param_double(lpi->
prob, QS_PARAM_OBJLLIM, dval) );
3630 QS_CONDRET( QSget_param_double(lpi->
prob, QS_PARAM_SIMPLEX_MAX_TIME, dval) );
3664 QS_CONDRET( QSset_param_double(lpi->
prob, QS_PARAM_SIMPLEX_MAX_TIME, dval) );
3670 if ( sense == QS_MIN )
3672 QS_CONDRET( QSset_param_double(lpi->
prob, QS_PARAM_OBJULIM, dval) );
3676 QS_CONDRET( QSset_param_double(lpi->
prob, QS_PARAM_OBJLLIM, dval) );
3721 return QS_MAXDOUBLE;
3731 return (val >= QS_MAXDOUBLE);
3759 QSfree_prob(lpi->
prob);
3764 lpi->
prob = QSread_prob(fname,
"LP");
3765 if( lpi->
prob == 0 )
3783 if( QSwrite_prob (lpi->
prob, fname,
"LP") )
void SCIPdecodeDualBit(const SCIP_DUALPACKET *inp, int *out, int count)
void SCIPencodeDualBit(const int *inp, SCIP_DUALPACKET *out, int count)
packing single and dual bit values
unsigned int SCIP_DUALPACKET
SCIP_RETCODE SCIPlpiChgSides(SCIP_LPI *lpi, int nrows, const int *ind, const SCIP_Real *lhs, const SCIP_Real *rhs)
SCIP_RETCODE SCIPlpiSetState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, const SCIP_LPISTATE *lpistate)
SCIP_RETCODE SCIPlpiGetBInvACol(SCIP_LPI *lpi, int c, SCIP_Real *coef, int *inds, int *ninds)
SCIP_RETCODE SCIPlpiGetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real *dval)
SCIP_Real SCIPlpiInfinity(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiIsObjlimExc(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiChgObjsen(SCIP_LPI *lpi, SCIP_OBJSEN objsen)
SCIP_Bool SCIPlpiIsInfinity(SCIP_LPI *lpi, SCIP_Real val)
SCIP_RETCODE SCIPlpiClear(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiClearState(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiExistsDualRay(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiExistsPrimalRay(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetBase(SCIP_LPI *lpi, int *cstat, int *rstat)
SCIP_RETCODE SCIPlpiReadState(SCIP_LPI *lpi, const char *fname)
SCIP_RETCODE SCIPlpiAddRows(SCIP_LPI *lpi, int nrows, const SCIP_Real *lhs, const SCIP_Real *rhs, char **rownames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)
SCIP_RETCODE SCIPlpiGetPrimalRay(SCIP_LPI *lpi, SCIP_Real *ray)
SCIP_RETCODE SCIPlpiGetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int *ival)
SCIP_RETCODE SCIPlpiWriteLP(SCIP_LPI *lpi, const char *fname)
SCIP_RETCODE SCIPlpiSetIntegralityInformation(SCIP_LPI *lpi, int ncols, int *intInfo)
SCIP_Bool SCIPlpiIsDualInfeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiSetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real dval)
SCIP_RETCODE SCIPlpiStrongbranchFrac(SCIP_LPI *lpi, int col, SCIP_Real psol, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
SCIP_RETCODE SCIPlpiSetNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, const SCIP_LPINORMS *lpinorms)
SCIP_RETCODE SCIPlpiGetNNonz(SCIP_LPI *lpi, int *nnonz)
SCIP_Bool SCIPlpiHasPrimalSolve(void)
SCIP_RETCODE SCIPlpiStrongbranchInt(SCIP_LPI *lpi, int col, SCIP_Real psol, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
SCIP_RETCODE SCIPlpiGetBounds(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *lbs, SCIP_Real *ubs)
SCIP_Bool SCIPlpiHasBarrierSolve(void)
SCIP_RETCODE SCIPlpiGetDualfarkas(SCIP_LPI *lpi, SCIP_Real *dualfarkas)
SCIP_RETCODE SCIPlpiGetObjval(SCIP_LPI *lpi, SCIP_Real *objval)
SCIP_RETCODE SCIPlpiScaleCol(SCIP_LPI *lpi, int col, SCIP_Real scaleval)
int SCIPlpiGetInternalStatus(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiStartStrongbranch(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetSolFeasibility(SCIP_LPI *lpi, SCIP_Bool *primalfeasible, SCIP_Bool *dualfeasible)
SCIP_RETCODE SCIPlpiFreeNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
SCIP_Bool SCIPlpiIsIterlimExc(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiChgBounds(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *lb, const SCIP_Real *ub)
SCIP_Bool SCIPlpiIsPrimalUnbounded(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiIgnoreInstability(SCIP_LPI *lpi, SCIP_Bool *success)
SCIP_RETCODE SCIPlpiWriteState(SCIP_LPI *lpi, const char *fname)
SCIP_RETCODE SCIPlpiFree(SCIP_LPI **lpi)
SCIP_RETCODE SCIPlpiStrongbranchesFrac(SCIP_LPI *lpi, int *cols, int ncols, SCIP_Real *psols, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
SCIP_RETCODE SCIPlpiGetCoef(SCIP_LPI *lpi, int row, int col, SCIP_Real *val)
SCIP_Bool SCIPlpiIsPrimalFeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiReadLP(SCIP_LPI *lpi, const char *fname)
SCIP_RETCODE SCIPlpiGetRealSolQuality(SCIP_LPI *lpi, SCIP_LPSOLQUALITY qualityindicator, SCIP_Real *quality)
SCIP_Bool SCIPlpiIsDualFeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
SCIP_Bool SCIPlpiIsTimelimExc(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiHasStateBasis(SCIP_LPI *lpi, SCIP_LPISTATE *lpistate)
SCIP_RETCODE SCIPlpiSetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int ival)
const char * SCIPlpiGetSolverName(void)
SCIP_RETCODE SCIPlpiSetBase(SCIP_LPI *lpi, const int *cstat, const int *rstat)
SCIP_Bool SCIPlpiHasPrimalRay(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetBInvRow(SCIP_LPI *lpi, int r, SCIP_Real *coef, int *inds, int *ninds)
SCIP_RETCODE SCIPlpiDelRows(SCIP_LPI *lpi, int firstrow, int lastrow)
SCIP_RETCODE SCIPlpiGetCols(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *lb, SCIP_Real *ub, int *nnonz, int *beg, int *ind, SCIP_Real *val)
SCIP_RETCODE SCIPlpiGetBInvCol(SCIP_LPI *lpi, int c, SCIP_Real *coef, int *inds, int *ninds)
SCIP_RETCODE SCIPlpiGetColNames(SCIP_LPI *lpi, int firstcol, int lastcol, char **colnames, char *namestorage, int namestoragesize, int *storageleft)
SCIP_RETCODE SCIPlpiGetBInvARow(SCIP_LPI *lpi, int r, const SCIP_Real *binvrow, SCIP_Real *coef, int *inds, int *ninds)
SCIP_RETCODE SCIPlpiGetRows(SCIP_LPI *lpi, int firstrow, int lastrow, SCIP_Real *lhs, SCIP_Real *rhs, int *nnonz, int *beg, int *ind, SCIP_Real *val)
SCIP_Bool SCIPlpiWasSolved(SCIP_LPI *lpi)
const char * SCIPlpiGetSolverDesc(void)
SCIP_RETCODE SCIPlpiSolveBarrier(SCIP_LPI *lpi, SCIP_Bool crossover)
SCIP_Bool SCIPlpiIsOptimal(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetRowNames(SCIP_LPI *lpi, int firstrow, int lastrow, char **rownames, char *namestorage, int namestoragesize, int *storageleft)
SCIP_Bool SCIPlpiHasDualSolve(void)
SCIP_RETCODE SCIPlpiEndStrongbranch(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetSides(SCIP_LPI *lpi, int firstrow, int lastrow, SCIP_Real *lhss, SCIP_Real *rhss)
SCIP_RETCODE SCIPlpiStrongbranchesInt(SCIP_LPI *lpi, int *cols, int ncols, SCIP_Real *psols, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
SCIP_RETCODE SCIPlpiGetSol(SCIP_LPI *lpi, SCIP_Real *objval, SCIP_Real *primsol, SCIP_Real *dualsol, SCIP_Real *activity, SCIP_Real *redcost)
SCIP_Bool SCIPlpiHasDualRay(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiDelColset(SCIP_LPI *lpi, int *dstat)
SCIP_RETCODE SCIPlpiGetObj(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *vals)
SCIP_RETCODE SCIPlpiFreeState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
SCIP_Bool SCIPlpiIsPrimalInfeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiSolveDual(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiAddCols(SCIP_LPI *lpi, int ncols, const SCIP_Real *obj, const SCIP_Real *lb, const SCIP_Real *ub, char **colnames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)
SCIP_RETCODE SCIPlpiSolvePrimal(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiLoadColLP(SCIP_LPI *lpi, SCIP_OBJSEN objsen, int ncols, const SCIP_Real *obj, const SCIP_Real *lb, const SCIP_Real *ub, char **colnames, int nrows, const SCIP_Real *lhs, const SCIP_Real *rhs, char **rownames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)
SCIP_Bool SCIPlpiIsDualUnbounded(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetIterations(SCIP_LPI *lpi, int *iterations)
SCIP_RETCODE SCIPlpiGetBasisInd(SCIP_LPI *lpi, int *bind)
SCIP_RETCODE SCIPlpiCreate(SCIP_LPI **lpi, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_OBJSEN objsen)
void * SCIPlpiGetSolverPointer(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiChgObj(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *obj)
SCIP_RETCODE SCIPlpiGetObjsen(SCIP_LPI *lpi, SCIP_OBJSEN *objsen)
SCIP_Bool SCIPlpiIsStable(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetNCols(SCIP_LPI *lpi, int *ncols)
SCIP_RETCODE SCIPlpiInterrupt(SCIP_LPI *lpi, SCIP_Bool interrupt)
SCIP_RETCODE SCIPlpiDelCols(SCIP_LPI *lpi, int firstcol, int lastcol)
SCIP_RETCODE SCIPlpiDelRowset(SCIP_LPI *lpi, int *dstat)
SCIP_RETCODE SCIPlpiScaleRow(SCIP_LPI *lpi, int row, SCIP_Real scaleval)
SCIP_RETCODE SCIPlpiGetNRows(SCIP_LPI *lpi, int *nrows)
SCIP_RETCODE SCIPlpiGetState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
SCIP_RETCODE SCIPlpiChgCoef(SCIP_LPI *lpi, int row, int col, SCIP_Real newval)
assert(minobj< SCIPgetCutoffbound(scip))
interface methods for specific LP solvers
SCIP_DUALPACKET ROWPACKET
SCIP_DUALPACKET COLPACKET
static void lpistatePack(SCIP_LPISTATE *lpistate, const int *cstat, const int *rstat)
static void lpistateUnpack(const SCIP_LPISTATE *lpistate, int *cstat, int *rstat)
static int rowpacketNum(int nrows)
SCIP_DUALPACKET ROWPACKET
static SCIP_RETCODE ensureTabMem(SCIP_LPI *const lpi, int sz)
enum LPI_QSOPT_Algo LPI_QSOPT_ALGO
static void lpistateFree(SCIP_LPISTATE **lpistate, BMS_BLKMEM *blkmem)
#define QS_TESTG(A, B, C)
SCIP_DUALPACKET COLPACKET
static int colpacketNum(int ncols)
static SCIP_RETCODE ensureRowMem(SCIP_LPI *const lpi, int nrows)
static SCIP_RETCODE convertSides(SCIP_LPI *const lpi, int nrows, const double *const lhs, const double *const rhs)
static SCIP_RETCODE ensureColMem(SCIP_LPI *const lpi, int ncols)
static SCIP_RETCODE lpistateCreate(SCIP_LPISTATE **lpistate, BMS_BLKMEM *blkmem, int ncols, int nrows)
#define BMSfreeMemory(ptr)
#define BMSfreeBlockMemory(mem, ptr)
#define BMSallocBlockMemory(mem, ptr)
#define BMSreallocMemoryArray(ptr, num)
#define BMSallocMemoryArray(ptr, num)
#define BMSfreeMemoryArray(ptr)
#define BMSallocBlockMemoryArray(mem, ptr, num)
#define BMScopyMemoryArray(ptr, source, num)
#define BMSfreeBlockMemoryArray(mem, ptr, num)
struct BMS_BlkMem BMS_BLKMEM
#define BMSallocMemory(ptr)
public methods for message output
public data structures and miscellaneous methods
SCIP_MESSAGEHDLR * messagehdlr
@ SCIP_PRICING_STEEPQSTART
@ SCIP_PRICING_LPIDEFAULT
enum SCIP_LPParam SCIP_LPPARAM
@ SCIP_LPPAR_BARRIERCONVTOL
enum SCIP_LPSolQuality SCIP_LPSOLQUALITY
enum SCIP_ObjSen SCIP_OBJSEN
enum SCIP_Retcode SCIP_RETCODE