Thyra_MultiVectorBase_decl.hpp

// @HEADER
// ***********************************************************************
// 
//    Thyra: Interfaces and Support for Abstract Numerical Algorithms
//                 Copyright (2004) 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 (bartlettra@ornl.gov) 
// 
// ***********************************************************************
// @HEADER

#ifndef THYRA_MULTI_VECTOR_BASE_DECL_HPP
#define THYRA_MULTI_VECTOR_BASE_DECL_HPP

#include "Thyra_LinearOpBase_decl.hpp"
#include "Thyra_RowStatLinearOpBase.hpp"
#include "Thyra_ScaledLinearOpBase.hpp"
#include "RTOpPack_RTOpT.hpp"


namespace Thyra {


template<class Scalar>
class MultiVectorBase : virtual public LinearOpBase<Scalar>, 
                        virtual public RowStatLinearOpBase<Scalar>,
                        virtual public ScaledLinearOpBase<Scalar>
{
public:

#ifdef THYRA_INJECT_USING_DECLARATIONS
  using LinearOpBase<Scalar>::apply;
#endif


  void assign(Scalar alpha)
    { assignImpl(alpha); }

  void assign(const MultiVectorBase<Scalar>& mv)
    { assignMultiVecImpl(mv); }

  void scale(Scalar alpha)
    { scaleImpl(alpha); }

  void update(
    Scalar alpha,
    const MultiVectorBase<Scalar>& mv
    )
    { updateImpl(alpha, mv); }

  void linear_combination(
    const ArrayView<const Scalar>& alpha,
    const ArrayView<const Ptr<const MultiVectorBase<Scalar> > >& mv,
    const Scalar& beta
    )
    { linearCombinationImpl(alpha, mv, beta); }

  void dots(
    const MultiVectorBase<Scalar>& mv,
    const ArrayView<Scalar>& prods
    ) const
    { dotsImpl(mv, prods); }

  void norms_1(
    const ArrayView<typename ScalarTraits<Scalar>::magnitudeType>& norms
    ) const
    { norms1Impl(norms); }

  void norms_2(
    const ArrayView<typename ScalarTraits<Scalar>::magnitudeType>& norms
    ) const
    { norms2Impl(norms); }

  void norms_inf(
    const ArrayView<typename ScalarTraits<Scalar>::magnitudeType>& norms
    ) const
    { normsInfImpl(norms); }



  RCP<const VectorBase<Scalar> > col(Ordinal j) const
    { return colImpl(j); }

  RCP<VectorBase<Scalar> > col(Ordinal j)
    { return nonconstColImpl(j); }



  RCP<const MultiVectorBase<Scalar> >
  subView( const Range1D& colRng ) const
    {
      return contigSubViewImpl(colRng);
    }

  RCP<MultiVectorBase<Scalar> >
  subView( const Range1D& colRng )
    { return nonconstContigSubViewImpl(colRng); }

  RCP<const MultiVectorBase<Scalar> >
  subView( const ArrayView<const int> &cols ) const
    { return nonContigSubViewImpl(cols); }

  RCP<MultiVectorBase<Scalar> >
  subView( const ArrayView<const int> &cols )
    { return nonconstNonContigSubViewImpl(cols); }
  


  void applyOp(
    const RTOpPack::RTOpT<Scalar> &primary_op,
    const ArrayView<const Ptr<const MultiVectorBase<Scalar> > > &multi_vecs,
    const ArrayView<const Ptr<MultiVectorBase<Scalar> > > &targ_multi_vecs,
    const ArrayView<const Ptr<RTOpPack::ReductTarget> > &reduct_objs,
    const Ordinal primary_global_offset
    ) const
    {
      mvMultiReductApplyOpImpl(primary_op, multi_vecs, targ_multi_vecs,
        reduct_objs, primary_global_offset);
    }

  void applyOp(
    const RTOpPack::RTOpT<Scalar> &primary_op,
    const RTOpPack::RTOpT<Scalar> &secondary_op,
    const ArrayView<const Ptr<const MultiVectorBase<Scalar> > > &multi_vecs,
    const ArrayView<const Ptr<MultiVectorBase<Scalar> > > &targ_multi_vecs,
    const Ptr<RTOpPack::ReductTarget> &reduct_obj,
    const Ordinal primary_global_offset
    ) const
    {
      mvSingleReductApplyOpImpl(primary_op, secondary_op, multi_vecs, targ_multi_vecs,
        reduct_obj, primary_global_offset);
    }
  


  void acquireDetachedView(
    const Range1D &rowRng,
    const Range1D &colRng,
    RTOpPack::ConstSubMultiVectorView<Scalar> *sub_mv
    ) const
    { acquireDetachedMultiVectorViewImpl( rowRng, colRng, sub_mv ); }

  void releaseDetachedView(
    RTOpPack::ConstSubMultiVectorView<Scalar>* sub_mv
    ) const
    { releaseDetachedMultiVectorViewImpl(sub_mv); }

  void acquireDetachedView(
    const Range1D &rowRng,
    const Range1D &colRng,
    RTOpPack::SubMultiVectorView<Scalar> *sub_mv
    )
    { acquireNonconstDetachedMultiVectorViewImpl(rowRng,colRng,sub_mv); }

  void commitDetachedView(
    RTOpPack::SubMultiVectorView<Scalar>* sub_mv
    )
    { commitNonconstDetachedMultiVectorViewImpl(sub_mv); }



  virtual RCP<MultiVectorBase<Scalar> > clone_mv() const = 0;



  RCP<const LinearOpBase<Scalar> > clone() const;


protected:


  virtual void assignImpl(Scalar alpha) = 0;

  virtual void assignMultiVecImpl(const MultiVectorBase<Scalar>& mv) = 0;

  virtual void scaleImpl(Scalar alpha) = 0;

  virtual void updateImpl(
    Scalar alpha,
    const MultiVectorBase<Scalar>& mv
    ) = 0;

  virtual void linearCombinationImpl(
    const ArrayView<const Scalar>& alpha,
    const ArrayView<const Ptr<const MultiVectorBase<Scalar> > >& mv,
    const Scalar& beta
    ) = 0;

  virtual void dotsImpl(
    const MultiVectorBase<Scalar>& mv,
    const ArrayView<Scalar>& prods
    ) const = 0;

  virtual void norms1Impl(
    const ArrayView<typename ScalarTraits<Scalar>::magnitudeType>& norms
    ) const = 0;

  virtual void norms2Impl(
    const ArrayView<typename ScalarTraits<Scalar>::magnitudeType>& norms
    ) const = 0;

  virtual void normsInfImpl(
    const ArrayView<typename ScalarTraits<Scalar>::magnitudeType>& norms
    ) const = 0;

  virtual RCP<const VectorBase<Scalar> > colImpl(Ordinal j) const;

  virtual RCP<VectorBase<Scalar> > nonconstColImpl(Ordinal j) = 0;

  virtual RCP<const MultiVectorBase<Scalar> >
  contigSubViewImpl( const Range1D& colRng ) const = 0;

  virtual RCP<MultiVectorBase<Scalar> >
  nonconstContigSubViewImpl( const Range1D& colRng ) = 0;

  virtual RCP<const MultiVectorBase<Scalar> >
  nonContigSubViewImpl( const ArrayView<const int> &cols ) const = 0;

  virtual RCP<MultiVectorBase<Scalar> >
  nonconstNonContigSubViewImpl( const ArrayView<const int> &cols ) = 0;

  virtual void mvMultiReductApplyOpImpl(
    const RTOpPack::RTOpT<Scalar> &primary_op,
    const ArrayView<const Ptr<const MultiVectorBase<Scalar> > > &multi_vecs,
    const ArrayView<const Ptr<MultiVectorBase<Scalar> > > &targ_multi_vecs,
    const ArrayView<const Ptr<RTOpPack::ReductTarget> > &reduct_objs,
    const Ordinal primary_global_offset
    ) const = 0;

  virtual void mvSingleReductApplyOpImpl(
    const RTOpPack::RTOpT<Scalar> &primary_op,
    const RTOpPack::RTOpT<Scalar> &secondary_op,
    const ArrayView<const Ptr<const MultiVectorBase<Scalar> > > &multi_vecs,
    const ArrayView<const Ptr<MultiVectorBase<Scalar> > > &targ_multi_vecs,
    const Ptr<RTOpPack::ReductTarget> &reduct_obj,
    const Ordinal primary_global_offset
    ) const = 0;

  virtual void acquireDetachedMultiVectorViewImpl(
    const Range1D &rowRng,
    const Range1D &colRng,
    RTOpPack::ConstSubMultiVectorView<Scalar> *sub_mv
    ) const = 0;

  virtual void releaseDetachedMultiVectorViewImpl(
    RTOpPack::ConstSubMultiVectorView<Scalar>* sub_mv
    ) const = 0;

  virtual void acquireNonconstDetachedMultiVectorViewImpl(
    const Range1D &rowRng,
    const Range1D &colRng,
    RTOpPack::SubMultiVectorView<Scalar> *sub_mv
    ) = 0;

  virtual void commitNonconstDetachedMultiVectorViewImpl(
    RTOpPack::SubMultiVectorView<Scalar>* sub_mv
    ) = 0;

  virtual bool rowStatIsSupportedImpl(
    const RowStatLinearOpBaseUtils::ERowStat rowStat) const;

  virtual void getRowStatImpl(
    const RowStatLinearOpBaseUtils::ERowStat rowStat,
    const Ptr<VectorBase<Scalar> > &rowStatVec) const;

  virtual bool supportsScaleLeftImpl() const;
  
  virtual bool supportsScaleRightImpl() const;
  
  virtual void scaleLeftImpl(const VectorBase< Scalar > &row_scaling);
  
  virtual void scaleRightImpl(const VectorBase< Scalar > &col_scaling);


  void absRowSum(const Teuchos::Ptr<Thyra::VectorBase<Scalar> > & output) const;

  void absColSum(const Teuchos::Ptr<Thyra::VectorBase<Scalar> > & output) const;

public:

private:
  
  // Not defined and not to be called
  MultiVectorBase<Scalar>&
  operator=(const MultiVectorBase<Scalar>&);

};


template<class Scalar>
inline
void applyOp(
  const RTOpPack::RTOpT<Scalar> &primary_op,
  const ArrayView<const Ptr<const MultiVectorBase<Scalar> > > &multi_vecs,
  const ArrayView<const Ptr<MultiVectorBase<Scalar> > > &targ_multi_vecs,
  const ArrayView<const Ptr<RTOpPack::ReductTarget> > &reduct_objs,
  const Ordinal primary_global_offset = 0
  )
{
  if(multi_vecs.size())
    multi_vecs[0]->applyOp(primary_op, multi_vecs, targ_multi_vecs,
      reduct_objs, primary_global_offset);
  else if(targ_multi_vecs.size())
    targ_multi_vecs[0]->applyOp(primary_op, multi_vecs, targ_multi_vecs,
      reduct_objs, primary_global_offset);
}


template<class Scalar>
inline
void applyOp(
  const RTOpPack::RTOpT<Scalar> &primary_op,
  const RTOpPack::RTOpT<Scalar> &secondary_op,
  const ArrayView<const Ptr<const MultiVectorBase<Scalar> > > &multi_vecs,
  const ArrayView<const Ptr<MultiVectorBase<Scalar> > > &targ_multi_vecs,
  const Ptr<RTOpPack::ReductTarget> &reduct_obj,
  const Ordinal primary_global_offset = 0
  )
{
  if(multi_vecs.size())
    multi_vecs[0]->applyOp(primary_op, secondary_op, multi_vecs, targ_multi_vecs,
      reduct_obj, primary_global_offset);
  else if(targ_multi_vecs.size())
    targ_multi_vecs[0]->applyOp(primary_op, secondary_op, multi_vecs, targ_multi_vecs,
      reduct_obj, primary_global_offset);
}


} // namespace Thyra


#endif // THYRA_MULTI_VECTOR_BASE_DECL_HPP