下次自动登录
现在的位置:
& 综合 & 正文
Neon Intrinsics各函数介绍
#ifndef __ARM_NEON__
#error You must enable NEON instructions (e.g. -mfloat-abi=softfp -mfpu=neon) to use arm_neon.h
/*(1)、正常指令：生成大小相同且类型通常与操作数向量相同的结果向量；
(2)、长指令：对双字向量操作数执行运算，生成四字向量的结果。所生成的元素一般是操作数元素宽度的两倍，
并属于同一类型；
(3)、宽指令：一个双字向量操作数和一个四字向量操作数执行运算，生成四字向量结果。所生成的元素和第一个
操作数的元素是第二个操作数元素宽度的两倍；
(4)、窄指令：四字向量操作数执行运算，并生成双字向量结果，所生成的元素一般是操作数元素宽度的一半；
(5)、饱和指令：当超过数据类型指定的范围则自动限制在该范围内。*/
/******************************************************Addition*************************/
/*--1、Vector add(正常指令): vadd -& ri = ai + r, a, b have equal lane sizes--*/
int8x8_t vadd_s8 (int8x8_t __a, int8x8_t __b);//_mm_add_epi8
int16x4_t vadd_s16 (int16x4_t __a, int16x4_t __b);//_mm_add_epi16
int32x2_t vadd_s32 (int32x2_t __a, int32x2_t __b);//_mm_add_epi32
int64x1_t vadd_s64 (int64x1_t __a, int64x1_t __b);//_mm_add_epi64
//_mm_add_ps, SSE, use only low 64 bits
float32x2_t vadd_f32 (float32x2_t __a, float32x2_t __b);
uint8x8_t vadd_u8 (uint8x8_t __a, uint8x8_t __b);//_mm_add_epi8
uint16x4_t vadd_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_add_epi16
uint32x2_t vadd_u32 (uint32x2_t __a, uint32x2_t __b);//_mm_add_epi32
uint64x1_t vadd_u64 (uint64x1_t __a, uint64x1_t __b);//_mm_add_epi64
int8x16_t vaddq_s8 (int8x16_t __a, int8x16_t __b);//_mm_add_epi8
int16x8_t vaddq_s16 (int16x8_t __a, int16x8_t __b);//_mm_add_epi16
int32x4_t vaddq_s32 (int32x4_t __a, int32x4_t __b);//_mm_add_epi32
int64x2_t vaddq_s64 (int64x2_t __a, int64x2_t __b);//_mm_add_epi64
float32x4_t vaddq_f32 (float32x4_t __a, float32x4_t __b);//_mm_add_ps
uint8x16_t vaddq_u8 (uint8x16_t __a, uint8x16_t __b);//_mm_add_epi8
uint16x8_t vaddq_u16 (uint16x8_t __a, uint16x8_t __b);//_mm_add_epi16
uint32x4_t vaddq_u32 (uint32x4_t __a, uint32x4_t __b);//_mm_add_epi32
uint64x2_t vaddq_u64 (uint64x2_t __a, uint64x2_t __b);//_mm_add_epi64
/*--2、Vector long add(长指令): vaddl -& ri = ai + a, b have equal lane sizes,
result is a 128 bit vector of lanes that are twice the width--*/
int16x8_t vaddl_s8 (int8x8_t __a, int8x8_t __b);
int32x4_t vaddl_s16 (int16x4_t __a, int16x4_t __b);
int64x2_t vaddl_s32 (int32x2_t __a, int32x2_t __b);
uint16x8_t vaddl_u8 (uint8x8_t __a, uint8x8_t __b);
uint32x4_t vaddl_u16 (uint16x4_t __a, uint16x4_t __b);
uint64x2_t vaddl_u32 (uint32x2_t __a, uint32x2_t __b);
/*--3、Vector wide add(宽指令): vaddw -& ri = ai + bi--*/
int16x8_t vaddw_s8 (int16x8_t __a, int8x8_t __b);
int32x4_t vaddw_s16 (int32x4_t __a, int16x4_t __b);
int64x2_t vaddw_s32 (int64x2_t __a, int32x2_t __b);
uint16x8_t vaddw_u8 (uint16x8_t __a, uint8x8_t __b);
uint32x4_t vaddw_u16 (uint32x4_t __a, uint16x4_t __b);
uint64x2_t vaddw_u32 (uint64x2_t __a, uint32x2_t __b);
/*--4、Vector halving add: vhadd -& ri = (ai + bi) && 1;
shifts each result right one bit, Results are truncated--*/
int8x8_t vhadd_s8 (int8x8_t __a, int8x8_t __b);
int16x4_t vhadd_s16 (int16x4_t __a, int16x4_t __b);
int32x2_t vhadd_s32 (int32x2_t __a, int32x2_t __b);
uint8x8_t vhadd_u8 (uint8x8_t __a, uint8x8_t __b);
uint16x4_t vhadd_u16 (uint16x4_t __a, uint16x4_t __b);
uint32x2_t vhadd_u32 (uint32x2_t __a, uint32x2_t __b);
int8x16_t vhaddq_s8 (int8x16_t __a, int8x16_t __b);
int16x8_t vhaddq_s16 (int16x8_t __a, int16x8_t __b)
int32x4_t vhaddq_s32 (int32x4_t __a, int32x4_t __b)
uint8x16_t vhaddq_u8 (uint8x16_t __a, uint8x16_t __b)
uint16x8_t vhaddq_u16 (uint16x8_t __a, uint16x8_t __b)
uint32x4_t vhaddq_u32 (uint32x4_t __a, uint32x4_t __b);
/*--5、Vector rounding halving add: vrhadd -& ri = (ai + bi + 1) && 1;
shifts each result right one bit, Results are rounded(四舍五入)--*/
int8x8_t vrhadd_s8 (int8x8_t __a, int8x8_t __b);
int16x4_t vrhadd_s16 (int16x4_t __a, int16x4_t __b);
int32x2_t vrhadd_s32 (int32x2_t __a, int32x2_t __b);
uint8x8_t vrhadd_u8 (uint8x8_t __a, uint8x8_t __b);//_mm_avg_epu8
uint16x4_t vrhadd_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_avg_epu16
uint32x2_t vrhadd_u32 (uint32x2_t __a, uint32x2_t __b);
int8x16_t vrhaddq_s8 (int8x16_t __a, int8x16_t __b);
int16x8_t vrhaddq_s16 (int16x8_t __a, int16x8_t __b);
int32x4_t vrhaddq_s32 (int32x4_t __a, int32x4_t __b);
uint8x16_t vrhaddq_u8 (uint8x16_t __a, uint8x16_t __b);//_mm_avg_epu8
uint16x8_t vrhaddq_u16 (uint16x8_t __a, uint16x8_t __b);//_mm_avg_epu16
uint32x4_t vrhaddq_u32 (uint32x4_t __a, uint32x4_t __b);
/*--6、Vector saturating add(饱和指令): vqadd -& ri = sat(ai + bi);
the results are saturated if they overflow--*/
int8x8_t vqadd_s8 (int8x8_t __a, int8x8_t __b);//_mm_adds_epi8
int16x4_t vqadd_s16 (int16x4_t __a, int16x4_t __b);//_mm_adds_epi16
int32x2_t vqadd_s32 (int32x2_t __a, int32x2_t __b);
int64x1_t vqadd_s64 (int64x1_t __a, int64x1_t __b);
uint8x8_t vqadd_u8 (uint8x8_t __a, uint8x8_t __b);//_mm_adds_epu8
uint16x4_t vqadd_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_adds_epu16
uint32x2_t vqadd_u32 (uint32x2_t __a, uint32x2_t __b);
uint64x1_t vqadd_u64 (uint64x1_t __a, uint64x1_t __b);
int8x16_t vqaddq_s8 (int8x16_t __a, int8x16_t __b);//_mm_adds_epi8
int16x8_t vqaddq_s16 (int16x8_t __a, int16x8_t __b);//_mm_adds_epi16
int32x4_t vqaddq_s32 (int32x4_t __a, int32x4_t __b);
int64x2_t vqaddq_s64 (int64x2_t __a, int64x2_t __b);
uint8x16_t vqaddq_u8 (uint8x16_t __a, uint8x16_t __b);//_mm_adds_epu8
uint16x8_t vqaddq_u16 (uint16x8_t __a, uint16x8_t __b);//_mm_adds_epu16
uint32x4_t vqaddq_u32 (uint32x4_t __a, uint32x4_t __b);
uint64x2_t vqaddq_u64 (uint64x2_t __a, uint64x2_t __b);
/*--7、Vector add high half(窄指令): vaddhn -& ri = sat(ai + bi);
selecting High half, The results are truncated--*/
int8x8_t vaddhn_s16 (int16x8_t __a, int16x8_t __b);
int16x4_t vaddhn_s32 (int32x4_t __a, int32x4_t __b);
int32x2_t vaddhn_s64 (int64x2_t __a, int64x2_t __b);
uint8x8_t vaddhn_u16 (uint16x8_t __a, uint16x8_t __b);
uint16x4_t vaddhn_u32 (uint32x4_t __a, uint32x4_t __b);
uint32x2_t vaddhn_u64 (uint64x2_t __a, uint64x2_t __b);
/*--8、Vector rounding add high half(窄指令): vraddhn -& ri = ai +
selecting High half, The results are rounded--*/
int8x8_t vraddhn_s16 (int16x8_t __a, int16x8_t __b);
int16x4_t vraddhn_s32 (int32x4_t __a, int32x4_t __b)
int32x2_t vraddhn_s64 (int64x2_t __a, int64x2_t __b)
uint8x8_t vraddhn_u16 (uint16x8_t __a, uint16x8_t __b)
uint16x4_t vraddhn_u32 (uint32x4_t __a, uint32x4_t __b)
uint32x2_t vraddhn_u64 (uint64x2_t __a, uint64x2_t __b);
/*******************************************Multiplication******************************/
/*--1、Vector multiply(正常指令): vmul -& ri = ai *--*/
int8x8_t vmul_s8 (int8x8_t __a, int8x8_t __b);
int16x4_t vmul_s16 (int16x4_t __a, int16x4_t __b);//_mm_mullo_epi16
int32x2_t vmul_s32 (int32x2_t __a, int32x2_t __b);
float32x2_t vmul_f32 (float32x2_t __a, float32x2_t __b);//_mm_mul_ps
uint8x8_t vmul_u8 (uint8x8_t __a, uint8x8_t __b);
uint16x4_t vmul_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_mullo_epi16
uint32x2_t vmul_u32 (uint32x2_t __a, uint32x2_t __b);
poly8x8_t vmul_p8 (poly8x8_t __a, poly8x8_t __b);
int8x16_t vmulq_s8 (int8x16_t __a, int8x16_t __b);
int16x8_t vmulq_s16 (int16x8_t __a, int16x8_t __b);//_mm_mullo_epi16
int32x4_t vmulq_s32 (int32x4_t __a, int32x4_t __b);
float32x4_t vmulq_f32 (float32x4_t __a, float32x4_t __b);//_mm_mul_ps
uint8x16_t vmulq_u8 (uint8x16_t __a, uint8x16_t __b);
uint16x8_t vmulq_u16 (uint16x8_t __a, uint16x8_t __b);//_mm_mullo_epi16
uint32x4_t vmulq_u32 (uint32x4_t __a, uint32x4_t __b);
poly8x16_t vmulq_p8 (poly8x16_t __a, poly8x16_t __b);
/*--2、Vector multiply accumulate: vmla -& ri = ai + bi * --*/
int8x8_t vmla_s8 (int8x8_t __a, int8x8_t __b, int8x8_t __c);
int16x4_t vmla_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c);
int32x2_t vmla_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c);
float32x2_t vmla_f32 (float32x2_t __a, float32x2_t __b, float32x2_t __c);
uint8x8_t vmla_u8 (uint8x8_t __a, uint8x8_t __b, uint8x8_t __c);
uint16x4_t vmla_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c);
uint32x2_t vmla_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c);
int8x16_t vmlaq_s8 (int8x16_t __a, int8x16_t __b, int8x16_t __c);
int16x8_t vmlaq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c);
int32x4_t vmlaq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c);
float32x4_t vmlaq_f32 (float32x4_t __a, float32x4_t __b, float32x4_t __c);
uint8x16_t vmlaq_u8 (uint8x16_t __a, uint8x16_t __b, uint8x16_t __c);
uint16x8_t vmlaq_u16 (uint16x8_t __a, uint16x8_t __b, uint16x8_t __c);
uint32x4_t vmlaq_u32 (uint32x4_t __a, uint32x4_t __b, uint32x4_t __c);
/*--3、Vector multiply accumulate long: vmlal -& ri = ai + bi * ci --*/
int16x8_t vmlal_s8 (int16x8_t __a, int8x8_t __b, int8x8_t __c);
int32x4_t vmlal_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c);
int64x2_t vmlal_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c);
uint16x8_t vmlal_u8 (uint16x8_t __a, uint8x8_t __b, uint8x8_t __c);
uint32x4_t vmlal_u16 (uint32x4_t __a, uint16x4_t __b, uint16x4_t __c);
uint64x2_t vmlal_u32 (uint64x2_t __a, uint32x2_t __b, uint32x2_t __c);
/*--4、Vector multiply subtract: vmls -& ri = ai - bi * ci --*/
int8x8_t vmls_s8 (int8x8_t __a, int8x8_t __b, int8x8_t __c);
int16x4_t vmls_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c);
int32x2_t vmls_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c);
float32x2_t vmls_f32 (float32x2_t __a, float32x2_t __b, float32x2_t __c);
uint8x8_t vmls_u8 (uint8x8_t __a, uint8x8_t __b, uint8x8_t __c);
uint16x4_t vmls_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c);
uint32x2_t vmls_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c);
int8x16_t vmlsq_s8 (int8x16_t __a, int8x16_t __b, int8x16_t __c);
int16x8_t vmlsq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c);
int32x4_t vmlsq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c);
float32x4_t vmlsq_f32 (float32x4_t __a, float32x4_t __b, float32x4_t __c);
uint8x16_t vmlsq_u8 (uint8x16_t __a, uint8x16_t __b, uint8x16_t __c);
uint16x8_t vmlsq_u16 (uint16x8_t __a, uint16x8_t __b, uint16x8_t __c);
uint32x4_t vmlsq_u32 (uint32x4_t __a, uint32x4_t __b, uint32x4_t __c);
/*--5、Vector multiply subtract long：vmlsl -& ri = ai - bi * ci --*/
int16x8_t vmlsl_s8 (int16x8_t __a, int8x8_t __b, int8x8_t __c);
int32x4_t vmlsl_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c);
int64x2_t vmlsl_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c);
uint16x8_t vmlsl_u8 (uint16x8_t __a, uint8x8_t __b, uint8x8_t __c);
uint32x4_t vmlsl_u16 (uint32x4_t __a, uint16x4_t __b, uint16x4_t __c);
uint64x2_t vmlsl_u32 (uint64x2_t __a, uint32x2_t __b, uint32x2_t __c);
/*--6、Vector saturating doubling multiply high: vqdmulh -& ri = sat(ai * bi);
doubles the results and returns only the high half of the truncated results--*/
int16x4_t vqdmulh_s16 (int16x4_t __a, int16x4_t __b);
int32x2_t vqdmulh_s32 (int32x2_t __a, int32x2_t __b);
int16x8_t vqdmulhq_s16 (int16x8_t __a, int16x8_t __b);
int32x4_t vqdmulhq_s32 (int32x4_t __a, int32x4_t __b);
/*--7、Vector saturating rounding doubling multiply high vqrdmulh -& ri = ai * bi:
doubles the results and returns only the high half of the rounded results.
The results are saturated if they overflow--*/
int16x4_t vqrdmulh_s16 (int16x4_t __a, int16x4_t __b);
int32x2_t vqrdmulh_s32 (int32x2_t __a, int32x2_t __b);
int16x8_t vqrdmulhq_s16 (int16x8_t __a, int16x8_t __b);
int32x4_t vqrdmulhq_s32 (int32x4_t __a, int32x4_t __b);
/*--8、Vector saturating doubling multiply accumulate long: vqdmlal -& ri = ai + bi *
multiplies the elements in the second and third vectors, doubles the results and adds the
results to the values in the first vector. The results are saturated if they overflow--*/
int32x4_t vqdmlal_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c);
vqdmlal_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c);
/*--9、Vector saturating doubling multiply subtract long: vqdmlsl -& ri = ai - bi *
multiplies the elements in the second and third vectors, doubles the results and subtracts
the results from the elements in the first vector.
The results are saturated if they overflow--*/
int32x4_t vqdmlsl_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c);
int64x2_t vqdmlsl_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c);
/*--10、Vector long multiply(长指令): vmull -& ri = ai *--*/
int16x8_t vmull_s8 (int8x8_t __a, int8x8_t __b);
int32x4_t vmull_s16 (int16x4_t __a, int16x4_t __b);
int64x2_t vmull_s32 (int32x2_t __a, int32x2_t __b);
uint16x8_t vmull_u8 (uint8x8_t __a, uint8x8_t __b);
uint32x4_t vmull_u16 (uint16x4_t __a, uint16x4_t __b);
uint64x2_t vmull_u32 (uint32x2_t __a, uint32x2_t __b);
poly16x8_t vmull_p8 (poly8x8_t __a, poly8x8_t __b);
/*--11、Vector saturating doubling long multiply: vqdmull -& ri = ai *
If any of the results overflow, they are saturated--*/
int32x4_t vqdmull_s16 (int16x4_t __a, int16x4_t __b);
int64x2_t vqdmull_s32 (int32x2_t __a, int32x2_t __b);
/*--12、Fused multiply accumulate: vfma -& ri = ai + bi *
The result of the multiply is not rounded before the accumulation--*/
float32x2_t vfma_f32 (float32x2_t __a, float32x2_t __b, float32x2_t __c)
float32x4_t vfmaq_f32 (float32x4_t __a, float32x4_t __b, float32x4_t __c);
/*--13、Fused multiply subtract: vfms -& ri = ai - bi *
The result of the multiply is not rounded before the subtraction--*/
float32x2_t vfms_f32 (float32x2_t __a, float32x2_t __b, float32x2_t __c);
float32x4_t vfmsq_f32 (float32x4_t __a, float32x4_t __b, float32x4_t __c);
/******************************************************Round to integral****************/
/*--1、to nearest, ties to even--*/
float32x2_t vrndn_f32 (float32x2_t __a);
float32x4_t vrndqn_f32 (float32x4_t __a);
/*--2、to nearest, ties away from zero--*/
float32x2_t vrnda_f32 (float32x2_t __a);
float32x4_t vrndqa_f32 (float32x4_t __a);
/*--3、towards +Inf--*/
float32x2_t vrndp_f32 (float32x2_t __a);
float32x4_t vrndqp_f32 (float32x4_t __a);
/*--4、towards -Inf--*/
float32x2_t vrndm_f32 (float32x2_t __a);
float32x4_t vrndqm_f32 (float32x4_t __a);
/*--5、towards 0--*/
float32x2_t vrnd_f32 (float32x2_t __a);
float32x4_t vrndq_f32 (float32x4_t __a);
/**********************************************Subtraction******************************/
/*--1、Vector subtract(正常指令):vsub -& ri = ai ---*/
int8x8_t vsub_s8 (int8x8_t __a, int8x8_t __b);//_mm_sub_epi8
int16x4_t vsub_s16 (int16x4_t __a, int16x4_t __b);//_mm_sub_epi16
int32x2_t vsub_s32 (int32x2_t __a, int32x2_t __b);//_mm_sub_epi32
int64x1_t vsub_s64 (int64x1_t __a, int64x1_t __b);//_mm_sub_epi64
float32x2_t vsub_f32 (float32x2_t __a, float32x2_t __b);//_mm_sub_ps
uint8x8_t vsub_u8 (uint8x8_t __a, uint8x8_t __b);//_mm_sub_epi8
uint16x4_t vsub_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_sub_epi16
uint32x2_t vsub_u32 (uint32x2_t __a, uint32x2_t __b);//_mm_sub_epi32
uint64x1_t vsub_u64 (uint64x1_t __a, uint64x1_t __b);//_mm_sub_epi64
int8x16_t vsubq_s8 (int8x16_t __a, int8x16_t __b);//_mm_sub_epi8
int16x8_t vsubq_s16 (int16x8_t __a, int16x8_t __b);//_mm_sub_epi16
int32x4_t vsubq_s32 (int32x4_t __a, int32x4_t __b);//_mm_sub_epi32
int64x2_t vsubq_s64 (int64x2_t __a, int64x2_t __b);//_mm_sub_epi64
float32x4_t vsubq_f32 (float32x4_t __a, float32x4_t __b);//_mm_sub_ps
uint8x16_t vsubq_u8 (uint8x16_t __a, uint8x16_t __b);//_mm_sub_epi8
uint16x8_t vsubq_u16 (uint16x8_t __a, uint16x8_t __b);//_mm_sub_epi16
uint32x4_t vsubq_u32 (uint32x4_t __a, uint32x4_t __b);//_mm_sub_epi32
uint64x2_t vsubq_u64 (uint64x2_t __a, uint64x2_t __b);//_mm_sub_epi64
/*--2、Vector long subtract(长指令): vsubl -& ri = ai - --*/
int16x8_t vsubl_s8 (int8x8_t __a, int8x8_t __b);
int32x4_t vsubl_s16 (int16x4_t __a, int16x4_t __b);
int64x2_t vsubl_s32 (int32x2_t __a, int32x2_t __b);
uint16x8_t vsubl_u8 (uint8x8_t __a, uint8x8_t __b);
uint32x4_t vsubl_u16 (uint16x4_t __a, uint16x4_t __b);
uint64x2_t vsubl_u32 (uint32x2_t __a, uint32x2_t __b);
/*--3、Vector wide subtract(宽指令): vsubw -& ri = ai ---*/
int16x8_t vsubw_s8 (int16x8_t __a, int8x8_t __b);
int32x4_t vsubw_s16 (int32x4_t __a, int16x4_t __b);
int64x2_t vsubw_s32 (int64x2_t __a, int32x2_t __b);
uint16x8_t vsubw_u8 (uint16x8_t __a, uint8x8_t __b);
uint32x4_t vsubw_u16 (uint32x4_t __a, uint16x4_t __b);
uint64x2_t vsubw_u32 (uint64x2_t __a, uint32x2_t __b);
/*--4、Vector saturating subtract(饱和指令): vqsub -& ri = sat(ai - bi);
If any of the results overflow, they are saturated--*/
int8x8_t vqsub_s8 (int8x8_t __a, int8x8_t __b);//_mm_subs_epi8
int16x4_t vqsub_s16 (int16x4_t __a, int16x4_t __b);//_mm_subs_epi16
int32x2_t vqsub_s32 (int32x2_t __a, int32x2_t __b);//_mm_subs_epi32
int64x1_t vqsub_s64 (int64x1_t __a, int64x1_t __b);
uint8x8_t vqsub_u8 (uint8x8_t __a, uint8x8_t __b);//_mm_subs_epu8
uint16x4_t vqsub_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_subs_epu16
uint32x2_t vqsub_u32 (uint32x2_t __a, uint32x2_t __b);//_mm_subs_epu32
uint64x1_t vqsub_u64 (uint64x1_t __a, uint64x1_t __b);
int8x16_t vqsubq_s8 (int8x16_t __a, int8x16_t __b);//_mm_subs_epi8
int16x8_t vqsubq_s16 (int16x8_t __a, int16x8_t __b);//_mm_subs_epi16
int32x4_t vqsubq_s32 (int32x4_t __a, int32x4_t __b);//_mm_subs_epi32
int64x2_t vqsubq_s64 (int64x2_t __a, int64x2_t __b);
uint8x16_t vqsubq_u8 (uint8x16_t __a, uint8x16_t __b);//_mm_subs_epu8
uint16x8_t vqsubq_u16 (uint16x8_t __a, uint16x8_t __b);//_mm_subs_epu16
uint32x4_t vqsubq_u32 (uint32x4_t __a, uint32x4_t __b);//_mm_subs_epu32
uint64x2_t vqsubq_u64 (uint64x2_t __a, uint64x2_t __b);
/*--5、Vector halving subtract: vhsub -& ri = (ai - bi) && 1;
shifts each result right one bit, The results are truncated.--*/
int8x8_t vhsub_s8 (int8x8_t __a, int8x8_t __b);
int16x4_t vhsub_s16 (int16x4_t __a, int16x4_t __b);
int32x2_t vhsub_s32 (int32x2_t __a, int32x2_t __b);
uint8x8_t vhsub_u8 (uint8x8_t __a, uint8x8_t __b);
uint16x4_t vhsub_u16 (uint16x4_t __a, uint16x4_t __b);
uint32x2_t vhsub_u32 (uint32x2_t __a, uint32x2_t __b);
int8x16_t vhsubq_s8 (int8x16_t __a, int8x16_t __b);
int16x8_t vhsubq_s16 (int16x8_t __a, int16x8_t __b);
int32x4_t vhsubq_s32 (int32x4_t __a, int32x4_t __b);
uint8x16_t vhsubq_u8 (uint8x16_t __a, uint8x16_t __b);
uint16x8_t vhsubq_u16 (uint16x8_t __a, uint16x8_t __b);
uint32x4_t vhsubq_u32 (uint32x4_t __a, uint32x4_t __b);
/*--6、Vector subtract high half(窄指令): vsubhn -& ri = ai -
It returns the most significant halves of the results. The results are truncated--*/
int8x8_t vsubhn_s16 (int16x8_t __a, int16x8_t __b);
int16x4_t vsubhn_s32 (int32x4_t __a, int32x4_t __b);
int32x2_t vsubhn_s64 (int64x2_t __a, int64x2_t __b);
uint8x8_t vsubhn_u16 (uint16x8_t __a, uint16x8_t __b);
uint16x4_t vsubhn_u32 (uint32x4_t __a, uint32x4_t __b);
uint32x2_t vsubhn_u64 (uint64x2_t __a, uint64x2_t __b);
/*--7、Vector rounding subtract high half(窄指令): vrsubhn -& ai -
It returns the most significant halves of the results. The results are rounded--*/
int8x8_t vrsubhn_s16 (int16x8_t __a, int16x8_t __b);
int16x4_t vrsubhn_s32 (int32x4_t __a, int32x4_t __b);
int32x2_t vrsubhn_s64 (int64x2_t __a, int64x2_t __b)
uint8x8_t vrsubhn_u16 (uint16x8_t __a, uint16x8_t __b);
uint16x4_t vrsubhn_u32 (uint32x4_t __a, uint32x4_t __b);
uint32x2_t vrsubhn_u64 (uint64x2_t __a, uint64x2_t __b);
/******************************************************Comparison***********************/
/*--1、Vector compare equal(正常指令): vceq -& ri = ai == bi ? 1...1 : 0...0;
If they are equal, the corresponding element in the destination vector is set to all ones.
Otherwise, it is set to all zeros--*/
uint8x8_t vceq_s8 (int8x8_t __a, int8x8_t __b);//_mm_cmpeq_epi8
uint16x4_t vceq_s16 (int16x4_t __a, int16x4_t __b);//_mm_cmpeq_epi16
uint32x2_t vceq_s32 (int32x2_t __a, int32x2_t __b);//_mm_cmpeq_epi32
uint32x2_t vceq_f32 (float32x2_t __a, float32x2_t __b);
uint8x8_t vceq_u8 (uint8x8_t __a, uint8x8_t __b);//_mm_cmpeq_epi8
uint16x4_t vceq_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_cmpeq_epi16
uint32x2_t vceq_u32 (uint32x2_t __a, uint32x2_t __b);//_mm_cmpeq_epi32
uint8x8_t vceq_p8 (poly8x8_t __a, poly8x8_t __b);//_mm_cmpeq_epi8
uint8x16_t vceqq_s8 (int8x16_t __a, int8x16_t __b);//_mm_cmpeq_epi8
uint16x8_t vceqq_s16 (int16x8_t __a, int16x8_t __b);//_mm_cmpeq_epi16
uint32x4_t vceqq_s32 (int32x4_t __a, int32x4_t __b);//_mm_cmpeq_epi32
uint32x4_t vceqq_f32 (float32x4_t __a, float32x4_t __b);
uint8x16_t vceqq_u8 (uint8x16_t __a, uint8x16_t __b);//_mm_cmpeq_epi8
uint16x8_t vceqq_u16 (uint16x8_t __a, uint16x8_t __b);//_mm_cmpeq_epi16
uint32x4_t vceqq_u32 (uint32x4_t __a, uint32x4_t __b);//_mm_cmpeq_epi32
uint8x16_t vceqq_p8 (poly8x16_t __a, poly8x16_t __b);//_mm_cmpeq_epi8
/*--2、Vector compare greater-than or equal(正常指令): vcge-& ri = ai &= bi ? 1...1:0...0;
If it is greater than or equal to it, the corresponding element in the destination
vector is set to all ones. Otherwise, it is set to all zeros.--*/
uint8x8_t vcge_s8 (int8x8_t __a, int8x8_t __b);
uint16x4_t vcge_s16 (int16x4_t __a, int16x4_t __b);
uint32x2_t vcge_s32 (int32x2_t __a, int32x2_t __b);
uint32x2_t vcge_f32 (float32x2_t __a, float32x2_t __b);
uint8x8_t vcge_u8 (uint8x8_t __a, uint8x8_t __b);
uint16x4_t vcge_u16 (uint16x4_t __a, uint16x4_t __b);
uint32x2_t vcge_u32 (uint32x2_t __a, uint32x2_t __b);
uint8x16_t vcgeq_s8 (int8x16_t __a, int8x16_t __b);
uint16x8_t vcgeq_s16 (int16x8_t __a, int16x8_t __b);
uint32x4_t vcgeq_s32 (int32x4_t __a, int32x4_t __b);
uint32x4_t vcgeq_f32 (float32x4_t __a, float32x4_t __b);
uint8x16_t vcgeq_u8 (uint8x16_t __a, uint8x16_t __b);
uint16x8_t vcgeq_u16 (uint16x8_t __a, uint16x8_t __b);
uint32x4_t vcgeq_u32 (uint32x4_t __a, uint32x4_t __b);
/*--3、Vector compare less-than or equal(正常指令): vcle -& ri = ai &= bi ? 1...1:0...0;
If it is less than or equal to it, the corresponding element in the destination vector
is set to all ones. Otherwise, it is set to all zeros.--*/
uint8x8_t vcle_s8 (int8x8_t __a, int8x8_t __b);
uint16x4_t vcle_s16 (int16x4_t __a, int16x4_t __b);
uint32x2_t vcle_s32 (int32x2_t __a, int32x2_t __b);
uint32x2_t vcle_f32 (float32x2_t __a, float32x2_t __b);
uint8x8_t vcle_u8 (uint8x8_t __a, uint8x8_t __b);
uint16x4_t vcle_u16 (uint16x4_t __a, uint16x4_t __b);
uint32x2_t vcle_u32 (uint32x2_t __a, uint32x2_t __b);
uint8x16_t vcleq_s8 (int8x16_t __a, int8x16_t __b);
uint16x8_t vcleq_s16 (int16x8_t __a, int16x8_t __b);
uint32x4_t vcleq_s32 (int32x4_t __a, int32x4_t __b);
uint32x4_t vcleq_f32 (float32x4_t __a, float32x4_t __b);
uint8x16_t vcleq_u8 (uint8x16_t __a, uint8x16_t __b);
uint16x8_t vcleq_u16 (uint16x8_t __a, uint16x8_t __b);
uint32x4_t vcleq_u32 (uint32x4_t __a, uint32x4_t __b);
/*--4、Vector compare greater-than(正常指令): vcgt -& ri = ai & bi ? 1...1:0...0;
If it is greater than it, the corresponding element in the destination vector is
set to all ones. Otherwise, it is set to all zeros--*/
uint8x8_t vcgt_s8 (int8x8_t __a, int8x8_t __b);
uint16x4_t vcgt_s16 (int16x4_t __a, int16x4_t __b);
uint32x2_t vcgt_s32 (int32x2_t __a, int32x2_t __b);
uint32x2_t vcgt_f32 (float32x2_t __a, float32x2_t __b);
uint8x8_t vcgt_u8 (uint8x8_t __a, uint8x8_t __b);
uint16x4_t vcgt_u16 (uint16x4_t __a, uint16x4_t __b);
uint32x2_t vcgt_u32 (uint32x2_t __a, uint32x2_t __b);
uint8x16_t vcgtq_s8 (int8x16_t __a, int8x16_t __b);
uint16x8_t vcgtq_s16 (int16x8_t __a, int16x8_t __b);
uint32x4_t vcgtq_s32 (int32x4_t __a, int32x4_t __b);
uint32x4_t vcgtq_f32 (float32x4_t __a, float32x4_t __b);
uint8x16_t vcgtq_u8 (uint8x16_t __a, uint8x16_t __b);
uint16x8_t vcgtq_u16 (uint16x8_t __a, uint16x8_t __b);
uint32x4_t vcgtq_u32 (uint32x4_t __a, uint32x4_t __b);
/*--5、Vector compare less-than(正常指令): vclt -& ri = ai & bi ? 1...1:0...0;
If it is less than it, the corresponding element in the destination vector is set
to all ones.Otherwise, it is set to all zeros--*/
uint8x8_t vclt_s8 (int8x8_t __a, int8x8_t __b);
uint16x4_t vclt_s16 (int16x4_t __a, int16x4_t __b);
uint32x2_t vclt_s32 (int32x2_t __a, int32x2_t __b);
uint32x2_t vclt_f32 (float32x2_t __a, float32x2_t __b);
uint8x8_t vclt_u8 (uint8x8_t __a, uint8x8_t __b);
uint16x4_t vclt_u16 (uint16x4_t __a, uint16x4_t __b);
uint32x2_t vclt_u32 (uint32x2_t __a, uint32x2_t __b);
uint8x16_t vcltq_s8 (int8x16_t __a, int8x16_t __b);
uint16x8_t vcltq_s16 (int16x8_t __a, int16x8_t __b);
uint32x4_t vcltq_s32 (int32x4_t __a, int32x4_t __b);
uint32x4_t vcltq_f32 (float32x4_t __a, float32x4_t __b);
uint8x16_t vcltq_u8 (uint8x16_t __a, uint8x16_t __b);
uint16x8_t vcltq_u16 (uint16x8_t __a, uint16x8_t __b);
uint32x4_t vcltq_u32 (uint32x4_t __a, uint32x4_t __b);
/*--6、Vector compare absolute greater-than or equal(正常指令):
vcage -& ri = |ai| &= |bi| ? 1...1:0...0;
compares the absolute value of each element in a vector with the absolute value of the
corresponding element of a second vector. If it is greater than or equal to it,
the corresponding element in the destination vector is set to all ones.
Otherwise, it is set to all zeros.--*/
uint32x2_t vcage_f32 (float32x2_t __a, float32x2_t __b);
uint32x4_t vcageq_f32 (float32x4_t __a, float32x4_t __b);
/*--7、Vector compare absolute less-than or equal(正常指令):
vcale -& ri = |ai| &= |bi| ? 1...1:0...0;
compares the absolute value of each element in a vector with the absolute value of the
corresponding element of a second vector. If it is less than or equal to it,
the corresponding element in the destination vector is set to all ones.
Otherwise, it is set to all zeros--*/
uint32x2_t vcale_f32 (float32x2_t __a, float32x2_t __b);
uint32x4_t vcaleq_f32 (float32x4_t __a, float32x4_t __b);
/*--8、Vector compare absolute greater-than(正常指令):
vcage -& ri = |ai| & |bi| ? 1...1:0...0;
compares the absolute value of each element in a vector with the absolute value of the
corresponding element of a second vector. If it is greater than it,
the corresponding element in the destination vector is set to all ones.
Otherwise, it is set to all zeros.--*/
uint32x2_t vcagt_f32 (float32x2_t __a, float32x2_t __b);
uint32x4_t vcagtq_f32 (float32x4_t __a, float32x4_t __b);
/*--9、Vector compare absolute less-than(正常指令):
vcalt -& ri = |ai| & |bi| ? 1...1:0...0;
compares the absolute value of each element in a vector with the absolute value of the
corresponding element of a second vector.If it is less than it, the corresponding
element in the destination vector is set to all ones. Otherwise,it is set to all zeros--*/
uint32x2_t vcalt_f32 (float32x2_t __a, float32x2_t __b);
uint32x4_t vcaltq_f32 (float32x4_t __a, float32x4_t __b);
/**********************************************Vector test bits*************************/
/*--正常指令，vtst -& ri = (ai & bi != 0) ? 1...1:0...0;
bitwise logical ANDs each element in a vector with the corresponding element of a second
vector.If the result is not zero, the corresponding element in the destination vector
is set to all ones. Otherwise, it is set to all zeros--*/
uint8x8_t vtst_s8 (int8x8_t __a, int8x8_t __b);
uint16x4_t vtst_s16 (int16x4_t __a, int16x4_t __b);
uint32x2_t vtst_s32 (int32x2_t __a, int32x2_t __b);
uint8x8_t vtst_u8 (uint8x8_t __a, uint8x8_t __b);
uint16x4_t vtst_u16 (uint16x4_t __a, uint16x4_t __b);
uint32x2_t vtst_u32 (uint32x2_t __a, uint32x2_t __b);
uint8x8_t vtst_p8 (poly8x8_t __a, poly8x8_t __b);
uint8x16_t vtstq_s8 (int8x16_t __a, int8x16_t __b);
uint16x8_t vtstq_s16 (int16x8_t __a, int16x8_t __b);
uint32x4_t vtstq_s32 (int32x4_t __a, int32x4_t __b);
uint8x16_t vtstq_u8 (uint8x16_t __a, uint8x16_t __b);
uint16x8_t vtstq_u16 (uint16x8_t __a, uint16x8_t __b);
uint32x4_t vtstq_u32 (uint32x4_t __a, uint32x4_t __b);
uint8x16_t vtstq_p8 (poly8x16_t __a, poly8x16_t __b);
/**********************************************Absolute difference**********************/
/*--1、Absolute difference between the arguments(正常指令): vabd -& ri = |ai - bi|;
returns the absolute values of the results--*/
int8x8_t vabd_s8 (int8x8_t __a, int8x8_t __b);
int16x4_t vabd_s16 (int16x4_t __a, int16x4_t __b);
int32x2_t vabd_s32 (int32x2_t __a, int32x2_t __b);
float32x2_t vabd_f32 (float32x2_t __a, float32x2_t __b);
uint8x8_t vabd_u8 (uint8x8_t __a, uint8x8_t __b);
uint16x4_t vabd_u16 (uint16x4_t __a, uint16x4_t __b);
uint32x2_t vabd_u32 (uint32x2_t __a, uint32x2_t __b);
int8x16_t vabdq_s8 (int8x16_t __a, int8x16_t __b);
int16x8_t vabdq_s16 (int16x8_t __a, int16x8_t __b);
int32x4_t vabdq_s32 (int32x4_t __a, int32x4_t __b);
float32x4_t vabdq_f32 (float32x4_t __a, float32x4_t __b);
uint8x16_t vabdq_u8 (uint8x16_t __a, uint8x16_t __b);
uint16x8_t vabdq_u16 (uint16x8_t __a, uint16x8_t __b);
uint32x4_t vabdq_u32 (uint32x4_t __a, uint32x4_t __b);
/*--2、Absolute difference - long(长指令): vabdl -& ri = |ai - bi|;
The elements in the result vector are wider--*/
int16x8_t vabdl_s8 (int8x8_t __a, int8x8_t __b);
int32x4_t vabdl_s16 (int16x4_t __a, int16x4_t __b);
int64x2_t vabdl_s32 (int32x2_t __a, int32x2_t __b);
uint16x8_t vabdl_u8 (uint8x8_t __a, uint8x8_t __b);
uint32x4_t vabdl_u16 (uint16x4_t __a, uint16x4_t __b);
uint64x2_t vabdl_u32 (uint32x2_t __a, uint32x2_t __b);
/*--3、Absolute difference and accumulate: vaba -& ri = ai + |bi - ci|;--*/
int8x8_t vaba_s8 (int8x8_t __a, int8x8_t __b, int8x8_t __c);
int16x4_t vaba_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c);
int32x2_t vaba_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c);
uint8x8_t vaba_u8 (uint8x8_t __a, uint8x8_t __b, uint8x8_t __c);
uint16x4_t vaba_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c);
uint32x2_t vaba_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c);
int8x16_t vabaq_s8 (int8x16_t __a, int8x16_t __b, int8x16_t __c);
int16x8_t vabaq_s16 (int16x8_t __a, int16x8_t __b, int16x8_t __c);
int32x4_t vabaq_s32 (int32x4_t __a, int32x4_t __b, int32x4_t __c);
uint8x16_t vabaq_u8 (uint8x16_t __a, uint8x16_t __b, uint8x16_t __c);
uint16x8_t vabaq_u16 (uint16x8_t __a, uint16x8_t __b, uint16x8_t __c);
uint32x4_t vabaq_u32 (uint32x4_t __a, uint32x4_t __b, uint32x4_t __c);
/*--4、Absolute difference and accumulate - long: vabal -& ri = ai + |bi - ci|;
The elements in the result are wider--*/
int16x8_t vabal_s8 (int16x8_t __a, int8x8_t __b, int8x8_t __c);
int32x4_t vabal_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c);
int64x2_t vabal_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c);
uint16x8_t vabal_u8 (uint16x8_t __a, uint8x8_t __b, uint8x8_t __c);
uint32x4_t vabal_u16 (uint32x4_t __a, uint16x4_t __b, uint16x4_t __c);
uint64x2_t vabal_u32 (uint64x2_t __a, uint32x2_t __b, uint32x2_t __c);
/***********************************************Max*************************************/
/*--正常指令, vmax -& ri = ai &= bi ? ai : returns the larger of each pair--*/
int8x8_t vmax_s8 (int8x8_t __a, int8x8_t __b);//_mm_max_epi8
int16x4_t vmax_s16 (int16x4_t __a, int16x4_t __b);//_mm_max_epi16
int32x2_t vmax_s32 (int32x2_t __a, int32x2_t __b);//_mm_max_epi32
float32x2_t vmax_f32 (float32x2_t __a, float32x2_t __b);//_mm_max_ps
uint8x8_t vmax_u8 (uint8x8_t __a, uint8x8_t __b);//_mm_max_epu8
uint16x4_t vmax_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_max_epu16
uint32x2_t vmax_u32 (uint32x2_t __a, uint32x2_t __b);//_mm_max_epu32
int8x16_t vmaxq_s8 (int8x16_t __a, int8x16_t __b);//_mm_max_epi8
int16x8_t vmaxq_s16 (int16x8_t __a, int16x8_t __b);//_mm_max_epi16
int32x4_t vmaxq_s32 (int32x4_t __a, int32x4_t __b);//_mm_max_epi32
float32x4_t vmaxq_f32 (float32x4_t __a, float32x4_t __b);//_mm_max_ps
uint8x16_t vmaxq_u8 (uint8x16_t __a, uint8x16_t __b);//_mm_max_epu8
uint16x8_t vmaxq_u16 (uint16x8_t __a, uint16x8_t __b);//_mm_max_epu16
uint32x4_t vmaxq_u32 (uint32x4_t __a, uint32x4_t __b);//_mm_max_epu32
/****************************************************Min********************************/
/*--正常指令, vmin -& ri = ai &= bi ? bi : returns the smaller of each pair--*/
int8x8_t vmin_s8 (int8x8_t __a, int8x8_t __b);//_mm_min_epi8
int16x4_t vmin_s16 (int16x4_t __a, int16x4_t __b);//_mm_min_epi16
int32x2_t vmin_s32 (int32x2_t __a, int32x2_t __b);//_mm_min_epi32
float32x2_t vmin_f32 (float32x2_t __a, float32x2_t __b);//_mm_min_ps
uint8x8_t vmin_u8 (uint8x8_t __a, uint8x8_t __b);//_mm_min_epu8
uint16x4_t vmin_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_min_epu16
uint32x2_t vmin_u32 (uint32x2_t __a, uint32x2_t __b);//_mm_min_epu32
int8x16_t vminq_s8 (int8x16_t __a, int8x16_t __b);//_mm_min_epi8
int16x8_t vminq_s16 (int16x8_t __a, int16x8_t __b);//_mm_min_epi16
int32x4_t vminq_s32 (int32x4_t __a, int32x4_t __b);//_mm_min_epi32
float32x4_t vminq_f32 (float32x4_t __a, float32x4_t __b);//_mm_min_ps
uint8x16_t vminq_u8 (uint8x16_t __a, uint8x16_t __b);//_mm_min_epu8
uint16x8_t vminq_u16 (uint16x8_t __a, uint16x8_t __b);//_mm_min_epu16
uint32x4_t vminq_u32 (uint32x4_t __a, uint32x4_t __b);//_mm_min_epu32
/*******************************************Pairwise addition***************************/
/*--1、Pairwise add(正常指令):
vpadd -& r0 = a0 + a1, ..., r3 = a6 + a7, r4 = b0 + b1, ..., r7 = b6 + b7
adds adjacent pairs of elements of two vectors,
and places the results in the destination vector.--*/
//r0 = a0 + a1, ...,r3 = a6 + a7, r4 = b0 + b1, ...,r7 = b6 + b7
int8x8_t vpadd_s8 (int8x8_t __a, int8x8_t __b);
int16x4_t vpadd_s16 (int16x4_t __a, int16x4_t __b);
int32x2_t vpadd_s32 (int32x2_t __a, int32x2_t __b);
float32x2_t vpadd_f32 (float32x2_t __a, float32x2_t __b);
uint8x8_t vpadd_u8 (uint8x8_t __a, uint8x8_t __b);
uint16x4_t vpadd_u16 (uint16x4_t __a, uint16x4_t __b);
uint32x2_t vpadd_u32 (uint32x2_t __a, uint32x2_t __b);
/*--2、Long pairwise add: vpaddl vpaddl -& r0 = a0 + a1, ..., r3 = a6 + a7;
adds adjacent pairs of elements of a vector, sign extends or zero extends the results to
twice their original width, and places the final results in the destination vector--*/
int16x4_t vpaddl_s8 (int8x8_t __a);
int32x2_t vpaddl_s16 (int16x4_t __a);
int64x1_t vpaddl_s32 (int32x2_t __a);
uint16x4_t vpaddl_u8 (uint8x8_t __a);
uint32x2_t vpaddl_u16 (uint16x4_t __a);
uint64x1_t vpaddl_u32 (uint32x2_t __a);
int16x8_t vpaddlq_s8 (int8x16_t __a);
int32x4_t vpaddlq_s16 (int16x8_t __a);
int64x2_t vpaddlq_s32 (int32x4_t __a);
uint16x8_t vpaddlq_u8 (uint8x16_t __a);
uint32x4_t vpaddlq_u16 (uint16x8_t __a);
uint64x2_t vpaddlq_u32 (uint32x4_t __a);
/*--3、Long pairwise add and accumulate:
vpadal -& r0 = a0 + (b0 + b1), ..., r3 = a3 + (b6 + b7);
adds adjacent pairs of elements in the second vector, sign extends or zero extends the
results to twice the original width.
It then accumulates this with the corresponding
element in the first vector and places the final results in the destination vector--*/
int16x4_t vpadal_s8 (int16x4_t __a, int8x8_t __b);
int32x2_t vpadal_s16 (int32x2_t __a, int16x4_t __b);
int64x1_t vpadal_s32 (int64x1_t __a, int32x2_t __b);
uint16x4_t vpadal_u8 (uint16x4_t __a, uint8x8_t __b);
uint32x2_t vpadal_u16 (uint32x2_t __a, uint16x4_t __b);
uint64x1_t vpadal_u32 (uint64x1_t __a, uint32x2_t __b);
int16x8_t vpadalq_s8 (int16x8_t __a, int8x16_t __b);
int32x4_t vpadalq_s16 (int32x4_t __a, int16x8_t __b);
int64x2_t vpadalq_s32 (int64x2_t __a, int32x4_t __b);
uint16x8_t vpadalq_u8 (uint16x8_t __a, uint8x16_t __b);
uint32x4_t vpadalq_u16 (uint32x4_t __a, uint16x8_t __b);
uint64x2_t vpadalq_u32 (uint64x2_t __a, uint32x4_t __b);
/**********************************************Folding maximum**************************/
/*--饱和指令, vpmax -& vpmax r0 = a0 &= a1 ? a0 : a1, ..., r4 = b0 &= b1 ? b0 : b1, ...;
compares adjacent pairs of elements, and copies the larger of each pair into the
destination vector.The maximums from each pair of the first input vector are stored in
the lower half of the destination vector. The maximums from each pair of the second input
vector are stored in the higher half of the destination vector--*/
int8x8_t vpmax_s8 (int8x8_t __a, int8x8_t __b);
int16x4_t vpmax_s16 (int16x4_t __a, int16x4_t __b);
int32x2_t vpmax_s32 (int32x2_t __a, int32x2_t __b);
float32x2_t vpmax_f32 (float32x2_t __a, float32x2_t __b);
uint8x8_t vpmax_u8 (uint8x8_t __a, uint8x8_t __b);
uint16x4_t vpmax_u16 (uint16x4_t __a, uint16x4_t __b);
uint32x2_t vpmax_u32 (uint32x2_t __a, uint32x2_t __b);
/***************************************************Folding minimum*********************/
/*--饱和指令, vpmin -& r0 = a0 &= a1 ? a1 : a0, ..., r4 = b0 &= b1 ? b1 : b0, ...;
compares adjacent pairs of elements, and copies the smaller of each pair into the
destination vector.The minimums from each pair of the first input vector are stored in
the lower half of the destination vector. The minimums from each pair of the second
input vector are stored in the higher half of the destination vector.--*/
int8x8_t vpmin_s8 (int8x8_t __a, int8x8_t __b);
int16x4_t vpmin_s16 (int16x4_t __a, int16x4_t __b);
int32x2_t vpmin_s32 (int32x2_t __a, int32x2_t __b);
float32x2_t vpmin_f32 (float32x2_t __a, float32x2_t __b);
uint8x8_t vpmin_u8 (uint8x8_t __a, uint8x8_t __b);
uint16x4_t vpmin_u16 (uint16x4_t __a, uint16x4_t __b);
uint32x2_t vpmin_u32 (uint32x2_t __a, uint32x2_t __b);
/***************************************************Reciprocal**************************/
/*--1、饱和指令, Newton-Raphson iteration(牛顿 - 拉夫逊迭代)
performs a Newton-Raphson step for finding the reciprocal. It multiplies the elements of
one vector by the corresponding elements of another vector, subtracts each of the results
from 2, and places the final results into the elements of the destination vector--*/
float32x2_t vrecps_f32 (float32x2_t __a, float32x2_t __b);
float32x4_t vrecpsq_f32 (float32x4_t __a, float32x4_t __b);
/*--2、饱和指令,performs a Newton-Raphson step for finding the reciprocal square root.
It multiplies the elements of one vector by the corresponding elements of another vector,
subtracts each of the results from 3, divides these results by two, and places
the final results into the elements of the destination vector--*/
float32x2_t vrsqrts_f32 (float32x2_t __a, float32x2_t __b);
float32x4_t vrsqrtsq_f32 (float32x4_t __a, float32x4_t __b);
/************************************************Shifts by signed variable**************/
/*--1、Vector shift left(饱和指令): vshl -& ri = ai && (negative values shift right)
left shifts each element in a vector by an amount specified in the corresponding element
in the second input vector. The shift amount is the signed integer value of the least
significant byte of the element in the second input vector. The bits shifted out of each
element are lost.If the signed integer value is negative, it results in a right shift--*/
int8x8_t vshl_s8 (int8x8_t __a, int8x8_t __b);
int16x4_t vshl_s16 (int16x4_t __a, int16x4_t __b);
int32x2_t vshl_s32 (int32x2_t __a, int32x2_t __b);
int64x1_t vshl_s64 (int64x1_t __a, int64x1_t __b);
uint8x8_t vshl_u8 (uint8x8_t __a, int8x8_t __b);
uint16x4_t vshl_u16 (uint16x4_t __a, int16x4_t __b);
uint32x2_t vshl_u32 (uint32x2_t __a, int32x2_t __b);
uint64x1_t vshl_u64 (uint64x1_t __a, int64x1_t __b);
int8x16_t vshlq_s8 (int8x16_t __a, int8x16_t __b);
int16x8_t vshlq_s16 (int16x8_t __a, int16x8_t __b);
int32x4_t vshlq_s32 (int32x4_t __a, int32x4_t __b);
int64x2_t vshlq_s64 (int64x2_t __a, int64x2_t __b);
uint8x16_t vshlq_u8 (uint8x16_t __a, int8x16_t __b);
uint16x8_t vshlq_u16 (uint16x8_t __a, int16x8_t __b);
uint32x4_t vshlq_u32 (uint32x4_t __a, int32x4_t __b);
uint64x2_t vshlq_u64 (uint64x2_t __a, int64x2_t __b);
/*--2、Vector saturating shift left(饱和指令):
vqshl -& ri = ai &&(negative values shift right)
If the shift value is positive, the operation is a left shift. Otherwise, it is a
truncating right shift. left shifts each element in a vector of integers and places
the results in the destination vector. It is similar to VSHL.
The difference is that the sticky QC flag is set if saturation occurs--*/
int8x8_t vqshl_s8 (int8x8_t __a, int8x8_t __b);
int16x4_t vqshl_s16 (int16x4_t __a, int16x4_t __b);
int32x2_t vqshl_s32 (int32x2_t __a, int32x2_t __b);
int64x1_t vqshl_s64 (int64x1_t __a, int64x1_t __b);
uint8x8_t vqshl_u8 (uint8x8_t __a, int8x8_t __b);
uint16x4_t vqshl_u16 (uint16x4_t __a, int16x4_t __b);
uint32x2_t vqshl_u32 (uint32x2_t __a, int32x2_t __b);
uint64x1_t vqshl_u64 (uint64x1_t __a, int64x1_t __b);
int8x16_t vqshlq_s8 (int8x16_t __a, int8x16_t __b);
int16x8_t vqshlq_s16 (int16x8_t __a, int16x8_t __b);
int32x4_t vqshlq_s32 (int32x4_t __a, int32x4_t __b);
int64x2_t vqshlq_s64 (int64x2_t __a, int64x2_t __b);
uint8x16_t vqshlq_u8 (uint8x16_t __a, int8x16_t __b);
uint16x8_t vqshlq_u16 (uint16x8_t __a, int16x8_t __b);
uint32x4_t vqshlq_u32 (uint32x4_t __a, int32x4_t __b);
uint64x2_t vqshlq_u64 (uint64x2_t __a, int64x2_t __b);
/*--3、Vector rounding shift left(饱和指令):
vrshl -& ri = ai &&(negative values shift right)
If the shift value is positive, the operation is a left shift. Otherwise, it is a
rounding right shift. left shifts each element in a vector of integers and places
the results in the destination vector. It is similar to VSHL.
The difference is that the shifted value is then rounded.--*/
int8x8_t vrshl_s8 (int8x8_t __a, int8x8_t __b);
int16x4_t vrshl_s16 (int16x4_t __a, int16x4_t __b);
int32x2_t vrshl_s32 (int32x2_t __a, int32x2_t __b);
int64x1_t vrshl_s64 (int64x1_t __a, int64x1_t __b);
uint8x8_t vrshl_u8 (uint8x8_t __a, int8x8_t __b);
uint16x4_t vrshl_u16 (uint16x4_t __a, int16x4_t __b);
uint32x2_t vrshl_u32 (uint32x2_t __a, int32x2_t __b);
uint64x1_t vrshl_u64 (uint64x1_t __a, int64x1_t __b);
int8x16_t vrshlq_s8 (int8x16_t __a, int8x16_t __b);
int16x8_t vrshlq_s16 (int16x8_t __a, int16x8_t __b);
int32x4_t vrshlq_s32 (int32x4_t __a, int32x4_t __b);
int64x2_t vrshlq_s64 (int64x2_t __a, int64x2_t __b);
uint8x16_t vrshlq_u8 (uint8x16_t __a, int8x16_t __b);
uint16x8_t vrshlq_u16 (uint16x8_t __a, int16x8_t __b);
uint32x4_t vrshlq_u32 (uint32x4_t __a, int32x4_t __b);
uint64x2_t vrshlq_u64 (uint64x2_t __a, int64x2_t __b);
/*--4、Vector saturating rounding shift left(饱和指令):
vqrshl -& ri = ai &&(negative values shift right)
left shifts each element in a vector of integers and places the results in the
destination vector.It is similar to VSHL. The difference is that the shifted value
is rounded, and the sticky QC flag is set if saturation occurs.--*/
int8x8_t vqrshl_s8 (int8x8_t __a, int8x8_t __b);
int16x4_t vqrshl_s16 (int16x4_t __a, int16x4_t __b);
int32x2_t vqrshl_s32 (int32x2_t __a, int32x2_t __b);
int64x1_t vqrshl_s64 (int64x1_t __a, int64x1_t __b);
uint8x8_t vqrshl_u8 (uint8x8_t __a, int8x8_t __b);
uint16x4_t vqrshl_u16 (uint16x4_t __a, int16x4_t __b);
uint32x2_t vqrshl_u32 (uint32x2_t __a, int32x2_t __b);
uint64x1_t vqrshl_u64 (uint64x1_t __a, int64x1_t __b);
int8x16_t vqrshlq_s8 (int8x16_t __a, int8x16_t __b);
int16x8_t vqrshlq_s16 (int16x8_t __a, int16x8_t __b);
int32x4_t vqrshlq_s32 (int32x4_t __a, int32x4_t __b);
int64x2_t vqrshlq_s64 (int64x2_t __a, int64x2_t __b);
uint8x16_t vqrshlq_u8 (uint8x16_t __a, int8x16_t __b);
uint16x8_t vqrshlq_u16 (uint16x8_t __a, int16x8_t __b);
uint32x4_t vqrshlq_u32 (uint32x4_t __a, int32x4_t __b);
uint64x2_t vqrshlq_u64 (uint64x2_t __a, int64x2_t __b);
/****************************************Shifts by a constant***************************/
/*--1、Vector shift right by constant: vshr -& ri = ai &&The results are truncated.
right shifts each element in a vector by an immediate value,
and places the results in the destination vector.--*/
int8x8_t vshr_n_s8 (int8x8_t __a, const int __b);
int16x4_t vshr_n_s16 (int16x4_t __a, const int __b);
int32x2_t vshr_n_s32 (int32x2_t __a, const int __b);
int64x1_t vshr_n_s64 (int64x1_t __a, const int __b);
uint8x8_t vshr_n_u8 (uint8x8_t __a, const int __b);
uint16x4_t vshr_n_u16 (uint16x4_t __a, const int __b);
uint32x2_t vshr_n_u32 (uint32x2_t __a, const int __b);
uint64x1_t vshr_n_u64 (uint64x1_t __a, const int __b);
int8x16_t vshrq_n_s8 (int8x16_t __a, const int __b);
int16x8_t vshrq_n_s16 (int16x8_t __a, const int __b);
int32x4_t vshrq_n_s32 (int32x4_t __a, const int __b);
int64x2_t vshrq_n_s64 (int64x2_t __a, const int __b);
uint8x16_t vshrq_n_u8 (uint8x16_t __a, const int __b);
uint16x8_t vshrq_n_u16 (uint16x8_t __a, const int __b);
uint32x4_t vshrq_n_u32 (uint32x4_t __a, const int __b);
uint64x2_t vshrq_n_u64 (uint64x2_t __a, const int __b);
/*--2、Vector shift left by constant: vshl -& ri = ai &&
left shifts each element in a vector by an immediate value, and places the results in the
destination vector. The bits shifted out of the left of each element are lost--*/
int8x8_t vshl_n_s8 (int8x8_t __a, const int __b);
int16x4_t vshl_n_s16 (int16x4_t __a, const int __b);
int32x2_t vshl_n_s32 (int32x2_t __a, const int __b);
int64x1_t vshl_n_s64 (int64x1_t __a, const int __b);
uint8x8_t vshl_n_u8 (uint8x8_t __a, const int __b);
uint16x4_t vshl_n_u16 (uint16x4_t __a, const int __b);
uint32x2_t vshl_n_u32 (uint32x2_t __a, const int __b);
uint64x1_t vshl_n_u64 (uint64x1_t __a, const int __b);
int8x16_t vshlq_n_s8 (int8x16_t __a, const int __b);
int16x8_t vshlq_n_s16 (int16x8_t __a, const int __b);
int32x4_t vshlq_n_s32 (int32x4_t __a, const int __b);
int64x2_t vshlq_n_s64 (int64x2_t __a, const int __b);
uint8x16_t vshlq_n_u8 (uint8x16_t __a, const int __b);
uint16x8_t vshlq_n_u16 (uint16x8_t __a, const int __b);
uint32x4_t vshlq_n_u32 (uint32x4_t __a, const int __b);
uint64x2_t vshlq_n_u64 (uint64x2_t __a, const int __b);
/*--3、Vector rounding shift right by constant: vrshr -& ri = ai &&
right shifts each element in a vector by an immediate value, and places the results
in the destination vector. The shifted values are rounded.--*/
int8x8_t vrshr_n_s8 (int8x8_t __a, const int __b);
int16x4_t vrshr_n_s16 (int16x4_t __a, const int __b);
int32x2_t vrshr_n_s32 (int32x2_t __a, const int __b);
int64x1_t vrshr_n_s64 (int64x1_t __a, const int __b);
uint8x8_t vrshr_n_u8 (uint8x8_t __a, const int __b);
uint16x4_t vrshr_n_u16 (uint16x4_t __a, const int __b);
uint32x2_t vrshr_n_u32 (uint32x2_t __a, const int __b);
uint64x1_t vrshr_n_u64 (uint64x1_t __a, const int __b);
int8x16_t vrshrq_n_s8 (int8x16_t __a, const int __b);
int16x8_t vrshrq_n_s16 (int16x8_t __a, const int __b);
int32x4_t vrshrq_n_s32 (int32x4_t __a, const int __b);
int64x2_t vrshrq_n_s64 (int64x2_t __a, const int __b);
uint8x16_t vrshrq_n_u8 (uint8x16_t __a, const int __b);
uint16x8_t vrshrq_n_u16 (uint16x8_t __a, const int __b);
uint32x4_t vrshrq_n_u32 (uint32x4_t __a, const int __b);
uint64x2_t vrshrq_n_u64 (uint64x2_t __a, const int __b);
/*--4、Vector shift right by constant and accumulate: vsra -& ri = (ai && c) + (bi && c);
The results are truncated. right shifts each element in a vector by an immediate value,
and accumulates the results into the destination vector.--*/
int8x8_t vsra_n_s8 (int8x8_t __a, int8x8_t __b, const int __c);
int16x4_t vsra_n_s16 (int16x4_t __a, int16x4_t __b, const int __c);
int32x2_t vsra_n_s32 (int32x2_t __a, int32x2_t __b, const int __c);
int64x1_t vsra_n_s64 (int64x1_t __a, int64x1_t __b, const int __c);
uint8x8_t vsra_n_u8 (uint8x8_t __a, uint8x8_t __b, const int __c);
uint16x4_t vsra_n_u16 (uint16x4_t __a, uint16x4_t __b, const int __c);
uint32x2_t vsra_n_u32 (uint32x2_t __a, uint32x2_t __b, const int __c);
uint64x1_t vsra_n_u64 (uint64x1_t __a, uint64x1_t __b, const int __c);
int8x16_t vsraq_n_s8 (int8x16_t __a, int8x16_t __b, const int __c);
int16x8_t vsraq_n_s16 (int16x8_t __a, int16x8_t __b, const int __c);
int32x4_t vsraq_n_s32 (int32x4_t __a, int32x4_t __b, const int __c);
int64x2_t vsraq_n_s64 (int64x2_t __a, int64x2_t __b, const int __c);
uint8x16_t vsraq_n_u8 (uint8x16_t __a, uint8x16_t __b, const int __c);
uint16x8_t vsraq_n_u16 (uint16x8_t __a, uint16x8_t __b, const int __c);
uint32x4_t vsraq_n_u32 (uint32x4_t __a, uint32x4_t __b, const int __c);
uint64x2_t vsraq_n_u64 (uint64x2_t __a, uint64x2_t __b, const int __c);
/*--5、Vector rounding shift right by constant and accumulate:
vrsra -& ri = (ai && c) + (bi && c);
The results are rounded.right shifts each element in a vector by an immediate value,
and accumulates the rounded results into the destination vector.--*/
int8x8_t vrsra_n_s8 (int8x8_t __a, int8x8_t __b, const int __c);
int16x4_t vrsra_n_s16 (int16x4_t __a, int16x4_t __b, const int __c);
int32x2_t vrsra_n_s32 (int32x2_t __a, int32x2_t __b, const int __c);
int64x1_t vrsra_n_s64 (int64x1_t __a, int64x1_t __b, const int __c);
uint8x8_t vrsra_n_u8 (uint8x8_t __a, uint8x8_t __b, const int __c);
uint16x4_t vrsra_n_u16 (uint16x4_t __a, uint16x4_t __b, const int __c);
uint32x2_t vrsra_n_u32 (uint32x2_t __a, uint32x2_t __b, const int __c);
uint64x1_t vrsra_n_u64 (uint64x1_t __a, uint64x1_t __b, const int __c);
int8x16_t vrsraq_n_s8 (int8x16_t __a, int8x16_t __b, const int __c);
int16x8_t vrsraq_n_s16 (int16x8_t __a, int16x8_t __b, const int __c);
int32x4_t vrsraq_n_s32 (int32x4_t __a, int32x4_t __b, const int __c);
int64x2_t vrsraq_n_s64 (int64x2_t __a, int64x2_t __b, const int __c);
uint8x16_t vrsraq_n_u8 (uint8x16_t __a, uint8x16_t __b, const int __c);
uint16x8_t vrsraq_n_u16 (uint16x8_t __a, uint16x8_t __b, const int __c);
uint32x4_t vrsraq_n_u32 (uint32x4_t __a, uint32x4_t __b, const int __c);
uint64x2_t vrsraq_n_u64 (uint64x2_t __a, uint64x2_t __b, const int __c);
/*--6、Vector saturating shift left by constant: vqshl -& ri = sat(ai && b);
left shifts each element in a vector of integers by an immediate value, and places the
results in the destination vector,and the sticky QC flag is set if saturation occurs.--*/
int8x8_t vqshl_n_s8 (int8x8_t __a, const int __b);
int16x4_t vqshl_n_s16 (int16x4_t __a, const int __b);
int32x2_t vqshl_n_s32 (int32x2_t __a, const int __b);
int64x1_t vqshl_n_s64 (int64x1_t __a, const int __b);
uint8x8_t vqshl_n_u8 (uint8x8_t __a, const int __b);
uint16x4_t vqshl_n_u16 (uint16x4_t __a, const int __b);
uint32x2_t vqshl_n_u32 (uint32x2_t __a, const int __b);
uint64x1_t vqshl_n_u64 (uint64x1_t __a, const int __b);
int8x16_t vqshlq_n_s8 (int8x16_t __a, const int __b);
int16x8_t vqshlq_n_s16 (int16x8_t __a, const int __b);
int32x4_t vqshlq_n_s32 (int32x4_t __a, const int __b);
int64x2_t vqshlq_n_s64 (int64x2_t __a, const int __b);
uint8x16_t vqshlq_n_u8 (uint8x16_t __a, const int __b);
uint16x8_t vqshlq_n_u16 (uint16x8_t __a, const int __b);
uint32x4_t vqshlq_n_u32 (uint32x4_t __a, const int __b);
uint64x2_t vqshlq_n_u64 (uint64x2_t __a, const int __b);
/*--7、Vector signed-&unsigned saturating shift left by constant: vqshlu -& ri = ai &&
left shifts each element in a vector of integers by an immediate value, places the
results in the destination vector, the sticky QC flag is set if saturation occurs,
and indicates that the results are unsigned even though the operands are signed.--*/
uint8x8_t vqshlu_n_s8 (int8x8_t __a, const int __b);
uint16x4_t vqshlu_n_s16 (int16x4_t __a, const int __b);
uint32x2_t vqshlu_n_s32 (int32x2_t __a, const int __b);
uint64x1_t vqshlu_n_s64 (int64x1_t __a, const int __b);
uint8x16_t vqshluq_n_s8 (int8x16_t __a, const int __b);
uint16x8_t vqshluq_n_s16 (int16x8_t __a, const int __b);
uint32x4_t vqshluq_n_s32 (int32x4_t __a, const int __b);
uint64x2_t vqshluq_n_s64 (int64x2_t __a, const int __b);
/*--8、Vector narrowing shift right by constant: vshrn -& ri = ai &&
The results are truncated.right shifts each element in the input vector by an
immediate value. It then narrows the result by storing only the least significant
half of each element into the destination vector.--*/
int8x8_t vshrn_n_s16 (int16x8_t __a, const int __b);
int16x4_t vshrn_n_s32 (int32x4_t __a, const int __b);
int32x2_t vshrn_n_s64 (int64x2_t __a, const int __b);
uint8x8_t vshrn_n_u16 (uint16x8_t __a, const int __b);
uint16x4_t vshrn_n_u32 (uint32x4_t __a, const int __b);
uint32x2_t vshrn_n_u64 (uint64x2_t __a, const int __b);
/*--9、Vector signed-&unsigned narrowing saturating shift right by constant:
vqshrun -& ri = ai &&
Results are truncated. right shifts each element in a quadword vector of integers by an
immediate value, and places the results in a doubleword vector. The results are unsigned,
although the operands are signed. The sticky QC flag is set if saturation occurs.--*/
uint8x8_t vqshrun_n_s16 (int16x8_t __a, const int __b);
uint16x4_t vqshrun_n_s32 (int32x4_t __a, const int __b);
uint32x2_t vqshrun_n_s64 (int64x2_t __a, const int __b);
/*--10、Vector signed-&unsigned rounding narrowing saturating shift right by constant:
vqrshrun -& ri = ai && Results are rounded. right shifts each element in a quadword
vector of integers by an immediate value, and places the rounded results in a doubleword
vector. The results are unsigned, although the operands are signed.--*/
uint8x8_t vqrshrun_n_s16 (int16x8_t __a, const int __b);
uint16x4_t vqrshrun_n_s32 (int32x4_t __a, const int __b);
uint32x2_t vqrshrun_n_s64 (int64x2_t __a, const int __b);
/*--11、Vector narrowing saturating shift right by constant: vqshrn -& ri = ai &&
Results are truncated. right shifts each element in a quadword vector of integers by an
immediate value, and places the results in a doubleword vector,
and the sticky QC flag is set if saturation occurs.--*/
int8x8_t vqshrn_n_s16 (int16x8_t __a, const int __b);
int16x4_t vqshrn_n_s32 (int32x4_t __a, const int __b);
int32x2_t vqshrn_n_s64 (int64x2_t __a, const int __b);
uint8x8_t vqshrn_n_u16 (uint16x8_t __a, const int __b);
uint16x4_t vqshrn_n_u32 (uint32x4_t __a, const int __b);
uint32x2_t vqshrn_n_u64 (uint64x2_t __a, const int __b);
/*--12、Vector rounding narrowing shift right by constant: vrshrn -& ri = ai &&
The results are rounded. right shifts each element in a vector by an immediate value,
and places the rounded,narrowed results in the destination vector.--*/
int8x8_t vrshrn_n_s16 (int16x8_t __a, const int __b);
int16x4_t vrshrn_n_s32 (int32x4_t __a, const int __b);
int32x2_t vrshrn_n_s64 (int64x2_t __a, const int __b);
uint8x8_t vrshrn_n_u16 (uint16x8_t __a, const int __b);
uint16x4_t vrshrn_n_u32 (uint32x4_t __a, const int __b);
uint32x2_t vrshrn_n_u64 (uint64x2_t __a, const int __b);
/*--13、Vector rounding narrowing saturating shift right by constant:
vqrshrn -& ri = ai &&
Results are rounded. right shifts each element in a quadword vector of integers by an
immediate value,and places the rounded,narrowed results in a doubleword vector.
The sticky QC flag is set if saturation occurs.--*/
int8x8_t vqrshrn_n_s16 (int16x8_t __a, const int __b);
int16x4_t vqrshrn_n_s32 (int32x4_t __a, const int __b);
int32x2_t vqrshrn_n_s64 (int64x2_t __a, const int __b);
uint8x8_t vqrshrn_n_u16 (uint16x8_t __a, const int __b);
uint16x4_t vqrshrn_n_u32 (uint32x4_t __a, const int __b);
uint32x2_t vqrshrn_n_u64 (uint64x2_t __a, const int __b);
/*--14、Vector widening shift left by constant: vshll -& ri = ai &&
left shifts each element in a vector of integers by an immediate value,
and place the results in the destination vector. Bits shifted out of the left of each
element are lost and values are sign extended or zero extended.--*/
int16x8_t vshll_n_s8 (int8x8_t __a, const int __b);
int32x4_t vshll_n_s16 (int16x4_t __a, const int __b);
int64x2_t vshll_n_s32 (int32x2_t __a, const int __b);
uint16x8_t vshll_n_u8 (uint8x8_t __a, const int __b);
uint32x4_t vshll_n_u16 (uint16x4_t __a, const int __b);
uint64x2_t vshll_n_u32 (uint32x2_t __a, const int __b);
/********************************************Shifts with insert*************************/
/*--1、Vector shift right and insert: vsri -& ; The two most significant bits in the
destination vector are unchanged. right shifts each element in the second input vector
by an immediate value, and inserts the results in the destination vector. It does not
affect the highest n significant bits of the elements in the destination register.
Bits shifted out of the right of each element are lost.The first input vector holds
the elements of the destination vector before the operation is performed.--*/
int8x8_t vsri_n_s8 (int8x8_t __a, int8x8_t __b, const int __c);
int16x4_t vsri_n_s16 (int16x4_t __a, int16x4_t __b, const int __c);
int32x2_t vsri_n_s32 (int32x2_t __a, int32x2_t __b, const int __c);
int64x1_t vsri_n_s64 (int64x1_t __a, int64x1_t __b, const int __c);
uint8x8_t vsri_n_u8 (uint8x8_t __a, uint8x8_t __b, const int __c);
uint16x4_t vsri_n_u16 (uint16x4_t __a, uint16x4_t __b, const int __c);
uint32x2_t vsri_n_u32 (uint32x2_t __a, uint32x2_t __b, const int __c);
uint64x1_t vsri_n_u64 (uint64x1_t __a, uint64x1_t __b, const int __c);
poly8x8_t vsri_n_p8 (poly8x8_t __a, poly8x8_t __b, const int __c);
poly16x4_t vsri_n_p16 (poly16x4_t __a, poly16x4_t __b, const int __c);
int8x16_t vsriq_n_s8 (int8x16_t __a, int8x16_t __b, const int __c);
int16x8_t vsriq_n_s16 (int16x8_t __a, int16x8_t __b, const int __c);
int32x4_t vsriq_n_s32 (int32x4_t __a, int32x4_t __b, const int __c);
int64x2_t vsriq_n_s64 (int64x2_t __a, int64x2_t __b, const int __c);
uint8x16_t vsriq_n_u8 (uint8x16_t __a, uint8x16_t __b, const int __c);
uint16x8_t vsriq_n_u16 (uint16x8_t __a, uint16x8_t __b, const int __c);
uint32x4_t vsriq_n_u32 (uint32x4_t __a, uint32x4_t __b, const int __c);
uint64x2_t vsriq_n_u64 (uint64x2_t __a, uint64x2_t __b, const int __c);
poly8x16_t vsriq_n_p8 (poly8x16_t __a, poly8x16_t __b, const int __c);
poly16x8_t vsriq_n_p16 (poly16x8_t __a, poly16x8_t __b, const int __c);
/*--2、Vector shift left and insert: vsli -&; The least significant bit in each element
in the destination vector is unchanged. left shifts each element in the second input
vector by an immediate value, and inserts the results in the destination vector.
It does not affect the lowest n significant bits of the elements in the destination
register. Bits shifted out of the left of each element are lost. The first input vector
holds the elements of the destination vector before the operation is performed.--*/
int8x8_t vsli_n_s8 (int8x8_t __a, int8x8_t __b, const int __c);
int16x4_t vsli_n_s16 (int16x4_t __a, int16x4_t __b, const int __c);
int32x2_t vsli_n_s32 (int32x2_t __a, int32x2_t __b, const int __c);
int64x1_t vsli_n_s64 (int64x1_t __a, int64x1_t __b, const int __c);
uint8x8_t vsli_n_u8 (uint8x8_t __a, uint8x8_t __b, const int __c);
uint16x4_t vsli_n_u16 (uint16x4_t __a, uint16x4_t __b, const int __c);
uint32x2_t vsli_n_u32 (uint32x2_t __a, uint32x2_t __b, const int __c);
uint64x1_t vsli_n_u64 (uint64x1_t __a, uint64x1_t __b, const int __c);
poly8x8_t vsli_n_p8 (poly8x8_t __a, poly8x8_t __b, const int __c);
poly16x4_t vsli_n_p16 (poly16x4_t __a, poly16x4_t __b, const int __c);
int8x16_t vsliq_n_s8 (int8x16_t __a, int8x16_t __b, const int __c);
int16x8_t vsliq_n_s16 (int16x8_t __a, int16x8_t __b, const int __c);
int32x4_t vsliq_n_s32 (int32x4_t __a, int32x4_t __b, const int __c);
int64x2_t vsliq_n_s64 (int64x2_t __a, int64x2_t __b, const int __c);
uint8x16_t vsliq_n_u8 (uint8x16_t __a, uint8x16_t __b, const int __c);
uint16x8_t vsliq_n_u16 (uint16x8_t __a, uint16x8_t __b, const int __c);
uint32x4_t vsliq_n_u32 (uint32x4_t __a, uint32x4_t __b, const int __c);
uint64x2_t vsliq_n_u64 (uint64x2_t __a, uint64x2_t __b, const int __c);
poly8x16_t vsliq_n_p8 (poly8x16_t __a, poly8x16_t __b, const int __c);
poly16x8_t vsliq_n_p16 (poly16x8_t __a, poly16x8_t __b, const int __c);
/*****************************************Absolute value********************************/
/*--1、Absolute(正常指令): vabs -& ri = |ai|;
returns the absolute value of each element in a vector.--*/
int8x8_t vabs_s8 (int8x8_t __a);//_mm_abs_epi8
int16x4_t vabs_s16 (int16x4_t __a);//_mm_abs_epi16
int32x2_t vabs_s32 (int32x2_t __a);//_mm_abs_epi32
float32x2_t vabs_f32 (float32x2_t __a);
int8x16_t vabsq_s8 (int8x16_t __a);//_mm_abs_epi8
int16x8_t vabsq_s16 (int16x8_t __a);//_mm_abs_epi16
int32x4_t vabsq_s32 (int32x4_t __a);//_mm_abs_epi32
float32x4_t vabsq_f32 (float32x4_t __a);
/*--2、Saturating absolute(饱和指令): vqabs -& ri = sat(|ai|);
returns the absolute value of each element in a vector. If any of the results overflow,
they are saturated and the sticky QC flag is set.--*/
int8x8_t vqabs_s8 (int8x8_t __a);
int16x4_t vqabs_s16 (int16x4_t __a);
int32x2_t vqabs_s32 (int32x2_t __a);
int8x16_t vqabsq_s8 (int8x16_t __a);
int16x8_t vqabsq_s16 (int16x8_t __a);
int32x4_t vqabsq_s32 (int32x4_t __a);
/***************************************************Negation****************************/
/*--1、Negate(正常指令): vneg -& ri = - negates each element in a vector.--*/
int8x8_t vneg_s8 (int8x8_t __a);
int16x4_t vneg_s16 (int16x4_t __a);
int32x2_t vneg_s32 (int32x2_t __a);
float32x2_t vneg_f32 (float32x2_t __a);
int8x16_t vnegq_s8 (int8x16_t __a);
int16x8_t vnegq_s16 (int16x8_t __a);
int32x4_t vnegq_s32 (int32x4_t __a);
float32x4_t vnegq_f32 (float32x4_t __a);
/*--2、Saturating Negate: vqneg -& ri = sat(-ai);
negates each element in a vector. If any of the results overflow,
they are saturated and the sticky QC flag is set.--*/
int8x8_t vqneg_s8 (int8x8_t __a);
int16x4_t vqneg_s16 (int16x4_t __a);
int32x2_t vqneg_s32 (int32x2_t __a);
int8x16_t vqnegq_s8 (int8x16_t __a);
int16x8_t vqnegq_s16 (int16x8_t __a);
int32x4_t vqnegq_s32 (int32x4_t __a);
/********************************************Logical operations*************************/
/*--1、Bitwise not(正常指令): vmvn -& ri = ~
performs a bitwise inversion of each element from the input vector.--*/
int8x8_t vmvn_s8 (int8x8_t __a);
int16x4_t vmvn_s16 (int16x4_t __a);
int32x2_t vmvn_s32 (int32x2_t __a);
uint8x8_t vmvn_u8 (uint8x8_t __a);
uint16x4_t vmvn_u16 (uint16x4_t __a);
uint32x2_t vmvn_u32 (uint32x2_t __a);
poly8x8_t vmvn_p8 (poly8x8_t __a);
int8x16_t vmvnq_s8 (int8x16_t __a);
int16x8_t vmvnq_s16 (int16x8_t __a);
int32x4_t vmvnq_s32 (int32x4_t __a);
uint8x16_t vmvnq_u8 (uint8x16_t __a);
uint16x8_t vmvnq_u16 (uint16x8_t __a);
uint32x4_t vmvnq_u32 (uint32x4_t __a);
poly8x16_t vmvnq_p8 (poly8x16_t __a);
/*--2、Bitwise and(正常指令): vand -& ri = ai & performs a bitwise AND between
corresponding elements of the input vectors.--*/
int8x8_t vand_s8 (int8x8_t __a, int8x8_t __b);//_mm_and_si128
int16x4_t vand_s16 (int16x4_t __a, int16x4_t __b);//_mm_and_si128
int32x2_t vand_s32 (int32x2_t __a, int32x2_t __b);//_mm_and_si128
uint8x8_t vand_u8 (uint8x8_t __a, uint8x8_t __b);//_mm_and_si128
uint16x4_t vand_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_and_si128
uint32x2_t vand_u32 (uint32x2_t __a, uint32x2_t __b);//_mm_and_si128
int64x1_t vand_s64 (int64x1_t __a, int64x1_t __b);//_mm_and_si128
uint64x1_t vand_u64 (uint64x1_t __a, uint64x1_t __b);//_mm_and_si128
int8x16_t vandq_s8 (int8x16_t __a, int8x16_t __b);//_mm_and_si128
int16x8_t vandq_s16 (int16x8_t __a, int16x8_t __b);//_mm_and_si128
int32x4_t vandq_s32 (int32x4_t __a, int32x4_t __b);//_mm_and_si128
int64x2_t vandq_s64 (int64x2_t __a, int64x2_t __b);//_mm_and_si128
uint8x16_t vandq_u8 (uint8x16_t __a, uint8x16_t __b);//_mm_and_si128
uint16x8_t vandq_u16 (uint16x8_t __a, uint16x8_t __b);//_mm_and_si128
uint32x4_t vandq_u32 (uint32x4_t __a, uint32x4_t __b);//_mm_and_si128
uint64x2_t vandq_u64 (uint64x2_t __a, uint64x2_t __b);//_mm_and_si128
/*--3、Bitwise or(正常指令): vorr -& ri = ai | performs a bitwise OR between
corresponding elements of the input vectors.--*/
int8x8_t vorr_s8 (int8x8_t __a, int8x8_t __b);//_mm_or_si128
int16x4_t vorr_s16 (int16x4_t __a, int16x4_t __b);//_mm_or_si128
int32x2_t vorr_s32 (int32x2_t __a, int32x2_t __b);//_mm_or_si128
uint8x8_t vorr_u8 (uint8x8_t __a, uint8x8_t __b);//_mm_or_si128
uint16x4_t vorr_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_or_si128
uint32x2_t vorr_u32 (uint32x2_t __a, uint32x2_t __b);//_mm_or_si128
int64x1_t vorr_s64 (int64x1_t __a, int64x1_t __b);//_mm_or_si128
uint64x1_t vorr_u64 (uint64x1_t __a, uint64x1_t __b);//_mm_or_si128
int8x16_t vorrq_s8 (int8x16_t __a, int8x16_t __b);//_mm_or_si128
int16x8_t vorrq_s16 (int16x8_t __a, int16x8_t __b);//_mm_or_si128
int32x4_t vorrq_s32 (int32x4_t __a, int32x4_t __b);//_mm_or_si128
int64x2_t vorrq_s64 (int64x2_t __a, int64x2_t __b);//_mm_or_si128
uint8x16_t vorrq_u8 (uint8x16_t __a, uint8x16_t __b);//_mm_or_si128
uint16x8_t vorrq_u16 (uint16x8_t __a, uint16x8_t __b);//_mm_or_si128
uint32x4_t vorrq_u32 (uint32x4_t __a, uint32x4_t __b);//_mm_or_si128
uint64x2_t vorrq_u64 (uint64x2_t __a, uint64x2_t __b);//_mm_or_si128
/*--4、Bitwise exclusive or (EOR or XOR)(正常指令): veor -& ri = ai ^
performs a bitwise exclusive-OR between corresponding elements of the input vectors.--*/
int8x8_t veor_s8 (int8x8_t __a, int8x8_t __b);//_mm_xor_si128
int16x4_t veor_s16 (int16x4_t __a, int16x4_t __b);//_mm_xor_si128
int32x2_t veor_s32 (int32x2_t __a, int32x2_t __b);//_mm_xor_si128
uint8x8_t veor_u8 (uint8x8_t __a, uint8x8_t __b);//_mm_xor_si128
uint16x4_t veor_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_xor_si128
uint32x2_t veor_u32 (uint32x2_t __a, uint32x2_t __b);//_mm_xor_si128
int64x1_t veor_s64 (int64x1_t __a, int64x1_t __b);//_mm_xor_si128
uint64x1_t veor_u64 (uint64x1_t __a, uint64x1_t __b);//_mm_xor_si128
int8x16_t veorq_s8 (int8x16_t __a, int8x16_t __b);//_mm_xor_si128
int16x8_t veorq_s16 (int16x8_t __a, int16x8_t __b);//_mm_xor_si128
int32x4_t veorq_s32 (int32x4_t __a, int32x4_t __b);//_mm_xor_si128
int64x2_t veorq_s64 (int64x2_t __a, int64x2_t __b);//_mm_xor_si128
uint8x16_t veorq_u8 (uint8x16_t __a, uint8x16_t __b);//_mm_xor_si128
uint16x8_t veorq_u16 (uint16x8_t __a, uint16x8_t __b);//_mm_xor_si128
uint32x4_t veorq_u32 (uint32x4_t __a, uint32x4_t __b);//_mm_xor_si128
uint64x2_t veorq_u64 (uint64x2_t __a, uint64x2_t __b);//_mm_xor_si128
/*--5、Bit Clear(正常指令): vbic -& ri = ~ai &
VBIC (Vector Bitwise Clear) performs a bitwise logical AND complement operation between
values in two registers, and places the results in the destination register.--*/
int8x8_t vbic_s8 (int8x8_t __a, int8x8_t __b);//_mm_andnot_si128
int16x4_t vbic_s16 (int16x4_t __a, int16x4_t __b);//_mm_andnot_si128
int32x2_t vbic_s32 (int32x2_t __a, int32x2_t __b);//_mm_andnot_si128
uint8x8_t vbic_u8 (uint8x8_t __a, uint8x8_t __b);//_mm_andnot_si128
uint16x4_t vbic_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_andnot_si128
uint32x2_t vbic_u32 (uint32x2_t __a, uint32x2_t __b);//_mm_andnot_si128
int64x1_t vbic_s64 (int64x1_t __a, int64x1_t __b);//_mm_andnot_si128
uint64x1_t vbic_u64 (ui