【安富莱DSP教程】第9章 BasicMathFunctions的使用（二）

席萌0209

特别说明：完整45期数字信号处理教程，原创高性能示波器代码全开源地址：链接

第9章 BasicMathFunctions的使用（二）

    本期教程主要讲基本函数中的相反数，偏移，位移，减法和比例因子。
    9.1 相反数（Vector Negate）
    9.2 求和（Vector Offset）
    9.3 点乘（Vector Shift）
    9.4 减法（Vector Sub）
    9.5 比例因子（Vector Scale）
    9.6 BasicMathFunctions的重要说明
    9.7 总结

9.1 相反数（Vector Negate）

    这部分函数主要用于求相反数，公式描述如下：
      pDst[n] = -pSrc[n],   0 <= n < blockSize.   
    特别注意，这部分函数支持目标指针和源指针指向相同的缓冲区。

9.1.1 arm_negate_f32

    这个函数用于求32位浮点数的相反数，源代码分析如下：

1. /**        
2. * @brief  Negates the elements of a floating-point vector.        
3. * @param[in]  *pSrc points to the input vector        
4. * @param[out]  *pDst points to the output vector        
5. * @param[in]  blockSize number of samples in the vector        
6. * @return none.        
7. */
9. void arm_negate_f32(
10.   float32_t * pSrc,
11.   float32_t * pDst,
12.   uint32_t blockSize)
13. {
14.   uint32_t blkCnt;                               /* loop counter */
17. #ifndef ARM_MATH_CM0_FAMILY
19. /* Run the below code for Cortex-M4 and Cortex-M3 */
20.   float32_t in1, in2, in3, in4;                  /* temporary variables */
22.   /*loop Unrolling */
23.   blkCnt = blockSize >> 2u;
25.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.        
26.    ** a second loop below computes the remaining 1 to 3 samples. */
27.   while(blkCnt > 0u)
28.   {
29.     /* read inputs from source */
30.     in1 = *pSrc;
31.     in2 = *(pSrc + 1);
32.     in3 = *(pSrc + 2);
33.     in4 = *(pSrc + 3);
35.     /* negate the input */                                                                            (1)
36.     in1 = -in1;
37.     in2 = -in2;
38.     in3 = -in3;
39.     in4 = -in4;
41.     /* store the result to destination */
42.     *pDst = in1;
43.     *(pDst + 1) = in2;
44.     *(pDst + 2) = in3;
45.     *(pDst + 3) = in4;
47.     /* update pointers to process next samples */
48.     pSrc += 4u;
49.     pDst += 4u;
51.     /* Decrement the loop counter */
52.     blkCnt--;
53.   }
55.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.        
56.    ** No loop unrolling is used. */
57.   blkCnt = blockSize % 0x4u;
59. #else
61.   /* Run the below code for Cortex-M0 */
63.   /* Initialize blkCnt with number of samples */
64.   blkCnt = blockSize;
66. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
68.   while(blkCnt > 0u)
69.   {
70.     /* C = -A */
71.     /* Negate and then store the results in the destination buffer. */
72.     *pDst++ = -*pSrc++;
74.     /* Decrement the loop counter */
75.     blkCnt--;
76.   }
77. }

复制代码

1. 浮点数的相反数求解比较简单，直接在相应的变量前加上负号即可。

9.1.2 arm_negate_q31

    这个函数用于求32位定点数的相反数，源代码分析如下：

1. /**   
2. * @brief  Negates the elements of a Q31 vector.   
3. * @param[in]  *pSrc points to the input vector   
4. * @param[out]  *pDst points to the output vector   
5. * @param[in]  blockSize number of samples in the vector   
6. * @return none.   
7. *   
8. * <b>Scaling and Overflow Behavior:</b>                                                             (1)
9. * \par   
10. * The function uses saturating arithmetic.   
11. * The Q31 value -1 (0x80000000) will be saturated to the maximum allowable positive value 0x7FFFFFFF.   
12. */
14. void arm_negate_q31(
15.   q31_t * pSrc,
16.   q31_t * pDst,
17.   uint32_t blockSize)
18. {
19.   q31_t in;                                      /* Temporary variable */
20.   uint32_t blkCnt;                               /* loop counter */
22. #ifndef ARM_MATH_CM0_FAMILY
24. /* Run the below code for Cortex-M4 and Cortex-M3 */
25.   q31_t in1, in2, in3, in4;
27.   /*loop Unrolling */
28.   blkCnt = blockSize >> 2u;
30.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
31.    ** a second loop below computes the remaining 1 to 3 samples. */
32.   while(blkCnt > 0u)
33.   {
34.     /* C = -A */
35.     /* Negate and then store the results in the destination buffer. */
36.     in1 = *pSrc++;
37.     in2 = *pSrc++;
38.     in3 = *pSrc++;
39.     in4 = *pSrc++;
41.     *pDst++ = __QSUB(0, in1);                                                                      (2)
42.     *pDst++ = __QSUB(0, in2);
43.     *pDst++ = __QSUB(0, in3);
44.     *pDst++ = __QSUB(0, in4);
46.     /* Decrement the loop counter */
47.     blkCnt--;
48.   }
50.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
51.    ** No loop unrolling is used. */
52.   blkCnt = blockSize % 0x4u;
54. #else
56.   /* Run the below code for Cortex-M0 */
58.   /* Initialize blkCnt with number of samples */
59.   blkCnt = blockSize;
61. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
64.   while(blkCnt > 0u)
65.   {
66.     /* C = -A */
67.     /* Negate and then store the result in the destination buffer. */
68.     in = *pSrc++;
69.     *pDst++ = (in == INT32_MIN) ? INT32_MAX : -in;
71.     /* Decrement the loop counter */
72.     blkCnt--;
73.   }
74. }

复制代码

1. 这个函数使用了饱和运算。
    饱和运算数值0x80000000将变成0x7FFFFFFF。
2. 饱和运算__QSUB我们在上一章已经详细讲述了，这就就是实现数值0减去相应的参数变量。

9.1.3 arm_negate_q15

    这个函数用于求16位定点数的相反数，源代码分析如下：

1. /**        
2. * @brief  Negates the elements of a Q15 vector.        
3. * @param[in]  *pSrc points to the input vector        
4. * @param[out]  *pDst points to the output vector        
5. * @param[in]  blockSize number of samples in the vector        
6. * @return none.        
7. *   
8. * \par Conditions for optimum performance   
9. *  Input and output buffers should be aligned by 32-bit   
10. *   
11. *        
12. * <b>Scaling and Overflow Behavior:</b>                                                             (1)
13. * \par        
14. * The function uses saturating arithmetic.        
15. * The Q15 value -1 (0x8000) will be saturated to the maximum allowable positive value 0x7FFF.        
16. */
18. void arm_negate_q15(
19.   q15_t * pSrc,
20.   q15_t * pDst,
21.   uint32_t blockSize)
22. {
23.   uint32_t blkCnt;                               /* loop counter */
24.   q15_t in;
26. #ifndef ARM_MATH_CM0_FAMILY
28. /* Run the below code for Cortex-M4 and Cortex-M3 */
30.   q31_t in1, in2;                                /* Temporary variables */
33.   /*loop Unrolling */
34.   blkCnt = blockSize >> 2u;
36.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.        
37.    ** a second loop below computes the remaining 1 to 3 samples. */
38.   while(blkCnt > 0u)
39.   {
40.     /* C = -A */
41.     /* Read two inputs at a time */                                                                  (2)
42.     in1 = _SIMD32_OFFSET(pSrc);
43.     in2 = _SIMD32_OFFSET(pSrc + 2);
45.     /* negate two samples at a time */                                                               (3)
46.     in1 = __QSUB16(0, in1);
48.     /* negate two samples at a time */
49.     in2 = __QSUB16(0, in2);
51.     /* store the result to destination 2 samples at a time */                                        (4)
52.     _SIMD32_OFFSET(pDst) = in1;
53.     /* store the result to destination 2 samples at a time */
54.     _SIMD32_OFFSET(pDst + 2) = in2;
57.     /* update pointers to process next samples */
58.     pSrc += 4u;
59.     pDst += 4u;
61.     /* Decrement the loop counter */
62.     blkCnt--;
63.   }
65.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.        
66.    ** No loop unrolling is used. */
67.   blkCnt = blockSize % 0x4u;
69. #else
71.   /* Run the below code for Cortex-M0 */
73.   /* Initialize blkCnt with number of samples */
74.   blkCnt = blockSize;
76. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
78.   while(blkCnt > 0u)
79.   {
80.     /* C = -A */
81.     /* Negate and then store the result in the destination buffer. */
82.     in = *pSrc++;
83.     *pDst++ = (in == (q15_t) 0x8000) ? 0x7fff : -in;
85.     /* Decrement the loop counter */
86.     blkCnt--;
87.   }
88. }

复制代码

1. 这个函数使用了饱和运算。
    饱和运算数值0x8000将变成0x7FFF。
2. 一次读取两个Q15格式的数据。
3. 由于__QSUB是SIMD指令，这里可以实现一次计算两个Q15数据的相反数。
4. 这里实现一次赋值两个Q15数据。

9.1.4 arm_negate_q7

    这个函数用于求8位定点数的相反数，源代码分析如下：

1. /**   
2. * @brief  Negates the elements of a Q7 vector.   
3. * @param[in]  *pSrc points to the input vector   
4. * @param[out]  *pDst points to the output vector   
5. * @param[in]  blockSize number of samples in the vector   
6. * @return none.   
7. *   
8. * <b>Scaling and Overflow Behavior:</b>                                                              (1)
9. * \par   
10. * The function uses saturating arithmetic.   
11. * The Q7 value -1 (0x80) will be saturated to the maximum allowable positive value 0x7F.   
12. */
14. void arm_negate_q7(
15.   q7_t * pSrc,
16.   q7_t * pDst,
17.   uint32_t blockSize)
18. {
19.   uint32_t blkCnt;                               /* loop counter */
20.   q7_t in;
22. #ifndef ARM_MATH_CM0_FAMILY
24. /* Run the below code for Cortex-M4 and Cortex-M3 */
25.   q31_t input;                                   /* Input values1-4 */
26.   q31_t zero = 0x00000000;                                                                           (2)
29.   /*loop Unrolling */
30.   blkCnt = blockSize >> 2u;
32.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
33.    ** a second loop below computes the remaining 1 to 3 samples. */
34.   while(blkCnt > 0u)
35.   {
36.     /* C = -A */
37.     /* Read four inputs */
38.     input = *__SIMD32(pSrc)++;                                                                        (3)
40.     /* Store the Negated results in the destination buffer in a single cycle by packing the results */
41.     *__SIMD32(pDst)++ = __QSUB8(zero, input);                                                         (4)
43.     /* Decrement the loop counter */
44.     blkCnt--;
45.   }
47.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
48.    ** No loop unrolling is used. */
49.   blkCnt = blockSize % 0x4u;
51. #else
53.   /* Run the below code for Cortex-M0 */
55.   /* Initialize blkCnt with number of samples */
56.   blkCnt = blockSize;
58. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
60.   while(blkCnt > 0u)
61.   {
62.     /* C = -A */
63.     /* Negate and then store the results in the destination buffer. */ \
64.       in = *pSrc++;
65.     *pDst++ = (in == (q7_t) 0x80) ? 0x7f : -in;
67.     /* Decrement the loop counter */
68.     blkCnt--;
69.   }
70. }

