Vec.h File Reference

#include "Global.h"
#include <array>

Go to the source code of this file.

Classes
class	reg23::Vec< T, N >
	A simple vector class derived from std::array<T, N>, providing overrides for all useful operators. More...

Namespaces
namespace	reg23

Functions
template<typename T , std::size_t N>
__host__ __device__ constexpr Vec< T, N >	reg23::operator+ (const Vec< T, N > &lhs, const Vec< T, N > &rhs)
	reg23::Vec element-wise addition
template<typename T , std::size_t N, typename scalar_t >
__host__ __device__ constexpr Vec< T, N >	reg23::operator+ (const Vec< T, N > &lhs, const scalar_t &rhs)
	reg23::Vec element-wise addition
template<typename T , std::size_t N, typename scalar_t >
__host__ __device__ constexpr Vec< T, N >	reg23::operator+ (const scalar_t &lhs, const Vec< T, N > &rhs)
	reg23::Vec element-wise addition
template<typename T , std::size_t N>
__host__ __device__ constexpr Vec< T, N >	reg23::operator- (const Vec< T, N > &lhs, const Vec< T, N > &rhs)
	reg23::Vec element-wise subtraction
template<typename T , std::size_t N, typename scalar_t >
__host__ __device__ constexpr Vec< T, N >	reg23::operator- (const Vec< T, N > &lhs, const scalar_t &rhs)
	reg23::Vec element-wise subtraction
template<typename T , std::size_t N, typename scalar_t >
__host__ __device__ constexpr Vec< T, N >	reg23::operator- (const scalar_t &lhs, const Vec< T, N > &rhs)
	reg23::Vec element-wise subtraction
template<typename T , std::size_t N>
__host__ __device__ constexpr Vec< T, N >	reg23::operator* (const Vec< T, N > &lhs, const Vec< T, N > &rhs)
	reg23::Vec element-wise multiplication
template<typename T , std::size_t N, typename scalar_t >
__host__ __device__ constexpr Vec< T, N >	reg23::operator* (const Vec< T, N > &lhs, const scalar_t &rhs)
	reg23::Vec element-wise multiplication
template<typename T , std::size_t N, typename scalar_t >
__host__ __device__ constexpr Vec< T, N >	reg23::operator* (const scalar_t &lhs, const Vec< T, N > &rhs)
	reg23::Vec element-wise multiplication
template<typename T , std::size_t N>
__host__ __device__ constexpr Vec< T, N >	reg23::operator/ (const Vec< T, N > &lhs, const Vec< T, N > &rhs)
	reg23::Vec element-wise division
template<typename T , std::size_t N, typename scalar_t >
__host__ __device__ constexpr Vec< T, N >	reg23::operator/ (const Vec< T, N > &lhs, const scalar_t &rhs)
	reg23::Vec element-wise division
template<typename T , std::size_t N, typename scalar_t >
__host__ __device__ constexpr Vec< T, N >	reg23::operator/ (const scalar_t &lhs, const Vec< T, N > &rhs)
	reg23::Vec element-wise division
template<typename T , std::size_t N>
__host__ __device__ constexpr Vec< T, N >	reg23::operator% (const Vec< T, N > &lhs, const Vec< T, N > &rhs)
	reg23::Vec element-wise modulo
template<typename T , std::size_t N, typename scalar_t >
__host__ __device__ constexpr Vec< T, N >	reg23::operator% (const Vec< T, N > &lhs, const scalar_t &rhs)
	reg23::Vec element-wise modulo
template<typename T , std::size_t N, typename scalar_t >
__host__ __device__ constexpr Vec< T, N >	reg23::operator% (const scalar_t &lhs, const Vec< T, N > &rhs)
	reg23::Vec element-wise modulo
template<typename T , std::size_t N>
__host__ __device__ constexpr T	reg23::VecDot (const Vec< T, N > &lhs, const Vec< T, N > &rhs)
	reg23::Vec dot product
