Namespaces
	ndarray::detail

Classes
struct	ndarray::ArrayTraits< T, N, C >
	Dimension-specialized traits shared by Array and ArrayRef. More...

struct	ndarray::ExpressionTraits< Expression_ >
	Traits for expressions. More...

class	ndarray::NumericTraits< T, U, is_complex, is_arithmetic >
	Numeric type traits. More...

class	ndarray::Promote< T1, T2, winner, is_complex >
	Metafunction to compute numeric promotions. More...

struct	ndarray::ApproximatelyEqual< T1, T2 >
	Binary predicate for floating point equality comparison with tolerance. More...

struct	ndarray::ApproximatelyEqual< std::complex< U1 >, std::complex< U2 > >
	Binary predicate for complex floating point equality comparison with tolerance. More...

class	ndarray::ArrayBase< Derived >
	CRTP implementation for Array and ArrayRef. More...

class	ndarray::ExpressionBase< Derived >
	CRTP base class for all multidimensional expressions. More...

class	ndarray::FormatOptions
	Options for controlling stream output of ExpressionBase. More...

Functions
template<typename T_ , typename T , int N, int C>
Array< T_, N, C >	ndarray::const_array_cast (Array< T, N, C > const &array)

template<int C_, typename T , int N, int C>
Array< T, N, C_ >	ndarray::static_dimension_cast (Array< T, N, C > const &array)

template<int C_, typename T , int N, int C>
Array< T, N, C_ >	ndarray::dynamic_dimension_cast (Array< T, N, C > const &array)

template<typename Array_ >
detail::ComplexExtractor < Array_ >::Result	ndarray::getReal (Array_ const &array)
	Return an ArrayRef view into the real part of a complex array. More...

template<typename Array_ >
detail::ComplexExtractor < Array_ >::Result	ndarray::getImag (Array_ const &array)
	Return an ArrayRef view into the imaginary part of a complex array. More...

template<int Nf, typename T , int N, int C>
boost::enable_if_c< ((C+Nf-N)> =1), ArrayRef< T, Nf,(C+Nf-N)> >::type	ndarray::flatten (Array< T, N, C > const &input)
	Create a view into an array with trailing contiguous dimensions merged. More...

template<int Nf, typename T , int N, int C>
boost::enable_if_c< ((C+Nf-N)> =1), ArrayRef< T, Nf,(C+Nf-N)> >::type	ndarray::flatten (ArrayRef< T, N, C > const &input)
	Create a view into an array with trailing contiguous dimensions merged. More...

template<int N>
detail::SimpleInitializer< N >	ndarray::allocate (Vector< int, N > const &shape)
	Create an expression that allocates uninitialized memory for an array. More...

detail::SimpleInitializer< 1 >	ndarray::allocate (int n)
	Create an expression that allocates uninitialized memory for a 1-d array. More...

detail::SimpleInitializer< 2 >	ndarray::allocate (int n1, int n2)
	Create an expression that allocates uninitialized memory for a 2-d array. More...

detail::SimpleInitializer< 3 >	ndarray::allocate (int n1, int n2, int n3)
	Create an expression that allocates uninitialized memory for a 3-d array. More...

template<typename Derived >
ArrayRef< typename boost::remove_const< typename Derived::Element >::type, Derived::ND::value, Derived::ND::value >	ndarray::copy (ExpressionBase< Derived > const &expr)
	Create a new Array by copying an Expression. More...

template<int N>
Vector< int, N >	ndarray::computeStrides (Vector< int, N > const &shape, DataOrderEnum order=ROW_MAJOR)
	Compute row- or column-major strides for the given shape. More...

template<typename T , int N, typename Owner >
detail::ExternalInitializer< T, N, Owner >	ndarray::external (T *data, Vector< int, N > const &shape, Vector< int, N > const &strides, Owner const &owner)
	Create an expression that initializes an Array with externally allocated memory. More...

template<typename T , int N>
detail::ExternalInitializer< T, N, detail::NullOwner >	ndarray::external (T *data, Vector< int, N > const &shape, Vector< int, N > const &strides)
	Create an expression that initializes an Array with externally allocated memory. More...