复制代码

1. 这个函数使用了饱和运算。
    饱和运算数值0x80将变成0x7F。
2. 给局部变量赋初值，防止默认初始值不是0，所以从某种意义上来说，给变量赋初值是很有必要的。
3. 一次读取4个Q7格式的数据到input里面。
4. 通过__QSUB8实现一次计算四个Q7格式数据的相反数。

9.1.5 实例讲解

实验目的：
    1. 四种类型数据的相反数。
实验内容：
    1. 按下K1键, 串口打印输出结果
实验现象：
    通过窗口上位机软件SecureCRT（V5光盘里面有此软件）查看打印信息现象如下：

程序设计：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: DSP_Negate
4. *    功能说明: 求相反数
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void DSP_Negate(void)
10. {
11. static float32_t pSrc;
12.     static float32_t pDst;
13. static q31_t pSrc1;
14. static q31_t pDst1;
15. static q15_t pSrc2;
16. static q15_t pDst2;
17. static q7_t pSrc3 = 127; /* 为了说明问题，在这里设置初始值为127，然后查看0x80是否饱和为0x7F */
18. static q7_t pDst3;
19. pSrc -= 1.23f;
20. arm_negate_f32(&pSrc, &pDst, 1);
21. printf("arm_negate_f32 = %f\r\n", pDst);
23. pSrc1 -= 1;
24. arm_negate_q31(&pSrc1, &pDst1, 1);
25. printf("arm_negate_q31 = %d\r\n", pDst1);
27. pSrc2 -= 1;
28. arm_negate_q15(&pSrc2, &pDst2, 1);
29. printf("arm_negate_q15 = %d\r\n", pDst2);
31. pSrc3 += 1;
32. arm_negate_q7(&pSrc3, &pDst3, 1);
33. printf("arm_negate_q7 = %d\r\n", pDst3);
34. printf("***********************************\r\n");
35. }

复制代码

席萌0209

9.2 偏移（Vector Offset）

    这部分函数主要用于求相反数，公式描述如下：
     pDst[n] = pSrc[n] + offset,   0 <= n < blockSize.
        注意，这部分函数支持目标指针和源指针指向相同的缓冲区。

9.2.1 arm_offset_f32

    这个函数用于求32位浮点数的偏移，源代码分析如下：

1. /**        
2. * @brief  Adds a constant offset to a floating-point vector.        
3. * @param[in]  *pSrc points to the input vector        
4. * @param[in]  offset is the offset to be added        
5. * @param[out]  *pDst points to the output vector        
6. * @param[in]  blockSize number of samples in the vector        
7. * @return none.        
8. */
9. void arm_offset_f32(
10.   float32_t * pSrc,
11.   float32_t offset,
12.   float32_t * pDst,
13.   uint32_t blockSize)
14. {
15.   uint32_t blkCnt;                               /* loop counter */
17. #ifndef ARM_MATH_CM0_FAMILY
19. /* Run the below code for Cortex-M4 and Cortex-M3 */
20.   float32_t in1, in2, in3, in4;
22.   /*loop Unrolling */
23.   blkCnt = blockSize >> 2u;
25.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.        
26.    ** a second loop below computes the remaining 1 to 3 samples. */
27.   while(blkCnt > 0u)
28.   {
29.     /* C = A + offset */                                                                            (1)
30.     /* Add offset and then store the results in the destination buffer. */
31.     /* read samples from source */
32.     in1 = *pSrc;
33.     in2 = *(pSrc + 1);
35.     /* add offset to input */
36.     in1 = in1 + offset;
38.     /* read samples from source */
39.     in3 = *(pSrc + 2);
41.     /* add offset to input */
42.     in2 = in2 + offset;
44.     /* read samples from source */
45.     in4 = *(pSrc + 3);
47.     /* add offset to input */
48.     in3 = in3 + offset;
50.     /* store result to destination */
51.     *pDst = in1;
53.     /* add offset to input */
54.     in4 = in4 + offset;
56.     /* store result to destination */
57.     *(pDst + 1) = in2;
59.     /* store result to destination */
60.     *(pDst + 2) = in3;
62.     /* store result to destination */
63.     *(pDst + 3) = in4;
65.     /* update pointers to process next samples */
66.     pSrc += 4u;
67.     pDst += 4u;
69.     /* Decrement the loop counter */
70.     blkCnt--;
71.   }
73.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.        
74.    ** No loop unrolling is used. */
75.   blkCnt = blockSize % 0x4u;
77. #else
79.   /* Run the below code for Cortex-M0 */
81.   /* Initialize blkCnt with number of samples */
82.   blkCnt = blockSize;
84. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
86.   while(blkCnt > 0u)
87.   {
88.     /* C = A + offset */
89.     /* Add offset and then store the result in the destination buffer. */
90.     *pDst++ = (*pSrc++) + offset;
92.     /* Decrement the loop counter */
93.     blkCnt--;
94.   }
95. }

复制代码

1. 浮点数的偏移值求解比较简单，加上相应的偏移值并赋值给目标变量即可。

9.2.2 arm_offset_q31

    这个函数用于求32位定点数的偏移值，源代码分析如下：

1. /**   
2. * @brief  Adds a constant offset to a Q31 vector.   
3. * @param[in]  *pSrc points to the input vector   
4. * @param[in]  offset is the offset to be added   
5. * @param[out]  *pDst points to the output vector   
6. * @param[in]  blockSize number of samples in the vector   
7. * @return none.   
8. *   
9. * <b>Scaling and Overflow Behavior:</b>                                                               (1)
10. * par   
11. * The function uses saturating arithmetic.   
12. * Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] are saturated.   
13. */
15. void arm_offset_q31(
16.   q31_t * pSrc,
17.   q31_t offset,
18.   q31_t * pDst,
19.   uint32_t blockSize)
20. {
21.   uint32_t blkCnt;                               /* loop counter */
23. #ifndef ARM_MATH_CM0_FAMILY
25. /* Run the below code for Cortex-M4 and Cortex-M3 */
26.   q31_t in1, in2, in3, in4;
29.   /*loop Unrolling */
30.   blkCnt = blockSize >> 2u;
32.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
33.    ** a second loop below computes the remaining 1 to 3 samples. */
34.   while(blkCnt > 0u)
35.   {
36.     /* C = A + offset */
37.     /* Add offset and then store the results in the destination buffer. */
38.     in1 = *pSrc++;
39.     in2 = *pSrc++;
40.     in3 = *pSrc++;
41.     in4 = *pSrc++;
43.     *pDst++ = __QADD(in1, offset);                                                                   (2)
44.     *pDst++ = __QADD(in2, offset);
45.     *pDst++ = __QADD(in3, offset);
46.     *pDst++ = __QADD(in4, offset);
48.     /* Decrement the loop counter */
49.     blkCnt--;
50.   }
52.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
53.    ** No loop unrolling is used. */
54.   blkCnt = blockSize % 0x4u;
56.   while(blkCnt > 0u)
57.   {
58.     /* C = A + offset */
59.     /* Add offset and then store the result in the destination buffer. */
60.     *pDst++ = __QADD(*pSrc++, offset);
62.     /* Decrement the loop counter */
63.     blkCnt--;
64.   }
66. #else
68.   /* Run the below code for Cortex-M0 */
70.   /* Initialize blkCnt with number of samples */
71.   blkCnt = blockSize;
73.   while(blkCnt > 0u)
74.   {
75.     /* C = A + offset */
76.     /* Add offset and then store the result in the destination buffer. */
77.     *pDst++ = (q31_t) clip_q63_to_q31((q63_t) * pSrc++ + offset);
79.     /* Decrement the loop counter */
80.     blkCnt--;
81.   }
83. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
85. }

复制代码

1. 这个函数使用了饱和运算。
    饱和运算数值0x80000000将变成0x7FFFFFFF。
2. 指令__QADD我们在上章教程中已经讲解过，这里是实现两个参数相加。

9.2.3 arm_offset_q15

    这个函数用于求16位定点数的偏移，源代码分析如下：

1. /**   
2. * @brief  Adds a constant offset to a Q15 vector.   
3. * @param[in]  *pSrc points to the input vector   
4. * @param[in]  offset is the offset to be added   
5. * @param[out]  *pDst points to the output vector   
6. * @param[in]  blockSize number of samples in the vector   
7. * @return none.   
8. *   
9. * <b>Scaling and Overflow Behavior:</b>                                                             (1)
10. * par   
11. * The function uses saturating arithmetic.   
12. * Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated.   
13. */
15. void arm_offset_q15(
16.   q15_t * pSrc,
17.   q15_t offset,
18.   q15_t * pDst,
19.   uint32_t blockSize)
20. {
21.   uint32_t blkCnt;                               /* loop counter */
23. #ifndef ARM_MATH_CM0_FAMILY
25. /* Run the below code for Cortex-M4 and Cortex-M3 */
26.   q31_t offset_packed;                           /* Offset packed to 32 bit */
29.   /*loop Unrolling */
30.   blkCnt = blockSize >> 2u;
32.   /* Offset is packed to 32 bit in order to use SIMD32 for addition */
33.   offset_packed = __PKHBT(offset, offset, 16);                                                       (2)
35.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
36.    ** a second loop below computes the remaining 1 to 3 samples. */
37.   while(blkCnt > 0u)
38.   {
39.     /* C = A + offset */
40.     /* Add offset and then store the results in the destination buffer, 2 samples at a time. */
41.     *__SIMD32(pDst)++ = __QADD16(*__SIMD32(pSrc)++, offset_packed);                                  (3)
42.     *__SIMD32(pDst)++ = __QADD16(*__SIMD32(pSrc)++, offset_packed);
44.     /* Decrement the loop counter */
45.     blkCnt--;
46.   }
48.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
49.    ** No loop unrolling is used. */
50.   blkCnt = blockSize % 0x4u;
52.   while(blkCnt > 0u)
53.   {
54.     /* C = A + offset */
55.     /* Add offset and then store the results in the destination buffer. */
56.     *pDst++ = (q15_t) __QADD16(*pSrc++, offset);
58.     /* Decrement the loop counter */
59.     blkCnt--;
60.   }
62. #else
64.   /* Run the below code for Cortex-M0 */
66.   /* Initialize blkCnt with number of samples */
67.   blkCnt = blockSize;
69.   while(blkCnt > 0u)
70.   {
71.     /* C = A + offset */
72.     /* Add offset and then store the results in the destination buffer. */
73.     *pDst++ = (q15_t) __SSAT(((q31_t) * pSrc++ + offset), 16);
75.     /* Decrement the loop counter */
76.     blkCnt--;
77.   }
79. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
81. }

