Namespaces
	detail

	index

	result_of

	tables

Classes
struct	ExpressionTraits< detail::CountingExpression >

class	Array
	A multidimensional strided array. More...

class	ArrayBase
	CRTP implementation for Array and ArrayRef. More...

class	ArrayBaseN
	An intermediate CRTP base class for Array and ArrayRef. More...

class	ArrayBaseN< Derived, 1 >
	An intermediate CRTP base class for Array and ArrayRef (specialization for 1). More...

class	ArrayBaseN< Derived, 2 >
	An intermediate CRTP base class for Array and ArrayRef (specialization for 2). More...

class	ArrayBaseN< Derived, 3 >
	An intermediate CRTP base class for Array and ArrayRef (specialization for 3). More...

class	ArrayBaseN< Derived, 4 >
	An intermediate CRTP base class for Array and ArrayRef (specialization for 4). More...

class	ArrayBaseN< Derived, 5 >
	An intermediate CRTP base class for Array and ArrayRef (specialization for 5). More...

class	ArrayBaseN< Derived, 6 >
	An intermediate CRTP base class for Array and ArrayRef (specialization for 6). More...

class	ArrayRef
	A proxy class for Array with deep assignment operators. More...

struct	ArrayTraits
	Dimension-specialized traits shared by Array and ArrayRef. More...

struct	ArrayTraits< T, 1, 0 >

struct	ArrayTraits< T, 1, 1 >

struct	ArrayTraits< T, 1,-1 >

struct	ExpressionTraits< Array< T, N, C > >

struct	ExpressionTraits< ArrayRef< T, N, C > >

class	EigenView
	Eigen3 view into an ndarray::Array. More...

struct	SelectEigenView
	A metafunction that computes the EigenView instantiation that most closely matches an Eigen type. More...

class	ExpressionBase
	CRTP base class for all multidimensional expressions. More...

struct	ExpressionTraits
	Traits for expressions. More...

struct	ExpressionTraits< detail::UnaryOpExpression< Operand, UnaryFunction, N > >

struct	ExpressionTraits< detail::UnaryOpExpression< Operand, UnaryFunction, 1 > >

struct	ExpressionTraits< detail::BinaryOpExpression< Operand1, Operand2, BinaryFunction, N > >

struct	ExpressionTraits< detail::BinaryOpExpression< Operand1, Operand2, BinaryFunction, 1 > >

class	FourierTransform
	A wrapper for FFTW plans for fast Fourier transforms. More...

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

class	Manager

class	SimpleManager

class	ExternalManager

struct	PyConverter< EigenView< T, N, C, XprKind_, Rows_, Cols_ > >
	Specialization of PyConverter for EigenView. More...

struct	PyConverter< Eigen::Matrix< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >
	Specialization of PyConverter for Eigen::Matrix. More...

struct	PyConverter< Eigen::Array< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >
	Specialization of PyConverter for Eigen::Array. More...

struct	PyConverter< Array< T, N, C > >
	A traits class providing Python conversion functions for Array. More...

struct	PyConverter
	A class providing Python conversion functions for T. More...

struct	PyUnaryUFunctor

struct	PyBinaryUFunctor

struct	PyConverter< Vector< T, N > >
	A traits class providing Python conversion functions for Vector. More...

class	NumericTraits
	Numeric type traits. More...

class	Promote
	Metafunction to compute numeric promotions. More...

struct	ApproximatelyEqual
	Binary predicate for floating point equality comparison with tolerance. More...

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

class	Vector
	A fixed-size 1D array class. More...

struct	Vector< T, 0 >
	PArtial specialization for zero-size vectors to avoid compiler errors on some platforms. More...

struct	View
	A template meta-sequence that defines an arbitrary view into an unspecified array. More...

Typedefs
typedef boost::intrusive_ptr < PyObject >	PyPtr
	A reference-counting smart pointer for PyObject. More...

Enumerations
enum	DataOrderEnum { ROW_MAJOR =1, COLUMN_MAJOR =2 }
	An enumeration for stride computation. More...