template<typename T , std::size_t N1, std::size_t N2>
__host__ __device__ constexpr Vec< Vec< T, N1 >, N2 >	reg23::VecOuter (const Vec< T, N1 > &lhs, const Vec< T, N2 > &rhs)
	reg23::Vec outer product; returns a column major matrix of size N1 x N2.
template<typename T , std::size_t N>
__host__ __device__ constexpr Vec< bool, N >	reg23::operator> (const Vec< T, N > &lhs, const Vec< T, N > &rhs)
	reg23::Vec element-wise greater-than
template<typename T , std::size_t N, typename scalar_t >
__host__ __device__ constexpr Vec< bool, N >	reg23::operator> (const Vec< T, N > &lhs, const scalar_t &rhs)
	reg23::Vec element-wise greater-than
template<typename T , std::size_t N, typename scalar_t >
__host__ __device__ constexpr Vec< bool, N >	reg23::operator> (const scalar_t &lhs, const Vec< T, N > &rhs)
	reg23::Vec element-wise greater-than
template<typename T , std::size_t N>
__host__ __device__ constexpr Vec< bool, N >	reg23::operator>= (const Vec< T, N > &lhs, const Vec< T, N > &rhs)
	reg23::Vec element-wise greater-than-or-equal-to
template<typename T , std::size_t N, typename scalar_t >
__host__ __device__ constexpr Vec< bool, N >	reg23::operator>= (const Vec< T, N > &lhs, const scalar_t &rhs)
	reg23::Vec element-wise greater-than-or-equal-to
template<typename T , std::size_t N, typename scalar_t >
__host__ __device__ constexpr Vec< bool, N >	reg23::operator>= (const scalar_t &lhs, const Vec< T, N > &rhs)
	reg23::Vec element-wise greater-than-or-equal-to
template<typename T , std::size_t N>
__host__ __device__ constexpr Vec< bool, N >	reg23::operator< (const Vec< T, N > &lhs, const Vec< T, N > &rhs)
	reg23::Vec element-wise less-than
template<typename T , std::size_t N, typename scalar_t >
__host__ __device__ constexpr Vec< bool, N >	reg23::operator< (const Vec< T, N > &lhs, const scalar_t &rhs)
	reg23::Vec element-wise less-than
template<typename T , std::size_t N, typename scalar_t >
__host__ __device__ constexpr Vec< bool, N >	reg23::operator< (const scalar_t &lhs, const Vec< T, N > &rhs)
	reg23::Vec element-wise less-than
template<typename T , std::size_t N>
__host__ __device__ constexpr Vec< bool, N >	reg23::operator<= (const Vec< T, N > &lhs, const Vec< T, N > &rhs)
	reg23::Vec element-wise less-than-or-equal-to
template<typename T , std::size_t N, typename scalar_t >
__host__ __device__ constexpr Vec< bool, N >	reg23::operator<= (const Vec< T, N > &lhs, const scalar_t &rhs)
	reg23::Vec element-wise less-than-or-equal-to
template<typename T , std::size_t N, typename scalar_t >
__host__ __device__ constexpr Vec< bool, N >	reg23::operator<= (const scalar_t &lhs, const Vec< T, N > &rhs)
	reg23::Vec element-wise less-than-or-equal-to
template<typename T , std::size_t... Ns>
__host__ __device__ constexpr Vec< T,(Ns+...)>	reg23::VecCat (const Vec< T, Ns > &... vecs)
	reg23::Vec concatenation of any number of vectors
template<typename T , std::size_t N>
__host__ __device__ constexpr Vec< T, N+1 >	reg23::VecCat (const Vec< T, N > &lhs, const T &rhs)
	reg23::Vec concatenation of a vector and a scalar
template<typename T , std::size_t N>
__host__ __device__ constexpr Vec< T, N+1 >	reg23::VecCat (const T &lhs, const Vec< T, N > &rhs)
	reg23::Vec concatenation of a scalar and a vector
template<typename T , std::size_t R, std::size_t C>
__host__ __device__ constexpr Vec< T, R >	reg23::MatMul (const Vec< Vec< T, R >, C > &lhs, const Vec< T, C > &rhs)
	Matrix-vector multiplication of the Vec struct.