复制代码

1. 这个函数使用了饱和运算。
    饱和运算数值0x8000将变成0x7FFF。
2. 将两个Q15格式的变量合并成一个Q31格式的数据，方便指令__QADD16的调用。
3. 由于__QADD16是SIMD指令，这里调用一次就能实现两个Q15格式数据的计算。

9.2.4 arm_offset_q7

    这个函数用于求8位定点数的偏移，源代码分析如下：

1. /**   
2. * @brief  Adds a constant offset to a Q7 vector.   
3. * @param[in]  *pSrc points to the input vector   
4. * @param[in]  offset is the offset to be added   
5. * @param[out]  *pDst points to the output vector   
6. * @param[in]  blockSize number of samples in the vector   
7. * @return none.   
8. *   
9. * <b>Scaling and Overflow Behavior:</b>                                                              (1)
10. * par   
11. * The function uses saturating arithmetic.   
12. * Results outside of the allowable Q7 range [0x80 0x7F] are saturated.   
13. */
15. void arm_offset_q7(
16.   q7_t * pSrc,
17.   q7_t offset,
18.   q7_t * pDst,
19.   uint32_t blockSize)
20. {
21.   uint32_t blkCnt;                               /* loop counter */
23. #ifndef ARM_MATH_CM0_FAMILY
25. /* Run the below code for Cortex-M4 and Cortex-M3 */
26.   q31_t offset_packed;                           /* Offset packed to 32 bit */
29.   /*loop Unrolling */
30.   blkCnt = blockSize >> 2u;
32.   /* Offset is packed to 32 bit in order to use SIMD32 for addition */                               (2)
33.   offset_packed = __PACKq7(offset, offset, offset, offset);
35.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
36.    ** a second loop below computes the remaining 1 to 3 samples. */
37.   while(blkCnt > 0u)
38.   {
39.     /* C = A + offset */
40.     /* Add offset and then store the results in the destination bufferfor 4 samples at a time. */
41.     *__SIMD32(pDst)++ = __QADD8(*__SIMD32(pSrc)++, offset_packed);                                   (3)
43.     /* Decrement the loop counter */
44.     blkCnt--;
45.   }
47.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
48.    ** No loop unrolling is used. */
49.   blkCnt = blockSize % 0x4u;
51.   while(blkCnt > 0u)
52.   {
53.     /* C = A + offset */
54.     /* Add offset and then store the result in the destination buffer. */
55.     *pDst++ = (q7_t) __SSAT(*pSrc++ + offset, 8);
57.     /* Decrement the loop counter */
58.     blkCnt--;
59.   }
61. #else
63.   /* Run the below code for Cortex-M0 */
65.   /* Initialize blkCnt with number of samples */
66.   blkCnt = blockSize;
68.   while(blkCnt > 0u)
69.   {
70.     /* C = A + offset */
71.     /* Add offset and then store the result in the destination buffer. */
72.     *pDst++ = (q7_t) __SSAT((q15_t) * pSrc++ + offset, 8);
74.     /* Decrement the loop counter */
75.     blkCnt--;
76.   }
78. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
80. }

复制代码

1. 这个函数使用了饱和运算。
    饱和运算数值0x80将变成0x7F。
2. 通过__PACKq7将4个Q7格式的数据合并成一个Q31格式的数据。
3. 由于__QADD8是SIMD指令，这里调用一次就能实现四个Q8格式数据的计算。

9.2.5 实例讲解

实验目的：
    1. 四种类型数据的相反数。
实验内容：
    1. 按下K2键, 串口打印输出结果
实验现象：
    通过窗口上位机软件SecureCRT（V5光盘里面有此软件）查看打印信息现象如下：

程序设计：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: DSP_Offset
4. *    功能说明: 偏移
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void DSP_Offset(void)
10. {
11. static float32_t   pSrcA;
12. static float32_t   Offset = 0.0f;  
13. static float32_t   pDst;  
14. static q31_t  pSrcA1;  
15. static q31_t  Offset1 = 0;  
16. static q31_t  pDst1;  
18. static q15_t  pSrcA2;  
19. static q15_t  Offset2 = 0;  
20. static q15_t  pDst2;
22. static q7_t  pSrcA3;
23. static q7_t  Offset3 = 0;  
24. static q7_t  pDst3;  
26. Offset--;
27. arm_offset_f32(&pSrcA, Offset, &pDst, 1);
28. printf("arm_add_f32 = %frn", pDst);
30. Offset1--;
31. arm_offset_q31(&pSrcA1, Offset1, &pDst1, 1);
32. printf("arm_add_q31 = %drn", pDst1);
34. Offset2--;
35. arm_offset_q15(&pSrcA2, Offset2, &pDst2, 1);
36. printf("arm_add_q15 = %drn", pDst2);
38. Offset3--;
39. arm_offset_q7(&pSrcA3, Offset3, &pDst3, 1);
40. printf("arm_add_q7 = %drn", pDst3);
41. printf("***********************************rn");
42. }

复制代码

席萌0209

9.3 位移（Vector Shift）

    这部分函数主要用于实现位移，公式描述如下：
     pDst[n] = pSrc[n] << shift,   0 <= n < blockSize.  
    注意，这部分函数支持目标指针和源指针指向相同的缓冲区。

9.3.1 arm_shift_q31

    这个函数用于求32位定点数的位移，源代码分析如下：

1. /**        
2. * @brief  Shifts the elements of a Q31 vector a specified number of bits.        
3. * @param[in]  *pSrc points to the input vector        
4. * @param[in]  shiftBits number of bits to shift.  
5. *              A positive value shifts left; a negative value shifts right.                           (1)
6. * @param[out]  *pDst points to the output vector        
7. * @param[in]  blockSize number of samples in the vector        
8. * @return none.        
9. *        
10. *        
11. * <b>Scaling and Overflow Behavior:</b>                                                              (2)
12. * par        
13. * The function uses saturating arithmetic.        
14. * Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] will be saturated.        
15. */
17. void arm_shift_q31(
18.   q31_t * pSrc,
19.   int8_t shiftBits,
20.   q31_t * pDst,
21.   uint32_t blockSize)
22. {
23.   uint32_t blkCnt;                               /* loop counter */
24.   uint8_t sign = (shiftBits & 0x80);             /* Sign of shiftBits */                              (3)
26. #ifndef ARM_MATH_CM0_FAMILY
28.   q31_t in1, in2, in3, in4;                      /* Temporary input variables */
29.   q31_t out1, out2, out3, out4;                  /* Temporary output variables */
31.   /*loop Unrolling */
32.   blkCnt = blockSize >> 2u;
35.   if(sign == 0u)                                                                                     (4)
36.   {
37.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
38.      ** a second loop below computes the remaining 1 to 3 samples. */
39.     while(blkCnt > 0u)
40.     {
41.       /* C = A  << shiftBits */
42.       /* Shift the input and then store the results in the destination buffer. */
43.       in1 = *pSrc;
44.       in2 = *(pSrc + 1);
45.       out1 = in1 << shiftBits;
46.       in3 = *(pSrc + 2);
47.       out2 = in2 << shiftBits;
48.       in4 = *(pSrc + 3);
49.       if(in1 != (out1 >> shiftBits))                                                                (5)
50.         out1 = 0x7FFFFFFF ^ (in1 >> 31);
52.       if(in2 != (out2 >> shiftBits))
53.         out2 = 0x7FFFFFFF ^ (in2 >> 31);
55.       *pDst = out1;
56.       out3 = in3 << shiftBits;
57.       *(pDst + 1) = out2;
58.       out4 = in4 << shiftBits;
60.       if(in3 != (out3 >> shiftBits))
61.         out3 = 0x7FFFFFFF ^ (in3 >> 31);
63.       if(in4 != (out4 >> shiftBits))
64.         out4 = 0x7FFFFFFF ^ (in4 >> 31);
66.       *(pDst + 2) = out3;
67.       *(pDst + 3) = out4;
69.       /* Update destination pointer to process next sampels */
70.       pSrc += 4u;
71.       pDst += 4u;
73.       /* Decrement the loop counter */
74.       blkCnt--;
75.     }
76.   }
77.   else                                                                                              (6)
78.   {
80.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
81.      ** a second loop below computes the remaining 1 to 3 samples. */
82.     while(blkCnt > 0u)
83.     {
84.       /* C = A >>  shiftBits */
85.       /* Shift the input and then store the results in the destination buffer. */
86.       in1 = *pSrc;
87.       in2 = *(pSrc + 1);
88.       in3 = *(pSrc + 2);
89.       in4 = *(pSrc + 3);
91.       *pDst = (in1 >> -shiftBits);                                                                  (7)
92.       *(pDst + 1) = (in2 >> -shiftBits);
93.       *(pDst + 2) = (in3 >> -shiftBits);
94.       *(pDst + 3) = (in4 >> -shiftBits);
97.       pSrc += 4u;
98.       pDst += 4u;
100.       blkCnt--;
101.     }
103.   }
105.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
106.    ** No loop unrolling is used. */
107.   blkCnt = blockSize % 0x4u;
109. #else
111.   /* Run the below code for Cortex-M0 */
114.   /* Initialize blkCnt with number of samples */
115.   blkCnt = blockSize;
117. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
120.   while(blkCnt > 0u)
121.   {
122.     /* C = A (>> or <<) shiftBits */
123.     /* Shift the input and then store the result in the destination buffer. */                       (8)
124.     *pDst++ = (sign == 0u) ? clip_q63_to_q31((q63_t) * pSrc++ << shiftBits) :
125.       (*pSrc++ >> -shiftBits);
127.     /* Decrement the loop counter */
128.     blkCnt--;
129.   }
132. }

复制代码

