86 for( i = 0; i < row->
len; ++i )
105 #define debugRowPrint(x,y) 129 for( r = 0; r < col->
len; ++r )
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);
376 assert(blkmem !=
NULL);
380 if( storedsolvals !=
NULL )
429 assert(blkmem !=
NULL);
458 assert(blkmem !=
NULL);
462 if( storedsolvals !=
NULL )
504 assert(blkmem !=
NULL);
543 assert(blkmem !=
NULL);
547 if( storedsolvals !=
NULL )
590 if( num > row->
size )
601 assert(num <= row->size);
617 if( !msgdisp_checkrow )
619 printf(
"LP ROW CHECKING ACTIVATED! THIS IS VERY SLOW!\n");
620 msgdisp_checkrow =
TRUE;
627 for( i = 1; i < row->
nlpcols; ++i )
638 for( i = row->
nlpcols + 1; i < row->len; ++i )
646 #define checkRow(row) 660 assert(cols !=
NULL || row->
len == 0);
664 for( c = row->
len - 1; c >= 0; --c )
666 if( cols[c]->lppos >= 0 )
667 sqrnorm += SQR(row->
vals[c]);
670 assert(ABS(sqrnorm - row->
sqrnorm) < 1e-06 *
MAX(1.0,sqrnorm));
683 assert(cols !=
NULL || row->
len == 0);
687 for( c = row->
len - 1; c >= 0; --c )
689 if( cols[c]->lppos >= 0 )
693 assert(ABS(sumnorm - row->
sumnorm) < 1e-06 *
MAX(1.0,sumnorm));
706 assert(cols !=
NULL || row->
len == 0);
710 for( c = row->
len - 1; c >= 0; --c )
712 if( cols[c]->lppos >= 0 )
716 assert(ABS(objprod - row->
objprod) < 1e-06 *
MAX(1.0,objprod));
719 #define checkRowSqrnorm(row) 720 #define checkRowSumnorm(row) 721 #define checkRowObjprod(row) 743 assert(prob !=
NULL);
751 for( v = 0; v < nvars; ++v )
784 assert(prob !=
NULL);
792 for( v = 0; v < nvars; ++v )
826 assert(prob !=
NULL);
834 for( v = 0; v < nvars; ++v )
864 assert(prob !=
NULL);
886 assert(prob !=
NULL);
903 assert(elem1 !=
NULL);
904 assert(elem2 !=
NULL);
936 for( i = 0; i < col->
nlprows; ++i )
969 for( i = col->
nlprows; i < col->len; ++i )
1000 for( i = 0; i < row->
nlpcols; ++i )
1023 assert(row !=
NULL);
1035 for( i = row->
nlpcols; i < row->len; ++i )
1063 assert(col !=
NULL);
1064 assert(row !=
NULL);
1067 searchidx = row->
index;
1068 while(minpos <= maxpos)
1070 pos = (minpos + maxpos)/2;
1071 assert(0 <= pos && pos < col->len);
1073 assert((pos < col->nlprows) == (col->
rows[pos]->
lppos >= 0 && col->
linkpos[pos] >= 0));
1075 if( searchidx == idx )
1077 else if( searchidx < idx )
1095 assert(col !=
NULL);
1096 assert(row !=
NULL);
1101 if( row->
lppos >= 0 )
1138 assert(row !=
NULL);
1139 assert(col !=
NULL);
1142 searchidx = col->
index;
1143 while(minpos <= maxpos)
1145 pos = (minpos + maxpos)/2;
1146 assert(0 <= pos && pos < row->len);
1148 assert((pos < row->nlpcols) == (row->
cols[pos]->
lppos >= 0 && row->
linkpos[pos] >= 0));
1151 if( searchidx == idx )
1153 else if( searchidx < idx )
1173 assert(row !=
NULL);
1174 assert(col !=
NULL);
1182 if( col->
lppos >= 0 )
1203 assert(-1 <= pos && pos < row->len);
1205 assert(row->
cols[pos] == col);
1209 for( i = 0; i < row->
len; ++i )
1210 assert(row->
cols[i] != col);
1225 assert(col !=
NULL);
1226 assert(0 <= oldpos && oldpos < col->len);
1227 assert(0 <= newpos && newpos < col->len);
1230 if( oldpos == newpos )
1233 col->
rows[newpos] = col->
rows[oldpos];
1234 col->
vals[newpos] = col->
vals[oldpos];
1238 if( col->
linkpos[newpos] >= 0 )
1265 assert(col !=
NULL);
1266 assert(0 <= pos1 && pos1 < col->len);
1267 assert(0 <= pos2 && pos2 < col->len);
1274 tmprow = col->
rows[pos2];
1275 tmpval = col->
vals[pos2];
1276 tmplinkpos = col->
linkpos[pos2];
1282 col->
rows[pos1] = tmprow;
1283 col->
vals[pos1] = tmpval;
1284 col->
linkpos[pos1] = tmplinkpos;
1321 assert(row !=
NULL);
1322 assert(0 <= oldpos && oldpos < row->len);
1323 assert(0 <= newpos && newpos < row->len);
1326 if( oldpos == newpos )
1329 row->
cols[newpos] = row->
cols[oldpos];
1331 row->
vals[newpos] = row->
vals[oldpos];
1335 if( row->
linkpos[newpos] >= 0 )
1363 assert(row !=
NULL);
1364 assert(0 <= pos1 && pos1 < row->len);
1365 assert(0 <= pos2 && pos2 < row->len);
1373 tmpcol = row->
cols[pos2];
1375 tmpval = row->
vals[pos2];
1376 tmplinkpos = row->
linkpos[pos2];
1383 row->
cols[pos1] = tmpcol;
1385 row->
vals[pos1] = tmpval;
1386 row->
linkpos[pos1] = tmplinkpos;
1427 assert(row !=
NULL);
1429 assert(col !=
NULL);
1456 assert(row !=
NULL);
1485 assert(row !=
NULL);
1505 #define ASSERT(x) do { if( !(x) ) abort(); } while( FALSE ) 1507 #define ASSERT(x) assert(x) 1525 if( !msgdisp_checklinks )
1527 printf(
"LP LINK CHECKING ACTIVATED! THIS IS VERY SLOW!\n");
1528 msgdisp_checklinks =
TRUE;
1531 for( i = 0; i < lp->
ncols; ++i )
1534 ASSERT(col !=
NULL);
1540 for( j = 0; j < col->
len; ++j )
1543 ASSERT(row !=
NULL);
1547 ASSERT((j < col->nlprows) == (col->
linkpos[j] >= 0 && row->
lppos >= 0));
1551 for( i = 0; i < lp->
nrows; ++i )
1554 ASSERT(row !=
NULL);
1560 for( j = 0; j < row->
len; ++j )
1563 ASSERT(col !=
NULL);
1567 ASSERT((j < row->nlpcols) == (row->
linkpos[j] >= 0 && col->
lppos >= 0));
1575 #define checkLinks(lp) 1590 assert(row !=
NULL);
1591 assert(col !=
NULL);
1662 assert(blkmem !=
NULL);
1663 assert(col !=
NULL);
1666 assert(row !=
NULL);
1681 if( row->
lppos >= 0 && linkpos >= 0 )
1696 col->
rows[pos] = row;
1697 col->
vals[pos] = val;
1706 if( col->
lppos >= 0 )
1712 if( row->
lppos >= 0 )
1716 assert(0 <= linkpos && linkpos < row->len);
1717 assert(row->
cols[linkpos] == col);
1718 assert(col->
rows[pos] == row);
1725 assert(row->
linkpos[linkpos] == -1);
1733 if( col->
lppos >= 0 )
1739 if( linkpos == row->
nlpcols-1 )
1745 if( row->
lppos >= 0 && linkpos >= 0 )
1755 assert(col->
rows[col->
len-1] == row);
1762 SCIPsetDebugMsg(
set,
"added coefficient %g * <%s> at position %d (%d/%d) to column <%s> (nunlinked=%d)\n",
1779 assert(col !=
NULL);
1781 assert(
set !=
NULL);
1782 assert(0 <= pos && pos < col->len);
1785 assert((pos < col->nlprows) == (col->
linkpos[pos] >= 0 && col->
rows[pos]->
lppos >= 0));
1787 row = col->
rows[pos];
1788 assert((row->
lppos >= 0) == (pos < col->nlprows));
1797 if( pos < col->nlprows )
1823 assert(col !=
NULL);
1825 assert(0 <= pos && pos < col->len);
1843 col->
vals[pos] = val;
1869 assert(row !=
NULL);
1872 assert(
set !=
NULL);
1873 assert(col !=
NULL);
1879 if( col->
lppos >= 0 )
1940 assert(row !=
NULL);
1943 assert(
set !=
NULL);
1944 assert(col !=
NULL);
1956 if( forcenormupdate || col->
lppos >= 0 )
1999 assert(row !=
NULL);
2001 assert(blkmem !=
NULL);
2002 assert(col !=
NULL);
2024 if( col->
lppos >= 0 && linkpos >= 0 )
2039 row->
cols[pos] = col;
2041 row->
vals[pos] = val;
2051 if( row->
lppos >= 0 )
2057 if( col->
lppos >= 0 )
2061 assert(0 <= linkpos && linkpos < col->len);
2062 assert(col->
rows[linkpos] == row);
2063 assert(row->
cols[pos] == col);
2070 assert(col->
linkpos[linkpos] == -1);
2078 if( row->
lppos >= 0 )
2084 if( linkpos == col->
nlprows-1 )
2090 if( col->
lppos >= 0 && linkpos >= 0 )
2103 assert(row->
cols[row->
len-1] == col);
2116 SCIPsetDebugMsg(
set,
"added coefficient %g * <%s> at position %d (%d/%d) to row <%s> (nunlinked=%d)\n",
2139 assert(row !=
NULL);
2140 assert(
set !=
NULL);
2141 assert(0 <= pos && pos < row->len);
2143 assert((pos < row->nlpcols) == (row->
linkpos[pos] >= 0 && row->
cols[pos]->
lppos >= 0));
2145 col = row->
cols[pos];
2146 val = row->
vals[pos];
2147 assert((pos < row->nlpcols) == (col->
lppos >= 0 && row->
linkpos[pos] >= 0));
2154 SCIPerrorMessage(
"cannot delete a coefficient from the locked unmodifiable row <%s>\n", row->
name);
2162 if( pos < row->nlpcols )
2199 assert(row !=
NULL);
2200 assert(0 <= pos && pos < row->len);
2207 SCIPerrorMessage(
"cannot change a coefficient of the locked unmodifiable row <%s>\n", row->
name);
2213 col = row->
cols[pos];
2225 oldval = row->
vals[pos];
2229 row->
vals[pos] = val;
2250 assert(row !=
NULL);
2306 assert(col !=
NULL);
2308 assert(blkmem !=
NULL);
2309 assert(
set !=
NULL);
2317 for( i = col->
nlprows; i < col->len; ++i )
2350 assert(col !=
NULL);
2352 assert(blkmem !=
NULL);
2353 assert(
set !=
NULL);
2359 for( i = 0; i < col->
len; ++i )
2389 assert(row !=
NULL);
2390 assert(blkmem !=
NULL);
2391 assert(
set !=
NULL);
2399 for( i = row->
nlpcols; i < row->len; ++i )
2430 assert(row !=
NULL);
2431 assert(
set !=
NULL);
2437 for( i = 0; i < row->
len; ++i )
2471 assert(success !=
NULL);
2495 return lpSetIntpar(lp, lpparam, (
int)value, success);
2510 assert(success !=
NULL);
2546 assert(lpivalue == value);
2582 assert(lpivalue == value);
2587 #define lpCheckIntpar(lp, lpparam, value) SCIP_OKAY 2588 #define lpCheckBoolpar(lp, lpparam, value) SCIP_OKAY 2589 #define lpCheckRealpar(lp, lpparam, value) SCIP_OKAY 2593 #define lpCutoffDisabled(set) (set->lp_disablecutoff == 1 || (set->nactivepricers > 0 && set->lp_disablecutoff == 2)) 2604 assert(
set !=
NULL);
2646 assert(feastol >= 0.0);
2647 assert(success !=
NULL);
2656 if( lp->
nrows > 0 && feastol < lp->lpifeastol )
2682 assert(dualfeastol >= 0.0);
2683 assert(success !=
NULL);
2692 if( lp->
nrows > 0 && dualfeastol < lp->lpidualfeastol )
2718 assert(barrierconvtol >= 0.0);
2719 assert(success !=
NULL);
2728 if( lp->
nrows > 0 && barrierconvtol < lp->lpibarrierconvtol
2755 assert(success !=
NULL);
2780 assert(success !=
NULL);
2781 assert(0 <= fastmip && fastmip <= 1);
2806 assert(success !=
NULL);
2831 assert(success !=
NULL);
2856 assert(success !=
NULL);
2881 assert(success !=
NULL);
2907 assert(itlim >= -1);
2965 switch( pricingchar )
3030 assert(success !=
NULL);
3058 assert(success !=
NULL);
3066 lptiming = (int) timing;
3089 assert(success !=
NULL);
3093 if( randomseed == 0 )
3119 assert(success !=
NULL);
3152 assert(col !=
NULL);
3153 assert(blkmem !=
NULL);
3154 assert(
set !=
NULL);
3155 assert(stat !=
NULL);
3156 assert(var !=
NULL);
3158 assert(len == 0 || (rows !=
NULL && vals !=
NULL));
3168 for( i = 0; i < len; ++i )
3170 assert(rows[i] !=
NULL);
3172 (*col)->linkpos[i] = -1;
3177 (*col)->rows =
NULL;
3178 (*col)->vals =
NULL;
3179 (*col)->linkpos =
NULL;
3187 (*col)->flushedobj = 0.0;
3188 (*col)->flushedlb = 0.0;
3189 (*col)->flushedub = 0.0;
3190 (*col)->index = stat->
ncolidx;
3194 (*col)->nlprows = 0;
3195 (*col)->nunlinked = len;
3197 (*col)->lpipos = -1;
3198 (*col)->lpdepth = -1;
3199 (*col)->primsol = 0.0;
3202 (*col)->minprimsol = (*col)->ub;
3203 (*col)->maxprimsol = (*col)->lb;
3208 (*col)->sbnode = -1;
3209 (*col)->validredcostlp = -1;
3210 (*col)->validfarkaslp = -1;
3211 (*col)->validsblp = -1;
3212 (*col)->sbitlim = -1;
3213 (*col)->nsbcalls = 0;
3215 (*col)->obsoletenode = -1;
3218 (*col)->lprowssorted =
TRUE;
3219 (*col)->nonlprowssorted = (len <= 1);
3220 (*col)->objchanged =
FALSE;
3221 (*col)->lbchanged =
FALSE;
3222 (*col)->ubchanged =
FALSE;
3223 (*col)->coefchanged =
FALSE;
3225 (*col)->removable = removable;
3226 (*col)->sbdownvalid =
FALSE;
3227 (*col)->sbupvalid =
FALSE;
3230 (*col)->storedsolvals =
NULL;
3244 assert(blkmem !=
NULL);
3245 assert(col !=
NULL);
3246 assert(*col !=
NULL);
3247 assert((*col)->var !=
NULL);
3249 assert(&(*col)->var->data.col == col);
3250 assert((*col)->lppos == -1);
3251 assert((*col)->lpipos == -1);
3274 assert(col !=
NULL);
3283 for( r = 0; r < col->
len; ++r )
3338 assert(col !=
NULL);
3342 assert(row !=
NULL);
3351 assert(0 <= pos && pos < col->len);
3352 assert(col->
rows[pos] == row);
3384 assert(col !=
NULL);
3387 assert(row !=
NULL);
3401 assert(0 <= pos && pos < col->len);
3402 assert(col->
rows[pos] == row);
3435 assert(col !=
NULL);
3438 assert(row !=
NULL);
3455 assert(0 <= pos && pos < col->len);
3456 assert(col->
rows[pos] == row);
3511 assert(
set !=
NULL);
3564 assert(col !=
NULL);
3623 assert(col !=
NULL);
3668 assert(col !=
NULL);
3715 assert(col !=
NULL);
3718 assert(dualsol !=
NULL);
3721 for( i = 0; i < col->
nlprows; ++i )
3724 assert(row !=
NULL);
3725 assert(row->
lppos >= 0);
3726 redcost -= col->
vals[i] * dualsol[row->
lppos];
3731 for( i = col->
nlprows; i < col->len; ++i )
3734 assert(row !=
NULL);
3736 if( row->
lppos >= 0 )
3737 redcost -= col->
vals[i] * dualsol[row->
lppos];
3743 for( i = col->
nlprows; i < col->len; ++i )
3746 assert(row !=
NULL);
3747 assert(row->
lppos == -1);
3766 assert(col !=
NULL);
3771 for( i = 0; i < col->
nlprows; ++i )
3774 assert(row !=
NULL);
3776 assert(row->
lppos >= 0);
3783 for( i = col->
nlprows; i < col->len; ++i )
3786 assert(row !=
NULL);
3789 if( row->
lppos >= 0 )
3796 for( i = col->
nlprows; i < col->len; ++i )
3799 assert(row !=
NULL);
3801 assert(row->
lppos == -1);
3817 assert(col !=
NULL);
3818 assert(stat !=
NULL);
3842 assert(col !=
NULL);
3843 assert(
set !=
NULL);
3844 assert(stat !=
NULL);
3898 assert(col !=
NULL);
3901 assert(dualfarkas !=
NULL);
3904 for( i = 0; i < col->
nlprows; ++i )
3907 assert(row !=
NULL);
3908 assert(row->
lppos >= 0);
3909 farkas += col->
vals[i] * dualfarkas[row->
lppos];
3914 for( i = col->
nlprows; i < col->len; ++i )
3917 assert(row !=
NULL);
3919 if( row->
lppos >= 0 )
3920 farkas += col->
vals[i] * dualfarkas[row->
lppos];
3926 for( i = col->
nlprows; i < col->len; ++i )
3929 assert(row !=
NULL);
3930 assert(row->
lppos == -1);
3949 assert(col !=
NULL);
3954 for( i = 0; i < col->
nlprows; ++i )
3957 assert(row !=
NULL);
3959 assert(row->
lppos >= 0);
3966 for( i = col->
nlprows; i < col->len; ++i )
3969 assert(row !=
NULL);
3972 if( row->
lppos >= 0 )
3979 for( i = col->
nlprows; i < col->len; ++i )
3982 assert(row !=
NULL);
3984 assert(row->
lppos == -1);
4000 assert(col !=
NULL);
4001 assert(stat !=
NULL);
4028 assert(col !=
NULL);
4032 if( farkascoef > 0.0 )
4033 return col->
ub * farkascoef;
4035 return col->
lb * farkascoef;
4084 assert(col !=
NULL);
4090 assert(col->
lpipos >= 0);
4091 assert(col->
lppos >= 0);
4092 assert(
set !=
NULL);
4093 assert(stat !=
NULL);
4118 SCIPstatAdd(stat,
set, nrootsblpiterations, iter);
4130 assert(col !=
NULL);
4136 assert(col->
lpipos >= 0);
4137 assert(col->
lppos >= 0);
4138 assert(
set !=
NULL);
4139 assert(stat !=
NULL);
4175 assert(col !=
NULL);
4182 assert(col->
lpipos >= 0);
4183 assert(col->
lppos >= 0);
4184 assert(
set !=
NULL);
4185 assert(stat !=
NULL);
4198 assert(lperror !=
NULL);
4227 SCIPsetDebugMsg(
set,
"performing strong branching on variable <%s>(%g) with %d iterations\n",
4285 if( iter/2 >= itlim )
4293 SCIPstatAdd(stat,
set, nrootsblpiterations, iter);
4308 if( downvalid !=
NULL )
4310 if( upvalid !=
NULL )
4348 assert(cols !=
NULL);
4349 assert(
set !=
NULL);
4350 assert(stat !=
NULL);
4357 assert(down !=
NULL);
4359 assert(lperror !=
NULL);
4380 for( j = 0; j < ncols; ++j )
4392 assert(col->
lpipos >= 0);
4393 assert(col->
lppos >= 0);
4413 if( downvalid !=
NULL )
4415 if( upvalid !=
NULL )
4423 lpipos[nsubcols] = col->
lpipos;
4424 primsols[nsubcols] = col->
primsol;
4426 subidx[nsubcols] = j;
4427 subcols[nsubcols++] = col;
4435 if( downvalid !=
NULL )
4437 if( upvalid !=
NULL )
4442 SCIPsetDebugMsg(
set,
"performing strong branching on %d variables with %d iterations\n", ncols, itlim);
4455 for( j = 0; j < nsubcols; ++j )
4473 up[idx] = col->
sbup;
4474 if( downvalid !=
NULL )
4476 if( upvalid !=
NULL )
4489 for( j = 0; j < nsubcols; ++j )
4506 up[idx] = col->
sbup;
4507 if( downvalid !=
NULL )
4509 if( upvalid !=
NULL )
4522 if( iter/2 >= itlim )
4529 SCIPstatAdd(stat,
set, nrootstrongbranchs, ncols);
4530 SCIPstatAdd(stat,
set, nrootsblpiterations, iter);
4565 assert(col !=
NULL);
4571 if( downvalid !=
NULL )
4573 if( upvalid !=
NULL )
4575 if( solval !=
NULL )
4577 if( lpobjval !=
NULL )
4590 assert(col !=
NULL);
4591 assert(stat !=
NULL);
4602 assert(col !=
NULL);
4603 assert(stat !=
NULL);
4604 assert(stat->
nnodes > 0);
4624 assert(row !=
NULL);
4625 assert(
set !=
NULL);
4643 for( i = 0; i < row->
nlpcols; ++i )
4658 for( i = row->
nlpcols; i < row->len; ++i )
4685 assert(row !=
NULL);
4686 assert(
set !=
NULL);
4697 for( i = 0; i < row->
len; ++i )
4700 assert(col !=
NULL);
4748 assert(mindelta <= 0.0);
4749 assert(maxdelta >= 0.0);
4751 sval = val * scalar;
4752 downval = floor(sval);
4757 if( intval !=
NULL )
4763 if( intval !=
NULL )
4805 assert(row !=
NULL);
4809 assert(-1.0 < minrounddelta && minrounddelta <= 0.0);
4810 assert(0.0 <= maxrounddelta && maxrounddelta < 1.0);
4812 SCIPsetDebugMsg(
set,
"scale row <%s> with %g (tolerance=[%g,%g])\n", row->
name, scaleval, minrounddelta, maxrounddelta);
4816 mindeltainf =
FALSE;
4817 maxdeltainf =
FALSE;
4827 while( c < row->len )
4846 newval = val * scaleval;
4848 &&
isIntegralScalar(val, scaleval, minrounddelta, maxrounddelta, &intval) )
4852 if( intval < newval )
4854 mindelta += (intval - newval)*ub;
4855 maxdelta += (intval - newval)*lb;
4861 mindelta += (intval - newval)*lb;
4862 maxdelta += (intval - newval)*ub;
4884 if( oldlen != row->
len )
4886 assert(row->
len == oldlen - 1);
4908 newval = (row->
lhs - row->
constant) * scaleval + mindelta;
4920 newval = (row->
rhs - row->
constant) * scaleval + maxdelta;
4966 assert(row !=
NULL);
4967 assert(blkmem !=
NULL);
4968 assert(stat !=
NULL);
4970 assert(len == 0 || (cols !=
NULL && vals !=
NULL));
4979 (*row)->integral =
TRUE;
4990 for( i = 0; i < len; ++i )
4992 assert(cols[i] !=
NULL);
4996 (*row)->cols_index[i] = cols[i]->
index;
4997 (*row)->linkpos[i] = -1;
5005 (*row)->integral =
FALSE;
5011 (*row)->cols =
NULL;
5012 (*row)->cols_index =
NULL;
5013 (*row)->vals =
NULL;
5014 (*row)->linkpos =
NULL;
5018 (*row)->constant = 0.0;
5023 (*row)->sqrnorm = 0.0;
5024 (*row)->sumnorm = 0.0;
5025 (*row)->objprod = 0.0;
5026 (*row)->maxval = 0.0;
5028 (*row)->dualsol = 0.0;
5030 (*row)->dualfarkas = 0.0;
5034 (*row)->origin = origin;
5035 (*row)->eventfilter =
NULL;
5036 (*row)->index = stat->
nrowidx;
5040 (*row)->nlpcols = 0;
5041 (*row)->nunlinked = len;
5044 (*row)->lpipos = -1;
5045 (*row)->lpdepth = -1;
5046 (*row)->minidx = INT_MAX;
5047 (*row)->maxidx = INT_MIN;
5048 (*row)->nummaxval = 0;
5049 (*row)->numminval = 0;
5050 (*row)->validactivitylp = -1;
5051 (*row)->validpsactivitydomchg = -1;
5052 (*row)->validactivitybdsdomchg = -1;
5053 (*row)->nlpsaftercreation = 0L;
5054 (*row)->activeinlpcounter = 0L;
5057 (*row)->obsoletenode = -1;
5059 (*row)->lpcolssorted =
TRUE;
5060 (*row)->nonlpcolssorted = (len <= 1);
5061 (*row)->delaysort =
FALSE;
5062 (*row)->validminmaxidx =
FALSE;
5063 (*row)->lhschanged =
FALSE;
5064 (*row)->rhschanged =
FALSE;
5065 (*row)->coefchanged =
FALSE;
5066 (*row)->local = local;
5067 (*row)->modifiable = modifiable;
5069 (*row)->origintype = origintype;
5070 (*row)->removable = removable;
5071 (*row)->inglobalcutpool =
FALSE;
5072 (*row)->storedsolvals =
NULL;
5094 assert(blkmem !=
NULL);
5095 assert(row !=
NULL);
5096 assert(*row !=
NULL);
5097 assert((*row)->nuses == 0);
5098 assert((*row)->lppos == -1);
5099 assert((*row)->eventfilter !=
NULL);
5127 assert(row !=
NULL);
5141 for( i = 0; i < row->
len; ++i )
5163 assert(row !=
NULL);
5164 assert(row->
nuses >= 0);
5165 assert(row->
nlocks <= (
unsigned int)(row->
nuses));
5179 assert(blkmem !=
NULL);
5180 assert(row !=
NULL);
5181 assert(*row !=
NULL);
5182 assert((*row)->nuses >= 1);
5183 assert((*row)->nlocks < (
unsigned int)((*row)->nuses));
5185 SCIPsetDebugMsg(
set,
"release row <%s> with nuses=%d and nlocks=%u\n", (*row)->name, (*row)->nuses, (*row)->nlocks);
5187 if( (*row)->nuses == 0 )
5202 assert(row !=
NULL);
5217 assert(row !=
NULL);
5261 assert(row !=
NULL);
5265 assert(col !=
NULL);
5275 assert(0 <= pos && pos < row->len);
5276 assert(row->
cols[pos] == col);
5308 assert(row !=
NULL);
5312 assert(col !=
NULL);
5326 assert(0 <= pos && pos < row->len);
5327 assert(row->
cols[pos] == col);
5360 assert(row !=
NULL);
5363 assert(col !=
NULL);
5380 assert(0 <= pos && pos < row->len);
5381 assert(row->
cols[pos] == col);
5415 assert(row !=
NULL);
5416 assert(row->
lhs <= row->
rhs);
5418 assert(stat !=
NULL);
5470 assert(row !=
NULL);
5471 assert(row->
lhs <= row->
rhs);
5473 assert(stat !=
NULL);
5495 assert(row !=
NULL);
5527 assert(row !=
NULL);
5555 assert(row !=
NULL);
5598 assert(row !=
NULL);
5602 assert(maxdnom >= 1);
5603 assert(mindelta < 0.0);
5604 assert(maxdelta > 0.0);
5605 assert(success !=
NULL);
5610 if( intscalar !=
NULL )
5616 for( c = 0; c < row->
len; ++c )
5620 assert(col !=
NULL);
5628 if( val < mindelta || val > maxdelta )
5631 minval =
MIN(minval, absval);
5637 if( intscalar !=
NULL )
5640 SCIPsetDebugMsg(
set,
" -> all values are zero (inside tolerances)\n");
5644 assert(minval >
MIN(-mindelta, maxdelta));
5651 scaleval = 1.0/minval;
5652 scalable = (scaleval <= maxscale);
5653 for( c = 0; c < row->
len && scalable; ++c )
5662 while( scaleval <= maxscale
5669 scaleval *= scalars[s];
5676 scalable = (scaleval <= maxscale);
5677 SCIPsetDebugMsg(
set,
" -> val=%g, scaleval=%g, val*scaleval=%g, scalable=%u\n", val, scaleval, val*scaleval, scalable);
5684 assert(scaleval <= maxscale);
5685 if( intscalar !=
NULL )
5686 *intscalar = scaleval;
5688 SCIPsetDebugMsg(
set,
" -> integrality can be achieved by scaling with %g (minval=%g)\n", scaleval, minval);
5695 twomult = (twomultval <= maxscale);
5696 for( c = 0; c < row->
len && twomult; ++c )
5705 while( twomultval <= maxscale
5706 && (absval * twomultval < 0.5 || !
isIntegralScalar(val, twomultval, mindelta, maxdelta,
NULL)) )
5712 twomultval *= scalars[s];
5719 twomult = (twomultval <= maxscale);
5720 SCIPsetDebugMsg(
set,
" -> val=%g, twomult=%g, val*twomult=%g, twomultable=%u\n",
5721 val, twomultval, val*twomultval, twomult);
5726 assert(twomultval <= maxscale);
5727 if( intscalar !=
NULL )
5728 *intscalar = twomultval;
5730 SCIPsetDebugMsg(
set,
" -> integrality can be achieved by scaling with %g (power of 2)\n", twomultval);
5740 rational = (maxdnom > 1);
5743 for( c = 0; c < row->
len && rational; ++c )
5748 rational =
SCIPrealToRational(val, mindelta, maxdelta, maxdnom, &nominator, &denominator);
5749 if( rational && nominator != 0 )
5751 assert(denominator > 0);
5752 gcd = ABS(nominator);
5755 SCIPsetDebugMsg(
set,
" -> first rational: val: %g == %" SCIP_LONGINT_FORMAT
"/%" SCIP_LONGINT_FORMAT
", gcd=%" SCIP_LONGINT_FORMAT
", scm=%" SCIP_LONGINT_FORMAT
", rational=%u\n",
5756 val, nominator, denominator, gcd, scm, rational);
5763 for( ++c; c < row->
len && rational; ++c )
5768 rational =
SCIPrealToRational(val, mindelta, maxdelta, maxdnom, &nominator, &denominator);
5769 if( rational && nominator != 0 )
5771 assert(denominator > 0);
5775 SCIPsetDebugMsg(
set,
" -> next rational : val: %g == %" SCIP_LONGINT_FORMAT
"/%" SCIP_LONGINT_FORMAT
", gcd=%" SCIP_LONGINT_FORMAT
", scm=%" SCIP_LONGINT_FORMAT
", rational=%u\n",
5776 val, nominator, denominator, gcd, scm, rational);
5785 if( intscalar !=
NULL )
5788 SCIPsetDebugMsg(
set,
" -> integrality can be achieved by scaling with %g (rational:%" SCIP_LONGINT_FORMAT
"/%" SCIP_LONGINT_FORMAT
")\n",
5793 assert(!(*success));
5794 SCIPsetDebugMsg(
set,
" -> rationalizing failed: gcd=%" SCIP_LONGINT_FORMAT
", scm=%" SCIP_LONGINT_FORMAT
", lastval=%g\n", gcd, scm, val);
5818 assert(success !=
NULL);
5822 &intscalar, success) );
5827 SCIP_CALL(
rowScale(row, blkmem,
set, eventqueue, stat, lp, intscalar, usecontvars, mindelta, maxdelta) );
5840 assert(row !=
NULL);
5848 #ifdef SCIP_MORE_DEBUG 5854 for( c = 1; c < row->
nlpcols; ++c )
5856 for( c = row->
nlpcols + 1; c < row->len; ++c )
5874 assert(row !=
NULL);
5899 assert(cols !=
NULL);
5900 assert(cols_index !=
NULL);
5901 assert(vals !=
NULL);
5906 assert(row->
linkpos[0] == -1);
5908 for( s = 1; s < row->
len; ++s )
5911 assert(row->
linkpos[s] == -1);
5913 if( cols[s] == cols[t] )
5930 cols_index[t] = cols_index[s];
5939 assert(s == row->
len);
5940 assert(t <= row->len);
5956 for( i = 0; i < row->
len; ++i )
5960 for( j = i+1; j < row->
len; ++j )
5961 assert(row->
cols[i] != row->
cols[j]);
5972 assert(row !=
NULL);
5984 assert(row !=
NULL);
6000 assert(row !=
NULL);
6001 assert(stat !=
NULL);
6004 for( c = 0; c < row->
nlpcols; ++c )
6007 assert(col !=
NULL);
6009 assert(col->
lppos >= 0);
6016 for( c = row->
nlpcols; c < row->len; ++c )
6019 assert(col !=
NULL);
6022 if( col->
lppos >= 0 )
6029 for( c = row->
nlpcols; c < row->len; ++c )
6032 assert(col !=
NULL);
6034 assert(col->
lppos == -1);
6054 assert(row !=
NULL);
6055 assert(stat !=
NULL);
6067 activity =
MAX(activity, -inf);
6068 activity =
MIN(activity, +inf);
6083 assert(row !=
NULL);
6087 return MIN(row->
rhs - activity, activity - row->
lhs);
6105 assert( row !=
NULL );
6106 assert( stat !=
NULL );
6109 for (c = 0; c < row->
nlpcols; ++c)
6112 assert( col !=
NULL );
6113 assert( col->
lppos >= 0 );
6115 assert( row->
linkpos[c] >= 0 );
6121 for (c = row->
nlpcols; c < row->len; ++c)
6124 assert( col !=
NULL );
6126 if ( col->
lppos >= 0 )
6136 for (c = row->
nlpcols; c < row->len; ++c)
6139 assert( col !=
NULL );
6140 assert( col->
lppos == -1 );
6141 assert( row->
linkpos[c] >= 0 );
6146 activity =
MAX(activity, -inf);
6147 activity =
MIN(activity, +inf);
6149 return MIN(row->
rhs - activity, activity - row->
lhs);
6167 assert( row !=
NULL );
6168 assert( stat !=
NULL );
6171 for (c = 0; c < row->
nlpcols; ++c)
6174 assert( col !=
NULL );
6175 assert( col->
lppos >= 0 );
6177 assert( row->
linkpos[c] >= 0 );
6183 for (c = row->
nlpcols; c < row->len; ++c)
6186 assert( col !=
NULL );
6188 if ( col->
lppos >= 0 )
6198 for (c = row->
nlpcols; c < row->len; ++c)
6201 assert( col !=
NULL );
6202 assert( col->
lppos == -1 );
6203 assert( row->
linkpos[c] >= 0 );
6208 activity =
MAX(activity, -inf);
6209 activity =
MIN(activity, +inf);
6211 return MIN(row->
rhs - activity, activity - row->
lhs);
6223 assert(row !=
NULL);
6224 assert(stat !=
NULL);
6227 for( i = 0; i < row->
len; ++i )
6230 assert(col !=
NULL);
6231 assert((i < row->nlpcols) == (row->
linkpos[i] >= 0 && col->
lppos >= 0));
6251 assert(row !=
NULL);
6252 assert(stat !=
NULL);
6263 activity =
MAX(activity, -inf);
6264 activity =
MIN(activity, +inf);
6278 assert(row !=
NULL);
6282 return MIN(row->
rhs - pseudoactivity, pseudoactivity - row->
lhs);
6299 assert(row !=
NULL);
6302 for( i = 0; i < row->
len; ++i )
6305 assert(col !=
NULL);
6306 assert((i < row->nlpcols) == (row->
linkpos[i] >= 0 && col->
lppos >= 0));
6311 solval = (row->
vals[i] >= 0.0 ? col->
lb : col->
ub);
6313 solval = (row->
vals[i] >= 0.0 ? col->
ub : col->
lb);
6315 solval = (col->
lb + col->
ub)/2.0;
6317 activity += row->
vals[i] * solval;
6321 activity =
MAX(activity, -inf);
6322 activity =
MIN(activity, +inf);
6337 assert(row !=
NULL);
6341 return MIN(row->
rhs - activity, activity - row->
lhs);
6358 assert(row !=
NULL);
6360 assert(stat !=
NULL);
6363 mininfinite =
FALSE;
6364 maxinfinite =
FALSE;
6367 for( i = 0; i < row->
len && (!mininfinite || !maxinfinite); ++i )
6370 assert(col !=
NULL);
6371 assert((i < row->nlpcols) == (row->
linkpos[i] >= 0 && col->
lppos >= 0));
6412 assert(row !=
NULL);
6413 assert(stat !=
NULL);
6433 assert(row !=
NULL);
6434 assert(stat !=
NULL);
6454 assert(row !=
NULL);
6484 assert(row !=
NULL);
6489 assert(row->
maxval >= 0.0 || row->
len == 0);
6500 assert(row !=
NULL);
6505 assert(row->
minval >= 0.0 || row->
len == 0);
6516 assert(row !=
NULL);
6520 assert(row->
maxidx >= 0 || row->
len == 0);
6532 assert(row !=
NULL);
6536 assert(row->
minidx >= 0 || row->
len == 0);
6554 assert(
set !=
NULL);
6556 switch( set->sepa_efficacynorm )
6568 norm = (row->
len == 0 ? 0.0 : 1.0);
6571 SCIPerrorMessage(
"invalid efficacy norm parameter '%c'\n", set->sepa_efficacynorm);
6577 norm =
MAX(norm, eps);
6580 return -feasibility / norm;
6611 assert(
set !=
NULL);
6613 switch( set->sepa_efficacynorm )
6625 norm = (row->
len == 0 ? 0.0 : 1.0);
6628 SCIPerrorMessage(
"invalid efficacy norm parameter '%c'\n", set->sepa_efficacynorm);
6634 norm =
MAX(norm, eps);
6637 return -feasibility / norm;
6669 assert(
set !=
NULL);
6671 switch( set->sepa_efficacynorm )
6683 norm = (row->
len == 0 ? 0.0 : 1.0);
6686 SCIPerrorMessage(
"invalid efficacy norm parameter '%c'\n", set->sepa_efficacynorm);
6692 norm =
MAX(norm, eps);
6695 return -feasibility / norm;
6709 assert(
set !=
NULL);
6711 switch( set->sepa_efficacynorm )
6723 norm = (row->
len == 0 ? 0.0 : 1.0);
6726 SCIPerrorMessage(
"invalid efficacy norm parameter '%c'\n", set->sepa_efficacynorm);
6732 norm =
MAX(norm, eps);
6735 return -feasibility / norm;
6754 assert(row1 !=
NULL);
6755 assert(row2 !=
NULL);
6809 while( i1 < row1->nlpcols && i2 < row2->len )
6811 assert(row1->
cols[i1] != row2->
cols[i2]);
6820 assert(i1 == row1->
nlpcols || i2 == row2->
len);
6824 while( i1 < row1->len && i2 < row2->nlpcols )
6826 assert(row1->
cols[i1] != row2->
cols[i2]);
6835 assert(i1 == row1->
len || i2 == row2->
nlpcols);
6856 while( i1 >= 0 && i2 >= 0 )
6858 assert(row1->
cols[i1]->
index == row1colsidx[i1]);
6859 assert(row2->
cols[i2]->
index == row2colsidx[i2]);
6860 assert((row1->
cols[i1] == row2->
cols[i2]) == (row1colsidx[i1] == row2colsidx[i2]));
6861 if( row1colsidx[i1] < row2colsidx[i2] )
6863 else if( row1colsidx[i1] > row2colsidx[i2] )
6867 scalarprod += row1->
vals[i1] * row2->
vals[i2];
6895 while( ilp1 < row1->nlpcols && inlp1 < row1->len && ilp2 < row2->nlpcols && inlp2 < row2->len )
6897 assert(row1->
cols[ilp1]->
index == row1colsidx[ilp1]);
6898 assert(row1->
cols[inlp1]->
index == row1colsidx[inlp1]);
6899 assert(row2->
cols[ilp2]->
index == row2colsidx[ilp2]);
6900 assert(row2->
cols[inlp2]->
index == row2colsidx[inlp2]);
6901 assert((row1->
cols[ilp1] == row2->
cols[ilp2]) == (row1colsidx[ilp1] == row2colsidx[ilp2]));
6902 assert((row1->
cols[ilp1] == row2->
cols[inlp2]) == (row1colsidx[ilp1] == row2colsidx[inlp2]));
6903 assert((row1->
cols[inlp1] == row2->
cols[ilp2]) == (row1colsidx[inlp1] == row2colsidx[ilp2]));
6904 assert((row1->
cols[inlp1] == row2->
cols[inlp2]) == (row1colsidx[inlp1] == row2colsidx[inlp2]));
6907 if( row1colsidx[ilp1] == row2colsidx[ilp2] )
6909 scalarprod += row1->
vals[ilp1] * row2->
vals[ilp2];
6914 else if( row1colsidx[ilp1] == row2colsidx[inlp2] )
6916 scalarprod += row1->
vals[ilp1] * row2->
vals[inlp2];
6921 else if( row1colsidx[inlp1] == row2colsidx[ilp2] )
6923 scalarprod += row1->
vals[inlp1] * row2->
vals[ilp2];
6928 else if( row1colsidx[inlp1] == row2colsidx[inlp2] && row1->
cols[inlp1]->
lppos >= 0 )
6930 scalarprod += row1->
vals[inlp1] * row2->
vals[inlp2];
6935 else if( row1colsidx[ilp1] < row1colsidx[inlp1] )
6937 if( row2colsidx[ilp2] < row2colsidx[inlp2] )
6939 if( row1colsidx[ilp1] < row2colsidx[ilp2] )
6946 if( row1colsidx[ilp1] < row2colsidx[inlp2] )
6954 if( row2colsidx[ilp2] < row2colsidx[inlp2] )
6956 if( row1colsidx[inlp1] < row2colsidx[ilp2] )
6963 if( row1colsidx[inlp1] < row2colsidx[inlp2] )
6975 if( ilp1 != row1->
nlpcols && inlp1 != row1->
len )
6980 assert(ilp2 == row2->
nlpcols || inlp2 == row2->
len);
7003 assert(inlp1 == row1->
len);
7013 while( i1 < end1 && ilp2 < row2->nlpcols && inlp2 < row2->len )
7015 assert(row1->
cols[i1]->
index == row1colsidx[i1]);
7016 assert(row2->
cols[ilp2]->
index == row2colsidx[ilp2]);
7017 assert(row2->
cols[inlp2]->
index == row2colsidx[inlp2]);
7018 assert((row1->
cols[i1] == row2->
cols[ilp2]) == (row1colsidx[i1] == row2colsidx[ilp2]));
7019 assert((row1->
cols[i1] == row2->
cols[inlp2]) == (row1colsidx[i1] == row2colsidx[inlp2]));
7022 if( row1colsidx[i1] == row2colsidx[ilp2] )
7024 scalarprod += row1->
vals[i1] * row2->
vals[ilp2];
7029 else if( row1colsidx[i1] == row2colsidx[inlp2] && (lpcols || row1->
cols[i1]->
lppos >= 0) )
7031 scalarprod += row1->
vals[i1] * row2->
vals[inlp2];
7036 else if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7038 if( row1colsidx[i1] < row2colsidx[ilp2] )
7045 if( row1colsidx[i1] < row2colsidx[inlp2] )
7066 assert(inlp2 == row2->
len);
7073 while( i1 < end1 && i2 < end2 )
7075 assert(row1->
cols[i1]->
index == row1colsidx[i1]);
7076 assert(row2->
cols[i2]->
index == row2colsidx[i2]);
7077 assert((row1->
cols[i1] == row2->
cols[i2]) == (row1colsidx[i1] == row2colsidx[i2]));
7080 if( row1colsidx[i1] == row2colsidx[i2] && (lpcols || row1->
cols[i1]->
lppos >= 0) )
7082 scalarprod += row1->
vals[i1] * row2->
vals[i2];
7087 else if( row1colsidx[i1] < row2colsidx[i2] )
7111 assert(row1 !=
NULL);
7112 assert(row2 !=
NULL);
7166 while( i1 < row1->nlpcols && i2 < row2->len )
7168 assert(row1->
cols[i1] != row2->
cols[i2]);
7177 assert(i1 == row1->
nlpcols || i2 == row2->
len);
7181 while( i1 < row1->len && i2 < row2->nlpcols )
7183 assert(row1->
cols[i1] != row2->
cols[i2]);
7192 assert(i1 == row1->
len || i2 == row2->
nlpcols);
7213 while( i1 >= 0 && i2 >= 0 )
7215 assert(row1->
cols[i1]->
index == row1colsidx[i1]);
7216 assert(row2->
cols[i2]->
index == row2colsidx[i2]);
7217 assert((row1->
cols[i1] == row2->
cols[i2]) == (row1colsidx[i1] == row2colsidx[i2]));
7218 if( row1colsidx[i1] < row2colsidx[i2] )
7220 else if( row1colsidx[i1] > row2colsidx[i2] )
7252 while( ilp1 < row1->nlpcols && inlp1 < row1->len && ilp2 < row2->nlpcols && inlp2 < row2->len )
7254 assert(row1->
cols[ilp1]->
index == row1colsidx[ilp1]);
7255 assert(row1->
cols[inlp1]->
index == row1colsidx[inlp1]);
7256 assert(row2->
cols[ilp2]->
index == row2colsidx[ilp2]);
7257 assert(row2->
cols[inlp2]->
index == row2colsidx[inlp2]);
7258 assert((row1->
cols[ilp1] == row2->
cols[ilp2]) == (row1colsidx[ilp1] == row2colsidx[ilp2]));
7259 assert((row1->
cols[ilp1] == row2->
cols[inlp2]) == (row1colsidx[ilp1] == row2colsidx[inlp2]));
7260 assert((row1->
cols[inlp1] == row2->
cols[ilp2]) == (row1colsidx[inlp1] == row2colsidx[ilp2]));
7261 assert((row1->
cols[inlp1] == row2->
cols[inlp2]) == (row1colsidx[inlp1] == row2colsidx[inlp2]));
7264 if( row1colsidx[ilp1] == row2colsidx[ilp2] )
7271 else if( row1colsidx[ilp1] == row2colsidx[inlp2] )
7278 else if( row1colsidx[inlp1] == row2colsidx[ilp2] )
7285 else if( row1colsidx[inlp1] == row2colsidx[inlp2] && row1->
cols[inlp1]->
lppos >= 0 )
7292 else if( row1colsidx[ilp1] < row1colsidx[inlp1] )
7294 if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7296 if( row1colsidx[ilp1] < row2colsidx[ilp2] )
7303 if( row1colsidx[ilp1] < row2colsidx[inlp2] )
7311 if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7313 if( row1colsidx[inlp1] < row2colsidx[ilp2] )
7320 if( row1colsidx[inlp1] < row2colsidx[inlp2] )
7332 if( ilp1 != row1->
nlpcols && inlp1 != row1->
len )
7337 assert(ilp2 == row2->
nlpcols || inlp2 == row2->
len);
7360 assert(inlp1 == row1->
len);
7370 while( i1 < end1 && ilp2 < row2->nlpcols && inlp2 < row2->len )
7372 assert(row1->
cols[i1]->
index == row1colsidx[i1]);
7373 assert(row2->
cols[ilp2]->
index == row2colsidx[ilp2]);
7374 assert(row2->
cols[inlp2]->
index == row2colsidx[inlp2]);
7375 assert((row1->
cols[i1] == row2->
cols[ilp2]) == (row1colsidx[i1] == row2colsidx[ilp2]));
7376 assert((row1->
cols[i1] == row2->
cols[inlp2]) == (row1colsidx[i1] == row2colsidx[inlp2]));
7379 if( row1colsidx[i1] == row2colsidx[ilp2] )
7386 else if( row1colsidx[i1] == row2colsidx[inlp2] && (lpcols || row1->
cols[i1]->
lppos >= 0) )
7393 else if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7395 if( row1colsidx[i1] < row2colsidx[ilp2] )
7402 if( row1colsidx[i1] < row2colsidx[inlp2] )
7423 assert(inlp2 == row2->
len);
7430 while( i1 < end1 && i2 < end2 )
7432 assert(row1->
cols[i1]->
index == row1colsidx[i1]);
7433 assert(row2->
cols[i2]->
index == row2colsidx[i2]);
7434 assert((row1->
cols[i1] == row2->
cols[i2]) == (row1colsidx[i1] == row2colsidx[i2]));
7437 if( row1colsidx[i1] == row2colsidx[i2] && (lpcols || row1->
cols[i1]->
lppos >= 0) )
7444 else if( row1colsidx[i1] < row2colsidx[i2] )
7472 if( scalarprod == 0.0 )
7486 for( i = 0; i < row1->
len; ++i )
7496 for( i = 0; i < row2->
len; ++i )
7511 SCIPerrorMessage(
"invalid orthogonality function parameter '%c'\n", orthofunc);
7544 assert(row !=
NULL);
7561 parallelism =
MIN(parallelism, 1.0);
7562 parallelism =
MAX(parallelism, 0.0);
7578 assert(row !=
NULL);
7584 eventtype, row->
name, (
void*)eventhdlr, (
void*)eventdata);
7602 assert(row !=
NULL);
7605 SCIPsetDebugMsg(
set,
"drop event of row <%s> with handler %p and data %p\n", row->
name, (
void*)eventhdlr, (
void*)eventdata);
7618 assert(row !=
NULL);
7619 assert(stat !=
NULL);
7620 assert(stat->
nnodes > 0);
7636 assert(col !=
NULL);
7714 assert(
set !=
NULL);
7715 assert(col !=
NULL);
7765 assert(blkmem !=
NULL);
7766 assert(
set !=
NULL);
7783 for( c = lp->
nlpicols; c < lp->ncols; ++c )
7784 naddcoefs += lp->
cols[c]->
len;
7785 assert(naddcols > 0);
7798 for( pos = 0, c = lp->
nlpicols; c < lp->ncols; ++pos, ++c )
7801 assert(col !=
NULL);
7805 assert(col->
lppos == c);
7806 assert(nnonz + col->
nlprows <= naddcoefs);
7833 obj[pos] = col->
obj;
7845 for( i = 0; i < col->
nlprows; ++i )
7851 assert(lpipos < lp->nrows);
7852 assert(nnonz < naddcoefs);
7853 ind[nnonz] = lpipos;
7854 val[nnonz] = col->
vals[i];
7859 for( i = col->
nlprows; i < col->len; ++i )
7900 assert(row !=
NULL);
7985 assert(blkmem !=
NULL);
8001 for( r = lp->
nlpirows; r < lp->nrows; ++r )
8002 naddcoefs += lp->
rows[r]->
len;
8003 assert(naddrows > 0);
8015 for( pos = 0, r = lp->
nlpirows; r < lp->nrows; ++pos, ++r )
8018 assert(row !=
NULL);
8019 assert(row->
lppos == r);
8020 assert(nnonz + row->
nlpcols <= naddcoefs);
8050 name[pos] = row->
name;
8055 SCIPsetDebugMsg(
set,
"flushing added row (SCIP_LPI): %+g <=", lhs[pos]);
8056 for( i = 0; i < row->
nlpcols; ++i )
8062 assert(lpipos < lp->ncols);
8063 assert(nnonz < naddcoefs);
8065 ind[nnonz] = lpipos;
8066 val[nnonz] = row->
vals[i];
8072 for( i = row->
nlpcols; i < row->len; ++i )
8144 for( i = 0; i < lp->
nchgcols; ++i )
8147 assert(col !=
NULL);
8177 assert(nobjchg < lp->ncols);
8178 objind[nobjchg] = col->
lpipos;
8179 obj[nobjchg] = newobj;
8196 assert(nbdchg < lp->ncols);
8197 bdind[nbdchg] = col->
lpipos;
8214 SCIPsetDebugMsg(
set,
"flushing objective changes: change %d objective values of %d changed columns\n", nobjchg, lp->
nchgcols);
8227 SCIPsetDebugMsg(
set,
"flushing bound changes: change %d bounds of %d changed columns\n", nbdchg, lp->
nchgcols);
8282 for( i = 0; i < lp->
nchgrows; ++i )
8285 assert(row !=
NULL);
8310 assert(nchg < lp->nrows);
8366 for( i = 0; i < lp->
ncols; ++i )
8405 assert(blkmem !=
NULL);
8407 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",
8442 assert(ncols == lp->
ncols);
8443 assert(nrows == lp->
nrows);
8494 for( i = 0; i < lp->
nchgcols; ++i )
8499 assert(col !=
NULL);
8533 for( i = 0; i < lp->
nchgrows; ++i )
8538 assert(row !=
NULL);
8588 assert(col !=
NULL);
8589 assert(col->
lppos >= 0);
8592 for( i = 0; i < col->
len; ++i )
8598 assert(row !=
NULL);
8599 assert(row->
linkpos[pos] == i);
8600 assert(row->
cols[pos] == col);
8601 assert(row->
nlpcols <= pos && pos < row->len);
8627 assert(row !=
NULL);
8628 assert(row->
lppos >= 0);
8631 for( i = 0; i < row->
len; ++i )
8637 assert(col !=
NULL);
8638 assert(col->
linkpos[pos] == i);
8639 assert(col->
rows[pos] == row);
8640 assert(col->
nlprows <= pos && pos < col->len);
8663 assert(col !=
NULL);
8664 assert(col->
lppos == -1);
8667 for( i = 0; i < col->
len; ++i )
8673 assert(row !=
NULL);
8674 assert(row->
linkpos[pos] == i);
8675 assert(row->
cols[pos] == col);
8676 assert(0 <= pos && pos < row->nlpcols);
8701 assert(row !=
NULL);
8702 assert(row->
lppos == -1);
8705 for( i = 0; i < row->
len; ++i )
8711 assert(col !=
NULL);
8712 assert(0 <= pos && pos < col->nlprows);
8713 assert(col->
linkpos[pos] == i);
8714 assert(col->
rows[pos] == row);
8738 assert(initsize > 0);
8761 assert(minsize > 0);
8763 if( minsize <= lp->divechgsidessize )
8792 #define DIVESTACKINITSIZE 100 8806 assert(
set !=
NULL);
8807 assert(stat !=
NULL);
8808 assert(name !=
NULL);
8815 (*lp)->lpicols =
NULL;
8816 (*lp)->lpirows =
NULL;
8817 (*lp)->chgcols =
NULL;
8818 (*lp)->chgrows =
NULL;
8820 (*lp)->lazycols =
NULL;
8823 (*lp)->lpobjval = 0.0;
8824 (*lp)->glbpseudoobjval = 0.0;
8825 (*lp)->relglbpseudoobjval = 0.0;
8826 (*lp)->glbpseudoobjvalid =
TRUE;
8827 (*lp)->glbpseudoobjvalinf = 0;
8828 (*lp)->pseudoobjval = 0.0;
8829 (*lp)->relpseudoobjval = 0.0;
8830 (*lp)->pseudoobjvalid =
TRUE;
8831 (*lp)->pseudoobjvalinf = 0;
8832 (*lp)->looseobjval = 0.0;
8833 (*lp)->rellooseobjval = 0.0;
8834 (*lp)->looseobjvalid =
TRUE;
8835 (*lp)->looseobjvalinf = 0;
8836 (*lp)->nloosevars = 0;
8840 (*lp)->objsqrnorm = 0.0;
8841 (*lp)->objsumnorm = 0.0;
8842 (*lp)->lpicolssize = 0;
8843 (*lp)->nlpicols = 0;
8844 (*lp)->lpirowssize = 0;
8845 (*lp)->nlpirows = 0;
8846 (*lp)->lpifirstchgcol = 0;
8847 (*lp)->lpifirstchgrow = 0;
8848 (*lp)->colssize = 0;
8850 (*lp)->lazycolssize = 0;
8851 (*lp)->nlazycols = 0;
8852 (*lp)->rowssize = 0;
8854 (*lp)->chgcolssize = 0;
8855 (*lp)->nchgcols = 0;
8856 (*lp)->chgrowssize = 0;
8857 (*lp)->nchgrows = 0;
8858 (*lp)->firstnewcol = 0;
8859 (*lp)->firstnewrow = 0;
8860 (*lp)->nremovablecols = 0;
8861 (*lp)->nremovablerows = 0;
8862 (*lp)->validsollp = stat->
lpcount;
8863 (*lp)->validfarkaslp = -1;
8864 (*lp)->objsqrnormunreliable =
FALSE;
8865 (*lp)->flushdeletedcols =
FALSE;
8866 (*lp)->flushaddedcols =
FALSE;
8867 (*lp)->flushdeletedrows =
FALSE;
8868 (*lp)->flushaddedrows =
FALSE;
8869 (*lp)->updateintegrality =
TRUE;
8870 (*lp)->flushed =
TRUE;
8871 (*lp)->solved =
TRUE;
8872 (*lp)->primalfeasible =
TRUE;
8873 (*lp)->dualfeasible =
TRUE;
8874 (*lp)->solisbasic =
FALSE;
8875 (*lp)->rootlpisrelax =
TRUE;
8876 (*lp)->isrelax =
TRUE;
8877 (*lp)->installing =
FALSE;
8878 (*lp)->strongbranching =
FALSE;
8879 (*lp)->strongbranchprobing =
FALSE;
8880 (*lp)->probing =
FALSE;
8881 (*lp)->diving =
FALSE;
8882 (*lp)->divingobjchg =
FALSE;
8883 (*lp)->divinglazyapplied =
FALSE;
8884 (*lp)->divelpistate =
NULL;
8885 (*lp)->divelpwasprimfeas =
TRUE;
8886 (*lp)->divelpwasdualfeas =
TRUE;
8887 (*lp)->divechgsides =
NULL;
8888 (*lp)->divechgsidetypes =
NULL;
8889 (*lp)->divechgrows =
NULL;
8890 (*lp)->ndivechgsides = 0;
8891 (*lp)->divechgsidessize = 0;
8892 (*lp)->ndivingrows = 0;
8893 (*lp)->divinglpiitlim = INT_MAX;
8894 (*lp)->resolvelperror =
FALSE;
8895 (*lp)->adjustlpval =
FALSE;
8900 (*lp)->lpifromscratch =
FALSE;
8901 (*lp)->lpifastmip =
set->lp_fastmip;
8902 (*lp)->lpiscaling =
set->lp_scaling;
8903 (*lp)->lpipresolving =
set->lp_presolving;
8904 (*lp)->lpilpinfo =
set->disp_lpinfo;
8905 (*lp)->lpirowrepswitch =
set->lp_rowrepswitch;
8906 (*lp)->lpisolutionpolishing = (
set->lp_solutionpolishing > 0);
8907 (*lp)->lpiconditionlimit =
set->lp_conditionlimit;
8908 (*lp)->lpiitlim = INT_MAX;
8911 (*lp)->lpithreads =
set->lp_threads;
8912 (*lp)->lpitiming = (int) set->time_clocktype;
8913 (*lp)->lpirandomseed = set->random_randomseed;
8914 (*lp)->storedsolvals =
NULL;
8924 "LP Solver <%s>: upper objective limit cannot be set -- can lead to unnecessary simplex iterations\n",
8928 (*lp)->lpihasfeastol = success;
8932 "LP Solver <%s>: primal feasibility tolerance cannot be set -- tolerance of SCIP and LP solver may differ\n",
8936 (*lp)->lpihasdualfeastol = success;
8940 "LP Solver <%s>: dual feasibility tolerance cannot be set -- tolerance of SCIP and LP solver may differ\n",
8944 (*lp)->lpihasbarrierconvtol = success;
8948 "LP Solver <%s>: barrier convergence tolerance cannot be set -- tolerance of SCIP and LP solver may differ\n",
8953 (*lp)->lpihasfastmip = success;
8957 "LP Solver <%s>: fastmip setting not available -- SCIP parameter has no effect\n",
8961 (*lp)->lpihasscaling = success;
8965 "LP Solver <%s>: scaling not available -- SCIP parameter has no effect\n",
8969 (*lp)->lpihaspresolving = success;
8973 "LP Solver <%s>: presolving not available -- SCIP parameter has no effect\n",
8980 "LP Solver <%s>: clock type cannot be set\n",
8987 "LP Solver <%s>: iteration limit cannot be set -- can lead to unnecessary simplex iterations\n",
8994 "LP Solver <%s>: pricing strategy cannot be set -- SCIP parameter has no effect\n",
9001 "LP Solver <%s>: lpinfo setting not available -- SCIP parameter has no effect\n",
9005 (*lp)->lpihasrowrep = success;
9009 "LP Solver <%s>: row representation of the basis not available -- SCIP parameter lp/rowrepswitch has no effect\n",
9013 (*lp)->lpihaspolishing = success;
9017 "LP Solver <%s>: solution polishing not available -- SCIP parameter lp/solutionpolishing has no effect\n",
9024 "LP Solver <%s>: condition number limit for the basis not available -- SCIP parameter lp/conditionlimit has no effect\n",
9031 "LP Solver <%s>: number of threads settings not available -- SCIP parameter has no effect\n",
9035 if( (*lp)->lpirandomseed != 0 )
9041 "LP Solver <%s>: random seed parameter not available -- SCIP parameter has no effect\n",
9061 assert(*lp !=
NULL);
9068 for( i = 0; i < (*lp)->nlpirows; ++i )
9073 if( (*lp)->lpi !=
NULL )
9103 assert(stat !=
NULL);
9132 assert(col !=
NULL);
9134 assert(col->
lppos == -1);
9145 for( i = 0; i < col->
len; ++i )
9193 assert(row !=
NULL);
9195 assert(row->
lppos == -1);
9205 for( i = 0; i < row->
len; ++i )
9272 for( c = 0; c < lp->
ncols; ++c )
9285 for( c = 0; c < lp->
ncols; ++c )
9302 #define checkLazyColArray(lp, set) 9318 assert(0 <= newncols);
9319 assert(newncols <= lp->ncols);
9321 if( newncols < lp->ncols )
9325 for( c = lp->
ncols-1; c >= newncols; --c )
9328 assert(col !=
NULL);
9333 assert(col->
lppos == c);
9350 assert(lp->
ncols == newncols);
9355 while( c < lp->nlazycols )
9391 assert(0 <= newnrows && newnrows <= lp->nrows);
9394 if( newnrows < lp->nrows )
9396 for( r = lp->
nrows-1; r >= newnrows; --r )
9399 assert(row !=
NULL);
9401 assert(row->
lppos == r);
9430 assert(lp->
nrows == newnrows);
9498 assert(basisind !=
NULL);
9536 assert(0 <= r && r < lp->nrows);
9537 assert(coef !=
NULL);
9562 assert(0 <= c && c < lp->nrows);
9563 assert(coef !=
NULL);
9585 assert(0 <= r && r < lp->nrows);
9586 assert(coef !=
NULL);
9609 assert(0 <= c && c < lp->ncols);
9610 assert(coef !=
NULL);
9638 assert(prob !=
NULL);
9639 assert(weights !=
NULL);
9640 assert(sumcoef !=
NULL);
9641 assert(sumlhs !=
NULL);
9642 assert(sumrhs !=
NULL);
9650 lhsinfinite =
FALSE;
9651 rhsinfinite =
FALSE;
9652 for( r = 0; r < lp->
nrows; ++r )
9657 assert(row !=
NULL);
9663 for( i = 0; i < row->
len; ++i )
9671 assert(0 <= idx && idx < prob->nvars);
9676 if( weights[r] > 0.0 )
9680 (*sumlhs) += weights[r] * (row->
lhs - row->
constant);
9683 (*sumrhs) += weights[r] * (row->
rhs - row->
constant);
9689 (*sumlhs) += weights[r] * (row->
rhs - row->
constant);
9692 (*sumrhs) += weights[r] * (row->
lhs - row->
constant);
9715 assert(blkmem !=
NULL);
9716 assert(lpistate !=
NULL);
9741 assert(blkmem !=
NULL);
9751 if( lpistate ==
NULL )
9776 if( *lpistate !=
NULL )
9794 assert(blkmem !=
NULL);
9795 assert(lpinorms !=
NULL);
9816 assert(blkmem !=
NULL);
9820 if( lpinorms !=
NULL )
9906 return "primal simplex";
9908 return "dual simplex";
9912 return "barrier/crossover";
9937 assert(
set !=
NULL);
9938 assert(stat !=
NULL);
9939 assert(lperror !=
NULL);
9941 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",
9952 SCIPmessagePrintInfo(
"wrote LP to file <%s> (primal simplex, uobjlim=%.15g, feastol=%.15g/%.15g, fromscratch=%d, fastmip=%d, scaling=%d, presolving=%d)\n",
9979 SCIPsetDebugMsg(
set,
"(node %" SCIP_LONGINT_FORMAT
") primal simplex solving error in LP %" SCIP_LONGINT_FORMAT
"\n", stat->
nnodes, stat->
nlps);
10005 if( iterations > 0 )
10010 SCIPstatAdd( stat,
set, nlpiterations, iterations );
10015 SCIPstatAdd(stat,
set, nprimalresolvelpiterations, iterations);
10022 SCIPstatAdd(stat,
set, nsbdivinglpiterations, iterations);
10028 SCIPstatAdd(stat,
set, ndivinglpiterations, iterations);
10034 SCIPstatAdd(stat,
set, nprimallpiterations, iterations);
10042 SCIPstatAdd(stat,
set, primalzeroittime, timedelta);
10045 if ( keepsol && !(*lperror) )
10055 SCIPsetDebugMsg(
set,
"solved LP %" SCIP_LONGINT_FORMAT
" with primal simplex (diving=%d, nprimallps=%" SCIP_LONGINT_FORMAT
", ndivinglps=%" SCIP_LONGINT_FORMAT
")\n",
10076 assert(lp !=
NULL);
10078 assert(
set !=
NULL);
10079 assert(stat !=
NULL);
10080 assert(lperror !=
NULL);
10082 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",
10093 SCIPmessagePrintInfo(
"wrote LP to file <%s> (dual simplex, uobjlim=%.15g, feastol=%.15g/%.15g, fromscratch=%d, fastmip=%d, scaling=%d, presolving=%d)\n",
10120 SCIPsetDebugMsg(
set,
"(node %" SCIP_LONGINT_FORMAT
") dual simplex solving error in LP %" SCIP_LONGINT_FORMAT
"\n", stat->
nnodes, stat->
nlps);
10146 if( iterations > 0 )
10151 SCIPstatAdd(stat,
set, nlpiterations, iterations);
10156 SCIPstatAdd(stat,
set, ndualresolvelpiterations, iterations);
10163 SCIPstatAdd(stat,
set, nsbdivinglpiterations, iterations);
10169 SCIPstatAdd(stat,
set, ndivinglpiterations, iterations);
10175 SCIPstatAdd(stat,
set, nduallpiterations, iterations);
10183 SCIPstatAdd(stat,
set, dualzeroittime, timedelta);
10186 if( keepsol && !(*lperror) )
10196 SCIPsetDebugMsg(
set,
"solved LP %" SCIP_LONGINT_FORMAT
" with dual simplex (diving=%d, nduallps=%" SCIP_LONGINT_FORMAT
", ndivinglps=%" SCIP_LONGINT_FORMAT
")\n",
10248 int totalIterations;
10253 assert(lp !=
NULL);
10255 assert(
set !=
NULL);
10256 assert(stat !=
NULL);
10257 assert(lperror !=
NULL);
10259 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",
10285 SCIPsetDebugMsg(
set,
"(node %" SCIP_LONGINT_FORMAT
") dual simplex solving error in LP %" SCIP_LONGINT_FORMAT
"\n", stat->
nnodes, stat->
nlps);
10292 totalIterations = iterations;
10310 if( iterations > 0 )
10314 SCIPstatAdd(stat,
set, nlpiterations, iterations);
10319 SCIPstatAdd(stat,
set, ndualresolvelpiterations, iterations);
10326 SCIPstatAdd(stat,
set, nsbdivinglpiterations, iterations);
10332 SCIPstatAdd(stat,
set, ndivinglpiterations, iterations);
10338 SCIPstatAdd(stat,
set, nduallpiterations, iterations);
10346 SCIPstatAdd(stat,
set, dualzeroittime, timedelta);
10383 chooseBasic =
set->lp_lexdualbasic;
10429 for( c = 0; c < lp->
nlpicols; ++c )
10440 for( r = 0; r < lp->
nlpirows; ++r )
10449 #ifdef DEBUG_LEXDUAL 10455 assert(primsol ==
NULL);
10458 assert(primsol !=
NULL);
10462 for( j = 0; j < lp->
nlpicols; ++j )
10498 assert(primsol ==
NULL);
10518 assert(primsol ==
NULL);
10529 for( c = 0; c < lp->
nlpicols; ++c )
10537 if( pos == -1 && c > oldpos )
10550 if( pos == -1 && c > oldpos )
10555 newlb[cntcol] = oldlb[c];
10556 newub[cntcol] = oldlb[c];
10557 indcol[cntcol++] = c;
10572 newlb[cntcol] = oldlb[c];
10573 newub[cntcol] = oldlb[c];
10579 newlb[cntcol] = oldub[c];
10580 newub[cntcol] = oldub[c];
10585 newlb[cntcol] = 0.0;
10586 newub[cntcol] = 0.0;
10589 indcol[cntcol++] = c;
10598 for( r = 0; r < lp->
nlpirows; ++r )
10613 newlhs[cntrow] = oldlhs[r];
10614 newrhs[cntrow] = oldlhs[r];
10619 newlhs[cntrow] = oldrhs[r];
10620 newrhs[cntrow] = oldrhs[r];
10622 indrow[cntrow++] = r;
10629 if( nDualDeg > 0 && pos >= 0 )
10631 assert(0 <= pos && pos < lp->nlpicols && pos > oldpos);
10656 SCIPsetDebugMsg(
set,
"(node %" SCIP_LONGINT_FORMAT
") in lex-dual: primal simplex solving error in LP %" SCIP_LONGINT_FORMAT
"\n", stat->
nnodes, stat->
nlps);
10663 lexIterations += iterations;
10665 #ifdef DEBUG_LEXDUAL 10666 if( iterations > 0 )
10672 assert(primsol ==
NULL);
10675 assert(primsol !=
NULL);
10678 for( j = 0; j < lp->
nlpicols; ++j )
10715 SCIPsetDebugMsg(
set,
"%f (%d) %c%c%c ", primsol[j], j, cstart, type, cend);
10723 assert(primsol ==
NULL);
10729 if( iterations > 0 )
10734 while( pos >= 0 && nDualDeg > 0 && (set->lp_lexdualmaxrounds == -1 || rounds < set->lp_lexdualmaxrounds) );
10746 SCIPsetDebugMsg(
set,
"(node %" SCIP_LONGINT_FORMAT
") dual simplex solving error in LP %" SCIP_LONGINT_FORMAT
"\n", stat->
nnodes, stat->
nlps);
10754 lexIterations += iterations;
10762 if( lexIterations > 0 )
10764 SCIPstatAdd(stat,
set, nlpiterations, lexIterations);
10768 SCIPstatAdd(stat,
set, nlexdualresolvelpiterations, lexIterations);
10771 SCIPstatAdd(stat,
set, nlexduallpiterations, lexIterations);
10773 totalIterations += lexIterations;
10810 SCIPsetDebugMsg(
set,
"solved LP %" SCIP_LONGINT_FORMAT
" with lex dual simplex (diving=%d, nduallps=%" SCIP_LONGINT_FORMAT
", ndivinglps=%" SCIP_LONGINT_FORMAT
")\n",
10820 if( keepsol && !(*lperror) )
10848 assert(lp !=
NULL);
10850 assert(
set !=
NULL);
10851 assert(stat !=
NULL);
10852 assert(lperror !=
NULL);
10854 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",
10866 SCIPmessagePrintInfo(
"wrote LP to file <%s> (barrier, uobjlim=%.15g, feastol=%.15g/%.15g, convtol=%.15g, fromscratch=%d, fastmip=%d, scaling=%d, presolving=%d)\n",
10893 SCIPsetDebugMsg(
set,
"(node %" SCIP_LONGINT_FORMAT
") barrier solving error in LP %" SCIP_LONGINT_FORMAT
"\n", stat->
nnodes, stat->
nlps);
10919 if( iterations > 0 )
10924 SCIPstatAdd(stat,
set, nlpiterations, iterations);
10931 SCIPstatAdd(stat,
set, nsbdivinglpiterations, iterations);
10937 SCIPstatAdd(stat,
set, ndivinglpiterations, iterations);
10943 SCIPstatAdd(stat,
set, nbarrierlpiterations, iterations);
10951 SCIPstatAdd(stat,
set, barrierzeroittime, timedelta);
10954 if( keepsol && !(*lperror) )
10964 SCIPsetDebugMsg(
set,
"solved LP %" SCIP_LONGINT_FORMAT
" with barrier%s (diving=%d, nduallps=%" SCIP_LONGINT_FORMAT
", nbarrierlps=%" SCIP_LONGINT_FORMAT
")\n",
10986 assert(lp !=
NULL);
10988 assert(lperror !=
NULL);
10992 if( set->istimelimitfinite )
10996 if( lptimelimit > 0.0 )
10999 if( lptimelimit <= 0.0 || !success )
11001 SCIPsetDebugMsg(
set,
"time limit of %f seconds could not be set\n", lptimelimit);
11002 *lperror = ((lptimelimit > 0.0) ?
TRUE :
FALSE);
11017 if( set->lp_lexdualalgo && (!set->lp_lexdualrootonly || stat->
maxdepth == 0) && (!set->lp_lexdualstalling || lp->
installing) )
11051 #define FEASTOLTIGHTFAC 0.001 11080 assert(lp !=
NULL);
11082 assert(
set !=
NULL);
11083 assert(stat !=
NULL);
11084 assert(lperror !=
NULL);
11085 assert(timelimit !=
NULL);
11096 SCIPerrorMessage(
"cannot solve LP when loose variable with infinite best bound is present\n");
11104 itlimishard = (itlim == harditlim);
11109 usepolishing =
TRUE;
11116 usepolishing =
FALSE;
11151 else if( !set->lp_checkstability )
11157 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- ignoring instability of %s\n",
11176 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- solve again with %s without FASTMIP\n",
11183 else if( !set->lp_checkstability )
11189 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- ignoring instability of %s\n",
11207 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- solve again with %s %s scaling\n",
11214 else if( !set->lp_checkstability )
11220 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- ignoring instability of %s\n",
11242 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- solve again with %s %s presolving\n",
11249 else if( !set->lp_checkstability )
11255 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- ignoring instability of %s\n",
11270 if( ((simplex && (!tightprimfeastol || !tightdualfeastol)) || (!tightprimfeastol && !tightdualfeastol)) &&
11274 if( !tightprimfeastol )
11280 if( !tightdualfeastol )
11286 if( !simplex && !tightprimfeastol && !tightdualfeastol )
11291 if( success || success2 || success3 )
11294 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- solve again with %s with tighter primal and dual feasibility tolerance\n",
11301 else if( !set->lp_checkstability )
11307 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- ignoring instability of %s\n",
11314 if( !tightprimfeastol )
11318 if( !tightdualfeastol )
11322 if( !simplex && !tightprimfeastol && !tightdualfeastol )
11334 if( !fromscratch && simplex )
11340 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- solve again from scratch with %s\n",
11347 else if( !set->lp_checkstability )
11353 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- ignoring instability of %s\n",
11366 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- solve again from scratch with %s\n",
11373 else if( !set->lp_checkstability )
11379 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- ignoring instability of %s\n",
11390 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- solve again from scratch with %s %s scaling\n",
11397 else if( !set->lp_checkstability )
11403 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- ignoring instability of %s\n",
11419 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- solve again from scratch with %s %s presolving\n",
11426 else if( !set->lp_checkstability )
11432 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- ignoring instability of %s\n",
11444 if( !tightprimfeastol || !tightdualfeastol )
11447 if( !tightprimfeastol )
11453 if( !tightdualfeastol )
11458 if( success || success2 )
11461 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- solve again from scratch with %s with tighter feasibility tolerance\n",
11468 else if( !set->lp_checkstability )
11474 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- ignoring instability of %s\n",
11481 if( !tightprimfeastol )
11485 if( !tightdualfeastol )
11509 assert(lp !=
NULL);
11510 assert(
set !=
NULL);
11559 assert(lp !=
NULL);
11561 assert(
set !=
NULL);
11562 assert(stat !=
NULL);
11563 assert(lperror !=
NULL);
11567 solvedprimal =
FALSE;
11568 solveddual =
FALSE;
11572 itlim = ( resolve ? resolveitlim : harditlim );
11576 SCIP_CALL(
lpSolveStable(lp,
set, messagehdlr, stat, prob, lpalgo, itlim, harditlim, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch,
11577 keepsol, &timelimit, lperror) );
11673 "(node %" SCIP_LONGINT_FORMAT
") solution status of LP %" SCIP_LONGINT_FORMAT
" could not be proven (internal status:%d) -- solve again with %s\n",
11682 "(node %" SCIP_LONGINT_FORMAT
") solution status of LP %" SCIP_LONGINT_FORMAT
" could not be proven (internal status:%d) -- solve again with %s\n",
11688 SCIPerrorMessage(
"(node %" SCIP_LONGINT_FORMAT
") error or unknown return status of %s in LP %" SCIP_LONGINT_FORMAT
" (internal status: %d)\n",
11696 SCIPsetDebugMsg(
set,
"solving LP with %s returned solstat=%d (internal status: %d, primalfeasible=%u, dualfeasible=%u)\n",
11728 assert(lp !=
NULL);
11729 assert(
set !=
NULL);
11730 assert(lperror !=
NULL);
11738 algo = resolve ?
set->lp_resolvealgorithm :
set->lp_initalgorithm;
11748 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, keepsol, lperror) );
11754 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, keepsol, lperror) );
11761 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, keepsol, lperror) );
11767 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, keepsol, lperror) );
11773 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, keepsol, lperror) );
11779 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, keepsol, lperror) );
11783 SCIPerrorMessage(
"invalid parameter setting <%c> for LP algorithm\n", algo);
11786 assert(!(*lperror) || !lp->
solved);
11814 #define checkLazyBounds(lp, set) 11837 SCIPsetDebugMsg(
set,
"mark all lazy columns as changed in order to reload bounds (diving=%u, applied=%u)\n",
11890 if( (set->lp_resolveiterfac == -1) || stat->
nlps - stat->
nrootlps < 5 )
11896 return (
int)
MIN(itlim,
MAX(set->lp_resolveitermin,
11926 assert(lp !=
NULL);
11927 assert(prob !=
NULL);
11929 assert(lperror !=
NULL);
11931 SCIPsetDebugMsg(
set,
"solving LP: %d rows, %d cols, primalfeasible=%u, dualfeasible=%u, solved=%u, diving=%u, probing=%u, cutoffbnd=%g\n",
11938 needprimalray =
TRUE;
11940 || (
set->conf_enable &&
set->conf_useinflp !=
'o'));
11943 harditlim = (int)
MIN(itlim, INT_MAX);
11944 resolveitlim = ( limitresolveiters ?
lpGetResolveItlim(
set, stat, harditlim) : harditlim );
11945 assert(harditlim == -1 || (resolveitlim <= harditlim));
11982 tightprimfeastol =
FALSE;
11983 tightdualfeastol =
FALSE;
11984 fromscratch =
FALSE;
11985 primalfeasible =
FALSE;
11986 dualfeasible =
FALSE;
11987 wasfromscratch = (stat->
nlps == 0);
11991 oldnlps = stat->
nlps;
11992 SCIP_CALL(
lpFlushAndSolve(lp, blkmem,
set, messagehdlr, stat, prob, eventqueue, resolveitlim, harditlim, needprimalray,
11993 needdualray, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, keepsol, lperror) );
11995 assert(!(*lperror) || !lp->
solved);
12009 if( set->lp_checkprimfeas )
12010 primalfeaspointer = &primalfeasible;
12014 primalfeasible =
TRUE;
12015 primalfeaspointer =
NULL;
12017 if( set->lp_checkdualfeas )
12018 dualfeaspointer = &dualfeasible;
12022 dualfeasible =
TRUE;
12023 dualfeaspointer =
NULL;
12031 if( primalfeasible && dualfeasible && aging && !lp->
diving && stat->
nlps > oldnlps )
12035 if( stat->
nlps % ((set->lp_rowagelimit+1)/2 + 1) == 0 )
12048 if( !primalfeasible || !dualfeasible )
12052 if( (fastmip > 0) && simplex )
12056 "(node %" SCIP_LONGINT_FORMAT
") solution of LP %" SCIP_LONGINT_FORMAT
" not optimal (pfeas=%d, dfeas=%d) -- solving again without FASTMIP\n",
12057 stat->
nnodes, stat->
nlps, primalfeasible, dualfeasible);
12061 else if( (!primalfeasible && !tightprimfeastol) || (!dualfeasible && !tightdualfeastol) )
12067 "(node %" SCIP_LONGINT_FORMAT
") solution of LP %" SCIP_LONGINT_FORMAT
" not optimal (pfeas=%d, dfeas=%d) -- solving again with tighter feasibility tolerance\n",
12068 stat->
nnodes, stat->
nlps, primalfeasible, dualfeasible);
12069 tightprimfeastol = tightprimfeastol || !primalfeasible;
12070 tightdualfeastol = tightdualfeastol || !dualfeasible;
12073 else if( !fromscratch && !wasfromscratch && simplex )
12077 "(node %" SCIP_LONGINT_FORMAT
") solution of LP %" SCIP_LONGINT_FORMAT
" not optimal (pfeas=%d, dfeas=%d) -- solving again from scratch\n",
12078 stat->
nnodes, stat->
nlps, primalfeasible, dualfeasible);
12079 fromscratch =
TRUE;
12085 "(node %" SCIP_LONGINT_FORMAT
") unresolved numerical troubles in LP %" SCIP_LONGINT_FORMAT
"\n", stat->
nnodes, stat->
nlps);
12091 SCIPsetDebugMsg(
set,
" -> LP objective value: %g + %g = %g (solstat=%d, cutoff=%g)\n",
12110 "(node %" SCIP_LONGINT_FORMAT
") infeasibility of LP %" SCIP_LONGINT_FORMAT
" could not be proven by dual ray\n", stat->
nnodes, stat->
nlps);
12119 if( set->lp_checkprimfeas )
12129 primalfeasible =
TRUE;
12130 rayfeasible =
TRUE;
12136 SCIPsetDebugMsg(
set,
" -> LP has unbounded primal ray (primalfeas=%u, rayfeas=%u)\n",
12137 primalfeasible, rayfeasible);
12139 if( !primalfeasible || !rayfeasible )
12143 if( (fastmip > 0) && simplex )
12147 "(node %" SCIP_LONGINT_FORMAT
") solution of unbounded LP %" SCIP_LONGINT_FORMAT
" not optimal (pfeas=%d, rfeas=%d) -- solving again without FASTMIP\n",
12148 stat->
nnodes, stat->
nlps, primalfeasible, rayfeasible);
12152 else if( !tightprimfeastol )
12158 "(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",
12159 stat->
nnodes, stat->
nlps, primalfeasible, rayfeasible);
12160 tightprimfeastol =
TRUE;
12163 else if( !fromscratch && simplex )
12167 "(node %" SCIP_LONGINT_FORMAT
") solution of unbounded LP %" SCIP_LONGINT_FORMAT
" not optimal (pfeas=%d, rfeas=%d) -- solving again from scratch\n",
12168 stat->
nnodes, stat->
nlps, primalfeasible, rayfeasible);
12169 fromscratch =
TRUE;
12178 "(node %" SCIP_LONGINT_FORMAT
") unresolved numerical troubles in unbounded LP %" SCIP_LONGINT_FORMAT
"\n", stat->
nnodes, stat->
nlps);
12203 assert(lpi !=
NULL);
12215 char tmppricingchar;
12221 fromscratch =
FALSE;
12233 FALSE,
FALSE,
TRUE, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, keepsol, lperror) );
12248 SCIPsetDebugMsg(
set,
" ---> new objval = %f (solstat: %d, 1 add. step)\n", objval, solstat);
12260 assert(!(*lperror));
12263 FALSE,
FALSE,
TRUE, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, keepsol, lperror) );
12271 SCIPsetDebugMsg(
set,
" ---> new objval = %f (solstat: %d, without fastmip)\n", objval, solstat);
12277 SCIPsetDebugMsg(
set,
"unresolved error while resolving LP in order to exceed the objlimit\n");
12293 if( set->lp_checkprimfeas )
12294 primalfeaspointer = &primalfeasible;
12298 primalfeasible =
TRUE;
12299 primalfeaspointer =
NULL;
12301 if( set->lp_checkdualfeas )
12302 dualfeaspointer = &dualfeasible;
12306 dualfeasible =
TRUE;
12307 dualfeaspointer =
NULL;
12331 if( !primalfeasible || !dualfeasible
12336 "(node %" SCIP_LONGINT_FORMAT
") unresolved numerical troubles in LP %" SCIP_LONGINT_FORMAT
"\n", stat->
nnodes, stat->
nlps);
12342 SCIPsetDebugMsg(
set,
" -> LP objective value: %g + %g = %g (solstat=%d, cutoff=%g)\n",
12355 if( set->lp_checkprimfeas )
12365 primalfeasible =
TRUE;
12366 rayfeasible =
TRUE;
12374 if( !primalfeasible || !rayfeasible )
12383 "(node %" SCIP_LONGINT_FORMAT
") unresolved numerical troubles in unbounded LP %" SCIP_LONGINT_FORMAT
"\n", stat->
nnodes, stat->
nlps);
12418 SCIPmessagePrintWarning(messagehdlr,
"LP solver reached time limit, but SCIP time limit is not exceeded yet; " 12419 "you might consider switching the clock type of SCIP\n");
12436 assert(!(*lperror) || !lp->
solved);
12445 SCIPsetDebugMsg(
set,
"resetting parameter SCIP_LPPARAM_FROMSCRATCH to FALSE %s\n", success ?
"" :
"failed");
12456 assert(lp !=
NULL);
12474 assert(lp !=
NULL);
12477 assert(
set !=
NULL);
12500 assert(lp !=
NULL);
12513 assert(lp !=
NULL);
12516 assert(
set !=
NULL);
12533 assert(lp !=
NULL);
12544 assert(lp !=
NULL);
12561 assert(lp !=
NULL);
12562 assert(
set !=
NULL);
12563 assert(prob !=
NULL);
12566 nvars = prob->
nvars;
12574 for( v = 0; v < nvars; ++v )
12625 assert(lp !=
NULL);
12627 assert(
set !=
NULL);
12654 assert(lp !=
NULL);
12656 assert(
set !=
NULL);
12686 int pseudoobjvalinf;
12697 pseudoobjval -= oldbound * obj;
12698 assert(pseudoobjvalinf >= 0);
12702 pseudoobjval += newbound * obj;
12704 assert(pseudoobjvalinf >= 0);
12706 if( pseudoobjvalinf > 0 || set->nactivepricers > 0 )
12709 return pseudoobjval;
12725 int pseudoobjvalinf;
12751 assert(pseudoobjvalinf >= 0);
12763 assert(pseudoobjvalinf >= 0);
12765 if( pseudoobjvalinf > 0 || set->nactivepricers > 0 )
12768 return pseudoobjval;
12799 (*deltaval) = lb * (newobj - oldobj);
12810 (*deltaval) = ub * newobj;
12819 (*deltaval) = -lb * oldobj;
12824 (*deltaval) = (ub * newobj) - (lb * oldobj);
12834 (*deltaval) = -lb * oldobj;
12845 (*deltaval) = ub * (newobj - oldobj);
12856 (*deltaval) = lb * newobj;
12865 (*deltaval) = -ub * oldobj;
12870 (*deltaval) = (lb * newobj) - (ub * oldobj);
12880 (*deltaval) = -ub * oldobj;
12891 (*deltaval) = ub * newobj;
12898 (*deltaval) = lb * newobj;
12924 (*deltaval) = newlb * obj;
12935 (*deltaval) = -oldlb * obj;
12940 (*deltaval) = obj * (newlb - oldlb);
12965 (*deltaval) = newub * obj;
12976 (*deltaval) = -oldub * obj;
12981 (*deltaval) = obj * (newub - oldub);
12998 assert(lp !=
NULL);
13088 assert(lp !=
NULL);
13097 assert(var !=
NULL);
13101 SCIPerrorMessage(
"LP was informed of an objective change of a non-active variable\n");
13123 else if( oldobj < 0.0 )
13149 else if( newobj < 0.0 )
13190 assert(
set !=
NULL);
13191 assert(var !=
NULL);
13193 if( set->misc_exactsolve )
13195 if( oldobj != newobj )
13244 assert(
set !=
NULL);
13245 assert(var !=
NULL);
13272 assert(
set !=
NULL);
13273 assert(var !=
NULL);
13275 if( set->misc_exactsolve )
13313 assert(
set !=
NULL);
13314 assert(var !=
NULL);
13340 assert(
set !=
NULL);
13341 assert(var !=
NULL);
13343 if( set->misc_exactsolve )
13379 assert(lp !=
NULL);
13400 assert(lp !=
NULL);
13428 assert(lp !=
NULL);
13479 assert(lp !=
NULL);
13536 assert(
set !=
NULL);
13538 if( set->misc_exactsolve )
13562 assert(lp !=
NULL);
13611 assert(lp !=
NULL);
13660 assert(
set !=
NULL);
13662 if( set->misc_exactsolve )
13679 assert(lp !=
NULL);
13719 assert(lp !=
NULL);
13722 assert(
set !=
NULL);
13723 assert(stat !=
NULL);
13729 if( primalfeasible ==
NULL )
13730 stillprimalfeasible =
FALSE;
13733 *primalfeasible =
TRUE;
13734 stillprimalfeasible =
TRUE;
13736 if( dualfeasible ==
NULL )
13737 stilldualfeasible =
FALSE;
13740 *dualfeasible =
TRUE;
13741 stilldualfeasible =
TRUE;
13749 SCIPsetDebugMsg(
set,
"getting new LP solution %" SCIP_LONGINT_FORMAT
" for solstat %d\n",
13781 for( c = 0; c < nlpicols; ++c )
13783 assert( 0 <= cstat[c] && cstat[c] < 4 );
13784 lpicols[c]->
primsol = primsol[c];
13785 lpicols[c]->
minprimsol =
MIN(lpicols[c]->minprimsol, primsol[c]);
13786 lpicols[c]->
maxprimsol =
MAX(lpicols[c]->maxprimsol, primsol[c]);
13787 lpicols[c]->
redcost = redcost[c];
13788 lpicols[c]->
basisstatus = (
unsigned int) cstat[c];
13790 if( stillprimalfeasible )
13792 stillprimalfeasible =
13795 primalbound += (lpicols[c]->
primsol * lpicols[c]->
obj);
13805 if( stilldualfeasible )
13807 compslack =
MIN((lpicols[c]->primsol - lpicols[c]->lb), 1.0) * lpicols[c]->
redcost;
13810 if( stilldualfeasible )
13812 compslack =
MIN((lpicols[c]->ub - lpicols[c]->primsol), 1.0) * lpicols[c]->
redcost;
13816 SCIPsetDebugMsg(
set,
" col <%s> [%.9g,%.9g]: primsol=%.9f, redcost=%.9f, pfeas=%u/%u(%u), dfeas=%d/%d(%u)\n",
13817 SCIPvarGetName(lpicols[c]->var), lpicols[c]->lb, lpicols[c]->ub, lpicols[c]->primsol, lpicols[c]->redcost,
13820 primalfeasible !=
NULL ? stillprimalfeasible :
TRUE,
13823 dualfeasible !=
NULL ? stilldualfeasible : TRUE);
13837 if( stilldualfeasible
13840 if( stilldualfeasible
13844 SCIPsetDebugMsg(
set,
" col <%s> [%.9g,%.9g]: primsol=%.9f, redcost=%.9f, pfeas=%u/%u(%u), dfeas=%d/%d(%u)\n",
13845 SCIPvarGetName(lpicols[c]->var), lpicols[c]->lb, lpicols[c]->ub, lpicols[c]->primsol, lpicols[c]->redcost,
13848 primalfeasible !=
NULL ? stillprimalfeasible :
TRUE,
13851 dualfeasible !=
NULL ? stilldualfeasible : TRUE);
13858 if( stilldualfeasible )
13861 dualbound += (lpicols[c]->
redcost * lpicols[c]->
lb);
13862 else if( lpicols[c]->redcost < 0.0 && !
SCIPsetIsInfinity(
set, lpicols[c]->ub) )
13863 dualbound += (lpicols[c]->redcost * lpicols[c]->ub);
13868 for( r = 0; r < nlpirows; ++r )
13870 assert( 0 <= rstat[r] && rstat[r] < 4 );
13871 lpirows[r]->
dualsol = dualsol[r];
13873 lpirows[r]->
basisstatus = (
unsigned int) rstat[r];
13875 if( stillprimalfeasible )
13877 stillprimalfeasible =
13889 if( stilldualfeasible )
13891 compslack =
MIN((lpirows[r]->activity - lpirows[r]->lhs), 1.0) * lpirows[r]->
dualsol;
13894 if( stilldualfeasible )
13896 compslack =
MIN((lpirows[r]->rhs - lpirows[r]->activity), 1.0) * lpirows[r]->
dualsol;
13900 SCIPsetDebugMsg(
set,
" row <%s> [%.9g,%.9g]: activity=%.9f, dualsol=%.9f, pfeas=%u/%u(%u), dfeas=%d/%d(%u)\n",
13901 lpirows[r]->name, lpirows[r]->lhs, lpirows[r]->rhs, lpirows[r]->activity, lpirows[r]->dualsol,
13904 primalfeasible !=
NULL ? stillprimalfeasible :
TRUE,
13907 dualfeasible !=
NULL ? stilldualfeasible : TRUE);
13915 if( stilldualfeasible &&
13918 if( stilldualfeasible &&
13922 SCIPsetDebugMsg(
set,
" row <%s> [%.9g,%.9g] + %.9g: activity=%.9f, dualsol=%.9f, pfeas=%u/%u(%u), dfeas=%d/%d(%u)\n",
13923 lpirows[r]->name, lpirows[r]->lhs, lpirows[r]->rhs, lpirows[r]->constant, lpirows[r]->activity, lpirows[r]->dualsol,
13926 primalfeasible !=
NULL ? stillprimalfeasible :
TRUE,
13929 dualfeasible !=
NULL ? stilldualfeasible : TRUE);
13936 if( stilldualfeasible )
13940 else if( lpirows[r]->dualsol < 0.0 && !
SCIPsetIsInfinity(
set, lpirows[r]->rhs) )
13941 dualbound += (lpirows[r]->dualsol * (lpirows[r]->rhs - lpirows[r]->constant));
13970 if( primalfeasible !=
NULL )
13971 *primalfeasible = stillprimalfeasible;
13972 if( dualfeasible !=
NULL )
13973 *dualfeasible = stilldualfeasible;
14008 assert(lp !=
NULL);
14013 assert(
set !=
NULL);
14014 assert(stat !=
NULL);
14017 if( primalfeasible !=
NULL )
14018 *primalfeasible =
TRUE;
14019 if( rayfeasible !=
NULL )
14020 *rayfeasible =
TRUE;
14056 for( c = 0; c < nlpicols; ++c )
14058 assert(lpicols[c] !=
NULL);
14059 assert(lpicols[c]->var !=
NULL);
14062 if( rayfeasible !=
NULL )
14063 *rayfeasible = *rayfeasible
14070 if( primalfeasible !=
NULL )
14071 *primalfeasible = *primalfeasible
14076 rayobjval += ray[c] * lpicols[c]->
obj;
14080 if( primalfeasible !=
NULL && !(*primalfeasible) )
14085 else if( rayfeasible !=
NULL && !(*rayfeasible) )
14095 if( rayfeasible !=
NULL )
14097 *rayfeasible =
FALSE;
14104 assert(rayobjval != 0.0);
14111 for( c = 0; c < nlpicols; ++c )
14114 rayscale =
MIN(rayscale, (lpicols[c]->ub - primsol[c])/ray[c]);
14116 rayscale =
MIN(rayscale, (lpicols[c]->lb - primsol[c])/ray[c]);
14122 SCIPsetDebugMsg(
set,
"unbounded LP solution: rayobjval=%f, rayscale=%f\n", rayobjval, rayscale);
14125 for( c = 0; c < nlpicols; ++c )
14128 lpicols[c]->
primsol = primsol[c];
14131 SCIP_Real primsolval = primsol[c] + rayscale * ray[c];
14138 for( r = 0; r < nlpirows; ++r )
14145 if( primalfeasible !=
NULL )
14146 *primalfeasible = *primalfeasible
14174 assert(lp !=
NULL);
14175 assert(
set !=
NULL);
14176 assert(ray !=
NULL);
14201 for( c = 0; c < nlpicols; c++ )
14203 assert(lpicols[c] !=
NULL);
14205 var = lpicols[c]->
var;
14206 assert(var !=
NULL);
14231 assert(lp !=
NULL);
14235 assert(
set !=
NULL);
14236 assert(stat !=
NULL);
14257 for( r = 0; r < nlpirows; ++r )
14259 SCIPsetDebugMsg(
set,
" row <%s>: dualfarkas=%f\n", lpirows[r]->name, dualfarkas[r]);
14268 for( c = 0; c < nlpicols; ++c )
14288 assert(lp !=
NULL);
14310 assert(lp !=
NULL);
14315 assert(stat !=
NULL);
14325 for( c = 0; c < nlpicols; ++c )
14327 assert(lpicols[c] == lp->
cols[c]);
14328 if( lpicols[c]->primsol == 0.0 )
14331 lpicols[c]->
age = 0;
14336 for( r = 0; r < nlpirows; ++r )
14339 assert(lpirows[r] == lp->
rows[r]);
14341 if( lpirows[r]->dualsol == 0.0 )
14348 lpirows[r]->
age = 0;
14368 assert(lp !=
NULL);
14372 assert(coldstat !=
NULL);
14381 for( c = 0; c < ncols; ++c )
14384 assert(col !=
NULL);
14385 assert(col == lp->
lpicols[c]);
14386 assert(coldstat[c] <= c);
14387 col->
lppos = coldstat[c];
14388 if( coldstat[c] == -1 )
14406 else if( coldstat[c] < c )
14408 assert(lp->
cols[coldstat[c]] ==
NULL);
14410 lp->
cols[coldstat[c]] = col;
14411 lp->
lpicols[coldstat[c]] = col;
14412 lp->
cols[coldstat[c]]->
lppos = coldstat[c];
14413 lp->
cols[coldstat[c]]->
lpipos = coldstat[c];
14421 while( c < lp->nlazycols )
14433 if( lp->
ncols < ncols )
14469 assert(lp !=
NULL);
14473 assert(rowdstat !=
NULL);
14481 for( r = 0; r < nrows; ++r )
14484 assert(row == lp->
lpirows[r]);
14485 assert(rowdstat[r] <= r);
14486 assert(row !=
NULL);
14487 row->
lppos = rowdstat[r];
14488 if( rowdstat[r] == -1 )
14517 else if( rowdstat[r] < r )
14519 assert(lp->
rows[rowdstat[r]] ==
NULL);
14521 lp->
rows[rowdstat[r]] = row;
14522 lp->
lpirows[rowdstat[r]] = row;
14523 lp->
rows[rowdstat[r]]->
lppos = rowdstat[r];
14524 lp->
rows[rowdstat[r]]->
lpipos = rowdstat[r];
14531 if( lp->
nrows < nrows )
14569 assert(lp !=
NULL);
14574 assert(
set !=
NULL);
14575 assert(stat !=
NULL);
14592 for( c = firstcol; c < ncols; ++c )
14594 assert(cols[c] == lpicols[c]);
14595 assert(cols[c]->lppos == c);
14596 assert(cols[c]->lpipos == c);
14597 if( cols[c]->removable
14598 && cols[c]->obsoletenode != stat->
nnodes 14599 && cols[c]->
age > set->lp_colagelimit
14603 assert(cols[c]->primsol == 0.0);
14607 SCIPsetDebugMsg(
set,
"removing obsolete col <%s>: primsol=%f, bounds=[%g,%g]\n",
14608 SCIPvarGetName(cols[c]->var), cols[c]->primsol, cols[c]->lb, cols[c]->ub);
14612 SCIPsetDebugMsg(
set,
"removing %d/%d obsolete columns from LP\n", ndelcols, ncols);
14619 assert(lp->
ncols == ncols - ndelcols);
14648 assert(lp !=
NULL);
14653 assert(
set !=
NULL);
14654 assert(stat !=
NULL);
14671 for( r = firstrow; r < nrows; ++r )
14673 assert(rows[r] == lpirows[r]);
14674 assert(rows[r]->lppos == r);
14675 assert(rows[r]->lpipos == r);
14676 if( rows[r]->removable
14677 && rows[r]->obsoletenode != stat->
nnodes 14678 && rows[r]->
age > set->lp_rowagelimit
14684 SCIPsetDebugMsg(
set,
"removing obsolete row <%s>: activity=%f, sides=[%g,%g]\n",
14685 rows[r]->name, rows[r]->activity, rows[r]->lhs, rows[r]->rhs);
14689 SCIPsetDebugMsg(
set,
"removing %d/%d obsolete rows from LP\n", ndelrows, nrows);
14696 assert(lp->
nrows == nrows - ndelrows);
14714 assert(lp !=
NULL);
14718 assert(
set !=
NULL);
14720 SCIPsetDebugMsg(
set,
"removing obsolete columns starting with %d/%d, obsolete rows starting with %d/%d\n",
14745 assert(lp !=
NULL);
14749 assert(
set !=
NULL);
14753 if( 0 < lp->
ncols )
14757 if( 0 < lp->
nrows )
14781 assert(lp !=
NULL);
14785 assert(stat !=
NULL);
14787 assert(0 <= firstcol && firstcol < lp->ncols);
14802 for( c = firstcol; c < ncols; ++c )
14804 assert(cols[c] == lpicols[c]);
14805 assert(cols[c]->lppos == c);
14806 assert(cols[c]->lpipos == c);
14807 if( lpicols[c]->removable
14809 && lpicols[c]->primsol == 0.0
14817 SCIPsetDebugMsg(
set,
"removing %d/%d unused columns from LP\n", ndelcols, ncols);
14824 assert(lp->
ncols == ncols - ndelcols);
14853 assert(lp !=
NULL);
14858 assert(stat !=
NULL);
14860 assert(0 <= firstrow && firstrow < lp->nrows);
14877 for( r = firstrow; r < nrows; ++r )
14879 assert(rows[r] == lpirows[r]);
14880 assert(rows[r]->lppos == r);
14881 assert(rows[r]->lpipos == r);
14889 SCIPsetDebugMsg(
set,
"removing %d/%d unused rows from LP\n", ndelrows, nrows);
14896 assert(lp->
nrows == nrows - ndelrows);
14918 assert(lp !=
NULL);
14922 assert(
set !=
NULL);
14925 cleanupcols = (root ?
set->lp_cleanupcolsroot :
set->lp_cleanupcols);
14926 cleanuprows = (root ?
set->lp_cleanuprowsroot :
set->lp_cleanuprows);
14928 SCIPsetDebugMsg(
set,
"removing unused columns starting with %d/%d (%u), unused rows starting with %d/%d (%u), LP algo: %d, basic sol: %u\n",
14957 assert(lp !=
NULL);
14961 assert(
set !=
NULL);
14964 cleanupcols = (root ?
set->lp_cleanupcolsroot :
set->lp_cleanupcols);
14965 cleanuprows = (root ?
set->lp_cleanuprowsroot :
set->lp_cleanuprows);
14967 SCIPsetDebugMsg(
set,
"removing all unused columns (%u) and rows (%u), LP algo: %d, basic sol: %u\n",
14970 if( cleanupcols && 0 < lp->
ncols )
14974 if( cleanuprows && 0 < lp->
nrows )
15001 assert(lp !=
NULL);
15006 assert(stat !=
NULL);
15027 assert(rows[r] == lpirows[r]);
15028 assert(rows[r]->lppos == r);
15029 assert(rows[r]->lpipos == r);
15033 SCIPsetDebugMsg(
set,
"basic row <%s> is redundant: sides=[%g,%g], act=[%g,%g]\n",
15041 SCIPsetDebugMsg(
set,
"removing %d/%d redundant basic rows from LP\n", ndelrows, nrows);
15048 assert(lp->
nrows == nrows - ndelrows);
15067 assert(lp !=
NULL);
15075 assert(blkmem !=
NULL);
15076 assert(
set !=
NULL);
15079 SCIPsetDebugMsg(
set,
"diving started (LP flushed: %u, LP solved: %u, solstat: %d)\n",
15083 for( c = 0; c < lp->
ncols; ++c )
15103 if( !set->lp_resolverestore && lp->
solved )
15134 for( c = 0; c < lp->
ncols; ++c )
15138 for( r = 0; r < lp->
nrows; ++r )
15174 assert(lp !=
NULL);
15176 assert(blkmem !=
NULL);
15177 assert(nvars == 0 || vars !=
NULL);
15182 for( v = 0; v < nvars; ++v )
15185 assert(var !=
NULL);
15248 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, prob, -1LL,
FALSE,
FALSE,
FALSE, &lperror) );
15252 "(node %" SCIP_LONGINT_FORMAT
") unresolved numerical troubles while resolving LP %" SCIP_LONGINT_FORMAT
" after diving\n", stat->
nnodes, stat->
nlps);
15261 "LP was not resolved to a sufficient status after diving\n");
15302 for( c = 0; c < lp->
ncols; ++c )
15306 for( r = 0; r < lp->
nrows; ++r )
15320 for( c = 0; c < lp->
ncols; ++c )
15336 #define DIVESTACKGROWFACT 1.5 15345 assert(lp !=
NULL);
15346 assert(row !=
NULL);
15367 assert(lp !=
NULL);
15382 assert(lp !=
NULL);
15397 assert(lp !=
NULL);
15410 assert(lp !=
NULL);
15451 assert(lp !=
NULL);
15453 assert(
set !=
NULL);
15454 assert(bound !=
NULL);
15461 for( j = 0; j < lp->
nrows; ++j )
15464 assert(row !=
NULL);
15490 for( j = 0; j < lp->
ncols; ++j )
15493 assert(col !=
NULL);
15498 c = usefarkas ? 0.0 : col->
obj;
15501 for( i = 0; i < col->
nlprows; ++i )
15505 assert(col->
linkpos[i] >= 0);
15512 for( i = col->
nlprows; i < col->len; ++i )
15518 assert(col->
linkpos[i] >= 0);
15561 assert(proved !=
NULL);
15565 *proved = (bound > 0.0);
15567 SCIPsetDebugMsg(
set,
"proved Farkas value of LP: %g -> infeasibility %sproved\n", bound, *proved ?
"" :
"not ");
15580 assert(lp !=
NULL);
15582 assert(fname !=
NULL);
15610 assert(lp !=
NULL);
15612 assert(fname !=
NULL);
15615 file = fopen(fname,
"w");
15625 SCIPmessageFPrintInfo(messagehdlr, file,
"\\ Original Variable and Constraint Names have been replaced by generic names.\n");
15628 SCIPmessageFPrintInfo(messagehdlr, file,
"\\ Warning: Variable and Constraint Names should not contain special characters like '+', '=' etc.\n");
15632 if( origobj && objoffset != 0.0 )
15634 SCIPmessageFPrintInfo(messagehdlr, file,
"\\ An artificial variable 'objoffset' has been added and fixed to 1.\n");
15635 SCIPmessageFPrintInfo(messagehdlr, file,
"\\ Switching this variable to 0 will disable the offset in the objective.\n\n");
15648 for( i = 0; i < lp->
ncols; ++i )
15650 if( lp->
cols[i]->
obj != 0.0 )
15670 if( origobj && objoffset != 0.0 )
15675 for( i = 0; i < lp->
nrows; i++ )
15708 if( strlen(rowname) > 0 )
15713 SCIPmessageFPrintInfo(messagehdlr, file,
"are not in a valid range. The following two constraints may be corrupted!\n");
15736 if( (j+1) % 10 == 0 )
15767 for( i = 0; i < lp->
nrows; i++ )
15800 if( strlen(rowname) > 0 )
15805 SCIPmessageFPrintInfo(messagehdlr, file,
"are not in a valid range. The following two constraints may be corrupted!\n");
15828 if( (j+1) % 10 == 0 )
15858 for( i = 0; i < lp->
ncols; ++i )
15878 if( origobj && objoffset != 0.0 )
15884 for( i = 0; i < lp->
ncols; ++i )
15916 #undef SCIPcolGetObj 15917 #undef SCIPcolGetLb 15918 #undef SCIPcolGetUb 15919 #undef SCIPcolGetBestBound 15920 #undef SCIPcolGetPrimsol 15921 #undef SCIPcolGetMinPrimsol 15922 #undef SCIPcolGetMaxPrimsol 15923 #undef SCIPcolGetBasisStatus 15924 #undef SCIPcolGetVar 15925 #undef SCIPcolGetIndex 15926 #undef SCIPcolIsIntegral 15927 #undef SCIPcolIsRemovable 15928 #undef SCIPcolGetLPPos 15929 #undef SCIPcolGetLPDepth 15930 #undef SCIPcolIsInLP 15931 #undef SCIPcolGetNNonz 15932 #undef SCIPcolGetNLPNonz 15933 #undef SCIPcolGetRows 15934 #undef SCIPcolGetVals 15935 #undef SCIPcolGetStrongbranchNode 15936 #undef SCIPcolGetNStrongbranchs 15937 #undef SCIPboundtypeOpposite 15938 #undef SCIProwGetNNonz 15939 #undef SCIProwGetNLPNonz 15940 #undef SCIProwGetCols 15941 #undef SCIProwGetVals 15942 #undef SCIProwGetConstant 15943 #undef SCIProwGetNorm 15944 #undef SCIProwGetSumNorm 15945 #undef SCIProwGetLhs 15946 #undef SCIProwGetRhs 15947 #undef SCIProwGetDualsol 15948 #undef SCIProwGetDualfarkas 15949 #undef SCIProwGetBasisStatus 15950 #undef SCIProwGetName 15951 #undef SCIProwGetIndex 15952 #undef SCIProwGetAge 15953 #undef SCIProwGetRank 15954 #undef SCIProwIsIntegral 15955 #undef SCIProwIsLocal 15956 #undef SCIProwIsModifiable 15957 #undef SCIProwIsRemovable 15958 #undef SCIProwGetOrigintype 15959 #undef SCIProwGetOriginCons 15960 #undef SCIProwGetOriginSepa 15961 #undef SCIProwIsInGlobalCutpool 15962 #undef SCIProwGetLPPos 15963 #undef SCIProwGetLPDepth 15964 #undef SCIProwIsInLP 15965 #undef SCIProwGetActiveLPCount 15966 #undef SCIProwGetNLPsAfterCreation 15967 #undef SCIProwChgRank 15968 #undef SCIPlpGetCols 15969 #undef SCIPlpGetNCols 15970 #undef SCIPlpGetRows 15971 #undef SCIPlpGetNRows 15972 #undef SCIPlpGetNewcols 15973 #undef SCIPlpGetNNewcols 15974 #undef SCIPlpGetNewrows 15975 #undef SCIPlpGetNNewrows 15976 #undef SCIPlpGetObjNorm 15977 #undef SCIPlpGetRootObjval 15978 #undef SCIPlpGetRootColumnObjval 15979 #undef SCIPlpGetRootLooseObjval 15980 #undef SCIPlpGetLPI 15981 #undef SCIPlpSetIsRelax 15982 #undef SCIPlpIsRelax 15983 #undef SCIPlpIsSolved 15984 #undef SCIPlpIsSolBasic 15985 #undef SCIPlpDiving 15986 #undef SCIPlpDivingObjChanged 15987 #undef SCIPlpMarkDivingObjChanged 15988 #undef SCIPlpUnmarkDivingObjChanged 15989 #undef SCIPlpDivingRowsChanged 15996 assert(col !=
NULL);
16006 assert(col !=
NULL);
16016 assert(col !=
NULL);
16026 assert(col !=
NULL);
16028 if( col->
obj >= 0.0 )
16039 assert(col !=
NULL);
16041 if( col->
lppos >= 0 )
16052 assert(col !=
NULL);
16062 assert(col !=
NULL);
16074 assert(col !=
NULL);
16085 assert(col !=
NULL);
16095 assert(col !=
NULL);
16105 assert(col !=
NULL);
16116 assert(col !=
NULL);
16126 assert(col !=
NULL);
16137 assert(col !=
NULL);
16148 assert(col !=
NULL);
16151 return (col->
lppos >= 0);
16159 assert(col !=
NULL);
16173 assert(col !=
NULL);
16184 assert(col !=
NULL);
16194 assert(col !=
NULL);
16206 assert(col !=
NULL);
16216 assert(col !=
NULL);
16236 assert(row !=
NULL);
16250 assert(row !=
NULL);
16261 assert(row !=
NULL);
16271 assert(row !=
NULL);
16281 assert(row !=
NULL);
16291 assert(row !=
NULL);
16303 assert(row !=
NULL);
16315 assert(row !=
NULL);
16325 assert(row !=
NULL);
16335 assert(row !=
NULL);
16337 if( row->
lppos >= 0 )
16348 assert(row !=
NULL);
16350 if( row->
lppos >= 0 )
16363 assert(row !=
NULL);
16374 assert(row !=
NULL);
16384 assert(row !=
NULL);
16394 assert(row !=
NULL);
16404 assert(row !=
NULL);
16414 assert(row !=
NULL);
16424 assert(row !=
NULL);
16434 assert(row !=
NULL);
16444 assert(row !=
NULL);
16454 assert( row !=
NULL );
16464 assert( row !=
NULL );
16479 assert( row !=
NULL );
16494 assert(row !=
NULL);
16504 assert(row !=
NULL);
16515 assert(row !=
NULL);
16526 assert(row !=
NULL);
16529 return (row->
lppos >= 0);
16538 assert(row !=
NULL);
16548 assert(row !=
NULL);
16558 assert(row !=
NULL);
16568 assert(lp !=
NULL);
16578 assert(lp !=
NULL);
16588 assert(lp !=
NULL);
16598 assert(lp !=
NULL);
16608 assert(lp !=
NULL);
16619 assert(lp !=
NULL);
16630 assert(lp !=
NULL);
16641 assert(lp !=
NULL);
16659 assert(cols !=
NULL || lp->
ncols == 0);
16663 for( c = lp->
ncols - 1; c >= 0; --c )
16665 lp->
objsqrnorm += SQR(cols[c]->unchangedobj);
16683 assert(lp !=
NULL);
16696 assert(lp !=
NULL);
16706 assert(lp !=
NULL);
16716 assert(lp !=
NULL);
16728 assert(lp !=
NULL);
16740 assert(lp !=
NULL);
16750 assert(lp !=
NULL);
16761 assert(lp !=
NULL);
16773 assert(lp !=
NULL);
16783 assert(lp !=
NULL);
16793 assert(lp !=
NULL);
16803 assert(lp !=
NULL);
16813 assert(lp !=
NULL);
16823 assert(lp !=
NULL);
16834 assert(lp !=
NULL);
16845 assert(lp !=
NULL);
16921 assert(
set !=
NULL);
16922 assert(lp !=
NULL);
16923 assert(point !=
NULL);
16924 assert(success !=
NULL);
16929 if ( timelimit <= 0.0 || iterlimit <= 0 )
16933 assert(lp->
nrows >= 0);
16934 assert(lp->
ncols >= 0);
16935 if( lp->
ncols == 0 )
16940 inclobjcutoff =
FALSE;
16942 SCIPsetDebugMsg(
set,
"Computing relative interior point to current LP.\n");
16945 if( lp->
nrows == 0 && !inclobjcutoff )
16970 nnewcols = 3*lp->
ncols + 2*lp->
nrows + (inclobjcutoff ? 1 : 0) + 1;
16976 for( j = 0; j < lp->
ncols; ++j )
16986 nnewcols = lp->
ncols;
16987 obj[nnewcols] = 0.0;
16988 lb[nnewcols] = 1.0;
16993 for( i = 0; i < lp->
nrows; ++i )
16998 assert( row !=
NULL );
17013 else if( relaxrows )
17018 obj[nnewcols] = 1.0;
17019 lb[nnewcols] = 0.0;
17020 ub[nnewcols] = 1.0;
17025 obj[nnewcols] = 1.0;
17026 lb[nnewcols] = 0.0;
17027 ub[nnewcols] = 1.0;
17034 if( inclobjcutoff && relaxrows )
17037 obj[nnewcols] = 1.0;
17038 lb[nnewcols] = 0.0;
17039 ub[nnewcols] = 1.0;
17044 for( j = 0; j < lp->
ncols; ++j )
17049 assert( col !=
NULL );
17058 obj[nnewcols] = 1.0;
17059 lb[nnewcols] = 0.0;
17060 ub[nnewcols] = 1.0;
17065 obj[nnewcols] = 1.0;
17066 lb[nnewcols] = 0.0;
17067 ub[nnewcols] = 1.0;
17072 nslacks = nnewcols - lp->
ncols - 1;
17073 assert( nslacks >= 0 );
17074 assert( nnewcols <= 3*lp->ncols + 2*lp->
nrows + (inclobjcutoff ? 1 : 0) + 1 );
17095 for( i = 0; i < lp->
nrows; ++i )
17105 assert( row !=
NULL );
17115 assert( nnonz <= lp->ncols );
17116 rowcols = row->
cols;
17117 rowvals = row->
vals;
17120 for( j = 0; j < nnonz; ++j )
17122 assert( rowcols[j] !=
NULL );
17123 assert( 0 <= rowcols[j]->lppos && rowcols[j]->lppos < lp->ncols );
17124 assert( lp->
cols[rowcols[j]->
lppos] == rowcols[j] );
17125 colinds[j] = rowcols[j]->
lppos;
17126 colvals[j] = rowvals[j];
17133 colinds[nnonz] = lp->
ncols;
17134 colvals[nnonz] = -rhs;
17150 colinds[nnonz] = lp->
ncols;
17151 colvals[nnonz] = -lhs;
17156 colinds[nnonz+1] = lp->
ncols + 1 + cnt;
17157 colvals[nnonz+1] = -
MAX(1.0, lhs);
17173 colinds[nnonz] = lp->
ncols;
17174 colvals[nnonz] = -rhs;
17179 colinds[nnonz+1] = lp->
ncols + 1 + cnt;
17180 colvals[nnonz+1] =
MAX(1.0, absrhs);
17193 if( inclobjcutoff )
17204 for( j = 0; j < lp->
ncols; ++j )
17209 if( lp->
cols[j]->
obj == 0.0 )
17212 colvals[nnonz] = lp->
cols[j]->
obj;
17218 colinds[nnonz] = lp->
ncols;
17219 colvals[nnonz] = -rhs;
17227 colinds[nnonz] = lp->
ncols + 1 + cnt;
17228 colvals[nnonz] =
MAX(1.0, absrhs);
17236 for( j = 0; j < lp->
ncols; ++j )
17243 assert( col !=
NULL );
17244 assert( col->
lppos == j );
17254 colinds[1] = lp->
ncols;
17255 colvals[1] = -col->
lb;
17270 colinds[1] = lp->
ncols;
17271 colvals[1] = -col->
lb;
17274 colinds[2] = lp->
ncols + 1 + cnt;
17275 colvals[2] = -
MAX(1.0, abscollb);
17284 colinds[1] = lp->
ncols;
17285 colvals[1] = -col->
ub;
17288 colinds[2] = lp->
ncols + 1 + cnt;
17289 colvals[2] =
MAX(1.0, abscolub);
17294 assert( cnt == nslacks );
17307 assert( ncols == nnewcols );
17318 SCIPmessagePrintWarning(messagehdlr,
"Could not set time limit of LP solver for relative interior point computation.\n");
17325 SCIPmessagePrintWarning(messagehdlr,
"Could not set iteration limit of LP solver for relative interior point computation.\n");
17350 alpha = primal[lp->
ncols];
17353 SCIPsetDebugMsg(
set,
"Solved relative interior lp with objective %g.\n", objval);
17356 for( j = 0; j < lp->
ncols; ++j )
17357 point[j] = primal[j]/alpha;
17364 for( i = 0; i < lp->
nrows; ++i )
17375 assert( row !=
NULL );
17381 assert( nnonz <= lp->ncols );
17382 rowcols = row->
cols;
17383 rowvals = row->
vals;
17386 for( j = 0; j < nnonz; ++j )
17387 sum += rowvals[j] * primal[rowcols[j]->lppos];
17411 if( inclobjcutoff )
17420 for( j = 0; j < lp->
ncols; ++j )
17429 for( j = 0; j < lp->
ncols; ++j )
17437 assert( col !=
NULL );
17439 val = primal[col->
lppos] / alpha;
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
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_Bool SCIPsolveIsStopped(SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool checknodelimits)
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)
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)
SCIP_Bool SCIPlpiIsDualFeasible(SCIP_LPI *lpi)
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 SCIPlpiSolveDual(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpUpdateAddVar(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
SCIP_Longint nlpiterations
SCIP_Bool SCIPlpDiving(SCIP_LP *lp)
SCIP_RETCODE SCIPlpiFreeNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
SCIP_RETCODE SCIPlpiSetState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, const SCIP_LPISTATE *lpistate)
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_RETCODE SCIPlpiGetDualfarkas(SCIP_LPI *lpi, SCIP_Real *dualfarkas)
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_Real SCIProwGetMinval(SCIP_ROW *row, SCIP_SET *set)
enum SCIP_LPAlgo SCIP_LPALGO
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)
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_RETCODE SCIPlpiGetBInvARow(SCIP_LPI *lpi, int r, const SCIP_Real *binvrow, 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)
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)
static SCIP_RETCODE lpFlushAddCols(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue)
SCIP_Bool SCIPlpiHasStateBasis(SCIP_LPI *lpi, SCIP_LPISTATE *lpistate)
SCIP_BASESTAT SCIPcolGetBasisStatus(SCIP_COL *col)
void SCIProwRecalcLPActivity(SCIP_ROW *row, SCIP_STAT *stat)
SCIP_RETCODE SCIPlpiGetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real *dval)
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_RETCODE SCIPlpiGetBInvCol(SCIP_LPI *lpi, int c, SCIP_Real *coef, int *inds, int *ninds)
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 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)
static void adjustLPobjval(SCIP_LP *lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
const char * SCIProwGetName(SCIP_ROW *row)
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)
static void rowSortLP(SCIP_ROW *row)
interface methods for specific LP solvers
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
static void colMoveCoef(SCIP_COL *col, int oldpos, int newpos)
static void rowUpdateAddLP(SCIP_ROW *row)
int SCIPlpiGetInternalStatus(SCIP_LPI *lpi)
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)
SCIP_RETCODE SCIPlpiIgnoreInstability(SCIP_LPI *lpi, SCIP_Bool *success)
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)
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)
SCIP_RETCODE SCIPlpiGetBInvACol(SCIP_LPI *lpi, int c, SCIP_Real *coef, int *inds, int *ninds)
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)
#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)
SCIP_RETCODE SCIPlpiGetObj(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *vals)
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)
SCIP_RETCODE SCIPlpiEndStrongbranch(SCIP_LPI *lpi)
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)
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 SCIPlpiIsStable(SCIP_LPI *lpi)
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
SCIP_RETCODE SCIPlpiFree(SCIP_LPI **lpi)
SCIP_RETCODE SCIPlpiChgObj(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *obj)
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_Real SCIPlpGetRootColumnObjval(SCIP_LP *lp)
void SCIPlpStartStrongbranchProbing(SCIP_LP *lp)
#define SCIPsetAllocBufferArray(set, ptr, num)
#define BMSfreeBlockMemoryNull(mem, ptr)
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 SCIPlpiGetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int *ival)
SCIP_RETCODE SCIPlpSetState(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LPISTATE *lpistate, SCIP_Bool wasprimfeas, SCIP_Bool wasdualfeas)
#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_RETCODE SCIPlpiGetSides(SCIP_LPI *lpi, int firstrow, int lastrow, SCIP_Real *lhss, SCIP_Real *rhss)
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)
#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 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)
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_Bool SCIPlpiIsObjlimExc(SCIP_LPI *lpi)
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_RETCODE SCIPlpiGetNCols(SCIP_LPI *lpi, int *ncols)
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
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_Bool SCIPlpIsRootLPRelax(SCIP_LP *lp)
SCIP_Bool objsqrnormunreliable
SCIP_RETCODE SCIPlpRecordOldRowSideDive(SCIP_LP *lp, SCIP_ROW *row, SCIP_SIDETYPE sidetype)
SCIP_Bool divelpwasdualfeas
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)
SCIP_Bool SCIPlpiIsTimelimExc(SCIP_LPI *lpi)
#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)
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)
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_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 SCIProwCatchEvent(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_RETCODE SCIPlpiGetNRows(SCIP_LPI *lpi, int *nrows)
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_Bool SCIPlpiIsPrimalFeasible(SCIP_LPI *lpi)
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_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
void SCIPsortPtrRealInt(void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
SCIP_ROW ** SCIPcolGetRows(SCIP_COL *col)
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 SCIPlpiGetBounds(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *lbs, SCIP_Real *ubs)
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)
SCIP_RETCODE SCIPlpiStrongbranchFrac(SCIP_LPI *lpi, int col, SCIP_Real psol, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
SCIP_Bool SCIPlpiHasDualRay(SCIP_LPI *lpi)
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
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_Real SCIPlpiInfinity(SCIP_LPI *lpi)
SCIP_Bool SCIProwIsIntegral(SCIP_ROW *row)
SCIP_RETCODE SCIPlpiDelRows(SCIP_LPI *lpi, int firstrow, int lastrow)
void SCIPmessagePrintWarning(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)
SCIP_Real SCIProwGetNLPFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPlpiChgSides(SCIP_LPI *lpi, int nrows, const int *ind, const SCIP_Real *lhs, const SCIP_Real *rhs)
SCIP_RETCODE SCIPlpiStartStrongbranch(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpGetUnboundedSol(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool *primalfeasible, SCIP_Bool *rayfeasible)
void SCIProwDelaySort(SCIP_ROW *row)
SCIP_RETCODE SCIPlpiGetObjval(SCIP_LPI *lpi, SCIP_Real *objval)
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_LPSOLVALS * storedsolvals
static SCIP_RETCODE lpSetFeastol(SCIP_LP *lp, SCIP_Real feastol, SCIP_Bool *success)
const char * SCIPlpiGetSolverName(void)
SCIP_RETCODE SCIPlpGetDualfarkas(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat)
internal methods for global SCIP settings
SCIP_Bool SCIPlpiIsOptimal(SCIP_LPI *lpi)
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)
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)
SCIP_Bool SCIPlpiIsPrimalInfeasible(SCIP_LPI *lpi)
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_RETCODE SCIPlpiDelRowset(SCIP_LPI *lpi, int *dstat)
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)
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)
SCIP_RETCODE SCIPlpiGetSol(SCIP_LPI *lpi, SCIP_Real *objval, SCIP_Real *primsol, SCIP_Real *dualsol, SCIP_Real *activity, SCIP_Real *redcost)
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
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_Real * SCIProwGetVals(SCIP_ROW *row)
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_Real SCIPsetSumepsilon(SCIP_SET *set)
SCIP_Longint ndualresolvelps
#define BMSallocBlockMemoryArray(mem, ptr, num)
SCIP_RETCODE SCIPlpiSetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int ival)
static void recomputePseudoObjectiveValue(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
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_RETCODE SCIPlpiGetPrimalRay(SCIP_LPI *lpi, SCIP_Real *ray)
SCIP_Real SCIPcolGetBestBound(SCIP_COL *col)
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_ROW ** SCIPlpGetNewrows(SCIP_LP *lp)
SCIP_Real SCIPvarGetNLPSol(SCIP_VAR *var)
SCIP_RETCODE SCIPlpiSetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real dval)
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)
SCIP_RETCODE SCIPlpiSetNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, const SCIP_LPINORMS *lpinorms)
#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)
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)
#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_RETCODE SCIPlpiGetBase(SCIP_LPI *lpi, int *cstat, int *rstat)
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 SCIPlpiSolvePrimal(SCIP_LPI *lpi)
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)
SCIP_RETCODE SCIPlpiDelColset(SCIP_LPI *lpi, int *dstat)
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_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_Real SCIProwGetSolEfficacy(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol)
SCIP_RETCODE SCIPlpiWriteLP(SCIP_LPI *lpi, const char *fname)
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_Bool SCIPlpiExistsPrimalRay(SCIP_LPI *lpi)
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 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 SCIPlpiGetNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
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_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
SCIP_RETCODE SCIPlpiSetIntegralityInformation(SCIP_LPI *lpi, int ncols, int *intInfo)
SCIP_RETCODE SCIPlpiChgBounds(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *lb, const SCIP_Real *ub)
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_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)
int SCIPcolGetNNonz(SCIP_COL *col)
SCIP_Bool SCIProwIsLPEfficacious(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_Bool root)
SCIP_Bool SCIPlpiIsIterlimExc(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
SCIP_Longint validpsactivitydomchg
SCIP_COLSOLVALS * storedsolvals
SCIP_Real SCIProwGetMinActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
SCIP_Bool strongbranchprobing
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[]
internal methods for main solving loop and node processing
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 SCIPlpiCreate(SCIP_LPI **lpi, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_OBJSEN objsen)
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)
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
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)
int SCIPcolGetNStrongbranchs(SCIP_COL *col)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
int SCIProwGetLPPos(SCIP_ROW *row)
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 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)
static SCIP_RETCODE lpSetUobjlim(SCIP_LP *lp, SCIP_SET *set, SCIP_Real uobjlim)
#define SCIPsetDebugMsgPrint
SCIP_Real SCIPcolGetFarkasValue(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)
SCIP_RETCODE SCIPlpiGetSolFeasibility(SCIP_LPI *lpi, SCIP_Bool *primalfeasible, SCIP_Bool *dualfeasible)
#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_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_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)
SCIP_RETCODE SCIPlpiGetIterations(SCIP_LPI *lpi, int *iterations)
SCIP_RETCODE SCIPlpiGetBInvRow(SCIP_LPI *lpi, int r, SCIP_Real *coef, int *inds, int *ninds)
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_RETCODE SCIPlpiDelCols(SCIP_LPI *lpi, int firstcol, int lastcol)
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)
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_Bool SCIPlpiHasPrimalRay(SCIP_LPI *lpi)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
#define BMSallocBlockMemory(mem, ptr)
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 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)
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 SCIPlpiGetBasisInd(SCIP_LPI *lpi, int *bind)
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_RETCODE SCIPlpiSolveBarrier(SCIP_LPI *lpi, SCIP_Bool crossover)
SCIP_Bool SCIPsetIsFeasNegative(SCIP_SET *set, SCIP_Real val)
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 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)