hi::v1::array_generic< T, N > Struct Template Reference

#include <hikocpu/array_generic.hpp>

Public Types
using	value_type = T
using	array_type = std::array<T, N>
using	intrinsic_type = array_intrinsic<T, N>
using	mask_type
using	signed_mask_type = std::make_signed_t<mask_type>

Public Member Functions
	hi_warning_push ()
	hi_warning_ignore_msvc (26494)
	hi_warning_pop ()

Static Public Member Functions
hi_force_inline static constexpr mask_type	to_mask (value_type a) noexcept
hi_force_inline static constexpr signed_mask_type	to_signed_mask (value_type a) noexcept
template<std::unsigned_integral M>
hi_force_inline static constexpr value_type	to_value (M a) noexcept
template<std::signed_integral M>
hi_force_inline static constexpr value_type	to_value (M a) noexcept
static hi_force_inline array_type	undefined () noexcept
template<std::same_as< value_type >... Args> requires (sizeof...(Args) == N)
hi_force_inline static constexpr array_type	set (Args... args) noexcept
hi_force_inline static constexpr array_type	set (value_type arg) noexcept
hi_force_inline static constexpr array_type	set_zero () noexcept
hi_force_inline static constexpr array_type	set_all_ones () noexcept
hi_force_inline static constexpr array_type	set_one () noexcept
hi_force_inline static constexpr array_type	broadcast (value_type a) noexcept
hi_force_inline static constexpr array_type	broadcast (array_type a) noexcept
template<size_t I>
hi_force_inline static constexpr value_type	get (array_type a) noexcept
hi_force_inline static constexpr array_type	set_mask (size_t mask) noexcept
	Set each element to all ones or all zero based on the bits of the mask.
hi_force_inline static constexpr size_t	get_mask (array_type a) noexcept
	Get an integer mask where each bit in the mask corresponds with the top-bit of each element.
template<array_generic_convertible_to< value_type > O>
hi_force_inline static constexpr array_type	convert (std::array< O, N > a) noexcept
hi_force_inline static constexpr array_type	neg (array_type a) noexcept
template<std::size_t Mask>
hi_force_inline static constexpr array_type	neg_mask (array_type a) noexcept
hi_force_inline static constexpr array_type	inv (array_type a) noexcept
hi_force_inline static constexpr array_type	rcp (array_type a) noexcept
static hi_force_inline array_type	sqrt (array_type a) noexcept
static hi_force_inline array_type	rsqrt (array_type a) noexcept
hi_force_inline static constexpr array_type	abs (array_type a) noexcept
hi_force_inline static constexpr array_type	round (array_type a) noexcept
hi_force_inline static constexpr array_type	floor (array_type a) noexcept
hi_force_inline static constexpr array_type	ceil (array_type a) noexcept
hi_force_inline static constexpr array_type	add (array_type a, array_type b) noexcept
hi_force_inline static constexpr array_type	sub (array_type a, array_type b) noexcept
template<std::size_t Mask>
hi_force_inline static constexpr array_type	addsub_mask (array_type a, array_type b) noexcept
	Add or subtract based on the mask.
hi_force_inline static constexpr array_type	mul (array_type a, array_type b) noexcept
hi_force_inline static constexpr array_type	div (array_type a, array_type b) noexcept
hi_force_inline static constexpr array_type	mod (array_type a, array_type b) noexcept
hi_force_inline static constexpr array_type	eq (array_type a, array_type b) noexcept
hi_force_inline static constexpr array_type	ne (array_type a, array_type b) noexcept
hi_force_inline static constexpr array_type	lt (array_type a, array_type b) noexcept
hi_force_inline static constexpr array_type	gt (array_type a, array_type b) noexcept
hi_force_inline static constexpr array_type	le (array_type a, array_type b) noexcept
hi_force_inline static constexpr array_type	ge (array_type a, array_type b) noexcept
hi_force_inline static constexpr bool	test (array_type a, array_type b) noexcept
	Test the two operands.
hi_force_inline static constexpr bool	all_equal (array_type a, array_type b) noexcept
	Compare the two operands.
hi_force_inline static constexpr array_type	max (array_type a, array_type b) noexcept
hi_force_inline static constexpr array_type	min (array_type a, array_type b) noexcept
hi_force_inline static constexpr array_type	clamp (array_type v, array_type lo, array_type hi) noexcept
hi_force_inline static constexpr array_type	_or (array_type a, array_type b) noexcept
hi_force_inline static constexpr array_type	_and (array_type a, array_type b) noexcept
hi_force_inline static constexpr array_type	_xor (array_type a, array_type b) noexcept
hi_force_inline static constexpr array_type	andnot (array_type a, array_type b) noexcept
	andnot of two operands
hi_force_inline static constexpr array_type	sll (array_type a, unsigned int b) noexcept
hi_force_inline static constexpr array_type	srl (array_type a, unsigned int b) noexcept
hi_force_inline static constexpr array_type	sra (array_type a, unsigned int b) noexcept
hi_force_inline static constexpr array_type	hadd (array_type a, array_type b) noexcept
	Add the elements of both operands pairwise and return the packed result.
