107 for(
i = 0;
i < row->
len; ++
i )
126#define debugRowPrint(x,y)
150 for(
r = 0;
r < col->
len; ++
r )
159#define debugColPrint(x,y)
184 assert(num <= lp->chgcolssize);
207 assert(num <= lp->chgrowssize);
230 assert(num <= lp->lpicolssize);
253 assert(num <= lp->lpirowssize);
276 assert(num <= lp->colssize);
296 assert(num <= lp->soldirectionsize);
319 assert(num <= lp->lazycolssize);
342 assert(num <= lp->rowssize);
359 if( num > col->
size )
423 if( storedsolvals !=
NULL )
511 if( storedsolvals !=
NULL )
596 if( storedsolvals !=
NULL )
639 if( num > row->
size )
656#ifdef SCIP_MORE_DEBUG
666 if( !msgdisp_checkrow )
668 printf(
"LP ROW CHECKING ACTIVATED! THIS IS VERY SLOW!\n");
669 msgdisp_checkrow =
TRUE;
698#ifdef SCIP_MORE_DEBUG
713 for(
c = row->
len - 1;
c >= 0; --
c )
715 if( cols[
c]->lppos >= 0 )
736 for(
c = row->
len - 1;
c >= 0; --
c )
738 if( cols[
c]->lppos >= 0 )
759 for(
c = row->
len - 1;
c >= 0; --
c )
761 if( cols[
c]->lppos >= 0 )
768#define checkRowSqrnorm(row)
769#define checkRowSumnorm(row)
770#define checkRowObjprod(row)
800 for( v = 0; v <
nvars; ++v )
841 for( v = 0; v <
nvars; ++v )
883 for( v = 0; v <
nvars; ++v )
1116 searchidx = row->
index;
1117 while(minpos <= maxpos)
1119 pos = (minpos + maxpos)/2;
1120 assert(0 <= pos && pos < col->len);
1124 if( searchidx == idx )
1126 else if( searchidx < idx )
1150 if( row->
lppos >= 0 )
1191 searchidx = col->
index;
1192 while(minpos <= maxpos)
1194 pos = (minpos + maxpos)/2;
1195 assert(0 <= pos && pos < row->len);
1200 if( searchidx == idx )
1202 else if( searchidx < idx )
1231 if( col->
lppos >= 0 )
1252 assert(-1 <= pos && pos < row->len);
1258 for(
i = 0;
i < row->
len; ++
i )
1275 assert(0 <= oldpos && oldpos < col->len);
1276 assert(0 <= newpos && newpos < col->len);
1279 if( oldpos == newpos )
1282 col->
rows[newpos] = col->
rows[oldpos];
1283 col->
vals[newpos] = col->
vals[oldpos];
1287 if( col->
linkpos[newpos] >= 0 )
1315 assert(0 <= pos1 && pos1 < col->len);
1316 assert(0 <= pos2 && pos2 < col->len);
1323 tmprow = col->
rows[pos2];
1324 tmpval = col->
vals[pos2];
1325 tmplinkpos = col->
linkpos[pos2];
1331 col->
rows[pos1] = tmprow;
1332 col->
vals[pos1] = tmpval;
1333 col->
linkpos[pos1] = tmplinkpos;
1371 assert(0 <= oldpos && oldpos < row->len);
1372 assert(0 <= newpos && newpos < row->len);
1375 if( oldpos == newpos )
1378 row->
cols[newpos] = row->
cols[oldpos];
1380 row->
vals[newpos] = row->
vals[oldpos];
1384 if( row->
linkpos[newpos] >= 0 )
1413 assert(0 <= pos1 && pos1 < row->len);
1414 assert(0 <= pos2 && pos2 < row->len);
1422 tmpcol = row->
cols[pos2];
1424 tmpval = row->
vals[pos2];
1425 tmplinkpos = row->
linkpos[pos2];
1432 row->
cols[pos1] = tmpcol;
1434 row->
vals[pos1] = tmpval;
1435 row->
linkpos[pos1] = tmplinkpos;
1551#ifdef SCIP_MORE_DEBUG
1554#define ASSERT(x) do { if( !(x) ) abort(); } while( FALSE )
1556#define ASSERT(x) assert(x)
1574 if( !msgdisp_checklinks )
1576 printf(
"LP LINK CHECKING ACTIVATED! THIS IS VERY SLOW!\n");
1577 msgdisp_checklinks =
TRUE;
1583 ASSERT(col !=
NULL);
1589 for( j = 0; j < col->
len; ++j )
1592 ASSERT(row !=
NULL);
1603 ASSERT(row !=
NULL);
1609 for( j = 0; j < row->
len; ++j )
1612 ASSERT(col !=
NULL);
1616 ASSERT((j < row->nlpcols) == (row->
linkpos[j] >= 0 && col->
lppos >= 0));
1624#define checkLinks(lp)
1730 if( row->
lppos >= 0 && linkpos >= 0 )
1745 col->
rows[pos] = row;
1746 col->
vals[pos] = val;
1755 if( col->
lppos >= 0 )
1761 if( row->
lppos >= 0 )
1765 assert(0 <= linkpos && linkpos < row->len);
1782 if( col->
lppos >= 0 )
1788 if( linkpos == row->
nlpcols-1 )
1794 if( row->
lppos >= 0 && linkpos >= 0 )
1811 SCIPsetDebugMsg(
set,
"added coefficient %g * <%s> at position %d (%d/%d) to column <%s> (nunlinked=%d)\n",
1831 assert(0 <= pos && pos < col->len);
1836 row = col->
rows[pos];
1874 assert(0 <= pos && pos < col->len);
1892 col->
vals[pos] = val;
1928 if( col->
lppos >= 0 )
2013 if( forcenormupdate || col->
lppos >= 0 )
2081 if( col->
lppos >= 0 && linkpos >= 0 )
2096 row->
cols[pos] = col;
2098 row->
vals[pos] = val;
2108 if( row->
lppos >= 0 )
2114 if( col->
lppos >= 0 )
2118 assert(0 <= linkpos && linkpos < col->len);
2135 if( row->
lppos >= 0 )
2141 if( linkpos == col->
nlprows-1 )
2147 if( col->
lppos >= 0 && linkpos >= 0 )
2173 SCIPsetDebugMsg(
set,
"added coefficient %g * <%s> at position %d (%d/%d) to row <%s> (nunlinked=%d)\n",
2198 assert(0 <= pos && pos < row->len);
2202 col = row->
cols[pos];
2203 val = row->
vals[pos];
2211 SCIPerrorMessage(
"cannot delete a coefficient from the locked unmodifiable row <%s>\n", row->
name);
2219 if( pos < row->nlpcols )
2257 assert(0 <= pos && pos < row->len);
2264 SCIPerrorMessage(
"cannot change a coefficient of the locked unmodifiable row <%s>\n", row->
name);
2270 col = row->
cols[pos];
2282 oldval = row->
vals[pos];
2286 row->
vals[pos] = val;
2414 for(
i = 0;
i < col->
len; ++
i )
2490 for(
i = 0;
i < row->
len; ++
i )
2548 return lpSetIntpar(lp, lpparam, (
int)value, success);
2599 assert(lpivalue == value);
2635 assert(lpivalue == value);
2640#define lpCheckIntpar(lp, lpparam, value) SCIP_OKAY
2641#define lpCheckBoolpar(lp, lpparam, value) SCIP_OKAY
2642#define lpCheckRealpar(lp, lpparam, value) SCIP_OKAY
2646#define lpCutoffDisabled(set, prob, lp) (set->lp_disablecutoff == 1 || (set->lp_disablecutoff == 2 && !SCIPprobAllColsInLP(prob, set, lp)) || set->misc_exactsolve)
2723 if( lp->
nrows > 0 && actualfeastol < lp->lpifeastol )
2752 assert(dualfeastol >= 0.0);
2766 if( lp->
nrows > 0 && actualdualfeastol < lp->lpidualfeastol )
2795 assert(barrierconvtol >= 0.0);
2809 if( lp->
nrows > 0 && actualbarrierconvtol < lp->lpibarrierconvtol
2865 assert(0 <= fastmip && fastmip <= 1);
3054 switch( pricingchar )
3180 lptiming = (int) timing;
3207 if( randomseed == 0 )
3306 for(
i = 0;
i < len; ++
i )
3310 (*col)->linkpos[
i] = -1;
3315 (*col)->rows =
NULL;
3316 (*col)->vals =
NULL;
3317 (*col)->linkpos =
NULL;
3325 (*col)->flushedobj = 0.0;
3326 (*col)->flushedlb = 0.0;
3327 (*col)->flushedub = 0.0;
3328 (*col)->index = stat->
ncolidx;
3332 (*col)->nlprows = 0;
3333 (*col)->nunlinked = len;
3335 (*col)->lpipos = -1;
3336 (*col)->lpdepth = -1;
3337 (*col)->primsol = 0.0;
3340 (*col)->minprimsol = (*col)->ub;
3341 (*col)->maxprimsol = (*col)->lb;
3346 (*col)->sbnode = -1;
3347 (*col)->validredcostlp = -1;
3348 (*col)->validfarkaslp = -1;
3349 (*col)->validsblp = -1;
3350 (*col)->sbitlim = -1;
3351 (*col)->nsbcalls = 0;
3353 (*col)->obsoletenode = -1;
3356 (*col)->lprowssorted =
TRUE;
3357 (*col)->nonlprowssorted = (len <= 1);
3358 (*col)->objchanged =
FALSE;
3359 (*col)->lbchanged =
FALSE;
3360 (*col)->ubchanged =
FALSE;
3361 (*col)->coefchanged =
FALSE;
3363 (*col)->removable = removable;
3364 (*col)->sbdownvalid =
FALSE;
3365 (*col)->sbupvalid =
FALSE;
3368 (*col)->storedsolvals =
NULL;
3387 assert(&(*col)->var->data.col == col);
3388 assert((*col)->lppos == -1);
3389 assert((*col)->lpipos == -1);
3421 for(
r = 0;
r < col->
len; ++
r )
3489 assert(0 <= pos && pos < col->len);
3539 assert(0 <= pos && pos < col->len);
3593 assert(0 <= pos && pos < col->len);
3864 redcost -= col->
vals[
i] * dualsol[row->
lppos];
3874 if( row->
lppos >= 0 )
3875 redcost -= col->
vals[
i] * dualsol[row->
lppos];
3927 if( row->
lppos >= 0 )
4047 farkas += col->
vals[
i] * dualfarkas[row->
lppos];
4057 if( row->
lppos >= 0 )
4058 farkas += col->
vals[
i] * dualfarkas[row->
lppos];
4110 if( row->
lppos >= 0 )
4170 if( farkascoef > 0.0 )
4171 return col->
ub * farkascoef;
4173 return col->
lb * farkascoef;
4360 validsblp = stat->
nlps;
4371 sbdownvalid =
FALSE;
4379 SCIPsetDebugMsg(
set,
"performing strong branching on variable <%s>(%g) with %d iterations\n",
4406 sbdownvalid =
FALSE;
4435 if( iter/2 >= itlim )
4458 if( downvalid !=
NULL )
4459 *downvalid = sbdownvalid;
4460 if( upvalid !=
NULL )
4461 *upvalid = sbupvalid;
4544 for( j = 0; j < ncols; ++j )
4575 if( downvalid !=
NULL )
4577 if( upvalid !=
NULL )
4585 lpipos[nsubcols] = col->
lpipos;
4586 primsols[nsubcols] = col->
primsol;
4588 subidx[nsubcols] = j;
4589 subcols[nsubcols++] = col;
4593 SCIPsetDebugMsg(
set,
"performing strong branching on %d variables with %d iterations\n", ncols, itlim);
4606 for( j = 0; j < nsubcols; ++j )
4624 up[idx] = col->
sbup;
4625 if( downvalid !=
NULL )
4627 if( upvalid !=
NULL )
4640 for( j = 0; j < nsubcols; ++j )
4657 up[idx] = col->
sbup;
4658 if( downvalid !=
NULL )
4660 if( upvalid !=
NULL )
4673 if( iter/2 >= itlim )
4722 if( downvalid !=
NULL )
4724 if( upvalid !=
NULL )
4726 if( solval !=
NULL )
4728 if( lpobjval !=
NULL )
4849 for(
i = 0;
i < row->
len; ++
i )
4912 sval = val * scalar;
4913 downval = floor(sval);
4918 if( intval !=
NULL )
4924 if( intval !=
NULL )
4970 assert(-1.0 < minrounddelta && minrounddelta <= 0.0);
4971 assert(0.0 <= maxrounddelta && maxrounddelta < 1.0);
4973 SCIPsetDebugMsg(
set,
"scale row <%s> with %g (tolerance=[%g,%g])\n", row->
name, scaleval, minrounddelta, maxrounddelta);
4977 mindeltainf =
FALSE;
4978 maxdeltainf =
FALSE;
5007 newval = val * scaleval;
5009 &&
isIntegralScalar(val, scaleval, minrounddelta, maxrounddelta, &intval) )
5013 if( intval < newval )
5015 mindelta += (intval - newval)*ub;
5016 maxdelta += (intval - newval)*lb;
5022 mindelta += (intval - newval)*lb;
5023 maxdelta += (intval - newval)*ub;
5045 if( oldlen != row->
len )
5068 newval = (row->
lhs - row->
constant) * scaleval + mindelta;
5080 newval = (row->
rhs - row->
constant) * scaleval + maxdelta;
5138 (*row)->integral =
TRUE;
5149 for(
i = 0;
i < len; ++
i )
5155 (*row)->cols_index[
i] = cols[
i]->
index;
5156 (*row)->linkpos[
i] = -1;
5164 (*row)->integral =
FALSE;
5170 (*row)->cols =
NULL;
5171 (*row)->cols_index =
NULL;
5172 (*row)->vals =
NULL;
5173 (*row)->linkpos =
NULL;
5177 (*row)->constant = 0.0;
5182 (*row)->sqrnorm = 0.0;
5183 (*row)->sumnorm = 0.0;
5184 (*row)->objprod = 0.0;
5185 (*row)->maxval = 0.0;
5187 (*row)->dualsol = 0.0;
5189 (*row)->dualfarkas = 0.0;
5193 (*row)->origin = origin;
5194 (*row)->eventfilter =
NULL;
5195 (*row)->index = stat->
nrowidx;
5199 (*row)->nlpcols = 0;
5200 (*row)->nunlinked = len;
5203 (*row)->lpipos = -1;
5204 (*row)->lpdepth = -1;
5205 (*row)->minidx = INT_MAX;
5206 (*row)->maxidx = INT_MIN;
5207 (*row)->nummaxval = 0;
5208 (*row)->numminval = 0;
5209 (*row)->numintcols = -1;
5210 (*row)->validactivitylp = -1;
5211 (*row)->validpsactivitydomchg = -1;
5212 (*row)->validactivitybdsdomchg = -1;
5213 (*row)->nlpsaftercreation = 0L;
5214 (*row)->activeinlpcounter = 0L;
5217 (*row)->obsoletenode = -1;
5218 (*row)->fromcutpool =
FALSE;
5220 (*row)->lpcolssorted =
TRUE;
5221 (*row)->nonlpcolssorted = (len <= 1);
5222 (*row)->delaysort =
FALSE;
5223 (*row)->validminmaxidx =
FALSE;
5224 (*row)->lhschanged =
FALSE;
5225 (*row)->rhschanged =
FALSE;
5226 (*row)->coefchanged =
FALSE;
5227 (*row)->local = local;
5228 (*row)->modifiable = modifiable;
5230 (*row)->origintype = origintype;
5231 (*row)->removable = removable;
5232 (*row)->inglobalcutpool =
FALSE;
5233 (*row)->storedsolvals =
NULL;
5266 assert((*row)->nuses == 0);
5267 assert((*row)->lppos == -1);
5318 for(
i = 0;
i < row->
len; ++
i )
5359 assert((*row)->nuses >= 1);
5360 assert((*row)->nlocks < (
unsigned int)((*row)->nuses));
5362 SCIPsetDebugMsg(
set,
"release row <%s> with nuses=%d and nlocks=%u\n", (*row)->name, (*row)->nuses, (*row)->nlocks);
5364 if( (*row)->nuses == 0 )
5452 assert(0 <= pos && pos < row->len);
5503 assert(0 <= pos && pos < row->len);
5557 assert(0 <= pos && pos < row->len);
5787 if( intscalar !=
NULL )
5793 for(
c = 0;
c < row->
len; ++
c )
5805 if( val < mindelta || val > maxdelta )
5808 minval =
MIN(minval, absval);
5814 if( intscalar !=
NULL )
5821 assert(minval >
MIN(-mindelta, maxdelta));
5828 scaleval = 1.0/minval;
5829 scalable = (scaleval <= maxscale);
5830 for(
c = 0;
c < row->
len && scalable; ++
c )
5839 while( scaleval <= maxscale
5853 scalable = (scaleval <= maxscale);
5854 SCIPsetDebugMsg(
set,
" -> val=%g, scaleval=%g, val*scaleval=%g, scalable=%u\n", val, scaleval, val*scaleval, scalable);
5861 assert(scaleval <= maxscale);
5862 if( intscalar !=
NULL )
5863 *intscalar = scaleval;
5865 SCIPsetDebugMsg(
set,
" -> integrality can be achieved by scaling with %g (minval=%g)\n", scaleval, minval);
5872 twomult = (twomultval <= maxscale);
5873 for(
c = 0;
c < row->
len && twomult; ++
c )
5882 while( twomultval <= maxscale
5883 && (absval * twomultval < 0.5 || !
isIntegralScalar(val, twomultval, mindelta, maxdelta,
NULL)) )
5896 twomult = (twomultval <= maxscale);
5898 val, twomultval, val*twomultval, twomult);
5903 assert(twomultval <= maxscale);
5904 if( intscalar !=
NULL )
5905 *intscalar = twomultval;
5907 SCIPsetDebugMsg(
set,
" -> integrality can be achieved by scaling with %g (power of 2)\n", twomultval);
5917 rational = (maxdnom > 1);
5920 for(
c = 0;
c < row->
len && rational; ++
c )
5925 rational =
SCIPrealToRational(val, mindelta, maxdelta, maxdnom, &nominator, &denominator);
5926 if( rational && nominator != 0 )
5929 gcd =
ABS(nominator);
5933 val, nominator, denominator, gcd, scm, rational);
5940 for( ++
c;
c < row->
len && rational; ++
c )
5945 rational =
SCIPrealToRational(val, mindelta, maxdelta, maxdnom, &nominator, &denominator);
5946 if( rational && nominator != 0 )
5953 val, nominator, denominator, gcd, scm, rational);
5962 if( intscalar !=
NULL )
5999 &intscalar, success) );
6004 SCIP_CALL(
rowScale(row, blkmem,
set, eventqueue, stat, lp, intscalar, usecontvars, mindelta, maxdelta) );
6025#ifdef SCIP_MORE_DEBUG
6085 for( s = 1; s < row->
len; ++s )
6090 if( cols[s] == cols[t] )
6107 cols_index[t] = cols_index[s];
6133 for(
i = 0;
i < row->
len; ++
i )
6137 for( j =
i+1; j < row->
len; ++j )
6199 if( col->
lppos >= 0 )
6244 activity =
MAX(activity, -inf);
6245 activity =
MIN(activity, +inf);
6264 return MIN(row->
rhs - activity, activity - row->
lhs);
6303 if ( col->
lppos >= 0 )
6323 activity =
MAX(activity, -inf);
6324 activity =
MIN(activity, +inf);
6326 return MIN(row->
rhs - activity, activity - row->
lhs);
6365 if ( col->
lppos >= 0 )
6385 activity =
MAX(activity, -inf);
6386 activity =
MIN(activity, +inf);
6388 return MIN(row->
rhs - activity, activity - row->
lhs);
6404 for(
i = 0;
i < row->
len; ++
i )
6440 activity =
MAX(activity, -inf);
6441 activity =
MIN(activity, +inf);
6459 return MIN(row->
rhs - pseudoactivity, pseudoactivity - row->
lhs);
6479 for(
i = 0;
i < row->
len; ++
i )
6488 solval = (row->
vals[
i] >= 0.0 ? col->
lb : col->
ub);
6490 solval = (row->
vals[
i] >= 0.0 ? col->
ub : col->
lb);
6492 solval = (col->
lb + col->
ub)/2.0;
6494 activity += row->
vals[
i] * solval;
6498 activity =
MAX(activity, -inf);
6499 activity =
MIN(activity, +inf);
6518 return MIN(row->
rhs - activity, activity - row->
lhs);
6540 mininfinite =
FALSE;
6541 maxinfinite =
FALSE;
6544 for(
i = 0;
i < row->
len && (!mininfinite || !maxinfinite); ++
i )
6770 for( k = 0; k < lp->
ncols; ++k )
6779 scale = 1.0 / sqrt(scale);
6781 for( k = 0; k < lp->
ncols; ++k )
6786 solcutoffdist = 0.0;
6787 for( k = 0; k < row->
nlpcols; ++k )
6790 for( k = row->
nlpcols; k < row->len; ++k )
6797 solcutoffdist =
set->num_sumepsilon;
6801 return solcutoffdist;
6818 switch(
set->sepa_efficacynorm )
6830 norm = (row->
len == 0 ? 0.0 : 1.0);
6842 return -feasibility / norm;
6875 switch(
set->sepa_efficacynorm )
6887 norm = (row->
len == 0 ? 0.0 : 1.0);
6899 return -feasibility / norm;
6933 switch(
set->sepa_efficacynorm )
6945 norm = (row->
len == 0 ? 0.0 : 1.0);
6957 return -feasibility / norm;
6973 switch(
set->sepa_efficacynorm )
6985 norm = (row->
len == 0 ? 0.0 : 1.0);
6997 return -feasibility / norm;
7071 while( i1 < row1->nlpcols && i2 < row2->len )
7086 while( i1 < row1->len && i2 < row2->nlpcols )
7118 while( i1 >= 0 && i2 >= 0 )
7122 assert((row1->
cols[i1] == row2->
cols[i2]) == (row1colsidx[i1] == row2colsidx[i2]));
7123 if( row1colsidx[i1] < row2colsidx[i2] )
7125 else if( row1colsidx[i1] > row2colsidx[i2] )
7129 scalarprod += row1->
vals[i1] * row2->
vals[i2];
7157 while( ilp1 < row1->nlpcols && inlp1 < row1->len && ilp2 < row2->nlpcols && inlp2 < row2->len )
7163 assert((row1->
cols[ilp1] == row2->
cols[ilp2]) == (row1colsidx[ilp1] == row2colsidx[ilp2]));
7164 assert((row1->
cols[ilp1] == row2->
cols[inlp2]) == (row1colsidx[ilp1] == row2colsidx[inlp2]));
7165 assert((row1->
cols[inlp1] == row2->
cols[ilp2]) == (row1colsidx[inlp1] == row2colsidx[ilp2]));
7166 assert((row1->
cols[inlp1] == row2->
cols[inlp2]) == (row1colsidx[inlp1] == row2colsidx[inlp2]));
7169 if( row1colsidx[ilp1] == row2colsidx[ilp2] )
7171 scalarprod += row1->
vals[ilp1] * row2->
vals[ilp2];
7176 else if( row1colsidx[ilp1] == row2colsidx[inlp2] )
7178 scalarprod += row1->
vals[ilp1] * row2->
vals[inlp2];
7183 else if( row1colsidx[inlp1] == row2colsidx[ilp2] )
7185 scalarprod += row1->
vals[inlp1] * row2->
vals[ilp2];
7190 else if( row1colsidx[inlp1] == row2colsidx[inlp2] && row1->
cols[inlp1]->
lppos >= 0 )
7192 scalarprod += row1->
vals[inlp1] * row2->
vals[inlp2];
7197 else if( row1colsidx[ilp1] < row1colsidx[inlp1] )
7199 if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7201 if( row1colsidx[ilp1] < row2colsidx[ilp2] )
7208 if( row1colsidx[ilp1] < row2colsidx[inlp2] )
7216 if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7218 if( row1colsidx[inlp1] < row2colsidx[ilp2] )
7225 if( row1colsidx[inlp1] < row2colsidx[inlp2] )
7237 if( ilp1 != row1->
nlpcols && inlp1 != row1->
len )
7275 while( i1 < end1 && ilp2 < row2->nlpcols && inlp2 < row2->len )
7280 assert((row1->
cols[i1] == row2->
cols[ilp2]) == (row1colsidx[i1] == row2colsidx[ilp2]));
7281 assert((row1->
cols[i1] == row2->
cols[inlp2]) == (row1colsidx[i1] == row2colsidx[inlp2]));
7284 if( row1colsidx[i1] == row2colsidx[ilp2] )
7286 scalarprod += row1->
vals[i1] * row2->
vals[ilp2];
7291 else if( row1colsidx[i1] == row2colsidx[inlp2] && (lpcols || row1->
cols[i1]->
lppos >= 0) )
7293 scalarprod += row1->
vals[i1] * row2->
vals[inlp2];
7298 else if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7300 if( row1colsidx[i1] < row2colsidx[ilp2] )
7307 if( row1colsidx[i1] < row2colsidx[inlp2] )
7335 while( i1 < end1 && i2 < end2 )
7339 assert((row1->
cols[i1] == row2->
cols[i2]) == (row1colsidx[i1] == row2colsidx[i2]));
7342 if( row1colsidx[i1] == row2colsidx[i2] && (lpcols || row1->
cols[i1]->
lppos >= 0) )
7344 scalarprod += row1->
vals[i1] * row2->
vals[i2];
7349 else if( row1colsidx[i1] < row2colsidx[i2] )
7428 while( i1 < row1->nlpcols && i2 < row2->len )
7443 while( i1 < row1->len && i2 < row2->nlpcols )
7475 while( i1 >= 0 && i2 >= 0 )
7479 assert((row1->
cols[i1] == row2->
cols[i2]) == (row1colsidx[i1] == row2colsidx[i2]));
7480 if( row1colsidx[i1] < row2colsidx[i2] )
7482 else if( row1colsidx[i1] > row2colsidx[i2] )
7514 while( ilp1 < row1->nlpcols && inlp1 < row1->len && ilp2 < row2->nlpcols && inlp2 < row2->len )
7520 assert((row1->
cols[ilp1] == row2->
cols[ilp2]) == (row1colsidx[ilp1] == row2colsidx[ilp2]));
7521 assert((row1->
cols[ilp1] == row2->
cols[inlp2]) == (row1colsidx[ilp1] == row2colsidx[inlp2]));
7522 assert((row1->
cols[inlp1] == row2->
cols[ilp2]) == (row1colsidx[inlp1] == row2colsidx[ilp2]));
7523 assert((row1->
cols[inlp1] == row2->
cols[inlp2]) == (row1colsidx[inlp1] == row2colsidx[inlp2]));
7526 if( row1colsidx[ilp1] == row2colsidx[ilp2] )
7533 else if( row1colsidx[ilp1] == row2colsidx[inlp2] )
7540 else if( row1colsidx[inlp1] == row2colsidx[ilp2] )
7547 else if( row1colsidx[inlp1] == row2colsidx[inlp2] && row1->
cols[inlp1]->
lppos >= 0 )
7554 else if( row1colsidx[ilp1] < row1colsidx[inlp1] )
7556 if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7558 if( row1colsidx[ilp1] < row2colsidx[ilp2] )
7565 if( row1colsidx[ilp1] < row2colsidx[inlp2] )
7573 if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7575 if( row1colsidx[inlp1] < row2colsidx[ilp2] )
7582 if( row1colsidx[inlp1] < row2colsidx[inlp2] )
7594 if( ilp1 != row1->
nlpcols && inlp1 != row1->
len )
7632 while( i1 < end1 && ilp2 < row2->nlpcols && inlp2 < row2->len )
7637 assert((row1->
cols[i1] == row2->
cols[ilp2]) == (row1colsidx[i1] == row2colsidx[ilp2]));
7638 assert((row1->
cols[i1] == row2->
cols[inlp2]) == (row1colsidx[i1] == row2colsidx[inlp2]));
7641 if( row1colsidx[i1] == row2colsidx[ilp2] )
7648 else if( row1colsidx[i1] == row2colsidx[inlp2] && (lpcols || row1->
cols[i1]->
lppos >= 0) )
7655 else if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7657 if( row1colsidx[i1] < row2colsidx[ilp2] )
7664 if( row1colsidx[i1] < row2colsidx[inlp2] )
7692 while( i1 < end1 && i2 < end2 )
7696 assert((row1->
cols[i1] == row2->
cols[i2]) == (row1colsidx[i1] == row2colsidx[i2]));
7699 if( row1colsidx[i1] == row2colsidx[i2] && (lpcols || row1->
cols[i1]->
lppos >= 0) )
7706 else if( row1colsidx[i1] < row2colsidx[i2] )
7734 if( scalarprod == 0.0 )
7748 for(
i = 0;
i < row1->
len; ++
i )
7758 for(
i = 0;
i < row2->
len; ++
i )
7773 SCIPerrorMessage(
"invalid orthogonality function parameter '%c'\n", orthofunc);
7823 parallelism =
MIN(parallelism, 1.0);
7824 parallelism =
MAX(parallelism, 0.0);
7846 eventtype, row->
name, (
void*)eventhdlr, (
void*)eventdata);
7867 SCIPsetDebugMsg(
set,
"drop event of row <%s> with handler %p and data %p\n", row->
name, (
void*)eventhdlr, (
void*)eventdata);
8114 assert(lpipos < lp->nrows);
8115 assert(nnonz < naddcoefs);
8116 ind[nnonz] = lpipos;
8117 val[nnonz] = col->
vals[
i];
8315 name[pos] = row->
name;
8327 assert(lpipos < lp->ncols);
8328 assert(nnonz < naddcoefs);
8330 ind[nnonz] = lpipos;
8331 val[nnonz] = row->
vals[
i];
8445 assert(nobjchg < lp->ncols);
8446 objind[nobjchg] = col->
lpipos;
8464 assert(nbdchg < lp->ncols);
8465 bdind[nbdchg] = col->
lpipos;
8482 SCIPsetDebugMsg(
set,
"flushing objective changes: change %d objective values of %d changed columns\n", nobjchg, lp->
nchgcols);
8580 assert(nchg < lp->nrows);
8679 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",
8873 for(
i = 0;
i < col->
len; ++
i )
8912 for(
i = 0;
i < row->
len; ++
i )
8948 for(
i = 0;
i < col->
len; ++
i )
8957 assert(0 <= pos && pos < row->nlpcols);
8986 for(
i = 0;
i < row->
len; ++
i )
9044 if( minsize <= lp->divechgsidessize )
9073#define DIVESTACKINITSIZE 100
9096 (*lp)->lpicols =
NULL;
9097 (*lp)->lpirows =
NULL;
9098 (*lp)->chgcols =
NULL;
9099 (*lp)->chgrows =
NULL;
9101 (*lp)->soldirection =
NULL;
9102 (*lp)->lazycols =
NULL;
9104 (*lp)->lpobjval = 0.0;
9105 (*lp)->glbpseudoobjval = 0.0;
9106 (*lp)->relglbpseudoobjval = 0.0;
9107 (*lp)->glbpseudoobjvalid =
TRUE;
9108 (*lp)->glbpseudoobjvalinf = 0;
9109 (*lp)->pseudoobjval = 0.0;
9110 (*lp)->relpseudoobjval = 0.0;
9111 (*lp)->pseudoobjvalid =
TRUE;
9112 (*lp)->pseudoobjvalinf = 0;
9113 (*lp)->looseobjval = 0.0;
9114 (*lp)->rellooseobjval = 0.0;
9115 (*lp)->looseobjvalid =
TRUE;
9116 (*lp)->looseobjvalinf = 0;
9117 (*lp)->nloosevars = 0;
9123 (*lp)->validdegeneracylp = -1;
9124 (*lp)->objsqrnorm = 0.0;
9125 (*lp)->objsumnorm = 0.0;
9126 (*lp)->lpicolssize = 0;
9127 (*lp)->nlpicols = 0;
9128 (*lp)->lpirowssize = 0;
9129 (*lp)->nlpirows = 0;
9130 (*lp)->lpifirstchgcol = 0;
9131 (*lp)->lpifirstchgrow = 0;
9132 (*lp)->colssize = 0;
9133 (*lp)->soldirectionsize = 0;
9135 (*lp)->lazycolssize = 0;
9136 (*lp)->nlazycols = 0;
9137 (*lp)->rowssize = 0;
9139 (*lp)->chgcolssize = 0;
9140 (*lp)->nchgcols = 0;
9141 (*lp)->chgrowssize = 0;
9142 (*lp)->nchgrows = 0;
9143 (*lp)->firstnewcol = 0;
9144 (*lp)->firstnewrow = 0;
9145 (*lp)->nremovablecols = 0;
9146 (*lp)->nremovablerows = 0;
9147 (*lp)->validsollp = stat->
lpcount;
9148 (*lp)->validfarkaslp = -1;
9149 (*lp)->validsoldirlp = -1;
9150 (*lp)->validsoldirsol =
NULL;
9151 (*lp)->objsqrnormunreliable =
FALSE;
9152 (*lp)->flushdeletedcols =
FALSE;
9153 (*lp)->flushaddedcols =
FALSE;
9154 (*lp)->flushdeletedrows =
FALSE;
9155 (*lp)->flushaddedrows =
FALSE;
9156 (*lp)->updateintegrality =
TRUE;
9157 (*lp)->flushed =
TRUE;
9159 (*lp)->solved =
TRUE;
9160 (*lp)->primalfeasible =
TRUE;
9161 (*lp)->primalchecked =
TRUE;
9162 (*lp)->dualfeasible =
TRUE;
9163 (*lp)->dualchecked =
TRUE;
9164 (*lp)->solisbasic =
FALSE;
9165 (*lp)->rootlpisrelax =
TRUE;
9166 (*lp)->isrelax =
TRUE;
9167 (*lp)->installing =
FALSE;
9168 (*lp)->strongbranching =
FALSE;
9169 (*lp)->strongbranchprobing =
FALSE;
9170 (*lp)->probing =
FALSE;
9171 (*lp)->diving =
FALSE;
9172 (*lp)->divingobjchg =
FALSE;
9173 (*lp)->divinglazyapplied =
FALSE;
9174 (*lp)->divelpistate =
NULL;
9175 (*lp)->divelpwasprimfeas =
TRUE;
9176 (*lp)->divelpwasprimchecked =
TRUE;
9177 (*lp)->divelpwasdualfeas =
TRUE;
9178 (*lp)->divelpwasdualchecked =
TRUE;
9179 (*lp)->divechgsides =
NULL;
9180 (*lp)->divechgsidetypes =
NULL;
9181 (*lp)->divechgrows =
NULL;
9182 (*lp)->ndivechgsides = 0;
9183 (*lp)->divechgsidessize = 0;
9184 (*lp)->ndivingrows = 0;
9185 (*lp)->divinglpiitlim = INT_MAX;
9186 (*lp)->resolvelperror =
FALSE;
9187 (*lp)->divenolddomchgs = 0;
9188 (*lp)->adjustlpval =
FALSE;
9190 (*lp)->lpifeastol = (*lp)->feastol;
9193 (*lp)->lpifromscratch =
FALSE;
9194 (*lp)->lpifastmip =
set->lp_fastmip;
9195 (*lp)->lpiscaling =
set->lp_scaling;
9196 (*lp)->lpipresolving =
set->lp_presolving;
9197 (*lp)->lpilpinfo =
set->disp_lpinfo;
9198 (*lp)->lpirowrepswitch =
set->lp_rowrepswitch;
9199 (*lp)->lpisolutionpolishing = (
set->lp_solutionpolishing > 0);
9200 (*lp)->lpirefactorinterval =
set->lp_refactorinterval;
9201 (*lp)->lpiconditionlimit =
set->lp_conditionlimit;
9202 (*lp)->lpimarkowitz =
set->lp_markowitz;
9203 (*lp)->lpiitlim = INT_MAX;
9206 (*lp)->lpithreads =
set->lp_threads;
9207 (*lp)->lpitiming = (int)
set->time_clocktype;
9208 (*lp)->lpirandomseed =
set->random_randomseed;
9209 (*lp)->storedsolvals =
NULL;
9219 "LP Solver <%s>: objective limit cannot be set -- can lead to unnecessary simplex iterations\n",
9223 (*lp)->lpihasfeastol = success;
9227 "LP Solver <%s>: primal feasibility tolerance cannot be set -- tolerance of SCIP and LP solver may differ\n",
9231 (*lp)->lpihasdualfeastol = success;
9235 "LP Solver <%s>: dual feasibility tolerance cannot be set -- tolerance of SCIP and LP solver may differ\n",
9239 (*lp)->lpihasbarrierconvtol = success;
9243 "LP Solver <%s>: barrier convergence tolerance cannot be set -- tolerance of SCIP and LP solver may differ\n",
9248 (*lp)->lpihasfastmip = success;
9252 "LP Solver <%s>: fastmip setting not available -- SCIP parameter has no effect\n",
9256 (*lp)->lpihasscaling = success;
9260 "LP Solver <%s>: scaling not available -- SCIP parameter has no effect\n",
9264 (*lp)->lpihaspresolving = success;
9268 "LP Solver <%s>: presolving not available -- SCIP parameter has no effect\n",
9275 "LP Solver <%s>: clock type cannot be set\n",
9282 "LP Solver <%s>: iteration limit cannot be set -- can lead to unnecessary simplex iterations\n",
9289 "LP Solver <%s>: pricing strategy cannot be set -- SCIP parameter has no effect\n",
9296 "LP Solver <%s>: lpinfo setting not available -- SCIP parameter has no effect\n",
9300 (*lp)->lpihasrowrep = success;
9304 "LP Solver <%s>: row representation of the basis not available -- SCIP parameter lp/rowrepswitch has no effect\n",
9308 (*lp)->lpihaspolishing = success;
9312 "LP Solver <%s>: solution polishing not available -- SCIP parameter lp/solutionpolishing has no effect\n",
9316 (*lp)->lpihasrefactor = success;
9320 "LP Solver <%s>: refactorization interval not available -- SCIP parameter lp/refactorinterval has no effect\n",
9327 "LP Solver <%s>: condition number limit for the basis not available -- SCIP parameter lp/conditionlimit has no effect\n",
9334 "LP Solver <%s>: markowitz threshhold not available -- SCIP parameter lp/minmarkowitz has no effect\n",
9341 "LP Solver <%s>: number of threads settings not available -- SCIP parameter has no effect\n",
9345 if( (*lp)->lpirandomseed != 0 )
9351 "LP Solver <%s>: random seed parameter not available -- SCIP parameter has no effect\n",
9360 SCIPerrorMessage(
"The infinity value of the LP solver has to be at least as large as the one of SCIP.\n");
9386 for(
i = 0;
i < (*lp)->nlpirows; ++
i )
9391 if( (*lp)->lpi !=
NULL )
9470 for(
i = 0;
i < col->
len; ++
i )
9530 for(
i = 0;
i < row->
len; ++
i )
9627#define checkLazyColArray(lp, set)
9644 assert(newncols <= lp->ncols);
9646 if( newncols < lp->ncols )
9650 for(
c = lp->
ncols-1;
c >= newncols; --
c )
9716 assert(0 <= newnrows && newnrows <= lp->nrows);
9719 if( newnrows < lp->nrows )
9721 for(
r = lp->
nrows-1;
r >= newnrows; --
r )
9975 lhsinfinite =
FALSE;
9976 rhsinfinite =
FALSE;
9988 for(
i = 0;
i < row->
len; ++
i )
10001 if( weights[
r] > 0.0 )
10079 if( lpistate ==
NULL )
10106 if( *lpistate !=
NULL )
10166 if( lpinorms !=
NULL )
10261 assert(newfeastol > 0.0);
10266 if( newfeastol < lp->feastol )
10303 return "primal simplex";
10305 return "dual simplex";
10309 return "barrier/crossover";
10344#ifdef SCIP_MORE_DEBUG
10350 SCIPsetDebugMsg(
set,
"wrote LP to file <%s> (primal simplex, objlim=%.15g, feastol=%.15g/%.15g, fromscratch=%d, fastmip=%d, scaling=%d, presolving=%d)\n",
10414 if( iterations > 0 )
10459 if ( keepsol && !(*
lperror) )
10502#ifdef SCIP_MORE_DEBUG
10508 SCIPsetDebugMsg(
set,
"wrote LP to file <%s> (dual simplex, objlim=%.15g, feastol=%.15g/%.15g, fromscratch=%d, fastmip=%d, scaling=%d, presolving=%d)\n",
10572 if( iterations > 0 )
10679 int totalIterations;
10723 totalIterations = iterations;
10741 if( iterations > 0 )
10814 chooseBasic =
set->lp_lexdualbasic;
10880#ifdef DEBUG_LEXDUAL
10893 for( j = 0; j < lp->
nlpicols; ++j )
10968 if( pos == -1 &&
c > oldpos )
10981 if( pos == -1 &&
c > oldpos )
10986 newlb[cntcol] = oldlb[
c];
10987 newub[cntcol] = oldlb[
c];
10988 indcol[cntcol++] =
c;
11003 newlb[cntcol] = oldlb[
c];
11004 newub[cntcol] = oldlb[
c];
11010 newlb[cntcol] = oldub[
c];
11011 newub[cntcol] = oldub[
c];
11016 newlb[cntcol] = 0.0;
11017 newub[cntcol] = 0.0;
11020 indcol[cntcol++] =
c;
11044 newlhs[cntrow] = oldlhs[
r];
11045 newrhs[cntrow] = oldlhs[
r];
11050 newlhs[cntrow] = oldrhs[
r];
11051 newrhs[cntrow] = oldrhs[
r];
11053 indrow[cntrow++] =
r;
11060 if( nDualDeg > 0 && pos >= 0 )
11062 assert(0 <= pos && pos < lp->nlpicols && pos > oldpos);
11094 lexIterations += iterations;
11096#ifdef DEBUG_LEXDUAL
11097 if( iterations > 0 )
11109 for( j = 0; j < lp->
nlpicols; ++j )
11160 if( iterations > 0 )
11165 while( pos >= 0 && nDualDeg > 0 && (
set->lp_lexdualmaxrounds == -1 || rounds < set->lp_lexdualmaxrounds) );
11185 lexIterations += iterations;
11193 if( lexIterations > 0 )
11199 SCIPstatAdd(stat,
set, nlexdualresolvelpiterations, lexIterations);
11204 totalIterations += lexIterations;
11291#ifdef SCIP_MORE_DEBUG
11297 SCIPsetDebugMsg(
set,
"wrote LP to file <%s> (barrier, objlim=%.15g, feastol=%.15g/%.15g, convtol=%.15g, fromscratch=%d, fastmip=%d, scaling=%d, presolving=%d)\n",
11350 if( iterations > 0 )
11424 if(
set->istimelimitfinite )
11428 if( lptimelimit > 0.0 )
11431 if( lptimelimit <= 0.0 || !success )
11486#define MAXNUMTROUBLELPMSGS 10
11500 const char* formatstr,
11523 if( verblevel >
set->disp_verblevel )
11533 va_start(ap, formatstr);
11540 SCIPmessagePrintInfo(messagehdlr,
" -- further messages will be suppressed (use display/verblevel=5 to see all)");
11565 if( !
set->lp_checkdualfeas )
11567 if( !
set->lp_checkprimfeas )
11574#define FEASTOLTIGHTFAC 0.001
11620 SCIPerrorMessage(
"cannot solve LP when loose variable with infinite best bound is present\n");
11628 itlimishard = (itlim == harditlim);
11634 usepolishing =
TRUE;
11641 usepolishing =
FALSE;
11683 if( !
set->lp_checkstability )
11710 if( !
set->lp_checkstability )
11730 lpalgoName(lpalgo), (scaling == 0) ?
"with" :
"without");
11737 if( !
set->lp_checkstability )
11760 lpalgoName(lpalgo), !
set->lp_presolving ?
"with" :
"without");
11767 if( !
set->lp_checkstability )
11784 if( ((simplex && (!tightprimfeastol || !tightdualfeastol)) || (!tightprimfeastol && !tightdualfeastol)) &&
11788 if( !tightprimfeastol )
11794 if( !tightdualfeastol )
11800 if( !simplex && !tightprimfeastol && !tightdualfeastol )
11806 if( success || success2 || success3 )
11816 if( !
set->lp_checkstability )
11825 if( !tightprimfeastol )
11829 if( !tightdualfeastol )
11833 if( !simplex && !tightprimfeastol && !tightdualfeastol )
11845 if( !fromscratch && simplex )
11857 if( !
set->lp_checkstability )
11878 if( !
set->lp_checkstability )
11891 lpalgoName(lpalgo), (scaling == 0) ?
"with" :
"without");
11898 if( !
set->lp_checkstability )
11916 lpalgoName(lpalgo), !
set->lp_presolving ?
"with" :
"without");
11923 if( !
set->lp_checkstability )
11937 if( !tightprimfeastol || !tightdualfeastol )
11940 if( !tightprimfeastol )
11946 if( !tightdualfeastol )
11952 if( success || success2 )
11962 if( !
set->lp_checkstability )
11971 if( !tightprimfeastol )
11975 if( !tightdualfeastol )
12058 solvedprimal =
FALSE;
12059 solveddual =
FALSE;
12063 itlim = ( resolve ? resolveitlim : harditlim );
12067 SCIP_CALL(
lpSolveStable(lp,
set, messagehdlr, stat, prob, lpalgo, itlim, harditlim, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch,
12068 scaling, keepsol, &timelimit,
lperror) );
12204 SCIPsetDebugMsg(
set,
"solving LP with %s returned solstat=%d (internal status: %d, primalfeasible=%u, dualfeasible=%u)\n",
12247 algo = resolve ?
set->lp_resolvealgorithm :
set->lp_initalgorithm;
12257 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12263 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12270 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12276 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12282 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12288 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12292 SCIPerrorMessage(
"invalid parameter setting <%c> for LP algorithm\n", algo);
12323#define checkLazyBounds(lp, set)
12346 SCIPsetDebugMsg(
set,
"mark all lazy columns as changed in order to reload bounds (diving=%u, applied=%u)\n",
12399 if( (
set->lp_resolveiterfac == -1) || stat->
nlps - stat->
nrootlps < 5 )
12405 return (
int)
MIN(itlim,
MAX(
set->lp_resolveitermin, \
12449 SCIPsetDebugMsg(
set,
"solving LP: %d rows, %d cols, primalfeasible=%u, dualfeasible=%u, solved=%u, diving=%u, probing=%u, cutoffbnd=%g\n",
12453 needprimalray =
TRUE;
12455 || (
set->conf_enable &&
set->conf_useinflp !=
'o'));
12458 harditlim = (int)
MIN(itlim, INT_MAX);
12460 assert(harditlim == -1 || (resolveitlim <= harditlim));
12499 tightprimfeastol =
FALSE;
12500 tightdualfeastol =
FALSE;
12501 fromscratch =
FALSE;
12502 primalfeasible =
FALSE;
12503 dualfeasible =
FALSE;
12504 wasfromscratch = (stat->
nlps == 0);
12505 scaling =
set->lp_scaling;
12509 oldnlps = stat->
nlps;
12510 SCIP_CALL(
lpFlushAndSolve(lp, blkmem,
set, messagehdlr, stat, prob, eventqueue, resolveitlim, harditlim, needprimalray,
12511 needdualray, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12527 if(
set->lp_checkprimfeas )
12529 primalfeaspointer = &primalfeasible;
12535 primalfeasible =
TRUE;
12536 primalfeaspointer =
NULL;
12539 if(
set->lp_checkdualfeas )
12541 dualfeaspointer = &dualfeasible;
12547 dualfeasible =
TRUE;
12548 dualfeaspointer =
NULL;
12557 if( primalfeasible && dualfeasible && aging && !lp->
diving && stat->
nlps > oldnlps )
12561 if( stat->
nlps % ((
set->lp_rowagelimit+1)/2 + 1) == 0 )
12574 if( !primalfeasible || !dualfeasible )
12578 if( (fastmip > 0) && simplex )
12583 stat->
nnodes, stat->
nlps, primalfeasible, dualfeasible);
12587 else if( (!primalfeasible && !tightprimfeastol) || (!dualfeasible && !tightdualfeastol) )
12594 stat->
nnodes, stat->
nlps, primalfeasible, dualfeasible);
12595 tightprimfeastol = tightprimfeastol || !primalfeasible;
12596 tightdualfeastol = tightdualfeastol || !dualfeasible;
12599 else if( !fromscratch && !wasfromscratch && simplex )
12604 stat->
nnodes, stat->
nlps, primalfeasible, dualfeasible);
12605 fromscratch =
TRUE;
12616 SCIPsetDebugMsg(
set,
" -> LP objective value: %g + %g = %g (solstat=%d, cutoff=%g)\n",
12638 farkasvalid =
FALSE;
12643 farkasvalid =
TRUE;
12646 if( !farkasvalid && !(*
lperror) )
12650 if( (fastmip > 0) && simplex )
12661 else if( !tightdualfeastol )
12669 tightdualfeastol =
TRUE;
12672 else if( !fromscratch && simplex )
12680 fromscratch =
TRUE;
12698 if(
set->lp_checkprimfeas )
12710 primalfeasible =
TRUE;
12711 rayfeasible =
TRUE;
12718 SCIPsetDebugMsg(
set,
" -> LP has unbounded primal ray (primalfeas=%u, rayfeas=%u)\n",
12719 primalfeasible, rayfeasible);
12721 if( !primalfeasible || !rayfeasible )
12725 if( (fastmip > 0) && simplex )
12730 stat->
nnodes, stat->
nlps, primalfeasible, rayfeasible);
12734 else if( !tightprimfeastol )
12741 stat->
nnodes, stat->
nlps, primalfeasible, rayfeasible);
12742 tightprimfeastol =
TRUE;
12745 else if( !fromscratch && simplex )
12750 stat->
nnodes, stat->
nlps, primalfeasible, rayfeasible);
12751 fromscratch =
TRUE;
12754 else if( scaling > 0 )
12759 stat->
nnodes, stat->
nlps, primalfeasible, rayfeasible);
12805 char tmppricingchar;
12811 fromscratch =
FALSE;
12823 FALSE,
FALSE,
TRUE, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12845 if( !(*
lperror) && (fastmip > 0) && simplex )
12849 FALSE,
FALSE,
TRUE, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12864 SCIPsetDebugMsg(
set,
"unresolved error while resolving LP in order to exceed the objlimit\n");
12880 if(
set->lp_checkprimfeas )
12882 primalfeaspointer = &primalfeasible;
12888 primalfeasible =
TRUE;
12889 primalfeaspointer =
NULL;
12892 if(
set->lp_checkdualfeas )
12894 dualfeaspointer = &dualfeasible;
12900 dualfeasible =
TRUE;
12901 dualfeaspointer =
NULL;
12926 if( !primalfeasible || !dualfeasible
12936 SCIPsetDebugMsg(
set,
" -> LP objective value: %g + %g = %g (solstat=%d, cutoff=%g)\n",
12960 farkasvalid =
FALSE;
12965 farkasvalid =
TRUE;
12971 if( !tightprimfeastol )
12979 tightprimfeastol =
TRUE;
12990 fromscratch =
TRUE;
13008 if(
set->lp_checkprimfeas )
13020 primalfeasible =
TRUE;
13021 rayfeasible =
TRUE;
13030 if( !primalfeasible || !rayfeasible )
13068 SCIPmessagePrintWarning(messagehdlr,
"LP solver reached time limit, but SCIP time limit is not exceeded yet; "
13069 "you might consider switching the clock type of SCIP\n");
13095 SCIPsetDebugMsg(
set,
"resetting parameter SCIP_LPPARAM_FROMSCRATCH to FALSE %s\n", success ?
"" :
"failed");
13225 for( v = 0; v <
nvars; ++v )
13343 int pseudoobjvalinf;
13354 pseudoobjval -= oldbound *
obj;
13355 assert(pseudoobjvalinf >= 0);
13359 pseudoobjval += newbound *
obj;
13361 assert(pseudoobjvalinf >= 0);
13363 if( pseudoobjvalinf > 0 ||
set->nactivepricers > 0 )
13366 return pseudoobjval;
13382 int pseudoobjvalinf;
13408 assert(pseudoobjvalinf >= 0);
13420 assert(pseudoobjvalinf >= 0);
13422 if( pseudoobjvalinf > 0 ||
set->nactivepricers > 0 )
13425 return pseudoobjval;
13467 (*deltaval) = ub *
newobj;
13476 (*deltaval) = -lb *
oldobj;
13491 (*deltaval) = -lb *
oldobj;
13512 (*deltaval) = lb *
newobj;
13521 (*deltaval) = -ub *
oldobj;
13536 (*deltaval) = -ub *
oldobj;
13547 (*deltaval) = ub *
newobj;
13554 (*deltaval) = lb *
newobj;
13580 (*deltaval) = newlb *
obj;
13591 (*deltaval) = -oldlb *
obj;
13596 (*deltaval) =
obj * (newlb - oldlb);
13621 (*deltaval) = newub *
obj;
13632 (*deltaval) = -oldub *
obj;
13637 (*deltaval) =
obj * (newub - oldub);
13757 SCIPerrorMessage(
"LP was informed of an objective change of a non-active variable\n");
13849 if(
set->misc_exactsolve )
13930 if(
set->misc_exactsolve )
13998 if(
set->misc_exactsolve )
14193 if(
set->misc_exactsolve )
14317 if(
set->misc_exactsolve )
14386 if( primalfeasible ==
NULL )
14387 stillprimalfeasible =
FALSE;
14390 *primalfeasible =
TRUE;
14391 stillprimalfeasible =
TRUE;
14393 if( dualfeasible ==
NULL )
14394 stilldualfeasible =
FALSE;
14397 *dualfeasible =
TRUE;
14398 stilldualfeasible =
TRUE;
14418#ifdef SCIP_USE_LPSOLVER_ACTIVITY
14440 for(
c = 0;
c < nlpicols; ++
c )
14442 assert( 0 <= cstat[
c] && cstat[
c] < 4 );
14450 stillprimalfeasible =
FALSE;
14451 stilldualfeasible =
FALSE;
14460 if( stillprimalfeasible )
14462 stillprimalfeasible =
14465 primalbound += (lpicols[
c]->
primsol * lpicols[
c]->
obj);
14475 if( stilldualfeasible )
14480 if( stilldualfeasible )
14486 SCIPsetDebugMsg(
set,
" col <%s> [%.9g,%.9g]: primsol=%.9f, redcost=%.9f, pfeas=%u/%u(%u), dfeas=%d/%d(%u)\n",
14490 primalfeasible !=
NULL ? stillprimalfeasible :
TRUE,
14493 dualfeasible !=
NULL ? stilldualfeasible :
TRUE);
14507 if( stilldualfeasible
14510 if( stilldualfeasible
14514 SCIPsetDebugMsg(
set,
" col <%s> [%.9g,%.9g]: primsol=%.9f, redcost=%.9f, pfeas=%u/%u(%u), dfeas=%d/%d(%u)\n",
14518 primalfeasible !=
NULL ? stillprimalfeasible :
TRUE,
14521 dualfeasible !=
NULL ? stilldualfeasible :
TRUE);
14528 if( stilldualfeasible )
14531 dualbound += (lpicols[
c]->
redcost * lpicols[
c]->
lb);
14533 dualbound += (lpicols[
c]->
redcost * lpicols[
c]->
ub);
14538 for(
r = 0;
r < nlpirows; ++
r )
14540 assert( 0 <= rstat[
r] && rstat[
r] < 4 );
14542#ifdef SCIP_USE_LPSOLVER_ACTIVITY
14546 if( lpirows[
r]->validactivitylp != stat->
lpcount )
14551 if( stillprimalfeasible )
14553 stillprimalfeasible =
14565 if( stilldualfeasible )
14567 compslack =
MIN((lpirows[
r]->activity - lpirows[
r]->lhs), 1.0) * lpirows[
r]->
dualsol;
14570 if( stilldualfeasible )
14572 compslack =
MIN((lpirows[
r]->rhs - lpirows[
r]->activity), 1.0) * lpirows[
r]->
dualsol;
14576 SCIPsetDebugMsg(
set,
" row <%s> [%.9g,%.9g]: activity=%.9f, dualsol=%.9f, pfeas=%u/%u(%u), dfeas=%d/%d(%u)\n",
14577 lpirows[
r]->name, lpirows[
r]->lhs, lpirows[
r]->rhs, lpirows[
r]->activity, lpirows[
r]->dualsol,
14580 primalfeasible !=
NULL ? stillprimalfeasible :
TRUE,
14583 dualfeasible !=
NULL ? stilldualfeasible :
TRUE);
14591 if( stilldualfeasible &&
14594 if( stilldualfeasible &&
14598 SCIPsetDebugMsg(
set,
" row <%s> [%.9g,%.9g] + %.9g: activity=%.9f, dualsol=%.9f, pfeas=%u/%u(%u), dfeas=%d/%d(%u)\n",
14599 lpirows[
r]->name, lpirows[
r]->lhs, lpirows[
r]->rhs, lpirows[
r]->constant, lpirows[
r]->activity, lpirows[
r]->dualsol,
14602 primalfeasible !=
NULL ? stillprimalfeasible :
TRUE,
14605 dualfeasible !=
NULL ? stilldualfeasible :
TRUE);
14612 if( stilldualfeasible )
14646 if( primalfeasible !=
NULL )
14647 *primalfeasible = stillprimalfeasible;
14648 if( dualfeasible !=
NULL )
14649 *dualfeasible = stilldualfeasible;
14655#ifdef SCIP_USE_LPSOLVER_ACTIVITY
14696 if( primalfeasible !=
NULL )
14697 *primalfeasible =
TRUE;
14698 if( rayfeasible !=
NULL )
14699 *rayfeasible =
TRUE;
14709 SCIPerrorMessage(
"LP solver has no primal ray to prove unboundedness.\n");
14731 for(
c = 0;
c < nlpicols; ++
c )
14739 if( rayfeasible !=
NULL )
14741 *rayfeasible = *rayfeasible
14747 rayobjval += ray[
c] * col->
obj;
14770 for(
r = 0;
r < nlpirows; ++
r )
14781 col = row->
cols[
c];
14795 col = row->
cols[
c];
14798 if( col->
lppos >= 0 )
14816 if( primalfeasible !=
NULL )
14818 assert( *primalfeasible );
14819 for(
c = 0;
c < nlpicols; ++
c )
14829 *primalfeasible =
FALSE;
14837 for(
r = 0;
r < nlpirows; ++
r )
14850 col = row->
cols[
c];
14865 col = row->
cols[
c];
14868 if( col->
lppos >= 0 )
14877 if( primalfeasible !=
NULL && *primalfeasible )
14881 *primalfeasible =
FALSE;
14885 if( rayfeasible !=
NULL && *rayfeasible )
14889 *rayfeasible =
FALSE;
14893 activity[
r] = primact;
14896 if( primalfeasible !=
NULL && !(*primalfeasible) )
14901 else if( rayfeasible !=
NULL && !(*rayfeasible) )
14912 if( rayfeasible !=
NULL )
14913 *rayfeasible =
FALSE;
14919 assert(rayobjval != 0.0);
14926 for(
c = 0;
c < nlpicols; ++
c )
14931 rayscale =
MIN(rayscale, (lpicols[
c]->ub -
primsol[
c]) / ray[
c]);
14936 rayscale =
MIN(rayscale, 1.0 / ray[
c]);
14942 rayscale =
MIN(rayscale, (lpicols[
c]->lb -
primsol[
c]) / ray[
c]);
14947 rayscale =
MIN(rayscale, -1.0 / ray[
c]);
14955 SCIPsetDebugMsg(
set,
"unbounded LP solution: rayobjval=%f, rayscale=%f\n", rayobjval, rayscale);
14960 for(
c = 0;
c < nlpicols; ++
c )
14967 primsolval =
primsol[
c] + rayscale * ray[
c];
14975 for(
r = 0;
r < nlpirows; ++
r )
15032 for(
c = 0;
c < nlpicols;
c++ )
15087 farkascoefs =
NULL;
15112 for(
r = 0;
r < nlpirows; ++
r )
15133 SCIPsetDebugMsg(
set,
"farkas proof is invalid: row <%s>[lhs=%g,rhs=%g,c=%g] has multiplier %g\n",
15134 SCIProwGetName(lpirows[
r]), lpirows[
r]->lhs, lpirows[
r]->rhs, lpirows[
r]->constant, dualfarkas[
r]);
15150 for(
c = 0;
c < lpirows[
r]->
len;
c++ )
15157 assert(pos >= 0 && pos < nlpicols);
15159 farkascoefs[pos] += dualfarkas[
r] * lpirows[
r]->
vals[
c];
15163 if( dualfarkas[
r] > 0.0 )
15167 farkaslhs += dualfarkas[
r] * (lpirows[
r]->
lhs - lpirows[
r]->
constant);
15170 else if( dualfarkas[
r] < 0.0 )
15174 farkaslhs += dualfarkas[
r] * (lpirows[
r]->
rhs - lpirows[
r]->
constant);
15180 for(
c = 0;
c < nlpicols; ++
c )
15197 if( farkascoefs[
c] > 0.0 )
15210 SCIPsetDebugMsg(
set,
"farkas proof is invalid: maxactivity=%.12f, lhs=%.12f\n", maxactivity, farkaslhs);
15269 for(
c = 0;
c < nlpicols; ++
c )
15275 lpicols[
c]->
age = 0;
15280 for(
r = 0;
r < nlpirows; ++
r )
15285 if( lpirows[
r]->dualsol == 0.0 )
15292 lpirows[
r]->
age = 0;
15325 for(
c = 0;
c < ncols; ++
c )
15331 col->
lppos = coldstat[
c];
15332 if( coldstat[
c] == -1 )
15350 else if( coldstat[
c] <
c )
15354 lp->
cols[coldstat[
c]] = col;
15377 if( lp->
ncols < ncols )
15426 for(
r = 0;
r < nrows; ++
r )
15432 row->
lppos = rowdstat[
r];
15433 if( rowdstat[
r] == -1 )
15462 else if( rowdstat[
r] <
r )
15466 lp->
rows[rowdstat[
r]] = row;
15476 if( lp->
nrows < nrows )
15538 for(
c = firstcol;
c < ncols; ++
c )
15543 if( cols[
c]->removable
15544 && cols[
c]->obsoletenode != stat->
nnodes
15545 && cols[
c]->
age >
set->lp_colagelimit
15617 for(
r = firstrow;
r < nrows; ++
r )
15622 if( rows[
r]->removable
15623 && rows[
r]->obsoletenode != stat->
nnodes
15624 && rows[
r]->
age >
set->lp_rowagelimit
15631 rows[
r]->name, rows[
r]->activity, rows[
r]->lhs, rows[
r]->rhs);
15666 SCIPsetDebugMsg(
set,
"removing obsolete columns starting with %d/%d, obsolete rows starting with %d/%d\n",
15699 if( 0 < lp->
ncols )
15703 if( 0 < lp->
nrows )
15733 assert(0 <= firstcol && firstcol < lp->ncols);
15748 for(
c = firstcol;
c < ncols; ++
c )
15753 if( lpicols[
c]->removable
15806 assert(0 <= firstrow && firstrow < lp->nrows);
15823 for(
r = firstrow;
r < nrows; ++
r )
15871 cleanupcols = (root ?
set->lp_cleanupcolsroot :
set->lp_cleanupcols);
15872 cleanuprows = (root ?
set->lp_cleanuprowsroot :
set->lp_cleanuprows);
15874 SCIPsetDebugMsg(
set,
"removing unused columns starting with %d/%d (%u), unused rows starting with %d/%d (%u), LP algo: %d, basic sol: %u\n",
15910 cleanupcols = (root ?
set->lp_cleanupcolsroot :
set->lp_cleanupcols);
15911 cleanuprows = (root ?
set->lp_cleanuprowsroot :
set->lp_cleanuprows);
15913 SCIPsetDebugMsg(
set,
"removing all unused columns (%u) and rows (%u), LP algo: %d, basic sol: %u\n",
15916 if( cleanupcols && 0 < lp->
ncols )
15920 if( cleanuprows && 0 < lp->
nrows )
15987 SCIPsetDebugMsg(
set,
"removing %d/%d redundant basic rows from LP\n", ndelrows, nrows);
16025 SCIPsetDebugMsg(
set,
"diving started (LP flushed: %u, LP solved: %u, solstat: %d)\n",
16051 if( !
set->lp_resolverestore && lp->
solved )
16133 for( v = 0; v <
nvars; ++v )
16201 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, prob, -1LL,
FALSE,
FALSE,
FALSE, &
lperror) );
16213 "LP was not resolved to a sufficient status after diving\n");
16288#define DIVESTACKGROWFACT 1.5
16413 for( j = 0; j < lp->
nrows; ++j )
16442 for( j = 0; j < lp->
ncols; ++j )
16450 c = usefarkas ? 0.0 : col->
obj;
16517 *proved = (
bound > 0.0);
16519 SCIPsetDebugMsg(
set,
"proved Farkas value of LP: %g -> infeasibility %sproved\n",
bound, *proved ?
"" :
"not ");
16567 file = fopen(fname,
"w");
16577 SCIPmessageFPrintInfo(messagehdlr, file,
"\\ Original Variable and Constraint Names have been replaced by generic names.\n");
16580 SCIPmessageFPrintInfo(messagehdlr, file,
"\\ Warning: Variable and Constraint Names should not contain special characters like '+', '=' etc.\n");
16584 if( origobj && objoffset != 0.0 )
16586 SCIPmessageFPrintInfo(messagehdlr, file,
"\\ An artificial variable 'objoffset' has been added and fixed to 1.\n");
16587 SCIPmessageFPrintInfo(messagehdlr, file,
"\\ Switching this variable to 0 will disable the offset in the objective.\n\n");
16622 if( origobj && objoffset != 0.0 )
16660 if( strlen(rowname) > 0 )
16665 SCIPmessageFPrintInfo(messagehdlr, file,
"are not in a valid range. The following two constraints may be corrupted!\n");
16686 if( (j+1) % 10 == 0 )
16751 if( strlen(rowname) > 0 )
16756 SCIPmessageFPrintInfo(messagehdlr, file,
"are not in a valid range. The following two constraints may be corrupted!\n");
16777 if( (j+1) % 10 == 0 )
16828 if( origobj && objoffset != 0.0 )
16866#undef SCIPcolGetObj
16869#undef SCIPcolGetBestBound
16870#undef SCIPcolGetPrimsol
16871#undef SCIPcolGetMinPrimsol
16872#undef SCIPcolGetMaxPrimsol
16873#undef SCIPcolGetBasisStatus
16874#undef SCIPcolGetVar
16875#undef SCIPcolGetIndex
16876#undef SCIPcolGetVarProbindex
16877#undef SCIPcolIsIntegral
16878#undef SCIPcolIsRemovable
16879#undef SCIPcolGetLPPos
16880#undef SCIPcolGetLPDepth
16881#undef SCIPcolIsInLP
16882#undef SCIPcolGetNNonz
16883#undef SCIPcolGetNLPNonz
16884#undef SCIPcolGetRows
16885#undef SCIPcolGetVals
16886#undef SCIPcolGetStrongbranchNode
16887#undef SCIPcolGetNStrongbranchs
16888#undef SCIPcolGetAge
16889#undef SCIPboundtypeOpposite
16890#undef SCIProwGetNNonz
16891#undef SCIProwGetNLPNonz
16892#undef SCIProwGetCols
16893#undef SCIProwGetVals
16894#undef SCIProwGetConstant
16895#undef SCIProwGetNorm
16896#undef SCIProwGetSumNorm
16897#undef SCIProwGetLhs
16898#undef SCIProwGetRhs
16899#undef SCIProwGetDualsol
16900#undef SCIProwGetDualfarkas
16901#undef SCIProwGetBasisStatus
16902#undef SCIProwGetName
16903#undef SCIProwGetIndex
16904#undef SCIProwGetAge
16905#undef SCIProwGetRank
16906#undef SCIProwIsIntegral
16907#undef SCIProwIsLocal
16908#undef SCIProwIsModifiable
16909#undef SCIProwIsRemovable
16910#undef SCIProwGetOrigintype
16911#undef SCIProwGetOriginCons
16912#undef SCIProwGetOriginConshdlr
16913#undef SCIProwGetOriginSepa
16914#undef SCIProwIsInGlobalCutpool
16915#undef SCIProwGetLPPos
16916#undef SCIProwGetLPDepth
16917#undef SCIProwIsInLP
16918#undef SCIProwGetActiveLPCount
16919#undef SCIProwGetNLPsAfterCreation
16920#undef SCIProwChgRank
16921#undef SCIPlpGetCols
16922#undef SCIPlpGetNCols
16923#undef SCIPlpGetRows
16924#undef SCIPlpGetNRows
16925#undef SCIPlpGetNewcols
16926#undef SCIPlpGetNNewcols
16927#undef SCIPlpGetNewrows
16928#undef SCIPlpGetNNewrows
16929#undef SCIPlpGetObjNorm
16930#undef SCIPlpGetRootObjval
16931#undef SCIPlpGetRootColumnObjval
16932#undef SCIPlpGetRootLooseObjval
16934#undef SCIPlpSetIsRelax
16935#undef SCIPlpIsRelax
16936#undef SCIPlpIsSolved
16937#undef SCIPlpIsSolBasic
16939#undef SCIPlpDivingObjChanged
16940#undef SCIPlpMarkDivingObjChanged
16941#undef SCIPlpUnmarkDivingObjChanged
16942#undef SCIPlpDivingRowsChanged
16943#undef SCIPlpIsFeasEQ
16944#undef SCIPlpIsFeasLT
16945#undef SCIPlpIsFeasLE
16946#undef SCIPlpIsFeasGT
16947#undef SCIPlpIsFeasGE
16948#undef SCIPlpIsFeasZero
16949#undef SCIPlpIsFeasPositive
16950#undef SCIPlpIsFeasNegative
16989 if( col->
obj >= 0.0 )
17002 if( col->
lppos >= 0 )
17122 return (col->
lppos >= 0);
17318 if( row->
lppos >= 0 )
17331 if( row->
lppos >= 0 )
17530 return (row->
lppos >= 0);
17599 nlpcols = lp->
ncols;
17602 for(
c = 0;
c < nlpcols; ++
c )
17604 if( lpcols[
c]->ub - lpcols[
c]->lb >
eps )
17608 return nunfixedcols;
17691 for(
c = lp->
ncols - 1;
c >= 0; --
c )
17945 SCIPmessagePrintWarning(messagehdlr,
"Could not set feasibility tolerance of LP solver for relative interior point computation.\n");
17953 SCIPmessagePrintWarning(messagehdlr,
"Could not set dual feasibility tolerance of LP solver for relative interior point computation.\n");
17958 nnewcols = 3*lp->
ncols + 2*lp->
nrows + (inclobjcutoff ? 1 : 0) + 1;
17964 for( j = 0; j < lp->
ncols; ++j )
17974 nnewcols = lp->
ncols;
17975 obj[nnewcols] = 0.0;
17976 lb[nnewcols] = 1.0;
18000 ntotnonz += row->
nlpcols + 1;
18010 lb[nnewcols] = 0.0;
18011 ub[nnewcols] = 1.0;
18012 obj[nnewcols++] = 1.0;
18013 ntotnonz += row->
nlpcols + 2;
18016 ntotnonz += row->
nlpcols + 1;
18023 lb[nnewcols] = 0.0;
18024 ub[nnewcols] = 1.0;
18025 obj[nnewcols++] = 1.0;
18026 ntotnonz += row->
nlpcols + 2;
18029 ntotnonz += row->
nlpcols + 1;
18036 if( inclobjcutoff && relaxrows )
18039 lb[nnewcols] = 0.0;
18040 ub[nnewcols] = 1.0;
18041 obj[nnewcols++] = 1.0;
18042 ntotnonz += lp->
ncols + 2;
18047 for( j = 0; j < lp->
ncols; ++j )
18065 lb[nnewcols] = 0.0;
18066 ub[nnewcols] = 1.0;
18067 obj[nnewcols++] = 1.0;
18073 lb[nnewcols] = 0.0;
18074 ub[nnewcols] = 1.0;
18075 obj[nnewcols++] = 1.0;
18082 nslacks = nnewcols - lp->
ncols - 1;
18084 assert( nnewcols <= 3*lp->ncols + 2*lp->
nrows + (inclobjcutoff ? 1 : 0) + 1 );
18126 assert( nnonz <= lp->ncols );
18127 rowcols = row->
cols;
18128 rowvals = row->
vals;
18134 matbeg[matrowidx] = matidx;
18135 for( j = 0; j < nnonz; ++j )
18138 assert( 0 <= rowcols[j]->lppos && rowcols[j]->lppos < lp->ncols );
18141 matinds[matidx] = rowcols[j]->
lppos;
18142 matvals[matidx++] = rowvals[j];
18143 assert( matidx <= ntotnonz );
18149 matinds[matidx] = lp->
ncols;
18150 matvals[matidx++] = -rhs;
18151 assert( matidx <= ntotnonz );
18154 matlhs[matrowidx] = 0.0;
18155 matrhs[matrowidx++] = 0.0;
18156 assert( matrowidx <= ntotrows );
18169 matbeg[matrowidx] = matidx;
18170 for( j = 0; j < nnonz; ++j )
18173 assert( 0 <= rowcols[j]->lppos && rowcols[j]->lppos < lp->ncols );
18176 matinds[matidx] = rowcols[j]->
lppos;
18177 matvals[matidx++] = rowvals[j];
18178 assert( matidx <= ntotnonz );
18184 matinds[matidx] = lp->
ncols;
18185 matvals[matidx++] = -lhs;
18186 assert( matidx <= ntotnonz );
18192 matvals[matidx] = -
MAX(1.0, lhs);
18193 matinds[matidx++] = lp->
ncols + 1 + cnt;
18194 assert( matidx <= ntotnonz );
18198 matlhs[matrowidx] = 0.0;
18200 assert( matrowidx <= ntotrows );
18207 matbeg[matrowidx] = matidx;
18208 for( j = 0; j < nnonz; ++j )
18211 assert( 0 <= rowcols[j]->lppos && rowcols[j]->lppos < lp->ncols );
18214 matinds[matidx] = rowcols[j]->
lppos;
18215 matvals[matidx++] = rowvals[j];
18216 assert( matidx <= ntotnonz );
18222 matinds[matidx] = lp->
ncols;
18223 matvals[matidx++] = -rhs;
18224 assert( matidx <= ntotnonz );
18230 matvals[matidx] =
MAX(1.0, absrhs);
18231 matinds[matidx++] = lp->
ncols + 1 + cnt;
18236 matrhs[matrowidx++] = 0.0;
18237 assert( matrowidx <= ntotrows );
18243 if( inclobjcutoff )
18252 matbeg[matrowidx] = matidx;
18253 for( j = 0; j < lp->
ncols; ++j )
18262 matvals[matidx++] = lp->
cols[j]->
obj;
18263 assert( matidx <= ntotnonz );
18272 matinds[matidx] = lp->
ncols;
18273 matvals[matidx++] = -rhs;
18274 assert( matidx <= ntotnonz );
18282 matvals[matidx] =
MAX(1.0, absrhs);
18283 matinds[matidx++] = lp->
ncols + 1 + cnt;
18284 assert( matidx <= ntotnonz );
18288 matrhs[matrowidx++] = 0.0;
18289 assert( matrowidx <= ntotrows );
18293 for( j = 0; j < lp->
ncols; ++j )
18307 matbeg[matrowidx] = matidx;
18309 matinds[matidx] = j;
18310 matvals[matidx++] = 1.0;
18311 assert( matidx <= ntotnonz );
18316 matinds[matidx] = lp->
ncols;
18317 matvals[matidx++] = -col->
ub;
18318 assert( matidx <= ntotnonz );
18321 matlhs[matrowidx] = 0.0;
18322 matrhs[matrowidx++] = 0.0;
18323 assert( matrowidx <= ntotrows );
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->
lb;
18346 assert( matidx <= ntotnonz );
18350 matvals[matidx] = -
MAX(1.0, abscollb);
18351 matinds[matidx++] = lp->
ncols + 1 + cnt;
18352 assert( matidx <= ntotnonz );
18355 matlhs[matrowidx] = 0.0;
18357 assert( matrowidx <= ntotrows );
18364 matbeg[matrowidx] = matidx;
18366 matinds[matidx] = j;
18367 matvals[matidx++] = 1.0;
18368 assert( matidx <= ntotnonz );
18373 matinds[matidx] = lp->
ncols;
18374 matvals[matidx++] = -col->
ub;
18375 assert( matidx <= ntotnonz );
18379 matvals[matidx] =
MAX(1.0, abscolub);
18380 matinds[matidx++] = lp->
ncols + 1 + cnt;
18381 assert( matidx <= ntotnonz );
18385 matrhs[matrowidx++] = 0.0;
18386 assert( matrowidx <= ntotrows );
18389 assert( cnt == nslacks );
18390 assert( matrowidx == ntotrows );
18409 assert( ncols == nnewcols );
18420 SCIPmessagePrintWarning(messagehdlr,
"Could not set time limit of LP solver for relative interior point computation.\n");
18429 SCIPmessagePrintWarning(messagehdlr,
"Could not set iteration limit of LP solver for relative interior point computation.\n");
18455 for( j = 0; j < lp->
ncols; ++j )
18456 point[j] = primal[j]/
alpha;
18480 assert( nnonz <= lp->ncols );
18481 rowcols = row->
cols;
18482 rowvals = row->
vals;
18485 for( j = 0; j < nnonz; ++j )
18486 sum += rowvals[j] * primal[rowcols[j]->lppos];
18510 if( inclobjcutoff )
18519 for( j = 0; j < lp->
ncols; ++j )
18528 for( j = 0; j < lp->
ncols; ++j )
18627 if ( timelimit <= 0.0 || iterlimit <= 0 )
18633 if( lp->
ncols == 0 )
18638 inclobjcutoff =
FALSE;
18643 if( lp->
nrows == 0 && !inclobjcutoff )
18656 retcode =
computeRelIntPoint(lpi,
set, messagehdlr, lp, prob, relaxrows, inclobjcutoff, timelimit, iterlimit, point, success);
18699 int nfixedcols = 0;
18700 int nalreadyfixedcols = 0;
18701 int nfixedrows = 0;
18703 int nimplicitfixedrows = 0;
18708 int nbasicequalities = 0;
18716 for(
c = ncols - 1 ;
c >= 0; --
c )
18729 ++nalreadyfixedcols;
18734 for(
r = nrows - 1;
r >= 0; --
r )
18767 ++nimplicitfixedrows;
18773 ++nbasicequalities;
18775 assert(nfixedcols + nfixedrows <= ncols + nineq + nbasicequalities - nrows - nalreadyfixedcols - nimplicitfixedrows);
18777 if( ncols + nineq - nrows + nbasicequalities - nalreadyfixedcols > 0 )
18778 lp->
degeneracy = 1.0 - 1.0 * (nfixedcols + nfixedrows) / (ncols + nineq - nrows + nbasicequalities - nalreadyfixedcols);
18783 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 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)
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 SCIPlpGetDualfarkas(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool *valid)
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)
SCIP_RETCODE SCIPlpSolveAndEval(SCIP_LP *lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_Longint itlim, SCIP_Bool limitresolveiters, SCIP_Bool aging, SCIP_Bool keepsol, SCIP_Bool *lperror)
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
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