template<typename T , int N, typename Owner >
detail::ExternalInitializer< T, N, Owner >	ndarray::external (T *data, Vector< int, N > const &shape, DataOrderEnum order, Owner const &owner)
	Create an expression that initializes an Array with externally allocated memory. More...

template<typename T , int N>
detail::ExternalInitializer< T, N, detail::NullOwner >	ndarray::external (T *data, Vector< int, N > const &shape, DataOrderEnum order=ROW_MAJOR)
	Create an expression that initializes an Array with externally allocated memory. More...

template<typename Derived >
bool	ndarray::any (ExpressionBase< Derived > const &expr)
	Return true if any of the elements of the given expression are true. More...

template<typename Derived >
bool	ndarray::all (ExpressionBase< Derived > const &expr)
	Return true if all of the elements of the given expression are true. More...

template<typename Derived >
Derived::Element	ndarray::sum (ExpressionBase< Derived > const &expr)
	Return the sum of all elements of the given expression. More...

Detailed Description

Function Documentation

template<typename Derived >

bool ndarray::all ( ExpressionBase< Derived > const & expr )

inline

Return true if all of the elements of the given expression are true.

Definition at line 1197 of file operators.h.

                                           {
     typename Derived::Iterator const i_end = expr.end();
     for (typename Derived::Iterator i = expr.begin(); i != i_end; ++i) {
         if (!all(*i)) return false;
     }
     return true;
 }

template<int N>

detail::SimpleInitializer<N> ndarray::allocate ( Vector< int, N > const & shape )

inline

Create an expression that allocates uninitialized memory for an array.

Returns: A temporary object convertible to an Array with fully contiguous row-major strides.

Definition at line 115 of file initialization.h.

                                                                         {
     return detail::SimpleInitializer<N>(shape); 
 }

detail::SimpleInitializer<1> ndarray::allocate ( int n )

inline

Create an expression that allocates uninitialized memory for a 1-d array.

Returns: A temporary object convertible to an Array with fully contiguous row-major strides.

Definition at line 124 of file initialization.h.

                                                   {
     return detail::SimpleInitializer<1>(ndarray::makeVector(n)); 
 }

detail::SimpleInitializer<2> ndarray::allocate	(	int	n1,
		int	n2
	)

inline

Create an expression that allocates uninitialized memory for a 2-d array.

Returns: A temporary object convertible to an Array with fully contiguous row-major strides.

Definition at line 133 of file initialization.h.

                                                            {
     return detail::SimpleInitializer<2>(ndarray::makeVector(n1, n2)); 
 }

detail::SimpleInitializer<3> ndarray::allocate	(	int	n1,
		int	n2,
		int	n3
	)

inline

Create an expression that allocates uninitialized memory for a 3-d array.

Returns: A temporary object convertible to an Array with fully contiguous row-major strides.

Definition at line 142 of file initialization.h.

                                                                    {
     return detail::SimpleInitializer<3>(ndarray::makeVector(n1, n2, n3)); 
 }

template<typename Derived >

bool ndarray::any ( ExpressionBase< Derived > const & expr )

inline

Return true if any of the elements of the given expression are true.

Definition at line 1176 of file operators.h.

                                           {
     typename Derived::Iterator const i_end = expr.end();
     for (typename Derived::Iterator i = expr.begin(); i != i_end; ++i) {
         if (any(*i)) return true;
     }
     return false;
 }

template<int N>

Vector<int,N> ndarray::computeStrides	(	Vector< int, N > const &	shape,
		DataOrderEnum	order = `ROW_MAJOR`
	)

Compute row- or column-major strides for the given shape.

Definition at line 163 of file initialization.h.

                                                                                          {
     Vector<int,N> r(1);
     if (order == ROW_MAJOR) {
         for (int n=N-1; n > 0; --n) r[n-1] = r[n] * shape[n];
     } else {
         for (int n=1; n < N; ++n) r[n] = r[n-1] * shape[n-1];
     }
     return r;
 }

template<typename T_ , typename T , int N, int C>

Array<T_,N,C> ndarray::const_array_cast ( Array< T, N, C > const & array )

Convert an Array with a const data type to an array with a non-const data type.

