Public Types
using	container_type = std::array<T, N>

using	value_type = typename container_type::value_type

using	size_type = typename container_type::size_type

using	difference_type = typename container_type::difference_type

using	reference = typename container_type::reference

using	const_reference = typename container_type::const_reference

using	pointer = typename container_type::pointer

using	const_pointer = typename container_type::const_pointer

using	iterator = typename container_type::iterator

using	const_iterator = typename container_type::const_iterator

Public Member Functions
constexpr	numeric_array (numeric_array const &rhs) noexcept=default

constexpr	numeric_array (numeric_array &&rhs) noexcept=default

constexpr numeric_array &	operator= (numeric_array const &rhs) noexcept=default

constexpr numeric_array &	operator= (numeric_array &&rhs) noexcept=default

template<numeric_limited U, std::size_t M>
constexpr	numeric_array (numeric_array< U, M > const &other) noexcept

template<numeric_limited U, std::size_t M>
constexpr	numeric_array (numeric_array< U, M > const &other1, numeric_array< U, M > const &other2) noexcept

constexpr	numeric_array (T const &x) noexcept

constexpr	numeric_array (T const &x, T const &y) noexcept

constexpr	numeric_array (T const &x, T const &y, T const &z) noexcept

constexpr	numeric_array (T const &x, T const &y, T const &z, T const &w) noexcept

	numeric_array (std::array< T, N > const &rhs) noexcept

numeric_array &	operator= (std::array< T, N > const &rhs) noexcept

	operator std::array< T, N > () const noexcept

__m128i	reg () const noexcept

__m128i	reg () const noexcept

__m128	reg () const noexcept

__m128d	reg () const noexcept

	numeric_array (__m128i const &rhs) noexcept

	numeric_array (__m128 const &rhs) noexcept

	numeric_array (__m128d const &rhs) noexcept

numeric_array &	operator= (__m128i const &rhs) noexcept

numeric_array &	operator= (__m128 const &rhs) noexcept

numeric_array &	operator= (__m128d const &rhs) noexcept

template<std::size_t S>
constexpr void	store (std::byte *ptr) const noexcept

constexpr void	store (std::byte *ptr) const noexcept
	Store a numeric array into memory.

constexpr	operator bool () const noexcept
	Check if the vector is non-zero.

constexpr T const &	operator[] (std::size_t i) const noexcept

constexpr T &	operator[] (std::size_t i) noexcept

constexpr reference	front () noexcept

constexpr const_reference	front () const noexcept

constexpr reference	back () noexcept

constexpr const_reference	back () const noexcept

constexpr pointer	data () noexcept

constexpr const_pointer	data () const noexcept

constexpr iterator	begin () noexcept

constexpr const_iterator	begin () const noexcept

constexpr const_iterator	cbegin () const noexcept

constexpr iterator	end () noexcept

constexpr const_iterator	end () const noexcept

constexpr const_iterator	cend () const noexcept

constexpr bool	empty () const noexcept

constexpr size_type	size () const noexcept

constexpr size_type	max_size () const noexcept

constexpr bool	is_point () const noexcept

constexpr bool	is_vector () const noexcept

constexpr bool	is_opaque () const noexcept

constexpr bool	is_transparent () const noexcept

constexpr T const &	x () const noexcept

constexpr T const &	y () const noexcept

constexpr T const &	z () const noexcept

constexpr T const &	w () const noexcept

constexpr T &	x () noexcept

constexpr T &	y () noexcept

constexpr T &	z () noexcept

constexpr T &	w () noexcept

constexpr T const &	r () const noexcept

constexpr T const &	g () const noexcept

constexpr T const &	b () const noexcept

constexpr T const &	a () const noexcept

constexpr T &	r () noexcept

constexpr T &	g () noexcept

constexpr T &	b () noexcept

constexpr T &	a () noexcept

constexpr T const &	width () const noexcept

constexpr T const &	height () const noexcept

constexpr T const &	depth () const noexcept

constexpr T &	width () noexcept

constexpr T &	height () noexcept

