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 )
500 SCIP_Longint validlp,
511 if( storedsolvals !=
NULL )
584 SCIP_Longint validlp,
585 SCIP_Bool freebuffer,
596 if( storedsolvals !=
NULL )
639 if( num > row->
size )
656#ifdef SCIP_MORE_DEBUG
657static SCIP_Bool msgdisp_checkrow =
FALSE;
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)
1559static SCIP_Bool msgdisp_checklinks =
FALSE;
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;
1913 SCIP_Bool updateidxvals
1928 if( col->
lppos >= 0 )
1990 SCIP_Bool forcenormupdate,
1991 SCIP_Bool updateindex,
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) (set->lp_disablecutoff == 1 || ((set->nactivepricers > 0 || !SCIPprobAllColsInLP(prob, set, lp)) && set->lp_disablecutoff == 2))
2683 SCIP_Real actualobjlim;
2722 SCIP_Real actualfeastol;
2726 if( lp->
nrows > 0 && actualfeastol < lp->lpifeastol )
2750 SCIP_Real dualfeastol,
2755 assert(dualfeastol >= 0.0);
2765 SCIP_Real actualdualfeastol;
2769 if( lp->
nrows > 0 && actualdualfeastol < lp->lpidualfeastol )
2793 SCIP_Real barrierconvtol,
2798 assert(barrierconvtol >= 0.0);
2808 SCIP_Real actualbarrierconvtol;
2812 if( lp->
nrows > 0 && actualbarrierconvtol < lp->lpibarrierconvtol
2837 SCIP_Bool fromscratch,
2868 assert(0 <= fastmip && fastmip <= 1);
2943 SCIP_Bool presolving,
2968 SCIP_Real rowrepswitch,
3057 switch( pricingchar )
3117 SCIP_Real condlimit,
3142 SCIP_Real threshhold,
3183 lptiming = (int) timing;
3210 if( randomseed == 0 )
3231 SCIP_Bool polishing,
3309 for(
i = 0;
i < len; ++
i )
3313 (*col)->linkpos[
i] = -1;
3318 (*col)->rows =
NULL;
3319 (*col)->vals =
NULL;
3320 (*col)->linkpos =
NULL;
3328 (*col)->flushedobj = 0.0;
3329 (*col)->flushedlb = 0.0;
3330 (*col)->flushedub = 0.0;
3331 (*col)->index = stat->
ncolidx;
3335 (*col)->nlprows = 0;
3336 (*col)->nunlinked = len;
3338 (*col)->lpipos = -1;
3339 (*col)->lpdepth = -1;
3340 (*col)->primsol = 0.0;
3343 (*col)->minprimsol = (*col)->ub;
3344 (*col)->maxprimsol = (*col)->lb;
3349 (*col)->sbnode = -1;
3350 (*col)->validredcostlp = -1;
3351 (*col)->validfarkaslp = -1;
3352 (*col)->validsblp = -1;
3353 (*col)->sbitlim = -1;
3354 (*col)->nsbcalls = 0;
3356 (*col)->obsoletenode = -1;
3359 (*col)->lprowssorted =
TRUE;
3360 (*col)->nonlprowssorted = (len <= 1);
3361 (*col)->objchanged =
FALSE;
3362 (*col)->lbchanged =
FALSE;
3363 (*col)->ubchanged =
FALSE;
3364 (*col)->coefchanged =
FALSE;
3366 (*col)->removable = removable;
3367 (*col)->sbdownvalid =
FALSE;
3368 (*col)->sbupvalid =
FALSE;
3371 (*col)->storedsolvals =
NULL;
3390 assert(&(*col)->var->data.col == col);
3391 assert((*col)->lppos == -1);
3392 assert((*col)->lpipos == -1);
3424 for(
r = 0;
r < col->
len; ++
r )
3492 assert(0 <= pos && pos < col->len);
3542 assert(0 <= pos && pos < col->len);
3596 assert(0 <= pos && pos < col->len);
3867 redcost -= col->
vals[
i] * dualsol[row->
lppos];
3877 if( row->
lppos >= 0 )
3878 redcost -= col->
vals[
i] * dualsol[row->
lppos];
3930 if( row->
lppos >= 0 )
4032 SCIP_Real* dualfarkas
4050 farkas += col->
vals[
i] * dualfarkas[row->
lppos];
4060 if( row->
lppos >= 0 )
4061 farkas += col->
vals[
i] * dualfarkas[row->
lppos];
4113 if( row->
lppos >= 0 )
4167 SCIP_Real farkascoef;
4173 if( farkascoef > 0.0 )
4174 return col->
ub * farkascoef;
4176 return col->
lb * farkascoef;
4219 SCIP_Bool sbdownvalid,
4220 SCIP_Bool sbupvalid,
4307 SCIP_Bool updatecol,
4308 SCIP_Bool updatestat,
4311 SCIP_Bool* downvalid,
4320 SCIP_Bool sbdownvalid;
4321 SCIP_Bool sbupvalid;
4322 SCIP_Longint validsblp;
4324 SCIP_Real sblpobjval;
4325 SCIP_Longint sbnode;
4363 validsblp = stat->
nlps;
4374 sbdownvalid =
FALSE;
4382 SCIPsetDebugMsg(
set,
"performing strong branching on variable <%s>(%g) with %d iterations\n",
4409 sbdownvalid =
FALSE;
4418 SCIP_Real looseobjval;
4438 if( iter/2 >= itlim )
4461 if( downvalid !=
NULL )
4462 *downvalid = sbdownvalid;
4463 if( upvalid !=
NULL )
4464 *upvalid = sbupvalid;
4495 SCIP_Bool* downvalid,
4505 SCIP_Bool* sbdownvalid;
4506 SCIP_Bool* sbupvalid;
4507 SCIP_Real* primsols;
4547 for( j = 0; j < ncols; ++j )
4578 if( downvalid !=
NULL )
4580 if( upvalid !=
NULL )
4588 lpipos[nsubcols] = col->
lpipos;
4589 primsols[nsubcols] = col->
primsol;
4591 subidx[nsubcols] = j;
4592 subcols[nsubcols++] = col;
4596 SCIPsetDebugMsg(
set,
"performing strong branching on %d variables with %d iterations\n", ncols, itlim);
4609 for( j = 0; j < nsubcols; ++j )
4627 up[idx] = col->
sbup;
4628 if( downvalid !=
NULL )
4630 if( upvalid !=
NULL )
4636 SCIP_Real looseobjval;
4643 for( j = 0; j < nsubcols; ++j )
4660 up[idx] = col->
sbup;
4661 if( downvalid !=
NULL )
4663 if( upvalid !=
NULL )
4676 if( iter/2 >= itlim )
4711 SCIP_Bool* downvalid,
4725 if( downvalid !=
NULL )
4727 if( upvalid !=
NULL )
4729 if( solval !=
NULL )
4731 if( lpobjval !=
NULL )
4852 for(
i = 0;
i < row->
len; ++
i )
4915 sval = val * scalar;
4916 downval = floor(sval);
4921 if( intval !=
NULL )
4927 if( intval !=
NULL )
4948 SCIP_Bool integralcontvars,
4950 SCIP_Real minrounddelta,
4952 SCIP_Real maxrounddelta
4964 SCIP_Bool mindeltainf;
4965 SCIP_Bool maxdeltainf;
4973 assert(-1.0 < minrounddelta && minrounddelta <= 0.0);
4974 assert(0.0 <= maxrounddelta && maxrounddelta < 1.0);
4976 SCIPsetDebugMsg(
set,
"scale row <%s> with %g (tolerance=[%g,%g])\n", row->
name, scaleval, minrounddelta, maxrounddelta);
4980 mindeltainf =
FALSE;
4981 maxdeltainf =
FALSE;
5010 newval = val * scaleval;
5012 &&
isIntegralScalar(val, scaleval, minrounddelta, maxrounddelta, &intval) )
5016 if( intval < newval )
5018 mindelta += (intval - newval)*ub;
5019 maxdelta += (intval - newval)*lb;
5025 mindelta += (intval - newval)*lb;
5026 maxdelta += (intval - newval)*ub;
5048 if( oldlen != row->
len )
5071 newval = (row->
lhs - row->
constant) * scaleval + mindelta;
5083 newval = (row->
rhs - row->
constant) * scaleval + maxdelta;
5124 SCIP_Bool modifiable,
5141 (*row)->integral =
TRUE;
5152 for(
i = 0;
i < len; ++
i )
5158 (*row)->cols_index[
i] = cols[
i]->
index;
5159 (*row)->linkpos[
i] = -1;
5167 (*row)->integral =
FALSE;
5173 (*row)->cols =
NULL;
5174 (*row)->cols_index =
NULL;
5175 (*row)->vals =
NULL;
5176 (*row)->linkpos =
NULL;
5180 (*row)->constant = 0.0;
5185 (*row)->sqrnorm = 0.0;
5186 (*row)->sumnorm = 0.0;
5187 (*row)->objprod = 0.0;
5188 (*row)->maxval = 0.0;
5190 (*row)->dualsol = 0.0;
5192 (*row)->dualfarkas = 0.0;
5196 (*row)->origin = origin;
5197 (*row)->eventfilter =
NULL;
5198 (*row)->index = stat->
nrowidx;
5202 (*row)->nlpcols = 0;
5203 (*row)->nunlinked = len;
5206 (*row)->lpipos = -1;
5207 (*row)->lpdepth = -1;
5208 (*row)->minidx = INT_MAX;
5209 (*row)->maxidx = INT_MIN;
5210 (*row)->nummaxval = 0;
5211 (*row)->numminval = 0;
5212 (*row)->numintcols = -1;
5213 (*row)->validactivitylp = -1;
5214 (*row)->validpsactivitydomchg = -1;
5215 (*row)->validactivitybdsdomchg = -1;
5216 (*row)->nlpsaftercreation = 0L;
5217 (*row)->activeinlpcounter = 0L;
5220 (*row)->obsoletenode = -1;
5221 (*row)->fromcutpool =
FALSE;
5223 (*row)->lpcolssorted =
TRUE;
5224 (*row)->nonlpcolssorted = (len <= 1);
5225 (*row)->delaysort =
FALSE;
5226 (*row)->validminmaxidx =
FALSE;
5227 (*row)->lhschanged =
FALSE;
5228 (*row)->rhschanged =
FALSE;
5229 (*row)->coefchanged =
FALSE;
5230 (*row)->local = local;
5231 (*row)->modifiable = modifiable;
5233 (*row)->origintype = origintype;
5234 (*row)->removable = removable;
5235 (*row)->inglobalcutpool =
FALSE;
5236 (*row)->storedsolvals =
NULL;
5269 assert((*row)->nuses == 0);
5270 assert((*row)->lppos == -1);
5321 for(
i = 0;
i < row->
len; ++
i )
5362 assert((*row)->nuses >= 1);
5363 assert((*row)->nlocks < (
unsigned int)((*row)->nuses));
5365 SCIPsetDebugMsg(
set,
"release row <%s> with nuses=%d and nlocks=%u\n", (*row)->name, (*row)->nuses, (*row)->nlocks);
5367 if( (*row)->nuses == 0 )
5455 assert(0 <= pos && pos < row->len);
5506 assert(0 <= pos && pos < row->len);
5560 assert(0 <= pos && pos < row->len);
5604 SCIP_Real oldconstant;
5743static const SCIP_Real
scalars[] = {3.0, 5.0, 7.0, 9.0, 11.0, 13.0, 15.0, 17.0, 19.0};
5752 SCIP_Longint maxdnom,
5754 SCIP_Bool usecontvars,
5755 SCIP_Real* intscalar,
5764 SCIP_Longint nominator;
5765 SCIP_Longint denominator;
5770 SCIP_Real twomultval;
5790 if( intscalar !=
NULL )
5796 for(
c = 0;
c < row->
len; ++
c )
5808 if( val < mindelta || val > maxdelta )
5811 minval =
MIN(minval, absval);
5817 if( intscalar !=
NULL )
5824 assert(minval >
MIN(-mindelta, maxdelta));
5831 scaleval = 1.0/minval;
5832 scalable = (scaleval <= maxscale);
5833 for(
c = 0;
c < row->
len && scalable; ++
c )
5842 while( scaleval <= maxscale
5856 scalable = (scaleval <= maxscale);
5857 SCIPsetDebugMsg(
set,
" -> val=%g, scaleval=%g, val*scaleval=%g, scalable=%u\n", val, scaleval, val*scaleval, scalable);
5864 assert(scaleval <= maxscale);
5865 if( intscalar !=
NULL )
5866 *intscalar = scaleval;
5868 SCIPsetDebugMsg(
set,
" -> integrality can be achieved by scaling with %g (minval=%g)\n", scaleval, minval);
5875 twomult = (twomultval <= maxscale);
5876 for(
c = 0;
c < row->
len && twomult; ++
c )
5885 while( twomultval <= maxscale
5886 && (absval * twomultval < 0.5 || !
isIntegralScalar(val, twomultval, mindelta, maxdelta,
NULL)) )
5899 twomult = (twomultval <= maxscale);
5901 val, twomultval, val*twomultval, twomult);
5906 assert(twomultval <= maxscale);
5907 if( intscalar !=
NULL )
5908 *intscalar = twomultval;
5910 SCIPsetDebugMsg(
set,
" -> integrality can be achieved by scaling with %g (power of 2)\n", twomultval);
5920 rational = (maxdnom > 1);
5923 for(
c = 0;
c < row->
len && rational; ++
c )
5928 rational =
SCIPrealToRational(val, mindelta, maxdelta, maxdnom, &nominator, &denominator);
5929 if( rational && nominator != 0 )
5932 gcd =
ABS(nominator);
5936 val, nominator, denominator, gcd, scm, rational);
5943 for( ++
c;
c < row->
len && rational; ++
c )
5948 rational =
SCIPrealToRational(val, mindelta, maxdelta, maxdnom, &nominator, &denominator);
5949 if( rational && nominator != 0 )
5956 val, nominator, denominator, gcd, scm, rational);
5964 assert((SCIP_Real)scm/(SCIP_Real)gcd <= maxscale);
5965 if( intscalar !=
NULL )
5966 *intscalar = (
SCIP_Real)scm/(SCIP_Real)gcd;
5969 (SCIP_Real)scm/(SCIP_Real)gcd, scm, gcd);
5990 SCIP_Longint maxdnom,
5992 SCIP_Bool usecontvars,
5996 SCIP_Real intscalar;
6002 &intscalar, success) );
6007 SCIP_CALL(
rowScale(row, blkmem,
set, eventqueue, stat, lp, intscalar, usecontvars, mindelta, maxdelta) );
6028#ifdef SCIP_MORE_DEBUG
6088 for( s = 1; s < row->
len; ++s )
6093 if( cols[s] == cols[t] )
6110 cols_index[t] = cols_index[s];
6136 for(
i = 0;
i < row->
len; ++
i )
6140 for( j =
i+1; j < row->
len; ++j )
6202 if( col->
lppos >= 0 )
6247 activity =
MAX(activity, -inf);
6248 activity =
MIN(activity, +inf);
6267 return MIN(row->
rhs - activity, activity - row->
lhs);
6306 if ( col->
lppos >= 0 )
6326 activity =
MAX(activity, -inf);
6327 activity =
MIN(activity, +inf);
6329 return MIN(row->
rhs - activity, activity - row->
lhs);
6368 if ( col->
lppos >= 0 )
6388 activity =
MAX(activity, -inf);
6389 activity =
MIN(activity, +inf);
6391 return MIN(row->
rhs - activity, activity - row->
lhs);
6407 for(
i = 0;
i < row->
len; ++
i )
6443 activity =
MAX(activity, -inf);
6444 activity =
MIN(activity, +inf);
6456 SCIP_Real pseudoactivity;
6462 return MIN(row->
rhs - pseudoactivity, pseudoactivity - row->
lhs);
6482 for(
i = 0;
i < row->
len; ++
i )
6491 solval = (row->
vals[
i] >= 0.0 ? col->
lb : col->
ub);
6493 solval = (row->
vals[
i] >= 0.0 ? col->
ub : col->
lb);
6495 solval = (col->
lb + col->
ub)/2.0;
6497 activity += row->
vals[
i] * solval;
6501 activity =
MAX(activity, -inf);
6502 activity =
MIN(activity, +inf);
6521 return MIN(row->
rhs - activity, activity - row->
lhs);
6534 SCIP_Bool mininfinite;
6535 SCIP_Bool maxinfinite;
6543 mininfinite =
FALSE;
6544 maxinfinite =
FALSE;
6547 for(
i = 0;
i < row->
len && (!mininfinite || !maxinfinite); ++
i )
6652 SCIP_Real minactivity;
6660 SCIP_Real maxactivity;
6759 SCIP_Real solcutoffdist;
6766 SCIP_Real scale = 0.0;
6773 for( k = 0; k < lp->
ncols; ++k )
6782 scale = 1.0 / sqrt(scale);
6784 for( k = 0; k < lp->
ncols; ++k )
6789 solcutoffdist = 0.0;
6790 for( k = 0; k < row->
nlpcols; ++k )
6793 for( k = row->
nlpcols; k < row->len; ++k )
6800 solcutoffdist =
set->num_sumepsilon;
6804 return solcutoffdist;
6816 SCIP_Real feasibility;
6821 switch(
set->sepa_efficacynorm )
6833 norm = (row->
len == 0 ? 0.0 : 1.0);
6845 return -feasibility / norm;
6873 SCIP_Real feasibility;
6878 switch(
set->sepa_efficacynorm )
6890 norm = (row->
len == 0 ? 0.0 : 1.0);
6902 return -feasibility / norm;
6931 SCIP_Real feasibility;
6936 switch(
set->sepa_efficacynorm )
6948 norm = (row->
len == 0 ? 0.0 : 1.0);
6960 return -feasibility / norm;
6971 SCIP_Real feasibility;
6976 switch(
set->sepa_efficacynorm )
6988 norm = (row->
len == 0 ? 0.0 : 1.0);
7000 return -feasibility / norm;
7013 SCIP_Real scalarprod;
7074 while( i1 < row1->nlpcols && i2 < row2->len )
7089 while( i1 < row1->len && i2 < row2->nlpcols )
7121 while( i1 >= 0 && i2 >= 0 )
7125 assert((row1->
cols[i1] == row2->
cols[i2]) == (row1colsidx[i1] == row2colsidx[i2]));
7126 if( row1colsidx[i1] < row2colsidx[i2] )
7128 else if( row1colsidx[i1] > row2colsidx[i2] )
7132 scalarprod += row1->
vals[i1] * row2->
vals[i2];
7160 while( ilp1 < row1->nlpcols && inlp1 < row1->len && ilp2 < row2->nlpcols && inlp2 < row2->len )
7166 assert((row1->
cols[ilp1] == row2->
cols[ilp2]) == (row1colsidx[ilp1] == row2colsidx[ilp2]));
7167 assert((row1->
cols[ilp1] == row2->
cols[inlp2]) == (row1colsidx[ilp1] == row2colsidx[inlp2]));
7168 assert((row1->
cols[inlp1] == row2->
cols[ilp2]) == (row1colsidx[inlp1] == row2colsidx[ilp2]));
7169 assert((row1->
cols[inlp1] == row2->
cols[inlp2]) == (row1colsidx[inlp1] == row2colsidx[inlp2]));
7172 if( row1colsidx[ilp1] == row2colsidx[ilp2] )
7174 scalarprod += row1->
vals[ilp1] * row2->
vals[ilp2];
7179 else if( row1colsidx[ilp1] == row2colsidx[inlp2] )
7181 scalarprod += row1->
vals[ilp1] * row2->
vals[inlp2];
7186 else if( row1colsidx[inlp1] == row2colsidx[ilp2] )
7188 scalarprod += row1->
vals[inlp1] * row2->
vals[ilp2];
7193 else if( row1colsidx[inlp1] == row2colsidx[inlp2] && row1->
cols[inlp1]->
lppos >= 0 )
7195 scalarprod += row1->
vals[inlp1] * row2->
vals[inlp2];
7200 else if( row1colsidx[ilp1] < row1colsidx[inlp1] )
7202 if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7204 if( row1colsidx[ilp1] < row2colsidx[ilp2] )
7211 if( row1colsidx[ilp1] < row2colsidx[inlp2] )
7219 if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7221 if( row1colsidx[inlp1] < row2colsidx[ilp2] )
7228 if( row1colsidx[inlp1] < row2colsidx[inlp2] )
7240 if( ilp1 != row1->
nlpcols && inlp1 != row1->
len )
7278 while( i1 < end1 && ilp2 < row2->nlpcols && inlp2 < row2->len )
7283 assert((row1->
cols[i1] == row2->
cols[ilp2]) == (row1colsidx[i1] == row2colsidx[ilp2]));
7284 assert((row1->
cols[i1] == row2->
cols[inlp2]) == (row1colsidx[i1] == row2colsidx[inlp2]));
7287 if( row1colsidx[i1] == row2colsidx[ilp2] )
7289 scalarprod += row1->
vals[i1] * row2->
vals[ilp2];
7294 else if( row1colsidx[i1] == row2colsidx[inlp2] && (lpcols || row1->
cols[i1]->
lppos >= 0) )
7296 scalarprod += row1->
vals[i1] * row2->
vals[inlp2];
7301 else if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7303 if( row1colsidx[i1] < row2colsidx[ilp2] )
7310 if( row1colsidx[i1] < row2colsidx[inlp2] )
7338 while( i1 < end1 && i2 < end2 )
7342 assert((row1->
cols[i1] == row2->
cols[i2]) == (row1colsidx[i1] == row2colsidx[i2]));
7345 if( row1colsidx[i1] == row2colsidx[i2] && (lpcols || row1->
cols[i1]->
lppos >= 0) )
7347 scalarprod += row1->
vals[i1] * row2->
vals[i2];
7352 else if( row1colsidx[i1] < row2colsidx[i2] )
7431 while( i1 < row1->nlpcols && i2 < row2->len )
7446 while( i1 < row1->len && i2 < row2->nlpcols )
7478 while( i1 >= 0 && i2 >= 0 )
7482 assert((row1->
cols[i1] == row2->
cols[i2]) == (row1colsidx[i1] == row2colsidx[i2]));
7483 if( row1colsidx[i1] < row2colsidx[i2] )
7485 else if( row1colsidx[i1] > row2colsidx[i2] )
7517 while( ilp1 < row1->nlpcols && inlp1 < row1->len && ilp2 < row2->nlpcols && inlp2 < row2->len )
7523 assert((row1->
cols[ilp1] == row2->
cols[ilp2]) == (row1colsidx[ilp1] == row2colsidx[ilp2]));
7524 assert((row1->
cols[ilp1] == row2->
cols[inlp2]) == (row1colsidx[ilp1] == row2colsidx[inlp2]));
7525 assert((row1->
cols[inlp1] == row2->
cols[ilp2]) == (row1colsidx[inlp1] == row2colsidx[ilp2]));
7526 assert((row1->
cols[inlp1] == row2->
cols[inlp2]) == (row1colsidx[inlp1] == row2colsidx[inlp2]));
7529 if( row1colsidx[ilp1] == row2colsidx[ilp2] )
7536 else if( row1colsidx[ilp1] == row2colsidx[inlp2] )
7543 else if( row1colsidx[inlp1] == row2colsidx[ilp2] )
7550 else if( row1colsidx[inlp1] == row2colsidx[inlp2] && row1->
cols[inlp1]->
lppos >= 0 )
7557 else if( row1colsidx[ilp1] < row1colsidx[inlp1] )
7559 if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7561 if( row1colsidx[ilp1] < row2colsidx[ilp2] )
7568 if( row1colsidx[ilp1] < row2colsidx[inlp2] )
7576 if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7578 if( row1colsidx[inlp1] < row2colsidx[ilp2] )
7585 if( row1colsidx[inlp1] < row2colsidx[inlp2] )
7597 if( ilp1 != row1->
nlpcols && inlp1 != row1->
len )
7635 while( i1 < end1 && ilp2 < row2->nlpcols && inlp2 < row2->len )
7640 assert((row1->
cols[i1] == row2->
cols[ilp2]) == (row1colsidx[i1] == row2colsidx[ilp2]));
7641 assert((row1->
cols[i1] == row2->
cols[inlp2]) == (row1colsidx[i1] == row2colsidx[inlp2]));
7644 if( row1colsidx[i1] == row2colsidx[ilp2] )
7651 else if( row1colsidx[i1] == row2colsidx[inlp2] && (lpcols || row1->
cols[i1]->
lppos >= 0) )
7658 else if( row2colsidx[ilp2] < row2colsidx[inlp2] )
7660 if( row1colsidx[i1] < row2colsidx[ilp2] )
7667 if( row1colsidx[i1] < row2colsidx[inlp2] )
7695 while( i1 < end1 && i2 < end2 )
7699 assert((row1->
cols[i1] == row2->
cols[i2]) == (row1colsidx[i1] == row2colsidx[i2]));
7702 if( row1colsidx[i1] == row2colsidx[i2] && (lpcols || row1->
cols[i1]->
lppos >= 0) )
7709 else if( row1colsidx[i1] < row2colsidx[i2] )
7730 SCIP_Real parallelism;
7731 SCIP_Real scalarprod;
7737 if( scalarprod == 0.0 )
7751 for(
i = 0;
i < row1->
len; ++
i )
7761 for(
i = 0;
i < row2->
len; ++
i )
7776 SCIPerrorMessage(
"invalid orthogonality function parameter '%c'\n", orthofunc);
7807 SCIP_Real parallelism;
7826 parallelism =
MIN(parallelism, 1.0);
7827 parallelism =
MAX(parallelism, 0.0);
7849 eventtype, row->
name, (
void*)eventhdlr, (
void*)eventdata);
7870 SCIPsetDebugMsg(
set,
"drop event of row <%s> with handler %p and data %p\n", row->
name, (
void*)eventhdlr, (
void*)eventdata);
8117 assert(lpipos < lp->nrows);
8118 assert(nnonz < naddcoefs);
8119 ind[nnonz] = lpipos;
8120 val[nnonz] = col->
vals[
i];
8318 name[pos] = row->
name;
8330 assert(lpipos < lp->ncols);
8331 assert(nnonz < naddcoefs);
8333 ind[nnonz] = lpipos;
8334 val[nnonz] = row->
vals[
i];
8448 assert(nobjchg < lp->ncols);
8449 objind[nobjchg] = col->
lpipos;
8467 assert(nbdchg < lp->ncols);
8468 bdind[nbdchg] = col->
lpipos;
8485 SCIPsetDebugMsg(
set,
"flushing objective changes: change %d objective values of %d changed columns\n", nobjchg, lp->
nchgcols);
8583 assert(nchg < lp->nrows);
8682 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",
8875 for(
i = 0;
i < col->
len; ++
i )
8914 for(
i = 0;
i < row->
len; ++
i )
8950 for(
i = 0;
i < col->
len; ++
i )
8959 assert(0 <= pos && pos < row->nlpcols);
8988 for(
i = 0;
i < row->
len; ++
i )
9046 if( minsize <= lp->divechgsidessize )
9075#define DIVESTACKINITSIZE 100
9098 (*lp)->lpicols =
NULL;
9099 (*lp)->lpirows =
NULL;
9100 (*lp)->chgcols =
NULL;
9101 (*lp)->chgrows =
NULL;
9103 (*lp)->soldirection =
NULL;
9104 (*lp)->lazycols =
NULL;
9106 (*lp)->lpobjval = 0.0;
9107 (*lp)->glbpseudoobjval = 0.0;
9108 (*lp)->relglbpseudoobjval = 0.0;
9109 (*lp)->glbpseudoobjvalid =
TRUE;
9110 (*lp)->glbpseudoobjvalinf = 0;
9111 (*lp)->pseudoobjval = 0.0;
9112 (*lp)->relpseudoobjval = 0.0;
9113 (*lp)->pseudoobjvalid =
TRUE;
9114 (*lp)->pseudoobjvalinf = 0;
9115 (*lp)->looseobjval = 0.0;
9116 (*lp)->rellooseobjval = 0.0;
9117 (*lp)->looseobjvalid =
TRUE;
9118 (*lp)->looseobjvalinf = 0;
9119 (*lp)->nloosevars = 0;
9125 (*lp)->validdegeneracylp = -1;
9126 (*lp)->objsqrnorm = 0.0;
9127 (*lp)->objsumnorm = 0.0;
9128 (*lp)->lpicolssize = 0;
9129 (*lp)->nlpicols = 0;
9130 (*lp)->lpirowssize = 0;
9131 (*lp)->nlpirows = 0;
9132 (*lp)->lpifirstchgcol = 0;
9133 (*lp)->lpifirstchgrow = 0;
9134 (*lp)->colssize = 0;
9135 (*lp)->soldirectionsize = 0;
9137 (*lp)->lazycolssize = 0;
9138 (*lp)->nlazycols = 0;
9139 (*lp)->rowssize = 0;
9141 (*lp)->chgcolssize = 0;
9142 (*lp)->nchgcols = 0;
9143 (*lp)->chgrowssize = 0;
9144 (*lp)->nchgrows = 0;
9145 (*lp)->firstnewcol = 0;
9146 (*lp)->firstnewrow = 0;
9147 (*lp)->nremovablecols = 0;
9148 (*lp)->nremovablerows = 0;
9149 (*lp)->validsollp = stat->
lpcount;
9150 (*lp)->validfarkaslp = -1;
9151 (*lp)->validsoldirlp = -1;
9152 (*lp)->validsoldirsol =
NULL;
9153 (*lp)->objsqrnormunreliable =
FALSE;
9154 (*lp)->flushdeletedcols =
FALSE;
9155 (*lp)->flushaddedcols =
FALSE;
9156 (*lp)->flushdeletedrows =
FALSE;
9157 (*lp)->flushaddedrows =
FALSE;
9158 (*lp)->updateintegrality =
TRUE;
9159 (*lp)->flushed =
TRUE;
9161 (*lp)->solved =
TRUE;
9162 (*lp)->primalfeasible =
TRUE;
9163 (*lp)->primalchecked =
TRUE;
9164 (*lp)->dualfeasible =
TRUE;
9165 (*lp)->dualchecked =
TRUE;
9166 (*lp)->solisbasic =
FALSE;
9167 (*lp)->rootlpisrelax =
TRUE;
9168 (*lp)->isrelax =
TRUE;
9169 (*lp)->installing =
FALSE;
9170 (*lp)->strongbranching =
FALSE;
9171 (*lp)->strongbranchprobing =
FALSE;
9172 (*lp)->probing =
FALSE;
9173 (*lp)->diving =
FALSE;
9174 (*lp)->divingobjchg =
FALSE;
9175 (*lp)->divinglazyapplied =
FALSE;
9176 (*lp)->divelpistate =
NULL;
9177 (*lp)->divelpwasprimfeas =
TRUE;
9178 (*lp)->divelpwasprimchecked =
TRUE;
9179 (*lp)->divelpwasdualfeas =
TRUE;
9180 (*lp)->divelpwasdualchecked =
TRUE;
9181 (*lp)->divechgsides =
NULL;
9182 (*lp)->divechgsidetypes =
NULL;
9183 (*lp)->divechgrows =
NULL;
9184 (*lp)->ndivechgsides = 0;
9185 (*lp)->divechgsidessize = 0;
9186 (*lp)->ndivingrows = 0;
9187 (*lp)->divinglpiitlim = INT_MAX;
9188 (*lp)->resolvelperror =
FALSE;
9189 (*lp)->divenolddomchgs = 0;
9190 (*lp)->adjustlpval =
FALSE;
9192 (*lp)->lpifeastol = (*lp)->feastol;
9195 (*lp)->lpifromscratch =
FALSE;
9196 (*lp)->lpifastmip =
set->lp_fastmip;
9197 (*lp)->lpiscaling =
set->lp_scaling;
9198 (*lp)->lpipresolving =
set->lp_presolving;
9199 (*lp)->lpilpinfo =
set->disp_lpinfo;
9200 (*lp)->lpirowrepswitch =
set->lp_rowrepswitch;
9201 (*lp)->lpisolutionpolishing = (
set->lp_solutionpolishing > 0);
9202 (*lp)->lpirefactorinterval =
set->lp_refactorinterval;
9203 (*lp)->lpiconditionlimit =
set->lp_conditionlimit;
9204 (*lp)->lpimarkowitz =
set->lp_markowitz;
9205 (*lp)->lpiitlim = INT_MAX;
9208 (*lp)->lpithreads =
set->lp_threads;
9209 (*lp)->lpitiming = (int)
set->time_clocktype;
9210 (*lp)->lpirandomseed =
set->random_randomseed;
9211 (*lp)->storedsolvals =
NULL;
9221 "LP Solver <%s>: objective limit cannot be set -- can lead to unnecessary simplex iterations\n",
9225 (*lp)->lpihasfeastol = success;
9229 "LP Solver <%s>: primal feasibility tolerance cannot be set -- tolerance of SCIP and LP solver may differ\n",
9233 (*lp)->lpihasdualfeastol = success;
9237 "LP Solver <%s>: dual feasibility tolerance cannot be set -- tolerance of SCIP and LP solver may differ\n",
9241 (*lp)->lpihasbarrierconvtol = success;
9245 "LP Solver <%s>: barrier convergence tolerance cannot be set -- tolerance of SCIP and LP solver may differ\n",
9250 (*lp)->lpihasfastmip = success;
9254 "LP Solver <%s>: fastmip setting not available -- SCIP parameter has no effect\n",
9258 (*lp)->lpihasscaling = success;
9262 "LP Solver <%s>: scaling not available -- SCIP parameter has no effect\n",
9266 (*lp)->lpihaspresolving = success;
9270 "LP Solver <%s>: presolving not available -- SCIP parameter has no effect\n",
9277 "LP Solver <%s>: clock type cannot be set\n",
9284 "LP Solver <%s>: iteration limit cannot be set -- can lead to unnecessary simplex iterations\n",
9291 "LP Solver <%s>: pricing strategy cannot be set -- SCIP parameter has no effect\n",
9298 "LP Solver <%s>: lpinfo setting not available -- SCIP parameter has no effect\n",
9302 (*lp)->lpihasrowrep = success;
9306 "LP Solver <%s>: row representation of the basis not available -- SCIP parameter lp/rowrepswitch has no effect\n",
9310 (*lp)->lpihaspolishing = success;
9314 "LP Solver <%s>: solution polishing not available -- SCIP parameter lp/solutionpolishing has no effect\n",
9318 (*lp)->lpihasrefactor = success;
9322 "LP Solver <%s>: refactorization interval not available -- SCIP parameter lp/refactorinterval has no effect\n",
9329 "LP Solver <%s>: condition number limit for the basis not available -- SCIP parameter lp/conditionlimit has no effect\n",
9336 "LP Solver <%s>: markowitz threshhold not available -- SCIP parameter lp/minmarkowitz has no effect\n",
9343 "LP Solver <%s>: number of threads settings not available -- SCIP parameter has no effect\n",
9347 if( (*lp)->lpirandomseed != 0 )
9353 "LP Solver <%s>: random seed parameter not available -- SCIP parameter has no effect\n",
9362 SCIPerrorMessage(
"The infinity value of the LP solver has to be at least as large as the one of SCIP.\n");
9388 for(
i = 0;
i < (*lp)->nlpirows; ++
i )
9393 if( (*lp)->lpi !=
NULL )
9472 for(
i = 0;
i < col->
len; ++
i )
9532 for(
i = 0;
i < row->
len; ++
i )
9585 SCIP_Bool contained;
9629#define checkLazyColArray(lp, set)
9646 assert(newncols <= lp->ncols);
9648 if( newncols < lp->ncols )
9652 for(
c = lp->
ncols-1;
c >= newncols; --
c )
9718 assert(0 <= newnrows && newnrows <= lp->nrows);
9721 if( newnrows < lp->nrows )
9723 for(
r = lp->
nrows-1;
r >= newnrows; --
r )
9961 SCIP_Bool lhsinfinite;
9962 SCIP_Bool rhsinfinite;
9977 lhsinfinite =
FALSE;
9978 rhsinfinite =
FALSE;
9990 for(
i = 0;
i < row->
len; ++
i )
10003 if( weights[
r] > 0.0 )
10064 SCIP_Bool wasprimfeas,
10065 SCIP_Bool wasprimchecked,
10066 SCIP_Bool wasdualfeas,
10067 SCIP_Bool wasdualchecked
10081 if( lpistate ==
NULL )
10108 if( *lpistate !=
NULL )
10119 SCIP_Bool interrupt
10168 if( lpinorms !=
NULL )
10205 SCIP_Real cutoffbound
10259 SCIP_Real newfeastol
10263 assert(newfeastol > 0.0);
10268 if( newfeastol < lp->feastol )
10305 return "primal simplex";
10307 return "dual simplex";
10311 return "barrier/crossover";
10327 SCIP_Bool instable,
10331 SCIP_Real timedelta;
10346#ifdef SCIP_MORE_DEBUG
10352 SCIPsetDebugMsg(
set,
"wrote LP to file <%s> (primal simplex, objlim=%.15g, feastol=%.15g/%.15g, fromscratch=%d, fastmip=%d, scaling=%d, presolving=%d)\n",
10416 if( iterations > 0 )
10461 if ( keepsol && !(*
lperror) )
10485 SCIP_Bool instable,
10489 SCIP_Real timedelta;
10504#ifdef SCIP_MORE_DEBUG
10510 SCIPsetDebugMsg(
set,
"wrote LP to file <%s> (dual simplex, objlim=%.15g, feastol=%.15g/%.15g, fromscratch=%d, fastmip=%d, scaling=%d, presolving=%d)\n",
10574 if( iterations > 0 )
10679 SCIP_Real timedelta;
10681 int totalIterations;
10725 totalIterations = iterations;
10743 if( iterations > 0 )
10787 SCIP_Bool chooseBasic;
10789 SCIP_Real* dualsol;
10790 SCIP_Real* redcost;
10816 chooseBasic =
set->lp_lexdualbasic;
10882#ifdef DEBUG_LEXDUAL
10895 for( j = 0; j < lp->
nlpicols; ++j )
10970 if( pos == -1 &&
c > oldpos )
10983 if( pos == -1 &&
c > oldpos )
10988 newlb[cntcol] = oldlb[
c];
10989 newub[cntcol] = oldlb[
c];
10990 indcol[cntcol++] =
c;
11005 newlb[cntcol] = oldlb[
c];
11006 newub[cntcol] = oldlb[
c];
11012 newlb[cntcol] = oldub[
c];
11013 newub[cntcol] = oldub[
c];
11018 newlb[cntcol] = 0.0;
11019 newub[cntcol] = 0.0;
11022 indcol[cntcol++] =
c;
11046 newlhs[cntrow] = oldlhs[
r];
11047 newrhs[cntrow] = oldlhs[
r];
11052 newlhs[cntrow] = oldrhs[
r];
11053 newrhs[cntrow] = oldrhs[
r];
11055 indrow[cntrow++] =
r;
11062 if( nDualDeg > 0 && pos >= 0 )
11064 assert(0 <= pos && pos < lp->nlpicols && pos > oldpos);
11076 SCIP_Real
obj = 1.0;
11096 lexIterations += iterations;
11098#ifdef DEBUG_LEXDUAL
11099 if( iterations > 0 )
11111 for( j = 0; j < lp->
nlpicols; ++j )
11162 if( iterations > 0 )
11167 while( pos >= 0 && nDualDeg > 0 && (
set->lp_lexdualmaxrounds == -1 || rounds < set->lp_lexdualmaxrounds) );
11187 lexIterations += iterations;
11195 if( lexIterations > 0 )
11201 SCIPstatAdd(stat,
set, nlexdualresolvelpiterations, lexIterations);
11206 totalIterations += lexIterations;
11272 SCIP_Bool crossover,
11277 SCIP_Real timedelta;
11293#ifdef SCIP_MORE_DEBUG
11299 SCIPsetDebugMsg(
set,
"wrote LP to file <%s> (barrier, objlim=%.15g, feastol=%.15g/%.15g, convtol=%.15g, fromscratch=%d, fastmip=%d, scaling=%d, presolving=%d)\n",
11352 if( iterations > 0 )
11412 SCIP_Bool instable,
11413 SCIP_Bool* timelimit,
11417 SCIP_Real lptimelimit;
11426 if(
set->istimelimitfinite )
11430 if( lptimelimit > 0.0 )
11433 if( lptimelimit <= 0.0 || !success )
11488#define MAXNUMTROUBLELPMSGS 10
11502 const char* formatstr,
11525 if( verblevel >
set->disp_verblevel )
11535 va_start(ap, formatstr);
11542 SCIPmessagePrintInfo(messagehdlr,
" -- further messages will be suppressed (use display/verblevel=5 to see all)");
11567 if( !
set->lp_checkdualfeas )
11569 if( !
set->lp_checkprimfeas )
11576#define FEASTOLTIGHTFAC 0.001
11590 SCIP_Bool tightprimfeastol,
11591 SCIP_Bool tightdualfeastol,
11592 SCIP_Bool fromscratch,
11595 SCIP_Bool* timelimit,
11600 SCIP_Bool success2;
11601 SCIP_Bool success3;
11603 SCIP_Bool itlimishard;
11604 SCIP_Bool usepolishing;
11622 SCIPerrorMessage(
"cannot solve LP when loose variable with infinite best bound is present\n");
11630 itlimishard = (itlim == harditlim);
11636 usepolishing =
TRUE;
11643 usepolishing =
FALSE;
11685 if( !
set->lp_checkstability )
11712 if( !
set->lp_checkstability )
11732 lpalgoName(lpalgo), (scaling == 0) ?
"with" :
"without");
11739 if( !
set->lp_checkstability )
11762 lpalgoName(lpalgo), !
set->lp_presolving ?
"with" :
"without");
11769 if( !
set->lp_checkstability )
11786 if( ((simplex && (!tightprimfeastol || !tightdualfeastol)) || (!tightprimfeastol && !tightdualfeastol)) &&
11790 if( !tightprimfeastol )
11796 if( !tightdualfeastol )
11802 if( !simplex && !tightprimfeastol && !tightdualfeastol )
11808 if( success || success2 || success3 )
11818 if( !
set->lp_checkstability )
11827 if( !tightprimfeastol )
11831 if( !tightdualfeastol )
11835 if( !simplex && !tightprimfeastol && !tightdualfeastol )
11847 if( !fromscratch && simplex )
11859 if( !
set->lp_checkstability )
11880 if( !
set->lp_checkstability )
11893 lpalgoName(lpalgo), (scaling == 0) ?
"with" :
"without");
11900 if( !
set->lp_checkstability )
11918 lpalgoName(lpalgo), !
set->lp_presolving ?
"with" :
"without");
11925 if( !
set->lp_checkstability )
11939 if( !tightprimfeastol || !tightdualfeastol )
11942 if( !tightprimfeastol )
11948 if( !tightdualfeastol )
11954 if( success || success2 )
11964 if( !
set->lp_checkstability )
11973 if( !tightprimfeastol )
11977 if( !tightdualfeastol )
12035 SCIP_Bool needprimalray,
12036 SCIP_Bool needdualray,
12039 SCIP_Bool tightprimfeastol,
12040 SCIP_Bool tightdualfeastol,
12041 SCIP_Bool fromscratch,
12047 SCIP_Bool solvedprimal;
12048 SCIP_Bool solveddual;
12049 SCIP_Bool timelimit;
12060 solvedprimal =
FALSE;
12061 solveddual =
FALSE;
12065 itlim = ( resolve ? resolveitlim : harditlim );
12069 SCIP_CALL(
lpSolveStable(lp,
set, messagehdlr, stat, prob, lpalgo, itlim, harditlim, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch,
12070 scaling, keepsol, &timelimit,
lperror) );
12205 SCIPsetDebugMsg(
set,
"solving LP with %s returned solstat=%d (internal status: %d, primalfeasible=%u, dualfeasible=%u)\n",
12224 SCIP_Bool needprimalray,
12225 SCIP_Bool needdualray,
12227 SCIP_Bool tightprimfeastol,
12228 SCIP_Bool tightdualfeastol,
12229 SCIP_Bool fromscratch,
12248 algo = resolve ?
set->lp_resolvealgorithm :
set->lp_initalgorithm;
12258 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12264 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12271 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12277 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12283 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12289 needdualray, resolve, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12293 SCIPerrorMessage(
"invalid parameter setting <%c> for LP algorithm\n", algo);
12324#define checkLazyBounds(lp, set)
12347 SCIPsetDebugMsg(
set,
"mark all lazy columns as changed in order to reload bounds (diving=%u, applied=%u)\n",
12400 if( (
set->lp_resolveiterfac == -1) || stat->
nlps - stat->
nrootlps < 5 )
12406 return (
int)
MIN(itlim,
MAX(
set->lp_resolveitermin, \
12422 SCIP_Longint itlim,
12423 SCIP_Bool limitresolveiters,
12431 SCIP_Bool needprimalray;
12432 SCIP_Bool needdualray;
12450 SCIPsetDebugMsg(
set,
"solving LP: %d rows, %d cols, primalfeasible=%u, dualfeasible=%u, solved=%u, diving=%u, probing=%u, cutoffbnd=%g\n",
12454 needprimalray =
TRUE;
12456 || (
set->conf_enable &&
set->conf_useinflp !=
'o'));
12459 harditlim = (int)
MIN(itlim, INT_MAX);
12461 assert(harditlim == -1 || (resolveitlim <= harditlim));
12484 SCIP_Bool* primalfeaspointer;
12485 SCIP_Bool* dualfeaspointer;
12486 SCIP_Bool primalfeasible;
12487 SCIP_Bool dualfeasible;
12488 SCIP_Bool farkasvalid;
12489 SCIP_Bool rayfeasible;
12490 SCIP_Bool tightprimfeastol;
12491 SCIP_Bool tightdualfeastol;
12492 SCIP_Bool fromscratch;
12493 SCIP_Bool wasfromscratch;
12495 SCIP_Longint oldnlps;
12500 tightprimfeastol =
FALSE;
12501 tightdualfeastol =
FALSE;
12502 fromscratch =
FALSE;
12503 primalfeasible =
FALSE;
12504 dualfeasible =
FALSE;
12505 wasfromscratch = (stat->
nlps == 0);
12506 scaling =
set->lp_scaling;
12510 oldnlps = stat->
nlps;
12511 SCIP_CALL(
lpFlushAndSolve(lp, blkmem,
set, messagehdlr, stat, prob, eventqueue, resolveitlim, harditlim, needprimalray,
12512 needdualray, fastmip, tightprimfeastol, tightdualfeastol, fromscratch, scaling, keepsol,
lperror) );
12528 if(
set->lp_checkprimfeas )
12530 primalfeaspointer = &primalfeasible;
12536 primalfeasible =
TRUE;
12537 primalfeaspointer =
NULL;
12540 if(
set->lp_checkdualfeas )
12542 dualfeaspointer = &dualfeasible;
12548 dualfeasible =
TRUE;
12549 dualfeaspointer =
NULL;
12558 if( primalfeasible && dualfeasible && aging && !lp->
diving && stat->
nlps > oldnlps )
12562 if( stat->
nlps % ((
set->lp_rowagelimit+1)/2 + 1) == 0 )
12575 if( !primalfeasible || !dualfeasible )
12579 if( (fastmip > 0) && simplex )
12584 stat->
nnodes, stat->
nlps, primalfeasible, dualfeasible);
12588 else if( (!primalfeasible && !tightprimfeastol) || (!dualfeasible && !tightdualfeastol) )
12595 stat->
nnodes, stat->
nlps, primalfeasible, dualfeasible);
12596 tightprimfeastol = tightprimfeastol || !primalfeasible;
12597 tightdualfeastol = tightdualfeastol || !dualfeasible;
12600 else if( !fromscratch && !wasfromscratch && simplex )
12605 stat->
nnodes, stat->
nlps, primalfeasible, dualfeasible);
12606 fromscratch =
TRUE;
12617 SCIPsetDebugMsg(
set,
" -> LP objective value: %g + %g = %g (solstat=%d, cutoff=%g)\n",
12639 farkasvalid =
FALSE;
12644 farkasvalid =
TRUE;
12647 if( !farkasvalid && !(*
lperror) )
12651 if( (fastmip > 0) && simplex )
12662 else if( !tightdualfeastol )
12670 tightdualfeastol =
TRUE;
12673 else if( !fromscratch && simplex )
12681 fromscratch =
TRUE;
12699 if(
set->lp_checkprimfeas )
12711 primalfeasible =
TRUE;
12712 rayfeasible =
TRUE;
12719 SCIPsetDebugMsg(
set,
" -> LP has unbounded primal ray (primalfeas=%u, rayfeas=%u)\n",
12720 primalfeasible, rayfeasible);
12722 if( !primalfeasible || !rayfeasible )
12726 if( (fastmip > 0) && simplex )
12731 stat->
nnodes, stat->
nlps, primalfeasible, rayfeasible);
12735 else if( !tightprimfeastol )
12742 stat->
nnodes, stat->
nlps, primalfeasible, rayfeasible);
12743 tightprimfeastol =
TRUE;
12746 else if( !fromscratch && simplex )
12751 stat->
nnodes, stat->
nlps, primalfeasible, rayfeasible);
12752 fromscratch =
TRUE;
12755 else if( scaling > 0 )
12760 stat->
nnodes, stat->
nlps, primalfeasible, rayfeasible);
12804 SCIP_Real tmpcutoff;
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 )
13337 SCIP_Real oldbound,
13338 SCIP_Real newbound,
13342 SCIP_Real pseudoobjval;
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;
13376 SCIP_Real oldbound,
13377 SCIP_Real newbound,
13381 SCIP_Real pseudoobjval;
13382 int pseudoobjvalinf;
13408 assert(pseudoobjvalinf >= 0);
13420 assert(pseudoobjvalinf >= 0);
13422 if( pseudoobjvalinf > 0 ||
set->nactivepricers > 0 )
13425 return pseudoobjval;
13436 SCIP_Real* deltaval,
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;
13566 SCIP_Real* deltaval,
13580 (*deltaval) = newlb *
obj;
13591 (*deltaval) = -oldlb *
obj;
13596 (*deltaval) =
obj * (newlb - oldlb);
13607 SCIP_Real* deltaval,
13621 (*deltaval) = newub *
obj;
13632 (*deltaval) = -oldub *
obj;
13637 (*deltaval) =
obj * (newub - oldub);
13647 SCIP_Real deltaval,
13757 SCIPerrorMessage(
"LP was informed of an objective change of a non-active variable\n");
13849 if(
set->misc_exactsolve )
13861 SCIP_Real deltaval;
13905 SCIP_Real deltaval;
13930 if(
set->misc_exactsolve )
13942 SCIP_Real deltaval;
13973 SCIP_Real deltaval;
13998 if(
set->misc_exactsolve )
14010 SCIP_Real deltaval;
14193 if(
set->misc_exactsolve )
14317 if(
set->misc_exactsolve )
14352 SCIP_Bool* primalfeasible,
14353 SCIP_Bool* dualfeasible
14359 SCIP_Real* dualsol;
14360 SCIP_Real* activity =
NULL;
14361 SCIP_Real* redcost;
14362 SCIP_Real primalbound;
14363 SCIP_Real dualbound;
14364 SCIP_Bool stillprimalfeasible;
14365 SCIP_Bool stilldualfeasible;
14368 SCIP_Longint lpcount;
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
14669 SCIP_Bool* primalfeasible,
14670 SCIP_Bool* rayfeasible
14676 SCIP_Real* activity;
14678 SCIP_Real rayobjval;
14679 SCIP_Real rayscale;
14680 SCIP_Longint lpcount;
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 )
14840 SCIP_Real rayact = 0.0;
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 )
14966 SCIP_Real primsolval;
14967 primsolval =
primsol[
c] + rayscale * ray[
c];
14975 for(
r = 0;
r < nlpirows; ++
r )
15032 for(
c = 0;
c < nlpicols;
c++ )
15061 SCIP_Real* dualfarkas;
15062 SCIP_Real* farkascoefs;
15063 SCIP_Real farkaslhs;
15064 SCIP_Real maxactivity;
15065 SCIP_Bool checkfarkas;
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 )
15861 SCIP_Bool cleanupcols;
15862 SCIP_Bool cleanuprows;
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",
15900 SCIP_Bool cleanupcols;
15901 SCIP_Bool cleanuprows;
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 )
16053 SCIP_Bool store =
TRUE;
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
16384 SCIP_Bool usefarkas,
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 ");
16547 SCIP_Bool genericnames,
16552 SCIP_Real objoffset,
16553 SCIP_Bool lazyconss
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 )
17907 SCIP_Bool relaxrows,
17908 SCIP_Bool inclobjcutoff,
17909 SCIP_Real timelimit,
17920 SCIP_Real* matvals;
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 );
18110 SCIP_Real* rowvals;
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 );
18160 SCIP_Real abslhs =
REALABS(lhs);
18161 SCIP_Real absrhs =
REALABS(rhs);
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 );
18279 SCIP_Real absrhs =
REALABS(rhs);
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 )
18296 SCIP_Real abscollb;
18297 SCIP_Real abscolub;
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;
18467 SCIP_Real* rowvals;
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 )
18608 SCIP_Bool relaxrows,
18609 SCIP_Bool inclobjcutoff,
18610 SCIP_Real timelimit,
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);
18679 SCIP_Real* degeneracy,
18680 SCIP_Real* varconsratio
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)
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)
#define lpCutoffDisabled(set, prob)
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)
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
#define SCIP_EVENTTYPE_ROWSIDECHANGED
#define SCIP_EVENTTYPE_ROWADDEDLP
struct SCIP_EventData SCIP_EVENTDATA
#define SCIP_EVENTTYPE_ROWCHANGED
#define SCIP_EVENTTYPE_FORMAT
#define SCIP_EVENTTYPE_ROWDELETEDLP
#define SCIP_EVENTTYPE_ROWCOEFCHANGED
#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
enum SCIP_BoundType SCIP_BOUNDTYPE
@ 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
@ SCIP_LPPAR_BARRIERCONVTOL
@ SCIP_LPPAR_CONDITIONLIMIT
@ SCIP_LPPAR_ROWREPSWITCH
enum SCIP_BaseStat SCIP_BASESTAT
enum SCIP_VerbLevel SCIP_VERBLEVEL
#define SCIP_DECL_SORTPTRCOMP(x)
enum SCIP_Objsense SCIP_OBJSENSE
enum SCIP_Retcode SCIP_RETCODE
SCIP_Real SCIPvarGetRelaxSol(SCIP_VAR *var, SCIP_SET *set)
internal methods for problem variables