dengzhihao
/
CMSIS-DSP
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

updated DSP_Lib files arm_sin_cos_f32.c, arm_var_f32.c.

Browse Source
pull/19/head
Martin Günther 9 years ago
parent 38abd8cf9f
commit 7a41fd0818
2 changed files with 227 additions and 222 deletions
Show Stats Download Patch File Download Diff File

219
Source/ControllerFunctions/arm_sin_cos_f32.c
Unescape Escape View File

@ -1,24 +1,24 @@
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
* Copyright (C) 2010-2014 ARM Limited. All rights reserved. * Copyright (C) 2010-2014 ARM Limited. All rights reserved.
* *
* $Date: 19. March 2015 * $Date: 22. December 2016
* $Revision: V.1.4.5 * $Revision: V.1.4.5 a
* *
* Project: CMSIS DSP Library * Project: CMSIS DSP Library
* Title: arm_sin_cos_f32.c * Title: arm_sin_cos_f32.c
* *
* Description: Sine and Cosine calculation for floating-point values. * Description: Sine and Cosine calculation for floating-point values.
* *
* Target Processor: Cortex-M4/Cortex-M3/Cortex-M0 * Target Processor: Cortex-M4/Cortex-M3/Cortex-M0
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions * modification, are permitted provided that the following conditions
* are met: * are met:
* - Redistributions of source code must retain the above copyright * - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer. * notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright * - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in * notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the * the documentation and/or other materials provided with the
* distribution. * distribution.
* - Neither the name of ARM LIMITED nor the names of its contributors * - Neither the name of ARM LIMITED nor the names of its contributors
* may be used to endorse or promote products derived from this * may be used to endorse or promote products derived from this
@ -27,7 +27,7 @@
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
@ -35,115 +35,120 @@
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE. * POSSIBILITY OF SUCH DAMAGE.
* -------------------------------------------------------------------- */ * -------------------------------------------------------------------- */
#include "arm_math.h" #include "arm_math.h"
#include "arm_common_tables.h" #include "arm_common_tables.h"
/** /**
* @ingroup groupController * @ingroup groupController
*/ */
/** /**
* @defgroup SinCos Sine Cosine * @defgroup SinCos Sine Cosine
* *
* Computes the trigonometric sine and cosine values using a combination of table lookup * Computes the trigonometric sine and cosine values using a combination of table lookup
* and linear interpolation. * and linear interpolation.
* There are separate functions for Q31 and floating-point data types. * There are separate functions for Q31 and floating-point data types.
* The input to the floating-point version is in degrees while the * The input to the floating-point version is in degrees while the
* fixed-point Q31 have a scaled input with the range * fixed-point Q31 have a scaled input with the range
* [-1 0.9999] mapping to [-180 +180] degrees. * [-1 0.9999] mapping to [-180 +180] degrees.
* *
* The floating point function also allows values that are out of the usual range. When this happens, the function will * The floating point function also allows values that are out of the usual range. When this happens, the function will
* take extra time to adjust the input value to the range of [-180 180]. * take extra time to adjust the input value to the range of [-180 180].
* *
* The implementation is based on table lookup using 360 values together with linear interpolation. * The implementation is based on table lookup using 360 values together with linear interpolation.
* The steps used are: * The steps used are:
* -# Calculation of the nearest integer table index. * -# Calculation of the nearest integer table index.
* -# Compute the fractional portion (fract) of the input. * -# Compute the fractional portion (fract) of the input.
* -# Fetch the value corresponding to \c index from sine table to \c y0 and also value from \c index+1 to \c y1. * -# Fetch the value corresponding to \c index from sine table to \c y0 and also value from \c index+1 to \c y1.
* -# Sine value is computed as <code> *psinVal = y0 + (fract * (y1 - y0))</code>. * -# Sine value is computed as <code> *psinVal = y0 + (fract * (y1 - y0))</code>.
* -# Fetch the value corresponding to \c index from cosine table to \c y0 and also value from \c index+1 to \c y1. * -# Fetch the value corresponding to \c index from cosine table to \c y0 and also value from \c index+1 to \c y1.
* -# Cosine value is computed as <code> *pcosVal = y0 + (fract * (y1 - y0))</code>. * -# Cosine value is computed as <code> *pcosVal = y0 + (fract * (y1 - y0))</code>.
*/ */
/** /**
* @addtogroup SinCos * @addtogroup SinCos
* @{ * @{
*/ */
/** /**
* @brief Floating-point sin_cos function. * @brief Floating-point sin_cos function.
* @param[in] theta input value in degrees * @param[in] theta input value in degrees
* @param[out] *pSinVal points to the processed sine output. * @param[out] *pSinVal points to the processed sine output.
* @param[out] *pCosVal points to the processed cos output. * @param[out] *pCosVal points to the processed cos output.
* @return none. * @return none.
*/ */
void arm_sin_cos_f32( void arm_sin_cos_f32(
float32_t theta, float32_t theta,
float32_t * pSinVal, float32_t * pSinVal,
float32_t * pCosVal) float32_t * pCosVal)
{ {
float32_t fract, in; /* Temporary variables for input, output */ float32_t fract, in; /* Temporary variables for input, output */
uint16_t indexS, indexC; /* Index variable */ uint16_t indexS, indexC; /* Index variable */
float32_t f1, f2, d1, d2; /* Two nearest output values */ float32_t f1, f2, d1, d2; /* Two nearest output values */
int32_t n; float32_t findex, Dn, Df, temp;
float32_t findex, Dn, Df, temp;
/* input x is in degrees */
/* input x is in degrees */ /* Scale the input, divide input by 360, for cosine add 0.25 (pi/2) to read sine table */
/* Scale the input, divide input by 360, for cosine add 0.25 (pi/2) to read sine table */ in = theta * 0.00277777777778f;
in = theta * 0.00277777777778f;
if (in < 0.0f)
/* Calculation of floor value of input */ {
n = (int32_t) in; in = -in;
}
/* Make negative values towards -infinity */
if(in < 0.0f) in = in - (int32_t)in;
{
n--; /* Calculation of index of the table */
} findex = (float32_t) FAST_MATH_TABLE_SIZE * in;
/* Map input value to [0 1] */ indexS = ((uint16_t)findex) & 0x1ff;
in = in - (float32_t) n; indexC = (indexS + (FAST_MATH_TABLE_SIZE / 4)) & 0x1ff;
/* Calculation of index of the table */ /* fractional value calculation */
findex = (float32_t) FAST_MATH_TABLE_SIZE * in; fract = findex - (float32_t) indexS;
indexS = ((uint16_t)findex) & 0x1ff;
indexC = (indexS + (FAST_MATH_TABLE_SIZE / 4)) & 0x1ff; /* Read two nearest values of input value from the cos & sin tables */
f1 = sinTable_f32[indexC+0];
/* fractional value calculation */ f2 = sinTable_f32[indexC+1];
fract = findex - (float32_t) indexS; d1 = -sinTable_f32[indexS+0];
d2 = -sinTable_f32[indexS+1];
/* Read two nearest values of input value from the cos & sin tables */
f1 = sinTable_f32[indexC+0]; temp = (1.0f - fract) * f1 + fract * f2;
f2 = sinTable_f32[indexC+1];
d1 = -sinTable_f32[indexS+0]; Dn = 0.0122718463030f; // delta between the two points (fixed), in this case 2*pi/FAST_MATH_TABLE_SIZE
d2 = -sinTable_f32[indexS+1]; Df = f2 - f1; // delta between the values of the functions
Dn = 0.0122718463030f; // delta between the two points (fixed), in this case 2*pi/FAST_MATH_TABLE_SIZE temp = Dn *(d1 + d2) - 2 * Df;
Df = f2 - f1; // delta between the values of the functions temp = fract * temp + (3 * Df - (d2 + 2 * d1) * Dn);
temp = Dn*(d1 + d2) - 2*Df; temp = fract * temp + d1 * Dn;
temp = fract*temp + (3*Df - (d2 + 2*d1)*Dn);
temp = fract*temp + d1*Dn; /* Calculation of cosine value */
*pCosVal = fract * temp + f1;
/* Calculation of cosine value */
*pCosVal = fract*temp + f1; /* Read two nearest values of input value from the cos & sin tables */
f1 = sinTable_f32[indexS+0];
/* Read two nearest values of input value from the cos & sin tables */ f2 = sinTable_f32[indexS+1];
f1 = sinTable_f32[indexS+0]; d1 = sinTable_f32[indexC+0];
f2 = sinTable_f32[indexS+1]; d2 = sinTable_f32[indexC+1];
d1 = sinTable_f32[indexC+0];
d2 = sinTable_f32[indexC+1]; temp = (1.0f - fract) * f1 + fract * f2;
Df = f2 - f1; // delta between the values of the functions Df = f2 - f1; // delta between the values of the functions
temp = Dn*(d1 + d2) - 2*Df; temp = Dn*(d1 + d2) - 2*Df;
temp = fract*temp + (3*Df - (d2 + 2*d1)*Dn); temp = fract*temp + (3*Df - (d2 + 2*d1)*Dn);
temp = fract*temp + d1*Dn; temp = fract*temp + d1*Dn;
/* Calculation of sine value */ /* Calculation of sine value */
*pSinVal = fract*temp + f1; *pSinVal = fract*temp + f1;
if (theta < 0.0f)
{
*pSinVal = -*pSinVal;
}
} }
/** /**
* @} end of SinCos group * @} end of SinCos group
*/ */