1. 如果函数的参数shiftBits是正数那么表示左移，如果参数shiftBits是负数那么就是右移。
2. 这个函数使用了饱和运算。
    饱和运算数值0x80000000将变成0x7FFFFFFF。
3. 获取偏移值shiftBits是正数还是负数。
4. 如果移位值是正数，那么就是左移。
5. 数值的左移仅支持将其左移后再右移相应的位数后数值不变的情况，如果不满足这个条件，那么输出结果只有两种结果（这里就是实现输出结果的饱和运算）。
     out = 0x7FFFFFFF & 0xFFFFFFFF =0x80000000
     out = 0x7FFFFFFF & 0x0000000 =0x7FFFFFFF
6. 如果移位值是负数，那么就是右移。
7. 将偏移值取反然后左移即可。
8. 用于实现剩余数值偏移的计算。

9.3.2 arm_shift_q15

    这个函数用于求16位定点数的位移，源代码分析如下：

1. /**   
2. * @brief  Shifts the elements of a Q15 vector a specified number of bits.   
3. * @param[in]  *pSrc points to the input vector   
4. * @param[in]  shiftBits number of bits to shift.  
5. *            A positive value shifts left; a negative value shifts right.                           (1)
6. * @param[out]  *pDst points to the output vector   
7. * @param[in]  blockSize number of samples in the vector   
8. * @return none.   
9. *   
10. * <b>Scaling and Overflow Behavior:</b>                                                             (2)
11. * par   
12. * The function uses saturating arithmetic.   
13. * Results outside of the allowable Q15 range [0x8000 0x7FFF] will be saturated.   
14. */
16. void arm_shift_q15(
17.   q15_t * pSrc,
18.   int8_t shiftBits,
19.   q15_t * pDst,
20.   uint32_t blockSize)
21. {
22.   uint32_t blkCnt;                               /* loop counter */
23.   uint8_t sign;                                  /* Sign of shiftBits */
25. #ifndef ARM_MATH_CM0_FAMILY
27. /* Run the below code for Cortex-M4 and Cortex-M3 */
29.   q15_t in1, in2;                                /* Temporary variables */
32.   /*loop Unrolling */
33.   blkCnt = blockSize >> 2u;
35.   /* Getting the sign of shiftBits */
36.   sign = (shiftBits & 0x80);                                                                        (3)
38.   /* If the shift value is positive then do right shift else left shift */
39.   if(sign == 0u)
40.   {
41.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
42.      ** a second loop below computes the remaining 1 to 3 samples. */
43.     while(blkCnt > 0u)
44.     {
45.       /* Read 2 inputs */
46.       in1 = *pSrc++;
47.       in2 = *pSrc++;
48.       /* C = A << shiftBits */
49.       /* Shift the inputs and then store the results in the destination buffer. */
50. #ifndef  ARM_MATH_BIG_ENDIAN
52.       *__SIMD32(pDst)++ = __PKHBT(__SSAT((in1 << shiftBits), 16),
53.                                   __SSAT((in2 << shiftBits), 16), 16);
55. #else
57.       *__SIMD32(pDst)++ = __PKHBT(__SSAT((in2 << shiftBits), 16),                                   (4)
58.                                   __SSAT((in1 << shiftBits), 16), 16);
60. #endif /* #ifndef  ARM_MATH_BIG_ENDIAN    */
62.       in1 = *pSrc++;
63.       in2 = *pSrc++;
65. #ifndef  ARM_MATH_BIG_ENDIAN
67.       *__SIMD32(pDst)++ = __PKHBT(__SSAT((in1 << shiftBits), 16),
68.                                   __SSAT((in2 << shiftBits), 16), 16);
70. #else
72.       *__SIMD32(pDst)++ = __PKHBT(__SSAT((in2 << shiftBits), 16),                                 
73.                                   __SSAT((in1 << shiftBits), 16), 16);
75. #endif /* #ifndef  ARM_MATH_BIG_ENDIAN    */
77.       /* Decrement the loop counter */
78.       blkCnt--;
79.     }
81.     /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
82.      ** No loop unrolling is used. */
83.     blkCnt = blockSize % 0x4u;
85.     while(blkCnt > 0u)
86.     {
87.       /* C = A << shiftBits */
88.       /* Shift and then store the results in the destination buffer. */
89.       *pDst++ = __SSAT((*pSrc++ << shiftBits), 16);                                                 (5)
91.       /* Decrement the loop counter */
92.       blkCnt--;
93.     }
94.   }
95.   else                                                                                              (6)
96.   {
97.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
98.      ** a second loop below computes the remaining 1 to 3 samples. */
99.     while(blkCnt > 0u)
100.     {
101.       /* Read 2 inputs */
102.       in1 = *pSrc++;
103.       in2 = *pSrc++;
105.       /* C = A >> shiftBits */
106.       /* Shift the inputs and then store the results in the destination buffer. */
107. #ifndef  ARM_MATH_BIG_ENDIAN
109.       *__SIMD32(pDst)++ = __PKHBT((in1 >> -shiftBits),
110.                                   (in2 >> -shiftBits), 16);
112. #else
114.       *__SIMD32(pDst)++ = __PKHBT((in2 >> -shiftBits),                                              (7)
115.                                   (in1 >> -shiftBits), 16);
117. #endif /* #ifndef  ARM_MATH_BIG_ENDIAN    */
119.       in1 = *pSrc++;
120.       in2 = *pSrc++;
122. #ifndef  ARM_MATH_BIG_ENDIAN
124.       *__SIMD32(pDst)++ = __PKHBT((in1 >> -shiftBits),
125.                                   (in2 >> -shiftBits), 16);
127. #else
129.       *__SIMD32(pDst)++ = __PKHBT((in2 >> -shiftBits),                                             
130.                                   (in1 >> -shiftBits), 16);
132. #endif /* #ifndef  ARM_MATH_BIG_ENDIAN    */
134.       /* Decrement the loop counter */
135.       blkCnt--;
136.     }
138.     /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
139.      ** No loop unrolling is used. */
140.     blkCnt = blockSize % 0x4u;
142.     while(blkCnt > 0u)
143.     {
144.       /* C = A >> shiftBits */
145.       /* Shift the inputs and then store the results in the destination buffer. */
146.       *pDst++ = (*pSrc++ >> -shiftBits);
148.       /* Decrement the loop counter */
149.       blkCnt--;
150.     }
151.   }
153. #else
155.   /* Run the below code for Cortex-M0 */
157.   /* Getting the sign of shiftBits */
158.   sign = (shiftBits & 0x80);
160.   /* If the shift value is positive then do right shift else left shift */
161.   if(sign == 0u)
162.   {
163.     /* Initialize blkCnt with number of samples */
164.     blkCnt = blockSize;
166.     while(blkCnt > 0u)
167.     {
168.       /* C = A << shiftBits */
169.       /* Shift and then store the results in the destination buffer. */
170.       *pDst++ = __SSAT(((q31_t) * pSrc++ << shiftBits), 16);
172.       /* Decrement the loop counter */
173.       blkCnt--;
174.     }
175.   }
176.   else
177.   {
178.     /* Initialize blkCnt with number of samples */
179.     blkCnt = blockSize;
181.     while(blkCnt > 0u)
182.     {
183.       /* C = A >> shiftBits */
184.       /* Shift the inputs and then store the results in the destination buffer. */
185.       *pDst++ = (*pSrc++ >> -shiftBits);
187.       /* Decrement the loop counter */
188.       blkCnt--;
189.     }
190.   }
192. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
194. }

复制代码

1. 如果函数的参数shiftBits是正数那么表示左移，如果参数shiftBits是负数那么就是右移。
2. 这个函数使用了饱和运算。
    饱和运算数值0x8000将变成0x7FFF。
3. 获取偏移值是正数还是负数。
4. 通过调用一次__PKHBT实现两个Q15格式数据的计算。
5. 剩余几个数值的计算。
6. 如果位移值为负数，那么就是右移。
7. 将位移值取反以后，通过调用一次__PKHBT实现两个Q15格式数据的计算。

9.3.3 arm_shift_q7

    这个函数用于求8位定点数的位移，源代码分析如下：

