void SPxSolver::qualConstraintViolation(Real& maxviol, Real& sumviol) const
{
maxviol = 0.0;
sumviol = 0.0;
DVector solu( nCols() );
getPrimal( solu );
for( int row = 0; row < nRows(); ++row )
{
const SVector& rowvec = rowVector( row );
Real val = 0.0;
for( int col = 0; col < rowvec.size(); ++col )
val += rowvec.value( col ) * solu[rowvec.index( col )];
Real viol = 0.0;
assert(lhs( row ) <= rhs( row ));
if (val < lhs( row ))
viol = spxAbs(val - lhs( row ));
else
if (val > rhs( row ))
viol = spxAbs(val - rhs( row ));
if (viol > maxviol)
maxviol = viol;
sumviol += viol;
}
}
void SPxSolver::qualBoundViolation(
Real& maxviol, Real& sumviol) const
{
maxviol = 0.0;
sumviol = 0.0;
DVector solu( nCols() );
getPrimal( solu );
for( int col = 0; col < nCols(); ++col )
{
assert( lower( col ) <= upper( col ));
Real viol = 0.0;
if (solu[col] < lower( col ))
viol = spxAbs( solu[col] - lower( col ));
else
if (solu[col] > upper( col ))
viol = spxAbs( solu[col] - upper( col ));
if (viol > maxviol)
maxviol = viol;
sumviol += viol;
}
}
void SPxSolver::qualSlackViolation(Real& maxviol, Real& sumviol) const
{
maxviol = 0.0;
sumviol = 0.0;
DVector solu( nCols() );
DVector slacks( nRows() );
getPrimal( solu );
getSlacks( slacks );
for( int row = 0; row < nRows(); ++row )
{
const SVector& rowvec = rowVector( row );
Real val = 0.0;
for( int col = 0; col < rowvec.size(); ++col )
val += rowvec.value( col ) * solu[rowvec.index( col )];
Real viol = spxAbs(val - slacks[row]);
if (viol > maxviol)
maxviol = viol;
sumviol += viol;
}
}
// ----------------------------------------------------------------
void SPxWeightST::generate(SPxSolver& base)
{
SPxId tmpId;
forbidden.reSize(base.dim());
rowWeight.reSize(base.nRows());
colWeight.reSize(base.nCols());
rowRight.reSize (base.nRows());
colUp.reSize (base.nCols());
if (base.rep() == SPxSolver::COLUMN)
{
weight = &colWeight;
coWeight = &rowWeight;
}
else
{
weight = &rowWeight;
coWeight = &colWeight;
}
assert(weight->size() == base.coDim());
assert(coWeight->size() == base.dim());
setupWeights(base);
SPxBasis::Desc desc(base);
// desc.reSize(base.nRows(), base.nCols());
DataArray < SPxId > pref(base.nRows() + base.nCols());
initPrefs(pref, base, rowWeight, colWeight);
int i;
int stepi;
int j;
int sel;
for(i = 0; i < base.dim(); ++i)
forbidden[i] = 0;
if (base.rep() == SPxSolver::COLUMN)
{
// in COLUMN rep we scan from beginning to end
i = 0;
stepi = 1;
}
else
{
// in ROW rep we scan from end to beginning
i = pref.size() - 1;
stepi = -1;
}
int dim = base.dim();
Real maxEntry = 0;
for (; i >= 0 && i < pref.size(); i += stepi)
{
tmpId = pref[i];
const SVector& vec = base.vector(tmpId);
sel = -1;
// column or row singleton ?
if (vec.size() == 1)
{
int idx = vec.index(0);
if (forbidden[idx] < 2)
{
sel = idx;
dim += (forbidden[idx] > 0) ? 1 : 0;
}
}
else
{
maxEntry = vec.maxAbs();
// initialize the nonzero counter
int minRowEntries = base.nRows();
// find a stable index with a sparse row/column
for (j = vec.size(); --j >= 0;)
{
Real x = vec.value(j);
int k = vec.index(j);
int nRowEntries = base.coVector(k).size();
if (!forbidden[k] && (spxAbs(x) > STABLE * maxEntry) && (nRowEntries < minRowEntries))
{
minRowEntries = nRowEntries;
sel = k;
}
}
}
// we found a valid index
if (sel >= 0)
{
MSG_DEBUG(
if (pref[i].type() == SPxId::ROW_ID)
std::cout << "DWEIST01 r" << base.number(pref[i]);
else
std::cout << "DWEIST02 c" << base.number(pref[i]);
)
forbidden[sel] = 2;
// put current column/row into basis
if (base.rep() == SPxSolver::COLUMN)
setDualStatus(desc, base, pref[i]);
else
setPrimalStatus(desc, base, pref[i]);
for (j = vec.size(); --j >= 0;)
{
Real x = vec.value(j);
int k = vec.index(j);
if (!forbidden[k] && (x > EPS * maxEntry || -x > EPS * maxEntry))
{
forbidden[k] = 1;
--dim;
}
}
if (--dim == 0)
{
//@ for(++i; i < pref.size(); ++i)
if (base.rep() == SPxSolver::COLUMN)
{
// set all remaining indeces to nonbasic status
for (i += stepi; i >= 0 && i < pref.size(); i += stepi)
setPrimalStatus(desc, base, pref[i]);
// fill up the basis wherever linear independence is assured
for (i = forbidden.size(); --i >= 0;)
{
if (forbidden[i] < 2)
setDualStatus(desc, base, base.coId(i));
}
}
else
{
for (i += stepi; i >= 0 && i < pref.size(); i += stepi)
setDualStatus(desc, base, pref[i]);
for (i = forbidden.size(); --i >= 0;)
{
if (forbidden[i] < 2)
setPrimalStatus(desc, base, base.coId(i));
}
}
break;
}
}