108 for(
i = 0;
i < row->
len; ++
i )
127#define debugRowPrint(x,y)
151 for(
r = 0;
r < col->
len; ++
r )
160#define debugColPrint(x,y)
185 assert(num <= lp->chgcolssize);
208 assert(num <= lp->chgrowssize);
231 assert(num <= lp->lpicolssize);
254 assert(num <= lp->lpirowssize);
277 assert(num <= lp->colssize);
297 assert(num <= lp->soldirectionsize);
320 assert(num <= lp->lazycolssize);
343 assert(num <= lp->rowssize);
360 if( num > col->
size )
424 if( storedsolvals !=
NULL )
512 if( storedsolvals !=
NULL )
597 if( storedsolvals !=
NULL )
640 if( num > row->
size )
657#ifdef SCIP_MORE_DEBUG
667 if( !msgdisp_checkrow )
669 printf(
"LP ROW CHECKING ACTIVATED! THIS IS VERY SLOW!\n");
670 msgdisp_checkrow =
TRUE;
699#ifdef SCIP_MORE_DEBUG
714 for(
c = row->
len - 1;
c >= 0; --
c )
716 if( cols[
c]->lppos >= 0 )
737 for(
c = row->
len - 1;
c >= 0; --
c )
739 if( cols[
c]->lppos >= 0 )
760 for(
c = row->
len - 1;
c >= 0; --
c )
762 if( cols[
c]->lppos >= 0 )
769#define checkRowSqrnorm(row)
770#define checkRowSumnorm(row)
771#define checkRowObjprod(row)
801 for( v = 0; v <
nvars; ++v )
842 for( v = 0; v <
nvars; ++v )
884 for( v = 0; v <
nvars; ++v )
1117 searchidx = row->
index;
1118 while(minpos <= maxpos)
1120 pos = (minpos + maxpos)/2;
1121 assert(0 <= pos && pos < col->len);
1125 if( searchidx == idx )
1127 else if( searchidx < idx )
1151 if( row->
lppos >= 0 )
1192 searchidx = col->
index;
1193 while(minpos <= maxpos)
1195 pos = (minpos + maxpos)/2;
1196 assert(0 <= pos && pos < row->len);
1201 if( searchidx == idx )
1203 else if( searchidx < idx )
1232 if( col->
lppos >= 0 )
1253 assert(-1 <= pos && pos < row->len);
1259 for(
i = 0;
i < row->
len; ++
i )
1276 assert(0 <= oldpos && oldpos < col->len);
1277 assert(0 <= newpos && newpos < col->len);
1280 if( oldpos == newpos )
1283 col->
rows[newpos] = col->
rows[oldpos];
1284 col->
vals[newpos] = col->
vals[oldpos];
1288 if( col->
linkpos[newpos] >= 0 )
1316 assert(0 <= pos1 && pos1 < col->len);
1317 assert(0 <= pos2 && pos2 < col->len);
1324 tmprow = col->
rows[pos2];
1325 tmpval = col->
vals[pos2];
1326 tmplinkpos = col->
linkpos[pos2];
1332 col->
rows[pos1] = tmprow;
1333 col->
vals[pos1] = tmpval;
1334 col->
linkpos[pos1] = tmplinkpos;
1372 assert(0 <= oldpos && oldpos < row->len);
1373 assert(0 <= newpos && newpos < row->len);
1376 if( oldpos == newpos )
1379 row->
cols[newpos] = row->
cols[oldpos];
1381 row->
vals[newpos] = row->
vals[oldpos];
1385 if( row->
linkpos[newpos] >= 0 )
1414 assert(0 <= pos1 && pos1 < row->len);
1415 assert(0 <= pos2 && pos2 < row->len);
1423 tmpcol = row->
cols[pos2];
1425 tmpval = row->
vals[pos2];
1426 tmplinkpos = row->
linkpos[pos2];
1433 row->
cols[pos1] = tmpcol;
1435 row->
vals[pos1] = tmpval;
1436 row->
linkpos[pos1] = tmplinkpos;
1552#ifdef SCIP_MORE_DEBUG
1555#define ASSERT(x) do { if( !(x) ) abort(); } while( FALSE )
1557#define ASSERT(x) assert(x)
1575 if( !msgdisp_checklinks )
1577 printf(
"LP LINK CHECKING ACTIVATED! THIS IS VERY SLOW!\n");
1578 msgdisp_checklinks =
TRUE;
1584 ASSERT(col !=
NULL);
1590 for( j = 0; j < col->
len; ++j )
1593 ASSERT(row !=
NULL);
1604 ASSERT(row !=
NULL);
1610 for( j = 0; j < row->
len; ++j )
1613 ASSERT(col !=
NULL);
1617 ASSERT((j < row->nlpcols) == (row->
linkpos[j] >= 0 && col->
lppos >= 0));
1625#define checkLinks(lp)
1731 if( row->
lppos >= 0 && linkpos >= 0 )
1746 col->
rows[pos] = row;
1747 col->
vals[pos] = val;
1756 if( col->
lppos >= 0 )
1762 if( row->
lppos >= 0 )
1766 assert(0 <= linkpos && linkpos < row->len);
1783 if( col->
lppos >= 0 )
1789 if( linkpos == row->
nlpcols-1 )
1795 if( row->
lppos >= 0 && linkpos >= 0 )
1812 SCIPsetDebugMsg(
set,
"added coefficient %g * <%s> at position %d (%d/%d) to column <%s> (nunlinked=%d)\n",
1832 assert(0 <= pos && pos < col->len);
1837 row = col->
rows[pos];
1875 assert(0 <= pos && pos < col->len);
1893 col->
vals[pos] = val;
1929 if( col->
lppos >= 0 )
2014 if( forcenormupdate || col->
lppos >= 0 )
2082 if( col->
lppos >= 0 && linkpos >= 0 )
2097 row->
cols[pos] = col;
2099 row->
vals[pos] = val;
2109 if( row->
lppos >= 0 )
2115 if( col->
lppos >= 0 )
2119 assert(0 <= linkpos && linkpos < col->len);
2136 if( row->
lppos >= 0 )
2142 if( linkpos == col->
nlprows-1 )
2148 if( col->
lppos >= 0 && linkpos >= 0 )
2174 SCIPsetDebugMsg(
set,
"added coefficient %g * <%s> at position %d (%d/%d) to row <%s> (nunlinked=%d)\n",
2199 assert(0 <= pos && pos < row->len);
2203 col = row->
cols[pos];
2204 val = row->
vals[pos];
2212 SCIPerrorMessage(
"cannot delete a coefficient from the locked unmodifiable row <%s>\n", row->
name);
2220 if( pos < row->nlpcols )
2258 assert(0 <= pos && pos < row->len);
2265 SCIPerrorMessage(
"cannot change a coefficient of the locked unmodifiable row <%s>\n", row->
name);
2271 col = row->
cols[pos];
2283 oldval = row->
vals[pos];
2287 row->
vals[pos] = val;
2415 for(
i = 0;
i < col->
len; ++
i )
2491 for(
i = 0;
i < row->
len; ++
i )
2549 return lpSetIntpar(lp, lpparam, (
int)value, success);
2600 assert(lpivalue == value);
2636 assert(lpivalue == value);
2641#define lpCheckIntpar(lp, lpparam, value) SCIP_OKAY
2642#define lpCheckBoolpar(lp, lpparam, value) SCIP_OKAY
2643#define lpCheckRealpar(lp, lpparam, value) SCIP_OKAY
2647#define lpCutoffDisabled(set, prob, lp) (set->lp_disablecutoff == 1 || (set->lp_disablecutoff == 2 && !SCIPprobAllColsInLP(prob, set, lp)) || set->misc_exactsolve)
2724 if( lp->
nrows > 0 && actualfeastol < lp->lpifeastol )
2753 assert(dualfeastol >= 0.0);
2767 if( lp->
nrows > 0 && actualdualfeastol < lp->lpidualfeastol )
2796 assert(barrierconvtol >= 0.0);
2810 if( lp->
nrows > 0 && actualbarrierconvtol < lp->lpibarrierconvtol
2866 assert(0 <= fastmip && fastmip <= 1);
3055 switch( pricingchar )
3181 lptiming = (int) timing;
3208 if( randomseed == 0 )
3307 for(
i = 0;
i < len; ++
i )
3311 (*col)->linkpos[
i] = -1;
3316 (*col)->rows =
NULL;
3317 (*col)->vals =
NULL;
3318 (*col)->linkpos =
NULL;
3326 (*col)->flushedobj = 0.0;
3327 (*col)->flushedlb = 0.0;
3328 (*col)->flushedub = 0.0;
3329 (*col)->index = stat->
ncolidx;
3333 (*col)->nlprows = 0;
3334 (*col)->nunlinked = len;
3336 (*col)->lpipos = -1;
3337 (*col)->lpdepth = -1;
3338 (*col)->primsol = 0.0;
3341 (*col)->minprimsol = (*col)->ub;
3342 (*col)->maxprimsol = (*col)->lb;
3347 (*col)->sbnode = -1;
3348 (*col)->validredcostlp = -1;
3349 (*col)->validfarkaslp = -1;
3350 (*col)->validsblp = -1;
3351 (*col)->sbitlim = -1;
3352 (*col)->nsbcalls = 0;
3354 (*col)->obsoletenode = -1;
3357 (*col)->lprowssorted =
TRUE;
3358 (*col)->nonlprowssorted = (len <= 1);
3359 (*col)->objchanged =
FALSE;
3360 (*col)->lbchanged =
FALSE;
3361 (*col)->ubchanged =
FALSE;
3362 (*col)->coefchanged =
FALSE;
3364 (*col)->removable = removable;
3365 (*col)->sbdownvalid =
FALSE;
3366 (*col)->sbupvalid =
FALSE;
3369 (*col)->storedsolvals =
NULL;
3388 assert(&(*col)->var->data.col == col);
3389 assert((*col)->lppos == -1);
3390 assert((*col)->lpipos == -1);
3422 for(
r = 0;
r < col->
len; ++
r )
3490 assert(0 <= pos && pos < col->len);
3540 assert(0 <= pos && pos < col->len);
3594 assert(0 <= pos && pos < col->len);
3865 redcost -= col->
vals[
i] * dualsol[row->
lppos];
3875 if( row->
lppos >= 0 )
3876 redcost -= col->
vals[
i] * dualsol[row->
lppos];
3928 if( row->
lppos >= 0 )
4048 farkas += col->
vals[
i] * dualfarkas[row->
lppos];
4058 if( row->
lppos >= 0 )
4059 farkas += col->
vals[
i] * dualfarkas[row->
lppos];
4111 if( row->
lppos >= 0 )
4171 if( farkascoef > 0.0 )
4172 return col->
ub * farkascoef;
4174 return col->
lb * farkascoef;
4361 validsblp = stat->
nlps;
4372 sbdownvalid =
FALSE;
4380 SCIPsetDebugMsg(
set,
"performing strong branching on variable <%s>(%g) with %d iterations\n",
4407 sbdownvalid =
FALSE;
4436 if( iter/2 >= itlim )
4459 if( downvalid !=
NULL )
4460 *downvalid = sbdownvalid;
4461 if( upvalid !=
NULL )
4462 *upvalid = sbupvalid;
4545 for( j = 0; j < ncols; ++j )
4576 if( downvalid !=
NULL )
4578 if( upvalid !=
NULL )
4586 lpipos[nsubcols] = col->
lpipos;
4587 primsols[nsubcols] = col->
primsol;
4589 subidx[nsubcols] = j;
4590 subcols[nsubcols++] = col;
4594 SCIPsetDebugMsg(
set,
"performing strong branching on %d variables with %d iterations\n", ncols, itlim);
4607 for( j = 0; j < nsubcols; ++j )
4625 up[idx] = col->
sbup;
4626 if( downvalid !=
NULL )
4628 if( upvalid !=
NULL )
4641 for( j = 0; j < nsubcols; ++j )
4658 up[idx] = col->
sbup;
4659 if( downvalid !=
NULL )
4661 if( upvalid !=
NULL )
4674 if( iter/2 >= itlim )
4723 if( downvalid !=
NULL )
4725 if( upvalid !=
NULL )
4727 if( solval !=
NULL )
4729 if( lpobjval !=
NULL )
4850 for(
i = 0;
i < row->
len; ++
i )
4913 sval = val * scalar;
4914 downval = floor(sval);
4919 if( intval !=
NULL )
4925 if( intval !=
NULL )
4971 assert(-1.0 < minrounddelta && minrounddelta <= 0.0);
4972 assert(0.0 <= maxrounddelta && maxrounddelta < 1.0);
4974 SCIPsetDebugMsg(
set,
"scale row <%s> with %g (tolerance=[%g,%g])\n", row->
name, scaleval, minrounddelta, maxrounddelta);
4978 mindeltainf =
FALSE;
4979 maxdeltainf =
FALSE;
5008 newval = val * scaleval;
5010 &&
isIntegralScalar(val, scaleval, minrounddelta, maxrounddelta, &intval) )
5014 if( intval < newval )
5016 mindelta += (intval - newval)*ub;
5017 maxdelta += (intval - newval)*lb;
5023 mindelta += (intval - newval)*lb;
5024 maxdelta += (intval - newval)*ub;
5046 if( oldlen != row->
len )
5069 newval = (row->
lhs - row->
constant) * scaleval + mindelta;
5081 newval = (row->
rhs - row->
constant) * scaleval + maxdelta;
5139 (*row)->integral =
TRUE;
5150 for(
i = 0;
i < len; ++
i )
5156 (*row)->cols_index[
i] = cols[
i]->
index;
5157 (*row)->linkpos[
i] = -1;
5165 (*row)->integral =
FALSE;
5171 (*row)->cols =
NULL;
5172 (*row)->cols_index =
NULL;
5173 (*row)->vals =
NULL;
5174 (*row)->linkpos =
NULL;
5178 (*row)->constant = 0.0;
5183 (*row)->sqrnorm = 0.0;
5184 (*row)->sumnorm = 0.0;
5185 (*row)->objprod = 0.0;
5186 (*row)->maxval = 0.0;
5188 (*row)->dualsol = 0.0;
5190 (*row)->dualfarkas = 0.0;
5194 (*row)->origin = origin;
5195 (*row)->eventfilter =
NULL;
5196 (*row)->index = stat->
nrowidx;
5200 (*row)->nlpcols = 0;
5201 (*row)->nunlinked = len;
5204 (*row)->lpipos = -1;
5205 (*row)->lpdepth = -1;
5206 (*row)->minidx = INT_MAX;
5207 (*row)->maxidx = INT_MIN;
5208 (*row)->nummaxval = 0;
5209 (*row)->numminval = 0;
5210 (*row)->numintcols = -1;
5211 (*row)->validactivitylp = -1;
5212 (*row)->validpsactivitydomchg = -1;
5213 (*row)->validactivitybdsdomchg = -1;
5214 (*row)->nlpsaftercreation = 0L;
5215 (*row)->activeinlpcounter = 0L;
5218 (*row)->obsoletenode = -1;
5219 (*row)->fromcutpool =
FALSE;
5221 (*row)->lpcolssorted =
TRUE;
5222 (*row)->nonlpcolssorted = (len <= 1);
5223 (*row)->delaysort =
FALSE;
5224 (*row)->validminmaxidx =
FALSE;
5225 (*row)->lhschanged =
FALSE;
5226 (*row)->rhschanged =
FALSE;
5227 (*row)->coefchanged =
FALSE;
5228 (*row)->local = local;
5229 (*row)->modifiable = modifiable;
5231 (*row)->origintype = origintype;
5232 (*row)->removable = removable;
5233 (*row)->inglobalcutpool =
FALSE;
5234 (*row)->storedsolvals =
NULL;
5267 assert((*row)->nuses == 0);
5268 assert((*row)->lppos == -1);
5319 for(
i = 0;
i < row->
len; ++
i )
5360 assert((*row)->nuses >= 1);
5361 assert((*row)->nlocks < (
unsigned int)((*row)->nuses));
5363 SCIPsetDebugMsg(
set,
"release row <%s> with nuses=%d and nlocks=%u\n", (*row)->name, (*row)->nuses, (*row)->nlocks);
5365 if( (*row)->nuses == 0 )
5453 assert(0 <= pos && pos < row->len);
5504 assert(0 <= pos && pos < row->len);
5558 assert(0 <= pos && pos < row->len);
5788 if( intscalar !=
NULL )
5794 for(
c = 0;
c < row->
len; ++
c )
5806 if( val < mindelta || val > maxdelta )
5809 minval =
MIN(minval, absval);
5815 if( intscalar !=
NULL )
5822 assert(minval >
MIN(-mindelta, maxdelta));
5829 scaleval = 1.0/minval;
5830 scalable = (scaleval <= maxscale);
5831 for(
c = 0;
c < row->
len && scalable; ++
c )
5840 while( scaleval <= maxscale
5854 scalable = (scaleval <= maxscale);
5855 SCIPsetDebugMsg(
set,
" -> val=%g, scaleval=%g, val*scaleval=%g, scalable=%u\n", val, scaleval, val*scaleval, scalable);
5862 assert(scaleval <= maxscale);
5863 if( intscalar !=
NULL )
5864 *intscalar = scaleval;
5866 SCIPsetDebugMsg(
set,
" -> integrality can be achieved by scaling with %g (minval=%g)\n", scaleval, minval);
5873 twomult = (twomultval <= maxscale);
5874 for(
c = 0;
c < row->
len && twomult; ++
c )
5883 while( twomultval <= maxscale
5884 && (absval * twomultval < 0.5 || !
isIntegralScalar(val, twomultval, mindelta, maxdelta,
NULL)) )
5897 twomult = (twomultval <= maxscale);
5899 val, twomultval, val*twomultval, twomult);
5904 assert(twomultval <= maxscale);
5905 if( intscalar !=
NULL )
5906 *intscalar = twomultval;
5908 SCIPsetDebugMsg(
set,
" -> integrality can be achieved by scaling with %g (power of 2)\n", twomultval);
5918 rational = (maxdnom > 1);
5921 for(
c = 0;
c < row->
len && rational; ++
c )
5926 rational =
SCIPrealToRational(val, mindelta, maxdelta, maxdnom, &nominator, &denominator);
5927 if( rational && nominator != 0 )
5930 gcd =
ABS(nominator);
5934 val, nominator, denominator, gcd, scm, rational);
5941 for( ++
c;
c < row->
len && rational; ++
c )
5946 rational =
SCIPrealToRational(val, mindelta, maxdelta, maxdnom, &nominator, &denominator);
5947 if( rational && nominator != 0 )
5954 val, nominator, denominator, gcd, scm, rational);
5963 if( intscalar !=
NULL )
6000 &intscalar, success) );
6005 SCIP_CALL(
rowScale(row, blkmem,
set, eventqueue, stat, lp, intscalar, usecontvars, mindelta, maxdelta) );
6026#ifdef SCIP_MORE_DEBUG
6086 for( s = 1; s < row->
len; ++s )
6091 if( cols[s] == cols[t] )
6108 cols_index[t] = cols_index[s];
6134 for(
i = 0;
i < row->
len; ++
i )
6138 for( j =
i+1; j < row->
len; ++j )
6200 if( col->
lppos >= 0 )
6245 activity =
MAX(activity, -inf);
6246 activity =
MIN(activity, +inf);
6265 return MIN(row->
rhs - activity, activity - row->
lhs);
6304 if ( col->
lppos >= 0 )
6324 activity =
MAX(activity, -inf);
6325 activity =
MIN(activity, +inf);
6327 return MIN(row->
rhs - activity, activity - row->
lhs);
6366 if ( col->
lppos >= 0 )
6386 activity =
MAX(activity, -inf);
6387 activity =
MIN(activity, +inf);
6389 return MIN(row->
rhs - activity, activity - row->
lhs);
6405 for(
i = 0;
i < row->
len; ++
i )
6441 activity =
MAX(activity, -inf);
6442 activity =
MIN(activity, +inf);
6460 return MIN(row->
rhs - pseudoactivity, pseudoactivity - row->
lhs);
6480 for(
i = 0;
i < row->
len; ++
i )
6489 solval = (row->
vals[
i] >= 0.0 ? col->
lb : col->
ub);
6491 solval = (row->
vals[
i] >= 0.0 ? col->
ub : col->
lb);
6493 solval = (col->
lb + col->
ub)/2.0;
6495 activity += row->
vals[
i] * solval;
6499 activity =
MAX(activity, -inf);
6500 activity =
MIN(activity, +inf);
6519 return MIN(row->
rhs - activity, activity - row->
lhs);
6541 mininfinite =
FALSE;
6542 maxinfinite =
FALSE;
6545 for(
i = 0;
i < row->
len && (!mininfinite || !maxinfinite); ++
i )
6771 for( k = 0; k < lp->
ncols; ++k )
6780 scale = 1.0 / sqrt(scale);
6782 for( k = 0; k < lp->
ncols; ++k )
6787 solcutoffdist = 0.0;
6788 for( k = 0; k < row->
nlpcols; ++k )
6791 for( k = row->
nlpcols; k < row->len; ++k )
6798 solcutoffdist =
set->num_sumepsilon;
6802 return solcutoffdist;
6819 switch(
set->sepa_efficacynorm )
6831 norm = (row->
len == 0 ? 0.0 : 1.0);
6843 return -feasibility / norm;
6876 switch(
set->sepa_efficacynorm )
6888 norm = (row->
len == 0 ? 0.0 : 1.0);
6900 return -feasibility / norm;
6934 switch(
set->sepa_efficacynorm )
6946 norm = (row->
len == 0 ? 0.0 : 1.0);
6958 return -feasibility / norm;
6974 switch(
set->sepa_efficacynorm )
6986 norm = (row->
len == 0 ? 0.0 : 1.0);
6998 return -feasibility / norm;
7072 while( i1 < row1->nlpcols && i2 < row2->len )
7087 while( i1 < row1->len && i2 < row2->nlpcols )
7119 while( i1 >= 0 && i2 >= 0 )
7123 assert((row1->
cols[i1] == row2->
cols[i2]) == (row1colsidx[i1] == row2colsidx[i2]));
7124 if( row1colsidx[i1] < row2colsidx[i2] )
7126 else if( row1colsidx[i1] > row2colsidx[i2] )
7130 scalarprod += row1->
vals[i1] * row2->
vals[i2];
7158 while( ilp1 < row1->nlpcols && inlp1 < row1->len && ilp2 < row2->nlpcols && inlp2 < row2->len )
7164 assert((row1->
cols[ilp1] == row2->
cols[ilp2]) == (row1colsidx[ilp1] == row2colsidx[ilp2]));
7165 assert((row1->
cols[ilp1] == row2->
cols[inlp2]) == (row1colsidx[ilp1] == row2colsidx[inlp2]));
7166 assert((row1->
cols[inlp1] == row2->
cols[ilp2]) == (row1colsidx[inlp1] == row2colsidx[ilp2]));
7167 assert((row1->
cols[inlp1] == row2->
cols[inlp2]) == (row1colsidx[inlp1] == row2colsidx[inlp2]));
7170 if( row1colsidx[ilp1] == row2colsidx[ilp2] )
7172 scalarprod += row1->
vals[ilp1] * row2->
vals[ilp2];
7177 else if( row1colsidx[ilp1] == row2colsidx[inlp2] )
7179 scalarprod += row1->
vals[ilp1] * row2->
vals[inlp2];
7184 else if( row1colsidx[inlp1] == row2colsidx[ilp2] )
7186 scalarprod += row1->
vals[inlp1] * row2->
vals[ilp2];
7191 else if( row1colsidx[inlp1] == row2colsidx[inlp2] && row1->
cols[inlp1]->
lppos >= 0 )
7193 scalarprod += row1->
vals[inlp1] * row2->
vals[inlp2];
7198 else if( row1colsidx[ilp1] < row1colsidx[inlp1] )
7200 if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7202 if( row1colsidx[ilp1] < row2colsidx[ilp2] )
7209 if( row1colsidx[ilp1] < row2colsidx[inlp2] )
7217 if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7219 if( row1colsidx[inlp1] < row2colsidx[ilp2] )
7226 if( row1colsidx[inlp1] < row2colsidx[inlp2] )
7238 if( ilp1 != row1->
nlpcols && inlp1 != row1->
len )
7276 while( i1 < end1 && ilp2 < row2->nlpcols && inlp2 < row2->len )
7281 assert((row1->
cols[i1] == row2->
cols[ilp2]) == (row1colsidx[i1] == row2colsidx[ilp2]));
7282 assert((row1->
cols[i1] == row2->
cols[inlp2]) == (row1colsidx[i1] == row2colsidx[inlp2]));
7285 if( row1colsidx[i1] == row2colsidx[ilp2] )
7287 scalarprod += row1->
vals[i1] * row2->
vals[ilp2];
7292 else if( row1colsidx[i1] == row2colsidx[inlp2] && (lpcols || row1->
cols[i1]->
lppos >= 0) )
7294 scalarprod += row1->
vals[i1] * row2->
vals[inlp2];
7299 else if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7301 if( row1colsidx[i1] < row2colsidx[ilp2] )
7308 if( row1colsidx[i1] < row2colsidx[inlp2] )
7336 while( i1 < end1 && i2 < end2 )
7340 assert((row1->
cols[i1] == row2->
cols[i2]) == (row1colsidx[i1] == row2colsidx[i2]));
7343 if( row1colsidx[i1] == row2colsidx[i2] && (lpcols || row1->
cols[i1]->
lppos >= 0) )
7345 scalarprod += row1->
vals[i1] * row2->
vals[i2];
7350 else if( row1colsidx[i1] < row2colsidx[i2] )
7429 while( i1 < row1->nlpcols && i2 < row2->len )
7444 while( i1 < row1->len && i2 < row2->nlpcols )
7476 while( i1 >= 0 && i2 >= 0 )
7480 assert((row1->
cols[i1] == row2->
cols[i2]) == (row1colsidx[i1] == row2colsidx[i2]));
7481 if( row1colsidx[i1] < row2colsidx[i2] )
7483 else if( row1colsidx[i1] > row2colsidx[i2] )
7515 while( ilp1 < row1->nlpcols && inlp1 < row1->len && ilp2 < row2->nlpcols && inlp2 < row2->len )
7521 assert((row1->
cols[ilp1] == row2->
cols[ilp2]) == (row1colsidx[ilp1] == row2colsidx[ilp2]));
7522 assert((row1->
cols[ilp1] == row2->
cols[inlp2]) == (row1colsidx[ilp1] == row2colsidx[inlp2]));
7523 assert((row1->
cols[inlp1] == row2->
cols[ilp2]) == (row1colsidx[inlp1] == row2colsidx[ilp2]));
7524 assert((row1->
cols[inlp1] == row2->
cols[inlp2]) == (row1colsidx[inlp1] == row2colsidx[inlp2]));
7527 if( row1colsidx[ilp1] == row2colsidx[ilp2] )
7534 else if( row1colsidx[ilp1] == row2colsidx[inlp2] )
7541 else if( row1colsidx[inlp1] == row2colsidx[ilp2] )
7548 else if( row1colsidx[inlp1] == row2colsidx[inlp2] && row1->
cols[inlp1]->
lppos >= 0 )
7555 else if( row1colsidx[ilp1] < row1colsidx[inlp1] )
7557 if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7559 if( row1colsidx[ilp1] < row2colsidx[ilp2] )
7566 if( row1colsidx[ilp1] < row2colsidx[inlp2] )
7574 if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7576 if( row1colsidx[inlp1] < row2colsidx[ilp2] )
7583 if( row1colsidx[inlp1] < row2colsidx[inlp2] )
7595 if( ilp1 != row1->
nlpcols && inlp1 != row1->
len )
7633 while( i1 < end1 && ilp2 < row2->nlpcols && inlp2 < row2->len )
7638 assert((row1->
cols[i1] == row2->
cols[ilp2]) == (row1colsidx[i1] == row2colsidx[ilp2]));
7639 assert((row1->
cols[i1] == row2->
cols[inlp2]) == (row1colsidx[i1] == row2colsidx[inlp2]));
7642 if( row1colsidx[i1] == row2colsidx[ilp2] )
7649 else if( row1colsidx[i1] == row2colsidx[inlp2] && (lpcols || row1->
cols[i1]->
lppos >= 0) )
7656 else if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7658 if( row1colsidx[i1] < row2colsidx[ilp2] )
7665 if( row1colsidx[i1] < row2colsidx[inlp2] )
7693 while( i1 < end1 && i2 < end2 )
7697 assert((row1->
cols[i1] == row2->
cols[i2]) == (row1colsidx[i1] == row2colsidx[i2]));
7700 if( row1colsidx[i1] == row2colsidx[i2] && (lpcols || row1->
cols[i1]->
lppos >= 0) )
7707 else if( row1colsidx[i1] < row2colsidx[i2] )
7735 if( scalarprod == 0.0 )
7749 for(
i = 0;
i < row1->
len; ++
i )
7759 for(
i = 0;
i < row2->
len; ++
i )
7774 SCIPerrorMessage(
"invalid orthogonality function parameter '%c'\n", orthofunc);
7824 parallelism =
MIN(parallelism, 1.0);
7825 parallelism =
MAX(parallelism, 0.0);
7847 eventtype, row->
name, (
void*)eventhdlr, (
void*)eventdata);
7868 SCIPsetDebugMsg(
set,
"drop event of row <%s> with handler %p and data %p\n", row->
name, (
void*)eventhdlr, (
void*)eventdata);
8115 assert(lpipos < lp->nrows);
8116 assert(nnonz < naddcoefs);
8117 ind[nnonz] = lpipos;
8118 val[nnonz] = col->
vals[
i];
8316 name[pos] = row->
name;
8328 assert(lpipos < lp->ncols);
8329 assert(nnonz < naddcoefs);
8331 ind[nnonz] = lpipos;
8332 val[nnonz] = row->
vals[
i];
8446 assert(nobjchg < lp->ncols);
8447 objind[nobjchg] = col->
lpipos;
8465 assert(nbdchg < lp->ncols);
8466 bdind[nbdchg] = col->
lpipos;
8483 SCIPsetDebugMsg(
set,
"flushing objective changes: change %d objective values of %d changed columns\n", nobjchg, lp->
nchgcols);
8581 assert(nchg < lp->nrows);
8680 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",
8874 for(
i = 0;
i < col->
len; ++
i )
8913 for(
i = 0;
i < row->
len; ++
i )
8949 for(
i = 0;
i < col->
len; ++
i )
8958 assert(0 <= pos && pos < row->nlpcols);
8987 for(
i = 0;
i < row->
len; ++
i )
9045 if( minsize <= lp->divechgsidessize )
9074#define DIVESTACKINITSIZE 100
9097 (*lp)->lpicols =
NULL;
9098 (*lp)->lpirows =
NULL;
9099 (*lp)->chgcols =
NULL;
9100 (*lp)->chgrows =
NULL;
9102 (*lp)->soldirection =
NULL;
9103 (*lp)->lazycols =
NULL;
9105 (*lp)->lpobjval = 0.0;
9106 (*lp)->glbpseudoobjval = 0.0;
9107 (*lp)->relglbpseudoobjval = 0.0;
9108 (*lp)->glbpseudoobjvalid =
TRUE;
9109 (*lp)->glbpseudoobjvalinf = 0;
9110 (*lp)->pseudoobjval = 0.0;
9111 (*lp)->relpseudoobjval = 0.0;
9112 (*lp)->pseudoobjvalid =
TRUE;
9113 (*lp)->pseudoobjvalinf = 0;
9114 (*lp)->looseobjval = 0.0;
9115 (*lp)->rellooseobjval = 0.0;
9116 (*lp)->looseobjvalid =
TRUE;
9117 (*lp)->looseobjvalinf = 0;
9118 (*lp)->nloosevars = 0;
9124 (*lp)->validdegeneracylp = -1;
9125 (*lp)->objsqrnorm = 0.0;
9126 (*lp)->objsumnorm = 0.0;
9127 (*lp)->lpicolssize = 0;
9128 (*lp)->nlpicols = 0;
9129 (*lp)->lpirowssize = 0;
9130 (*lp)->nlpirows = 0;
9131 (*lp)->lpifirstchgcol = 0;
9132 (*lp)->lpifirstchgrow = 0;
9133 (*lp)->colssize = 0;
9134 (*lp)->soldirectionsize = 0;
9136 (*lp)->lazycolssize = 0;
9137 (*lp)->nlazycols = 0;
9138 (*lp)->rowssize = 0;
9140 (*lp)->chgcolssize = 0;
9141 (*lp)->nchgcols = 0;
9142 (*lp)->chgrowssize = 0;
9143 (*lp)->nchgrows = 0;
9144 (*lp)->firstnewcol = 0;
9145 (*lp)->firstnewrow = 0;
9146 (*lp)->nremovablecols = 0;
9147 (*lp)->nremovablerows = 0;
9148 (*lp)->validsollp = stat->
lpcount;
9149 (*lp)->validfarkaslp = -1;
9150 (*lp)->validsoldirlp = -1;
9151 (*lp)->validsoldirsol =
NULL;
9152 (*lp)->objsqrnormunreliable =
FALSE;
9153 (*lp)->flushdeletedcols =
FALSE;
9154 (*lp)->flushaddedcols =
FALSE;
9155 (*lp)->flushdeletedrows =
FALSE;
9156 (*lp)->flushaddedrows =
FALSE;
9157 (*lp)->updateintegrality =
TRUE;
9158 (*lp)->flushed =
TRUE;
9160 (*lp)->solved =
TRUE;
9161 (*lp)->primalfeasible =
TRUE;
9162 (*lp)->primalchecked =
TRUE;
9163 (*lp)->dualfeasible =
TRUE;
9164 (*lp)->dualchecked =
TRUE;
9165 (*lp)->solisbasic =
FALSE;
9166 (*lp)->rootlpisrelax =
TRUE;
9167 (*lp)->isrelax =
TRUE;
9168 (*lp)->installing =
FALSE;
9169 (*lp)->strongbranching =
FALSE;
9170 (*lp)->strongbranchprobing =
FALSE;
9171 (*lp)->probing =
FALSE;
9172 (*lp)->diving =
FALSE;
9173 (*lp)->divingobjchg =
FALSE;
9174 (*lp)->divinglazyapplied =
FALSE;
9175 (*lp)->divelpistate =
NULL;
9176 (*lp)->divelpwasprimfeas =
TRUE;
9177 (*lp)->divelpwasprimchecked =
TRUE;
9178 (*lp)->divelpwasdualfeas =
TRUE;
9179 (*lp)->divelpwasdualchecked =
TRUE;
9180 (*lp)->divechgsides =
NULL;
9181 (*lp)->divechgsidetypes =
NULL;
9182 (*lp)->divechgrows =
NULL;
9183 (*lp)->ndivechgsides = 0;
9184 (*lp)->divechgsidessize = 0;
9185 (*lp)->ndivingrows = 0;
9186 (*lp)->divinglpiitlim = INT_MAX;
9187 (*lp)->resolvelperror =
FALSE;
9188 (*lp)->divenolddomchgs = 0;
9189 (*lp)->adjustlpval =
FALSE;
9191 (*lp)->lpifeastol = (*lp)->feastol;
9194 (*lp)->lpifromscratch =
FALSE;
9195 (*lp)->lpifastmip =
set->lp_fastmip;
9196 (*lp)->lpiscaling =
set->lp_scaling;
9197 (*lp)->lpipresolving =
set->lp_presolving;
9198 (*lp)->lpilpinfo =
set->disp_lpinfo;
9199 (*lp)->lpirowrepswitch =
set->lp_rowrepswitch;
9200 (*lp)->lpisolutionpolishing = (
set->lp_solutionpolishing > 0);
9201 (*lp)->lpirefactorinterval =
set->lp_refactorinterval;
9202 (*lp)->lpiconditionlimit =
set->lp_conditionlimit;
9203 (*lp)->lpimarkowitz =
set->lp_markowitz;
9204 (*lp)->lpiitlim = INT_MAX;
9207 (*lp)->lpithreads =
set->lp_threads;
9208 (*lp)->lpitiming = (int)
set->time_clocktype;
9209 (*lp)->lpirandomseed =
set->random_randomseed;
9210 (*lp)->storedsolvals =
NULL;
9220 "LP Solver <%s>: objective limit cannot be set -- can lead to unnecessary simplex iterations\n",
9224 (*lp)->lpihasfeastol = success;
9228 "LP Solver <%s>: primal feasibility tolerance cannot be set -- tolerance of SCIP and LP solver may differ\n",
9232 (*lp)->lpihasdualfeastol = success;
9236 "LP Solver <%s>: dual feasibility tolerance cannot be set -- tolerance of SCIP and LP solver may differ\n",
9240 (*lp)->lpihasbarrierconvtol = success;
9244 "LP Solver <%s>: barrier convergence tolerance cannot be set -- tolerance of SCIP and LP solver may differ\n",
9249 (*lp)->lpihasfastmip = success;
9253 "LP Solver <%s>: fastmip setting not available -- SCIP parameter has no effect\n",
9257 (*lp)->lpihasscaling = success;
9261 "LP Solver <%s>: scaling not available -- SCIP parameter has no effect\n",
9265 (*lp)->lpihaspresolving = success;
9269 "LP Solver <%s>: presolving not available -- SCIP parameter has no effect\n",
9276 "LP Solver <%s>: clock type cannot be set\n",
9283 "LP Solver <%s>: iteration limit cannot be set -- can lead to unnecessary simplex iterations\n",
9290 "LP Solver <%s>: pricing strategy cannot be set -- SCIP parameter has no effect\n",
9297 "LP Solver <%s>: lpinfo setting not available -- SCIP parameter has no effect\n",
9301 (*lp)->lpihasrowrep = success;
9305 "LP Solver <%s>: row representation of the basis not available -- SCIP parameter lp/rowrepswitch has no effect\n",
9309 (*lp)->lpihaspolishing = success;
9313 "LP Solver <%s>: solution polishing not available -- SCIP parameter lp/solutionpolishing has no effect\n",
9317 (*lp)->lpihasrefactor = success;
9321 "LP Solver <%s>: refactorization interval not available -- SCIP parameter lp/refactorinterval has no effect\n",
9328 "LP Solver <%s>: condition number limit for the basis not available -- SCIP parameter lp/conditionlimit has no effect\n",
9335 "LP Solver <%s>: markowitz threshhold not available -- SCIP parameter lp/minmarkowitz has no effect\n",
9342 "LP Solver <%s>: number of threads settings not available -- SCIP parameter has no effect\n",
9346 if( (*lp)->lpirandomseed != 0 )
9352 "LP Solver <%s>: random seed parameter not available -- SCIP parameter has no effect\n",
9361 SCIPerrorMessage(
"The infinity value of the LP solver has to be at least as large as the one of SCIP.\n");
9387 for(
i = 0;
i < (*lp)->nlpirows; ++
i )
9392 if( (*lp)->lpi !=
NULL )
9471 for(
i = 0;
i < col->
len; ++
i )
9531 for(
i = 0;
i < row->
len; ++
i )
9628#define checkLazyColArray(lp, set)
9645 assert(newncols <= lp->ncols);
9647 if( newncols < lp->ncols )
9651 for(
c = lp->
ncols-1;
c >= newncols; --
c )
9717 assert(0 <= newnrows && newnrows <= lp->nrows);
9720 if( newnrows < lp->nrows )
9722 for(
r = lp->
nrows-1;
r >= newnrows; --
r )
9976 lhsinfinite =
FALSE;
9977 rhsinfinite =
FALSE;
9989 for(
i = 0;
i < row->
len; ++
i )
10002 if( weights[
r] > 0.0 )
10080 if( lpistate ==
NULL )
10107 if( *lpistate !=
NULL )
10167 if( lpinorms !=
NULL )
10262 assert(newfeastol > 0.0);
10267 if( newfeastol < lp->feastol )
10304 return "primal simplex";
10306 return "dual simplex";
10310 return "barrier/crossover";
10345#ifdef SCIP_MORE_DEBUG
10351 SCIPsetDebugMsg(
set,
"wrote LP to file <%s> (primal simplex, objlim=%.15g, feastol=%.15g/%.15g, fromscratch=%d, fastmip=%d, scaling=%d, presolving=%d)\n",
10415 if( iterations > 0 )
10460 if ( keepsol && !(*
lperror) )
10503#ifdef SCIP_MORE_DEBUG
10509 SCIPsetDebugMsg(
set,
"wrote LP to file <%s> (dual simplex, objlim=%.15g, feastol=%.15g/%.15g, fromscratch=%d, fastmip=%d, scaling=%d, presolving=%d)\n",
10573 if( iterations > 0 )
10680 int totalIterations;
10724 totalIterations = iterations;
10742 if( iterations > 0 )
10815 chooseBasic =
set->lp_lexdualbasic;
10881#ifdef DEBUG_LEXDUAL
10894 for( j = 0; j < lp->
nlpicols; ++j )
10969 if( pos == -1 &&
c > oldpos )
10982 if( pos == -1 &&
c > oldpos )
10987 newlb[cntcol] = oldlb[
c];
10988 newub[cntcol] = oldlb[
c];
10989 indcol[cntcol++] =
c;
11004 newlb[cntcol] = oldlb[
c];
11005 newub[cntcol] = oldlb[
c];
11011 newlb[cntcol] = oldub[
c];
11012 newub[cntcol] = oldub[
c];
11017 newlb[cntcol] = 0.0;
11018 newub[cntcol] = 0.0;
11021 indcol[cntcol++] =
c;
11045 newlhs[cntrow] = oldlhs[
r];
11046 newrhs[cntrow] = oldlhs[
r];
11051 newlhs[cntrow] = oldrhs[
r];
11052 newrhs[cntrow] = oldrhs[
r];
11054 indrow[cntrow++] =
r;
11061 if( nDualDeg > 0 && pos >= 0 )
11063 assert(0 <= pos && pos < lp->nlpicols && pos > oldpos);
11095 lexIterations += iterations;
11097#ifdef DEBUG_LEXDUAL
11098 if( iterations > 0 )
11110 for( j = 0; j < lp->
nlpicols; ++j )
11161 if( iterations > 0 )
11166 while( pos >= 0 && nDualDeg > 0 && (
set->lp_lexdualmaxrounds == -1 || rounds < set->lp_lexdualmaxrounds) );
11186 lexIterations += iterations;
11194 if( lexIterations > 0 )
11200 SCIPstatAdd(stat,
set, nlexdualresolvelpiterations, lexIterations);
11205 totalIterations += lexIterations;
11292#ifdef SCIP_MORE_DEBUG
11298 SCIPsetDebugMsg(
set,
"wrote LP to file <%s> (barrier, objlim=%.15g, feastol=%.15g/%.15g, convtol=%.15g, fromscratch=%d, fastmip=%d, scaling=%d, presolving=%d)\n",
11351 if( iterations > 0 )
11425 if(
set->istimelimitfinite )
11429 if( lptimelimit > 0.0 )
11432 if( lptimelimit <= 0.0 || !success )
11487#define MAXNUMTROUBLELPMSGS 10
11501 const char* formatstr,
11524 if( verblevel >
set->disp_verblevel )
11534 va_start(ap, formatstr);
11541 SCIPmessagePrintInfo(messagehdlr,
" -- further messages will be suppressed (use display/verblevel=5 to see all)");
11566 if( !
set->lp_checkdualfeas )
11568 if( !
set->lp_checkprimfeas )
11575#define FEASTOLTIGHTFAC 0.001
11621 SCIPerrorMessage(
"cannot solve LP when loose variable with infinite best bound is present\n");
11629 itlimishard = (itlim == harditlim);
11635 usepolishing =
TRUE;
11642 usepolishing =
FALSE;
11684 if( !
set->lp_checkstability )
11711 if( !
set->lp_checkstability )
11731 lpalgoName(lpalgo), (scaling == 0) ?
"with" :
"without");
11738 if( !
set->lp_checkstability )
11761 lpalgoName(lpalgo), !
set->lp_presolving ?
"with" :
"without");
11768 if( !
set->lp_checkstability )
11785 if( ((simplex && (!tightprimfeastol || !tightdualfeastol)) || (!tightprimfeastol && !tightdualfeastol)) &&
11789 if( !tightprimfeastol )
11795 if( !tightdualfeastol )
11801 if( !simplex && !tightprimfeastol && !tightdualfeastol )
11807 if( success || success2 || success3 )
11817 if( !
set->lp_checkstability )
11826 if( !tightprimfeastol )
11830 if( !tightdualfeastol )
11834 if( !simplex && !tightprimfeastol && !tightdualfeastol )
11846 if( !fromscratch && simplex )
11858 if( !
set->lp_checkstability )
11879 if( !
set->lp_checkstability )
11892 lpalgoName(lpalgo), (scaling == 0) ?
"with" :
"without");
11899 if( !
set->lp_checkstability )
11917 lpalgoName(lpalgo), !
set->lp_presolving ?
"with" :
"without");
11924 if( !
set->lp_checkstability )
11938 if( !tightprimfeastol || !tightdualfeastol )
11941 if( !tightprimfeastol )
11947 if( !tightdualfeastol )
11953 if( success || success2 )
11963 if( !
set->lp_checkstability )
11972 if( !tightprimfeastol )
11976 if( !tightdualfeastol )
12059 solvedprimal =
FALSE;
12060 solveddual =
FALSE;
12064 itlim = ( resolve ? resolveitlim : harditlim );
12068 SCIP_CALL(
lpSolveStable(lp,
set, messagehdlr, stat, prob, lpalgo, itlim, harditlim, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch,
12069 scaling, keepsol, &timelimit,
lperror) );
12205 SCIPsetDebugMsg(
set,
"solving LP with %s returned solstat=%d (internal status: %d, primalfeasible=%u, dualfeasible=%u)\n",
12248 algo = resolve ?
set->lp_resolvealgorithm :
set->lp_initalgorithm;
12258 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12264 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12271 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12277 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12283 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12289 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12293 SCIPerrorMessage(
"invalid parameter setting <%c> for LP algorithm\n", algo);
12324#define checkLazyBounds(lp, set)
12347 SCIPsetDebugMsg(
set,
"mark all lazy columns as changed in order to reload bounds (diving=%u, applied=%u)\n",
12400 if( (
set->lp_resolveiterfac == -1) || stat->
nlps - stat->
nrootlps < 5 )
12406 return (
int)
MIN(itlim,
MAX(
set->lp_resolveitermin, \
12451 SCIPsetDebugMsg(
set,
"solving LP: %d rows, %d cols, primalfeasible=%u, dualfeasible=%u, solved=%u, diving=%u, probing=%u, cutoffbnd=%g\n",
12455 needprimalray =
TRUE;
12457 || (
set->conf_enable &&
set->conf_useinflp !=
'o'));
12460 harditlim = (int)
MIN(itlim, INT_MAX);
12462 assert(harditlim == -1 || (resolveitlim <= harditlim));
12501 tightprimfeastol =
FALSE;
12502 tightdualfeastol =
FALSE;
12503 fromscratch =
FALSE;
12504 primalfeasible =
FALSE;
12505 dualfeasible =
FALSE;
12506 wasfromscratch = (stat->
nlps == 0);
12507 scaling =
set->lp_scaling;
12511 oldnlps = stat->
nlps;
12512 SCIP_CALL(
lpFlushAndSolve(lp, blkmem,
set, messagehdlr, stat, prob, eventqueue, resolveitlim, harditlim, needprimalray,
12513 needdualray, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12529 if(
set->lp_checkprimfeas )
12531 primalfeaspointer = &primalfeasible;
12537 primalfeasible =
TRUE;
12538 primalfeaspointer =
NULL;
12541 if(
set->lp_checkdualfeas )
12543 dualfeaspointer = &dualfeasible;
12549 dualfeasible =
TRUE;
12550 dualfeaspointer =
NULL;
12559 if( primalfeasible && dualfeasible && aging && !lp->
diving && stat->
nlps > oldnlps )
12563 if( stat->
nlps % ((
set->lp_rowagelimit+1)/2 + 1) == 0 )
12576 if( !primalfeasible || !dualfeasible )
12580 if( (fastmip > 0) && simplex )
12585 stat->
nnodes, stat->
nlps, primalfeasible, dualfeasible);
12589 else if( (!primalfeasible && !tightprimfeastol) || (!dualfeasible && !tightdualfeastol) )
12596 stat->
nnodes, stat->
nlps, primalfeasible, dualfeasible);
12597 tightprimfeastol = tightprimfeastol || !primalfeasible;
12598 tightdualfeastol = tightdualfeastol || !dualfeasible;
12601 else if( !fromscratch && !wasfromscratch && simplex )
12606 stat->
nnodes, stat->
nlps, primalfeasible, dualfeasible);
12607 fromscratch =
TRUE;
12618 SCIPsetDebugMsg(
set,
" -> LP objective value: %g + %g = %g (solstat=%d, cutoff=%g)\n",
12640 farkasvalid =
FALSE;
12645 farkasvalid =
TRUE;
12648 if( !farkasvalid && !(*
lperror) )
12652 if( (fastmip > 0) && simplex )
12663 else if( !tightdualfeastol )
12671 tightdualfeastol =
TRUE;
12674 else if( !fromscratch && simplex )
12682 fromscratch =
TRUE;
12700 if(
set->lp_checkprimfeas )
12712 primalfeasible =
TRUE;
12713 rayfeasible =
TRUE;
12720 SCIPsetDebugMsg(
set,
" -> LP has unbounded primal ray (primalfeas=%u, rayfeas=%u)\n",
12721 primalfeasible, rayfeasible);
12723 if( !primalfeasible || !rayfeasible )
12727 if( (fastmip > 0) && simplex )
12732 stat->
nnodes, stat->
nlps, primalfeasible, rayfeasible);
12736 else if( !tightprimfeastol )
12743 stat->
nnodes, stat->
nlps, primalfeasible, rayfeasible);
12744 tightprimfeastol =
TRUE;
12747 else if( !fromscratch && simplex )
12752 stat->
nnodes, stat->
nlps, primalfeasible, rayfeasible);
12753 fromscratch =
TRUE;
12756 else if( scaling > 0 )
12761 stat->
nnodes, stat->
nlps, primalfeasible, rayfeasible);
12807 char tmppricingchar;
12813 fromscratch =
FALSE;
12825 FALSE,
FALSE,
TRUE, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12847 if( !(*
lperror) && (fastmip > 0) && simplex )
12851 FALSE,
FALSE,
TRUE, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12866 SCIPsetDebugMsg(
set,
"unresolved error while resolving LP in order to exceed the objlimit\n");
12882 if(
set->lp_checkprimfeas )
12884 primalfeaspointer = &primalfeasible;
12890 primalfeasible =
TRUE;
12891 primalfeaspointer =
NULL;
12894 if(
set->lp_checkdualfeas )
12896 dualfeaspointer = &dualfeasible;
12902 dualfeasible =
TRUE;
12903 dualfeaspointer =
NULL;
12928 if( !primalfeasible || !dualfeasible
12938 SCIPsetDebugMsg(
set,
" -> LP objective value: %g + %g = %g (solstat=%d, cutoff=%g)\n",
12962 farkasvalid =
FALSE;
12967 farkasvalid =
TRUE;
12973 if( !tightprimfeastol )
12981 tightprimfeastol =
TRUE;
12992 fromscratch =
TRUE;
13010 if(
set->lp_checkprimfeas )
13022 primalfeasible =
TRUE;
13023 rayfeasible =
TRUE;
13032 if( !primalfeasible || !rayfeasible )
13070 SCIPmessagePrintWarning(messagehdlr,
"LP solver reached time limit, but SCIP time limit is not exceeded yet; "
13071 "you might consider switching the clock type of SCIP\n");
13097 SCIPsetDebugMsg(
set,
"resetting parameter SCIP_LPPARAM_FROMSCRATCH to FALSE %s\n", success ?
"" :
"failed");
13227 for( v = 0; v <
nvars; ++v )
13345 int pseudoobjvalinf;
13356 pseudoobjval -= oldbound *
obj;
13357 assert(pseudoobjvalinf >= 0);
13361 pseudoobjval += newbound *
obj;
13363 assert(pseudoobjvalinf >= 0);
13365 if( pseudoobjvalinf > 0 ||
set->nactivepricers > 0 )
13368 return pseudoobjval;
13384 int pseudoobjvalinf;
13410 assert(pseudoobjvalinf >= 0);
13422 assert(pseudoobjvalinf >= 0);
13424 if( pseudoobjvalinf > 0 ||
set->nactivepricers > 0 )
13427 return pseudoobjval;
13469 (*deltaval) = ub *
newobj;
13478 (*deltaval) = -lb *
oldobj;
13493 (*deltaval) = -lb *
oldobj;
13514 (*deltaval) = lb *
newobj;
13523 (*deltaval) = -ub *
oldobj;
13538 (*deltaval) = -ub *
oldobj;
13549 (*deltaval) = ub *
newobj;
13556 (*deltaval) = lb *
newobj;
13582 (*deltaval) = newlb *
obj;
13593 (*deltaval) = -oldlb *
obj;
13598 (*deltaval) =
obj * (newlb - oldlb);
13623 (*deltaval) = newub *
obj;
13634 (*deltaval) = -oldub *
obj;
13639 (*deltaval) =
obj * (newub - oldub);
13759 SCIPerrorMessage(
"LP was informed of an objective change of a non-active variable\n");
13851 if(
set->misc_exactsolve )
13932 if(
set->misc_exactsolve )
14000 if(
set->misc_exactsolve )
14195 if(
set->misc_exactsolve )
14319 if(
set->misc_exactsolve )
14388 if( primalfeasible ==
NULL )
14389 stillprimalfeasible =
FALSE;
14392 *primalfeasible =
TRUE;
14393 stillprimalfeasible =
TRUE;
14395 if( dualfeasible ==
NULL )
14396 stilldualfeasible =
FALSE;
14399 *dualfeasible =
TRUE;
14400 stilldualfeasible =
TRUE;
14420#ifdef SCIP_USE_LPSOLVER_ACTIVITY
14442 for(
c = 0;
c < nlpicols; ++
c )
14444 assert( 0 <= cstat[
c] && cstat[
c] < 4 );
14452 stillprimalfeasible =
FALSE;
14453 stilldualfeasible =
FALSE;
14462 if( stillprimalfeasible )
14464 stillprimalfeasible =
14467 primalbound += (lpicols[
c]->
primsol * lpicols[
c]->
obj);
14477 if( stilldualfeasible )
14482 if( stilldualfeasible )
14488 SCIPsetDebugMsg(
set,
" col <%s> [%.9g,%.9g]: primsol=%.9f, redcost=%.9f, pfeas=%u/%u(%u), dfeas=%d/%d(%u)\n",
14492 primalfeasible !=
NULL ? stillprimalfeasible :
TRUE,
14495 dualfeasible !=
NULL ? stilldualfeasible :
TRUE);
14509 if( stilldualfeasible
14512 if( stilldualfeasible
14516 SCIPsetDebugMsg(
set,
" col <%s> [%.9g,%.9g]: primsol=%.9f, redcost=%.9f, pfeas=%u/%u(%u), dfeas=%d/%d(%u)\n",
14520 primalfeasible !=
NULL ? stillprimalfeasible :
TRUE,
14523 dualfeasible !=
NULL ? stilldualfeasible :
TRUE);
14530 if( stilldualfeasible )
14533 dualbound += (lpicols[
c]->
redcost * lpicols[
c]->
lb);
14535 dualbound += (lpicols[
c]->
redcost * lpicols[
c]->
ub);
14540 for(
r = 0;
r < nlpirows; ++
r )
14542 assert( 0 <= rstat[
r] && rstat[
r] < 4 );
14544#ifdef SCIP_USE_LPSOLVER_ACTIVITY
14548 if( lpirows[
r]->validactivitylp != stat->
lpcount )
14553 if( stillprimalfeasible )
14555 stillprimalfeasible =
14567 if( stilldualfeasible )
14569 compslack =
MIN((lpirows[
r]->activity - lpirows[
r]->lhs), 1.0) * lpirows[
r]->
dualsol;
14572 if( stilldualfeasible )
14574 compslack =
MIN((lpirows[
r]->rhs - lpirows[
r]->activity), 1.0) * lpirows[
r]->
dualsol;
14578 SCIPsetDebugMsg(
set,
" row <%s> [%.9g,%.9g]: activity=%.9f, dualsol=%.9f, pfeas=%u/%u(%u), dfeas=%d/%d(%u)\n",
14579 lpirows[
r]->name, lpirows[
r]->lhs, lpirows[
r]->rhs, lpirows[
r]->activity, lpirows[
r]->dualsol,
14582 primalfeasible !=
NULL ? stillprimalfeasible :
TRUE,
14585 dualfeasible !=
NULL ? stilldualfeasible :
TRUE);
14593 if( stilldualfeasible &&
14596 if( stilldualfeasible &&
14600 SCIPsetDebugMsg(
set,
" row <%s> [%.9g,%.9g] + %.9g: activity=%.9f, dualsol=%.9f, pfeas=%u/%u(%u), dfeas=%d/%d(%u)\n",
14601 lpirows[
r]->name, lpirows[
r]->lhs, lpirows[
r]->rhs, lpirows[
r]->constant, lpirows[
r]->activity, lpirows[
r]->dualsol,
14604 primalfeasible !=
NULL ? stillprimalfeasible :
TRUE,
14607 dualfeasible !=
NULL ? stilldualfeasible :
TRUE);
14614 if( stilldualfeasible )
14648 if( primalfeasible !=
NULL )
14649 *primalfeasible = stillprimalfeasible;
14650 if( dualfeasible !=
NULL )
14651 *dualfeasible = stilldualfeasible;
14657#ifdef SCIP_USE_LPSOLVER_ACTIVITY
14698 if( primalfeasible !=
NULL )
14699 *primalfeasible =
TRUE;
14700 if( rayfeasible !=
NULL )
14701 *rayfeasible =
TRUE;
14711 SCIPerrorMessage(
"LP solver has no primal ray to prove unboundedness.\n");
14733 for(
c = 0;
c < nlpicols; ++
c )
14741 if( rayfeasible !=
NULL )
14743 *rayfeasible = *rayfeasible
14749 rayobjval += ray[
c] * col->
obj;
14772 for(
r = 0;
r < nlpirows; ++
r )
14783 col = row->
cols[
c];
14797 col = row->
cols[
c];
14800 if( col->
lppos >= 0 )
14818 if( primalfeasible !=
NULL )
14820 assert( *primalfeasible );
14821 for(
c = 0;
c < nlpicols; ++
c )
14831 *primalfeasible =
FALSE;
14839 for(
r = 0;
r < nlpirows; ++
r )
14852 col = row->
cols[
c];
14867 col = row->
cols[
c];
14870 if( col->
lppos >= 0 )
14879 if( primalfeasible !=
NULL && *primalfeasible )
14883 *primalfeasible =
FALSE;
14887 if( rayfeasible !=
NULL && *rayfeasible )
14891 *rayfeasible =
FALSE;
14895 activity[
r] = primact;
14898 if( primalfeasible !=
NULL && !(*primalfeasible) )
14903 else if( rayfeasible !=
NULL && !(*rayfeasible) )
14914 if( rayfeasible !=
NULL )
14915 *rayfeasible =
FALSE;
14921 assert(rayobjval != 0.0);
14928 for(
c = 0;
c < nlpicols; ++
c )
14933 rayscale =
MIN(rayscale, (lpicols[
c]->ub -
primsol[
c]) / ray[
c]);
14938 rayscale =
MIN(rayscale, 1.0 / ray[
c]);
14944 rayscale =
MIN(rayscale, (lpicols[
c]->lb -
primsol[
c]) / ray[
c]);
14949 rayscale =
MIN(rayscale, -1.0 / ray[
c]);
14957 SCIPsetDebugMsg(
set,
"unbounded LP solution: rayobjval=%f, rayscale=%f\n", rayobjval, rayscale);
14962 for(
c = 0;
c < nlpicols; ++
c )
14969 primsolval =
primsol[
c] + rayscale * ray[
c];
14977 for(
r = 0;
r < nlpirows; ++
r )
15034 for(
c = 0;
c < nlpicols;
c++ )
15090 farkascoefs =
NULL;
15114 for(
r = 0;
r < nlpirows; ++
r )
15123 if( checkfarkas && dualfarkas[
r] != 0.0 )
15136 SCIPsetDebugMsg(
set,
"farkas proof is invalid: row <%s>[lhs=%g,rhs=%g,c=%g] has multiplier %g\n",
15137 SCIProwGetName(lpirows[
r]), lpirows[
r]->lhs, lpirows[
r]->rhs, lpirows[
r]->constant, dualfarkas[
r]);
15151 for(
c = 0;
c < lpirows[
r]->
len;
c++ )
15158 assert(pos >= 0 && pos < nlpicols);
15160 farkascoefs[pos] += dualfarkas[
r] * lpirows[
r]->
vals[
c];
15164 if( dualfarkas[
r] > 0.0 )
15168 farkaslhs += dualfarkas[
r] * lpirows[
r]->
lhs;
15171 else if( dualfarkas[
r] < 0.0 )
15175 farkaslhs += dualfarkas[
r] * lpirows[
r]->
rhs;
15178 maxactivity += dualfarkas[
r] * lpirows[
r]->
constant;
15183 for(
c = 0;
c < nlpicols; ++
c )
15201 if( farkascoefs[
c] > 0.0 )
15203 maxactivity += farkascoefs[
c] * lpicols[
c]->
ub;
15207 SCIPsetDebugMsg(
set,
"farkas proof is invalid: col <%s>[lb=%g,ub=%g] has coefficient %g\n",
15216 maxactivity += farkascoefs[
c] * lpicols[
c]->
lb;
15220 SCIPsetDebugMsg(
set,
"farkas proof is invalid: col <%s>[lb=%g,ub=%g] has coefficient %g\n",
15236 SCIPsetDebugMsg(
set,
"farkas proof is invalid: maxactivity=%.12f, lhs=%.12f\n", maxactivity, farkaslhs);
15297 for(
c = 0;
c < nlpicols; ++
c )
15303 lpicols[
c]->
age = 0;
15308 for(
r = 0;
r < nlpirows; ++
r )
15313 if( lpirows[
r]->dualsol == 0.0 )
15320 lpirows[
r]->
age = 0;
15353 for(
c = 0;
c < ncols; ++
c )
15359 col->
lppos = coldstat[
c];
15360 if( coldstat[
c] == -1 )
15378 else if( coldstat[
c] <
c )
15382 lp->
cols[coldstat[
c]] = col;
15405 if( lp->
ncols < ncols )
15454 for(
r = 0;
r < nrows; ++
r )
15460 row->
lppos = rowdstat[
r];
15461 if( rowdstat[
r] == -1 )
15490 else if( rowdstat[
r] <
r )
15494 lp->
rows[rowdstat[
r]] = row;
15504 if( lp->
nrows < nrows )
15566 for(
c = firstcol;
c < ncols; ++
c )
15571 if( cols[
c]->removable
15572 && cols[
c]->obsoletenode != stat->
nnodes
15573 && cols[
c]->
age >
set->lp_colagelimit
15645 for(
r = firstrow;
r < nrows; ++
r )
15650 if( rows[
r]->removable
15651 && rows[
r]->obsoletenode != stat->
nnodes
15652 && rows[
r]->
age >
set->lp_rowagelimit
15659 rows[
r]->name, rows[
r]->activity, rows[
r]->lhs, rows[
r]->rhs);
15694 SCIPsetDebugMsg(
set,
"removing obsolete columns starting with %d/%d, obsolete rows starting with %d/%d\n",
15727 if( 0 < lp->
ncols )
15731 if( 0 < lp->
nrows )
15761 assert(0 <= firstcol && firstcol < lp->ncols);
15776 for(
c = firstcol;
c < ncols; ++
c )
15781 if( lpicols[
c]->removable
15834 assert(0 <= firstrow && firstrow < lp->nrows);
15851 for(
r = firstrow;
r < nrows; ++
r )
15899 cleanupcols = (root ?
set->lp_cleanupcolsroot :
set->lp_cleanupcols);
15900 cleanuprows = (root ?
set->lp_cleanuprowsroot :
set->lp_cleanuprows);
15902 SCIPsetDebugMsg(
set,
"removing unused columns starting with %d/%d (%u), unused rows starting with %d/%d (%u), LP algo: %d, basic sol: %u\n",
15938 cleanupcols = (root ?
set->lp_cleanupcolsroot :
set->lp_cleanupcols);
15939 cleanuprows = (root ?
set->lp_cleanuprowsroot :
set->lp_cleanuprows);
15941 SCIPsetDebugMsg(
set,
"removing all unused columns (%u) and rows (%u), LP algo: %d, basic sol: %u\n",
15944 if( cleanupcols && 0 < lp->
ncols )
15948 if( cleanuprows && 0 < lp->
nrows )
16015 SCIPsetDebugMsg(
set,
"removing %d/%d redundant basic rows from LP\n", ndelrows, nrows);
16053 SCIPsetDebugMsg(
set,
"diving started (LP flushed: %u, LP solved: %u, solstat: %d)\n",
16079 if( !
set->lp_resolverestore && lp->
solved )
16161 for( v = 0; v <
nvars; ++v )
16229 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, prob, -1LL,
FALSE,
FALSE,
FALSE,
FALSE, &
lperror) );
16241 "LP was not resolved to a sufficient status after diving\n");
16316#define DIVESTACKGROWFACT 1.5
16441 for( j = 0; j < lp->
nrows; ++j )
16470 for( j = 0; j < lp->
ncols; ++j )
16478 c = usefarkas ? 0.0 : col->
obj;
16545 *proved = (
bound > 0.0);
16547 SCIPsetDebugMsg(
set,
"proved Farkas value of LP: %g -> infeasibility %sproved\n",
bound, *proved ?
"" :
"not ");
16595 file = fopen(fname,
"w");
16605 SCIPmessageFPrintInfo(messagehdlr, file,
"\\ Original Variable and Constraint Names have been replaced by generic names.\n");
16608 SCIPmessageFPrintInfo(messagehdlr, file,
"\\ Warning: Variable and Constraint Names should not contain special characters like '+', '=' etc.\n");
16612 if( origobj && objoffset != 0.0 )
16614 SCIPmessageFPrintInfo(messagehdlr, file,
"\\ An artificial variable 'objoffset' has been added and fixed to 1.\n");
16615 SCIPmessageFPrintInfo(messagehdlr, file,
"\\ Switching this variable to 0 will disable the offset in the objective.\n\n");
16650 if( origobj && objoffset != 0.0 )
16688 if( strlen(rowname) > 0 )
16693 SCIPmessageFPrintInfo(messagehdlr, file,
"are not in a valid range. The following two constraints may be corrupted!\n");
16714 if( (j+1) % 10 == 0 )
16779 if( strlen(rowname) > 0 )
16784 SCIPmessageFPrintInfo(messagehdlr, file,
"are not in a valid range. The following two constraints may be corrupted!\n");
16805 if( (j+1) % 10 == 0 )
16856 if( origobj && objoffset != 0.0 )
16894#undef SCIPcolGetObj
16897#undef SCIPcolGetBestBound
16898#undef SCIPcolGetPrimsol
16899#undef SCIPcolGetMinPrimsol
16900#undef SCIPcolGetMaxPrimsol
16901#undef SCIPcolGetBasisStatus
16902#undef SCIPcolGetVar
16903#undef SCIPcolGetIndex
16904#undef SCIPcolGetVarProbindex
16905#undef SCIPcolIsIntegral
16906#undef SCIPcolIsRemovable
16907#undef SCIPcolGetLPPos
16908#undef SCIPcolGetLPDepth
16909#undef SCIPcolIsInLP
16910#undef SCIPcolGetNNonz
16911#undef SCIPcolGetNLPNonz
16912#undef SCIPcolGetRows
16913#undef SCIPcolGetVals
16914#undef SCIPcolGetStrongbranchNode
16915#undef SCIPcolGetNStrongbranchs
16916#undef SCIPcolGetAge
16917#undef SCIPboundtypeOpposite
16918#undef SCIProwGetNNonz
16919#undef SCIProwGetNLPNonz
16920#undef SCIProwGetCols
16921#undef SCIProwGetVals
16922#undef SCIProwGetConstant
16923#undef SCIProwGetNorm
16924#undef SCIProwGetSumNorm
16925#undef SCIProwGetLhs
16926#undef SCIProwGetRhs
16927#undef SCIProwGetDualsol
16928#undef SCIProwGetDualfarkas
16929#undef SCIProwGetBasisStatus
16930#undef SCIProwGetName
16931#undef SCIProwGetIndex
16932#undef SCIProwGetAge
16933#undef SCIProwGetRank
16934#undef SCIProwIsIntegral
16935#undef SCIProwIsLocal
16936#undef SCIProwIsModifiable
16937#undef SCIProwIsRemovable
16938#undef SCIProwGetOrigintype
16939#undef SCIProwGetOriginCons
16940#undef SCIProwGetOriginConshdlr
16941#undef SCIProwGetOriginSepa
16942#undef SCIProwIsInGlobalCutpool
16943#undef SCIProwGetLPPos
16944#undef SCIProwGetLPDepth
16945#undef SCIProwIsInLP
16946#undef SCIProwGetActiveLPCount
16947#undef SCIProwGetNLPsAfterCreation
16948#undef SCIProwChgRank
16949#undef SCIPlpGetCols
16950#undef SCIPlpGetNCols
16951#undef SCIPlpGetRows
16952#undef SCIPlpGetNRows
16953#undef SCIPlpGetNewcols
16954#undef SCIPlpGetNNewcols
16955#undef SCIPlpGetNewrows
16956#undef SCIPlpGetNNewrows
16957#undef SCIPlpGetObjNorm
16958#undef SCIPlpGetRootObjval
16959#undef SCIPlpGetRootColumnObjval
16960#undef SCIPlpGetRootLooseObjval
16962#undef SCIPlpSetIsRelax
16963#undef SCIPlpIsRelax
16964#undef SCIPlpIsSolved
16965#undef SCIPlpIsSolBasic
16967#undef SCIPlpDivingObjChanged
16968#undef SCIPlpMarkDivingObjChanged
16969#undef SCIPlpUnmarkDivingObjChanged
16970#undef SCIPlpDivingRowsChanged
16971#undef SCIPlpIsFeasEQ
16972#undef SCIPlpIsFeasLT
16973#undef SCIPlpIsFeasLE
16974#undef SCIPlpIsFeasGT
16975#undef SCIPlpIsFeasGE
16976#undef SCIPlpIsFeasZero
16977#undef SCIPlpIsFeasPositive
16978#undef SCIPlpIsFeasNegative
17017 if( col->
obj >= 0.0 )
17030 if( col->
lppos >= 0 )
17150 return (col->
lppos >= 0);
17346 if( row->
lppos >= 0 )
17359 if( row->
lppos >= 0 )
17558 return (row->
lppos >= 0);
17627 nlpcols = lp->
ncols;
17630 for(
c = 0;
c < nlpcols; ++
c )
17632 if( lpcols[
c]->ub - lpcols[
c]->lb >
eps )
17636 return nunfixedcols;
17719 for(
c = lp->
ncols - 1;
c >= 0; --
c )
17973 SCIPmessagePrintWarning(messagehdlr,
"Could not set feasibility tolerance of LP solver for relative interior point computation.\n");
17981 SCIPmessagePrintWarning(messagehdlr,
"Could not set dual feasibility tolerance of LP solver for relative interior point computation.\n");
17986 nnewcols = 3*lp->
ncols + 2*lp->
nrows + (inclobjcutoff ? 1 : 0) + 1;
17992 for( j = 0; j < lp->
ncols; ++j )
18002 nnewcols = lp->
ncols;
18003 obj[nnewcols] = 0.0;
18004 lb[nnewcols] = 1.0;
18028 ntotnonz += row->
nlpcols + 1;
18038 lb[nnewcols] = 0.0;
18039 ub[nnewcols] = 1.0;
18040 obj[nnewcols++] = 1.0;
18041 ntotnonz += row->
nlpcols + 2;
18044 ntotnonz += row->
nlpcols + 1;
18051 lb[nnewcols] = 0.0;
18052 ub[nnewcols] = 1.0;
18053 obj[nnewcols++] = 1.0;
18054 ntotnonz += row->
nlpcols + 2;
18057 ntotnonz += row->
nlpcols + 1;
18064 if( inclobjcutoff && relaxrows )
18067 lb[nnewcols] = 0.0;
18068 ub[nnewcols] = 1.0;
18069 obj[nnewcols++] = 1.0;
18070 ntotnonz += lp->
ncols + 2;
18075 for( j = 0; j < lp->
ncols; ++j )
18093 lb[nnewcols] = 0.0;
18094 ub[nnewcols] = 1.0;
18095 obj[nnewcols++] = 1.0;
18101 lb[nnewcols] = 0.0;
18102 ub[nnewcols] = 1.0;
18103 obj[nnewcols++] = 1.0;
18110 nslacks = nnewcols - lp->
ncols - 1;
18112 assert( nnewcols <= 3*lp->ncols + 2*lp->
nrows + (inclobjcutoff ? 1 : 0) + 1 );
18154 assert( nnonz <= lp->ncols );
18155 rowcols = row->
cols;
18156 rowvals = row->
vals;
18162 matbeg[matrowidx] = matidx;
18163 for( j = 0; j < nnonz; ++j )
18166 assert( 0 <= rowcols[j]->lppos && rowcols[j]->lppos < lp->ncols );
18169 matinds[matidx] = rowcols[j]->
lppos;
18170 matvals[matidx++] = rowvals[j];
18171 assert( matidx <= ntotnonz );
18177 matinds[matidx] = lp->
ncols;
18178 matvals[matidx++] = -rhs;
18179 assert( matidx <= ntotnonz );
18182 matlhs[matrowidx] = 0.0;
18183 matrhs[matrowidx++] = 0.0;
18184 assert( matrowidx <= ntotrows );
18197 matbeg[matrowidx] = matidx;
18198 for( j = 0; j < nnonz; ++j )
18201 assert( 0 <= rowcols[j]->lppos && rowcols[j]->lppos < lp->ncols );
18204 matinds[matidx] = rowcols[j]->
lppos;
18205 matvals[matidx++] = rowvals[j];
18206 assert( matidx <= ntotnonz );
18212 matinds[matidx] = lp->
ncols;
18213 matvals[matidx++] = -lhs;
18214 assert( matidx <= ntotnonz );
18220 matvals[matidx] = -
MAX(1.0, lhs);
18221 matinds[matidx++] = lp->
ncols + 1 + cnt;
18222 assert( matidx <= ntotnonz );
18226 matlhs[matrowidx] = 0.0;
18228 assert( matrowidx <= ntotrows );
18235 matbeg[matrowidx] = matidx;
18236 for( j = 0; j < nnonz; ++j )
18239 assert( 0 <= rowcols[j]->lppos && rowcols[j]->lppos < lp->ncols );
18242 matinds[matidx] = rowcols[j]->
lppos;
18243 matvals[matidx++] = rowvals[j];
18244 assert( matidx <= ntotnonz );
18250 matinds[matidx] = lp->
ncols;
18251 matvals[matidx++] = -rhs;
18252 assert( matidx <= ntotnonz );
18258 matvals[matidx] =
MAX(1.0, absrhs);
18259 matinds[matidx++] = lp->
ncols + 1 + cnt;
18264 matrhs[matrowidx++] = 0.0;
18265 assert( matrowidx <= ntotrows );
18271 if( inclobjcutoff )
18280 matbeg[matrowidx] = matidx;
18281 for( j = 0; j < lp->
ncols; ++j )
18290 matvals[matidx++] = lp->
cols[j]->
obj;
18291 assert( matidx <= ntotnonz );
18300 matinds[matidx] = lp->
ncols;
18301 matvals[matidx++] = -rhs;
18302 assert( matidx <= ntotnonz );
18310 matvals[matidx] =
MAX(1.0, absrhs);
18311 matinds[matidx++] = lp->
ncols + 1 + cnt;
18312 assert( matidx <= ntotnonz );
18316 matrhs[matrowidx++] = 0.0;
18317 assert( matrowidx <= ntotrows );
18321 for( j = 0; j < lp->
ncols; ++j )
18335 matbeg[matrowidx] = matidx;
18337 matinds[matidx] = j;
18338 matvals[matidx++] = 1.0;
18339 assert( matidx <= ntotnonz );
18344 matinds[matidx] = lp->
ncols;
18345 matvals[matidx++] = -col->
ub;
18346 assert( matidx <= ntotnonz );
18349 matlhs[matrowidx] = 0.0;
18350 matrhs[matrowidx++] = 0.0;
18351 assert( matrowidx <= ntotrows );
18363 matbeg[matrowidx] = matidx;
18365 matinds[matidx] = j;
18366 matvals[matidx++] = 1.0;
18367 assert( matidx <= ntotnonz );
18372 matinds[matidx] = lp->
ncols;
18373 matvals[matidx++] = -col->
lb;
18374 assert( matidx <= ntotnonz );
18378 matvals[matidx] = -
MAX(1.0, abscollb);
18379 matinds[matidx++] = lp->
ncols + 1 + cnt;
18380 assert( matidx <= ntotnonz );
18383 matlhs[matrowidx] = 0.0;
18385 assert( matrowidx <= ntotrows );
18392 matbeg[matrowidx] = matidx;
18394 matinds[matidx] = j;
18395 matvals[matidx++] = 1.0;
18396 assert( matidx <= ntotnonz );
18401 matinds[matidx] = lp->
ncols;
18402 matvals[matidx++] = -col->
ub;
18403 assert( matidx <= ntotnonz );
18407 matvals[matidx] =
MAX(1.0, abscolub);
18408 matinds[matidx++] = lp->
ncols + 1 + cnt;
18409 assert( matidx <= ntotnonz );
18413 matrhs[matrowidx++] = 0.0;
18414 assert( matrowidx <= ntotrows );
18417 assert( cnt == nslacks );
18418 assert( matrowidx == ntotrows );
18437 assert( ncols == nnewcols );
18448 SCIPmessagePrintWarning(messagehdlr,
"Could not set time limit of LP solver for relative interior point computation.\n");
18457 SCIPmessagePrintWarning(messagehdlr,
"Could not set iteration limit of LP solver for relative interior point computation.\n");
18483 for( j = 0; j < lp->
ncols; ++j )
18484 point[j] = primal[j]/
alpha;
18508 assert( nnonz <= lp->ncols );
18509 rowcols = row->
cols;
18510 rowvals = row->
vals;
18513 for( j = 0; j < nnonz; ++j )
18514 sum += rowvals[j] * primal[rowcols[j]->lppos];
18538 if( inclobjcutoff )
18547 for( j = 0; j < lp->
ncols; ++j )
18556 for( j = 0; j < lp->
ncols; ++j )
18655 if ( timelimit <= 0.0 || iterlimit <= 0 )
18661 if( lp->
ncols == 0 )
18666 inclobjcutoff =
FALSE;
18671 if( lp->
nrows == 0 && !inclobjcutoff )
18684 retcode =
computeRelIntPoint(lpi,
set, messagehdlr, lp, prob, relaxrows, inclobjcutoff, timelimit, iterlimit, point, success);
18727 int nfixedcols = 0;
18728 int nalreadyfixedcols = 0;
18729 int nfixedrows = 0;
18731 int nimplicitfixedrows = 0;
18736 int nbasicequalities = 0;
18744 for(
c = ncols - 1 ;
c >= 0; --
c )
18757 ++nalreadyfixedcols;
18762 for(
r = nrows - 1;
r >= 0; --
r )
18795 ++nimplicitfixedrows;
18801 ++nbasicequalities;
18803 assert(nfixedcols + nfixedrows <= ncols + nineq + nbasicequalities - nrows - nalreadyfixedcols - nimplicitfixedrows);
18805 if( ncols + nineq - nrows + nbasicequalities - nalreadyfixedcols > 0 )
18806 lp->
degeneracy = 1.0 - 1.0 * (nfixedcols + nfixedrows) / (ncols + nineq - nrows + nbasicequalities - nalreadyfixedcols);
18811 lp->
varconsratio = 1.0 * (ncols + nineq + nbasicequalities - nfixedcols - nfixedrows - nalreadyfixedcols) / nrows;
void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)
void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)
SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)
internal methods for clocks and timing issues
void SCIPconsCapture(SCIP_CONS *cons)
SCIP_RETCODE SCIPconsRelease(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)
internal methods for constraints and constraint handlers
#define SCIP_DEFAULT_SUMEPSILON
#define SCIP_DEFAULT_EPSILON
#define SCIP_CALL_ABORT(x)
#define SCIP_LONGINT_FORMAT
SCIP_RETCODE SCIPeventCreateRowDeletedLP(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_ROW *row)
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_RETCODE SCIPeventfilterFree(SCIP_EVENTFILTER **eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set)
SCIP_RETCODE SCIPeventCreateRowSideChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_ROW *row, SCIP_SIDETYPE side, SCIP_Real oldval, SCIP_Real newval)
SCIP_RETCODE SCIPeventfilterDel(SCIP_EVENTFILTER *eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_RETCODE SCIPeventfilterCreate(SCIP_EVENTFILTER **eventfilter, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPeventCreateRowConstChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_ROW *row, SCIP_Real oldval, SCIP_Real newval)
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 SCIPeventCreateRowCoefChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_ROW *row, SCIP_COL *col, SCIP_Real oldval, SCIP_Real newval)
SCIP_RETCODE SCIPeventCreateRowAddedLP(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_ROW *row)
internal methods for managing events
SCIP_RETCODE SCIPlpiChgSides(SCIP_LPI *lpi, int nrows, const int *ind, const SCIP_Real *lhs, const SCIP_Real *rhs)
SCIP_RETCODE SCIPlpiSetState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, const SCIP_LPISTATE *lpistate)
SCIP_RETCODE SCIPlpiGetBInvACol(SCIP_LPI *lpi, int c, SCIP_Real *coef, int *inds, int *ninds)
SCIP_RETCODE SCIPlpiGetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real *dval)
SCIP_Real SCIPlpiInfinity(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiIsObjlimExc(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiExistsPrimalRay(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetBase(SCIP_LPI *lpi, int *cstat, int *rstat)
SCIP_RETCODE SCIPlpiAddRows(SCIP_LPI *lpi, int nrows, const SCIP_Real *lhs, const SCIP_Real *rhs, char **rownames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)
SCIP_RETCODE SCIPlpiGetPrimalRay(SCIP_LPI *lpi, SCIP_Real *ray)
SCIP_RETCODE SCIPlpiGetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int *ival)
SCIP_RETCODE SCIPlpiWriteLP(SCIP_LPI *lpi, const char *fname)
SCIP_RETCODE SCIPlpiSetIntegralityInformation(SCIP_LPI *lpi, int ncols, int *intInfo)
SCIP_RETCODE SCIPlpiSetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real dval)
SCIP_RETCODE SCIPlpiStrongbranchFrac(SCIP_LPI *lpi, int col, SCIP_Real psol, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
SCIP_RETCODE SCIPlpiSetNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, const SCIP_LPINORMS *lpinorms)
SCIP_RETCODE SCIPlpiStrongbranchInt(SCIP_LPI *lpi, int col, SCIP_Real psol, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
SCIP_RETCODE SCIPlpiGetBounds(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *lbs, SCIP_Real *ubs)
SCIP_RETCODE SCIPlpiGetDualfarkas(SCIP_LPI *lpi, SCIP_Real *dualfarkas)
SCIP_RETCODE SCIPlpiGetObjval(SCIP_LPI *lpi, SCIP_Real *objval)
int SCIPlpiGetInternalStatus(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiStartStrongbranch(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetSolFeasibility(SCIP_LPI *lpi, SCIP_Bool *primalfeasible, SCIP_Bool *dualfeasible)
SCIP_RETCODE SCIPlpiFreeNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
SCIP_Bool SCIPlpiIsIterlimExc(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiChgBounds(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *lb, const SCIP_Real *ub)
SCIP_Bool SCIPlpiIsPrimalUnbounded(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiIgnoreInstability(SCIP_LPI *lpi, SCIP_Bool *success)
SCIP_RETCODE SCIPlpiFree(SCIP_LPI **lpi)
SCIP_RETCODE SCIPlpiStrongbranchesFrac(SCIP_LPI *lpi, int *cols, int ncols, SCIP_Real *psols, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
SCIP_Bool SCIPlpiIsPrimalFeasible(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiIsDualFeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
SCIP_Bool SCIPlpiIsTimelimExc(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiHasStateBasis(SCIP_LPI *lpi, SCIP_LPISTATE *lpistate)
SCIP_RETCODE SCIPlpiSetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int ival)
const char * SCIPlpiGetSolverName(void)
SCIP_Bool SCIPlpiHasPrimalRay(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetBInvRow(SCIP_LPI *lpi, int r, SCIP_Real *coef, int *inds, int *ninds)
SCIP_RETCODE SCIPlpiDelRows(SCIP_LPI *lpi, int firstrow, int lastrow)
SCIP_RETCODE SCIPlpiGetBInvCol(SCIP_LPI *lpi, 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_RETCODE SCIPlpiSolveBarrier(SCIP_LPI *lpi, SCIP_Bool crossover)
SCIP_Bool SCIPlpiIsOptimal(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiEndStrongbranch(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetSides(SCIP_LPI *lpi, int firstrow, int lastrow, SCIP_Real *lhss, SCIP_Real *rhss)
SCIP_RETCODE SCIPlpiStrongbranchesInt(SCIP_LPI *lpi, int *cols, int ncols, SCIP_Real *psols, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
SCIP_RETCODE SCIPlpiGetSol(SCIP_LPI *lpi, SCIP_Real *objval, SCIP_Real *primsol, SCIP_Real *dualsol, SCIP_Real *activity, SCIP_Real *redcost)
SCIP_Bool SCIPlpiHasDualRay(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiDelColset(SCIP_LPI *lpi, int *dstat)
SCIP_RETCODE SCIPlpiGetObj(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *vals)
SCIP_RETCODE SCIPlpiFreeState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
SCIP_Bool SCIPlpiIsPrimalInfeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiSolveDual(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiAddCols(SCIP_LPI *lpi, int ncols, const SCIP_Real *obj, const SCIP_Real *lb, const SCIP_Real *ub, char **colnames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)
SCIP_RETCODE SCIPlpiSolvePrimal(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetIterations(SCIP_LPI *lpi, int *iterations)
SCIP_RETCODE SCIPlpiGetBasisInd(SCIP_LPI *lpi, int *bind)
SCIP_RETCODE SCIPlpiCreate(SCIP_LPI **lpi, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_OBJSEN objsen)
SCIP_RETCODE SCIPlpiChgObj(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *obj)
SCIP_Bool SCIPlpiIsStable(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetNCols(SCIP_LPI *lpi, int *ncols)
SCIP_RETCODE SCIPlpiInterrupt(SCIP_LPI *lpi, SCIP_Bool interrupt)
SCIP_RETCODE SCIPlpiDelCols(SCIP_LPI *lpi, int firstcol, int lastcol)
SCIP_RETCODE SCIPlpiDelRowset(SCIP_LPI *lpi, int *dstat)
SCIP_RETCODE SCIPlpiGetNRows(SCIP_LPI *lpi, int *nrows)
SCIP_RETCODE SCIPlpiGetState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
SCIP_Longint SCIPcalcGreComDiv(SCIP_Longint val1, SCIP_Longint val2)
SCIP_Bool SCIPrealToRational(SCIP_Real val, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Longint *nominator, SCIP_Longint *denominator)
SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)
void SCIPswapPointers(void **pointer1, void **pointer2)
SCIP_Real SCIPcolGetMinPrimsol(SCIP_COL *col)
int SCIPcolGetLPPos(SCIP_COL *col)
int SCIPcolGetVarProbindex(SCIP_COL *col)
SCIP_Bool SCIPcolIsRemovable(SCIP_COL *col)
SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)
SCIP_Bool SCIPcolIsIntegral(SCIP_COL *col)
SCIP_Real SCIPcolGetObj(SCIP_COL *col)
int SCIPcolGetNNonz(SCIP_COL *col)
SCIP_Real * SCIPcolGetVals(SCIP_COL *col)
SCIP_ROW ** SCIPcolGetRows(SCIP_COL *col)
void SCIPcolSort(SCIP_COL *col)
int SCIPcolGetIndex(SCIP_COL *col)
SCIP_Real SCIPcolGetBestBound(SCIP_COL *col)
SCIP_Real SCIPcolGetLb(SCIP_COL *col)
SCIP_Real SCIPcolGetPrimsol(SCIP_COL *col)
SCIP_Real SCIPcolGetUb(SCIP_COL *col)
SCIP_Longint SCIPcolGetStrongbranchNode(SCIP_COL *col)
int SCIPcolGetNLPNonz(SCIP_COL *col)
int SCIPcolGetNStrongbranchs(SCIP_COL *col)
int SCIPcolGetAge(SCIP_COL *col)
SCIP_Bool SCIPcolIsInLP(SCIP_COL *col)
int SCIPcolGetLPDepth(SCIP_COL *col)
SCIP_BASESTAT SCIPcolGetBasisStatus(SCIP_COL *col)
SCIP_BOUNDTYPE SCIPboundtypeOpposite(SCIP_BOUNDTYPE boundtype)
SCIP_Real SCIPcolGetMaxPrimsol(SCIP_COL *col)
SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)
SCIP_Real SCIPintervalGetInf(SCIP_INTERVAL interval)
void SCIPintervalSub(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)
void SCIPintervalSet(SCIP_INTERVAL *resultant, SCIP_Real value)
void SCIPintervalSetBounds(SCIP_INTERVAL *resultant, SCIP_Real inf, SCIP_Real sup)
struct SCIP_Interval SCIP_INTERVAL
void SCIPintervalMul(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)
void SCIPintervalAdd(SCIP_Real infinity, SCIP_INTERVAL *resultant, SCIP_INTERVAL operand1, SCIP_INTERVAL operand2)
SCIP_Bool SCIProwIsIntegral(SCIP_ROW *row)
void SCIProwSort(SCIP_ROW *row)
SCIP_Real SCIProwGetLhs(SCIP_ROW *row)
SCIP_Bool SCIProwIsModifiable(SCIP_ROW *row)
SCIP_Longint SCIProwGetActiveLPCount(SCIP_ROW *row)
SCIP_Real SCIProwGetOrthogonality(SCIP_ROW *row1, SCIP_ROW *row2, char orthofunc)
SCIP_Real SCIProwGetScalarProduct(SCIP_ROW *row1, SCIP_ROW *row2)
int SCIProwGetLPDepth(SCIP_ROW *row)
SCIP_Real SCIProwGetParallelism(SCIP_ROW *row1, SCIP_ROW *row2, char orthofunc)
SCIP_CONS * SCIProwGetOriginCons(SCIP_ROW *row)
int SCIProwGetNNonz(SCIP_ROW *row)
SCIP_COL ** SCIProwGetCols(SCIP_ROW *row)
SCIP_Bool SCIProwIsInGlobalCutpool(SCIP_ROW *row)
SCIP_Real SCIProwGetRhs(SCIP_ROW *row)
int SCIProwGetAge(SCIP_ROW *row)
int SCIProwGetNLPNonz(SCIP_ROW *row)
SCIP_Real SCIProwGetNorm(SCIP_ROW *row)
int SCIProwGetLPPos(SCIP_ROW *row)
SCIP_Bool SCIProwIsLocal(SCIP_ROW *row)
SCIP_CONSHDLR * SCIProwGetOriginConshdlr(SCIP_ROW *row)
SCIP_Longint SCIProwGetNLPsAfterCreation(SCIP_ROW *row)
void SCIProwLock(SCIP_ROW *row)
SCIP_Bool SCIProwIsRemovable(SCIP_ROW *row)
const char * SCIProwGetName(SCIP_ROW *row)
SCIP_SEPA * SCIProwGetOriginSepa(SCIP_ROW *row)
void SCIProwUnlock(SCIP_ROW *row)
SCIP_Real SCIProwGetSumNorm(SCIP_ROW *row)
int SCIProwGetRank(SCIP_ROW *row)
SCIP_Real SCIProwGetDualfarkas(SCIP_ROW *row)
int SCIProwGetIndex(SCIP_ROW *row)
void SCIProwChgRank(SCIP_ROW *row, int rank)
SCIP_Real SCIProwGetConstant(SCIP_ROW *row)
SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)
SCIP_Real SCIProwGetDualsol(SCIP_ROW *row)
SCIP_Real * SCIProwGetVals(SCIP_ROW *row)
SCIP_ROWORIGINTYPE SCIProwGetOrigintype(SCIP_ROW *row)
SCIP_BASESTAT SCIProwGetBasisStatus(SCIP_ROW *row)
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
SCIP_BOUNDTYPE SCIPvarGetBestBoundType(SCIP_VAR *var)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
int SCIPvarGetNLocksDown(SCIP_VAR *var)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
int SCIPvarGetProbindex(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbLazy(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
int SCIPvarGetNLocksUp(SCIP_VAR *var)
SCIP_Real SCIPvarGetNLPSol(SCIP_VAR *var)
SCIP_Real SCIPvarGetUnchangedObj(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbLazy(SCIP_VAR *var)
void SCIPsortPtrRealInt(void **ptrarray, SCIP_Real *realarray, int *intarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortIntPtrIntReal(int *intarray1, void **ptrarray, int *intarray2, SCIP_Real *realarray, int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
void SCIPprintSysError(const char *message)
assert(minobj< SCIPgetCutoffbound(scip))
interval arithmetics for provable bounds
static SCIP_RETCODE lpFlushDelRows(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set)
static void rowCalcIdxsAndVals(SCIP_ROW *row, SCIP_SET *set)
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 SCIPlpIsSolBasic(SCIP_LP *lp)
#define debugColPrint(x, y)
static void getObjvalDeltaObj(SCIP_SET *set, SCIP_Real oldobj, SCIP_Real newobj, SCIP_Real lb, SCIP_Real ub, SCIP_Real *deltaval, int *deltainf)
static SCIP_RETCODE lpSetObjlim(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob, SCIP_Real objlim, SCIP_Bool *success)
static SCIP_RETCODE insertColChgcols(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp)
SCIP_Real SCIProwGetMaxval(SCIP_ROW *row, SCIP_SET *set)
SCIP_Real SCIProwGetRelaxEfficacy(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPcolChgUb(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newub)
SCIP_Real SCIProwGetLPFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
SCIP_Real SCIPcolCalcRedcost(SCIP_COL *col, SCIP_Real *dualsol)
SCIP_RETCODE SCIPlpGetBInvRow(SCIP_LP *lp, int r, SCIP_Real *coef, int *inds, int *ninds)
static SCIP_RETCODE lpSetRefactorInterval(SCIP_LP *lp, int refactor, SCIP_Bool *success)
SCIP_Real SCIProwGetNLPFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPcolFree(SCIP_COL **col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
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, int scaling, SCIP_Bool keepsol, SCIP_Bool *timelimit, SCIP_Bool *lperror)
SCIP_Real SCIPlpGetModifiedProvedPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype)
void SCIProwCapture(SCIP_ROW *row)
SCIP_RETCODE SCIPlpFreeState(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
SCIP_Real SCIProwGetPseudoFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPlpUpdateAges(SCIP_LP *lp, SCIP_STAT *stat)
SCIP_RETCODE SCIPlpGetBInvCol(SCIP_LP *lp, int c, SCIP_Real *coef, int *inds, int *ninds)
SCIP_RETCODE SCIPcolChgLb(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newlb)
#define DIVESTACKGROWFACT
static SCIP_RETCODE lpSetTiming(SCIP_LP *lp, SCIP_CLOCKTYPE timing, SCIP_Bool enabled, SCIP_Bool *success)
SCIP_RETCODE SCIPlpInterrupt(SCIP_LP *lp, SCIP_Bool interrupt)
static SCIP_RETCODE lpLexDualSimplex(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool resolve, SCIP_Bool keepsol, SCIP_Bool *lperror)
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_RETCODE SCIProwChgCoef(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_COL *col, SCIP_Real val)
static SCIP_RETCODE lpSetFromscratch(SCIP_LP *lp, SCIP_Bool fromscratch, SCIP_Bool *success)
static void colSortNonLP(SCIP_COL *col)
static SCIP_RETCODE ensureLpicolsSize(SCIP_LP *lp, SCIP_SET *set, int num)
SCIP_Real SCIPcolCalcFarkasCoef(SCIP_COL *col, SCIP_Real *dualfarkas)
static void rowMoveCoef(SCIP_ROW *row, int oldpos, int newpos)
static SCIP_RETCODE lpSetFastmip(SCIP_LP *lp, int fastmip, SCIP_Bool *success)
SCIP_RETCODE SCIPlpGetNorms(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
static SCIP_RETCODE lpSetRealpar(SCIP_LP *lp, SCIP_LPPARAM lpparam, SCIP_Real value, SCIP_Bool *success)
static SCIP_RETCODE lpCopyIntegrality(SCIP_LP *lp, SCIP_SET *set)
static SCIP_RETCODE lpStoreSolVals(SCIP_LP *lp, SCIP_STAT *stat, BMS_BLKMEM *blkmem)
void SCIPlpMarkSize(SCIP_LP *lp)
int SCIProwGetNumIntCols(SCIP_ROW *row, SCIP_SET *set)
static SCIP_RETCODE lpSetLPInfo(SCIP_LP *lp, SCIP_Bool lpinfo)
SCIP_RETCODE SCIPlpGetState(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
void SCIPlpRecalculateObjSqrNorm(SCIP_SET *set, SCIP_LP *lp)
static void lpUpdateObjNorms(SCIP_LP *lp, SCIP_SET *set, SCIP_Real oldobj, SCIP_Real newobj)
static SCIP_RETCODE lpRemoveObsoleteRows(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, int firstrow)
int SCIPlpGetNNewcols(SCIP_LP *lp)
SCIP_Real SCIProwGetSolFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol)
void SCIProwRecalcPseudoActivity(SCIP_ROW *row, SCIP_STAT *stat)
SCIP_RETCODE SCIProwEnsureSize(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
SCIP_Bool SCIPlpIsFeasPositive(SCIP_LP *lp, SCIP_Real val)
SCIP_Bool SCIPlpIsFeasGT(SCIP_SET *set, SCIP_LP *lp, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPlpIsInfeasibilityProved(SCIP_LP *lp, SCIP_SET *set, SCIP_Bool *proved)
SCIP_Real SCIProwGetRelaxFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPlpAddCol(SCIP_LP *lp, SCIP_SET *set, SCIP_COL *col, int depth)
#define MAXNUMTROUBLELPMSGS
SCIP_Real SCIPlpGetLooseObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
SCIP_RETCODE SCIPlpSetState(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_EVENTQUEUE *eventqueue, SCIP_LPISTATE *lpistate, SCIP_Bool wasprimfeas, SCIP_Bool wasprimchecked, SCIP_Bool wasdualfeas, SCIP_Bool wasdualchecked)
static SCIP_RETCODE colDelCoefPos(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, int pos)
static void colSwapCoefs(SCIP_COL *col, int pos1, int pos2)
static void rowCalcActivityBounds(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
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)
SCIP_Real SCIPlpGetObjNorm(SCIP_LP *lp)
SCIP_Real SCIProwGetMaxActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
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)
static SCIP_RETCODE lpSetPresolving(SCIP_LP *lp, SCIP_Bool presolving, SCIP_Bool *success)
SCIP_RETCODE SCIPlpRemoveNewObsoletes(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
SCIP_Bool SCIProwIsLPEfficacious(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_Bool root)
SCIP_Real SCIProwGetSolEfficacy(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol)
static int colSearchCoefPart(SCIP_COL *col, const SCIP_ROW *row, int minpos, int maxpos)
SCIP_RETCODE SCIPlpStartStrongbranch(SCIP_LP *lp)
static int rowSearchCoefPart(SCIP_ROW *row, const SCIP_COL *col, int minpos, int maxpos)
SCIP_Bool SCIPlpDivingObjChanged(SCIP_LP *lp)
#define checkRowSumnorm(row)
static int colSearchCoef(SCIP_COL *col, const SCIP_ROW *row)
SCIP_RETCODE SCIPlpFlush(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_EVENTQUEUE *eventqueue)
static SCIP_RETCODE rowDelCoefPos(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, int pos)
SCIP_RETCODE SCIPlpUpdateVarLb(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldlb, SCIP_Real newlb)
void SCIPlpDecNLoosevars(SCIP_LP *lp)
static void rowSwapCoefs(SCIP_ROW *row, int pos1, int pos2)
SCIP_RETCODE SCIProwAddConstant(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real addval)
static SCIP_RETCODE rowChgCoefPos(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, int pos, SCIP_Real val)
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)
static void recomputePseudoObjectiveValue(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
void SCIPlpSetFeastol(SCIP_LP *lp, SCIP_SET *set, SCIP_Real newfeastol)
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_RETCODE rowUnlink(SCIP_ROW *row, SCIP_SET *set, SCIP_LP *lp)
#define lpCutoffDisabled(set, prob, lp)
SCIP_RETCODE SCIPlpWrite(SCIP_LP *lp, const char *fname)
int SCIProwGetMaxidx(SCIP_ROW *row, SCIP_SET *set)
static void colSortLP(SCIP_COL *col)
static void adjustLPobjval(SCIP_LP *lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
static SCIP_RETCODE lpFlushAddRows(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue)
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 int rowSearchCoef(SCIP_ROW *row, const SCIP_COL *col)
SCIP_Real SCIProwGetLPActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
void SCIProwMarkNotRemovableLocal(SCIP_ROW *row, SCIP_STAT *stat)
static SCIP_RETCODE lpSetPricing(SCIP_LP *lp, SCIP_PRICING pricing)
SCIP_RETCODE SCIPlpUpdateVarLbGlobal(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldlb, SCIP_Real newlb)
static SCIP_RETCODE colRestoreSolVals(SCIP_COL *col, BMS_BLKMEM *blkmem, SCIP_Longint validlp, SCIP_Bool freebuffer)
SCIP_LPSOLSTAT SCIPlpGetSolstat(SCIP_LP *lp)
SCIP_RETCODE SCIPlpShrinkCols(SCIP_LP *lp, SCIP_SET *set, int newncols)
void SCIPlpStoreRootObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
static SCIP_RETCODE lpSetPricingChar(SCIP_LP *lp, char pricingchar)
SCIP_RETCODE SCIProwCreate(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, 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)
static SCIP_RETCODE colStoreSolVals(SCIP_COL *col, BMS_BLKMEM *blkmem)
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_ROW ** SCIPlpGetNewrows(SCIP_LP *lp)
static SCIP_RETCODE ensureSoldirectionSize(SCIP_LP *lp, int num)
void SCIPlpRecomputeLocalAndGlobalPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
static SCIP_RETCODE lpSetMarkowitz(SCIP_LP *lp, SCIP_Real threshhold, SCIP_Bool *success)
static void rowUpdateAddLP(SCIP_ROW *row)
static SCIP_RETCODE lpCheckIntpar(SCIP_LP *lp, SCIP_LPPARAM lpparam, int value)
SCIP_Real SCIPlpGetColumnObjval(SCIP_LP *lp)
SCIP_RETCODE SCIPlpUpdateAddVar(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
SCIP_RETCODE SCIPlpClear(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
SCIP_Bool SCIPlpIsPrimalReliable(SCIP_LP *lp)
static SCIP_RETCODE colEnsureSize(SCIP_COL *col, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
static void rowSortNonLP(SCIP_ROW *row)
void SCIPlpSetIsRelax(SCIP_LP *lp, SCIP_Bool relax)
static SCIP_RETCODE ensureChgcolsSize(SCIP_LP *lp, SCIP_SET *set, int num)
SCIP_RETCODE SCIProwDelCoef(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_COL *col)
SCIP_RETCODE SCIPlpGetBase(SCIP_LP *lp, int *cstat, int *rstat)
SCIP_Bool SCIPlpIsRelax(SCIP_LP *lp)
static SCIP_RETCODE rowEventConstantChanged(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_Real oldval, SCIP_Real newval)
void SCIPcolInvalidateStrongbranchData(SCIP_COL *col, SCIP_SET *set, SCIP_STAT *stat, 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, int scaling, SCIP_Bool keepsol, SCIP_Bool *lperror)
static int lpGetResolveItlim(SCIP_SET *set, SCIP_STAT *stat, int itlim)
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 forcedlpsolve, SCIP_Bool *lperror)
SCIP_RETCODE SCIPcolGetStrongbranch(SCIP_COL *col, SCIP_Bool integral, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LP *lp, int itlim, SCIP_Bool updatecol, SCIP_Bool updatestat, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *lperror)
static SCIP_RETCODE lpCheckRealpar(SCIP_LP *lp, SCIP_LPPARAM lpparam, SCIP_Real value)
SCIP_RETCODE SCIPcolDelCoef(SCIP_COL *col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_ROW *row)
static void rowMerge(SCIP_ROW *row, SCIP_SET *set)
static void colMoveCoef(SCIP_COL *col, int oldpos, int newpos)
static SCIP_Bool isIntegralScalar(SCIP_Real val, SCIP_Real scalar, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Real *intval)
SCIP_Real SCIPlpGetObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
static void computeLPBounds(SCIP_LP *lp, SCIP_SET *set, SCIP_COL *col, SCIP_Real lpiinf, SCIP_Real *lb, SCIP_Real *ub)
SCIP_RETCODE SCIPlpCleanupAll(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_Bool root)
void SCIProwRecalcLPActivity(SCIP_ROW *row, SCIP_STAT *stat)
static SCIP_Bool isNewValueUnreliable(SCIP_SET *set, SCIP_Real newvalue, SCIP_Real oldvalue)
static SCIP_RETCODE provedBound(SCIP_LP *lp, SCIP_SET *set, SCIP_Bool usefarkas, SCIP_Real *bound)
SCIP_Real SCIProwGetMinval(SCIP_ROW *row, SCIP_SET *set)
SCIP_RETCODE SCIPlpEndStrongbranch(SCIP_LP *lp)
SCIP_Longint SCIPcolGetStrongbranchLPAge(SCIP_COL *col, SCIP_STAT *stat)
static SCIP_RETCODE lpDelColset(SCIP_LP *lp, SCIP_SET *set, int *coldstat)
static SCIP_RETCODE lpRemoveObsoleteCols(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, int firstcol)
SCIP_Real SCIPlpGetRootObjval(SCIP_LP *lp)
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)
static SCIP_RETCODE ensureLazycolsSize(SCIP_LP *lp, SCIP_SET *set, int num)
SCIP_Bool SCIPlpIsFeasGE(SCIP_SET *set, SCIP_LP *lp, SCIP_Real val1, SCIP_Real val2)
static SCIP_RETCODE ignoreInstability(SCIP_LP *lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_LPALGO lpalgo, SCIP_Bool *success)
SCIP_RETCODE SCIPlpGetProvedLowerbound(SCIP_LP *lp, SCIP_SET *set, SCIP_Real *bound)
static void checkLazyColArray(SCIP_LP *lp, SCIP_SET *set)
SCIP_RETCODE SCIPcolChgObj(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newobj)
static void colUpdateAddLP(SCIP_COL *col, SCIP_SET *set)
SCIP_Real SCIProwGetLPSolCutoffDistance(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol, SCIP_LP *lp)
static SCIP_RETCODE lpSetRandomseed(SCIP_LP *lp, int randomseed, SCIP_Bool *success)
static SCIP_RETCODE rowRestoreSolVals(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_Longint validlp, SCIP_Bool freebuffer, SCIP_Bool infeasible)
static SCIP_RETCODE ensureChgrowsSize(SCIP_LP *lp, SCIP_SET *set, int num)
SCIP_Real SCIProwGetSolActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol)
static SCIP_RETCODE lpSetScaling(SCIP_LP *lp, int scaling, SCIP_Bool *success)
static SCIP_RETCODE colChgCoefPos(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, int pos, SCIP_Real val)
SCIP_RETCODE SCIPlpFree(SCIP_LP **lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
static SCIP_RETCODE lpSetIntpar(SCIP_LP *lp, SCIP_LPPARAM lpparam, int value, SCIP_Bool *success)
void SCIPlpMarkDivingObjChanged(SCIP_LP *lp)
SCIP_COL ** SCIPlpGetNewcols(SCIP_LP *lp)
SCIP_RETCODE SCIPlpFreeNorms(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
static SCIP_RETCODE lpBarrier(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool crossover, SCIP_Bool keepsol, SCIP_Bool *lperror)
SCIP_RETCODE SCIProwAddCoef(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_COL *col, SCIP_Real val)
static void freeDiveChgSideArrays(SCIP_LP *lp)
SCIP_RETCODE SCIPlpGetBInvARow(SCIP_LP *lp, int r, SCIP_Real *binvrow, SCIP_Real *coef, int *inds, int *ninds)
SCIP_LPI * SCIPlpGetLPI(SCIP_LP *lp)
SCIP_Bool SCIPlpIsFeasLT(SCIP_SET *set, SCIP_LP *lp, SCIP_Real val1, SCIP_Real val2)
static SCIP_RETCODE rowStoreSolVals(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_Bool infeasible)
SCIP_RETCODE SCIProwIncCoef(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_COL *col, SCIP_Real incval)
static SCIP_RETCODE lpUpdateVarColumnProved(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
#define debugRowPrint(x, y)
SCIP_RETCODE SCIPlpRemoveRedundantRows(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
SCIP_Bool SCIPlpDiving(SCIP_LP *lp)
static void rowUpdateDelLP(SCIP_ROW *row)
void SCIPlpUnmarkDivingObjChanged(SCIP_LP *lp)
SCIP_RETCODE SCIPlpGetBasisInd(SCIP_LP *lp, int *basisind)
SCIP_Real SCIProwGetNLPEfficacy(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPlpSetNorms(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPINORMS *lpinorms)
SCIP_RETCODE SCIProwChgLocal(SCIP_ROW *row, SCIP_Bool local)
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)
#define DIVESTACKINITSIZE
SCIP_RETCODE SCIPlpGetDualDegeneracy(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real *degeneracy, SCIP_Real *varconsratio)
static SCIP_RETCODE lpSetBoolpar(SCIP_LP *lp, SCIP_LPPARAM lpparam, SCIP_Bool value, SCIP_Bool *success)
static SCIP_RETCODE ensureColsSize(SCIP_LP *lp, SCIP_SET *set, int num)
static void rowCalcNorms(SCIP_ROW *row, SCIP_SET *set)
SCIP_Real SCIProwGetLPEfficacy(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
SCIP_RETCODE SCIPlpGetSol(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool *primalfeasible, SCIP_Bool *dualfeasible)
static void markRowDeleted(SCIP_ROW *row)
static void rowAddNorms(SCIP_ROW *row, SCIP_SET *set, SCIP_COL *col, SCIP_Real val, SCIP_Bool updateidxvals)
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)
static const int nscalars
void SCIPcolGetStrongbranchLast(SCIP_COL *col, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Real *solval, SCIP_Real *lpobjval)
SCIP_RETCODE SCIPcolAddCoef(SCIP_COL *col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_ROW *row, SCIP_Real val)
static SCIP_RETCODE computeRelIntPoint(SCIP_LPI *lpi, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_LP *lp, SCIP_PROB *prob, SCIP_Bool relaxrows, SCIP_Bool inclobjcutoff, SCIP_Real timelimit, int iterlimit, SCIP_Real *point, SCIP_Bool *success)
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_Real SCIPlpGetRootLooseObjval(SCIP_LP *lp)
SCIP_RETCODE SCIPlpGetDualfarkas(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool forcedlpsolve, SCIP_Bool *valid)
void SCIProwPrint(SCIP_ROW *row, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
SCIP_RETCODE SCIPlpSetCutoffbound(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob, SCIP_Real cutoffbound)
SCIP_RETCODE SCIPlpRecordOldRowSideDive(SCIP_LP *lp, SCIP_ROW *row, SCIP_SIDETYPE sidetype)
static SCIP_RETCODE lpCleanupCols(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, int firstcol)
SCIP_RETCODE SCIPlpMarkFlushed(SCIP_LP *lp, SCIP_SET *set)
static SCIP_RETCODE lpAlgorithm(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_LPALGO lpalgo, SCIP_Bool resolve, SCIP_Bool keepsol, SCIP_Bool instable, SCIP_Bool *timelimit, SCIP_Bool *lperror)
SCIP_Real SCIPcolGetFeasibility(SCIP_COL *col, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
#define checkRowSqrnorm(row)
SCIP_RETCODE SCIPlpShrinkRows(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, int newnrows)
SCIP_Bool SCIProwIsRedundant(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
void SCIPlpStartStrongbranchProbing(SCIP_LP *lp)
static SCIP_RETCODE lpFlushDelCols(SCIP_LP *lp)
static SCIP_RETCODE lpSetRowrepswitch(SCIP_LP *lp, SCIP_Real rowrepswitch, SCIP_Bool *success)
SCIP_RETCODE SCIPlpGetIterations(SCIP_LP *lp, int *iterations)
static void recomputeLooseObjectiveValue(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
static void colUpdateDelLP(SCIP_COL *col, SCIP_SET *set)
SCIP_RETCODE SCIProwChgConstant(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real constant)
SCIP_RETCODE SCIPlpStartProbing(SCIP_LP *lp)
SCIP_Real SCIPlpGetFeastol(SCIP_LP *lp)
static SCIP_RETCODE lpSetFeastol(SCIP_LP *lp, SCIP_Real feastol, SCIP_Bool *success)
SCIP_Bool SCIProwIsSolEfficacious(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol, SCIP_Bool root)
static SCIP_RETCODE lpUpdateVarColumn(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
SCIP_RETCODE SCIPlpUpdateDelVar(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
void SCIPlpEndStrongbranchProbing(SCIP_LP *lp)
SCIP_RETCODE SCIPlpGetBInvACol(SCIP_LP *lp, int c, SCIP_Real *coef, int *inds, int *ninds)
SCIP_Bool SCIPlpIsFeasZero(SCIP_LP *lp, SCIP_Real val)
static SCIP_RETCODE lpSetThreads(SCIP_LP *lp, int threads, SCIP_Bool *success)
SCIP_RETCODE SCIPlpRemoveAllObsoletes(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
static SCIP_RETCODE lpFlushChgCols(SCIP_LP *lp, SCIP_SET *set)
static SCIP_RETCODE lpUpdateVarLooseProved(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
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 colLink(SCIP_COL *col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_RETCODE SCIProwFree(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)
static SCIP_Real getFiniteLooseObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
SCIP_Real SCIPcolGetFarkasValue(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)
static SCIP_RETCODE lpDualSimplex(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool resolve, SCIP_Bool keepsol, SCIP_Bool instable, SCIP_Bool *lperror)
static const char * lpalgoName(SCIP_LPALGO lpalgo)
static void coefChanged(SCIP_ROW *row, SCIP_COL *col, SCIP_LP *lp)
static SCIP_RETCODE lpUpdateVarLoose(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
static void getObjvalDeltaUb(SCIP_SET *set, SCIP_Real obj, SCIP_Real oldub, SCIP_Real newub, SCIP_Real *deltaval, int *deltainf)
static SCIP_RETCODE lpRestoreSolVals(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_Longint validlp)
static SCIP_RETCODE rowSideChanged(SCIP_ROW *row, SCIP_SET *set, SCIP_LP *lp, SCIP_SIDETYPE sidetype)
static void rowSortLP(SCIP_ROW *row)
static SCIP_Real colCalcInternalFarkasCoef(SCIP_COL *col)
SCIP_RETCODE colUnlink(SCIP_COL *col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_RETCODE SCIPlpCreate(SCIP_LP **lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, const char *name)
SCIP_Bool SCIPlpDivingRowsChanged(SCIP_LP *lp)
SCIP_RETCODE SCIPlpUpdateVarUbGlobal(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldub, SCIP_Real newub)
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, int scaling, SCIP_Bool keepsol, SCIP_Bool *lperror)
SCIP_RETCODE SCIPlpReset(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
static SCIP_RETCODE lpCheckBoolpar(SCIP_LP *lp, SCIP_LPPARAM lpparam, SCIP_Bool value)
SCIP_Real SCIPcolGetRedcost(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)
SCIP_RETCODE SCIPlpEndProbing(SCIP_LP *lp)
SCIP_RETCODE SCIProwDropEvent(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
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_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)
SCIP_Bool SCIPlpIsRootLPRelax(SCIP_LP *lp)
SCIP_Bool SCIPlpIsSolved(SCIP_LP *lp)
SCIP_RETCODE SCIPlpUpdateVarUb(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldub, SCIP_Real newub)
static SCIP_RETCODE lpSetConditionLimit(SCIP_LP *lp, SCIP_Real condlimit, SCIP_Bool *success)
SCIP_RETCODE SCIPlpUpdateVarObj(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldobj, SCIP_Real newobj)
static void lpNumericalTroubleMessage(SCIP_MESSAGEHDLR *messagehdlr, SCIP_SET *set, SCIP_STAT *stat, SCIP_VERBLEVEL verblevel, const char *formatstr,...)
SCIP_Real SCIPcolGetFarkasCoef(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)
SCIP_RETCODE SCIPlpUpdateVarLoose(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
SCIP_Real SCIPlpGetGlobalPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
static SCIP_RETCODE reallocDiveChgSideArrays(SCIP_LP *lp, int minsize, SCIP_Real growfact)
SCIP_Bool SCIPlpIsDualReliable(SCIP_LP *lp)
SCIP_RETCODE SCIPlpAddRow(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_ROW *row, int depth)
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)
static void getObjvalDeltaLb(SCIP_SET *set, SCIP_Real obj, SCIP_Real oldlb, SCIP_Real newlb, SCIP_Real *deltaval, int *deltainf)
int SCIProwGetMinidx(SCIP_ROW *row, SCIP_SET *set)
static SCIP_Real colCalcInternalRedcost(SCIP_COL *col)
SCIP_RETCODE SCIPlpStartDive(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
SCIP_Bool SCIPlpIsFeasNegative(SCIP_LP *lp, SCIP_Real val)
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_COL ** SCIPlpGetCols(SCIP_LP *lp)
int SCIPlpGetNCols(SCIP_LP *lp)
static SCIP_RETCODE lpSetBarrierconvtol(SCIP_LP *lp, SCIP_Real barrierconvtol, SCIP_Bool *success)
SCIP_RETCODE SCIProwChgRhs(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real rhs)
SCIP_Real SCIPlpGetRootColumnObjval(SCIP_LP *lp)
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)
SCIP_RETCODE SCIPlpGetUnboundedSol(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool *primalfeasible, SCIP_Bool *rayfeasible)
static SCIP_RETCODE lpSetDualfeastol(SCIP_LP *lp, SCIP_Real dualfeastol, SCIP_Bool *success)
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_Real SCIPlpGetCutoffbound(SCIP_LP *lp)
SCIP_Bool SCIPlpIsFeasEQ(SCIP_SET *set, SCIP_LP *lp, SCIP_Real val1, SCIP_Real val2)
static void markColDeleted(SCIP_COL *col)
SCIP_Real SCIProwGetPseudoActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
static void checkLazyBounds(SCIP_LP *lp, SCIP_SET *set)
static SCIP_RETCODE lpSetIterationLimit(SCIP_LP *lp, int itlim)
static SCIP_RETCODE ensureRowsSize(SCIP_LP *lp, SCIP_SET *set, int num)
static SCIP_Real getFinitePseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
static SCIP_RETCODE allocDiveChgSideArrays(SCIP_LP *lp, int initsize)
SCIP_ROW ** SCIPlpGetRows(SCIP_LP *lp)
void SCIPlpSetRootLPIsRelax(SCIP_LP *lp, SCIP_Bool isrelax)
static SCIP_RETCODE ensureLpirowsSize(SCIP_LP *lp, SCIP_SET *set, int num)
SCIP_RETCODE SCIProwChgLhs(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real lhs)
void SCIProwForceSort(SCIP_ROW *row, SCIP_SET *set)
void SCIPcolMarkNotRemovableLocal(SCIP_COL *col, SCIP_STAT *stat)
static SCIP_RETCODE updateLazyBounds(SCIP_LP *lp, SCIP_SET *set)
SCIP_RETCODE rowLink(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
int SCIPlpGetNUnfixedCols(SCIP_LP *lp, SCIP_Real eps)
SCIP_Real SCIProwGetMinActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)
#define checkRowObjprod(row)
static const SCIP_Real scalars[]
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 SCIPlpIsFeasLE(SCIP_SET *set, SCIP_LP *lp, SCIP_Real val1, SCIP_Real val2)
int SCIPlpGetNNewrows(SCIP_LP *lp)
void SCIPlpResetFeastol(SCIP_LP *lp, SCIP_SET *set)
SCIP_RETCODE SCIPlpGetPrimalRay(SCIP_LP *lp, SCIP_SET *set, SCIP_Real *ray)
void SCIProwDelaySort(SCIP_ROW *row)
static SCIP_RETCODE lpSetSolutionPolishing(SCIP_LP *lp, SCIP_Bool polishing, SCIP_Bool *success)
void SCIPlpInvalidateRootObjval(SCIP_LP *lp)
int SCIPlpGetNRows(SCIP_LP *lp)
static SCIP_RETCODE lpFlushChgRows(SCIP_LP *lp, SCIP_SET *set)
static SCIP_RETCODE lpPrimalSimplex(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool resolve, SCIP_Bool keepsol, SCIP_Bool instable, SCIP_Bool *lperror)
SCIP_Real SCIProwGetObjParallelism(SCIP_ROW *row, SCIP_SET *set, SCIP_LP *lp)
static void recomputeGlbPseudoObjectiveValue(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
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_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)
static SCIP_RETCODE lpCleanupRows(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, int firstrow)
SCIP_Real SCIPlpGetPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
static SCIP_RETCODE lpDelRowset(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, int *rowdstat)
void SCIPlpSetSizeMark(SCIP_LP *lp, int nrows, int ncols)
static int SCIProwGetDiscreteScalarProduct(SCIP_ROW *row1, SCIP_ROW *row2)
SCIP_RETCODE SCIPlpUpdateVarColumn(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
SCIP_RETCODE SCIProwRelease(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)
static SCIP_RETCODE lpFlushAddCols(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue)
void SCIPcolPrint(SCIP_COL *col, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
internal methods for LP management
interface methods for specific LP solvers
#define BMSduplicateBlockMemoryArray(mem, ptr, source, num)
#define BMSfreeMemory(ptr)
#define BMSfreeBlockMemory(mem, ptr)
#define BMSallocBlockMemory(mem, ptr)
#define BMSreallocMemoryArray(ptr, num)
#define BMSfreeBlockMemoryArrayNull(mem, ptr, num)
#define BMSfreeMemoryNull(ptr)
#define BMSallocMemoryArray(ptr, num)
#define BMSallocBlockMemoryArray(mem, ptr, num)
#define BMSfreeBlockMemoryNull(mem, ptr)
#define BMSfreeBlockMemoryArray(mem, ptr, num)
#define BMSreallocBlockMemoryArray(mem, ptr, oldnum, newnum)
#define BMSclearMemoryArray(ptr, num)
struct BMS_BlkMem BMS_BLKMEM
#define BMSfreeMemoryArrayNull(ptr)
#define BMSallocMemory(ptr)
void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)
void SCIPmessageVFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr, va_list ap)
void SCIPmessagePrintInfo(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)
void SCIPmessagePrintWarning(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)
void SCIPmessagePrintVerbInfo(SCIP_MESSAGEHDLR *messagehdlr, SCIP_VERBLEVEL verblevel, SCIP_VERBLEVEL msgverblevel, const char *formatstr,...)
SCIP_RETCODE SCIPrealarrayExtend(SCIP_REALARRAY *realarray, int arraygrowinit, SCIP_Real arraygrowfac, int minidx, int maxidx)
SCIP_RETCODE SCIPrealarrayIncVal(SCIP_REALARRAY *realarray, int arraygrowinit, SCIP_Real arraygrowfac, int idx, SCIP_Real incval)
SCIP_RETCODE SCIPrealarrayClear(SCIP_REALARRAY *realarray)
internal miscellaneous methods
SCIP_Bool SCIPprobAllColsInLP(SCIP_PROB *prob, SCIP_SET *set, SCIP_LP *lp)
internal methods for storing and manipulating the main problem
public methods for LP management
public methods for message output
public data structures and miscellaneous methods
methods for sorting joint arrays of various types
public methods for problem variables
SCIP_Bool SCIPsetIsDualfeasZero(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsEfficacious(SCIP_SET *set, SCIP_Bool root, SCIP_Real efficacy)
SCIP_Bool SCIPsetIsFeasPositive(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPsetGetCharParam(SCIP_SET *set, const char *name, char *value)
SCIP_Real SCIPsetSumFloor(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsFeasNegative(SCIP_SET *set, SCIP_Real val)
SCIP_Real SCIPsetFeastol(SCIP_SET *set)
SCIP_Bool SCIPsetIsDualfeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsPositive(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPsetRelaxfeastol(SCIP_SET *set)
SCIP_Bool SCIPsetIsSumLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsDualfeasNegative(SCIP_SET *set, SCIP_Real val)
SCIP_Real SCIPsetDualfeastol(SCIP_SET *set)
SCIP_Bool SCIPsetIsSumGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasZero(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsFeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPsetSetCharParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *name, char value)
SCIP_Real SCIPsetLPFeastolFactor(SCIP_SET *set)
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
SCIP_Real SCIPsetSumepsilon(SCIP_SET *set)
SCIP_Bool SCIPsetIsLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsSumZero(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsRelGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsDualfeasPositive(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsDualfeasGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsSumEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsIntegral(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsUpdateUnreliable(SCIP_SET *set, SCIP_Real newvalue, SCIP_Real oldvalue)
SCIP_Real SCIPsetSumCeil(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsFeasGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPsetBarrierconvtol(SCIP_SET *set)
SCIP_Real SCIPsetRound(SCIP_SET *set, SCIP_Real val)
int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)
SCIP_Bool SCIPsetIsFeasIntegral(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsNegative(SCIP_SET *set, SCIP_Real val)
unsigned int SCIPsetInitializeRandomSeed(SCIP_SET *set, unsigned int initialseedvalue)
internal methods for global SCIP settings
#define SCIPsetFreeBufferArray(set, ptr)
#define SCIPsetDebugMsgPrint
#define SCIPsetAllocBufferArray(set, ptr, num)
SCIP_Real SCIPsolGetVal(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var)
internal methods for storing primal CIP solutions
SCIP_Bool SCIPsolveIsStopped(SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool checknodelimits)
internal methods for main solving loop and node processing
internal methods for problem statistics
#define SCIPstatAdd(stat, set, field, val)
#define SCIPstatIncrement(stat, set, field)
#define SCIPstatUpdate(stat, set, field, val)
SCIP_COLSOLVALS * storedsolvals
SCIP_Longint obsoletenode
unsigned int lprowssorted
SCIP_Longint validredcostlp
unsigned int nonlprowssorted
SCIP_Longint validfarkaslp
SCIP_Bool glbpseudoobjvalid
SCIP_Real lpirowrepswitch
SCIP_Longint validsoldirlp
SCIP_Real relglbpseudoobjval
SCIP_SIDETYPE * divechgsidetypes
SCIP_Bool strongbranching
SCIP_Bool updateintegrality
SCIP_Bool objsqrnormunreliable
SCIP_Real lpiconditionlimit
SCIP_Bool strongbranchprobing
SCIP_Real rootlooseobjval
SCIP_Bool divelpwasdualfeas
SCIP_Bool lpisolutionpolishing
SCIP_Bool divelpwasprimchecked
SCIP_LPSOLVALS * storedsolvals
SCIP_LPISTATE * divelpistate
SCIP_SOL * validsoldirsol
SCIP_Real relpseudoobjval
SCIP_Real lpibarrierconvtol
SCIP_Longint validdegeneracylp
SCIP_Longint divenolddomchgs
SCIP_Bool divinglazyapplied
SCIP_Bool divelpwasdualchecked
SCIP_Longint validfarkaslp
SCIP_Real glbpseudoobjval
SCIP_Bool lpihaspolishing
SCIP_Bool flushdeletedrows
SCIP_Bool divelpwasprimfeas
SCIP_Bool flushdeletedcols
SCIP_Longint nlpsaftercreation
SCIP_Longint activeinlpcounter
unsigned int lpcolssorted
unsigned int inglobalcutpool
SCIP_Longint obsoletenode
unsigned int nonlpcolssorted
unsigned int validminmaxidx
SCIP_Longint validpsactivitydomchg
SCIP_Longint validactivitybdsdomchg
SCIP_ROWSOLVALS * storedsolvals
SCIP_EVENTFILTER * eventfilter
SCIP_Longint validactivitylp
SCIP_Longint ndualresolvelpiterations
SCIP_Longint nprimalresolvelpiterations
SCIP_CLOCK * strongbranchtime
SCIP_CLOCK * barrierlptime
SCIP_Longint nduallpiterations
SCIP_Longint ndualresolvelps
SCIP_CLOCK * divinglptime
SCIP_Longint nlpiterations
SCIP_Longint nprimalresolvelps
SCIP_Longint nrootlpiterations
SCIP_Longint nnumtroublelpmsgs
SCIP_CLOCK * resolveinstablelptime
SCIP_CLOCK * primallptime
SCIP_Longint nprimallpiterations
SCIP_CLOCK * lexduallptime
datastructures for managing events
data structures for LP management
datastructures for storing and manipulating the main problem
SCIP main data structure.
datastructures for global SCIP settings
datastructures for problem statistics
datastructures for problem variables
enum SCIP_ClockType SCIP_CLOCKTYPE
struct SCIP_Cons SCIP_CONS
struct SCIP_Conshdlr SCIP_CONSHDLR
struct SCIP_Eventhdlr SCIP_EVENTHDLR
#define SCIP_EVENTTYPE_ROWSIDECHANGED
#define SCIP_EVENTTYPE_ROWADDEDLP
struct SCIP_EventData SCIP_EVENTDATA
struct SCIP_EventFilter SCIP_EVENTFILTER
#define SCIP_EVENTTYPE_ROWCHANGED
struct SCIP_EventQueue SCIP_EVENTQUEUE
#define SCIP_EVENTTYPE_FORMAT
#define SCIP_EVENTTYPE_ROWDELETEDLP
#define SCIP_EVENTTYPE_ROWCOEFCHANGED
struct SCIP_Event SCIP_EVENT
#define SCIP_EVENTTYPE_ROWCONSTCHANGED
enum SCIP_RowOriginType SCIP_ROWORIGINTYPE
@ SCIP_LPALGO_PRIMALSIMPLEX
@ SCIP_LPALGO_BARRIERCROSSOVER
@ SCIP_LPALGO_DUALSIMPLEX
enum SCIP_LPSolStat SCIP_LPSOLSTAT
@ SCIP_ROWORIGINTYPE_CONSHDLR
@ SCIP_ROWORIGINTYPE_SEPA
@ SCIP_ROWORIGINTYPE_CONS
struct SCIP_LpSolVals SCIP_LPSOLVALS
struct SCIP_ColSolVals SCIP_COLSOLVALS
enum SCIP_BoundType SCIP_BOUNDTYPE
struct SCIP_RowSolVals SCIP_ROWSOLVALS
@ SCIP_LPSOLSTAT_NOTSOLVED
@ SCIP_LPSOLSTAT_TIMELIMIT
@ SCIP_LPSOLSTAT_UNBOUNDEDRAY
@ SCIP_LPSOLSTAT_INFEASIBLE
@ SCIP_LPSOLSTAT_OBJLIMIT
@ SCIP_LPSOLSTAT_ITERLIMIT
enum SCIP_LPAlgo SCIP_LPALGO
enum SCIP_SideType SCIP_SIDETYPE
@ SCIP_PRICING_STEEPQSTART
@ SCIP_PRICING_LPIDEFAULT
enum SCIP_Pricing SCIP_PRICING
enum SCIP_LPParam SCIP_LPPARAM
struct SCIP_LPiState SCIP_LPISTATE
struct SCIP_LPiNorms SCIP_LPINORMS
@ SCIP_LPPAR_BARRIERCONVTOL
@ SCIP_LPPAR_CONDITIONLIMIT
@ SCIP_LPPAR_ROWREPSWITCH
enum SCIP_BaseStat SCIP_BASESTAT
enum SCIP_VerbLevel SCIP_VERBLEVEL
struct SCIP_Messagehdlr SCIP_MESSAGEHDLR
struct SCIP_RealArray SCIP_REALARRAY
#define SCIP_DECL_SORTPTRCOMP(x)
struct SCIP_Prob SCIP_PROB
enum SCIP_Objsense SCIP_OBJSENSE
enum SCIP_Retcode SCIP_RETCODE
struct SCIP_Sepa SCIP_SEPA
struct SCIP_Stat SCIP_STAT
SCIP_Real SCIPvarGetRelaxSol(SCIP_VAR *var, SCIP_SET *set)
internal methods for problem variables