1. /**        
2. * @brief  Shifts the elements of a Q7 vector a specified number of bits.        
3. * @param[in]  *pSrc points to the input vector        
4. * @param[in]  shiftBits number of bits to shift.  
5. *             A positive value shifts left; a negative value shifts right.                          (1)
6. * @param[out]  *pDst points to the output vector        
7. * @param[in]  blockSize number of samples in the vector        
8. * @return none.        
9. *   
10. * par Conditions for optimum performance   
11. *  Input and output buffers should be aligned by 32-bit   
12. *   
13. *        
14. * <b>Scaling and Overflow Behavior:</b>                                                             (2)
15. * par        
16. * The function uses saturating arithmetic.        
17. * Results outside of the allowable Q7 range [0x8 0x7F] will be saturated.        
18. */
20. void arm_shift_q7(
21.   q7_t * pSrc,
22.   int8_t shiftBits,
23.   q7_t * pDst,
24.   uint32_t blockSize)
25. {
26.   uint32_t blkCnt;                               /* loop counter */
27.   uint8_t sign;                                  /* Sign of shiftBits */
29. #ifndef ARM_MATH_CM0_FAMILY
31. /* Run the below code for Cortex-M4 and Cortex-M3 */
32.   q7_t in1;                                      /* Input value1 */
33.   q7_t in2;                                      /* Input value2 */
34.   q7_t in3;                                      /* Input value3 */
35.   q7_t in4;                                      /* Input value4 */
38.   /*loop Unrolling */
39.   blkCnt = blockSize >> 2u;
41.   /* Getting the sign of shiftBits */
42.   sign = (shiftBits & 0x80);                                                                         (3)
44.   /* If the shift value is positive then do right shift else left shift */
45.   if(sign == 0u)
46.   {
47.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
48.      ** a second loop below computes the remaining 1 to 3 samples. */
49.     while(blkCnt > 0u)
50.     {
51.       /* C = A << shiftBits */
52.       /* Read 4 inputs */
53.       in1 = *pSrc;
54.       in2 = *(pSrc + 1);
55.       in3 = *(pSrc + 2);
56.       in4 = *(pSrc + 3);
57.                                                                                                      (4)
58.       /* Store the Shifted result in the destination buffer in single cycle by packing the outputs */
59.       *__SIMD32(pDst)++ = __PACKq7(__SSAT((in1 << shiftBits), 8),
60.                                    __SSAT((in2 << shiftBits), 8),
61.                                    __SSAT((in3 << shiftBits), 8),
62.                                    __SSAT((in4 << shiftBits), 8));
63.       /* Update source pointer to process next sampels */
64.       pSrc += 4u;
66.       /* Decrement the loop counter */
67.       blkCnt--;
68.     }
70.     /* If the blockSize is not a multiple of 4, compute any remaining output samples here.        
71.      ** No loop unrolling is used. */
72.     blkCnt = blockSize % 0x4u;
74.     while(blkCnt > 0u)
75.     {
76.       /* C = A << shiftBits */                                                                      (5)
77.       /* Shift the input and then store the result in the destination buffer. */
78.       *pDst++ = (q7_t) __SSAT((*pSrc++ << shiftBits), 8);
80.       /* Decrement the loop counter */
81.       blkCnt--;
82.     }
83.   }
84.   else                                                                                              (6)
85.   {
86.     shiftBits = -shiftBits;
87.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
88.      ** a second loop below computes the remaining 1 to 3 samples. */
89.     while(blkCnt > 0u)
90.     {
91.       /* C = A >> shiftBits */
92.       /* Read 4 inputs */
93.       in1 = *pSrc;
94.       in2 = *(pSrc + 1);
95.       in3 = *(pSrc + 2);
96.       in4 = *(pSrc + 3);
98.       /* Store the Shifted result in the destination buffer in single cycle by packing the outputs */
99.       *__SIMD32(pDst)++ = __PACKq7((in1 >> shiftBits), (in2 >> shiftBits),
100.                                    (in3 >> shiftBits), (in4 >> shiftBits));
103.       pSrc += 4u;
105.       /* Decrement the loop counter */
106.       blkCnt--;
107.     }
109.     /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
110.      ** No loop unrolling is used. */
111.     blkCnt = blockSize % 0x4u;
113.     while(blkCnt > 0u)
114.     {
115.       /* C = A >> shiftBits */
116.       /* Shift the input and then store the result in the destination buffer. */
117.       in1 = *pSrc++;
118.       *pDst++ = (in1 >> shiftBits);
120.       /* Decrement the loop counter */
121.       blkCnt--;
122.     }
123.   }
125. #else
127.   /* Run the below code for Cortex-M0 */
129.   /* Getting the sign of shiftBits */
130.   sign = (shiftBits & 0x80);
132.   /* If the shift value is positive then do right shift else left shift */
133.   if(sign == 0u)
134.   {
135.     /* Initialize blkCnt with number of samples */
136.     blkCnt = blockSize;
138.     while(blkCnt > 0u)
139.     {
140.       /* C = A << shiftBits */
141.       /* Shift the input and then store the result in the destination buffer. */
142.       *pDst++ = (q7_t) __SSAT(((q15_t) * pSrc++ << shiftBits), 8);
144.       /* Decrement the loop counter */
145.       blkCnt--;
146.     }
147.   }
148.   else
149.   {
150.     /* Initialize blkCnt with number of samples */
151.     blkCnt = blockSize;
153.     while(blkCnt > 0u)
154.     {
155.       /* C = A >> shiftBits */
156.       /* Shift the input and then store the result in the destination buffer. */
157.       *pDst++ = (*pSrc++ >> -shiftBits);
159.       /* Decrement the loop counter */
160.       blkCnt--;
161.     }
162.   }
164. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
165. }

复制代码

1. 如果函数的参数shiftBits是正数那么表示左移，如果参数shiftBits是负数那么就是右移。
2. 这个函数使用了饱和运算。
    饱和运算数值0x80将变成0x7F。
3. 获取偏移值是正数还是负数。
4. 通过调用一次__PACKq7实现四个Q7格式数据的位移。
5. 剩余几不足4个数据的位移求解。
6. 如果移位值是负数，那么就是右移。

9.3.4 实例讲解

实验目的：
    1. 三种类型数据的位移。
实验内容：
    1. 按下K3键, 串口打印输出结果
实验现象：
    通过窗口上位机软件SecureCRT（V5光盘里面有此软件）查看打印信息现象如下：

程序设计：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: DSP_Shift
4. *    功能说明: 位移
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void DSP_Shift(void)
10. {
11. static q31_t  pSrcA1 = 0x88886666;  
12. static q31_t  pDst1;  
14. static q15_t  pSrcA2 = 0x8866;  
15. static q15_t  pDst2;
17. static q7_t  pSrcA3 = 0x86;
18. static q7_t  pDst3;  
21. arm_shift_q31(&pSrcA1, 3, &pDst1, 1);
22. printf("arm_shift_q31 = %8xrn", pDst1);
24. arm_shift_q15(&pSrcA2, -3, &pDst2, 1);
25. printf("arm_shift_q15 = %4xrn", pDst2);
27. arm_shift_q7(&pSrcA3, 3, &pDst3, 1);
28. printf("arm_shift_q7 = %2xrn", pDst3);
29. printf("***********************************rn");
30. }

复制代码

席萌0209

9.4 减法（Vector Sub）

    这部分函数主要用于实现减法，公式描述如下：
     pDst[n] = pSrcA[n] - pSrcB[n],   0 <= n < blockSize.     

9.4.1 arm_sub_f32

    这个函数用于求32位浮点数的减法，源代码分析如下：

1. /**        
2. * @brief Floating-point vector subtraction.        
3. * @param[in]       *pSrcA points to the first input vector        
4. * @param[in]       *pSrcB points to the second input vector        
5. * @param[out]      *pDst points to the output vector        
6. * @param[in]       blockSize number of samples in each vector        
7. * @return none.        
8. */
10. void arm_sub_f32(
11.   float32_t * pSrcA,
12.   float32_t * pSrcB,
13.   float32_t * pDst,
14.   uint32_t blockSize)
15. {
16.   uint32_t blkCnt;                               /* loop counter */
18. #ifndef ARM_MATH_CM0_FAMILY
20. /* Run the below code for Cortex-M4 and Cortex-M3 */
21.   float32_t inA1, inA2, inA3, inA4;              /* temporary variables */
22.   float32_t inB1, inB2, inB3, inB4;              /* temporary variables */
24.   /*loop Unrolling */
25.   blkCnt = blockSize >> 2u;
27.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.        
28.    ** a second loop below computes the remaining 1 to 3 samples. */
29.   while(blkCnt > 0u)
30.   {
31.     /* C = A - B */
32.     /* Subtract and then store the results in the destination buffer. */
33.     /* Read 4 input samples from sourceA and sourceB */
34.     inA1 = *pSrcA;
35.     inB1 = *pSrcB;
36.     inA2 = *(pSrcA + 1);
37.     inB2 = *(pSrcB + 1);
38.     inA3 = *(pSrcA + 2);
39.     inB3 = *(pSrcB + 2);
40.     inA4 = *(pSrcA + 3);
41.     inB4 = *(pSrcB + 3);
43.     /* dst = srcA - srcB */
44.     /* subtract and store the result */                                                              (1)
45.     *pDst = inA1 - inB1;
46.     *(pDst + 1) = inA2 - inB2;
47.     *(pDst + 2) = inA3 - inB3;
48.     *(pDst + 3) = inA4 - inB4;
51.     /* Update pointers to process next sampels */
52.     pSrcA += 4u;
53.     pSrcB += 4u;
54.     pDst += 4u;
56.     /* Decrement the loop counter */
57.     blkCnt--;
58.   }
60.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.        
61.    ** No loop unrolling is used. */
62.   blkCnt = blockSize % 0x4u;
64. #else
66.   /* Run the below code for Cortex-M0 */
68.   /* Initialize blkCnt with number of samples */
69.   blkCnt = blockSize;
71. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
73.   while(blkCnt > 0u)
74.   {
75.     /* C = A - B */
76.     /* Subtract and then store the results in the destination buffer. */
77.     *pDst++ = (*pSrcA++) - (*pSrcB++);
79.     /* Decrement the loop counter */
80.     blkCnt--;
81.   }
82. }

复制代码

1. 浮点数的减法运算比较简单，直接两个数值相减即可。

9.4.2 arm_sub_q31

    这个函数用于求32位定点数的减法，源代码分析如下：

1. /**   
2. * @brief Q31 vector subtraction.   
3. * @param[in]       *pSrcA points to the first input vector   
4. * @param[in]       *pSrcB points to the second input vector   
5. * @param[out]      *pDst points to the output vector   
6. * @param[in]       blockSize number of samples in each vector   
7. * @return none.   
8. *   
9. * <b>Scaling and Overflow Behavior:</b>                                                              (1)
10. * par   
11. * The function uses saturating arithmetic.   
12. * Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] will be saturated.   
13. */
15. void arm_sub_q31(
16.   q31_t * pSrcA,
17.   q31_t * pSrcB,
18.   q31_t * pDst,
19.   uint32_t blockSize)
20. {
21.   uint32_t blkCnt;                               /* loop counter */
24. #ifndef ARM_MATH_CM0_FAMILY
26. /* Run the below code for Cortex-M4 and Cortex-M3 */
27.   q31_t inA1, inA2, inA3, inA4;
28.   q31_t inB1, inB2, inB3, inB4;
30.   /*loop Unrolling */
31.   blkCnt = blockSize >> 2u;
33.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
34.    ** a second loop below computes the remaining 1 to 3 samples. */
35.   while(blkCnt > 0u)
36.   {
37.     /* C = A - B */
38.     /* Subtract and then store the results in the destination buffer. */
39.     inA1 = *pSrcA++;
40.     inA2 = *pSrcA++;
41.     inB1 = *pSrcB++;
42.     inB2 = *pSrcB++;
44.     inA3 = *pSrcA++;
45.     inA4 = *pSrcA++;
46.     inB3 = *pSrcB++;
47.     inB4 = *pSrcB++;
49.     *pDst++ = __QSUB(inA1, inB1);                                                                    (2)
50.     *pDst++ = __QSUB(inA2, inB2);
51.     *pDst++ = __QSUB(inA3, inB3);
52.     *pDst++ = __QSUB(inA4, inB4);
54.     /* Decrement the loop counter */
55.     blkCnt--;
56.   }
58.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
59.    ** No loop unrolling is used. */
60.   blkCnt = blockSize % 0x4u;
62.   while(blkCnt > 0u)
63.   {
64.     /* C = A - B */
65.     /* Subtract and then store the result in the destination buffer. */
66.     *pDst++ = __QSUB(*pSrcA++, *pSrcB++);
68.     /* Decrement the loop counter */
69.     blkCnt--;
70.   }
72. #else
74.   /* Run the below code for Cortex-M0 */
76.   /* Initialize blkCnt with number of samples */
77.   blkCnt = blockSize;
79.   while(blkCnt > 0u)
80.   {
81.     /* C = A - B */
82.     /* Subtract and then store the result in the destination buffer. */
83.     *pDst++ = (q31_t) clip_q63_to_q31((q63_t) * pSrcA++ - *pSrcB++);
85.     /* Decrement the loop counter */
86.     blkCnt--;
87.   }
89. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
91. }

