Eagle::FixedArray Class Reference

A FixedArray is a simple copy-by-value array providing random access to its elements. More...

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

List of all members.

Classes

• struct subarray

  Helper class for retrieve a subset of the current array. More...
  

Public Types

• enum { SIZE = N }
• typedef
  FlattenedArray_t::value_type Element_t

  The maximally reduced type of elements stored here.
  

• typedef GetFixedArrayType
  < value >::result_t ElementAsFixedArray_t

  Element type as fixed array, if it is convertible to a fixed array.
  

• typedef FixedArray FixedArray_t

  Exporting the type definition of this array cass type.
  

• typedef FixedArrayFlattener
  < FixedArrayOfElements_t > FixedArrayFlattener_t

  Internal helper class.
  

• typedef FixedArray
  < ElementAsFixedArray_t, N > FixedArrayOfElements_t

  If the value is derived from a fixed array type itself, then the FixedArrayOfElements_t is an FixedArray<FixedArray<>> type.
  

• typedef
  FixedArrayFlattener_t::result_t FlattenedArray_t

  Reduction of this array type, if it is nested, to an flattened type which contains elementary types.
  

• typedef value value_type

  Export the type of the respective element value type.
  

Public Member Functions

• const Element_t * const_element_ptr () const
• const ElementAsFixedArray_t * const_elements_as_fixed_array () const
• const value * const_ptr (int i=0) const
• template<typename T > FixedArray & copy (const FixedArray< T, N > &F)
• FixedArray div (const FixedArray &r) const
• Element_t * element_ptr ()
• ElementAsFixedArray_t * elements_as_fixed_array ()
• void expandMax (FixedArray &MaxValues) const
• void expandMin (FixedArray &MinValues) const
• void expandMinMax (FixedArray &MinValues, FixedArray &MaxValues) const

  Expand a range given by MinValues,MaxValues to include the values of this array, done per component.
  

• FixedArray ()

  Default constructor (no explicit initialization!)
  

• template<typename T , typename ConversionFunctor > FixedArray (const FixedArray< T, N > &F, const ConversionFunctor &CF, const FA_CONVERT &)

  Construct array from another array type of same length.
  

• template<class AType , class BType , OperatorID_t CompType> FixedArray (const FixedArray< AType, N > &l, const FixedArray< BType, N > &r, const Operator< CompType > &)

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

• FixedArray (const value &a)

  Convenience Constructor: initialize the first element.
  

• FixedArray (const value &a, const value &b)

  Convenience Constructor: initialize the first two elements.
  

• FixedArray (const value &a, const value &b, const value &c)

  Convenience Constructor: initialize the first three elements.
  

• FixedArray (const value &a, const value &b, const value &c, const value &d)

  Convenience Constructor: initialize the first four elements.
  

• FlattenedArray_t & flattened ()
• const FlattenedArray_t & flattened () const
• value & get (int i)

  writable element access
  

• const value & get (int i) const

  read-only element access
  

• template<int subsize, int offset> const FixedArray< value,
  subsize > * get_subarray () const

  Same functionality as the subarray template member class, but simpler interface.
  

• const FixedArray< value, SIZE-1 > & get_subdim () const

  Mainly introduced because of Interpolate::operator[].
  

• FixedArray mul (const FixedArray &r) const
• template<typename T > bool operator!= (const FixedArray< T, N > &F) const

  Compare two arrays.
  

• Assignment< FixedArray, 0 > operator= (const value &x)
• template<typename T > FixedArray & operator= (const FixedArray< T, N > &F)
• template<typename T > bool operator== (const FixedArray< T, N > &F) const

  Compare two arrays.
  

• value & operator[] (int i)

  writeable element access operator
  

• const value & operator[] (int i) const

  read-only element access operator
  

• value * ptr (int i=0)

  Return a pointer to the ith element, no range checking.
  

• template<class Value > void set (const Value &x)

  Set all array elements to the same value.
  

• void setFromArray (const value *x, int length=SIZE, int offset=0)

  Set all array elements to an array's element value.
  

• void sort (FixedArray< int, N > &I) const

  Sort the elements of an array into the index array.
  

• template<int subsize, int offset> const FixedArray< value,
  subsize > & suboffset () const
• template<int subsize> const FixedArray< value,
  subsize > & subset () const

Static Public Member Functions

• template<typename T , typename ConversionFunctor > static FixedArray convert (const FixedArray< T, N > &F, const ConversionFunctor &CF)

  Perform a type conversion on a given fixed array into another basis type:
  

• static FixedArray * fa_cast (value *data)
• static const FixedArray * fa_cast (const value *data)
• static int size ()

  The number of elements here.
  

Protected Attributes

• value data [SIZE]

  The actual data values.
  

Friends

• template<OperatorID_t CompType> FixedArray component_wise (const FixedArray &l, const FixedArray &r, const Operator< CompType > &Op)

  Apply a certain operator component-wise.
  

• template<typename T > bool isEqual (const FixedArray< value, N > &L, const FixedArray< T, N > &R, double precision)

  Compare two arrays with limited precision.
  

---

Detailed Description

A FixedArray is a simple copy-by-value array providing random access to its elements.

Its purpose is to implement small, light-weight types such as 3-vectors, 3x3 matrices and similar, useful for small efficient numerical operations, as they don't have an new/delete memory allocation overhead. The FixedArray does not provide operations on its elements - use class Vector for this purpose.

Copying or creating temporary FixedArray objects should be avoided, as the entire data fields are copied.

See also:

Vector

---

Member Function Documentation

template<typename T , typename ConversionFunctor >

static FixedArray Eagle::FixedArray::convert	(	const FixedArray< T, N > &	F,
		const ConversionFunctor &	CF
	)		[inline, static]

Perform a type conversion on a given fixed array into another basis type:

           FixedArray<double, 3> data;
           FixedArray<int,3> idata = FixedArray<int, 3>::convert( data );

This is implemented as a type-safe static member function, thus allows explicit type conversion when calling polymorphic or template functions.

template<int subsize, int offset>

const FixedArray<value, subsize>* Eagle::FixedArray::get_subarray

(

)

const [inline]

Same functionality as the subarray template member class, but simpler interface.

Example:

	const FixedArray<3 , CoordinateType>*P3D;
	const FixedArray<2 , CoordinateType>*P2D;
		P2D = P3D->get_subarray<2,0>();

template<typename T >

bool Eagle::FixedArray::operator!=

(

const FixedArray< T, N > &

F

)

const [inline]

Compare two arrays.

The types might differ, but the length must be identical. The comparision loop is terminated at the first type mismatch.

template<typename T >

bool Eagle::FixedArray::operator==

(

const FixedArray< T, N > &

F

)

const [inline]

Compare two arrays.

The types might differ, but the length must be identical. The comparision loop is terminated at the first type mismatch.

void Eagle::FixedArray::setFromArray	(	const value *	x,
		int	length = SIZE,
		int	offset = 0
	)		[inline]

Set all array elements to an array's element value.

Note that the array must have at least the same length as the FixedArray.

---

Friends And Related Function Documentation

template<typename T >

bool isEqual	(	const FixedArray< value, N > &	L,
		const FixedArray< T, N > &	R,
		double	precision
	)		[friend]

Compare two arrays with limited precision.

The types might differ, but the length must be identical. The comparision loop is terminated at the first type mismatch.

---

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

• ocean/eagle/FixedArray.hpp