Structures and classes that help with contained data manipulation and storage. More...

Classes
struct	reg23::Linear2< T >
	A functor class that represents a linear transformation of two variables: intercept + gradient1 * x + gradient2 * y. More...

struct	reg23::Linear< T >
	A functor class that represents a linear transformation: intercept + gradient * x. More...

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

Functions
template<typename T >
__host__ __device__ Vec< T, 3 >	reg23::UnflipSphericalCoordinate (const Vec< T, 3 > &coordSph)
	'Unflips' the given spherical coordinates so that theta and phi both lie between -pi/2 and pi/2

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.

__host__ __device__ Linear2< T >	reg23::Linear< T >::operator() (const Linear2< T > &other) const

Detailed Description

Structures and classes that help with contained data manipulation and storage.

Function Documentation

◆ MatMul()

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
	)

constexpr

Matrix-vector multiplication of the Vec struct.

Template Parameters

T	Matrix / vector element type
R	Number of rows in matrix, the size of the returned vector
C	Number of columns in matrix, the size of the multiplied vector

Parameters

lhs	A column-major, `R` x `C` matrix
rhs	A vector of length `C`

Returns: The vector of length R that is the result of multiplication of the given vector on the left by the given matrix

◆ operator%() [1/3]

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
	)

constexpr

reg23::Vec element-wise modulo

◆ operator%() [2/3]

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
	)

constexpr

reg23::Vec element-wise modulo

◆ operator%() [3/3]

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
	)

constexpr

reg23::Vec element-wise modulo

◆ operator()()

template<typename T >

__host__ __device__ Linear2< T > reg23::Linear< T >::operator() ( const Linear2< T > & other ) const

Chain a Linear transformation with a Linear2 transformation

Parameters

other

Returns: The Linear2 transformation corresponding to the application of other, followed by this

◆ operator*() [1/3]

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
	)

constexpr

reg23::Vec element-wise multiplication

◆ operator*() [2/3]

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
	)

constexpr

reg23::Vec element-wise multiplication

◆ operator*() [3/3]

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
	)

constexpr

reg23::Vec element-wise multiplication

◆ operator+() [1/3]

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
	)

constexpr

reg23::Vec element-wise addition

◆ operator+() [2/3]

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
	)

constexpr

reg23::Vec element-wise addition

◆ operator+() [3/3]

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
	)

constexpr

reg23::Vec element-wise addition

◆ operator-() [1/3]

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
	)

constexpr

reg23::Vec element-wise subtraction

◆ operator-() [2/3]

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
	)

constexpr

reg23::Vec element-wise subtraction

◆ operator-() [3/3]

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
	)

constexpr

reg23::Vec element-wise subtraction

◆ operator/() [1/3]

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
	)

constexpr

reg23::Vec element-wise division

◆ operator/() [2/3]

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
	)

constexpr

reg23::Vec element-wise division

◆ operator/() [3/3]

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
	)

constexpr

reg23::Vec element-wise division

◆ operator<() [1/3]

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
	)

constexpr

reg23::Vec element-wise less-than

◆ operator<() [2/3]

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
	)

constexpr

reg23::Vec element-wise less-than

◆ operator<() [3/3]

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
	)

constexpr

reg23::Vec element-wise less-than

◆ operator<=() [1/3]

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
	)

constexpr

reg23::Vec element-wise less-than-or-equal-to

◆ operator<=() [2/3]

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
	)

constexpr

reg23::Vec element-wise less-than-or-equal-to

◆ operator<=() [3/3]

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
	)

constexpr

reg23::Vec element-wise less-than-or-equal-to

◆ operator>() [1/3]

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
	)

constexpr

reg23::Vec element-wise greater-than

◆ operator>() [2/3]

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
	)

constexpr

reg23::Vec element-wise greater-than

◆ operator>() [3/3]

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
	)

constexpr

reg23::Vec element-wise greater-than

◆ operator>=() [1/3]

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
	)

constexpr

reg23::Vec element-wise greater-than-or-equal-to

◆ operator>=() [2/3]

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
	)

constexpr

reg23::Vec element-wise greater-than-or-equal-to

◆ operator>=() [3/3]

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
	)

constexpr

reg23::Vec element-wise greater-than-or-equal-to

◆ UnflipSphericalCoordinate()

template<typename T >

__host__ __device__ Vec< T, 3 > reg23::UnflipSphericalCoordinate ( const Vec< T, 3 > & coordSph )

'Unflips' the given spherical coordinates so that theta and phi both lie between -pi/2 and pi/2

Template Parameters

T	The type of the parameter and returned coordinate values

Parameters

coordSph A 3-vector containing (r, theta, phi)

Returns: The unflipped 3-vector (r', theta', phi'),

The spherical coordinates should be defined according to the convention stated in Conventions

◆ VecCat() [1/3]

template<typename T , std::size_t N>

__host__ __device__ constexpr Vec< T, N+1 > reg23::VecCat	(	const T &	lhs,
		const Vec< T, N > &	rhs
	)

constexpr

reg23::Vec concatenation of a scalar and a vector

◆ VecCat() [2/3]

template<typename T , std::size_t N>

__host__ __device__ constexpr Vec< T, N+1 > reg23::VecCat	(	const Vec< T, N > &	lhs,
		const T &	rhs
	)

constexpr

reg23::Vec concatenation of a vector and a scalar

◆ VecCat() [3/3]

template<typename T , std::size_t... Ns>

__host__ __device__ constexpr Vec< T,(Ns+...)> reg23::VecCat ( const Vec< T, Ns > &... vecs )

constexpr

reg23::Vec concatenation of any number of vectors

◆ VecDot()

template<typename T , std::size_t N>

__host__ __device__ constexpr T reg23::VecDot	(	const Vec< T, N > &	lhs,
		const Vec< T, N > &	rhs
	)

constexpr

reg23::Vec dot product

◆ VecOuter()

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
	)

constexpr

reg23::Vec outer product; returns a column major matrix of size N1 x N2.

\mathbf{a} ( \mathbf{x} \cdot \mathbf{b} ) = [ \mathbf{a} outer \mathbf{b} ] \mathbf{x}

Classes

Functions

Detailed Description

Function Documentation

◆ MatMul()

◆ operator%() [1/3]

◆ operator%() [2/3]

◆ operator%() [3/3]

◆ operator()()

◆ operator*() [1/3]

◆ operator*() [2/3]

◆ operator*() [3/3]

◆ operator+() [1/3]

◆ operator+() [2/3]

◆ operator+() [3/3]

◆ operator-() [1/3]

◆ operator-() [2/3]

◆ operator-() [3/3]

◆ operator/() [1/3]

◆ operator/() [2/3]

◆ operator/() [3/3]

◆ operator<() [1/3]

◆ operator<() [2/3]

◆ operator<() [3/3]

◆ operator<=() [1/3]

◆ operator<=() [2/3]

◆ operator<=() [3/3]

◆ operator>() [1/3]

◆ operator>() [2/3]

◆ operator>() [3/3]

◆ operator>=() [1/3]

◆ operator>=() [2/3]

◆ operator>=() [3/3]

◆ UnflipSphericalCoordinate()

◆ VecCat() [1/3]

◆ VecCat() [2/3]

◆ VecCat() [3/3]

◆ VecDot()

◆ VecOuter()