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

25
Source/ControllerFunctions/arm_sin_cos_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_sin_cos_f32.c * Title: arm_sin_cos_f32.c
@ -89,23 +89,18 @@ void arm_sin_cos_f32(
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;
/* Calculation of floor value of input */
n = (int32_t) in;
/* Make negative values towards -infinity */
if (in < 0.0f) if (in < 0.0f)
{ {
n--; in = -in;
} }
/* Map input value to [0 1] */
in = in - (float32_t) n; in = in - (int32_t)in;
/* Calculation of index of the table */ /* Calculation of index of the table */
findex = (float32_t) FAST_MATH_TABLE_SIZE * in; findex = (float32_t) FAST_MATH_TABLE_SIZE * in;
@ -121,8 +116,11 @@ void arm_sin_cos_f32(
d1 = -sinTable_f32[indexS+0]; d1 = -sinTable_f32[indexS+0];
d2 = -sinTable_f32[indexS+1]; d2 = -sinTable_f32[indexS+1];
temp = (1.0f - fract) * f1 + fract * f2;
Dn = 0.0122718463030f; // delta between the two points (fixed), in this case 2*pi/FAST_MATH_TABLE_SIZE Dn = 0.0122718463030f; // delta between the two points (fixed), in this case 2*pi/FAST_MATH_TABLE_SIZE
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;
@ -136,6 +134,8 @@ void arm_sin_cos_f32(
d1 = sinTable_f32[indexC+0]; d1 = sinTable_f32[indexC+0];
d2 = sinTable_f32[indexC+1]; 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);
@ -143,6 +143,11 @@ void arm_sin_cos_f32(
/* 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

128
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.
@ -80,23 +79,23 @@ void arm_var_f32(
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 */
float32_t in; /* input value */
uint32_t blkCnt; /* loop counter */ uint32_t blkCnt; /* loop counter */
#ifndef ARM_MATH_CM0_FAMILY float32_t * pInput = pSrc;
float32_t meanOfSquares, mean, squareOfMean; /* Temporary variables */ float32_t sum = 0.0f;
#else float32_t fSum = 0.0f;
float32_t squareOfSum; /* Square of Sum */ #if !defined(ARM_MATH_CM0_FAMILY) && !defined(ARM_MATH_CM3_FAMILY)
float32_t in1, in2, in3, in4;
#endif #endif
if(blockSize == 1u) if (blockSize <= 1u)
{ {
*pResult = 0; *pResult = 0;
return; return;
} }
#ifndef ARM_MATH_CM0_FAMILY #if !defined(ARM_MATH_CM0_FAMILY) && !defined(ARM_MATH_CM3_FAMILY)
/* Run the below code for Cortex-M4 and Cortex-M7 */
/*loop Unrolling */ /*loop Unrolling */
blkCnt = blockSize >> 2u; blkCnt = blockSize >> 2u;
@ -105,21 +104,16 @@ void arm_var_f32(
** 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;
in = *pSrc++;
sum += in;
sumOfSquares += in * in;
/* Decrement the loop counter */ /* Decrement the loop counter */
blkCnt--; blkCnt--;
@ -129,63 +123,69 @@ void arm_var_f32(
** No loop unrolling is used. */ ** No loop unrolling is used. */
blkCnt = blockSize % 0x4u; blkCnt = blockSize % 0x4u;
#else
/* Run the below code for Cortex-M0 or Cortex-M3 */
/* Loop over blockSize number of values */
blkCnt = blockSize;
#endif
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 sum += *pInput++;
* and then store the result in a temporary variable, sum. */
in = *pSrc++;
sum += in;
sumOfSquares += in * in;
/* Decrement the loop counter */ /* Decrement the loop counter */
blkCnt--; blkCnt--;
} }
/* Compute Mean of squares of the input samples /* C = (A[0] + A[1] + A[2] + ... + A[blockSize-1]) / blockSize */
* and then store the result in a temporary variable, meanOfSquares. */ fMean = sum / (float32_t) blockSize;
meanOfSquares = sumOfSquares / ((float32_t) blockSize - 1.0f);
/* Compute mean of all input values */ pInput = pSrc;
mean = sum / (float32_t) blockSize;
/* Compute square of mean */ #if !defined(ARM_MATH_CM0_FAMILY) && !defined(ARM_MATH_CM3_FAMILY)
squareOfMean = (mean * mean) * (((float32_t) blockSize) /
((float32_t) blockSize - 1.0f));
/* Compute variance and then store the result to the destination */ /*loop Unrolling */
*pResult = meanOfSquares - squareOfMean; blkCnt = blockSize >> 2u;
/* 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. */
while (blkCnt > 0u)
{
fValue = *pInput++ - fMean;
fSum += fValue * fValue;
fValue = *pInput++ - fMean;
fSum += fValue * fValue;
fValue = *pInput++ - fMean;
fSum += fValue * fValue;
fValue = *pInput++ - fMean;
fSum += fValue * fValue;
/* Decrement the loop counter */
blkCnt--;
}
blkCnt = blockSize % 0x4u;
#else #else
/* Run the below code for Cortex-M0 */ /* Run the below code for Cortex-M0 or Cortex-M3 */
/* Loop over blockSize number of values */ /* Loop over blockSize number of values */
blkCnt = blockSize; blkCnt = blockSize;
#endif
while (blkCnt > 0u) while (blkCnt > 0u)
{ {
/* C = (A[0] * A[0] + A[1] * A[1] + ... + A[blockSize-1] * A[blockSize-1]) */ fValue = *pInput++ - fMean;
/* Compute Sum of squares of the input samples fSum += fValue * fValue;
* and then store the result in a temporary variable, sumOfSquares. */
in = *pSrc++;
sumOfSquares += in * in;
/* C = (A[0] + A[1] + ... + A[blockSize-1]) */
/* Compute Sum of the input samples
* and then store the result in a temporary variable, sum. */
sum += in;
/* Decrement the loop counter */ /* Decrement the loop counter */
blkCnt--; blkCnt--;
} }
/* Compute the square of sum */ /* Variance */
squareOfSum = ((sum * sum) / (float32_t) blockSize); *pResult = fSum / (float32_t)(blockSize - 1.0f);
/* Compute the variance */
*pResult = ((sumOfSquares - squareOfSum) / (float32_t) (blockSize - 1.0f));
#endif /* #ifndef ARM_MATH_CM0_FAMILY */
} }
/** /**

Write Preview
Loading…
Cancel
Save