73 if( row->
name != NULL && row->
name[0] !=
'\0' )
86 for( i = 0; i < row->
len; ++i )
88 assert(row->
cols[i] != NULL);
89 assert(row->
cols[i]->
var != NULL);
105 #define debugRowPrint(x,y) 119 assert(col->
var != NULL);
129 for( r = 0; r < col->
len; ++r )
131 assert(col->
rows[r] != NULL);
138 #define debugColPrint(x,y) 163 assert(num <= lp->chgcolssize);
186 assert(num <= lp->chgrowssize);
209 assert(num <= lp->lpicolssize);
232 assert(num <= lp->lpirowssize);
255 assert(num <= lp->colssize);
278 assert(num <= lp->lazycolssize);
301 assert(num <= lp->rowssize);
318 if( num > col->
size )
328 assert(num <= col->size);
344 assert(stat != NULL);
345 assert(blkmem != NULL);
378 assert(blkmem != NULL);
382 if( storedsolvals != NULL )
435 assert(blkmem != NULL);
464 assert(blkmem != NULL);
468 if( storedsolvals != NULL )
510 assert(blkmem != NULL);
549 assert(blkmem != NULL);
553 if( storedsolvals != NULL )
596 if( num > row->
size )
607 assert(num <= row->size);
623 if( !msgdisp_checkrow )
625 printf(
"LP ROW CHECKING ACTIVATED! THIS IS VERY SLOW!\n");
626 msgdisp_checkrow =
TRUE;
633 for( i = 1; i < row->
nlpcols; ++i )
644 for( i = row->
nlpcols + 1; i < row->len; ++i )
652 #define checkRow(row) 666 assert(cols != NULL || row->
len == 0);
670 for( c = row->
len - 1; c >= 0; --c )
672 if( cols[c]->lppos >= 0 )
673 sqrnorm += SQR(row->
vals[c]);
676 assert(ABS(sqrnorm - row->
sqrnorm) < 1e-06 *
MAX(1.0,sqrnorm));
689 assert(cols != NULL || row->
len == 0);
693 for( c = row->
len - 1; c >= 0; --c )
695 if( cols[c]->lppos >= 0 )
699 assert(ABS(sumnorm - row->
sumnorm) < 1e-06 *
MAX(1.0,sumnorm));
712 assert(cols != NULL || row->
len == 0);
716 for( c = row->
len - 1; c >= 0; --c )
718 if( cols[c]->lppos >= 0 )
722 assert(ABS(objprod - row->
objprod) < 1e-06 *
MAX(1.0,objprod));
725 #define checkRowSqrnorm(row) 726 #define checkRowSumnorm(row) 727 #define checkRowObjprod(row) 749 assert(prob != NULL);
757 for( v = 0; v < nvars; ++v )
790 assert(prob != NULL);
798 for( v = 0; v < nvars; ++v )
832 assert(prob != NULL);
840 for( v = 0; v < nvars; ++v )
870 assert(prob != NULL);
892 assert(prob != NULL);
909 assert(elem1 != NULL);
910 assert(elem2 != NULL);
942 for( i = 0; i < col->
nlprows; ++i )
975 for( i = col->
nlprows; i < col->len; ++i )
1006 for( i = 0; i < row->
nlpcols; ++i )
1029 assert(row != NULL);
1041 for( i = row->
nlpcols; i < row->len; ++i )
1069 assert(col != NULL);
1070 assert(row != NULL);
1073 searchidx = row->
index;
1074 while(minpos <= maxpos)
1076 pos = (minpos + maxpos)/2;
1077 assert(0 <= pos && pos < col->len);
1078 assert(col->
rows[pos] != NULL);
1079 assert((pos < col->nlprows) == (col->
rows[pos]->
lppos >= 0 && col->
linkpos[pos] >= 0));
1081 if( searchidx == idx )
1083 else if( searchidx < idx )
1101 assert(col != NULL);
1102 assert(row != NULL);
1107 if( row->
lppos >= 0 )
1144 assert(row != NULL);
1145 assert(col != NULL);
1148 searchidx = col->
index;
1149 while(minpos <= maxpos)
1151 pos = (minpos + maxpos)/2;
1152 assert(0 <= pos && pos < row->len);
1153 assert(row->
cols[pos] != NULL);
1154 assert((pos < row->nlpcols) == (row->
cols[pos]->
lppos >= 0 && row->
linkpos[pos] >= 0));
1157 if( searchidx == idx )
1159 else if( searchidx < idx )
1179 assert(row != NULL);
1180 assert(col != NULL);
1188 if( col->
lppos >= 0 )
1209 assert(-1 <= pos && pos < row->len);
1211 assert(row->
cols[pos] == col);
1215 for( i = 0; i < row->
len; ++i )
1216 assert(row->
cols[i] != col);
1231 assert(col != NULL);
1232 assert(0 <= oldpos && oldpos < col->len);
1233 assert(0 <= newpos && newpos < col->len);
1234 assert(col->
rows[oldpos] != NULL);
1236 if( oldpos == newpos )
1239 col->
rows[newpos] = col->
rows[oldpos];
1240 col->
vals[newpos] = col->
vals[oldpos];
1244 if( col->
linkpos[newpos] >= 0 )
1271 assert(col != NULL);
1272 assert(0 <= pos1 && pos1 < col->len);
1273 assert(0 <= pos2 && pos2 < col->len);
1274 assert(col->
rows[pos1] != NULL);
1280 tmprow = col->
rows[pos2];
1281 tmpval = col->
vals[pos2];
1282 tmplinkpos = col->
linkpos[pos2];
1288 col->
rows[pos1] = tmprow;
1289 col->
vals[pos1] = tmpval;
1290 col->
linkpos[pos1] = tmplinkpos;
1327 assert(row != NULL);
1328 assert(0 <= oldpos && oldpos < row->len);
1329 assert(0 <= newpos && newpos < row->len);
1330 assert(row->
cols[oldpos] != NULL);
1332 if( oldpos == newpos )
1335 row->
cols[newpos] = row->
cols[oldpos];
1337 row->
vals[newpos] = row->
vals[oldpos];
1341 if( row->
linkpos[newpos] >= 0 )
1369 assert(row != NULL);
1370 assert(0 <= pos1 && pos1 < row->len);
1371 assert(0 <= pos2 && pos2 < row->len);
1372 assert(row->
cols[pos1] != NULL);
1379 tmpcol = row->
cols[pos2];
1381 tmpval = row->
vals[pos2];
1382 tmplinkpos = row->
linkpos[pos2];
1389 row->
cols[pos1] = tmpcol;
1391 row->
vals[pos1] = tmpval;
1392 row->
linkpos[pos1] = tmplinkpos;
1433 assert(row != NULL);
1435 assert(col != NULL);
1462 assert(row != NULL);
1491 assert(row != NULL);
1511 #define ASSERT(x) do { if( !(x) ) abort(); } while( FALSE ) 1513 #define ASSERT(x) assert(x) 1531 if( !msgdisp_checklinks )
1533 printf(
"LP LINK CHECKING ACTIVATED! THIS IS VERY SLOW!\n");
1534 msgdisp_checklinks =
TRUE;
1537 for( i = 0; i < lp->
ncols; ++i )
1540 ASSERT(col != NULL);
1546 for( j = 0; j < col->
len; ++j )
1549 ASSERT(row != NULL);
1553 ASSERT((j < col->nlprows) == (col->
linkpos[j] >= 0 && row->
lppos >= 0));
1557 for( i = 0; i < lp->
nrows; ++i )
1560 ASSERT(row != NULL);
1566 for( j = 0; j < row->
len; ++j )
1569 ASSERT(col != NULL);
1573 ASSERT((j < row->nlpcols) == (row->
linkpos[j] >= 0 && col->
lppos >= 0));
1581 #define checkLinks(lp) 1596 assert(row != NULL);
1597 assert(col != NULL);
1668 assert(blkmem != NULL);
1669 assert(col != NULL);
1671 assert(col->
var != NULL);
1672 assert(row != NULL);
1677 assert(col->
rows != NULL);
1678 assert(col->
vals != NULL);
1687 if( row->
lppos >= 0 && linkpos >= 0 )
1702 col->
rows[pos] = row;
1703 col->
vals[pos] = val;
1712 if( col->
lppos >= 0 )
1718 if( row->
lppos >= 0 )
1722 assert(0 <= linkpos && linkpos < row->len);
1723 assert(row->
cols[linkpos] == col);
1724 assert(col->
rows[pos] == row);
1731 assert(row->
linkpos[linkpos] == -1);
1739 if( col->
lppos >= 0 )
1745 if( linkpos == row->
nlpcols-1 )
1751 if( row->
lppos >= 0 && linkpos >= 0 )
1761 assert(col->
rows[col->
len-1] == row);
1768 SCIPsetDebugMsg(
set,
"added coefficient %g * <%s> at position %d (%d/%d) to column <%s> (nunlinked=%d)\n",
1785 assert(col != NULL);
1786 assert(col->
var != NULL);
1787 assert(
set != NULL);
1788 assert(0 <= pos && pos < col->len);
1789 assert(col->
rows[pos] != NULL);
1791 assert((pos < col->nlprows) == (col->
linkpos[pos] >= 0 && col->
rows[pos]->
lppos >= 0));
1793 row = col->
rows[pos];
1794 assert((row->
lppos >= 0) == (pos < col->nlprows));
1803 if( pos < col->nlprows )
1829 assert(col != NULL);
1830 assert(col->
var != NULL);
1831 assert(0 <= pos && pos < col->len);
1832 assert(col->
rows[pos] != NULL);
1849 col->
vals[pos] = val;
1875 assert(row != NULL);
1878 assert(
set != NULL);
1879 assert(col != NULL);
1885 if( col->
lppos >= 0 )
1936 assert(row->
nummaxval <= 0 || absval <= row->maxval);
1954 assert(row != NULL);
1957 assert(
set != NULL);
1958 assert(col != NULL);
1970 if( forcenormupdate || col->
lppos >= 0 )
2013 assert(row != NULL);
2015 assert(blkmem != NULL);
2016 assert(col != NULL);
2017 assert(col->
var != NULL);
2029 assert(row->
cols != NULL);
2030 assert(row->
vals != NULL);
2038 if( col->
lppos >= 0 && linkpos >= 0 )
2053 row->
cols[pos] = col;
2055 row->
vals[pos] = val;
2065 if( row->
lppos >= 0 )
2071 if( col->
lppos >= 0 )
2075 assert(0 <= linkpos && linkpos < col->len);
2076 assert(col->
rows[linkpos] == row);
2077 assert(row->
cols[pos] == col);
2084 assert(col->
linkpos[linkpos] == -1);
2092 if( row->
lppos >= 0 )
2098 if( linkpos == col->
nlprows-1 )
2104 if( col->
lppos >= 0 && linkpos >= 0 )
2117 assert(row->
cols[row->
len-1] == col);
2130 SCIPsetDebugMsg(
set,
"added coefficient %g * <%s> at position %d (%d/%d) to row <%s> (nunlinked=%d)\n",
2153 assert(row != NULL);
2154 assert(
set != NULL);
2155 assert(0 <= pos && pos < row->len);
2156 assert(row->
cols[pos] != NULL);
2157 assert((pos < row->nlpcols) == (row->
linkpos[pos] >= 0 && row->
cols[pos]->
lppos >= 0));
2159 col = row->
cols[pos];
2160 val = row->
vals[pos];
2161 assert((pos < row->nlpcols) == (col->
lppos >= 0 && row->
linkpos[pos] >= 0));
2168 SCIPerrorMessage(
"cannot delete a coefficient from the locked unmodifiable row <%s>\n", row->
name);
2176 if( pos < row->nlpcols )
2213 assert(row != NULL);
2214 assert(0 <= pos && pos < row->len);
2221 SCIPerrorMessage(
"cannot change a coefficient of the locked unmodifiable row <%s>\n", row->
name);
2227 col = row->
cols[pos];
2228 assert(row->
cols[pos] != NULL);
2239 oldval = row->
vals[pos];
2243 row->
vals[pos] = val;
2264 assert(row != NULL);
2320 assert(col != NULL);
2321 assert(col->
var != NULL);
2322 assert(blkmem != NULL);
2323 assert(
set != NULL);
2331 for( i = col->
nlprows; i < col->len; ++i )
2364 assert(col != NULL);
2365 assert(col->
var != NULL);
2366 assert(blkmem != NULL);
2367 assert(
set != NULL);
2373 for( i = 0; i < col->
len; ++i )
2403 assert(row != NULL);
2404 assert(blkmem != NULL);
2405 assert(
set != NULL);
2413 for( i = row->
nlpcols; i < row->len; ++i )
2444 assert(row != NULL);
2445 assert(
set != NULL);
2451 for( i = 0; i < row->
len; ++i )
2485 assert(success != NULL);
2509 return lpSetIntpar(lp, lpparam, (
int)value, success);
2524 assert(success != NULL);
2560 assert(lpivalue == value);
2596 assert(lpivalue == value);
2601 #define lpCheckIntpar(lp, lpparam, value) SCIP_OKAY 2602 #define lpCheckBoolpar(lp, lpparam, value) SCIP_OKAY 2603 #define lpCheckRealpar(lp, lpparam, value) SCIP_OKAY 2607 #define lpCutoffDisabled(set) (set->lp_disablecutoff == 1 || (set->nactivepricers > 0 && set->lp_disablecutoff == 2)) 2621 assert(
set != NULL);
2663 assert(feastol >= 0.0);
2664 assert(success != NULL);
2673 if( lp->
nrows > 0 && feastol < lp->lpifeastol )
2700 assert(dualfeastol >= 0.0);
2701 assert(success != NULL);
2710 if( lp->
nrows > 0 && dualfeastol < lp->lpidualfeastol )
2737 assert(barrierconvtol >= 0.0);
2738 assert(success != NULL);
2747 if( lp->
nrows > 0 && barrierconvtol < lp->lpibarrierconvtol
2775 assert(success != NULL);
2800 assert(success != NULL);
2801 assert(0 <= fastmip && fastmip <= 1);
2826 assert(success != NULL);
2851 assert(success != NULL);
2876 assert(success != NULL);
2901 assert(success != NULL);
2927 assert(itlim >= -1);
2985 switch( pricingchar )
3050 assert(success != NULL);
3078 assert(success != NULL);
3086 lptiming = (int) timing;
3109 assert(success != NULL);
3113 if( randomseed == 0 )
3139 assert(success != NULL);
3162 assert(success != NULL);
3196 assert(col != NULL);
3197 assert(blkmem != NULL);
3198 assert(
set != NULL);
3199 assert(stat != NULL);
3200 assert(var != NULL);
3202 assert(len == 0 || (rows != NULL && vals != NULL));
3212 for( i = 0; i < len; ++i )
3214 assert(rows[i] != NULL);
3216 (*col)->linkpos[i] = -1;
3221 (*col)->rows = NULL;
3222 (*col)->vals = NULL;
3223 (*col)->linkpos = NULL;
3231 (*col)->flushedobj = 0.0;
3232 (*col)->flushedlb = 0.0;
3233 (*col)->flushedub = 0.0;
3234 (*col)->index = stat->
ncolidx;
3238 (*col)->nlprows = 0;
3239 (*col)->nunlinked = len;
3241 (*col)->lpipos = -1;
3242 (*col)->lpdepth = -1;
3243 (*col)->primsol = 0.0;
3246 (*col)->minprimsol = (*col)->ub;
3247 (*col)->maxprimsol = (*col)->lb;
3252 (*col)->sbnode = -1;
3253 (*col)->validredcostlp = -1;
3254 (*col)->validfarkaslp = -1;
3255 (*col)->validsblp = -1;
3256 (*col)->sbitlim = -1;
3257 (*col)->nsbcalls = 0;
3259 (*col)->obsoletenode = -1;
3262 (*col)->lprowssorted =
TRUE;
3263 (*col)->nonlprowssorted = (len <= 1);
3264 (*col)->objchanged =
FALSE;
3265 (*col)->lbchanged =
FALSE;
3266 (*col)->ubchanged =
FALSE;
3267 (*col)->coefchanged =
FALSE;
3269 (*col)->removable = removable;
3270 (*col)->sbdownvalid =
FALSE;
3271 (*col)->sbupvalid =
FALSE;
3274 (*col)->storedsolvals = NULL;
3288 assert(blkmem != NULL);
3289 assert(col != NULL);
3290 assert(*col != NULL);
3291 assert((*col)->var != NULL);
3293 assert(&(*col)->var->data.col == col);
3294 assert((*col)->lppos == -1);
3295 assert((*col)->lpipos == -1);
3318 assert(col != NULL);
3319 assert(col->
var != NULL);
3327 for( r = 0; r < col->
len; ++r )
3329 assert(col->
rows[r] != NULL);
3330 assert(col->
rows[r]->
name != NULL);
3382 assert(col != NULL);
3383 assert(col->
var != NULL);
3386 assert(row != NULL);
3395 assert(0 <= pos && pos < col->len);
3396 assert(col->
rows[pos] == row);
3428 assert(col != NULL);
3431 assert(row != NULL);
3445 assert(0 <= pos && pos < col->len);
3446 assert(col->
rows[pos] == row);
3479 assert(col != NULL);
3482 assert(row != NULL);
3499 assert(0 <= pos && pos < col->len);
3500 assert(col->
rows[pos] == row);
3555 assert(
set != NULL);
3608 assert(col != NULL);
3609 assert(col->
var != NULL);
3667 assert(col != NULL);
3668 assert(col->
var != NULL);
3712 assert(col != NULL);
3713 assert(col->
var != NULL);
3759 assert(col != NULL);
3762 assert(dualsol != NULL);
3765 for( i = 0; i < col->
nlprows; ++i )
3768 assert(row != NULL);
3769 assert(row->
lppos >= 0);
3770 redcost -= col->
vals[i] * dualsol[row->
lppos];
3775 for( i = col->
nlprows; i < col->len; ++i )
3778 assert(row != NULL);
3780 if( row->
lppos >= 0 )
3781 redcost -= col->
vals[i] * dualsol[row->
lppos];
3787 for( i = col->
nlprows; i < col->len; ++i )
3790 assert(row != NULL);
3791 assert(row->
lppos == -1);
3810 assert(col != NULL);
3815 for( i = 0; i < col->
nlprows; ++i )
3818 assert(row != NULL);
3820 assert(row->
lppos >= 0);
3827 for( i = col->
nlprows; i < col->len; ++i )
3830 assert(row != NULL);
3833 if( row->
lppos >= 0 )
3840 for( i = col->
nlprows; i < col->len; ++i )
3843 assert(row != NULL);
3845 assert(row->
lppos == -1);
3861 assert(col != NULL);
3862 assert(stat != NULL);
3886 assert(col != NULL);
3887 assert(
set != NULL);
3888 assert(stat != NULL);
3942 assert(col != NULL);
3945 assert(dualfarkas != NULL);
3948 for( i = 0; i < col->
nlprows; ++i )
3951 assert(row != NULL);
3952 assert(row->
lppos >= 0);
3953 farkas += col->
vals[i] * dualfarkas[row->
lppos];
3958 for( i = col->
nlprows; i < col->len; ++i )
3961 assert(row != NULL);
3963 if( row->
lppos >= 0 )
3964 farkas += col->
vals[i] * dualfarkas[row->
lppos];
3970 for( i = col->
nlprows; i < col->len; ++i )
3973 assert(row != NULL);
3974 assert(row->
lppos == -1);
3993 assert(col != NULL);
3998 for( i = 0; i < col->
nlprows; ++i )
4001 assert(row != NULL);
4003 assert(row->
lppos >= 0);
4010 for( i = col->
nlprows; i < col->len; ++i )
4013 assert(row != NULL);
4016 if( row->
lppos >= 0 )
4023 for( i = col->
nlprows; i < col->len; ++i )
4026 assert(row != NULL);
4028 assert(row->
lppos == -1);
4044 assert(col != NULL);
4045 assert(stat != NULL);
4072 assert(col != NULL);
4076 if( farkascoef > 0.0 )
4077 return col->
ub * farkascoef;
4079 return col->
lb * farkascoef;
4128 assert(col != NULL);
4129 assert(col->
var != NULL);
4134 assert(col->
lpipos >= 0);
4135 assert(col->
lppos >= 0);
4136 assert(
set != NULL);
4137 assert(stat != NULL);
4162 SCIPstatAdd(stat,
set, nrootsblpiterations, iter);
4174 assert(col != NULL);
4175 assert(col->
var != NULL);
4180 assert(col->
lpipos >= 0);
4181 assert(col->
lppos >= 0);
4182 assert(
set != NULL);
4183 assert(stat != NULL);
4219 assert(col != NULL);
4220 assert(col->
var != NULL);
4226 assert(col->
lpipos >= 0);
4227 assert(col->
lppos >= 0);
4228 assert(
set != NULL);
4229 assert(stat != NULL);
4242 assert(lperror != NULL);
4271 SCIPsetDebugMsg(
set,
"performing strong branching on variable <%s>(%g) with %d iterations\n",
4329 if( iter/2 >= itlim )
4337 SCIPstatAdd(stat,
set, nrootsblpiterations, iter);
4352 if( downvalid != NULL )
4354 if( upvalid != NULL )
4392 assert(cols != NULL);
4393 assert(
set != NULL);
4394 assert(stat != NULL);
4401 assert(down != NULL);
4403 assert(lperror != NULL);
4424 for( j = 0; j < ncols; ++j )
4436 assert(col->
lpipos >= 0);
4437 assert(col->
lppos >= 0);
4457 if( downvalid != NULL )
4459 if( upvalid != NULL )
4467 lpipos[nsubcols] = col->
lpipos;
4468 primsols[nsubcols] = col->
primsol;
4470 subidx[nsubcols] = j;
4471 subcols[nsubcols++] = col;
4479 if( downvalid != NULL )
4481 if( upvalid != NULL )
4486 SCIPsetDebugMsg(
set,
"performing strong branching on %d variables with %d iterations\n", ncols, itlim);
4499 for( j = 0; j < nsubcols; ++j )
4517 up[idx] = col->
sbup;
4518 if( downvalid != NULL )
4520 if( upvalid != NULL )
4533 for( j = 0; j < nsubcols; ++j )
4550 up[idx] = col->
sbup;
4551 if( downvalid != NULL )
4553 if( upvalid != NULL )
4566 if( iter/2 >= itlim )
4573 SCIPstatAdd(stat,
set, nrootstrongbranchs, ncols);
4574 SCIPstatAdd(stat,
set, nrootsblpiterations, iter);
4609 assert(col != NULL);
4615 if( downvalid != NULL )
4617 if( upvalid != NULL )
4619 if( solval != NULL )
4621 if( lpobjval != NULL )
4634 assert(col != NULL);
4635 assert(stat != NULL);
4646 assert(col != NULL);
4647 assert(stat != NULL);
4648 assert(stat->
nnodes > 0);
4668 assert(row != NULL);
4669 assert(
set != NULL);
4687 for( i = 0; i < row->
nlpcols; ++i )
4689 assert(row->
cols[i] != NULL);
4702 for( i = row->
nlpcols; i < row->len; ++i )
4704 assert(row->
cols[i] != NULL);
4729 assert(row != NULL);
4730 assert(
set != NULL);
4742 for( i = 0; i < row->
len; ++i )
4745 assert(col != NULL);
4802 assert(mindelta <= 0.0);
4803 assert(maxdelta >= 0.0);
4805 sval = val * scalar;
4806 downval = floor(sval);
4811 if( intval != NULL )
4817 if( intval != NULL )
4859 assert(row != NULL);
4860 assert(row->
len == 0 || row->
cols != NULL);
4861 assert(row->
len == 0 || row->
vals != NULL);
4863 assert(-1.0 < minrounddelta && minrounddelta <= 0.0);
4864 assert(0.0 <= maxrounddelta && maxrounddelta < 1.0);
4866 SCIPsetDebugMsg(
set,
"scale row <%s> with %g (tolerance=[%g,%g])\n", row->
name, scaleval, minrounddelta, maxrounddelta);
4870 mindeltainf =
FALSE;
4871 maxdeltainf =
FALSE;
4881 while( c < row->len )
4900 newval = val * scaleval;
4902 &&
isIntegralScalar(val, scaleval, minrounddelta, maxrounddelta, &intval) )
4906 if( intval < newval )
4908 mindelta += (intval - newval)*ub;
4909 maxdelta += (intval - newval)*lb;
4915 mindelta += (intval - newval)*lb;
4916 maxdelta += (intval - newval)*ub;
4938 if( oldlen != row->
len )
4940 assert(row->
len == oldlen - 1);
4962 newval = (row->
lhs - row->
constant) * scaleval + mindelta;
4974 newval = (row->
rhs - row->
constant) * scaleval + maxdelta;
5020 assert(row != NULL);
5021 assert(blkmem != NULL);
5022 assert(stat != NULL);
5024 assert(len == 0 || (cols != NULL && vals != NULL));
5033 (*row)->integral =
TRUE;
5044 for( i = 0; i < len; ++i )
5046 assert(cols[i] != NULL);
5050 (*row)->cols_index[i] = cols[i]->
index;
5051 (*row)->linkpos[i] = -1;
5059 (*row)->integral =
FALSE;
5065 (*row)->cols = NULL;
5066 (*row)->cols_index = NULL;
5067 (*row)->vals = NULL;
5068 (*row)->linkpos = NULL;
5072 (*row)->constant = 0.0;
5077 (*row)->sqrnorm = 0.0;
5078 (*row)->sumnorm = 0.0;
5079 (*row)->objprod = 0.0;
5080 (*row)->maxval = 0.0;
5082 (*row)->dualsol = 0.0;
5084 (*row)->dualfarkas = 0.0;
5088 (*row)->origin = origin;
5089 (*row)->eventfilter = NULL;
5090 (*row)->index = stat->
nrowidx;
5094 (*row)->nlpcols = 0;
5095 (*row)->nunlinked = len;
5098 (*row)->lpipos = -1;
5099 (*row)->lpdepth = -1;
5100 (*row)->minidx = INT_MAX;
5101 (*row)->maxidx = INT_MIN;
5102 (*row)->nummaxval = 0;
5103 (*row)->numminval = 0;
5104 (*row)->numintcols = -1;
5105 (*row)->validactivitylp = -1;
5106 (*row)->validpsactivitydomchg = -1;
5107 (*row)->validactivitybdsdomchg = -1;
5108 (*row)->nlpsaftercreation = 0L;
5109 (*row)->activeinlpcounter = 0L;
5112 (*row)->obsoletenode = -1;
5114 (*row)->lpcolssorted =
TRUE;
5115 (*row)->nonlpcolssorted = (len <= 1);
5116 (*row)->delaysort =
FALSE;
5117 (*row)->validminmaxidx =
FALSE;
5118 (*row)->lhschanged =
FALSE;
5119 (*row)->rhschanged =
FALSE;
5120 (*row)->coefchanged =
FALSE;
5121 (*row)->local = local;
5122 (*row)->modifiable = modifiable;
5124 (*row)->origintype = origintype;
5125 (*row)->removable = removable;
5126 (*row)->inglobalcutpool =
FALSE;
5127 (*row)->storedsolvals = NULL;
5149 assert(blkmem != NULL);
5150 assert(row != NULL);
5151 assert(*row != NULL);
5152 assert((*row)->nuses == 0);
5153 assert((*row)->lppos == -1);
5154 assert((*row)->eventfilter != NULL);
5182 assert(row != NULL);
5185 if( row->
name != NULL && row->
name[0] !=
'\0' )
5196 for( i = 0; i < row->
len; ++i )
5198 assert(row->
cols[i] != NULL);
5199 assert(row->
cols[i]->
var != NULL);
5218 assert(row != NULL);
5219 assert(row->
nuses >= 0);
5220 assert(row->
nlocks <= (
unsigned int)(row->
nuses));
5234 assert(blkmem != NULL);
5235 assert(row != NULL);
5236 assert(*row != NULL);
5237 assert((*row)->nuses >= 1);
5238 assert((*row)->nlocks < (
unsigned int)((*row)->nuses));
5240 SCIPsetDebugMsg(
set,
"release row <%s> with nuses=%d and nlocks=%u\n", (*row)->name, (*row)->nuses, (*row)->nlocks);
5242 if( (*row)->nuses == 0 )
5257 assert(row != NULL);
5272 assert(row != NULL);
5316 assert(row != NULL);
5320 assert(col != NULL);
5321 assert(col->
var != NULL);
5330 assert(0 <= pos && pos < row->len);
5331 assert(row->
cols[pos] == col);
5363 assert(row != NULL);
5367 assert(col != NULL);
5381 assert(0 <= pos && pos < row->len);
5382 assert(row->
cols[pos] == col);
5415 assert(row != NULL);
5418 assert(col != NULL);
5435 assert(0 <= pos && pos < row->len);
5436 assert(row->
cols[pos] == col);
5470 assert(row != NULL);
5471 assert(row->
lhs <= row->
rhs);
5473 assert(stat != NULL);
5525 assert(row != NULL);
5526 assert(row->
lhs <= row->
rhs);
5528 assert(stat != NULL);
5550 assert(row != NULL);
5582 assert(row != NULL);
5610 assert(row != NULL);
5653 assert(row != NULL);
5654 assert(row->
len == 0 || row->
cols != NULL);
5656 assert(row->
len == 0 || row->
vals != NULL);
5657 assert(maxdnom >= 1);
5658 assert(mindelta < 0.0);
5659 assert(maxdelta > 0.0);
5660 assert(success != NULL);
5665 if( intscalar != NULL )
5671 for( c = 0; c < row->
len; ++c )
5675 assert(col != NULL);
5676 assert(col->
var != NULL);
5683 if( val < mindelta || val > maxdelta )
5686 minval = MIN(minval, absval);
5692 if( intscalar != NULL )
5695 SCIPsetDebugMsg(
set,
" -> all values are zero (inside tolerances)\n");
5699 assert(minval > MIN(-mindelta, maxdelta));
5706 scaleval = 1.0/minval;
5707 scalable = (scaleval <= maxscale);
5708 for( c = 0; c < row->
len && scalable; ++c )
5717 while( scaleval <= maxscale
5718 && (absval * scaleval < 0.5 || !
isIntegralScalar(val, scaleval, mindelta, maxdelta, NULL)) )
5722 if(
isIntegralScalar(val, scaleval * scalars[s], mindelta, maxdelta, NULL) )
5724 scaleval *= scalars[s];
5731 scalable = (scaleval <= maxscale);
5732 SCIPsetDebugMsg(
set,
" -> val=%g, scaleval=%g, val*scaleval=%g, scalable=%u\n", val, scaleval, val*scaleval, scalable);
5739 assert(scaleval <= maxscale);
5740 if( intscalar != NULL )
5741 *intscalar = scaleval;
5743 SCIPsetDebugMsg(
set,
" -> integrality can be achieved by scaling with %g (minval=%g)\n", scaleval, minval);
5750 twomult = (twomultval <= maxscale);
5751 for( c = 0; c < row->
len && twomult; ++c )
5760 while( twomultval <= maxscale
5761 && (absval * twomultval < 0.5 || !
isIntegralScalar(val, twomultval, mindelta, maxdelta, NULL)) )
5765 if(
isIntegralScalar(val, twomultval * scalars[s], mindelta, maxdelta, NULL) )
5767 twomultval *= scalars[s];
5774 twomult = (twomultval <= maxscale);
5775 SCIPsetDebugMsg(
set,
" -> val=%g, twomult=%g, val*twomult=%g, twomultable=%u\n",
5776 val, twomultval, val*twomultval, twomult);
5781 assert(twomultval <= maxscale);
5782 if( intscalar != NULL )
5783 *intscalar = twomultval;
5785 SCIPsetDebugMsg(
set,
" -> integrality can be achieved by scaling with %g (power of 2)\n", twomultval);
5795 rational = (maxdnom > 1);
5798 for( c = 0; c < row->
len && rational; ++c )
5803 rational =
SCIPrealToRational(val, mindelta, maxdelta, maxdnom, &nominator, &denominator);
5804 if( rational && nominator != 0 )
5806 assert(denominator > 0);
5807 gcd = ABS(nominator);
5810 SCIPsetDebugMsg(
set,
" -> first rational: val: %g == %" SCIP_LONGINT_FORMAT
"/%" SCIP_LONGINT_FORMAT
", gcd=%" SCIP_LONGINT_FORMAT
", scm=%" SCIP_LONGINT_FORMAT
", rational=%u\n",
5811 val, nominator, denominator, gcd, scm, rational);
5818 for( ++c; c < row->
len && rational; ++c )
5823 rational =
SCIPrealToRational(val, mindelta, maxdelta, maxdnom, &nominator, &denominator);
5824 if( rational && nominator != 0 )
5826 assert(denominator > 0);
5830 SCIPsetDebugMsg(
set,
" -> next rational : val: %g == %" SCIP_LONGINT_FORMAT
"/%" SCIP_LONGINT_FORMAT
", gcd=%" SCIP_LONGINT_FORMAT
", scm=%" SCIP_LONGINT_FORMAT
", rational=%u\n",
5831 val, nominator, denominator, gcd, scm, rational);
5840 if( intscalar != NULL )
5843 SCIPsetDebugMsg(
set,
" -> integrality can be achieved by scaling with %g (rational:%" SCIP_LONGINT_FORMAT
"/%" SCIP_LONGINT_FORMAT
")\n",
5848 assert(!(*success));
5849 SCIPsetDebugMsg(
set,
" -> rationalizing failed: gcd=%" SCIP_LONGINT_FORMAT
", scm=%" SCIP_LONGINT_FORMAT
", lastval=%g\n", gcd, scm, val);
5873 assert(success != NULL);
5877 &intscalar, success) );
5882 SCIP_CALL(
rowScale(row, blkmem,
set, eventqueue, stat, lp, intscalar, usecontvars, mindelta, maxdelta) );
5895 assert(row != NULL);
5903 #ifdef SCIP_MORE_DEBUG 5909 for( c = 1; c < row->
nlpcols; ++c )
5911 for( c = row->
nlpcols + 1; c < row->len; ++c )
5929 assert(row != NULL);
5954 assert(cols != NULL);
5955 assert(cols_index != NULL);
5956 assert(vals != NULL);
5961 assert(row->
linkpos[0] == -1);
5963 for( s = 1; s < row->
len; ++s )
5966 assert(row->
linkpos[s] == -1);
5968 if( cols[s] == cols[t] )
5985 cols_index[t] = cols_index[s];
5994 assert(s == row->
len);
5995 assert(t <= row->len);
6011 for( i = 0; i < row->
len; ++i )
6013 assert(row->
cols[i] != NULL);
6015 for( j = i+1; j < row->
len; ++j )
6016 assert(row->
cols[i] != row->
cols[j]);
6027 assert(row != NULL);
6039 assert(row != NULL);
6055 assert(row != NULL);
6056 assert(stat != NULL);
6059 for( c = 0; c < row->
nlpcols; ++c )
6062 assert(col != NULL);
6064 assert(col->
lppos >= 0);
6071 for( c = row->
nlpcols; c < row->len; ++c )
6074 assert(col != NULL);
6077 if( col->
lppos >= 0 )
6084 for( c = row->
nlpcols; c < row->len; ++c )
6087 assert(col != NULL);
6089 assert(col->
lppos == -1);
6109 assert(row != NULL);
6110 assert(stat != NULL);
6122 activity =
MAX(activity, -inf);
6123 activity = MIN(activity, +inf);
6138 assert(row != NULL);
6142 return MIN(row->
rhs - activity, activity - row->
lhs);
6160 assert( row != NULL );
6161 assert( stat != NULL );
6164 for (c = 0; c < row->
nlpcols; ++c)
6167 assert( col != NULL );
6168 assert( col->
lppos >= 0 );
6169 assert( col->
var != NULL );
6170 assert( row->
linkpos[c] >= 0 );
6176 for (c = row->
nlpcols; c < row->len; ++c)
6179 assert( col != NULL );
6181 if ( col->
lppos >= 0 )
6183 assert( col->
var != NULL );
6191 for (c = row->
nlpcols; c < row->len; ++c)
6194 assert( col != NULL );
6195 assert( col->
lppos == -1 );
6196 assert( row->
linkpos[c] >= 0 );
6201 activity =
MAX(activity, -inf);
6202 activity = MIN(activity, +inf);
6204 return MIN(row->
rhs - activity, activity - row->
lhs);
6222 assert( row != NULL );
6223 assert( stat != NULL );
6226 for (c = 0; c < row->
nlpcols; ++c)
6229 assert( col != NULL );
6230 assert( col->
lppos >= 0 );
6231 assert( col->
var != NULL );
6232 assert( row->
linkpos[c] >= 0 );
6238 for (c = row->
nlpcols; c < row->len; ++c)
6241 assert( col != NULL );
6243 if ( col->
lppos >= 0 )
6245 assert( col->
var != NULL );
6253 for (c = row->
nlpcols; c < row->len; ++c)
6256 assert( col != NULL );
6257 assert( col->
lppos == -1 );
6258 assert( row->
linkpos[c] >= 0 );
6263 activity =
MAX(activity, -inf);
6264 activity = MIN(activity, +inf);
6266 return MIN(row->
rhs - activity, activity - row->
lhs);
6278 assert(row != NULL);
6279 assert(stat != NULL);
6282 for( i = 0; i < row->
len; ++i )
6285 assert(col != NULL);
6286 assert((i < row->nlpcols) == (row->
linkpos[i] >= 0 && col->
lppos >= 0));
6287 assert(col->
var != NULL);
6306 assert(row != NULL);
6307 assert(stat != NULL);
6318 activity =
MAX(activity, -inf);
6319 activity = MIN(activity, +inf);
6333 assert(row != NULL);
6337 return MIN(row->
rhs - pseudoactivity, pseudoactivity - row->
lhs);
6354 assert(row != NULL);
6357 for( i = 0; i < row->
len; ++i )
6360 assert(col != NULL);
6361 assert((i < row->nlpcols) == (row->
linkpos[i] >= 0 && col->
lppos >= 0));
6366 solval = (row->
vals[i] >= 0.0 ? col->
lb : col->
ub);
6368 solval = (row->
vals[i] >= 0.0 ? col->
ub : col->
lb);
6370 solval = (col->
lb + col->
ub)/2.0;
6372 activity += row->
vals[i] * solval;
6376 activity =
MAX(activity, -inf);
6377 activity = MIN(activity, +inf);
6392 assert(row != NULL);
6396 return MIN(row->
rhs - activity, activity - row->
lhs);
6413 assert(row != NULL);
6415 assert(stat != NULL);
6418 mininfinite =
FALSE;
6419 maxinfinite =
FALSE;
6422 for( i = 0; i < row->
len && (!mininfinite || !maxinfinite); ++i )
6425 assert(col != NULL);
6426 assert((i < row->nlpcols) == (row->
linkpos[i] >= 0 && col->
lppos >= 0));
6467 assert(row != NULL);
6468 assert(stat != NULL);
6488 assert(row != NULL);
6489 assert(stat != NULL);
6509 assert(row != NULL);
6539 assert(row != NULL);
6544 assert(row->
maxval >= 0.0 || row->
len == 0);
6555 assert(row != NULL);
6560 assert(row->
minval >= 0.0 || row->
len == 0);
6571 assert(row != NULL);
6575 assert(row->
maxidx >= 0 || row->
len == 0);
6587 assert(row != NULL);
6591 assert(row->
minidx >= 0 || row->
len == 0);
6603 assert(row != NULL);
6625 assert(
set != NULL);
6627 switch( set->sepa_efficacynorm )
6639 norm = (row->
len == 0 ? 0.0 : 1.0);
6642 SCIPerrorMessage(
"invalid efficacy norm parameter '%c'\n", set->sepa_efficacynorm);
6648 norm =
MAX(norm, eps);
6651 return -feasibility / norm;
6682 assert(
set != NULL);
6684 switch( set->sepa_efficacynorm )
6696 norm = (row->
len == 0 ? 0.0 : 1.0);
6699 SCIPerrorMessage(
"invalid efficacy norm parameter '%c'\n", set->sepa_efficacynorm);
6705 norm =
MAX(norm, eps);
6708 return -feasibility / norm;
6740 assert(
set != NULL);
6742 switch( set->sepa_efficacynorm )
6754 norm = (row->
len == 0 ? 0.0 : 1.0);
6757 SCIPerrorMessage(
"invalid efficacy norm parameter '%c'\n", set->sepa_efficacynorm);
6763 norm =
MAX(norm, eps);
6766 return -feasibility / norm;
6780 assert(
set != NULL);
6782 switch( set->sepa_efficacynorm )
6794 norm = (row->
len == 0 ? 0.0 : 1.0);
6797 SCIPerrorMessage(
"invalid efficacy norm parameter '%c'\n", set->sepa_efficacynorm);
6803 norm =
MAX(norm, eps);
6806 return -feasibility / norm;
6825 assert(row1 != NULL);
6826 assert(row2 != NULL);
6880 while( i1 < row1->nlpcols && i2 < row2->len )
6882 assert(row1->
cols[i1] != row2->
cols[i2]);
6891 assert(i1 == row1->
nlpcols || i2 == row2->
len);
6895 while( i1 < row1->len && i2 < row2->nlpcols )
6897 assert(row1->
cols[i1] != row2->
cols[i2]);
6906 assert(i1 == row1->
len || i2 == row2->
nlpcols);
6927 while( i1 >= 0 && i2 >= 0 )
6929 assert(row1->
cols[i1]->
index == row1colsidx[i1]);
6930 assert(row2->
cols[i2]->
index == row2colsidx[i2]);
6931 assert((row1->
cols[i1] == row2->
cols[i2]) == (row1colsidx[i1] == row2colsidx[i2]));
6932 if( row1colsidx[i1] < row2colsidx[i2] )
6934 else if( row1colsidx[i1] > row2colsidx[i2] )
6938 scalarprod += row1->
vals[i1] * row2->
vals[i2];
6966 while( ilp1 < row1->nlpcols && inlp1 < row1->len && ilp2 < row2->nlpcols && inlp2 < row2->len )
6968 assert(row1->
cols[ilp1]->
index == row1colsidx[ilp1]);
6969 assert(row1->
cols[inlp1]->
index == row1colsidx[inlp1]);
6970 assert(row2->
cols[ilp2]->
index == row2colsidx[ilp2]);
6971 assert(row2->
cols[inlp2]->
index == row2colsidx[inlp2]);
6972 assert((row1->
cols[ilp1] == row2->
cols[ilp2]) == (row1colsidx[ilp1] == row2colsidx[ilp2]));
6973 assert((row1->
cols[ilp1] == row2->
cols[inlp2]) == (row1colsidx[ilp1] == row2colsidx[inlp2]));
6974 assert((row1->
cols[inlp1] == row2->
cols[ilp2]) == (row1colsidx[inlp1] == row2colsidx[ilp2]));
6975 assert((row1->
cols[inlp1] == row2->
cols[inlp2]) == (row1colsidx[inlp1] == row2colsidx[inlp2]));
6978 if( row1colsidx[ilp1] == row2colsidx[ilp2] )
6980 scalarprod += row1->
vals[ilp1] * row2->
vals[ilp2];
6985 else if( row1colsidx[ilp1] == row2colsidx[inlp2] )
6987 scalarprod += row1->
vals[ilp1] * row2->
vals[inlp2];
6992 else if( row1colsidx[inlp1] == row2colsidx[ilp2] )
6994 scalarprod += row1->
vals[inlp1] * row2->
vals[ilp2];
6999 else if( row1colsidx[inlp1] == row2colsidx[inlp2] && row1->
cols[inlp1]->
lppos >= 0 )
7001 scalarprod += row1->
vals[inlp1] * row2->
vals[inlp2];
7006 else if( row1colsidx[ilp1] < row1colsidx[inlp1] )
7008 if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7010 if( row1colsidx[ilp1] < row2colsidx[ilp2] )
7017 if( row1colsidx[ilp1] < row2colsidx[inlp2] )
7025 if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7027 if( row1colsidx[inlp1] < row2colsidx[ilp2] )
7034 if( row1colsidx[inlp1] < row2colsidx[inlp2] )
7046 if( ilp1 != row1->
nlpcols && inlp1 != row1->
len )
7051 assert(ilp2 == row2->
nlpcols || inlp2 == row2->
len);
7074 assert(inlp1 == row1->
len);
7084 while( i1 < end1 && ilp2 < row2->nlpcols && inlp2 < row2->len )
7086 assert(row1->
cols[i1]->
index == row1colsidx[i1]);
7087 assert(row2->
cols[ilp2]->
index == row2colsidx[ilp2]);
7088 assert(row2->
cols[inlp2]->
index == row2colsidx[inlp2]);
7089 assert((row1->
cols[i1] == row2->
cols[ilp2]) == (row1colsidx[i1] == row2colsidx[ilp2]));
7090 assert((row1->
cols[i1] == row2->
cols[inlp2]) == (row1colsidx[i1] == row2colsidx[inlp2]));
7093 if( row1colsidx[i1] == row2colsidx[ilp2] )
7095 scalarprod += row1->
vals[i1] * row2->
vals[ilp2];
7100 else if( row1colsidx[i1] == row2colsidx[inlp2] && (lpcols || row1->
cols[i1]->
lppos >= 0) )
7102 scalarprod += row1->
vals[i1] * row2->
vals[inlp2];
7107 else if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7109 if( row1colsidx[i1] < row2colsidx[ilp2] )
7116 if( row1colsidx[i1] < row2colsidx[inlp2] )
7137 assert(inlp2 == row2->
len);
7144 while( i1 < end1 && i2 < end2 )
7146 assert(row1->
cols[i1]->
index == row1colsidx[i1]);
7147 assert(row2->
cols[i2]->
index == row2colsidx[i2]);
7148 assert((row1->
cols[i1] == row2->
cols[i2]) == (row1colsidx[i1] == row2colsidx[i2]));
7151 if( row1colsidx[i1] == row2colsidx[i2] && (lpcols || row1->
cols[i1]->
lppos >= 0) )
7153 scalarprod += row1->
vals[i1] * row2->
vals[i2];
7158 else if( row1colsidx[i1] < row2colsidx[i2] )
7182 assert(row1 != NULL);
7183 assert(row2 != NULL);
7237 while( i1 < row1->nlpcols && i2 < row2->len )
7239 assert(row1->
cols[i1] != row2->
cols[i2]);
7248 assert(i1 == row1->
nlpcols || i2 == row2->
len);
7252 while( i1 < row1->len && i2 < row2->nlpcols )
7254 assert(row1->
cols[i1] != row2->
cols[i2]);
7263 assert(i1 == row1->
len || i2 == row2->
nlpcols);
7284 while( i1 >= 0 && i2 >= 0 )
7286 assert(row1->
cols[i1]->
index == row1colsidx[i1]);
7287 assert(row2->
cols[i2]->
index == row2colsidx[i2]);
7288 assert((row1->
cols[i1] == row2->
cols[i2]) == (row1colsidx[i1] == row2colsidx[i2]));
7289 if( row1colsidx[i1] < row2colsidx[i2] )
7291 else if( row1colsidx[i1] > row2colsidx[i2] )
7323 while( ilp1 < row1->nlpcols && inlp1 < row1->len && ilp2 < row2->nlpcols && inlp2 < row2->len )
7325 assert(row1->
cols[ilp1]->
index == row1colsidx[ilp1]);
7326 assert(row1->
cols[inlp1]->
index == row1colsidx[inlp1]);
7327 assert(row2->
cols[ilp2]->
index == row2colsidx[ilp2]);
7328 assert(row2->
cols[inlp2]->
index == row2colsidx[inlp2]);
7329 assert((row1->
cols[ilp1] == row2->
cols[ilp2]) == (row1colsidx[ilp1] == row2colsidx[ilp2]));
7330 assert((row1->
cols[ilp1] == row2->
cols[inlp2]) == (row1colsidx[ilp1] == row2colsidx[inlp2]));
7331 assert((row1->
cols[inlp1] == row2->
cols[ilp2]) == (row1colsidx[inlp1] == row2colsidx[ilp2]));
7332 assert((row1->
cols[inlp1] == row2->
cols[inlp2]) == (row1colsidx[inlp1] == row2colsidx[inlp2]));
7335 if( row1colsidx[ilp1] == row2colsidx[ilp2] )
7342 else if( row1colsidx[ilp1] == row2colsidx[inlp2] )
7349 else if( row1colsidx[inlp1] == row2colsidx[ilp2] )
7356 else if( row1colsidx[inlp1] == row2colsidx[inlp2] && row1->
cols[inlp1]->
lppos >= 0 )
7363 else if( row1colsidx[ilp1] < row1colsidx[inlp1] )
7365 if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7367 if( row1colsidx[ilp1] < row2colsidx[ilp2] )
7374 if( row1colsidx[ilp1] < row2colsidx[inlp2] )
7382 if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7384 if( row1colsidx[inlp1] < row2colsidx[ilp2] )
7391 if( row1colsidx[inlp1] < row2colsidx[inlp2] )
7403 if( ilp1 != row1->
nlpcols && inlp1 != row1->
len )
7408 assert(ilp2 == row2->
nlpcols || inlp2 == row2->
len);
7431 assert(inlp1 == row1->
len);
7441 while( i1 < end1 && ilp2 < row2->nlpcols && inlp2 < row2->len )
7443 assert(row1->
cols[i1]->
index == row1colsidx[i1]);
7444 assert(row2->
cols[ilp2]->
index == row2colsidx[ilp2]);
7445 assert(row2->
cols[inlp2]->
index == row2colsidx[inlp2]);
7446 assert((row1->
cols[i1] == row2->
cols[ilp2]) == (row1colsidx[i1] == row2colsidx[ilp2]));
7447 assert((row1->
cols[i1] == row2->
cols[inlp2]) == (row1colsidx[i1] == row2colsidx[inlp2]));
7450 if( row1colsidx[i1] == row2colsidx[ilp2] )
7457 else if( row1colsidx[i1] == row2colsidx[inlp2] && (lpcols || row1->
cols[i1]->
lppos >= 0) )
7464 else if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7466 if( row1colsidx[i1] < row2colsidx[ilp2] )
7473 if( row1colsidx[i1] < row2colsidx[inlp2] )
7494 assert(inlp2 == row2->
len);
7501 while( i1 < end1 && i2 < end2 )
7503 assert(row1->
cols[i1]->
index == row1colsidx[i1]);
7504 assert(row2->
cols[i2]->
index == row2colsidx[i2]);
7505 assert((row1->
cols[i1] == row2->
cols[i2]) == (row1colsidx[i1] == row2colsidx[i2]));
7508 if( row1colsidx[i1] == row2colsidx[i2] && (lpcols || row1->
cols[i1]->
lppos >= 0) )
7515 else if( row1colsidx[i1] < row2colsidx[i2] )
7543 if( scalarprod == 0.0 )
7557 for( i = 0; i < row1->
len; ++i )
7567 for( i = 0; i < row2->
len; ++i )
7582 SCIPerrorMessage(
"invalid orthogonality function parameter '%c'\n", orthofunc);
7615 assert(row != NULL);
7632 parallelism = MIN(parallelism, 1.0);
7633 parallelism =
MAX(parallelism, 0.0);
7649 assert(row != NULL);
7655 eventtype, row->
name, (
void*)eventhdlr, (
void*)eventdata);
7673 assert(row != NULL);
7676 SCIPsetDebugMsg(
set,
"drop event of row <%s> with handler %p and data %p\n", row->
name, (
void*)eventhdlr, (
void*)eventdata);
7689 assert(row != NULL);
7690 assert(stat != NULL);
7691 assert(stat->
nnodes > 0);
7707 assert(col != NULL);
7786 assert(
set != NULL);
7787 assert(col != NULL);
7837 assert(blkmem != NULL);
7838 assert(
set != NULL);
7855 for( c = lp->
nlpicols; c < lp->ncols; ++c )
7856 naddcoefs += lp->
cols[c]->
len;
7857 assert(naddcols > 0);
7870 for( pos = 0, c = lp->
nlpicols; c < lp->ncols; ++pos, ++c )
7873 assert(col != NULL);
7874 assert(col->
var != NULL);
7877 assert(col->
lppos == c);
7878 assert(nnonz + col->
nlprows <= naddcoefs);
7905 obj[pos] = col->
obj;
7917 for( i = 0; i < col->
nlprows; ++i )
7919 assert(col->
rows[i] != NULL);
7923 assert(lpipos < lp->nrows);
7924 assert(nnonz < naddcoefs);
7925 ind[nnonz] = lpipos;
7926 val[nnonz] = col->
vals[i];
7931 for( i = col->
nlprows; i < col->len; ++i )
7933 assert(col->
rows[i] != NULL);
7973 assert(row != NULL);
8059 assert(blkmem != NULL);
8075 for( r = lp->
nlpirows; r < lp->nrows; ++r )
8076 naddcoefs += lp->
rows[r]->
len;
8077 assert(naddrows > 0);
8089 for( pos = 0, r = lp->
nlpirows; r < lp->nrows; ++pos, ++r )
8092 assert(row != NULL);
8093 assert(row->
lppos == r);
8094 assert(nnonz + row->
nlpcols <= naddcoefs);
8124 name[pos] = row->
name;
8129 SCIPsetDebugMsg(
set,
"flushing added row (SCIP_LPI): %+g <=", lhs[pos]);
8130 for( i = 0; i < row->
nlpcols; ++i )
8132 assert(row->
cols[i] != NULL);
8136 assert(lpipos < lp->ncols);
8137 assert(nnonz < naddcoefs);
8139 ind[nnonz] = lpipos;
8140 val[nnonz] = row->
vals[i];
8146 for( i = row->
nlpcols; i < row->len; ++i )
8148 assert(row->
cols[i] != NULL);
8219 for( i = 0; i < lp->
nchgcols; ++i )
8222 assert(col != NULL);
8223 assert(col->
var != NULL);
8254 assert(nobjchg < lp->ncols);
8255 objind[nobjchg] = col->
lpipos;
8256 obj[nobjchg] = newobj;
8273 assert(nbdchg < lp->ncols);
8274 bdind[nbdchg] = col->
lpipos;
8291 SCIPsetDebugMsg(
set,
"flushing objective changes: change %d objective values of %d changed columns\n", nobjchg, lp->
nchgcols);
8305 SCIPsetDebugMsg(
set,
"flushing bound changes: change %d bounds of %d changed columns\n", nbdchg, lp->
nchgcols);
8361 for( i = 0; i < lp->
nchgrows; ++i )
8364 assert(row != NULL);
8389 assert(nchg < lp->nrows);
8446 for( i = 0; i < lp->
ncols; ++i )
8485 assert(blkmem != NULL);
8487 SCIPsetDebugMsg(
set,
"flushing LP changes: old (%d cols, %d rows), nchgcols=%d, nchgrows=%d, firstchgcol=%d, firstchgrow=%d, new (%d cols, %d rows), flushed=%u\n",
8526 assert(ncols == lp->
ncols);
8527 assert(nrows == lp->
nrows);
8578 for( i = 0; i < lp->
nchgcols; ++i )
8583 assert(col != NULL);
8584 assert(col->
var != NULL);
8617 for( i = 0; i < lp->
nchgrows; ++i )
8622 assert(row != NULL);
8672 assert(col != NULL);
8673 assert(col->
lppos >= 0);
8676 for( i = 0; i < col->
len; ++i )
8682 assert(row != NULL);
8683 assert(row->
linkpos[pos] == i);
8684 assert(row->
cols[pos] == col);
8685 assert(row->
nlpcols <= pos && pos < row->len);
8711 assert(row != NULL);
8712 assert(row->
lppos >= 0);
8715 for( i = 0; i < row->
len; ++i )
8721 assert(col != NULL);
8722 assert(col->
linkpos[pos] == i);
8723 assert(col->
rows[pos] == row);
8724 assert(col->
nlprows <= pos && pos < col->len);
8747 assert(col != NULL);
8748 assert(col->
lppos == -1);
8751 for( i = 0; i < col->
len; ++i )
8757 assert(row != NULL);
8758 assert(row->
linkpos[pos] == i);
8759 assert(row->
cols[pos] == col);
8760 assert(0 <= pos && pos < row->nlpcols);
8785 assert(row != NULL);
8786 assert(row->
lppos == -1);
8789 for( i = 0; i < row->
len; ++i )
8795 assert(col != NULL);
8796 assert(0 <= pos && pos < col->nlprows);
8797 assert(col->
linkpos[pos] == i);
8798 assert(col->
rows[pos] == row);
8822 assert(initsize > 0);
8845 assert(minsize > 0);
8847 if( minsize <= lp->divechgsidessize )
8876 #define DIVESTACKINITSIZE 100 8890 assert(
set != NULL);
8891 assert(stat != NULL);
8892 assert(name != NULL);
8899 (*lp)->lpicols = NULL;
8900 (*lp)->lpirows = NULL;
8901 (*lp)->chgcols = NULL;
8902 (*lp)->chgrows = NULL;
8904 (*lp)->lazycols = NULL;
8907 (*lp)->lpobjval = 0.0;
8908 (*lp)->glbpseudoobjval = 0.0;
8909 (*lp)->relglbpseudoobjval = 0.0;
8910 (*lp)->glbpseudoobjvalid =
TRUE;
8911 (*lp)->glbpseudoobjvalinf = 0;
8912 (*lp)->pseudoobjval = 0.0;
8913 (*lp)->relpseudoobjval = 0.0;
8914 (*lp)->pseudoobjvalid =
TRUE;
8915 (*lp)->pseudoobjvalinf = 0;
8916 (*lp)->looseobjval = 0.0;
8917 (*lp)->rellooseobjval = 0.0;
8918 (*lp)->looseobjvalid =
TRUE;
8919 (*lp)->looseobjvalinf = 0;
8920 (*lp)->nloosevars = 0;
8924 (*lp)->objsqrnorm = 0.0;
8925 (*lp)->objsumnorm = 0.0;
8926 (*lp)->lpicolssize = 0;
8927 (*lp)->nlpicols = 0;
8928 (*lp)->lpirowssize = 0;
8929 (*lp)->nlpirows = 0;
8930 (*lp)->lpifirstchgcol = 0;
8931 (*lp)->lpifirstchgrow = 0;
8932 (*lp)->colssize = 0;
8934 (*lp)->lazycolssize = 0;
8935 (*lp)->nlazycols = 0;
8936 (*lp)->rowssize = 0;
8938 (*lp)->chgcolssize = 0;
8939 (*lp)->nchgcols = 0;
8940 (*lp)->chgrowssize = 0;
8941 (*lp)->nchgrows = 0;
8942 (*lp)->firstnewcol = 0;
8943 (*lp)->firstnewrow = 0;
8944 (*lp)->nremovablecols = 0;
8945 (*lp)->nremovablerows = 0;
8946 (*lp)->validsollp = stat->
lpcount;
8947 (*lp)->validfarkaslp = -1;
8948 (*lp)->objsqrnormunreliable =
FALSE;
8949 (*lp)->flushdeletedcols =
FALSE;
8950 (*lp)->flushaddedcols =
FALSE;
8951 (*lp)->flushdeletedrows =
FALSE;
8952 (*lp)->flushaddedrows =
FALSE;
8953 (*lp)->updateintegrality =
TRUE;
8954 (*lp)->flushed =
TRUE;
8955 (*lp)->solved =
TRUE;
8956 (*lp)->primalfeasible =
TRUE;
8957 (*lp)->primalchecked =
TRUE;
8958 (*lp)->dualfeasible =
TRUE;
8959 (*lp)->dualchecked =
TRUE;
8960 (*lp)->solisbasic =
FALSE;
8961 (*lp)->rootlpisrelax =
TRUE;
8962 (*lp)->isrelax =
TRUE;
8963 (*lp)->installing =
FALSE;
8964 (*lp)->strongbranching =
FALSE;
8965 (*lp)->strongbranchprobing =
FALSE;
8966 (*lp)->probing =
FALSE;
8967 (*lp)->diving =
FALSE;
8968 (*lp)->divingobjchg =
FALSE;
8969 (*lp)->divinglazyapplied =
FALSE;
8970 (*lp)->divelpistate = NULL;
8971 (*lp)->divelpwasprimfeas =
TRUE;
8972 (*lp)->divelpwasprimchecked =
TRUE;
8973 (*lp)->divelpwasdualfeas =
TRUE;
8974 (*lp)->divelpwasdualchecked =
TRUE;
8975 (*lp)->divechgsides = NULL;
8976 (*lp)->divechgsidetypes = NULL;
8977 (*lp)->divechgrows = NULL;
8978 (*lp)->ndivechgsides = 0;
8979 (*lp)->divechgsidessize = 0;
8980 (*lp)->ndivingrows = 0;
8981 (*lp)->divinglpiitlim = INT_MAX;
8982 (*lp)->resolvelperror =
FALSE;
8983 (*lp)->divenolddomchgs = 0;
8984 (*lp)->adjustlpval =
FALSE;
8989 (*lp)->lpifromscratch =
FALSE;
8990 (*lp)->lpifastmip =
set->lp_fastmip;
8991 (*lp)->lpiscaling =
set->lp_scaling;
8992 (*lp)->lpipresolving =
set->lp_presolving;
8993 (*lp)->lpilpinfo =
set->disp_lpinfo;
8994 (*lp)->lpirowrepswitch =
set->lp_rowrepswitch;
8995 (*lp)->lpisolutionpolishing = (
set->lp_solutionpolishing > 0);
8996 (*lp)->lpirefactorinterval =
set->lp_refactorinterval;
8997 (*lp)->lpiconditionlimit =
set->lp_conditionlimit;
8998 (*lp)->lpiitlim = INT_MAX;
9001 (*lp)->lpithreads =
set->lp_threads;
9002 (*lp)->lpitiming = (int) set->time_clocktype;
9003 (*lp)->lpirandomseed = set->random_randomseed;
9004 (*lp)->storedsolvals = NULL;
9014 "LP Solver <%s>: objective limit cannot be set -- can lead to unnecessary simplex iterations\n",
9018 (*lp)->lpihasfeastol = success;
9022 "LP Solver <%s>: primal feasibility tolerance cannot be set -- tolerance of SCIP and LP solver may differ\n",
9026 (*lp)->lpihasdualfeastol = success;
9030 "LP Solver <%s>: dual feasibility tolerance cannot be set -- tolerance of SCIP and LP solver may differ\n",
9034 (*lp)->lpihasbarrierconvtol = success;
9038 "LP Solver <%s>: barrier convergence tolerance cannot be set -- tolerance of SCIP and LP solver may differ\n",
9043 (*lp)->lpihasfastmip = success;
9047 "LP Solver <%s>: fastmip setting not available -- SCIP parameter has no effect\n",
9051 (*lp)->lpihasscaling = success;
9055 "LP Solver <%s>: scaling not available -- SCIP parameter has no effect\n",
9059 (*lp)->lpihaspresolving = success;
9063 "LP Solver <%s>: presolving not available -- SCIP parameter has no effect\n",
9070 "LP Solver <%s>: clock type cannot be set\n",
9077 "LP Solver <%s>: iteration limit cannot be set -- can lead to unnecessary simplex iterations\n",
9084 "LP Solver <%s>: pricing strategy cannot be set -- SCIP parameter has no effect\n",
9091 "LP Solver <%s>: lpinfo setting not available -- SCIP parameter has no effect\n",
9095 (*lp)->lpihasrowrep = success;
9099 "LP Solver <%s>: row representation of the basis not available -- SCIP parameter lp/rowrepswitch has no effect\n",
9103 (*lp)->lpihaspolishing = success;
9107 "LP Solver <%s>: solution polishing not available -- SCIP parameter lp/solutionpolishing has no effect\n",
9111 (*lp)->lpihasrefactor = success;
9115 "LP Solver <%s>: refactorization interval not available -- SCIP parameter lp/refactorinterval has no effect\n",
9122 "LP Solver <%s>: condition number limit for the basis not available -- SCIP parameter lp/conditionlimit has no effect\n",
9129 "LP Solver <%s>: number of threads settings not available -- SCIP parameter has no effect\n",
9133 if( (*lp)->lpirandomseed != 0 )
9139 "LP Solver <%s>: random seed parameter not available -- SCIP parameter has no effect\n",
9148 SCIPerrorMessage(
"The infinity value of the LP solver has to be at least as large as the one of SCIP.\n");
9167 assert(*lp != NULL);
9174 for( i = 0; i < (*lp)->nlpirows; ++i )
9179 if( (*lp)->lpi != NULL )
9209 assert(stat != NULL);
9240 assert(col != NULL);
9241 assert(col->
len == 0 || col->
rows != NULL);
9242 assert(col->
lppos == -1);
9243 assert(col->
var != NULL);
9253 for( i = 0; i < col->
len; ++i )
9301 assert(row != NULL);
9302 assert(row->
len == 0 || row->
cols != NULL);
9303 assert(row->
lppos == -1);
9313 for( i = 0; i < row->
len; ++i )
9380 for( c = 0; c < lp->
ncols; ++c )
9393 for( c = 0; c < lp->
ncols; ++c )
9396 assert(lp->
cols[c] != NULL);
9410 #define checkLazyColArray(lp, set) 9426 assert(0 <= newncols);
9427 assert(newncols <= lp->ncols);
9429 if( newncols < lp->ncols )
9433 for( c = lp->
ncols-1; c >= newncols; --c )
9436 assert(col != NULL);
9437 assert(col->
len == 0 || col->
rows != NULL);
9438 assert(col->
var != NULL);
9441 assert(col->
lppos == c);
9458 assert(lp->
ncols == newncols);
9463 while( c < lp->nlazycols )
9499 assert(0 <= newnrows && newnrows <= lp->nrows);
9502 if( newnrows < lp->nrows )
9504 for( r = lp->
nrows-1; r >= newnrows; --r )
9507 assert(row != NULL);
9508 assert(row->
len == 0 || row->
cols != NULL);
9509 assert(row->
lppos == r);
9538 assert(lp->
nrows == newnrows);
9606 assert(basisind != NULL);
9644 assert(0 <= r && r < lp->nrows);
9645 assert(coef != NULL);
9670 assert(0 <= c && c < lp->nrows);
9671 assert(coef != NULL);
9693 assert(0 <= r && r < lp->nrows);
9694 assert(coef != NULL);
9717 assert(0 <= c && c < lp->ncols);
9718 assert(coef != NULL);
9746 assert(prob != NULL);
9747 assert(weights != NULL);
9748 assert(sumcoef != NULL);
9749 assert(sumlhs != NULL);
9750 assert(sumrhs != NULL);
9758 lhsinfinite =
FALSE;
9759 rhsinfinite =
FALSE;
9760 for( r = 0; r < lp->
nrows; ++r )
9765 assert(row != NULL);
9766 assert(row->
len == 0 || row->
cols != NULL);
9768 assert(row->
len == 0 || row->
vals != NULL);
9771 for( i = 0; i < row->
len; ++i )
9773 assert(row->
cols[i] != NULL);
9774 assert(row->
cols[i]->
var != NULL);
9779 assert(0 <= idx && idx < prob->nvars);
9784 if( weights[r] > 0.0 )
9788 (*sumlhs) += weights[r] * (row->
lhs - row->
constant);
9791 (*sumrhs) += weights[r] * (row->
rhs - row->
constant);
9797 (*sumlhs) += weights[r] * (row->
rhs - row->
constant);
9800 (*sumrhs) += weights[r] * (row->
lhs - row->
constant);
9823 assert(blkmem != NULL);
9824 assert(lpistate != NULL);
9851 assert(blkmem != NULL);
9861 if( lpistate == NULL )
9888 if( *lpistate != NULL )
9906 assert(blkmem != NULL);
9907 assert(lpinorms != NULL);
9928 assert(blkmem != NULL);
9932 if( lpinorms != NULL )
10018 return "primal simplex";
10020 return "dual simplex";
10024 return "barrier/crossover";
10047 assert(lp != NULL);
10049 assert(
set != NULL);
10050 assert(stat != NULL);
10051 assert(lperror != NULL);
10053 SCIPsetDebugMsg(
set,
"solving LP %" SCIP_LONGINT_FORMAT
" (%d cols, %d rows) with primal simplex (diving=%d, nprimallps=%" SCIP_LONGINT_FORMAT
", ndivinglps=%" SCIP_LONGINT_FORMAT
")\n",
10064 SCIPsetDebugMsg(
"wrote LP to file <%s> (primal simplex, objlim=%.15g, feastol=%.15g/%.15g, fromscratch=%d, fastmip=%d, scaling=%d, presolving=%d)\n",
10091 SCIPsetDebugMsg(
set,
"(node %" SCIP_LONGINT_FORMAT
") primal simplex solving error in LP %" SCIP_LONGINT_FORMAT
"\n", stat->
nnodes, stat->
nlps);
10117 if( iterations > 0 )
10122 SCIPstatAdd( stat,
set, nlpiterations, iterations );
10127 SCIPstatAdd(stat,
set, nprimalresolvelpiterations, iterations);
10134 SCIPstatAdd(stat,
set, nsbdivinglpiterations, iterations);
10140 SCIPstatAdd(stat,
set, ndivinglpiterations, iterations);
10146 SCIPstatAdd(stat,
set, nprimallpiterations, iterations);
10154 SCIPstatAdd(stat,
set, primalzeroittime, timedelta);
10157 if ( keepsol && !(*lperror) )
10167 SCIPsetDebugMsg(
set,
"solved LP %" SCIP_LONGINT_FORMAT
" with primal simplex (diving=%d, nprimallps=%" SCIP_LONGINT_FORMAT
", ndivinglps=%" SCIP_LONGINT_FORMAT
")\n",
10188 assert(lp != NULL);
10190 assert(
set != NULL);
10191 assert(stat != NULL);
10192 assert(lperror != NULL);
10194 SCIPsetDebugMsg(
set,
"solving LP %" SCIP_LONGINT_FORMAT
" (%d cols, %d rows) with dual simplex (diving=%d, nduallps=%" SCIP_LONGINT_FORMAT
", ndivinglps=%" SCIP_LONGINT_FORMAT
")\n",
10205 SCIPsetDebugMsg(
"wrote LP to file <%s> (dual simplex, objlim=%.15g, feastol=%.15g/%.15g, fromscratch=%d, fastmip=%d, scaling=%d, presolving=%d)\n",
10232 SCIPsetDebugMsg(
set,
"(node %" SCIP_LONGINT_FORMAT
") dual simplex solving error in LP %" SCIP_LONGINT_FORMAT
"\n", stat->
nnodes, stat->
nlps);
10258 if( iterations > 0 )
10263 SCIPstatAdd(stat,
set, nlpiterations, iterations);
10268 SCIPstatAdd(stat,
set, ndualresolvelpiterations, iterations);
10275 SCIPstatAdd(stat,
set, nsbdivinglpiterations, iterations);
10281 SCIPstatAdd(stat,
set, ndivinglpiterations, iterations);
10287 SCIPstatAdd(stat,
set, nduallpiterations, iterations);
10295 SCIPstatAdd(stat,
set, dualzeroittime, timedelta);
10298 if( keepsol && !(*lperror) )
10308 SCIPsetDebugMsg(
set,
"solved LP %" SCIP_LONGINT_FORMAT
" with dual simplex (diving=%d, nduallps=%" SCIP_LONGINT_FORMAT
", ndivinglps=%" SCIP_LONGINT_FORMAT
")\n",
10360 int totalIterations;
10365 assert(lp != NULL);
10367 assert(
set != NULL);
10368 assert(stat != NULL);
10369 assert(lperror != NULL);
10371 SCIPsetDebugMsg(
set,
"solving LP %" SCIP_LONGINT_FORMAT
" (%d cols, %d rows) with lex dual simplex (diving=%d, nduallps=%" SCIP_LONGINT_FORMAT
", ndivinglps=%" SCIP_LONGINT_FORMAT
")\n",
10397 SCIPsetDebugMsg(
set,
"(node %" SCIP_LONGINT_FORMAT
") dual simplex solving error in LP %" SCIP_LONGINT_FORMAT
"\n", stat->
nnodes, stat->
nlps);
10404 totalIterations = iterations;
10422 if( iterations > 0 )
10426 SCIPstatAdd(stat,
set, nlpiterations, iterations);
10431 SCIPstatAdd(stat,
set, ndualresolvelpiterations, iterations);
10438 SCIPstatAdd(stat,
set, nsbdivinglpiterations, iterations);
10444 SCIPstatAdd(stat,
set, ndivinglpiterations, iterations);
10450 SCIPstatAdd(stat,
set, nduallpiterations, iterations);
10458 SCIPstatAdd(stat,
set, dualzeroittime, timedelta);
10495 chooseBasic =
set->lp_lexdualbasic;
10541 for( c = 0; c < lp->
nlpicols; ++c )
10552 for( r = 0; r < lp->
nlpirows; ++r )
10561 #ifdef DEBUG_LEXDUAL 10567 assert(primsol == NULL);
10570 assert(primsol != NULL);
10574 for( j = 0; j < lp->
nlpicols; ++j )
10610 assert(primsol == NULL);
10630 assert(primsol == NULL);
10641 for( c = 0; c < lp->
nlpicols; ++c )
10649 if( pos == -1 && c > oldpos )
10662 if( pos == -1 && c > oldpos )
10667 newlb[cntcol] = oldlb[c];
10668 newub[cntcol] = oldlb[c];
10669 indcol[cntcol++] = c;
10684 newlb[cntcol] = oldlb[c];
10685 newub[cntcol] = oldlb[c];
10691 newlb[cntcol] = oldub[c];
10692 newub[cntcol] = oldub[c];
10697 newlb[cntcol] = 0.0;
10698 newub[cntcol] = 0.0;
10701 indcol[cntcol++] = c;
10710 for( r = 0; r < lp->
nlpirows; ++r )
10725 newlhs[cntrow] = oldlhs[r];
10726 newrhs[cntrow] = oldlhs[r];
10731 newlhs[cntrow] = oldrhs[r];
10732 newrhs[cntrow] = oldrhs[r];
10734 indrow[cntrow++] = r;
10741 if( nDualDeg > 0 && pos >= 0 )
10743 assert(0 <= pos && pos < lp->nlpicols && pos > oldpos);
10768 SCIPsetDebugMsg(
set,
"(node %" SCIP_LONGINT_FORMAT
") in lex-dual: primal simplex solving error in LP %" SCIP_LONGINT_FORMAT
"\n", stat->
nnodes, stat->
nlps);
10775 lexIterations += iterations;
10777 #ifdef DEBUG_LEXDUAL 10778 if( iterations > 0 )
10784 assert(primsol == NULL);
10787 assert(primsol != NULL);
10790 for( j = 0; j < lp->
nlpicols; ++j )
10827 SCIPsetDebugMsg(
set,
"%f (%d) %c%c%c ", primsol[j], j, cstart, type, cend);
10835 assert(primsol == NULL);
10841 if( iterations > 0 )
10846 while( pos >= 0 && nDualDeg > 0 && (set->lp_lexdualmaxrounds == -1 || rounds < set->lp_lexdualmaxrounds) );
10858 SCIPsetDebugMsg(
set,
"(node %" SCIP_LONGINT_FORMAT
") dual simplex solving error in LP %" SCIP_LONGINT_FORMAT
"\n", stat->
nnodes, stat->
nlps);
10866 lexIterations += iterations;
10874 if( lexIterations > 0 )
10876 SCIPstatAdd(stat,
set, nlpiterations, lexIterations);
10880 SCIPstatAdd(stat,
set, nlexdualresolvelpiterations, lexIterations);
10883 SCIPstatAdd(stat,
set, nlexduallpiterations, lexIterations);
10885 totalIterations += lexIterations;
10922 SCIPsetDebugMsg(
set,
"solved LP %" SCIP_LONGINT_FORMAT
" with lex dual simplex (diving=%d, nduallps=%" SCIP_LONGINT_FORMAT
", ndivinglps=%" SCIP_LONGINT_FORMAT
")\n",
10932 if( keepsol && !(*lperror) )
10960 assert(lp != NULL);
10962 assert(
set != NULL);
10963 assert(stat != NULL);
10964 assert(lperror != NULL);
10966 SCIPsetDebugMsg(
set,
"solving LP %" SCIP_LONGINT_FORMAT
" (%d cols, %d rows) with barrier%s (diving=%d, nbarrierlps=%" SCIP_LONGINT_FORMAT
", ndivinglps=%" SCIP_LONGINT_FORMAT
")\n",
10978 SCIPsetDebugMsg(
"wrote LP to file <%s> (barrier, objlim=%.15g, feastol=%.15g/%.15g, convtol=%.15g, fromscratch=%d, fastmip=%d, scaling=%d, presolving=%d)\n",
11005 SCIPsetDebugMsg(
set,
"(node %" SCIP_LONGINT_FORMAT
") barrier solving error in LP %" SCIP_LONGINT_FORMAT
"\n", stat->
nnodes, stat->
nlps);
11031 if( iterations > 0 )
11036 SCIPstatAdd(stat,
set, nlpiterations, iterations);
11043 SCIPstatAdd(stat,
set, nsbdivinglpiterations, iterations);
11049 SCIPstatAdd(stat,
set, ndivinglpiterations, iterations);
11055 SCIPstatAdd(stat,
set, nbarrierlpiterations, iterations);
11063 SCIPstatAdd(stat,
set, barrierzeroittime, timedelta);
11066 if( keepsol && !(*lperror) )
11076 SCIPsetDebugMsg(
set,
"solved LP %" SCIP_LONGINT_FORMAT
" with barrier%s (diving=%d, nduallps=%" SCIP_LONGINT_FORMAT
", nbarrierlps=%" SCIP_LONGINT_FORMAT
")\n",
11098 assert(lp != NULL);
11100 assert(lperror != NULL);
11104 if( set->istimelimitfinite )
11108 if( lptimelimit > 0.0 )
11111 if( lptimelimit <= 0.0 || !success )
11113 SCIPsetDebugMsg(
set,
"time limit of %f seconds could not be set\n", lptimelimit);
11114 *lperror = ((lptimelimit > 0.0) ?
TRUE :
FALSE);
11129 if( set->lp_lexdualalgo && (!set->lp_lexdualrootonly || stat->
maxdepth == 0) && (!set->lp_lexdualstalling || lp->
installing) )
11166 #define MAXNUMTROUBLELPMSGS 10 11180 const char* formatstr,
11203 if( verblevel > set->disp_verblevel )
11209 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- ",
11213 va_start(ap, formatstr);
11220 SCIPmessagePrintInfo(messagehdlr,
" -- further messages will be suppressed (use display/verblevel=5 to see all)");
11227 #define FEASTOLTIGHTFAC 0.001 11256 assert(lp != NULL);
11258 assert(
set != NULL);
11259 assert(stat != NULL);
11260 assert(lperror != NULL);
11261 assert(timelimit != NULL);
11272 SCIPerrorMessage(
"cannot solve LP when loose variable with infinite best bound is present\n");
11280 itlimishard = (itlim == harditlim);
11286 usepolishing =
TRUE;
11293 usepolishing =
FALSE;
11329 else if( !set->lp_checkstability )
11357 else if( !set->lp_checkstability )
11384 else if( !set->lp_checkstability )
11410 lpalgoName(lpalgo), !set->lp_presolving ?
"with" :
"without");
11416 else if( !set->lp_checkstability )
11435 if( ((simplex && (!tightprimfeastol || !tightdualfeastol)) || (!tightprimfeastol && !tightdualfeastol)) &&
11439 if( !tightprimfeastol )
11445 if( !tightdualfeastol )
11451 if( !simplex && !tightprimfeastol && !tightdualfeastol )
11456 if( success || success2 || success3 )
11464 else if( !set->lp_checkstability )
11475 if( !tightprimfeastol )
11479 if( !tightdualfeastol )
11483 if( !simplex && !tightprimfeastol && !tightdualfeastol )
11495 if( !fromscratch && simplex )
11506 else if( !set->lp_checkstability )
11528 else if( !set->lp_checkstability )
11543 lpalgoName(lpalgo), (set->lp_scaling == 0) ?
"with" :
"without");
11549 else if( !set->lp_checkstability )
11569 lpalgoName(lpalgo), !set->lp_presolving ?
"with" :
"without");
11575 else if( !set->lp_checkstability )
11591 if( !tightprimfeastol || !tightdualfeastol )
11594 if( !tightprimfeastol )
11600 if( !tightdualfeastol )
11605 if( success || success2 )
11613 else if( !set->lp_checkstability )
11624 if( !tightprimfeastol )
11628 if( !tightdualfeastol )
11651 assert(lp != NULL);
11652 assert(
set != NULL);
11701 assert(lp != NULL);
11703 assert(
set != NULL);
11704 assert(stat != NULL);
11705 assert(lperror != NULL);
11709 solvedprimal =
FALSE;
11710 solveddual =
FALSE;
11714 itlim = ( resolve ? resolveitlim : harditlim );
11718 SCIP_CALL(
lpSolveStable(lp,
set, messagehdlr, stat, prob, lpalgo, itlim, harditlim, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch,
11719 keepsol, &timelimit, lperror) );
11815 "(node %" SCIP_LONGINT_FORMAT
") solution status of LP %" SCIP_LONGINT_FORMAT
" could not be proven (internal status:%d) -- solve again with %s\n",
11824 "(node %" SCIP_LONGINT_FORMAT
") solution status of LP %" SCIP_LONGINT_FORMAT
" could not be proven (internal status:%d) -- solve again with %s\n",
11830 SCIPerrorMessage(
"(node %" SCIP_LONGINT_FORMAT
") error or unknown return status of %s in LP %" SCIP_LONGINT_FORMAT
" (internal status: %d)\n",
11838 SCIPsetDebugMsg(
set,
"solving LP with %s returned solstat=%d (internal status: %d, primalfeasible=%u, dualfeasible=%u)\n",
11870 assert(lp != NULL);
11871 assert(
set != NULL);
11872 assert(lperror != NULL);
11880 algo = resolve ?
set->lp_resolvealgorithm :
set->lp_initalgorithm;
11890 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, keepsol, lperror) );
11896 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, keepsol, lperror) );
11903 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, keepsol, lperror) );
11909 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, keepsol, lperror) );
11915 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, keepsol, lperror) );
11921 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, keepsol, lperror) );
11925 SCIPerrorMessage(
"invalid parameter setting <%c> for LP algorithm\n", algo);
11928 assert(!(*lperror) || !lp->
solved);
11956 #define checkLazyBounds(lp, set) 11979 SCIPsetDebugMsg(
set,
"mark all lazy columns as changed in order to reload bounds (diving=%u, applied=%u)\n",
12032 if( (set->lp_resolveiterfac == -1) || stat->
nlps - stat->
nrootlps < 5 )
12038 return (
int) MIN(itlim,
MAX(set->lp_resolveitermin, \
12068 assert(lp != NULL);
12069 assert(prob != NULL);
12071 assert(lperror != NULL);
12073 SCIPsetDebugMsg(
set,
"solving LP: %d rows, %d cols, primalfeasible=%u, dualfeasible=%u, solved=%u, diving=%u, probing=%u, cutoffbnd=%g\n",
12080 needprimalray =
TRUE;
12082 || (
set->conf_enable &&
set->conf_useinflp !=
'o'));
12085 harditlim = (int) MIN(itlim, INT_MAX);
12086 resolveitlim = ( limitresolveiters ?
lpGetResolveItlim(
set, stat, harditlim) : harditlim );
12087 assert(harditlim == -1 || (resolveitlim <= harditlim));
12124 tightprimfeastol =
FALSE;
12125 tightdualfeastol =
FALSE;
12126 fromscratch =
FALSE;
12127 primalfeasible =
FALSE;
12128 dualfeasible =
FALSE;
12129 wasfromscratch = (stat->
nlps == 0);
12133 oldnlps = stat->
nlps;
12134 SCIP_CALL(
lpFlushAndSolve(lp, blkmem,
set, messagehdlr, stat, prob, eventqueue, resolveitlim, harditlim, needprimalray,
12135 needdualray, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, keepsol, lperror) );
12137 assert(!(*lperror) || !lp->
solved);
12151 if( set->lp_checkprimfeas )
12153 primalfeaspointer = &primalfeasible;
12159 primalfeasible =
TRUE;
12160 primalfeaspointer = NULL;
12163 if( set->lp_checkdualfeas )
12165 dualfeaspointer = &dualfeasible;
12171 dualfeasible =
TRUE;
12172 dualfeaspointer = NULL;
12181 if( primalfeasible && dualfeasible && aging && !lp->
diving && stat->
nlps > oldnlps )
12185 if( stat->
nlps % ((set->lp_rowagelimit+1)/2 + 1) == 0 )
12198 if( !primalfeasible || !dualfeasible )
12202 if( (fastmip > 0) && simplex )
12206 "(node %" SCIP_LONGINT_FORMAT
") solution of LP %" SCIP_LONGINT_FORMAT
" not optimal (pfeas=%d, dfeas=%d) -- solving again without FASTMIP\n",
12207 stat->
nnodes, stat->
nlps, primalfeasible, dualfeasible);
12211 else if( (!primalfeasible && !tightprimfeastol) || (!dualfeasible && !tightdualfeastol) )
12217 "(node %" SCIP_LONGINT_FORMAT
") solution of LP %" SCIP_LONGINT_FORMAT
" not optimal (pfeas=%d, dfeas=%d) -- solving again with tighter feasibility tolerance\n",
12218 stat->
nnodes, stat->
nlps, primalfeasible, dualfeasible);
12219 tightprimfeastol = tightprimfeastol || !primalfeasible;
12220 tightdualfeastol = tightdualfeastol || !dualfeasible;
12223 else if( !fromscratch && !wasfromscratch && simplex )
12227 "(node %" SCIP_LONGINT_FORMAT
") solution of LP %" SCIP_LONGINT_FORMAT
" not optimal (pfeas=%d, dfeas=%d) -- solving again from scratch\n",
12228 stat->
nnodes, stat->
nlps, primalfeasible, dualfeasible);
12229 fromscratch =
TRUE;
12240 SCIPsetDebugMsg(
set,
" -> LP objective value: %g + %g = %g (solstat=%d, cutoff=%g)\n",
12259 "(node %" SCIP_LONGINT_FORMAT
") infeasibility of LP %" SCIP_LONGINT_FORMAT
" could not be proven by dual ray\n", stat->
nnodes, stat->
nlps);
12268 if( set->lp_checkprimfeas )
12280 primalfeasible =
TRUE;
12281 rayfeasible =
TRUE;
12288 SCIPsetDebugMsg(
set,
" -> LP has unbounded primal ray (primalfeas=%u, rayfeas=%u)\n",
12289 primalfeasible, rayfeasible);
12291 if( !primalfeasible || !rayfeasible )
12295 if( (fastmip > 0) && simplex )
12299 "(node %" SCIP_LONGINT_FORMAT
") solution of unbounded LP %" SCIP_LONGINT_FORMAT
" not optimal (pfeas=%d, rfeas=%d) -- solving again without FASTMIP\n",
12300 stat->
nnodes, stat->
nlps, primalfeasible, rayfeasible);
12304 else if( !tightprimfeastol )
12310 "(node %" SCIP_LONGINT_FORMAT
") solution of unbounded LP %" SCIP_LONGINT_FORMAT
" not optimal (pfeas=%d, rfeas=%d) -- solving again with tighter primal feasibility tolerance\n",
12311 stat->
nnodes, stat->
nlps, primalfeasible, rayfeasible);
12312 tightprimfeastol =
TRUE;
12315 else if( !fromscratch && simplex )
12319 "(node %" SCIP_LONGINT_FORMAT
") solution of unbounded LP %" SCIP_LONGINT_FORMAT
" not optimal (pfeas=%d, rfeas=%d) -- solving again from scratch\n",
12320 stat->
nnodes, stat->
nlps, primalfeasible, rayfeasible);
12321 fromscratch =
TRUE;
12354 assert(lpi != NULL);
12366 char tmppricingchar;
12372 fromscratch =
FALSE;
12384 FALSE,
FALSE,
TRUE, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, keepsol, lperror) );
12399 SCIPsetDebugMsg(
set,
" ---> new objval = %f (solstat: %d, 1 add. step)\n", objval, solstat);
12411 assert(!(*lperror));
12414 FALSE,
FALSE,
TRUE, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, keepsol, lperror) );
12422 SCIPsetDebugMsg(
set,
" ---> new objval = %f (solstat: %d, without fastmip)\n", objval, solstat);
12428 SCIPsetDebugMsg(
set,
"unresolved error while resolving LP in order to exceed the objlimit\n");
12444 if( set->lp_checkprimfeas )
12446 primalfeaspointer = &primalfeasible;
12452 primalfeasible =
TRUE;
12453 primalfeaspointer = NULL;
12456 if( set->lp_checkdualfeas )
12458 dualfeaspointer = &dualfeasible;
12464 dualfeasible =
TRUE;
12465 dualfeaspointer = NULL;
12490 if( !primalfeasible || !dualfeasible
12500 SCIPsetDebugMsg(
set,
" -> LP objective value: %g + %g = %g (solstat=%d, cutoff=%g)\n",
12513 if( set->lp_checkprimfeas )
12525 primalfeasible =
TRUE;
12526 rayfeasible =
TRUE;
12535 if( !primalfeasible || !rayfeasible )
12578 SCIPmessagePrintWarning(messagehdlr,
"LP solver reached time limit, but SCIP time limit is not exceeded yet; " 12579 "you might consider switching the clock type of SCIP\n");
12596 assert(!(*lperror) || !lp->
solved);
12605 SCIPsetDebugMsg(
set,
"resetting parameter SCIP_LPPARAM_FROMSCRATCH to FALSE %s\n", success ?
"" :
"failed");
12616 assert(lp != NULL);
12634 assert(lp != NULL);
12637 assert(
set != NULL);
12660 assert(lp != NULL);
12673 assert(lp != NULL);
12676 assert(
set != NULL);
12693 assert(lp != NULL);
12704 assert(lp != NULL);
12721 assert(lp != NULL);
12722 assert(
set != NULL);
12723 assert(prob != NULL);
12726 nvars = prob->
nvars;
12734 for( v = 0; v < nvars; ++v )
12785 assert(lp != NULL);
12787 assert(
set != NULL);
12817 assert(lp != NULL);
12819 assert(
set != NULL);
12852 int pseudoobjvalinf;
12863 pseudoobjval -= oldbound * obj;
12864 assert(pseudoobjvalinf >= 0);
12868 pseudoobjval += newbound * obj;
12870 assert(pseudoobjvalinf >= 0);
12872 if( pseudoobjvalinf > 0 || set->nactivepricers > 0 )
12875 return pseudoobjval;
12891 int pseudoobjvalinf;
12917 assert(pseudoobjvalinf >= 0);
12929 assert(pseudoobjvalinf >= 0);
12931 if( pseudoobjvalinf > 0 || set->nactivepricers > 0 )
12934 return pseudoobjval;
12965 (*deltaval) = lb * (newobj - oldobj);
12976 (*deltaval) = ub * newobj;
12985 (*deltaval) = -lb * oldobj;
12990 (*deltaval) = (ub * newobj) - (lb * oldobj);
13000 (*deltaval) = -lb * oldobj;
13011 (*deltaval) = ub * (newobj - oldobj);
13022 (*deltaval) = lb * newobj;
13031 (*deltaval) = -ub * oldobj;
13036 (*deltaval) = (lb * newobj) - (ub * oldobj);
13046 (*deltaval) = -ub * oldobj;
13057 (*deltaval) = ub * newobj;
13064 (*deltaval) = lb * newobj;
13090 (*deltaval) = newlb * obj;
13101 (*deltaval) = -oldlb * obj;
13106 (*deltaval) = obj * (newlb - oldlb);
13131 (*deltaval) = newub * obj;
13142 (*deltaval) = -oldub * obj;
13147 (*deltaval) = obj * (newub - oldub);
13164 assert(lp != NULL);
13254 assert(lp != NULL);
13263 assert(var != NULL);
13267 SCIPerrorMessage(
"LP was informed of an objective change of a non-active variable\n");
13289 else if( oldobj < 0.0 )
13315 else if( newobj < 0.0 )
13356 assert(
set != NULL);
13357 assert(var != NULL);
13359 if( set->misc_exactsolve )
13361 if( oldobj != newobj )
13410 assert(
set != NULL);
13411 assert(var != NULL);
13438 assert(
set != NULL);
13439 assert(var != NULL);
13441 if( set->misc_exactsolve )
13479 assert(
set != NULL);
13480 assert(var != NULL);
13506 assert(
set != NULL);
13507 assert(var != NULL);
13509 if( set->misc_exactsolve )
13545 assert(lp != NULL);
13566 assert(lp != NULL);
13594 assert(lp != NULL);
13645 assert(lp != NULL);
13702 assert(
set != NULL);
13704 if( set->misc_exactsolve )
13728 assert(lp != NULL);
13777 assert(lp != NULL);
13826 assert(
set != NULL);
13828 if( set->misc_exactsolve )
13845 assert(lp != NULL);
13885 assert(lp != NULL);
13888 assert(
set != NULL);
13889 assert(stat != NULL);
13895 if( primalfeasible == NULL )
13896 stillprimalfeasible =
FALSE;
13899 *primalfeasible =
TRUE;
13900 stillprimalfeasible =
TRUE;
13902 if( dualfeasible == NULL )
13903 stilldualfeasible =
FALSE;
13906 *dualfeasible =
TRUE;
13907 stilldualfeasible =
TRUE;
13915 SCIPsetDebugMsg(
set,
"getting new LP solution %" SCIP_LONGINT_FORMAT
" for solstat %d\n",
13947 for( c = 0; c < nlpicols; ++c )
13949 assert( 0 <= cstat[c] && cstat[c] < 4 );
13950 lpicols[c]->
primsol = primsol[c];
13951 lpicols[c]->
minprimsol = MIN(lpicols[c]->minprimsol, primsol[c]);
13952 lpicols[c]->
maxprimsol =
MAX(lpicols[c]->maxprimsol, primsol[c]);
13953 lpicols[c]->
redcost = redcost[c];
13954 lpicols[c]->
basisstatus = (
unsigned int) cstat[c];
13956 if( stillprimalfeasible )
13958 stillprimalfeasible =
13961 primalbound += (lpicols[c]->
primsol * lpicols[c]->
obj);
13971 if( stilldualfeasible )
13973 compslack = MIN((lpicols[c]->primsol - lpicols[c]->lb), 1.0) * lpicols[c]->
redcost;
13976 if( stilldualfeasible )
13978 compslack = MIN((lpicols[c]->ub - lpicols[c]->primsol), 1.0) * lpicols[c]->
redcost;
13982 SCIPsetDebugMsg(
set,
" col <%s> [%.9g,%.9g]: primsol=%.9f, redcost=%.9f, pfeas=%u/%u(%u), dfeas=%d/%d(%u)\n",
13983 SCIPvarGetName(lpicols[c]->var), lpicols[c]->lb, lpicols[c]->ub, lpicols[c]->primsol, lpicols[c]->redcost,
13986 primalfeasible != NULL ? stillprimalfeasible :
TRUE,
13989 dualfeasible != NULL ? stilldualfeasible : TRUE);
13994 if( dualfeasible == NULL && lpicols[c]->basisstatus == (
unsigned int)
SCIP_BASESTAT_BASIC )
14003 if( stilldualfeasible
14006 if( stilldualfeasible
14010 SCIPsetDebugMsg(
set,
" col <%s> [%.9g,%.9g]: primsol=%.9f, redcost=%.9f, pfeas=%u/%u(%u), dfeas=%d/%d(%u)\n",
14011 SCIPvarGetName(lpicols[c]->var), lpicols[c]->lb, lpicols[c]->ub, lpicols[c]->primsol, lpicols[c]->redcost,
14014 primalfeasible != NULL ? stillprimalfeasible :
TRUE,
14017 dualfeasible != NULL ? stilldualfeasible : TRUE);
14024 if( stilldualfeasible )
14027 dualbound += (lpicols[c]->
redcost * lpicols[c]->
lb);
14028 else if( lpicols[c]->redcost < 0.0 && !
SCIPsetIsInfinity(
set, lpicols[c]->ub) )
14029 dualbound += (lpicols[c]->redcost * lpicols[c]->ub);
14034 for( r = 0; r < nlpirows; ++r )
14036 assert( 0 <= rstat[r] && rstat[r] < 4 );
14037 lpirows[r]->
dualsol = dualsol[r];
14039 lpirows[r]->
basisstatus = (
unsigned int) rstat[r];
14041 if( stillprimalfeasible )
14043 stillprimalfeasible =
14055 if( stilldualfeasible )
14057 compslack = MIN((lpirows[r]->activity - lpirows[r]->lhs), 1.0) * lpirows[r]->
dualsol;
14060 if( stilldualfeasible )
14062 compslack = MIN((lpirows[r]->rhs - lpirows[r]->activity), 1.0) * lpirows[r]->
dualsol;
14066 SCIPsetDebugMsg(
set,
" row <%s> [%.9g,%.9g]: activity=%.9f, dualsol=%.9f, pfeas=%u/%u(%u), dfeas=%d/%d(%u)\n",
14067 lpirows[r]->name, lpirows[r]->lhs, lpirows[r]->rhs, lpirows[r]->activity, lpirows[r]->dualsol,
14070 primalfeasible != NULL ? stillprimalfeasible :
TRUE,
14073 dualfeasible != NULL ? stilldualfeasible : TRUE);
14081 if( stilldualfeasible &&
14084 if( stilldualfeasible &&
14088 SCIPsetDebugMsg(
set,
" row <%s> [%.9g,%.9g] + %.9g: activity=%.9f, dualsol=%.9f, pfeas=%u/%u(%u), dfeas=%d/%d(%u)\n",
14089 lpirows[r]->name, lpirows[r]->lhs, lpirows[r]->rhs, lpirows[r]->constant, lpirows[r]->activity, lpirows[r]->dualsol,
14092 primalfeasible != NULL ? stillprimalfeasible :
TRUE,
14095 dualfeasible != NULL ? stilldualfeasible : TRUE);
14102 if( stilldualfeasible )
14106 else if( lpirows[r]->dualsol < 0.0 && !
SCIPsetIsInfinity(
set, lpirows[r]->rhs) )
14107 dualbound += (lpirows[r]->dualsol * (lpirows[r]->rhs - lpirows[r]->constant));
14136 if( primalfeasible != NULL )
14137 *primalfeasible = stillprimalfeasible;
14138 if( dualfeasible != NULL )
14139 *dualfeasible = stilldualfeasible;
14174 assert(lp != NULL);
14179 assert(
set != NULL);
14180 assert(stat != NULL);
14183 if( primalfeasible != NULL )
14184 *primalfeasible =
TRUE;
14185 if( rayfeasible != NULL )
14186 *rayfeasible =
TRUE;
14222 for( c = 0; c < nlpicols; ++c )
14224 assert(lpicols[c] != NULL);
14225 assert(lpicols[c]->var != NULL);
14228 if( rayfeasible != NULL )
14229 *rayfeasible = *rayfeasible
14236 if( primalfeasible != NULL )
14237 *primalfeasible = *primalfeasible
14242 rayobjval += ray[c] * lpicols[c]->
obj;
14246 if( primalfeasible != NULL && !(*primalfeasible) )
14251 else if( rayfeasible != NULL && !(*rayfeasible) )
14261 if( rayfeasible != NULL )
14263 *rayfeasible =
FALSE;
14270 assert(rayobjval != 0.0);
14277 for( c = 0; c < nlpicols; ++c )
14280 rayscale = MIN(rayscale, (lpicols[c]->ub - primsol[c])/ray[c]);
14282 rayscale = MIN(rayscale, (lpicols[c]->lb - primsol[c])/ray[c]);
14288 SCIPsetDebugMsg(
set,
"unbounded LP solution: rayobjval=%f, rayscale=%f\n", rayobjval, rayscale);
14291 for( c = 0; c < nlpicols; ++c )
14294 lpicols[c]->
primsol = primsol[c];
14297 SCIP_Real primsolval = primsol[c] + rayscale * ray[c];
14304 for( r = 0; r < nlpirows; ++r )
14311 if( primalfeasible != NULL )
14312 *primalfeasible = *primalfeasible
14340 assert(lp != NULL);
14341 assert(
set != NULL);
14342 assert(ray != NULL);
14367 for( c = 0; c < nlpicols; c++ )
14369 assert(lpicols[c] != NULL);
14371 var = lpicols[c]->
var;
14372 assert(var != NULL);
14397 assert(lp != NULL);
14401 assert(
set != NULL);
14402 assert(stat != NULL);
14423 for( r = 0; r < nlpirows; ++r )
14425 SCIPsetDebugMsg(
set,
" row <%s>: dualfarkas=%f\n", lpirows[r]->name, dualfarkas[r]);
14434 for( c = 0; c < nlpicols; ++c )
14454 assert(lp != NULL);
14476 assert(lp != NULL);
14481 assert(stat != NULL);
14491 for( c = 0; c < nlpicols; ++c )
14493 assert(lpicols[c] == lp->
cols[c]);
14494 if( lpicols[c]->primsol == 0.0 )
14497 lpicols[c]->
age = 0;
14502 for( r = 0; r < nlpirows; ++r )
14505 assert(lpirows[r] == lp->
rows[r]);
14507 if( lpirows[r]->dualsol == 0.0 )
14514 lpirows[r]->
age = 0;
14534 assert(lp != NULL);
14538 assert(coldstat != NULL);
14547 for( c = 0; c < ncols; ++c )
14550 assert(col != NULL);
14551 assert(col == lp->
lpicols[c]);
14552 assert(coldstat[c] <= c);
14553 col->
lppos = coldstat[c];
14554 if( coldstat[c] == -1 )
14566 lp->
cols[c] = NULL;
14572 else if( coldstat[c] < c )
14574 assert(lp->
cols[coldstat[c]] == NULL);
14575 assert(lp->
lpicols[coldstat[c]] == NULL);
14576 lp->
cols[coldstat[c]] = col;
14577 lp->
lpicols[coldstat[c]] = col;
14578 lp->
cols[coldstat[c]]->
lppos = coldstat[c];
14579 lp->
cols[coldstat[c]]->
lpipos = coldstat[c];
14580 lp->
cols[c] = NULL;
14587 while( c < lp->nlazycols )
14599 if( lp->
ncols < ncols )
14636 assert(lp != NULL);
14640 assert(rowdstat != NULL);
14648 for( r = 0; r < nrows; ++r )
14651 assert(row == lp->
lpirows[r]);
14652 assert(rowdstat[r] <= r);
14653 assert(row != NULL);
14654 row->
lppos = rowdstat[r];
14655 if( rowdstat[r] == -1 )
14679 assert(lp->
lpirows[r] == NULL);
14680 assert(lp->
rows[r] == NULL);
14684 else if( rowdstat[r] < r )
14686 assert(lp->
rows[rowdstat[r]] == NULL);
14687 assert(lp->
lpirows[rowdstat[r]] == NULL);
14688 lp->
rows[rowdstat[r]] = row;
14689 lp->
lpirows[rowdstat[r]] = row;
14690 lp->
rows[rowdstat[r]]->
lppos = rowdstat[r];
14691 lp->
rows[rowdstat[r]]->
lpipos = rowdstat[r];
14692 lp->
rows[r] = NULL;
14698 if( lp->
nrows < nrows )
14737 assert(lp != NULL);
14742 assert(
set != NULL);
14743 assert(stat != NULL);
14760 for( c = firstcol; c < ncols; ++c )
14762 assert(cols[c] == lpicols[c]);
14763 assert(cols[c]->lppos == c);
14764 assert(cols[c]->lpipos == c);
14765 if( cols[c]->removable
14766 && cols[c]->obsoletenode != stat->
nnodes 14767 && cols[c]->
age > set->lp_colagelimit
14771 assert(cols[c]->primsol == 0.0);
14775 SCIPsetDebugMsg(
set,
"removing obsolete col <%s>: primsol=%f, bounds=[%g,%g]\n",
14776 SCIPvarGetName(cols[c]->var), cols[c]->primsol, cols[c]->lb, cols[c]->ub);
14780 SCIPsetDebugMsg(
set,
"removing %d/%d obsolete columns from LP\n", ndelcols, ncols);
14787 assert(lp->
ncols == ncols - ndelcols);
14816 assert(lp != NULL);
14821 assert(
set != NULL);
14822 assert(stat != NULL);
14839 for( r = firstrow; r < nrows; ++r )
14841 assert(rows[r] == lpirows[r]);
14842 assert(rows[r]->lppos == r);
14843 assert(rows[r]->lpipos == r);
14844 if( rows[r]->removable
14845 && rows[r]->obsoletenode != stat->
nnodes 14846 && rows[r]->
age > set->lp_rowagelimit
14852 SCIPsetDebugMsg(
set,
"removing obsolete row <%s>: activity=%f, sides=[%g,%g]\n",
14853 rows[r]->name, rows[r]->activity, rows[r]->lhs, rows[r]->rhs);
14857 SCIPsetDebugMsg(
set,
"removing %d/%d obsolete rows from LP\n", ndelrows, nrows);
14864 assert(lp->
nrows == nrows - ndelrows);
14882 assert(lp != NULL);
14886 assert(
set != NULL);
14888 SCIPsetDebugMsg(
set,
"removing obsolete columns starting with %d/%d, obsolete rows starting with %d/%d\n",
14913 assert(lp != NULL);
14917 assert(
set != NULL);
14921 if( 0 < lp->
ncols )
14925 if( 0 < lp->
nrows )
14949 assert(lp != NULL);
14953 assert(stat != NULL);
14955 assert(0 <= firstcol && firstcol < lp->ncols);
14970 for( c = firstcol; c < ncols; ++c )
14972 assert(cols[c] == lpicols[c]);
14973 assert(cols[c]->lppos == c);
14974 assert(cols[c]->lpipos == c);
14975 if( lpicols[c]->removable
14977 && lpicols[c]->primsol == 0.0
14985 SCIPsetDebugMsg(
set,
"removing %d/%d unused columns from LP\n", ndelcols, ncols);
14992 assert(lp->
ncols == ncols - ndelcols);
15021 assert(lp != NULL);
15026 assert(stat != NULL);
15028 assert(0 <= firstrow && firstrow < lp->nrows);
15045 for( r = firstrow; r < nrows; ++r )
15047 assert(rows[r] == lpirows[r]);
15048 assert(rows[r]->lppos == r);
15049 assert(rows[r]->lpipos == r);
15057 SCIPsetDebugMsg(
set,
"removing %d/%d unused rows from LP\n", ndelrows, nrows);
15064 assert(lp->
nrows == nrows - ndelrows);
15086 assert(lp != NULL);
15090 assert(
set != NULL);
15093 cleanupcols = (root ?
set->lp_cleanupcolsroot :
set->lp_cleanupcols);
15094 cleanuprows = (root ?
set->lp_cleanuprowsroot :
set->lp_cleanuprows);
15096 SCIPsetDebugMsg(
set,
"removing unused columns starting with %d/%d (%u), unused rows starting with %d/%d (%u), LP algo: %d, basic sol: %u\n",
15125 assert(lp != NULL);
15129 assert(
set != NULL);
15132 cleanupcols = (root ?
set->lp_cleanupcolsroot :
set->lp_cleanupcols);
15133 cleanuprows = (root ?
set->lp_cleanuprowsroot :
set->lp_cleanuprows);
15135 SCIPsetDebugMsg(
set,
"removing all unused columns (%u) and rows (%u), LP algo: %d, basic sol: %u\n",
15138 if( cleanupcols && 0 < lp->
ncols )
15142 if( cleanuprows && 0 < lp->
nrows )
15169 assert(lp != NULL);
15174 assert(stat != NULL);
15195 assert(rows[r] == lpirows[r]);
15196 assert(rows[r]->lppos == r);
15197 assert(rows[r]->lpipos == r);
15201 SCIPsetDebugMsg(
set,
"basic row <%s> is redundant: sides=[%g,%g], act=[%g,%g]\n",
15209 SCIPsetDebugMsg(
set,
"removing %d/%d redundant basic rows from LP\n", ndelrows, nrows);
15216 assert(lp->
nrows == nrows - ndelrows);
15235 assert(lp != NULL);
15243 assert(blkmem != NULL);
15244 assert(
set != NULL);
15247 SCIPsetDebugMsg(
set,
"diving started (LP flushed: %u, LP solved: %u, solstat: %d)\n",
15251 for( c = 0; c < lp->
ncols; ++c )
15253 assert(lp->
cols[c] != NULL);
15254 assert(lp->
cols[c]->
var != NULL);
15273 if( !set->lp_resolverestore && lp->
solved )
15304 for( c = 0; c < lp->
ncols; ++c )
15308 for( r = 0; r < lp->
nrows; ++r )
15347 assert(lp != NULL);
15349 assert(blkmem != NULL);
15350 assert(nvars == 0 || vars != NULL);
15355 for( v = 0; v < nvars; ++v )
15358 assert(var != NULL);
15423 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, prob, -1LL,
FALSE,
FALSE,
FALSE, &lperror) );
15435 "LP was not resolved to a sufficient status after diving\n");
15476 for( c = 0; c < lp->
ncols; ++c )
15480 for( r = 0; r < lp->
nrows; ++r )
15494 for( c = 0; c < lp->
ncols; ++c )
15496 assert(lp->
cols[c] != NULL);
15497 assert(lp->
cols[c]->
var != NULL);
15510 #define DIVESTACKGROWFACT 1.5 15519 assert(lp != NULL);
15520 assert(row != NULL);
15541 assert(lp != NULL);
15556 assert(lp != NULL);
15571 assert(lp != NULL);
15584 assert(lp != NULL);
15625 assert(lp != NULL);
15627 assert(
set != NULL);
15628 assert(bound != NULL);
15635 for( j = 0; j < lp->
nrows; ++j )
15638 assert(row != NULL);
15664 for( j = 0; j < lp->
ncols; ++j )
15667 assert(col != NULL);
15672 c = usefarkas ? 0.0 : col->
obj;
15675 for( i = 0; i < col->
nlprows; ++i )
15677 assert(col->
rows[i] != NULL);
15679 assert(col->
linkpos[i] >= 0);
15686 for( i = col->
nlprows; i < col->len; ++i )
15688 assert(col->
rows[i] != NULL);
15692 assert(col->
linkpos[i] >= 0);
15735 assert(proved != NULL);
15739 *proved = (bound > 0.0);
15741 SCIPsetDebugMsg(
set,
"proved Farkas value of LP: %g -> infeasibility %sproved\n", bound, *proved ?
"" :
"not ");
15754 assert(lp != NULL);
15756 assert(fname != NULL);
15784 assert(lp != NULL);
15786 assert(fname != NULL);
15789 file = fopen(fname,
"w");
15799 SCIPmessageFPrintInfo(messagehdlr, file,
"\\ Original Variable and Constraint Names have been replaced by generic names.\n");
15802 SCIPmessageFPrintInfo(messagehdlr, file,
"\\ Warning: Variable and Constraint Names should not contain special characters like '+', '=' etc.\n");
15806 if( origobj && objoffset != 0.0 )
15808 SCIPmessageFPrintInfo(messagehdlr, file,
"\\ An artificial variable 'objoffset' has been added and fixed to 1.\n");
15809 SCIPmessageFPrintInfo(messagehdlr, file,
"\\ Switching this variable to 0 will disable the offset in the objective.\n\n");
15822 for( i = 0; i < lp->
ncols; ++i )
15824 if( lp->
cols[i]->
obj != 0.0 )
15844 if( origobj && objoffset != 0.0 )
15849 for( i = 0; i < lp->
nrows; i++ )
15882 if( strlen(rowname) > 0 )
15887 SCIPmessageFPrintInfo(messagehdlr, file,
"are not in a valid range. The following two constraints may be corrupted!\n");
15895 assert(type ==
'B');
15908 if( (j+1) % 10 == 0 )
15939 for( i = 0; i < lp->
nrows; i++ )
15972 if( strlen(rowname) > 0 )
15977 SCIPmessageFPrintInfo(messagehdlr, file,
"are not in a valid range. The following two constraints may be corrupted!\n");
15985 assert(type ==
'B');
15998 if( (j+1) % 10 == 0 )
16028 for( i = 0; i < lp->
ncols; ++i )
16048 if( origobj && objoffset != 0.0 )
16054 for( i = 0; i < lp->
ncols; ++i )
16086 #undef SCIPcolGetObj 16087 #undef SCIPcolGetLb 16088 #undef SCIPcolGetUb 16089 #undef SCIPcolGetBestBound 16090 #undef SCIPcolGetPrimsol 16091 #undef SCIPcolGetMinPrimsol 16092 #undef SCIPcolGetMaxPrimsol 16093 #undef SCIPcolGetBasisStatus 16094 #undef SCIPcolGetVar 16095 #undef SCIPcolGetIndex 16096 #undef SCIPcolIsIntegral 16097 #undef SCIPcolIsRemovable 16098 #undef SCIPcolGetLPPos 16099 #undef SCIPcolGetLPDepth 16100 #undef SCIPcolIsInLP 16101 #undef SCIPcolGetNNonz 16102 #undef SCIPcolGetNLPNonz 16103 #undef SCIPcolGetRows 16104 #undef SCIPcolGetVals 16105 #undef SCIPcolGetStrongbranchNode 16106 #undef SCIPcolGetNStrongbranchs 16107 #undef SCIPboundtypeOpposite 16108 #undef SCIProwGetNNonz 16109 #undef SCIProwGetNLPNonz 16110 #undef SCIProwGetCols 16111 #undef SCIProwGetVals 16112 #undef SCIProwGetConstant 16113 #undef SCIProwGetNorm 16114 #undef SCIProwGetSumNorm 16115 #undef SCIProwGetLhs 16116 #undef SCIProwGetRhs 16117 #undef SCIProwGetDualsol 16118 #undef SCIProwGetDualfarkas 16119 #undef SCIProwGetBasisStatus 16120 #undef SCIProwGetName 16121 #undef SCIProwGetIndex 16122 #undef SCIProwGetAge 16123 #undef SCIProwGetRank 16124 #undef SCIProwIsIntegral 16125 #undef SCIProwIsLocal 16126 #undef SCIProwIsModifiable 16127 #undef SCIProwIsRemovable 16128 #undef SCIProwGetOrigintype 16129 #undef SCIProwGetOriginCons 16130 #undef SCIProwGetOriginSepa 16131 #undef SCIProwIsInGlobalCutpool 16132 #undef SCIProwGetLPPos 16133 #undef SCIProwGetLPDepth 16134 #undef SCIProwIsInLP 16135 #undef SCIProwGetActiveLPCount 16136 #undef SCIProwGetNLPsAfterCreation 16137 #undef SCIProwChgRank 16138 #undef SCIPlpGetCols 16139 #undef SCIPlpGetNCols 16140 #undef SCIPlpGetRows 16141 #undef SCIPlpGetNRows 16142 #undef SCIPlpGetNewcols 16143 #undef SCIPlpGetNNewcols 16144 #undef SCIPlpGetNewrows 16145 #undef SCIPlpGetNNewrows 16146 #undef SCIPlpGetObjNorm 16147 #undef SCIPlpGetRootObjval 16148 #undef SCIPlpGetRootColumnObjval 16149 #undef SCIPlpGetRootLooseObjval 16150 #undef SCIPlpGetLPI 16151 #undef SCIPlpSetIsRelax 16152 #undef SCIPlpIsRelax 16153 #undef SCIPlpIsSolved 16154 #undef SCIPlpIsSolBasic 16155 #undef SCIPlpDiving 16156 #undef SCIPlpDivingObjChanged 16157 #undef SCIPlpMarkDivingObjChanged 16158 #undef SCIPlpUnmarkDivingObjChanged 16159 #undef SCIPlpDivingRowsChanged 16166 assert(col != NULL);
16176 assert(col != NULL);
16186 assert(col != NULL);
16196 assert(col != NULL);
16198 if( col->
obj >= 0.0 )
16209 assert(col != NULL);
16211 if( col->
lppos >= 0 )
16222 assert(col != NULL);
16232 assert(col != NULL);
16244 assert(col != NULL);
16255 assert(col != NULL);
16265 assert(col != NULL);
16275 assert(col != NULL);
16286 assert(col != NULL);
16296 assert(col != NULL);
16307 assert(col != NULL);
16318 assert(col != NULL);
16321 return (col->
lppos >= 0);
16329 assert(col != NULL);
16343 assert(col != NULL);
16354 assert(col != NULL);
16364 assert(col != NULL);
16376 assert(col != NULL);
16386 assert(col != NULL);
16406 assert(row != NULL);
16420 assert(row != NULL);
16431 assert(row != NULL);
16441 assert(row != NULL);
16451 assert(row != NULL);
16461 assert(row != NULL);
16473 assert(row != NULL);
16485 assert(row != NULL);
16495 assert(row != NULL);
16505 assert(row != NULL);
16507 if( row->
lppos >= 0 )
16518 assert(row != NULL);
16520 if( row->
lppos >= 0 )
16533 assert(row != NULL);
16544 assert(row != NULL);
16554 assert(row != NULL);
16564 assert(row != NULL);
16574 assert(row != NULL);
16584 assert(row != NULL);
16594 assert(row != NULL);
16604 assert(row != NULL);
16614 assert(row != NULL);
16624 assert( row != NULL );
16634 assert( row != NULL );
16638 assert( row->
origin != NULL );
16649 assert( row != NULL );
16653 assert( row->
origin != NULL );
16664 assert(row != NULL);
16674 assert(row != NULL);
16685 assert(row != NULL);
16696 assert(row != NULL);
16699 return (row->
lppos >= 0);
16708 assert(row != NULL);
16718 assert(row != NULL);
16728 assert(row != NULL);
16738 assert(lp != NULL);
16748 assert(lp != NULL);
16758 assert(lp != NULL);
16768 assert(lp != NULL);
16778 assert(lp != NULL);
16789 assert(lp != NULL);
16800 assert(lp != NULL);
16811 assert(lp != NULL);
16829 assert(cols != NULL || lp->
ncols == 0);
16833 for( c = lp->
ncols - 1; c >= 0; --c )
16835 lp->
objsqrnorm += SQR(cols[c]->unchangedobj);
16853 assert(lp != NULL);
16866 assert(lp != NULL);
16876 assert(lp != NULL);
16886 assert(lp != NULL);
16898 assert(lp != NULL);
16910 assert(lp != NULL);
16920 assert(lp != NULL);
16931 assert(lp != NULL);
16943 assert(lp != NULL);
16953 assert(lp != NULL);
16963 assert(lp != NULL);
16973 assert(lp != NULL);
16983 assert(lp != NULL);
16993 assert(lp != NULL);
17003 assert(lp != NULL);
17013 assert(lp != NULL);
17024 assert(lp != NULL);
17035 assert(lp != NULL);
17081 assert(lpi != NULL);
17096 nnewcols = 3*lp->
ncols + 2*lp->
nrows + (inclobjcutoff ? 1 : 0) + 1;
17102 for( j = 0; j < lp->
ncols; ++j )
17112 nnewcols = lp->
ncols;
17113 obj[nnewcols] = 0.0;
17114 lb[nnewcols] = 1.0;
17119 for( i = 0; i < lp->
nrows; ++i )
17124 assert( row != NULL );
17138 ntotnonz += row->
nlpcols + 1;
17148 lb[nnewcols] = 0.0;
17149 ub[nnewcols] = 1.0;
17150 obj[nnewcols++] = 1.0;
17151 ntotnonz += row->
nlpcols + 2;
17154 ntotnonz += row->
nlpcols + 1;
17161 lb[nnewcols] = 0.0;
17162 ub[nnewcols] = 1.0;
17163 obj[nnewcols++] = 1.0;
17164 ntotnonz += row->
nlpcols + 2;
17167 ntotnonz += row->
nlpcols + 1;
17174 if( inclobjcutoff && relaxrows )
17177 lb[nnewcols] = 0.0;
17178 ub[nnewcols] = 1.0;
17179 obj[nnewcols++] = 1.0;
17180 ntotnonz += lp->
ncols + 2;
17185 for( j = 0; j < lp->
ncols; ++j )
17190 assert( col != NULL );
17203 lb[nnewcols] = 0.0;
17204 ub[nnewcols] = 1.0;
17205 obj[nnewcols++] = 1.0;
17211 lb[nnewcols] = 0.0;
17212 ub[nnewcols] = 1.0;
17213 obj[nnewcols++] = 1.0;
17220 nslacks = nnewcols - lp->
ncols - 1;
17221 assert( nslacks >= 0 );
17222 assert( nnewcols <= 3*lp->ncols + 2*lp->
nrows + (inclobjcutoff ? 1 : 0) + 1 );
17244 for( i = 0; i < lp->
nrows; ++i )
17254 assert( row != NULL );
17264 assert( nnonz <= lp->ncols );
17265 rowcols = row->
cols;
17266 rowvals = row->
vals;
17272 matbeg[matrowidx] = matidx;
17273 for( j = 0; j < nnonz; ++j )
17275 assert( rowcols[j] != NULL );
17276 assert( 0 <= rowcols[j]->lppos && rowcols[j]->lppos < lp->ncols );
17277 assert( lp->
cols[rowcols[j]->
lppos] == rowcols[j] );
17279 matinds[matidx] = rowcols[j]->
lppos;
17280 matvals[matidx++] = rowvals[j];
17281 assert( matidx <= ntotnonz );
17287 matinds[matidx] = lp->
ncols;
17288 matvals[matidx++] = -rhs;
17289 assert( matidx <= ntotnonz );
17292 matlhs[matrowidx] = 0.0;
17293 matrhs[matrowidx++] = 0.0;
17294 assert( matrowidx <= ntotrows );
17307 matbeg[matrowidx] = matidx;
17308 for( j = 0; j < nnonz; ++j )
17310 assert( rowcols[j] != NULL );
17311 assert( 0 <= rowcols[j]->lppos && rowcols[j]->lppos < lp->ncols );
17312 assert( lp->
cols[rowcols[j]->
lppos] == rowcols[j] );
17314 matinds[matidx] = rowcols[j]->
lppos;
17315 matvals[matidx++] = rowvals[j];
17316 assert( matidx <= ntotnonz );
17322 matinds[matidx] = lp->
ncols;
17323 matvals[matidx++] = -lhs;
17324 assert( matidx <= ntotnonz );
17330 matvals[matidx] = -
MAX(1.0, lhs);
17331 matinds[matidx++] = lp->
ncols + 1 + cnt;
17332 assert( matidx <= ntotnonz );
17336 matlhs[matrowidx] = 0.0;
17338 assert( matrowidx <= ntotrows );
17345 matbeg[matrowidx] = matidx;
17346 for( j = 0; j < nnonz; ++j )
17348 assert( rowcols[j] != NULL );
17349 assert( 0 <= rowcols[j]->lppos && rowcols[j]->lppos < lp->ncols );
17350 assert( lp->
cols[rowcols[j]->
lppos] == rowcols[j] );
17352 matinds[matidx] = rowcols[j]->
lppos;
17353 matvals[matidx++] = rowvals[j];
17354 assert( matidx <= ntotnonz );
17360 matinds[matidx] = lp->
ncols;
17361 matvals[matidx++] = -rhs;
17362 assert( matidx <= ntotnonz );
17368 matvals[matidx] =
MAX(1.0, absrhs);
17369 matinds[matidx++] = lp->
ncols + 1 + cnt;
17374 matrhs[matrowidx++] = 0.0;
17375 assert( matrowidx <= ntotrows );
17381 if( inclobjcutoff )
17390 matbeg[matrowidx] = matidx;
17391 for( j = 0; j < lp->
ncols; ++j )
17393 assert( lp->
cols[j] != NULL );
17400 matvals[matidx++] = lp->
cols[j]->
obj;
17401 assert( matidx <= ntotnonz );
17410 matinds[matidx] = lp->
ncols;
17411 matvals[matidx++] = -rhs;
17412 assert( matidx <= ntotnonz );
17420 matvals[matidx] =
MAX(1.0, absrhs);
17421 matinds[matidx++] = lp->
ncols + 1 + cnt;
17422 assert( matidx <= ntotnonz );
17426 matrhs[matrowidx++] = 0.0;
17427 assert( matrowidx <= ntotrows );
17431 for( j = 0; j < lp->
ncols; ++j )
17438 assert( col != NULL );
17439 assert( col->
lppos == j );
17445 matbeg[matrowidx] = matidx;
17447 matinds[matidx] = j;
17448 matvals[matidx++] = 1.0;
17449 assert( matidx <= ntotnonz );
17454 matinds[matidx] = lp->
ncols;
17455 matvals[matidx++] = -col->
lb;
17456 assert( matidx <= ntotnonz );
17459 matlhs[matrowidx] = 0.0;
17460 matrhs[matrowidx++] = 0.0;
17461 assert( matrowidx <= ntotrows );
17473 matbeg[matrowidx] = matidx;
17475 matinds[matidx] = j;
17476 matvals[matidx++] = 1.0;
17477 assert( matidx <= ntotnonz );
17482 matinds[matidx] = lp->
ncols;
17483 matvals[matidx++] = -col->
lb;
17484 assert( matidx <= ntotnonz );
17488 matvals[matidx] = -
MAX(1.0, abscollb);
17489 matinds[matidx++] = lp->
ncols + 1 + cnt;
17490 assert( matidx <= ntotnonz );
17493 matlhs[matrowidx] = 0.0;
17495 assert( matrowidx <= ntotrows );
17502 matbeg[matrowidx] = matidx;
17504 matinds[matidx] = j;
17505 matvals[matidx++] = 1.0;
17506 assert( matidx <= ntotnonz );
17511 matinds[matidx] = lp->
ncols;
17512 matvals[matidx++] = -col->
ub;
17513 assert( matidx <= ntotnonz );
17517 matvals[matidx] =
MAX(1.0, abscolub);
17518 matinds[matidx++] = lp->
ncols + 1 + cnt;
17519 assert( matidx <= ntotnonz );
17523 matrhs[matrowidx++] = 0.0;
17524 assert( matrowidx <= ntotrows );
17527 assert( cnt == nslacks );
17528 assert( matrowidx == ntotrows );
17547 assert( ncols == nnewcols );
17558 SCIPmessagePrintWarning(messagehdlr,
"Could not set time limit of LP solver for relative interior point computation.\n");
17565 SCIPmessagePrintWarning(messagehdlr,
"Could not set iteration limit of LP solver for relative interior point computation.\n");
17583 alpha = primal[lp->
ncols];
17586 SCIPsetDebugMsg(
set,
"Solved relative interior lp with objective %g.\n", objval);
17589 for( j = 0; j < lp->
ncols; ++j )
17590 point[j] = primal[j]/alpha;
17597 for( i = 0; i < lp->
nrows; ++i )
17608 assert( row != NULL );
17614 assert( nnonz <= lp->ncols );
17615 rowcols = row->
cols;
17616 rowvals = row->
vals;
17619 for( j = 0; j < nnonz; ++j )
17620 sum += rowvals[j] * primal[rowcols[j]->lppos];
17644 if( inclobjcutoff )
17653 for( j = 0; j < lp->
ncols; ++j )
17662 for( j = 0; j < lp->
ncols; ++j )
17670 assert( col != NULL );
17672 val = primal[col->
lppos] / alpha;
17754 assert(
set != NULL);
17755 assert(lp != NULL);
17756 assert(point != NULL);
17757 assert(success != NULL);
17762 if ( timelimit <= 0.0 || iterlimit <= 0 )
17766 assert(lp->
nrows >= 0);
17767 assert(lp->
ncols >= 0);
17768 if( lp->
ncols == 0 )
17773 inclobjcutoff =
FALSE;
17775 SCIPsetDebugMsg(
set,
"Computing relative interior point to current LP.\n");
17778 if( lp->
nrows == 0 && !inclobjcutoff )
17791 retcode =
computeRelIntPoint(lpi,
set, messagehdlr, lp, prob, relaxrows, inclobjcutoff, timelimit, iterlimit, point, success);
static SCIP_RETCODE lpRestoreSolVals(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_Longint validlp)
SCIP_Bool SCIPsetIsUpdateUnreliable(SCIP_SET *set, SCIP_Real newvalue, SCIP_Real oldvalue)
SCIP_Bool SCIProwIsRemovable(SCIP_ROW *row)
enum SCIP_BoundType SCIP_BOUNDTYPE
SCIP_RETCODE SCIPeventfilterCreate(SCIP_EVENTFILTER **eventfilter, BMS_BLKMEM *blkmem)
SCIP_Longint ndualresolvelpiterations
static SCIP_RETCODE computeRelIntPoint(SCIP_LPI *lpi, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_LP *lp, SCIP_PROB *prob, SCIP_Bool relaxrows, SCIP_Bool inclobjcutoff, SCIP_Real timelimit, int iterlimit, SCIP_Real *point, SCIP_Bool *success)
void SCIPcolMarkNotRemovableLocal(SCIP_COL *col, SCIP_STAT *stat)
SCIP_RETCODE SCIPlpGetProvedLowerbound(SCIP_LP *lp, SCIP_SET *set, SCIP_Real *bound)
SCIP_Real SCIProwGetSolFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol)
void SCIPlpInvalidateRootObjval(SCIP_LP *lp)
void SCIPcolGetStrongbranchLast(SCIP_COL *col, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Real *solval, SCIP_Real *lpobjval)
SCIP_RETCODE SCIPlpiGetBInvCol(SCIP_LPI *lpi, int c, SCIP_Real *coef, int *inds, int *ninds)
SCIP_Bool SCIPsolveIsStopped(SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool checknodelimits)
SCIP_RETCODE SCIPlpiGetNRows(SCIP_LPI *lpi, int *nrows)
SCIP_Longint nsbdivinglps
static SCIP_RETCODE lpStoreSolVals(SCIP_LP *lp, SCIP_STAT *stat, BMS_BLKMEM *blkmem)
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsSumGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
static SCIP_RETCODE lpSetBoolpar(SCIP_LP *lp, SCIP_LPPARAM lpparam, SCIP_Bool value, SCIP_Bool *success)
static SCIP_RETCODE lpSetFastmip(SCIP_LP *lp, int fastmip, SCIP_Bool *success)
int SCIProwGetMaxidx(SCIP_ROW *row, SCIP_SET *set)
#define BMSfreeBlockMemoryArrayNull(mem, ptr, num)
static SCIP_RETCODE lpSetDualfeastol(SCIP_LP *lp, SCIP_Real dualfeastol, SCIP_Bool *success)
static SCIP_RETCODE lpUpdateVarProved(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldobj, SCIP_Real oldlb, SCIP_Real oldub, SCIP_Real newobj, SCIP_Real newlb, SCIP_Real newub)
static void colUpdateDelLP(SCIP_COL *col, SCIP_SET *set)
SCIP_RETCODE SCIPeventCreateRowAddedLP(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_ROW *row)
internal methods for managing events
SCIP_RETCODE SCIPlpFreeNorms(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
SCIP_Bool SCIPlpDivingRowsChanged(SCIP_LP *lp)
SCIP_RETCODE SCIPlpiFree(SCIP_LPI **lpi)
static SCIP_RETCODE lpSetFromscratch(SCIP_LP *lp, SCIP_Bool fromscratch, SCIP_Bool *success)
static int SCIProwGetDiscreteScalarProduct(SCIP_ROW *row1, SCIP_ROW *row2)
SCIP_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
int SCIPlpGetNNewrows(SCIP_LP *lp)
SCIP_Bool SCIPsetIsFeasZero(SCIP_SET *set, SCIP_Real val)
internal methods for storing primal CIP solutions
static SCIP_RETCODE lpSetRowrepswitch(SCIP_LP *lp, SCIP_Real rowrepswitch, SCIP_Bool *success)
SCIP_Real SCIProwGetScalarProduct(SCIP_ROW *row1, SCIP_ROW *row2)
SCIP_EVENTFILTER * eventfilter
static SCIP_RETCODE rowScale(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_STAT *stat, SCIP_LP *lp, SCIP_Real scaleval, SCIP_Bool integralcontvars, SCIP_Real minrounddelta, SCIP_Real maxrounddelta)
SCIP_RETCODE SCIPlpUpdateAddVar(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
SCIP_RETCODE SCIPlpiSetState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, const SCIP_LPISTATE *lpistate)
SCIP_Longint nlpiterations
SCIP_Bool SCIPlpDiving(SCIP_LP *lp)
static SCIP_RETCODE colChgCoefPos(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, int pos, SCIP_Real val)
#define BMSfreeMemoryArrayNull(ptr)
SCIP_RETCODE SCIPlpShrinkRows(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, int newnrows)
void SCIPlpSetIsRelax(SCIP_LP *lp, SCIP_Bool relax)
SCIP_Longint validactivitylp
static SCIP_RETCODE colUnlink(SCIP_COL *col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
static SCIP_Bool isNewValueUnreliable(SCIP_SET *set, SCIP_Real newvalue, SCIP_Real oldvalue)
int SCIProwGetAge(SCIP_ROW *row)
static void rowSwapCoefs(SCIP_ROW *row, int pos1, int pos2)
SCIP_SEPA * SCIProwGetOriginSepa(SCIP_ROW *row)
#define SCIP_EVENTTYPE_ROWADDEDLP
SCIP_Longint nnumtroublelpmsgs
SCIP_Real SCIProwGetMinval(SCIP_ROW *row, SCIP_SET *set)
enum SCIP_LPAlgo SCIP_LPALGO
SCIP_RETCODE SCIPlpiSetNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, const SCIP_LPINORMS *lpinorms)
void SCIPlpEndStrongbranchProbing(SCIP_LP *lp)
static SCIP_RETCODE lpCleanupCols(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, int firstcol)
SCIP_RETCODE SCIPlpComputeRelIntPoint(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_LP *lp, SCIP_PROB *prob, SCIP_Bool relaxrows, SCIP_Bool inclobjcutoff, SCIP_Real timelimit, int iterlimit, SCIP_Real *point, SCIP_Bool *success)
static SCIP_Real getFiniteLooseObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
static SCIP_RETCODE lpSetConditionLimit(SCIP_LP *lp, SCIP_Real condlimit, SCIP_Bool *success)
SCIP_RETCODE SCIPeventCreateRowDeletedLP(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_ROW *row)
SCIP_RETCODE SCIPlpiGetDualfarkas(SCIP_LPI *lpi, SCIP_Real *dualfarkas)
static SCIP_RETCODE ensureLpirowsSize(SCIP_LP *lp, SCIP_SET *set, int num)
SCIP_RETCODE SCIPlpFlush(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue)
SCIP_RETCODE SCIPlpGetBInvCol(SCIP_LP *lp, int c, SCIP_Real *coef, int *inds, int *ninds)
SCIP_Real SCIPvarGetUbLazy(SCIP_VAR *var)
SCIP_Real SCIProwGetRelaxFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPcolChgCoef(SCIP_COL *col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_ROW *row, SCIP_Real val)
SCIP_Bool SCIPsetIsFeasEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPlpiStartStrongbranch(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetSol(SCIP_LPI *lpi, SCIP_Real *objval, SCIP_Real *primsol, SCIP_Real *dualsol, SCIP_Real *activity, SCIP_Real *redcost)
static SCIP_RETCODE rowStoreSolVals(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_Bool infeasible)
enum SCIP_BaseStat SCIP_BASESTAT
SCIP_RETCODE SCIPlpRemoveAllObsoletes(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
SCIP_Real SCIProwGetPseudoActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
void SCIPlpSetRootLPIsRelax(SCIP_LP *lp, SCIP_Bool isrelax)
SCIP_Longint activeinlpcounter
SCIP_RETCODE SCIPeventqueueAdd(SCIP_EVENTQUEUE *eventqueue, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENT **event)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_Bool SCIProwIsRedundant(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPlpiSetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int ival)
static SCIP_RETCODE lpFlushAddCols(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue)
SCIP_BASESTAT SCIPcolGetBasisStatus(SCIP_COL *col)
void SCIProwRecalcLPActivity(SCIP_ROW *row, SCIP_STAT *stat)
SCIP_RETCODE SCIPlpiSolvePrimal(SCIP_LPI *lpi)
void SCIPlpRecalculateObjSqrNorm(SCIP_SET *set, SCIP_LP *lp)
enum SCIP_RowOriginType SCIP_ROWORIGINTYPE
internal methods for clocks and timing issues
static void getObjvalDeltaUb(SCIP_SET *set, SCIP_Real obj, SCIP_Real oldub, SCIP_Real newub, SCIP_Real *deltaval, int *deltainf)
SCIP_Real * SCIPcolGetVals(SCIP_COL *col)
SCIP_Longint SCIPcolGetStrongbranchNode(SCIP_COL *col)
SCIP_Bool SCIPsetIsPositive(SCIP_SET *set, SCIP_Real val)
#define debugRowPrint(x, y)
int SCIProwGetNNonz(SCIP_ROW *row)
SCIP_RETCODE SCIPlpiGetBase(SCIP_LPI *lpi, int *cstat, int *rstat)
SCIP_RETCODE SCIPeventfilterDel(SCIP_EVENTFILTER *eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
void SCIProwCapture(SCIP_ROW *row)
SCIP_RETCODE SCIProwChgConstant(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real constant)
static SCIP_RETCODE lpDelColset(SCIP_LP *lp, SCIP_SET *set, int *coldstat)
SCIP_RETCODE SCIPlpGetIterations(SCIP_LP *lp, int *iterations)
SCIP_RETCODE SCIPlpiChgSides(SCIP_LPI *lpi, int nrows, const int *ind, const SCIP_Real *lhs, const SCIP_Real *rhs)
static void adjustLPobjval(SCIP_LP *lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
const char * SCIProwGetName(SCIP_ROW *row)
SCIP_RETCODE SCIPlpiGetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int *ival)
static void rowSortLP(SCIP_ROW *row)
interface methods for specific LP solvers
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
SCIP_RETCODE SCIPlpiGetIterations(SCIP_LPI *lpi, int *iterations)
static void colMoveCoef(SCIP_COL *col, int oldpos, int newpos)
static void rowUpdateAddLP(SCIP_ROW *row)
SCIP_RETCODE SCIPcolChgObj(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newobj)
static void markColDeleted(SCIP_COL *col)
SCIP_Longint SCIProwGetActiveLPCount(SCIP_ROW *row)
SCIP_Real SCIPlpGetGlobalPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
SCIP_RETCODE SCIPlpUpdateVarLb(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldlb, SCIP_Real newlb)
static SCIP_RETCODE lpUpdateVarLoose(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
SCIP_RETCODE SCIProwEnsureSize(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
static void lpNumericalTroubleMessage(SCIP_MESSAGEHDLR *messagehdlr, SCIP_SET *set, SCIP_STAT *stat, SCIP_VERBLEVEL verblevel, const char *formatstr,...)
unsigned int nonlprowssorted
SCIP_RETCODE SCIPlpFreeState(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
static void colSwapCoefs(SCIP_COL *col, int pos1, int pos2)
#define SCIP_EVENTTYPE_ROWSIDECHANGED
#define SCIP_EVENTTYPE_ROWCHANGED
int SCIProwGetNLPNonz(SCIP_ROW *row)
#define debugColPrint(x, y)
SCIP_RETCODE SCIPcolCreate(SCIP_COL **col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, int len, SCIP_ROW **rows, SCIP_Real *vals, SCIP_Bool removable)
static const int nscalars
void SCIPswapPointers(void **pointer1, void **pointer2)
void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)
enum SCIP_ClockType SCIP_CLOCKTYPE
SCIP_RETCODE SCIPlpUpdateVarLbGlobal(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldlb, SCIP_Real newlb)
SCIP_Real SCIProwGetLhs(SCIP_ROW *row)
void SCIPsortIntPtrIntReal(int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, int len)
void SCIPintervalMul(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)
SCIP_RETCODE SCIPlpWrite(SCIP_LP *lp, const char *fname)
SCIP_Bool SCIPlpIsSolBasic(SCIP_LP *lp)
static SCIP_RETCODE ensureLazycolsSize(SCIP_LP *lp, SCIP_SET *set, int num)
SCIP_RETCODE SCIPlpUpdateVarUbGlobal(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldub, SCIP_Real newub)
SCIP_Bool SCIPsetIsFeasIntegral(SCIP_SET *set, SCIP_Real val)
static void recomputeLooseObjectiveValue(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
SCIP_Bool SCIPcolIsIntegral(SCIP_COL *col)
static SCIP_RETCODE insertColChgcols(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp)
SCIP_Real SCIPcolGetUb(SCIP_COL *col)
static SCIP_RETCODE colAddCoef(SCIP_COL *col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_ROW *row, SCIP_Real val, int linkpos)
SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)
struct SCIP_LPiNorms SCIP_LPINORMS
void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)
SCIP_BASESTAT SCIProwGetBasisStatus(SCIP_ROW *row)
SCIP_Real SCIPcolGetObj(SCIP_COL *col)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)
SCIP_RETCODE SCIPlpIsInfeasibilityProved(SCIP_LP *lp, SCIP_SET *set, SCIP_Bool *proved)
static SCIP_RETCODE lpFlushAddRows(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue)
enum SCIP_Retcode SCIP_RETCODE
static SCIP_RETCODE lpSetBarrierconvtol(SCIP_LP *lp, SCIP_Real barrierconvtol, SCIP_Bool *success)
SCIP_Real SCIProwGetLPEfficacy(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
SCIP_RETCODE SCIPlpGetState(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
SCIP_RETCODE SCIPlpiSetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real dval)
SCIP_Real SCIPlpGetRootColumnObjval(SCIP_LP *lp)
void SCIPlpStartStrongbranchProbing(SCIP_LP *lp)
#define SCIPsetAllocBufferArray(set, ptr, num)
#define BMSfreeBlockMemoryNull(mem, ptr)
SCIP_Bool SCIPlpiHasPrimalRay(SCIP_LPI *lpi)
static SCIP_RETCODE lpCheckIntpar(SCIP_LP *lp, SCIP_LPPARAM lpparam, int value)
SCIP_RETCODE SCIProwChgCoef(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_COL *col, SCIP_Real val)
int SCIPvarGetProbindex(SCIP_VAR *var)
SCIP_RETCODE SCIPlpiGetNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
enum SCIP_VerbLevel SCIP_VERBLEVEL
#define DIVESTACKGROWFACT
int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)
int SCIPcolGetLPDepth(SCIP_COL *col)
void SCIPintervalSetBounds(SCIP_INTERVAL *resultant, SCIP_Real inf, SCIP_Real sup)
enum SCIP_LPParam SCIP_LPPARAM
SCIP_RETCODE SCIPlpRemoveNewObsoletes(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
SCIP_Real SCIPsetRound(SCIP_SET *set, SCIP_Real val)
static SCIP_RETCODE lpSetLPInfo(SCIP_LP *lp, SCIP_Bool lpinfo)
static void freeDiveChgSideArrays(SCIP_LP *lp)
SCIP_RETCODE SCIPlpiGetNCols(SCIP_LPI *lpi, int *ncols)
#define BMSallocMemoryArray(ptr, num)
SCIP_Real SCIProwGetNLPEfficacy(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
static void rowAddNorms(SCIP_ROW *row, SCIP_SET *set, SCIP_COL *col, SCIP_Real val, SCIP_Bool updateidxvals)
SCIP_RETCODE SCIPlpEndDive(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_VAR **vars, int nvars)
SCIP_RETCODE SCIProwMakeIntegral(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_STAT *stat, SCIP_LP *lp, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Bool usecontvars, SCIP_Bool *success)
SCIP_Real relpseudoobjval
static SCIP_RETCODE lpSetPresolving(SCIP_LP *lp, SCIP_Bool presolving, SCIP_Bool *success)
SCIP_RETCODE SCIPlpSolveAndEval(SCIP_LP *lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_Longint itlim, SCIP_Bool limitresolveiters, SCIP_Bool aging, SCIP_Bool keepsol, SCIP_Bool *lperror)
SCIP_CLOCK * barrierlptime
static SCIP_RETCODE updateLazyBounds(SCIP_LP *lp, SCIP_SET *set)
SCIP_ROW ** SCIPlpGetRows(SCIP_LP *lp)
static SCIP_RETCODE lpFlushDelCols(SCIP_LP *lp)
static void lpUpdateObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real deltaval, int deltainf, SCIP_Bool local, SCIP_Bool loose, SCIP_Bool global)
SCIP_Real SCIPlpGetPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
SCIP_Real rootlooseobjval
SCIP_RETCODE SCIPlpiGetBounds(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *lbs, SCIP_Real *ubs)
SCIP_RETCODE SCIPcolIncCoef(SCIP_COL *col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_ROW *row, SCIP_Real incval)
SCIP_RETCODE SCIPlpCleanupAll(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_Bool root)
SCIP_RETCODE SCIPcolDelCoef(SCIP_COL *col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_ROW *row)
SCIP_Real SCIPlpGetCutoffbound(SCIP_LP *lp)
SCIP_RETCODE SCIProwCreate(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_ROWORIGINTYPE origintype, void *origin, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
SCIP_RETCODE SCIPlpUpdateAges(SCIP_LP *lp, SCIP_STAT *stat)
static SCIP_RETCODE colStoreSolVals(SCIP_COL *col, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPlpSetNorms(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPINORMS *lpinorms)
static int colSearchCoef(SCIP_COL *col, const SCIP_ROW *row)
#define SCIP_EVENTTYPE_ROWDELETEDLP
SCIP_Bool SCIPsetIsNegative(SCIP_SET *set, SCIP_Real val)
SCIP_ROWORIGINTYPE SCIProwGetOrigintype(SCIP_ROW *row)
static SCIP_RETCODE lpSetPricing(SCIP_LP *lp, SCIP_PRICING pricing)
static void rowSortNonLP(SCIP_ROW *row)
static SCIP_RETCODE ensureChgcolsSize(SCIP_LP *lp, SCIP_SET *set, int num)
#define SCIPsetFreeBufferArray(set, ptr)
enum SCIP_LPSolStat SCIP_LPSOLSTAT
#define BMSfreeMemory(ptr)
SCIP_RETCODE SCIPlpEndProbing(SCIP_LP *lp)
SCIP_RETCODE SCIPlpiSetIntegralityInformation(SCIP_LPI *lpi, int ncols, int *intInfo)
static SCIP_RETCODE lpSetRealpar(SCIP_LP *lp, SCIP_LPPARAM lpparam, SCIP_Real value, SCIP_Bool *success)
SCIP_Real SCIPsetSumFloor(SCIP_SET *set, SCIP_Real val)
static SCIP_RETCODE reallocDiveChgSideArrays(SCIP_LP *lp, int minsize, SCIP_Real growfact)
enum SCIP_Pricing SCIP_PRICING
SCIP_Bool flushdeletedcols
SCIP_RETCODE SCIProwIncCoef(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_COL *col, SCIP_Real incval)
SCIP_Real SCIProwGetDualsol(SCIP_ROW *row)
static SCIP_RETCODE lpAlgorithm(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_LPALGO lpalgo, SCIP_Bool resolve, SCIP_Bool keepsol, SCIP_Bool *timelimit, SCIP_Bool *lperror)
unsigned int lprowssorted
SCIP_LPSOLSTAT SCIPlpGetSolstat(SCIP_LP *lp)
#define SCIPstatIncrement(stat, set, field)
SCIP_Longint SCIPcolGetStrongbranchLPAge(SCIP_COL *col, SCIP_STAT *stat)
internal methods for LP management
SCIP_RETCODE SCIPlpiCreate(SCIP_LPI **lpi, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_OBJSEN objsen)
static SCIP_RETCODE lpUpdateVarColumnProved(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
static void recomputeGlbPseudoObjectiveValue(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
SCIP_RETCODE SCIPlpiGetBInvARow(SCIP_LPI *lpi, int r, const SCIP_Real *binvrow, SCIP_Real *coef, int *inds, int *ninds)
SCIP_Bool SCIPlpIsRootLPRelax(SCIP_LP *lp)
SCIP_Bool objsqrnormunreliable
SCIP_RETCODE SCIPlpRecordOldRowSideDive(SCIP_LP *lp, SCIP_ROW *row, SCIP_SIDETYPE sidetype)
SCIP_Bool divelpwasdualfeas
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_Bool strongbranching
SCIP_Real SCIPsolGetVal(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var)
int SCIPlpGetNCols(SCIP_LP *lp)
static void checkLazyBounds(SCIP_LP *lp, SCIP_SET *set)
#define SCIP_DEFAULT_EPSILON
static SCIP_RETCODE lpSolveStable(SCIP_LP *lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LPALGO lpalgo, int itlim, int harditlim, SCIP_Bool resolve, int fastmip, SCIP_Bool tightprimfeastol, SCIP_Bool tightdualfeastol, SCIP_Bool fromscratch, SCIP_Bool keepsol, SCIP_Bool *timelimit, SCIP_Bool *lperror)
SCIP_Bool SCIPsetIsGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
int SCIPlpiGetInternalStatus(SCIP_LPI *lpi)
SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)
SCIP_Bool SCIPsetIsEfficacious(SCIP_SET *set, SCIP_Bool root, SCIP_Real efficacy)
static SCIP_RETCODE colLink(SCIP_COL *col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_Bool SCIPrealToRational(SCIP_Real val, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Longint *nominator, SCIP_Longint *denominator)
SCIP_RETCODE SCIPrealarrayIncVal(SCIP_REALARRAY *realarray, int arraygrowinit, SCIP_Real arraygrowfac, int idx, SCIP_Real incval)
SCIP_RETCODE SCIPlpiSolveDual(SCIP_LPI *lpi)
static void rowDelNorms(SCIP_ROW *row, SCIP_SET *set, SCIP_COL *col, SCIP_Real val, SCIP_Bool forcenormupdate, SCIP_Bool updateindex, SCIP_Bool updateval)
SCIP_Bool SCIPlpiIsStable(SCIP_LPI *lpi)
SCIP_Real SCIPlpGetRootObjval(SCIP_LP *lp)
SCIP_Real SCIPcolCalcRedcost(SCIP_COL *col, SCIP_Real *dualsol)
static void rowCalcIdxsAndVals(SCIP_ROW *row, SCIP_SET *set)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
void SCIProwForceSort(SCIP_ROW *row, SCIP_SET *set)
SCIP_Bool SCIPsetIsLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPlpCleanupNew(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_Bool root)
SCIP_Bool SCIPsetIsSumLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
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 SCIPlpSetState(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LPISTATE *lpistate, SCIP_Bool wasprimfeas, SCIP_Bool wasprimchecked, SCIP_Bool wasdualfeas, SCIP_Bool wasdualchecked)
SCIP_RETCODE SCIProwCatchEvent(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_RETCODE SCIPlpiWriteLP(SCIP_LPI *lpi, const char *fname)
SCIP_Real lpibarrierconvtol
SCIP_RETCODE SCIPcolAddCoef(SCIP_COL *col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_ROW *row, SCIP_Real val)
int SCIPlpGetNNewcols(SCIP_LP *lp)
SCIP_RETCODE SCIPlpUpdateVarUb(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldub, SCIP_Real newub)
SCIP_Real SCIProwGetSumNorm(SCIP_ROW *row)
#define BMSduplicateBlockMemoryArray(mem, ptr, source, num)
static SCIP_RETCODE rowUnlink(SCIP_ROW *row, SCIP_SET *set, SCIP_LP *lp)
static SCIP_RETCODE lpUpdateVarLooseProved(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
static SCIP_RETCODE colRestoreSolVals(SCIP_COL *col, BMS_BLKMEM *blkmem, SCIP_Longint validlp, SCIP_Bool freebuffer)
SCIP_RETCODE SCIPlpStartDive(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
SCIP_Real SCIPcolGetPrimsol(SCIP_COL *col)
int SCIProwGetMinidx(SCIP_ROW *row, SCIP_SET *set)
SCIP_RETCODE SCIPlpStartProbing(SCIP_LP *lp)
SCIP_RETCODE SCIProwChgLhs(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real lhs)
void SCIProwSort(SCIP_ROW *row)
SCIP_Real lpirowrepswitch
static SCIP_RETCODE lpFlushDelRows(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set)
SCIP_RETCODE SCIPeventfilterAdd(SCIP_EVENTFILTER *eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_RETCODE SCIPlpWriteMip(SCIP_LP *lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *fname, SCIP_Bool genericnames, SCIP_Bool origobj, SCIP_OBJSENSE objsense, SCIP_Real objscale, SCIP_Real objoffset, SCIP_Bool lazyconss)
SCIP_Bool divelpwasdualchecked
SCIP_Bool SCIPlpIsPrimalReliable(SCIP_LP *lp)
SCIP_BOUNDTYPE SCIPboundtypeOpposite(SCIP_BOUNDTYPE boundtype)
internal methods for storing and manipulating the main problem
static SCIP_Bool isIntegralScalar(SCIP_Real val, SCIP_Real scalar, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Real *intval)
SCIP_Real SCIPsetLpfeastol(SCIP_SET *set)
void SCIPmessagePrintVerbInfo(SCIP_MESSAGEHDLR *messagehdlr, SCIP_VERBLEVEL verblevel, SCIP_VERBLEVEL msgverblevel, const char *formatstr,...)
static SCIP_RETCODE lpSetSolutionPolishing(SCIP_LP *lp, SCIP_Bool polishing, SCIP_Bool *success)
void SCIPlpDecNLoosevars(SCIP_LP *lp)
interval arithmetics for provable bounds
SCIP_Bool SCIPlpIsDualReliable(SCIP_LP *lp)
void SCIPsortPtrRealInt(void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
SCIP_ROW ** SCIPcolGetRows(SCIP_COL *col)
SCIP_RETCODE SCIPlpiGetBasisInd(SCIP_LPI *lpi, int *bind)
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 SCIPlpAddCol(SCIP_LP *lp, SCIP_SET *set, SCIP_COL *col, int depth)
SCIP_Real SCIPintervalGetInf(SCIP_INTERVAL interval)
static void colSortNonLP(SCIP_COL *col)
SCIP_RETCODE SCIPlpShrinkCols(SCIP_LP *lp, SCIP_SET *set, int newncols)
SCIP_COL ** SCIPlpGetCols(SCIP_LP *lp)
SCIP_Bool SCIProwIsLocal(SCIP_ROW *row)
static SCIP_Real colCalcInternalFarkasCoef(SCIP_COL *col)
SCIPInterval sqrt(const SCIPInterval &x)
SCIP_RETCODE SCIPlpiFreeState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
static SCIP_RETCODE lpCleanupRows(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, int firstrow)
static SCIP_RETCODE lpCopyIntegrality(SCIP_LP *lp, SCIP_SET *set)
SCIP_RETCODE SCIProwChgLocal(SCIP_ROW *row, SCIP_Bool local)
SCIP_Longint validfarkaslp
SCIP_RETCODE SCIPlpSumRows(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob, SCIP_Real *weights, SCIP_REALARRAY *sumcoef, SCIP_Real *sumlhs, SCIP_Real *sumrhs)
SCIP_Longint validactivitybdsdomchg
SCIP_Bool SCIPlpiIsPrimalInfeasible(SCIP_LPI *lpi)
void SCIPlpMarkSize(SCIP_LP *lp)
SCIP_Real SCIPsetBarrierconvtol(SCIP_SET *set)
SCIP_Real SCIPcolGetLb(SCIP_COL *col)
#define SCIP_EVENTTYPE_ROWCONSTCHANGED
struct SCIP_EventData SCIP_EVENTDATA
const char * SCIPvarGetName(SCIP_VAR *var)
static SCIP_RETCODE rowAddCoef(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_COL *col, SCIP_Real val, int linkpos)
SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)
SCIP_Bool SCIProwIsIntegral(SCIP_ROW *row)
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)
struct SCIP_LPiState SCIP_LPISTATE
void SCIPmessagePrintWarning(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)
SCIP_Real SCIProwGetNLPFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPlpGetUnboundedSol(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool *primalfeasible, SCIP_Bool *rayfeasible)
void SCIProwDelaySort(SCIP_ROW *row)
SCIP_Real SCIProwGetPseudoFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPlpAddRow(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_ROW *row, int depth)
internal miscellaneous methods
SCIP_CONSHDLR * SCIProwGetOriginCons(SCIP_ROW *row)
static SCIP_RETCODE lpPrimalSimplex(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool resolve, SCIP_Bool keepsol, SCIP_Bool *lperror)
SCIP_Real SCIPlpGetObjNorm(SCIP_LP *lp)
SCIP_Longint nprimalresolvelpiterations
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_LPSOLVALS * storedsolvals
static SCIP_RETCODE lpSetFeastol(SCIP_LP *lp, SCIP_Real feastol, SCIP_Bool *success)
SCIP_RETCODE SCIPlpGetDualfarkas(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat)
internal methods for global SCIP settings
SCIP_Bool SCIPsetIsFeasGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPvarGetLbLazy(SCIP_VAR *var)
static void rowCalcActivityBounds(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPlpiGetSolFeasibility(SCIP_LPI *lpi, SCIP_Bool *primalfeasible, SCIP_Bool *dualfeasible)
int SCIPlpGetNRows(SCIP_LP *lp)
void SCIPmessagePrintInfo(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)
SCIP_Longint nlpsaftercreation
void SCIPlpMarkDivingObjChanged(SCIP_LP *lp)
SCIP_Longint nduallpiterations
#define SCIPstatAdd(stat, set, field, val)
void SCIPintervalSet(SCIP_INTERVAL *resultant, SCIP_Real value)
SCIP_Real SCIProwGetRhs(SCIP_ROW *row)
static SCIP_RETCODE lpFlushChgCols(SCIP_LP *lp, SCIP_SET *set)
#define MAXNUMTROUBLELPMSGS
SCIP_RETCODE SCIPlpiFreeNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
SCIP_RETCODE SCIPlpiDelRows(SCIP_LPI *lpi, int firstrow, int lastrow)
SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
#define lpCutoffDisabled(set)
SCIP_LPI * SCIPlpGetLPI(SCIP_LP *lp)
SCIP_Real SCIPlpGetObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
void SCIProwPrint(SCIP_ROW *row, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
static SCIP_RETCODE rowLink(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_Bool SCIProwIsModifiable(SCIP_ROW *row)
static SCIP_RETCODE colDelCoefPos(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, int pos)
SCIP_Real glbpseudoobjval
SCIP_Bool SCIPsetIsFeasLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_COL ** SCIProwGetCols(SCIP_ROW *row)
SCIP_Bool SCIProwIsSolEfficacious(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol, SCIP_Bool root)
SCIP_Longint nprimalresolvelps
SCIP_SIDETYPE * divechgsidetypes
static SCIP_RETCODE rowSideChanged(SCIP_ROW *row, SCIP_SET *set, SCIP_LP *lp, SCIP_SIDETYPE sidetype)
SCIP_RETCODE SCIPlpStartStrongbranch(SCIP_LP *lp)
int SCIProwGetNumIntCols(SCIP_ROW *row, SCIP_SET *set)
SCIP_CLOCK * divinglptime
static SCIP_RETCODE rowEventSideChanged(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_SIDETYPE side, SCIP_Real oldval, SCIP_Real newval)
static SCIP_RETCODE allocDiveChgSideArrays(SCIP_LP *lp, int initsize)
static void colUpdateAddLP(SCIP_COL *col, SCIP_SET *set)
SCIP_RETCODE SCIProwRelease(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)
static SCIP_RETCODE lpSolve(SCIP_LP *lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LPALGO lpalgo, int resolveitlim, int harditlim, SCIP_Bool needprimalray, SCIP_Bool needdualray, SCIP_Bool resolve, int fastmip, SCIP_Bool tightprimfeastol, SCIP_Bool tightdualfeastol, SCIP_Bool fromscratch, SCIP_Bool keepsol, SCIP_Bool *lperror)
SCIP_Real SCIProwGetSolActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol)
int SCIPcolGetIndex(SCIP_COL *col)
#define BMSfreeBlockMemory(mem, ptr)
internal methods for problem variables
SCIP_Bool SCIPlpiExistsPrimalRay(SCIP_LPI *lpi)
static void computeLPBounds(SCIP_LP *lp, SCIP_SET *set, SCIP_COL *col, SCIP_Real lpiinf, SCIP_Real *lb, SCIP_Real *ub)
SCIP_RETCODE SCIPlpGetBasisInd(SCIP_LP *lp, int *basisind)
SCIP_Bool SCIPsetIsIntegral(SCIP_SET *set, SCIP_Real val)
SCIP_RETCODE SCIPlpiGetObjval(SCIP_LPI *lpi, SCIP_Real *objval)
SCIP_Real * SCIProwGetVals(SCIP_ROW *row)
SCIP_RETCODE SCIPlpiDelRowset(SCIP_LPI *lpi, int *dstat)
SCIP_Real SCIPlpGetRootLooseObjval(SCIP_LP *lp)
SCIP_RETCODE SCIPlpClear(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
void SCIPlpRecomputeLocalAndGlobalPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
SCIP_Bool SCIPlpiHasStateBasis(SCIP_LPI *lpi, SCIP_LPISTATE *lpistate)
SCIP_RETCODE SCIPlpiDelCols(SCIP_LPI *lpi, int firstcol, int lastcol)
SCIP_Real SCIPsetSumepsilon(SCIP_SET *set)
SCIP_Longint ndualresolvelps
#define BMSallocBlockMemoryArray(mem, ptr, num)
static void recomputePseudoObjectiveValue(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
SCIP_Real SCIPlpiInfinity(SCIP_LPI *lpi)
void SCIPprintSysError(const char *message)
static SCIP_RETCODE lpDelRowset(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, int *rowdstat)
enum SCIP_Objsense SCIP_OBJSENSE
SCIP_RETCODE SCIPlpFree(SCIP_LP **lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
SCIP_Real SCIPcolGetBestBound(SCIP_COL *col)
SCIP_Bool SCIPlpiIsDualFeasible(SCIP_LPI *lpi)
static void rowMerge(SCIP_ROW *row, SCIP_SET *set)
#define SCIP_EVENTTYPE_ROWCOEFCHANGED
static SCIP_Real colCalcInternalRedcost(SCIP_COL *col)
SCIP_RETCODE SCIPeventCreateRowSideChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_ROW *row, SCIP_SIDETYPE side, SCIP_Real oldval, SCIP_Real newval)
SCIP_RETCODE SCIPlpiGetState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
SCIP_ROW ** SCIPlpGetNewrows(SCIP_LP *lp)
SCIP_Real SCIPvarGetNLPSol(SCIP_VAR *var)
SCIP_Longint validfarkaslp
static SCIP_RETCODE ensureRowsSize(SCIP_LP *lp, SCIP_SET *set, int num)
SCIP_RETCODE SCIPlpGetBInvRow(SCIP_LP *lp, int r, SCIP_Real *coef, int *inds, int *ninds)
#define BMSfreeBlockMemoryArray(mem, ptr, num)
SCIP_Bool SCIPlpDivingObjChanged(SCIP_LP *lp)
SCIP_RETCODE SCIPcolChgLb(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newlb)
static int colSearchCoefPart(SCIP_COL *col, const SCIP_ROW *row, int minpos, int maxpos)
SCIP_Bool updateintegrality
SCIP_Real SCIPvarGetUnchangedObj(SCIP_VAR *var)
#define DIVESTACKINITSIZE
SCIP_Bool lpihaspolishing
void SCIPcolSetStrongbranchData(SCIP_COL *col, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_Real lpobjval, SCIP_Real primsol, SCIP_Real sbdown, SCIP_Real sbup, SCIP_Bool sbdownvalid, SCIP_Bool sbupvalid, SCIP_Longint iter, int itlim)
SCIP_Bool SCIPcolIsRemovable(SCIP_COL *col)
static SCIP_RETCODE rowDelCoefPos(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, int pos)
SCIP_Bool SCIPprobAllColsInLP(SCIP_PROB *prob, SCIP_SET *set, SCIP_LP *lp)
SCIP_Bool divelpwasprimchecked
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
void SCIPintervalAdd(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)
SCIP_RETCODE SCIProwDelCoef(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_COL *col)
SCIP_RETCODE SCIPlpCreate(SCIP_LP **lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, const char *name)
SCIP_RETCODE SCIPlpGetBase(SCIP_LP *lp, int *cstat, int *rstat)
unsigned int lpcolssorted
SCIP_Bool divinglazyapplied
SCIP_RETCODE SCIPsetSetCharParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, char value)
void SCIPlpSetSizeMark(SCIP_LP *lp, int nrows, int ncols)
SCIP_Real SCIProwGetDualfarkas(SCIP_ROW *row)
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
static void colSortLP(SCIP_COL *col)
SCIP_Real SCIPvarGetRelaxSol(SCIP_VAR *var, SCIP_SET *set)
SCIP_Real SCIProwGetSolEfficacy(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol)
SCIP_Real SCIProwGetRelaxEfficacy(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
static SCIP_RETCODE ensureColsSize(SCIP_LP *lp, SCIP_SET *set, int num)
SCIP_RETCODE SCIPlpRemoveRedundantRows(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
SCIP_Bool SCIPsetIsFeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPlpiIsOptimal(SCIP_LPI *lpi)
SCIP_Bool SCIPsetIsSumEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Longint validredcostlp
SCIP_RETCODE SCIPcolChgUb(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newub)
static int rowSearchCoef(SCIP_ROW *row, const SCIP_COL *col)
SCIP_LPISTATE * divelpistate
SCIP_RETCODE SCIPlpGetNorms(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
SCIP_RETCODE SCIPsetGetCharParam(SCIP_SET *set, const char *name, char *value)
SCIP_RETCODE SCIProwDropEvent(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_RETCODE SCIPcolFree(SCIP_COL **col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
void SCIPcolPrint(SCIP_COL *col, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
static int lpGetResolveItlim(SCIP_SET *set, SCIP_STAT *stat, int itlim)
static int rowSearchCoefPart(SCIP_ROW *row, const SCIP_COL *col, int minpos, int maxpos)
SCIP_RETCODE SCIPeventCreateRowCoefChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_ROW *row, SCIP_COL *col, SCIP_Real oldval, SCIP_Real newval)
int SCIProwGetRank(SCIP_ROW *row)
static void getObjvalDeltaObj(SCIP_SET *set, SCIP_Real oldobj, SCIP_Real newobj, SCIP_Real lb, SCIP_Real ub, SCIP_Real *deltaval, int *deltainf)
SCIP_CLOCK * lexduallptime
SCIP_Real SCIPcolGetMinPrimsol(SCIP_COL *col)
SCIP_RETCODE SCIPlpiChgBounds(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *lb, const SCIP_Real *ub)
SCIP_RETCODE SCIPlpReset(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
SCIP_RETCODE SCIPcolGetStrongbranches(SCIP_COL **cols, int ncols, SCIP_Bool integral, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LP *lp, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *lperror)
void SCIProwLock(SCIP_ROW *row)
SCIP_Bool SCIPsetIsDualfeasPositive(SCIP_SET *set, SCIP_Real val)
SCIP_Real SCIProwGetMaxActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
static void getObjvalDeltaLb(SCIP_SET *set, SCIP_Real obj, SCIP_Real oldlb, SCIP_Real newlb, SCIP_Real *deltaval, int *deltainf)
static SCIP_RETCODE lpBarrier(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool crossover, SCIP_Bool keepsol, SCIP_Bool *lperror)
SCIP_Longint nrootlpiterations
SCIP_Bool SCIPlpiIsTimelimExc(SCIP_LPI *lpi)
SCIP_Real SCIProwGetParallelism(SCIP_ROW *row1, SCIP_ROW *row2, char orthofunc)
#define checkRowObjprod(row)
SCIP_Real SCIPlpGetLooseObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
static SCIP_RETCODE provedBound(SCIP_LP *lp, SCIP_SET *set, SCIP_Bool usefarkas, SCIP_Real *bound)
static void markRowDeleted(SCIP_ROW *row)
SCIP_Real SCIPlpGetModifiedPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype)
static SCIP_RETCODE rowRestoreSolVals(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_Longint validlp, SCIP_Bool freebuffer, SCIP_Bool infeasible)
static SCIP_RETCODE lpCheckRealpar(SCIP_LP *lp, SCIP_LPPARAM lpparam, SCIP_Real value)
SCIP_CLOCK * strongbranchtime
static SCIP_RETCODE rowEventCoefChanged(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_COL *col, SCIP_Real oldval, SCIP_Real newval)
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_Real relglbpseudoobjval
SCIP_Real SCIProwGetConstant(SCIP_ROW *row)
static SCIP_RETCODE lpRemoveObsoleteCols(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, int firstcol)
void SCIPlpStoreRootObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
SCIP_RETCODE SCIPlpiSolveBarrier(SCIP_LPI *lpi, SCIP_Bool crossover)
int SCIPcolGetNNonz(SCIP_COL *col)
SCIP_Bool SCIProwIsLPEfficacious(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_Bool root)
SCIP_Longint validpsactivitydomchg
SCIP_COLSOLVALS * storedsolvals
SCIP_Real SCIProwGetMinActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPlpiGetPrimalRay(SCIP_LPI *lpi, SCIP_Real *ray)
SCIP_Bool strongbranchprobing
SCIP_RETCODE SCIPlpiEndStrongbranch(SCIP_LPI *lpi)
SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)
static void rowUpdateDelLP(SCIP_ROW *row)
SCIP_RETCODE SCIPlpSetCutoffbound(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob, SCIP_Real cutoffbound)
static const SCIP_Real scalars[]
static SCIP_RETCODE lpSetObjlim(SCIP_LP *lp, SCIP_SET *set, SCIP_Real objlim)
internal methods for main solving loop and node processing
void SCIPmessageVFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr, va_list ap)
SCIP_ROWSOLVALS * storedsolvals
void SCIProwChgRank(SCIP_ROW *row, int rank)
SCIP_RETCODE SCIPlpMarkFlushed(SCIP_LP *lp, SCIP_SET *set)
static void coefChanged(SCIP_ROW *row, SCIP_COL *col, SCIP_LP *lp)
SCIP_RETCODE SCIPlpiGetSides(SCIP_LPI *lpi, int firstrow, int lastrow, SCIP_Real *lhss, SCIP_Real *rhss)
SCIP_RETCODE SCIPeventfilterFree(SCIP_EVENTFILTER **eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set)
#define SCIP_EVENTTYPE_FORMAT
static SCIP_RETCODE lpFlushChgRows(SCIP_LP *lp, SCIP_SET *set)
SCIP_CLOCK * primallptime
SCIP_RETCODE SCIPlpUpdateVarObj(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldobj, SCIP_Real newobj)
SCIP_Real SCIPsetSumCeil(SCIP_SET *set, SCIP_Real val)
#define BMSfreeMemoryNull(ptr)
SCIP_Bool SCIPlpiHasDualRay(SCIP_LPI *lpi)
unsigned int inglobalcutpool
#define checkRowSqrnorm(row)
static SCIP_RETCODE lpRemoveObsoleteRows(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, int firstrow)
#define SCIP_DEFAULT_SUMEPSILON
static SCIP_RETCODE lpUpdateVarColumn(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
static SCIP_RETCODE ensureChgrowsSize(SCIP_LP *lp, SCIP_SET *set, int num)
public methods for message output
SCIP_RETCODE SCIPlpiGetBInvACol(SCIP_LPI *lpi, int c, SCIP_Real *coef, int *inds, int *ninds)
static void rowCalcNorms(SCIP_ROW *row, SCIP_SET *set)
SCIP_Bool divelpwasprimfeas
#define SCIPstatUpdate(stat, set, field, val)
void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)
SCIP_Real SCIProwGetLPFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
SCIP_Bool SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPlpiGetObj(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *vals)
int SCIPcolGetNStrongbranchs(SCIP_COL *col)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_Bool SCIPlpiIsObjlimExc(SCIP_LPI *lpi)
int SCIProwGetLPPos(SCIP_ROW *row)
SCIP_Longint divenolddomchgs
SCIP_RETCODE SCIPcolGetStrongbranch(SCIP_COL *col, SCIP_Bool integral, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LP *lp, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *lperror)
internal methods for problem statistics
SCIP_Bool SCIPlpiIsPrimalFeasible(SCIP_LPI *lpi)
SCIP_Bool SCIPlpIsSolved(SCIP_LP *lp)
SCIP_Real SCIProwGetObjParallelism(SCIP_ROW *row, SCIP_SET *set, SCIP_LP *lp)
SCIP_Bool SCIPsetIsFeasPositive(SCIP_SET *set, SCIP_Real val)
SCIP_RETCODE SCIPrealarrayExtend(SCIP_REALARRAY *realarray, int arraygrowinit, SCIP_Real arraygrowfac, int minidx, int maxidx)
SCIP_Real SCIPsetDualfeastol(SCIP_SET *set)
#define SCIPsetDebugMsgPrint
SCIP_Real SCIPcolGetFarkasValue(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)
#define BMSallocMemory(ptr)
SCIP_RETCODE SCIPlpUpdateVarLoose(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
#define BMSreallocMemoryArray(ptr, num)
SCIP_RETCODE SCIProwChgRhs(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real rhs)
SCIP_Bool SCIPlpIsRelax(SCIP_LP *lp)
SCIP_BOUNDTYPE SCIPvarGetBestBoundType(SCIP_VAR *var)
SCIP_Bool SCIPsetIsDualfeasZero(SCIP_SET *set, SCIP_Real val)
static const char * lpalgoName(SCIP_LPALGO lpalgo)
static SCIP_RETCODE lpSetPricingChar(SCIP_LP *lp, char pricingchar)
int SCIProwGetLPDepth(SCIP_ROW *row)
SCIP_RETCODE SCIPlpGetPrimalRay(SCIP_LP *lp, SCIP_SET *set, SCIP_Real *ray)
SCIP_Longint nprimallpiterations
static SCIP_RETCODE lpSetIterationLimit(SCIP_LP *lp, int itlim)
SCIP_RETCODE SCIProwCalcIntegralScalar(SCIP_ROW *row, SCIP_SET *set, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Bool usecontvars, SCIP_Real *intscalar, SCIP_Bool *success)
SCIP_Bool lpisolutionpolishing
SCIP_Bool SCIPsetIsFeasGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPlpGetBInvARow(SCIP_LP *lp, int r, SCIP_Real *binvrow, SCIP_Real *coef, int *inds, int *ninds)
void SCIProwMarkNotRemovableLocal(SCIP_ROW *row, SCIP_STAT *stat)
int SCIPsetInitializeRandomSeed(SCIP_SET *set, int initialseedvalue)
SCIP_RETCODE SCIPlpiChgObj(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *obj)
int SCIProwGetIndex(SCIP_ROW *row)
void SCIPintervalSub(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)
static SCIP_RETCODE colEnsureSize(SCIP_COL *col, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
SCIP_Real SCIProwGetMaxval(SCIP_ROW *row, SCIP_SET *set)
SCIP_Real SCIPcolGetFarkasCoef(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)
SCIP_Real SCIProwGetLPActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
static SCIP_RETCODE lpSetScaling(SCIP_LP *lp, int scaling, SCIP_Bool *success)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
#define BMSallocBlockMemory(mem, ptr)
SCIP_Bool SCIPlpiIsIterlimExc(SCIP_LPI *lpi)
SCIP_Bool SCIPsetIsDualfeasNegative(SCIP_SET *set, SCIP_Real val)
void SCIPcolSort(SCIP_COL *col)
SCIP_Real SCIPcolGetFeasibility(SCIP_COL *col, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
SCIP_Longint obsoletenode
SCIP_DECL_SORTPTRCOMP(SCIProwComp)
#define BMSclearMemoryArray(ptr, num)
SCIP_RETCODE SCIPlpGetBInvACol(SCIP_LP *lp, int c, SCIP_Real *coef, int *inds, int *ninds)
SCIP_RETCODE SCIPlpUpdateVarColumn(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
SCIP_Longint obsoletenode
common defines and data types used in all packages of SCIP
SCIP_Real SCIPlpGetModifiedProvedPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype)
static SCIP_Real getFinitePseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
struct BMS_BlkMem BMS_BLKMEM
void SCIPcolInvalidateStrongbranchData(SCIP_COL *col, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
SCIP_RETCODE SCIPlpUpdateDelVar(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
static SCIP_RETCODE rowEventConstantChanged(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_Real oldval, SCIP_Real newval)
static SCIP_RETCODE lpSetRandomseed(SCIP_LP *lp, int randomseed, SCIP_Bool *success)
SCIP_COL ** SCIPlpGetNewcols(SCIP_LP *lp)
SCIP_Real SCIPcolGetMaxPrimsol(SCIP_COL *col)
SCIP_RETCODE SCIProwAddCoef(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_COL *col, SCIP_Real val)
unsigned int validminmaxidx
SCIP_Real SCIPcolGetRedcost(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)
SCIP_RETCODE SCIPlpiGetBInvRow(SCIP_LPI *lpi, int r, SCIP_Real *coef, int *inds, int *ninds)
SCIP_RETCODE SCIPlpGetSol(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool *primalfeasible, SCIP_Bool *dualfeasible)
SCIP_Real SCIPlpGetColumnObjval(SCIP_LP *lp)
void SCIProwRecalcPseudoActivity(SCIP_ROW *row, SCIP_STAT *stat)
static SCIP_RETCODE lpSetThreads(SCIP_LP *lp, int threads, SCIP_Bool *success)
static SCIP_RETCODE ensureLpicolsSize(SCIP_LP *lp, SCIP_SET *set, int num)
static SCIP_RETCODE rowChgCoefPos(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, int pos, SCIP_Real val)
int SCIPcolGetNLPNonz(SCIP_COL *col)
static SCIP_RETCODE lpSetIntpar(SCIP_LP *lp, SCIP_LPPARAM lpparam, int value, SCIP_Bool *success)
unsigned int nonlpcolssorted
int SCIPcolGetLPPos(SCIP_COL *col)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
const char * SCIPlpiGetSolverName(void)
static SCIP_RETCODE lpLexDualSimplex(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool resolve, SCIP_Bool keepsol, SCIP_Bool *lperror)
SCIP_Longint SCIProwGetNLPsAfterCreation(SCIP_ROW *row)
SCIP_Bool glbpseudoobjvalid
SCIP_Longint SCIPcalcGreComDiv(SCIP_Longint val1, SCIP_Longint val2)
static SCIP_RETCODE lpCheckBoolpar(SCIP_LP *lp, SCIP_LPPARAM lpparam, SCIP_Bool value)
SCIP_RETCODE SCIPlpEndStrongbranch(SCIP_LP *lp)
SCIP_Real SCIProwGetNorm(SCIP_ROW *row)
static SCIP_RETCODE lpDualSimplex(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool resolve, SCIP_Bool keepsol, SCIP_Bool *lperror)
void SCIPlpUnmarkDivingObjChanged(SCIP_LP *lp)
#define BMSreallocBlockMemoryArray(mem, ptr, oldnum, newnum)
static void rowMoveCoef(SCIP_ROW *row, int oldpos, int newpos)
static void lpUpdateObjNorms(SCIP_LP *lp, SCIP_SET *set, SCIP_Real oldobj, SCIP_Real newobj)
SCIP_Bool SCIPcolIsInLP(SCIP_COL *col)
SCIP_RETCODE SCIPlpiIgnoreInstability(SCIP_LPI *lpi, SCIP_Bool *success)
SCIP_RETCODE SCIPlpiGetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real *dval)
SCIP_RETCODE SCIProwFree(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)
SCIP_Bool flushdeletedrows
SCIP_Real SCIProwGetOrthogonality(SCIP_ROW *row1, SCIP_ROW *row2, char orthofunc)
SCIP_Bool SCIPsetIsFeasNegative(SCIP_SET *set, SCIP_Real val)
static SCIP_RETCODE lpSetRefactorInterval(SCIP_LP *lp, int refactor, SCIP_Bool *success)
static SCIP_RETCODE lpFlushAndSolve(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_EVENTQUEUE *eventqueue, int resolveitlim, int harditlim, SCIP_Bool needprimalray, SCIP_Bool needdualray, int fastmip, SCIP_Bool tightprimfeastol, SCIP_Bool tightdualfeastol, SCIP_Bool fromscratch, SCIP_Bool keepsol, SCIP_Bool *lperror)
static void checkLazyColArray(SCIP_LP *lp, SCIP_SET *set)
SCIP_RETCODE SCIPlpiDelColset(SCIP_LPI *lpi, int *dstat)
SCIP_RETCODE SCIProwAddConstant(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real addval)
SCIP_RETCODE SCIPeventCreateRowConstChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_ROW *row, SCIP_Real oldval, SCIP_Real newval)
void SCIProwUnlock(SCIP_ROW *row)
SCIP_RETCODE SCIPrealarrayClear(SCIP_REALARRAY *realarray)
SCIP_Real SCIPcolCalcFarkasCoef(SCIP_COL *col, SCIP_Real *dualfarkas)
SCIP_Real lpiconditionlimit
static SCIP_RETCODE lpSetTiming(SCIP_LP *lp, SCIP_CLOCKTYPE timing, SCIP_Bool enabled, SCIP_Bool *success)
SCIP_Bool SCIProwIsInGlobalCutpool(SCIP_ROW *row)
enum SCIP_SideType SCIP_SIDETYPE
#define checkRowSumnorm(row)