PlayaVectorDecl.hpp

/* @HEADER@ */
//   
 /* @HEADER@ */

#ifndef PLAYA_VECTORDECL_HPP
#define PLAYA_VECTORDECL_HPP

#include "PlayaDefs.hpp"
#include "PlayaHandle.hpp"
#include "PlayaVectorBaseDecl.hpp"
#include "PlayaVectorSpaceDecl.hpp"
#include "PlayaVectorFunctorsDecl.hpp"
#include "Teuchos_TimeMonitor.hpp"

namespace Playa
{

template <class Scalar, int> class LCN;
  
template <class Scalar>
class Vector : public Playa::Handle<VectorBase<Scalar> >
{
public:
  HANDLE_CTORS(Vector<Scalar>, VectorBase<Scalar>);

  template <int N>
  Vector<Scalar>(const LCN<Scalar, N>& x);


  Vector<Scalar>& operator=(const LCN<Scalar, 1>& x);

  Vector<Scalar>& operator=(const LCN<Scalar, 2>& x);

  Vector<Scalar>& operator=(const LCN<Scalar, 3>& x);

  template <int N>
  Vector<Scalar>& operator=(const LCN<Scalar, N>& x);


  Vector<Scalar>& operator+=(const Vector<Scalar>& other);

  Vector<Scalar>& operator+=(const LCN<Scalar, 1>& x);

  Vector<Scalar>& operator+=(const LCN<Scalar, 2>& x);

  template <int N>
  Vector<Scalar>& operator+=(const LCN<Scalar, N>& x);

  Vector<Scalar>& operator-=(const Vector<Scalar>& other);

  Vector<Scalar>& operator-=(const LCN<Scalar, 1>& x);

  Vector<Scalar>& operator-=(const LCN<Scalar, 2>& x);

  template <int N>
  Vector<Scalar>& operator-=(const LCN<Scalar, N>& x);

  Vector<Scalar>& operator*=(const Scalar& a);

  Vector<Scalar>& operator/=(const Scalar& a);

  VectorSpace<Scalar> space() const 
    {return this->ptr()->space();}

  const MPIComm& comm() const 
    {return this->space().comm();}

  int dim() const
    {
      return this->ptr()->space()->dim();
    }
      

  int numBlocks() const ;

  void setBlock(int i, const Vector<Scalar>& v);
      
  const Vector<Scalar>& getBlock(int i) const;
      
  Vector<Scalar> getNonConstBlock(int i) ;
      
  const Vector<Scalar>& getBlock(const BlockIterator<Scalar>& b) const;
      
  Vector<Scalar> getNonConstBlock(const BlockIterator<Scalar>& b);



  ConstDataChunk<Scalar> nextConstChunk() const ;
    
  NonConstDataChunk<Scalar> nextChunk() ;

  bool hasMoreChunks() const ;

  void rewind() const ;

  const Scalar& operator[](int localIndex) const ;
    
  Scalar& operator[](int localIndex);

  const Scalar& operator()(const BlockIterator<Scalar>& b,
    int localIndexWithinBlock) const ;
    
  Scalar& operator()(const BlockIterator<Scalar>& b,
    int localIndexWithinBlock) ;

  std::string description() const ;

  void print(std::ostream& os) const ;    


  Vector<Scalar>& scale(const Scalar& alpha);

  Vector<Scalar>& update(const Scalar& alpha, const Vector<Scalar>& x, 
    const Scalar& gamma=1.0);
  Vector<Scalar>& update(const Scalar& alpha, const Vector<Scalar>& x, 
    const Scalar& beta, const Vector<Scalar>& y, 
    const Scalar& gamma);
  Vector<Scalar>& update(const Scalar& alpha, const Vector<Scalar>& x, 
    const Scalar& beta, const Vector<Scalar>& y, 
    const Scalar& gamma, const Vector<Scalar>& z, 
    const Scalar& delta);

  Vector<Scalar>& acceptCopyOf(const Vector<Scalar>& x);

  Vector<Scalar> copy() const ;

  Vector<Scalar>& selfDotStar(const Vector<Scalar>& other) ;

  Vector<Scalar>& selfDotSlash(const Vector<Scalar>& other) ;

  Vector<Scalar> dotStar(const Vector<Scalar>& other) const ;

  Vector<Scalar> dotSlash(const Vector<Scalar>& other) const ;

  Vector<Scalar> reciprocal() const ;


  Vector<Scalar> abs() const ;

  Vector<Scalar>& selfReciprocal() ;

  Vector<Scalar>& selfAbs() ;

  Vector<Scalar>& randomize() ;

  void setToConstant(const Scalar& alpha) ;

      
  Scalar dot(const Vector<Scalar>& other) const ;

  Scalar operator*(const Vector<Scalar>& other) const ;

  Scalar norm1() const ;

  Scalar norm2() const ;

  Scalar norm2(const Vector<Scalar>& weights) const ;    


  Scalar normInf() const ;

  void zero();


  Scalar max() const;

  Scalar min()const;






  static RCP<Time>& opTimer()
    {
      static RCP<Time> rtn 
        = TimeMonitor::getNewTimer("Low-level vector operations");
      return rtn;
    }


  template <class UF> 
  Vector<Scalar>& applyUnaryFunctor(const UF& functor);

  template <class UF> 
  Vector<Scalar>& acceptUnaryFunctor(const UF& functor,
    const Vector<Scalar>& other);

  template <class VF> 
  Vector<Scalar>& applyBinaryFunctor(const VF& functor,
    const Vector<Scalar>& other);

  template <class VF> 
  Vector<Scalar>& applyTernaryFunctor(const VF& functor,
    const Vector<Scalar>& x, const Vector<Scalar>& y);

  template <class RF> 
  typename PlayaFunctors::VectorFunctorTraits<Scalar, RF>::ReturnType 
  applyUnaryReductionFunctor(
    const RF& functor)
    const ;

  template <class RF> 
  typename PlayaFunctors::VectorFunctorTraits<Scalar, RF>::ReturnType 
  applyBinaryReductionFunctor(const RF& functor, const Vector<Scalar>& other)
    const ;
    

    
    
protected:

  const Vector<Scalar>& getBlock(const std::deque<int>& iter) const ;

  Vector<Scalar> getNonConstBlock(const std::deque<int>& iter) ;
  

private:

};


template <class Scalar> class LoadableVector;
template <class Scalar>
LoadableVector<Scalar>* loadable(Vector<Scalar> vec) ;


template <class Scalar>
Scalar* dataPtr(Vector<Scalar> vec) ;

template <class Scalar>
const Scalar* dataPtr(const Vector<Scalar>& vec) ;


}

template <class Scalar> inline
std::ostream& operator<<(std::ostream& os, const Playa::Vector<Scalar>& x) 
{
  x.print(os);
  return os;
}




#endif