MADNESS  version 0.9
Public Types | Public Member Functions | Static Public Attributes | Friends | List of all members
madness::Vector< T, N > Class Template Reference

A simple, fixed dimension Coordinate. More...

#include <array.h>

Public Types

typedef std::array< T, NarrayT
 
typedef arrayT::value_type value_type
 
typedef arrayT::iterator iterator
 
typedef arrayT::const_iterator const_iterator
 
typedef arrayT::reverse_iterator reverse_iterator
 
typedef
arrayT::const_reverse_iterator 
const_reverse_iterator
 
typedef arrayT::reference reference
 
typedef arrayT::const_reference const_reference
 
typedef arrayT::size_type size_type
 
typedef arrayT::difference_type difference_type
 

Public Member Functions

 Vector ()
 Default constructor does not initialize vector contents. More...
 
template<typename Q >
 Vector (Q t)
 Initialize all elements to value t. More...
 
template<typename Q >
 Vector (const Q(&t)[N])
 Construct from a C-style array of the same dimension. More...
 
template<typename Q , typename A >
 Vector (const std::vector< Q, A > &t)
 Construct from an STL vector of equal or greater length. More...
 
template<typename Q >
 Vector (const std::array< Q, N > &t)
 
 Vector (const Vector< T, N > &other)
 Copy constructor is deep (since a coordinate is POD) More...
 
template<typename Q >
 Vector (const Vector< Q, N > &other)
 Copy constructor is deep (since a coordinate is POD) More...
 
Vector< T, N > & operator= (const Vector< T, N > &other)
 Assignment is deep (since a vector is POD) More...
 
template<typename Q >
Vector< T, N > & operator= (const Vector< Q, N > &other)
 Assignment is deep (since a vector is POD) More...
 
template<typename Q , typename A >
Vector< T, N > & operator= (const std::vector< Q, A > &other)
 Assignment is deep (since a vector is POD) More...
 
Vector< T, N > & operator= (const T &t)
 Fill from scalar value. More...
 
 operator std::array< T, N > ()
 
iterator begin ()
 
const_iterator begin () const
 
iterator end ()
 
const_iterator end () const
 
reverse_iterator rbegin ()
 
const_reverse_iterator rbegin () const
 
reverse_iterator rend ()
 
const_reverse_iterator rend () const
 
size_type size () const
 
bool empty () const
 
size_type max_size () const
 
reference operator[] (size_type i)
 
const_reference operator[] (size_type i) const
 
reference at (size_type i)
 
const_reference at (size_type i) const
 
reference front ()
 
const_reference front () const
 
reference back ()
 
const_reference back () const
 
const T * data () const
 
T * c_array ()
 
void swap (Vector< T, N > &other)
 
void fill (const T &t)
 
template<typename Q >
Vector< T, N > & operator*= (Q q)
 In-place element-wise multiplcation by a scalar. More...
 
template<typename Q >
Vector< T, N > & operator+= (const Vector< Q, N > &q)
 In-place element-wise addition of another vector. More...
 
template<typename Q >
Vector< T, N > & operator-= (const Vector< Q, N > &q)
 In-place element-wise subtraction of another vector. More...
 
normf () const
 return the 2-norm of the vector elements More...
 
template<typename Archive >
void serialize (Archive &ar)
 Support for MADNESS serialization. More...
 
hashT hash () const
 Support for MADNESS hashing. More...
 

Static Public Attributes

static const size_type static_size = N
 The size of the vector. More...
 

Friends

bool operator== (const Vector< T, N > &l, const Vector< T, N > &r)
 
bool operator!= (const Vector< T, N > &l, const Vector< T, N > &r)
 
bool operator< (const Vector< T, N > &l, const Vector< T, N > &r)
 
bool operator> (const Vector< T, N > &l, const Vector< T, N > &r)
 
bool operator<= (const Vector< T, N > &l, const Vector< T, N > &r)
 
bool operator>= (const Vector< T, N > &l, const Vector< T, N > &r)
 
std::ostream & operator<< (std::ostream &s, const Vector< T, N > &v)
 Output Vector to stream for human consumption. More...
 

Detailed Description

template<typename T, std::size_t N>
class madness::Vector< T, N >

