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.
// 
// 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 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