ConstrainedOptPack_MatrixKKTFullSpaceRelaxed.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 MATRIX_KKT_FULL_SPACE_RELAXED_H
#define MATRIX_KKT_FULL_SPACE_RELAXED_H

#include "ConstrainedOptPack_Types.hpp"
#include "AbstractLinAlgPack/src/MatrixWithOpFactorized.hpp"
#include "AbstractLinAlgPack/src/MatrixConvertToSparseFortranCompatible.hpp"
#include "Teuchos_StandardCompositionMacros.hpp"

namespace ConstrainedOptPack {

class MatrixKKTFullSpaceRelaxed
  : public MatrixWithOpFactorized
  , public MatrixConvertToSparseFortranCompatible
{
public:
  
  typedef AbstractLinAlgPack::DirectSparseFortranCompatibleSolver
    DirectSparseFortranCompatibleSolver;

  class NotInitializedException : public std::logic_error
  {public: NotInitializedException (const std::string& what_arg) : std::logic_error(what_arg) {}};

  class SingularMatrixException : public std::logic_error
  {public: SingularMatrixException (const std::string& what_arg) : std::logic_error(what_arg) {}};

  class InvalidMatrixType : public std::logic_error
  {public: InvalidMatrixType (const std::string& what_arg) : std::logic_error(what_arg) {}};

  enum ERunTests { RUN_TESTS, NO_TESTS };

  enum EPrintMoreOrLess { PRINT_MORE, PRINT_LESS };

  STANDARD_COMPOSITION_MEMBERS( DirectSparseFortranCompatibleSolver, direct_solver );

  MatrixKKTFullSpaceRelaxed( const direct_solver_ptr_t& direct_solver = 0 );


  void initialize( const MatrixOp& G, const MatrixOp& A
    , std::ostream* out = 0, EPrintMoreOrLess print_what = PRINT_LESS
    , ERunTests test_what = NO_TESTS );

  void initialize_relaxed( const MatrixOp& G, const MatrixOp& A
    , const DVectorSlice& c, value_type bigM = 1e+10
    , std::ostream* out = 0, EPrintMoreOrLess print_what = PRINT_LESS
    , ERunTests test_what = NO_TESTS );

  void set_uninitialized();

  void release_memory();


  // /////////////////////////////////////////////////////
  // Overridden from Matrix

  size_type rows() const;

  size_type cols() const;

  // /////////////////////////////////////////////////////////
  // Overridden from MatrixOp

  std::ostream& output(std::ostream& out) const;

  MatrixOp& operator=(const MatrixOp& m);

  void Vp_StMtV(DVectorSlice* vs_lhs, value_type alpha, BLAS_Cpp::Transp trans_rhs1
    , const DVectorSlice& vs_rhs2, value_type beta) const;

  // ////////////////////////////////////////////////////////////
  // Overridden from MatrixFactorized

  void V_InvMtV( DVectorSlice* v_lhs, BLAS_Cpp::Transp trans_rhs1
    , const DVectorSlice& vs_rhs2) const;

  // ////////////////////////////////////////////////////////////
  // Overridden from MatrixConvertToSparseFortranCompatible

  FortranTypes::f_int num_nonzeros( EExtractRegion extract_region ) const;

  void coor_extract_nonzeros(
      EExtractRegion extract_region
    , const FortranTypes::f_int len_Aval
      , FortranTypes::f_dbl_prec Aval[]
    , const FortranTypes::f_int len_Aij
      , FortranTypes::f_int Arow[]
      , FortranTypes::f_int Acol[]
      , const FortranTypes::f_int row_offset
      , const FortranTypes::f_int col_offset
     ) const;

private:

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

  bool        initialized_;
  size_type     n_;   // Number of rows and columns in G and number of rows in A.
  size_type     m_;   // Number of columns in A
  bool        use_relaxation_;
  value_type      bigM_;
  EPrintMoreOrLess  print_what_;
  ERunTests     test_what_;
  std::ostream    *out_;
  const MatrixOp  *G_;
  const MatrixConvertToSparseFortranCompatible
            *convG_;
  size_type     G_nz_;  // Remember the number of nonzeros of G
  const MatrixOp  *A_;
  const MatrixConvertToSparseFortranCompatible
            *convA_;
  size_type     A_nz_;  // Remember the number of nonzeros of A

  // //////////////////////////////
  // Private member functions

  void assert_matrices_set() const;

  void assert_initialized() const;

  void validate_and_set_matrices( const MatrixOp& G, const MatrixOp& A );

};  // end class MatrixKKTFullSpaceRelaxed

} // end namespace ConstrainedOptPack

#endif  // MATRIX_KKT_FULL_SPACE_RELAXED_H