rvv-inl.h File Reference
`#include <riscv_vector.h>`
`#include <stddef.h>`
`#include <stdint.h>`
`#include "hwy/base.h"`
`#include "hwy/ops/shared-inl.h"`

Go to the source code of this file.

## Classes

struct | hwy::HWY_NAMESPACE::DFromV_t< V >
struct | hwy::HWY_NAMESPACE::CompressIsPartition< T >

## Namespaces

namespace | hwy
namespace | hwy::HWY_NAMESPACE
namespace | hwy::HWY_NAMESPACE::detail

## Macros

#define | HWY_RVV_IF_POW2_IN(D, min, max) hwy::EnableIf<(min) <= Pow2(D()) && Pow2(D()) <= (max)>* = nullptr
#define | HWY_RVV_FOREACH_B(X_MACRO, NAME, OP)
#define | HWY_RVV_FOREACH_08_TRUNC(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_16_TRUNC(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_32_TRUNC(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_64_TRUNC(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_08_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_16_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_32_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_64_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_08_LE2(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_16_LE2(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_32_LE2(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_64_LE2(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_08_EXT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_16_EXT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_32_EXT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_64_EXT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_08_ALL(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_16_ALL(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_32_ALL(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_64_ALL(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_08_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_16_VIRT(X_MACRO, BASE, CHAR, NAME, OP) X_MACRO(BASE, CHAR, 16, 32, 8, mf4, mf2, mf8, -3, /*MLEN=*/64, NAME, OP)
#define | HWY_RVV_FOREACH_32_VIRT(X_MACRO, BASE, CHAR, NAME, OP) X_MACRO(BASE, CHAR, 32, 64, 16, mf2, m1, mf4, -2, /*MLEN=*/64, NAME, OP)
#define | HWY_RVV_FOREACH_64_VIRT(X_MACRO, BASE, CHAR, NAME, OP) X_MACRO(BASE, CHAR, 64, __, 32, m1, m2, mf2, -1, /*MLEN=*/64, NAME, OP)
#define | HWY_RVV_FOREACH_08_ALL_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_16_ALL_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_32_ALL_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_64_ALL_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_08_LE2_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_16_LE2_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_32_LE2_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_64_LE2_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_08_EXT_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_16_EXT_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_32_EXT_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_64_EXT_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_08_DEMOTE_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_16_DEMOTE_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_32_DEMOTE_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_64_DEMOTE_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
#define | HWY_RVV_FOREACH_U08(X_MACRO, NAME, OP, LMULS) HWY_CONCAT(HWY_RVV_FOREACH_08, LMULS)(X_MACRO, uint, u, NAME, OP)
#define | HWY_RVV_FOREACH_U16(X_MACRO, NAME, OP, LMULS) HWY_CONCAT(HWY_RVV_FOREACH_16, LMULS)(X_MACRO, uint, u, NAME, OP)
#define | HWY_RVV_FOREACH_U32(X_MACRO, NAME, OP, LMULS) HWY_CONCAT(HWY_RVV_FOREACH_32, LMULS)(X_MACRO, uint, u, NAME, OP)
#define | HWY_RVV_FOREACH_U64(X_MACRO, NAME, OP, LMULS) HWY_CONCAT(HWY_RVV_FOREACH_64, LMULS)(X_MACRO, uint, u, NAME, OP)
#define | HWY_RVV_FOREACH_I08(X_MACRO, NAME, OP, LMULS) HWY_CONCAT(HWY_RVV_FOREACH_08, LMULS)(X_MACRO, int, i, NAME, OP)
#define | HWY_RVV_FOREACH_I16(X_MACRO, NAME, OP, LMULS) HWY_CONCAT(HWY_RVV_FOREACH_16, LMULS)(X_MACRO, int, i, NAME, OP)
#define | HWY_RVV_FOREACH_I32(X_MACRO, NAME, OP, LMULS) HWY_CONCAT(HWY_RVV_FOREACH_32, LMULS)(X_MACRO, int, i, NAME, OP)
#define | HWY_RVV_FOREACH_I64(X_MACRO, NAME, OP, LMULS) HWY_CONCAT(HWY_RVV_FOREACH_64, LMULS)(X_MACRO, int, i, NAME, OP)
#define | HWY_RVV_FOREACH_F16(X_MACRO, NAME, OP, LMULS)
#define | HWY_RVV_FOREACH_F32(X_MACRO, NAME, OP, LMULS) HWY_CONCAT(HWY_RVV_FOREACH_32, LMULS)(X_MACRO, float, f, NAME, OP)
#define | HWY_RVV_FOREACH_F64(X_MACRO, NAME, OP, LMULS) HWY_CONCAT(HWY_RVV_FOREACH_64, LMULS)(X_MACRO, float, f, NAME, OP)
#define | HWY_RVV_FOREACH_UI08(X_MACRO, NAME, OP, LMULS)
#define | HWY_RVV_FOREACH_UI16(X_MACRO, NAME, OP, LMULS)
#define | HWY_RVV_FOREACH_UI32(X_MACRO, NAME, OP, LMULS)
#define | HWY_RVV_FOREACH_UI64(X_MACRO, NAME, OP, LMULS)
#define | HWY_RVV_FOREACH_UI3264(X_MACRO, NAME, OP, LMULS)
#define | HWY_RVV_FOREACH_U163264(X_MACRO, NAME, OP, LMULS)
#define | HWY_RVV_FOREACH_I163264(X_MACRO, NAME, OP, LMULS)
#define | HWY_RVV_FOREACH_UI163264(X_MACRO, NAME, OP, LMULS)
#define | HWY_RVV_FOREACH_F3264(X_MACRO, NAME, OP, LMULS)
#define | HWY_RVV_FOREACH_U(X_MACRO, NAME, OP, LMULS)
#define | HWY_RVV_FOREACH_I(X_MACRO, NAME, OP, LMULS)
#define | HWY_RVV_FOREACH_F(X_MACRO, NAME, OP, LMULS)
#define | HWY_RVV_FOREACH_UI(X_MACRO, NAME, OP, LMULS)
#define | HWY_RVV_FOREACH(X_MACRO, NAME, OP, LMULS)
#define | HWY_RVV_T(BASE, SEW) BASE##SEW##_t
#define | HWY_RVV_D(BASE, SEW, N, SHIFT) Simd<HWY_RVV_T(BASE, SEW), N, SHIFT>
#define | HWY_RVV_V(BASE, SEW, LMUL) v##BASE##SEW##LMUL##_t
#define | HWY_RVV_M(MLEN) vbool##MLEN##_t
#define | HWY_SPECIALIZE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_LANES(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_AVL(SEW, SHIFT) Lanes(ScalableTag<HWY_RVV_T(uint, SEW), SHIFT>())
#define | HWY_RVV_RETV_ARGV(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_RETV_ARGVS(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_RETV_ARGVV(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_RETM_ARGM(SEW, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_SET(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_UNDEFINED(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_TRUNC(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_EXT(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_EXT_VIRT(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_CAST_U8(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_CAST_I8(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_CAST_U(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_CAST_IF(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_CAST_VIRT_U(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_CAST_VIRT_IF(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_IOTA(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_SHIFT(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_SHIFT_VV(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_SHIFT_II(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_NATIVE_I64MULLO
#define | HWY_RVV_FMA(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_RETM_ARGVV(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_RETM_ARGVS(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_RETM_ARGMM(SEW, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_IF_THEN_ELSE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_IF_THEN_ZERO_ELSE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_VEC_FROM_MASK(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_FIND_FIRST_TRUE(SEW, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_ALL_TRUE(SEW, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_COUNT_TRUE(SEW, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_LOAD(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_MASKED_LOAD(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_STORE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_BLENDED_STORE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_STOREN(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_SCATTER(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_GATHER(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_NATIVE_LOAD_STORE_INTERLEAVED
#define | HWY_RVV_LOAD2(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_LOAD3(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_LOAD4(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_STORE2(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_STORE3(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_STORE4(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_PROMOTE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, LMUL, LMUL_IN, SHIFT, ADD)
#define | HWY_RVV_PROMOTE_X2(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN)
#define | HWY_RVV_PROMOTE_X4(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN)
#define | HWY_RVV_DEMOTE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_DEMOTE_I_TO_U(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_DEMOTE_F(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_CONVERT(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_NEAREST(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_SLIDE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_SLIDE1(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_GET_LANE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_TABLE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_NATIVE_COMPRESS8
#define | HWY_RVV_COMPRESS(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_REDUCE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_LOAD_MASK_BITS(SEW, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_STORE_MASK_BITS(SEW, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_RETV_ARGV2(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
#define | HWY_RVV_WIDEN_MACC(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)

## Functions