230
Source/StatisticsFunctions/arm_var_f32.c
Unescape Escape View File

@ -1,8 +1,8 @@
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
* Copyright (C) 2010-2014 ARM Limited. All rights reserved. * Copyright (C) 2010-2014 ARM Limited. All rights reserved.
* *
* $Date: 19. March 2015 * $Date: 22. December 2016
* $Revision: V.1.4.5 * $Revision: V.1.4.5 a
* *
* Project: CMSIS DSP Library * Project: CMSIS DSP Library
* Title: arm_var_f32.c * Title: arm_var_f32.c
@ -48,14 +48,13 @@
* @defgroup variance Variance * @defgroup variance Variance
* *
* Calculates the variance of the elements in the input vector. * Calculates the variance of the elements in the input vector.
* The underlying algorithm is used: * The underlying algorithm used is the direct method sometimes referred to as the two-pass method:
* *
* <pre> * <pre>
* Result = (sumOfSquares - sum<sup>2</sup> / blockSize) / (blockSize - 1) * Result = sum(element - meanOfElements)^2) / numElement - 1
* *
* where, sumOfSquares = pSrc[0] * pSrc[0] + pSrc[1] * pSrc[1] + ... + pSrc[blockSize-1] * pSrc[blockSize-1] * where, meanOfElements = ( pSrc[0] * pSrc[0] + pSrc[1] * pSrc[1] + ... + pSrc[blockSize-1] ) / blockSize
* *
* sum = pSrc[0] + pSrc[1] + pSrc[2] + ... + pSrc[blockSize-1]
* </pre> * </pre>
* *
* There are separate functions for floating point, Q31, and Q15 data types. * There are separate functions for floating point, Q31, and Q15 data types.
@ -76,116 +75,117 @@
*/ */
void arm_var_f32( void arm_var_f32(
float32_t * pSrc, float32_t * pSrc,
uint32_t blockSize, uint32_t blockSize,
float32_t * pResult) float32_t * pResult)
{ {
float32_t sum = 0.0f; /* Temporary result storage */ float32_t fMean, fValue;
float32_t sumOfSquares = 0.0f; /* Sum of squares */ uint32_t blkCnt; /* loop counter */
float32_t in; /* input value */ float32_t * pInput = pSrc;
uint32_t blkCnt; /* loop counter */ float32_t sum = 0.0f;
#ifndef ARM_MATH_CM0_FAMILY float32_t fSum = 0.0f;
float32_t meanOfSquares, mean, squareOfMean; /* Temporary variables */ #if !defined(ARM_MATH_CM0_FAMILY) && !defined(ARM_MATH_CM3_FAMILY)
#else float32_t in1, in2, in3, in4;
float32_t squareOfSum; /* Square of Sum */ #endif
#endif
if (blockSize <= 1u)
if(blockSize == 1u) {
{ *pResult = 0;
*pResult = 0; return;
return; }
}
#if !defined(ARM_MATH_CM0_FAMILY) && !defined(ARM_MATH_CM3_FAMILY)
#ifndef ARM_MATH_CM0_FAMILY /* Run the below code for Cortex-M4 and Cortex-M7 */
/*loop Unrolling */ /*loop Unrolling */
blkCnt = blockSize >> 2u; blkCnt = blockSize >> 2u;
/* First part of the processing with loop unrolling. Compute 4 outputs at a time. /* First part of the processing with loop unrolling. Compute 4 outputs at a time.
** a second loop below computes the remaining 1 to 3 samples. */ ** a second loop below computes the remaining 1 to 3 samples. */
while(blkCnt > 0u) while (blkCnt > 0u)
{ {
/* C = (A[0] * A[0] + A[1] * A[1] + ... + A[blockSize-1] * A[blockSize-1]) */ /* C = (A[0] + A[1] + A[2] + ... + A[blockSize-1]) */
/* Compute Sum of squares of the input samples in1 = *pInput++;
* and then store the result in a temporary variable, sum. */ in2 = *pInput++;
in = *pSrc++; in3 = *pInput++;
sum += in; in4 = *pInput++;
sumOfSquares += in * in;
in = *pSrc++; sum += in1;
sum += in; sum += in2;
sumOfSquares += in * in; sum += in3;
in = *pSrc++; sum += in4;
sum += in;
sumOfSquares += in * in; /* Decrement the loop counter */
in = *pSrc++; blkCnt--;
sum += in; }
sumOfSquares += in * in;
/* If the blockSize is not a multiple of 4, compute any remaining output samples here.
/* Decrement the loop counter */ ** No loop unrolling is used. */
blkCnt--; blkCnt = blockSize % 0x4u;
}
#else
/* If the blockSize is not a multiple of 4, compute any remaining output samples here. /* Run the below code for Cortex-M0 or Cortex-M3 */
** No loop unrolling is used. */
blkCnt = blockSize % 0x4u; /* Loop over blockSize number of values */
blkCnt = blockSize;
while(blkCnt > 0u)
{ #endif
/* C = (A[0] * A[0] + A[1] * A[1] + ... + A[blockSize-1] * A[blockSize-1]) */
/* Compute Sum of squares of the input samples while (blkCnt > 0u)
* and then store the result in a temporary variable, sum. */ {
in = *pSrc++; /* C = (A[0] + A[1] + A[2] + ... + A[blockSize-1]) */
sum += in; sum += *pInput++;
sumOfSquares += in * in;
/* Decrement the loop counter */
/* Decrement the loop counter */ blkCnt--;
blkCnt--; }
}
/* C = (A[0] + A[1] + A[2] + ... + A[blockSize-1]) / blockSize */
/* Compute Mean of squares of the input samples fMean = sum / (float32_t) blockSize;
* and then store the result in a temporary variable, meanOfSquares. */
meanOfSquares = sumOfSquares / ((float32_t) blockSize - 1.0f); pInput = pSrc;
/* Compute mean of all input values */ #if !defined(ARM_MATH_CM0_FAMILY) && !defined(ARM_MATH_CM3_FAMILY)
mean = sum / (float32_t) blockSize;
/*loop Unrolling */
/* Compute square of mean */ blkCnt = blockSize >> 2u;
squareOfMean = (mean * mean) * (((float32_t) blockSize) /
((float32_t) blockSize - 1.0f)); /* First part of the processing with loop unrolling. Compute 4 outputs at a time.
** a second loop below computes the remaining 1 to 3 samples. */
/* Compute variance and then store the result to the destination */ while (blkCnt > 0u)
*pResult = meanOfSquares - squareOfMean; {
fValue = *pInput++ - fMean;
#else fSum += fValue * fValue;
/* Run the below code for Cortex-M0 */ fValue = *pInput++ - fMean;
fSum += fValue * fValue;
/* Loop over blockSize number of values */ fValue = *pInput++ - fMean;
blkCnt = blockSize; fSum += fValue * fValue;
fValue = *pInput++ - fMean;
while(blkCnt > 0u) fSum += fValue * fValue;
{
/* C = (A[0] * A[0] + A[1] * A[1] + ... + A[blockSize-1] * A[blockSize-1]) */ /* Decrement the loop counter */
/* Compute Sum of squares of the input samples blkCnt--;
* and then store the result in a temporary variable, sumOfSquares. */ }
in = *pSrc++;
sumOfSquares += in * in; blkCnt = blockSize % 0x4u;
#else
/* C = (A[0] + A[1] + ... + A[blockSize-1]) */ /* Run the below code for Cortex-M0 or Cortex-M3 */
/* Compute Sum of the input samples
* and then store the result in a temporary variable, sum. */ /* Loop over blockSize number of values */
sum += in; blkCnt = blockSize;
#endif
/* Decrement the loop counter */
blkCnt--; while (blkCnt > 0u)
} {
fValue = *pInput++ - fMean;
/* Compute the square of sum */ fSum += fValue * fValue;
squareOfSum = ((sum * sum) / (float32_t) blockSize);
/* Decrement the loop counter */
/* Compute the variance */ blkCnt--;
*pResult = ((sumOfSquares - squareOfSum) / (float32_t) (blockSize - 1.0f)); }
#endif /* #ifndef ARM_MATH_CM0_FAMILY */ /* Variance */
*pResult = fSum / (float32_t)(blockSize - 1.0f);
} }
/** /**

Write Preview
Loading…
Cancel
Save