复制代码

1. 这个函数使用了饱和运算。
    饱和运算数值0x80000000将变成0x7FFFFFFF。
2. __QSUB也是SIMD指令，这里可以用这个指令实现两个Q31格式数据的饱和减法。

9.4.3 arm_sub_q15

    这个函数用于求16位定点数的减法，源代码分析如下：

1. /**   
2. * @brief Q15 vector subtraction.   
3. * @param[in]       *pSrcA points to the first input vector   
4. * @param[in]       *pSrcB points to the second input vector   
5. * @param[out]      *pDst points to the output vector   
6. * @param[in]       blockSize number of samples in each vector   
7. * @return none.   
8. *   
9. * <b>Scaling and Overflow Behavior:</b>   
10. * par   
11. * The function uses saturating arithmetic.   
12. * Results outside of the allowable Q15 range [0x8000 0x7FFF] will be saturated.   
13. */
15. void arm_sub_q15(
16.   q15_t * pSrcA,
17.   q15_t * pSrcB,
18.   q15_t * pDst,
19.   uint32_t blockSize)
20. {
21.   uint32_t blkCnt;                               /* loop counter */
24. #ifndef ARM_MATH_CM0_FAMILY
26. /* Run the below code for Cortex-M4 and Cortex-M3 */
27.   q31_t inA1, inA2;
28.   q31_t inB1, inB2;
30.   /*loop Unrolling */
31.   blkCnt = blockSize >> 2u;
33.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
34.    ** a second loop below computes the remaining 1 to 3 samples. */
35.   while(blkCnt > 0u)
36.   {
37.     /* C = A - B */
38.     /* Subtract and then store the results in the destination buffer two samples at a time. */
39.     inA1 = *__SIMD32(pSrcA)++;                                                                      (1)
40.     inA2 = *__SIMD32(pSrcA)++;
41.     inB1 = *__SIMD32(pSrcB)++;
42.     inB2 = *__SIMD32(pSrcB)++;
44.     *__SIMD32(pDst)++ = __QSUB16(inA1, inB1);                                                       (2)
45.     *__SIMD32(pDst)++ = __QSUB16(inA2, inB2);
47.     /* Decrement the loop counter */
48.     blkCnt--;
49.   }
51.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
52.    ** No loop unrolling is used. */
53.   blkCnt = blockSize % 0x4u;
55.   while(blkCnt > 0u)
56.   {
57.     /* C = A - B */
58.     /* Subtract and then store the result in the destination buffer. */
59.     *pDst++ = (q15_t) __QSUB16(*pSrcA++, *pSrcB++);
61.     /* Decrement the loop counter */
62.     blkCnt--;
63.   }
65. #else
67.   /* Run the below code for Cortex-M0 */
69.   /* Initialize blkCnt with number of samples */
70.   blkCnt = blockSize;
72.   while(blkCnt > 0u)
73.   {
74.     /* C = A - B */
75.     /* Subtract and then store the result in the destination buffer. */
76.     *pDst++ = (q15_t) __SSAT(((q31_t) * pSrcA++ - *pSrcB++), 16);
78.     /* Decrement the loop counter */
79.     blkCnt--;
80.   }
82. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
85. }

复制代码

1. 这里一次读取两个Q15格式的数据。
2. 由于__QSUB16是SIMD指令，在这里调用一次__QSUB16可以实现两次减法运算。

9.4.4 arm_sub_q7

    这个函数用于求8位定点数的减法，源代码分析如下：

1. /**   
2. * @brief Q7 vector subtraction.   
3. * @param[in]       *pSrcA points to the first input vector   
4. * @param[in]       *pSrcB points to the second input vector   
5. * @param[out]      *pDst points to the output vector   
6. * @param[in]       blockSize number of samples in each vector   
7. * @return none.   
8. *   
9. * <b>Scaling and Overflow Behavior:</b>   
10. * par   
11. * The function uses saturating arithmetic.   
12. * Results outside of the allowable Q7 range [0x80 0x7F] will be saturated.   
13. */
15. void arm_sub_q7(
16.   q7_t * pSrcA,
17.   q7_t * pSrcB,
18.   q7_t * pDst,
19.   uint32_t blockSize)
20. {
21.   uint32_t blkCnt;                               /* loop counter */
23. #ifndef ARM_MATH_CM0_FAMILY
25. /* Run the below code for Cortex-M4 and Cortex-M3 */
27.   /*loop Unrolling */
28.   blkCnt = blockSize >> 2u;
30.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
31.    ** a second loop below computes the remaining 1 to 3 samples. */
32.   while(blkCnt > 0u)
33.   {
34.     /* C = A - B */
35.     /* Subtract and then store the results in the destination buffer 4 samples at a time. */
36.     *__SIMD32(pDst)++ = __QSUB8(*__SIMD32(pSrcA)++, *__SIMD32(pSrcB)++);                              (1)
38.     /* Decrement the loop counter */
39.     blkCnt--;
40.   }
42.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
43.    ** No loop unrolling is used. */
44.   blkCnt = blockSize % 0x4u;
46.   while(blkCnt > 0u)
47.   {
48.     /* C = A - B */
49.     /* Subtract and then store the result in the destination buffer. */
50.     *pDst++ = __SSAT(*pSrcA++ - *pSrcB++, 8);
52.     /* Decrement the loop counter */
53.     blkCnt--;
54.   }
56. #else
58.   /* Run the below code for Cortex-M0 */
60.   /* Initialize blkCnt with number of samples */
61.   blkCnt = blockSize;
63.   while(blkCnt > 0u)
64.   {
65.     /* C = A - B */
66.     /* Subtract and then store the result in the destination buffer. */
67.     *pDst++ = (q7_t) __SSAT((q15_t) * pSrcA++ - *pSrcB++, 8);
69.     /* Decrement the loop counter */
70.     blkCnt--;
71.   }
73. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
76. }

复制代码

1. __QSUB8也是SIMD指令，调用一次就能实现4个Q7格式数据的减法运算。

9.4.5 实例讲解

实验目的：
    1. 四种种类型数据的减法。
实验内容：
    1. 按下按键UP, 串口打印输出结果
实验现象：
    通过窗口上位机软件SecureCRT（V5光盘里面有此软件）查看打印信息现象如下：

程序设计：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: DSP_Sub
4. *    功能说明: 减法
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void DSP_Sub(void)
10. {
11. static float32_t   pSrcA[5] = {1.0f,1.0f,1.0f,1.0f,1.0f};
12. static float32_t   pSrcB[5] = {1.0f,1.0f,1.0f,1.0f,1.0f};  
13. static float32_t   pDst[5];  
14. static q31_t  pSrcA1[5] = {1,1,1,1,1};  
15. static q31_t  pSrcB1[5] = {1,1,1,1,1};  
16. static q31_t  pDst1[5];   
18. static q15_t  pSrcA2[5] = {1,1,1,1,1};  
19. static q15_t  pSrcB2[5] = {1,1,1,1,1};  
20. static q15_t  pDst2[5];   
22. static q7_t  pSrcA3[5] = {0x70,1,1,1,1};
23. static q7_t  pSrcB3[5] = {0x7f,1,1,1,1};  
24. static q7_t pDst3[5];  
26. pSrcA[0] += 1.1f;
27. arm_sub_f32(pSrcA, pSrcB, pDst, 5);
28. printf("arm_sub_f32 = %frn", pDst[0]);
29. pSrcA1[0] += 1;
30. arm_sub_q31(pSrcA1, pSrcB1, pDst1, 5);
31. printf("arm_sub_q31 = %drn", pDst1[0]);
33. pSrcA2[0] += 1;
34. arm_sub_q15(pSrcA2, pSrcB2, pDst2, 5);
35. printf("arm_sub_q15 = %drn", pDst2[0]);
37. pSrcA3[0] += 1;
38. arm_sub_q7(pSrcA3, pSrcB3, pDst3, 5);
39. printf("arm_sub_q7 = %drn", pDst3[0]);
40. printf("***********************************rn");
41. }

复制代码

席萌0209

9.5 比例因子（Vector Scale）

    这部分函数主要用于实现数据的比例放大和缩小，浮点数据公式描述如下：
      pDst[n] = pSrc[n] * scale,   0 <= n < blockSize.        
    如果是Q31，Q15，Q7格式的数据，公式描述如下：
      pDst[n] = (pSrc[n] * scaleFract) << shift,   0 <= n < blockSize.   
    这种情况下，比例因子就是：
      scale = scaleFract * 2^shift.      
      注意，这部分函数支持目标指针和源指针指向相同的缓冲区。

9.5.1 arm_scale_f32

    这个函数用于求32位浮点数的比例放缩，源代码分析如下：

1. /**        
2. * @brief Multiplies a floating-point vector by a scalar.        
3. * @param[in]       *pSrc points to the input vector        
4. * @param[in]       scale scale factor to be applied        
5. * @param[out]      *pDst points to the output vector        
6. * @param[in]       blockSize number of samples in the vector        
7. * @return none.        
8. */
11. void arm_scale_f32(
12.   float32_t * pSrc,
13.   float32_t scale,
14.   float32_t * pDst,
15.   uint32_t blockSize)
16. {
17.   uint32_t blkCnt;                               /* loop counter */
18. #ifndef ARM_MATH_CM0_FAMILY
20. /* Run the below code for Cortex-M4 and Cortex-M3 */
21.   float32_t in1, in2, in3, in4;                  /* temporary variabels */
23.   /*loop Unrolling */
24.   blkCnt = blockSize >> 2u;
26.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.        
27.    ** a second loop below computes the remaining 1 to 3 samples. */
28.   while(blkCnt > 0u)
29.   {
30.     /* C = A * scale */
31.     /* Scale the input and then store the results in the destination buffer. */
32.     /* read input samples from source */
33.     in1 = *pSrc;
34.     in2 = *(pSrc + 1);
36.     /* multiply with scaling factor */                                                               (1)
37.     in1 = in1 * scale;
39.     /* read input sample from source */
40.     in3 = *(pSrc + 2);
42.     /* multiply with scaling factor */
43.     in2 = in2 * scale;
45.     /* read input sample from source */
46.     in4 = *(pSrc + 3);
48.     /* multiply with scaling factor */
49.     in3 = in3 * scale;
50.     in4 = in4 * scale;
51.     /* store the result to destination */
52.     *pDst = in1;
53.     *(pDst + 1) = in2;
54.     *(pDst + 2) = in3;
55.     *(pDst + 3) = in4;
57.     /* update pointers to process next samples */
58.     pSrc += 4u;
59.     pDst += 4u;
61.     /* Decrement the loop counter */
62.     blkCnt--;
63.   }
65.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.        
66.    ** No loop unrolling is used. */
67.   blkCnt = blockSize % 0x4u;
69. #else
71.   /* Run the below code for Cortex-M0 */
73.   /* Initialize blkCnt with number of samples */
74.   blkCnt = blockSize;
76. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
78.   while(blkCnt > 0u)
79.   {
80.     /* C = A * scale */
81.     /* Scale the input and then store the result in the destination buffer. */
82.     *pDst++ = (*pSrc++) * scale;
84.     /* Decrement the loop counter */
85.     blkCnt--;
86.   }
87. }