constexpr T &	depth () noexcept

constexpr numeric_array &	operator<<= (unsigned int rhs) noexcept

constexpr numeric_array &	operator>>= (unsigned int rhs) noexcept

constexpr numeric_array &	operator\|= (numeric_array const &rhs) noexcept

constexpr numeric_array &	operator\|= (T const &rhs) noexcept

constexpr numeric_array &	operator&= (numeric_array const &rhs) noexcept

constexpr numeric_array &	operator&= (T const &rhs) noexcept

constexpr numeric_array &	operator^= (numeric_array const &rhs) noexcept

constexpr numeric_array &	operator^= (T const &rhs) noexcept

constexpr numeric_array &	operator+= (numeric_array const &rhs) noexcept

constexpr numeric_array &	operator+= (T const &rhs) noexcept

constexpr numeric_array &	operator-= (numeric_array const &rhs) noexcept

constexpr numeric_array &	operator-= (T const &rhs) noexcept

constexpr numeric_array &	*operator=** (numeric_array const &rhs) noexcept

constexpr numeric_array &	*operator=** (T const &rhs) noexcept

constexpr numeric_array &	operator/= (numeric_array const &rhs) noexcept

constexpr numeric_array &	operator/= (T const &rhs) noexcept

constexpr numeric_array &	operator%= (numeric_array const &rhs) noexcept

constexpr numeric_array &	operator%= (T const &rhs) noexcept

template<ssize_t... Elements>
constexpr numeric_array	swizzle () const
	swizzle around the elements of the numeric array.

template<ssize_t I, ssize_t FirstElement, ssize_t... RestElements>
constexpr void	swizzle_detail (numeric_array &r) const noexcept

Static Public Member Functions
static constexpr numeric_array	broadcast (T rhs) noexcept

static constexpr numeric_array	epsilon () noexcept

static constexpr numeric_array	interleave_lo (numeric_array a, numeric_array b) noexcept
	Interleave the first words in both arrays.

template<std::size_t S>
static constexpr numeric_array	load (std::byte const *ptr) noexcept
	Load a numeric array from memory.

static constexpr numeric_array	load (std::byte const *ptr) noexcept
	Load a numeric array from memory.

static constexpr numeric_array	load (T const *ptr) noexcept
	Load a numeric array from memory.

static constexpr numeric_array	byte_srl_shuffle_indices (unsigned int rhs)

static constexpr numeric_array	byte_sll_shuffle_indices (unsigned int rhs)

Data Fields
container_type	v

Static Public Attributes
static constexpr bool	is_i8x1 = std::is_same_v<T, int8_t> && N == 1

static constexpr bool	is_i8x2 = std::is_same_v<T, int8_t> && N == 2

static constexpr bool	is_i8x4 = std::is_same_v<T, int8_t> && N == 4

static constexpr bool	is_i8x8 = std::is_same_v<T, int8_t> && N == 8

static constexpr bool	is_i8x16 = std::is_same_v<T, int8_t> && N == 16

static constexpr bool	is_i8x32 = std::is_same_v<T, int8_t> && N == 32

static constexpr bool	is_i8x64 = std::is_same_v<T, int8_t> && N == 64

static constexpr bool	is_u8x1 = std::is_same_v<T, uint8_t> && N == 1

static constexpr bool	is_u8x2 = std::is_same_v<T, uint8_t> && N == 2

static constexpr bool	is_u8x4 = std::is_same_v<T, uint8_t> && N == 4

static constexpr bool	is_u8x8 = std::is_same_v<T, uint8_t> && N == 8

static constexpr bool	is_u8x16 = std::is_same_v<T, uint8_t> && N == 16

static constexpr bool	is_u8x32 = std::is_same_v<T, uint8_t> && N == 32

static constexpr bool	is_u8x64 = std::is_same_v<T, uint8_t> && N == 64

static constexpr bool	is_i16x1 = std::is_same_v<T, int16_t> && N == 1

static constexpr bool	is_i16x2 = std::is_same_v<T, int16_t> && N == 2