Definition at line 76 of file casts.h.

                                              {
     return detail::ArrayAccess< Array<T_,N,C> >::construct(
         const_cast<T_*>(array.getData()),
         detail::ArrayAccess< Array<T,N,C> >::getCore(array)
     );
 }

template<typename Derived >

ArrayRef<typename boost::remove_const<typename Derived::Element>::type, Derived::ND::value, Derived::ND::value> ndarray::copy ( ExpressionBase< Derived > const & expr )

inline

Create a new Array by copying an Expression.

Definition at line 152 of file initialization.h.

                                            {
     ArrayRef<typename boost::remove_const<typename Derived::Element>::type, 
         Derived::ND::value,Derived::ND::value> r(
             allocate(expr.getShape())
         );
     r = expr;
     return r;
 }

template<int C_, typename T , int N, int C>

Array<T,N,C_> ndarray::dynamic_dimension_cast ( Array< T, N, C > const & array )

Convert an Array to a type with more guaranteed row-major-contiguous dimensions, if the strides of the array match the desired number of RMC dimensions. If the cast fails, an empty Array is returned.

Definition at line 105 of file casts.h.

                                                    {
     Vector<int,N> shape = array.getShape();
     Vector<int,N> strides = array.getStrides();
     if (C_ >= 0) {
         int n = 1;
         for (int i=1; i <= C_; ++i) {
             if (strides[N-i] != n) return Array<T,N,C_>();
             n *= shape[N-i];
         }
     } else {
         int n = 1;
         for (int i=0; i < -C_; ++i) {
             if (strides[i] != n) return Array<T,N,C_>();
             n *= strides[i];
         }
     }
     return static_dimension_cast<C_>(array);
 }

template<typename T , int N, typename Owner >

detail::ExternalInitializer<T,N,Owner> ndarray::external	(	T *	data,
		Vector< int, N > const &	shape,
		Vector< int, N > const &	strides,
		Owner const &	owner
	)

inline

Create an expression that initializes an Array with externally allocated memory.

No checking is done to ensure the shape, strides, and data pointers are sensible.

Parameters

[in]	data	A raw pointer to the first element of the Array.
[in]	shape	A Vector of dimensions for the new Array.
[in]	strides	A Vector of strides for the new Array.
[in]	owner	A copy-constructable object with an internal reference count that owns the memory pointed at by 'data'.

Returns: A temporary object convertible to an Array.

Definition at line 187 of file initialization.h.

   {
     return detail::ExternalInitializer<T,N,Owner>(data, shape, strides, owner);
 }

template<typename T , int N>

detail::ExternalInitializer<T,N,detail::NullOwner> ndarray::external	(	T *	data,
		Vector< int, N > const &	shape,
		Vector< int, N > const &	strides
	)

inline

Create an expression that initializes an Array with externally allocated memory.

No checking is done to ensure the shape, strides, and data pointers are sensible. Memory will not be managed at all; the user must ensure the data pointer remains valid for the lifetime of the array.

Parameters

[in]	data	A raw pointer to the first element of the Array.
[in]	shape	A Vector of dimensions for the new Array.
[in]	strides	A Vector of strides for the new Array.

Returns: A temporary object convertible to an Array.

Definition at line 209 of file initialization.h.

   {
     return detail::ExternalInitializer<T,N,detail::NullOwner>(data, shape, strides, detail::NullOwner());
 }

template<typename T , int N, typename Owner >

detail::ExternalInitializer<T,N,Owner> ndarray::external	(	T *	data,
		Vector< int, N > const &	shape,
		DataOrderEnum	order,
		Owner const &	owner
	)

inline

Create an expression that initializes an Array with externally allocated memory.

No checking is done to ensure the shape and data pointers are sensible.

Parameters

[in]	data	A raw pointer to the first element of the Array.
[in]	shape	A Vector of dimensions for the new Array.
[in]	order	Whether the strides are row- or column-major.
[in]	owner	A copy-constructable object with an internal reference count that owns the memory pointed at by 'data'.

Returns: A temporary object convertible to an Array.

Definition at line 231 of file initialization.h.

   {
     return detail::ExternalInitializer<T,N,Owner>(data, shape, computeStrides(shape, order), owner);
 }