A simple, fixed dimension Coordinate.

Eliminates memory allocation cost, is just POD so can be copied easily and allocated on the stack, and the known dimension permits aggressive compiler optimizations.

Member Typedef Documentation

template<typename T, std::size_t N>
typedef std::array<T,N> madness::Vector< T, N >::arrayT
template<typename T, std::size_t N>
typedef arrayT::const_iterator madness::Vector< T, N >::const_iterator
template<typename T, std::size_t N>
typedef arrayT::const_reference madness::Vector< T, N >::const_reference
template<typename T, std::size_t N>
typedef arrayT::const_reverse_iterator madness::Vector< T, N >::const_reverse_iterator
template<typename T, std::size_t N>
typedef arrayT::difference_type madness::Vector< T, N >::difference_type
template<typename T, std::size_t N>
typedef arrayT::iterator madness::Vector< T, N >::iterator
template<typename T, std::size_t N>
typedef arrayT::reference madness::Vector< T, N >::reference
template<typename T, std::size_t N>
typedef arrayT::reverse_iterator madness::Vector< T, N >::reverse_iterator
template<typename T, std::size_t N>
typedef arrayT::size_type madness::Vector< T, N >::size_type
template<typename T, std::size_t N>
typedef arrayT::value_type madness::Vector< T, N >::value_type

Constructor & Destructor Documentation

template<typename T, std::size_t N>
madness::Vector< T, N >::Vector ( )
inline

Default constructor does not initialize vector contents.

template<typename T, std::size_t N>
template<typename Q >
madness::Vector< T, N >::Vector ( t)
inlineexplicit

Initialize all elements to value t.

template<typename T, std::size_t N>
template<typename Q >
madness::Vector< T, N >::Vector ( const Q(&)  t[N])
inlineexplicit

Construct from a C-style array of the same dimension.

template<typename T, std::size_t N>
template<typename Q , typename A >
madness::Vector< T, N >::Vector ( const std::vector< Q, A > &  t)
inlineexplicit

Construct from an STL vector of equal or greater length.

template<typename T, std::size_t N>
template<typename Q >
madness::Vector< T, N >::Vector ( const std::array< Q, N > &  t)
inlineexplicit
template<typename T, std::size_t N>
madness::Vector< T, N >::Vector ( const Vector< T, N > &  other)
inline

Copy constructor is deep (since a coordinate is POD)

template<typename T, std::size_t N>
template<typename Q >
madness::Vector< T, N >::Vector ( const Vector< Q, N > &  other)
inline

Copy constructor is deep (since a coordinate is POD)

Member Function Documentation

template<typename T, std::size_t N>
reference madness::Vector< T, N >::at ( size_type  i)
inline
template<typename T, std::size_t N>
const_reference madness::Vector< T, N >::at ( size_type  i) const
inline
template<typename T, std::size_t N>
reference madness::Vector< T, N >::back ( )
inline
template<typename T, std::size_t N>
const_reference madness::Vector< T, N >::back ( ) const
inline
template<typename T, std::size_t N>
iterator madness::Vector< T, N >::begin ( )
inline

Referenced by TipMolecule::Inhomogeneity(), and main().

template<typename T, std::size_t N>
const_iterator madness::Vector< T, N >::begin ( ) const
inline
template<typename T, std::size_t N>
T* madness::Vector< T, N >::c_array ( )
inline
template<typename T, std::size_t N>
const T* madness::Vector< T, N >::data ( ) const
inline
template<typename T, std::size_t N>
bool madness::Vector< T, N >::empty ( ) const
inline
template<typename T, std::size_t N>
iterator madness::Vector< T, N >::end ( )
inline
template<typename T, std::size_t N>
const_iterator madness::Vector< T, N >::end ( ) const
inline
template<typename T, std::size_t N>
void madness::Vector< T, N >::fill ( const T &  t)
inline
template<typename T, std::size_t N>
reference madness::Vector< T, N >::front ( )
inline
template<typename T, std::size_t N>
const_reference madness::Vector< T, N >::front ( ) const
inline
template<typename T, std::size_t N>
hashT madness::Vector< T, N >::hash ( ) const
inline

Support for MADNESS hashing.