复制代码

1. 浮点数据的比例因子计算比较简单，源浮点数相应相应的比例因子即可。

9.5.2 arm_scale_q31

    这个函数用于求32位定点数的比例放缩，源代码分析如下：

1. /**      
2. * @brief Multiplies a Q31 vector by a scalar.      
3. * @param[in]       *pSrc points to the input vector      
4. * @param[in]       scaleFract fractional portion of the scale value      
5. * @param[in]       shift number of bits to shift the result by      
6. * @param[out]      *pDst points to the output vector      
7. * @param[in]       blockSize number of samples in the vector      
8. * @return none.      
9. *      
10. * <b>Scaling and Overflow Behavior:</b>                                                             (1)
11. * par      
12. * The input data <code>*pSrc</code> and <code>scaleFract</code> are in 1.31 format.      
13. * These are multiplied to yield a 2.62 intermediate result and this is shifted with saturation to 1.31 format.      
14. */
16. void arm_scale_q31(
17.   q31_t * pSrc,
18.   q31_t scaleFract,
19.   int8_t shift,
20.   q31_t * pDst,
21.   uint32_t blockSize)
22. {
23.   int8_t kShift = shift + 1;                     /* Shift to apply after scaling */                 (2)
24.   int8_t sign = (kShift & 0x80);
25.   uint32_t blkCnt;                               /* loop counter */
26.   q31_t in, out;
28. #ifndef ARM_MATH_CM0_FAMILY
30. /* Run the below code for Cortex-M4 and Cortex-M3 */
32.   q31_t in1, in2, in3, in4;                      /* temporary input variables */
33.   q31_t out1, out2, out3, out4;                  /* temporary output variabels */
36.   /*loop Unrolling */
37.   blkCnt = blockSize >> 2u;
39.   if(sign == 0u)                                                                                    (3)
40.   {
41.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.      
42.      ** a second loop below computes the remaining 1 to 3 samples. */
43.     while(blkCnt > 0u)
44.     {
45.       /* read four inputs from source */
46.       in1 = *pSrc;
47.       in2 = *(pSrc + 1);
48.       in3 = *(pSrc + 2);
49.       in4 = *(pSrc + 3);
51.       /* multiply input with scaler value */                                                        (4)
52.       in1 = ((q63_t) in1 * scaleFract) >> 32;
53.       in2 = ((q63_t) in2 * scaleFract) >> 32;
54.       in3 = ((q63_t) in3 * scaleFract) >> 32;
55.       in4 = ((q63_t) in4 * scaleFract) >> 32;
57.       /* apply shifting */
58.       out1 = in1 << kShift;
59.       out2 = in2 << kShift;
61.       /* saturate the results. */
62.       if(in1 != (out1 >> kShift))                                                                   (5)
63.         out1 = 0x7FFFFFFF ^ (in1 >> 31);
65.       if(in2 != (out2 >> kShift))
66.         out2 = 0x7FFFFFFF ^ (in2 >> 31);
68.       out3 = in3 << kShift;
69.       out4 = in4 << kShift;
71.       *pDst = out1;
72.       *(pDst + 1) = out2;
74.       if(in3 != (out3 >> kShift))
75.         out3 = 0x7FFFFFFF ^ (in3 >> 31);
77.       if(in4 != (out4 >> kShift))
78.         out4 = 0x7FFFFFFF ^ (in4 >> 31);
80.       /* Store result destination */
81.       *(pDst + 2) = out3;
82.       *(pDst + 3) = out4;
84.       /* Update pointers to process next sampels */
85.       pSrc += 4u;
86.       pDst += 4u;
88.       /* Decrement the loop counter */
89.       blkCnt--;
90.     }
92.   }
93.   else                                                                                               {
94.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.      
95.      ** a second loop below computes the remaining 1 to 3 samples. */
96.     while(blkCnt > 0u)
97.     {
98.       /* read four inputs from source */
99.       in1 = *pSrc;
100.       in2 = *(pSrc + 1);
101.       in3 = *(pSrc + 2);
102.       in4 = *(pSrc + 3);
104.       /* multiply input with scaler value */
105.       in1 = ((q63_t) in1 * scaleFract) >> 32;
106.       in2 = ((q63_t) in2 * scaleFract) >> 32;
107.       in3 = ((q63_t) in3 * scaleFract) >> 32;
108.       in4 = ((q63_t) in4 * scaleFract) >> 32;
110.       /* apply shifting */                                                                           (6)
111.       out1 = in1 >> -kShift;
112.       out2 = in2 >> -kShift;
114.       out3 = in3 >> -kShift;
115.       out4 = in4 >> -kShift;
117.       /* Store result destination */
118.       *pDst = out1;
119.       *(pDst + 1) = out2;
121.       *(pDst + 2) = out3;
122.       *(pDst + 3) = out4;
124.       /* Update pointers to process next sampels */
125.       pSrc += 4u;
126.       pDst += 4u;
128.       /* Decrement the loop counter */
129.       blkCnt--;
130.     }
131.   }
132.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.      
133.    ** No loop unrolling is used. */
134.   blkCnt = blockSize % 0x4u;
136. #else
138.   /* Run the below code for Cortex-M0 */
140.   /* Initialize blkCnt with number of samples */
141.   blkCnt = blockSize;
143. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
145.   if(sign == 0)
146.   {
147.   while(blkCnt > 0u)
148.   {
149. /* C = A * scale */
150. /* Scale the input and then store the result in the destination buffer. */
151. in = *pSrc++;
152. in = ((q63_t) in * scaleFract) >> 32;
154. out = in << kShift;
155. if(in != (out >> kShift))
156. out = 0x7FFFFFFF ^ (in >> 31);
158. *pDst++ = out;
160. /* Decrement the loop counter */
161. blkCnt--;
162.   }
163.   }
164.   else
165.   {
166.   while(blkCnt > 0u)
167.   {
168. /* C = A * scale */
169. /* Scale the input and then store the result in the destination buffer. */
170. in = *pSrc++;
171. in = ((q63_t) in * scaleFract) >> 32;
173. out = in >> -kShift;
175. *pDst++ = out;
177. /* Decrement the loop counter */
178. blkCnt--;
179.   }
180.   
181.   }
182. }

复制代码

1. 源数据和比例因子都是Q31格式。这样他们的乘积就是1.31 * 1.31 = 2.62格式。由于输出结果也是Q31格式，那么源数据和比例因子的乘积需要右移32位，并且输出结果需要饱和处理。
2. 这里不清楚为什么要加1操作，留作以后解决。
3. 如果位移是正值，那么就是左移位，否则就是右移位。
4. 将源数据和比例因子的乘积左移32位，保证结果也是Q31格式。
5. 这里是对结果的饱和处理。
6. 数值的右移不存在饱和问题，这里直接取反即可。

9.5.3 arm_scale_q15

    这个函数用于求16位定点数的比例放缩，源代码分析如下：

1. /**   
2. * @brief Multiplies a Q15 vector by a scalar.   
3. * @param[in]       *pSrc points to the input vector   
4. * @param[in]       scaleFract fractional portion of the scale value   
5. * @param[in]       shift number of bits to shift the result by   
6. * @param[out]      *pDst points to the output vector   
7. * @param[in]       blockSize number of samples in the vector   
8. * @return none.   
9. *   
10. * <b>Scaling and Overflow Behavior:</b>                                                               (1)
11. * par   
12. * The input data <code>*pSrc</code> and <code>scaleFract</code> are in 1.15 format.   
13. * These are multiplied to yield a 2.30 intermediate result and this is shifted with saturation to 1.15 format.   
14. */
17. void arm_scale_q15(
18.   q15_t * pSrc,
19.   q15_t scaleFract,
20.   int8_t shift,
21.   q15_t * pDst,
22.   uint32_t blockSize)
23. {
24.   int8_t kShift = 15 - shift;                    /* shift to apply after scaling */                   (2)
25.   uint32_t blkCnt;                               /* loop counter */
27. #ifndef ARM_MATH_CM0_FAMILY
29. /* Run the below code for Cortex-M4 and Cortex-M3 */
30.   q15_t in1, in2, in3, in4;
31.   q31_t inA1, inA2;                              /* Temporary variables */
32.   q31_t out1, out2, out3, out4;
35.   /*loop Unrolling */
36.   blkCnt = blockSize >> 2u;
38.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.        
39.    ** a second loop below computes the remaining 1 to 3 samples. */
40.   while(blkCnt > 0u)
41.   {
42.     /* Reading 2 inputs from memory */
43.     inA1 = *__SIMD32(pSrc)++;                                                                       (3)
44.     inA2 = *__SIMD32(pSrc)++;
46.     /* C = A * scale */
47.     /* Scale the inputs and then store the 2 results in the destination buffer        
48.      * in single cycle by packing the outputs */
49.     out1 = (q31_t) ((q15_t) (inA1 >> 16) * scaleFract);                                             (4)
50.     out2 = (q31_t) ((q15_t) inA1 * scaleFract);
51.     out3 = (q31_t) ((q15_t) (inA2 >> 16) * scaleFract);
52.     out4 = (q31_t) ((q15_t) inA2 * scaleFract);
54.     /* apply shifting */
55.     out1 = out1 >> kShift;
56.     out2 = out2 >> kShift;
57.     out3 = out3 >> kShift;
58.     out4 = out4 >> kShift;
60.     /* saturate the output */
61.     in1 = (q15_t) (__SSAT(out1, 16));                                                               (5)
62.     in2 = (q15_t) (__SSAT(out2, 16));
63.     in3 = (q15_t) (__SSAT(out3, 16));
64.     in4 = (q15_t) (__SSAT(out4, 16));
66.     /* store the result to destination */                                                           (6)
67.     *__SIMD32(pDst)++ = __PKHBT(in2, in1, 16);
68.     *__SIMD32(pDst)++ = __PKHBT(in4, in3, 16);
70.     /* Decrement the loop counter */
71.     blkCnt--;
72.   }
74.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
75.    ** No loop unrolling is used. */
76.   blkCnt = blockSize % 0x4u;
78.   while(blkCnt > 0u)
79.   {
80.     /* C = A * scale */
81.     /* Scale the input and then store the result in the destination buffer. */
82.     *pDst++ = (q15_t) (__SSAT(((*pSrc++) * scaleFract) >> kShift, 16));
84.     /* Decrement the loop counter */
85.     blkCnt--;
86.   }
88. #else
90.   /* Run the below code for Cortex-M0 */
92.   /* Initialize blkCnt with number of samples */
93.   blkCnt = blockSize;
95.   while(blkCnt > 0u)
96.   {
97.     /* C = A * scale */
98.     /* Scale the input and then store the result in the destination buffer. */
99.     *pDst++ = (q15_t) (__SSAT(((q31_t) * pSrc++ * scaleFract) >> kShift, 16));
101.     /* Decrement the loop counter */
102.     blkCnt--;
103.   }
105. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
107. }

