lib/main/CMSIS/DSP/Source/StatisticsFunctions/arm_var_f32.c

   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  */