| HWY_BEFORE_NAMESPACE ()
template<typename T , size_t N, int kPow2>
constexpr size_t | hwy::HWY_NAMESPACE::MLenFromD (Simd< T, N, kPow2 >)
template<size_t N, int kPow2>
HWY_API size_t | hwy::HWY_NAMESPACE::Lanes (Simd< bfloat16_t, N, kPow2 >)
template<size_t N, int kPow2>
decltype(Set(Simd< uint16_t, N, kPow2 >(), 0)) | hwy::HWY_NAMESPACE::Set (Simd< bfloat16_t, N, kPow2 > d, bfloat16_t arg)
template<class D >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::Zero (D d)
template<class D >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::Undefined (D d)
template<size_t N, int kPow2>
HWY_INLINE VFromD< Simd< uint16_t, N, kPow2 > > | hwy::HWY_NAMESPACE::detail::BitCastFromByte (Simd< bfloat16_t, N, kPow2 >, VFromD< Simd< uint8_t, N, kPow2 > > v)
template<class D , class FromV >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::BitCast (D d, FromV v)
template<class V , class DU = RebindToUnsigned<DFromV<V>>>
HWY_INLINE VFromD< DU > | hwy::HWY_NAMESPACE::detail::BitCastToUnsigned (V v)
template<class D , class DU = RebindToUnsigned<D>>
HWY_INLINE VFromD< DU > | hwy::HWY_NAMESPACE::detail::Iota0 (const D)
template<class V , HWY_IF_FLOAT_V(V) >
HWY_API V | hwy::HWY_NAMESPACE::Not (const V v)
template<class V , HWY_IF_FLOAT_V(V) >
HWY_API V | hwy::HWY_NAMESPACE::And (const V a, const V b)
template<class V , HWY_IF_FLOAT_V(V) >
HWY_API V | hwy::HWY_NAMESPACE::Or (const V a, const V b)
template<class V , HWY_IF_FLOAT_V(V) >
HWY_API V | hwy::HWY_NAMESPACE::Xor (const V a, const V b)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::AndNot (const V not_a, const V b)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::Xor3 (V x1, V x2, V x3)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::Or3 (V o1, V o2, V o3)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::OrAnd (const V o, const V a1, const V a2)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::CopySignToAbs (const V abs, const V sign)
template<class VU8 >
HWY_API VFromD< Repartition< uint64_t, DFromV< VU8 > > > | hwy::HWY_NAMESPACE::SumsOf8 (const VU8 v)
template<int kBits, class V >
HWY_API V | hwy::HWY_NAMESPACE::RotateRight (const V v)
template<class V >
HWY_API auto | hwy::HWY_NAMESPACE::Ge (const V a, const V b) -> decltype(Le(a, b))
template<class V >
HWY_API auto | hwy::HWY_NAMESPACE::Gt (const V a, const V b) -> decltype(Lt(a, b))
template<class V >
HWY_API auto | hwy::HWY_NAMESPACE::TestBit (const V a, const V bit) -> decltype(Eq(a, bit))
template<class M , class V >
HWY_API V | hwy::HWY_NAMESPACE::IfThenElseZero (const M mask, const V yes)
template<class V >
HWY_API auto | hwy::HWY_NAMESPACE::MaskFromVec (const V v) -> decltype(Eq(v, v))
template<class D , typename MFrom >
HWY_API MFromD< D > | hwy::HWY_NAMESPACE::RebindMask (const D, const MFrom mask)
template<class D , HWY_IF_NOT_FLOAT_D(D) >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::VecFromMask (const D d, MFromD< D > mask)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::IfVecThenElse (const V mask, const V yes, const V no)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::ZeroIfNegative (const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::BroadcastSignBit (const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::IfNegativeThenElse (V v, V yes, V no)
template<class D >
HWY_API bool | hwy::HWY_NAMESPACE::AllFalse (D d, MFromD< D > m)
template<size_t N, int kPow2>
HWY_API VFromD< Simd< uint16_t, N, kPow2 > > | hwy::HWY_NAMESPACE::Load (Simd< bfloat16_t, N, kPow2 > d, const bfloat16_t *HWY_RESTRICT p)
template<size_t N, int kPow2>
HWY_API void | hwy::HWY_NAMESPACE::Store (VFromD< Simd< uint16_t, N, kPow2 > > v, Simd< bfloat16_t, N, kPow2 > d, bfloat16_t *HWY_RESTRICT p)
template<class D >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::LoadU (D d, const TFromD< D > *HWY_RESTRICT p)
template<class V , class D >
HWY_API void | hwy::HWY_NAMESPACE::StoreU (const V v, D d, TFromD< D > *HWY_RESTRICT p)
template<class V , class D , typename T >
HWY_API void | hwy::HWY_NAMESPACE::Stream (const V v, D d, T *HWY_RESTRICT aligned)
template<class D , HWY_IF_LANE_SIZE_D(D, 4) >
HWY_API void | hwy::HWY_NAMESPACE::ScatterIndex (VFromD< D > v, D d, TFromD< D > *HWY_RESTRICT base, const VFromD< RebindToSigned< D > > index)
template<class D , HWY_IF_LANE_SIZE_D(D, 4) >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::GatherIndex (D d, const TFromD< D > *HWY_RESTRICT base, const VFromD< RebindToSigned< D > > index)
template<size_t N, int kPow2>
HWY_API auto | hwy::HWY_NAMESPACE::PromoteTo (Simd< int16_t, N, kPow2 > d, VFromD< Rebind< uint8_t, decltype(d)> > v) -> VFromD< decltype(d)>
template<size_t N, int kPow2>
HWY_API auto | hwy::HWY_NAMESPACE::PromoteTo (Simd< int32_t, N, kPow2 > d, VFromD< Rebind< uint8_t, decltype(d)> > v) -> VFromD< decltype(d)>
template<size_t N, int kPow2>
HWY_API auto | hwy::HWY_NAMESPACE::PromoteTo (Simd< int32_t, N, kPow2 > d, VFromD< Rebind< uint16_t, decltype(d)> > v) -> VFromD< decltype(d)>
template<size_t N, int kPow2>
HWY_API auto | hwy::HWY_NAMESPACE::PromoteTo (Simd< float32_t, N, kPow2 > d, VFromD< Rebind< bfloat16_t, decltype(d)> > v) -> VFromD< decltype(d)>
template<size_t N>
HWY_API vuint8mf8_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, -3 > d, const vint32mf2_t v)
template<size_t N>
HWY_API vuint8mf4_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, -2 > d, const vint32m1_t v)
template<size_t N>
HWY_API vuint8mf2_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, -1 > d, const vint32m2_t v)
template<size_t N>
HWY_API vuint8m1_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, 0 > d, const vint32m4_t v)
template<size_t N>
HWY_API vuint8m2_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, 1 > d, const vint32m8_t v)
HWY_API vuint8mf8_t | hwy::HWY_NAMESPACE::U8FromU32 (const vuint32mf2_t v)
HWY_API vuint8mf4_t | hwy::HWY_NAMESPACE::U8FromU32 (const vuint32m1_t v)
HWY_API vuint8mf2_t | hwy::HWY_NAMESPACE::U8FromU32 (const vuint32m2_t v)
HWY_API vuint8m1_t | hwy::HWY_NAMESPACE::U8FromU32 (const vuint32m4_t v)
HWY_API vuint8m2_t | hwy::HWY_NAMESPACE::U8FromU32 (const vuint32m8_t v)
template<size_t N>
HWY_API vuint8mf8_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, -3 > d, const VFromD< Simd< uint64_t, N, 0 > > v)
template<size_t N>
HWY_API vuint8mf4_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, -2 > d, const VFromD< Simd< uint64_t, N, 1 > > v)
template<size_t N>
HWY_API vuint8mf2_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, -1 > d, const VFromD< Simd< uint64_t, N, 2 > > v)
template<size_t N>
HWY_API vuint8m1_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, 0 > d, const VFromD< Simd< uint64_t, N, 3 > > v)
template<size_t N>
HWY_API vuint16mf4_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, -2 > d, const VFromD< Simd< uint64_t, N, 0 > > v)
template<size_t N>
HWY_API vuint16mf2_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, -1 > d, const VFromD< Simd< uint64_t, N, 1 > > v)
template<size_t N>
HWY_API vuint16m1_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, 0 > d, const VFromD< Simd< uint64_t, N, 2 > > v)
template<size_t N>
HWY_API vuint16m2_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, 1 > d, const VFromD< Simd< uint64_t, N, 3 > > v)
template<size_t N>
HWY_API vuint32mf2_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint32_t, N, -1 > d, const VFromD< Simd< uint64_t, N, 0 > > v)
template<size_t N>
HWY_API vuint32m1_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint32_t, N, 0 > d, const VFromD< Simd< uint64_t, N, 1 > > v)
template<size_t N>
HWY_API vuint32m2_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint32_t, N, 1 > d, const VFromD< Simd< uint64_t, N, 2 > > v)
template<size_t N>
HWY_API vuint32m4_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint32_t, N, 2 > d, const VFromD< Simd< uint64_t, N, 3 > > v)
template<size_t N>
HWY_API vuint8mf8_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, -3 > d, const VFromD< Simd< uint32_t, N, -1 > > v)
template<size_t N>
HWY_API vuint8mf4_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, -2 > d, const VFromD< Simd< uint32_t, N, 0 > > v)
template<size_t N>
HWY_API vuint8mf2_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, -1 > d, const VFromD< Simd< uint32_t, N, 1 > > v)
template<size_t N>
HWY_API vuint8m1_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, 0 > d, const VFromD< Simd< uint32_t, N, 2 > > v)
template<size_t N>
HWY_API vuint8m2_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, 1 > d, const VFromD< Simd< uint32_t, N, 3 > > v)
template<size_t N>
HWY_API vuint16mf4_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, -2 > d, const VFromD< Simd< uint32_t, N, -1 > > v)
template<size_t N>
HWY_API vuint16mf2_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, -1 > d, const VFromD< Simd< uint32_t, N, 0 > > v)
template<size_t N>
HWY_API vuint16m1_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, 0 > d, const VFromD< Simd< uint32_t, N, 1 > > v)
template<size_t N>
HWY_API vuint16m2_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, 1 > d, const VFromD< Simd< uint32_t, N, 2 > > v)
template<size_t N>
HWY_API vuint16m4_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, 2 > d, const VFromD< Simd< uint32_t, N, 3 > > v)
template<size_t N>
HWY_API vuint8mf8_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, -3 > d, const VFromD< Simd< uint16_t, N, -2 > > v)
template<size_t N>
HWY_API vuint8mf4_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, -2 > d, const VFromD< Simd< uint16_t, N, -1 > > v)
template<size_t N>
HWY_API vuint8mf2_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, -1 > d, const VFromD< Simd< uint16_t, N, 0 > > v)
template<size_t N>
HWY_API vuint8m1_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, 0 > d, const VFromD< Simd< uint16_t, N, 1 > > v)
template<size_t N>
HWY_API vuint8m2_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, 1 > d, const VFromD< Simd< uint16_t, N, 2 > > v)
template<size_t N>
HWY_API vuint8m4_t | hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, 2 > d, const VFromD< Simd< uint16_t, N, 3 > > v)
template<size_t N>
HWY_API vint8mf8_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< int8_t, N, -3 > d, const vint32mf2_t v)
template<size_t N>
HWY_API vint8mf4_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< int8_t, N, -2 > d, const vint32m1_t v)
template<size_t N>
HWY_API vint8mf2_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< int8_t, N, -1 > d, const vint32m2_t v)
template<size_t N>
HWY_API vint8m1_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< int8_t, N, 0 > d, const vint32m4_t v)
template<size_t N>
HWY_API vint8m2_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< int8_t, N, 1 > d, const vint32m8_t v)
| hwy::HWY_NAMESPACE::HWY_RVV_FOREACH_F64 (HWY_RVV_DEMOTE_F, DemoteTo, vfncvt_rod_f_f_w_f, _DEMOTE_VIRT) template< size_t N > HWY_API vint32mf2_t DemoteTo(Simd< int32_t
template<size_t N>
HWY_API vint32mf2_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< int32_t, N, -1 > d, const vfloat64m1_t v)
template<size_t N>
HWY_API vint32m1_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< int32_t, N, 0 > d, const vfloat64m2_t v)
template<size_t N>
HWY_API vint32m2_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< int32_t, N, 1 > d, const vfloat64m4_t v)
template<size_t N>
HWY_API vint32m4_t | hwy::HWY_NAMESPACE::DemoteTo (Simd< int32_t, N, 2 > d, const vfloat64m8_t v)
template<size_t N, int kPow2>
HWY_API VFromD< Simd< uint16_t, N, kPow2 > > | hwy::HWY_NAMESPACE::DemoteTo (Simd< bfloat16_t, N, kPow2 > d, VFromD< Simd< float, N, kPow2+1 > > v)
template<typename T , size_t N, int kPow2>
size_t | hwy::HWY_NAMESPACE::detail::LanesPerBlock (Simd< T, N, kPow2 > d)
template<class D , class V >
HWY_INLINE V | hwy::HWY_NAMESPACE::detail::OffsetsOf128BitBlocks (const D d, const V iota0)
template<size_t kLanes, class D >
HWY_INLINE MFromD< D > | hwy::HWY_NAMESPACE::detail::FirstNPerBlock (D)
template<class D , class V >
HWY_API V | hwy::HWY_NAMESPACE::ConcatUpperLower (const D d, const V hi, const V lo)
template<class D , class V >
HWY_API V | hwy::HWY_NAMESPACE::ConcatLowerLower (const D d, const V hi, const V lo)
template<class D , class V >
HWY_API V | hwy::HWY_NAMESPACE::ConcatUpperUpper (const D d, const V hi, const V lo)
template<class D , class V >
HWY_API V | hwy::HWY_NAMESPACE::ConcatLowerUpper (const D d, const V hi, const V lo)
template<class D2 , class V >
HWY_API VFromD< D2 > | hwy::HWY_NAMESPACE::Combine (D2 d2, const V hi, const V lo)
template<class D2 , class V >
HWY_API VFromD< D2 > | hwy::HWY_NAMESPACE::ZeroExtendVector (D2 d2, const V lo)
template<class D >
constexpr bool | hwy::HWY_NAMESPACE::detail::IsSupportedLMUL (D d)
template<class DH , hwy::EnableIf< detail::IsSupportedLMUL(DH())> * = nullptr>
HWY_API VFromD< DH > | hwy::HWY_NAMESPACE::LowerHalf (const DH, const VFromD< Twice< DH > > v)
template<class DH , class V , hwy::EnableIf<!detail::IsSupportedLMUL(DH())> * = nullptr>
HWY_API V | hwy::HWY_NAMESPACE::LowerHalf (const DH, const V v)
template<class V >
HWY_API VFromD< Half< DFromV< V > > > | hwy::HWY_NAMESPACE::LowerHalf (const V v)
template<class DH >
HWY_API VFromD< DH > | hwy::HWY_NAMESPACE::UpperHalf (const DH d2, const VFromD< Twice< DH > > v)
template<class V >
HWY_API TFromV< V > | hwy::HWY_NAMESPACE::ExtractLane (V v, size_t i)
template<class V , HWY_IF_NOT_LANE_SIZE_V(V, 1) >
HWY_API V | hwy::HWY_NAMESPACE::InsertLane (const V v, size_t i, TFromV< V > t)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::OddEven (const V a, const V b)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::DupEven (const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::DupOdd (const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::OddEvenBlocks (const V odd, const V even)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::SwapAdjacentBlocks (const V v)
template<class D , class VI >
HWY_API VFromD< RebindToUnsigned< D > > | hwy::HWY_NAMESPACE::IndicesFromVec (D d, VI vec)
template<class D , typename TI >
HWY_API VFromD< RebindToUnsigned< D > > | hwy::HWY_NAMESPACE::SetTableIndices (D d, const TI *idx)
template<class D , class V >
HWY_API V | hwy::HWY_NAMESPACE::ConcatOdd (D d, const V hi, const V lo)
template<class D , class V >
HWY_API V | hwy::HWY_NAMESPACE::ConcatEven (D d, const V hi, const V lo)
template<class D >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::Reverse (D, VFromD< D > v)
template<class D , HWY_IF_LANE_SIZE_D(D, 2) , HWY_RVV_IF_POW2_IN(D, -1, 3) >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::Reverse2 (D d, const VFromD< D > v)
template<class D , class V = VFromD<D>, HWY_IF_LANE_SIZE_D(D, 8) >
HWY_API V | hwy::HWY_NAMESPACE::Reverse2 (D, const V v)
template<class D >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::Reverse4 (D d, const VFromD< D > v)
template<class D >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::Reverse8 (D d, const VFromD< D > v)
template<class D , class V = VFromD<D>>
HWY_API V | hwy::HWY_NAMESPACE::ReverseBlocks (D d, V v)
template<class V , class M >
HWY_API V | hwy::HWY_NAMESPACE::CompressNot (V v, const M mask)
template<class V , class M >
HWY_API V | hwy::HWY_NAMESPACE::CompressBlocksNot (V v, const M mask)
template<class V , class M , class D >
HWY_API size_t | hwy::HWY_NAMESPACE::CompressStore (const V v, const M mask, const D d, TFromD< D > *HWY_RESTRICT unaligned)
template<class V , class M , class D >
HWY_API size_t | hwy::HWY_NAMESPACE::CompressBlendedStore (const V v, const M mask, const D d, TFromD< D > *HWY_RESTRICT unaligned)
template<size_t kBytes, class D , class V = VFromD<D>>
HWY_API V | hwy::HWY_NAMESPACE::CombineShiftRightBytes (const D d, const V hi, const V lo)
template<size_t kLanes, class D , class V = VFromD<D>>
HWY_API V | hwy::HWY_NAMESPACE::CombineShiftRightLanes (const D d, const V hi, V lo)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::Shuffle2301 (const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::Shuffle2103 (const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::Shuffle0321 (const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::Shuffle1032 (const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::Shuffle01 (const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::Shuffle0123 (const V v)
template<typename T , size_t N, int kPow2>
HWY_INLINE auto | hwy::HWY_NAMESPACE::detail::ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< Simd< T, N, kPow2 - 3 > > v) -> VFromD< decltype(d)>
template<typename T , size_t N, int kPow2>
HWY_INLINE auto | hwy::HWY_NAMESPACE::detail::ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< Simd< T, N, kPow2 - 2 > > v) -> VFromD< decltype(d)>
template<typename T , size_t N, int kPow2>
HWY_INLINE auto | hwy::HWY_NAMESPACE::detail::ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< Simd< T, N, kPow2 - 1 > > v) -> VFromD< decltype(d)>
template<typename T , size_t N, int kPow2>
HWY_INLINE auto | hwy::HWY_NAMESPACE::detail::ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< decltype(d)> v) -> VFromD< decltype(d)>
template<typename T , size_t N, int kPow2>
HWY_INLINE auto | hwy::HWY_NAMESPACE::detail::ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< Simd< T, N, kPow2+1 > > v) -> VFromD< decltype(d)>
template<typename T , size_t N, int kPow2>
HWY_INLINE auto | hwy::HWY_NAMESPACE::detail::ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< Simd< T, N, kPow2+2 > > v) -> VFromD< decltype(d)>
template<typename T , size_t N, int kPow2>
HWY_INLINE auto | hwy::HWY_NAMESPACE::detail::ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< Simd< T, N, kPow2+3 > > v) -> VFromD< decltype(d)>
template<class VT , class VI >
HWY_API VI | hwy::HWY_NAMESPACE::TableLookupBytes (const VT vt, const VI vi)
template<class VT , class VI >
HWY_API VI | hwy::HWY_NAMESPACE::TableLookupBytesOr0 (const VT vt, const VI idx)
template<int kLane, class V >
HWY_API V | hwy::HWY_NAMESPACE::Broadcast (const V v)
template<size_t kLanes, class D , class V = VFromD<D>>
HWY_API V | hwy::HWY_NAMESPACE::ShiftLeftLanes (D d, const V v)
template<size_t kLanes, class V >
HWY_API V | hwy::HWY_NAMESPACE::ShiftLeftLanes (const V v)
template<int kBytes, class D >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::ShiftLeftBytes (D d, const VFromD< D > v)
template<int kBytes, class V >
HWY_API V | hwy::HWY_NAMESPACE::ShiftLeftBytes (const V v)
template<size_t kLanes, typename T , size_t N, int kPow2, class V = VFromD<Simd<T, N, kPow2>>>
HWY_API V | hwy::HWY_NAMESPACE::ShiftRightLanes (const Simd< T, N, kPow2 > d, V v)
template<int kBytes, class D , class V = VFromD<D>>
HWY_API V | hwy::HWY_NAMESPACE::ShiftRightBytes (const D d, const V v)
template<class D , class V >
HWY_API V | hwy::HWY_NAMESPACE::InterleaveLower (D d, const V a, const V b)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::InterleaveLower (const V a, const V b)
template<class D , class V >
HWY_API V | hwy::HWY_NAMESPACE::InterleaveUpper (const D d, const V a, const V b)
template<class V , class DW = RepartitionToWide<DFromV<V>>>
HWY_API VFromD< DW > | hwy::HWY_NAMESPACE::ZipLower (DW dw, V a, V b)
template<class V , class DW = RepartitionToWide<DFromV<V>>>
HWY_API VFromD< DW > | hwy::HWY_NAMESPACE::ZipLower (V a, V b)
template<class V , class DW = RepartitionToWide<DFromV<V>>>
HWY_API VFromD< DW > | hwy::HWY_NAMESPACE::ZipUpper (DW dw, V a, V b)
template<class D >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::SumOfLanes (D d, const VFromD< D > v)
template<class D >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::MinOfLanes (D d, const VFromD< D > v)
template<class D >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::MaxOfLanes (D d, const VFromD< D > v)
template<class V >
decltype(MaskFromVec(v)) HWY_API V | hwy::HWY_NAMESPACE::Round (const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::Trunc (const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::Ceil (const V v)
template<class V >
HWY_API V | hwy::HWY_NAMESPACE::Floor (const V v)
template<class V >
HWY_API MFromD< DFromV< V > > | hwy::HWY_NAMESPACE::IsNaN (const V v)
template<class V , class D = DFromV<V>>
HWY_API MFromD< D > | hwy::HWY_NAMESPACE::IsInf (const V v)
template<class V , class D = DFromV<V>>
HWY_API MFromD< D > | hwy::HWY_NAMESPACE::IsFinite (const V v)
template<class D , HWY_IF_FLOAT_D(D) >
HWY_API VFromD< D > | hwy::HWY_NAMESPACE::Iota (const D d, TFromD< D > first)
template<class V , HWY_IF_LANE_SIZE_V(V, 4) , class D = DFromV<V>, class DW = RepartitionToWide<D>>
HWY_API VFromD< DW > | hwy::HWY_NAMESPACE::MulEven (const V a, const V b)
template<class V , HWY_IF_LANE_SIZE_V(V, 8) >
HWY_INLINE V | hwy::HWY_NAMESPACE::MulEven (const V a, const V b)
template<class V , HWY_IF_LANE_SIZE_V(V, 8) >
HWY_INLINE V | hwy::HWY_NAMESPACE::MulOdd (const V a, const V b)
template<size_t N, int kPow2>
HWY_API VFromD< Simd< uint16_t, N, kPow2 > > | hwy::HWY_NAMESPACE::ReorderDemote2To (Simd< bfloat16_t, N, kPow2 > dbf16, VFromD< RepartitionToWide< decltype(dbf16)> > a, VFromD< RepartitionToWide< decltype(dbf16)> > b)
template<size_t N, int kPow2, hwy::EnableIf<(kPow2< 3)> * = nullptr, class D32 = RepartitionToWide<Simd<int16_t, N, kPow2>>>
HWY_API VFromD< Simd< int16_t, N, kPow2 > > | hwy::HWY_NAMESPACE::ReorderDemote2To (Simd< int16_t, N, kPow2 > d16, VFromD< D32 > a, VFromD< D32 > b)
template<size_t N, class V32 = VFromD<RepartitionToWide<Simd<int16_t, N, 3>>>>
HWY_API VFromD< Simd< int16_t, N, 3 > > | hwy::HWY_NAMESPACE::ReorderDemote2To (Simd< int16_t, N, 3 > d16, V32 a, V32 b)
template<size_t N, int kPow2, class DF32 = Simd<float, N, kPow2>, class VF32 = VFromD<DF32>, class DU16 = RepartitionToNarrow<RebindToUnsigned<Simd<float, N, kPow2>>>>
HWY_API VF32 | hwy::HWY_NAMESPACE::detail::ReorderWidenMulAccumulateBF16 (Simd< float, N, kPow2 > df32, VFromD< DU16 > a, VFromD< DU16 > b, const VF32 sum0, VF32 &sum1)
template<size_t N, int kPow2, hwy::EnableIf<(kPow2< 3)> * = nullptr, class D32 = Simd<int32_t, N, kPow2>, class V32 = VFromD<D32>, class D16 = RepartitionToNarrow<D32>>
HWY_API VFromD< D32 > | hwy::HWY_NAMESPACE::detail::ReorderWidenMulAccumulateI16 (Simd< int32_t, N, kPow2 > d32, VFromD< D16 > a, VFromD< D16 > b, const V32 sum0, V32 &sum1)
template<size_t N, class D32 = Simd<int32_t, N, 3>, class V32 = VFromD<D32>, class D16 = RepartitionToNarrow<D32>>
HWY_API VFromD< D32 > | hwy::HWY_NAMESPACE::detail::ReorderWidenMulAccumulateI16 (Simd< int32_t, N, 3 > d32, VFromD< D16 > a, VFromD< D16 > b, const V32 sum0, V32 &sum1)
template<size_t N, int kPow2, class VN , class VW >
HWY_API VW | hwy::HWY_NAMESPACE::ReorderWidenMulAccumulate (Simd< float, N, kPow2 > d32, VN a, VN b, const VW sum0, VW &sum1)
template<size_t N, int kPow2, class VN , class VW >
HWY_API VW | hwy::HWY_NAMESPACE::ReorderWidenMulAccumulate (Simd< int32_t, N, kPow2 > d32, VN a, VN b, const VW sum0, VW &sum1)
template<class VW , HWY_IF_SIGNED_V(VW) >
HWY_API VW | hwy::HWY_NAMESPACE::RearrangeToOddPlusEven (const VW sum0, const VW sum1)
HWY_API vint32m8_t | hwy::HWY_NAMESPACE::RearrangeToOddPlusEven (vint32m8_t sum0, vint32m8_t sum1)
template<class D >
HWY_INLINE MFromD< D > | hwy::HWY_NAMESPACE::Lt128 (D d, const VFromD< D > a, const VFromD< D > b)
template<class D >
HWY_INLINE MFromD< D > | hwy::HWY_NAMESPACE::Lt128Upper (D d, const VFromD< D > a, const VFromD< D > b)
template<class D >
HWY_INLINE MFromD< D > | hwy::HWY_NAMESPACE::Eq128 (D d, const VFromD< D > a, const VFromD< D > b)
template<class D >
HWY_INLINE MFromD< D > | hwy::HWY_NAMESPACE::Eq128Upper (D d, const VFromD< D > a, const VFromD< D > b)
template<class D >
HWY_INLINE MFromD< D > | hwy::HWY_NAMESPACE::Ne128 (D d, const VFromD< D > a, const VFromD< D > b)
template<class D >
HWY_INLINE MFromD< D > | hwy::HWY_NAMESPACE::Ne128Upper (D d, const VFromD< D > a, const VFromD< D > b)
template<class D >
HWY_INLINE VFromD< D > | hwy::HWY_NAMESPACE::Min128 (D d, const VFromD< D > a, const VFromD< D > b)
template<class D >
HWY_INLINE VFromD< D > | hwy::HWY_NAMESPACE::Max128 (D d, const VFromD< D > a, const VFromD< D > b)
template<class D >
HWY_INLINE VFromD< D > | hwy::HWY_NAMESPACE::Min128Upper (D d, const VFromD< D > a, const VFromD< D > b)
template<class D >
HWY_INLINE VFromD< D > | hwy::HWY_NAMESPACE::Max128Upper (D d, const VFromD< D > a, const VFromD< D > b)
| HWY_AFTER_NAMESPACE ()

## Variables

| hwy::HWY_NAMESPACE::N
| hwy::HWY_NAMESPACE::d
const vfloat64m1_t | hwy::HWY_NAMESPACE::v

## Macro Definition Documentation

## HWY_NATIVE_COMPRESS8

#define HWY_NATIVE_COMPRESS8

## HWY_NATIVE_I64MULLO

#define HWY_NATIVE_I64MULLO

## HWY_NATIVE_LOAD_STORE_INTERLEAVED

#define HWY_NATIVE_LOAD_STORE_INTERLEAVED

## HWY_RVV_ALL_TRUE

#define HWY_RVV_ALL_TRUE | ( |  | SEW,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <class D> \
HWY_API bool AllTrue(D d, HWY_RVV_M(MLEN) m) { \
static_assert(MLenFromD(d) == MLEN, "Type mismatch"); \
return AllFalse(d, vmnot_m_b##MLEN(m, Lanes(d))); \
}
HWY_API
#define HWY_API
Definition base.h:129
HWY_RVV_M
#define HWY_RVV_M(MLEN)
Definition rvv-inl.h:388

## HWY_RVV_AVL

#define HWY_RVV_AVL | ( |  | SEW,
|  |  | SHIFT
| ) |  | Lanes(ScalableTag<HWY_RVV_T(uint, SEW), SHIFT>())

## HWY_RVV_BLENDED_STORE

#define HWY_RVV_BLENDED_STORE | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API void NAME(HWY_RVV_V(BASE, SEW, LMUL) v, HWY_RVV_M(MLEN) m, \
HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
HWY_RVV_T(BASE, SEW) * HWY_RESTRICT p) { \
return v##OP##SEW##_v_##CHAR##SEW##LMUL##_m(m, p, v, Lanes(d)); \
}
HWY_RESTRICT
#define HWY_RESTRICT
Definition base.h:64
HWY_RVV_D
#define HWY_RVV_D(BASE, SEW, N, SHIFT)
Definition rvv-inl.h:386
HWY_RVV_V
#define HWY_RVV_V(BASE, SEW, LMUL)
Definition rvv-inl.h:387
HWY_RVV_T
#define HWY_RVV_T(BASE, SEW)
Definition rvv-inl.h:385

## HWY_RVV_CAST_I8

#define HWY_RVV_CAST_I8 | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <typename T, size_t N> \
HWY_API vuint8##LMUL##_t BitCastToByte(Simd<T, N, SHIFT> /* d */, \
vint8##LMUL##_t v) { \
return vreinterpret_v_i8##LMUL##_u8##LMUL(v); \
} \
template <size_t N> \
HWY_API vint8##LMUL##_t BitCastFromByte( \
HWY_RVV_D(BASE, SEW, N, SHIFT) /* d */, vuint8##LMUL##_t v) { \
return vreinterpret_v_u8##LMUL##_i8##LMUL(v); \
}

