NOX_Playa_Vector.hpp

// $Id$ 
// $Source$ 

//@HEADER
//   
//@HEADER

#ifndef NOX_Playa_VECTOR_H
#define NOX_Playa_VECTOR_H

#include "NOX_Abstract_Vector.H" // base class
#include "NOX_Common.H" // for #include<vector> 
#include "PlayaVectorDecl.hpp" // definitions for Playa Vectors
#include "PlayaVectorSpaceDecl.hpp"

namespace NOX 
{


namespace NOXPlaya 
{
using Teuchos::RCP;
  
class Vector : public NOX::Abstract::Vector 
{

public: 

  Vector(const NOX::NOXPlaya::Vector& source, 
    NOX::CopyType type = DeepCopy);

  Vector(const Playa::Vector<double>& source, 
    NOX::CopyType type = DeepCopy);

  Vector(const NOX::NOXPlaya::Vector& source, 
    int numdigits, 
    NOX::CopyType type = DeepCopy);

  Vector(const Playa::Vector<double>& source, 
    int numdigits,
    NOX::CopyType type = DeepCopy);

  /* There's no need to write an explicit dtor for this class, because
   * the Playa vector cleans up its own memory. I've commented out 
   * this method for now, but it should probably just be deleted. 
   * - KL 12 July 2004 */ 
  //~Vector();

  Playa::Vector<double>& getPlayaVector();

  const Playa::Vector<double>& getPlayaVector() const;

  int getPrecision() const;


  NOX::Abstract::Vector& init(double value);

  NOX::Abstract::Vector& operator=(const NOX::NOXPlaya::Vector& y);
  NOX::Abstract::Vector& operator=(const NOX::Abstract::Vector& y);

  /* Element access should not be implemented in this class; it should
   * be done through the LoadableVector and AccessibleVector 
   * interfaces of Playa.
   * -KL 12 July 2004  */
  // Store value in the i-th element of a vector 
  //void setElement(int i, const double& value);

  // Return the i-th element (const version).
  //const double& getElement(int i) const;
  
  NOX::Abstract::Vector& abs(const NOX::NOXPlaya::Vector& y);
  NOX::Abstract::Vector& abs(const NOX::Abstract::Vector& y);
  
  NOX::Abstract::Vector& reciprocal(const NOX::NOXPlaya::Vector& y);
  NOX::Abstract::Vector& reciprocal(const NOX::Abstract::Vector& y);
  
  
  
  // derived
  NOX::Abstract::Vector& scale(double gamma);
  
  // derived
  NOX::Abstract::Vector& scale(const NOX::NOXPlaya::Vector& a);
  NOX::Abstract::Vector& scale(const NOX::Abstract::Vector& a);
  
  // derived
  NOX::Abstract::Vector& update(double alpha, const NOX::NOXPlaya::Vector& a, double gamma = 0.0);
  NOX::Abstract::Vector& update(double alpha, const NOX::Abstract::Vector& a, double gamma = 0.0);
  
  // derived
  NOX::Abstract::Vector& update(double alpha, const NOX::NOXPlaya::Vector& a, 
    double beta, const NOX::NOXPlaya::Vector& b,
    double gamma = 0.0);
  NOX::Abstract::Vector& update(double alpha, const NOX::Abstract::Vector& a, 
    double beta, const NOX::Abstract::Vector& b,
    double gamma = 0.0);
  
  
  
  // derived
#ifdef TRILINOS_6
  NOX::Abstract::Vector* clone(NOX::CopyType type = NOX::DeepCopy) const;
#else
  RCP<NOX::Abstract::Vector> clone(NOX::CopyType type = NOX::DeepCopy) const ;
#endif
  
  
  
  // derived
  double norm(NOX::Abstract::Vector::NormType type = NOX::Abstract::Vector::TwoNorm) const;
  
  // derived
  double norm(const NOX::NOXPlaya::Vector& weights) const;
  double norm(const NOX::Abstract::Vector& weights) const;
  
  
  
  // derived
  double dot(const NOX::NOXPlaya::Vector& y) const;
  double dot(const NOX::Abstract::Vector& y) const;
  double innerProduct(const NOX::Abstract::Vector& y) const;
  
  
  // derived
  int length() const;


  ostream& leftshift(std::ostream& stream) const;

  // derived
  void print() const;

private:

  int precision;

  Playa::Vector<double> x;
};

} // namespace Playa
} // namespace NOX


namespace std{
ostream& operator<<(std::ostream& stream, const NOX::NOXPlaya::Vector& v);
}

#endif