Eagle::Vector Class Reference

A Vector is an fixed-size array (see class FixedArray) with vector space operations, i.e. More...

#include </home/werner/origo/vish/ocean/eagle/Vector.hpp>

List of all members.

Classes

• struct subvector

  Access part of the vector as a vector of smaller size. More...
  

Public Types

• enum { SIZE = FixedArray<T, SIZE = FixedArray<T }

  The number of elements in this array.
  

• typedef FixedArray< T, n > Base_t
• typedef FixedArray< T, n > FixedArray_t

  Exporting the type definition of this array cass type.
  

• typedef FixedArray< T, n >
  ::value_type value_type

  Export the type of the respective element value type.
  

• typedef Vector Vector_t

Public Member Functions

• template<class V > void set (const V &value)

  Assign all values to the same scalar.
  

• Vector ()

  Default constructor.
  

• Vector (const Vector &v)

  Copy constructor.
  

• Vector (const FixedArray_t &v)

  Upcast constructor.
  

• template<typename InputType > Vector (const Vector< InputType, SIZE > &V)

  Type conversion constructor.
  

• Vector (const T &a)

  Convenience Constructor: initialize the first element.
  

• Vector (const T &a, const T &b)

  Convenience Constructor: initialize the first two elements.
  

• Vector (const T &a, const T &b, const T &c)

  Convenience Constructor: initialize the first three elements.
  

• Vector (const T &a, const T &b, const T &c, const T &d)

  Convenience Constructor: initialize the first four elements.
  

• template<typename Indicable > Vector (const Indicable &I, const AnyType &)

  Construct from indicable object, i.e.
  

• template<int CompType> Vector (const Vector &l, const Vector &r, const Operator< CompType > &)

  Computational constructor for binary operations on two vectors calls the Operator's ternary() member function for each element.
  

• template<class AType , class BType , int CompType> Vector (const FixedArray< AType, n > &l, const FixedArray< BType, n > &r, const Operator< CompType > &Op)

  Computational constructor for binary operations on two fixed arrays, calls the Operator's ternary() member function for each element.
  

• template<class AType , class ScalarType , int CompType> Vector (const FixedArray< AType, n > &l, const Operator< CompType > &, const ScalarType &scalar)

  Computational constructor from vector with scalar, calls the Operator's ternary() member function for each element and the scalar as its 3rd argument.
  

• template<class AType , class ScalarType , int CompType> Vector (const Operator< CompType > &, const ScalarType &scalar, const FixedArray< AType, n > &v)

  Computational constructor from scalar with vector calls the Operator's ternary() member function for each element and the scalar as its 2nd argument.
  

• Vector (const Vector &v, const Operator<'-'> &)

  Unitary minus computational constructor Applies the unitary minus to each element.
  

Friends

• std::ostream & operator<< (std::ostream &os, const Vector &v)

  Output operator of C++ I/O streams.
  

• Base_t & fixed_array ()

  Provide access to the base class, writable.
  

• const Base_t & fixed_array () const

  Provide access to the base class, read-only.
  

• template<int size, int offset> subvector< size, offset >
  ::Subvector_t & subvec ()
• template<int size, int offset> const subvector< size, offset >
  ::Subvector_t & subvec () const
• static Vector & upcast (FixedArray_t &F)
• static const Vector & upcast (const FixedArray_t &F)

• Vector & operator+= (const Vector &v)

  Self-addition.
  

• Vector & operator-= (const Vector &v)

  Self-subtraction.
  

• Vector & operator*= (const T &value)

  Self-multiplication.
  

• Vector & operator/= (const T &value)

  Self-division.
  

• Vector operator- () const

  Unary minus.
  

• Vector (const Vector &NV, const Sub &, const Sub &)

  Computational constructor for unary minus.
  

• Vector & operator= (const Vector &src)

  Assignment operator.
  

• template<class scalar > Assignment< Vector, 0 > operator= (const scalar &x)

  Assign first element with scalar and use consecutive comma expressions for assignment of further elements As such a Vector may be assigned as.
  

• template<class scalar > Vector operator* (const Vector &A, const scalar &V)

  Array * Scalar.
  

• template<class scalar > Vector operator* (const scalar &V, const Vector &A)

  Scalar * Array.
  

• template<class scalar > Vector operator/ (const Vector &A, const scalar &V)

  Array / Scalar.
  

• Vector operator+ (const Vector &A, const Vector &B)

  Array + Array.
  

• Vector operator- (const Vector &A, const Vector &B)

  Array - Array.
  

---

Detailed Description

A Vector is an fixed-size array (see class FixedArray) with vector space operations, i.e.

addition, subtraction and scalar multiplication. The class name Vector denotes any elements of a vector space and its functionality is not limited to vectors in the narrower meaning within differential geometry. As such, a Matrix or tensor of higher rank is derived from a Vector as well and inherits all vector space operations as provided by the Vector base class.

Various computational constructors are supported, which make use of the Operator<> template trait class.

Note:

The same cautions as when using FixedArray's apply, i.e. copying of objects of class Vector should be avoided because it will require to copy all elements.

Parameters:

N	The dimensionality of the vector, i.e. the number of elements.
T	The type of the elements which construct the vector.

Examples:

WebVish.cpp.

---

Constructor & Destructor Documentation

template<typename Indicable >

Eagle::Vector::Vector	(	const Indicable &	I,
		const AnyType &
	)		[inline]

Construct from indicable object, i.e.

anything which can be indiced with an integer. Example are native arrays or Vector types instantiations on other numerical types.

            double      values[5];
            Vector<4, double> V( values, AnyType() );

template<class AType , class ScalarType , int CompType>

Eagle::Vector::Vector	(	const FixedArray< AType, n > &	l,
		const Operator< CompType > &	,
		const ScalarType &	scalar
	)		[inline]

Computational constructor from vector with scalar, calls the Operator's ternary() member function for each element and the scalar as its 3rd argument.

Note:

The operator argument is the second argument here, not the last because when giving it as last it would lead to ambiguities with the alternative computational constructors

template<class AType , class ScalarType , int CompType>

Eagle::Vector::Vector	(	const Operator< CompType > &	,
		const ScalarType &	scalar,
		const FixedArray< AType, n > &	v
	)		[inline]

Computational constructor from scalar with vector calls the Operator's ternary() member function for each element and the scalar as its 2nd argument.

Note:

The operator argument is the first argument here, not the last because when giving it as last it would lead to ambiguities with the alternative computational constructors

---

Member Function Documentation

template<class scalar >

Assignment<Vector, 0> Eagle::Vector::operator=

(

const scalar &

x

)

[inline]

Assign first element with scalar and use consecutive comma expressions for assignment of further elements As such a Vector may be assigned as.

            Vector<4, double> V;
                V = 1.1, 2.2, 3.3, 4.4;

---

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

• ocean/eagle/Vector.hpp