## HWY_RVV_CAST_IF

#define HWY_RVV_CAST_IF | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <typename T, size_t N> \
HWY_API vuint8##LMUL##_t BitCastToByte(Simd<T, N, SHIFT> /* d */, \
HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_v_u##SEW##LMUL##_u8##LMUL( \
v##OP##_v_##CHAR##SEW##LMUL##_u##SEW##LMUL(v)); \
} \
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) BitCastFromByte( \
HWY_RVV_D(BASE, SEW, N, SHIFT) /* d */, vuint8##LMUL##_t v) { \
return v##OP##_v_u##SEW##LMUL##_##CHAR##SEW##LMUL( \
v##OP##_v_u8##LMUL##_u##SEW##LMUL(v)); \
}

## HWY_RVV_CAST_U

#define HWY_RVV_CAST_U | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <typename T, size_t N> \
HWY_API vuint8##LMUL##_t BitCastToByte(Simd<T, N, SHIFT> /* d */, \
HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_v_##CHAR##SEW##LMUL##_u8##LMUL(v); \
} \
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) BitCastFromByte( \
HWY_RVV_D(BASE, SEW, N, SHIFT) /* d */, vuint8##LMUL##_t v) { \
return v##OP##_v_u8##LMUL##_##CHAR##SEW##LMUL(v); \
}

