This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Namespaces | |
| yakl | |
| yakl::componentwise | |
This namespace contains routines that perform element-wise / component-wise operations on Array, SArray, and FSArray objects. | |
Functions | |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| template<class T1 , int N, int STYLE> | |
| Array< decltype(!T1()), N, memDevice, STYLE > | yakl::componentwise::operator! (Array< T1, N, memDevice, STYLE > const &left) |
| template<class T1 , int N, int STYLE> | |
| Array< decltype(!T1()), N, memHost, STYLE > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::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 > | yakl::componentwise::operator++ (Array< T1, N, memDevice, STYLE > const &left) |
| 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) |
| template<class T1 , int N, int STYLE> | |
| Array< decltype(T1()+1), N, memHost, STYLE > | yakl::componentwise::operator++ (Array< T1, N, memHost, STYLE > const &left) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| template<class T1 , int N, int STYLE> | |
| Array< decltype(T1() -1), N, memDevice, STYLE > | yakl::componentwise::operator-- (Array< T1, N, memDevice, STYLE > const &left) |
| 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) |
| template<class T1 , int N, int STYLE> | |
| Array< decltype(T1() -1), N, memHost, STYLE > | yakl::componentwise::operator-- (Array< T1, N, memHost, STYLE > const &left) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
| 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) |
