/home/brandes/workspace/LAMA/src/lama/Vector.hpp

Go to the documentation of this file.

#ifndef LAMA_VECTOR_HPP_
#define LAMA_VECTOR_HPP_

// for dll_import
#include <lama/config.hpp>

// base classes
#include <lama/Distributed.hpp>

// others
#include <lama/expression/Expression.hpp>
#include <lama/ContextFactory.hpp>

#include <lama/LAMATypes.hpp>
#include <lama/Scalar.hpp>
#include <lama/Context.hpp>

// logging
#include <logging/logging.hpp>

namespace lama
{

class Matrix;

typedef boost::shared_ptr<class Vector> VectorPtr;

class LAMA_DLL_IMPORTEXPORT Vector : public Distributed, 
                                     public Printable
{
public:

    static std::auto_ptr<Vector> createVector(
        const Scalar::ScalarType valueType,
        DistributionPtr distribution);

    typedef const Vector& ExpressionMemberType;

    virtual ~Vector();

    Vector& operator=(const Expression<Matrix,Vector,Times>& expression);

    Vector& operator=(const Expression<Scalar,
                                       Expression<Matrix,Vector,Times>,
                                       Times>& expression);

    Vector& operator=(const Expression<Expression<Scalar,Vector,Times>,
                                       Expression<Scalar,Vector,Times>,
                                       Plus >& expression);

    Vector& operator=(const Expression<Expression<Scalar,
                                                  Expression<Matrix,Vector,Times>,
                                                  Times>,
                                       Expression<Scalar,Vector,Times>,
                                       Plus>& expression);

    Vector& operator= (const Expression<Scalar,Vector,Times>& expression);

    Vector& operator= (const Expression<Vector,Vector,Plus>& expression);

    Vector& operator= (const Vector& other);

    Vector& operator*= ( const Scalar value );

    Vector& operator+= ( const Vector& other );

    Vector& operator+= ( const Expression<Scalar, Vector, Times>& expression );

    Vector& operator-= ( const Vector& other );

    Vector& operator=( const Scalar value );

    const Scalar operator()( const IndexType i ) const;

    Scalar operator*( const Vector& other ) const;
  
    virtual void buildValues( _LAMAArray& values ) const = 0;

    virtual void setValues( const _LAMAArray& values ) = 0;

    virtual Scalar::ScalarType getValueType() const = 0;

    virtual Scalar getValue(IndexType globalIndex) const =0;

    virtual Scalar min() const =0;

    virtual Scalar max() const =0;

    virtual Scalar l1Norm() const =0;

    virtual Scalar l2Norm() const =0;

    virtual Scalar maxNorm() const =0;

    //TODO: This is an uninitialized create, do we need a initialized create?
    //      What is a good interface for an initialized create?
    virtual std::auto_ptr<Vector> create() const =0;

    virtual std::auto_ptr<Vector> create( DistributionPtr distribution) const =0;

    inline IndexType size() const;

    virtual void swap( Vector& other ) = 0;

    virtual void writeAt(std::ostream& stream) const;

    virtual void assign( const Vector& other ) =0;

    virtual void assign( const _LAMAArray& localValues, DistributionPtr distribution ) = 0;
  
    virtual void buildLocalValues( _LAMAArray& localValues ) const = 0;

    virtual void assign( const Scalar value ) =0;

    virtual void assign( const Expression<Expression<Scalar,Vector,Times>,
                                          Expression<Scalar,Vector,Times>,
                                          Plus >& expression ) =0;

    virtual Scalar dotProduct( const Vector& other ) const =0;

    virtual void prefetch( const ContextPtr context ) const =0;

    virtual void wait() const =0;

    virtual void invert() =0;

    void setContext( ContextPtr location );

    inline ContextPtr getContext() const;

    virtual size_t getMemoryUsage() const =0;

    void resize( DistributionPtr distributionPtr );

    virtual void redistribute( DistributionPtr distribution ) =0;

protected:

    explicit Vector( const IndexType size = 0, ContextPtr context = ContextFactory::getContext( Context::Host )  );

    explicit Vector( DistributionPtr distribution, ContextPtr context = ContextFactory::getContext( Context::Host ) );

    Vector( const Vector& other );

    void swapVector( Vector& other ); 

    virtual void resizeImpl() =0;

    ContextPtr mContext;   

    LAMA_LOG_DECL_STATIC_LOGGER( logger );
};

IndexType Vector::size() const
{
    return getDistributionPtr()->getGlobalSize();
}

ContextPtr Vector::getContext() const
{
    return mContext;
}

}

#endif // LAMA_VECTOR_HPP_