ConstrainedOptPack_QPSolverRelaxedQPSchur.hpp

// @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.
// 
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//  
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//  
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// 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