static constexpr bool	is_i16x4 = std::is_same_v<T, int16_t> && N == 4

static constexpr bool	is_i16x8 = std::is_same_v<T, int16_t> && N == 8

static constexpr bool	is_i16x16 = std::is_same_v<T, int16_t> && N == 16

static constexpr bool	is_i16x32 = std::is_same_v<T, int16_t> && N == 32

static constexpr bool	is_u16x1 = std::is_same_v<T, uint16_t> && N == 1

static constexpr bool	is_u16x2 = std::is_same_v<T, uint16_t> && N == 2

static constexpr bool	is_u16x4 = std::is_same_v<T, uint16_t> && N == 4

static constexpr bool	is_u16x8 = std::is_same_v<T, uint16_t> && N == 8

static constexpr bool	is_u16x16 = std::is_same_v<T, uint16_t> && N == 16

static constexpr bool	is_u16x32 = std::is_same_v<T, uint16_t> && N == 32

static constexpr bool	is_f16x4 = std::is_same_v<T, float16> && N == 4

static constexpr bool	is_i32x1 = std::is_same_v<T, int32_t> && N == 1

static constexpr bool	is_i32x2 = std::is_same_v<T, int32_t> && N == 2

static constexpr bool	is_i32x4 = std::is_same_v<T, int32_t> && N == 4

static constexpr bool	is_i32x8 = std::is_same_v<T, int32_t> && N == 8

static constexpr bool	is_i32x16 = std::is_same_v<T, int32_t> && N == 16

static constexpr bool	is_u32x1 = std::is_same_v<T, uint32_t> && N == 1

static constexpr bool	is_u32x2 = std::is_same_v<T, uint32_t> && N == 2

static constexpr bool	is_u32x4 = std::is_same_v<T, uint32_t> && N == 4

static constexpr bool	is_u32x8 = std::is_same_v<T, uint32_t> && N == 8

static constexpr bool	is_u32x16 = std::is_same_v<T, uint32_t> && N == 16

static constexpr bool	is_f32x1 = std::is_same_v<T, float> && N == 1

static constexpr bool	is_f32x2 = std::is_same_v<T, float> && N == 2

static constexpr bool	is_f32x4 = std::is_same_v<T, float> && N == 4

static constexpr bool	is_f32x8 = std::is_same_v<T, float> && N == 8

static constexpr bool	is_f32x16 = std::is_same_v<T, float> && N == 16

static constexpr bool	is_i64x1 = std::is_same_v<T, int64_t> && N == 1

static constexpr bool	is_i64x2 = std::is_same_v<T, int64_t> && N == 2

static constexpr bool	is_i64x4 = std::is_same_v<T, int64_t> && N == 4

static constexpr bool	is_i64x8 = std::is_same_v<T, int64_t> && N == 8

static constexpr bool	is_u64x1 = std::is_same_v<T, uint64_t> && N == 1

static constexpr bool	is_u64x2 = std::is_same_v<T, uint64_t> && N == 2

static constexpr bool	is_u64x4 = std::is_same_v<T, uint64_t> && N == 4

static constexpr bool	is_u64x8 = std::is_same_v<T, uint64_t> && N == 8

static constexpr bool	is_f64x1 = std::is_same_v<T, double> && N == 1

static constexpr bool	is_f64x2 = std::is_same_v<T, double> && N == 2

static constexpr bool	is_f64x4 = std::is_same_v<T, double> && N == 4

static constexpr bool	is_f64x8 = std::is_same_v<T, double> && N == 8

static constexpr ssize_t	get_zero = -1

static constexpr ssize_t	get_one = -2

Friends
template<typename Other > requires (sizeof(Other) == sizeof(container_type))
constexpr friend Other	bit_cast (numeric_array const &rhs) noexcept

template<std::size_t I>
constexpr T &	get (numeric_array &rhs) noexcept
	Get a element from the numeric array.

template<ssize_t I>
constexpr T	get (numeric_array &&rhs) noexcept
	Get a element from the numeric array.

