volk_rename: renamed basically everything in the volk lib to have logically consistent function names

author: Nick Foster <nick@nerdnetworks.org> 2011-01-16 14:03:16 -0800
committer: Nick Foster <nick@nerdnetworks.org> 2011-01-16 14:03:16 -0800
commit: d486ff4b4c039c8b3b06b6519839d522cf69be69 (patch)
tree: bf9858d509fdc0c49130f2b484cc3f1ddb6c399f /volk/include
parent: 5c4aab18e4e5e34ce1f8e286bc534a02c1318932 (diff)
90 files changed, 627 insertions, 629 deletions
diff --git a/volk/include/volk/Makefile.am b/volk/include/volk/Makefile.am
index 99276ab87b..aef1d7ba8c 100644
--- a/volk/include/volk/Makefile.am
+++ b/volk/include/volk/Makefile.am
@@ -41,93 +41,93 @@ volkinclude_HEADERS = \
 	volk.h \
 	volk_cpu.h \
 	volk_environment_init.h \
-	volk_16s_add_quad_aligned16.h \
-	volk_16s_branch_4_state_8_aligned16.h \
-	volk_16sc_deinterleave_16s_aligned16.h \
-	volk_16sc_deinterleave_32f_aligned16.h \
-	volk_16sc_deinterleave_real_16s_aligned16.h \
-	volk_16sc_deinterleave_real_32f_aligned16.h \
-	volk_16sc_deinterleave_real_8s_aligned16.h \
-	volk_16sc_magnitude_16s_aligned16.h \
-	volk_16sc_magnitude_32f_aligned16.h \
-	volk_16s_convert_32f_aligned16.h \
-	volk_16s_convert_32f_unaligned16.h \
-	volk_16s_convert_8s_aligned16.h \
-	volk_16s_convert_8s_unaligned16.h \
-	volk_16s_max_star_aligned16.h \
-	volk_16s_max_star_horizontal_aligned16.h \
-	volk_16s_permute_and_scalar_add_aligned16.h \
-	volk_16s_quad_max_star_aligned16.h \
-	volk_16u_byteswap_aligned16.h \
-	volk_32f_accumulator_aligned16.h \
-	volk_32f_add_aligned16.h \
-	volk_32fc_32f_multiply_aligned16.h \
-	volk_32fc_32f_power_32fc_aligned16.h \
-	volk_32f_calc_spectral_noise_floor_aligned16.h \
-	volk_32fc_atan2_32f_aligned16.h \
-	volk_32fc_conjugate_dot_prod_aligned16.h \
-	volk_32fc_deinterleave_32f_aligned16.h \
-	volk_32fc_deinterleave_64f_aligned16.h \
-	volk_32fc_deinterleave_real_16s_aligned16.h \
-	volk_32fc_deinterleave_real_32f_aligned16.h \
-	volk_32fc_deinterleave_real_64f_aligned16.h \
-	volk_32fc_dot_prod_aligned16.h \
-	volk_32fc_index_max_aligned16.h \
-	volk_32fc_magnitude_16s_aligned16.h \
-	volk_32fc_magnitude_32f_aligned16.h \
-	volk_32fc_multiply_aligned16.h \
-	volk_32f_convert_16s_aligned16.h \
-	volk_32f_convert_16s_unaligned16.h \
-	volk_32f_convert_32s_aligned16.h \
-	volk_32f_convert_32s_unaligned16.h \
-	volk_32f_convert_64f_aligned16.h \
-	volk_32f_convert_64f_unaligned16.h \
-	volk_32f_convert_8s_aligned16.h \
-	volk_32f_convert_8s_unaligned16.h \
-	volk_32fc_power_spectral_density_32f_aligned16.h \
-	volk_32fc_power_spectrum_32f_aligned16.h \
-	volk_32fc_square_dist_aligned16.h \
-	volk_32fc_square_dist_scalar_mult_aligned16.h \
-	volk_32f_divide_aligned16.h \
-	volk_32f_dot_prod_aligned16.h \
-	volk_32f_dot_prod_unaligned16.h \
-	volk_32f_fm_detect_aligned16.h \
-	volk_32f_index_max_aligned16.h \
-	volk_32f_interleave_16sc_aligned16.h \
-	volk_32f_interleave_32fc_aligned16.h \
-	volk_32f_max_aligned16.h \
-	volk_32f_min_aligned16.h \
-	volk_32f_multiply_aligned16.h \
-	volk_32f_normalize_aligned16.h \
-	volk_32f_power_aligned16.h \
-	volk_32f_sqrt_aligned16.h \
-	volk_32f_stddev_aligned16.h \
-	volk_32f_stddev_and_mean_aligned16.h \
-	volk_32f_subtract_aligned16.h \
-	volk_32f_sum_of_poly_aligned16.h \
-	volk_32s_and_aligned16.h \
-	volk_32s_convert_32f_aligned16.h \
-	volk_32s_convert_32f_unaligned16.h \
-	volk_32s_or_aligned16.h \
-	volk_32u_byteswap_aligned16.h \
-	volk_32u_popcnt_aligned16.h \
-	volk_64f_convert_32f_aligned16.h \
-	volk_64f_convert_32f_unaligned16.h \
-	volk_64f_max_aligned16.h \
-	volk_64f_min_aligned16.h \
-	volk_64u_byteswap_aligned16.h \
-	volk_64u_popcnt_aligned16.h \
-	volk_8sc_deinterleave_16s_aligned16.h \
-	volk_8sc_deinterleave_32f_aligned16.h \
-	volk_8sc_deinterleave_real_16s_aligned16.h \
-	volk_8sc_deinterleave_real_32f_aligned16.h \
-	volk_8sc_deinterleave_real_8s_aligned16.h \
-	volk_8sc_multiply_conjugate_16sc_aligned16.h \
-	volk_8sc_multiply_conjugate_32fc_aligned16.h \
-	volk_8s_convert_16s_aligned16.h \
-	volk_8s_convert_16s_unaligned16.h \
-	volk_8s_convert_32f_aligned16.h \
-	volk_8s_convert_32f_unaligned16.h 
+	volk_16s_add_quad_a16.h \
+	volk_16s_branch_4_state_8_a16.h \
+	volk_16sc_deinterleave_16s_16s_a16.h \
+	volk_16sc_s32f_deinterleave_32f_32f_a16.h \
+	volk_16sc_deinterleave_real_16s_a16.h \
+	volk_16sc_s32f_deinterleave_real_32f_a16.h \
+	volk_16sc_deinterleave_real_8s_a16.h \
+	volk_16sc_magnitude_16s_a16.h \
+	volk_16sc_s32f_magnitude_32f_a16.h \
+	volk_16s_s32f_convert_32f_a16.h \
+	volk_16s_s32f_convert_32f_ua16.h \
+	volk_16s_convert_8s_a16.h \
+	volk_16s_convert_8s_ua16.h \
+	volk_16s_max_star_16s_a16.h \
+	volk_16s_max_star_horizontal_16s_a16.h \
+	volk_16s_permute_and_scalar_add_a16.h \
+	volk_16s_quad_max_star_16s_a16.h \
+	volk_16u_byteswap_a16.h \
+	volk_32f_accumulator_s32f_a16.h \
+	volk_32f_32f_add_32f_a16.h \
+	volk_32fc_32f_multiply_32fc_a16.h \
+	volk_32fc_32f_power_32fc_a16.h \
+	volk_32f_calc_spectral_noise_floor_a16.h \
+	volk_32fc_s32f_atan2_32f_a16.h \
+	volk_32fc_32fc_conjugate_dot_prod_32fc_a16.h \
+	volk_32fc_deinterleave_32f_32f_a16.h \
+	volk_32fc_deinterleave_64f_64f_a16.h \
+	volk_32fc_deinterleave_real_16s_a16.h \
+	volk_32fc_deinterleave_real_32f_a16.h \
+	volk_32fc_deinterleave_real_64f_a16.h \
+	volk_32fc_32fc_dot_prod_32fc_a16.h \
+	volk_32fc_index_max_16u_a16.h \
+	volk_32fc_s32f_magnitude_16s_a16.h \
+	volk_32fc_magnitude_32f_a16.h \
+	volk_32fc_32fc_multiply_32fc_a16.h \
+	volk_32f_s32f_convert_16s_a16.h \
+	volk_32f_s32f_convert_16s_ua16.h \
+	volk_32f_s32f_convert_32s_a16.h \
+	volk_32f_s32f_convert_32s_ua16.h \
+	volk_32f_convert_64f_a16.h \
+	volk_32f_convert_64f_ua16.h \
+	volk_32f_s32f_convert_8s_a16.h \
+	volk_32f_s32f_convert_8s_ua16.h \
+	volk_32fc_s32f_s32f_power_spectral_density_32f_a16.h \
+	volk_32fc_s32f_power_spectrum_32f_a16.h \
+	volk_32fc_32fc_square_dist_32f_a16.h \
+	volk_32fc_32fc_s32f_square_dist_scalar_mult_32f_a16.h \
+	volk_32f_32f_divide_32f_a16.h \
+	volk_32f_32f_dot_prod_32f_a16.h \
+	volk_32f_32f_dot_prod_32f_ua16.h \
+	volk_32f_s32f_32f_fm_detect_32f_a16.h \
+	volk_32f_index_max_16u_a16.h \
+	volk_32f_32f_s32f_interleave_16sc_a16.h \
+	volk_32f_32f_interleave_32fc_a16.h \
+	volk_32f_32f_max_32f_a16.h \
+	volk_32f_32f_min_32f_a16.h \
+	volk_32f_32f_multiply_32f_a16.h \
+	volk_32f_s32f_normalize_a16.h \
+	volk_32f_s32f_power_32f_a16.h \
+	volk_32f_sqrt_32f_a16.h \
+	volk_32f_s32f_stddev_32f_a16.h \
+	volk_32f_stddev_and_mean_32f_32f_a16.h \
+	volk_32f_32f_subtract_32f_a16.h \
+	volk_32f_32f_32f_sum_of_poly_32f_a16.h \
+	volk_32s_32s_and_32s_a16.h \
+	volk_32s_s32f_convert_32f_a16.h \
+	volk_32s_s32f_convert_32f_ua16.h \
+	volk_32s_32s_or_32s_a16.h \
+	volk_32u_byteswap_a16.h \
+	volk_32u_popcnt_a16.h \
+	volk_64f_convert_32f_a16.h \
+	volk_64f_convert_32f_ua16.h \
+	volk_64f_64f_max_64f_a16.h \
+	volk_64f_64f_min_64f_a16.h \
+	volk_64u_byteswap_a16.h \
+	volk_64u_popcnt_a16.h \
+	volk_8sc_deinterleave_16s_16s_a16.h \
+	volk_8sc_s32f_deinterleave_32f_32f_a16.h \
+	volk_8sc_deinterleave_real_16s_a16.h \
+	volk_8sc_s32f_deinterleave_real_32f_a16.h \
+	volk_8sc_deinterleave_real_8s_a16.h \
+	volk_8sc_8sc_multiply_conjugate_16sc_a16.h \
+	volk_8sc_8sc_s32f_multiply_conjugate_32fc_a16.h \
+	volk_8s_convert_16s_a16.h \
+	volk_8s_convert_16s_ua16.h \
+	volk_8s_s32f_convert_32f_a16.h \
+	volk_8s_s32f_convert_32f_ua16.h 
 
 VOLK_MKTABLES_SOURCES = \
 	$(top_srcdir)/lib/volk_rank_archs.c \
diff --git a/volk/include/volk/make_c.py b/volk/include/volk/make_c.py
index f2432d7a4e..f708ba7d07 100644
--- a/volk/include/volk/make_c.py
+++ b/volk/include/volk/make_c.py
@@ -24,8 +24,7 @@ def make_c(funclist, taglist, arched_arglist, retlist, my_arglist, fcountlist) :
     tempstring = tempstring + "    }\n"
     tempstring = tempstring + "    return 0;\n"
     tempstring = tempstring + "}\n"
-
-
+    
     for i in range(len(funclist)): 
         tempstring = tempstring + "static const " + replace_volk.sub("p", funclist[i]) + " " + funclist[i] + "_archs[] = {\n";
         
diff --git a/volk/include/volk/volk_16s_add_quad_aligned16.h b/volk/include/volk/volk_16s_add_quad_a16.h
index 63042bef18..67d0c55a3d 100644
--- a/volk/include/volk/volk_16s_add_quad_aligned16.h
+++ b/volk/include/volk/volk_16s_add_quad_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_16s_ADD_QUAD_ALIGNED16_H
-#define INCLUDED_VOLK_16s_ADD_QUAD_ALIGNED16_H
+#ifndef INCLUDED_volk_16s_add_quad_a16_H
+#define INCLUDED_volk_16s_add_quad_a16_H
 
 
 #include<inttypes.h>
@@ -13,7 +13,7 @@
 #include<xmmintrin.h>
 #include<emmintrin.h>
 