## HWY_RVV_CAST_U8

#define HWY_RVV_CAST_U8 | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <typename T, size_t N> \
HWY_API vuint8##LMUL##_t BitCastToByte(Simd<T, N, SHIFT> /* d */, \
vuint8##LMUL##_t v) { \
return v; \
} \
template <size_t N> \
HWY_API vuint8##LMUL##_t BitCastFromByte( \
HWY_RVV_D(BASE, SEW, N, SHIFT) /* d */, vuint8##LMUL##_t v) { \
return v; \
}

## HWY_RVV_CAST_VIRT_IF

#define HWY_RVV_CAST_VIRT_IF | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <typename T, size_t N> \
HWY_API vuint8##LMULH##_t BitCastToByte(Simd<T, N, SHIFT> /* d */, \
HWY_RVV_V(BASE, SEW, LMUL) v) { \
return detail::Trunc(v##OP##_v_u##SEW##LMUL##_u8##LMUL( \
v##OP##_v_##CHAR##SEW##LMUL##_u##SEW##LMUL(v))); \
} \
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) BitCastFromByte( \
HWY_RVV_D(BASE, SEW, N, SHIFT) /* d */, vuint8##LMULH##_t v) { \
HWY_RVV_D(uint, 8, N, SHIFT + 1) d2; \
const vuint8##LMUL##_t v2 = detail::Ext(d2, v); \
return v##OP##_v_u##SEW##LMUL##_##CHAR##SEW##LMUL( \
v##OP##_v_u8##LMUL##_u##SEW##LMUL(v2)); \
}

## HWY_RVV_CAST_VIRT_U

#define HWY_RVV_CAST_VIRT_U | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <typename T, size_t N> \
HWY_API vuint8##LMULH##_t BitCastToByte(Simd<T, N, SHIFT> /* d */, \
HWY_RVV_V(BASE, SEW, LMUL) v) { \
return detail::Trunc(v##OP##_v_##CHAR##SEW##LMUL##_u8##LMUL(v)); \
} \
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) BitCastFromByte( \
HWY_RVV_D(BASE, SEW, N, SHIFT) /* d */, vuint8##LMULH##_t v) { \
HWY_RVV_D(uint, 8, N, SHIFT + 1) d2; \
const vuint8##LMUL##_t v2 = detail::Ext(d2, v); \
return v##OP##_v_u8##LMUL##_##CHAR##SEW##LMUL(v2); \
}

## HWY_RVV_COMPRESS

#define HWY_RVV_COMPRESS | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) v, HWY_RVV_M(MLEN) mask) { \
return v##OP##_vm_##CHAR##SEW##LMUL(v, v, mask, HWY_RVV_AVL(SEW, SHIFT)); \
}
HWY_RVV_AVL
#define HWY_RVV_AVL(SEW, SHIFT)
Definition rvv-inl.h:436

## HWY_RVV_CONVERT

#define HWY_RVV_CONVERT | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) ConvertTo( \
HWY_RVV_D(BASE, SEW, N, SHIFT) d, HWY_RVV_V(int, SEW, LMUL) v) { \
return vfcvt_f_x_v_f##SEW##LMUL(v, Lanes(d)); \
} \
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) ConvertTo( \
HWY_RVV_D(BASE, SEW, N, SHIFT) d, HWY_RVV_V(uint, SEW, LMUL) v) {\
return vfcvt_f_xu_v_f##SEW##LMUL(v, Lanes(d)); \
} \
/* Truncates (rounds toward zero). */ \
template <size_t N> \
HWY_API HWY_RVV_V(int, SEW, LMUL) ConvertTo(HWY_RVV_D(int, SEW, N, SHIFT) d, \
HWY_RVV_V(BASE, SEW, LMUL) v) { \
return vfcvt_rtz_x_f_v_i##SEW##LMUL(v, Lanes(d)); \
} \
hwy::HWY_NAMESPACE::Lanes
HWY_API constexpr size_t Lanes(Simd< T, N, kPow2 >)
Definition arm_sve-inl.h:243
hwy::HWY_NAMESPACE::ConvertTo
HWY_API Vec128< float > ConvertTo(Full128< float >, const Vec128< int32_t > v)
Definition arm_neon-inl.h:3327

## HWY_RVV_COUNT_TRUE

#define HWY_RVV_COUNT_TRUE | ( |  | SEW,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <class D> \
HWY_API size_t CountTrue(D d, HWY_RVV_M(MLEN) m) { \
static_assert(MLenFromD(d) == MLEN, "Type mismatch"); \
return vcpop_m_b##MLEN(m, Lanes(d)); \
}