template<std::size_t I>
constexpr friend T	extract (numeric_array const &rhs) noexcept
	Extract an element from the array.

template<std::size_t I, std::size_t ZeroMask = 0> requires (is_f32x4 or is_i32x4 or is_u32x4)
constexpr friend numeric_array	insert (numeric_array const &lhs, T rhs) noexcept
	Insert a value in the array.

template<ssize_t I>
constexpr T	get (numeric_array const &rhs) noexcept
	Get a element from the numeric array.

template<std::size_t Mask = ~std::size_t{0}>
constexpr numeric_array	zero (numeric_array rhs) noexcept
	Set individual elements to zero.

template<std::size_t Mask>
constexpr numeric_array	blend (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	blend (numeric_array const &a, numeric_array const &b, numeric_array const &mask)
	Blend the values using a dynamic mask.

template<std::size_t Mask>
constexpr numeric_array	neg (numeric_array rhs) noexcept
	Negate individual elements.

constexpr numeric_array	operator- (numeric_array const &rhs) noexcept

constexpr numeric_array	abs (numeric_array const &rhs) noexcept

constexpr numeric_array	rcp (numeric_array const &rhs) noexcept

constexpr numeric_array	sqrt (numeric_array const &rhs) noexcept

constexpr numeric_array	rcp_sqrt (numeric_array const &rhs) noexcept

constexpr numeric_array	floor (numeric_array const &rhs) noexcept

constexpr numeric_array	ceil (numeric_array const &rhs) noexcept

constexpr numeric_array	round (numeric_array const &rhs) noexcept

template<std::size_t Mask>
hi_force_inline friend constexpr T	dot (numeric_array const &lhs, numeric_array const &rhs) noexcept
	Take a dot product.

template<std::size_t Mask>
constexpr T	hypot (numeric_array const &rhs) noexcept
	Take the length of the vector.

template<std::size_t Mask>
hi_force_inline friend constexpr T	squared_hypot (numeric_array const &rhs) noexcept
	Take the squared length of the vector.

template<std::size_t Mask>
constexpr T	rcp_hypot (numeric_array const &rhs) noexcept
	Take a reciprocal of the length.

template<std::size_t Mask>
constexpr numeric_array	normalize (numeric_array const &rhs) noexcept
	Normalize a vector.

constexpr std::size_t	eq (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr std::size_t	ne (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr std::size_t	gt (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr std::size_t	lt (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr std::size_t	ge (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr std::size_t	le (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	gt_mask (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr bool	operator== (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	operator<< (numeric_array const &lhs, unsigned int rhs) noexcept

constexpr numeric_array	operator>> (numeric_array const &lhs, unsigned int rhs) noexcept

constexpr numeric_array	operator\| (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	operator\| (numeric_array const &lhs, T const &rhs) noexcept

constexpr numeric_array	operator\| (T const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	operator& (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	operator& (numeric_array const &lhs, T const &rhs) noexcept

constexpr numeric_array	operator& (T const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	operator^ (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	operator^ (numeric_array const &lhs, T const &rhs) noexcept

constexpr numeric_array	operator^ (T const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	operator+ (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	operator+ (numeric_array const &lhs, T const &rhs) noexcept

constexpr numeric_array	operator+ (T const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	operator- (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	operator- (numeric_array const &lhs, T const &rhs) noexcept

constexpr numeric_array	operator- (T const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	operator* (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	operator* (numeric_array const &lhs, T const &rhs) noexcept

constexpr numeric_array	operator* (T const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	operator/ (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	operator/ (numeric_array const &lhs, T const &rhs) noexcept

constexpr numeric_array	operator/ (T const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	operator% (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	operator% (numeric_array const &lhs, T const &rhs) noexcept

constexpr numeric_array	operator% (T const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	min (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	max (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	clamp (numeric_array const &lhs, numeric_array const &low, numeric_array const &high) noexcept

constexpr numeric_array	hadd (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	hsub (numeric_array const &lhs, numeric_array const &rhs) noexcept

template<std::size_t Mask>
constexpr numeric_array	addsub (numeric_array const &lhs, numeric_array const &rhs) noexcept
	Add or subtract individual elements.

constexpr numeric_array	cross_2D (numeric_array const &rhs) noexcept
	Calculate the 2D normal on a 2D vector.

constexpr numeric_array	normal_2D (numeric_array const &rhs) noexcept
	Calculate the 2D unit-normal on a 2D vector.

constexpr float	cross_2D (numeric_array const &lhs, numeric_array const &rhs) noexcept
	Calculate the cross-product between two 2D vectors.

constexpr friend numeric_array	cross_3D (numeric_array const &lhs, numeric_array const &rhs) noexcept

constexpr numeric_array	shuffle (numeric_array const &lhs, numeric_array const &rhs) noexcept
	Shuffle a 16x byte array, using the indices from the right-hand-side.

constexpr numeric_array	midpoint (numeric_array const &p1, numeric_array const &p2) noexcept
	Find a point at the midpoint between two points.

constexpr numeric_array	reflect_point (numeric_array const &p, numeric_array const anchor) noexcept
	Find the point on the other side and at the same distance of an anchor-point.

template<typename... Columns>
constexpr std::array< numeric_array, N >	transpose (Columns const &...columns) noexcept

constexpr friend numeric_array	composit (numeric_array const &under, numeric_array const &over) noexcept

constexpr friend numeric_array	composit (numeric_array const &under, numeric_array const &over) noexcept

std::string	to_string (numeric_array const &rhs) noexcept

std::ostream &	operator<< (std::ostream &lhs, numeric_array const &rhs)

template<std::size_t FromElement, std::size_t ToElement>
constexpr friend numeric_array	insert (numeric_array const &lhs, numeric_array const &rhs)
	Insert an element from rhs into the result.

template<int I, typename First , typename... Rest>
constexpr void	transpose_detail (First const &first, Rest const &...rest, std::array< numeric_array, N > &r) noexcept

Member Function Documentation

◆ interleave_lo()

template<numeric_limited T, std::size_t N>

static constexpr numeric_array v1::numeric_array< T, N >::interleave_lo	(	numeric_array< T, N >	a,
		numeric_array< T, N >	b )

inlinestaticconstexprnoexcept

Interleave the first words in both arrays.

◆ load() [1/3]

template<numeric_limited T, std::size_t N>

template<std::size_t S>

static constexpr numeric_array v1::numeric_array< T, N >::load ( std::byte const * ptr )

inlinestaticconstexprnoexcept

Load a numeric array from memory.

Parameters

ptr	A Pointer to an array of values in memory.

Returns: A numeric array.

◆ load() [2/3]

template<numeric_limited T, std::size_t N>

static constexpr numeric_array v1::numeric_array< T, N >::load ( std::byte const * ptr )

inlinestaticconstexprnoexcept

Load a numeric array from memory.

Parameters

ptr	A Pointer to an array of values in memory.

Returns: A numeric array.

◆ load() [3/3]

template<numeric_limited T, std::size_t N>

static constexpr numeric_array v1::numeric_array< T, N >::load ( T const * ptr )

inlinestaticconstexprnoexcept

Load a numeric array from memory.

Parameters

ptr	A Pointer to an array of values in memory.

Returns: A numeric array.

◆ operator bool()

template<numeric_limited T, std::size_t N>

constexpr v1::numeric_array< T, N >::operator bool ( ) const

inlineexplicitconstexprnoexcept

Check if the vector is non-zero.

Returns: True if at least one element is non-zero.

◆ store()

template<numeric_limited T, std::size_t N>

constexpr void v1::numeric_array< T, N >::store ( std::byte * ptr ) const

inlineconstexprnoexcept

Store a numeric array into memory.

Parameters

[out]

A pointer to where the numeric array should be stored into memory.

◆ swizzle()

template<numeric_limited T, std::size_t N>

template<ssize_t... Elements>

constexpr numeric_array v1::numeric_array< T, N >::swizzle ( ) const

inlineconstexpr

swizzle around the elements of the numeric array.

Template Parameters

Elements a list of indices pointing to an element in this array. Or the special indices -1: literal zero, -2: literal one.

Returns: A new array with the elements ordered based on the Elements list. The elements at the end of the array are set to zero.

Friends And Related Symbol Documentation

◆ addsub

template<numeric_limited T, std::size_t N>

template<std::size_t Mask>

constexpr numeric_array addsub	(	numeric_array< T, N > const &	lhs,
		numeric_array< T, N > const &	rhs )

friend

Add or subtract individual elements.

Template Parameters

Mask	bit mask where '1' means to add, '0' means to subtract.

◆ blend

template<numeric_limited T, std::size_t N>

constexpr numeric_array blend	(	numeric_array< T, N > const &	a,
		numeric_array< T, N > const &	b,
		numeric_array< T, N > const &	mask )

friend

Blend the values using a dynamic mask.

◆ cross_2D [1/2]

template<numeric_limited T, std::size_t N>

constexpr float cross_2D	(	numeric_array< T, N > const &	lhs,
		numeric_array< T, N > const &	rhs )

friend

Calculate the cross-product between two 2D vectors.

a.x * b.y - a.y * b.x

◆ cross_2D [2/2]

template<numeric_limited T, std::size_t N>

constexpr numeric_array cross_2D ( numeric_array< T, N > const & rhs )

friend

Calculate the 2D normal on a 2D vector.

◆ dot

template<numeric_limited T, std::size_t N>

template<std::size_t Mask>

hi_force_inline friend constexpr T dot	(	numeric_array< T, N > const &	lhs,
		numeric_array< T, N > const &	rhs )

friend

Take a dot product.

Template Parameters

Mask	A mask for which elements participate in the dot product.

Parameters

lhs	The left hand side.
rhs	The right hand side.

Returns: Result of the dot product.

◆ extract

template<numeric_limited T, std::size_t N>

template<std::size_t I>

constexpr friend T extract ( numeric_array< T, N > const & rhs )

friend

Extract an element from the array.

Template Parameters

I	The index into the array.

Parameters

rhs	The vector to extract the value from.

Returns: The value extracted.

◆ get [1/3]

template<numeric_limited T, std::size_t N>

template<ssize_t I>

constexpr T get ( numeric_array< T, N > && rhs )

friend

Get a element from the numeric array.

Template Parameters

I	Index into the array, or the special indices: -1 yields a literal 0, -2 yields a literal 1.

◆ get [2/3]

template<numeric_limited T, std::size_t N>

template<std::size_t I>

constexpr T & get ( numeric_array< T, N > & rhs )

friend

Get a element from the numeric array.

Template Parameters

I	Index into the array

◆ get [3/3]

template<numeric_limited T, std::size_t N>

template<ssize_t I>

constexpr T get ( numeric_array< T, N > const & rhs )

friend

Get a element from the numeric array.

Template Parameters

I	Index into the array, or the special indices: -1 yields a literal 0, -2 yields a literal 1.

◆ hypot

template<numeric_limited T, std::size_t N>

template<std::size_t Mask>

constexpr T hypot ( numeric_array< T, N > const & rhs )

friend

Take the length of the vector.

Template Parameters

Mask	A mask for which elements participate in the hypot calculation.

Parameters

lhs	The left hand side.
rhs	The right hand side.

Returns: Result of the hypot calculation.

◆ insert [1/2]

template<numeric_limited T, std::size_t N>

template<std::size_t FromElement, std::size_t ToElement>

constexpr friend numeric_array insert	(	numeric_array< T, N > const &	lhs,
		numeric_array< T, N > const &	rhs )

friend

Insert an element from rhs into the result.

This function copies the lhs, then inserts one element from rhs into the result. It also can clear any of the elements to zero.

◆ insert [2/2]

template<numeric_limited T, std::size_t N>

template<std::size_t I, std::size_t ZeroMask = 0>
requires (is_f32x4 or is_i32x4 or is_u32x4)

constexpr friend numeric_array insert	(	numeric_array< T, N > const &	lhs,
		T	rhs )

friend

Insert a value in the array.

Template Parameters

I	The index into the array.
ZeroMask	When a bit in the mask is '1' set that element to zero.

Parameters

lhs	The vector to insert the value into.
rhs	The value to insert.

Returns: The vector with the inserted value.

◆ midpoint

template<numeric_limited T, std::size_t N>

constexpr numeric_array midpoint	(	numeric_array< T, N > const &	p1,
		numeric_array< T, N > const &	p2 )

friend

Find a point at the midpoint between two points.

◆ neg

template<numeric_limited T, std::size_t N>

template<std::size_t Mask>

constexpr numeric_array neg ( numeric_array< T, N > rhs )

friend

Negate individual elements.

Template Parameters

Mask	bit mask where '1' means to negate, '0' to keep original.

◆ normal_2D

template<numeric_limited T, std::size_t N>

constexpr numeric_array normal_2D ( numeric_array< T, N > const & rhs )

friend

Calculate the 2D unit-normal on a 2D vector.

◆ normalize

template<numeric_limited T, std::size_t N>

template<std::size_t Mask>

constexpr numeric_array normalize ( numeric_array< T, N > const & rhs )

friend

Normalize a vector.

All elements that do not participate in the normalization will be set to zero.

Template Parameters

Mask	A mask for which elements participate in the normalization calculation.

Parameters

lhs	The left hand side.
rhs	The right hand side.

Returns: The normalized vector.

◆ rcp_hypot

template<numeric_limited T, std::size_t N>

template<std::size_t Mask>

constexpr T rcp_hypot ( numeric_array< T, N > const & rhs )

friend

Take a reciprocal of the length.

Template Parameters

Mask	A mask for which elements participate in the hypot calculation.

Parameters

lhs	The left hand side.
rhs	The right hand side.

Returns: Result of the hypot-squared calculation.

◆ reflect_point

template<numeric_limited T, std::size_t N>

constexpr numeric_array reflect_point	(	numeric_array< T, N > const &	p,
		numeric_array< T, N > const	anchor )

friend

Find the point on the other side and at the same distance of an anchor-point.

◆ shuffle

template<numeric_limited T, std::size_t N>

constexpr numeric_array shuffle	(	numeric_array< T, N > const &	lhs,
		numeric_array< T, N > const &	rhs )

friend

Shuffle a 16x byte array, using the indices from the right-hand-side.

◆ squared_hypot

template<numeric_limited T, std::size_t N>

template<std::size_t Mask>

hi_force_inline friend constexpr T squared_hypot ( numeric_array< T, N > const & rhs )

friend

Take the squared length of the vector.

Template Parameters

Mask	A mask for which elements participate in the hypot calculation.

Parameters

lhs	The left hand side.
rhs	The right hand side.

Returns: Result of the hypot-squared calculation.

◆ zero

template<numeric_limited T, std::size_t N>

template<std::size_t Mask = ~std::size_t{0}>

constexpr numeric_array zero ( numeric_array< T, N > rhs )

friend

Set individual elements to zero.

Template Parameters

Mask	bit mask where '1' means to zero, '0' to keep original.

The documentation for this struct was generated from the following file:

hikogui/src/hikogui/rapid/numeric_array.hpp

Public Types

Public Member Functions

Static Public Member Functions

Data Fields

Static Public Attributes

Friends

Member Function Documentation

◆ interleave_lo()

◆ load() [1/3]

◆ load() [2/3]

◆ load() [3/3]

◆ operator bool()

◆ store()

◆ swizzle()

Friends And Related Symbol Documentation

◆ addsub

◆ blend

◆ cross_2D [1/2]

◆ cross_2D [2/2]

◆ dot

◆ extract

◆ get [1/3]

◆ get [2/3]

◆ get [3/3]

◆ hypot

◆ insert [1/2]

◆ insert [2/2]

◆ midpoint

◆ neg

◆ normal_2D

◆ normalize

◆ rcp_hypot

◆ reflect_point

◆ shuffle

◆ squared_hypot

◆ zero