-static inline  void volk_16s_add_quad_aligned16_sse2(short* target0, short* target1, short* target2, short* target3, short* src0, short* src1, short* src2, short* src3, short* src4, unsigned int num_bytes) {
+static inline  void volk_16s_add_quad_a16_sse2(short* target0, short* target1, short* target2, short* target3, short* src0, short* src1, short* src2, short* src3, short* src4, unsigned int num_bytes) {
   
   __m128i xmm0, xmm1, xmm2, xmm3, xmm4;
   __m128i *p_target0, *p_target1, *p_target2, *p_target3,  *p_src0, *p_src1, *p_src2, *p_src3, *p_src4;
@@ -65,9 +65,9 @@ static inline  void volk_16s_add_quad_aligned16_sse2(short* target0, short* targ
   }
     /*asm volatile
 		(
-		 ".%=volk_16s_add_quad_aligned16_sse2_L1:\n\t"
+		 ".%=volk_16s_add_quad_a16_sse2_L1:\n\t"
 		 "cmp $0, %[bound]\n\t"
-		 "je .%=volk_16s_add_quad_aligned16_sse2_END\n\t"
+		 "je .%=volk_16s_add_quad_a16_sse2_END\n\t"
 		 "movaps (%[src0]), %%xmm1\n\t"
 		 "movaps (%[src1]), %%xmm2\n\t"
 		 "movaps (%[src2]), %%xmm3\n\t"
@@ -91,8 +91,8 @@ static inline  void volk_16s_add_quad_aligned16_sse2(short* target0, short* targ
 		 "add $16, %[target1]\n\t"
 		 "add $16, %[target2]\n\t"
 		 "add $16, %[target3]\n\t"
-		 "jmp .%=volk_16s_add_quad_aligned16_sse2_L1\n\t"
-		 ".%=volk_16s_add_quad_aligned16_sse2_END:\n\t"
+		 "jmp .%=volk_16s_add_quad_a16_sse2_L1\n\t"
+		 ".%=volk_16s_add_quad_a16_sse2_END:\n\t"
 		 :
 		 :[bound]"r"(bound), [src0]"r"(src0), [src1]"r"(src1), [src2]"r"(src2), [src3]"r"(src3), [src4]"r"(src4), [target0]"r"(target0), [target1]"r"(target1), [target2]"r"(target2), [target3]"r"(target3)
 		 :"xmm1", "xmm2", "xmm3", "xmm4", "xmm5"
@@ -113,7 +113,7 @@ static inline  void volk_16s_add_quad_aligned16_sse2(short* target0, short* targ
 
 #if LV_HAVE_GENERIC
 
-static inline void volk_16s_add_quad_aligned16_generic(short* target0, short* target1, short* target2, short* target3, short* src0, short* src1, short* src2, short* src3, short* src4, unsigned int num_bytes) {
+static inline void volk_16s_add_quad_a16_generic(short* target0, short* target1, short* target2, short* target3, short* src0, short* src1, short* src2, short* src3, short* src4, unsigned int num_bytes) {
 	
 	int i = 0;
 	
@@ -133,4 +133,4 @@ static inline void volk_16s_add_quad_aligned16_generic(short* target0, short* ta
 
 
 
-#endif /*INCLUDED_VOLK_16s_ADD_QUAD_ALIGNED16_H*/
+#endif /*INCLUDED_volk_16s_add_quad_a16_H*/
diff --git a/volk/include/volk/volk_16s_branch_4_state_8_aligned16.h b/volk/include/volk/volk_16s_branch_4_state_8_a16.h
index fb9d7cb874..4c1af87297 100644
--- a/volk/include/volk/volk_16s_branch_4_state_8_aligned16.h
+++ b/volk/include/volk/volk_16s_branch_4_state_8_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_16s_BRANCH_4_STATE_8_ALIGNED16_H
-#define INCLUDED_VOLK_16s_BRANCH_4_STATE_8_ALIGNED16_H
+#ifndef INCLUDED_volk_16s_branch_4_state_8_a16_H
+#define INCLUDED_volk_16s_branch_4_state_8_a16_H
 
 
 #include<inttypes.h>
@@ -14,7 +14,7 @@
 #include<emmintrin.h>
 #include<tmmintrin.h>
 
-static inline  void volk_16s_branch_4_state_8_aligned16_ssse3(short* target,  short* src0, char** permuters, short* cntl2, short* cntl3, short* scalars) {
+static inline  void volk_16s_branch_4_state_8_a16_ssse3(short* target,  short* src0, char** permuters, short* cntl2, short* cntl3, short* scalars) {
 	
   
   __m128i xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11;
@@ -138,7 +138,7 @@ static inline  void volk_16s_branch_4_state_8_aligned16_ssse3(short* target,  sh
 #endif /*LV_HAVE_SSEs*/
 
 #if LV_HAVE_GENERIC
-static inline  void volk_16s_branch_4_state_8_aligned16_generic(short* target,  short* src0, char** permuters, short* cntl2, short* cntl3, short* scalars) {
+static inline  void volk_16s_branch_4_state_8_a16_generic(short* target,  short* src0, char** permuters, short* cntl2, short* cntl3, short* scalars) {
 	int i = 0;
 	
 	int bound = 4;
@@ -191,4 +191,4 @@ static inline  void volk_16s_branch_4_state_8_aligned16_generic(short* target,
 #endif /*LV_HAVE_GENERIC*/
 
 
-#endif /*INCLUDED_VOLK_16s_BRANCH_4_STATE_8_ALIGNED16_H*/
+#endif /*INCLUDED_volk_16s_branch_4_state_8_a16_H*/
diff --git a/volk/include/volk/volk_16s_convert_8s_aligned16.h b/volk/include/volk/volk_16s_convert_8s_a16.h
index 64c368688f..13db435def 100644
--- a/volk/include/volk/volk_16s_convert_8s_aligned16.h
+++ b/volk/include/volk/volk_16s_convert_8s_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_16s_CONVERT_8s_ALIGNED16_H
-#define INCLUDED_VOLK_16s_CONVERT_8s_ALIGNED16_H
+#ifndef INCLUDED_volk_16s_convert_8s_a16_H
+#define INCLUDED_volk_16s_convert_8s_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -12,7 +12,7 @@
   \param outputVector The 8 bit output data buffer
   \param num_points The number of data values to be converted
 */
-static inline void volk_16s_convert_8s_aligned16_sse2(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points){
+static inline void volk_16s_convert_8s_a16_sse2(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int sixteenthPoints = num_points / 16;
     
@@ -52,7 +52,7 @@ static inline void volk_16s_convert_8s_aligned16_sse2(int8_t* outputVector, cons
   \param outputVector The 8 bit output data buffer
   \param num_points The number of data values to be converted
 */
-static inline void volk_16s_convert_8s_aligned16_generic(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points){
+static inline void volk_16s_convert_8s_a16_generic(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points){
   int8_t* outputVectorPtr = outputVector;
   const int16_t* inputVectorPtr = inputVector;
   unsigned int number = 0;
@@ -66,4 +66,4 @@ static inline void volk_16s_convert_8s_aligned16_generic(int8_t* outputVector, c
 
 
 
-#endif /* INCLUDED_VOLK_16s_CONVERT_8s_ALIGNED16_H */
+#endif /* INCLUDED_volk_16s_convert_8s_a16_H */
diff --git a/volk/include/volk/volk_16s_convert_8s_unaligned16.h b/volk/include/volk/volk_16s_convert_8s_ua16.h
index ca925de86f..9941118ae6 100644
--- a/volk/include/volk/volk_16s_convert_8s_unaligned16.h
+++ b/volk/include/volk/volk_16s_convert_8s_ua16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_16s_CONVERT_8s_UNALIGNED16_H
-#define INCLUDED_VOLK_16s_CONVERT_8s_UNALIGNED16_H
+#ifndef INCLUDED_volk_16s_convert_8s_ua16_H
+#define INCLUDED_volk_16s_convert_8s_ua16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param num_points The number of data values to be converted
   \note Input and output buffers do NOT need to be properly aligned
 */
-static inline void volk_16s_convert_8s_unaligned16_sse2(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points){
+static inline void volk_16s_convert_8s_ua16_sse2(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int sixteenthPoints = num_points / 16;
     
@@ -54,7 +54,7 @@ static inline void volk_16s_convert_8s_unaligned16_sse2(int8_t* outputVector, co
   \param num_points The number of data values to be converted
   \note Input and output buffers do NOT need to be properly aligned
 */
-static inline void volk_16s_convert_8s_unaligned16_generic(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points){
+static inline void volk_16s_convert_8s_ua16_generic(int8_t* outputVector, const int16_t* inputVector, unsigned int num_points){
   int8_t* outputVectorPtr = outputVector;
   const int16_t* inputVectorPtr = inputVector;
   unsigned int number = 0;
@@ -68,4 +68,4 @@ static inline void volk_16s_convert_8s_unaligned16_generic(int8_t* outputVector,
 
 
 
-#endif /* INCLUDED_VOLK_16s_CONVERT_8s_UNALIGNED16_H */
+#endif /* INCLUDED_volk_16s_convert_8s_ua16_H */
diff --git a/volk/include/volk/volk_16s_max_star_aligned16.h b/volk/include/volk/volk_16s_max_star_16s_a16.h
index ba4e979ecd..b2ec90552c 100644
--- a/volk/include/volk/volk_16s_max_star_aligned16.h
+++ b/volk/include/volk/volk_16s_max_star_16s_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_16s_MAX_STAR_ALIGNED16_H
-#define INCLUDED_VOLK_16s_MAX_STAR_ALIGNED16_H
+#ifndef INCLUDED_volk_16s_max_star_16s_a16_H
+#define INCLUDED_volk_16s_max_star_16s_a16_H
 
 
 #include<inttypes.h>
@@ -12,7 +12,7 @@
 #include<emmintrin.h>
 #include<tmmintrin.h>
 
-static inline  void volk_16s_max_star_aligned16_ssse3(short* target, short* src0, unsigned int num_bytes) {
+static inline  void volk_16s_max_star_16s_a16_ssse3(short* target, short* src0, unsigned int num_bytes) {
 
 
   
@@ -87,7 +87,7 @@ static inline  void volk_16s_max_star_aligned16_ssse3(short* target, short* src0
 
 #if LV_HAVE_GENERIC
 
-static inline void volk_16s_max_star_aligned16_generic(short* target, short* src0, unsigned int num_bytes) {
+static inline void volk_16s_max_star_16s_a16_generic(short* target, short* src0, unsigned int num_bytes) {
 	
 	int i = 0;
 	
@@ -105,4 +105,4 @@ static inline void volk_16s_max_star_aligned16_generic(short* target, short* src
 #endif /*LV_HAVE_GENERIC*/
 
 
-#endif /*INCLUDED_VOLK_16s_MAX_STAR_ALIGNED16_H*/
+#endif /*INCLUDED_volk_16s_max_star_16s_a16_H*/
diff --git a/volk/include/volk/volk_16s_max_star_horizontal_aligned16.h b/volk/include/volk/volk_16s_max_star_horizontal_16s_a16.h
index 82d011677b..68994593bc 100644
--- a/volk/include/volk/volk_16s_max_star_horizontal_aligned16.h
+++ b/volk/include/volk/volk_16s_max_star_horizontal_16s_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_16s_MAX_STAR_HORIZONTAL_ALIGNED16_H
-#define INCLUDED_VOLK_16s_MAX_STAR_HORIZONTAL_ALIGNED16_H
+#ifndef INCLUDED_volk_16s_max_star_horizontal_16s_a16_H
+#define INCLUDED_volk_16s_max_star_horizontal_16s_a16_H
 
 
 #include<inttypes.h>
@@ -12,7 +12,7 @@
 #include<emmintrin.h>
 #include<tmmintrin.h>
 
-static inline  void volk_16s_max_star_horizontal_aligned16_ssse3(int16_t* target, int16_t* src0, unsigned int num_bytes) {
+static inline  void volk_16s_max_star_horizontal_16s_a16_ssse3(int16_t* target, int16_t* src0, unsigned int num_bytes) {
 
   const static uint8_t shufmask0[16] = {0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0c, 0x0d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
   const static uint8_t shufmask1[16] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x04, 0x05, 0x08, 0x09, 0x0c, 0x0d};
@@ -110,7 +110,7 @@ static inline  void volk_16s_max_star_horizontal_aligned16_ssse3(int16_t* target
 
 
 #if LV_HAVE_GENERIC
-static inline void volk_16s_max_star_horizontal_aligned16_generic(int16_t* target, int16_t* src0, unsigned int num_bytes) {
+static inline void volk_16s_max_star_horizontal_16s_a16_generic(int16_t* target, int16_t* src0, unsigned int num_bytes) {
 	
 	int i = 0;
 	
@@ -127,4 +127,4 @@ static inline void volk_16s_max_star_horizontal_aligned16_generic(int16_t* targe
 
 #endif /*LV_HAVE_GENERIC*/
 
-#endif /*INCLUDED_VOLK_16s_MAX_STAR_HORIZONTAL_ALIGNED16_H*/
+#endif /*INCLUDED_volk_16s_max_star_horizontal_16s_a16_H*/
diff --git a/volk/include/volk/volk_16s_permute_and_scalar_add_aligned16.h b/volk/include/volk/volk_16s_permute_and_scalar_add_a16.h
index 452d05c4f2..2e7586b575 100644
--- a/volk/include/volk/volk_16s_permute_and_scalar_add_aligned16.h
+++ b/volk/include/volk/volk_16s_permute_and_scalar_add_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_16s_PERMUTE_AND_SCALAR_ADD_ALIGNED16_H
-#define INCLUDED_VOLK_16s_PERMUTE_AND_SCALAR_ADD_ALIGNED16_H
+#ifndef INCLUDED_volk_16s_permute_and_scalar_add_a16_H
+#define INCLUDED_volk_16s_permute_and_scalar_add_a16_H
 
 
 #include<inttypes.h>
@@ -13,7 +13,7 @@
 #include<xmmintrin.h>
 #include<emmintrin.h>
 
-static inline  void volk_16s_permute_and_scalar_add_aligned16_sse2(short* target,  short* src0, short* permute_indexes, short* cntl0, short* cntl1, short* cntl2, short* cntl3, short* scalars, unsigned int num_bytes) {
+static inline  void volk_16s_permute_and_scalar_add_a16_sse2(short* target,  short* src0, short* permute_indexes, short* cntl0, short* cntl1, short* cntl2, short* cntl3, short* scalars, unsigned int num_bytes) {
 	
 
   __m128i xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7;
@@ -117,7 +117,7 @@ static inline  void volk_16s_permute_and_scalar_add_aligned16_sse2(short* target
 
 
 #if LV_HAVE_GENERIC
-static inline void volk_16s_permute_and_scalar_add_aligned16_generic(short* target, short* src0, short* permute_indexes, short* cntl0, short* cntl1, short* cntl2, short* cntl3, short* scalars, unsigned int num_bytes) {
+static inline void volk_16s_permute_and_scalar_add_a16_generic(short* target, short* src0, short* permute_indexes, short* cntl0, short* cntl1, short* cntl2, short* cntl3, short* scalars, unsigned int num_bytes) {
 	
 	int i = 0;
 	
@@ -136,4 +136,4 @@ static inline void volk_16s_permute_and_scalar_add_aligned16_generic(short* targ
 #endif /*LV_HAVE_GENERIC*/
 
 
-#endif /*INCLUDED_VOLK_16s_PERMUTE_AND_SCALAR_ADD_ALIGNED16_H*/
+#endif /*INCLUDED_volk_16s_permute_and_scalar_add_a16_H*/
diff --git a/volk/include/volk/volk_16s_quad_max_star_aligned16.h b/volk/include/volk/volk_16s_quad_max_star_16s_a16.h
index 1004c4d23e..3e89ff963d 100644
--- a/volk/include/volk/volk_16s_quad_max_star_aligned16.h
+++ b/volk/include/volk/volk_16s_quad_max_star_16s_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_16s_QUAD_MAX_STAR_ALIGNED16_H
-#define INCLUDED_VOLK_16s_QUAD_MAX_STAR_ALIGNED16_H
+#ifndef INCLUDED_volk_16s_quad_max_star_16s_a16_H
+#define INCLUDED_volk_16s_quad_max_star_16s_a16_H
 
 
 #include<inttypes.h>
@@ -13,7 +13,7 @@
 
 #include<emmintrin.h>
 
-static inline  void volk_16s_quad_max_star_aligned16_sse2(short* target, short* src0, short* src1, short* src2, short* src3, unsigned int num_bytes) {
+static inline  void volk_16s_quad_max_star_16s_a16_sse2(short* target, short* src0, short* src1, short* src2, short* src3, unsigned int num_bytes) {
 	
 
 
@@ -96,9 +96,9 @@ static inline  void volk_16s_quad_max_star_aligned16_sse2(short* target, short*
 
 	/*asm volatile
 		(
-		 "volk_16s_quad_max_star_aligned16_sse2_L1:\n\t"
+		 "volk_16s_quad_max_star_16s_a16_sse2_L1:\n\t"
 		 "cmp $0, %[bound]\n\t"
-		 "je volk_16s_quad_max_star_aligned16_sse2_END\n\t"
+		 "je volk_16s_quad_max_star_16s_a16_sse2_END\n\t"
 
 		 "movaps (%[src0]), %%xmm1\n\t"
 		 "movaps (%[src1]), %%xmm2\n\t"
@@ -143,9 +143,9 @@ static inline  void volk_16s_quad_max_star_aligned16_sse2(short* target, short*
 
 		 "movaps %%xmm1, (%[target])\n\t"
 		 "addw $16, %[target]\n\t"
-		 "jmp volk_16s_quad_max_star_aligned16_sse2_L1\n\t"
+		 "jmp volk_16s_quad_max_star_16s_a16_sse2_L1\n\t"
 		 
-		 "volk_16s_quad_max_star_aligned16_sse2_END:\n\t"
+		 "volk_16s_quad_max_star_16s_a16_sse2_END:\n\t"
 		 :
 		 :[bound]"r"(bound), [src0]"r"(src0), [src1]"r"(src1), [src2]"r"(src2), [src3]"r"(src3), [target]"r"(target)
 		 :
@@ -168,7 +168,7 @@ static inline  void volk_16s_quad_max_star_aligned16_sse2(short* target, short*
 
 
 #if LV_HAVE_GENERIC
-static inline void volk_16s_quad_max_star_aligned16_generic(short* target, short* src0, short* src1, short* src2, short* src3, unsigned int num_bytes) {
+static inline void volk_16s_quad_max_star_16s_a16_generic(short* target, short* src0, short* src1, short* src2, short* src3, unsigned int num_bytes) {
 	
 	int i = 0;
 	
@@ -188,4 +188,4 @@ static inline void volk_16s_quad_max_star_aligned16_generic(short* target, short
 
 #endif /*LV_HAVE_GENERIC*/
 
-#endif /*INCLUDED_VOLK_16s_QUAD_MAX_STAR_ALIGNED16_H*/
+#endif /*INCLUDED_volk_16s_quad_max_star_16s_a16_H*/
diff --git a/volk/include/volk/volk_16s_convert_32f_unaligned16.h b/volk/include/volk/volk_16s_s32f_convert_32f_a16.h
index d6212fba5e..8f9b44478d 100644
--- a/volk/include/volk/volk_16s_convert_32f_unaligned16.h
+++ b/volk/include/volk/volk_16s_s32f_convert_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_16s_CONVERT_32f_UNALIGNED16_H
-#define INCLUDED_VOLK_16s_CONVERT_32f_UNALIGNED16_H
+#ifndef INCLUDED_volk_16s_s32f_convert_32f_a16_H
+#define INCLUDED_volk_16s_s32f_convert_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,9 +13,8 @@
     \param outputVector The floating point output data buffer
     \param scalar The value divided against each point in the output buffer
     \param num_points The number of data values to be converted
-    \note Output buffer does NOT need to be properly aligned
   */
-static inline void volk_16s_convert_32f_unaligned16_sse4_1(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_16s_s32f_convert_32f_a16_sse4_1(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int eighthPoints = num_points / 8;
     
@@ -68,9 +67,8 @@ static inline void volk_16s_convert_32f_unaligned16_sse4_1(float* outputVector,
     \param outputVector The floating point output data buffer
     \param scalar The value divided against each point in the output buffer
     \param num_points The number of data values to be converted
-    \note Output buffer does NOT need to be properly aligned
   */
-static inline void volk_16s_convert_32f_unaligned16_sse(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_16s_s32f_convert_32f_a16_sse(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int quarterPoints = num_points / 4;
     
@@ -103,9 +101,8 @@ static inline void volk_16s_convert_32f_unaligned16_sse(float* outputVector, con
     \param outputVector The floating point output data buffer
     \param scalar The value divided against each point in the output buffer
     \param num_points The number of data values to be converted
-    \note Output buffer does NOT need to be properly aligned
   */
-static inline void volk_16s_convert_32f_unaligned16_generic(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_16s_s32f_convert_32f_a16_generic(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points){
   float* outputVectorPtr = outputVector;
   const int16_t* inputVectorPtr = inputVector;
   unsigned int number = 0;
@@ -119,4 +116,4 @@ static inline void volk_16s_convert_32f_unaligned16_generic(float* outputVector,
 
 
 
-#endif /* INCLUDED_VOLK_16s_CONVERT_32f_UNALIGNED16_H */
+#endif /* INCLUDED_volk_16s_s32f_convert_32f_a16_H */
diff --git a/volk/include/volk/volk_16s_convert_32f_aligned16.h b/volk/include/volk/volk_16s_s32f_convert_32f_ua16.h
index 126ce15282..ad52aea1a5 100644
--- a/volk/include/volk/volk_16s_convert_32f_aligned16.h
+++ b/volk/include/volk/volk_16s_s32f_convert_32f_ua16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_16s_CONVERT_32f_ALIGNED16_H
-#define INCLUDED_VOLK_16s_CONVERT_32f_ALIGNED16_H
+#ifndef INCLUDED_volk_16s_s32f_convert_32f_ua16_H
+#define INCLUDED_volk_16s_s32f_convert_32f_ua16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,8 +13,9 @@
     \param outputVector The floating point output data buffer
     \param scalar The value divided against each point in the output buffer
     \param num_points The number of data values to be converted
+    \note Output buffer does NOT need to be properly aligned
   */
-static inline void volk_16s_convert_32f_aligned16_sse4_1(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_16s_s32f_convert_32f_ua16_sse4_1(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int eighthPoints = num_points / 8;
     
@@ -67,8 +68,9 @@ static inline void volk_16s_convert_32f_aligned16_sse4_1(float* outputVector, co
     \param outputVector The floating point output data buffer
     \param scalar The value divided against each point in the output buffer
     \param num_points The number of data values to be converted
+    \note Output buffer does NOT need to be properly aligned
   */
-static inline void volk_16s_convert_32f_aligned16_sse(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_16s_s32f_convert_32f_ua16_sse(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int quarterPoints = num_points / 4;
     
@@ -101,8 +103,9 @@ static inline void volk_16s_convert_32f_aligned16_sse(float* outputVector, const
     \param outputVector The floating point output data buffer
     \param scalar The value divided against each point in the output buffer
     \param num_points The number of data values to be converted
+    \note Output buffer does NOT need to be properly aligned
   */
-static inline void volk_16s_convert_32f_aligned16_generic(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_16s_s32f_convert_32f_ua16_generic(float* outputVector, const int16_t* inputVector, const float scalar, unsigned int num_points){
   float* outputVectorPtr = outputVector;
   const int16_t* inputVectorPtr = inputVector;
   unsigned int number = 0;
@@ -116,4 +119,4 @@ static inline void volk_16s_convert_32f_aligned16_generic(float* outputVector, c
 
 
 
-#endif /* INCLUDED_VOLK_16s_CONVERT_32f_ALIGNED16_H */
+#endif /* INCLUDED_volk_16s_s32f_convert_32f_ua16_H */
diff --git a/volk/include/volk/volk_16sc_deinterleave_16s_aligned16.h b/volk/include/volk/volk_16sc_deinterleave_16s_16s_a16.h
index cf94a3f385..8e5da24ec6 100644
--- a/volk/include/volk/volk_16sc_deinterleave_16s_aligned16.h
+++ b/volk/include/volk/volk_16sc_deinterleave_16s_16s_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_16sc_DEINTERLEAVE_16S_ALIGNED16_H
-#define INCLUDED_VOLK_16sc_DEINTERLEAVE_16S_ALIGNED16_H
+#ifndef INCLUDED_volk_16sc_deinterleave_16s_16s_a16_H
+#define INCLUDED_volk_16sc_deinterleave_16s_16s_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param qBuffer The Q buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_16sc_deinterleave_16s_aligned16_ssse3(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t* complexVector, unsigned int num_points){
+static inline void volk_16sc_deinterleave_16s_16s_a16_ssse3(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t* complexVector, unsigned int num_points){
   unsigned int number = 0;
   const int8_t* complexVectorPtr = (int8_t*)complexVector;
   int16_t* iBufferPtr = iBuffer;
@@ -61,7 +61,7 @@ static inline void volk_16sc_deinterleave_16s_aligned16_ssse3(int16_t* iBuffer,
   \param qBuffer The Q buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_16sc_deinterleave_16s_aligned16_sse2(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t* complexVector, unsigned int num_points){
+static inline void volk_16sc_deinterleave_16s_16s_a16_sse2(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t* complexVector, unsigned int num_points){
   unsigned int number = 0;
   const int16_t* complexVectorPtr = (int16_t*)complexVector;
   int16_t* iBufferPtr = iBuffer;
@@ -128,7 +128,7 @@ static inline void volk_16sc_deinterleave_16s_aligned16_sse2(int16_t* iBuffer, i
   \param qBuffer The Q buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_16sc_deinterleave_16s_aligned16_generic(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t* complexVector, unsigned int num_points){
+static inline void volk_16sc_deinterleave_16s_16s_a16_generic(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t* complexVector, unsigned int num_points){
   const int16_t* complexVectorPtr = (const int16_t*)complexVector;
   int16_t* iBufferPtr = iBuffer;
   int16_t* qBufferPtr = qBuffer;
@@ -148,11 +148,11 @@ static inline void volk_16sc_deinterleave_16s_aligned16_generic(int16_t* iBuffer
   \param qBuffer The Q buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-extern void volk_16sc_deinterleave_16s_aligned16_orc_impl(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t* complexVector, unsigned int num_points);
-static inline void volk_16sc_deinterleave_16s_aligned16_orc(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t* complexVector, unsigned int num_points){
-    volk_16sc_deinterleave_16s_aligned16_orc_impl(iBuffer, qBuffer, complexVector, num_points);
+extern void volk_16sc_deinterleave_16s_16s_a16_orc_impl(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t* complexVector, unsigned int num_points);
+static inline void volk_16sc_deinterleave_16s_16s_a16_orc(int16_t* iBuffer, int16_t* qBuffer, const lv_16sc_t* complexVector, unsigned int num_points){
+    volk_16sc_deinterleave_16s_16s_a16_orc_impl(iBuffer, qBuffer, complexVector, num_points);
 }
 #endif /* LV_HAVE_ORC */
 
 
-#endif /* INCLUDED_VOLK_16sc_DEINTERLEAVE_16S_ALIGNED16_H */
+#endif /* INCLUDED_volk_16sc_deinterleave_16s_16s_a16_H */
diff --git a/volk/include/volk/volk_16sc_deinterleave_real_16s_aligned16.h b/volk/include/volk/volk_16sc_deinterleave_real_16s_a16.h
index b594c85b84..068c1350c2 100644
--- a/volk/include/volk/volk_16sc_deinterleave_real_16s_aligned16.h
+++ b/volk/include/volk/volk_16sc_deinterleave_real_16s_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_16sc_DEINTERLEAVE_REAL_16s_ALIGNED16_H
-#define INCLUDED_VOLK_16sc_DEINTERLEAVE_REAL_16s_ALIGNED16_H
+#ifndef INCLUDED_volk_16sc_deinterleave_real_16s_a16_H
+#define INCLUDED_volk_16sc_deinterleave_real_16s_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -12,7 +12,7 @@
   \param iBuffer The I buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_16sc_deinterleave_real_16s_aligned16_ssse3(int16_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points){
+static inline void volk_16sc_deinterleave_real_16s_a16_ssse3(int16_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points){
   unsigned int number = 0;
   const int16_t* complexVectorPtr = (int16_t*)complexVector;
   int16_t* iBufferPtr = iBuffer;
@@ -55,7 +55,7 @@ static inline void volk_16sc_deinterleave_real_16s_aligned16_ssse3(int16_t* iBuf
   \param iBuffer The I buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_16sc_deinterleave_real_16s_aligned16_sse2(int16_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points){
+static inline void volk_16sc_deinterleave_real_16s_a16_sse2(int16_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points){
   unsigned int number = 0;
   const int16_t* complexVectorPtr = (int16_t*)complexVector;
   int16_t* iBufferPtr = iBuffer;
@@ -103,7 +103,7 @@ static inline void volk_16sc_deinterleave_real_16s_aligned16_sse2(int16_t* iBuff
   \param iBuffer The I buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_16sc_deinterleave_real_16s_aligned16_generic(int16_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points){
+static inline void volk_16sc_deinterleave_real_16s_a16_generic(int16_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points){
   unsigned int number = 0;
   const int16_t* complexVectorPtr = (int16_t*)complexVector;
   int16_t* iBufferPtr = iBuffer;
@@ -117,4 +117,4 @@ static inline void volk_16sc_deinterleave_real_16s_aligned16_generic(int16_t* iB
 
 
 
-#endif /* INCLUDED_VOLK_16sc_DEINTERLEAVE_REAL_16s_ALIGNED16_H */
+#endif /* INCLUDED_volk_16sc_deinterleave_real_16s_a16_H */
diff --git a/volk/include/volk/volk_16sc_deinterleave_real_8s_aligned16.h b/volk/include/volk/volk_16sc_deinterleave_real_8s_a16.h
index 2dd85a4225..afa21ebc43 100644
--- a/volk/include/volk/volk_16sc_deinterleave_real_8s_aligned16.h
+++ b/volk/include/volk/volk_16sc_deinterleave_real_8s_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_16sc_DEINTERLEAVE_REAL_8s_ALIGNED16_H
-#define INCLUDED_VOLK_16sc_DEINTERLEAVE_REAL_8s_ALIGNED16_H
+#ifndef INCLUDED_volk_16sc_deinterleave_real_8s_a16_H
+#define INCLUDED_volk_16sc_deinterleave_real_8s_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -12,7 +12,7 @@
   \param iBuffer The I buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_16sc_deinterleave_real_8s_aligned16_ssse3(int8_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points){
+static inline void volk_16sc_deinterleave_real_8s_a16_ssse3(int8_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points){
   unsigned int number = 0;
   const int8_t* complexVectorPtr = (int8_t*)complexVector;
   int8_t* iBufferPtr = iBuffer;
@@ -66,7 +66,7 @@ static inline void volk_16sc_deinterleave_real_8s_aligned16_ssse3(int8_t* iBuffe
   \param iBuffer The I buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_16sc_deinterleave_real_8s_aligned16_generic(int8_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points){
+static inline void volk_16sc_deinterleave_real_8s_a16_generic(int8_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points){
   unsigned int number = 0;
   const int16_t* complexVectorPtr = (int16_t*)complexVector;
   int8_t* iBufferPtr = iBuffer;
@@ -84,11 +84,11 @@ static inline void volk_16sc_deinterleave_real_8s_aligned16_generic(int8_t* iBuf
   \param iBuffer The I buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-extern void volk_16sc_deinterleave_real_8s_aligned16_orc_impl(int8_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points);
-static inline void volk_16sc_deinterleave_real_8s_aligned16_orc(int8_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points){
-    volk_16sc_deinterleave_real_8s_aligned16_orc_impl(iBuffer, complexVector, num_points);
+extern void volk_16sc_deinterleave_real_8s_a16_orc_impl(int8_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points);
+static inline void volk_16sc_deinterleave_real_8s_a16_orc(int8_t* iBuffer, const lv_16sc_t* complexVector, unsigned int num_points){
+    volk_16sc_deinterleave_real_8s_a16_orc_impl(iBuffer, complexVector, num_points);
 }
 #endif /* LV_HAVE_ORC */
 
 
-#endif /* INCLUDED_VOLK_16sc_DEINTERLEAVE_REAL_8s_ALIGNED16_H */
+#endif /* INCLUDED_volk_16sc_deinterleave_real_8s_a16_H */
diff --git a/volk/include/volk/volk_16sc_magnitude_16s_aligned16.h b/volk/include/volk/volk_16sc_magnitude_16s_a16.h
index 41e8751d61..d832de5fe7 100644
--- a/volk/include/volk/volk_16sc_magnitude_16s_aligned16.h
+++ b/volk/include/volk/volk_16sc_magnitude_16s_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_16sc_MAGNITUDE_16s_ALIGNED16_H
-#define INCLUDED_VOLK_16sc_MAGNITUDE_16s_ALIGNED16_H
+#ifndef INCLUDED_volk_16sc_magnitude_16s_a16_H
+#define INCLUDED_volk_16sc_magnitude_16s_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param magnitudeVector The vector containing the real output values
   \param num_points The number of complex values in complexVector to be calculated and stored into cVector
 */
-static inline void volk_16sc_magnitude_16s_aligned16_sse3(int16_t* magnitudeVector, const lv_16sc_t* complexVector, unsigned int num_points){
+static inline void volk_16sc_magnitude_16s_a16_sse3(int16_t* magnitudeVector, const lv_16sc_t* complexVector, unsigned int num_points){
   unsigned int number = 0;
   const unsigned int quarterPoints = num_points / 4;
    
@@ -84,7 +84,7 @@ static inline void volk_16sc_magnitude_16s_aligned16_sse3(int16_t* magnitudeVect
   \param magnitudeVector The vector containing the real output values
   \param num_points The number of complex values in complexVector to be calculated and stored into cVector
 */
-static inline void volk_16sc_magnitude_16s_aligned16_sse(int16_t* magnitudeVector, const lv_16sc_t* complexVector, unsigned int num_points){
+static inline void volk_16sc_magnitude_16s_a16_sse(int16_t* magnitudeVector, const lv_16sc_t* complexVector, unsigned int num_points){
   unsigned int number = 0;
   const unsigned int quarterPoints = num_points / 4;
 
@@ -160,7 +160,7 @@ static inline void volk_16sc_magnitude_16s_aligned16_sse(int16_t* magnitudeVecto
   \param magnitudeVector The vector containing the real output values
   \param num_points The number of complex values in complexVector to be calculated and stored into cVector
 */
-static inline void volk_16sc_magnitude_16s_aligned16_generic(int16_t* magnitudeVector, const lv_16sc_t* complexVector, unsigned int num_points){
+static inline void volk_16sc_magnitude_16s_a16_generic(int16_t* magnitudeVector, const lv_16sc_t* complexVector, unsigned int num_points){
   const int16_t* complexVectorPtr = (const int16_t*)complexVector;
   int16_t* magnitudeVectorPtr = magnitudeVector;
   unsigned int number = 0;
@@ -180,11 +180,11 @@ static inline void volk_16sc_magnitude_16s_aligned16_generic(int16_t* magnitudeV
   \param magnitudeVector The vector containing the real output values
   \param num_points The number of complex values in complexVector to be calculated and stored into cVector
 */
-extern void volk_16sc_magnitude_16s_aligned16_orc_impl(int16_t* magnitudeVector, const lv_16sc_t* complexVector, float scalar, unsigned int num_points);
-static inline void volk_16sc_magnitude_16s_aligned16_orc(int16_t* magnitudeVector, const lv_16sc_t* complexVector, unsigned int num_points){
-    volk_16sc_magnitude_16s_aligned16_orc_impl(magnitudeVector, complexVector, 32768.0, num_points);
+extern void volk_16sc_magnitude_16s_a16_orc_impl(int16_t* magnitudeVector, const lv_16sc_t* complexVector, float scalar, unsigned int num_points);
+static inline void volk_16sc_magnitude_16s_a16_orc(int16_t* magnitudeVector, const lv_16sc_t* complexVector, unsigned int num_points){
+    volk_16sc_magnitude_16s_a16_orc_impl(magnitudeVector, complexVector, 32768.0, num_points);
 }
 #endif /* LV_HAVE_ORC */
 
 
-#endif /* INCLUDED_VOLK_16sc_MAGNITUDE_16s_ALIGNED16_H */
+#endif /* INCLUDED_volk_16sc_magnitude_16s_a16_H */
diff --git a/volk/include/volk/volk_16sc_deinterleave_32f_aligned16.h b/volk/include/volk/volk_16sc_s32f_deinterleave_32f_32f_a16.h
index 50b8b62d5d..53e4253c44 100644
--- a/volk/include/volk/volk_16sc_deinterleave_32f_aligned16.h
+++ b/volk/include/volk/volk_16sc_s32f_deinterleave_32f_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_16sc_DEINTERLEAVE_32F_ALIGNED16_H
-#define INCLUDED_VOLK_16sc_DEINTERLEAVE_32F_ALIGNED16_H
+#ifndef INCLUDED_volk_16sc_s32f_deinterleave_32f_32f_a16_H
+#define INCLUDED_volk_16sc_s32f_deinterleave_32f_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -14,7 +14,7 @@
     \param scalar The data value to be divided against each input data value of the input complex vector
     \param num_points The number of complex data values to be deinterleaved
   */
-static inline void volk_16sc_deinterleave_32f_aligned16_sse(float* iBuffer, float* qBuffer, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
+static inline void volk_16sc_s32f_deinterleave_32f_32f_a16_sse(float* iBuffer, float* qBuffer, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
     float* iBufferPtr = iBuffer;
     float* qBufferPtr = qBuffer;
 
@@ -77,7 +77,7 @@ static inline void volk_16sc_deinterleave_32f_aligned16_sse(float* iBuffer, floa
     \param scalar The data value to be divided against each input data value of the input complex vector
     \param num_points The number of complex data values to be deinterleaved
   */
-static inline void volk_16sc_deinterleave_32f_aligned16_generic(float* iBuffer, float* qBuffer, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
+static inline void volk_16sc_s32f_deinterleave_32f_32f_a16_generic(float* iBuffer, float* qBuffer, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
   const int16_t* complexVectorPtr = (const int16_t*)complexVector;
   float* iBufferPtr = iBuffer;
   float* qBufferPtr = qBuffer;
@@ -98,11 +98,11 @@ static inline void volk_16sc_deinterleave_32f_aligned16_generic(float* iBuffer,
     \param scalar The data value to be divided against each input data value of the input complex vector
     \param num_points The number of complex data values to be deinterleaved
   */
-extern void volk_16sc_deinterleave_32f_aligned16_orc_impl(float* iBuffer, float* qBuffer, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points);
-static inline void volk_16sc_deinterleave_32f_aligned16_orc(float* iBuffer, float* qBuffer, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
-    volk_16sc_deinterleave_32f_aligned16_orc_impl(iBuffer, qBuffer, complexVector, scalar, num_points);
+extern void volk_16sc_s32f_deinterleave_32f_32f_a16_orc_impl(float* iBuffer, float* qBuffer, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points);
+static inline void volk_16sc_s32f_deinterleave_32f_32f_a16_orc(float* iBuffer, float* qBuffer, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
+    volk_16sc_s32f_deinterleave_32f_32f_a16_orc_impl(iBuffer, qBuffer, complexVector, scalar, num_points);
 }
 #endif /* LV_HAVE_ORC */
 
 
-#endif /* INCLUDED_VOLK_16sc_DEINTERLEAVE_32F_ALIGNED16_H */
+#endif /* INCLUDED_volk_16sc_s32f_deinterleave_32f_32f_a16_H */
diff --git a/volk/include/volk/volk_16sc_deinterleave_real_32f_aligned16.h b/volk/include/volk/volk_16sc_s32f_deinterleave_real_32f_a16.h
index 3e7be1e642..7320db3688 100644
--- a/volk/include/volk/volk_16sc_deinterleave_real_32f_aligned16.h
+++ b/volk/include/volk/volk_16sc_s32f_deinterleave_real_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_16sc_DEINTERLEAVE_REAL_32f_ALIGNED16_H
-#define INCLUDED_VOLK_16sc_DEINTERLEAVE_REAL_32f_ALIGNED16_H
+#ifndef INCLUDED_volk_16sc_s32f_deinterleave_real_32f_a16_H
+#define INCLUDED_volk_16sc_s32f_deinterleave_real_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param scalar The scaling value being multiplied against each data point
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_16sc_deinterleave_real_32f_aligned16_sse4_1(float* iBuffer, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
+static inline void volk_16sc_s32f_deinterleave_real_32f_a16_sse4_1(float* iBuffer, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
   float* iBufferPtr = iBuffer;
 
   unsigned int number = 0;
@@ -61,7 +61,7 @@ static inline void volk_16sc_deinterleave_real_32f_aligned16_sse4_1(float* iBuff
   \param scalar The scaling value being multiplied against each data point
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_16sc_deinterleave_real_32f_aligned16_sse(float* iBuffer, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
+static inline void volk_16sc_s32f_deinterleave_real_32f_a16_sse(float* iBuffer, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
   float* iBufferPtr = iBuffer;
 
   unsigned int number = 0;
@@ -107,7 +107,7 @@ static inline void volk_16sc_deinterleave_real_32f_aligned16_sse(float* iBuffer,
   \param scalar The scaling value being multiplied against each data point
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_16sc_deinterleave_real_32f_aligned16_generic(float* iBuffer, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
+static inline void volk_16sc_s32f_deinterleave_real_32f_a16_generic(float* iBuffer, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
   const int16_t* complexVectorPtr = (const int16_t*)complexVector;
   float* iBufferPtr = iBuffer;
@@ -122,4 +122,4 @@ static inline void volk_16sc_deinterleave_real_32f_aligned16_generic(float* iBuf
 
 
 
-#endif /* INCLUDED_VOLK_16sc_DEINTERLEAVE_REAL_32f_ALIGNED16_H */
+#endif /* INCLUDED_volk_16sc_s32f_deinterleave_real_32f_a16_H */
diff --git a/volk/include/volk/volk_16sc_magnitude_32f_aligned16.h b/volk/include/volk/volk_16sc_s32f_magnitude_32f_a16.h
index c2605d5519..649b5cc96c 100644
--- a/volk/include/volk/volk_16sc_magnitude_32f_aligned16.h
+++ b/volk/include/volk/volk_16sc_s32f_magnitude_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_16sc_MAGNITUDE_32f_ALIGNED16_H
-#define INCLUDED_VOLK_16sc_MAGNITUDE_32f_ALIGNED16_H
+#ifndef INCLUDED_volk_16sc_s32f_magnitude_32f_a16_H
+#define INCLUDED_volk_16sc_s32f_magnitude_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -14,7 +14,7 @@
   \param scalar The data value to be divided against each input data value of the input complex vector
   \param num_points The number of complex values in complexVector to be calculated and stored into cVector
 */
-static inline void volk_16sc_magnitude_32f_aligned16_sse3(float* magnitudeVector, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
+static inline void volk_16sc_s32f_magnitude_32f_a16_sse3(float* magnitudeVector, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
   const unsigned int quarterPoints = num_points / 4;
   
@@ -79,7 +79,7 @@ static inline void volk_16sc_magnitude_32f_aligned16_sse3(float* magnitudeVector
   \param scalar The data value to be divided against each input data value of the input complex vector
   \param num_points The number of complex values in complexVector to be calculated and stored into cVector
 */
-static inline void volk_16sc_magnitude_32f_aligned16_sse(float* magnitudeVector, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
+static inline void volk_16sc_s32f_magnitude_32f_a16_sse(float* magnitudeVector, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
   const unsigned int quarterPoints = num_points / 4;
 
@@ -148,7 +148,7 @@ static inline void volk_16sc_magnitude_32f_aligned16_sse(float* magnitudeVector,
   \param scalar The data value to be divided against each input data value of the input complex vector
   \param num_points The number of complex values in complexVector to be calculated and stored into cVector
 */
-static inline void volk_16sc_magnitude_32f_aligned16_generic(float* magnitudeVector, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
+static inline void volk_16sc_s32f_magnitude_32f_a16_generic(float* magnitudeVector, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
   const int16_t* complexVectorPtr = (const int16_t*)complexVector;
   float* magnitudeVectorPtr = magnitudeVector;
   unsigned int number = 0;
@@ -169,11 +169,11 @@ static inline void volk_16sc_magnitude_32f_aligned16_generic(float* magnitudeVec
   \param scalar The data value to be divided against each input data value of the input complex vector
   \param num_points The number of complex values in complexVector to be calculated and stored into cVector
 */
-extern void volk_16sc_magnitude_32f_aligned16_orc_impl(float* magnitudeVector, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points);
-static inline void volk_16sc_magnitude_32f_aligned16_orc(float* magnitudeVector, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
-    volk_16sc_magnitude_32f_aligned16_orc_impl(magnitudeVector, complexVector, scalar, num_points);
+extern void volk_16sc_s32f_magnitude_32f_a16_orc_impl(float* magnitudeVector, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points);
+static inline void volk_16sc_s32f_magnitude_32f_a16_orc(float* magnitudeVector, const lv_16sc_t* complexVector, const float scalar, unsigned int num_points){
+    volk_16sc_s32f_magnitude_32f_a16_orc_impl(magnitudeVector, complexVector, scalar, num_points);
 }
 #endif /* LV_HAVE_ORC */
 
 
-#endif /* INCLUDED_VOLK_16sc_MAGNITUDE_32f_ALIGNED16_H */
+#endif /* INCLUDED_volk_16sc_s32f_magnitude_32f_a16_H */
diff --git a/volk/include/volk/volk_16u_byteswap_aligned16.h b/volk/include/volk/volk_16u_byteswap_a16.h
index 9d19d1a456..c8128dbab8 100644
--- a/volk/include/volk/volk_16u_byteswap_aligned16.h
+++ b/volk/include/volk/volk_16u_byteswap_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_16u_BYTESWAP_ALIGNED16_H
-#define INCLUDED_VOLK_16u_BYTESWAP_ALIGNED16_H
+#ifndef INCLUDED_volk_16u_byteswap_a16_H
+#define INCLUDED_volk_16u_byteswap_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -12,7 +12,7 @@
   \param intsToSwap The vector of data to byte swap
   \param numDataPoints The number of data points
 */
-static inline void volk_16u_byteswap_aligned16_sse2(uint16_t* intsToSwap, unsigned int num_points){
+static inline void volk_16u_byteswap_a16_sse2(uint16_t* intsToSwap, unsigned int num_points){
   unsigned int number = 0;
   uint16_t* inputPtr = intsToSwap;
   __m128i input, left, right, output;
@@ -49,7 +49,7 @@ static inline void volk_16u_byteswap_aligned16_sse2(uint16_t* intsToSwap, unsign
   \param intsToSwap The vector of data to byte swap
   \param numDataPoints The number of data points
 */
-static inline void volk_16u_byteswap_aligned16_generic(uint16_t* intsToSwap, unsigned int num_points){
+static inline void volk_16u_byteswap_a16_generic(uint16_t* intsToSwap, unsigned int num_points){
   unsigned int point;
   uint16_t* inputPtr = intsToSwap;
   for(point = 0; point < num_points; point++){
@@ -67,11 +67,11 @@ static inline void volk_16u_byteswap_aligned16_generic(uint16_t* intsToSwap, uns
   \param intsToSwap The vector of data to byte swap
   \param numDataPoints The number of data points
 */
-extern void volk_16u_byteswap_aligned16_orc_impl(uint16_t* intsToSwap, unsigned int num_points);
-static inline void volk_16u_byteswap_aligned16_orc(uint16_t* intsToSwap, unsigned int num_points){
-    volk_16u_byteswap_aligned16_orc_impl(intsToSwap, num_points);
+extern void volk_16u_byteswap_a16_orc_impl(uint16_t* intsToSwap, unsigned int num_points);
+static inline void volk_16u_byteswap_a16_orc(uint16_t* intsToSwap, unsigned int num_points){
+    volk_16u_byteswap_a16_orc_impl(intsToSwap, num_points);
 }
 #endif /* LV_HAVE_ORC */
 
 
-#endif /* INCLUDED_VOLK_16u_BYTESWAP_ALIGNED16_H */
+#endif /* INCLUDED_volk_16u_byteswap_a16_H */
diff --git a/volk/include/volk/volk_32f_sum_of_poly_aligned16.h b/volk/include/volk/volk_32f_32f_32f_sum_of_poly_32f_a16.h
index a326e62b1d..a0f97f94e2 100644
--- a/volk/include/volk/volk_32f_sum_of_poly_aligned16.h
+++ b/volk/include/volk/volk_32f_32f_32f_sum_of_poly_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32F_SUM_OF_POLY_ALIGNED16_H
-#define INCLUDED_VOLK_32F_SUM_OF_POLY_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_32f_32f_sum_of_poly_32f_a16_H
+#define INCLUDED_volk_32f_32f_32f_sum_of_poly_32f_a16_H
 
 #include<inttypes.h>
 #include<stdio.h>
@@ -13,7 +13,7 @@
 #include<xmmintrin.h>
 #include<pmmintrin.h>
 
-static inline void volk_32f_sum_of_poly_aligned16_sse3(float* target, float* src0, float* center_point_array, float* cutoff, unsigned int num_bytes) {
+static inline void volk_32f_32f_32f_sum_of_poly_32f_a16_sse3(float* target, float* src0, float* center_point_array, float* cutoff, unsigned int num_bytes) {
   
   
   float result = 0.0;
@@ -100,7 +100,7 @@ static inline void volk_32f_sum_of_poly_aligned16_sse3(float* target, float* src
 
 #if LV_HAVE_GENERIC
 
-static inline void volk_32f_sum_of_poly_aligned16_generic(float* target, float* src0, float* center_point_array, float* cutoff, unsigned int num_bytes) {
+static inline void volk_32f_32f_32f_sum_of_poly_32f_a16_generic(float* target, float* src0, float* center_point_array, float* cutoff, unsigned int num_bytes) {
 
 
     
@@ -148,4 +148,4 @@ static inline void volk_32f_sum_of_poly_aligned16_generic(float* target, float*
 #endif /*LV_HAVE_GENERIC*/
 
 
-#endif /*INCLUDED_VOLK_32F_SUM_OF_POLY_ALIGNED16_H*/
+#endif /*INCLUDED_volk_32f_32f_32f_sum_of_poly_32f_a16_H*/
diff --git a/volk/include/volk/volk_32f_add_aligned16.h b/volk/include/volk/volk_32f_32f_add_32f_a16.h
index e7d8de265d..ba38c310f7 100644
--- a/volk/include/volk/volk_32f_add_aligned16.h
+++ b/volk/include/volk/volk_32f_32f_add_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_ADD_ALIGNED16_H
-#define INCLUDED_VOLK_32f_ADD_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_32f_add_32f_a16_H
+#define INCLUDED_volk_32f_32f_add_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param bVector One of the vectors to be added
   \param num_points The number of values in aVector and bVector to be added together and stored into cVector
 */
-static inline void volk_32f_add_aligned16_sse(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
+static inline void volk_32f_32f_add_32f_a16_sse(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int quarterPoints = num_points / 4;
 
@@ -51,7 +51,7 @@ static inline void volk_32f_add_aligned16_sse(float* cVector, const float* aVect
   \param bVector One of the vectors to be added
   \param num_points The number of values in aVector and bVector to be added together and stored into cVector
 */
-static inline void volk_32f_add_aligned16_generic(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
+static inline void volk_32f_32f_add_32f_a16_generic(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
     float* cPtr = cVector;
     const float* aPtr = aVector;
     const float* bPtr=  bVector;
@@ -71,11 +71,11 @@ static inline void volk_32f_add_aligned16_generic(float* cVector, const float* a
   \param bVector One of the vectors to be added
   \param num_points The number of values in aVector and bVector to be added together and stored into cVector
 */
-extern void volk_32f_add_aligned16_orc_impl(float* cVector, const float* aVector, const float* bVector, unsigned int num_points);
-static inline void volk_32f_add_aligned16_orc(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
-    volk_32f_add_aligned16_orc_impl(cVector, aVector, bVector, num_points);
+extern void volk_32f_32f_add_32f_a16_orc_impl(float* cVector, const float* aVector, const float* bVector, unsigned int num_points);
+static inline void volk_32f_32f_add_32f_a16_orc(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
+    volk_32f_32f_add_32f_a16_orc_impl(cVector, aVector, bVector, num_points);
 }
 #endif /* LV_HAVE_ORC */
 
 
-#endif /* INCLUDED_VOLK_32f_ADD_ALIGNED16_H */
+#endif /* INCLUDED_volk_32f_32f_add_32f_a16_H */
diff --git a/volk/include/volk/volk_32f_divide_aligned16.h b/volk/include/volk/volk_32f_32f_divide_32f_a16.h
index c595b5e92c..a0995e631b 100644
--- a/volk/include/volk/volk_32f_divide_aligned16.h
+++ b/volk/include/volk/volk_32f_32f_divide_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_DIVIDE_ALIGNED16_H
-#define INCLUDED_VOLK_32f_DIVIDE_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_32f_divide_32f_a16_H
+#define INCLUDED_volk_32f_32f_divide_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param bVector The divisor vector
   \param num_points The number of values in aVector and bVector to be divideed together and stored into cVector
 */
-static inline void volk_32f_divide_aligned16_sse(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
+static inline void volk_32f_32f_divide_32f_a16_sse(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int quarterPoints = num_points / 4;
 
@@ -51,7 +51,7 @@ static inline void volk_32f_divide_aligned16_sse(float* cVector, const float* aV
   \param bVector The divisor vector
   \param num_points The number of values in aVector and bVector to be divideed together and stored into cVector
 */
-static inline void volk_32f_divide_aligned16_generic(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
+static inline void volk_32f_32f_divide_32f_a16_generic(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
     float* cPtr = cVector;
     const float* aPtr = aVector;
     const float* bPtr=  bVector;
@@ -71,12 +71,12 @@ static inline void volk_32f_divide_aligned16_generic(float* cVector, const float
   \param bVector The divisor vector
   \param num_points The number of values in aVector and bVector to be divideed together and stored into cVector
 */
-extern void volk_32f_divide_aligned16_orc_impl(float* cVector, const float* aVector, const float* bVector, unsigned int num_points);
-static inline void volk_32f_divide_aligned16_orc(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
-    volk_32f_divide_aligned16_orc_impl(cVector, aVector, bVector, num_points);
+extern void volk_32f_32f_divide_32f_a16_orc_impl(float* cVector, const float* aVector, const float* bVector, unsigned int num_points);
+static inline void volk_32f_32f_divide_32f_a16_orc(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
+    volk_32f_32f_divide_32f_a16_orc_impl(cVector, aVector, bVector, num_points);
 }
 #endif /* LV_HAVE_ORC */
 
 
 
-#endif /* INCLUDED_VOLK_32f_DIVIDE_ALIGNED16_H */
+#endif /* INCLUDED_volk_32f_32f_divide_32f_a16_H */
diff --git a/volk/include/volk/volk_32f_dot_prod_aligned16.h b/volk/include/volk/volk_32f_32f_dot_prod_32f_a16.h
index 3aee1136ac..63f5221d32 100644
--- a/volk/include/volk/volk_32f_dot_prod_aligned16.h
+++ b/volk/include/volk/volk_32f_32f_dot_prod_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_DOT_PROD_ALIGNED16_H
-#define INCLUDED_VOLK_32f_DOT_PROD_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_32f_dot_prod_32f_a16_H
+#define INCLUDED_volk_32f_32f_dot_prod_32f_a16_H
 
 #include<stdio.h>
 
@@ -7,7 +7,7 @@
 #if LV_HAVE_GENERIC
 
 
-static inline void volk_32f_dot_prod_aligned16_generic(float * result, const float * input, const float * taps, unsigned int num_points) {
+static inline void volk_32f_32f_dot_prod_32f_a16_generic(float * result, const float * input, const float * taps, unsigned int num_points) {
 
   float dotProduct = 0;
   const float* aPtr = input;
@@ -27,7 +27,7 @@ static inline void volk_32f_dot_prod_aligned16_generic(float * result, const flo
 #if LV_HAVE_SSE
 
 
-static inline void volk_32f_dot_prod_aligned16_sse( float* result, const  float* input, const  float* taps, unsigned int num_points) {
+static inline void volk_32f_32f_dot_prod_32f_a16_sse( float* result, const  float* input, const  float* taps, unsigned int num_points) {
   
   unsigned int number = 0;
   const unsigned int quarterPoints = num_points / 4;
@@ -77,7 +77,7 @@ static inline void volk_32f_dot_prod_aligned16_sse( float* result, const  float*
 
 #include <pmmintrin.h>
 
-static inline void volk_32f_dot_prod_aligned16_sse3(float * result, const float * input, const float * taps, unsigned int num_points) {
+static inline void volk_32f_32f_dot_prod_32f_a16_sse3(float * result, const float * input, const float * taps, unsigned int num_points) {
   unsigned int number = 0;
   const unsigned int quarterPoints = num_points / 4;
 
@@ -124,7 +124,7 @@ static inline void volk_32f_dot_prod_aligned16_sse3(float * result, const float
 
 #include <smmintrin.h>
 
-static inline void volk_32f_dot_prod_aligned16_sse4_1(float * result, const float * input, const float* taps, unsigned int num_points) {
+static inline void volk_32f_32f_dot_prod_32f_a16_sse4_1(float * result, const float * input, const float* taps, unsigned int num_points) {
   unsigned int number = 0;
   const unsigned int sixteenthPoints = num_points / 16;
 
@@ -181,4 +181,4 @@ static inline void volk_32f_dot_prod_aligned16_sse4_1(float * result, const floa
 
 #endif /*LV_HAVE_SSE4_1*/
 
-#endif /*INCLUDED_VOLK_32f_DOT_PROD_ALIGNED16_H*/
+#endif /*INCLUDED_volk_32f_32f_dot_prod_32f_a16_H*/
diff --git a/volk/include/volk/volk_32f_dot_prod_unaligned16.h b/volk/include/volk/volk_32f_32f_dot_prod_32f_ua16.h
index bce6aa15fd..b5fa7d7a44 100644
--- a/volk/include/volk/volk_32f_dot_prod_unaligned16.h
+++ b/volk/include/volk/volk_32f_32f_dot_prod_32f_ua16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_DOT_PROD_UNALIGNED16_H
-#define INCLUDED_VOLK_32f_DOT_PROD_UNALIGNED16_H
+#ifndef INCLUDED_volk_32f_32f_dot_prod_32f_ua16_H
+#define INCLUDED_volk_32f_32f_dot_prod_32f_ua16_H
 
 #include<stdio.h>
 
@@ -7,7 +7,7 @@
 #if LV_HAVE_GENERIC
 
 
-static inline void volk_32f_dot_prod_unaligned16_generic(float * result, const float * input, const float * taps, unsigned int num_points) {
+static inline void volk_32f_32f_dot_prod_32f_ua16_generic(float * result, const float * input, const float * taps, unsigned int num_points) {
 
   float dotProduct = 0;
   const float* aPtr = input;
@@ -27,7 +27,7 @@ static inline void volk_32f_dot_prod_unaligned16_generic(float * result, const f
 #if LV_HAVE_SSE
 
 
-static inline void volk_32f_dot_prod_unaligned16_sse( float* result, const  float* input, const  float* taps, unsigned int num_points) {
+static inline void volk_32f_32f_dot_prod_32f_ua16_sse( float* result, const  float* input, const  float* taps, unsigned int num_points) {
   
   unsigned int number = 0;
   const unsigned int quarterPoints = num_points / 4;
@@ -77,7 +77,7 @@ static inline void volk_32f_dot_prod_unaligned16_sse( float* result, const  floa
 
 #include <pmmintrin.h>
 
-static inline void volk_32f_dot_prod_unaligned16_sse3(float * result, const float * input, const float * taps, unsigned int num_points) {
+static inline void volk_32f_32f_dot_prod_32f_ua16_sse3(float * result, const float * input, const float * taps, unsigned int num_points) {
   unsigned int number = 0;
   const unsigned int quarterPoints = num_points / 4;
 
@@ -124,7 +124,7 @@ static inline void volk_32f_dot_prod_unaligned16_sse3(float * result, const floa
 
 #include <smmintrin.h>
 
-static inline void volk_32f_dot_prod_unaligned16_sse4_1(float * result, const float * input, const float* taps, unsigned int num_points) {
+static inline void volk_32f_32f_dot_prod_32f_ua16_sse4_1(float * result, const float * input, const float* taps, unsigned int num_points) {
   unsigned int number = 0;
   const unsigned int sixteenthPoints = num_points / 16;
 
@@ -181,4 +181,4 @@ static inline void volk_32f_dot_prod_unaligned16_sse4_1(float * result, const fl
 
 #endif /*LV_HAVE_SSE4_1*/
 
-#endif /*INCLUDED_VOLK_32f_DOT_PROD_UNALIGNED16_H*/
+#endif /*INCLUDED_volk_32f_32f_dot_prod_32f_ua16_H*/
diff --git a/volk/include/volk/volk_32f_interleave_32fc_aligned16.h b/volk/include/volk/volk_32f_32f_interleave_32fc_a16.h
index 859c6a0efa..34ea933491 100644
--- a/volk/include/volk/volk_32f_interleave_32fc_aligned16.h
+++ b/volk/include/volk/volk_32f_32f_interleave_32fc_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_INTERLEAVE_32FC_ALIGNED16_H
-#define INCLUDED_VOLK_32f_INTERLEAVE_32FC_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_32f_interleave_32fc_a16_H
+#define INCLUDED_volk_32f_32f_interleave_32fc_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param complexVector The complex output vector
   \param num_points The number of complex data values to be interleaved
 */
-static inline void volk_32f_interleave_32fc_aligned16_sse(lv_32fc_t* complexVector, const float* iBuffer, const float* qBuffer, unsigned int num_points){
+static inline void volk_32f_32f_interleave_32fc_a16_sse(lv_32fc_t* complexVector, const float* iBuffer, const float* qBuffer, unsigned int num_points){
   unsigned int number = 0;
   float* complexVectorPtr = (float*)complexVector;
   const float* iBufferPtr = iBuffer;
@@ -56,7 +56,7 @@ static inline void volk_32f_interleave_32fc_aligned16_sse(lv_32fc_t* complexVect
   \param complexVector The complex output vector
   \param num_points The number of complex data values to be interleaved
 */
-static inline void volk_32f_interleave_32fc_aligned16_generic(lv_32fc_t* complexVector, const float* iBuffer, const float* qBuffer, unsigned int num_points){
+static inline void volk_32f_32f_interleave_32fc_a16_generic(lv_32fc_t* complexVector, const float* iBuffer, const float* qBuffer, unsigned int num_points){
   float* complexVectorPtr = (float*)complexVector;
   const float* iBufferPtr = iBuffer;
   const float* qBufferPtr = qBuffer;
@@ -72,4 +72,4 @@ static inline void volk_32f_interleave_32fc_aligned16_generic(lv_32fc_t* complex
 
 
 
-#endif /* INCLUDED_VOLK_32f_INTERLEAVE_32FC_ALIGNED16_H */
+#endif /* INCLUDED_volk_32f_32f_interleave_32fc_a16_H */
diff --git a/volk/include/volk/volk_32f_max_aligned16.h b/volk/include/volk/volk_32f_32f_max_32f_a16.h
index d4e30fba81..8ca7a5ba8b 100644
--- a/volk/include/volk/volk_32f_max_aligned16.h
+++ b/volk/include/volk/volk_32f_32f_max_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_MAX_ALIGNED16_H
-#define INCLUDED_VOLK_32f_MAX_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_32f_max_32f_a16_H
+#define INCLUDED_volk_32f_32f_max_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param bVector The vector to be checked
   \param num_points The number of values in aVector and bVector to be checked and stored into cVector
 */
-static inline void volk_32f_max_aligned16_sse(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
+static inline void volk_32f_32f_max_32f_a16_sse(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int quarterPoints = num_points / 4;
 
@@ -53,7 +53,7 @@ static inline void volk_32f_max_aligned16_sse(float* cVector, const float* aVect
   \param bVector The vector to be checked
   \param num_points The number of values in aVector and bVector to be checked and stored into cVector
 */
-static inline void volk_32f_max_aligned16_generic(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
+static inline void volk_32f_32f_max_32f_a16_generic(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
     float* cPtr = cVector;
     const float* aPtr = aVector;
     const float* bPtr=  bVector;
@@ -75,11 +75,11 @@ static inline void volk_32f_max_aligned16_generic(float* cVector, const float* a
   \param bVector The vector to be checked
   \param num_points The number of values in aVector and bVector to be checked and stored into cVector
 */
-extern void volk_32f_max_aligned16_orc_impl(float* cVector, const float* aVector, const float* bVector, unsigned int num_points);
-static inline void volk_32f_max_aligned16_orc(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
-    volk_32f_max_aligned16_orc_impl(cVector, aVector, bVector, num_points);
+extern void volk_32f_32f_max_32f_a16_orc_impl(float* cVector, const float* aVector, const float* bVector, unsigned int num_points);
+static inline void volk_32f_32f_max_32f_a16_orc(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
+    volk_32f_32f_max_32f_a16_orc_impl(cVector, aVector, bVector, num_points);
 }
 #endif /* LV_HAVE_ORC */
 
 
-#endif /* INCLUDED_VOLK_32f_MAX_ALIGNED16_H */
+#endif /* INCLUDED_volk_32f_32f_max_32f_a16_H */
diff --git a/volk/include/volk/volk_32f_min_aligned16.h b/volk/include/volk/volk_32f_32f_min_32f_a16.h
index 55daafb6a9..dd05988bea 100644
--- a/volk/include/volk/volk_32f_min_aligned16.h
+++ b/volk/include/volk/volk_32f_32f_min_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_MIN_ALIGNED16_H
-#define INCLUDED_VOLK_32f_MIN_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_32f_min_32f_a16_H
+#define INCLUDED_volk_32f_32f_min_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param bVector The vector to be checked
   \param num_points The number of values in aVector and bVector to be checked and stored into cVector
 */
-static inline void volk_32f_min_aligned16_sse(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
+static inline void volk_32f_32f_min_32f_a16_sse(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int quarterPoints = num_points / 4;
 
@@ -53,7 +53,7 @@ static inline void volk_32f_min_aligned16_sse(float* cVector, const float* aVect
   \param bVector The vector to be checked
   \param num_points The number of values in aVector and bVector to be checked and stored into cVector
 */
-static inline void volk_32f_min_aligned16_generic(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
+static inline void volk_32f_32f_min_32f_a16_generic(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
     float* cPtr = cVector;
     const float* aPtr = aVector;
     const float* bPtr=  bVector;
@@ -75,11 +75,11 @@ static inline void volk_32f_min_aligned16_generic(float* cVector, const float* a
   \param bVector The vector to be checked
   \param num_points The number of values in aVector and bVector to be checked and stored into cVector
 */
-extern void volk_32f_min_aligned16_orc_impl(float* cVector, const float* aVector, const float* bVector, unsigned int num_points);
-static inline void volk_32f_min_aligned16_orc(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
-    volk_32f_min_aligned16_orc_impl(cVector, aVector, bVector, num_points);
+extern void volk_32f_32f_min_32f_a16_orc_impl(float* cVector, const float* aVector, const float* bVector, unsigned int num_points);
+static inline void volk_32f_32f_min_32f_a16_orc(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
+    volk_32f_32f_min_32f_a16_orc_impl(cVector, aVector, bVector, num_points);
 }
 #endif /* LV_HAVE_ORC */
 
 
-#endif /* INCLUDED_VOLK_32f_MIN_ALIGNED16_H */
+#endif /* INCLUDED_volk_32f_32f_min_32f_a16_H */
diff --git a/volk/include/volk/volk_32f_multiply_aligned16.h b/volk/include/volk/volk_32f_32f_multiply_32f_a16.h
index 87ae7bcf8c..2d004db105 100644
--- a/volk/include/volk/volk_32f_multiply_aligned16.h
+++ b/volk/include/volk/volk_32f_32f_multiply_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_MULTIPLY_ALIGNED16_H
-#define INCLUDED_VOLK_32f_MULTIPLY_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_32f_multiply_32f_a16_H
+#define INCLUDED_volk_32f_32f_multiply_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param bVector One of the vectors to be multiplied
   \param num_points The number of values in aVector and bVector to be multiplied together and stored into cVector
 */
-static inline void volk_32f_multiply_aligned16_sse(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
+static inline void volk_32f_32f_multiply_32f_a16_sse(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int quarterPoints = num_points / 4;
 
@@ -51,7 +51,7 @@ static inline void volk_32f_multiply_aligned16_sse(float* cVector, const float*
   \param bVector One of the vectors to be multiplied
   \param num_points The number of values in aVector and bVector to be multiplied together and stored into cVector
 */
-static inline void volk_32f_multiply_aligned16_generic(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
+static inline void volk_32f_32f_multiply_32f_a16_generic(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
     float* cPtr = cVector;
     const float* aPtr = aVector;
     const float* bPtr=  bVector;
@@ -71,11 +71,11 @@ static inline void volk_32f_multiply_aligned16_generic(float* cVector, const flo
   \param bVector One of the vectors to be multiplied
   \param num_points The number of values in aVector and bVector to be multiplied together and stored into cVector
 */
-extern void volk_32f_multiply_aligned16_orc_impl(float* cVector, const float* aVector, const float* bVector, unsigned int num_points);
-static inline void volk_32f_multiply_aligned16_orc(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
-    volk_32f_multiply_aligned16_orc_impl(cVector, aVector, bVector, num_points);
+extern void volk_32f_32f_multiply_32f_a16_orc_impl(float* cVector, const float* aVector, const float* bVector, unsigned int num_points);
+static inline void volk_32f_32f_multiply_32f_a16_orc(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
+    volk_32f_32f_multiply_32f_a16_orc_impl(cVector, aVector, bVector, num_points);
 }
 #endif /* LV_HAVE_ORC */
 
 
-#endif /* INCLUDED_VOLK_32f_MULTIPLY_ALIGNED16_H */
+#endif /* INCLUDED_volk_32f_32f_multiply_32f_a16_H */
diff --git a/volk/include/volk/volk_32f_interleave_16sc_aligned16.h b/volk/include/volk/volk_32f_32f_s32f_interleave_16sc_a16.h
index 476946b887..207382a199 100644
--- a/volk/include/volk/volk_32f_interleave_16sc_aligned16.h
+++ b/volk/include/volk/volk_32f_32f_s32f_interleave_16sc_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_INTERLEAVE_16SC_ALIGNED16_H
-#define INCLUDED_VOLK_32f_INTERLEAVE_16SC_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_32f_s32f_interleave_16sc_a16_H
+#define INCLUDED_volk_32f_32f_s32f_interleave_16sc_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -14,7 +14,7 @@
     \param scalar The scaling value being multiplied against each data point
     \param num_points The number of complex data values to be interleaved
   */
-static inline void volk_32f_interleave_16sc_aligned16_sse2(lv_16sc_t* complexVector, const float* iBuffer, const float* qBuffer, const float scalar, unsigned int num_points){
+static inline void volk_32f_32f_s32f_interleave_16sc_a16_sse2(lv_16sc_t* complexVector, const float* iBuffer, const float* qBuffer, const float scalar, unsigned int num_points){
     unsigned int number = 0;
     const float* iBufferPtr = iBuffer;
     const float* qBufferPtr = qBuffer;
@@ -72,7 +72,7 @@ static inline void volk_32f_interleave_16sc_aligned16_sse2(lv_16sc_t* complexVec
     \param scalar The scaling value being multiplied against each data point
     \param num_points The number of complex data values to be interleaved
   */
-static inline void volk_32f_interleave_16sc_aligned16_sse(lv_16sc_t* complexVector, const float* iBuffer, const float* qBuffer, const float scalar, unsigned int num_points){
+static inline void volk_32f_32f_s32f_interleave_16sc_a16_sse(lv_16sc_t* complexVector, const float* iBuffer, const float* qBuffer, const float scalar, unsigned int num_points){
     unsigned int number = 0;
     const float* iBufferPtr = iBuffer;
     const float* qBufferPtr = qBuffer;
@@ -136,7 +136,7 @@ static inline void volk_32f_interleave_16sc_aligned16_sse(lv_16sc_t* complexVect
     \param scalar The scaling value being multiplied against each data point
     \param num_points The number of complex data values to be interleaved
   */
-static inline void volk_32f_interleave_16sc_aligned16_generic(lv_16sc_t* complexVector, const float* iBuffer, const float* qBuffer, const float scalar, unsigned int num_points){
+static inline void volk_32f_32f_s32f_interleave_16sc_a16_generic(lv_16sc_t* complexVector, const float* iBuffer, const float* qBuffer, const float scalar, unsigned int num_points){
   int16_t* complexVectorPtr = (int16_t*)complexVector;
   const float* iBufferPtr = iBuffer;
   const float* qBufferPtr = qBuffer;
@@ -152,4 +152,4 @@ static inline void volk_32f_interleave_16sc_aligned16_generic(lv_16sc_t* complex
 
 
 
-#endif /* INCLUDED_VOLK_32f_INTERLEAVE_16SC_ALIGNED16_H */
+#endif /* INCLUDED_volk_32f_32f_s32f_interleave_16sc_a16_H */
diff --git a/volk/include/volk/volk_32f_subtract_aligned16.h b/volk/include/volk/volk_32f_32f_subtract_32f_a16.h
index e152429016..9fea6aa27e 100644
--- a/volk/include/volk/volk_32f_subtract_aligned16.h
+++ b/volk/include/volk/volk_32f_32f_subtract_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_SUBTRACT_ALIGNED16_H
-#define INCLUDED_VOLK_32f_SUBTRACT_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_32f_subtract_32f_a16_H
+#define INCLUDED_volk_32f_32f_subtract_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param bVector The vector to be subtracted
   \param num_points The number of values in aVector and bVector to be subtracted together and stored into cVector
 */
-static inline void volk_32f_subtract_aligned16_sse(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
+static inline void volk_32f_32f_subtract_32f_a16_sse(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int quarterPoints = num_points / 4;
 
@@ -51,7 +51,7 @@ static inline void volk_32f_subtract_aligned16_sse(float* cVector, const float*
   \param bVector The vector to be subtracted
   \param num_points The number of values in aVector and bVector to be subtracted together and stored into cVector
 */
-static inline void volk_32f_subtract_aligned16_generic(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
+static inline void volk_32f_32f_subtract_32f_a16_generic(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
     float* cPtr = cVector;
     const float* aPtr = aVector;
     const float* bPtr=  bVector;
@@ -71,11 +71,11 @@ static inline void volk_32f_subtract_aligned16_generic(float* cVector, const flo
   \param bVector The vector to be subtracted
   \param num_points The number of values in aVector and bVector to be subtracted together and stored into cVector
 */
-extern void volk_32f_subtract_aligned16_orc_impl(float* cVector, const float* aVector, const float* bVector, unsigned int num_points);
-static inline void volk_32f_subtract_aligned16_orc(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
-    volk_32f_subtract_aligned16_orc_impl(cVector, aVector, bVector, num_points);
+extern void volk_32f_32f_subtract_32f_a16_orc_impl(float* cVector, const float* aVector, const float* bVector, unsigned int num_points);
+static inline void volk_32f_32f_subtract_32f_a16_orc(float* cVector, const float* aVector, const float* bVector, unsigned int num_points){
+    volk_32f_32f_subtract_32f_a16_orc_impl(cVector, aVector, bVector, num_points);
 }
 #endif /* LV_HAVE_ORC */
 
 
-#endif /* INCLUDED_VOLK_32f_SUBTRACT_ALIGNED16_H */
+#endif /* INCLUDED_volk_32f_32f_subtract_32f_a16_H */
diff --git a/volk/include/volk/volk_32f_accumulator_aligned16.h b/volk/include/volk/volk_32f_accumulator_s32f_a16.h
index 7e395cf501..4a3588e6d2 100644
--- a/volk/include/volk/volk_32f_accumulator_aligned16.h
+++ b/volk/include/volk/volk_32f_accumulator_s32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_ACCUMULATOR_ALIGNED16_H
-#define INCLUDED_VOLK_32f_ACCUMULATOR_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_accumulator_s32f_a16_H
+#define INCLUDED_volk_32f_accumulator_s32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -12,7 +12,7 @@
   \param inputBuffer The buffer of data to be accumulated
   \param num_points The number of values in inputBuffer to be accumulated
 */
-static inline void volk_32f_accumulator_aligned16_sse(float* result, const float* inputBuffer, unsigned int num_points){
+static inline void volk_32f_accumulator_s32f_a16_sse(float* result, const float* inputBuffer, unsigned int num_points){
   float returnValue = 0;
   unsigned int number = 0;
   const unsigned int quarterPoints = num_points / 4;
@@ -49,7 +49,7 @@ static inline void volk_32f_accumulator_aligned16_sse(float* result, const float
   \param inputBuffer The buffer of data to be accumulated
   \param num_points The number of values in inputBuffer to be accumulated
 */
-static inline void volk_32f_accumulator_aligned16_generic(float* result, const float* inputBuffer, unsigned int num_points){
+static inline void volk_32f_accumulator_s32f_a16_generic(float* result, const float* inputBuffer, unsigned int num_points){
   const float* aPtr = inputBuffer;
   unsigned int number = 0;
   float returnValue = 0;
@@ -64,4 +64,4 @@ static inline void volk_32f_accumulator_aligned16_generic(float* result, const f
 
 
 
-#endif /* INCLUDED_VOLK_32f_ACCUMULATOR_ALIGNED16_H */
+#endif /* INCLUDED_volk_32f_accumulator_s32f_a16_H */
diff --git a/volk/include/volk/volk_32f_calc_spectral_noise_floor_aligned16.h b/volk/include/volk/volk_32f_calc_spectral_noise_floor_a16.h
index ff917525ff..fce77cd045 100644
--- a/volk/include/volk/volk_32f_calc_spectral_noise_floor_aligned16.h
+++ b/volk/include/volk/volk_32f_calc_spectral_noise_floor_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_CALC_SPECTRAL_NOISE_FLOOR_ALIGNED16_H
-#define INCLUDED_VOLK_32f_CALC_SPECTRAL_NOISE_FLOOR_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_calc_spectral_noise_floor_a16_H
+#define INCLUDED_volk_32f_calc_spectral_noise_floor_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -16,7 +16,7 @@
   \param spectralExclusionValue The number of dB above the noise floor that a data point must be to be excluded from the noise floor calculation - default value is 20
   \param noiseFloorAmplitude The noise floor of the input spectrum, in dB
 */
-static inline void volk_32f_calc_spectral_noise_floor_aligned16_sse(float* noiseFloorAmplitude, const float* realDataPoints, const float spectralExclusionValue, const unsigned int num_points){
+static inline void volk_32f_calc_spectral_noise_floor_a16_sse(float* noiseFloorAmplitude, const float* realDataPoints, const float spectralExclusionValue, const unsigned int num_points){
   unsigned int number = 0;
   const unsigned int quarterPoints = num_points / 4;
 
@@ -127,7 +127,7 @@ static inline void volk_32f_calc_spectral_noise_floor_aligned16_sse(float* noise
   \param spectralExclusionValue The number of dB above the noise floor that a data point must be to be excluded from the noise floor calculation - default value is 20
   \param noiseFloorAmplitude The noise floor of the input spectrum, in dB
 */
-static inline void volk_32f_calc_spectral_noise_floor_aligned16_generic(float* noiseFloorAmplitude, const float* realDataPoints, const float spectralExclusionValue, const unsigned int num_points){
+static inline void volk_32f_calc_spectral_noise_floor_a16_generic(float* noiseFloorAmplitude, const float* realDataPoints, const float spectralExclusionValue, const unsigned int num_points){
   float sumMean = 0.0;
   unsigned int number;
   // find the sum (for mean), etc
@@ -164,4 +164,4 @@ static inline void volk_32f_calc_spectral_noise_floor_aligned16_generic(float* n
 
 
 
-#endif /* INCLUDED_VOLK_32f_CALC_SPECTRAL_NOISE_FLOOR_ALIGNED16_H */
+#endif /* INCLUDED_volk_32f_calc_spectral_noise_floor_a16_H */
diff --git a/volk/include/volk/volk_32f_convert_64f_aligned16.h b/volk/include/volk/volk_32f_convert_64f_a16.h
index 91a8558135..c303dc1188 100644
--- a/volk/include/volk/volk_32f_convert_64f_aligned16.h
+++ b/volk/include/volk/volk_32f_convert_64f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_CONVERT_64f_ALIGNED16_H
-#define INCLUDED_VOLK_32f_CONVERT_64f_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_convert_64f_a16_H
+#define INCLUDED_volk_32f_convert_64f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -12,7 +12,7 @@
     \param fVector The float vector values to be converted
     \param num_points The number of points in the two vectors to be converted
   */
-static inline void volk_32f_convert_64f_aligned16_sse2(double* outputVector, const float* inputVector, unsigned int num_points){
+static inline void volk_32f_convert_64f_a16_sse2(double* outputVector, const float* inputVector, unsigned int num_points){
   unsigned int number = 0;
 
   const unsigned int quarterPoints = num_points / 4;
@@ -53,7 +53,7 @@ static inline void volk_32f_convert_64f_aligned16_sse2(double* outputVector, con
   \param fVector The float vector values to be converted
   \param num_points The number of points in the two vectors to be converted
 */
-static inline void volk_32f_convert_64f_aligned16_generic(double* outputVector, const float* inputVector, unsigned int num_points){
+static inline void volk_32f_convert_64f_a16_generic(double* outputVector, const float* inputVector, unsigned int num_points){
   double* outputVectorPtr = outputVector;
   const float* inputVectorPtr = inputVector;
   unsigned int number = 0;
@@ -67,4 +67,4 @@ static inline void volk_32f_convert_64f_aligned16_generic(double* outputVector,
 
 
 
-#endif /* INCLUDED_VOLK_32f_CONVERT_64f_ALIGNED16_H */
+#endif /* INCLUDED_volk_32f_convert_64f_a16_H */
diff --git a/volk/include/volk/volk_32f_convert_64f_unaligned16.h b/volk/include/volk/volk_32f_convert_64f_ua16.h
index 698e0d4460..c8de768dc9 100644
--- a/volk/include/volk/volk_32f_convert_64f_unaligned16.h
+++ b/volk/include/volk/volk_32f_convert_64f_ua16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_CONVERT_64f_UNALIGNED16_H
-#define INCLUDED_VOLK_32f_CONVERT_64f_UNALIGNED16_H
+#ifndef INCLUDED_volk_32f_convert_64f_ua16_H
+#define INCLUDED_volk_32f_convert_64f_ua16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -12,7 +12,7 @@
     \param fVector The float vector values to be converted
     \param num_points The number of points in the two vectors to be converted
   */
-static inline void volk_32f_convert_64f_unaligned16_sse2(double* outputVector, const float* inputVector, unsigned int num_points){
+static inline void volk_32f_convert_64f_ua16_sse2(double* outputVector, const float* inputVector, unsigned int num_points){
   unsigned int number = 0;
 
   const unsigned int quarterPoints = num_points / 4;
@@ -53,7 +53,7 @@ static inline void volk_32f_convert_64f_unaligned16_sse2(double* outputVector, c
   \param fVector The float vector values to be converted
   \param num_points The number of points in the two vectors to be converted
 */
-static inline void volk_32f_convert_64f_unaligned16_generic(double* outputVector, const float* inputVector, unsigned int num_points){
+static inline void volk_32f_convert_64f_ua16_generic(double* outputVector, const float* inputVector, unsigned int num_points){
   double* outputVectorPtr = outputVector;
   const float* inputVectorPtr = inputVector;
   unsigned int number = 0;
@@ -67,4 +67,4 @@ static inline void volk_32f_convert_64f_unaligned16_generic(double* outputVector
 
 
 
-#endif /* INCLUDED_VOLK_32f_CONVERT_64f_UNALIGNED16_H */
+#endif /* INCLUDED_volk_32f_convert_64f_ua16_H */
diff --git a/volk/include/volk/volk_32f_index_max_aligned16.h b/volk/include/volk/volk_32f_index_max_16u_a16.h
index 26322bfa26..d070e17d56 100644
--- a/volk/include/volk/volk_32f_index_max_aligned16.h
+++ b/volk/include/volk/volk_32f_index_max_16u_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32F_INDEX_MAX_ALIGNED16_H
-#define INCLUDED_VOLK_32F_INDEX_MAX_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_index_max_16u_a16_H
+#define INCLUDED_volk_32f_index_max_16u_a16_H
 
 #include <volk/volk_common.h>
 #include <inttypes.h>
@@ -8,7 +8,7 @@
 #if LV_HAVE_SSE4_1
 #include<smmintrin.h>
 
-static inline void volk_32f_index_max_aligned16_sse4_1(unsigned int* target, const float* src0, unsigned int num_points) {
+static inline void volk_32f_index_max_16u_a16_sse4_1(unsigned int* target, const float* src0, unsigned int num_points) {
   if(num_points > 0){
     unsigned int number = 0;
     const unsigned int quarterPoints = num_points / 4;
@@ -66,7 +66,7 @@ static inline void volk_32f_index_max_aligned16_sse4_1(unsigned int* target, con
 #if LV_HAVE_SSE
 #include<xmmintrin.h>
 
-static inline void volk_32f_index_max_aligned16_sse(unsigned int* target, const float* src0, unsigned int num_points) {
+static inline void volk_32f_index_max_16u_a16_sse(unsigned int* target, const float* src0, unsigned int num_points) {
   if(num_points > 0){
     unsigned int number = 0;
     const unsigned int quarterPoints = num_points / 4;
@@ -123,7 +123,7 @@ static inline void volk_32f_index_max_aligned16_sse(unsigned int* target, const
 #endif /*LV_HAVE_SSE*/
 
 #if LV_HAVE_GENERIC
-static inline void volk_32f_index_max_aligned16_generic(unsigned int* target, const float* src0, unsigned int num_points) {
+static inline void volk_32f_index_max_16u_a16_generic(unsigned int* target, const float* src0, unsigned int num_points) {
   if(num_points > 0){
     float max = src0[0];
     unsigned int index = 0;
@@ -145,4 +145,4 @@ static inline void volk_32f_index_max_aligned16_generic(unsigned int* target, co
 #endif /*LV_HAVE_GENERIC*/
 
 
-#endif /*INCLUDED_VOLK_32F_INDEX_MAX_ALIGNED16_H*/
+#endif /*INCLUDED_volk_32f_index_max_16u_a16_H*/
diff --git a/volk/include/volk/volk_32f_fm_detect_aligned16.h b/volk/include/volk/volk_32f_s32f_32f_fm_detect_32f_a16.h
index c82239d749..ff4d5b19c3 100644
--- a/volk/include/volk/volk_32f_fm_detect_aligned16.h
+++ b/volk/include/volk/volk_32f_s32f_32f_fm_detect_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_FM_DETECT_ALIGNED16_H
-#define INCLUDED_VOLK_32f_FM_DETECT_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_s32f_32f_fm_detect_32f_a16_H
+#define INCLUDED_volk_32f_s32f_32f_fm_detect_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -14,7 +14,7 @@
   \param saveValue A pointer to a float which contains the phase value of the sample before the first input sample.
   \param num_noints The number of real values in the input vector.
 */
-static inline void volk_32f_fm_detect_aligned16_sse(float* outputVector, const float* inputVector, const float bound, float* saveValue, unsigned int num_points){
+static inline void volk_32f_s32f_32f_fm_detect_32f_a16_sse(float* outputVector, const float* inputVector, const float bound, float* saveValue, unsigned int num_points){
   if (num_points < 1) {
     return;
   }
@@ -87,7 +87,7 @@ static inline void volk_32f_fm_detect_aligned16_sse(float* outputVector, const f
   \param saveValue A pointer to a float which contains the phase value of the sample before the first input sample.
   \param num_points The number of real values in the input vector.
 */
-static inline void volk_32f_fm_detect_aligned16_generic(float* outputVector, const float* inputVector, const float bound, float* saveValue, unsigned int num_points){
+static inline void volk_32f_s32f_32f_fm_detect_32f_a16_generic(float* outputVector, const float* inputVector, const float bound, float* saveValue, unsigned int num_points){
   if (num_points < 1) {
     return;
   }
@@ -117,4 +117,4 @@ static inline void volk_32f_fm_detect_aligned16_generic(float* outputVector, con
 
 
 
-#endif /* INCLUDED_VOLK_32f_FM_DETECT_ALIGNED16_H */
+#endif /* INCLUDED_volk_32f_s32f_32f_fm_detect_32f_a16_H */
diff --git a/volk/include/volk/volk_32f_convert_16s_aligned16.h b/volk/include/volk/volk_32f_s32f_convert_16s_a16.h
index 7fbabd9c38..cf51cf9c53 100644
--- a/volk/include/volk/volk_32f_convert_16s_aligned16.h
+++ b/volk/include/volk/volk_32f_s32f_convert_16s_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_CONVERT_16s_ALIGNED16_H
-#define INCLUDED_VOLK_32f_CONVERT_16s_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_s32f_convert_16s_a16_H
+#define INCLUDED_volk_32f_s32f_convert_16s_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
     \param scalar The value multiplied against each point in the input buffer
     \param num_points The number of data values to be converted
   */
-static inline void volk_32f_convert_16s_aligned16_sse2(int16_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32f_s32f_convert_16s_a16_sse2(int16_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
 
   const unsigned int eighthPoints = num_points / 8;
@@ -53,7 +53,7 @@ static inline void volk_32f_convert_16s_aligned16_sse2(int16_t* outputVector, co
     \param scalar The value multiplied against each point in the input buffer
     \param num_points The number of data values to be converted
   */
-static inline void volk_32f_convert_16s_aligned16_sse(int16_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32f_s32f_convert_16s_a16_sse(int16_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
 
   const unsigned int quarterPoints = num_points / 4;
@@ -93,7 +93,7 @@ static inline void volk_32f_convert_16s_aligned16_sse(int16_t* outputVector, con
     \param scalar The value multiplied against each point in the input buffer
     \param num_points The number of data values to be converted
   */
-static inline void volk_32f_convert_16s_aligned16_generic(int16_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32f_s32f_convert_16s_a16_generic(int16_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
   int16_t* outputVectorPtr = outputVector;
   const float* inputVectorPtr = inputVector;
   unsigned int number = 0;
@@ -107,4 +107,4 @@ static inline void volk_32f_convert_16s_aligned16_generic(int16_t* outputVector,
 
 
 
-#endif /* INCLUDED_VOLK_32f_CONVERT_16s_ALIGNED16_H */
+#endif /* INCLUDED_volk_32f_s32f_convert_16s_a16_H */
diff --git a/volk/include/volk/volk_32f_convert_16s_unaligned16.h b/volk/include/volk/volk_32f_s32f_convert_16s_ua16.h
index d2bbdf13ad..53d159f82a 100644
--- a/volk/include/volk/volk_32f_convert_16s_unaligned16.h
+++ b/volk/include/volk/volk_32f_s32f_convert_16s_ua16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_CONVERT_16s_UNALIGNED16_H
-#define INCLUDED_VOLK_32f_CONVERT_16s_UNALIGNED16_H
+#ifndef INCLUDED_volk_32f_s32f_convert_16s_ua16_H
+#define INCLUDED_volk_32f_s32f_convert_16s_ua16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -14,7 +14,7 @@
     \param num_points The number of data values to be converted
     \note Input buffer does NOT need to be properly aligned
   */
-static inline void volk_32f_convert_16s_unaligned16_sse2(int16_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32f_s32f_convert_16s_ua16_sse2(int16_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
 
   const unsigned int eighthPoints = num_points / 8;
@@ -55,7 +55,7 @@ static inline void volk_32f_convert_16s_unaligned16_sse2(int16_t* outputVector,
     \param num_points The number of data values to be converted
     \note Input buffer does NOT need to be properly aligned
   */
-static inline void volk_32f_convert_16s_unaligned16_sse(int16_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32f_s32f_convert_16s_ua16_sse(int16_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
 
   const unsigned int quarterPoints = num_points / 4;
@@ -96,7 +96,7 @@ static inline void volk_32f_convert_16s_unaligned16_sse(int16_t* outputVector, c
     \param num_points The number of data values to be converted
     \note Input buffer does NOT need to be properly aligned
   */
-static inline void volk_32f_convert_16s_unaligned16_generic(int16_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32f_s32f_convert_16s_ua16_generic(int16_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
   int16_t* outputVectorPtr = outputVector;
   const float* inputVectorPtr = inputVector;
   unsigned int number = 0;
@@ -110,4 +110,4 @@ static inline void volk_32f_convert_16s_unaligned16_generic(int16_t* outputVecto
 
 
 
-#endif /* INCLUDED_VOLK_32f_CONVERT_16s_UNALIGNED16_H */
+#endif /* INCLUDED_volk_32f_s32f_convert_16s_ua16_H */
diff --git a/volk/include/volk/volk_32f_convert_32s_aligned16.h b/volk/include/volk/volk_32f_s32f_convert_32s_a16.h
index 011ef5d0e4..0be649418a 100644
--- a/volk/include/volk/volk_32f_convert_32s_aligned16.h
+++ b/volk/include/volk/volk_32f_s32f_convert_32s_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_CONVERT_32s_ALIGNED16_H
-#define INCLUDED_VOLK_32f_CONVERT_32s_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_s32f_convert_32s_a16_H
+#define INCLUDED_volk_32f_s32f_convert_32s_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
     \param scalar The value multiplied against each point in the input buffer
     \param num_points The number of data values to be converted
   */
-static inline void volk_32f_convert_32s_aligned16_sse2(int32_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32f_s32f_convert_32s_a16_sse2(int32_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
 
   const unsigned int quarterPoints = num_points / 4;
@@ -49,7 +49,7 @@ static inline void volk_32f_convert_32s_aligned16_sse2(int32_t* outputVector, co
     \param scalar The value multiplied against each point in the input buffer
     \param num_points The number of data values to be converted
   */
-static inline void volk_32f_convert_32s_aligned16_sse(int32_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32f_s32f_convert_32s_a16_sse(int32_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
 
   const unsigned int quarterPoints = num_points / 4;
@@ -89,7 +89,7 @@ static inline void volk_32f_convert_32s_aligned16_sse(int32_t* outputVector, con
     \param scalar The value multiplied against each point in the input buffer
     \param num_points The number of data values to be converted
   */
-static inline void volk_32f_convert_32s_aligned16_generic(int32_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32f_s32f_convert_32s_a16_generic(int32_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
   int32_t* outputVectorPtr = outputVector;
   const float* inputVectorPtr = inputVector;
   unsigned int number = 0;
@@ -103,4 +103,4 @@ static inline void volk_32f_convert_32s_aligned16_generic(int32_t* outputVector,
 
 
 
-#endif /* INCLUDED_VOLK_32f_CONVERT_32s_ALIGNED16_H */
+#endif /* INCLUDED_volk_32f_s32f_convert_32s_a16_H */
diff --git a/volk/include/volk/volk_32f_convert_32s_unaligned16.h b/volk/include/volk/volk_32f_s32f_convert_32s_ua16.h
index a6df826c72..efb2c3a20d 100644
--- a/volk/include/volk/volk_32f_convert_32s_unaligned16.h
+++ b/volk/include/volk/volk_32f_s32f_convert_32s_ua16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_CONVERT_32s_UNALIGNED16_H
-#define INCLUDED_VOLK_32f_CONVERT_32s_UNALIGNED16_H
+#ifndef INCLUDED_volk_32f_s32f_convert_32s_ua16_H
+#define INCLUDED_volk_32f_s32f_convert_32s_ua16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -14,7 +14,7 @@
     \param num_points The number of data values to be converted
     \note Input buffer does NOT need to be properly aligned
   */
-static inline void volk_32f_convert_32s_unaligned16_sse2(int32_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32f_s32f_convert_32s_ua16_sse2(int32_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
 
   const unsigned int quarterPoints = num_points / 4;
@@ -51,7 +51,7 @@ static inline void volk_32f_convert_32s_unaligned16_sse2(int32_t* outputVector,
     \param num_points The number of data values to be converted
     \note Input buffer does NOT need to be properly aligned
   */
-static inline void volk_32f_convert_32s_unaligned16_sse(int32_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32f_s32f_convert_32s_ua16_sse(int32_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
 
   const unsigned int quarterPoints = num_points / 4;
@@ -92,7 +92,7 @@ static inline void volk_32f_convert_32s_unaligned16_sse(int32_t* outputVector, c
     \param num_points The number of data values to be converted
     \note Input buffer does NOT need to be properly aligned
   */
-static inline void volk_32f_convert_32s_unaligned16_generic(int32_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32f_s32f_convert_32s_ua16_generic(int32_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
   int32_t* outputVectorPtr = outputVector;
   const float* inputVectorPtr = inputVector;
   unsigned int number = 0;
@@ -106,4 +106,4 @@ static inline void volk_32f_convert_32s_unaligned16_generic(int32_t* outputVecto
 
 
 
-#endif /* INCLUDED_VOLK_32f_CONVERT_32s_UNALIGNED16_H */
+#endif /* INCLUDED_volk_32f_s32f_convert_32s_ua16_H */
diff --git a/volk/include/volk/volk_32f_convert_8s_aligned16.h b/volk/include/volk/volk_32f_s32f_convert_8s_a16.h
index b9487b6229..69ccec5c63 100644
--- a/volk/include/volk/volk_32f_convert_8s_aligned16.h
+++ b/volk/include/volk/volk_32f_s32f_convert_8s_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_CONVERT_8s_ALIGNED16_H
-#define INCLUDED_VOLK_32f_CONVERT_8s_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_s32f_convert_8s_a16_H
+#define INCLUDED_volk_32f_s32f_convert_8s_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
     \param scalar The value multiplied against each point in the input buffer
     \param num_points The number of data values to be converted
   */
-static inline void volk_32f_convert_8s_aligned16_sse2(int8_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32f_s32f_convert_8s_a16_sse2(int8_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
 
   const unsigned int sixteenthPoints = num_points / 16;
@@ -60,7 +60,7 @@ static inline void volk_32f_convert_8s_aligned16_sse2(int8_t* outputVector, cons
     \param scalar The value multiplied against each point in the input buffer
     \param num_points The number of data values to be converted
   */
-static inline void volk_32f_convert_8s_aligned16_sse(int8_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32f_s32f_convert_8s_a16_sse(int8_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
 
   const unsigned int quarterPoints = num_points / 4;
@@ -100,7 +100,7 @@ static inline void volk_32f_convert_8s_aligned16_sse(int8_t* outputVector, const
     \param scalar The value multiplied against each point in the input buffer
     \param num_points The number of data values to be converted
   */
-static inline void volk_32f_convert_8s_aligned16_generic(int8_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32f_s32f_convert_8s_a16_generic(int8_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
   int8_t* outputVectorPtr = outputVector;
   const float* inputVectorPtr = inputVector;
   unsigned int number = 0;
@@ -114,4 +114,4 @@ static inline void volk_32f_convert_8s_aligned16_generic(int8_t* outputVector, c
 
 
 
-#endif /* INCLUDED_VOLK_32f_CONVERT_8s_ALIGNED16_H */
+#endif /* INCLUDED_volk_32f_s32f_convert_8s_a16_H */
diff --git a/volk/include/volk/volk_32f_convert_8s_unaligned16.h b/volk/include/volk/volk_32f_s32f_convert_8s_ua16.h
index e986dbc872..af1652b194 100644
--- a/volk/include/volk/volk_32f_convert_8s_unaligned16.h
+++ b/volk/include/volk/volk_32f_s32f_convert_8s_ua16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_CONVERT_8s_UNALIGNED16_H
-#define INCLUDED_VOLK_32f_CONVERT_8s_UNALIGNED16_H
+#ifndef INCLUDED_volk_32f_s32f_convert_8s_ua16_H
+#define INCLUDED_volk_32f_s32f_convert_8s_ua16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -14,7 +14,7 @@
     \param num_points The number of data values to be converted
     \note Input buffer does NOT need to be properly aligned
   */
-static inline void volk_32f_convert_8s_unaligned16_sse2(int8_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32f_s32f_convert_8s_ua16_sse2(int8_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
 
   const unsigned int sixteenthPoints = num_points / 16;
@@ -62,7 +62,7 @@ static inline void volk_32f_convert_8s_unaligned16_sse2(int8_t* outputVector, co
     \param num_points The number of data values to be converted
     \note Input buffer does NOT need to be properly aligned
   */
-static inline void volk_32f_convert_8s_unaligned16_sse(int8_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32f_s32f_convert_8s_ua16_sse(int8_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
 
   const unsigned int quarterPoints = num_points / 4;
@@ -103,7 +103,7 @@ static inline void volk_32f_convert_8s_unaligned16_sse(int8_t* outputVector, con
     \param num_points The number of data values to be converted
     \note Input buffer does NOT need to be properly aligned
   */
-static inline void volk_32f_convert_8s_unaligned16_generic(int8_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32f_s32f_convert_8s_ua16_generic(int8_t* outputVector, const float* inputVector, const float scalar, unsigned int num_points){
   int8_t* outputVectorPtr = outputVector;
   const float* inputVectorPtr = inputVector;
   unsigned int number = 0;
@@ -117,4 +117,4 @@ static inline void volk_32f_convert_8s_unaligned16_generic(int8_t* outputVector,
 
 
 
-#endif /* INCLUDED_VOLK_32f_CONVERT_8s_UNALIGNED16_H */
+#endif /* INCLUDED_volk_32f_s32f_convert_8s_ua16_H */
diff --git a/volk/include/volk/volk_32f_normalize_aligned16.h b/volk/include/volk/volk_32f_s32f_normalize_a16.h
index 323d0513c2..0850cddf79 100644
--- a/volk/include/volk/volk_32f_normalize_aligned16.h
+++ b/volk/include/volk/volk_32f_s32f_normalize_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_NORMALIZE_ALIGNED16_H
-#define INCLUDED_VOLK_32f_NORMALIZE_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_s32f_normalize_a16_H
+#define INCLUDED_volk_32f_s32f_normalize_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -12,7 +12,7 @@
   \param num_points The number of values in vecBuffer
   \param scalar The scale value to be applied to each buffer value
 */
-static inline void volk_32f_normalize_aligned16_sse(float* vecBuffer, const float scalar, unsigned int num_points){
+static inline void volk_32f_s32f_normalize_a16_sse(float* vecBuffer, const float scalar, unsigned int num_points){
   unsigned int number = 0;
   float* inputPtr = vecBuffer;
 
@@ -49,7 +49,7 @@ static inline void volk_32f_normalize_aligned16_sse(float* vecBuffer, const floa
   \param bVector One of the vectors to be normalizeed
   \param num_points The number of values in aVector and bVector to be normalizeed together and stored into cVector
 */
-static inline void volk_32f_normalize_aligned16_generic(float* vecBuffer, const float scalar, unsigned int num_points){
+static inline void volk_32f_s32f_normalize_a16_generic(float* vecBuffer, const float scalar, unsigned int num_points){
   unsigned int number = 0;
   float* inputPtr = vecBuffer;
   const float invScalar = 1.0 / scalar;
@@ -68,14 +68,14 @@ static inline void volk_32f_normalize_aligned16_generic(float* vecBuffer, const
   \param bVector One of the vectors to be normalizeed
   \param num_points The number of values in aVector and bVector to be normalizeed together and stored into cVector
 */
-extern void volk_32f_normalize_aligned16_orc_impl(float* dst, float* src, const float scalar, unsigned int num_points);
-static inline void volk_32f_normalize_aligned16_orc(float* vecBuffer, const float scalar, unsigned int num_points){
+extern void volk_32f_s32f_normalize_a16_orc_impl(float* dst, float* src, const float scalar, unsigned int num_points);
+static inline void volk_32f_s32f_normalize_a16_orc(float* vecBuffer, const float scalar, unsigned int num_points){
     float invscalar = 1.0 / scalar;
-    volk_32f_normalize_aligned16_orc_impl(vecBuffer, vecBuffer, invscalar, num_points);
+    volk_32f_s32f_normalize_a16_orc_impl(vecBuffer, vecBuffer, invscalar, num_points);
 }
 #endif /* LV_HAVE_GENERIC */
 
 
 
 
-#endif /* INCLUDED_VOLK_32f_NORMALIZE_ALIGNED16_H */
+#endif /* INCLUDED_volk_32f_s32f_normalize_a16_H */
diff --git a/volk/include/volk/volk_32f_power_aligned16.h b/volk/include/volk/volk_32f_s32f_power_32f_a16.h
index 2ecd8eecbd..3ed594d9a7 100644
--- a/volk/include/volk/volk_32f_power_aligned16.h
+++ b/volk/include/volk/volk_32f_s32f_power_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_POWER_ALIGNED16_H
-#define INCLUDED_VOLK_32f_POWER_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_s32f_power_32f_a16_H
+#define INCLUDED_volk_32f_s32f_power_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -19,7 +19,7 @@
   \param power The power value to be applied to each data point
   \param num_points The number of values in aVector to be taken to the specified power level and stored into cVector
 */
-static inline void volk_32f_power_aligned16_sse4_1(float* cVector, const float* aVector, const float power, unsigned int num_points){
+static inline void volk_32f_s32f_power_32f_a16_sse4_1(float* cVector, const float* aVector, const float power, unsigned int num_points){
   unsigned int number = 0;
   const unsigned int quarterPoints = num_points / 4;
   
@@ -76,7 +76,7 @@ static inline void volk_32f_power_aligned16_sse4_1(float* cVector, const float*
   \param power The power value to be applied to each data point
   \param num_points The number of values in aVector to be taken to the specified power level and stored into cVector
 */
-static inline void volk_32f_power_aligned16_sse(float* cVector, const float* aVector, const float power, unsigned int num_points){
+static inline void volk_32f_s32f_power_32f_a16_sse(float* cVector, const float* aVector, const float power, unsigned int num_points){
   unsigned int number = 0;
   const unsigned int quarterPoints = num_points / 4;
   
@@ -127,7 +127,7 @@ static inline void volk_32f_power_aligned16_sse(float* cVector, const float* aVe
     \param power The power value to be applied to each data point
     \param num_points The number of values in aVector to be taken to the specified power level and stored into cVector
   */
-static inline void volk_32f_power_aligned16_generic(float* cVector, const float* aVector, const float power, unsigned int num_points){
+static inline void volk_32f_s32f_power_32f_a16_generic(float* cVector, const float* aVector, const float power, unsigned int num_points){
   float* cPtr = cVector;
   const float* aPtr = aVector;
   unsigned int number = 0;
@@ -141,4 +141,4 @@ static inline void volk_32f_power_aligned16_generic(float* cVector, const float*
 
 
 
-#endif /* INCLUDED_VOLK_32f_POWER_ALIGNED16_H */
+#endif /* INCLUDED_volk_32f_s32f_power_32f_a16_H */
diff --git a/volk/include/volk/volk_32f_stddev_aligned16.h b/volk/include/volk/volk_32f_s32f_stddev_32f_a16.h
index 1c6a08437e..32f4fa0672 100644
--- a/volk/include/volk/volk_32f_stddev_aligned16.h
+++ b/volk/include/volk/volk_32f_s32f_stddev_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_STDDEV_ALIGNED16_H
-#define INCLUDED_VOLK_32f_STDDEV_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_s32f_stddev_32f_a16_H
+#define INCLUDED_volk_32f_s32f_stddev_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -14,7 +14,7 @@
   \param mean The mean of the input buffer
   \param num_points The number of values in input buffer to used in the stddev calculation
 */
-static inline void volk_32f_stddev_aligned16_sse4_1(float* stddev, const float* inputBuffer, const float mean, unsigned int num_points){
+static inline void volk_32f_s32f_stddev_32f_a16_sse4_1(float* stddev, const float* inputBuffer, const float mean, unsigned int num_points){
   float returnValue = 0;
   if(num_points > 0){
     unsigned int number = 0;
@@ -74,7 +74,7 @@ static inline void volk_32f_stddev_aligned16_sse4_1(float* stddev, const float*
   \param mean The mean of the input buffer
   \param num_points The number of values in input buffer to used in the stddev calculation
 */
-static inline void volk_32f_stddev_aligned16_sse(float* stddev, const float* inputBuffer, const float mean, unsigned int num_points){
+static inline void volk_32f_s32f_stddev_32f_a16_sse(float* stddev, const float* inputBuffer, const float mean, unsigned int num_points){
   float returnValue = 0;
   if(num_points > 0){
     unsigned int number = 0;
@@ -119,7 +119,7 @@ static inline void volk_32f_stddev_aligned16_sse(float* stddev, const float* inp
   \param mean The mean of the input buffer
   \param num_points The number of values in input buffer to used in the stddev calculation
 */
-static inline void volk_32f_stddev_aligned16_generic(float* stddev, const float* inputBuffer, const float mean, unsigned int num_points){
+static inline void volk_32f_s32f_stddev_32f_a16_generic(float* stddev, const float* inputBuffer, const float mean, unsigned int num_points){
   float returnValue = 0;
   if(num_points > 0){
     const float* aPtr = inputBuffer;
@@ -141,4 +141,4 @@ static inline void volk_32f_stddev_aligned16_generic(float* stddev, const float*
 
 
 
-#endif /* INCLUDED_VOLK_32f_STDDEV_ALIGNED16_H */
+#endif /* INCLUDED_volk_32f_s32f_stddev_32f_a16_H */
diff --git a/volk/include/volk/volk_32f_sqrt_aligned16.h b/volk/include/volk/volk_32f_sqrt_32f_a16.h
index f6996ad5fc..513c2cffec 100644
--- a/volk/include/volk/volk_32f_sqrt_aligned16.h
+++ b/volk/include/volk/volk_32f_sqrt_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_SQRT_ALIGNED16_H
-#define INCLUDED_VOLK_32f_SQRT_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_sqrt_32f_a16_H
+#define INCLUDED_volk_32f_sqrt_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param aVector One of the vectors to be sqrted
   \param num_points The number of values in aVector and bVector to be sqrted together and stored into cVector
 */
-static inline void volk_32f_sqrt_aligned16_sse(float* cVector, const float* aVector, unsigned int num_points){
+static inline void volk_32f_sqrt_32f_a16_sse(float* cVector, const float* aVector, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int quarterPoints = num_points / 4;
 
@@ -47,7 +47,7 @@ static inline void volk_32f_sqrt_aligned16_sse(float* cVector, const float* aVec
   \param aVector One of the vectors to be sqrted
   \param num_points The number of values in aVector and bVector to be sqrted together and stored into cVector
 */
-static inline void volk_32f_sqrt_aligned16_generic(float* cVector, const float* aVector, unsigned int num_points){
+static inline void volk_32f_sqrt_32f_a16_generic(float* cVector, const float* aVector, unsigned int num_points){
     float* cPtr = cVector;
     const float* aPtr = aVector;
     unsigned int number = 0;
@@ -59,19 +59,19 @@ static inline void volk_32f_sqrt_aligned16_generic(float* cVector, const float*
 #endif /* LV_HAVE_GENERIC */
 
 #if LV_HAVE_ORC
-extern void volk_32f_sqrt_aligned16_orc_impl(float *, const float*, unsigned int);
+extern void volk_32f_sqrt_32f_a16_orc_impl(float *, const float*, unsigned int);
 /*!
   \brief Sqrts the two input vectors and store their results in the third vector
   \param cVector The vector where the results will be stored
   \param aVector One of the vectors to be sqrted
   \param num_points The number of values in aVector and bVector to be sqrted together and stored into cVector
 */
-static inline void volk_32f_sqrt_aligned16_orc(float* cVector, const float* aVector, unsigned int num_points){
-    volk_32f_sqrt_aligned16_orc_impl(cVector, aVector, num_points);
+static inline void volk_32f_sqrt_32f_a16_orc(float* cVector, const float* aVector, unsigned int num_points){
+    volk_32f_sqrt_32f_a16_orc_impl(cVector, aVector, num_points);
 }
 
 #endif /* LV_HAVE_ORC */
 
 
 
-#endif /* INCLUDED_VOLK_32f_SQRT_ALIGNED16_H */
+#endif /* INCLUDED_volk_32f_sqrt_32f_a16_H */
diff --git a/volk/include/volk/volk_32f_stddev_and_mean_aligned16.h b/volk/include/volk/volk_32f_stddev_and_mean_32f_32f_a16.h
index 1cd502257c..2ba8098454 100644
--- a/volk/include/volk/volk_32f_stddev_and_mean_aligned16.h
+++ b/volk/include/volk/volk_32f_stddev_and_mean_32f_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32f_STDDEV_AND_MEAN_ALIGNED16_H
-#define INCLUDED_VOLK_32f_STDDEV_AND_MEAN_ALIGNED16_H
+#ifndef INCLUDED_volk_32f_stddev_and_mean_32f_32f_a16_H
+#define INCLUDED_volk_32f_stddev_and_mean_32f_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -14,7 +14,7 @@
   \param inputBuffer The buffer of points to calculate the std deviation for
   \param num_points The number of values in input buffer to used in the stddev and mean calculations
 */
-static inline void volk_32f_stddev_and_mean_aligned16_sse4_1(float* stddev, float* mean, const float* inputBuffer, unsigned int num_points){
+static inline void volk_32f_stddev_and_mean_32f_32f_a16_sse4_1(float* stddev, float* mean, const float* inputBuffer, unsigned int num_points){
   float returnValue = 0;
   float newMean = 0;
   if(num_points > 0){
@@ -87,7 +87,7 @@ static inline void volk_32f_stddev_and_mean_aligned16_sse4_1(float* stddev, floa
   \param inputBuffer The buffer of points to calculate the std deviation for
   \param num_points The number of values in input buffer to used in the stddev and mean calculations
 */
-static inline void volk_32f_stddev_and_mean_aligned16_sse(float* stddev, float* mean, const float* inputBuffer, unsigned int num_points){
+static inline void volk_32f_stddev_and_mean_32f_32f_a16_sse(float* stddev, float* mean, const float* inputBuffer, unsigned int num_points){
   float returnValue = 0;
   float newMean = 0;
   if(num_points > 0){
@@ -142,7 +142,7 @@ static inline void volk_32f_stddev_and_mean_aligned16_sse(float* stddev, float*
   \param inputBuffer The buffer of points to calculate the std deviation for
   \param num_points The number of values in input buffer to used in the stddev and mean calculations
 */
-static inline void volk_32f_stddev_and_mean_aligned16_generic(float* stddev, float* mean, const float* inputBuffer, unsigned int num_points){
+static inline void volk_32f_stddev_and_mean_32f_32f_a16_generic(float* stddev, float* mean, const float* inputBuffer, unsigned int num_points){
   float returnValue = 0;
   float newMean = 0;
   if(num_points > 0){
@@ -166,4 +166,4 @@ static inline void volk_32f_stddev_and_mean_aligned16_generic(float* stddev, flo
 
 
 
-#endif /* INCLUDED_VOLK_32f_STDDEV_AND_MEAN_ALIGNED16_H */
+#endif /* INCLUDED_volk_32f_stddev_and_mean_32f_32f_a16_H */
diff --git a/volk/include/volk/volk_32fc_32f_multiply_aligned16.h b/volk/include/volk/volk_32fc_32f_multiply_32fc_a16.h
index 304ed8e2d0..514998800f 100644
--- a/volk/include/volk/volk_32fc_32f_multiply_aligned16.h
+++ b/volk/include/volk/volk_32fc_32f_multiply_32fc_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32fc_32f_MULTIPLY_ALIGNED16_H
-#define INCLUDED_VOLK_32fc_32f_MULTIPLY_ALIGNED16_H
+#ifndef INCLUDED_volk_32fc_32f_multiply_32fc_a16_H
+#define INCLUDED_volk_32fc_32f_multiply_32fc_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
     \param bVector The vectors containing the float values to be multiplied against each complex value in aVector
     \param num_points The number of values in aVector and bVector to be multiplied together and stored into cVector
   */
-static inline void volk_32fc_32f_multiply_aligned16_sse(lv_32fc_t* cVector, const lv_32fc_t* aVector, const float* bVector, unsigned int num_points){
+static inline void volk_32fc_32f_multiply_32fc_a16_sse(lv_32fc_t* cVector, const lv_32fc_t* aVector, const float* bVector, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int quarterPoints = num_points / 4;
 
@@ -64,7 +64,7 @@ static inline void volk_32fc_32f_multiply_aligned16_sse(lv_32fc_t* cVector, cons
     \param bVector The vectors containing the lv_32fc_t values to be multiplied against each complex value in aVector
     \param num_points The number of values in aVector and bVector to be multiplied together and stored into cVector
   */
-static inline void volk_32fc_32f_multiply_aligned16_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector, const float* bVector, unsigned int num_points){
+static inline void volk_32fc_32f_multiply_32fc_a16_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector, const float* bVector, unsigned int num_points){
   lv_32fc_t* cPtr = cVector;
   const lv_32fc_t* aPtr = aVector;
   const float* bPtr=  bVector;
@@ -84,12 +84,12 @@ static inline void volk_32fc_32f_multiply_aligned16_generic(lv_32fc_t* cVector,
     \param bVector The vectors containing the lv_32fc_t values to be multiplied against each complex value in aVector
     \param num_points The number of values in aVector and bVector to be multiplied together and stored into cVector
   */
-extern void volk_32fc_32f_multiply_aligned16_orc_impl(lv_32fc_t* cVector, const lv_32fc_t* aVector, const float* bVector, unsigned int num_points);
-static inline void volk_32fc_32f_multiply_aligned16_orc(lv_32fc_t* cVector, const lv_32fc_t* aVector, const float* bVector, unsigned int num_points){
-    volk_32fc_32f_multiply_aligned16_orc_impl(cVector, aVector, bVector, num_points);
+extern void volk_32fc_32f_multiply_32fc_a16_orc_impl(lv_32fc_t* cVector, const lv_32fc_t* aVector, const float* bVector, unsigned int num_points);
+static inline void volk_32fc_32f_multiply_32fc_a16_orc(lv_32fc_t* cVector, const lv_32fc_t* aVector, const float* bVector, unsigned int num_points){
+    volk_32fc_32f_multiply_32fc_a16_orc_impl(cVector, aVector, bVector, num_points);
 }
 #endif /* LV_HAVE_GENERIC */
 
 
 
-#endif /* INCLUDED_VOLK_32fc_32f_MULTIPLY_ALIGNED16_H */
+#endif /* INCLUDED_volk_32fc_32f_multiply_32fc_a16_H */
diff --git a/volk/include/volk/volk_32fc_32f_power_32fc_aligned16.h b/volk/include/volk/volk_32fc_32f_power_32fc_a16.h
index 2d71ee4f88..6f9e9e3ee1 100644
--- a/volk/include/volk/volk_32fc_32f_power_32fc_aligned16.h
+++ b/volk/include/volk/volk_32fc_32f_power_32fc_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32fc_32f_POWER_32fc_ALIGNED16_H
-#define INCLUDED_VOLK_32fc_32f_POWER_32fc_ALIGNED16_H
+#ifndef INCLUDED_volk_32fc_32f_power_32fc_a16_H
+#define INCLUDED_volk_32fc_32f_power_32fc_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -18,7 +18,7 @@
   \param power The power value to be applied to each data point
   \param num_points The number of values in aVector to be taken to the specified power level and stored into cVector
 */
-static inline void volk_32fc_32f_power_32fc_aligned16_sse(lv_32fc_t* cVector, const lv_32fc_t* aVector, const float power, unsigned int num_points){
+static inline void volk_32fc_32f_power_32fc_a16_sse(lv_32fc_t* cVector, const lv_32fc_t* aVector, const float power, unsigned int num_points){
   unsigned int number = 0;
   const unsigned int quarterPoints = num_points / 4;
   
@@ -89,7 +89,7 @@ static inline void volk_32fc_32f_power_32fc_aligned16_sse(lv_32fc_t* cVector, co
     \param power The power value to be applied to each data point
     \param num_points The number of values in aVector to be taken to the specified power level and stored into cVector
   */
-static inline void volk_32fc_32f_power_32fc_aligned16_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector, const float power, unsigned int num_points){
+static inline void volk_32fc_32f_power_32fc_a16_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector, const float power, unsigned int num_points){
   lv_32fc_t* cPtr = cVector;
   const lv_32fc_t* aPtr = aVector;
   unsigned int number = 0;
@@ -106,4 +106,4 @@ static inline void volk_32fc_32f_power_32fc_aligned16_generic(lv_32fc_t* cVector
 
 
 
-#endif /* INCLUDED_VOLK_32fc_32f_POWER_32fc_ALIGNED16_H */
+#endif /* INCLUDED_volk_32fc_32f_power_32fc_a16_H */
diff --git a/volk/include/volk/volk_32fc_conjugate_dot_prod_aligned16.h b/volk/include/volk/volk_32fc_32fc_conjugate_dot_prod_32fc_a16.h
index 60103c1b5f..cd9cc81609 100644
--- a/volk/include/volk/volk_32fc_conjugate_dot_prod_aligned16.h
+++ b/volk/include/volk/volk_32fc_32fc_conjugate_dot_prod_32fc_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32fc_CONJUGATE_DOT_PROD_ALIGNED16_H
-#define INCLUDED_VOLK_32fc_CONJUGATE_DOT_PROD_ALIGNED16_H
+#ifndef INCLUDED_volk_32fc_32fc_conjugate_dot_prod_32fc_a16_H
+#define INCLUDED_volk_32fc_32fc_conjugate_dot_prod_32fc_a16_H
 
 #include<volk/volk_complex.h>
 #include<stdio.h>
@@ -8,7 +8,7 @@
 #if LV_HAVE_GENERIC
 
 
-static inline void volk_32fc_conjugate_dot_prod_aligned16_generic(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {
+static inline void volk_32fc_32fc_conjugate_dot_prod_32fc_a16_generic(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {
   
   float * res = (float*) result;
   float * in = (float*) input;
@@ -62,7 +62,7 @@ static inline void volk_32fc_conjugate_dot_prod_aligned16_generic(lv_32fc_t* res
 #if LV_HAVE_SSE && LV_HAVE_64
 
 
-static inline void volk_32fc_conjugate_dot_prod_aligned16_sse(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {
+static inline void volk_32fc_32fc_conjugate_dot_prod_32fc_a16_sse(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {
   
   static const uint32_t conjugator[4] __attribute__((aligned(16)))= {0x00000000, 0x80000000, 0x00000000, 0x80000000};
   
@@ -203,7 +203,7 @@ static inline void volk_32fc_conjugate_dot_prod_aligned16_sse(lv_32fc_t* result,
 #endif
 
 #if LV_HAVE_SSE && LV_HAVE_32
-static inline void volk_32fc_conjugate_dot_prod_aligned16_sse_32(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {
+static inline void volk_32fc_32fc_conjugate_dot_prod_32fc_a16_sse_32(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {
   
   static const uint32_t conjugator[4] __attribute__((aligned(16)))= {0x00000000, 0x80000000, 0x00000000, 0x80000000};
 
@@ -341,4 +341,4 @@ static inline void volk_32fc_conjugate_dot_prod_aligned16_sse_32(lv_32fc_t* resu
 
 
 
-#endif /*INCLUDED_VOLK_32fc_CONJUGATE_DOT_PROD_ALIGNED16_H*/
+#endif /*INCLUDED_volk_32fc_32fc_conjugate_dot_prod_32fc_a16_H*/
diff --git a/volk/include/volk/volk_32fc_dot_prod_aligned16.h b/volk/include/volk/volk_32fc_32fc_dot_prod_32fc_a16.h
index 1a834dc252..2ccfcf2f27 100644
--- a/volk/include/volk/volk_32fc_dot_prod_aligned16.h
+++ b/volk/include/volk/volk_32fc_32fc_dot_prod_32fc_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32fc_DOT_PROD_ALIGNED16_H
-#define INCLUDED_VOLK_32fc_DOT_PROD_ALIGNED16_H
+#ifndef INCLUDED_volk_32fc_32fc_dot_prod_32fc_a16_H
+#define INCLUDED_volk_32fc_32fc_dot_prod_32fc_a16_H
 
 #include <volk/volk_complex.h>
 #include <stdio.h>
@@ -9,7 +9,7 @@
 #if LV_HAVE_GENERIC 
 
 
-static inline void volk_32fc_dot_prod_aligned16_generic(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {
+static inline void volk_32fc_32fc_dot_prod_32fc_a16_generic(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {
   
   float * res = (float*) result;
   float * in = (float*) input;
@@ -59,7 +59,7 @@ static inline void volk_32fc_dot_prod_aligned16_generic(lv_32fc_t* result, const
 #if LV_HAVE_SSE && LV_HAVE_64
 
 
-static inline void volk_32fc_dot_prod_aligned16_sse_64(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {
+static inline void volk_32fc_32fc_dot_prod_32fc_a16_sse_64(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {
   
 
   asm 
@@ -194,7 +194,7 @@ static inline void volk_32fc_dot_prod_aligned16_sse_64(lv_32fc_t* result, const
 
 #if LV_HAVE_SSE && LV_HAVE_32
 
-static inline void volk_32fc_dot_prod_aligned16_sse_32(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {
+static inline void volk_32fc_32fc_dot_prod_32fc_a16_sse_32(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {
   
   asm volatile 
     (
@@ -320,7 +320,7 @@ static inline void volk_32fc_dot_prod_aligned16_sse_32(lv_32fc_t* result, const
 
 #include <pmmintrin.h>
 
-static inline void volk_32fc_dot_prod_aligned16_sse3(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {
+static inline void volk_32fc_32fc_dot_prod_32fc_a16_sse3(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {
   
 
   lv_32fc_t dotProduct;
@@ -377,8 +377,8 @@ static inline void volk_32fc_dot_prod_aligned16_sse3(lv_32fc_t* result, const lv
 
 #include <smmintrin.h>
 
-static inline void volk_32fc_dot_prod_aligned16_sse4_1(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {
-  volk_32fc_dot_prod_aligned16_sse3(result, input, taps, num_bytes);
+static inline void volk_32fc_32fc_dot_prod_32fc_a16_sse4_1(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_bytes) {
+  volk_32fc_32fc_dot_prod_32fc_a16_sse3(result, input, taps, num_bytes);
   // SSE3 version runs twice as fast as the SSE4.1 version, so turning off SSE4 version for now
    /* 
     __m128 xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, real0, real1, im0, im1;
@@ -465,4 +465,4 @@ static inline void volk_32fc_dot_prod_aligned16_sse4_1(lv_32fc_t* result, const
 
 #endif /*LV_HAVE_SSE4_1*/
 
-#endif /*INCLUDED_VOLK_32fc_DOT_PROD_ALIGNED16_H*/
+#endif /*INCLUDED_volk_32fc_32fc_dot_prod_32fc_a16_H*/
diff --git a/volk/include/volk/volk_32fc_multiply_aligned16.h b/volk/include/volk/volk_32fc_32fc_multiply_32fc_a16.h
index c8f2418c32..59259882ca 100644
--- a/volk/include/volk/volk_32fc_multiply_aligned16.h
+++ b/volk/include/volk/volk_32fc_32fc_multiply_32fc_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32fc_MULTIPLY_ALIGNED16_H
-#define INCLUDED_VOLK_32fc_MULTIPLY_ALIGNED16_H
+#ifndef INCLUDED_volk_32fc_32fc_multiply_32fc_a16_H
+#define INCLUDED_volk_32fc_32fc_multiply_32fc_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -15,7 +15,7 @@
     \param bVector One of the vectors to be multiplied
     \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector
   */
-static inline void volk_32fc_multiply_aligned16_sse3(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, unsigned int num_points){
+static inline void volk_32fc_32fc_multiply_32fc_a16_sse3(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, unsigned int num_points){
   unsigned int number = 0;
     const unsigned int halfPoints = num_points / 2;
 
@@ -61,7 +61,7 @@ static inline void volk_32fc_multiply_aligned16_sse3(lv_32fc_t* cVector, const l
     \param bVector One of the vectors to be multiplied
     \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector
   */
-static inline void volk_32fc_multiply_aligned16_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, unsigned int num_points){
+static inline void volk_32fc_32fc_multiply_32fc_a16_generic(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, unsigned int num_points){
     lv_32fc_t* cPtr = cVector;
     const lv_32fc_t* aPtr = aVector;
     const lv_32fc_t* bPtr=  bVector;
@@ -81,10 +81,10 @@ static inline void volk_32fc_multiply_aligned16_generic(lv_32fc_t* cVector, cons
     \param bVector One of the vectors to be multiplied
     \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector
   */
-extern void volk_32fc_multiply_aligned16_orc_impl(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, float mask, unsigned int num_points);
-static inline void volk_32fc_multiply_aligned16_orc(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, unsigned int num_points){
+extern void volk_32fc_32fc_multiply_32fc_a16_orc_impl(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, float mask, unsigned int num_points);
+static inline void volk_32fc_32fc_multiply_32fc_a16_orc(lv_32fc_t* cVector, const lv_32fc_t* aVector, const lv_32fc_t* bVector, unsigned int num_points){
     static const float mask = -0.0;
-    volk_32fc_multiply_aligned16_orc_impl(cVector, aVector, bVector, mask, num_points);
+    volk_32fc_32fc_multiply_32fc_a16_orc_impl(cVector, aVector, bVector, mask, num_points);
 }
 #endif /* LV_HAVE_ORC */
 
@@ -92,4 +92,4 @@ static inline void volk_32fc_multiply_aligned16_orc(lv_32fc_t* cVector, const lv
 
 
 
-#endif /* INCLUDED_VOLK_32fc_MULTIPLY_ALIGNED16_H */
+#endif /* INCLUDED_volk_32fc_32fc_multiply_32fc_a16_H */
diff --git a/volk/include/volk/volk_32fc_square_dist_scalar_mult_aligned16.h b/volk/include/volk/volk_32fc_32fc_s32f_square_dist_scalar_mult_32f_a16.h
index 0fcc86f1ed..14f5116970 100644
--- a/volk/include/volk/volk_32fc_square_dist_scalar_mult_aligned16.h
+++ b/volk/include/volk/volk_32fc_32fc_s32f_square_dist_scalar_mult_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32FC_SQUARE_DIST_SCALAR_MULT_ALIGNED16_H
-#define INCLUDED_VOLK_32FC_SQUARE_DIST_SCALAR_MULT_ALIGNED16_H
+#ifndef INCLUDED_volk_32fc_32fc_s32f_square_dist_scalar_mult_32f_a16_H
+#define INCLUDED_volk_32fc_32fc_s32f_square_dist_scalar_mult_32f_a16_H
 
 #include<inttypes.h>
 #include<stdio.h>
@@ -10,7 +10,7 @@
 #include<xmmintrin.h>
 #include<pmmintrin.h>
 
-static inline void volk_32fc_square_dist_scalar_mult_aligned16_sse3(float* target, lv_32fc_t* src0, lv_32fc_t* points, float scalar, unsigned int num_bytes) {
+static inline void volk_32fc_32fc_s32f_square_dist_scalar_mult_32f_a16_sse3(float* target, lv_32fc_t* src0, lv_32fc_t* points, float scalar, unsigned int num_bytes) {
   
 
   __m128 xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8;
@@ -106,7 +106,7 @@ static inline void volk_32fc_square_dist_scalar_mult_aligned16_sse3(float* targe
 #endif /*LV_HAVE_SSE3*/
 
 #if LV_HAVE_GENERIC
-static inline void volk_32fc_square_dist_scalar_mult_aligned16_generic(float* target, lv_32fc_t* src0, lv_32fc_t* points, float scalar, unsigned int num_bytes) {
+static inline void volk_32fc_32fc_s32f_square_dist_scalar_mult_32f_a16_generic(float* target, lv_32fc_t* src0, lv_32fc_t* points, float scalar, unsigned int num_bytes) {
   lv_32fc_t diff;
   float sq_dist;
   int i = 0; 
@@ -123,4 +123,4 @@ static inline void volk_32fc_square_dist_scalar_mult_aligned16_generic(float* ta
 #endif /*LV_HAVE_GENERIC*/
 
 
-#endif /*INCLUDED_VOLK_32FC_SQUARE_DIST_SCALAR_MULT_ALIGNED16_H*/
+#endif /*INCLUDED_volk_32fc_32fc_s32f_square_dist_scalar_mult_32f_a16_H*/
diff --git a/volk/include/volk/volk_32fc_square_dist_aligned16.h b/volk/include/volk/volk_32fc_32fc_square_dist_32f_a16.h
index 6458ea4dd4..b6c72adbf2 100644
--- a/volk/include/volk/volk_32fc_square_dist_aligned16.h
+++ b/volk/include/volk/volk_32fc_32fc_square_dist_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32FC_SQUARE_DIST_ALIGNED16_H
-#define INCLUDED_VOLK_32FC_SQUARE_DIST_ALIGNED16_H
+#ifndef INCLUDED_volk_32fc_32fc_square_dist_32f_a16_H
+#define INCLUDED_volk_32fc_32fc_square_dist_32f_a16_H
 
 #include<inttypes.h>
 #include<stdio.h>
@@ -9,7 +9,7 @@
 #include<xmmintrin.h>
 #include<pmmintrin.h>
 
-static inline void volk_32fc_square_dist_aligned16_sse3(float* target, lv_32fc_t* src0, lv_32fc_t* points, unsigned int num_bytes) {
+static inline void volk_32fc_32fc_square_dist_32f_a16_sse3(float* target, lv_32fc_t* src0, lv_32fc_t* points, unsigned int num_bytes) {
   
 
   __m128 xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7;
@@ -92,7 +92,7 @@ static inline void volk_32fc_square_dist_aligned16_sse3(float* target, lv_32fc_t
 #endif /*LV_HAVE_SSE3*/
 
 #if LV_HAVE_GENERIC
-static inline void volk_32fc_square_dist_aligned16_generic(float* target, lv_32fc_t* src0, lv_32fc_t* points, unsigned int num_bytes) {
+static inline void volk_32fc_32fc_square_dist_32f_a16_generic(float* target, lv_32fc_t* src0, lv_32fc_t* points, unsigned int num_bytes) {
   lv_32fc_t diff;
   float sq_dist;
   int i = 0; 
@@ -109,4 +109,4 @@ static inline void volk_32fc_square_dist_aligned16_generic(float* target, lv_32f
 #endif /*LV_HAVE_GENERIC*/
 
 
-#endif /*INCLUDED_VOLK_32FC_SQUARE_DIST_ALIGNED16_H*/
+#endif /*INCLUDED_volk_32fc_32fc_square_dist_32f_a16_H*/
diff --git a/volk/include/volk/volk_32fc_deinterleave_32f_aligned16.h b/volk/include/volk/volk_32fc_deinterleave_32f_32f_a16.h
index 02085cd1e8..3ee579c2ef 100644
--- a/volk/include/volk/volk_32fc_deinterleave_32f_aligned16.h
+++ b/volk/include/volk/volk_32fc_deinterleave_32f_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32fc_DEINTERLEAVE_32F_ALIGNED16_H
-#define INCLUDED_VOLK_32fc_DEINTERLEAVE_32F_ALIGNED16_H
+#ifndef INCLUDED_volk_32fc_deinterleave_32f_32f_a16_H
+#define INCLUDED_volk_32fc_deinterleave_32f_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param qBuffer The Q buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_32fc_deinterleave_32f_aligned16_sse(float* iBuffer, float* qBuffer, const lv_32fc_t* complexVector, unsigned int num_points){
+static inline void volk_32fc_deinterleave_32f_32f_a16_sse(float* iBuffer, float* qBuffer, const lv_32fc_t* complexVector, unsigned int num_points){
   const float* complexVectorPtr = (float*)complexVector;
   float* iBufferPtr = iBuffer;
   float* qBufferPtr = qBuffer;
@@ -57,7 +57,7 @@ static inline void volk_32fc_deinterleave_32f_aligned16_sse(float* iBuffer, floa
   \param qBuffer The Q buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_32fc_deinterleave_32f_aligned16_generic(float* iBuffer, float* qBuffer, const lv_32fc_t* complexVector, unsigned int num_points){
+static inline void volk_32fc_deinterleave_32f_32f_a16_generic(float* iBuffer, float* qBuffer, const lv_32fc_t* complexVector, unsigned int num_points){
   const float* complexVectorPtr = (float*)complexVector;
   float* iBufferPtr = iBuffer;
   float* qBufferPtr = qBuffer;
@@ -72,4 +72,4 @@ static inline void volk_32fc_deinterleave_32f_aligned16_generic(float* iBuffer,
 
 
 
-#endif /* INCLUDED_VOLK_32fc_DEINTERLEAVE_32F_ALIGNED16_H */
+#endif /* INCLUDED_volk_32fc_deinterleave_32f_32f_a16_H */
diff --git a/volk/include/volk/volk_32fc_deinterleave_64f_aligned16.h b/volk/include/volk/volk_32fc_deinterleave_64f_64f_a16.h
index 3d9ebccdd3..404defc367 100644
--- a/volk/include/volk/volk_32fc_deinterleave_64f_aligned16.h
+++ b/volk/include/volk/volk_32fc_deinterleave_64f_64f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32fc_DEINTERLEAVE_64F_ALIGNED16_H
-#define INCLUDED_VOLK_32fc_DEINTERLEAVE_64F_ALIGNED16_H
+#ifndef INCLUDED_volk_32fc_deinterleave_64f_64f_a16_H
+#define INCLUDED_volk_32fc_deinterleave_64f_64f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param qBuffer The Q buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_32fc_deinterleave_64f_aligned16_sse2(double* iBuffer, double* qBuffer, const lv_32fc_t* complexVector, unsigned int num_points){
+static inline void volk_32fc_deinterleave_64f_64f_a16_sse2(double* iBuffer, double* qBuffer, const lv_32fc_t* complexVector, unsigned int num_points){
   unsigned int number = 0;
 
     const float* complexVectorPtr = (float*)complexVector;
@@ -59,7 +59,7 @@ static inline void volk_32fc_deinterleave_64f_aligned16_sse2(double* iBuffer, do
   \param qBuffer The Q buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_32fc_deinterleave_64f_aligned16_generic(double* iBuffer, double* qBuffer, const lv_32fc_t* complexVector, unsigned int num_points){
+static inline void volk_32fc_deinterleave_64f_64f_a16_generic(double* iBuffer, double* qBuffer, const lv_32fc_t* complexVector, unsigned int num_points){
   unsigned int number = 0;
   const float* complexVectorPtr = (float*)complexVector;
   double* iBufferPtr = iBuffer;
@@ -75,4 +75,4 @@ static inline void volk_32fc_deinterleave_64f_aligned16_generic(double* iBuffer,
 
 
 
-#endif /* INCLUDED_VOLK_32fc_DEINTERLEAVE_64F_ALIGNED16_H */
+#endif /* INCLUDED_volk_32fc_deinterleave_64f_64f_a16_H */
diff --git a/volk/include/volk/volk_32fc_deinterleave_real_16s_aligned16.h b/volk/include/volk/volk_32fc_deinterleave_real_16s_a16.h
index 3026b24220..53235e5f79 100644
--- a/volk/include/volk/volk_32fc_deinterleave_real_16s_aligned16.h
+++ b/volk/include/volk/volk_32fc_deinterleave_real_16s_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32fc_DEINTERLEAVE_REAL_16s_ALIGNED16_H
-#define INCLUDED_VOLK_32fc_DEINTERLEAVE_REAL_16s_ALIGNED16_H
+#ifndef INCLUDED_volk_32fc_deinterleave_real_16s_a16_H
+#define INCLUDED_volk_32fc_deinterleave_real_16s_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param iBuffer The I buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_32fc_deinterleave_real_16s_aligned16_sse(int16_t* iBuffer, const lv_32fc_t* complexVector, const float scalar, unsigned int num_points){
+static inline void volk_32fc_deinterleave_real_16s_a16_sse(int16_t* iBuffer, const lv_32fc_t* complexVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
   const unsigned int quarterPoints = num_points / 4;
 
@@ -62,7 +62,7 @@ static inline void volk_32fc_deinterleave_real_16s_aligned16_sse(int16_t* iBuffe
   \param iBuffer The I buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_32fc_deinterleave_real_16s_aligned16_generic(int16_t* iBuffer, const lv_32fc_t* complexVector, const float scalar, unsigned int num_points){
+static inline void volk_32fc_deinterleave_real_16s_a16_generic(int16_t* iBuffer, const lv_32fc_t* complexVector, const float scalar, unsigned int num_points){
   const float* complexVectorPtr = (float*)complexVector;
   int16_t* iBufferPtr = iBuffer;
   unsigned int number = 0;
@@ -77,4 +77,4 @@ static inline void volk_32fc_deinterleave_real_16s_aligned16_generic(int16_t* iB
 
 
 
-#endif /* INCLUDED_VOLK_32fc_DEINTERLEAVE_REAL_16s_ALIGNED16_H */
+#endif /* INCLUDED_volk_32fc_deinterleave_real_16s_a16_H */
diff --git a/volk/include/volk/volk_32fc_deinterleave_real_32f_aligned16.h b/volk/include/volk/volk_32fc_deinterleave_real_32f_a16.h
index 2af973bcc0..9838ec88ba 100644
--- a/volk/include/volk/volk_32fc_deinterleave_real_32f_aligned16.h
+++ b/volk/include/volk/volk_32fc_deinterleave_real_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32fc_DEINTERLEAVE_REAL_32F_ALIGNED16_H
-#define INCLUDED_VOLK_32fc_DEINTERLEAVE_REAL_32F_ALIGNED16_H
+#ifndef INCLUDED_volk_32fc_deinterleave_real_32f_a16_H
+#define INCLUDED_volk_32fc_deinterleave_real_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -12,7 +12,7 @@
   \param iBuffer The I buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_32fc_deinterleave_real_32f_aligned16_sse(float* iBuffer, const lv_32fc_t* complexVector, unsigned int num_points){
+static inline void volk_32fc_deinterleave_real_32f_a16_sse(float* iBuffer, const lv_32fc_t* complexVector, unsigned int num_points){
   unsigned int number = 0;
   const unsigned int quarterPoints = num_points / 4;
 
@@ -51,7 +51,7 @@ static inline void volk_32fc_deinterleave_real_32f_aligned16_sse(float* iBuffer,
   \param iBuffer The I buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_32fc_deinterleave_real_32f_aligned16_generic(float* iBuffer, const lv_32fc_t* complexVector, unsigned int num_points){
+static inline void volk_32fc_deinterleave_real_32f_a16_generic(float* iBuffer, const lv_32fc_t* complexVector, unsigned int num_points){
   unsigned int number = 0;
   const float* complexVectorPtr = (float*)complexVector;
   float* iBufferPtr = iBuffer;
@@ -65,4 +65,4 @@ static inline void volk_32fc_deinterleave_real_32f_aligned16_generic(float* iBuf
 
 
 
-#endif /* INCLUDED_VOLK_32fc_DEINTERLEAVE_REAL_32F_ALIGNED16_H */
+#endif /* INCLUDED_volk_32fc_deinterleave_real_32f_a16_H */
diff --git a/volk/include/volk/volk_32fc_deinterleave_real_64f_aligned16.h b/volk/include/volk/volk_32fc_deinterleave_real_64f_a16.h
index f408589c41..af392d0748 100644
--- a/volk/include/volk/volk_32fc_deinterleave_real_64f_aligned16.h
+++ b/volk/include/volk/volk_32fc_deinterleave_real_64f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32fc_DEINTERLEAVE_REAL_64F_ALIGNED16_H
-#define INCLUDED_VOLK_32fc_DEINTERLEAVE_REAL_64F_ALIGNED16_H
+#ifndef INCLUDED_volk_32fc_deinterleave_real_64f_a16_H
+#define INCLUDED_volk_32fc_deinterleave_real_64f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -12,7 +12,7 @@
   \param iBuffer The I buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_32fc_deinterleave_real_64f_aligned16_sse2(double* iBuffer, const lv_32fc_t* complexVector, unsigned int num_points){
+static inline void volk_32fc_deinterleave_real_64f_a16_sse2(double* iBuffer, const lv_32fc_t* complexVector, unsigned int num_points){
   unsigned int number = 0;
 
   const float* complexVectorPtr = (float*)complexVector;
@@ -49,7 +49,7 @@ static inline void volk_32fc_deinterleave_real_64f_aligned16_sse2(double* iBuffe
   \param iBuffer The I buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_32fc_deinterleave_real_64f_aligned16_generic(double* iBuffer, const lv_32fc_t* complexVector, unsigned int num_points){
+static inline void volk_32fc_deinterleave_real_64f_a16_generic(double* iBuffer, const lv_32fc_t* complexVector, unsigned int num_points){
   unsigned int number = 0;
   const float* complexVectorPtr = (float*)complexVector;
   double* iBufferPtr = iBuffer;
@@ -63,4 +63,4 @@ static inline void volk_32fc_deinterleave_real_64f_aligned16_generic(double* iBu
 
 
 
-#endif /* INCLUDED_VOLK_32fc_DEINTERLEAVE_REAL_64F_ALIGNED16_H */
+#endif /* INCLUDED_volk_32fc_deinterleave_real_64f_a16_H */
diff --git a/volk/include/volk/volk_32fc_index_max_aligned16.h b/volk/include/volk/volk_32fc_index_max_16u_a16.h
index d77a95f90d..532ae4e7c8 100644
--- a/volk/include/volk/volk_32fc_index_max_aligned16.h
+++ b/volk/include/volk/volk_32fc_index_max_16u_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32FC_INDEX_MAX_ALIGNED16_H
-#define INCLUDED_VOLK_32FC_INDEX_MAX_ALIGNED16_H
+#ifndef INCLUDED_volk_32fc_index_max_16u_a16_H
+#define INCLUDED_volk_32fc_index_max_16u_a16_H
 
 #include <volk/volk_common.h>
 #include<inttypes.h>
@@ -11,7 +11,7 @@
 #include<pmmintrin.h>
 
 
-static inline void volk_32fc_index_max_aligned16_sse3(unsigned int* target, lv_32fc_t* src0, unsigned int num_bytes) {
+static inline void volk_32fc_index_max_16u_a16_sse3(unsigned int* target, lv_32fc_t* src0, unsigned int num_bytes) {
   
   
   
@@ -189,7 +189,7 @@ static inline void volk_32fc_index_max_aligned16_sse3(unsigned int* target, lv_3
 #endif /*LV_HAVE_SSE3*/
 
 #if LV_HAVE_GENERIC
-static inline void volk_32fc_index_max_aligned16_generic(unsigned int* target, lv_32fc_t* src0, unsigned int num_bytes) {
+static inline void volk_32fc_index_max_16u_a16_generic(unsigned int* target, lv_32fc_t* src0, unsigned int num_bytes) {
   float sq_dist = 0.0;
   float max = 0.0;
   unsigned int index = 0;
@@ -212,4 +212,4 @@ static inline void volk_32fc_index_max_aligned16_generic(unsigned int* target, l
 #endif /*LV_HAVE_GENERIC*/
 
 
-#endif /*INCLUDED_VOLK_32FC_INDEX_MAX_ALIGNED16_H*/
+#endif /*INCLUDED_volk_32fc_index_max_16u_a16_H*/
diff --git a/volk/include/volk/volk_32fc_magnitude_32f_aligned16.h b/volk/include/volk/volk_32fc_magnitude_32f_a16.h
index 3ea62da6a6..be7216dce2 100644
--- a/volk/include/volk/volk_32fc_magnitude_32f_aligned16.h
+++ b/volk/include/volk/volk_32fc_magnitude_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32fc_MAGNITUDE_32f_ALIGNED16_H
-#define INCLUDED_VOLK_32fc_MAGNITUDE_32f_ALIGNED16_H
+#ifndef INCLUDED_volk_32fc_magnitude_32f_a16_H
+#define INCLUDED_volk_32fc_magnitude_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
     \param magnitudeVector The vector containing the real output values
     \param num_points The number of complex values in complexVector to be calculated and stored into cVector
   */
-static inline void volk_32fc_magnitude_32f_aligned16_sse3(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){
+static inline void volk_32fc_magnitude_32f_a16_sse3(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int quarterPoints = num_points / 4;
 
@@ -56,7 +56,7 @@ static inline void volk_32fc_magnitude_32f_aligned16_sse3(float* magnitudeVector
     \param magnitudeVector The vector containing the real output values
     \param num_points The number of complex values in complexVector to be calculated and stored into cVector
   */
-static inline void volk_32fc_magnitude_32f_aligned16_sse(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){
+static inline void volk_32fc_magnitude_32f_a16_sse(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int quarterPoints = num_points / 4;
     
@@ -103,7 +103,7 @@ static inline void volk_32fc_magnitude_32f_aligned16_sse(float* magnitudeVector,
     \param magnitudeVector The vector containing the real output values
     \param num_points The number of complex values in complexVector to be calculated and stored into cVector
   */
-static inline void volk_32fc_magnitude_32f_aligned16_generic(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){
+static inline void volk_32fc_magnitude_32f_a16_generic(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){
   const float* complexVectorPtr = (float*)complexVector;
   float* magnitudeVectorPtr = magnitudeVector;
   unsigned int number = 0;
@@ -122,11 +122,11 @@ static inline void volk_32fc_magnitude_32f_aligned16_generic(float* magnitudeVec
     \param magnitudeVector The vector containing the real output values
     \param num_points The number of complex values in complexVector to be calculated and stored into cVector
   */
-extern void volk_32fc_magnitude_32f_aligned16_orc_impl(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points);
-static inline void volk_32fc_magnitude_32f_aligned16_orc(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){
-    volk_32fc_magnitude_32f_aligned16_orc_impl(magnitudeVector, complexVector, num_points);
+extern void volk_32fc_magnitude_32f_a16_orc_impl(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points);
+static inline void volk_32fc_magnitude_32f_a16_orc(float* magnitudeVector, const lv_32fc_t* complexVector, unsigned int num_points){
+    volk_32fc_magnitude_32f_a16_orc_impl(magnitudeVector, complexVector, num_points);
 }
 #endif /* LV_HAVE_ORC */
 
 
-#endif /* INCLUDED_VOLK_32fc_MAGNITUDE_32f_ALIGNED16_H */
+#endif /* INCLUDED_volk_32fc_magnitude_32f_a16_H */
diff --git a/volk/include/volk/volk_32fc_atan2_32f_aligned16.h b/volk/include/volk/volk_32fc_s32f_atan2_32f_a16.h
index df0ebb987b..e9f74438d7 100644
--- a/volk/include/volk/volk_32fc_atan2_32f_aligned16.h
+++ b/volk/include/volk/volk_32fc_s32f_atan2_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32fc_ATAN2_32f_ALIGNED16_H
-#define INCLUDED_VOLK_32fc_ATAN2_32f_ALIGNED16_H
+#ifndef INCLUDED_volk_32fc_s32f_atan2_32f_a16_H
+#define INCLUDED_volk_32fc_s32f_atan2_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -19,7 +19,7 @@
   \param normalizeFactor The atan2 results will be divided by this normalization factor.
   \param num_points The number of complex values in the input vector.
 */
-static inline void volk_32fc_atan2_32f_aligned16_sse4_1(float* outputVector,  const lv_32fc_t* complexVector, const float normalizeFactor, unsigned int num_points){
+static inline void volk_32fc_s32f_atan2_32f_a16_sse4_1(float* outputVector,  const lv_32fc_t* complexVector, const float normalizeFactor, unsigned int num_points){
   const float* complexVectorPtr = (float*)complexVector;
   float* outPtr = outputVector;
 
@@ -81,7 +81,7 @@ static inline void volk_32fc_atan2_32f_aligned16_sse4_1(float* outputVector,  co
   \param normalizeFactor The atan2 results will be divided by this normalization factor.
   \param num_points The number of complex values in the input vector.
 */
-static inline void volk_32fc_atan2_32f_aligned16_sse(float* outputVector,  const lv_32fc_t* complexVector, const float normalizeFactor, unsigned int num_points){
+static inline void volk_32fc_s32f_atan2_32f_a16_sse(float* outputVector,  const lv_32fc_t* complexVector, const float normalizeFactor, unsigned int num_points){
   const float* complexVectorPtr = (float*)complexVector;
   float* outPtr = outputVector;
 
@@ -139,7 +139,7 @@ static inline void volk_32fc_atan2_32f_aligned16_sse(float* outputVector,  const
   \param normalizeFactor The atan2 results will be divided by this normalization factor.
   \param num_points The number of complex values in the input vector.
 */
-static inline void volk_32fc_atan2_32f_aligned16_generic(float* outputVector, const lv_32fc_t* inputVector, const float normalizeFactor, unsigned int num_points){
+static inline void volk_32fc_s32f_atan2_32f_a16_generic(float* outputVector, const lv_32fc_t* inputVector, const float normalizeFactor, unsigned int num_points){
   float* outPtr = outputVector;
   const float* inPtr = (float*)inputVector;
   const float invNormalizeFactor = 1.0 / normalizeFactor;
@@ -155,4 +155,4 @@ static inline void volk_32fc_atan2_32f_aligned16_generic(float* outputVector, co
 
 
 
-#endif /* INCLUDED_VOLK_32fc_ATAN2_32f_ALIGNED16_H */
+#endif /* INCLUDED_volk_32fc_s32f_atan2_32f_a16_H */
diff --git a/volk/include/volk/volk_32fc_magnitude_16s_aligned16.h b/volk/include/volk/volk_32fc_s32f_magnitude_16s_a16.h
index 4e590e120e..dc3c6741a0 100644
--- a/volk/include/volk/volk_32fc_magnitude_16s_aligned16.h
+++ b/volk/include/volk/volk_32fc_s32f_magnitude_16s_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32fc_MAGNITUDE_16s_ALIGNED16_H
-#define INCLUDED_VOLK_32fc_MAGNITUDE_16s_ALIGNED16_H
+#ifndef INCLUDED_volk_32fc_s32f_magnitude_16s_a16_H
+#define INCLUDED_volk_32fc_s32f_magnitude_16s_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -14,7 +14,7 @@
   \param magnitudeVector The vector containing the real output values
   \param num_points The number of complex values in complexVector to be calculated and stored into cVector
 */
-static inline void volk_32fc_magnitude_16s_aligned16_sse3(int16_t* magnitudeVector, const lv_32fc_t* complexVector, const float scalar, unsigned int num_points){
+static inline void volk_32fc_s32f_magnitude_16s_a16_sse3(int16_t* magnitudeVector, const lv_32fc_t* complexVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
   const unsigned int quarterPoints = num_points / 4;
 
@@ -69,7 +69,7 @@ static inline void volk_32fc_magnitude_16s_aligned16_sse3(int16_t* magnitudeVect
   \param magnitudeVector The vector containing the real output values
   \param num_points The number of complex values in complexVector to be calculated and stored into cVector
 */
-static inline void volk_32fc_magnitude_16s_aligned16_sse(int16_t* magnitudeVector, const lv_32fc_t* complexVector, const float scalar, unsigned int num_points){
+static inline void volk_32fc_s32f_magnitude_16s_a16_sse(int16_t* magnitudeVector, const lv_32fc_t* complexVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
   const unsigned int quarterPoints = num_points / 4;
 
@@ -128,7 +128,7 @@ static inline void volk_32fc_magnitude_16s_aligned16_sse(int16_t* magnitudeVecto
   \param magnitudeVector The vector containing the real output values
   \param num_points The number of complex values in complexVector to be calculated and stored into cVector
 */
-static inline void volk_32fc_magnitude_16s_aligned16_generic(int16_t* magnitudeVector, const lv_32fc_t* complexVector, const float scalar, unsigned int num_points){
+static inline void volk_32fc_s32f_magnitude_16s_a16_generic(int16_t* magnitudeVector, const lv_32fc_t* complexVector, const float scalar, unsigned int num_points){
   const float* complexVectorPtr = (float*)complexVector;
   int16_t* magnitudeVectorPtr = magnitudeVector;
   unsigned int number = 0;
@@ -148,11 +148,11 @@ static inline void volk_32fc_magnitude_16s_aligned16_generic(int16_t* magnitudeV
   \param magnitudeVector The vector containing the real output values
   \param num_points The number of complex values in complexVector to be calculated and stored into cVector
 */
-extern void volk_32fc_magnitude_16s_aligned16_orc_impl(int16_t* magnitudeVector, const lv_32fc_t* complexVector, const float scalar, unsigned int num_points);
-static inline void volk_32fc_magnitude_16s_aligned16_orc(int16_t* magnitudeVector, const lv_32fc_t* complexVector, const float scalar, unsigned int num_points){
-    volk_32fc_magnitude_16s_aligned16_orc_impl(magnitudeVector, complexVector, scalar, num_points);
+extern void volk_32fc_s32f_magnitude_16s_a16_orc_impl(int16_t* magnitudeVector, const lv_32fc_t* complexVector, const float scalar, unsigned int num_points);
+static inline void volk_32fc_s32f_magnitude_16s_a16_orc(int16_t* magnitudeVector, const lv_32fc_t* complexVector, const float scalar, unsigned int num_points){
+    volk_32fc_s32f_magnitude_16s_a16_orc_impl(magnitudeVector, complexVector, scalar, num_points);
 }
 #endif /* LV_HAVE_ORC */
 
 
-#endif /* INCLUDED_VOLK_32fc_MAGNITUDE_16s_ALIGNED16_H */
+#endif /* INCLUDED_volk_32fc_s32f_magnitude_16s_a16_H */
diff --git a/volk/include/volk/volk_32fc_power_spectrum_32f_aligned16.h b/volk/include/volk/volk_32fc_s32f_power_spectrum_32f_a16.h
index 645629b9d4..39d8f7aa2e 100644
--- a/volk/include/volk/volk_32fc_power_spectrum_32f_aligned16.h
+++ b/volk/include/volk/volk_32fc_s32f_power_spectrum_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32fc_POWER_SPECTRUM_32F_ALIGNED16_H
-#define INCLUDED_VOLK_32fc_POWER_SPECTRUM_32F_ALIGNED16_H
+#ifndef INCLUDED_volk_32fc_s32f_power_spectrum_32f_a16_H
+#define INCLUDED_volk_32fc_s32f_power_spectrum_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -19,7 +19,7 @@
   \param normalizationFactor This value is divided against all the input values before the power is calculated
   \param num_points The number of fft data points
 */
-static inline void volk_32fc_power_spectrum_32f_aligned16_sse3(float* logPowerOutput, const lv_32fc_t* complexFFTInput, const float normalizationFactor, unsigned int num_points){
+static inline void volk_32fc_s32f_power_spectrum_32f_a16_sse3(float* logPowerOutput, const lv_32fc_t* complexFFTInput, const float normalizationFactor, unsigned int num_points){
   const float* inputPtr = (const float*)complexFFTInput;
   float* destPtr = logPowerOutput;
   uint64_t number = 0;
@@ -96,7 +96,7 @@ static inline void volk_32fc_power_spectrum_32f_aligned16_sse3(float* logPowerOu
   \param normalizationFactor This value is divided agains all the input values before the power is calculated
   \param num_points The number of fft data points
 */
-static inline void volk_32fc_power_spectrum_32f_aligned16_generic(float* logPowerOutput, const lv_32fc_t* complexFFTInput, const float normalizationFactor, unsigned int num_points){
+static inline void volk_32fc_s32f_power_spectrum_32f_a16_generic(float* logPowerOutput, const lv_32fc_t* complexFFTInput, const float normalizationFactor, unsigned int num_points){
   // Calculate the Power of the complex point
   const float* inputPtr = (float*)complexFFTInput;
   float* realFFTDataPointsPtr = logPowerOutput;
@@ -123,4 +123,4 @@ static inline void volk_32fc_power_spectrum_32f_aligned16_generic(float* logPowe
 
 
 
-#endif /* INCLUDED_VOLK_32fc_POWER_SPECTRUM_32F_ALIGNED16_H */
+#endif /* INCLUDED_volk_32fc_s32f_power_spectrum_32f_a16_H */
diff --git a/volk/include/volk/volk_32fc_power_spectral_density_32f_aligned16.h b/volk/include/volk/volk_32fc_s32f_s32f_power_spectral_density_32f_a16.h
index 52ec0f95b6..29ccdaef70 100644
--- a/volk/include/volk/volk_32fc_power_spectral_density_32f_aligned16.h
+++ b/volk/include/volk/volk_32fc_s32f_s32f_power_spectral_density_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32fc_POWER_SPECTRAL_DENSITY_32F_ALIGNED16_H
-#define INCLUDED_VOLK_32fc_POWER_SPECTRAL_DENSITY_32F_ALIGNED16_H
+#ifndef INCLUDED_volk_32fc_s32f_s32f_power_spectral_density_32f_a16_H
+#define INCLUDED_volk_32fc_s32f_s32f_power_spectral_density_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -20,7 +20,7 @@
   \param rbw The resolution bandwith of the fft spectrum
   \param num_points The number of fft data points
 */
-static inline void volk_32fc_power_spectral_density_32f_aligned16_sse3(float* logPowerOutput, const lv_32fc_t* complexFFTInput, const float normalizationFactor, const float rbw, unsigned int num_points){
+static inline void volk_32fc_s32f_s32f_power_spectral_density_32f_a16_sse3(float* logPowerOutput, const lv_32fc_t* complexFFTInput, const float normalizationFactor, const float rbw, unsigned int num_points){
   const float* inputPtr = (const float*)complexFFTInput;
   float* destPtr = logPowerOutput;
   uint64_t number = 0;
@@ -103,7 +103,7 @@ static inline void volk_32fc_power_spectral_density_32f_aligned16_sse3(float* lo
   \param rbw The resolution bandwith of the fft spectrum
   \param num_points The number of fft data points
 */
-static inline void volk_32fc_power_spectral_density_32f_aligned16_generic(float* logPowerOutput, const lv_32fc_t* complexFFTInput, const float normalizationFactor, const float rbw, unsigned int num_points){
+static inline void volk_32fc_s32f_s32f_power_spectral_density_32f_a16_generic(float* logPowerOutput, const lv_32fc_t* complexFFTInput, const float normalizationFactor, const float rbw, unsigned int num_points){
   // Calculate the Power of the complex point
   const float* inputPtr = (float*)complexFFTInput;
   float* realFFTDataPointsPtr = logPowerOutput;
@@ -131,4 +131,4 @@ static inline void volk_32fc_power_spectral_density_32f_aligned16_generic(float*
 
 
 
-#endif /* INCLUDED_VOLK_32fc_POWER_SPECTRAL_DENSITY_32F_ALIGNED16_H */
+#endif /* INCLUDED_volk_32fc_s32f_s32f_power_spectral_density_32f_a16_H */
diff --git a/volk/include/volk/volk_32s_and_aligned16.h b/volk/include/volk/volk_32s_32s_and_32s_a16.h
index 16c63fd482..0e8380757e 100644
--- a/volk/include/volk/volk_32s_and_aligned16.h
+++ b/volk/include/volk/volk_32s_32s_and_32s_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32s_AND_ALIGNED16_H
-#define INCLUDED_VOLK_32s_AND_ALIGNED16_H
+#ifndef INCLUDED_volk_32s_32s_and_32s_a16_H
+#define INCLUDED_volk_32s_32s_and_32s_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param bVector One of the vectors
   \param num_points The number of values in aVector and bVector to be anded together and stored into cVector
 */
-static inline void volk_32s_and_aligned16_sse(int32_t* cVector, const int32_t* aVector, const int32_t* bVector, unsigned int num_points){
+static inline void volk_32s_32s_and_32s_a16_sse(int32_t* cVector, const int32_t* aVector, const int32_t* bVector, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int quarterPoints = num_points / 4;
 
@@ -51,7 +51,7 @@ static inline void volk_32s_and_aligned16_sse(int32_t* cVector, const int32_t* a
   \param bVector One of the vectors
   \param num_points The number of values in aVector and bVector to be anded together and stored into cVector
 */
-static inline void volk_32s_and_aligned16_generic(int32_t* cVector, const int32_t* aVector, const int32_t* bVector, unsigned int num_points){
+static inline void volk_32s_32s_and_32s_a16_generic(int32_t* cVector, const int32_t* aVector, const int32_t* bVector, unsigned int num_points){
     int32_t* cPtr = cVector;
     const int32_t* aPtr = aVector;
     const int32_t* bPtr=  bVector;
@@ -71,11 +71,11 @@ static inline void volk_32s_and_aligned16_generic(int32_t* cVector, const int32_
   \param bVector One of the vectors
   \param num_points The number of values in aVector and bVector to be anded together and stored into cVector
 */
-extern void volk_32s_and_aligned16_orc_impl(int32_t* cVector, const int32_t* aVector, const int32_t* bVector, unsigned int num_points);
-static inline void volk_32s_and_aligned16_orc(int32_t* cVector, const int32_t* aVector, const int32_t* bVector, unsigned int num_points){
-    volk_32s_and_aligned16_orc_impl(cVector, aVector, bVector, num_points);
+extern void volk_32s_32s_and_32s_a16_orc_impl(int32_t* cVector, const int32_t* aVector, const int32_t* bVector, unsigned int num_points);
+static inline void volk_32s_32s_and_32s_a16_orc(int32_t* cVector, const int32_t* aVector, const int32_t* bVector, unsigned int num_points){
+    volk_32s_32s_and_32s_a16_orc_impl(cVector, aVector, bVector, num_points);
 }
 #endif /* LV_HAVE_ORC */
 
 
-#endif /* INCLUDED_VOLK_32s_AND_ALIGNED16_H */
+#endif /* INCLUDED_volk_32s_32s_and_32s_a16_H */
diff --git a/volk/include/volk/volk_32s_or_aligned16.h b/volk/include/volk/volk_32s_32s_or_32s_a16.h
index 64748d5354..2dcf2e5515 100644
--- a/volk/include/volk/volk_32s_or_aligned16.h
+++ b/volk/include/volk/volk_32s_32s_or_32s_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32s_OR_ALIGNED16_H
-#define INCLUDED_VOLK_32s_OR_ALIGNED16_H
+#ifndef INCLUDED_volk_32s_32s_or_32s_a16_H
+#define INCLUDED_volk_32s_32s_or_32s_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param bVector One of the vectors to be ored
   \param num_points The number of values in aVector and bVector to be ored together and stored into cVector
 */
-static inline void volk_32s_or_aligned16_sse(int32_t* cVector, const int32_t* aVector, const int32_t* bVector, unsigned int num_points){
+static inline void volk_32s_32s_or_32s_a16_sse(int32_t* cVector, const int32_t* aVector, const int32_t* bVector, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int quarterPoints = num_points / 4;
 
@@ -51,7 +51,7 @@ static inline void volk_32s_or_aligned16_sse(int32_t* cVector, const int32_t* aV
   \param bVector One of the vectors to be ored
   \param num_points The number of values in aVector and bVector to be ored together and stored into cVector
 */
-static inline void volk_32s_or_aligned16_generic(int32_t* cVector, const int32_t* aVector, const int32_t* bVector, unsigned int num_points){
+static inline void volk_32s_32s_or_32s_a16_generic(int32_t* cVector, const int32_t* aVector, const int32_t* bVector, unsigned int num_points){
     int32_t* cPtr = cVector;
     const int32_t* aPtr = aVector;
     const int32_t* bPtr=  bVector;
@@ -71,11 +71,11 @@ static inline void volk_32s_or_aligned16_generic(int32_t* cVector, const int32_t
   \param bVector One of the vectors to be ored
   \param num_points The number of values in aVector and bVector to be ored together and stored into cVector
 */
-extern void volk_32s_or_aligned16_orc_impl(int32_t* cVector, const int32_t* aVector, const int32_t* bVector, unsigned int num_points);
-static inline void volk_32s_or_aligned16_orc(int32_t* cVector, const int32_t* aVector, const int32_t* bVector, unsigned int num_points){
-    volk_32s_or_aligned16_orc_impl(cVector, aVector, bVector, num_points);
+extern void volk_32s_32s_or_32s_a16_orc_impl(int32_t* cVector, const int32_t* aVector, const int32_t* bVector, unsigned int num_points);
+static inline void volk_32s_32s_or_32s_a16_orc(int32_t* cVector, const int32_t* aVector, const int32_t* bVector, unsigned int num_points){
+    volk_32s_32s_or_32s_a16_orc_impl(cVector, aVector, bVector, num_points);
 }
 #endif /* LV_HAVE_ORC */
 
 
-#endif /* INCLUDED_VOLK_32s_OR_ALIGNED16_H */
+#endif /* INCLUDED_volk_32s_32s_or_32s_a16_H */
diff --git a/volk/include/volk/volk_32s_convert_32f_aligned16.h b/volk/include/volk/volk_32s_s32f_convert_32f_a16.h
index a407e68bda..c16ecc9dde 100644
--- a/volk/include/volk/volk_32s_convert_32f_aligned16.h
+++ b/volk/include/volk/volk_32s_s32f_convert_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32s_CONVERT_32f_ALIGNED16_H
-#define INCLUDED_VOLK_32s_CONVERT_32f_ALIGNED16_H
+#ifndef INCLUDED_volk_32s_s32f_convert_32f_a16_H
+#define INCLUDED_volk_32s_s32f_convert_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -14,7 +14,7 @@
     \param scalar The value divided against each point in the output buffer
     \param num_points The number of data values to be converted
   */
-static inline void volk_32s_convert_32f_aligned16_sse2(float* outputVector, const int32_t* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32s_s32f_convert_32f_a16_sse2(float* outputVector, const int32_t* inputVector, const float scalar, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int quarterPoints = num_points / 4;
     
@@ -55,7 +55,7 @@ static inline void volk_32s_convert_32f_aligned16_sse2(float* outputVector, cons
     \param scalar The value divided against each point in the output buffer
     \param num_points The number of data values to be converted
   */
-static inline void volk_32s_convert_32f_aligned16_generic(float* outputVector, const int32_t* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32s_s32f_convert_32f_a16_generic(float* outputVector, const int32_t* inputVector, const float scalar, unsigned int num_points){
   float* outputVectorPtr = outputVector;
   const int32_t* inputVectorPtr = inputVector;
   unsigned int number = 0;
@@ -70,4 +70,4 @@ static inline void volk_32s_convert_32f_aligned16_generic(float* outputVector, c
 
 
 
-#endif /* INCLUDED_VOLK_32s_CONVERT_32f_ALIGNED16_H */
+#endif /* INCLUDED_volk_32s_s32f_convert_32f_a16_H */
diff --git a/volk/include/volk/volk_32s_convert_32f_unaligned16.h b/volk/include/volk/volk_32s_s32f_convert_32f_ua16.h
index ad7d4eb173..4eb5a5b850 100644
--- a/volk/include/volk/volk_32s_convert_32f_unaligned16.h
+++ b/volk/include/volk/volk_32s_s32f_convert_32f_ua16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32s_CONVERT_32f_UNALIGNED16_H
-#define INCLUDED_VOLK_32s_CONVERT_32f_UNALIGNED16_H
+#ifndef INCLUDED_volk_32s_s32f_convert_32f_ua16_H
+#define INCLUDED_volk_32s_s32f_convert_32f_ua16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -15,7 +15,7 @@
     \param num_points The number of data values to be converted
     \note Output buffer does NOT need to be properly aligned
   */
-static inline void volk_32s_convert_32f_unaligned16_sse2(float* outputVector, const int32_t* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32s_s32f_convert_32f_ua16_sse2(float* outputVector, const int32_t* inputVector, const float scalar, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int quarterPoints = num_points / 4;
     
@@ -57,7 +57,7 @@ static inline void volk_32s_convert_32f_unaligned16_sse2(float* outputVector, co
     \param num_points The number of data values to be converted
     \note Output buffer does NOT need to be properly aligned
   */
-static inline void volk_32s_convert_32f_unaligned16_generic(float* outputVector, const int32_t* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_32s_s32f_convert_32f_ua16_generic(float* outputVector, const int32_t* inputVector, const float scalar, unsigned int num_points){
   float* outputVectorPtr = outputVector;
   const int32_t* inputVectorPtr = inputVector;
   unsigned int number = 0;
@@ -72,4 +72,4 @@ static inline void volk_32s_convert_32f_unaligned16_generic(float* outputVector,
 
 
 
-#endif /* INCLUDED_VOLK_32s_CONVERT_32f_UNALIGNED16_H */
+#endif /* INCLUDED_volk_32s_s32f_convert_32f_ua16_H */
diff --git a/volk/include/volk/volk_32u_byteswap_aligned16.h b/volk/include/volk/volk_32u_byteswap_a16.h
index 09173a9d58..7556ec7b1d 100644
--- a/volk/include/volk/volk_32u_byteswap_aligned16.h
+++ b/volk/include/volk/volk_32u_byteswap_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32u_BYTESWAP_ALIGNED16_H
-#define INCLUDED_VOLK_32u_BYTESWAP_ALIGNED16_H
+#ifndef INCLUDED_volk_32u_byteswap_a16_H
+#define INCLUDED_volk_32u_byteswap_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -12,7 +12,7 @@
   \param intsToSwap The vector of data to byte swap
   \param numDataPoints The number of data points
 */
-static inline void volk_32u_byteswap_aligned16_sse2(uint32_t* intsToSwap, unsigned int num_points){
+static inline void volk_32u_byteswap_a16_sse2(uint32_t* intsToSwap, unsigned int num_points){
   unsigned int number = 0;
 
   uint32_t* inputPtr = intsToSwap;
@@ -57,7 +57,7 @@ static inline void volk_32u_byteswap_aligned16_sse2(uint32_t* intsToSwap, unsign
   \param intsToSwap The vector of data to byte swap
   \param numDataPoints The number of data points
 */
-static inline void volk_32u_byteswap_aligned16_generic(uint32_t* intsToSwap, unsigned int num_points){
+static inline void volk_32u_byteswap_a16_generic(uint32_t* intsToSwap, unsigned int num_points){
   uint32_t* inputPtr = intsToSwap;
 
   unsigned int point;
@@ -74,4 +74,4 @@ static inline void volk_32u_byteswap_aligned16_generic(uint32_t* intsToSwap, uns
 
 
 
-#endif /* INCLUDED_VOLK_32u_BYTESWAP_ALIGNED16_H */
+#endif /* INCLUDED_volk_32u_byteswap_a16_H */
diff --git a/volk/include/volk/volk_32u_popcnt_aligned16.h b/volk/include/volk/volk_32u_popcnt_a16.h
index 37cfd112c0..f6e25e4e81 100644
--- a/volk/include/volk/volk_32u_popcnt_aligned16.h
+++ b/volk/include/volk/volk_32u_popcnt_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_32u_POPCNT_ALIGNED16_H
-#define INCLUDED_VOLK_32u_POPCNT_ALIGNED16_H
+#ifndef INCLUDED_VOLK_32u_POPCNT_A16_H
+#define INCLUDED_VOLK_32u_POPCNT_A16_H
 
 #include <stdio.h>
 #include <inttypes.h>
@@ -7,7 +7,7 @@
 
 #if LV_HAVE_GENERIC
 
-static inline void volk_32u_popcnt_aligned16_generic(uint32_t* ret, const uint32_t value) {
+static inline void volk_32u_popcnt_a16_generic(uint32_t* ret, const uint32_t value) {
 
   // This is faster than a lookup table
   uint32_t retVal = value;
@@ -27,10 +27,10 @@ static inline void volk_32u_popcnt_aligned16_generic(uint32_t* ret, const uint32
 
 #include <nmmintrin.h>
 
-static inline void volk_32u_popcnt_aligned16_sse4_2(uint32_t* ret, const uint32_t value) {
+static inline void volk_32u_popcnt_a16_sse4_2(uint32_t* ret, const uint32_t value) {
   *ret = _mm_popcnt_u32(value);
 }
 
 #endif /*LV_HAVE_SSE4_2*/
 
-#endif /*INCLUDED_VOLK_32u_POPCNT_ALIGNED16_H*/
+#endif /*INCLUDED_VOLK_32u_POPCNT_A16_H*/
diff --git a/volk/include/volk/volk_64f_max_aligned16.h b/volk/include/volk/volk_64f_64f_max_64f_a16.h
index ce4907a8c4..7e091851f2 100644
--- a/volk/include/volk/volk_64f_max_aligned16.h
+++ b/volk/include/volk/volk_64f_64f_max_64f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_64f_MAX_ALIGNED16_H
-#define INCLUDED_VOLK_64f_MAX_ALIGNED16_H
+#ifndef INCLUDED_volk_64f_64f_max_64f_a16_H
+#define INCLUDED_volk_64f_64f_max_64f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param bVector The vector to be checked
   \param num_points The number of values in aVector and bVector to be checked and stored into cVector
 */
-static inline void volk_64f_max_aligned16_sse2(double* cVector, const double* aVector, const double* bVector, unsigned int num_points){
+static inline void volk_64f_64f_max_64f_a16_sse2(double* cVector, const double* aVector, const double* bVector, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int halfPoints = num_points / 2;
 
@@ -53,7 +53,7 @@ static inline void volk_64f_max_aligned16_sse2(double* cVector, const double* aV
   \param bVector The vector to be checked
   \param num_points The number of values in aVector and bVector to be checked and stored into cVector
 */
-static inline void volk_64f_max_aligned16_generic(double* cVector, const double* aVector, const double* bVector, unsigned int num_points){
+static inline void volk_64f_64f_max_64f_a16_generic(double* cVector, const double* aVector, const double* bVector, unsigned int num_points){
     double* cPtr = cVector;
     const double* aPtr = aVector;
     const double* bPtr=  bVector;
@@ -68,4 +68,4 @@ static inline void volk_64f_max_aligned16_generic(double* cVector, const double*
 #endif /* LV_HAVE_GENERIC */
 
 
-#endif /* INCLUDED_VOLK_64f_MAX_ALIGNED16_H */
+#endif /* INCLUDED_volk_64f_64f_max_64f_a16_H */
diff --git a/volk/include/volk/volk_64f_min_aligned16.h b/volk/include/volk/volk_64f_64f_min_64f_a16.h
index acf4d6b2a4..f2bcbe83b6 100644
--- a/volk/include/volk/volk_64f_min_aligned16.h
+++ b/volk/include/volk/volk_64f_64f_min_64f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_64f_MIN_ALIGNED16_H
-#define INCLUDED_VOLK_64f_MIN_ALIGNED16_H
+#ifndef INCLUDED_volk_64f_64f_min_64f_a16_H
+#define INCLUDED_volk_64f_64f_min_64f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param bVector The vector to be checked
   \param num_points The number of values in aVector and bVector to be checked and stored into cVector
 */
-static inline void volk_64f_min_aligned16_sse2(double* cVector, const double* aVector, const double* bVector, unsigned int num_points){
+static inline void volk_64f_64f_min_64f_a16_sse2(double* cVector, const double* aVector, const double* bVector, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int halfPoints = num_points / 2;
 
@@ -53,7 +53,7 @@ static inline void volk_64f_min_aligned16_sse2(double* cVector, const double* aV
   \param bVector The vector to be checked
   \param num_points The number of values in aVector and bVector to be checked and stored into cVector
 */
-static inline void volk_64f_min_aligned16_generic(double* cVector, const double* aVector, const double* bVector, unsigned int num_points){
+static inline void volk_64f_64f_min_64f_a16_generic(double* cVector, const double* aVector, const double* bVector, unsigned int num_points){
     double* cPtr = cVector;
     const double* aPtr = aVector;
     const double* bPtr=  bVector;
@@ -68,4 +68,4 @@ static inline void volk_64f_min_aligned16_generic(double* cVector, const double*
 #endif /* LV_HAVE_GENERIC */
 
 
-#endif /* INCLUDED_VOLK_64f_MIN_ALIGNED16_H */
+#endif /* INCLUDED_volk_64f_64f_min_64f_a16_H */
diff --git a/volk/include/volk/volk_64f_convert_32f_aligned16.h b/volk/include/volk/volk_64f_convert_32f_a16.h
index 44df661044..7dca065f08 100644
--- a/volk/include/volk/volk_64f_convert_32f_aligned16.h
+++ b/volk/include/volk/volk_64f_convert_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_64f_CONVERT_32f_ALIGNED16_H
-#define INCLUDED_VOLK_64f_CONVERT_32f_ALIGNED16_H
+#ifndef INCLUDED_volk_64f_convert_32f_a16_H
+#define INCLUDED_volk_64f_convert_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -12,7 +12,7 @@
     \param fVector The double vector values to be converted
     \param num_points The number of points in the two vectors to be converted
   */
-static inline void volk_64f_convert_32f_aligned16_sse2(float* outputVector, const double* inputVector, unsigned int num_points){
+static inline void volk_64f_convert_32f_a16_sse2(float* outputVector, const double* inputVector, unsigned int num_points){
   unsigned int number = 0;
 
   const unsigned int quarterPoints = num_points / 4;
@@ -50,7 +50,7 @@ static inline void volk_64f_convert_32f_aligned16_sse2(float* outputVector, cons
   \param fVector The double vector values to be converted
   \param num_points The number of points in the two vectors to be converted
 */
-static inline void volk_64f_convert_32f_aligned16_generic(float* outputVector, const double* inputVector, unsigned int num_points){
+static inline void volk_64f_convert_32f_a16_generic(float* outputVector, const double* inputVector, unsigned int num_points){
   float* outputVectorPtr = outputVector;
   const double* inputVectorPtr = inputVector;
   unsigned int number = 0;
@@ -64,4 +64,4 @@ static inline void volk_64f_convert_32f_aligned16_generic(float* outputVector, c
 
 
 
-#endif /* INCLUDED_VOLK_64f_CONVERT_32f_ALIGNED16_H */
+#endif /* INCLUDED_volk_64f_convert_32f_a16_H */
diff --git a/volk/include/volk/volk_64f_convert_32f_unaligned16.h b/volk/include/volk/volk_64f_convert_32f_ua16.h
index 08cfb6127b..7774db1b75 100644
--- a/volk/include/volk/volk_64f_convert_32f_unaligned16.h
+++ b/volk/include/volk/volk_64f_convert_32f_ua16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_64f_CONVERT_32f_UNALIGNED16_H
-#define INCLUDED_VOLK_64f_CONVERT_32f_UNALIGNED16_H
+#ifndef INCLUDED_volk_64f_convert_32f_ua16_H
+#define INCLUDED_volk_64f_convert_32f_ua16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -12,7 +12,7 @@
     \param fVector The double vector values to be converted
     \param num_points The number of points in the two vectors to be converted
   */
-static inline void volk_64f_convert_32f_unaligned16_sse2(float* outputVector, const double* inputVector, unsigned int num_points){
+static inline void volk_64f_convert_32f_ua16_sse2(float* outputVector, const double* inputVector, unsigned int num_points){
   unsigned int number = 0;
 
   const unsigned int quarterPoints = num_points / 4;
@@ -50,7 +50,7 @@ static inline void volk_64f_convert_32f_unaligned16_sse2(float* outputVector, co
   \param fVector The double vector values to be converted
   \param num_points The number of points in the two vectors to be converted
 */
-static inline void volk_64f_convert_32f_unaligned16_generic(float* outputVector, const double* inputVector, unsigned int num_points){
+static inline void volk_64f_convert_32f_ua16_generic(float* outputVector, const double* inputVector, unsigned int num_points){
   float* outputVectorPtr = outputVector;
   const double* inputVectorPtr = inputVector;
   unsigned int number = 0;
@@ -64,4 +64,4 @@ static inline void volk_64f_convert_32f_unaligned16_generic(float* outputVector,
 
 
 
-#endif /* INCLUDED_VOLK_64f_CONVERT_32f_UNALIGNED16_H */
+#endif /* INCLUDED_volk_64f_convert_32f_ua16_H */
diff --git a/volk/include/volk/volk_64u_byteswap_aligned16.h b/volk/include/volk/volk_64u_byteswap_a16.h
index d5e1b6f307..0eefe01383 100644
--- a/volk/include/volk/volk_64u_byteswap_aligned16.h
+++ b/volk/include/volk/volk_64u_byteswap_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_64u_BYTESWAP_ALIGNED16_H
-#define INCLUDED_VOLK_64u_BYTESWAP_ALIGNED16_H
+#ifndef INCLUDED_volk_64u_byteswap_a16_H
+#define INCLUDED_volk_64u_byteswap_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -12,7 +12,7 @@
   \param intsToSwap The vector of data to byte swap
   \param numDataPoints The number of data points
 */
-static inline void volk_64u_byteswap_aligned16_sse2(uint64_t* intsToSwap, unsigned int num_points){
+static inline void volk_64u_byteswap_a16_sse2(uint64_t* intsToSwap, unsigned int num_points){
     uint32_t* inputPtr = (uint32_t*)intsToSwap;
     __m128i input, byte1, byte2, byte3, byte4, output;
     __m128i byte2mask = _mm_set1_epi32(0x00FF0000);
@@ -65,7 +65,7 @@ static inline void volk_64u_byteswap_aligned16_sse2(uint64_t* intsToSwap, unsign
   \param intsToSwap The vector of data to byte swap
   \param numDataPoints The number of data points
 */
-static inline void volk_64u_byteswap_aligned16_generic(uint64_t* intsToSwap, unsigned int num_points){
+static inline void volk_64u_byteswap_a16_generic(uint64_t* intsToSwap, unsigned int num_points){
   uint32_t* inputPtr = (uint32_t*)intsToSwap;
   unsigned int point;
   for(point = 0; point < num_points; point++){
@@ -85,4 +85,4 @@ static inline void volk_64u_byteswap_aligned16_generic(uint64_t* intsToSwap, uns
 
 
 
-#endif /* INCLUDED_VOLK_64u_BYTESWAP_ALIGNED16_H */
+#endif /* INCLUDED_volk_64u_byteswap_a16_H */
diff --git a/volk/include/volk/volk_64u_popcnt_aligned16.h b/volk/include/volk/volk_64u_popcnt_a16.h
index 4d62f93754..59511dc29d 100644
--- a/volk/include/volk/volk_64u_popcnt_aligned16.h
+++ b/volk/include/volk/volk_64u_popcnt_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_64u_POPCNT_ALIGNED16_H
-#define INCLUDED_VOLK_64u_POPCNT_ALIGNED16_H
+#ifndef INCLUDED_volk_64u_popcnt_a16_H
+#define INCLUDED_volk_64u_popcnt_a16_H
 
 #include <stdio.h>
 #include <inttypes.h>
@@ -8,7 +8,7 @@
 #if LV_HAVE_GENERIC
 
 
-static inline void volk_64u_popcnt_aligned16_generic(uint64_t* ret, const uint64_t value) {
+static inline void volk_64u_popcnt_a16_generic(uint64_t* ret, const uint64_t value) {
 
   const uint32_t* valueVector = (const uint32_t*)&value;
   
@@ -40,11 +40,11 @@ static inline void volk_64u_popcnt_aligned16_generic(uint64_t* ret, const uint64
 
 #include <nmmintrin.h>
 
-static inline void volk_64u_popcnt_aligned16_sse4_2(uint64_t* ret, const uint64_t value) {
+static inline void volk_64u_popcnt_a16_sse4_2(uint64_t* ret, const uint64_t value) {
   *ret = _mm_popcnt_u64(value);
 
 }
 
 #endif /*LV_HAVE_SSE4_2*/
 
-#endif /*INCLUDED_VOLK_64u_POPCNT_ALIGNED16_H*/
+#endif /*INCLUDED_volk_64u_popcnt_a16_H*/
diff --git a/volk/include/volk/volk_8s_convert_16s_aligned16.h b/volk/include/volk/volk_8s_convert_16s_a16.h
index c52c64eaef..38efdb6a35 100644
--- a/volk/include/volk/volk_8s_convert_16s_aligned16.h
+++ b/volk/include/volk/volk_8s_convert_16s_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_8s_CONVERT_16s_ALIGNED16_H
-#define INCLUDED_VOLK_8s_CONVERT_16s_ALIGNED16_H
+#ifndef INCLUDED_volk_8s_convert_16s_a16_H
+#define INCLUDED_volk_8s_convert_16s_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
     \param outputVector The 16 bit output data buffer
     \param num_points The number of data values to be converted
   */
-static inline void volk_8s_convert_16s_aligned16_sse4_1(int16_t* outputVector, const int8_t* inputVector, unsigned int num_points){
+static inline void volk_8s_convert_16s_a16_sse4_1(int16_t* outputVector, const int8_t* inputVector, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int sixteenthPoints = num_points / 16;
 
@@ -54,7 +54,7 @@ static inline void volk_8s_convert_16s_aligned16_sse4_1(int16_t* outputVector, c
     \param outputVector The 16 bit output data buffer
     \param num_points The number of data values to be converted
   */
-static inline void volk_8s_convert_16s_aligned16_generic(int16_t* outputVector, const int8_t* inputVector, unsigned int num_points){
+static inline void volk_8s_convert_16s_a16_generic(int16_t* outputVector, const int8_t* inputVector, unsigned int num_points){
   int16_t* outputVectorPtr = outputVector;
   const int8_t* inputVectorPtr = inputVector;
   unsigned int number = 0;
@@ -72,9 +72,9 @@ static inline void volk_8s_convert_16s_aligned16_generic(int16_t* outputVector,
     \param outputVector The 16 bit output data buffer
     \param num_points The number of data values to be converted
   */
-extern void volk_8s_convert_16s_aligned16_orc_impl(int16_t* outputVector, const int8_t* inputVector, unsigned int num_points);
-static inline void volk_8s_convert_16s_aligned16_orc(int16_t* outputVector, const int8_t* inputVector, unsigned int num_points){
-    volk_8s_convert_16s_aligned16_orc_impl(outputVector, inputVector, num_points);
+extern void volk_8s_convert_16s_a16_orc_impl(int16_t* outputVector, const int8_t* inputVector, unsigned int num_points);
+static inline void volk_8s_convert_16s_a16_orc(int16_t* outputVector, const int8_t* inputVector, unsigned int num_points){
+    volk_8s_convert_16s_a16_orc_impl(outputVector, inputVector, num_points);
 }
 #endif /* LV_HAVE_ORC */
 
diff --git a/volk/include/volk/volk_8s_convert_16s_unaligned16.h b/volk/include/volk/volk_8s_convert_16s_ua16.h
index 05b916cea4..a726bfb5e1 100644
--- a/volk/include/volk/volk_8s_convert_16s_unaligned16.h
+++ b/volk/include/volk/volk_8s_convert_16s_ua16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_8s_CONVERT_16s_UNALIGNED16_H
-#define INCLUDED_VOLK_8s_CONVERT_16s_UNALIGNED16_H
+#ifndef INCLUDED_volk_8s_convert_16s_ua16_H
+#define INCLUDED_volk_8s_convert_16s_ua16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -14,7 +14,7 @@
     \param num_points The number of data values to be converted
     \note Input and output buffers do NOT need to be properly aligned
   */
-static inline void volk_8s_convert_16s_unaligned16_sse4_1(int16_t* outputVector, const int8_t* inputVector, unsigned int num_points){
+static inline void volk_8s_convert_16s_ua16_sse4_1(int16_t* outputVector, const int8_t* inputVector, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int sixteenthPoints = num_points / 16;
 
@@ -56,7 +56,7 @@ static inline void volk_8s_convert_16s_unaligned16_sse4_1(int16_t* outputVector,
     \param num_points The number of data values to be converted
     \note Input and output buffers do NOT need to be properly aligned
   */
-static inline void volk_8s_convert_16s_unaligned16_generic(int16_t* outputVector, const int8_t* inputVector, unsigned int num_points){
+static inline void volk_8s_convert_16s_ua16_generic(int16_t* outputVector, const int8_t* inputVector, unsigned int num_points){
   int16_t* outputVectorPtr = outputVector;
   const int8_t* inputVectorPtr = inputVector;
   unsigned int number = 0;
diff --git a/volk/include/volk/volk_8s_convert_32f_aligned16.h b/volk/include/volk/volk_8s_s32f_convert_32f_a16.h
index 700a0fa422..45185ac2ee 100644
--- a/volk/include/volk/volk_8s_convert_32f_aligned16.h
+++ b/volk/include/volk/volk_8s_s32f_convert_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_8s_CONVERT_32f_ALIGNED16_H
-#define INCLUDED_VOLK_8s_CONVERT_32f_ALIGNED16_H
+#ifndef INCLUDED_volk_8s_s32f_convert_32f_a16_H
+#define INCLUDED_volk_8s_s32f_convert_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -14,7 +14,7 @@
     \param scalar The value divided against each point in the output buffer
     \param num_points The number of data values to be converted
   */
-static inline void volk_8s_convert_32f_aligned16_sse4_1(float* outputVector, const int8_t* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_8s_s32f_convert_32f_a16_sse4_1(float* outputVector, const int8_t* inputVector, const float scalar, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int sixteenthPoints = num_points / 16;
     
@@ -74,7 +74,7 @@ static inline void volk_8s_convert_32f_aligned16_sse4_1(float* outputVector, con
     \param scalar The value divided against each point in the output buffer
     \param num_points The number of data values to be converted
   */
-static inline void volk_8s_convert_32f_aligned16_generic(float* outputVector, const int8_t* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_8s_s32f_convert_32f_a16_generic(float* outputVector, const int8_t* inputVector, const float scalar, unsigned int num_points){
   float* outputVectorPtr = outputVector;
   const int8_t* inputVectorPtr = inputVector;
   unsigned int number = 0;
@@ -94,9 +94,9 @@ static inline void volk_8s_convert_32f_aligned16_generic(float* outputVector, co
     \param scalar The value divided against each point in the output buffer
     \param num_points The number of data values to be converted
   */
-extern void volk_8s_convert_32f_aligned16_orc_impl(float* outputVector, const int8_t* inputVector, const float scalar, unsigned int num_points);
-static inline void volk_8s_convert_32f_aligned16_orc(float* outputVector, const int8_t* inputVector, const float scalar, unsigned int num_points){
-    volk_8s_convert_32f_aligned16_orc_impl(outputVector, inputVector, scalar, num_points);
+extern void volk_8s_s32f_convert_32f_a16_orc_impl(float* outputVector, const int8_t* inputVector, const float scalar, unsigned int num_points);
+static inline void volk_8s_s32f_convert_32f_a16_orc(float* outputVector, const int8_t* inputVector, const float scalar, unsigned int num_points){
+    volk_8s_s32f_convert_32f_a16_orc_impl(outputVector, inputVector, scalar, num_points);
 }
 #endif /* LV_HAVE_ORC */
 
diff --git a/volk/include/volk/volk_8s_convert_32f_unaligned16.h b/volk/include/volk/volk_8s_s32f_convert_32f_ua16.h
index 8019aac9a2..310824580c 100644
--- a/volk/include/volk/volk_8s_convert_32f_unaligned16.h
+++ b/volk/include/volk/volk_8s_s32f_convert_32f_ua16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_8s_CONVERT_32f_UNALIGNED16_H
-#define INCLUDED_VOLK_8s_CONVERT_32f_UNALIGNED16_H
+#ifndef INCLUDED_volk_8s_s32f_convert_32f_ua16_H
+#define INCLUDED_volk_8s_s32f_convert_32f_ua16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -15,7 +15,7 @@
     \param num_points The number of data values to be converted
     \note Output buffer does NOT need to be properly aligned
   */
-static inline void volk_8s_convert_32f_unaligned16_sse4_1(float* outputVector, const int8_t* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_8s_s32f_convert_32f_ua16_sse4_1(float* outputVector, const int8_t* inputVector, const float scalar, unsigned int num_points){
     unsigned int number = 0;
     const unsigned int sixteenthPoints = num_points / 16;
     
@@ -76,7 +76,7 @@ static inline void volk_8s_convert_32f_unaligned16_sse4_1(float* outputVector, c
     \param num_points The number of data values to be converted
     \note Output buffer does NOT need to be properly aligned
   */
-static inline void volk_8s_convert_32f_unaligned16_generic(float* outputVector, const int8_t* inputVector, const float scalar, unsigned int num_points){
+static inline void volk_8s_s32f_convert_32f_ua16_generic(float* outputVector, const int8_t* inputVector, const float scalar, unsigned int num_points){
   float* outputVectorPtr = outputVector;
   const int8_t* inputVectorPtr = inputVector;
   unsigned int number = 0;
diff --git a/volk/include/volk/volk_8sc_multiply_conjugate_16sc_aligned16.h b/volk/include/volk/volk_8sc_8sc_multiply_conjugate_16sc_a16.h
index 470a67539f..eae1185ec7 100644
--- a/volk/include/volk/volk_8sc_multiply_conjugate_16sc_aligned16.h
+++ b/volk/include/volk/volk_8sc_8sc_multiply_conjugate_16sc_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_8sc_MULTIPLY_CONJUGATE_16sc_ALIGNED16_H
-#define INCLUDED_VOLK_8sc_MULTIPLY_CONJUGATE_16sc_ALIGNED16_H
+#ifndef INCLUDED_volk_8sc_8sc_multiply_conjugate_16sc_a16_H
+#define INCLUDED_volk_8sc_8sc_multiply_conjugate_16sc_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -14,7 +14,7 @@
   \param bVector The complex vector which will be converted to complex conjugate and multiplied
   \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector
 */
-static inline void volk_8sc_multiply_conjugate_16sc_aligned16_sse4_1(lv_16sc_t* cVector, const lv_8sc_t* aVector, const lv_8sc_t* bVector, unsigned int num_points){
+static inline void volk_8sc_8sc_multiply_conjugate_16sc_a16_sse4_1(lv_16sc_t* cVector, const lv_8sc_t* aVector, const lv_8sc_t* bVector, unsigned int num_points){
   unsigned int number = 0;
   const unsigned int quarterPoints = num_points / 4;
 
@@ -76,7 +76,7 @@ static inline void volk_8sc_multiply_conjugate_16sc_aligned16_sse4_1(lv_16sc_t*
   \param bVector The complex vector which will be converted to complex conjugate and multiplied
   \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector
 */
-static inline void volk_8sc_multiply_conjugate_16sc_aligned16_generic(lv_16sc_t* cVector, const lv_8sc_t* aVector, const lv_8sc_t* bVector, unsigned int num_points){
+static inline void volk_8sc_8sc_multiply_conjugate_16sc_a16_generic(lv_16sc_t* cVector, const lv_8sc_t* aVector, const lv_8sc_t* bVector, unsigned int num_points){
   unsigned int number = 0;
   int16_t* c16Ptr = (int16_t*)cVector;
   int8_t* a8Ptr = (int8_t*)aVector;
@@ -99,4 +99,4 @@ static inline void volk_8sc_multiply_conjugate_16sc_aligned16_generic(lv_16sc_t*
 
 
 
-#endif /* INCLUDED_VOLK_8sc_MULTIPLY_CONJUGATE_16sc_ALIGNED16_H */
+#endif /* INCLUDED_volk_8sc_8sc_multiply_conjugate_16sc_a16_H */
diff --git a/volk/include/volk/volk_8sc_multiply_conjugate_32fc_aligned16.h b/volk/include/volk/volk_8sc_8sc_s32f_multiply_conjugate_32fc_a16.h
index 52b444cf7e..621276b089 100644
--- a/volk/include/volk/volk_8sc_multiply_conjugate_32fc_aligned16.h
+++ b/volk/include/volk/volk_8sc_8sc_s32f_multiply_conjugate_32fc_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_8sc_MULTIPLY_CONJUGATE_32fc_ALIGNED16_H
-#define INCLUDED_VOLK_8sc_MULTIPLY_CONJUGATE_32fc_ALIGNED16_H
+#ifndef INCLUDED_volk_8sc_8sc_s32f_multiply_conjugate_32fc_a16_H
+#define INCLUDED_volk_8sc_8sc_s32f_multiply_conjugate_32fc_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -14,7 +14,7 @@
   \param bVector The complex vector which will be converted to complex conjugate and multiplied
   \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector
 */
-static inline void volk_8sc_multiply_conjugate_32fc_aligned16_sse4_1(lv_32fc_t* cVector, const lv_8sc_t* aVector, const lv_8sc_t* bVector, const float scalar, unsigned int num_points){
+static inline void volk_8sc_8sc_s32f_multiply_conjugate_32fc_a16_sse4_1(lv_32fc_t* cVector, const lv_8sc_t* aVector, const lv_8sc_t* bVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
   const unsigned int quarterPoints = num_points / 4;
 
@@ -95,7 +95,7 @@ static inline void volk_8sc_multiply_conjugate_32fc_aligned16_sse4_1(lv_32fc_t*
   \param bVector The complex vector which will be converted to complex conjugate and multiplied
   \param num_points The number of complex values in aVector and bVector to be multiplied together and stored into cVector
 */
-static inline void volk_8sc_multiply_conjugate_32fc_aligned16_generic(lv_32fc_t* cVector, const lv_8sc_t* aVector, const lv_8sc_t* bVector, const float scalar, unsigned int num_points){
+static inline void volk_8sc_8sc_s32f_multiply_conjugate_32fc_a16_generic(lv_32fc_t* cVector, const lv_8sc_t* aVector, const lv_8sc_t* bVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
   float* cPtr = (float*)cVector;
   const float invScalar = 1.0 / scalar;
@@ -119,4 +119,4 @@ static inline void volk_8sc_multiply_conjugate_32fc_aligned16_generic(lv_32fc_t*
 
 
 
-#endif /* INCLUDED_VOLK_8sc_MULTIPLY_CONJUGATE_32fc_ALIGNED16_H */
+#endif /* INCLUDED_volk_8sc_8sc_s32f_multiply_conjugate_32fc_a16_H */
diff --git a/volk/include/volk/volk_8sc_deinterleave_16s_aligned16.h b/volk/include/volk/volk_8sc_deinterleave_16s_16s_a16.h
index 38eaa49eab..6a35e969d1 100644
--- a/volk/include/volk/volk_8sc_deinterleave_16s_aligned16.h
+++ b/volk/include/volk/volk_8sc_deinterleave_16s_16s_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_8sc_DEINTERLEAVE_16S_ALIGNED16_H
-#define INCLUDED_VOLK_8sc_DEINTERLEAVE_16S_ALIGNED16_H
+#ifndef INCLUDED_volk_8sc_deinterleave_16s_16s_a16_H
+#define INCLUDED_volk_8sc_deinterleave_16s_16s_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param qBuffer The Q buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_8sc_deinterleave_16s_aligned16_sse4_1(int16_t* iBuffer, int16_t* qBuffer, const lv_8sc_t* complexVector, unsigned int num_points){
+static inline void volk_8sc_deinterleave_16s_16s_a16_sse4_1(int16_t* iBuffer, int16_t* qBuffer, const lv_8sc_t* complexVector, unsigned int num_points){
   unsigned int number = 0;
   const int8_t* complexVectorPtr = (int8_t*)complexVector;
   int16_t* iBufferPtr = iBuffer;
@@ -59,7 +59,7 @@ static inline void volk_8sc_deinterleave_16s_aligned16_sse4_1(int16_t* iBuffer,
   \param qBuffer The Q buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_8sc_deinterleave_16s_aligned16_generic(int16_t* iBuffer, int16_t* qBuffer, const lv_8sc_t* complexVector, unsigned int num_points){
+static inline void volk_8sc_deinterleave_16s_16s_a16_generic(int16_t* iBuffer, int16_t* qBuffer, const lv_8sc_t* complexVector, unsigned int num_points){
   const int8_t* complexVectorPtr = (const int8_t*)complexVector;
   int16_t* iBufferPtr = iBuffer;
   int16_t* qBufferPtr = qBuffer;
@@ -74,4 +74,4 @@ static inline void volk_8sc_deinterleave_16s_aligned16_generic(int16_t* iBuffer,
 
 
 
-#endif /* INCLUDED_VOLK_8sc_DEINTERLEAVE_16S_ALIGNED16_H */
+#endif /* INCLUDED_volk_8sc_deinterleave_16s_16s_a16_H */
diff --git a/volk/include/volk/volk_8sc_deinterleave_real_16s_aligned16.h b/volk/include/volk/volk_8sc_deinterleave_real_16s_a16.h
index d0cb494946..67ffebd992 100644
--- a/volk/include/volk/volk_8sc_deinterleave_real_16s_aligned16.h
+++ b/volk/include/volk/volk_8sc_deinterleave_real_16s_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_8sc_DEINTERLEAVE_REAL_16s_ALIGNED16_H
-#define INCLUDED_VOLK_8sc_DEINTERLEAVE_REAL_16s_ALIGNED16_H
+#ifndef INCLUDED_volk_8sc_deinterleave_real_16s_a16_H
+#define INCLUDED_volk_8sc_deinterleave_real_16s_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -12,7 +12,7 @@
   \param iBuffer The I buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_8sc_deinterleave_real_16s_aligned16_sse4_1(int16_t* iBuffer, const lv_8sc_t* complexVector, unsigned int num_points){
+static inline void volk_8sc_deinterleave_real_16s_a16_sse4_1(int16_t* iBuffer, const lv_8sc_t* complexVector, unsigned int num_points){
   unsigned int number = 0;
   const int8_t* complexVectorPtr = (int8_t*)complexVector;
   int16_t* iBufferPtr = iBuffer;
@@ -49,7 +49,7 @@ static inline void volk_8sc_deinterleave_real_16s_aligned16_sse4_1(int16_t* iBuf
   \param iBuffer The I buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_8sc_deinterleave_real_16s_aligned16_generic(int16_t* iBuffer, const lv_8sc_t* complexVector, unsigned int num_points){
+static inline void volk_8sc_deinterleave_real_16s_a16_generic(int16_t* iBuffer, const lv_8sc_t* complexVector, unsigned int num_points){
   unsigned int number = 0;
   const int8_t* complexVectorPtr = (const int8_t*)complexVector;
   int16_t* iBufferPtr = iBuffer;
@@ -63,4 +63,4 @@ static inline void volk_8sc_deinterleave_real_16s_aligned16_generic(int16_t* iBu
 
 
 
-#endif /* INCLUDED_VOLK_8sc_DEINTERLEAVE_REAL_16s_ALIGNED16_H */
+#endif /* INCLUDED_volk_8sc_deinterleave_real_16s_a16_H */
diff --git a/volk/include/volk/volk_8sc_deinterleave_real_8s_aligned16.h b/volk/include/volk/volk_8sc_deinterleave_real_8s_a16.h
index d84d645682..ecffc092e1 100644
--- a/volk/include/volk/volk_8sc_deinterleave_real_8s_aligned16.h
+++ b/volk/include/volk/volk_8sc_deinterleave_real_8s_a16.h
@@ -12,7 +12,7 @@
   \param iBuffer The I buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_8sc_deinterleave_real_8s_aligned16_ssse3(int8_t* iBuffer, const lv_8sc_t* complexVector, unsigned int num_points){
+static inline void volk_8sc_deinterleave_real_8s_a16_ssse3(int8_t* iBuffer, const lv_8sc_t* complexVector, unsigned int num_points){
   unsigned int number = 0;
   const int8_t* complexVectorPtr = (int8_t*)complexVector;
   int8_t* iBufferPtr = iBuffer;
@@ -50,7 +50,7 @@ static inline void volk_8sc_deinterleave_real_8s_aligned16_ssse3(int8_t* iBuffer
   \param iBuffer The I buffer output data
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_8sc_deinterleave_real_8s_aligned16_generic(int8_t* iBuffer, const lv_8sc_t* complexVector, unsigned int num_points){
+static inline void volk_8sc_deinterleave_real_8s_a16_generic(int8_t* iBuffer, const lv_8sc_t* complexVector, unsigned int num_points){
   unsigned int number = 0;
   const int8_t* complexVectorPtr = (int8_t*)complexVector;
   int8_t* iBufferPtr = iBuffer;
diff --git a/volk/include/volk/volk_8sc_deinterleave_32f_aligned16.h b/volk/include/volk/volk_8sc_s32f_deinterleave_32f_32f_a16.h
index d0c118965f..cedbf202cc 100644
--- a/volk/include/volk/volk_8sc_deinterleave_32f_aligned16.h
+++ b/volk/include/volk/volk_8sc_s32f_deinterleave_32f_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_8sc_DEINTERLEAVE_32F_ALIGNED16_H
-#define INCLUDED_VOLK_8sc_DEINTERLEAVE_32F_ALIGNED16_H
+#ifndef INCLUDED_volk_8sc_s32f_deinterleave_32f_32f_a16_H
+#define INCLUDED_volk_8sc_s32f_deinterleave_32f_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -14,7 +14,7 @@
   \param scalar The scaling value being multiplied against each data point
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_8sc_deinterleave_32f_aligned16_sse4_1(float* iBuffer, float* qBuffer, const lv_8sc_t* complexVector, const float scalar, unsigned int num_points){
+static inline void volk_8sc_s32f_deinterleave_32f_32f_a16_sse4_1(float* iBuffer, float* qBuffer, const lv_8sc_t* complexVector, const float scalar, unsigned int num_points){
   float* iBufferPtr = iBuffer;
   float* qBufferPtr = qBuffer;
 
@@ -84,7 +84,7 @@ static inline void volk_8sc_deinterleave_32f_aligned16_sse4_1(float* iBuffer, fl
   \param scalar The scaling value being multiplied against each data point
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_8sc_deinterleave_32f_aligned16_sse(float* iBuffer, float* qBuffer, const lv_8sc_t* complexVector, const float scalar, unsigned int num_points){
+static inline void volk_8sc_s32f_deinterleave_32f_32f_a16_sse(float* iBuffer, float* qBuffer, const lv_8sc_t* complexVector, const float scalar, unsigned int num_points){
   float* iBufferPtr = iBuffer;
   float* qBufferPtr = qBuffer;
 
@@ -145,7 +145,7 @@ static inline void volk_8sc_deinterleave_32f_aligned16_sse(float* iBuffer, float
   \param scalar The scaling value being multiplied against each data point
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_8sc_deinterleave_32f_aligned16_generic(float* iBuffer, float* qBuffer, const lv_8sc_t* complexVector, const float scalar, unsigned int num_points){
+static inline void volk_8sc_s32f_deinterleave_32f_32f_a16_generic(float* iBuffer, float* qBuffer, const lv_8sc_t* complexVector, const float scalar, unsigned int num_points){
   const int8_t* complexVectorPtr = (const int8_t*)complexVector;
   float* iBufferPtr = iBuffer;
   float* qBufferPtr = qBuffer;
@@ -161,4 +161,4 @@ static inline void volk_8sc_deinterleave_32f_aligned16_generic(float* iBuffer, f
 
 
 
-#endif /* INCLUDED_VOLK_8sc_DEINTERLEAVE_32F_ALIGNED16_H */
+#endif /* INCLUDED_volk_8sc_s32f_deinterleave_32f_32f_a16_H */
diff --git a/volk/include/volk/volk_8sc_deinterleave_real_32f_aligned16.h b/volk/include/volk/volk_8sc_s32f_deinterleave_real_32f_a16.h
index c849448eae..902795131c 100644
--- a/volk/include/volk/volk_8sc_deinterleave_real_32f_aligned16.h
+++ b/volk/include/volk/volk_8sc_s32f_deinterleave_real_32f_a16.h
@@ -1,5 +1,5 @@
-#ifndef INCLUDED_VOLK_8sc_DEINTERLEAVE_REAL_32f_ALIGNED16_H
-#define INCLUDED_VOLK_8sc_DEINTERLEAVE_REAL_32f_ALIGNED16_H
+#ifndef INCLUDED_volk_8sc_s32f_deinterleave_real_32f_a16_H
+#define INCLUDED_volk_8sc_s32f_deinterleave_real_32f_a16_H
 
 #include <inttypes.h>
 #include <stdio.h>
@@ -13,7 +13,7 @@
   \param scalar The scaling value being multiplied against each data point
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_8sc_deinterleave_real_32f_aligned16_sse4_1(float* iBuffer, const lv_8sc_t* complexVector, const float scalar, unsigned int num_points){
+static inline void volk_8sc_s32f_deinterleave_real_32f_a16_sse4_1(float* iBuffer, const lv_8sc_t* complexVector, const float scalar, unsigned int num_points){
   float* iBufferPtr = iBuffer;
 
   unsigned int number = 0;
@@ -70,7 +70,7 @@ static inline void volk_8sc_deinterleave_real_32f_aligned16_sse4_1(float* iBuffe
   \param scalar The scaling value being multiplied against each data point
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_8sc_deinterleave_real_32f_aligned16_sse(float* iBuffer, const lv_8sc_t* complexVector, const float scalar, unsigned int num_points){
+static inline void volk_8sc_s32f_deinterleave_real_32f_a16_sse(float* iBuffer, const lv_8sc_t* complexVector, const float scalar, unsigned int num_points){
   float* iBufferPtr = iBuffer;
 
   unsigned int number = 0;
@@ -115,7 +115,7 @@ static inline void volk_8sc_deinterleave_real_32f_aligned16_sse(float* iBuffer,
   \param scalar The scaling value being multiplied against each data point
   \param num_points The number of complex data values to be deinterleaved
 */
-static inline void volk_8sc_deinterleave_real_32f_aligned16_generic(float* iBuffer, const lv_8sc_t* complexVector, const float scalar, unsigned int num_points){
+static inline void volk_8sc_s32f_deinterleave_real_32f_a16_generic(float* iBuffer, const lv_8sc_t* complexVector, const float scalar, unsigned int num_points){
   unsigned int number = 0;
   const int8_t* complexVectorPtr = (const int8_t*)complexVector;
   float* iBufferPtr = iBuffer;
@@ -130,4 +130,4 @@ static inline void volk_8sc_deinterleave_real_32f_aligned16_generic(float* iBuff
 
 
 
-#endif /* INCLUDED_VOLK_8sc_DEINTERLEAVE_REAL_32f_ALIGNED16_H */
+#endif /* INCLUDED_volk_8sc_s32f_deinterleave_real_32f_a16_H */
diff --git a/volk/include/volk/volk_register.py b/volk/include/volk/volk_register.py
index 9fded9a3ec..fc1ec10ef6 100755
--- a/volk/include/volk/volk_register.py
+++ b/volk/include/volk/volk_register.py
@@ -55,7 +55,7 @@ functions = [];
 
 
 for line in mfile:
-    subline = re.search(".*(aligned).*", line);
+    subline = re.search(".*(a16).*", line);
     if subline:
         subsubline = re.search("(?<=volk_).*", subline.group(0));
         if subsubline:
@@ -70,11 +70,10 @@ datatypes = set(datatypes);
 for line in mfile:
     for dt in datatypes:
         if dt in line:
-            subline = re.search("(volk_" + dt +"_.*(aligned).*\.h)", line);
+            subline = re.search("(volk_" + dt +"_.*(a16).*\.h)", line);
             if subline:
                 
                 subsubline = re.search(".+(?=\.h)", subline.group(0));
-                
                 functions.append(subsubline.group(0));
 
 archs = [];
author	Nick Foster <nick@nerdnetworks.org>	2011-01-16 14:03:16 -0800
committer	Nick Foster <nick@nerdnetworks.org>	2011-01-16 14:03:16 -0800
commit	d486ff4b4c039c8b3b06b6519839d522cf69be69 (patch)
tree	bf9858d509fdc0c49130f2b484cc3f1ddb6c399f /volk/include
parent	5c4aab18e4e5e34ce1f8e286bc534a02c1318932 (diff)