## HWY_RVV_D

#define HWY_RVV_D | ( |  | BASE,
|  |  | SEW,
|  |  | N,
|  |  | SHIFT
| ) |  | Simd<HWY_RVV_T(BASE, SEW), N, SHIFT>

## HWY_RVV_DEMOTE

#define HWY_RVV_DEMOTE | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEWH, LMULH) NAME( \
HWY_RVV_D(BASE, SEWH, N, SHIFT - 1) d, HWY_RVV_V(BASE, SEW, LMUL) v) { \
return OP##CHAR##SEWH##LMULH(v, 0, Lanes(d)); \
} \
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEWH, LMULH) NAME##Shr16( \
HWY_RVV_D(BASE, SEWH, N, SHIFT - 1) d, HWY_RVV_V(BASE, SEW, LMUL) v) { \
return OP##CHAR##SEWH##LMULH(v, 16, Lanes(d)); \
}

## HWY_RVV_DEMOTE_F

#define HWY_RVV_DEMOTE_F | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEWH, LMULH) NAME( \
HWY_RVV_D(BASE, SEWH, N, SHIFT - 1) d, HWY_RVV_V(BASE, SEW, LMUL) v) { \
return OP##SEWH##LMULH(v, Lanes(d)); \
}

## HWY_RVV_DEMOTE_I_TO_U

#define HWY_RVV_DEMOTE_I_TO_U | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API HWY_RVV_V(uint, SEWH, LMULH) NAME( \
HWY_RVV_D(uint, SEWH, N, SHIFT - 1) d, HWY_RVV_V(int, SEW, LMUL) v) { \
/* First clamp negative numbers to zero to match x86 packus. */ \
return detail::DemoteTo(d, detail::BitCastToUnsigned(detail::MaxS(v, 0))); \
}

## HWY_RVV_EXT

#define HWY_RVV_EXT | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMULD) \
NAME(HWY_RVV_D(BASE, SEW, N, SHIFT + 1) /* d2 */, \
HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_v_##CHAR##SEW##LMUL##_##CHAR##SEW##LMULD(v); /* no AVL */ \
}

## HWY_RVV_EXT_VIRT

#define HWY_RVV_EXT_VIRT | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_D(BASE, SEW, N, SHIFT + 1) /* d2 */, \
HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v; \
}

## HWY_RVV_FIND_FIRST_TRUE

#define HWY_RVV_FIND_FIRST_TRUE | ( |  | SEW,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <class D> \
HWY_API intptr_t FindFirstTrue(D d, HWY_RVV_M(MLEN) m) { \
static_assert(MLenFromD(d) == MLEN, "Type mismatch"); \
return vfirst_m_b##MLEN(m, Lanes(d)); \
} \
template <class D> \
HWY_API size_t FindKnownFirstTrue(D d, HWY_RVV_M(MLEN) m) { \
static_assert(MLenFromD(d) == MLEN, "Type mismatch"); \
return static_cast<size_t>(vfirst_m_b##MLEN(m, Lanes(d))); \
}

## HWY_RVV_FMA

#define HWY_RVV_FMA | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) mul, HWY_RVV_V(BASE, SEW, LMUL) x, \
HWY_RVV_V(BASE, SEW, LMUL) add) { \
return v##OP##_vv_##CHAR##SEW##LMUL(add, mul, x, HWY_RVV_AVL(SEW, SHIFT)); \
}

## HWY_RVV_FOREACH

#define HWY_RVV_FOREACH | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  |

Value:
HWY_RVV_FOREACH_U(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_F(X_MACRO, NAME, OP, LMULS)
HWY_RVV_FOREACH_U
#define HWY_RVV_FOREACH_U(X_MACRO, NAME, OP, LMULS)
Definition rvv-inl.h:358

## HWY_RVV_FOREACH_08_ALL

#define HWY_RVV_FOREACH_08_ALL | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_08_EXT(X_MACRO, BASE, CHAR, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m8, __, m4, 3, /*MLEN=*/1, NAME, OP)
HWY_RVV_FOREACH_08_EXT
#define HWY_RVV_FOREACH_08_EXT(X_MACRO, BASE, CHAR, NAME, OP)
Definition rvv-inl.h:158

## HWY_RVV_FOREACH_08_ALL_VIRT

#define HWY_RVV_FOREACH_08_ALL_VIRT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_08_ALL(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_08_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
HWY_RVV_FOREACH_08_ALL
#define HWY_RVV_FOREACH_08_ALL(X_MACRO, BASE, CHAR, NAME, OP)
Definition rvv-inl.h:175

## HWY_RVV_FOREACH_08_DEMOTE

#define HWY_RVV_FOREACH_08_DEMOTE | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
X_MACRO(BASE, CHAR, 8, 16, __, mf4, mf2, mf8, -2, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, mf2, m1, mf4, -1, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m1, m2, mf2, 0, /*MLEN=*/8, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m2, m4, m1, 1, /*MLEN=*/4, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m4, m8, m2, 2, /*MLEN=*/2, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m8, __, m4, 3, /*MLEN=*/1, NAME, OP)

## HWY_RVV_FOREACH_08_DEMOTE_VIRT

#define HWY_RVV_FOREACH_08_DEMOTE_VIRT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_08_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_08_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
HWY_RVV_FOREACH_08_DEMOTE
#define HWY_RVV_FOREACH_08_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP)
Definition rvv-inl.h:105

## HWY_RVV_FOREACH_08_EXT

#define HWY_RVV_FOREACH_08_EXT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_08_LE2(X_MACRO, BASE, CHAR, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m4, m8, m2, 2, /*MLEN=*/2, NAME, OP)
HWY_RVV_FOREACH_08_LE2
#define HWY_RVV_FOREACH_08_LE2(X_MACRO, BASE, CHAR, NAME, OP)
Definition rvv-inl.h:135

## HWY_RVV_FOREACH_08_EXT_VIRT

#define HWY_RVV_FOREACH_08_EXT_VIRT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_08_EXT(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_08_VIRT(X_MACRO, BASE, CHAR, NAME, OP)

## HWY_RVV_FOREACH_08_LE2

#define HWY_RVV_FOREACH_08_LE2 | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
X_MACRO(BASE, CHAR, 8, 16, __, mf8, mf4, __, -3, /*MLEN=*/64, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, mf4, mf2, mf8, -2, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, mf2, m1, mf4, -1, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m1, m2, mf2, 0, /*MLEN=*/8, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m2, m4, m1, 1, /*MLEN=*/4, NAME, OP)

## HWY_RVV_FOREACH_08_LE2_VIRT

#define HWY_RVV_FOREACH_08_LE2_VIRT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_08_LE2(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_08_VIRT(X_MACRO, BASE, CHAR, NAME, OP)

## HWY_RVV_FOREACH_08_TRUNC

#define HWY_RVV_FOREACH_08_TRUNC | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
X_MACRO(BASE, CHAR, 8, 16, __, mf4, mf2, mf8, -2, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, mf2, m1, mf4, -1, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m1, m2, mf2, 0, /*MLEN=*/8, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m2, m4, m1, 1, /*MLEN=*/4, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m4, m8, m2, 2, /*MLEN=*/2, NAME, OP) \
X_MACRO(BASE, CHAR, 8, 16, __, m8, __, m4, 3, /*MLEN=*/1, NAME, OP)

## HWY_RVV_FOREACH_08_VIRT

#define HWY_RVV_FOREACH_08_VIRT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

## HWY_RVV_FOREACH_16_ALL

#define HWY_RVV_FOREACH_16_ALL | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_16_EXT(X_MACRO, BASE, CHAR, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m8, __, m4, 3, /*MLEN=*/2, NAME, OP)
HWY_RVV_FOREACH_16_EXT
#define HWY_RVV_FOREACH_16_EXT(X_MACRO, BASE, CHAR, NAME, OP)
Definition rvv-inl.h:162

## HWY_RVV_FOREACH_16_ALL_VIRT

#define HWY_RVV_FOREACH_16_ALL_VIRT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_16_ALL(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_16_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
HWY_RVV_FOREACH_16_ALL
#define HWY_RVV_FOREACH_16_ALL(X_MACRO, BASE, CHAR, NAME, OP)
Definition rvv-inl.h:179

## HWY_RVV_FOREACH_16_DEMOTE

#define HWY_RVV_FOREACH_16_DEMOTE | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
X_MACRO(BASE, CHAR, 16, 32, 8, mf4, mf2, mf8, -2, /*MLEN=*/64, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, mf2, m1, mf4, -1, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m1, m2, mf2, 0, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m2, m4, m1, 1, /*MLEN=*/8, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m4, m8, m2, 2, /*MLEN=*/4, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m8, __, m4, 3, /*MLEN=*/2, NAME, OP)

## HWY_RVV_FOREACH_16_DEMOTE_VIRT

#define HWY_RVV_FOREACH_16_DEMOTE_VIRT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_16_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_16_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
HWY_RVV_FOREACH_16_DEMOTE
#define HWY_RVV_FOREACH_16_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP)
Definition rvv-inl.h:113

## HWY_RVV_FOREACH_16_EXT

#define HWY_RVV_FOREACH_16_EXT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_16_LE2(X_MACRO, BASE, CHAR, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m4, m8, m2, 2, /*MLEN=*/4, NAME, OP)
HWY_RVV_FOREACH_16_LE2
#define HWY_RVV_FOREACH_16_LE2(X_MACRO, BASE, CHAR, NAME, OP)
Definition rvv-inl.h:142

## HWY_RVV_FOREACH_16_EXT_VIRT

#define HWY_RVV_FOREACH_16_EXT_VIRT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_16_EXT(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_16_VIRT(X_MACRO, BASE, CHAR, NAME, OP)

## HWY_RVV_FOREACH_16_LE2

#define HWY_RVV_FOREACH_16_LE2 | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
X_MACRO(BASE, CHAR, 16, 32, 8, mf4, mf2, mf8, -2, /*MLEN=*/64, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, mf2, m1, mf4, -1, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m1, m2, mf2, 0, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m2, m4, m1, 1, /*MLEN=*/8, NAME, OP)

## HWY_RVV_FOREACH_16_LE2_VIRT

#define HWY_RVV_FOREACH_16_LE2_VIRT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_16_LE2(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_16_VIRT(X_MACRO, BASE, CHAR, NAME, OP)

## HWY_RVV_FOREACH_16_TRUNC

#define HWY_RVV_FOREACH_16_TRUNC | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
X_MACRO(BASE, CHAR, 16, 32, 8, mf2, m1, mf4, -1, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m1, m2, mf2, 0, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m2, m4, m1, 1, /*MLEN=*/8, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m4, m8, m2, 2, /*MLEN=*/4, NAME, OP) \
X_MACRO(BASE, CHAR, 16, 32, 8, m8, __, m4, 3, /*MLEN=*/2, NAME, OP)

## HWY_RVV_FOREACH_16_VIRT

#define HWY_RVV_FOREACH_16_VIRT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  | X_MACRO(BASE, CHAR, 16, 32, 8, mf4, mf2, mf8, -3, /*MLEN=*/64, NAME, OP)

## HWY_RVV_FOREACH_32_ALL

#define HWY_RVV_FOREACH_32_ALL | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_32_EXT(X_MACRO, BASE, CHAR, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m8, __, m4, 3, /*MLEN=*/4, NAME, OP)
HWY_RVV_FOREACH_32_EXT
#define HWY_RVV_FOREACH_32_EXT(X_MACRO, BASE, CHAR, NAME, OP)
Definition rvv-inl.h:166

## HWY_RVV_FOREACH_32_ALL_VIRT

#define HWY_RVV_FOREACH_32_ALL_VIRT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_32_ALL(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_32_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
HWY_RVV_FOREACH_32_ALL
#define HWY_RVV_FOREACH_32_ALL(X_MACRO, BASE, CHAR, NAME, OP)
Definition rvv-inl.h:183

## HWY_RVV_FOREACH_32_DEMOTE

#define HWY_RVV_FOREACH_32_DEMOTE | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
X_MACRO(BASE, CHAR, 32, 64, 16, mf2, m1, mf4, -1, /*MLEN=*/64, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m1, m2, mf2, 0, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m2, m4, m1, 1, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m4, m8, m2, 2, /*MLEN=*/8, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m8, __, m4, 3, /*MLEN=*/4, NAME, OP)

## HWY_RVV_FOREACH_32_DEMOTE_VIRT

#define HWY_RVV_FOREACH_32_DEMOTE_VIRT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_32_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_32_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
HWY_RVV_FOREACH_32_DEMOTE
#define HWY_RVV_FOREACH_32_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP)
Definition rvv-inl.h:121

## HWY_RVV_FOREACH_32_EXT

#define HWY_RVV_FOREACH_32_EXT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_32_LE2(X_MACRO, BASE, CHAR, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m4, m8, m2, 2, /*MLEN=*/8, NAME, OP)
HWY_RVV_FOREACH_32_LE2
#define HWY_RVV_FOREACH_32_LE2(X_MACRO, BASE, CHAR, NAME, OP)
Definition rvv-inl.h:148

## HWY_RVV_FOREACH_32_EXT_VIRT

#define HWY_RVV_FOREACH_32_EXT_VIRT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_32_EXT(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_32_VIRT(X_MACRO, BASE, CHAR, NAME, OP)

## HWY_RVV_FOREACH_32_LE2

#define HWY_RVV_FOREACH_32_LE2 | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
X_MACRO(BASE, CHAR, 32, 64, 16, mf2, m1, mf4, -1, /*MLEN=*/64, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m1, m2, mf2, 0, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m2, m4, m1, 1, /*MLEN=*/16, NAME, OP)

## HWY_RVV_FOREACH_32_LE2_VIRT

#define HWY_RVV_FOREACH_32_LE2_VIRT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_32_LE2(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_32_VIRT(X_MACRO, BASE, CHAR, NAME, OP)

## HWY_RVV_FOREACH_32_TRUNC

#define HWY_RVV_FOREACH_32_TRUNC | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
X_MACRO(BASE, CHAR, 32, 64, 16, m1, m2, mf2, 0, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m2, m4, m1, 1, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m4, m8, m2, 2, /*MLEN=*/8, NAME, OP) \
X_MACRO(BASE, CHAR, 32, 64, 16, m8, __, m4, 3, /*MLEN=*/4, NAME, OP)

## HWY_RVV_FOREACH_32_VIRT

#define HWY_RVV_FOREACH_32_VIRT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  | X_MACRO(BASE, CHAR, 32, 64, 16, mf2, m1, mf4, -2, /*MLEN=*/64, NAME, OP)

## HWY_RVV_FOREACH_64_ALL

#define HWY_RVV_FOREACH_64_ALL | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_64_EXT(X_MACRO, BASE, CHAR, NAME, OP) \
X_MACRO(BASE, CHAR, 64, __, 32, m8, __, m4, 3, /*MLEN=*/8, NAME, OP)
HWY_RVV_FOREACH_64_EXT
#define HWY_RVV_FOREACH_64_EXT(X_MACRO, BASE, CHAR, NAME, OP)
Definition rvv-inl.h:170

## HWY_RVV_FOREACH_64_ALL_VIRT

#define HWY_RVV_FOREACH_64_ALL_VIRT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_64_ALL(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_64_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
HWY_RVV_FOREACH_64_ALL
#define HWY_RVV_FOREACH_64_ALL(X_MACRO, BASE, CHAR, NAME, OP)
Definition rvv-inl.h:187

## HWY_RVV_FOREACH_64_DEMOTE

#define HWY_RVV_FOREACH_64_DEMOTE | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
X_MACRO(BASE, CHAR, 64, __, 32, m1, m2, mf2, 0, /*MLEN=*/64, NAME, OP) \
X_MACRO(BASE, CHAR, 64, __, 32, m2, m4, m1, 1, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 64, __, 32, m4, m8, m2, 2, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 64, __, 32, m8, __, m4, 3, /*MLEN=*/8, NAME, OP)

## HWY_RVV_FOREACH_64_DEMOTE_VIRT

#define HWY_RVV_FOREACH_64_DEMOTE_VIRT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_64_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_64_VIRT(X_MACRO, BASE, CHAR, NAME, OP)
HWY_RVV_FOREACH_64_DEMOTE
#define HWY_RVV_FOREACH_64_DEMOTE(X_MACRO, BASE, CHAR, NAME, OP)
Definition rvv-inl.h:128

## HWY_RVV_FOREACH_64_EXT

#define HWY_RVV_FOREACH_64_EXT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_64_LE2(X_MACRO, BASE, CHAR, NAME, OP) \
X_MACRO(BASE, CHAR, 64, __, 32, m4, m8, m2, 2, /*MLEN=*/16, NAME, OP)
HWY_RVV_FOREACH_64_LE2
#define HWY_RVV_FOREACH_64_LE2(X_MACRO, BASE, CHAR, NAME, OP)
Definition rvv-inl.h:153

## HWY_RVV_FOREACH_64_EXT_VIRT

#define HWY_RVV_FOREACH_64_EXT_VIRT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_64_EXT(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_64_VIRT(X_MACRO, BASE, CHAR, NAME, OP)

## HWY_RVV_FOREACH_64_LE2

#define HWY_RVV_FOREACH_64_LE2 | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
X_MACRO(BASE, CHAR, 64, __, 32, m1, m2, mf2, 0, /*MLEN=*/64, NAME, OP) \
X_MACRO(BASE, CHAR, 64, __, 32, m2, m4, m1, 1, /*MLEN=*/32, NAME, OP)

## HWY_RVV_FOREACH_64_LE2_VIRT

#define HWY_RVV_FOREACH_64_LE2_VIRT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_RVV_FOREACH_64_LE2(X_MACRO, BASE, CHAR, NAME, OP) \
HWY_RVV_FOREACH_64_VIRT(X_MACRO, BASE, CHAR, NAME, OP)

## HWY_RVV_FOREACH_64_TRUNC

#define HWY_RVV_FOREACH_64_TRUNC | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
X_MACRO(BASE, CHAR, 64, __, 32, m2, m4, m1, 1, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 64, __, 32, m4, m8, m2, 2, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 64, __, 32, m8, __, m4, 3, /*MLEN=*/8, NAME, OP)

## HWY_RVV_FOREACH_64_VIRT

#define HWY_RVV_FOREACH_64_VIRT | ( |  | X_MACRO,
|  |  | BASE,
|  |  | CHAR,
|  |  | NAME,
|  |  | OP
| ) |  | X_MACRO(BASE, CHAR, 64, __, 32, m1, m2, mf2, -1, /*MLEN=*/64, NAME, OP)

