Tsqr_NodeTsqr.hpp

// @HEADER
// ***********************************************************************
//
//                 Anasazi: Block Eigensolvers Package
//                 Copyright (2010) 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 Michael A. Heroux (maherou@sandia.gov)
//
// ***********************************************************************
// @HEADER

#ifndef __TSQR_Tsqr_NodeTsqr_hpp
#define __TSQR_Tsqr_NodeTsqr_hpp

#include <Tsqr_ApplyType.hpp>
#include <Tsqr_Lapack.hpp>
#include <Tsqr_MatView.hpp>
#include <Tsqr_ScalarTraits.hpp>
#include <cstring> // size_t


namespace TSQR {

  template< class LocalOrdinal, class Scalar >
  class NodeTsqrFactorOutput {
  public:
    NodeTsqrFactorOutput () {}
    virtual ~NodeTsqrFactorOutput() = 0;
  };

  template< class LocalOrdinal, class Scalar >
  class NodeTsqr {
  public:
    typedef Scalar scalar_type;
    typedef typename ScalarTraits< Scalar >::magnitude_type magnitude_type;
    typedef LocalOrdinal ordinal_type;
    typedef NodeTsqrFactorOutput factor_output_type;

    NodeTsqr(const size_t cacheBlockSize = 0) {}
    virtual ~NodeTsqr() {}

    bool QR_produces_R_factor_with_nonnegative_diagonal () const {
      return LAPACK< LocalOrdinal, Scalar >::QR_produces_R_factor_with_nonnegative_diagonal;
    }

    virtual size_t
    cache_block_size() const = 0;

    virtual void
    cache_block (const LocalOrdinal nrows,
     const LocalOrdinal ncols, 
     Scalar A_out[],
     const Scalar A_in[],
     const LocalOrdinal lda_in) const = 0;

    virtual void
    un_cache_block (const LocalOrdinal nrows,
        const LocalOrdinal ncols,
        Scalar A_out[],
        const LocalOrdinal lda_out,       
        const Scalar A_in[]) const = 0;

    virtual factor_output_type
    factor (const LocalOrdinal nrows,
      const LocalOrdinal ncols, 
      Scalar A[],
      const LocalOrdinal lda,
      Scalar R[],
      const LocalOrdinal ldr,
      const bool contiguous_cache_blocks) = 0;

    virtual void
    apply (const ApplyType& apply_type,
     const LocalOrdinal nrows,
     const LocalOrdinal ncols_Q,
     const Scalar* const Q,
     const LocalOrdinal ldq,
     const FactorOutput& factor_output,
     const LocalOrdinal ncols_C,
     Scalar* const C,
     const LocalOrdinal ldc,
     const bool contiguous_cache_blocks) = 0;

    virtual void
    explicit_Q (const LocalOrdinal nrows,
    const LocalOrdinal ncols_Q,
    const Scalar Q[],
    const LocalOrdinal ldq,
    const factor_output_type& factor_output,
    const LocalOrdinal ncols_C,
    Scalar C[],
    const LocalOrdinal ldc,
    const bool contiguous_cache_blocks) = 0;

    virtual void
    Q_times_B (const LocalOrdinal nrows,
         const LocalOrdinal ncols,
         Scalar Q[],
         const LocalOrdinal ldq,
         const Scalar B[],
         const LocalOrdinal ldb,
         const bool contiguous_cache_blocks) const = 0;

    virtual LocalOrdinal
    reveal_R_rank (const LocalOrdinal ncols,
       Scalar R[],
       const LocalOrdinal ldr,
       Scalar U[],
       const LocalOrdinal ldu,
       const magnitude_type tol) const = 0;

    virtual LocalOrdinal
    reveal_rank (const LocalOrdinal nrows,
     const LocalOrdinal ncols,
     Scalar Q[],
     const LocalOrdinal ldq,
     Scalar R[],
     const LocalOrdinal ldr,
     const magnitude_type tol,
     const bool contiguous_cache_blocks) = 0;

    virtual void
    fill_with_zeros (const LocalOrdinal nrows,
         const LocalOrdinal ncols,
         Scalar A[],
         const LocalOrdinal lda, 
         const bool contiguous_cache_blocks = false) = 0;

    template< class MatrixViewType >
    virtual MatrixViewType
    top_block (const MatrixViewType& C, 
         const bool contiguous_cache_blocks = false) const = 0;
  };
} // namespace TSQR


#endif __TSQR_Tsqr_NodeTsqr_hpp