Subversion Repositories dashGPS

Rev

Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 mjames 1 
/* ----------------------------------------------------------------------
2 
 * Project:      CMSIS DSP Library
3 
 * Title:        arm_var_f32.c
4 
 * Description:  Variance of the elements of a floating-point vector
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 groupStats
33 
 */
34 
 
35 
/**
36 
 * @defgroup variance  Variance
37 
 *
38 
 * Calculates the variance of the elements in the input vector.
39 
 * The underlying algorithm used is the direct method sometimes referred to as the two-pass method:
40 
 *
41 
 * <pre>
42 
 *   Result = sum(element - meanOfElements)^2) / numElement - 1
43 
 *
44 
 *     where, meanOfElements = ( pSrc[0] * pSrc[0] + pSrc[1] * pSrc[1] + ... + pSrc[blockSize-1] ) / blockSize
45 
 *
46 
 * </pre>
47 
 *
48 
 * There are separate functions for floating point, Q31, and Q15 data types.
49 
 */
50 
 
51 
/**
52 
 * @addtogroup variance
53 
 * @{
54 
 */
55 
 
56 
 
57 
/**
58 
 * @brief Variance of the elements of a floating-point vector.
59 
 * @param[in]       *pSrc points to the input vector
60 
 * @param[in]       blockSize length of the input vector
61 
 * @param[out]      *pResult variance value returned here
62 
 * @return none.
63 
 */
64 
 
65 
void arm_var_f32(
66 
                 float32_t * pSrc,
67 
                 uint32_t blockSize,
68 
                 float32_t * pResult)
69 
{
70 
    float32_t fMean, fValue;
71 
    uint32_t blkCnt;            /* loop counter */
72 
    float32_t * pInput = pSrc;
73 
    float32_t sum = 0.0f;
74 
    float32_t fSum = 0.0f;
75 
    #if defined(ARM_MATH_DSP)
76 
    float32_t in1, in2, in3, in4;
77 
    #endif
78 
 
79 
    if (blockSize <= 1U)
80 
    {
81 
        *pResult = 0;
82 
        return;
83 
    }
84 
 
85 
    #if defined(ARM_MATH_DSP)
86 
        /* Run the below code for Cortex-M4 and Cortex-M7 */
87 
 
88 
        /*loop Unrolling */
89 
        blkCnt = blockSize >> 2U;
90 
 
91 
        /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.
92 
        ** a second loop below computes the remaining 1 to 3 samples. */
93 
        while (blkCnt > 0U)
94 
        {
95 
            /* C = (A[0] + A[1] + A[2] + ... + A[blockSize-1]) */
96 
            in1 = *pInput++;
97 
            in2 = *pInput++;
98 
            in3 = *pInput++;
99 
            in4 = *pInput++;
100 
 
101 
            sum += in1;
102 
            sum += in2;
103 
            sum += in3;
104 
            sum += in4;
105 
 
106 
            /* Decrement the loop counter */
107 
            blkCnt--;
108 
        }
109 
 
110 
        /* If the blockSize is not a multiple of 4, compute any remaining output samples here.
111 
        ** No loop unrolling is used. */
112 
        blkCnt = blockSize % 0x4U;
113 
 
114 
    #else
115 
        /* Run the below code for Cortex-M0 or Cortex-M3 */
116 
 
117 
        /* Loop over blockSize number of values */
118 
        blkCnt = blockSize;
119 
 
120 
    #endif
121 
 
122 
    while (blkCnt > 0U)
123 
    {
124 
        /* C = (A[0] + A[1] + A[2] + ... + A[blockSize-1]) */
125 
        sum += *pInput++;
126 
 
127 
        /* Decrement the loop counter */
128 
        blkCnt--;
129 
    }
130 
 
131 
    /* C = (A[0] + A[1] + A[2] + ... + A[blockSize-1]) / blockSize  */
132 
    fMean = sum / (float32_t) blockSize;
133 
 
134 
    pInput = pSrc;
135 
 
136 
    #if defined(ARM_MATH_DSP)
137 
 
138 
        /*loop Unrolling */
139 
        blkCnt = blockSize >> 2U;
140 
 
141 
        /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.
142 
        ** a second loop below computes the remaining 1 to 3 samples. */
143 
        while (blkCnt > 0U)
144 
        {
145 
            fValue = *pInput++ - fMean;
146 
            fSum += fValue * fValue;
147 
            fValue = *pInput++ - fMean;
148 
            fSum += fValue * fValue;
149 
            fValue = *pInput++ - fMean;
150 
            fSum += fValue * fValue;
151 
            fValue = *pInput++ - fMean;
152 
            fSum += fValue * fValue;
153 
 
154 
            /* Decrement the loop counter */
155 
            blkCnt--;
156 
        }
157 
 
158 
        blkCnt = blockSize % 0x4U;
159 
    #else
160 
        /* Run the below code for Cortex-M0 or Cortex-M3 */
161 
 
162 
        /* Loop over blockSize number of values */
163 
        blkCnt = blockSize;
164 
    #endif
165 
 
166 
    while (blkCnt > 0U)
167 
    {
168 
        fValue = *pInput++ - fMean;
169 
        fSum += fValue * fValue;
170 
 
171 
        /* Decrement the loop counter */
172 
        blkCnt--;
173 
    }
174 
 
175 
    /* Variance */
176 
    *pResult = fSum / (float32_t)(blockSize - 1.0f);
177 
}
178 
 
179 
/**
180 
 * @} end of variance group
181 
 */