hi_force_inline static constexpr array_type	hsub (array_type a, array_type b) noexcept
template<size_t I, int First, int... Rest>
hi_force_inline static constexpr void	_shuffle (array_type &r, array_type a) noexcept
template<size_t I, int First, int... Rest>
static constexpr bool	_have_to_shuffle () noexcept
template<int... Indices>
hi_force_inline static constexpr array_type	shuffle (array_type a) noexcept
template<size_t Mask>
hi_force_inline static constexpr array_type	blend (array_type a, array_type b) noexcept
template<std::derived_from< array_type >... Columns> requires (sizeof...(Columns) == N)
static constexpr std::array< array_type, N >	transpose (Columns... columns) noexcept
template<size_t I, int Value, int First, int... Rest>
static constexpr void	_make_swizzle_blend_mask (std::size_t &r) noexcept
template<int Value, int... Indices>
static constexpr std::size_t	_make_swizzle_blend_mask () noexcept
template<int... Indices>
hi_force_inline static constexpr array_type	swizzle (array_type a) noexcept
	Swizzle elements.
hi_force_inline static constexpr array_type	sum (array_type a) noexcept
template<size_t Mask>
hi_force_inline static constexpr array_type	dot (array_type a, array_type b) noexcept
template<size_t Mask>
hi_force_inline static constexpr array_type	hypot (array_type a) noexcept
template<size_t Mask>
hi_force_inline static constexpr array_type	rhypot (array_type a) noexcept
template<size_t Mask>
hi_force_inline static constexpr array_type	normalize (array_type a) noexcept

Static Public Attributes
static constexpr value_type	_zero_mask = to_value(mask_type{0})
static constexpr value_type	_ones_mask = to_value(~mask_type{0})

Detailed Description

template<typename T, std::size_t N>
struct hi::v1::array_generic< T, N >

Intrinsic operations on arrays.

Member Typedef Documentation

mask_type

template<typename T , std::size_t N>

using hi::v1::array_generic< T, N >::mask_type

Initial value:

 
        std::conditional_t<sizeof(T) * CHAR_BIT == 8, uint8_t,
        std::conditional_t<sizeof(T) * CHAR_BIT == 16, uint16_t,
        std::conditional_t<sizeof(T) * CHAR_BIT == 32, uint32_t,
        std::conditional_t<sizeof(T) * CHAR_BIT == 64, uint64_t, void>>>>

Member Function Documentation

addsub_mask()

template<typename T , std::size_t N>

template<std::size_t Mask>

hi_force_inline static constexpr array_type hi::v1::array_generic< T, N >::addsub_mask ( array_type a, array_type b )

inlinestaticconstexprnoexcept

Add or subtract based on the mask.

If the mask bit is '1' then add, if the bit is '0' then substract.

all_equal()

template<typename T , std::size_t N>

hi_force_inline static constexpr bool hi::v1::array_generic< T, N >::all_equal ( array_type a, array_type b )

inlinestaticconstexprnoexcept

Compare the two operands.

This will compare both operands bit-wise and if equal return true.

andnot()

template<typename T , std::size_t N>

hi_force_inline static constexpr array_type hi::v1::array_generic< T, N >::andnot ( array_type a, array_type b )

inlinestaticconstexprnoexcept

andnot of two operands

The following calculation is done on the bits of the two operands: result = ~a & b

get_mask()

template<typename T , std::size_t N>

hi_force_inline static constexpr size_t hi::v1::array_generic< T, N >::get_mask ( array_type a )

inlinestaticconstexprnoexcept

Get an integer mask where each bit in the mask corresponds with the top-bit of each element.

hadd()

template<typename T , std::size_t N>

hi_force_inline static constexpr array_type hi::v1::array_generic< T, N >::hadd ( array_type a, array_type b )

inlinestaticconstexprnoexcept

Add the elements of both operands pairwise and return the packed result.

set_mask()

template<typename T , std::size_t N>

hi_force_inline static constexpr array_type hi::v1::array_generic< T, N >::set_mask ( size_t mask )

inlinestaticconstexprnoexcept

Set each element to all ones or all zero based on the bits of the mask.

swizzle()

template<typename T , std::size_t N>

template<int... Indices>

hi_force_inline static constexpr array_type hi::v1::array_generic< T, N >::swizzle ( array_type a )

inlinestaticconstexprnoexcept

Swizzle elements.

This function shuffles the elements or inserts the constants 0 or 1 depending on the value of the Indices.

The Indices can have the following values:

• -2: The value 1.
• -1: The value 0.
• other: The index of an element of a.

test()

template<typename T , std::size_t N>

hi_force_inline static constexpr bool hi::v1::array_generic< T, N >::test ( array_type a, array_type b )

inlinestaticconstexprnoexcept

Test the two operands.

This will AND the two operands together and if all the bits are zero the test returns true.

---

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

• hikogui/src/hikocpu/array_generic.hpp