QPSolverStats::ESolutionType
QPSolverRelaxedQPKWIK::imp_solve_qp(
std::ostream* out, EOutputLevel olevel, ERunTests test_what
,const Vector& g, const MatrixSymOp& G
,value_type etaL
,const Vector* dL, const Vector* dU
,const MatrixOp* E, BLAS_Cpp::Transp trans_E, const Vector* b
,const Vector* eL, const Vector* eU
,const MatrixOp* F, BLAS_Cpp::Transp trans_F, const Vector* f
,value_type* obj_d
,value_type* eta, VectorMutable* d
,VectorMutable* nu
,VectorMutable* mu, VectorMutable* Ed
,VectorMutable* lambda, VectorMutable* Fd
)
{
using Teuchos::dyn_cast;
using DenseLinAlgPack::nonconst_tri_ele;
using LinAlgOpPack::dot;
using LinAlgOpPack::V_StV;
using LinAlgOpPack::assign;
using LinAlgOpPack::V_StV;
using LinAlgOpPack::V_MtV;
using AbstractLinAlgPack::EtaVector;
using AbstractLinAlgPack::transVtMtV;
using AbstractLinAlgPack::num_bounded;
using ConstrainedOptPack::MatrixExtractInvCholFactor;
// /////////////////////////
// Map to QPKWIK input
// Validate that rHL is of the proper type.
const MatrixExtractInvCholFactor &cG
= dyn_cast<const MatrixExtractInvCholFactor>(G);
// Determine the number of sparse bounds on variables and inequalities.
// By default set for the dense case
const value_type inf = this->infinite_bound();
const size_type
nd = d->dim(),
m_in = E ? b->dim() : 0,
m_eq = F ? f->dim() : 0,
nvarbounds = dL ? num_bounded(*dL,*dU,inf) : 0,
ninequbounds = E ? num_bounded(*eL,*eU,inf) : 0,
nequalities = F ? f->dim() : 0;
// Determine if this is a QP with a structure different from the
// one just solved.
const bool same_qp_struct = ( N_ == nd && M1_ == nvarbounds && M2_ == ninequbounds && M3_ == nequalities );
/////////////////////////////////////////////////////////////////
// Set the input parameters to be sent to QPKWIKNEW
// N
N_ = nd;
// M1
M1_ = nvarbounds;
// M2
M2_ = ninequbounds;
// M3
M3_ = nequalities;
// GRAD
GRAD_ = VectorDenseEncap(g)();
// UINV_AUG
//
// UINV_AUG = [ sqrt(bigM) 0 ]
// [ 0 L' ]
//
UINV_AUG_.resize(N_+1,N_+1);
cG.extract_inv_chol( &nonconst_tri_ele( UINV_AUG_(2,N_+1,2,N_+1), BLAS_Cpp::upper ) );
UINV_AUG_(1,1) = 1.0 / ::sqrt( NUMPARAM_[2] );
UINV_AUG_.col(1)(2,N_+1) = 0.0;
UINV_AUG_.row(1)(2,N_+1) = 0.0;
// LDUINV_AUG
LDUINV_AUG_ = UINV_AUG_.rows();
// IBND, BL , BU, A, LDA, YPY
IBND_INV_.resize( nd + m_in);
std::fill( IBND_INV_.begin(), IBND_INV_.end(), 0 ); // Initialize the zero
IBND_.resize( my_max( 1, M1_ + M2_ ) );
BL_.resize( my_max( 1, M1_ + M2_ ) );
BU_.resize( my_max( 1, M1_ + M2_ + M3_ ) );
LDA_ = my_max( 1, M2_ + M3_ );
A_.resize( LDA_, ( M2_ + M3_ > 0 ? N_ : 1 ) );
YPY_.resize( my_max( 1, M1_ + M2_ ) );
if(M1_)
YPY_(1,M1_) = 0.0; // Must be for this QP interface
// Initialize variable bound constraints
if( dL ) {
VectorDenseEncap dL_de(*dL);
VectorDenseEncap dU_de(*dU);
// read iterators
AbstractLinAlgPack::sparse_bounds_itr
dLU_itr( dL_de().begin(), dL_de().end()
,dU_de().begin(), dU_de().end()
,inf );
// written iterators
IBND_t::iterator
IBND_itr = IBND_.begin(),
IBND_end = IBND_.begin() + M1_;
DVector::iterator
BL_itr = BL_.begin(),
BU_itr = BU_.begin(),
YPY_itr = YPY_.begin();
// Loop
for( size_type ibnd_i = 1; IBND_itr != IBND_end; ++ibnd_i, ++dLU_itr ) {
IBND_INV_[dLU_itr.index()-1] = ibnd_i;
*IBND_itr++ = dLU_itr.index();
*BL_itr++ = dLU_itr.lbound();
*BU_itr++ = dLU_itr.ubound();
*YPY_itr++ = 0.0; // Must be zero with this QP interface
}
}
// Initialize inequality constraints
if(M2_) {
VectorDenseEncap eL_de(*eL);
VectorDenseEncap eU_de(*eU);
VectorDenseEncap b_de(*b);
AbstractLinAlgPack::sparse_bounds_itr
eLU_itr( eL_de().begin(), eL_de().end()
,eU_de().begin(), eU_de().end()
,inf );
if( M2_ < m_in ) {
// Initialize BL, BU, YPY and A for sparse bounds on general inequalities
// written iterators
DVector::iterator
BL_itr = BL_.begin() + M1_,
BU_itr = BU_.begin() + M1_,
YPY_itr = YPY_.begin() + M1_;
IBND_t::iterator
ibnds_itr = IBND_.begin() + M1_;
// loop
for(size_type i = 1; i <= M2_; ++i, ++eLU_itr, ++ibnds_itr ) {
TEST_FOR_EXCEPT( !( !eLU_itr.at_end() ) );
const size_type k = eLU_itr.index();
*BL_itr++ = eLU_itr.lbound();
*BU_itr++ = eLU_itr.ubound();
*YPY_itr++ = b_de()(k);
*ibnds_itr = k; // Only for my record, not used by QPKWIK
IBND_INV_[nd+k-1] = M1_ + i;
// Add the corresponding row of op(E) to A
// y == A.row(i)'
// y' = e_k' * op(E) => y = op(E')*e_k
DVectorSlice y = A_.row(i);
EtaVector e_k(k,eL_de().dim());
V_MtV( &y( 1, N_ ), *E, BLAS_Cpp::trans_not(trans_E), e_k() ); // op(E')*e_k
}
}
else {
//
// Initialize BL, BU, YPY and A for dense bounds on general inequalities
//
// Initialize BL(M1+1:M1+M2), BU(M1+1:M1+M2)
// and IBND(M1+1:M1+M2) = identity (only for my record, not used by QPKWIK)
DVector::iterator
BL_itr = BL_.begin() + M1_,
BU_itr = BU_.begin() + M1_;
IBND_t::iterator
ibnds_itr = IBND_.begin() + M1_;
for(size_type i = 1; i <= m_in; ++i ) {
if( !eLU_itr.at_end() && eLU_itr.index() == i ) {
*BL_itr++ = eLU_itr.lbound();
*BU_itr++ = eLU_itr.ubound();
++eLU_itr;
}
else {
*BL_itr++ = -inf;
*BU_itr++ = +inf;
}
*ibnds_itr++ = i;
IBND_INV_[nd+i-1]= M1_ + i;
}
// A(1:M2,1:N) = op(E)
assign( &A_(1,M2_,1,N_), *E, trans_E );
// YPY
YPY_(M1_+1,M1_+M2_) = b_de();
}
}
// Initialize equalities
if(M3_) {
V_StV( &BU_( M1_ + M2_ + 1, M1_ + M2_ + M3_ ), -1.0, VectorDenseEncap(*f)() );
assign( &A_( M2_ + 1, M2_ + M3_, 1, N_ ), *F, trans_F );
}
// IYPY
IYPY_ = 1; // ???
// WARM
WARM_ = 0; // Cold start by default
// MAX_ITER
MAX_ITER_ = static_cast<f_int>(max_qp_iter_frac() * N_);
// INF
INF_ = ( same_qp_struct ? 1 : 0 );
// Initilize output, internal state and workspace quantities.
if(!same_qp_struct) {
X_.resize(N_);
NACTSTORE_ = 0;
IACTSTORE_.resize(N_+1);
IACT_.resize(N_+1);
UR_.resize(N_+1);
ISTATE_.resize( QPKWIKNEW_CppDecl::qpkwiknew_listate(N_,M1_,M2_,M3_) );
LRW_ = QPKWIKNEW_CppDecl::qpkwiknew_lrw(N_,M1_,M2_,M3_);
RW_.resize(LRW_);
}
// /////////////////////////////////////////////
// Setup a warm start form the input arguments
//
// Interestingly enough, QPKWIK sorts all of the
// constraints according to scaled multiplier values
// and mixes equality with inequality constriants.
// It seems to me that you should start with equality
// constraints first.
WARM_ = 0;
NACTSTORE_ = 0;
if( m_eq ) {
// Add equality constraints first since we know these will
// be part of the active set.
for( size_type j = 1; j <= m_eq; ++j ) {
IACTSTORE_[NACTSTORE_] = 2*M1_ + 2*M2_ + j;
++NACTSTORE_;
}
}
if( ( nu && nu->nz() ) || ( mu && mu->nz() ) ) {
// Add inequality constraints
const size_type
nu_nz = nu ? nu->nz() : 0,
mu_nz = mu ? mu->nz() : 0;
// Combine all the multipliers for the bound and general inequality
// constraints and sort them from the largest to the smallest. Hopefully
// the constraints with the larger multiplier values will not be dropped
// from the active set.
SpVector gamma( nd + 1 + m_in , nu_nz + mu_nz );
typedef SpVector::element_type ele_t;
if(nu && nu_nz) {
VectorDenseEncap nu_de(*nu);
DVectorSlice::const_iterator
nu_itr = nu_de().begin(),
nu_end = nu_de().end();
index_type i = 1;
while( nu_itr != nu_end ) {
for( ; *nu_itr == 0.0; ++nu_itr, ++i );
gamma.add_element(ele_t(i,*nu_itr));
++nu_itr; ++i;
}
}
if(mu && mu_nz) {
VectorDenseEncap mu_de(*mu);
DVectorSlice::const_iterator
mu_itr = mu_de().begin(),
mu_end = mu_de().end();
index_type i = 1;
while( mu_itr != mu_end ) {
for( ; *mu_itr == 0.0; ++mu_itr, ++i );
gamma.add_element(ele_t(i+nd,*mu_itr));
++mu_itr; ++i;
}
}
std::sort( gamma.begin(), gamma.end()
, AbstractLinAlgPack::SortByDescendingAbsValue() );
// Now add the inequality constraints in decreasing order
const SpVector::difference_type o = gamma.offset();
for( SpVector::const_iterator itr = gamma.begin(); itr != gamma.end(); ++itr ) {
const size_type j = itr->index() + o;
const value_type val = itr->value();
if( j <= nd ) { // Variable bound
const size_type ibnd_i = IBND_INV_[j-1];
TEST_FOR_EXCEPT( !( ibnd_i ) );
IACTSTORE_[NACTSTORE_]
= (val < 0.0
? ibnd_i // lower bound (see IACT(*))
: M1_ + M2_ + ibnd_i // upper bound (see IACT(*))
);
++NACTSTORE_;
}
else if( j <= nd + m_in ) { // General inequality constraint
const size_type ibnd_i = IBND_INV_[j-1]; // offset into M1_ + ibnd_j
TEST_FOR_EXCEPT( !( ibnd_i ) );
IACTSTORE_[NACTSTORE_]
= (val < 0.0
? ibnd_i // lower bound (see IACT(*))
: M1_ + M2_ + ibnd_i // upper bound (see IACT(*))
);
++NACTSTORE_;
}
}
}
if( NACTSTORE_ > 0 )
WARM_ = 1;
// /////////////////////////
// Call QPKWIK
if( out && olevel > PRINT_NONE ) {
*out
<< "\nCalling QPKWIK to solve QP problem ...\n";
}
QPKWIKNEW_CppDecl::qpkwiknew(
N_, M1_, M2_, M3_, &GRAD_(1), &UINV_AUG_(1,1), LDUINV_AUG_, &IBND_[0]
,&BL_(1), &BU_(1), &A_(1,1), LDA_, &YPY_(1), IYPY_, WARM_, NUMPARAM_, MAX_ITER_, &X_(1)
,&NACTSTORE_, &IACTSTORE_[0], &INF_, &NACT_, &IACT_[0], &UR_[0], &EXTRA_
,&ITER_, &NUM_ADDS_, &NUM_DROPS_, &ISTATE_[0], LRW_, &RW_[0]
);
// ////////////////////////
// Map from QPKWIK output
// eta
*eta = EXTRA_;
// d
(VectorDenseMutableEncap(*d))() = X_();
// nu (simple variable bounds) and mu (general inequalities)
if(nu) *nu = 0.0;
if(mu) *mu = 0.0;
// ToDo: Create VectorDenseMutableEncap views for faster access!
{for(size_type i = 1; i <= NACT_; ++i) {
size_type j = IACT_[i-1];
EConstraintType type = constraint_type(M1_,M2_,M3_,j);
FortranTypes::f_int idc = constraint_index(M1_,M2_,M3_,&IBND_[0],type,j);
switch(type) {
case NU_L:
nu->set_ele( idc , -UR_(i) );
break;
case GAMA_L:
mu->set_ele( IBND_[ M1_ + idc - 1 ], -UR_(i) );
break;
case NU_U:
nu->set_ele( idc, UR_(i)) ;
break;
case GAMA_U:
mu->set_ele( IBND_[ M1_ + idc - 1 ], UR_(i) );
break;
case LAMBDA:
lambda->set_ele( idc, UR_(i) );
break;
}
}}
// obj_d (This could be updated within QPKWIK in the future)
if(obj_d) {
// obj_d = g'*d + 1/2 * d' * G * g
*obj_d = dot(g,*d) + 0.5 * transVtMtV(*d,G,BLAS_Cpp::no_trans,*d);
}
// Ed (This could be updated within QPKWIK in the future)
if(Ed) {
V_MtV( Ed, *E, trans_E, *d );
}
// Fd (This could be updated within QPKWIK in the future)
if(Fd) {
V_MtV( Fd, *F, trans_F, *d );
}
// Set the QP statistics
QPSolverStats::ESolutionType solution_type;
if( INF_ >= 0 ) {
solution_type = QPSolverStats::OPTIMAL_SOLUTION;
}
else if( INF_ == -1 ) { // Infeasible constraints
TEST_FOR_EXCEPTION(
true, QPSolverRelaxed::Infeasible
,"QPSolverRelaxedQPKWIK::solve_qp(...) : Error, QP is infeasible" );
}
else if( INF_ == -2 ) { // LRW too small
TEST_FOR_EXCEPT( !( INF_ != -2 ) ); // Local programming error?
}
else if( INF_ == -3 ) { // Max iterations exceeded
solution_type = QPSolverStats::DUAL_FEASIBLE_POINT;
}
else {
TEST_FOR_EXCEPT(true); // Unknown return value!
}
qp_stats_.set_stats(
solution_type, QPSolverStats::CONVEX
,ITER_, NUM_ADDS_, NUM_DROPS_
,WARM_==1, *eta > 0.0 );
return qp_stats_.solution_type();
}
bool CheckConvergenceIP_Strategy::Converged(
Algorithm& _algo
)
{
using Teuchos::dyn_cast;
using AbstractLinAlgPack::num_bounded;
using AbstractLinAlgPack::IP_comp_err_with_mu;
// Calculate kkt errors and check for overall convergence
//bool found_solution = CheckConvergenceStd_Strategy::Converged(_algo);
bool found_solution = false;
// Recalculate the complementarity error including mu
// Get the iteration quantities
IpState &s = dyn_cast<IpState>(*_algo.get_state());
NLPAlgo& algo = rsqp_algo(_algo);
NLP& nlp = algo.nlp();
EJournalOutputLevel olevel = algo.algo_cntr().journal_output_level();
std::ostream& out = algo.track().journal_out();
// Get necessary iteration quantities
const value_type &mu_km1 = s.barrier_parameter().get_k(-1);
const Vector& x_k = s.x().get_k(0);
const VectorMutable& Gf_k = s.Gf().get_k(0);
const Vector& rGL_k = s.rGL().get_k(0);
const Vector& c_k = s.c().get_k(0);
const Vector& vl_k = s.Vl().get_k(0).diag();
const Vector& vu_k = s.Vu().get_k(0).diag();
// Calculate the errors with Andreas' scaling
value_type& opt_err = s.opt_kkt_err().set_k(0);
value_type& feas_err = s.feas_kkt_err().set_k(0);
value_type& comp_err = s.comp_kkt_err().set_k(0);
value_type& comp_err_mu = s.comp_err_mu().set_k(0);
// scaling
value_type scale_1 = 1 + x_k.norm_1()/x_k.dim();
Teuchos::RCP<VectorMutable> temp = Gf_k.clone();
temp->axpy(-1.0, vl_k);
temp->axpy(1.0, vu_k);
value_type scale_2 = temp->norm_1();
scale_2 += vl_k.norm_1() + vu_k.norm_1();
*temp = nlp.infinite_bound();
const size_type nlb = num_bounded(nlp.xl(), *temp, nlp.infinite_bound());
*temp = -nlp.infinite_bound();
const size_type nub = num_bounded(*temp, nlp.xu(), nlp.infinite_bound());
scale_2 = 1 + scale_2/(1+nlp.m()+nlb+nub);
// Calculate the opt_err
opt_err = rGL_k.norm_inf() / scale_2;
// Calculate the feas_err
feas_err = c_k.norm_inf() / scale_1;
// Calculate the comp_err
if( (int)olevel >= (int)PRINT_VECTORS )
{
out << "\nx =\n" << s.x().get_k(0);
out << "\nxl =\n" << nlp.xl();
out << "\nvl =\n" << s.Vl().get_k(0).diag();
out << "\nxu =\n" << nlp.xu();
out << "\nvu =\n" << s.Vu().get_k(0).diag();
}
comp_err = IP_comp_err_with_mu(
0.0, nlp.infinite_bound(), s.x().get_k(0), nlp.xl(), nlp.xu()
,s.Vl().get_k(0).diag(), s.Vu().get_k(0).diag());
comp_err_mu = IP_comp_err_with_mu(
mu_km1, nlp.infinite_bound(), s.x().get_k(0), nlp.xl(), nlp.xu()
,s.Vl().get_k(0).diag(), s.Vu().get_k(0).diag());
comp_err = comp_err / scale_2;
comp_err_mu = comp_err_mu / scale_2;
// check for convergence
const value_type opt_tol = algo.algo_cntr().opt_tol();
const value_type feas_tol = algo.algo_cntr().feas_tol();
const value_type comp_tol = algo.algo_cntr().comp_tol();
if (opt_err < opt_tol && feas_err < feas_tol && comp_err < comp_tol)
{
found_solution = true;
}
if( int(olevel) >= int(PRINT_ALGORITHM_STEPS) || (int(olevel) >= int(PRINT_BASIC_ALGORITHM_INFO) && found_solution) )
{
out
<< "\nopt_kkt_err_k = " << opt_err << ( opt_err < opt_tol ? " < " : " > " )
<< "opt_tol = " << opt_tol
<< "\nfeas_kkt_err_k = " << feas_err << ( feas_err < feas_tol ? " < " : " > " )
<< "feas_tol = " << feas_tol
<< "\ncomp_kkt_err_k = " << comp_err << ( comp_err < comp_tol ? " < " : " > " )
<< "comp_tol = " << comp_tol
<< "\ncomp_err_mu = " << comp_err_mu
<< "\nbarrier_parameter_k (mu_km1) = " << mu_km1
<< "comp_tol = " << comp_tol
<< std::endl;
}
return found_solution;
}