复制代码

1. 源数据和比例因子的数据格式都是Q15，这样的话，输出结果就是1.15 * 1.15 = 2.30格式，由于输出结果也是Q15格式，所以输出结果需要饱和处理。
2. 这个变量设计很巧妙，这样下面处理正数左移和负数右移就很方面了，可以直接使用一个右移就可以实现。
3. 读取两个Q15格式的数据。
4. 将源数据乘以比例因子后赋值给Q31格式的变量。
5. 对输出结果做饱和处理。
6. 通过调用一次__PKHBT指令，将两个Q15格式的数据都赋值给目的变量。

9.5.4 arm_scale_q7

    这个函数用于求8位定点数的比例放缩，源代码分析如下：

1. /**   
2. * @brief Multiplies a Q7 vector by a scalar.   
3. * @param[in]       *pSrc points to the input vector   
4. * @param[in]       scaleFract fractional portion of the scale value   
5. * @param[in]       shift number of bits to shift the result by   
6. * @param[out]      *pDst points to the output vector   
7. * @param[in]       blockSize number of samples in the vector   
8. * @return none.   
9. *   
10. * <b>Scaling and Overflow Behavior:</b>                                                              (1)
11. * par   
12. * The input data <code>*pSrc</code> and <code>scaleFract</code> are in 1.7 format.            
13. * These are multiplied to yield a 2.14 intermediate result and this is shifted with saturation to 1.7 format.   
14. */
16. void arm_scale_q7(
17.   q7_t * pSrc,
18.   q7_t scaleFract,
19.   int8_t shift,
20.   q7_t * pDst,
21.   uint32_t blockSize)
22. {
23.   int8_t kShift = 7 - shift;                     /* shift to apply after scaling */                   (2)
24.   uint32_t blkCnt;                               /* loop counter */
26. #ifndef ARM_MATH_CM0_FAMILY
28. /* Run the below code for Cortex-M4 and Cortex-M3 */
29.   q7_t in1, in2, in3, in4, out1, out2, out3, out4;      /* Temporary variables to store input & output */
32.   /*loop Unrolling */
33.   blkCnt = blockSize >> 2u;
36.   /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.   
37.    ** a second loop below computes the remaining 1 to 3 samples. */
38.   while(blkCnt > 0u)
39.   {
40.     /* Reading 4 inputs from memory */
41.     in1 = *pSrc++;
42.     in2 = *pSrc++;
43.     in3 = *pSrc++;
44.     in4 = *pSrc++;
46.     /* C = A * scale */
47.     /* Scale the inputs and then store the results in the temporary variables. */
48.     out1 = (q7_t) (__SSAT(((in1) * scaleFract) >> kShift, 8));                                        (3)
49.     out2 = (q7_t) (__SSAT(((in2) * scaleFract) >> kShift, 8));
50.     out3 = (q7_t) (__SSAT(((in3) * scaleFract) >> kShift, 8));
51.     out4 = (q7_t) (__SSAT(((in4) * scaleFract) >> kShift, 8));
53.     /* Packing the individual outputs into 32bit and storing in   
54.      * destination buffer in single write */
55.     *__SIMD32(pDst)++ = __PACKq7(out1, out2, out3, out4);                                             (4)
57.     /* Decrement the loop counter */
58.     blkCnt--;
59.   }
61.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.   
62.    ** No loop unrolling is used. */
63.   blkCnt = blockSize % 0x4u;
65.   while(blkCnt > 0u)
66.   {
67.     /* C = A * scale */
68.     /* Scale the input and then store the result in the destination buffer. */
69.     *pDst++ = (q7_t) (__SSAT(((*pSrc++) * scaleFract) >> kShift, 8));
71.     /* Decrement the loop counter */
72.     blkCnt--;
73.   }
75. #else
77.   /* Run the below code for Cortex-M0 */
79.   /* Initialize blkCnt with number of samples */
80.   blkCnt = blockSize;
82.   while(blkCnt > 0u)
83.   {
84.     /* C = A * scale */
85.     /* Scale the input and then store the result in the destination buffer. */
86.     *pDst++ = (q7_t) (__SSAT((((q15_t) * pSrc++ * scaleFract) >> kShift), 8));
88.     /* Decrement the loop counter */
89.     blkCnt--;
90.   }
92. #endif /* #ifndef ARM_MATH_CM0_FAMILY */
94. }

复制代码

1. 源数据和比例因子的数据格式都是Q7，这样的话，输出结果就是1.7 * 1.7 = 2.14格式，由于输出结果也是Q7格式，所以输出结果需要饱和处理。
2. 这个变量设计很巧妙，这样下面处理正数左移和负数右移就很方面了，可以直接使用一个右移就可以实现。
3. 对源数据和比例因子的输出结果做8位精度的饱和处理。

9.5.5 实例讲解

实验目的：
    1. 四种种类型数据的比例放缩。
实验内容：
    1. 按下按键DOWN 串口打印输出结果
实验现象：
    通过窗口上位机软件SecureCRT（V5光盘里面有此软件）查看打印信息现象如下：

程序设计：

1. /*
2. *********************************************************************************************************
3. *    函 数 名: DSP_Scale
4. *    功能说明: 比例因子
5. *    形    参：无
6. *    返 回 值: 无
7. *********************************************************************************************************
8. */
9. static void DSP_Scale(void)
10. {
11. static float32_t   pSrcA[5] = {1.0f,1.0f,1.0f,1.0f,1.0f};
12. static float32_t   scale = 0.0f;  
13. static float32_t   pDst[5];  
14. static q31_t  pSrcA1[5] = {0x6fffffff,1,1,1,1};  
15. static q31_t  scale1 = 0x6fffffff;  
16. static q31_t  pDst1[5];   
18. static q15_t  pSrcA2[5] = {0x6fff,1,1,1,1};  
19. static q15_t  scale2 = 0x6fff;  
20. static q15_t  pDst2[5];   
22. static q7_t  pSrcA3[5] = {0x70,1,1,1,1};
23. static q7_t  scale3 = 0x6f;  
24. static q7_t pDst3[5];  
26. scale += 0.1f;
27. arm_scale_f32(pSrcA, scale, pDst, 5);
28. printf("arm_sub_f32 = %frn", pDst[0]);
29. scale1 += 1;
30. arm_scale_q31(pSrcA1, scale1, 0, pDst1, 5);
31. printf("arm_scale_q31 = %xrn", pDst1[0]);
33. scale2 += 1;
34. arm_scale_q15(pSrcA2, scale2, 0, pDst2, 5);
35. printf("arm_scale_q15 = %xrn", pDst2[0]);
37. scale3 += 1;
38. arm_scale_q7(pSrcA3, scale3, 0, pDst3, 5);
39. printf("arm_scale_q7 = %xrn", pDst3[0]);
40. printf("***********************************rn");
41. }

复制代码

席萌0209

9.6 BasicMathFunctions的重要说明

    截至到这里，BasicMathFunctions函数已经讲解完了，也许大家也发现了这些函数的一些共同点，在前面第8章的时候我们简单的阐述过，这里再进一步的阐述一下：
l 这些函数基本都是支持重入的。
l 基本每个函数都有四种数据类型，F32，Q31，Q15，Q7。
l 函数中数值的处理基本都是4个为一组，这么做的原因是F32，Q31，Q15，Q7就可以统一采用一个程序设计架构，便于管理。更重要的是可以在Q15和Q7数据处理中很好的发挥SIMD指令的作用（因为4个为一组的话，可以用SIMD指令正好处理2个Q15数据或者4个Q7数据）。
l 部分函数是支持目标指针和源指针指向相同的缓冲区。
    关于这个的使用，我们没有在前面的讲解中举例子，下面举一个简单的例子进行说明，这里就以9.5小节中scale函数进行说明：

1. static void DSP_Scale(void)
2. {
3. static float32_t   pSrcA[5] = {1.0f,1.0f,1.0f,1.0f,1.0f};
4. static float32_t   scale = 0.0f;  
5. static q31_t  pSrcA1[5] = {0x6fffffff,1,1,1,1};  
6. static q31_t  scale1 = 0x6fffffff;  
8. static q15_t  pSrcA2[5] = {0x6fff,1,1,1,1};  
9. static q15_t  scale2 = 0x6fff;  
10. static q7_t  pSrcA3[5] = {0x70,1,1,1,1};
11. static q7_t  scale3 = 0x6f;  
13. scale += 0.1f;
14. arm_scale_f32(pSrcA, scale, pSrcA, 5);              (1)
15. printf("arm_sub_f32 = %frn", pSrcA[0]);
16. scale1 += 1;
17. arm_scale_q31(pSrcA1, scale1, 0, pSrcA1, 5);        (2)
18. printf("arm_scale_q31 = %xrn", pSrcA1[0]);
20. scale2 += 1;
21. arm_scale_q15(pSrcA2, scale2, 0, pSrcA2, 5);        (3)
22. printf("arm_scale_q15 = %xrn", pSrcA2[0]);
24. scale3 += 1;
25. arm_scale_q7(pSrcA3, scale3, 0, pSrcA3, 5);         (4)
26. printf("arm_scale_q7 = %xrn", pSrcA3[0]);
27. printf("***********************************rn");
28. }

复制代码

上面代码的（1）至（4）目标指针和源指针指向相同的缓冲区。

9.7 总结

    BasicMathFunctions函数就跟大家讲这么多，希望初学的同学多多的联系，并在自己以后的项目中多多使用，效果必将事半功倍。