hemmingway

ARM Neon Intrinsics各函数介绍

ARM NEON Optimization. An Example

[cpp] view plain copy

 
     
 #ifndef __ARM_NEON__  
 #error You must enable NEON instructions (e.g. -mfloat-abi=softfp -mfpu=neon) to use arm_neon.h  
 #endif  
   
 /*(1)、正常指令：生成大小相同且类型通常与操作数向量相同的结果向量； 
 (2)、长指令：对双字向量操作数执行运算，生成四字向量的结果。所生成的元素一般是操作数元素宽度的两倍， 
 并属于同一类型； 
 (3)、宽指令：一个双字向量操作数和一个四字向量操作数执行运算，生成四字向量结果。所生成的元素和第一个 
 操作数的元素是第二个操作数元素宽度的两倍； 
 (4)、窄指令：四字向量操作数执行运算，并生成双字向量结果，所生成的元素一般是操作数元素宽度的一半； 
 (5)、饱和指令：当超过数据类型指定的范围则自动限制在该范围内。*/  
   
 /******************************************************Addition*************************/  
 /*--1、Vector add(正常指令): vadd -> ri = ai + bi; 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 + bi; 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 + bi;  
 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 * bi;--*/  
 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 * ci; --*/  
 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 * ci; 
 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);  
 int64x2_t  vqdmlal_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c);  
 /*--9、Vector saturating doubling multiply subtract long: vqdmlsl -> ri = ai - bi * ci; 
 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 * bi;--*/  
 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 * bi; 
 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 * ci;  
 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 * ci;  
 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 - bi;--*/  
 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 - bi; --*/  
 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 - bi;--*/  
 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 - bi; 
 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 - bi;  
 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 : bi; 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 : ai; 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 << bi; (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 << bi;(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 << bi;(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 << bi;(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 >> b;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 << b; 
 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 >> b; 
 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 << b;  
 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 >> b; 
 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 >> b;  
 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 >> b; 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 >> b;  
 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 >> b;  
 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 >> b; 
 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 << b;  
 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 = -ai; 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 = ~ai;  
 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 & bi; 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 | bi; 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 ^ bi;  
 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 & bi; 
 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 (uint64x1_t __a, uint64x1_t __b);//_mm_andnot_si128  
 int8x16_t vbicq_s8 (int8x16_t __a, int8x16_t __b);//_mm_andnot_si128  
 int16x8_t vbicq_s16 (int16x8_t __a, int16x8_t __b);//_mm_andnot_si128  
 int32x4_t vbicq_s32 (int32x4_t __a, int32x4_t __b);//_mm_andnot_si128  
 int64x2_t vbicq_s64 (int64x2_t __a, int64x2_t __b);//_mm_andnot_si128  
 uint8x16_t vbicq_u8 (uint8x16_t __a, uint8x16_t __b);//_mm_andnot_si128  
 uint16x8_t vbicq_u16 (uint16x8_t __a, uint16x8_t __b);//_mm_andnot_si128  
 uint32x4_t vbicq_u32 (uint32x4_t __a, uint32x4_t __b);//_mm_andnot_si128  
 uint64x2_t vbicq_u64 (uint64x2_t __a, uint64x2_t __b);//_mm_andnot_si128  
 /*--6、Bitwise OR complement(正常指令): vorn -> ri = ai | (~bi);  
 performs a bitwise logical OR NOT operation  
 between values in two registers, and places the results in the destination register.--*/  
 int8x8_t vorn_s8 (int8x8_t __a, int8x8_t __b);  
 int16x4_t vorn_s16 (int16x4_t __a, int16x4_t __b);  
 int32x2_t vorn_s32 (int32x2_t __a, int32x2_t __b);  
 uint8x8_t vorn_u8 (uint8x8_t __a, uint8x8_t __b);  
 uint16x4_t vorn_u16 (uint16x4_t __a, uint16x4_t __b);  
 uint32x2_t vorn_u32 (uint32x2_t __a, uint32x2_t __b);  
 int64x1_t vorn_s64 (int64x1_t __a, int64x1_t __b);  
 uint64x1_t vorn_u64 (uint64x1_t __a, uint64x1_t __b);  
 int8x16_t vornq_s8 (int8x16_t __a, int8x16_t __b);  
 int16x8_t vornq_s16 (int16x8_t __a, int16x8_t __b);  
 int32x4_t vornq_s32 (int32x4_t __a, int32x4_t __b);  
 int64x2_t vornq_s64 (int64x2_t __a, int64x2_t __b);  
 uint8x16_t vornq_u8 (uint8x16_t __a, uint8x16_t __b);  
 uint16x8_t vornq_u16 (uint16x8_t __a, uint16x8_t __b);  
 uint32x4_t vornq_u32 (uint32x4_t __a, uint32x4_t __b);  
 uint64x2_t vornq_u64 (uint64x2_t __a, uint64x2_t __b);  
 /****************************************Count leading sign bits************************/  
 /*--正常指令, vcls -> ; counts the number of consecutive bits, starting from the most  
 significant bit,that are the same as the most significant bit, in each element in a  
 vector, and places the count in the result vector.--*/  
 int8x8_t vcls_s8 (int8x8_t __a);  
 int16x4_t vcls_s16 (int16x4_t __a);  
 int32x2_t vcls_s32 (int32x2_t __a);  
 int8x16_t vclsq_s8 (int8x16_t __a);  
 int16x8_t vclsq_s16 (int16x8_t __a);  
 int32x4_t vclsq_s32 (int32x4_t __a);  
 /*******************************************Count leading zeros*************************/  
 /*--正常指令, vclz -> ; counts the number of consecutive zeros, starting from the most 
 significant bit, in each element in a vector, and places the count in result vector.--*/  
 int8x8_t vclz_s8 (int8x8_t __a);  
 int16x4_t vclz_s16 (int16x4_t __a);  
 int32x2_t vclz_s32 (int32x2_t __a);  
 uint8x8_t vclz_u8 (uint8x8_t __a);  
 uint16x4_t vclz_u16 (uint16x4_t __a);  
 uint32x2_t vclz_u32 (uint32x2_t __a);  
 int8x16_t vclzq_s8 (int8x16_t __a);  
 int16x8_t vclzq_s16 (int16x8_t __a);  
 int32x4_t vclzq_s32 (int32x4_t __a);  
 uint8x16_t vclzq_u8 (uint8x16_t __a);  
 uint16x8_t vclzq_u16 (uint16x8_t __a);  
 uint32x4_t vclzq_u32 (uint32x4_t __a);  
 /*******************************************Count number of set bits********************/  
 /*--正常指令, vcnt -> counts the number of bits that are one in each element in a vector,  
 and places the count in the result vector.--*/  
 int8x8_t vcnt_s8 (int8x8_t __a);  
 uint8x8_t vcnt_u8 (uint8x8_t __a);  
 poly8x8_t vcnt_p8 (poly8x8_t __a);  
 int8x16_t vcntq_s8 (int8x16_t __a);  
 uint8x16_t vcntq_u8 (uint8x16_t __a);  
 poly8x16_t vcntq_p8 (poly8x16_t __a);  
 /*****************************************Reciprocal estimate***************************/  
 /*--正常指令, vrecpe -> ; finds an approximate reciprocal of each element in a vector,  
 and places it in the result vector.--*/  
 float32x2_t vrecpe_f32 (float32x2_t __a);  
 uint32x2_t vrecpe_u32 (uint32x2_t __a);  
 float32x4_t vrecpeq_f32 (float32x4_t __a);  
 uint32x4_t vrecpeq_u32 (uint32x4_t __a);  
 /****************************************Reciprocal square-root estimate****************/  
 /*--正常指令, vrsqrte -> ; finds an approximate reciprocal square root of each element 
 in a vector, and places it in the return vector.--*/  
 float32x2_t vrsqrte_f32 (float32x2_t __a);  
 uint32x2_t vrsqrte_u32 (uint32x2_t __a);  
 float32x4_t vrsqrteq_f32 (float32x4_t __a);  
 uint32x4_t vrsqrteq_u32 (uint32x4_t __a);  
 /*******************************************Get lanes from a vector*********************/  
 /*--vmov -> r = a[b]; returns the value from the specified lane of a vector. 
 Extract lanes from a vector and put into a register.  
 These intrinsics extract a single lane (element) from a vector.--*/  
 int8_t vget_lane_s8 (int8x8_t __a, const int __b);//_mm_extract_epi8  
 int16_t vget_lane_s16 (int16x4_t __a, const int __b);//_mm_extract_epi16  
 int32_t vget_lane_s32 (int32x2_t __a, const int __b);//_mm_extract_epi32  
 float32_t vget_lane_f32 (float32x2_t __a, const int __b);  
 uint8_t vget_lane_u8 (uint8x8_t __a, const int __b);//_mm_extract_epi8  
 uint16_t vget_lane_u16 (uint16x4_t __a, const int __b);//_mm_extract_epi16  
 uint32_t vget_lane_u32 (uint32x2_t __a, const int __b);//_mm_extract_epi32  
 poly8_t vget_lane_p8 (poly8x8_t __a, const int __b);//_mm_extract_epi8  
 poly16_t vget_lane_p16 (poly16x4_t __a, const int __b);//_mm_extract_epi16  
 int64_t vget_lane_s64 (int64x1_t __a, const int __b);//_mm_extract_epi64  
 uint64_t vget_lane_u64 (uint64x1_t __a, const int __b);//_mm_extract_epi64  
 int8_t vgetq_lane_s8 (int8x16_t __a, const int __b);//_mm_extract_epi8  
 int16_t vgetq_lane_s16 (int16x8_t __a, const int __b);//_mm_extract_epi16  
 int32_t vgetq_lane_s32 (int32x4_t __a, const int __b);//_mm_extract_epi32  
 float32_t vgetq_lane_f32 (float32x4_t __a, const int __b);  
 uint8_t vgetq_lane_u8 (uint8x16_t __a, const int __b);//_mm_extract_epi8  
 uint16_t vgetq_lane_u16 (uint16x8_t __a, const int __b);//_mm_extract_epi16  
 uint32_t vgetq_lane_u32 (uint32x4_t __a, const int __b);//_mm_extract_epi32  
 poly8_t vgetq_lane_p8 (poly8x16_t __a, const int __b);//_mm_extract_epi8  
 poly16_t vgetq_lane_p16 (poly16x8_t __a, const int __b);//_mm_extract_epi16  
 int64_t vgetq_lane_s64 (int64x2_t __a, const int __b);//_mm_extract_epi64  
 uint64_t vgetq_lane_u64 (uint64x2_t __a, const int __b);//_mm_extract_epi64  
 /*********************************************Set lanes in a vector********************/  
 /*--vmov -> ; sets the value of the specified lane of a vector. It returns the vector  
 with the new value.Load a single lane of a vector from a literal. These intrinsics set  
 a single lane (element) within a vector.--*/  
 int8x8_t vset_lane_s8 (int8_t __a, int8x8_t __b, const int __c);  
 int16x4_t vset_lane_s16 (int16_t __a, int16x4_t __b, const int __c);  
 int32x2_t vset_lane_s32 (int32_t __a, int32x2_t __b, const int __c);  
 float32x2_t vset_lane_f32 (float32_t __a, float32x2_t __b, const int __c);  
 uint8x8_t vset_lane_u8 (uint8_t __a, uint8x8_t __b, const int __c);  
 uint16x4_t vset_lane_u16 (uint16_t __a, uint16x4_t __b, const int __c);  
 uint32x2_t vset_lane_u32 (uint32_t __a, uint32x2_t __b, const int __c);  
 poly8x8_t vset_lane_p8 (poly8_t __a, poly8x8_t __b, const int __c);  
 poly16x4_t vset_lane_p16 (poly16_t __a, poly16x4_t __b, const int __c);  
 int64x1_t vset_lane_s64 (int64_t __a, int64x1_t __b, const int __c);  
 uint64x1_t vset_lane_u64 (uint64_t __a, uint64x1_t __b, const int __c);  
 int8x16_t vsetq_lane_s8 (int8_t __a, int8x16_t __b, const int __c);  
 int16x8_t vsetq_lane_s16 (int16_t __a, int16x8_t __b, const int __c);  
 int32x4_t vsetq_lane_s32 (int32_t __a, int32x4_t __b, const int __c);  
 float32x4_t vsetq_lane_f32 (float32_t __a, float32x4_t __b, const int __c);  
 uint8x16_t vsetq_lane_u8 (uint8_t __a, uint8x16_t __b, const int __c);  
 uint16x8_t vsetq_lane_u16 (uint16_t __a, uint16x8_t __b, const int __c);  
 uint32x4_t vsetq_lane_u32 (uint32_t __a, uint32x4_t __b, const int __c);  
 poly8x16_t vsetq_lane_p8 (poly8_t __a, poly8x16_t __b, const int __c);  
 poly16x8_t vsetq_lane_p16 (poly16_t __a, poly16x8_t __b, const int __c);  
 int64x2_t vsetq_lane_s64 (int64_t __a, int64x2_t __b, const int __c);  
 uint64x2_t vsetq_lane_u64 (uint64_t __a, uint64x2_t __b, const int __c);  
 /****************************************Create vector from literal bit pattern*********/  
 /*--vmov -> ; creates a vector from a 64-bit pattern.  
 Initialize a vector from a literal bit pattern.--*/  
 int8x8_t vcreate_s8 (uint64_t __a);//_mm_loadl_epi64  
 int16x4_t vcreate_s16 (uint64_t __a);//_mm_loadl_epi64  
 int32x2_t vcreate_s32 (uint64_t __a);//_mm_loadl_epi64  
 int64x1_t vcreate_s64 (uint64_t __a);//_mm_loadl_epi64  
 float32x2_t vcreate_f32 (uint64_t __a);  
 uint8x8_t vcreate_u8 (uint64_t __a);//_mm_loadl_epi64  
 uint16x4_t vcreate_u16 (uint64_t __a);//_mm_loadl_epi64  
 uint32x2_t vcreate_u32 (uint64_t __a);//_mm_loadl_epi64  
 uint64x1_t vcreate_u64 (uint64_t __a);//_mm_loadl_epi64  
 poly8x8_t vcreate_p8 (uint64_t __a);//_mm_loadl_epi64  
 poly16x4_t vcreate_p16 (uint64_t __a);//_mm_loadl_epi64  
 /*****************************************Set all lanes to the same value***************/  
 /*--1、Load all lanes of vector to the same literal value: vdup/vmov -> ri = a;  
 duplicates a scalar into every element of the destination vector.  
 Load all lanes of vector to the same literal value--*/  
 int8x8_t vdup_n_s8 (int8_t __a);//_mm_set1_epi8  
 int16x4_t vdup_n_s16 (int16_t __a);//_mm_set1_epi16  
 int32x2_t vdup_n_s32 (int32_t __a);//_mm_set1_epi32  
 float32x2_t vdup_n_f32 (float32_t __a);//_mm_set1_ps  
 uint8x8_t vdup_n_u8 (uint8_t __a);//_mm_set1_epi8  
 uint16x4_t vdup_n_u16 (uint16_t __a);//_mm_set1_epi16  
 uint32x2_t vdup_n_u32 (uint32_t __a);//_mm_set1_epi32  
 poly8x8_t vdup_n_p8 (poly8_t __a);//_mm_set1_epi8  
 poly16x4_t vdup_n_p16 (poly16_t __a);//_mm_set1_epi16  
 int64x1_t vdup_n_s64 (int64_t __a);  
 uint64x1_t vdup_n_u64 (uint64_t __a);  
 int8x16_t vdupq_n_s8 (int8_t __a);//_mm_set1_epi8  
 int16x8_t vdupq_n_s16 (int16_t __a);//_mm_set1_epi16  
 int32x4_t vdupq_n_s32 (int32_t __a);//_mm_set1_epi32  
 float32x4_t vdupq_n_f32 (float32_t __a);//_mm_set1_ps  
 uint8x16_t vdupq_n_u8 (uint8_t __a);//_mm_set1_epi8  
 uint16x8_t vdupq_n_u16 (uint16_t __a);//_mm_set1_epi16  
 uint32x4_t vdupq_n_u32 (uint32_t __a);//_mm_set1_epi32  
 poly8x16_t vdupq_n_p8 (poly8_t __a);//_mm_set1_epi8  
 poly16x8_t vdupq_n_p16 (poly16_t __a);//_mm_set1_epi16  
 int64x2_t vdupq_n_s64 (int64_t __a);  
 uint64x2_t vdupq_n_u64 (uint64_t __a);  
 int8x8_t vmov_n_s8 (int8_t __a);//_mm_set1_epi8  
 int16x4_t vmov_n_s16 (int16_t __a);//_mm_set1_epi16  
 int32x2_t vmov_n_s32 (int32_t __a);//_mm_set1_epi32  
 float32x2_t vmov_n_f32 (float32_t __a);//_mm_set1_ps  
 uint8x8_t vmov_n_u8 (uint8_t __a);//_mm_set1_epi8  
 uint16x4_t vmov_n_u16 (uint16_t __a);//_mm_set1_epi16  
 uint32x2_t vmov_n_u32 (uint32_t __a);//_mm_set1_epi32  
 poly8x8_t vmov_n_p8 (poly8_t __a);//_mm_set1_epi8  
 poly16x4_t vmov_n_p16 (poly16_t __a);//_mm_set1_epi16  
 int64x1_t vmov_n_s64 (int64_t __a);  
 uint64x1_t vmov_n_u64 (uint64_t __a);  
 int8x16_t vmovq_n_s8 (int8_t __a);//_mm_set1_epi8  
 int16x8_t vmovq_n_s16 (int16_t __a);//_mm_set1_epi16  
 int32x4_t vmovq_n_s32 (int32_t __a);//_mm_set1_epi32  
 float32x4_t vmovq_n_f32 (float32_t __a);//_mm_set1_ps  
 uint8x16_t vmovq_n_u8 (uint8_t __a);//_mm_set1_epi8  
 uint16x8_t vmovq_n_u16 (uint16_t __a);//_mm_set1_epi16  
 uint32x4_t vmovq_n_u32 (uint32_t __a);//_mm_set1_epi32  
 poly8x16_t vmovq_n_p8 (poly8_t __a);//_mm_set1_epi8  
 poly16x8_t vmovq_n_p16 (poly16_t __a);//_mm_set1_epi16  
 int64x2_t vmovq_n_s64 (int64_t __a);  
 uint64x2_t vmovq_n_u64 (uint64_t __a);  
 /*--2、Load all lanes of the vector to the value of a lane of a vector:  
 vdup/vmov -> ri = a[b]; 
 duplicates a scalar into every element of the destination vector.--*/  
 int8x8_t vdup_lane_s8 (int8x8_t __a, const int __b);  
 int16x4_t vdup_lane_s16 (int16x4_t __a, const int __b);  
 int32x2_t vdup_lane_s32 (int32x2_t __a, const int __b);  
 float32x2_t vdup_lane_f32 (float32x2_t __a, const int __b);  
 uint8x8_t vdup_lane_u8 (uint8x8_t __a, const int __b);  
 uint16x4_t vdup_lane_u16 (uint16x4_t __a, const int __b);  
 uint32x2_t vdup_lane_u32 (uint32x2_t __a, const int __b);  
 poly8x8_t vdup_lane_p8 (poly8x8_t __a, const int __b);  
 poly16x4_t vdup_lane_p16 (poly16x4_t __a, const int __b);  
 int64x1_t vdup_lane_s64 (int64x1_t __a, const int __b);  
 uint64x1_t vdup_lane_u64 (uint64x1_t __a, const int __b);  
 int8x16_t vdupq_lane_s8 (int8x8_t __a, const int __b);  
 int16x8_t vdupq_lane_s16 (int16x4_t __a, const int __b);  
 int32x4_t vdupq_lane_s32 (int32x2_t __a, const int __b);  
 float32x4_t vdupq_lane_f32 (float32x2_t __a, const int __b);  
 uint8x16_t vdupq_lane_u8 (uint8x8_t __a, const int __b);  
 uint16x8_t vdupq_lane_u16 (uint16x4_t __a, const int __b);  
 uint32x4_t vdupq_lane_u32 (uint32x2_t __a, const int __b);  
 poly8x16_t vdupq_lane_p8 (poly8x8_t __a, const int __b);  
 poly16x8_t vdupq_lane_p16 (poly16x4_t __a, const int __b);  
 int64x2_t vdupq_lane_s64 (int64x1_t __a, const int __b);//_mm_unpacklo_epi64  
 uint64x2_t vdupq_lane_u64 (uint64x1_t __a, const int __b);//_mm_unpacklo_epi64  
 /********************************************Combining vectors**************************/  
 /*--长指令, -> r0 = a0, ..., r7 = a7, r8 = b0, ..., r15 = b7; 
 joins two 64-bit vectors into a single 128-bit vector.  
 The output vector contains twice the number of elements as each input vector.  
 The lower half of the output vector contains the elements of the first input vector.--*/  
 int8x16_t vcombine_s8 (int8x8_t __a, int8x8_t __b);//_mm_unpacklo_epi64  
 int16x8_t vcombine_s16 (int16x4_t __a, int16x4_t __b);//_mm_unpacklo_epi64  
 int32x4_t vcombine_s32 (int32x2_t __a, int32x2_t __b);//_mm_unpacklo_epi64  
 int64x2_t vcombine_s64 (int64x1_t __a, int64x1_t __b);//_mm_unpacklo_epi64  
 float32x4_t vcombine_f32 (float32x2_t __a, float32x2_t __b);  
 uint8x16_t vcombine_u8 (uint8x8_t __a, uint8x8_t __b);//_mm_unpacklo_epi64  
 uint16x8_t vcombine_u16 (uint16x4_t __a, uint16x4_t __b);//_mm_unpacklo_epi64  
 uint32x4_t vcombine_u32 (uint32x2_t __a, uint32x2_t __b);//_mm_unpacklo_epi64  
 uint64x2_t vcombine_u64 (uint64x1_t __a, uint64x1_t __b);//_mm_unpacklo_epi64  
 poly8x16_t vcombine_p8 (poly8x8_t __a, poly8x8_t __b);//_mm_unpacklo_epi64  
 poly16x8_t vcombine_p16 (poly16x4_t __a, poly16x4_t __b);//_mm_unpacklo_epi64  
 /***************************************Splitting vectors*******************************/  
 /*--1、窄指令, -> ri = a(i+4); returns the higher half of the 128-bit input vector. The 
 output is a 64-bit vector that has half the number of elements as the input vector.--*/  
 int8x8_t vget_high_s8 (int8x16_t __a);//_mm_unpackhi_epi64  
 int16x4_t vget_high_s16 (int16x8_t __a);//_mm_unpackhi_epi64  
 int32x2_t vget_high_s32 (int32x4_t __a);//_mm_unpackhi_epi64  
 int64x1_t vget_high_s64 (int64x2_t __a);//_mm_unpackhi_epi64  
 float32x2_t vget_high_f32 (float32x4_t __a);  
 uint8x8_t vget_high_u8 (uint8x16_t __a);//_mm_unpackhi_epi64  
 uint16x4_t vget_high_u16 (uint16x8_t __a);//_mm_unpackhi_epi64  
 uint32x2_t vget_high_u32 (uint32x4_t __a);//_mm_unpackhi_epi64  
 uint64x1_t vget_high_u64 (uint64x2_t __a);//_mm_unpackhi_epi64  
 poly8x8_t vget_high_p8 (poly8x16_t __a);//_mm_unpackhi_epi64  
 poly16x4_t vget_high_p16 (poly16x8_t __a);//_mm_unpackhi_epi64  
 /*--2、窄指令, -> ri = ai; returns the lower half of the 128-bit input vector. The 
 output is a 64-bit vector that has half the number of elements as the input vector.--*/  
 int8x8_t vget_low_s8 (int8x16_t __a);  
 int16x4_t vget_low_s16 (int16x8_t __a);  
 int32x2_t vget_low_s32 (int32x4_t __a);  
 float32x2_t vget_low_f32 (float32x4_t __a);  
 uint8x8_t vget_low_u8 (uint8x16_t __a);  
 uint16x4_t vget_low_u16 (uint16x8_t __a);  
 uint32x2_t vget_low_u32 (uint32x4_t __a);  
 poly8x8_t vget_low_p8 (poly8x16_t __a);  
 poly16x4_t vget_low_p16 (poly16x8_t __a);  
 int64x1_t vget_low_s64 (int64x2_t __a);  
 uint64x1_t vget_low_u64 (uint64x2_t __a);  
 /****************************************************Conversions************************/  
 /*--1、Convert from float: vcvt ->, convert from floating-point to integer.--*/  
 int32x2_t vcvt_s32_f32 (float32x2_t __a);  
 uint32x2_t vcvt_u32_f32 (float32x2_t __a);  
 int32x4_t vcvtq_s32_f32 (float32x4_t __a);  
 uint32x4_t vcvtq_u32_f32 (float32x4_t __a);  
 int32x2_t vcvt_n_s32_f32 (float32x2_t __a, const int __b);  
 uint32x2_t vcvt_n_u32_f32 (float32x2_t __a, const int __b);  
 int32x4_t vcvtq_n_s32_f32 (float32x4_t __a, const int __b);  
 uint32x4_t vcvtq_n_u32_f32 (float32x4_t __a, const int __b);  
 /*--2、Convert to float: vcvt ->, convert from integer to floating-point.--*/  
 float32x2_t vcvt_f32_s32 (int32x2_t __a);  
 float32x2_t vcvt_f32_u32 (uint32x2_t __a);  
 float32x4_t vcvtq_f32_s32 (int32x4_t __a);  
 float32x4_t vcvtq_f32_u32 (uint32x4_t __a);  
 float32x2_t vcvt_n_f32_s32 (int32x2_t __a, const int __b);  
 float32x2_t vcvt_n_f32_u32 (uint32x2_t __a, const int __b);  
 float32x4_t vcvtq_n_f32_s32 (int32x4_t __a, const int __b);  
 float32x4_t vcvtq_n_f32_u32 (uint32x4_t __a, const int __b);  
 /*--3、between single-precision and double-precision numbers: vcvt ->--*/  
 float16x4_t vcvt_f16_f32(float32x4_t a);  
 float32x4_t vcvt_f32_f16(float16x4_t a);  
 /*************************************************Move**********************************/  
 /*--1、Vector narrow integer(窄指令): vmovn -> ri = ai[0...8]; copies the least  
 significant half of each element of a quadword vector into  
 the corresponding elements of a doubleword vector.--*/  
 int8x8_t vmovn_s16 (int16x8_t __a);  
 int16x4_t vmovn_s32 (int32x4_t __a);  
 int32x2_t vmovn_s64 (int64x2_t __a);  
 uint8x8_t vmovn_u16 (uint16x8_t __a);  
 uint16x4_t vmovn_u32 (uint32x4_t __a);  
 uint32x2_t vmovn_u64 (uint64x2_t __a);  
 /*--2、Vector long move(长指令): vmovl -> sign extends or zero extends each element 
 in a doubleword vector to twice its original length, 
 and places the results in a quadword vector.--*/  
 int16x8_t vmovl_s8 (int8x8_t __a);//_mm_cvtepi8_epi16  
 int32x4_t vmovl_s16 (int16x4_t __a);//_mm_cvtepi16_epi32  
 int64x2_t vmovl_s32 (int32x2_t __a);//_mm_cvtepi32_epi64  
 uint16x8_t vmovl_u8 (uint8x8_t __a);//_mm_cvtepu8_epi16  
 uint32x4_t vmovl_u16 (uint16x4_t __a);//_mm_cvtepu16_epi32  
 uint64x2_t vmovl_u32 (uint32x2_t __a);////_mm_cvtepu32_epi64  
 /*--3、Vector saturating narrow integer(窄指令): vqmovn -> copies each element of the 
 operand vector to the corresponding element of the destination vector.  
 The result element is half the width of  
 the operand element, and values are saturated to the result width. 
 The results are the same type as the operands.--*/  
 int8x8_t vqmovn_s16 (int16x8_t __a);//_mm_packs_epi16  
 int16x4_t vqmovn_s32 (int32x4_t __a);//_mm_packs_epi32  
 int32x2_t vqmovn_s64 (int64x2_t __a);  
 uint8x8_t vqmovn_u16 (uint16x8_t __a);  
 uint16x4_t vqmovn_u32 (uint32x4_t __a);  
 uint32x2_t vqmovn_u64 (uint64x2_t __a);  
 /*--4、Vector saturating narrow integer signed->unsigned(窄指令): copies each element of 
 the operand vector to the corresponding element of the destination vector. 
 The result element is half the width of the operand element, 
 and values are saturated to the result width. 
 The elements in the operand are signed and the elements in the result are unsigned.--*/  
 uint8x8_t vqmovun_s16 (int16x8_t __a);//_mm_packus_epi16  
 uint16x4_t vqmovun_s32 (int32x4_t __a);//_mm_packus_epi32  
 uint32x2_t vqmovun_s64 (int64x2_t __a);  
 /******************************************************Table lookup*********************/  
 /*--1、Table lookup: vtbl -> uses byte indexes in a control vector to look up byte  
 values in a table and generate a new vector. Indexes out of range return 0.  
 The table is in Vector1 and uses one(or two or three or four)D registers.--*/  
 int8x8_t vtbl1_s8 (int8x8_t __a, int8x8_t __b);  
 uint8x8_t vtbl1_u8 (uint8x8_t __a, uint8x8_t __b);  
 poly8x8_t vtbl1_p8 (poly8x8_t __a, uint8x8_t __b);  
 int8x8_t vtbl2_s8 (int8x8x2_t __a, int8x8_t __b);  
 uint8x8_t vtbl2_u8 (uint8x8x2_t __a, uint8x8_t __b);  
 poly8x8_t vtbl2_p8 (poly8x8x2_t __a, uint8x8_t __b);  
 int8x8_t vtbl3_s8 (int8x8x3_t __a, int8x8_t __b);  
 uint8x8_t vtbl3_u8 (uint8x8x3_t __a, uint8x8_t __b);  
 poly8x8_t vtbl3_p8 (poly8x8x3_t __a, uint8x8_t __b);  
 int8x8_t vtbl4_s8 (int8x8x4_t __a, int8x8_t __b);  
 uint8x8_t vtbl4_u8 (uint8x8x4_t __a, uint8x8_t __b);  
 poly8x8_t vtbl4_p8 (poly8x8x4_t __a, uint8x8_t __b);  
 /*--2、Extended table lookup: vtbx -> uses byte indexes in a control vector to look up 
 byte values in a table and generate a new vector. Indexes out of range leave the  
 destination element unchanged.The table is in Vector2 and uses one(or two or three or 
 four) D register. Vector1 contains the elements of the destination vector.--*/  
 int8x8_t vtbx1_s8 (int8x8_t __a, int8x8_t __b, int8x8_t __c);  
 uint8x8_t vtbx1_u8 (uint8x8_t __a, uint8x8_t __b, uint8x8_t __c);  
 poly8x8_t vtbx1_p8 (poly8x8_t __a, poly8x8_t __b, uint8x8_t __c);  
 int8x8_t vtbx2_s8 (int8x8_t __a, int8x8x2_t __b, int8x8_t __c);  
 uint8x8_t vtbx2_u8 (uint8x8_t __a, uint8x8x2_t __b, uint8x8_t __c);  
 poly8x8_t vtbx2_p8 (poly8x8_t __a, poly8x8x2_t __b, uint8x8_t __c);  
 int8x8_t vtbx3_s8 (int8x8_t __a, int8x8x3_t __b, int8x8_t __c);  
 uint8x8_t vtbx3_u8 (uint8x8_t __a, uint8x8x3_t __b, uint8x8_t __c);  
 poly8x8_t vtbx3_p8 (poly8x8_t __a, poly8x8x3_t __b, uint8x8_t __c);  
 int8x8_t vtbx4_s8 (int8x8_t __a, int8x8x4_t __b, int8x8_t __c);  
 uint8x8_t vtbx4_u8 (uint8x8_t __a, uint8x8x4_t __b, uint8x8_t __c);  
 poly8x8_t vtbx4_p8 (poly8x8_t __a, poly8x8x4_t __b, uint8x8_t __c);  
 /***************************************Multiply, scalar, lane**************************/  
 /*--1、Vector multiply by scalar: vmul -> ri = ai * b;  
 multiplies each element in a vector by a scalar,  
 and places the results in the destination vector.--*/  
 int16x4_t vmul_n_s16 (int16x4_t __a, int16_t __b);  
 int32x2_t vmul_n_s32 (int32x2_t __a, int32_t __b);  
 float32x2_t vmul_n_f32 (float32x2_t __a, float32_t __b);  
 uint16x4_t vmul_n_u16 (uint16x4_t __a, uint16_t __b);  
 uint32x2_t vmul_n_u32 (uint32x2_t __a, uint32_t __b);  
 int16x8_t vmulq_n_s16 (int16x8_t __a, int16_t __b);  
 int32x4_t vmulq_n_s32 (int32x4_t __a, int32_t __b);  
 float32x4_t vmulq_n_f32 (float32x4_t __a, float32_t __b);  
 uint16x8_t vmulq_n_u16 (uint16x8_t __a, uint16_t __b);  
 uint32x4_t vmulq_n_u32 (uint32x4_t __a, uint32_t __b);  
 /*--2、Vector multiply by scalar: -> ri = ai * b[c];  
 multiplies the first vector by a scalar.  
 The scalar is the element in the second vector with index c.--*/  
 int16x4_t vmul_lane_s16 (int16x4_t __a, int16x4_t __b, const int __c);  
 int32x2_t vmul_lane_s32 (int32x2_t __a, int32x2_t __b, const int __c);  
 float32x2_t vmul_lane_f32 (float32x2_t __a, float32x2_t __b, const int __c);  
 uint16x4_t vmul_lane_u16 (uint16x4_t __a, uint16x4_t __b, const int __c);  
 uint32x2_t vmul_lane_u32 (uint32x2_t __a, uint32x2_t __b, const int __c);  
 int16x8_t vmulq_lane_s16 (int16x8_t __a, int16x4_t __b, const int __c);  
 int32x4_t vmulq_lane_s32 (int32x4_t __a, int32x2_t __b, const int __c);  
 float32x4_t vmulq_lane_f32 (float32x4_t __a, float32x2_t __b, const int __c);  
 uint16x8_t vmulq_lane_u16 (uint16x8_t __a, uint16x4_t __b, const int __c);  
 uint32x4_t vmulq_lane_u32 (uint32x4_t __a, uint32x2_t __b, const int __c);  
 /*--3、Vector long multiply with scalar: vmull ->  ri = ai * b; 
 multiplies a vector by a scalar.  
 Elements in the result are wider than elements in input vector.--*/  
 int32x4_t vmull_n_s16 (int16x4_t __a, int16_t __b);  
 int64x2_t vmull_n_s32 (int32x2_t __a, int32_t __b);  
 uint32x4_t vmull_n_u16 (uint16x4_t __a, uint16_t __b);  
 uint64x2_t vmull_n_u32 (uint32x2_t __a, uint32_t __b);  
 /*--4、Vector long multiply by scalar: vmull -> ri = ai * b[c]; 
 multiplies the first vector by a scalar.  
 The scalar is the element in the second vector with index c.  
 The elements in the result are wider than the elements in input vector.--*/  
 int32x4_t vmull_lane_s16 (int16x4_t __a, int16x4_t __b, const int __c);  
 int64x2_t vmull_lane_s32 (int32x2_t __a, int32x2_t __b, const int __c);  
 uint32x4_t vmull_lane_u16 (uint16x4_t __a, uint16x4_t __b, const int __c);  
 uint64x2_t vmull_lane_u32 (uint32x2_t __a, uint32x2_t __b, const int __c);  
 /*--5、Vector saturating doubling long multiply with scalar: vqdmull -> ri = sat(ai * b); 
 multiplies the elements in the vector by a scalar, and doubles the results.  
 If any of the results overflow, they are saturated and the sticky QC flag is set.--*/  
 int32x4_t vqdmull_n_s16 (int16x4_t __a, int16_t __b);  
 int64x2_t vqdmull_n_s32 (int32x2_t __a, int32_t __b);  
 /*--6、Vector saturating doubling long multiply by scalar: vqdmull -> ri = sat(ai * b[c]); 
 multiplies the elements in the first vector by a scalar, and doubles the results.  
 The scalar has index c in the second vector. If any of the results overflow,  
 they are saturated and the sticky QC flagis set.--*/  
 int32x4_t vqdmull_lane_s16 (int16x4_t __a, int16x4_t __b, const int __c);  
 int64x2_t vqdmull_lane_s32 (int32x2_t __a, int32x2_t __b, const int __c);  
 /*--7、Vector saturating doubling multiply high with scalar: vqdmulh -> ri = sat(ai * b) 
 multiplies the elements of the vector by a scalar, and doubles the results. 
 It then returns only the high half of the results. 
 If any of the results overflow, they are saturated and the sticky QC flag is set.--*/  
 int16x4_t vqdmulh_n_s16 (int16x4_t __a, int16_t __b);  
 int32x2_t vqdmulh_n_s32 (int32x2_t __a, int32_t __b);  
 int16x8_t vqdmulhq_n_s16 (int16x8_t __a, int16_t __b);  
 int32x4_t vqdmulhq_n_s32 (int32x4_t __a, int32_t __b);  
 /*--8、Vector saturating doubling multiply high by scalar:  
 vqdmulh -> ri = sat(ai * b[c]); 
 multiplies the elements of the first vector by a scalar, and doubles the results. It then 
 returns only the high half of the results. The scalar has index n in the second vector. 
 If any of the results overflow, they are saturated and the sticky QC flag is set.--*/  
 int16x4_t vqdmulh_lane_s16 (int16x4_t __a, int16x4_t __b, const int __c);  
 int32x2_t vqdmulh_lane_s32 (int32x2_t __a, int32x2_t __b, const int __c);  
 int16x8_t vqdmulhq_lane_s16 (int16x8_t __a, int16x4_t __b, const int __c);  
 int32x4_t vqdmulhq_lane_s32 (int32x4_t __a, int32x2_t __b, const int __c);  
 /*--9、Vector saturating rounding doubling multiply high with scalar:  
 vqqrdmulh -> ri = sat(ai * b); 
 multiplies the elements of the vector by a scalar and doubles the results.  
 It then returns only the high half of the rounded results.  
 If any of the results overflow, they are saturated and the sticky QC flag is set.--*/  
 int16x4_t vqrdmulh_n_s16 (int16x4_t __a, int16_t __b);  
 int32x2_t vqrdmulh_n_s32 (int32x2_t __a, int32_t __b);  
 int16x8_t vqrdmulhq_n_s16 (int16x8_t __a, int16_t __b);  
 int32x4_t vqrdmulhq_n_s32 (int32x4_t __a, int32_t __b);  
 /*--10、Vector rounding saturating doubling multiply high by scalar:  
 vqrdmulh -> ri = sat(ai * b[c]); 
 multiplies the elements of the first vector by a scalar and doubles the results. 
 It then returns only the high half of the rounded results. 
 The scalar has index n in the second vector. If any of the results overflow,  
 they are saturated and the sticky QC flag is set.--*/  
 int16x4_t vqrdmulh_lane_s16 (int16x4_t __a, int16x4_t __b, const int __c);  
 int32x2_t vqrdmulh_lane_s32 (int32x2_t __a, int32x2_t __b, const int __c);  
 int16x8_t vqrdmulhq_lane_s16 (int16x8_t __a, int16x4_t __b, const int __c);  
 int32x4_t vqrdmulhq_lane_s32 (int32x4_t __a, int32x2_t __b, const int __c);  
 /*--11、Vector multiply accumulate with scalar: vmla -> ri = ai + bi * c; 
 multiplies each element in the second vector by a scalar,  
 and adds the results to the corresponding elements of the first vector.--*/  
 int16x4_t vmla_n_s16 (int16x4_t __a, int16x4_t __b, int16_t __c);  
 int32x2_t vmla_n_s32 (int32x2_t __a, int32x2_t __b, int32_t __c);  
 float32x2_t vmla_n_f32 (float32x2_t __a, float32x2_t __b, float32_t __c);  
 uint16x4_t vmla_n_u16 (uint16x4_t __a, uint16x4_t __b, uint16_t __c);  
 uint32x2_t vmla_n_u32 (uint32x2_t __a, uint32x2_t __b, uint32_t __c);  
 int16x8_t vmlaq_n_s16 (int16x8_t __a, int16x8_t __b, int16_t __c);  
 int32x4_t vmlaq_n_s32 (int32x4_t __a, int32x4_t __b, int32_t __c);  
 float32x4_t vmlaq_n_f32 (float32x4_t __a, float32x4_t __b, float32_t __c);  
 uint16x8_t vmlaq_n_u16 (uint16x8_t __a, uint16x8_t __b, uint16_t __c);  
 uint32x4_t vmlaq_n_u32 (uint32x4_t __a, uint32x4_t __b, uint32_t __c);  
 /*--12、Vector multiply accumulate by scalar: vmla -> ri = ai + bi * c[d]; 
 multiplies each element in the second vector by a scalar,  
 and adds the results to the corresponding elements of the first vector.  
 The scalar has index d in the third vector.--*/  
 int16x4_t vmla_lane_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c, const int __d);  
 int32x2_t vmla_lane_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c, const int __d);  
 float32x2_t vmla_lane_f32 (float32x2_t __a, float32x2_t __b, float32x2_t __c,  
     const int __d);  
 uint16x4_t vmla_lane_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c, const int __d);  
 uint32x2_t vmla_lane_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c, const int __d);  
 int16x8_t vmlaq_lane_s16 (int16x8_t __a, int16x8_t __b, int16x4_t __c, const int __d);  
 int32x4_t vmlaq_lane_s32 (int32x4_t __a, int32x4_t __b, int32x2_t __c, const int __d);  
 float32x4_t vmlaq_lane_f32 (float32x4_t __a, float32x4_t __b, float32x2_t __c,  
     const int __d);  
 uint16x8_t vmlaq_lane_u16 (uint16x8_t __a, uint16x8_t __b, uint16x4_t __c, const int __d);  
 uint32x4_t vmlaq_lane_u32 (uint32x4_t __a, uint32x4_t __b, uint32x2_t __c, const int __d);  
 /*--13、Vector widening multiply accumulate with scalar: vmlal -> ri = ai + bi * c; 
 multiplies each element in the second vector by a scalar, and adds the results into the  
 corresponding elements of the first vector.  
 The scalar has index n in the third vector. The elements in the result are wider.--*/  
 int32x4_t vmlal_n_s16 (int32x4_t __a, int16x4_t __b, int16_t __c);  
 int64x2_t vmlal_n_s32 (int64x2_t __a, int32x2_t __b, int32_t __c);  
 uint32x4_t vmlal_n_u16 (uint32x4_t __a, uint16x4_t __b, uint16_t __c);  
 uint64x2_t vmlal_n_u32 (uint64x2_t __a, uint32x2_t __b, uint32_t __c);  
 /*--14、Vector widening multiply accumulate by scalar: vmlal -> ri = ai + bi * c[d]; 
 multiplies each element in the second vector by a scalar, and adds the results to the  
 corresponding elements of the first vector. The scalar has index d in the third vector. 
 The elements in the result are wider.--*/  
 int32x4_t vmlal_lane_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c, const int __d);  
 int64x2_t vmlal_lane_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c, const int __d);  
 uint32x4_t vmlal_lane_u16 (uint32x4_t __a, uint16x4_t __b, uint16x4_t __c, const int __d);  
 uint64x2_t vmlal_lane_u32 (uint64x2_t __a, uint32x2_t __b, uint32x2_t __c, const int __d);  
 /*--15、Vector widening saturating doubling multiply accumulate with scalar:  
 vqdmlal -> ri = sat(ai + bi * c); 
 multiplies the elements in the second vector by a scalar, and doubles the results.  
 It then adds the results to the elements in the first vector. 
 If any of the results overflow, they are saturated and the sticky QC flag is set.--*/  
 int32x4_t vqdmlal_n_s16 (int32x4_t __a, int16x4_t __b, int16_t __c);  
 int64x2_t vqdmlal_n_s32 (int64x2_t __a, int32x2_t __b, int32_t __c);  
 /*--16、Vector widening saturating doubling multiply accumulate by scalar:  
 vqdmlal -> ri = sat(ai + bi * c[d]) 
 multiplies each element in the second vector by a scalar, doubles the results and adds  
 them to the corresponding elements of the first vector. The scalar has index d in the  
 third vector. If any of the results overflow, 
 they are saturated and the sticky QC flag is set.--*/  
 int32x4_t vqdmlal_lane_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c, const int __d);  
 int64x2_t vqdmlal_lane_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c, const int __d);  
 /*--17、Vector multiply subtract with scalar: vmls -> ri = ai - bi * c; 
 multiplies each element in a vector by a scalar, subtracts the results from the  
 corresponding elements of the destination vector,  
 and places the final results in the destination vector.--*/  
 int16x4_t vmls_n_s16 (int16x4_t __a, int16x4_t __b, int16_t __c);  
 int32x2_t vmls_n_s32 (int32x2_t __a, int32x2_t __b, int32_t __c);  
 float32x2_t vmls_n_f32 (float32x2_t __a, float32x2_t __b, float32_t __c);  
 uint16x4_t vmls_n_u16 (uint16x4_t __a, uint16x4_t __b, uint16_t __c);  
 uint32x2_t vmls_n_u32 (uint32x2_t __a, uint32x2_t __b, uint32_t __c);  
 int16x8_t vmlsq_n_s16 (int16x8_t __a, int16x8_t __b, int16_t __c);  
 int32x4_t vmlsq_n_s32 (int32x4_t __a, int32x4_t __b, int32_t __c);  
 float32x4_t vmlsq_n_f32 (float32x4_t __a, float32x4_t __b, float32_t __c);  
 uint16x8_t vmlsq_n_u16 (uint16x8_t __a, uint16x8_t __b, uint16_t __c);  
 uint32x4_t vmlsq_n_u32 (uint32x4_t __a, uint32x4_t __b, uint32_t __c);  
 /*--18、Vector multiply subtract by scalar: vmls -> ri = ai - bi * c[d]; 
 multiplies each element in the second vector by a scalar, and subtracts them from the 
 corresponding elements of the first vector. 
 The scalar has index d in the third vector.--*/  
 int16x4_t vmls_lane_s16 (int16x4_t __a, int16x4_t __b, int16x4_t __c, const int __d);  
 int32x2_t vmls_lane_s32 (int32x2_t __a, int32x2_t __b, int32x2_t __c, const int __d);  
 float32x2_t vmls_lane_f32 (float32x2_t __a, float32x2_t __b, float32x2_t __c,  
     const int __d);  
 uint16x4_t vmls_lane_u16 (uint16x4_t __a, uint16x4_t __b, uint16x4_t __c, const int __d);  
 uint32x2_t vmls_lane_u32 (uint32x2_t __a, uint32x2_t __b, uint32x2_t __c, const int __d);  
 int16x8_t vmlsq_lane_s16 (int16x8_t __a, int16x8_t __b, int16x4_t __c, const int __d);  
 int32x4_t vmlsq_lane_s32 (int32x4_t __a, int32x4_t __b, int32x2_t __c, const int __d);  
 float32x4_t vmlsq_lane_f32 (float32x4_t __a, float32x4_t __b, float32x2_t __c,  
     const int __d);  
 uint16x8_t vmlsq_lane_u16 (uint16x8_t __a, uint16x8_t __b, uint16x4_t __c, const int __d);  
 uint32x4_t vmlsq_lane_u32 (uint32x4_t __a, uint32x4_t __b, uint32x2_t __c, const int __d);  
 /*--19、Vector widening multiply subtract with scalar: vmlsl -> ri = ai - bi * c; 
 multiplies the elements in the second vector by a scalar, then subtracts the results from 
 the elements in the first vector. The elements of the result are wider.--*/  
 int32x4_t vmlsl_n_s16 (int32x4_t __a, int16x4_t __b, int16_t __c);  
 int64x2_t vmlsl_n_s32 (int64x2_t __a, int32x2_t __b, int32_t __c);  
 uint32x4_t vmlsl_n_u16 (uint32x4_t __a, uint16x4_t __b, uint16_t __c);  
 uint64x2_t vmlsl_n_u32 (uint64x2_t __a, uint32x2_t __b, uint32_t __c);  
 /*--20、Vector widening multiply subtract by scalar: vmlsl -> ri = ai - bi * c[d]; 
 multiplies each element in the second vector by a scalar,  
 and subtracts them from the corresponding elements of the first vector.  
 The scalar has index d in the third vector. The elements in the result are wider.--*/  
 int32x4_t vmlsl_lane_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c, const int __d);  
 int64x2_t vmlsl_lane_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c, const int __d);  
 uint32x4_t vmlsl_lane_u16 (uint32x4_t __a, uint16x4_t __b, uint16x4_t __c, const int __d)  
 uint64x2_t vmlsl_lane_u32 (uint64x2_t __a, uint32x2_t __b, uint32x2_t __c, const int __d);  
 /*--21、Vector widening saturating doubling multiply subtract with scalar:  
 vqdmlsl -> ri = sat(ai - bi * c); 
 multiplies the elements of the second vector with a scalar and doubles the results.  
 It then subtracts the results from the elements in the first vector. 
 If any of the results overflow, they are saturated and the sticky QC flag is set.--*/  
 int32x4_t vqdmlsl_n_s16 (int32x4_t __a, int16x4_t __b, int16_t __c);  
 int64x2_t vqdmlsl_n_s32 (int64x2_t __a, int32x2_t __b, int32_t __c);  
 /*--22、Vector widening saturating doubling multiply subtract by scalar: 
 vqdmlsl -> ri = sat(ai - bi * c[[d]); 
 multiplies each element in the second vector by a scalar, doubles the results and subtracts 
 them from the corresponding elements of the first vector. The scalar has index n in the  
 third vector.If any of the results overflow,  
 they are saturated and the sticky QC flag is set.--*/  
 int32x4_t vqdmlsl_lane_s16 (int32x4_t __a, int16x4_t __b, int16x4_t __c, const int __d);  
 int64x2_t vqdmlsl_lane_s32 (int64x2_t __a, int32x2_t __b, int32x2_t __c, const int __d);  
 /*****************************************************Vector extract********************/  
 /*--Vector extract: vext -> extracts n elements from the lower end of the second operand 
 vector and the remaining elements from the higher end of the first, and combines them to 
 form the result vector. The elements from the second operand are placed in the most  
 significant part of the result vector.The elements from the first operand are placed in 
 the least significant part of the result vector.This intrinsic cycles the elements 
 through the lanes if the two input vectors are the same.--*/  
 int8x8_t vext_s8 (int8x8_t __a, int8x8_t __b, const int __c);  
 int16x4_t vext_s16 (int16x4_t __a, int16x4_t __b, const int __c);  
 int32x2_t vext_s32 (int32x2_t __a, int32x2_t __b, const int __c);  
 int64x1_t vext_s64 (int64x1_t __a, int64x1_t __b, const int __c);  
 float32x2_t vext_f32 (float32x2_t __a, float32x2_t __b, const int __c);  
 uint8x8_t vext_u8 (uint8x8_t __a, uint8x8_t __b, const int __c);  
 uint16x4_t vext_u16 (uint16x4_t __a, uint16x4_t __b, const int __c);  
 uint32x2_t vext_u32 (uint32x2_t __a, uint32x2_t __b, const int __c);  
 uint64x1_t vext_u64 (uint64x1_t __a, uint64x1_t __b, const int __c);  
 poly8x8_t vext_p8 (poly8x8_t __a, poly8x8_t __b, const int __c);  
 poly16x4_t vext_p16 (poly16x4_t __a, poly16x4_t __b, const int __c);  
 int8x16_t vextq_s8 (int8x16_t __a, int8x16_t __b, const int __c);//_mm_alignr_epi8   
 int16x8_t vextq_s16 (int16x8_t __a, int16x8_t __b, const int __c);//_mm_alignr_epi8   
 int32x4_t vextq_s32 (int32x4_t __a, int32x4_t __b, const int __c);//_mm_alignr_epi8  
 int64x2_t vextq_s64 (int64x2_t __a, int64x2_t __b, const int __c);//_mm_alignr_epi8  
 float32x4_t vextq_f32 (float32x4_t __a, float32x4_t __b, const int __c);//_mm_alignr_epi8  
 uint8x16_t vextq_u8 (uint8x16_t __a, uint8x16_t __b, const int __c);//_mm_alignr_epi8  
 uint16x8_t vextq_u16 (uint16x8_t __a, uint16x8_t __b, const int __c);//_mm_alignr_epi8  
 uint32x4_t vextq_u32 (uint32x4_t __a, uint32x4_t __b, const int __c);//_mm_alignr_epi8  
 uint64x2_t vextq_u64 (uint64x2_t __a, uint64x2_t __b, const int __c);//_mm_alignr_epi8  
 poly8x16_t vextq_p8 (poly8x16_t __a, poly8x16_t __b, const int __c);//_mm_alignr_epi8  
 poly16x8_t vextq_p16 (poly16x8_t __a, poly16x8_t __b, const int __c);//_mm_alignr_epi8  
 /****************************************************Reverse elements*******************/  
 /*--1、Reverse vector elements (swap endianness): vrev64 -> reverses the order of 8-bit,  
 16-bit, or 32-bit elements within each doubleword of the vector,  
 and places the result in the corresponding destination vector.--*/  
 int8x8_t vrev64_s8 (int8x8_t __a);  
 int16x4_t vrev64_s16 (int16x4_t __a);  
 int32x2_t vrev64_s32 (int32x2_t __a);  
 float32x2_t vrev64_f32 (float32x2_t __a);//_mm_shuffle_ps  
 uint8x8_t vrev64_u8 (uint8x8_t __a);  
 uint16x4_t vrev64_u16 (uint16x4_t __a);  
 uint32x2_t vrev64_u32 (uint32x2_t __a);  
 poly8x8_t vrev64_p8 (poly8x8_t __a);  
 poly16x4_t vrev64_p16 (poly16x4_t __a);  
 int8x16_t vrev64q_s8 (int8x16_t __a);  
 int16x8_t vrev64q_s16 (int16x8_t __a);  
 int32x4_t vrev64q_s32 (int32x4_t __a);  
 float32x4_t vrev64q_f32 (float32x4_t __a);//_mm_shuffle_ps  
 uint8x16_t vrev64q_u8 (uint8x16_t __a);  
 uint16x8_t vrev64q_u16 (uint16x8_t __a);  
 uint32x4_t vrev64q_u32 (uint32x4_t __a);  
 poly8x16_t vrev64q_p8 (poly8x16_t __a);  
 poly16x8_t vrev64q_p16 (poly16x8_t __a);  
 /*--2、Reverse vector elements (swap endianness): vrev32 -> reverses the order of 8-bit  
 or 16-bit elements within each word of the vector,  
 and places the result in the corresponding destination vector.--*/  
 int8x8_t vrev32_s8 (int8x8_t __a);  
 int16x4_t vrev32_s16 (int16x4_t __a);  
 uint8x8_t vrev32_u8 (uint8x8_t __a);  
 uint16x4_t vrev32_u16 (uint16x4_t __a);  
 poly8x8_t vrev32_p8 (poly8x8_t __a);  
 poly16x4_t vrev32_p16 (poly16x4_t __a);  
 int8x16_t vrev32q_s8 (int8x16_t __a);  
 int16x8_t vrev32q_s16 (int16x8_t __a);  
 