## HWY_RVV_FOREACH_B

#define HWY_RVV_FOREACH_B | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
X_MACRO(64, 0, 64, NAME, OP) \
X_MACRO(32, 0, 32, NAME, OP) \
X_MACRO(16, 0, 16, NAME, OP) \
X_MACRO(8, 0, 8, NAME, OP) \
X_MACRO(8, 1, 4, NAME, OP) \
X_MACRO(8, 2, 2, NAME, OP) \
X_MACRO(8, 3, 1, NAME, OP)

## HWY_RVV_FOREACH_F

#define HWY_RVV_FOREACH_F | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  |

Value:
HWY_RVV_FOREACH_F16(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_F3264(X_MACRO, NAME, OP, LMULS)
HWY_RVV_FOREACH_F16
#define HWY_RVV_FOREACH_F16(X_MACRO, NAME, OP, LMULS)
Definition rvv-inl.h:311

## HWY_RVV_FOREACH_F16

#define HWY_RVV_FOREACH_F16 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  |

## HWY_RVV_FOREACH_F32

#define HWY_RVV_FOREACH_F32 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  | HWY_CONCAT(HWY_RVV_FOREACH_32, LMULS)(X_MACRO, float, f, NAME, OP)

## HWY_RVV_FOREACH_F3264

#define HWY_RVV_FOREACH_F3264 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  |

Value:
HWY_RVV_FOREACH_F32(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_F64(X_MACRO, NAME, OP, LMULS)
HWY_RVV_FOREACH_F32
#define HWY_RVV_FOREACH_F32(X_MACRO, NAME, OP, LMULS)
Definition rvv-inl.h:313

## HWY_RVV_FOREACH_F64

#define HWY_RVV_FOREACH_F64 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  | HWY_CONCAT(HWY_RVV_FOREACH_64, LMULS)(X_MACRO, float, f, NAME, OP)

## HWY_RVV_FOREACH_I

#define HWY_RVV_FOREACH_I | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  |

Value:
HWY_RVV_FOREACH_I08(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I16(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I32(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I64(X_MACRO, NAME, OP, LMULS)
HWY_RVV_FOREACH_I08
#define HWY_RVV_FOREACH_I08(X_MACRO, NAME, OP, LMULS)
Definition rvv-inl.h:297

## HWY_RVV_FOREACH_I08

#define HWY_RVV_FOREACH_I08 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  | HWY_CONCAT(HWY_RVV_FOREACH_08, LMULS)(X_MACRO, int, i, NAME, OP)

## HWY_RVV_FOREACH_I16

#define HWY_RVV_FOREACH_I16 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  | HWY_CONCAT(HWY_RVV_FOREACH_16, LMULS)(X_MACRO, int, i, NAME, OP)

## HWY_RVV_FOREACH_I163264

#define HWY_RVV_FOREACH_I163264 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  |

Value:
HWY_RVV_FOREACH_I16(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I32(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I64(X_MACRO, NAME, OP, LMULS)
HWY_RVV_FOREACH_I16
#define HWY_RVV_FOREACH_I16(X_MACRO, NAME, OP, LMULS)
Definition rvv-inl.h:299

## HWY_RVV_FOREACH_I32

#define HWY_RVV_FOREACH_I32 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  | HWY_CONCAT(HWY_RVV_FOREACH_32, LMULS)(X_MACRO, int, i, NAME, OP)

## HWY_RVV_FOREACH_I64

#define HWY_RVV_FOREACH_I64 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  | HWY_CONCAT(HWY_RVV_FOREACH_64, LMULS)(X_MACRO, int, i, NAME, OP)

## HWY_RVV_FOREACH_U

#define HWY_RVV_FOREACH_U | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  |

Value:
HWY_RVV_FOREACH_U08(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_U16(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_U32(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_U64(X_MACRO, NAME, OP, LMULS)
HWY_RVV_FOREACH_U08
#define HWY_RVV_FOREACH_U08(X_MACRO, NAME, OP, LMULS)
Definition rvv-inl.h:287

## HWY_RVV_FOREACH_U08

#define HWY_RVV_FOREACH_U08 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  | HWY_CONCAT(HWY_RVV_FOREACH_08, LMULS)(X_MACRO, uint, u, NAME, OP)

## HWY_RVV_FOREACH_U16

#define HWY_RVV_FOREACH_U16 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  | HWY_CONCAT(HWY_RVV_FOREACH_16, LMULS)(X_MACRO, uint, u, NAME, OP)

## HWY_RVV_FOREACH_U163264

#define HWY_RVV_FOREACH_U163264 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  |

Value:
HWY_RVV_FOREACH_U16(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_U32(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_U64(X_MACRO, NAME, OP, LMULS)
HWY_RVV_FOREACH_U16
#define HWY_RVV_FOREACH_U16(X_MACRO, NAME, OP, LMULS)
Definition rvv-inl.h:289

## HWY_RVV_FOREACH_U32

#define HWY_RVV_FOREACH_U32 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  | HWY_CONCAT(HWY_RVV_FOREACH_32, LMULS)(X_MACRO, uint, u, NAME, OP)

## HWY_RVV_FOREACH_U64

#define HWY_RVV_FOREACH_U64 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  | HWY_CONCAT(HWY_RVV_FOREACH_64, LMULS)(X_MACRO, uint, u, NAME, OP)

## HWY_RVV_FOREACH_UI

#define HWY_RVV_FOREACH_UI | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  |

Value:
HWY_RVV_FOREACH_U(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I(X_MACRO, NAME, OP, LMULS)

## HWY_RVV_FOREACH_UI08

#define HWY_RVV_FOREACH_UI08 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  |

Value:
HWY_RVV_FOREACH_U08(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I08(X_MACRO, NAME, OP, LMULS)

## HWY_RVV_FOREACH_UI16

#define HWY_RVV_FOREACH_UI16 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  |

Value:
HWY_RVV_FOREACH_U16(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I16(X_MACRO, NAME, OP, LMULS)

## HWY_RVV_FOREACH_UI163264

#define HWY_RVV_FOREACH_UI163264 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  |

Value:
HWY_RVV_FOREACH_U163264(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I163264(X_MACRO, NAME, OP, LMULS)
HWY_RVV_FOREACH_U163264
#define HWY_RVV_FOREACH_U163264(X_MACRO, NAME, OP, LMULS)
Definition rvv-inl.h:339

## HWY_RVV_FOREACH_UI32

#define HWY_RVV_FOREACH_UI32 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  |

Value:
HWY_RVV_FOREACH_U32(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I32(X_MACRO, NAME, OP, LMULS)
HWY_RVV_FOREACH_U32
#define HWY_RVV_FOREACH_U32(X_MACRO, NAME, OP, LMULS)
Definition rvv-inl.h:291

## HWY_RVV_FOREACH_UI3264

#define HWY_RVV_FOREACH_UI3264 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  |

Value:
HWY_RVV_FOREACH_UI32(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_UI64(X_MACRO, NAME, OP, LMULS)
HWY_RVV_FOREACH_UI32
#define HWY_RVV_FOREACH_UI32(X_MACRO, NAME, OP, LMULS)
Definition rvv-inl.h:327

## HWY_RVV_FOREACH_UI64

#define HWY_RVV_FOREACH_UI64 | ( |  | X_MACRO,
|  |  | NAME,
|  |  | OP,
|  |  | LMULS
| ) |  |

Value:
HWY_RVV_FOREACH_U64(X_MACRO, NAME, OP, LMULS) \
HWY_RVV_FOREACH_I64(X_MACRO, NAME, OP, LMULS)
HWY_RVV_FOREACH_U64
#define HWY_RVV_FOREACH_U64(X_MACRO, NAME, OP, LMULS)
Definition rvv-inl.h:293

## HWY_RVV_GATHER

#define HWY_RVV_GATHER | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
const HWY_RVV_T(BASE, SEW) * HWY_RESTRICT base, \
HWY_RVV_V(int, SEW, LMUL) offset) { \
return v##OP##ei##SEW##_v_##CHAR##SEW##LMUL( \
base, detail::BitCastToUnsigned(offset), Lanes(d)); \
}

## HWY_RVV_GET_LANE

#define HWY_RVV_GET_LANE | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_T(BASE, SEW) NAME(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_s_##CHAR##SEW##LMUL##_##CHAR##SEW(v); /* no AVL */ \
}

## HWY_RVV_IF_POW2_IN

#define HWY_RVV_IF_POW2_IN | ( |  | D,
|  |  | min,
|  |  | max
| ) |  | hwy::EnableIf<(min) <= Pow2(D()) && Pow2(D()) <= (max)>* = nullptr

## HWY_RVV_IF_THEN_ELSE

#define HWY_RVV_IF_THEN_ELSE | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_M(MLEN) m, HWY_RVV_V(BASE, SEW, LMUL) yes, \
HWY_RVV_V(BASE, SEW, LMUL) no) { \
return v##OP##_vvm_##CHAR##SEW##LMUL(no, yes, m, HWY_RVV_AVL(SEW, SHIFT)); \
}

## HWY_RVV_IF_THEN_ZERO_ELSE

#define HWY_RVV_IF_THEN_ZERO_ELSE | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_M(MLEN) m, HWY_RVV_V(BASE, SEW, LMUL) no) { \
return v##OP##_##CHAR##SEW##LMUL(no, 0, m, HWY_RVV_AVL(SEW, SHIFT)); \
}

## HWY_RVV_IOTA

#define HWY_RVV_IOTA | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) NAME(HWY_RVV_D(BASE, SEW, N, SHIFT) d) { \
return v##OP##_##CHAR##SEW##LMUL(Lanes(d)); \
}

## HWY_RVV_LANES

#define HWY_RVV_LANES | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API size_t NAME(HWY_RVV_D(BASE, SEW, N, SHIFT) d) { \
size_t actual = v##OP##SEW##LMUL(); \
/* Common case of full vectors: avoid any extra instructions. */ \
/* actual includes LMUL, so do not shift again. */ \
if (detail::IsFull(d)) return actual; \
/* Check for virtual LMUL, e.g. "uint16mf8_t" (not provided by */ \
/* intrinsics). In this case the actual LMUL is 1/4, so divide by */ \
/* another factor of two. */ \
if (detail::ScaleByPower(128 / SEW, SHIFT) == 1) actual >>= 1; \
return HWY_MIN(actual, N); \
}
HWY_MIN
#define HWY_MIN(a, b)
Definition base.h:134

## HWY_RVV_LOAD

#define HWY_RVV_LOAD | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
const HWY_RVV_T(BASE, SEW) * HWY_RESTRICT p) { \
return v##OP##SEW##_v_##CHAR##SEW##LMUL(p, Lanes(d)); \
}

## HWY_RVV_LOAD2

#define HWY_RVV_LOAD2 | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API void NAME(HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
const HWY_RVV_T(BASE, SEW) * HWY_RESTRICT unaligned, \
HWY_RVV_V(BASE, SEW, LMUL) & v0, \
HWY_RVV_V(BASE, SEW, LMUL) & v1) { \
v##OP##e##SEW##_v_##CHAR##SEW##LMUL(&v0, &v1, unaligned, Lanes(d)); \
}

## HWY_RVV_LOAD3

#define HWY_RVV_LOAD3 | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API void NAME(HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
const HWY_RVV_T(BASE, SEW) * HWY_RESTRICT unaligned, \
HWY_RVV_V(BASE, SEW, LMUL) & v0, \
HWY_RVV_V(BASE, SEW, LMUL) & v1, \
HWY_RVV_V(BASE, SEW, LMUL) & v2) { \
v##OP##e##SEW##_v_##CHAR##SEW##LMUL(&v0, &v1, &v2, unaligned, Lanes(d)); \
}

## HWY_RVV_LOAD4

#define HWY_RVV_LOAD4 | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API void NAME( \
HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
const HWY_RVV_T(BASE, SEW) * HWY_RESTRICT aligned, \
HWY_RVV_V(BASE, SEW, LMUL) & v0, HWY_RVV_V(BASE, SEW, LMUL) & v1, \
HWY_RVV_V(BASE, SEW, LMUL) & v2, HWY_RVV_V(BASE, SEW, LMUL) & v3) { \
v##OP##e##SEW##_v_##CHAR##SEW##LMUL(&v0, &v1, &v2, &v3, aligned, \
Lanes(d)); \
}

## HWY_RVV_LOAD_MASK_BITS

#define HWY_RVV_LOAD_MASK_BITS | ( |  | SEW,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_INLINE HWY_RVV_M(MLEN) \
NAME(hwy::SizeTag<MLEN> /* tag */, const uint8_t* bits, size_t N) { \
return OP##_v_b##MLEN(bits, N); \
}
HWY_INLINE
#define HWY_INLINE
Definition base.h:70
hwy::SizeTag
Definition base.h:435

## HWY_RVV_M

#define HWY_RVV_M | ( |  | MLEN | ) | vbool##MLEN##_t

## HWY_RVV_MASKED_LOAD

#define HWY_RVV_MASKED_LOAD | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_M(MLEN) m, HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
const HWY_RVV_T(BASE, SEW) * HWY_RESTRICT p) { \
return v##OP##SEW##_v_##CHAR##SEW##LMUL##_m(m, Zero(d), p, Lanes(d)); \
}

## HWY_RVV_NEAREST

#define HWY_RVV_NEAREST | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_V(int, SEW, LMUL) NearestInt(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return vfcvt_x_f_v_i##SEW##LMUL(v, HWY_RVV_AVL(SEW, SHIFT)); \
}

## HWY_RVV_PROMOTE [1/2]

#define HWY_RVV_PROMOTE | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEWD, LMULD) NAME( \
HWY_RVV_D(BASE, SEWD, N, SHIFT + 1) d, HWY_RVV_V(BASE, SEW, LMUL) v) { \
return OP##CHAR##SEWD##LMULD(v, Lanes(d)); \
}

## HWY_RVV_PROMOTE [2/2]

#define HWY_RVV_PROMOTE | ( |  | OP,
|  |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | BASE_IN,
|  |  | BITS_IN,
|  |  | LMUL,
|  |  | LMUL_IN,
|  |  | SHIFT,
|  |  | ADD
| ) |  |

Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, BITS, LMUL) \
PromoteTo(HWY_RVV_D(BASE, BITS, N, SHIFT + ADD) d, \
HWY_RVV_V(BASE_IN, BITS_IN, LMUL_IN) v) { \
return OP##CHAR##BITS##LMUL(v, Lanes(d)); \
}