Functions
detail::CountingExpression	arange (int stop)
	Create 1D Expression that contains integer values in the range [0,stop). More...

detail::UnaryOpExpression < detail::CountingExpression, detail::RangeTransformer< int > >	arange (int start, int stop, int step=1)
	Create 1D Expression that contains integer values in the range [start,stop) with increment step. More...

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

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

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

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

template<typename Array_ >
detail::ComplexExtractor < Array_ >::Result	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	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	flatten (ArrayRef< T, N, C > const &input)
	Create a view into an array with trailing contiguous dimensions merged. More...

template<typename T >
SelectEigenView< T >::Type	copy (Eigen::EigenBase< T > const &other)
	Copy an arbitrary Eigen expression into a new EigenView. More...

template<typename T , int N, int C>
void	shift (Vector< T, N > const &offset, Array< std::complex< T >, N, C > const &array, int const real_last_dim)
	Perform a Fourier-space translation transform. More...

template<typename T , int N, int C>
void	differentiate (int n, Array< std::complex< T >, N, C > const &array, int const real_last_dim)
	Numerically differentiate the array in Fourier-space in the given dimension. More...

template<typename Derived >
std::ostream &	operator<< (std::ostream &os, ExpressionBase< Derived > const &expr)
	Stream output for ExpressionBase using default-constructed FormatOptions. More...

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

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

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

detail::SimpleInitializer< 3 >	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 >	copy (ExpressionBase< Derived > const &expr)
	Create a new Array by copying an Expression. More...

template<int N>
Vector< int, N >	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 >	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 >	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 >	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 >	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 T >
Manager::Ptr	makeManager (T const &owner)

Manager::Ptr	makeManager (Manager::Ptr const &owner)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	operator+ (ExpressionBase< Operand > const &operand, Scalar const &scalar)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	operator+ (Scalar const &scalar, ExpressionBase< Operand > const &operand)