你可能感兴趣的:(ARM Neon Intrinsics各函数介绍)

C语言宏函数南林yan C语言 c语言
一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
C语言如何定义宏函数？小九格物 c语言
在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
理解Gunicorn：Python WSGI服务器的基石范范0825 ipython linux 运维
理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）研学随笔 arcgis 经验分享
我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
每日一题——第八十四题互联网打工人no1 C语言程序设计每日一练 c语言
题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
网易严选官方旗舰店，优质商品，卓越服务高省_飞智666600
网易严选官方旗舰店是网易旗下的一家电商平台，以提供优质商品和卓越服务而闻名。作为一名SEO优化师，我将为您详细介绍网易严选官方旗舰店，并重点强调其特点和优势。大家好！我是高省APP最大团队&联合创始人飞智导师。相较于其他返利app，高省APP的佣金更高，模式更好，最重要的是，终端用户不会流失！高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几
Python中os.environ基本介绍及使用方法鹤冲天Pro #Python python 服务器开发语言
文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
Python教程：一文了解使用Python处理XPath 旦莫 Python进阶 python 开发语言
目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
PHP环境搭建详细教程好看资源平台前端 php
PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
基于社交网络算法优化的二维最大熵图像分割智能算法研学社（Jack旭）智能优化算法应用图像分割算法 php 开发语言
智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
直返最高等级与直返APP：无需邀请码的返利新体验古楼
随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
SQL Server_查询某一数据库中的所有表的内容 qq_42772833 SQL Server 数据库 sqlserver
1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【加密社】Solidity 中的事件机制及其应用加密社闲侃区块链智能合约区块链
加密社引言在Solidity合约开发过程中，事件（Events）是一种非常重要的机制。它们不仅能够让开发者记录智能合约的重要状态变更，还能够让外部系统（如前端应用）监听这些状态的变化。本文将详细介绍Solidity中的事件机制以及如何利用不同的手段来触发、监听和获取这些事件。事件存储的地方当我们在Solidity合约中使用emit关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
探索OpenAI和LangChain的适配器集成：轻松切换模型提供商 nseejrukjhad langchain easyui 前端 python
#探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
使用Faiss进行高效相似度搜索 llzwxh888 faiss python
在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
使用LLaVa和Ollama实现多模态RAG示例 llzwxh888 python 人工智能开发语言
本文将详细介绍如何使用LLaVa和Ollama实现多模态RAG（检索增强生成），通过提取图像中的结构化数据、生成图像字幕等功能来展示这一技术的强大之处。安装环境首先，您需要安装以下依赖包：!pipinstallllama-index-multi-modal-llms-ollama!pipinstallllama-index-readers-file!pipinstallunstructured!p
使用Apify加载Twitter消息以进行微调的完整指南 nseejrukjhad twitter easyui 前端 python
#使用Apify加载Twitter消息以进行微调的完整指南##引言在自然语言处理领域，微调模型以适应特定任务是提升模型性能的常见方法。本文将介绍如何使用Apify从Twitter导出聊天信息，以便进一步进行微调。##主要内容###使用Apify导出推文首先，我们需要从Twitter导出推文。Apify可以帮助我们做到这一点。通过Apify的强大功能，我们可以批量抓取和导出数据，适用于各类应用场景。
利用Requests Toolkit轻松完成HTTP请求 nseejrukjhad http 网络协议网络 python
RequestsToolkit的力量：轻松构建HTTP请求Agent在现代软件开发中，API请求是与外部服务交互的核心。RequestsToolkit提供了一种便捷的方式，帮助开发者构建自动化的HTTP请求Agent。本文旨在详细介绍RequestsToolkit的设置、使用和潜在挑战。引言RequestsToolkit是一个强大的工具包，可用于构建执行HTTP请求的智能代理。这对于想要自动化与外
深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具 nseejrukjhad 数据库 python
深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
利用LangChain的StackExchange组件实现智能问答系统 nseejrukjhad langchain microsoft 数据库 python
利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
如何部分格式化提示模板:LangChain中的高级技巧 nseejrukjhad langchain java 服务器 python
标题:如何部分格式化提示模板:LangChain中的高级技巧内容:如何部分格式化提示模板:LangChain中的高级技巧引言在使用大型语言模型(LLM)时,提示工程是一个关键环节。LangChain提供了强大的提示模板功能,让我们能更灵活地构建和管理提示。本文将介绍LangChain中一个高级特性-部分格式化提示模板,这个技巧可以让你的提示管理更加高效和灵活。什么是部分格式化提示模板?部分格式化提
东南林氏之九牧林候选父系祖缘树TheYtree
渊源介绍东晋初年晋安林始祖林禄公入闽，传十世隋右丞林茂，由晋安迁居莆田北螺村。又五世而至林万宠，唐开元间任高平太守，生三子：韬、披、昌。韬公之孙攒，唐德宗立双阙以旌表其孝，时号"阙下林家"。昌公字茂吉，乃万宠公第三子，官兵部司马，配宋氏，生一子名萍。萍于唐贞元间明经及第，官沣洲司马(后追赠中宪大夫)。唐太和年间归隐后，迁居仙游游洋，世称“游洋林”；其后裔居游洋后迁移漳州漳浦路下，由路下林第四房平和
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
Day17笔记-高阶函数 ~在杰难逃~ Python 笔记 python 开发语言 pycharm 数据分析
高阶函数【重点掌握】函数的本质：函数是一个变量，函数名是一个变量名，一个函数可以作为另一个函数的参数或返回值使用如果A函数作为B函数的参数，B函数调用完成之后，会得到一个结果，则B函数被称为高阶函数常用的高阶函数：map(),reduce(),filter(),sorted()1.map()map(func,iterable)，返回值是一个iterator【容器，迭代器】func:函数iterab
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
Python快速入门 —— 第三节：类与对象孤华暗香 Python快速入门 python 开发语言
第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
libyuv之linux编译 jaronho Linux linux 运维服务器
文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
ios内付费 374016526 ios 内付费
近年来写了很多IOS的程序，内付费也用到不少，使用IOS的内付费实现起来比较麻烦，这里我写了一个简单的内付费包，希望对大家有帮助。具体使用如下: 这里的sender其实就是调用者，这里主要是为了回调使用。 [KuroStoreApi kuroStoreProductId:@"产品ID" storeSender:self storeFinishCallBa
20 款优秀的 Linux 终端仿真器 brotherlamp linux linux视频 linux资料 linux自学 linux教程
终端仿真器是一款用其它显示架构重现可视终端的计算机程序。换句话说就是终端仿真器能使哑终端看似像一台连接上了服务器的客户机。终端仿真器允许最终用户用文本用户界面和命令行来访问控制台和应用程序。（LCTT 译注：终端仿真器原意指对大型机-哑终端方式的模拟，不过在当今的 Linux 环境中，常指通过远程或本地方式连接的伪终端，俗称“终端”。）你能从开源世界中找到大量的终端仿真器，它们
Solr Deep Paging(solr 深分页) eksliang solr深分页 solr分页性能问题
转载请出自出处：http://eksliang.iteye.com/blog/2148370 作者：eksliang(ickes) blg:http://eksliang.iteye.com/ 概述长期以来，我们一直有一个深分页问题。如果直接跳到很靠后的页数，查询速度会比较慢。这是因为Solr的需要为查询从开始遍历所有数据。直到Solr的4.7这个问题一直没有一个很好的解决方案。直到solr
数据库面试题 18289753290 面试题数据库
1.union ,union all 网络搜索出的最佳答案： union和union all的区别是,union会自动压缩多个结果集合中的重复结果，而union all则将所有的结果全部显示出来，不管是不是重复。 Union：对两个结果集进行并集操作，不包括重复行，同时进行默认规则的排序； Union All：对两个结果集进行并集操作，包括重复行，不进行排序； 2.索引有哪些分类？作用是
Android TV屏幕适配酷的飞上天空 android
先说下现在市面上TV分辨率的大概情况两种分辨率为主 1.720标清，分辨率为1280x720. 屏幕尺寸以32寸为主，部分电视为42寸 2.1080p全高清，分辨率为1920x1080 屏幕尺寸以42寸为主，此分辨率电视屏幕从32寸到50寸都有适配遇到问题，已1080p尺寸为例：分辨率固定不变，屏幕尺寸变化较大。如：效果图尺寸为1920x1080，如果使用d
Timer定时器与ActionListener联合应用永夜-极光 java
功能:在控制台每秒输出一次代码: package Main; import javax.swing.Timer; import java.awt.event.*; public class T { private static int count = 0; public static void main(String[] args){
Ubuntu14.04系统Tab键不能自动补全问题解决随便小屋 Ubuntu 14.04
Unbuntu 14.4安装之后就在终端中使用Tab键不能自动补全，解决办法如下： 1、利用vi编辑器打开/etc/bash.bashrc文件（需要root权限） sudo vi /etc/bash.bashrc 接下来会提示输入密码 2、找到文件中的下列代码 #enable bash completion in interactive shells #if
学会人际关系三招轻松走职场 aijuans 职场
要想成功，仅有专业能力是不够的，处理好与老板、同事及下属的人际关系也是门大学问。如何才能在职场如鱼得水、游刃有余呢？在此，教您简单实用的三个窍门。　　第一，多汇报最近，管理学又提出了一个新名词“追随力”。它告诉我们，做下属最关键的就是要多请示汇报，让上司随时了解你的工作进度，有了新想法也要及时建议。不知不觉，你就有了“追随力”，上司会越来越了解和信任你。　　第二，勤沟通团队的力
《O2O：移动互联网时代的商业革命》读书笔记 aoyouzi 读书笔记
移动互联网的未来：碎片化内容+碎片化渠道=各式精准、互动的新型社会化营销。 O2O：Online to OffLine 线上线下活动 O2O就是在移动互联网时代，生活消费领域通过线上和线下互动的一种新型商业模式。手机二维码本质：O2O商务行为从线下现实世界到线上虚拟世界的入口。线上虚拟世界创造的本意是打破信息鸿沟，让不同地域、不同需求的人
js实现图片随鼠标滚动的效果百合不是茶 JavaScript 滚动属性的获取图片滚动属性获取页面加载
1,获取样式属性值 top 与顶部的距离 left 与左边的距离 right 与右边的距离 bottom 与下边的距离 zIndex 层叠层次例子:获取左边的宽度,当css写在body标签中时 <div id="adver" style="position:absolute;top:50px;left:1000p
ajax同步异步参数async bijian1013 jquery Ajax async
开发项目开发过程中，需要将ajax的返回值赋到全局变量中，然后在该页面其他地方引用，因为ajax异步的原因一直无法成功，需将async:false，使其变成同步的。格式： $.ajax({ type: 'POST', ur
Webx3框架（1） Bill_chen eclipse spring maven 框架 ibatis
Webx是淘宝开发的一套Web开发框架，Webx3是其第三个升级版本；采用Eclipse的开发环境，现在支持java开发；采用turbine原型的MVC框架，扩展了Spring容器，利用Maven进行项目的构建管理，灵活的ibatis持久层支持，总的来说，还是一套很不错的Web框架。 Webx3遵循turbine风格，velocity的模板被分为layout/screen/control三部
【MongoDB学习笔记五】MongoDB概述 bit1129 mongodb
MongoDB是面向文档的NoSQL数据库，尽量业界还对MongoDB存在一些质疑的声音，比如性能尤其是查询性能、数据一致性的支持没有想象的那么好，但是MongoDB用户群确实已经够多。MongoDB的亮点不在于它的性能，而是它处理非结构化数据的能力以及内置对分布式的支持(复制、分片达到的高可用、高可伸缩)，同时它提供的近似于SQL的查询能力，也是在做NoSQL技术选型时，考虑的一个重要因素。Mo
spring/hibernate/struts2常见异常总结白糖_ Hibernate
Spring ①ClassNotFoundException: org.aspectj.weaver.reflect.ReflectionWorld$ReflectionWorldException 缺少aspectjweaver.jar，该jar包常用于spring aop中 ②java.lang.ClassNotFoundException: org.sprin
jquery easyui表单重置(reset)扩展思路 bozch form jquery easyui reset
在jquery easyui表单中尚未提供表单重置的功能，这就需要自己对其进行扩展。扩展的时候要考虑的控件有： combo,combobox,combogrid,combotree,datebox,datetimebox 需要对其添加reset方法，reset方法就是把初始化的值赋值给当前的组件，这就需要在组件的初始化时将值保存下来。在所有的reset方法添加完毕之后，就需要对fo
编程之美-烙饼排序 bylijinnan 编程之美
package beautyOfCoding; import java.util.Arrays; /* *《编程之美》的思路是：搜索+剪枝。有点像是写下棋程序：当前情况下，把所有可能的下一步都做一遍；在这每一遍操作里面，计算出如果按这一步走的话，能不能赢（得出最优结果）。 *《编程之美》上代码有很多错误，且每个变量的含义令人费解。因此我按我的理解写了以下代码： */
Struts1.X 源码分析之ActionForm赋值原理 chenbowen00 struts
struts1在处理请求参数之前，首先会根据配置文件action节点的name属性创建对应的ActionForm。如果配置了name属性，却找不到对应的ActionForm类也不会报错，只是不会处理本次请求的请求参数。如果找到了对应的ActionForm类，则先判断是否已经存在ActionForm的实例，如果不存在则创建实例，并将其存放在对应的作用域中。作用域由配置文件action节点的s
[空天防御与经济]在获得充足的外部资源之前,太空投资需有限度 comsci 资源
这里有一个常识性的问题: 地球的资源,人类的资金是有限的,而太空是无限的..... 就算全人类联合起来,要在太空中修建大型空间站,也不一定能够成功,因为资源和资金,技术有客观的限制.... &
ORACLE临时表—ON COMMIT PRESERVE ROWS daizj oracle 临时表
ORACLE临时表转临时表：像普通表一样，有结构，但是对数据的管理上不一样，临时表存储事务或会话的中间结果集，临时表中保存的数据只对当前会话可见，所有会话都看不到其他会话的数据，即使其他会话提交了，也看不到。临时表不存在并发行为，因为他们对于当前会话都是独立的。创建临时表时，ORACLE只创建了表的结构（在数据字典中定义），并没有初始化内存空间，当某一会话使用临时表时，ORALCE会
基于Nginx XSendfile+SpringMVC进行文件下载 denger 应用服务器 Web nginx 网络应用 lighttpd
在平常我们实现文件下载通常是通过普通 read-write方式，如下代码所示。 @RequestMapping("/courseware/{id}") public void download(@PathVariable("id") String courseID, HttpServletResp
scanf接受char类型的字符 dcj3sjt126com c
/* 2013年3月11日22:35:54 目的：学习char只接受一个字符 */ # include <stdio.h> int main(void) { int i; char ch; scanf("%d", &i); printf("i = %d\n", i); scanf("%
学编程的价值 dcj3sjt126com 编程
发一个人会编程, 想想以后可以教儿女, 是多么美好的事啊, 不管儿女将来从事什么样的职业, 教一教, 对他思维的开拓大有帮助像这位朋友学习: http://blog.sina.com.cn/s/articlelist_2584320772_0_1.html VirtualGS教程 (By @林泰前): 几十年的老程序员，资深的
二维数组（矩阵）对角线输出飞天奔月二维数组
今天在BBS里面看到这样的面试题目, 1，二维数组（N*N），沿对角线方向，从右上角打印到左下角如N=4： 4*4二维数组 { 1 2 3 4 } { 5 6 7 8 } { 9 10 11 12 } {13 14 15 16 } 打印顺序 4 3 8 2 7 12 1 6 11 16 5 10 15 9 14 13 要
Ehcache（08）——可阻塞的Cache——BlockingCache 234390216 并发 ehcache BlockingCache 阻塞
可阻塞的Cache—BlockingCache 在上一节我们提到了显示使用Ehcache锁的问题，其实我们还可以隐式的来使用Ehcache的锁，那就是通过BlockingCache。BlockingCache是Ehcache的一个封装类，可以让我们对Ehcache进行并发操作。其内部的锁机制是使用的net.
mysqldiff对数据库间进行差异比较 jackyrong mysqld
mysqldiff该工具是官方mysql-utilities工具集的一个脚本，可以用来对比不同数据库之间的表结构，或者同个数据库间的表结构如果在windows下，直接下载mysql-utilities安装就可以了，然后运行后，会跑到命令行下： 1）基本用法 mysqldiff --server1=admin:12345
spring data jpa 方法中可用的关键字 lawrence.li java spring
spring data jpa 支持以方法名进行查询/删除/统计。查询的关键字为find 删除的关键字为delete/remove (>=1.7.x) 统计的关键字为count (>=1.7.x) 修改需要使用@Modifying注解 @Modifying @Query("update User u set u.firstna
Spring的ModelAndView类 nicegege spring
项目中controller的方法跳转的到ModelAndView类，一直很好奇spring怎么实现的？ /* * Copyright 2002-2010 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * yo
搭建 CentOS 6 服务器(13) - rsync、Amanda rensanning centos
（一）rsync Server端 # yum install rsync # vi /etc/xinetd.d/rsync service rsync { disable = no flags = IPv6 socket_type = stream wait
Learn Nodejs 02 toknowme nodejs
（1）npm是什么 npm is the package manager for node 官方网站：https://www.npmjs.com/ npm上有很多优秀的nodejs包，来解决常见的一些问题，比如用node-mysql，就可以方便通过nodejs链接到mysql，进行数据库的操作在开发过程往往会需要用到其他的包，使用npm就可以下载这些包来供程序调用 &nb
Spring MVC 拦截器 xp9802 spring mvc
Controller层的拦截器继承于HandlerInterceptorAdapter HandlerInterceptorAdapter.java 1 public abstract class HandlerInterceptorAdapter implements HandlerIntercep