/** Computes indicators for printing. They are v2=vstar * vstar, asc= v*v,
vu= vstar * u, vabs = sum( abs(vstar[i]))/m, v2= sum( vstar[i]^2) / m.
*/
VOL_indc::VOL_indc(const VOL_dvector& dual_lb, const VOL_dvector& dual_ub,
const VOL_primal& primal, const VOL_primal& pstar,
const VOL_dual& dual) {
v2 = vu = vabs = asc = 0.0;
const VOL_dvector v = primal.v;
const VOL_dvector vstar = pstar.v;
const VOL_dvector u = dual.u;
int i;
const int nc = vstar.size();
for (i = 0; i < nc; ++i) {
if (u[i] == 0.0 && dual_lb[i] == 0.0 && vstar[i] <= 0.0)
continue;
if (u[i] == 0.0 && dual_ub[i] == 0.0 && vstar[i] >= 0.0)
continue;
v2 += vstar[i] * vstar[i];
asc += v[i] * v[i];
vu -= vstar[i] * u[i];
vabs += VolAbs(vstar[i]);
}
v2 = sqrt(v2) / nc;
vabs /= nc;
}
int
OsiVolSolverInterface::solve_subproblem(const VOL_dvector& dual,
const VOL_dvector& rc,
double& lcost,
VOL_dvector& x, VOL_dvector& v,
double& pcost)
{
int i;
const int psize = x.size();
for (i = 0; i < psize; ++i) {
x[i] = (rc[i] >= 0.0) ? collower_[i] : colupper_[i];
}
const int dsize = v.size();
lcost = (std::inner_product(rhs_, rhs_ + dsize, dual.v, 0.0) +
std::inner_product(x.v, x.v + psize, rc.v, 0.0) );
if (isZeroOneMinusOne_) {
colMatrixOneMinusOne_->timesMajor(x.v, v.v);
} else {
colMatrix_.times(x.v, v.v);
}
std::transform(v.v, v.v+dsize, rhs_, v.v, std::minus<double>());
std::transform(v.v, v.v+dsize, v.v, std::negate<double>());
pcost = std::inner_product(x.v, x.v + psize, objcoeffs_, 0.0);
return 0;
}
int
lpHook::solve_subproblem(const VOL_dvector& dual, const VOL_dvector& rc,
double& lcost, VOL_dvector& x, VOL_dvector& v,
double& pcost)
{
int i;
const int psize = x.size();
const int dsize = v.size();
// compute the lagrangean solution corresponding to the reduced costs
for (i = 0; i < psize; ++i)
x[i] = (rc[i] >= 0.0) ? collower_[i] : colupper_[i];
// compute the lagrangean value (rhs*dual + primal*rc)
lcost = 0;
for (i = 0; i < dsize; ++i)
lcost += rhs_[i] * dual[i];
for (i = 0; i < psize; ++i)
lcost += x[i] * rc[i];
// compute the rhs - lhs
colMatrix_.times(x.v, v.v);
for (i = 0; i < dsize; ++i)
v[i] = rhs_[i] - v[i];
// compute the lagrangean primal objective
pcost = 0;
for (i = 0; i < psize; ++i)
pcost += x[i] * objcoeffs_[i];
return 0;
}
/** Computes indicators for printing. They are v2=vstar * vstar, asc= v*v,
vu= vstar * u, vabs = sum( abs(vstar[i]))/m, v2= sum( vstar[i]^2) / m.
*/
VOL_indc::VOL_indc(const VOL_dvector& dual_lb, const VOL_dvector& dual_ub,
const VOL_primal& primal, const VOL_primal& pstar,
const VOL_dual& dual)
{
v2 = vu = vabs = asc = 0.0;
const VOL_dvector v = primal.v;
const VOL_dvector vstar = pstar.v;
const VOL_dvector u = dual.u;
int i;
const int nc = vstar.size();
double v2_incr = 0.0;
double asc_incr = 0.0;
double vu_incr = 0.0;
double vabs_incr = 0.0;
double this_vabs_incr = 0.0;
for (i = 0; i < nc; ++i)
{
bool ok = (!((u[i] == 0.0 && dual_lb[i] == 0.0 && vstar[i] <= 0.0) ||
(u[i] == 0.0 && dual_ub[i] == 0.0 && vstar[i] >= 0.0)));
this_vabs_incr = vstar[i] > 0 ? vstar[i] : -vstar[i];
if (ok)
{
v2_incr += vstar[i] * vstar[i];
asc_incr += v[i] * v[i];
vu_incr -= vstar[i] * u[i];
vabs_incr += this_vabs_incr;
}
}
/*******************original, non MTA-friendly**************************
for (i = 0; i < nc; ++i) {
if (u[i] == 0.0 && dual_lb[i] == 0.0 && vstar[i] <= 0.0)
continue;
if (u[i] == 0.0 && dual_ub[i] == 0.0 && vstar[i] >= 0.0)
continue;
v2 += vstar[i] * vstar[i];
asc += v[i] * v[i];
vu -= vstar[i] * u[i];
vabs += VolAbs(vstar[i]);
}
*******************original, non MTA-friendly**************************/
v2 = sqrt(v2) / nc;
vabs /= nc;
}
/** compute xrc. This is (c - u A) * ( xstar - x ). This is just
miscellaneous information, it is not used in the algorithm. */
void
VOL_dual::compute_xrc(const VOL_dvector& xstar, const VOL_dvector& x,
const VOL_dvector& rc)
{
const int nc = x.size();
xrc = 0;
for (int i = 0; i < nc; ++i) {
xrc += rc[i] * (xstar[i] - x[i]);
}
}
/** compute xrc. This is (c - u A) * ( xstar - x ). This is just
miscellaneous information, it is not used in the algorithm. */
void
VOL_dual::compute_xrc(const VOL_dvector& xstar, const VOL_dvector& x,
const VOL_dvector& rc)
{
const int nc = x.size();
double _xrc = 0; // need this local variable for MTA compiler
for (int i = 0; i < nc; ++i)
{
_xrc += rc[i] * (xstar[i] - x[i]);
}
xrc = _xrc;
}
/** Computing inner products. It computes v * ( alpha v + (1-alpha) h),
v * h, v * v, h * h. Here v is the subgradient direction, and h is
the conjugate direction. */
VOL_vh::VOL_vh(const double alpha,
const VOL_dvector& dual_lb, const VOL_dvector& dual_ub,
const VOL_dvector& v, const VOL_dvector& vstar,
const VOL_dvector& u) :
hh(0), norm(0), vh(0), asc(0)
{
int i;
const int nc = vstar.size();
double vv;
double asc_incr = 0.0;
double vh_incr = 0.0;
double norm_incr = 0.0;
double hh_incr = 0.0;
for (i = 0; i < nc; ++i)
{
const double vi = v[i];
const double vsi = vstar[i];
vv = alpha * vi + (1.0 - alpha) * vsi;
bool ok = (!((u[i] == 0.0 && dual_lb[i] == 0.0 && vv <= 0.0) ||
(u[i] == 0.0 && dual_ub[i] == 0.0 && vv >= 0.0)));
if (ok)
{
asc_incr += vi * vv;
vh_incr += vi * vsi;
norm_incr += vi * vi;
hh_incr += vsi * vsi;
}
}
asc += asc_incr;
vh += vh_incr;
norm += norm_incr;
hh += hh_incr;
/*********** original, not MTA-friendly *************************
for (i = 0; i < nc; ++i) {
const double vi = v[i];
const double vsi = vstar[i];
vv = alpha * vi + (1.0 - alpha) * vsi;
if (u[i] == 0.0 && dual_lb[i] == 0.0 && vv <= 0.0)
continue;
if (u[i] == 0.0 && dual_ub[i] == 0.0 && vv >= 0.0)
continue;
asc += vi * vv;
vh += vi * vsi;
norm += vi * vi;
hh += vsi * vsi;
}
****************************************************************/
}
/** Computing inner products. It computes v * ( alpha v + (1-alpha) h),
v * h, v * v, h * h. Here v is the subgradient direction, and h is
the conjugate direction. */
VOL_vh::VOL_vh(const double alpha,
const VOL_dvector& dual_lb, const VOL_dvector& dual_ub,
const VOL_dvector& v, const VOL_dvector& vstar,
const VOL_dvector& u) :
hh(0), norm(0), vh(0), asc(0)
{
int i;
const int nc = vstar.size();
double vv;
for (i = 0; i < nc; ++i) {
const double vi = v[i];
const double vsi = vstar[i];
vv = alpha * vi + (1.0 - alpha) * vsi;
if (u[i] == 0.0 && dual_lb[i] == 0.0 && vv <= 0.0)
continue;
if (u[i] == 0.0 && dual_ub[i] == 0.0 && vv >= 0.0)
continue;
asc += vi * vv;
vh += vi * vsi;
norm += vi * vi;
hh += vsi * vsi;
}
}