## HWY_RVV_PROMOTE_X2

#define HWY_RVV_PROMOTE_X2 | ( |  | OP,
|  |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | BASE_IN,
|  |  | BITS_IN
| ) |  |

Value:
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m1, mf2, -2, 1) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m1, mf2, -1, 1) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m2, m1, 0, 1) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m4, m2, 1, 1) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m8, m4, 2, 1)
HWY_RVV_PROMOTE
#define HWY_RVV_PROMOTE(BASE, CHAR, SEW, SEWD, SEWH, LMUL, LMULD, LMULH, SHIFT, MLEN, NAME, OP)
Definition rvv-inl.h:1545

## HWY_RVV_PROMOTE_X4

#define HWY_RVV_PROMOTE_X4 | ( |  | OP,
|  |  | BASE,
|  |  | CHAR,
|  |  | BITS,
|  |  | BASE_IN,
|  |  | BITS_IN
| ) |  |

Value:
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, mf2, mf8, -3, 2) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m1, mf4, -2, 2) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m2, mf2, -1, 2) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m4, m1, 0, 2) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m8, m2, 1, 2)

## HWY_RVV_REDUCE

#define HWY_RVV_REDUCE | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <class D> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(D d, HWY_RVV_V(BASE, SEW, LMUL) v, HWY_RVV_V(BASE, SEW, m1) v0) { \
return Set(d, GetLane(v##OP##_vs_##CHAR##SEW##LMUL##_##CHAR##SEW##m1( \
v0, v, v0, Lanes(d)))); \
}

