ConstrainedOptPack_QPSolverRelaxedQPSchur.hpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
// 
// Moocho: Multi-functional Object-Oriented arCHitecture for Optimization
//                  Copyright (2003) Sandia Corporation
// 
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Roscoe A. Bartlett (rabartl@sandia.gov) 
// 
// ***********************************************************************
// @HEADER

#ifndef QP_SOLVER_RELAXED_QP_SCHUR_H
#define QP_SOLVER_RELAXED_QP_SCHUR_H

#include "ConstrainedOptPack_QPSolverRelaxed.hpp"
#include "ConstrainedOptPack_QPSchur.hpp"
#include "ConstrainedOptPack_QPInitFixedFreeStd.hpp"
#include "ConstrainedOptPack_MatrixSymHessianRelaxNonSing.hpp"
#include "ConstrainedOptPack_ConstraintsRelaxedStd.hpp"
#include "ConstrainedOptPack_MatrixSymAddDelBunchKaufman.hpp"
#include "AbstractLinAlgPack_VectorMutableDense.hpp"
#include "Teuchos_StandardCompositionMacros.hpp"
#include "Teuchos_StandardMemberCompositionMacros.hpp"

namespace ConstrainedOptPack {

class QPSolverRelaxedQPSchur : public QPSolverRelaxed {
public:

  class InitKKTSystem {
  public:
    typedef std::vector<size_type> i_x_free_t;
    typedef std::vector<size_type> i_x_fixed_t;
    typedef std::vector<EBounds>   bnd_fixed_t;
    typedef std::vector<size_type> j_f_decomp_t;
    typedef Teuchos::RCP<const MatrixSymOpNonsing>
      Ko_ptr_t;
    virtual ~InitKKTSystem() {}
    virtual void initialize_kkt_system(
      const Vector    &g
      ,const MatrixOp   &G
      ,value_type           etaL
      ,const Vector   *dL
      ,const Vector   *dU
      ,const MatrixOp   *F
      ,BLAS_Cpp::Transp     trans_F
      ,const Vector   *f
      ,const Vector   *d
      ,const Vector   *nu
      ,size_type            *n_R
      ,i_x_free_t           *i_x_free
      ,i_x_fixed_t          *i_x_fixed
      ,bnd_fixed_t          *bnd_fixed
      ,j_f_decomp_t         *j_f_decomp
      ,DVector               *b_X
      ,Ko_ptr_t             *Ko
      ,DVector               *fo
      ) const = 0;

  }; // end class InitKKTSystem

  class ReinitKKTSystem : public InitKKTSystem {
  public:
    // ToDo: Create method reinitailze_kkt_system(...)
  }; // end class ReinitKKTSystem

  STANDARD_COMPOSITION_MEMBERS( InitKKTSystem, init_kkt_sys );

  STANDARD_COMPOSITION_MEMBERS( QPSchurPack::ConstraintsRelaxedStd, constraints );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, max_qp_iter_frac );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, max_real_runtime );

  STANDARD_MEMBER_COMPOSITION_MEMBERS(
    QPSchurPack::ConstraintsRelaxedStd::EInequalityPickPolicy
    ,inequality_pick_policy
    );

  enum ELocalOutputLevel {
     USE_INPUT_ARG        = -1  // Use the value input to solve_qp(...)
    ,NO_OUTPUT          = 0   //
    ,OUTPUT_BASIC_INFO      = 1   // values sent to QPSchur::solve_qp(...)
    ,OUTPUT_ITER_SUMMARY    = 2   // ...
    ,OUTPUT_ITER_STEPS      = 3
    ,OUTPUT_ACT_SET       = 4
    ,OUTPUT_ITER_QUANTITIES   = 5
  };

  STANDARD_MEMBER_COMPOSITION_MEMBERS( ELocalOutputLevel, print_level );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, bounds_tol );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, inequality_tol );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, equality_tol );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, loose_feas_tol );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, dual_infeas_tol );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, huge_primal_step );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, huge_dual_step );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, bigM );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, warning_tol );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, error_tol );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( size_type, iter_refine_min_iter );
    
  STANDARD_MEMBER_COMPOSITION_MEMBERS( size_type, iter_refine_max_iter );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, iter_refine_opt_tol );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, iter_refine_feas_tol );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( bool, iter_refine_at_solution );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, pivot_warning_tol );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, pivot_singular_tol );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( value_type, pivot_wrong_inertia_tol );

  STANDARD_MEMBER_COMPOSITION_MEMBERS( bool, add_equalities_initially );

  QPSolverRelaxedQPSchur(
    const init_kkt_sys_ptr_t&    init_kkt_sys       = Teuchos::null
    ,const constraints_ptr_t&    constraints        = Teuchos::rcp(new QPSchurPack::ConstraintsRelaxedStd)
    ,value_type                  max_qp_iter_frac   = 10.0
    ,value_type                  max_real_runtime   = 1e+20
    ,QPSchurPack::ConstraintsRelaxedStd::EInequalityPickPolicy
                                 inequality_pick_policy
                                     = QPSchurPack::ConstraintsRelaxedStd::ADD_BOUNDS_THEN_MOST_VIOLATED_INEQUALITY
    ,ELocalOutputLevel           print_level             = USE_INPUT_ARG  // Deduce from input arguments
    ,value_type                  bounds_tol              = -1.0           // use default
    ,value_type                  inequality_tol          = -1.0           // use default
    ,value_type                  equality_tol            = -1.0           // use default
    ,value_type                  loose_feas_tol          = -1.0           // use default
    ,value_type                  dual_infeas_tol         = -1.0           // use default
    ,value_type                  huge_primal_step        = -1.0           // use defalut
    ,value_type                  huge_dual_step          = -1.0           // use default
    ,value_type                  bigM                    = 1e+10
    ,value_type                  warning_tol             = 1e-10
    ,value_type                  error_tol               = 1e-5
    ,size_type                   iter_refine_min_iter    = 1
    ,size_type                   iter_refine_max_iter    = 3
    ,value_type                  iter_refine_opt_tol     = 1e-12
    ,value_type                  iter_refine_feas_tol    = 1e-12
    ,bool                        iter_refine_at_solution = true
    ,value_type                  pivot_warning_tol       = 1e-8
    ,value_type                  pivot_singular_tol      = 1e-11
    ,value_type                  pivot_wrong_inertia_tol = 1e-11
    ,bool                        add_equalities_initially= true
    );

  ~QPSolverRelaxedQPSchur();


  QPSolverStats get_qp_stats() const;
  void release_memory();


protected:


  QPSolverStats::ESolutionType 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
    );


private:

  // ////////////////////////////
  // Private data members

  QPSolverStats                    qp_stats_;
  QPSchur                          qp_solver_;
  QPSchurPack::QPInitFixedFreeStd  qp_;
  MatrixSymHessianRelaxNonSing     G_relaxed_;
  VectorMutableDense         bigM_vec_;
  MatrixSymAddDelBunchKaufman      schur_comp_;
  DVector                           g_relaxed_;
  DVector                           b_X_;
  InitKKTSystem::Ko_ptr_t          Ko_;
  DVector                           fo_;

}; // end class QPSolverRelaxedQPSchur

} // end namespace ConstrainedOptPack

#endif // QP_SOLVER_RELAXED_QP_SCHUR_H