template<typename Operand1 , typename Operand2 >
< unspecified-expression-type >	operator+ (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	operator- (ExpressionBase< Operand > const &operand, Scalar const &scalar)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	operator- (Scalar const &scalar, ExpressionBase< Operand > const &operand)

template<typename Operand1 , typename Operand2 >
< unspecified-expression-type >	operator- (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	operator* (ExpressionBase< Operand > const &operand, Scalar const &scalar)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	operator* (Scalar const &scalar, ExpressionBase< Operand > const &operand)

template<typename Operand1 , typename Operand2 >
< unspecified-expression-type >	operator* (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	operator/ (ExpressionBase< Operand > const &operand, Scalar const &scalar)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	operator/ (Scalar const &scalar, ExpressionBase< Operand > const &operand)

template<typename Operand1 , typename Operand2 >
< unspecified-expression-type >	operator/ (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	operator% (ExpressionBase< Operand > const &operand, Scalar const &scalar)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	operator% (Scalar const &scalar, ExpressionBase< Operand > const &operand)

template<typename Operand1 , typename Operand2 >
< unspecified-expression-type >	operator% (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	operator^ (ExpressionBase< Operand > const &operand, Scalar const &scalar)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	operator^ (Scalar const &scalar, ExpressionBase< Operand > const &operand)

template<typename Operand1 , typename Operand2 >
< unspecified-expression-type >	operator^ (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	operator\| (ExpressionBase< Operand > const &operand, Scalar const &scalar)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	operator\| (Scalar const &scalar, ExpressionBase< Operand > const &operand)

template<typename Operand1 , typename Operand2 >
< unspecified-expression-type >	operator\| (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	operator& (ExpressionBase< Operand > const &operand, Scalar const &scalar)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	operator& (Scalar const &scalar, ExpressionBase< Operand > const &operand)

template<typename Operand1 , typename Operand2 >
< unspecified-expression-type >	operator& (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	operator<< (ExpressionBase< Operand > const &operand, Scalar const &scalar)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	operator<< (Scalar const &scalar, ExpressionBase< Operand > const &operand)

template<typename Operand1 , typename Operand2 >
< unspecified-expression-type >	operator<< (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	operator>> (ExpressionBase< Operand > const &operand, Scalar const &scalar)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	operator>> (Scalar const &scalar, ExpressionBase< Operand > const &operand)

template<typename Operand1 , typename Operand2 >
< unspecified-expression-type >	operator>> (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	equal (ExpressionBase< Operand > const &operand, Scalar const &scalar)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	equal (Scalar const &scalar, ExpressionBase< Operand > const &operand)

template<typename Operand1 , typename Operand2 >
< unspecified-expression-type >	equal (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	not_equal (ExpressionBase< Operand > const &operand, Scalar const &scalar)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	not_equal (Scalar const &scalar, ExpressionBase< Operand > const &operand)

template<typename Operand1 , typename Operand2 >
< unspecified-expression-type >	not_equal (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	less (ExpressionBase< Operand > const &operand, Scalar const &scalar)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	less (Scalar const &scalar, ExpressionBase< Operand > const &operand)

template<typename Operand1 , typename Operand2 >
< unspecified-expression-type >	less (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	greater (ExpressionBase< Operand > const &operand, Scalar const &scalar)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	greater (Scalar const &scalar, ExpressionBase< Operand > const &operand)

template<typename Operand1 , typename Operand2 >
< unspecified-expression-type >	greater (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	less_equal (ExpressionBase< Operand > const &operand, Scalar const &scalar)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	less_equal (Scalar const &scalar, ExpressionBase< Operand > const &operand)

template<typename Operand1 , typename Operand2 >
< unspecified-expression-type >	less_equal (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	great_equal (ExpressionBase< Operand > const &operand, Scalar const &scalar)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	great_equal (Scalar const &scalar, ExpressionBase< Operand > const &operand)

template<typename Operand1 , typename Operand2 >
< unspecified-expression-type >	great_equal (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	logical_and (ExpressionBase< Operand > const &operand, Scalar const &scalar)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	logical_and (Scalar const &scalar, ExpressionBase< Operand > const &operand)

template<typename Operand1 , typename Operand2 >
< unspecified-expression-type >	logical_and (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	logical_or (ExpressionBase< Operand > const &operand, Scalar const &scalar)

template<typename Operand , typename Scalar >
< unspecified-expression-type >	logical_or (Scalar const &scalar, ExpressionBase< Operand > const &operand)

template<typename Operand1 , typename Operand2 >
< unspecified-expression-type >	logical_or (ExpressionBase< Operand1 > const &operand1, ExpressionBase< Operand2 > const &operand2)

template<typename Operand >
< unspecified-expression-type >	operator- (ExpressionBase< Operand > const &operand)

template<typename Operand >
< unspecified-expression-type >	logical_not (ExpressionBase< Operand > const &operand)

template<typename Operand >
< unspecified-expression-type >	operator~ (ExpressionBase< Operand > const &operand)

template<typename Scalar >
boost::enable_if< typename ExpressionTraits< Scalar > ::IsScalar, bool >::type	any (Scalar const &scalar)

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

template<typename Scalar >
boost::enable_if< typename ExpressionTraits< Scalar > ::IsScalar, bool >::type	all (Scalar const &scalar)

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

template<typename Scalar1 , typename Scalar2 >
boost::enable_if < boost::mpl::and_< typename ExpressionTraits< Scalar1 > ::IsScalar, typename ExpressionTraits< Scalar2 > ::IsScalar >, bool >::type	allclose (Scalar1 const &scalar1, Scalar2 const &scalar2, double tol=1E-8)

template<typename Scalar , typename Derived >
boost::enable_if< typename ExpressionTraits< Scalar > ::IsScalar, bool >::type	allclose (Scalar const &scalar, ExpressionBase< Derived > const &expr, double tol=1E-8)

template<typename Scalar , typename Derived >
boost::enable_if< typename ExpressionTraits< Scalar > ::IsScalar, bool >::type	allclose (ExpressionBase< Derived > const &expr, Scalar const &scalar, double tol=1E-8)

template<typename Derived1 , typename Derived2 >
bool	allclose (ExpressionBase< Derived1 > const &expr1, ExpressionBase< Derived2 > const &expr2, double tol=1E-8)

template<typename Scalar >
boost::enable_if< typename ExpressionTraits< Scalar > ::IsScalar, Scalar >::type	sum (Scalar const &scalar)

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

template<typename T , int N, int M>
Vector< T, N+M >	concatenate (Vector< T, N > const &a, Vector< T, M > const &b)
	Concatenate two Vectors into a single long Vector. More...

template<typename T , int N>
Vector< T, N+1 >	concatenate (Vector< T, N > const &a, T const &b)
	Return a new Vector with the given scalar appended to the original. More...

template<typename T , int N>
Vector< T, N+1 >	concatenate (T const &a, Vector< T, N > const &b)
	Return a new Vector with the given scalar prepended to the original. More...

template<typename T , int N>
Vector< T, N >	makeVector (T v1, T v2,..., T vN)
	Variadic constructor for Vector. More...

template<typename T , int N>
Vector< T, N >	operator~ (Vector< T, N > const &vector)
	Unary bitwise NOT for Vector. More...

template<typename T , int N>
Vector< T, N >	operator! (Vector< T, N > const &vector)
	Unary negation for Vector. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator+ (Vector< T, N > const &a, Vector< U, N > const &b)
	Operator overload for Vector + Vector. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator+ (Vector< T, N > const &a, U b)
	Operator overload for Vector + Scalar. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator+ (U a, Vector< T, N > const &b)
	Operator overload for Scalar + Vector. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator- (Vector< T, N > const &a, Vector< U, N > const &b)
	Operator overload for Vector - Vector. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator- (Vector< T, N > const &a, U b)
	Operator overload for Vector - Scalar. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator- (U a, Vector< T, N > const &b)
	Operator overload for Scalar - Vector. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator* (Vector< T, N > const &a, Vector< U, N > const &b)
	Operator overload for Vector * Vector. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator* (Vector< T, N > const &a, U b)
	Operator overload for Vector * Scalar. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator* (U a, Vector< T, N > const &b)
	Operator overload for Scalar * Vector. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator/ (Vector< T, N > const &a, Vector< U, N > const &b)
	Operator overload for Vector / Vector. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator/ (Vector< T, N > const &a, U b)
	Operator overload for Vector / Scalar. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator/ (U a, Vector< T, N > const &b)
	Operator overload for Scalar / Vector. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator% (Vector< T, N > const &a, Vector< U, N > const &b)
	Operator overload for Vector % Vector. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator% (Vector< T, N > const &a, U b)
	Operator overload for Vector % Scalar. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator% (U a, Vector< T, N > const &b)
	Operator overload for Scalar % Vector. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator& (Vector< T, N > const &a, Vector< U, N > const &b)
	Operator overload for Vector & Vector. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator& (Vector< T, N > const &a, U b)
	Operator overload for Vector & Scalar. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator& (U a, Vector< T, N > const &b)
	Operator overload for Scalar & Vector. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator^ (Vector< T, N > const &a, Vector< U, N > const &b)
	Operator overload for Vector ^ Vector. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator^ (Vector< T, N > const &a, U b)
	Operator overload for Vector ^ Scalar. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator^ (U a, Vector< T, N > const &b)
	Operator overload for Scalar ^ Vector. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator\| (Vector< T, N > const &a, Vector< U, N > const &b)
	Operator overload for Vector \| Vector. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator\| (Vector< T, N > const &a, U b)
	Operator overload for Vector \| Scalar. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator\| (U a, Vector< T, N > const &b)
	Operator overload for Scalar \| Vector. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator<< (Vector< T, N > const &a, Vector< U, N > const &b)
	Operator overload for Vector << Vector. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator<< (Vector< T, N > const &a, U b)
	Operator overload for Vector << Scalar. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator<< (U a, Vector< T, N > const &b)
	Operator overload for Scalar << Vector. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator>> (Vector< T, N > const &a, Vector< U, N > const &b)
	Operator overload for Vector >> Vector. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator>> (Vector< T, N > const &a, U b)
	Operator overload for Vector >> Scalar. More...

template<typename T , typename U , int N>
Vector< typename Promote< T, U > ::Type, N >	operator>> (U a, Vector< T, N > const &b)
	Operator overload for Scalar >> Vector. More...

template<typename Scalar , typename UnaryFunction >
UnaryFunction::result_type	vectorize (UnaryFunction const &functor, Scalar const &scalar)
	Apply a non-mutating unary function object to a scalar. More...

template<typename Derived , typename UnaryFunction >
detail::UnaryOpExpression < Derived, UnaryFunction >	vectorize (UnaryFunction const &functor, ExpressionBase< Derived > const &operand)
	Apply a non-mutating unary function object to each element of a multidimensional Expression. More...

template<typename Scalar1 , typename Scalar2 , typename BinaryFunction >
BinaryFunction::result_type	vectorize (BinaryFunction const &functor, Scalar1 const &scalar1, Scalar2 const &scalar2)
	Apply a non-mutating binary function object to a pair of scalars. More...

template<typename Derived1 , typename Derived2 , typename BinaryFunction >
detail::BinaryOpExpression < Derived1, Derived2, BinaryFunction >	vectorize (BinaryFunction const &functor, ExpressionBase< Derived1 > const &operand1, ExpressionBase< Derived2 > const &operand2)
	Apply a non-mutating binary function object pairwise to the elements of two multidimensional Expressions. More...

View< boost::fusion::vector1 < index::Full > >	view ()
	Start a view definition that includes the entire first dimension. More...

View< boost::fusion::vector1 < index::Range > >	view (int start, int stop)
	Start a view definition that selects a contiguous range in the first dimension. More...

View< boost::fusion::vector1 < index::Slice > >	view (int start, int stop, int step)
	Start a view definition that selects a noncontiguous slice of the first dimension. More...

View< boost::fusion::vector1 < index::Scalar > >	view (int n)
	Start a view definition that selects single element from the first dimension. More...

template<typename Sequence >
View< Sequence >	view (Sequence const &sequence)
	Create a view definition from a boost::fusion sequence of index objects. More...

Typedef Documentation

typedef boost::intrusive_ptr<PyObject> ndarray::PyPtr

A reference-counting smart pointer for PyObject.

Definition at line 48 of file PyConverter.h.

Enumeration Type Documentation

enum ndarray::DataOrderEnum

An enumeration for stride computation.

Enumerator
ROW_MAJOR
COLUMN_MAJOR

Definition at line 60 of file ndarray_fwd.h.

60 { ROW_MAJOR=1, COLUMN_MAJOR=2 };

ndarray::ROW_MAJOR

Definition: ndarray_fwd.h:60

ndarray::COLUMN_MAJOR

Definition: ndarray_fwd.h:60

Function Documentation

template<typename Scalar >

boost::enable_if<typename ExpressionTraits<Scalar>::IsScalar, bool>::type ndarray::all ( Scalar const & scalar )

inline

Definition at line 1186 of file operators.h.

                            {
     return bool(scalar);
 }

template<typename Scalar1 , typename Scalar2 >

boost::enable_if< boost::mpl::and_< typename ExpressionTraits<Scalar1>::IsScalar, typename ExpressionTraits<Scalar2>::IsScalar >, bool>::type ndarray::allclose	(	Scalar1 const &	scalar1,
		Scalar2 const &	scalar2,
		double	tol = `1E-8`
	)

inline

Definition at line 1213 of file operators.h.

                                                                             {
     ApproximatelyEqual<Scalar1,Scalar2> func(tol);
     return func(scalar1, scalar2);
 }

template<typename Scalar , typename Derived >

boost::enable_if<typename ExpressionTraits<Scalar>::IsScalar,bool>::type ndarray::allclose	(	Scalar const &	scalar,
		ExpressionBase< Derived > const &	expr,
		double	tol = `1E-8`
	)

inline

Definition at line 1220 of file operators.h.

                                                                                        {
     ApproximatelyEqual<Scalar,typename Derived::Element> func(tol);
     typename Derived::Iterator const i_end = expr.end();
     for (typename Derived::Iterator i = expr.begin(); i != i_end; ++i) {
         if (!allclose(scalar, *i, tol)) return false;
     }
     return true;
 }

template<typename Scalar , typename Derived >

boost::enable_if<typename ExpressionTraits<Scalar>::IsScalar,bool>::type ndarray::allclose	(	ExpressionBase< Derived > const &	expr,
		Scalar const &	scalar,
		double	tol = `1E-8`
	)

inline

Definition at line 1231 of file operators.h.

                                                                                        {
     return allclose(scalar, expr, tol);
 }

template<typename Derived1 , typename Derived2 >

bool ndarray::allclose	(	ExpressionBase< Derived1 > const &	expr1,
		ExpressionBase< Derived2 > const &	expr2,
		double	tol = `1E-8`
	)

inline

Definition at line 1237 of file operators.h.

                                                                                                           {
     typename Derived1::Iterator const i_end = expr1.end();
     typename Derived1::Iterator i = expr1.begin();
     typename Derived2::Iterator j = expr2.begin();
     for (; i != i_end; ++i, ++j) {
         if (!allclose(*i, *j, tol)) return false;
     }
     return true;
 }

template<typename Scalar >

boost::enable_if<typename ExpressionTraits<Scalar>::IsScalar, bool>::type ndarray::any ( Scalar const & scalar )

inline

Definition at line 1165 of file operators.h.

                            {
     return bool(scalar);
 }

detail::CountingExpression ndarray::arange ( int stop )

inline

Create 1D Expression that contains integer values in the range [0,stop).

Definition at line 112 of file arange.h.

                                                  {
     return detail::CountingExpression(stop);
 }

detail::UnaryOpExpression< detail::CountingExpression, detail::RangeTransformer<int> > ndarray::arange	(	int	start,
		int	stop,
		int	step = `1`
	)

inline

Create 1D Expression that contains integer values in the range [start,stop) with increment step.

Definition at line 118 of file arange.h.

                                           {
     NDARRAY_ASSERT(step != 0);
     int size = stop - start;
     if (step < -1) ++size;
     if (step > 1) --size;
     size /= step;
     return vectorize(
         detail::RangeTransformer<int>(start,step),
         detail::CountingExpression(size)
     );
 }

template<typename T >

SelectEigenView<T>::Type ndarray::copy ( Eigen::EigenBase< T > const & other )

inline

Copy an arbitrary Eigen expression into a new EigenView.

Definition at line 390 of file eigen.h.

                                                                              {
     typename SelectEigenView<T>::Type result(
         typename SelectEigenView<T>::Shallow(allocate(other.rows(), other.cols()))
     );
     result = other.derived();
     return result;
 }

template<typename T >

Manager::Ptr ndarray::makeManager ( T const & owner )

inline

Definition at line 101 of file Manager.h.

                                                {
     return Manager::Ptr(new ExternalManager<T>(owner));
 }

Manager::Ptr ndarray::makeManager ( Manager::Ptr const & owner )

inline

Definition at line 106 of file Manager.h.

                                                         {
     return owner;
 }

template<typename Derived >

std::ostream& ndarray::operator<<	(	std::ostream &	os,
		ExpressionBase< Derived > const &	expr
	)

Stream output for ExpressionBase using default-constructed FormatOptions.

Definition at line 83 of file formatting.h.

                                                                                {
     FormatOptions options;
     options.apply(os,expr);
     return os;
 }

template<typename Scalar >

boost::enable_if<typename ExpressionTraits<Scalar>::IsScalar, Scalar>::type ndarray::sum ( Scalar const & scalar )

inline

Definition at line 1250 of file operators.h.

1250 { return scalar; }

Namespaces

Classes

Typedefs

Enumerations

Functions

Typedef Documentation

Enumeration Type Documentation

Function Documentation