## HWY_RVV_RETM_ARGM

#define HWY_RVV_RETM_ARGM | ( |  | SEW,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_M(MLEN) NAME(HWY_RVV_M(MLEN) m) { \
return vm##OP##_m_b##MLEN(m, ~0ull); \
}

## HWY_RVV_RETM_ARGMM

#define HWY_RVV_RETM_ARGMM | ( |  | SEW,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_M(MLEN) NAME(HWY_RVV_M(MLEN) a, HWY_RVV_M(MLEN) b) { \
return vm##OP##_mm_b##MLEN(b, a, HWY_RVV_AVL(SEW, SHIFT)); \
}

## HWY_RVV_RETM_ARGVS

#define HWY_RVV_RETM_ARGVS | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_M(MLEN) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) a, HWY_RVV_T(BASE, SEW) b) { \
return v##OP##_##CHAR##SEW##LMUL##_b##MLEN(a, b, HWY_RVV_AVL(SEW, SHIFT)); \
}

## HWY_RVV_RETM_ARGVV

#define HWY_RVV_RETM_ARGVV | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_M(MLEN) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) a, HWY_RVV_V(BASE, SEW, LMUL) b) { \
return v##OP##_vv_##CHAR##SEW##LMUL##_b##MLEN(a, b, \
HWY_RVV_AVL(SEW, SHIFT)); \
}

## HWY_RVV_RETV_ARGV

#define HWY_RVV_RETV_ARGV | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) NAME(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_v_##CHAR##SEW##LMUL(v, HWY_RVV_AVL(SEW, SHIFT)); \
}

## HWY_RVV_RETV_ARGV2

#define HWY_RVV_RETV_ARGV2 | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) NAME(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_vv_##CHAR##SEW##LMUL(v, v, HWY_RVV_AVL(SEW, SHIFT)); \
}

## HWY_RVV_RETV_ARGVS

#define HWY_RVV_RETV_ARGVS | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) a, HWY_RVV_T(BASE, SEW) b) { \
return v##OP##_##CHAR##SEW##LMUL(a, b, HWY_RVV_AVL(SEW, SHIFT)); \
}

## HWY_RVV_RETV_ARGVV

#define HWY_RVV_RETV_ARGVV | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) a, HWY_RVV_V(BASE, SEW, LMUL) b) { \
return v##OP##_vv_##CHAR##SEW##LMUL(a, b, HWY_RVV_AVL(SEW, SHIFT)); \
}

## HWY_RVV_SCATTER

#define HWY_RVV_SCATTER | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API void NAME(HWY_RVV_V(BASE, SEW, LMUL) v, \
HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
HWY_RVV_T(BASE, SEW) * HWY_RESTRICT base, \
HWY_RVV_V(int, SEW, LMUL) offset) { \
return v##OP##ei##SEW##_v_##CHAR##SEW##LMUL( \
base, detail::BitCastToUnsigned(offset), v, Lanes(d)); \
}

## HWY_RVV_SET

#define HWY_RVV_SET | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_D(BASE, SEW, N, SHIFT) d, HWY_RVV_T(BASE, SEW) arg) { \
return v##OP##_##CHAR##SEW##LMUL(arg, Lanes(d)); \
}

## HWY_RVV_SHIFT

#define HWY_RVV_SHIFT | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <int kBits> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) NAME(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_vx_##CHAR##SEW##LMUL(v, kBits, HWY_RVV_AVL(SEW, SHIFT)); \
} \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME##Same(HWY_RVV_V(BASE, SEW, LMUL) v, int bits) { \
return v##OP##_vx_##CHAR##SEW##LMUL(v, static_cast<uint8_t>(bits), \
HWY_RVV_AVL(SEW, SHIFT)); \
}

## HWY_RVV_SHIFT_II

#define HWY_RVV_SHIFT_II | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) v, HWY_RVV_V(BASE, SEW, LMUL) bits) { \
return v##OP##_vv_##CHAR##SEW##LMUL(v, detail::BitCastToUnsigned(bits), \
HWY_RVV_AVL(SEW, SHIFT)); \
}

## HWY_RVV_SHIFT_VV

#define HWY_RVV_SHIFT_VV | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) v, HWY_RVV_V(BASE, SEW, LMUL) bits) { \
return v##OP##_vv_##CHAR##SEW##LMUL(v, bits, HWY_RVV_AVL(SEW, SHIFT)); \
}

## HWY_RVV_SLIDE

#define HWY_RVV_SLIDE | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) dst, HWY_RVV_V(BASE, SEW, LMUL) src, \
size_t lanes) { \
return v##OP##_vx_##CHAR##SEW##LMUL(dst, src, lanes, \
HWY_RVV_AVL(SEW, SHIFT)); \
}

## HWY_RVV_SLIDE1

#define HWY_RVV_SLIDE1 | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) NAME(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_##CHAR##SEW##LMUL(v, 0, HWY_RVV_AVL(SEW, SHIFT)); \
}

## HWY_RVV_STORE

#define HWY_RVV_STORE | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API void NAME(HWY_RVV_V(BASE, SEW, LMUL) v, \
HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
HWY_RVV_T(BASE, SEW) * HWY_RESTRICT p) { \
return v##OP##SEW##_v_##CHAR##SEW##LMUL(p, v, Lanes(d)); \
}

## HWY_RVV_STORE2

#define HWY_RVV_STORE2 | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API void NAME(HWY_RVV_V(BASE, SEW, LMUL) v0, \
HWY_RVV_V(BASE, SEW, LMUL) v1, \
HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
HWY_RVV_T(BASE, SEW) * HWY_RESTRICT unaligned) { \
v##OP##e##SEW##_v_##CHAR##SEW##LMUL(unaligned, v0, v1, Lanes(d)); \
}

## HWY_RVV_STORE3

#define HWY_RVV_STORE3 | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API void NAME( \
HWY_RVV_V(BASE, SEW, LMUL) v0, HWY_RVV_V(BASE, SEW, LMUL) v1, \
HWY_RVV_V(BASE, SEW, LMUL) v2, HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
HWY_RVV_T(BASE, SEW) * HWY_RESTRICT unaligned) { \
v##OP##e##SEW##_v_##CHAR##SEW##LMUL(unaligned, v0, v1, v2, Lanes(d)); \
}

## HWY_RVV_STORE4

#define HWY_RVV_STORE4 | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API void NAME( \
HWY_RVV_V(BASE, SEW, LMUL) v0, HWY_RVV_V(BASE, SEW, LMUL) v1, \
HWY_RVV_V(BASE, SEW, LMUL) v2, HWY_RVV_V(BASE, SEW, LMUL) v3, \
HWY_RVV_D(BASE, SEW, N, SHIFT) d, \
HWY_RVV_T(BASE, SEW) * HWY_RESTRICT aligned) { \
v##OP##e##SEW##_v_##CHAR##SEW##LMUL(aligned, v0, v1, v2, v3, Lanes(d)); \
}

## HWY_RVV_STORE_MASK_BITS

#define HWY_RVV_STORE_MASK_BITS | ( |  | SEW,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <class D> \
HWY_API size_t NAME(D d, HWY_RVV_M(MLEN) m, uint8_t* bits) { \
const size_t N = Lanes(d); \
OP##_v_b##MLEN(bits, m, N); \
/* Non-full byte, need to clear the undefined upper bits. */ \
/* Use MaxLanes and sizeof(T) to move some checks to compile-time. */ \
constexpr bool kLessThan8 = \
detail::ScaleByPower(16 / sizeof(TFromD<D>), Pow2(d)) < 8; \
if (MaxLanes(d) < 8 || (kLessThan8 && N < 8)) { \
const int mask = (1 << N) - 1; \
bits[0] = static_cast<uint8_t>(bits[0] & mask); \
} \
return (N + 7) / 8; \
}

## HWY_RVV_STOREN

#define HWY_RVV_STOREN | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API void NAME(size_t count, HWY_RVV_V(BASE, SEW, LMUL) v, \
HWY_RVV_D(BASE, SEW, N, SHIFT) /* d */, \
HWY_RVV_T(BASE, SEW) * HWY_RESTRICT p) { \
return v##OP##SEW##_v_##CHAR##SEW##LMUL(p, v, count); \
}

## HWY_RVV_T

#define HWY_RVV_T | ( |  | BASE,
|  |  | SEW
| ) |  | BASE##SEW##_t

## HWY_RVV_TABLE

#define HWY_RVV_TABLE | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) v, HWY_RVV_V(uint, SEW, LMUL) idx) { \
return v##OP##_vv_##CHAR##SEW##LMUL(v, idx, HWY_RVV_AVL(SEW, SHIFT)); \
}

## HWY_RVV_TRUNC

#define HWY_RVV_TRUNC | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_V(BASE, SEW, LMULH) NAME(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_v_##CHAR##SEW##LMUL##_##CHAR##SEW##LMULH(v); /* no AVL */ \
}

## HWY_RVV_UNDEFINED

#define HWY_RVV_UNDEFINED | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_D(BASE, SEW, N, SHIFT) /* tag */) { \
return v##OP##_##CHAR##SEW##LMUL(); /* no AVL */ \
}

## HWY_RVV_V

#define HWY_RVV_V | ( |  | BASE,
|  |  | SEW,
|  |  | LMUL
| ) |  | v##BASE##SEW##LMUL##_t

## HWY_RVV_VEC_FROM_MASK

#define HWY_RVV_VEC_FROM_MASK | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) v0, HWY_RVV_M(MLEN) m) { \
return v##OP##_##CHAR##SEW##LMUL##_m(m, v0, v0, 1, \
HWY_RVV_AVL(SEW, SHIFT)); \
}

## HWY_RVV_WIDEN_MACC

#define HWY_RVV_WIDEN_MACC | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <size_t N> \
HWY_API HWY_RVV_V(BASE, SEWD, LMULD) NAME( \
HWY_RVV_D(BASE, SEWD, N, SHIFT + 1) d, HWY_RVV_V(BASE, SEWD, LMULD) sum, \
HWY_RVV_V(BASE, SEW, LMUL) a, HWY_RVV_V(BASE, SEW, LMUL) b) { \
return OP##CHAR##SEWD##LMULD(sum, a, b, Lanes(d)); \
}

## HWY_SPECIALIZE

#define HWY_SPECIALIZE | ( |  | BASE,
|  |  | CHAR,
|  |  | SEW,
|  |  | SEWD,
|  |  | SEWH,
|  |  | LMUL,
|  |  | LMULD,
|  |  | LMULH,
|  |  | SHIFT,
|  |  | MLEN,
|  |  | NAME,
|  |  | OP
| ) |  |

Value:
template <> \
struct DFromV_t<HWY_RVV_V(BASE, SEW, LMUL)> { \
using Lane = HWY_RVV_T(BASE, SEW); \
using type = ScalableTag<Lane, SHIFT>; \
};

## Function Documentation

## HWY_AFTER_NAMESPACE()

HWY_AFTER_NAMESPACE | ( |  | ) |

## HWY_BEFORE_NAMESPACE()

HWY_BEFORE_NAMESPACE | ( |  | ) |