template<typename T, std::size_t N>
size_type madness::Vector< T, N >::max_size ( ) const
inline
template<typename T, std::size_t N>
T madness::Vector< T, N >::normf ( ) const
inline

return the 2-norm of the vector elements

Referenced by madness::n12().

template<typename T, std::size_t N>
madness::Vector< T, N >::operator std::array< T, N > ( )
inline
template<typename T, std::size_t N>
template<typename Q >
Vector<T,N>& madness::Vector< T, N >::operator*= ( q)
inline

In-place element-wise multiplcation by a scalar.

Returns a reference to this for chaining operations

template<typename T, std::size_t N>
template<typename Q >
Vector<T,N>& madness::Vector< T, N >::operator+= ( const Vector< Q, N > &  q)
inline

In-place element-wise addition of another vector.

Returns a reference to this for chaining operations

template<typename T, std::size_t N>
template<typename Q >
Vector<T,N>& madness::Vector< T, N >::operator-= ( const Vector< Q, N > &  q)
inline

In-place element-wise subtraction of another vector.

Returns a reference to this for chaining operations

template<typename T, std::size_t N>
Vector<T,N>& madness::Vector< T, N >::operator= ( const Vector< T, N > &  other)
inline

Assignment is deep (since a vector is POD)

Referenced by madness::Vector< int, 3 >::Vector().

template<typename T, std::size_t N>
template<typename Q >
Vector<T,N>& madness::Vector< T, N >::operator= ( const Vector< Q, N > &  other)
inline

Assignment is deep (since a vector is POD)

template<typename T, std::size_t N>
template<typename Q , typename A >
Vector<T,N>& madness::Vector< T, N >::operator= ( const std::vector< Q, A > &  other)
inline

Assignment is deep (since a vector is POD)

template<typename T, std::size_t N>
Vector<T,N>& madness::Vector< T, N >::operator= ( const T &  t)
inline

Fill from scalar value.

template<typename T, std::size_t N>
reference madness::Vector< T, N >::operator[] ( size_type  i)
inline
template<typename T, std::size_t N>
const_reference madness::Vector< T, N >::operator[] ( size_type  i) const
inline
template<typename T, std::size_t N>
reverse_iterator madness::Vector< T, N >::rbegin ( )
inline
template<typename T, std::size_t N>
const_reverse_iterator madness::Vector< T, N >::rbegin ( ) const
inline
template<typename T, std::size_t N>
reverse_iterator madness::Vector< T, N >::rend ( )
inline
template<typename T, std::size_t N>
const_reverse_iterator madness::Vector< T, N >::rend ( ) const
inline
template<typename T, std::size_t N>
template<typename Archive >
void madness::Vector< T, N >::serialize ( Archive &  ar)
inline

Support for MADNESS serialization.

template<typename T, std::size_t N>
size_type madness::Vector< T, N >::size ( ) const
inline
template<typename T, std::size_t N>
void madness::Vector< T, N >::swap ( Vector< T, N > &  other)
inline

Referenced by madness::swap().

Friends And Related Function Documentation

template<typename T, std::size_t N>
bool operator!= ( const Vector< T, N > &  l,
const Vector< T, N > &  r 
)
friend
template<typename T, std::size_t N>
bool operator< ( const Vector< T, N > &  l,
const Vector< T, N > &  r 
)
friend
template<typename T, std::size_t N>
std::ostream& operator<< ( std::ostream &  s,
const Vector< T, N > &  v 
)
friend

Output Vector to stream for human consumption.

template<typename T, std::size_t N>
bool operator<= ( const Vector< T, N > &  l,
const Vector< T, N > &  r 
)
friend
template<typename T, std::size_t N>
bool operator== ( const Vector< T, N > &  l,
const Vector< T, N > &  r 
)
friend
template<typename T, std::size_t N>
bool operator> ( const Vector< T, N > &  l,
const Vector< T, N > &  r 
)
friend
template<typename T, std::size_t N>
bool operator>= ( const Vector< T, N > &  l,
const Vector< T, N > &  r 
)
friend

Member Data Documentation

template<typename T, std::size_t N>
const size_type madness::Vector< T, N >::static_size = N
static

The size of the vector.


The documentation for this class was generated from the following file: