yakl::componentwise Namespace Reference

This namespace contains routines that perform element-wise / component-wise operations on Array, SArray, and FSArray objects. More...

Functions
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()+T2()), N, memDevice, STYLE >	add_array_scalar (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()+T2()), N, memDevice, STYLE >	add_scalar_array (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()&&T2()), N, memDevice, STYLE >	and_array_scalar (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()&&T2()), N, memDevice, STYLE >	and_scalar_array (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()/T2()), N, memDevice, STYLE >	div_array_scalar (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()/T2()), N, memDevice, STYLE >	div_scalar_array (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()==T2()), N, memDevice, STYLE >	eq_array_scalar (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()==T2()), N, memDevice, STYLE >	eq_scalar_array (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()>=T2()), N, memDevice, STYLE >	ge_array_scalar (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()>=T2()), N, memDevice, STYLE >	ge_scalar_array (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()>T2()), N, memDevice, STYLE >	gt_array_scalar (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()>T2()), N, memDevice, STYLE >	gt_scalar_array (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()<=T2()), N, memDevice, STYLE >	le_array_scalar (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()<=T2()), N, memDevice, STYLE >	le_scalar_array (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< bool, N, memDevice, STYLE >	lt_array_array (Array< T1, N, memDevice, STYLE > const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()< T2()), N, memDevice, STYLE >	lt_array_scalar (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()< T2()), N, memDevice, STYLE >	lt_scalar_array (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1() *T2()), N, memDevice, STYLE >	mult_array_scalar (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1() *T2()), N, memDevice, STYLE >	mult_scalar_array (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()!=T2()), N, memDevice, STYLE >	ne_array_scalar (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()!=T2()), N, memDevice, STYLE >	ne_scalar_array (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , int N, int STYLE>
Array< decltype(!T1()), N, memDevice, STYLE >	operator! (Array< T1, N, memDevice, STYLE > const &left)
template<class T1 , int N, int STYLE>
Array< decltype(!T1()), N, memHost, STYLE >	operator! (Array< T1, N, memHost, STYLE > const &left)
template<class T1 , int N, class B0 , class B1 , class B2 , class B3 >
YAKL_INLINE FSArray< decltype(!T1()), N, B0, B1, B2, B3 >	operator! (FSArray< T1, N, B0, B1, B2, B3 > const &left)
template<class T1 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>
YAKL_INLINE SArray< decltype(!T1()), N, D0, D1, D2, D3 >	operator! (SArray< T1, N, D0, D1, D2, D3 > const &left)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()!=T2()), N, memDevice, STYLE >	operator!= (Array< T1, N, memDevice, STYLE > const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1()!=T2()), N, memDevice, STYLE >	operator!= (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()!=T2()), N, memHost, STYLE >	operator!= (Array< T1, N, memHost, STYLE > const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1()!=T2()), N, memHost, STYLE >	operator!= (Array< T1, N, memHost, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >
YAKL_INLINE FSArray< decltype(T1()!=T2()), N, B0, B1, B2, B3 >	operator!= (FSArray< T1, N, B0, B1, B2, B3 > const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1()!=T2()), N, B0, B1, B2, B3 >	operator!= (FSArray< T1, N, B0, B1, B2, B3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>
YAKL_INLINE SArray< decltype(T1()!=T2()), N, D0, D1, D2, D3 >	operator!= (SArray< T1, N, D0, D1, D2, D3 > const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1()!=T2()), N, D0, D1, D2, D3 >	operator!= (SArray< T1, N, D0, D1, D2, D3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1()!=T2()), N, memDevice, STYLE >	operator!= (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1()!=T2()), N, memHost, STYLE >	operator!= (T1 const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1()!=T2()), N, B0, B1, B2, B3 >	operator!= (T1 const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1()!=T2()), N, D0, D1, D2, D3 >	operator!= (T1 const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()&&T2()), N, memDevice, STYLE >	operator&& (Array< T1, N, memDevice, STYLE > const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1()&&T2()), N, memDevice, STYLE >	operator&& (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()&&T2()), N, memHost, STYLE >	operator&& (Array< T1, N, memHost, STYLE > const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1()&&T2()), N, memHost, STYLE >	operator&& (Array< T1, N, memHost, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >
YAKL_INLINE FSArray< decltype(T1()&&T2()), N, B0, B1, B2, B3 >	operator&& (FSArray< T1, N, B0, B1, B2, B3 > const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1()&&T2()), N, B0, B1, B2, B3 >	operator&& (FSArray< T1, N, B0, B1, B2, B3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>
YAKL_INLINE SArray< decltype(T1()&&T2()), N, D0, D1, D2, D3 >	operator&& (SArray< T1, N, D0, D1, D2, D3 > const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1()&&T2()), N, D0, D1, D2, D3 >	operator&& (SArray< T1, N, D0, D1, D2, D3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1()&&T2()), N, memDevice, STYLE >	operator&& (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1()&&T2()), N, memHost, STYLE >	operator&& (T1 const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1()&&T2()), N, B0, B1, B2, B3 >	operator&& (T1 const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1()&&T2()), N, D0, D1, D2, D3 >	operator&& (T1 const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1() *T2()), N, memDevice, STYLE >	operator* (Array< T1, N, memDevice, STYLE > const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1() *T2()), N, memDevice, STYLE >	operator* (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1() *T2()), N, memHost, STYLE >	operator* (Array< T1, N, memHost, STYLE > const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1() *T2()), N, memHost, STYLE >	operator* (Array< T1, N, memHost, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >
YAKL_INLINE FSArray< decltype(T1() *T2()), N, B0, B1, B2, B3 >	operator* (FSArray< T1, N, B0, B1, B2, B3 > const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1() *T2()), N, B0, B1, B2, B3 >	operator* (FSArray< T1, N, B0, B1, B2, B3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>
YAKL_INLINE SArray< decltype(T1() *T2()), N, D0, D1, D2, D3 >	operator* (SArray< T1, N, D0, D1, D2, D3 > const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1() *T2()), N, D0, D1, D2, D3 >	operator* (SArray< T1, N, D0, D1, D2, D3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1() *T2()), N, memDevice, STYLE >	operator* (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1() *T2()), N, memHost, STYLE >	operator* (T1 const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1() *T2()), N, B0, B1, B2, B3 >	operator* (T1 const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1() *T2()), N, D0, D1, D2, D3 >	operator* (T1 const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()+T2()), N, memDevice, STYLE >	operator+ (Array< T1, N, memDevice, STYLE > const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1()+T2()), N, memDevice, STYLE >	operator+ (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()+T2()), N, memHost, STYLE >	operator+ (Array< T1, N, memHost, STYLE > const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1()+T2()), N, memHost, STYLE >	operator+ (Array< T1, N, memHost, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >
YAKL_INLINE FSArray< decltype(T1()+T2()), N, B0, B1, B2, B3 >	operator+ (FSArray< T1, N, B0, B1, B2, B3 > const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1()+T2()), N, B0, B1, B2, B3 >	operator+ (FSArray< T1, N, B0, B1, B2, B3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>
YAKL_INLINE SArray< decltype(T1()+T2()), N, D0, D1, D2, D3 >	operator+ (SArray< T1, N, D0, D1, D2, D3 > const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1()+T2()), N, D0, D1, D2, D3 >	operator+ (SArray< T1, N, D0, D1, D2, D3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1()+T2()), N, memDevice, STYLE >	operator+ (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1()+T2()), N, memHost, STYLE >	operator+ (T1 const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1()+T2()), N, B0, B1, B2, B3 >	operator+ (T1 const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1()+T2()), N, D0, D1, D2, D3 >	operator+ (T1 const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , int N, int STYLE>
Array< decltype(T1()+1), N, memDevice, STYLE >	operator++ (Array< T1, N, memDevice, STYLE > const &left)
template<class T1 , int N, int STYLE>
Array< decltype(T1()+1), N, memDevice, STYLE >	operator++ (Array< T1, N, memDevice, STYLE > const &left, int dummy)
template<class T1 , int N, int STYLE>
Array< decltype(T1()+1), N, memHost, STYLE >	operator++ (Array< T1, N, memHost, STYLE > const &left)
template<class T1 , int N, int STYLE>
Array< decltype(T1()+1), N, memHost, STYLE >	operator++ (Array< T1, N, memHost, STYLE > const &left, int dummy)
template<class T1 , int N, class B0 , class B1 , class B2 , class B3 >
YAKL_INLINE FSArray< decltype(T1()+1), N, B0, B1, B2, B3 >	operator++ (FSArray< T1, N, B0, B1, B2, B3 > const &left)
template<class T1 , int N, class B0 , class B1 , class B2 , class B3 >
YAKL_INLINE FSArray< decltype(T1()+1), N, B0, B1, B2, B3 >	operator++ (FSArray< T1, N, B0, B1, B2, B3 > const &left, int dummy)
template<class T1 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>
YAKL_INLINE SArray< decltype(T1()+1), N, D0, D1, D2, D3 >	operator++ (SArray< T1, N, D0, D1, D2, D3 > const &left)
template<class T1 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>
YAKL_INLINE SArray< decltype(T1()+1), N, D0, D1, D2, D3 >	operator++ (SArray< T1, N, D0, D1, D2, D3 > const &left, int dummy)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1() -T2()), N, memDevice, STYLE >	operator- (Array< T1, N, memDevice, STYLE > const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1() -T2()), N, memDevice, STYLE >	operator- (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1() -T2()), N, memHost, STYLE >	operator- (Array< T1, N, memHost, STYLE > const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1() -T2()), N, memHost, STYLE >	operator- (Array< T1, N, memHost, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >
YAKL_INLINE FSArray< decltype(T1() -T2()), N, B0, B1, B2, B3 >	operator- (FSArray< T1, N, B0, B1, B2, B3 > const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1() -T2()), N, B0, B1, B2, B3 >	operator- (FSArray< T1, N, B0, B1, B2, B3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>
YAKL_INLINE SArray< decltype(T1() -T2()), N, D0, D1, D2, D3 >	operator- (SArray< T1, N, D0, D1, D2, D3 > const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1() -T2()), N, D0, D1, D2, D3 >	operator- (SArray< T1, N, D0, D1, D2, D3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1() -T2()), N, memDevice, STYLE >	operator- (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1() -T2()), N, memHost, STYLE >	operator- (T1 const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1() -T2()), N, B0, B1, B2, B3 >	operator- (T1 const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1() -T2()), N, D0, D1, D2, D3 >	operator- (T1 const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , int N, int STYLE>
Array< decltype(T1() -1), N, memDevice, STYLE >	operator-- (Array< T1, N, memDevice, STYLE > const &left)
template<class T1 , int N, int STYLE>
Array< decltype(T1() -1), N, memDevice, STYLE >	operator-- (Array< T1, N, memDevice, STYLE > const &left, int dummy)
template<class T1 , int N, int STYLE>
Array< decltype(T1() -1), N, memHost, STYLE >	operator-- (Array< T1, N, memHost, STYLE > const &left)
template<class T1 , int N, int STYLE>
Array< decltype(T1() -1), N, memHost, STYLE >	operator-- (Array< T1, N, memHost, STYLE > const &left, int dummy)
template<class T1 , int N, class B0 , class B1 , class B2 , class B3 >
YAKL_INLINE FSArray< decltype(T1() -1), N, B0, B1, B2, B3 >	operator-- (FSArray< T1, N, B0, B1, B2, B3 > const &left)
template<class T1 , int N, class B0 , class B1 , class B2 , class B3 >
YAKL_INLINE FSArray< decltype(T1() -1), N, B0, B1, B2, B3 >	operator-- (FSArray< T1, N, B0, B1, B2, B3 > const &left, int dummy)
template<class T1 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>
YAKL_INLINE SArray< decltype(T1() -1), N, D0, D1, D2, D3 >	operator-- (SArray< T1, N, D0, D1, D2, D3 > const &left)
template<class T1 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>
YAKL_INLINE SArray< decltype(T1() -1), N, D0, D1, D2, D3 >	operator-- (SArray< T1, N, D0, D1, D2, D3 > const &left, int dummy)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()/T2()), N, memDevice, STYLE >	operator/ (Array< T1, N, memDevice, STYLE > const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1()/T2()), N, memDevice, STYLE >	operator/ (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()/T2()), N, memHost, STYLE >	operator/ (Array< T1, N, memHost, STYLE > const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1()/T2()), N, memHost, STYLE >	operator/ (Array< T1, N, memHost, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >
YAKL_INLINE FSArray< decltype(T1()/T2()), N, B0, B1, B2, B3 >	operator/ (FSArray< T1, N, B0, B1, B2, B3 > const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1()/T2()), N, B0, B1, B2, B3 >	operator/ (FSArray< T1, N, B0, B1, B2, B3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>
YAKL_INLINE SArray< decltype(T1()/T2()), N, D0, D1, D2, D3 >	operator/ (SArray< T1, N, D0, D1, D2, D3 > const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1()/T2()), N, D0, D1, D2, D3 >	operator/ (SArray< T1, N, D0, D1, D2, D3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1()/T2()), N, memDevice, STYLE >	operator/ (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1()/T2()), N, memHost, STYLE >	operator/ (T1 const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1()/T2()), N, B0, B1, B2, B3 >	operator/ (T1 const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1()/T2()), N, D0, D1, D2, D3 >	operator/ (T1 const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< bool, N, memDevice, STYLE >	operator< (Array< T1, N, memDevice, STYLE > const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1()< T2()), N, memDevice, STYLE >	operator< (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()< T2()), N, memHost, STYLE >	operator< (Array< T1, N, memHost, STYLE > const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1()< T2()), N, memHost, STYLE >	operator< (Array< T1, N, memHost, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >
YAKL_INLINE FSArray< decltype(T1()< T2()), N, B0, B1, B2, B3 >	operator< (FSArray< T1, N, B0, B1, B2, B3 > const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1()< T2()), N, B0, B1, B2, B3 >	operator< (FSArray< T1, N, B0, B1, B2, B3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>
YAKL_INLINE SArray< decltype(T1()< T2()), N, D0, D1, D2, D3 >	operator< (SArray< T1, N, D0, D1, D2, D3 > const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1()< T2()), N, D0, D1, D2, D3 >	operator< (SArray< T1, N, D0, D1, D2, D3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1()< T2()), N, memDevice, STYLE >	operator< (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1()< T2()), N, memHost, STYLE >	operator< (T1 const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1()< T2()), N, B0, B1, B2, B3 >	operator< (T1 const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1()< T2()), N, D0, D1, D2, D3 >	operator< (T1 const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()<=T2()), N, memDevice, STYLE >	operator<= (Array< T1, N, memDevice, STYLE > const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1()<=T2()), N, memDevice, STYLE >	operator<= (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()<=T2()), N, memHost, STYLE >	operator<= (Array< T1, N, memHost, STYLE > const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1()<=T2()), N, memHost, STYLE >	operator<= (Array< T1, N, memHost, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >
YAKL_INLINE FSArray< decltype(T1()<=T2()), N, B0, B1, B2, B3 >	operator<= (FSArray< T1, N, B0, B1, B2, B3 > const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1()<=T2()), N, B0, B1, B2, B3 >	operator<= (FSArray< T1, N, B0, B1, B2, B3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>
YAKL_INLINE SArray< decltype(T1()<=T2()), N, D0, D1, D2, D3 >	operator<= (SArray< T1, N, D0, D1, D2, D3 > const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1()<=T2()), N, D0, D1, D2, D3 >	operator<= (SArray< T1, N, D0, D1, D2, D3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1()<=T2()), N, memDevice, STYLE >	operator<= (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1()<=T2()), N, memHost, STYLE >	operator<= (T1 const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1()<=T2()), N, B0, B1, B2, B3 >	operator<= (T1 const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1()<=T2()), N, D0, D1, D2, D3 >	operator<= (T1 const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()==T2()), N, memDevice, STYLE >	operator== (Array< T1, N, memDevice, STYLE > const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1()==T2()), N, memDevice, STYLE >	operator== (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()==T2()), N, memHost, STYLE >	operator== (Array< T1, N, memHost, STYLE > const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1()==T2()), N, memHost, STYLE >	operator== (Array< T1, N, memHost, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >
YAKL_INLINE FSArray< decltype(T1()==T2()), N, B0, B1, B2, B3 >	operator== (FSArray< T1, N, B0, B1, B2, B3 > const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1()==T2()), N, B0, B1, B2, B3 >	operator== (FSArray< T1, N, B0, B1, B2, B3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>
YAKL_INLINE SArray< decltype(T1()==T2()), N, D0, D1, D2, D3 >	operator== (SArray< T1, N, D0, D1, D2, D3 > const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1()==T2()), N, D0, D1, D2, D3 >	operator== (SArray< T1, N, D0, D1, D2, D3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1()==T2()), N, memDevice, STYLE >	operator== (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1()==T2()), N, memHost, STYLE >	operator== (T1 const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1()==T2()), N, B0, B1, B2, B3 >	operator== (T1 const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1()==T2()), N, D0, D1, D2, D3 >	operator== (T1 const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()>T2()), N, memDevice, STYLE >	operator> (Array< T1, N, memDevice, STYLE > const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1()>T2()), N, memDevice, STYLE >	operator> (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()>T2()), N, memHost, STYLE >	operator> (Array< T1, N, memHost, STYLE > const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1()>T2()), N, memHost, STYLE >	operator> (Array< T1, N, memHost, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >
YAKL_INLINE FSArray< decltype(T1()>T2()), N, B0, B1, B2, B3 >	operator> (FSArray< T1, N, B0, B1, B2, B3 > const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1()>T2()), N, B0, B1, B2, B3 >	operator> (FSArray< T1, N, B0, B1, B2, B3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>
YAKL_INLINE SArray< decltype(T1()>T2()), N, D0, D1, D2, D3 >	operator> (SArray< T1, N, D0, D1, D2, D3 > const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1()>T2()), N, D0, D1, D2, D3 >	operator> (SArray< T1, N, D0, D1, D2, D3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1()>T2()), N, memDevice, STYLE >	operator> (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1()>T2()), N, memHost, STYLE >	operator> (T1 const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1()>T2()), N, B0, B1, B2, B3 >	operator> (T1 const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1()>T2()), N, D0, D1, D2, D3 >	operator> (T1 const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()>=T2()), N, memDevice, STYLE >	operator>= (Array< T1, N, memDevice, STYLE > const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1()>=T2()), N, memDevice, STYLE >	operator>= (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()>=T2()), N, memHost, STYLE >	operator>= (Array< T1, N, memHost, STYLE > const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1()>=T2()), N, memHost, STYLE >	operator>= (Array< T1, N, memHost, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >
YAKL_INLINE FSArray< decltype(T1()>=T2()), N, B0, B1, B2, B3 >	operator>= (FSArray< T1, N, B0, B1, B2, B3 > const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1()>=T2()), N, B0, B1, B2, B3 >	operator>= (FSArray< T1, N, B0, B1, B2, B3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>
YAKL_INLINE SArray< decltype(T1()>=T2()), N, D0, D1, D2, D3 >	operator>= (SArray< T1, N, D0, D1, D2, D3 > const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1()>=T2()), N, D0, D1, D2, D3 >	operator>= (SArray< T1, N, D0, D1, D2, D3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1()>=T2()), N, memDevice, STYLE >	operator>= (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1()>=T2()), N, memHost, STYLE >	operator>= (T1 const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1()>=T2()), N, B0, B1, B2, B3 >	operator>= (T1 const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1()>=T2()), N, D0, D1, D2, D3 >	operator>= (T1 const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()||T2()), N, memDevice, STYLE >	operator|| (Array< T1, N, memDevice, STYLE > const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1()||T2()), N, memDevice, STYLE >	operator|| (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()||T2()), N, memHost, STYLE >	operator|| (Array< T1, N, memHost, STYLE > const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
Array< decltype(T1()||T2()), N, memHost, STYLE >	operator|| (Array< T1, N, memHost, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >
YAKL_INLINE FSArray< decltype(T1()||T2()), N, B0, B1, B2, B3 >	operator|| (FSArray< T1, N, B0, B1, B2, B3 > const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1()||T2()), N, B0, B1, B2, B3 >	operator|| (FSArray< T1, N, B0, B1, B2, B3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>
YAKL_INLINE SArray< decltype(T1()||T2()), N, D0, D1, D2, D3 >	operator|| (SArray< T1, N, D0, D1, D2, D3 > const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1()||T2()), N, D0, D1, D2, D3 >	operator|| (SArray< T1, N, D0, D1, D2, D3 > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1()||T2()), N, memDevice, STYLE >	operator|| (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
Array< decltype(T1()||T2()), N, memHost, STYLE >	operator|| (T1 const &left, Array< T2, N, memHost, STYLE > const &right)
template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE FSArray< decltype(T1()||T2()), N, B0, B1, B2, B3 >	operator|| (T1 const &left, FSArray< T2, N, B0, B1, B2, B3 > const &right)
template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>
YAKL_INLINE SArray< decltype(T1()||T2()), N, D0, D1, D2, D3 >	operator|| (T1 const &left, SArray< T2, N, D0, D1, D2, D3 > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()||T2()), N, memDevice, STYLE >	or_array_scalar (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1()||T2()), N, memDevice, STYLE >	or_scalar_array (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1() -T2()), N, memDevice, STYLE >	sub_array_scalar (Array< T1, N, memDevice, STYLE > const &left, T2 const &right)
template<class T1 , class T2 , int N, int STYLE>
Array< decltype(T1() -T2()), N, memDevice, STYLE >	sub_scalar_array (T1 const &left, Array< T2, N, memDevice, STYLE > const &right)

Detailed Description

This namespace contains routines that perform element-wise / component-wise operations on Array, SArray, and FSArray objects.

Function Documentation

add_array_scalar()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()+T2()),N,memDevice,STYLE> yakl::componentwise::add_array_scalar ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

add_scalar_array()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()+T2()),N,memDevice,STYLE> yakl::componentwise::add_scalar_array ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

and_array_scalar()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()&&T2()),N,memDevice,STYLE> yakl::componentwise::and_array_scalar ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

and_scalar_array()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()&&T2()),N,memDevice,STYLE> yakl::componentwise::and_scalar_array ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

div_array_scalar()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()/T2()),N,memDevice,STYLE> yakl::componentwise::div_array_scalar ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

div_scalar_array()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()/T2()),N,memDevice,STYLE> yakl::componentwise::div_scalar_array ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

eq_array_scalar()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()==T2()),N,memDevice,STYLE> yakl::componentwise::eq_array_scalar ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

eq_scalar_array()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()==T2()),N,memDevice,STYLE> yakl::componentwise::eq_scalar_array ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

ge_array_scalar()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()>=T2()),N,memDevice,STYLE> yakl::componentwise::ge_array_scalar ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

ge_scalar_array()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()>=T2()),N,memDevice,STYLE> yakl::componentwise::ge_scalar_array ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

gt_array_scalar()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()>T2()),N,memDevice,STYLE> yakl::componentwise::gt_array_scalar ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

gt_scalar_array()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()>T2()),N,memDevice,STYLE> yakl::componentwise::gt_scalar_array ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

le_array_scalar()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()<=T2()),N,memDevice,STYLE> yakl::componentwise::le_array_scalar ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

le_scalar_array()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()<=T2()),N,memDevice,STYLE> yakl::componentwise::le_scalar_array ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

lt_array_array()

template<class T1 , class T2 , int N, int STYLE>

Array<bool,N,memDevice,STYLE> yakl::componentwise::lt_array_array ( Array< T1, N, memDevice, STYLE > const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

lt_array_scalar()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()<T2()),N,memDevice,STYLE> yakl::componentwise::lt_array_scalar ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

lt_scalar_array()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()<T2()),N,memDevice,STYLE> yakl::componentwise::lt_scalar_array ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

mult_array_scalar()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()*T2()),N,memDevice,STYLE> yakl::componentwise::mult_array_scalar ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

mult_scalar_array()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()*T2()),N,memDevice,STYLE> yakl::componentwise::mult_scalar_array ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

ne_array_scalar()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()!=T2()),N,memDevice,STYLE> yakl::componentwise::ne_array_scalar ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

ne_scalar_array()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()!=T2()),N,memDevice,STYLE> yakl::componentwise::ne_scalar_array ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator!() [1/4]

template<class T1 , int N, int STYLE>

Array<decltype(!T1()),N,memDevice,STYLE> yakl::componentwise::operator! ( Array< T1, N, memDevice, STYLE > const &  left )

inline

operator!() [2/4]

template<class T1 , int N, int STYLE>

Array<decltype(!T1()),N,memHost,STYLE> yakl::componentwise::operator! ( Array< T1, N, memHost, STYLE > const &  left )

inline

operator!() [3/4]

template<class T1 , int N, class B0 , class B1 , class B2 , class B3 >

YAKL_INLINE FSArray<decltype(!T1()),N,B0,B1,B2,B3> yakl::componentwise::operator!

(

FSArray< T1, N, B0, B1, B2, B3 > const &

left

)

operator!() [4/4]

template<class T1 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>

YAKL_INLINE SArray<decltype(!T1()),N,D0,D1,D2,D3> yakl::componentwise::operator!

(

SArray< T1, N, D0, D1, D2, D3 > const &

left

)

operator!=() [1/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()!=T2()),N,memDevice,STYLE> yakl::componentwise::operator!= ( Array< T1, N, memDevice, STYLE > const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator!=() [2/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()!=T2()),N,memDevice,STYLE> yakl::componentwise::operator!= ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

operator!=() [3/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()!=T2()),N,memHost,STYLE> yakl::componentwise::operator!= ( Array< T1, N, memHost, STYLE > const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator!=() [4/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()!=T2()),N,memHost,STYLE> yakl::componentwise::operator!= ( Array< T1, N, memHost, STYLE > const &  left, T2 const &  right  )

inline

operator!=() [5/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >

YAKL_INLINE FSArray<decltype(T1()!=T2()),N,B0,B1,B2,B3> yakl::componentwise::operator!=	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator!=() [6/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()!=T2()),N,B0,B1,B2,B3> yakl::componentwise::operator!=	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		T2 const &	right
	)

operator!=() [7/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>

YAKL_INLINE SArray<decltype(T1()!=T2()),N,D0,D1,D2,D3> yakl::componentwise::operator!=	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator!=() [8/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()!=T2()),N,D0,D1,D2,D3> yakl::componentwise::operator!=	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		T2 const &	right
	)

operator!=() [9/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()!=T2()),N,memDevice,STYLE> yakl::componentwise::operator!= ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator!=() [10/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()!=T2()),N,memHost,STYLE> yakl::componentwise::operator!= ( T1 const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator!=() [11/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()!=T2()),N,B0,B1,B2,B3> yakl::componentwise::operator!=	(	T1 const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator!=() [12/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()!=T2()),N,D0,D1,D2,D3> yakl::componentwise::operator!=	(	T1 const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator&&() [1/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()&&T2()),N,memDevice,STYLE> yakl::componentwise::operator&& ( Array< T1, N, memDevice, STYLE > const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator&&() [2/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()&&T2()),N,memDevice,STYLE> yakl::componentwise::operator&& ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

operator&&() [3/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()&&T2()),N,memHost,STYLE> yakl::componentwise::operator&& ( Array< T1, N, memHost, STYLE > const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator&&() [4/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()&&T2()),N,memHost,STYLE> yakl::componentwise::operator&& ( Array< T1, N, memHost, STYLE > const &  left, T2 const &  right  )

inline

operator&&() [5/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >

YAKL_INLINE FSArray<decltype(T1()&&T2()),N,B0,B1,B2,B3> yakl::componentwise::operator&&	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator&&() [6/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()&&T2()),N,B0,B1,B2,B3> yakl::componentwise::operator&&	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		T2 const &	right
	)

operator&&() [7/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>

YAKL_INLINE SArray<decltype(T1()&&T2()),N,D0,D1,D2,D3> yakl::componentwise::operator&&	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator&&() [8/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()&&T2()),N,D0,D1,D2,D3> yakl::componentwise::operator&&	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		T2 const &	right
	)

operator&&() [9/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()&&T2()),N,memDevice,STYLE> yakl::componentwise::operator&& ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator&&() [10/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()&&T2()),N,memHost,STYLE> yakl::componentwise::operator&& ( T1 const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator&&() [11/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()&&T2()),N,B0,B1,B2,B3> yakl::componentwise::operator&&	(	T1 const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator&&() [12/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()&&T2()),N,D0,D1,D2,D3> yakl::componentwise::operator&&	(	T1 const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator*() [1/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()*T2()),N,memDevice,STYLE> yakl::componentwise::operator* ( Array< T1, N, memDevice, STYLE > const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator*() [2/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()*T2()),N,memDevice,STYLE> yakl::componentwise::operator* ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

operator*() [3/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()*T2()),N,memHost,STYLE> yakl::componentwise::operator* ( Array< T1, N, memHost, STYLE > const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator*() [4/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()*T2()),N,memHost,STYLE> yakl::componentwise::operator* ( Array< T1, N, memHost, STYLE > const &  left, T2 const &  right  )

inline

operator*() [5/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >

YAKL_INLINE FSArray<decltype(T1()*T2()),N,B0,B1,B2,B3> yakl::componentwise::operator*	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator*() [6/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()*T2()),N,B0,B1,B2,B3> yakl::componentwise::operator*	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		T2 const &	right
	)

operator*() [7/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>

YAKL_INLINE SArray<decltype(T1()*T2()),N,D0,D1,D2,D3> yakl::componentwise::operator*	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator*() [8/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()*T2()),N,D0,D1,D2,D3> yakl::componentwise::operator*	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		T2 const &	right
	)

operator*() [9/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()*T2()),N,memDevice,STYLE> yakl::componentwise::operator* ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator*() [10/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()*T2()),N,memHost,STYLE> yakl::componentwise::operator* ( T1 const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator*() [11/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()*T2()),N,B0,B1,B2,B3> yakl::componentwise::operator*	(	T1 const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator*() [12/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()*T2()),N,D0,D1,D2,D3> yakl::componentwise::operator*	(	T1 const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator+() [1/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()+T2()),N,memDevice,STYLE> yakl::componentwise::operator+ ( Array< T1, N, memDevice, STYLE > const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator+() [2/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()+T2()),N,memDevice,STYLE> yakl::componentwise::operator+ ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

operator+() [3/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()+T2()),N,memHost,STYLE> yakl::componentwise::operator+ ( Array< T1, N, memHost, STYLE > const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator+() [4/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()+T2()),N,memHost,STYLE> yakl::componentwise::operator+ ( Array< T1, N, memHost, STYLE > const &  left, T2 const &  right  )

inline

operator+() [5/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >

YAKL_INLINE FSArray<decltype(T1()+T2()),N,B0,B1,B2,B3> yakl::componentwise::operator+	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator+() [6/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()+T2()),N,B0,B1,B2,B3> yakl::componentwise::operator+	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		T2 const &	right
	)

operator+() [7/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>

YAKL_INLINE SArray<decltype(T1()+T2()),N,D0,D1,D2,D3> yakl::componentwise::operator+	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator+() [8/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()+T2()),N,D0,D1,D2,D3> yakl::componentwise::operator+	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		T2 const &	right
	)

operator+() [9/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()+T2()),N,memDevice,STYLE> yakl::componentwise::operator+ ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator+() [10/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()+T2()),N,memHost,STYLE> yakl::componentwise::operator+ ( T1 const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator+() [11/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()+T2()),N,B0,B1,B2,B3> yakl::componentwise::operator+	(	T1 const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator+() [12/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()+T2()),N,D0,D1,D2,D3> yakl::componentwise::operator+	(	T1 const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator++() [1/8]

template<class T1 , int N, int STYLE>

Array<decltype(T1()+1),N,memDevice,STYLE> yakl::componentwise::operator++ ( Array< T1, N, memDevice, STYLE > const &  left )

inline

operator++() [2/8]

template<class T1 , int N, int STYLE>

Array<decltype(T1()+1),N,memDevice,STYLE> yakl::componentwise::operator++ ( Array< T1, N, memDevice, STYLE > const &  left, int  dummy  )

inline

operator++() [3/8]

template<class T1 , int N, int STYLE>

Array<decltype(T1()+1),N,memHost,STYLE> yakl::componentwise::operator++ ( Array< T1, N, memHost, STYLE > const &  left )

inline

operator++() [4/8]

template<class T1 , int N, int STYLE>

Array<decltype(T1()+1),N,memHost,STYLE> yakl::componentwise::operator++ ( Array< T1, N, memHost, STYLE > const &  left, int  dummy  )

inline

operator++() [5/8]

template<class T1 , int N, class B0 , class B1 , class B2 , class B3 >

YAKL_INLINE FSArray<decltype(T1()+1),N,B0,B1,B2,B3> yakl::componentwise::operator++

(

FSArray< T1, N, B0, B1, B2, B3 > const &

left

)

operator++() [6/8]

template<class T1 , int N, class B0 , class B1 , class B2 , class B3 >

YAKL_INLINE FSArray<decltype(T1()+1),N,B0,B1,B2,B3> yakl::componentwise::operator++	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		int	dummy
	)

operator++() [7/8]

template<class T1 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>

YAKL_INLINE SArray<decltype(T1()+1),N,D0,D1,D2,D3> yakl::componentwise::operator++

(

SArray< T1, N, D0, D1, D2, D3 > const &

left

)

operator++() [8/8]

template<class T1 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>

YAKL_INLINE SArray<decltype(T1()+1),N,D0,D1,D2,D3> yakl::componentwise::operator++	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		int	dummy
	)

operator-() [1/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()-T2()),N,memDevice,STYLE> yakl::componentwise::operator- ( Array< T1, N, memDevice, STYLE > const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator-() [2/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()-T2()),N,memDevice,STYLE> yakl::componentwise::operator- ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

operator-() [3/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()-T2()),N,memHost,STYLE> yakl::componentwise::operator- ( Array< T1, N, memHost, STYLE > const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator-() [4/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()-T2()),N,memHost,STYLE> yakl::componentwise::operator- ( Array< T1, N, memHost, STYLE > const &  left, T2 const &  right  )

inline

operator-() [5/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >

YAKL_INLINE FSArray<decltype(T1()-T2()),N,B0,B1,B2,B3> yakl::componentwise::operator-	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator-() [6/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()-T2()),N,B0,B1,B2,B3> yakl::componentwise::operator-	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		T2 const &	right
	)

operator-() [7/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>

YAKL_INLINE SArray<decltype(T1()-T2()),N,D0,D1,D2,D3> yakl::componentwise::operator-	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator-() [8/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()-T2()),N,D0,D1,D2,D3> yakl::componentwise::operator-	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		T2 const &	right
	)

operator-() [9/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()-T2()),N,memDevice,STYLE> yakl::componentwise::operator- ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator-() [10/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()-T2()),N,memHost,STYLE> yakl::componentwise::operator- ( T1 const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator-() [11/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()-T2()),N,B0,B1,B2,B3> yakl::componentwise::operator-	(	T1 const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator-() [12/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()-T2()),N,D0,D1,D2,D3> yakl::componentwise::operator-	(	T1 const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator--() [1/8]

template<class T1 , int N, int STYLE>

Array<decltype(T1()-1),N,memDevice,STYLE> yakl::componentwise::operator-- ( Array< T1, N, memDevice, STYLE > const &  left )

inline

operator--() [2/8]

template<class T1 , int N, int STYLE>

Array<decltype(T1()-1),N,memDevice,STYLE> yakl::componentwise::operator-- ( Array< T1, N, memDevice, STYLE > const &  left, int  dummy  )

inline

operator--() [3/8]

template<class T1 , int N, int STYLE>

Array<decltype(T1()-1),N,memHost,STYLE> yakl::componentwise::operator-- ( Array< T1, N, memHost, STYLE > const &  left )

inline

operator--() [4/8]

template<class T1 , int N, int STYLE>

Array<decltype(T1()-1),N,memHost,STYLE> yakl::componentwise::operator-- ( Array< T1, N, memHost, STYLE > const &  left, int  dummy  )

inline

operator--() [5/8]

template<class T1 , int N, class B0 , class B1 , class B2 , class B3 >

YAKL_INLINE FSArray<decltype(T1()-1),N,B0,B1,B2,B3> yakl::componentwise::operator--

(

FSArray< T1, N, B0, B1, B2, B3 > const &

left

)

operator--() [6/8]

template<class T1 , int N, class B0 , class B1 , class B2 , class B3 >

YAKL_INLINE FSArray<decltype(T1()-1),N,B0,B1,B2,B3> yakl::componentwise::operator--	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		int	dummy
	)

operator--() [7/8]

template<class T1 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>

YAKL_INLINE SArray<decltype(T1()-1),N,D0,D1,D2,D3> yakl::componentwise::operator--

(

SArray< T1, N, D0, D1, D2, D3 > const &

left

)

operator--() [8/8]

template<class T1 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>

YAKL_INLINE SArray<decltype(T1()-1),N,D0,D1,D2,D3> yakl::componentwise::operator--	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		int	dummy
	)

operator/() [1/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()/T2()),N,memDevice,STYLE> yakl::componentwise::operator/ ( Array< T1, N, memDevice, STYLE > const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator/() [2/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()/T2()),N,memDevice,STYLE> yakl::componentwise::operator/ ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

operator/() [3/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()/T2()),N,memHost,STYLE> yakl::componentwise::operator/ ( Array< T1, N, memHost, STYLE > const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator/() [4/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()/T2()),N,memHost,STYLE> yakl::componentwise::operator/ ( Array< T1, N, memHost, STYLE > const &  left, T2 const &  right  )

inline

operator/() [5/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >

YAKL_INLINE FSArray<decltype(T1()/T2()),N,B0,B1,B2,B3> yakl::componentwise::operator/	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator/() [6/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()/T2()),N,B0,B1,B2,B3> yakl::componentwise::operator/	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		T2 const &	right
	)

operator/() [7/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>

YAKL_INLINE SArray<decltype(T1()/T2()),N,D0,D1,D2,D3> yakl::componentwise::operator/	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator/() [8/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()/T2()),N,D0,D1,D2,D3> yakl::componentwise::operator/	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		T2 const &	right
	)

operator/() [9/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()/T2()),N,memDevice,STYLE> yakl::componentwise::operator/ ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator/() [10/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()/T2()),N,memHost,STYLE> yakl::componentwise::operator/ ( T1 const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator/() [11/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()/T2()),N,B0,B1,B2,B3> yakl::componentwise::operator/	(	T1 const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator/() [12/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()/T2()),N,D0,D1,D2,D3> yakl::componentwise::operator/	(	T1 const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator<() [1/12]

template<class T1 , class T2 , int N, int STYLE>

Array<bool,N,memDevice,STYLE> yakl::componentwise::operator< ( Array< T1, N, memDevice, STYLE > const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator<() [2/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()<T2()),N,memDevice,STYLE> yakl::componentwise::operator< ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

operator<() [3/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()<T2()),N,memHost,STYLE> yakl::componentwise::operator< ( Array< T1, N, memHost, STYLE > const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator<() [4/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()<T2()),N,memHost,STYLE> yakl::componentwise::operator< ( Array< T1, N, memHost, STYLE > const &  left, T2 const &  right  )

inline

operator<() [5/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >

YAKL_INLINE FSArray<decltype(T1()<T2()),N,B0,B1,B2,B3> yakl::componentwise::operator<	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator<() [6/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()<T2()),N,B0,B1,B2,B3> yakl::componentwise::operator<	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		T2 const &	right
	)

operator<() [7/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>

YAKL_INLINE SArray<decltype(T1()<T2()),N,D0,D1,D2,D3> yakl::componentwise::operator<	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator<() [8/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()<T2()),N,D0,D1,D2,D3> yakl::componentwise::operator<	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		T2 const &	right
	)

operator<() [9/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()<T2()),N,memDevice,STYLE> yakl::componentwise::operator< ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator<() [10/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()<T2()),N,memHost,STYLE> yakl::componentwise::operator< ( T1 const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator<() [11/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()<T2()),N,B0,B1,B2,B3> yakl::componentwise::operator<	(	T1 const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator<() [12/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()<T2()),N,D0,D1,D2,D3> yakl::componentwise::operator<	(	T1 const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator<=() [1/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()<=T2()),N,memDevice,STYLE> yakl::componentwise::operator<= ( Array< T1, N, memDevice, STYLE > const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator<=() [2/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()<=T2()),N,memDevice,STYLE> yakl::componentwise::operator<= ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

operator<=() [3/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()<=T2()),N,memHost,STYLE> yakl::componentwise::operator<= ( Array< T1, N, memHost, STYLE > const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator<=() [4/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()<=T2()),N,memHost,STYLE> yakl::componentwise::operator<= ( Array< T1, N, memHost, STYLE > const &  left, T2 const &  right  )

inline

operator<=() [5/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >

YAKL_INLINE FSArray<decltype(T1()<=T2()),N,B0,B1,B2,B3> yakl::componentwise::operator<=	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator<=() [6/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()<=T2()),N,B0,B1,B2,B3> yakl::componentwise::operator<=	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		T2 const &	right
	)

operator<=() [7/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>

YAKL_INLINE SArray<decltype(T1()<=T2()),N,D0,D1,D2,D3> yakl::componentwise::operator<=	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator<=() [8/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()<=T2()),N,D0,D1,D2,D3> yakl::componentwise::operator<=	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		T2 const &	right
	)

operator<=() [9/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()<=T2()),N,memDevice,STYLE> yakl::componentwise::operator<= ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator<=() [10/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()<=T2()),N,memHost,STYLE> yakl::componentwise::operator<= ( T1 const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator<=() [11/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()<=T2()),N,B0,B1,B2,B3> yakl::componentwise::operator<=	(	T1 const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator<=() [12/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()<=T2()),N,D0,D1,D2,D3> yakl::componentwise::operator<=	(	T1 const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator==() [1/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()==T2()),N,memDevice,STYLE> yakl::componentwise::operator== ( Array< T1, N, memDevice, STYLE > const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator==() [2/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()==T2()),N,memDevice,STYLE> yakl::componentwise::operator== ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

operator==() [3/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()==T2()),N,memHost,STYLE> yakl::componentwise::operator== ( Array< T1, N, memHost, STYLE > const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator==() [4/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()==T2()),N,memHost,STYLE> yakl::componentwise::operator== ( Array< T1, N, memHost, STYLE > const &  left, T2 const &  right  )

inline

operator==() [5/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >

YAKL_INLINE FSArray<decltype(T1()==T2()),N,B0,B1,B2,B3> yakl::componentwise::operator==	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator==() [6/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()==T2()),N,B0,B1,B2,B3> yakl::componentwise::operator==	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		T2 const &	right
	)

operator==() [7/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>

YAKL_INLINE SArray<decltype(T1()==T2()),N,D0,D1,D2,D3> yakl::componentwise::operator==	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator==() [8/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()==T2()),N,D0,D1,D2,D3> yakl::componentwise::operator==	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		T2 const &	right
	)

operator==() [9/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()==T2()),N,memDevice,STYLE> yakl::componentwise::operator== ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator==() [10/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()==T2()),N,memHost,STYLE> yakl::componentwise::operator== ( T1 const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator==() [11/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()==T2()),N,B0,B1,B2,B3> yakl::componentwise::operator==	(	T1 const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator==() [12/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()==T2()),N,D0,D1,D2,D3> yakl::componentwise::operator==	(	T1 const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator>() [1/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()>T2()),N,memDevice,STYLE> yakl::componentwise::operator> ( Array< T1, N, memDevice, STYLE > const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator>() [2/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()>T2()),N,memDevice,STYLE> yakl::componentwise::operator> ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

operator>() [3/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()>T2()),N,memHost,STYLE> yakl::componentwise::operator> ( Array< T1, N, memHost, STYLE > const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator>() [4/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()>T2()),N,memHost,STYLE> yakl::componentwise::operator> ( Array< T1, N, memHost, STYLE > const &  left, T2 const &  right  )

inline

operator>() [5/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >

YAKL_INLINE FSArray<decltype(T1()>T2()),N,B0,B1,B2,B3> yakl::componentwise::operator>	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator>() [6/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()>T2()),N,B0,B1,B2,B3> yakl::componentwise::operator>	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		T2 const &	right
	)

operator>() [7/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>

YAKL_INLINE SArray<decltype(T1()>T2()),N,D0,D1,D2,D3> yakl::componentwise::operator>	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator>() [8/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()>T2()),N,D0,D1,D2,D3> yakl::componentwise::operator>	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		T2 const &	right
	)

operator>() [9/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()>T2()),N,memDevice,STYLE> yakl::componentwise::operator> ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator>() [10/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()>T2()),N,memHost,STYLE> yakl::componentwise::operator> ( T1 const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator>() [11/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()>T2()),N,B0,B1,B2,B3> yakl::componentwise::operator>	(	T1 const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator>() [12/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()>T2()),N,D0,D1,D2,D3> yakl::componentwise::operator>	(	T1 const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator>=() [1/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()>=T2()),N,memDevice,STYLE> yakl::componentwise::operator>= ( Array< T1, N, memDevice, STYLE > const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator>=() [2/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()>=T2()),N,memDevice,STYLE> yakl::componentwise::operator>= ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

operator>=() [3/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()>=T2()),N,memHost,STYLE> yakl::componentwise::operator>= ( Array< T1, N, memHost, STYLE > const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator>=() [4/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()>=T2()),N,memHost,STYLE> yakl::componentwise::operator>= ( Array< T1, N, memHost, STYLE > const &  left, T2 const &  right  )

inline

operator>=() [5/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >

YAKL_INLINE FSArray<decltype(T1()>=T2()),N,B0,B1,B2,B3> yakl::componentwise::operator>=	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator>=() [6/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()>=T2()),N,B0,B1,B2,B3> yakl::componentwise::operator>=	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		T2 const &	right
	)

operator>=() [7/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>

YAKL_INLINE SArray<decltype(T1()>=T2()),N,D0,D1,D2,D3> yakl::componentwise::operator>=	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator>=() [8/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()>=T2()),N,D0,D1,D2,D3> yakl::componentwise::operator>=	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		T2 const &	right
	)

operator>=() [9/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()>=T2()),N,memDevice,STYLE> yakl::componentwise::operator>= ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator>=() [10/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()>=T2()),N,memHost,STYLE> yakl::componentwise::operator>= ( T1 const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator>=() [11/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()>=T2()),N,B0,B1,B2,B3> yakl::componentwise::operator>=	(	T1 const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator>=() [12/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()>=T2()),N,D0,D1,D2,D3> yakl::componentwise::operator>=	(	T1 const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator||() [1/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()||T2()),N,memDevice,STYLE> yakl::componentwise::operator|| ( Array< T1, N, memDevice, STYLE > const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator||() [2/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()||T2()),N,memDevice,STYLE> yakl::componentwise::operator|| ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

operator||() [3/12]

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()||T2()),N,memHost,STYLE> yakl::componentwise::operator|| ( Array< T1, N, memHost, STYLE > const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator||() [4/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

Array<decltype(T1()||T2()),N,memHost,STYLE> yakl::componentwise::operator|| ( Array< T1, N, memHost, STYLE > const &  left, T2 const &  right  )

inline

operator||() [5/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 >

YAKL_INLINE FSArray<decltype(T1()||T2()),N,B0,B1,B2,B3> yakl::componentwise::operator||	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator||() [6/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()||T2()),N,B0,B1,B2,B3> yakl::componentwise::operator||	(	FSArray< T1, N, B0, B1, B2, B3 > const &	left,
		T2 const &	right
	)

operator||() [7/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3>

YAKL_INLINE SArray<decltype(T1()||T2()),N,D0,D1,D2,D3> yakl::componentwise::operator||	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

operator||() [8/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T2 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()||T2()),N,D0,D1,D2,D3> yakl::componentwise::operator||	(	SArray< T1, N, D0, D1, D2, D3 > const &	left,
		T2 const &	right
	)

operator||() [9/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()||T2()),N,memDevice,STYLE> yakl::componentwise::operator|| ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

operator||() [10/12]

template<class T1 , class T2 , int N, int STYLE, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

Array<decltype(T1()||T2()),N,memHost,STYLE> yakl::componentwise::operator|| ( T1 const &  left, Array< T2, N, memHost, STYLE > const &  right  )

inline

operator||() [11/12]

template<class T1 , class T2 , int N, class B0 , class B1 , class B2 , class B3 , typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE FSArray<decltype(T1()||T2()),N,B0,B1,B2,B3> yakl::componentwise::operator||	(	T1 const &	left,
		FSArray< T2, N, B0, B1, B2, B3 > const &	right
	)

operator||() [12/12]

template<class T1 , class T2 , int N, unsigned D0, unsigned D1, unsigned D2, unsigned D3, typename std::enable_if< std::is_arithmetic< T1 >::value, bool >::type = false>

YAKL_INLINE SArray<decltype(T1()||T2()),N,D0,D1,D2,D3> yakl::componentwise::operator||	(	T1 const &	left,
		SArray< T2, N, D0, D1, D2, D3 > const &	right
	)

or_array_scalar()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()||T2()),N,memDevice,STYLE> yakl::componentwise::or_array_scalar ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

or_scalar_array()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()||T2()),N,memDevice,STYLE> yakl::componentwise::or_scalar_array ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline

sub_array_scalar()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()-T2()),N,memDevice,STYLE> yakl::componentwise::sub_array_scalar ( Array< T1, N, memDevice, STYLE > const &  left, T2 const &  right  )

inline

sub_scalar_array()

template<class T1 , class T2 , int N, int STYLE>

Array<decltype(T1()-T2()),N,memDevice,STYLE> yakl::componentwise::sub_scalar_array ( T1 const &  left, Array< T2, N, memDevice, STYLE > const &  right  )

inline