template<typename T , int N>

detail::ExternalInitializer<T,N,detail::NullOwner> ndarray::external	(	T *	data,
		Vector< int, N > const &	shape,
		DataOrderEnum	order = `ROW_MAJOR`
	)

inline

Create an expression that initializes an Array with externally allocated memory.

No checking is done to ensure the shape and data pointers are sensible. Memory will not be managed at all; the user must ensure the data pointer remains valid for the lifetime of the array.

Parameters

[in]	data	A raw pointer to the first element of the Array.
[in]	shape	A Vector of dimensions for the new Array.
[in]	order	Whether the strides are row- or column-major.

Returns: A temporary object convertible to an Array.

Definition at line 253 of file initialization.h.

   {
     return detail::ExternalInitializer<T,N,detail::NullOwner>(
         data, shape, computeStrides(shape, order), detail::NullOwner()
     );
 }

template<int Nf, typename T , int N, int C>

boost::enable_if_c< ((C+Nf-N)>=1), ArrayRef<T,Nf,(C+Nf-N)> >::type ndarray::flatten ( Array< T, N, C > const & input )

inline

Create a view into an array with trailing contiguous dimensions merged.

The first template parameter sets the dimension of the output array and must be specified directly. Only row-major contiguous dimensions can be flattened.

Definition at line 150 of file casts.h.

                                     {
     typedef detail::ArrayAccess< ArrayRef<T,Nf,(C+Nf-N)> > Access;
     typedef typename Access::Core Core;
     BOOST_STATIC_ASSERT(C+Nf-N >= 1);
     Vector<int,N> oldShape = input.getShape();
     Vector<int,Nf> newShape = oldShape.template first<Nf>();
     for (int n=Nf; n<N; ++n)
         newShape[Nf-1] *= oldShape[n];
     Vector<int,Nf> newStrides = input.getStrides().template first<Nf>();
     newStrides[Nf-1] = 1;
     return Access::construct(input.getData(), Core::create(newShape, newStrides, input.getManager()));
 }

template<int Nf, typename T , int N, int C>

boost::enable_if_c< ((C+Nf-N)>=1), ArrayRef<T,Nf,(C+Nf-N)> >::type ndarray::flatten ( ArrayRef< T, N, C > const & input )

inline

Create a view into an array with trailing contiguous dimensions merged.

The first template parameter sets the dimension of the output array and must be specified directly. Only row-major contiguous dimensions can be flattened.

Definition at line 171 of file casts.h.

                                        {
     return flatten<Nf>(input.shallow());
 }

template<typename Array_ >

detail::ComplexExtractor<Array_>::Result ndarray::getImag ( Array_ const & array )

Return an ArrayRef view into the imaginary part of a complex array.

Definition at line 138 of file casts.h.

                               {
     return detail::ComplexExtractor<Array_>::apply(array, 1);
 }

template<typename Array_ >

detail::ComplexExtractor<Array_>::Result ndarray::getReal ( Array_ const & array )

Return an ArrayRef view into the real part of a complex array.

Definition at line 129 of file casts.h.

                               {
     return detail::ComplexExtractor<Array_>::apply(array, 0);
 }

template<int C_, typename T , int N, int C>

Array<T,N,C_> ndarray::static_dimension_cast ( Array< T, N, C > const & array )

Convert an Array to a type with more guaranteed row-major-contiguous dimensions with no checking.

Definition at line 89 of file casts.h.

                                                   {
     return detail::ArrayAccess< Array<T,N,C_> >::construct(
         array.getData(),
         detail::ArrayAccess< Array<T,N,C> >::getCore(array)
     );
 }

template<typename Derived >

Derived::Element ndarray::sum ( ExpressionBase< Derived > const & expr )

inline

Return the sum of all elements of the given expression.

Definition at line 1260 of file operators.h.

                                           {
     typename Derived::Iterator const i_end = expr.end();
     typename Derived::Element total = static_cast<typename Derived::Element>(0);
     for (typename Derived::Iterator i = expr.begin(); i != i_end; ++i) {
         total += sum(*i);
     }
     return total;
 }

Namespaces

Classes

Functions

Detailed Description

Function Documentation