source: S-port/trunk/Drivers/CMSIS/DSP/Source/BasicMathFunctions/arm_mult_f32.c

Last change on this file was 1, checked in by AlexLir, 3 years ago
File size: 4.3 KB
Line 
1/* ----------------------------------------------------------------------
2 * Project: CMSIS DSP Library
3 * Title: arm_mult_f32.c
4 * Description: Floating-point vector multiplication
5 *
6 * $Date: 27. January 2017
7 * $Revision: V.1.5.1
8 *
9 * Target Processor: Cortex-M cores
10 * -------------------------------------------------------------------- */
11/*
12 * Copyright (C) 2010-2017 ARM Limited or its affiliates. All rights reserved.
13 *
14 * SPDX-License-Identifier: Apache-2.0
15 *
16 * Licensed under the Apache License, Version 2.0 (the License); you may
17 * not use this file except in compliance with the License.
18 * You may obtain a copy of the License at
19 *
20 * www.apache.org/licenses/LICENSE-2.0
21 *
22 * Unless required by applicable law or agreed to in writing, software
23 * distributed under the License is distributed on an AS IS BASIS, WITHOUT
24 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
25 * See the License for the specific language governing permissions and
26 * limitations under the License.
27 */
28
29#include "arm_math.h"
30
31/**
32 * @ingroup groupMath
33 */
34
35/**
36 * @defgroup BasicMult Vector Multiplication
37 *
38 * Element-by-element multiplication of two vectors.
39 *
40 * <pre>
41 * pDst[n] = pSrcA[n] * pSrcB[n], 0 <= n < blockSize.
42 * </pre>
43 *
44 * There are separate functions for floating-point, Q7, Q15, and Q31 data types.
45 */
46
47/**
48 * @addtogroup BasicMult
49 * @{
50 */
51
52/**
53 * @brief Floating-point vector multiplication.
54 * @param[in] *pSrcA points to the first input vector
55 * @param[in] *pSrcB points to the second input vector
56 * @param[out] *pDst points to the output vector
57 * @param[in] blockSize number of samples in each vector
58 * @return none.
59 */
60
61void arm_mult_f32(
62 float32_t * pSrcA,
63 float32_t * pSrcB,
64 float32_t * pDst,
65 uint32_t blockSize)
66{
67 uint32_t blkCnt; /* loop counters */
68#if defined (ARM_MATH_DSP)
69
70 /* Run the below code for Cortex-M4 and Cortex-M3 */
71 float32_t inA1, inA2, inA3, inA4; /* temporary input variables */
72 float32_t inB1, inB2, inB3, inB4; /* temporary input variables */
73 float32_t out1, out2, out3, out4; /* temporary output variables */
74
75 /* loop Unrolling */
76 blkCnt = blockSize >> 2U;
77
78 /* First part of the processing with loop unrolling. Compute 4 outputs at a time.
79 ** a second loop below computes the remaining 1 to 3 samples. */
80 while (blkCnt > 0U)
81 {
82 /* C = A * B */
83 /* Multiply the inputs and store the results in output buffer */
84 /* read sample from sourceA */
85 inA1 = *pSrcA;
86 /* read sample from sourceB */
87 inB1 = *pSrcB;
88 /* read sample from sourceA */
89 inA2 = *(pSrcA + 1);
90 /* read sample from sourceB */
91 inB2 = *(pSrcB + 1);
92
93 /* out = sourceA * sourceB */
94 out1 = inA1 * inB1;
95
96 /* read sample from sourceA */
97 inA3 = *(pSrcA + 2);
98 /* read sample from sourceB */
99 inB3 = *(pSrcB + 2);
100
101 /* out = sourceA * sourceB */
102 out2 = inA2 * inB2;
103
104 /* read sample from sourceA */
105 inA4 = *(pSrcA + 3);
106
107 /* store result to destination buffer */
108 *pDst = out1;
109
110 /* read sample from sourceB */
111 inB4 = *(pSrcB + 3);
112
113 /* out = sourceA * sourceB */
114 out3 = inA3 * inB3;
115
116 /* store result to destination buffer */
117 *(pDst + 1) = out2;
118
119 /* out = sourceA * sourceB */
120 out4 = inA4 * inB4;
121 /* store result to destination buffer */
122 *(pDst + 2) = out3;
123 /* store result to destination buffer */
124 *(pDst + 3) = out4;
125
126
127 /* update pointers to process next samples */
128 pSrcA += 4U;
129 pSrcB += 4U;
130 pDst += 4U;
131
132 /* Decrement the blockSize loop counter */
133 blkCnt--;
134 }
135
136 /* If the blockSize is not a multiple of 4, compute any remaining output samples here.
137 ** No loop unrolling is used. */
138 blkCnt = blockSize % 0x4U;
139
140#else
141
142 /* Run the below code for Cortex-M0 */
143
144 /* Initialize blkCnt with number of samples */
145 blkCnt = blockSize;
146
147#endif /* #if defined (ARM_MATH_DSP) */
148
149 while (blkCnt > 0U)
150 {
151 /* C = A * B */
152 /* Multiply the inputs and store the results in output buffer */
153 *pDst++ = (*pSrcA++) * (*pSrcB++);
154
155 /* Decrement the blockSize loop counter */
156 blkCnt--;
157 }
158}
159
160/**
161 * @} end of BasicMult group
162 */
Note: See TracBrowser for help on using the repository browser.