Mercurial > pub > halpp
comparison f103c8/Drivers/CMSIS/DSP_Lib/Source/StatisticsFunctions/arm_std_f32.c @ 2:0c59e7a7782a
Working on GPIO and RCC
author | cin |
---|---|
date | Mon, 16 Jan 2017 11:04:47 +0300 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
1:a0b14b11ad9f | 2:0c59e7a7782a |
---|---|
1 /* ---------------------------------------------------------------------- | |
2 * Copyright (C) 2010-2014 ARM Limited. All rights reserved. | |
3 * | |
4 * $Date: 19. March 2015 | |
5 * $Revision: V.1.4.5 | |
6 * | |
7 * Project: CMSIS DSP Library | |
8 * Title: arm_std_f32.c | |
9 * | |
10 * Description: Standard deviation of the elements of a floating-point vector. | |
11 * | |
12 * Target Processor: Cortex-M4/Cortex-M3/Cortex-M0 | |
13 * | |
14 * Redistribution and use in source and binary forms, with or without | |
15 * modification, are permitted provided that the following conditions | |
16 * are met: | |
17 * - Redistributions of source code must retain the above copyright | |
18 * notice, this list of conditions and the following disclaimer. | |
19 * - Redistributions in binary form must reproduce the above copyright | |
20 * notice, this list of conditions and the following disclaimer in | |
21 * the documentation and/or other materials provided with the | |
22 * distribution. | |
23 * - Neither the name of ARM LIMITED nor the names of its contributors | |
24 * may be used to endorse or promote products derived from this | |
25 * software without specific prior written permission. | |
26 * | |
27 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
28 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
29 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS | |
30 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE | |
31 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, | |
32 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, | |
33 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
34 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER | |
35 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN | |
37 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
38 * POSSIBILITY OF SUCH DAMAGE. | |
39 * ---------------------------------------------------------------------------- */ | |
40 | |
41 #include "arm_math.h" | |
42 | |
43 /** | |
44 * @ingroup groupStats | |
45 */ | |
46 | |
47 /** | |
48 * @defgroup STD Standard deviation | |
49 * | |
50 * Calculates the standard deviation of the elements in the input vector. | |
51 * The underlying algorithm is used: | |
52 * | |
53 * <pre> | |
54 * Result = sqrt((sumOfSquares - sum<sup>2</sup> / blockSize) / (blockSize - 1)) | |
55 * | |
56 * where, sumOfSquares = pSrc[0] * pSrc[0] + pSrc[1] * pSrc[1] + ... + pSrc[blockSize-1] * pSrc[blockSize-1] | |
57 * | |
58 * sum = pSrc[0] + pSrc[1] + pSrc[2] + ... + pSrc[blockSize-1] | |
59 * </pre> | |
60 * | |
61 * There are separate functions for floating point, Q31, and Q15 data types. | |
62 */ | |
63 | |
64 /** | |
65 * @addtogroup STD | |
66 * @{ | |
67 */ | |
68 | |
69 | |
70 /** | |
71 * @brief Standard deviation of the elements of a floating-point vector. | |
72 * @param[in] *pSrc points to the input vector | |
73 * @param[in] blockSize length of the input vector | |
74 * @param[out] *pResult standard deviation value returned here | |
75 * @return none. | |
76 * | |
77 */ | |
78 | |
79 | |
80 void arm_std_f32( | |
81 float32_t * pSrc, | |
82 uint32_t blockSize, | |
83 float32_t * pResult) | |
84 { | |
85 float32_t sum = 0.0f; /* Temporary result storage */ | |
86 float32_t sumOfSquares = 0.0f; /* Sum of squares */ | |
87 float32_t in; /* input value */ | |
88 uint32_t blkCnt; /* loop counter */ | |
89 | |
90 #ifndef ARM_MATH_CM0_FAMILY | |
91 | |
92 /* Run the below code for Cortex-M4 and Cortex-M3 */ | |
93 | |
94 float32_t meanOfSquares, mean, squareOfMean; | |
95 | |
96 if(blockSize == 1) | |
97 { | |
98 *pResult = 0; | |
99 return; | |
100 } | |
101 | |
102 /*loop Unrolling */ | |
103 blkCnt = blockSize >> 2u; | |
104 | |
105 /* First part of the processing with loop unrolling. Compute 4 outputs at a time. | |
106 ** a second loop below computes the remaining 1 to 3 samples. */ | |
107 while(blkCnt > 0u) | |
108 { | |
109 /* C = (A[0] * A[0] + A[1] * A[1] + ... + A[blockSize-1] * A[blockSize-1]) */ | |
110 /* Compute Sum of squares of the input samples | |
111 * and then store the result in a temporary variable, sum. */ | |
112 in = *pSrc++; | |
113 sum += in; | |
114 sumOfSquares += in * in; | |
115 in = *pSrc++; | |
116 sum += in; | |
117 sumOfSquares += in * in; | |
118 in = *pSrc++; | |
119 sum += in; | |
120 sumOfSquares += in * in; | |
121 in = *pSrc++; | |
122 sum += in; | |
123 sumOfSquares += in * in; | |
124 | |
125 /* Decrement the loop counter */ | |
126 blkCnt--; | |
127 } | |
128 | |
129 /* If the blockSize is not a multiple of 4, compute any remaining output samples here. | |
130 ** No loop unrolling is used. */ | |
131 blkCnt = blockSize % 0x4u; | |
132 | |
133 while(blkCnt > 0u) | |
134 { | |
135 /* C = (A[0] * A[0] + A[1] * A[1] + ... + A[blockSize-1] * A[blockSize-1]) */ | |
136 /* Compute Sum of squares of the input samples | |
137 * and then store the result in a temporary variable, sum. */ | |
138 in = *pSrc++; | |
139 sum += in; | |
140 sumOfSquares += in * in; | |
141 | |
142 /* Decrement the loop counter */ | |
143 blkCnt--; | |
144 } | |
145 | |
146 /* Compute Mean of squares of the input samples | |
147 * and then store the result in a temporary variable, meanOfSquares. */ | |
148 meanOfSquares = sumOfSquares / ((float32_t) blockSize - 1.0f); | |
149 | |
150 /* Compute mean of all input values */ | |
151 mean = sum / (float32_t) blockSize; | |
152 | |
153 /* Compute square of mean */ | |
154 squareOfMean = (mean * mean) * (((float32_t) blockSize) / | |
155 ((float32_t) blockSize - 1.0f)); | |
156 | |
157 /* Compute standard deviation and then store the result to the destination */ | |
158 arm_sqrt_f32((meanOfSquares - squareOfMean), pResult); | |
159 | |
160 #else | |
161 | |
162 /* Run the below code for Cortex-M0 */ | |
163 | |
164 float32_t squareOfSum; /* Square of Sum */ | |
165 float32_t var; /* Temporary varaince storage */ | |
166 | |
167 if(blockSize == 1) | |
168 { | |
169 *pResult = 0; | |
170 return; | |
171 } | |
172 | |
173 /* Loop over blockSize number of values */ | |
174 blkCnt = blockSize; | |
175 | |
176 while(blkCnt > 0u) | |
177 { | |
178 /* C = (A[0] * A[0] + A[1] * A[1] + ... + A[blockSize-1] * A[blockSize-1]) */ | |
179 /* Compute Sum of squares of the input samples | |
180 * and then store the result in a temporary variable, sumOfSquares. */ | |
181 in = *pSrc++; | |
182 sumOfSquares += in * in; | |
183 | |
184 /* C = (A[0] + A[1] + ... + A[blockSize-1]) */ | |
185 /* Compute Sum of the input samples | |
186 * and then store the result in a temporary variable, sum. */ | |
187 sum += in; | |
188 | |
189 /* Decrement the loop counter */ | |
190 blkCnt--; | |
191 } | |
192 | |
193 /* Compute the square of sum */ | |
194 squareOfSum = ((sum * sum) / (float32_t) blockSize); | |
195 | |
196 /* Compute the variance */ | |
197 var = ((sumOfSquares - squareOfSum) / (float32_t) (blockSize - 1.0f)); | |
198 | |
199 /* Compute standard deviation and then store the result to the destination */ | |
200 arm_sqrt_f32(var, pResult); | |
201 | |
202 #endif /* #ifndef ARM_MATH_CM0_FAMILY */ | |
203 | |
204 } | |
205 | |
206 /** | |
207 * @} end of STD group | |
208 */ |