CMSIS-DSP: Added new tests for Biquads.

Added MVE code for Biquads.

CMSIS/DSP/Include/arm_math.h

@@ -1904,6 +1904,16 @@ __STATIC_INLINE q31_t arm_div_q63_to_q31(q63_t num, q31_t den)
     const float32_t *pCoeffs;      /**< Points to the array of coefficients.  The array is of length 5*numStages. */
   } arm_biquad_casd_df1_inst_f32;
 
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+  /**
+   * @brief Instance structure for the modified Biquad coefs required by vectorized code.
+   */
+  typedef struct
+  {
+      float32_t coeffs[8][4]; /**< Points to the array of modified coefficients.  The array is of length 32. There is one per stage */
+  } arm_biquad_mod_coef_f32;
+#endif 
+
   /**
    * @brief Processing function for the Q15 Biquad cascade filter.
    * @param[in]  S          points to an instance of the Q15 Biquad cascade structure.
@@ -2004,14 +2014,25 @@ __STATIC_INLINE q31_t arm_div_q63_to_q31(q63_t num, q31_t den)
    * @param[in,out] S          points to an instance of the floating-point Biquad cascade structure.
    * @param[in]     numStages  number of 2nd order stages in the filter.
    * @param[in]     pCoeffs    points to the filter coefficients.
+   * @param[in]     pCoeffsMod points to the modified filter coefficients (only MVE version).
    * @param[in]     pState     points to the state buffer.
    */
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+  void arm_biquad_cascade_df1_mve_init_f32(
+      arm_biquad_casd_df1_inst_f32 * S,
+      uint8_t numStages,
+      const float32_t * pCoeffs, 
+      arm_biquad_mod_coef_f32 * pCoeffsMod, 
+      float32_t * pState);
+#endif
+  
   void arm_biquad_cascade_df1_init_f32(
         arm_biquad_casd_df1_inst_f32 * S,
         uint8_t numStages,
   const float32_t * pCoeffs,
         float32_t * pState);
 
+
   /**
    * @brief Instance structure for the floating-point matrix structure.
    */

CMSIS/DSP/Source/FilteringFunctions/arm_biquad_cascade_df1_32x64_q31.c

@@ -172,6 +172,241 @@
                    - \ref arm_biquad_cascade_df1_fast_q31() implements a Biquad cascade with 32-bit coefficients and state variables with a Q31 accumulator.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+#include "arm_helium_utils.h"
+void arm_biquad_cas_df1_32x64_q31(
+  const arm_biquad_cas_df1_32x64_ins_q31 * S,
+        q31_t * pSrc,
+        q31_t * pDst,
+        uint32_t blockSize)
+{
+    const q31_t *pIn = pSrc;    /*  input pointer initialization  */
+    q31_t    *pOut = pDst;      /*  output pointer initialization */
+    q63_t    *pState = S->pState;   /*  state pointer initialization  */
+    const q31_t    *pCoeffs = S->pCoeffs; /*  coeff pointer initialization  */
+    q31_t     Xn1, Xn2;         /*  Input Filter state variables        */
+    q63_t     Yn1, Yn2;         /*  Output Filter state variables        */
+    q31_t     b0, b1, b2, a1, a2;   /*  Filter coefficients           */
+    int32_t   shift = (int32_t) S->postShift + 1;   /*  Shift to be applied to the output */
+    uint32_t  sample, stage = S->numStages; /*  loop counters                     */
+    q31x4_t vecCoef, vecIn;
+    q63_t     acc;
+
+    do
+    {
+        uint32_t  i;
+        /*
+         * Reading the coefficients
+         */
+        b0 = *pCoeffs++;
+        b1 = *pCoeffs++;
+        b2 = *pCoeffs++;
+        a1 = *pCoeffs++;
+        a2 = *pCoeffs++;
+
+        vecCoef[0] = 0;
+        vecCoef[1] = b2;
+        vecCoef[2] = b1;
+        vecCoef[3] = b0;
+        /*
+         * Reading the state values
+         */
+        Xn1 = pState[0];
+        Xn2 = pState[1];
+        Yn1 = pState[2];
+        Yn2 = pState[3];
+
+        /*
+         * append history with initial samples
+         */
+        q31_t     hist[6];
+        hist[0] = 0;
+        hist[1] = Xn2;
+        hist[2] = Xn1;
+        hist[3] = pIn[0];
+        hist[4] = pIn[1];
+        hist[5] = pIn[2];
+
+        const q31_t  *pIn1 = hist;
+        q31x4_t vecIn0 = *(q31x4_t *) & pIn[0];
+        q31x4_t vecIn1 = *(q31x4_t *) & pIn[1];
+        q31x4_t vecIn2 = *(q31x4_t *) & pIn[2];
+
+        i = 3;
+        do
+        {
+            acc = mult32x64(Yn1, a1);
+            acc += mult32x64(Yn2, a2);
+            Yn2 = Yn1;
+            Yn1 = acc;
+            vecIn = vld1q(pIn1);
+            pIn1 += 1;
+            Yn1 = vmlaldavaq(Yn1, vecIn, vecCoef);
+            Yn1 = asrl(Yn1, -shift);
+            /*
+             * Store the output in the destination buffer in 1.31 format.
+             */
+            *pOut++ = (q31_t) (Yn1 >> 32);
+        }
+        while (--i);
+
+        sample = blockSize - 3;
+        pIn1 = pIn + 3;
+
+        i = sample / 4;
+        while (i > 0U)
+        {
+
+            acc = mult32x64(Yn1, a1);
+            acc += mult32x64(Yn2, a2);
+            Yn2 = Yn1;
+            Yn1 = acc;
+            Yn1 = vmlaldavaq(Yn1, vecIn0, vecCoef);
+            vecIn = vld1q(pIn1);
+            pIn1 += 1;
+            Yn1 = asrl(Yn1, -shift);
+            /*
+             * Store the output in the destination buffer in 1.31 format.
+             */
+            *pOut++ = (q31_t) (Yn1 >> 32);
+
+            acc = mult32x64(Yn1, a1);
+            acc += mult32x64(Yn2, a2);
+            Yn2 = Yn1;
+            Yn1 = acc;
+            Yn1 = vmlaldavaq(Yn1, vecIn1, vecCoef);
+            vecIn0 = vld1q(pIn1);
+            pIn1 += 1;
+            Yn1 = asrl(Yn1, -shift);
+            *pOut++ = (q31_t) (Yn1 >> 32);
+
+            acc = mult32x64(Yn1, a1);
+            acc += mult32x64(Yn2, a2);
+            Yn2 = Yn1;
+            Yn1 = acc;
+            Yn1 = vmlaldavaq(Yn1, vecIn2, vecCoef);
+            vecIn1 = vld1q(pIn1);
+            pIn1 += 1;
+            Yn1 = asrl(Yn1, -shift);
+            *pOut++ = (q31_t) (Yn1 >> 32);
+
+            acc = mult32x64(Yn1, a1);
+            acc += mult32x64(Yn2, a2);
+            Yn2 = Yn1;
+            Yn1 = acc;
+            Yn1 = vmlaldavaq(Yn1, vecIn, vecCoef);
+            vecIn2 = vld1q(pIn1);
+            pIn1 += 1;
+            Yn1 = asrl(Yn1, -shift);
+            *pOut++ = (q31_t) (Yn1 >> 32);
+            /*
+             * Decrement the loop counter
+             */
+            i--;
+        }
+        /*
+         * save input state
+         */
+        Xn2 = vecIn[2];
+        Xn1 = vecIn[3];
+
+        int       loopRemainder = blockSize - 3 - 4 * ((blockSize - 3) / 4);
+        if (loopRemainder == 1)
+        {
+            /*
+             * remainder
+             */
+            acc = mult32x64(Yn1, a1);
+            acc += mult32x64(Yn2, a2);
+            Yn2 = Yn1;
+            Yn1 = acc;
+            Yn1 = vmlaldavaq(Yn1, vecIn0, vecCoef);
+            Yn1 = asrl(Yn1, -shift);
+            *pOut++ = (q31_t) (Yn1 >> 32);
+            /*
+             * save input state
+             */
+            Xn2 = vecIn0[2];
+            Xn1 = vecIn0[3];
+
+        }
+        else if (loopRemainder == 2)
+        {
+            acc = mult32x64(Yn1, a1);
+            acc += mult32x64(Yn2, a2);
+            Yn2 = Yn1;
+            Yn1 = acc;
+            Yn1 = vmlaldavaq(Yn1, vecIn0, vecCoef);
+            Yn1 = asrl(Yn1, -shift);
+            *pOut++ = (q31_t) (Yn1 >> 32);
+
+            acc = mult32x64(Yn1, a1);
+            acc += mult32x64(Yn2, a2);
+            Yn2 = Yn1;
+            Yn1 = acc;
+            Yn1 = vmlaldavaq(Yn1, vecIn1, vecCoef);
+            Yn1 = asrl(Yn1, -shift);
+            *pOut++ = (q31_t) (Yn1 >> 32);
+            /*
+             * save input state
+             */
+            Xn2 = vecIn1[2];
+            Xn1 = vecIn1[3];
+
+        }
+        else if (loopRemainder == 3)
+        {
+            acc = mult32x64(Yn1, a1);
+            acc += mult32x64(Yn2, a2);
+            Yn2 = Yn1;
+            Yn1 = acc;
+            Yn1 = vmlaldavaq(Yn1, vecIn0, vecCoef);
+            Yn1 = asrl(Yn1, -shift);
+            *pOut++ = (q31_t) (Yn1 >> 32);
+
+            acc = mult32x64(Yn1, a1);
+            acc += mult32x64(Yn2, a2);
+            Yn2 = Yn1;
+            Yn1 = acc;
+            Yn1 = vmlaldavaq(Yn1, vecIn1, vecCoef);
+            Yn1 = asrl(Yn1, -shift);
+            *pOut++ = (q31_t) (Yn1 >> 32);
+
+            acc = mult32x64(Yn1, a1);
+            acc += mult32x64(Yn2, a2);
+            Yn2 = Yn1;
+            Yn1 = acc;
+            Yn1 = vmlaldavaq(Yn1, vecIn2, vecCoef);
+            Yn1 = asrl(Yn1, -shift);
+            *pOut++ = (q31_t) (Yn1 >> 32);
+            /*
+             * save input state
+             */
+            Xn2 = vecIn2[2];
+            Xn1 = vecIn2[3];
+
+        }
+
+        /*
+         * The first stage output is given as input to the second stage.
+         */
+        pIn = pDst;
+        /*
+         * Reset to destination buffer working pointer
+         */
+        pOut = pDst;
+        /*
+         * Store the updated state variables back into the pState array
+         */
+        *pState++ = (q63_t) Xn1;
+        *pState++ = (q63_t) Xn2;
+        *pState++ = Yn1;
+        *pState++ = Yn2;
+    }
+    while (--stage);
+}
+#else
 void arm_biquad_cas_df1_32x64_q31(
   const arm_biquad_cas_df1_32x64_ins_q31 * S,
         q31_t * pSrc,
@@ -452,6 +687,7 @@ void arm_biquad_cas_df1_32x64_q31(
   } while (--stage);
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BiquadCascadeDF1_32x64 group

CMSIS/DSP/Source/FilteringFunctions/arm_biquad_cascade_df1_f32.c

@@ -162,7 +162,185 @@
   @return        none
  */
 
-#if defined(ARM_MATH_NEON) 
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+#include "arm_helium_utils.h"
+void arm_biquad_cascade_df1_f32(
+  const arm_biquad_casd_df1_inst_f32 * S,
+  const float32_t * pSrc,
+  float32_t * pDst,
+  uint32_t blockSize)
+{
+    const float32_t *pIn = pSrc;              /*  source pointer            */
+    float32_t *pOut = pDst;             /*  destination pointer       */
+    float32_t *pState = S->pState;      /*  pState pointer            */
+    const float32_t *pCoeffs = S->pCoeffs;    /*  coefficient pointer       */
+    float32_t Xn1, Xn2, Yn1, Yn2;       /*  Filter pState variables   */
+    float32_t lastX, lastY;             /*  X,Y history for tail handling */
+    float32_t X0, X1, X2, X3;           /*  temporary input           */
+    f32x4_t coeffs;
+    f32x4_t accVec;                   /* accumultor vector */
+    uint32_t  sample, stage = S->numStages; /*  loop counters             */
+
+    do
+    {
+        /*
+         * Reading the pState values
+         */
+        Xn1 = pState[0];
+        Xn2 = pState[1];
+        Yn1 = pState[2];
+        Yn2 = pState[3];
+
+        sample = blockSize >> 2U;
+
+        /*
+         * First part of the processing with loop unrolling.  Compute 4 outputs at a time.
+         * second loop below computes the remaining 1 to 3 samples.
+         */
+        while (sample > 0U)
+        {
+            X0 = *pIn++;
+            X1 = *pIn++;
+            X2 = *pIn++;
+            X3 = *pIn++;
+
+            coeffs = vld1q(pCoeffs);
+            accVec = vmulq(coeffs, X3);
+
+            coeffs = vld1q(&pCoeffs[4]);
+            accVec = vfmaq(accVec, coeffs, X2);
+
+            coeffs = vld1q(&pCoeffs[8]);
+            accVec = vfmaq(accVec, coeffs, X1);
+
+            coeffs = vld1q(&pCoeffs[12]);
+            accVec = vfmaq(accVec, coeffs, X0);
+
+            coeffs = vld1q(&pCoeffs[16]);
+            accVec = vfmaq(accVec, coeffs, Xn1);
+
+            coeffs = vld1q(&pCoeffs[20]);
+            accVec = vfmaq(accVec, coeffs, Xn2);
+
+            coeffs = vld1q(&pCoeffs[24]);
+            accVec = vfmaq(accVec, coeffs, Yn1);
+
+            coeffs = vld1q(&pCoeffs[28]);
+            accVec = vfmaq(accVec, coeffs, Yn2);
+            /*
+             * Store the result in the accumulator in the destination buffer.
+             */
+            vst1q(pOut, accVec);
+            pOut += 4;
+
+            /*
+             * update recurrence
+             */
+            Xn1 = X3;
+            Xn2 = X2;
+            Yn1 = vgetq_lane(accVec, 3);
+            Yn2 = vgetq_lane(accVec, 2);
+            /*
+             * decrement the loop counter
+             */
+            sample--;
+        }
+
+        /*
+         * If the blockSize is not a multiple of 4,
+         * compute any remaining output samples here.
+         */
+        sample = blockSize & 0x3U;
+        if (sample)
+        {
+            /* save previous X, Y for modulo 1 length case */
+            lastX = X3;
+            lastY = Yn1;
+
+            X0 = *pIn++;
+            X1 = *pIn++;
+            X2 = *pIn++;
+            X3 = *pIn++;
+
+            coeffs = vld1q(pCoeffs);
+            accVec = vmulq(coeffs, X3);
+
+            coeffs = vld1q(&pCoeffs[4]);
+            accVec = vfmaq(accVec, coeffs, X2);
+
+            coeffs = vld1q(&pCoeffs[8]);
+            accVec = vfmaq(accVec, coeffs, X1);
+
+            coeffs = vld1q(&pCoeffs[12]);
+            accVec = vfmaq(accVec, coeffs, X0);
+
+            coeffs = vld1q(&pCoeffs[16]);
+            accVec = vfmaq(accVec, coeffs, Xn1);
+
+            coeffs = vld1q(&pCoeffs[20]);
+            accVec = vfmaq(accVec, coeffs, Xn2);
+
+            coeffs = vld1q(&pCoeffs[24]);
+            accVec = vfmaq(accVec, coeffs, Yn1);
+
+            coeffs = vld1q(&pCoeffs[28]);
+            accVec = vfmaq(accVec, coeffs, Yn2);
+
+            if (sample == 1)
+            {
+                *pOut++ = vgetq_lane(accVec, 0);
+                Xn1 = X0;
+                Xn2 = lastX;
+                Yn1 = vgetq_lane(accVec, 0);
+                Yn2 = lastY;
+            }
+            else if (sample == 2)
+            {
+                *pOut++ = vgetq_lane(accVec, 0);
+                *pOut++ = vgetq_lane(accVec, 1);
+                Xn1 = X1;
+                Xn2 = X0;
+                Yn1 = vgetq_lane(accVec, 1);
+                Yn2 = vgetq_lane(accVec, 0);
+            }
+            else
+            {
+                *pOut++ = vgetq_lane(accVec, 0);
+                *pOut++ = vgetq_lane(accVec, 1);
+                *pOut++ = vgetq_lane(accVec, 2);
+                Xn1 = X2;
+                Xn2 = X1;
+                Yn1 = vgetq_lane(accVec, 2);
+                Yn2 = vgetq_lane(accVec, 1);
+            }
+        }
+        /*
+         * Store the updated state variables back into the pState array
+         */
+        *pState++ = Xn1;
+        *pState++ = Xn2;
+        *pState++ = Yn1;
+        *pState++ = Yn2;
+
+        pCoeffs += sizeof(arm_biquad_mod_coef_f32) / sizeof(float32_t);
+        /*
+         * The first stage goes from the input buffer to the output buffer.
+         * Subsequent numStages  occur in-place in the output buffer
+         */
+        pIn = pDst;
+        /*
+         * Reset the output pointer
+         */
+        pOut = pDst;
+        /*
+         * decrement the loop counter
+         */
+        stage--;
+    }
+    while (stage > 0U);
+}
+#else
+#if defined(ARM_MATH_NEON)  && !defined(ARM_MATH_AUTOVECTORIZE)
 void arm_biquad_cascade_df1_f32(
   const arm_biquad_casd_df1_inst_f32 * S,
   const float32_t * pSrc,
@@ -192,8 +370,11 @@ void arm_biquad_cascade_df1_f32(
   while (stage > 0U)
   {
     /* Reading the coefficients */
-    Xn = vld1q_f32(pState);
-    Yn = vld1_f32(pState + 2);
+    Xn = vdupq_n_f32(0.0);
+    Xn[2] = pState[0];
+    Xn[3] = pState[1];
+    Yn[0] = pState[2];
+    Yn[1] = pState[3];
 
     b = vld1q_f32(pCoeffs);
     b = vrev64q_f32(b);  
@@ -268,6 +449,7 @@ void arm_biquad_cascade_df1_f32(
       sample--;
     }
 
+    
     /* If the block size is not a multiple of 4, compute any remaining output samples here.
      ** No loop unrolling is used. */
     sample = blockSize & 0x3U;
@@ -299,7 +481,7 @@ void arm_biquad_cascade_df1_f32(
 
     }
 
-    vst1q_f32(pState,vcombine_f32(vrev64_f32(vget_high_f32(Xn)),vrev64_f32(Yn)));
+    vst1q_f32(pState,vcombine_f32((vget_high_f32(Xn)),(Yn)));
     pState += 4;
     /*  Store the updated state variables back into the pState array */
    
@@ -347,7 +529,7 @@ void arm_biquad_cascade_df1_f32(
     Yn1 = pState[2];
     Yn2 = pState[3];
 
-#if defined (ARM_MATH_LOOPUNROLL)
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
 
     /* Apply loop unrolling and compute 4 output values simultaneously. */
     /* Variable acc hold output values that are being computed:
@@ -490,6 +672,8 @@ void arm_biquad_cascade_df1_f32(
 }
 
 #endif /* #if defined(ARM_MATH_NEON) */
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
+
 /**
   @} end of BiquadCascadeDF1 group
  */

CMSIS/DSP/Source/FilteringFunctions/arm_biquad_cascade_df1_init_f32.c

@@ -65,8 +65,15 @@
                    The 4 state variables for stage 1 are first, then the 4 state variables for stage 2, and so on.
                    The state array has a total length of <code>4*numStages</code> values.
                    The state variables are updated after each block of data is processed; the coefficients are untouched.
+ 
+  @par             For MVE code, an additional buffer of modified coefficients is required.
+                   Its size is numStages and each element of this buffer has type arm_biquad_mod_coef_f32.
+                   So, its total size is 32*numStages float32_t elements.
+
+                   The initialization function which must be used is arm_biquad_cascade_df1_mve_init_f32.
  */
 
+
 void arm_biquad_cascade_df1_init_f32(
         arm_biquad_casd_df1_inst_f32 * S,
         uint8_t numStages,
@@ -86,6 +93,54 @@ void arm_biquad_cascade_df1_init_f32(
   S->pState = pState;
 }
 
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+static void generateCoefsFastBiquadF32(float32_t b0, float32_t b1, float32_t b2, float32_t a1, float32_t a2,
+                                arm_biquad_mod_coef_f32 * newCoef)
+{
+    float32_t coeffs[4][8] = {
+        {0, 0, 0, b0, b1, b2, a1, a2},
+        {0, 0, b0, b1, b2, 0, a2, 0},
+        {0, b0, b1, b2, 0, 0, 0, 0},
+        {b0, b1, b2, 0, 0, 0, 0, 0},
+    };
+
+    for (int i = 0; i < 8; i++)
+    {
+        coeffs[1][i] += a1 * coeffs[0][i];
+        coeffs[2][i] += a1 * coeffs[1][i] + a2 * coeffs[0][i];
+        coeffs[3][i] += a1 * coeffs[2][i] + a2 * coeffs[1][i];
+
+        /*
+         * transpose
+         */
+        newCoef->coeffs[i][0] = (float32_t) coeffs[0][i];
+        newCoef->coeffs[i][1] = (float32_t) coeffs[1][i];
+        newCoef->coeffs[i][2] = (float32_t) coeffs[2][i];
+        newCoef->coeffs[i][3] = (float32_t) coeffs[3][i];
+    }
+}
+
+void arm_biquad_cascade_df1_mve_init_f32(
+      arm_biquad_casd_df1_inst_f32 * S,
+      uint8_t numStages,
+      const float32_t * pCoeffs, 
+      arm_biquad_mod_coef_f32 * pCoeffsMod, 
+      float32_t * pState)
+{
+    arm_biquad_cascade_df1_init_f32(S, numStages, (float32_t *)pCoeffsMod, pState);
+
+    /* Generate SIMD friendly modified coefs */
+    for (int i = 0; i < numStages; i++)
+    {
+        generateCoefsFastBiquadF32(pCoeffs[0], pCoeffs[1], pCoeffs[2], pCoeffs[3], pCoeffs[4], pCoeffsMod);
+        pCoeffs += 5;
+        pCoeffsMod++;
+    }
+}
+#endif 
+
 /**
   @} end of BiquadCascadeDF1 group
  */

CMSIS/DSP/Source/FilteringFunctions/arm_biquad_cascade_df1_q15.c

@@ -56,6 +56,260 @@
                    Refer to \ref arm_biquad_cascade_df1_fast_q15() for a faster but less precise implementation of this filter.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+void arm_biquad_cascade_df1_q15(
+  const arm_biquad_casd_df1_inst_q15 * S,
+  const q15_t * pSrc,
+        q15_t * pDst,
+        uint32_t blockSize)
+{
+    const q15_t    *pIn = pSrc; /*  input pointer initialization  */
+    q15_t          *pOut = pDst;        /*  output pointer initialization */
+    int             shift;
+    uint32_t        sample, stages = S->numStages;      /*  loop counters                 */
+    int             postShift = S->postShift;
+    q15x8_t         bCoeffs0, bCoeffs1, bCoeffs2, bCoeffs3;     /*  Coefficients vector           */
+    q15_t          *pState = S->pState; /*  pState pointer initialization */
+    q15x8_t         inVec0;
+    int64_t         acc;
+    const q15_t     *pCoeffs = S->pCoeffs;       /*  coeff pointer initialization  */
+    q31_t           out, out1;
+
+    shift = (15 - postShift) - 32;
+
+    do {
+        q15_t           a2 = pCoeffs[5];
+        q15_t           a1 = pCoeffs[4];
+
+        bCoeffs0 = vdupq_n_s16(0);
+        bCoeffs0[0] = pCoeffs[3];       // b2
+        bCoeffs0[1] = pCoeffs[2];       // b1
+        bCoeffs0[2] = pCoeffs[0];       // b0
+
+        uint32_t        zero = 0;
+        bCoeffs1 = bCoeffs0;
+        bCoeffs1 = vshlcq_s16(bCoeffs1, &zero, 16);
+
+        bCoeffs2 = bCoeffs1;
+        bCoeffs2 = vshlcq_s16(bCoeffs2, &zero, 16);
+
+        bCoeffs3 = bCoeffs2;
+        bCoeffs3 = vshlcq_s16(bCoeffs3, &zero, 16);
+
+        bCoeffs0[6] = a2;
+        bCoeffs0[7] = a1;
+        bCoeffs1[7] = a2;
+        bCoeffs1[6] = a1;
+
+        bCoeffs2 =
+            vsetq_lane_s32(vgetq_lane_s32((q31x4_t) bCoeffs0, 3), (q31x4_t) bCoeffs2, 3);
+        bCoeffs3 =
+            vsetq_lane_s32(vgetq_lane_s32((q31x4_t) bCoeffs1, 3), (q31x4_t) bCoeffs3, 3);
+
+
+        /* 2 first elements are garbage, will be updated with history */
+        inVec0 = vld1q(pIn - 2);
+        pIn += 2;
+
+        inVec0[0] = pState[1];
+        inVec0[1] = pState[0];
+        inVec0[6] = pState[3];
+        inVec0[7] = pState[2];
+
+        acc = vmlaldavq(bCoeffs0, inVec0);
+        acc = sqrshrl_sat48(acc, shift);
+        out1 = (q31_t) ((acc >> 32) & 0xffffffff);
+
+        inVec0[6] = out1;
+        acc = vmlaldavq(bCoeffs1, inVec0);
+        acc = sqrshrl_sat48(acc, shift);
+        out = (q31_t) ((acc >> 32) & 0xffffffff);
+
+        inVec0[7] = out;
+        *pOut++ = (q15_t) out1;
+        *pOut++ = (q15_t) out;
+
+        acc = vmlaldavq(bCoeffs2, inVec0);
+        acc = sqrshrl_sat48(acc, shift);
+        out1 = (q31_t) ((acc >> 32) & 0xffffffff);
+
+
+        inVec0[6] = out1;
+        acc = vmlaldavq(bCoeffs3, inVec0);
+        acc = sqrshrl_sat48(acc, shift);
+        out = (q31_t) ((acc >> 32) & 0xffffffff);
+
+        /*
+         * main loop
+         */
+        sample = (blockSize - 4) >> 2U;
+        /* preload (efficient scheduling) */
+        inVec0 = vld1q(pIn);
+        pIn += 4;
+
+        /*
+         * Compute 4 outputs at a time.
+         */
+        while (sample > 0U) {
+
+            inVec0[6] = out1;
+            inVec0[7] = out;
+
+            /* store */
+            *pOut++ = (q15_t) out1;
+            *pOut++ = (q15_t) out;
+
+            /*
+             * in       { x0  x1  x2  x3  x4  x5  yn2  yn1 }
+             *                          x
+             * bCoeffs0 { b2  b1  b0   0   0   0   a2  a1 }
+             *
+             */
+            acc = vmlaldavq(bCoeffs0, inVec0);
+            /* shift + saturate to 16 bit */
+            acc = sqrshrl_sat48(acc, shift);
+            out1 = (q31_t) ((acc >> 32) & 0xffffffff);
+            inVec0[6] = out1;
+
+            /*
+             * in       { x0  x1  x2  x3  x4  x5  y0  yn1 }
+             *                          x
+             * bCoeffs1 {  0  b2  b1  b0   0   0  a1  a2 }
+             */
+            acc = vmlaldavq(bCoeffs1, inVec0);
+            acc = sqrshrl_sat48(acc, shift);
+            out = (q31_t) ((acc >> 32) & 0xffffffff);
+
+            *pOut++ = (q15_t) out1;
+            *pOut++ = (q15_t) out;
+
+
+            inVec0[7] = out;
+            /*
+             * in       { x0  x1  x2  x3  x4  x5  y0  yp1 }
+             *                         x
+             * bCoeffs2 { 0   0   b2  b1  b0   0  a2  a1 }
+             */
+            acc = vmlaldavq(bCoeffs2, inVec0);
+            acc = sqrshrl_sat48(acc, shift);
+            out1 = (q31_t) ((acc >> 32) & 0xffffffff);
+            inVec0[6] = out1;
+
+            /*
+             * in       { x0  x1  x2  x3  x4  x5  y0  yp1 }
+             *                         x
+             * bCoeffs2 {  0   0   0  b2  b1  b0  a1  a2  }
+             */
+            acc = vmlaldavq(bCoeffs3, inVec0);
+            acc = sqrshrl_sat48(acc, shift);
+            out = (q31_t) ((acc >> 32) & 0xffffffff);
+
+            inVec0 = vld1q(pIn);
+            pIn += 4;
+
+            /* decrement the loop counter  */
+            sample--;
+        }
+
+        *pOut++ = (q15_t) out1;
+        *pOut++ = (q15_t) out;
+
+        /*
+         * Tail handling
+         */
+        int32_t         loopRemainder = blockSize & 3;
+
+        if (loopRemainder == 3) {
+            inVec0[6] = out1;
+            inVec0[7] = out;
+
+            acc = vmlaldavq(bCoeffs0, inVec0);
+            acc = sqrshrl_sat48(acc, shift);
+            out1 = (q31_t) ((acc >> 32) & 0xffffffff);
+            inVec0[6] = out1;
+
+            acc = vmlaldavq(bCoeffs1, inVec0);
+            acc = sqrshrl_sat48(acc, shift);
+            out = (q31_t) ((acc >> 32) & 0xffffffff);
+
+            *pOut++ = (q15_t) out1;
+            *pOut++ = (q15_t) out;
+
+            inVec0[7] = out;
+            acc = vmlaldavq(bCoeffs2, inVec0);
+            acc = sqrshrl_sat48(acc, shift);
+            out1 = (q31_t) ((acc >> 32) & 0xffffffff);
+            *pOut++ = (q15_t) out1;
+
+            /* Store the updated state variables back into the pState array */
+            pState[0] = vgetq_lane_s16(inVec0, 4);
+            pState[1] = vgetq_lane_s16(inVec0, 3);
+            pState[3] = out;
+            pState[2] = out1;
+
+        } else if (loopRemainder == 2) {
+            inVec0[6] = out1;
+            inVec0[7] = out;
+
+            acc = vmlaldavq(bCoeffs0, inVec0);
+            acc = sqrshrl_sat48(acc, shift);
+            out1 = (q31_t) ((acc >> 32) & 0xffffffff);
+            inVec0[6] = out1;
+
+            acc = vmlaldavq(bCoeffs1, inVec0);
+            acc = sqrshrl_sat48(acc, shift);
+            out = (q31_t) ((acc >> 32) & 0xffffffff);
+
+            *pOut++ = (q15_t) out1;
+            *pOut++ = (q15_t) out;
+
+            /* Store the updated state variables back into the pState array */
+            pState[0] = vgetq_lane_s16(inVec0, 3);
+            pState[1] = vgetq_lane_s16(inVec0, 2);
+            pState[3] = out1;
+            pState[2] = out;
+        } else if (loopRemainder == 1) {
+
+            inVec0[6] = out1;
+            inVec0[7] = out;
+
+            acc = vmlaldavq(bCoeffs0, inVec0);
+            acc = sqrshrl_sat48(acc, shift);
+            out1 = (q31_t) ((acc >> 32) & 0xffffffff);
+            *pOut++ = (q15_t) out1;
+
+            /* Store the updated state variables back into the pState array */
+            pState[0] = vgetq_lane_s16(inVec0, 2);
+            pState[1] = vgetq_lane_s16(inVec0, 1);
+            pState[3] = out;
+            pState[2] = out1;
+
+
+        } else {
+            /* Store the updated state variables back into the pState array */
+            pState[0] = vgetq_lane_s16(inVec0, 1);
+            pState[1] = vgetq_lane_s16(inVec0, 0);
+            pState[3] = out1;
+            pState[2] = out;
+        }
+
+        pState += 4;
+        pCoeffs += 6;
+
+        /*
+         * The first stage goes from the input buffer to the output buffer.
+         * Subsequent stages occur in-place in the output buffer
+         */
+        pIn = pDst;
+        /*
+         * Reset to destination pointer
+         */
+        pOut = pDst;
+    }
+    while (--stages);
+}
+#else
 void arm_biquad_cascade_df1_q15(
   const arm_biquad_casd_df1_inst_q15 * S,
   const q15_t * pSrc,
@@ -357,6 +611,7 @@ void arm_biquad_cascade_df1_q15(
 #endif /* #if defined (ARM_MATH_DSP) */
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BiquadCascadeDF1 group

CMSIS/DSP/Source/FilteringFunctions/arm_biquad_cascade_df1_q31.c

@@ -55,7 +55,269 @@
   @remark
                    Refer to \ref arm_biquad_cascade_df1_fast_q31() for a faster but less precise implementation of this filter.
  */
+#if defined(ARM_MATH_MVEI)
 
+void arm_biquad_cascade_df1_q31(
+  const arm_biquad_casd_df1_inst_q31 * S,
+  const q31_t * pSrc,
+        q31_t * pDst,
+        uint32_t blockSize)
+{
+    const q31_t    *pIn = pSrc; /*  input pointer initialization  */
+    q31_t          *pOut = pDst;        /*  output pointer initialization */
+    int             shift;
+    uint32_t        stages = S->numStages;      /*  loop counters                 */
+    int             postShift = S->postShift;
+    q31x4_t         b0Coeffs, b1Coeffs, a0Coeffs, a1Coeffs;     /*  Coefficients vector           */
+    q31x4_t         stateVec;
+    q31_t          *pState = S->pState; /*  pState pointer initialization */
+    q31x4_t         inVec0;
+    int64_t         acc;
+    const q31_t          *pCoeffs = S->pCoeffs;       /*  coeff pointer initialization  */
+    q31_t           out, out1;
+
+
+    shift = (postShift + 1 + 8);
+
+    do {
+        /*
+         * Reading the coefficients
+         * generates :
+         * Fwd0 { b2  b1  b0  0  }
+         * Fwd1 { 0   b2  b1  b0 }
+         * Bwd0 { 0   0   a2  a1 }
+         * Bwd0 { 0   0   a1  a2 }
+         * (can be moved in init)
+         */
+        b0Coeffs = vdupq_n_s32(0);
+        a0Coeffs = vdupq_n_s32(0);
+
+        b0Coeffs[0] = pCoeffs[2];       // b2
+        b0Coeffs[1] = pCoeffs[1];       // b1
+        b0Coeffs[2] = pCoeffs[0];       // b0
+
+        b1Coeffs = b0Coeffs;
+        uint32_t        zero = 0;
+        b1Coeffs = vshlcq_s32(b1Coeffs, &zero, 32);
+
+        a0Coeffs[2] = pCoeffs[4];
+        a0Coeffs[3] = pCoeffs[3];
+        a1Coeffs = vrev64q_s32(a0Coeffs);
+
+
+        /*
+         * prologue consumes history samples
+         */
+
+        /* 2 first elements are garbage, will be updated with history */
+        inVec0 = vld1q(pIn - 2);
+
+        inVec0[0] = pState[1];
+        inVec0[1] = pState[0];
+
+        stateVec[2] = pState[3];
+        stateVec[3] = pState[2];
+
+        acc = vrmlaldavhq(b0Coeffs, inVec0);
+        acc = vrmlaldavhaq(acc, a0Coeffs, stateVec);
+        acc = lsll(acc, shift);
+        out = (q31_t) ((acc >> 32) & 0xffffffff);
+
+        stateVec[2] = out;
+        acc = vrmlaldavhq(b1Coeffs, inVec0);
+        acc = vrmlaldavhaq(acc, a1Coeffs, stateVec);
+
+        acc = lsll(acc, shift);
+        out1 = (q31_t) ((acc >> 32) & 0xffffffff);
+
+
+        inVec0 = vld1q(pIn);
+        pIn += 2;
+
+        /*
+         * main loop
+         */
+        uint32_t            sample = (blockSize - 2) >> 2U;
+        /*
+         * First part of the processing with loop unrolling.
+         * Compute 4 outputs at a time.
+         */
+        while (sample > 0U) {
+
+            stateVec[3] = out1;
+
+            *pOut++ = out;
+            *pOut++ = out1;
+
+            /*
+             * in         { x0  x1  x2  x3 }
+             *                    x
+             * b0Coeffs   { b2  b1  b0  0  }
+             */
+            acc = vrmlaldavhq(b0Coeffs, inVec0);
+            /*
+             * out         { 0   0   yn2 yn1 }
+             *                    x
+             * a0Coeffs    { 0   0   a2  a1  }
+             */
+            acc = vrmlaldavhaq(acc, a0Coeffs, stateVec);
+            acc = lsll(acc, shift);
+            out = (q31_t) ((acc >> 32) & 0xffffffff);
+
+            stateVec[2] = out;
+
+            /*
+             * in         { x0  x1  x2  x3 }
+             *                    x
+             * b0Coeffs   {  0  b2  b1  b0 }
+             */
+            acc = vrmlaldavhq(b1Coeffs, inVec0);
+            /*
+             * out         { 0   0   y0  yn1 }
+             *                    x
+             * a0Coeffs    { 0   0   a1  a2  }
+             */
+            acc = vrmlaldavhaq(acc, a1Coeffs, stateVec);
+            acc = lsll(acc, shift);
+            out1 = (q31_t) ((acc >> 32) & 0xffffffff);
+
+            stateVec[3] = out1;
+
+            inVec0 = vld1q(pIn);
+            pIn += 2;
+
+            /* unrolled part */
+            *pOut++ = out;
+            *pOut++ = out1;
+
+            acc = vrmlaldavhq(b0Coeffs, inVec0);
+            acc = vrmlaldavhaq(acc, a0Coeffs, stateVec);
+            acc = lsll(acc, shift);
+            out = (q31_t) ((acc >> 32) & 0xffffffff);
+
+            stateVec[2] = out;
+
+            acc = vrmlaldavhq(b1Coeffs, inVec0);
+            acc = vrmlaldavhaq(acc, a1Coeffs, stateVec);
+            acc = lsll(acc, shift);
+            out1 = (q31_t) ((acc >> 32) & 0xffffffff);
+
+            inVec0 = vld1q(pIn);
+            pIn += 2;
+
+            sample--;
+        }
+
+        *pOut++ = out;
+        *pOut++ = out1;
+
+        /*
+         * Tail handling
+         */
+        int32_t         loopRemainder = blockSize & 3;
+        if (loopRemainder == 2) {
+            /*
+             * Store the updated state variables back into the pState array
+             */
+            pState[0] = inVec0[1];
+            pState[1] = inVec0[0];
+            pState[3] = out;
+            pState[2] = out1;
+        } else if (loopRemainder == 1) {
+            stateVec[3] = out1;
+
+            acc = vrmlaldavhq(b0Coeffs, inVec0);
+            acc = vrmlaldavhaq(acc, a0Coeffs, stateVec);
+            acc = lsll(acc, shift);
+            out = (q31_t) ((acc >> 32) & 0xffffffff);
+
+            stateVec[2] = out;
+
+            acc = vrmlaldavhq(b1Coeffs, inVec0);
+            acc = vrmlaldavhaq(acc, a1Coeffs, stateVec);
+            acc = lsll(acc, shift);
+            out1 = (q31_t) ((acc >> 32) & 0xffffffff);
+
+            stateVec[3] = out1;
+
+            inVec0 = vld1q(pIn);
+            pIn += 2;
+
+            *pOut++ = out;
+            *pOut++ = out1;
+
+            acc = vrmlaldavhq(b0Coeffs, inVec0);
+            acc = vrmlaldavhaq(acc, a0Coeffs, stateVec);
+            acc = lsll(acc, shift);
+            out = (q31_t) ((acc >> 32) & 0xffffffff);
+
+            *pOut++ = out;
+
+            /*
+             * Store the updated state variables back into the pState array
+             */
+            pState[0] = inVec0[2];
+            pState[1] = inVec0[1];
+            pState[3] = out1;
+            pState[2] = out;
+        } else if (loopRemainder == 0) {
+            stateVec[3] = out1;
+
+            acc = vrmlaldavhq(b0Coeffs, inVec0);
+            acc = vrmlaldavhaq(acc, a0Coeffs, stateVec);
+            acc = lsll(acc, shift);
+            out = (q31_t) ((acc >> 32) & 0xffffffff);
+
+            stateVec[2] = out;
+
+            acc = vrmlaldavhq(b1Coeffs, inVec0);
+            acc = vrmlaldavhaq(acc, a1Coeffs, stateVec);
+            acc = lsll(acc, shift);
+            out1 = (q31_t) ((acc >> 32) & 0xffffffff);
+
+            *pOut++ = out;
+            *pOut++ = out1;
+
+            /*
+             * Store the updated state variables back into the pState array
+             */
+            pState[0] = inVec0[3];
+            pState[1] = inVec0[2];
+            pState[3] = out;
+            pState[2] = out1;
+        } else {
+            stateVec[3] = out1;
+
+            acc = vrmlaldavhq(b0Coeffs, inVec0);
+            acc = vrmlaldavhaq(acc, a0Coeffs, stateVec);
+            acc = lsll(acc, shift);
+            out = (q31_t) ((acc >> 32) & 0xffffffff);
+
+            *pOut++ = out;
+
+            /*
+             * Store the updated state variables back into the pState array
+             */
+            pState[0] = inVec0[2];
+            pState[1] = inVec0[1];
+            pState[3] = out1;
+            pState[2] = out;
+        }
+
+
+        pCoeffs += 5;
+        pState += 4;
+
+        /*  The first stage goes from the input buffer to the output buffer. */
+        /*  Subsequent stages occur in-place in the output buffer */
+        pIn = pDst;
+
+        /* Reset to destination pointer */
+        pOut = pDst;
+    }
+    while (--stages);
+}
+#else
 void arm_biquad_cascade_df1_q31(
   const arm_biquad_casd_df1_inst_q31 * S,
   const q31_t * pSrc,
@@ -241,6 +503,7 @@ void arm_biquad_cascade_df1_q31(
   } while (stage > 0U);
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BiquadCascadeDF1 group

CMSIS/DSP/Source/FilteringFunctions/arm_biquad_cascade_df2T_f32.c

@@ -45,7 +45,141 @@
   @param[in]     blockSize number of samples to process
   @return        none
  */
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+#include "arm_helium_utils.h"
 
+void arm_biquad_cascade_df2T_f32(
+  const arm_biquad_cascade_df2T_instance_f32 * S,
+  const float32_t * pSrc,
+        float32_t * pDst,
+        uint32_t blockSize)
+{
+    const float32_t *pIn = pSrc;                  /*  source pointer            */
+    float32_t Xn0, Xn1;
+    float32_t acc0, acc1;
+    float32_t *pOut = pDst;                 /*  destination pointer       */
+    float32_t *pState = S->pState;          /*  State pointer             */
+    uint32_t  sample, stage = S->numStages; /*  loop counters             */
+    float32_t const *pCurCoeffs =          /*  coefficient pointer       */
+                (float32_t const *) S->pCoeffs;
+    f32x4_t b0Coeffs, a0Coeffs;           /*  Coefficients vector       */
+    f32x4_t b1Coeffs, a1Coeffs;           /*  Modified coef. vector     */
+    f32x4_t state;                        /*  State vector              */
+
+    do
+    {
+        /*
+         * temporary carry variable for feeding the 128-bit vector shifter
+         */
+        uint32_t  tmp = 0;
+        /*
+         * Reading the coefficients
+         * b0Coeffs = {b0, b1, b2, x}
+         * a0Coeffs = { x, a1, a2, x}
+         */
+        b0Coeffs = vld1q(pCurCoeffs);   pCurCoeffs+= 2;
+        a0Coeffs = vld1q(pCurCoeffs);   pCurCoeffs+= 3;
+        /*
+         * Reading the state values
+         * state = {d1, d2,  0, 0}
+         */
+        state = *(f32x4_t *) pState;
+        state = vsetq_lane(0.0f, state, 2);
+        state = vsetq_lane(0.0f, state, 3);
+
+        /* b1Coeffs = {b0, b1, b2, x} */
+        /* b1Coeffs = { x, x, a1, a2} */
+        b1Coeffs = vshlcq_s32(b0Coeffs, &tmp, 32);
+        a1Coeffs = vshlcq_s32(a0Coeffs, &tmp, 32);
+
+        sample = blockSize / 2;
+
+        /* unrolled 2 x */
+        while (sample > 0U)
+        {
+            /*
+             * Read 2 inputs
+             */
+            Xn0 = *pIn++;
+            Xn1 = *pIn++;
+
+            /*
+             * 1st half:
+             * / acc0 \   / b0 \         / d1 \   / 0  \
+             * |  d1  | = | b1 | * Xn0 + | d2 | + | a1 | x acc0
+             * |  d2  |   | b2 |         | 0  |   | a2 |
+             * \  x   /   \ x  /         \ x  /   \ x  /
+             */
+
+            state = vfmaq(state, b0Coeffs, Xn0);
+            acc0 = vgetq_lane(state, 0);
+            state = vfmaq(state, a0Coeffs, acc0);
+            state = vsetq_lane(0.0f, state, 3);
+
+            /*
+             * 2nd half:
+             * same as 1st half, but all vector elements shifted down.
+             * /  x   \   / x  \         / x  \   / x  \
+             * | acc1 | = | b0 | * Xn1 + | d1 | + | 0  | x acc1
+             * |  d1  |   | b1 |         | d2 |   | a1 |
+             * \  d2  /   \ b2 /         \ 0  /   \ a2 /
+             */
+
+            state = vfmaq(state, b1Coeffs, Xn1);
+            acc1 = vgetq_lane(state, 1);
+            state = vfmaq(state, a1Coeffs, acc1);
+
+            /* move d1, d2 up + clearing */
+            /* expect dual move or long move */
+            state = vsetq_lane(vgetq_lane(state, 2), state, 0);
+            state = vsetq_lane(vgetq_lane(state, 3), state, 1);
+            state = vsetq_lane(0.0f, state, 2);
+            /*
+             * Store the results in the destination buffer.
+             */
+            *pOut++ = acc0;
+            *pOut++ = acc1;
+            /*
+             * decrement the loop counter
+             */
+            sample--;
+        }
+
+        /*
+         * tail handling
+         */
+        if (blockSize & 1)
+        {
+            Xn0 = *pIn++;
+            state = vfmaq(state, b0Coeffs, Xn0);
+            acc0 = vgetq_lane(state, 0);
+
+            state = vfmaq(state, a0Coeffs, acc0);
+            *pOut++ = acc0;
+            *pState++ = vgetq_lane(state, 1);
+            *pState++ = vgetq_lane(state, 2);
+        }
+        else
+        {
+            *pState++ = vgetq_lane(state, 0);
+            *pState++ = vgetq_lane(state, 1);
+        }
+        /*
+         * The current stage input is given as the output to the next stage
+         */
+        pIn = pDst;
+        /*
+         * Reset the output working pointer
+         */
+        pOut = pDst;
+        /*
+         * decrement the loop counter
+         */
+        stage--;
+    }
+    while (stage > 0U);
+}
+#else
 #if defined(ARM_MATH_NEON) 
 
 void arm_biquad_cascade_df2T_f32(
@@ -511,6 +645,7 @@ void arm_biquad_cascade_df2T_f32(
 }
 LOW_OPTIMIZATION_EXIT
 #endif /* #if defined(ARM_MATH_NEON) */
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
 
 /**
   @} end of BiquadCascadeDF2T group

CMSIS/DSP/Source/FilteringFunctions/arm_biquad_cascade_stereo_df2T_f32.c

@@ -45,7 +45,140 @@
   @param[in]     blockSize number of samples to process
   @return        none
  */
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+#include "arm_helium_utils.h"
 
+void arm_biquad_cascade_stereo_df2T_f32(
+  const arm_biquad_cascade_stereo_df2T_instance_f32 * S,
+  const float32_t * pSrc,
+        float32_t * pDst,
+        uint32_t blockSize)
+{
+    const float32_t *pIn = pSrc;              /*  source pointer            */
+    float32_t *pOut = pDst;             /*  destination pointer       */
+    float32_t *pState = S->pState;      /*  State pointer             */
+    const float32_t *pCoeffs = S->pCoeffs;    /*  coefficient pointer       */
+    float32_t b0, b1, b2, a1, a2;       /*  Filter coefficients       */
+    uint32_t  sample, stage = S->numStages; /*  loop counters           */
+    float32_t scratch[6];
+    uint32x4_t loadIdxVec;
+    f32x4_t aCoeffs, bCoeffs;
+    f32x4_t stateVec0, stateVec1;
+    f32x4_t inVec;
+    uint32_t  startIdx = 0;
+
+    /*
+     * {0, 1, 0, 1} generator
+     */
+    loadIdxVec = viwdupq_u32(&startIdx, 2, 1);
+
+    /*
+     * scratch top clearing
+     * layout : [d1a d1b d2a d2b 0 0]
+     */
+    scratch[4] = 0.0f;
+    scratch[5] = 0.0f;
+
+    do
+    {
+        /*
+         * Reading the coefficients
+         */
+        b0 = *pCoeffs++;
+        b1 = *pCoeffs++;
+        b2 = *pCoeffs++;
+        a1 = *pCoeffs++;
+        a2 = *pCoeffs++;
+
+        /*
+         * aCoeffs = {a1 a1 a2 a2}
+         */
+        aCoeffs = vdupq_n_f32(a1);
+        aCoeffs = vsetq_lane(a2, aCoeffs, 2);
+        aCoeffs = vsetq_lane(a2, aCoeffs, 3);
+
+        /*
+         * bCoeffs = {b1 b1 b2 b2}
+         */
+        bCoeffs = vdupq_n_f32(b1);
+        bCoeffs = vsetq_lane(b2, bCoeffs, 2);
+        bCoeffs = vsetq_lane(b2, bCoeffs, 3);
+
+        /*
+         * Reading the state values
+         * Save into scratch
+         */
+        *(f32x4_t *) scratch = *(f32x4_t *) pState;
+
+        sample = blockSize;
+
+        while (sample > 0U)
+        {
+            /*
+             * step 1
+             *
+             * 0   | acc1a = xn1a * b0 + d1a
+             * 1   | acc1b = xn1b * b0 + d1b
+             * 2   | acc1a = xn1a * b0 + d1a
+             * 3   | acc1b = xn1b * b0 + d1b
+             */
+            /*
+             * load {d1a, d1b, d1a, d1b}
+             */
+            stateVec0 = vldrwq_gather_shifted_offset((uint32_t const *) scratch, loadIdxVec);
+            /*
+             * load {in0 in1 in0 in1}
+             */
+            inVec = vldrwq_gather_shifted_offset((uint32_t const *) pIn, loadIdxVec);
+
+            stateVec0 = vfmaq(stateVec0, inVec, b0);
+            *pOut++ = vgetq_lane(stateVec0, 0);
+            *pOut++ = vgetq_lane(stateVec0, 1);
+
+            /*
+             * step 2
+             *
+             * 0  | d1a = b1 * xn1a  +  a1 * acc1a  +  d2a
+             * 1  | d1b = b1 * xn1b  +  a1 * acc1b  +  d2b
+             * 2  | d2a = b2 * xn1a  +  a2 * acc1a  +  0
+             * 3  | d2b = b2 * xn1b  +  a2 * acc1b  +  0
+             */
+
+            /*
+             * load {d2a, d2b, 0, 0}
+             */
+            stateVec1 = *(f32x4_t *) & scratch[2];
+            stateVec1 = vfmaq(stateVec1, stateVec0, aCoeffs);
+            stateVec1 = vfmaq(stateVec1, inVec, bCoeffs);
+            *(f32x4_t *) scratch = stateVec1;
+
+            pIn = pIn + 2;
+            sample--;
+        }
+
+        /*
+         * Store the updated state variables back into the state array
+         */
+        vst1q(pState, stateVec1);
+        pState += 4;
+
+        /*
+         * The current stage input is given as the output to the next stage
+         */
+        pIn = pDst;
+        /*
+         * Reset the output working pointer
+         */
+        pOut = pDst;
+        /*
+         * decrement the loop counter
+         */
+        stage--;
+    }
+    while (stage > 0U);
+}
+
+#else
 LOW_OPTIMIZATION_ENTER
 void arm_biquad_cascade_stereo_df2T_f32(
   const arm_biquad_cascade_stereo_df2T_instance_f32 * S,
@@ -280,6 +413,8 @@ void arm_biquad_cascade_stereo_df2T_f32(
 
 }
 LOW_OPTIMIZATION_EXIT
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
+
 /**
   @} end of BiquadCascadeDF2T group
  */

CMSIS/DSP/Testing/CMakeLists.txt

@@ -147,9 +147,9 @@ set(TESTSRC
   Source/Tests/ComplexTestsQ15.cpp
   Source/Tests/SVMF32.cpp
   Source/Tests/BayesF32.cpp
-  Source/Tests/TransformCF64.cpp
+  #Source/Tests/TransformCF64.cpp
   Source/Tests/TransformCF32.cpp
-  Source/Tests/TransformRF64.cpp
+  #Source/Tests/TransformRF64.cpp
   Source/Tests/TransformRF32.cpp
   Source/Tests/TransformQ31.cpp
   Source/Tests/TransformQ15.cpp
@@ -183,6 +183,10 @@ set(TESTSRC
   Source/Tests/FIRQ31.cpp
   Source/Tests/FIRQ15.cpp
   Source/Tests/FIRQ7.cpp
+  Source/Tests/BIQUADF64.cpp
+  Source/Tests/BIQUADF32.cpp
+  Source/Tests/BIQUADQ31.cpp
+  Source/Tests/BIQUADQ15.cpp
   Source/Tests/Pooling.cpp
   Source/Tests/Softmax.cpp
   Source/Tests/NNSupport.cpp

CMSIS/DSP/Testing/DebugScripts/debugbiquad.py

@@ -0,0 +1,49 @@
+import numpy as np
+from pylab import figure, clf, plot, xlabel, ylabel, xlim, ylim, title, grid, axes, show,semilogx, semilogy
+import scipy.fftpack
+import os.path 
+import struct
+import argparse
+import sys
+from inspect import getsourcefile
+
+current_path = os.path.abspath(getsourcefile(lambda:0))
+current_dir = os.path.dirname(current_path)
+parent_dir = current_dir[:current_dir.rfind(os.path.sep)]
+
+sys.path.insert(0, parent_dir)
+
+import PatternGeneration.DebugTools as d
+
+f = "f32"
+
+inputPath = os.path.join(parent_dir,"Patterns","DSP","Filtering","BIQUAD","BIQUAD%s" % f.upper(),"BiquadInput1_%s.txt" % f )
+refPath = os.path.join(parent_dir,"Patterns","DSP","Filtering","BIQUAD","BIQUAD%s" % f.upper(),"BiquadOutput1_%s.txt" % f)
+outputPath= os.path.join(parent_dir,"Output","DSP","Filtering","BIQUAD","BIQUAD%s" % f.upper(),"Output_1.txt")
+
+
+
+
+inSig = d.readF32Pattern(inputPath)
+     
+refSig = d.readF32Pattern(refPath)
+     
+sig = d.readF32Output(outputPath)
+
+
+figure()
+plot(inSig)
+figure()
+plot(refSig)
+figure()
+plot(sig)
+
+#print(d.SNR(refSig,sig))
+
+#figure()
+#plot(np.unwrap(np.angle(refSig)))
+#figure()
+#plot(np.unwrap(np.angle(sig)))
+#figure()
+#plot(np.unwrap(np.angle(sig)) - np.unwrap(np.angle(refSig)))
+show()#

CMSIS/DSP/Testing/FrameworkInclude/Error.h

@@ -85,6 +85,9 @@ to get the line number.
 extern void assert_relative_error(unsigned long nb,float32_t &a, float32_t &b, double threshold);
 extern void assert_relative_error(unsigned long nb,AnyPattern<float32_t> &pa, AnyPattern<float32_t> &pb, double threshold);
 
+extern void assert_relative_error(unsigned long nb,float64_t &a, float64_t &b, double threshold);
+extern void assert_relative_error(unsigned long nb,AnyPattern<float64_t> &pa, AnyPattern<float64_t> &pb, double threshold);
+
 /* Similar to numpy isclose */
 extern void assert_close_error(unsigned long nb,float64_t &ref, float64_t &val, double absthreshold, double relthreshold);
 extern void assert_close_error(unsigned long nb,AnyPattern<float64_t> &pref, AnyPattern<float64_t> &pval, double absthreshold, double relthreshold);

CMSIS/DSP/Testing/FrameworkSource/Error.cpp

@@ -142,6 +142,26 @@ void assert_not_empty(unsigned long nb, AnyPattern<q7_t> &p)
   assert_not_empty_generic(nb,p);
 }
 
+void assert_relative_error(unsigned long nb,float64_t &a, float64_t &b, double threshold)
+{
+    float64_t rel,delta,average;
+
+    delta=abs(a-b);
+    average = (abs(a) + abs(b)) / 2.0f;
+    if (average !=0)
+    {
+        rel = delta / average;
+        //printf("%6.9f %6.9f %6.9f %g %g\n",a,b,rel,delta,average);
+        if (rel > threshold)
+        {
+            //printf("rel = %g, threshold %g \n",rel,threshold);
+            char details[200];
+            sprintf(details,"diff (%g,%g), %g > %g",a,b,rel , threshold);
+            throw (Error(RELATIVE_ERROR,nb,details));
+        }
+    }
+};
+
 void assert_relative_error(unsigned long nb,float32_t &a, float32_t &b, double threshold)
 {
     double rel,delta,average;
@@ -162,6 +182,37 @@ void assert_relative_error(unsigned long nb,float32_t &a, float32_t &b, double t
     }
 };
 
+void assert_relative_error(unsigned long nb,AnyPattern<float64_t> &pa, AnyPattern<float64_t> &pb, double threshold)
+{
+    ASSERT_NOT_EMPTY(pa);
+    ASSERT_NOT_EMPTY(pb);
+
+    if (pa.nbSamples() != pb.nbSamples())
+    {
+        throw (Error(DIFFERENT_LENGTH_ERROR,nb));
+    }
+
+    unsigned long i=0;
+
+    float64_t *ptrA = pa.ptr();
+    float64_t *ptrB = pb.ptr();
+    char id[40];
+
+    for(i=0; i < pa.nbSamples(); i++)
+    {
+       try
+       {
+          assert_relative_error(nb,ptrA[i],ptrB[i],threshold);
+       }
+       catch(Error &err)
+       {          
+          sprintf(id," (nb=%lu)",i+1);
+          strcat(err.details,id);
+          throw(err);
+       }
+    }
+};
+
 void assert_relative_error(unsigned long nb,AnyPattern<float32_t> &pa, AnyPattern<float32_t> &pb, double threshold)
 {
     ASSERT_NOT_EMPTY(pa);

CMSIS/DSP/Testing/Include/Tests/BIQUADF32.h

@@ -0,0 +1,27 @@
+#include "Test.h"
+#include "Pattern.h"
+class BIQUADF32:public Client::Suite
+    {
+        public:
+            BIQUADF32(Testing::testID_t id);
+            virtual void setUp(Testing::testID_t,std::vector<Testing::param_t>& params,Client::PatternMgr *mgr);
+            virtual void tearDown(Testing::testID_t,Client::PatternMgr *mgr);
+        private:
+            #include "BIQUADF32_decl.h"
+            
+            Client::Pattern<float32_t> coefs;
+            Client::Pattern<float32_t> inputs;
+            Client::Pattern<int16_t> configs;
+            Client::LocalPattern<float32_t> output;
+            Client::LocalPattern<float32_t> state;
+            Client::LocalPattern<float32_t> debugstate;
+            Client::LocalPattern<float32_t> vecCoefs;
+            // Reference patterns are not loaded when we are in dump mode
+            Client::RefPattern<float32_t> ref;
+
+
+            arm_biquad_casd_df1_inst_f32 Sdf1;
+            arm_biquad_cascade_df2T_instance_f32 Sdf2T;
+            arm_biquad_cascade_stereo_df2T_instance_f32 SStereodf2T;
+
+    };

CMSIS/DSP/Testing/Include/Tests/BIQUADF64.h

@@ -0,0 +1,25 @@
+#include "Test.h"
+#include "Pattern.h"
+class BIQUADF64:public Client::Suite
+    {
+        public:
+            BIQUADF64(Testing::testID_t id);
+            virtual void setUp(Testing::testID_t,std::vector<Testing::param_t>& params,Client::PatternMgr *mgr);
+            virtual void tearDown(Testing::testID_t,Client::PatternMgr *mgr);
+        private:
+            #include "BIQUADF64_decl.h"
+            
+            Client::Pattern<float64_t> coefs;
+            Client::Pattern<float64_t> inputs;
+            Client::Pattern<int16_t> configs;
+            Client::LocalPattern<float64_t> output;
+            Client::LocalPattern<float64_t> state;
+            Client::LocalPattern<float64_t> debugstate;
+            Client::LocalPattern<float64_t> vecCoefs;
+            // Reference patterns are not loaded when we are in dump mode
+            Client::RefPattern<float64_t> ref;
+
+
+            arm_biquad_cascade_df2T_instance_f64 Sdf2T;
+
+    };

CMSIS/DSP/Testing/Include/Tests/BIQUADQ15.h

@@ -0,0 +1,22 @@
+#include "Test.h"
+#include "Pattern.h"
+class BIQUADQ15:public Client::Suite
+    {
+        public:
+            BIQUADQ15(Testing::testID_t id);
+            virtual void setUp(Testing::testID_t,std::vector<Testing::param_t>& params,Client::PatternMgr *mgr);
+            virtual void tearDown(Testing::testID_t,Client::PatternMgr *mgr);
+        private:
+            #include "BIQUADQ15_decl.h"
+            
+            Client::Pattern<q15_t> coefs;
+            Client::Pattern<q15_t> inputs;
+            Client::LocalPattern<q15_t> output;
+            Client::LocalPattern<q15_t> state;
+            // Reference patterns are not loaded when we are in dump mode
+            Client::RefPattern<q15_t> ref;
+
+
+            arm_biquad_casd_df1_inst_q15 S;
+
+    };

CMSIS/DSP/Testing/Include/Tests/BIQUADQ31.h

@@ -0,0 +1,24 @@
+#include "Test.h"
+#include "Pattern.h"
+class BIQUADQ31:public Client::Suite
+    {
+        public:
+            BIQUADQ31(Testing::testID_t id);
+            virtual void setUp(Testing::testID_t,std::vector<Testing::param_t>& params,Client::PatternMgr *mgr);
+            virtual void tearDown(Testing::testID_t,Client::PatternMgr *mgr);
+        private:
+            #include "BIQUADQ31_decl.h"
+            
+            Client::Pattern<q31_t> coefs;
+            Client::Pattern<q31_t> inputs;
+            Client::LocalPattern<q31_t> output;
+            Client::LocalPattern<q31_t> state;
+            Client::LocalPattern<q63_t> state64;
+            // Reference patterns are not loaded when we are in dump mode
+            Client::RefPattern<q31_t> ref;
+
+
+            arm_biquad_casd_df1_inst_q31 S;
+            arm_biquad_cas_df1_32x64_ins_q31 S32x64;
+
+    };

CMSIS/DSP/Testing/PatternGeneration/BIQUAD.py

@@ -2,14 +2,20 @@ import os.path
 import numpy as np
 import itertools
 import Tools
-
+from scipy import signal
+from pylab import figure, clf, plot, xlabel, ylabel, xlim, ylim, title, grid, axes, show,semilogx, semilogy
+import math
 
 # Those patterns are used for tests and benchmarks.
 # For tests, there is the need to add tests for saturation
 
+def cartesian(*somelists):
+   r=[]
+   for element in itertools.product(*somelists):
+       r.append(element)
+   return(r)
 
-
-def writeTests(config):
+def writeBenchmarks(config):
     NBSAMPLES=512 # 512 for stereo
     NUMSTAGES = 4
 
@@ -20,9 +26,150 @@ def writeTests(config):
     coefs = Tools.normalize(coefs)
     
 
+    # Used for benchmarks
     config.writeInput(1, samples,"Samples")
     config.writeInput(1, coefs,"Coefs")
 
+def getCoefs(n,sos,format):
+    if format==15:
+       coefs=np.reshape(np.hstack((np.insert(sos[:,:3],1,0.0,axis=1),-sos[:,4:])),n*6)
+    else:
+       coefs=np.reshape(np.hstack((sos[:,:3],-sos[:,4:])),n*5)
+    
+    if format==31:
+        # Postshift must be 2 in the tests
+        coefs = coefs / 4.0
+
+    if format==15:
+        # Postshift must be 2 in the tests
+        coefs = coefs / 4.0
+
+    return(coefs)
+
+def genSos(numTaps):
+    zeros=[] 
+    poles=[] 
+    for i in range(0,numTaps):
+        phase = np.random.rand()*2.0 * math.pi
+        z = np.exp(1j*phase)
+
+        phase = np.random.rand()*2.0 * math.pi
+        amplitude = np.random.rand()*0.7
+        p = np.exp(1j*phase) * amplitude
+
+        zeros += [z,np.conj(z)]
+        poles += [p,np.conj(p)]
+    
+    g = 0.02
+
+    sos = signal.zpk2sos(zeros,poles,g)
+
+    return(sos)
+
+
+def writeTests(config,format):
+    # Write test with fixed and known patterns
+    NB = 100
+    t = np.linspace(0, 1,NB)
+
+    sig = Tools.normalize(np.sin(2*np.pi*5*t)+np.random.randn(len(t)) * 0.2 + 0.4*np.sin(2*np.pi*20*t))
+
+    if format==31:
+       sig = 1.0*sig / (1 << 2)
+
+    #if format==15:
+    #   sig = 1.0*sig / 2.0
+
+    p0 = np.exp(1j*0.05) * 0.98 
+    p1 = np.exp(1j*0.25) * 0.9 
+    p2 = np.exp(1j*0.45) * 0.97
+    
+    z0 = np.exp(1j*0.02)
+    z1 = np.exp(1j*0.65)
+    z2 = np.exp(1j*1.0)
+    
+    g = 0.02
+        
+    sos = signal.zpk2sos(
+          [z0,np.conj(z0),z1,np.conj(z1),z2,np.conj(z2)]
+         ,[p0, np.conj(p0),p1, np.conj(p1),p2, np.conj(p2)]
+         ,g)
+
+    coefs=getCoefs(3,sos,format)
+    
+    res=signal.sosfilt(sos,sig)
+
+    config.writeInput(1, sig,"BiquadInput")
+    config.writeInput(1, res,"BiquadOutput")
+    config.writeInput(1, coefs,"BiquadCoefs")
+
+    #if format==0:
+    #   figure()
+    #   plot(sig)
+    #   figure()
+    #   plot(res)
+    #   show()
+
+    # Now random patterns to test different tail sizes
+    # and number of loops
+
+    numStages = [Tools.loopnb(format,Tools.TAILONLY),
+       Tools.loopnb(format,Tools.BODYONLY),
+       Tools.loopnb(format,Tools.BODYANDTAIL)
+    ]
+
+    blockSize=[Tools.loopnb(format,Tools.TAILONLY),
+       Tools.loopnb(format,Tools.BODYONLY),
+       Tools.loopnb(format,Tools.BODYANDTAIL)
+    ]
+
+    allConfigs = cartesian(numStages, blockSize)
+    
+    allconf=[] 
+    allcoefs=[]
+    allsamples=[]
+    allStereo=[]
+    alloutputs=[]
+    allStereoOutputs=[]
+
+    for (n,b) in allConfigs:
+        samples=np.random.randn(b)
+        samples = Tools.normalize(samples)
+
+        samplesB=np.random.randn(b)
+        samplesB = Tools.normalize(samplesB)
+
+        stereo = np.empty((samples.size + samplesB.size,), dtype=samples.dtype)
+        stereo[0::2] = samples
+        stereo[1::2] = samplesB
+
+        sos = genSos(n)
+        coefs=getCoefs(n,sos,format)
+        
+        output=signal.sosfilt(sos,samples)
+        outputB=signal.sosfilt(sos,samplesB)
+
+        stereoOutput = np.empty((output.size + outputB.size,), dtype=output.dtype)
+        stereoOutput[0::2] = output
+        stereoOutput[1::2] = outputB
+
+        allStereoOutputs += list(stereoOutput)
+        alloutputs += list(output)
+        allconf += [n,b]
+        allcoefs += list(coefs)
+        allsamples += list(samples)
+        allStereo += list(stereo)
+
+
+    config.writeReferenceS16(2,allconf,"AllBiquadConfigs")
+    config.writeInput(2,allsamples,"AllBiquadInputs")
+    config.writeInput(2,allcoefs,"AllBiquadCoefs")
+    config.writeReference(2,alloutputs,"AllBiquadRefs")
+    if format==0:
+        config.writeInput(2,allStereo,"AllBiquadStereoInputs")
+        config.writeReference(2,allStereoOutputs,"AllBiquadStereoRefs")
+
+
     
 def generatePatterns():
     PATTERNDIR = os.path.join("Patterns","DSP","Filtering","BIQUAD","BIQUAD")
@@ -36,10 +183,15 @@ def generatePatterns():
     
     
     
-    writeTests(configf32)
-    writeTests(configq31)
-    writeTests(configq15)
-    writeTests(configf64)
+    writeBenchmarks(configf32)
+    writeBenchmarks(configq31)
+    writeBenchmarks(configq15)
+    writeBenchmarks(configf64)
+
+    writeTests(configf32,0)
+    writeTests(configq31,31)
+    writeTests(configq15,15)
+    writeTests(configf64,64)
     
     #writeTests(configq7)
 

CMSIS/DSP/Testing/PatternGeneration/Tools.py

@@ -12,6 +12,8 @@ BODYANDTAIL = 3
 def loopnb(format,loopkind):
     nb = 0
     if loopkind == TAILONLY:
+        if format == 64:
+            nb = 1 
         if format == 0 or format == 31:
             nb = 3 
         if format == 15:
@@ -19,6 +21,8 @@ def loopnb(format,loopkind):
         if format == 7:
             nb = 15
     if loopkind == BODYONLY:
+        if format == 64:
+            nb = 4 
         if format == 0 or format == 31:
             nb = 8 
         if format == 15:
@@ -26,6 +30,8 @@ def loopnb(format,loopkind):
         if format == 7:
             nb = 32
     if loopkind == BODYANDTAIL:
+        if format == 64:
+            nb = 5
         if format == 0 or format == 31:
             nb = 11 # 9
         if format == 15:

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADF32/AllBiquadCoefs2_f32.txt

@@ -0,0 +1,662 @@
+W
+330
+// 0.020000
+0x3ca3d70a
+// 0.012037
+0x3c4537e4
+// 0.020000
+0x3ca3d70a
+// 0.199104
+0x3e4be208
+// -0.012306
+0xbc499fe1
+// 1.000000
+0x3f800000
+// 1.889097
+0x3ff1cdec
+// 1.000000
+0x3f800000
+// -0.949678
+0xbf731e19
+// -0.236693
+0xbe725f8a
+// 1.000000
+0x3f800000
+// 1.037196
+0x3f84c2d6
+// 1.000000
+0x3f800000
+// -0.495325
+0xbefd9b34
+// -0.313520
+0xbea085a6
+// 0.020000
+0x3ca3d70a
+// -0.024479
+0xbcc888ab
+// 0.020000
+0x3ca3d70a
+// -0.471932
+0xbef1a105
+// -0.082296
+0xbda88ab3
+// 1.000000
+0x3f800000
+// -0.874890
+0xbf5ff8c6
+// 1.000000
+0x3f800000
+// -0.863779
+0xbf5d20a3
+// -0.208806
+0xbe55d122
+// 1.000000
+0x3f800000
+// -0.827090
+0xbf53bc2c
+// 1.000000
+0x3f800000
+// -1.384395
+0xbfb133d9
+// -0.481299
+0xbef66cd1
+// 0.020000
+0x3ca3d70a
+// 0.038033
+0x3d1bc833
+// 0.020000
+0x3ca3d70a
+// -0.032064
+0xbd0355e1
+// -0.000267
+0xb98bf1f3
+// 1.000000
+0x3f800000
+// 1.474981
+0x3fbccc2c
+// 1.000000
+0x3f800000
+// 0.007100
+0x3be8a4a2
+// -0.001515
+0xbac68db9
+// 1.000000
+0x3f800000
+// -1.887427
+0xbff19732
+// 1.000000
+0x3f800000
+// 0.899127
+0x3f662d36
+// -0.384210
+0xbec4b721
+// 0.020000
+0x3ca3d70a
+// -0.013804
+0xbc622b92
+// 0.020000
+0x3ca3d70a
+// -0.117502
+0xbdf0a4fa
+// -0.012055
+0xbc45833d
+// 1.000000
+0x3f800000
+// 1.078180
+0x3f8a01cb
+// 1.000000
+0x3f800000
+// -0.129681
+0xbe04cb2b
+// -0.033098
+0xbd079165
+// 1.000000
+0x3f800000
+// 0.996541
+0x3f7f1d51
+// 1.000000
+0x3f800000
+// -0.194323
+0xbe46fc7e
+// -0.038220
+0xbd1c8ce6
+// 1.000000
+0x3f800000
+// -0.687177
+0xbf2feada
+// 1.000000
+0x3f800000
+// 0.063508
+0x3d82109a
+// -0.042775
+0xbd2f34ea
+// 1.000000
+0x3f800000
+// 1.704006
+0x3fda1cdb
+// 1.000000
+0x3f800000
+// -0.548171
+0xbf0c54e7
+// -0.084293
+0xbdaca1a4
+// 1.000000
+0x3f800000
+// -0.628642
+0xbf20eeb1
+// 1.000000
+0x3f800000
+// 0.199490
+0x3e4c4735
+// -0.156659
+0xbe206b56
+// 1.000000
+0x3f800000
+// -1.965964
+0xbffba4b8
+// 1.000000
+0x3f800000
+// 0.678742
+0x3f2dc202
+// -0.169337
+0xbe2d66a5
+// 1.000000
+0x3f800000
+// 0.052987
+0x3d590906
+// 1.000000
+0x3f800000
+// -0.347633
+0xbeb1fce7
+// -0.485736
+0xbef8b263
+// 0.020000
+0x3ca3d70a
+// 0.039890
+0x3d236345
+// 0.020000
+0x3ca3d70a
+// -0.059243
+0xbd72a875
+// -0.000878
+0xba66091c
+// 1.000000
+0x3f800000
+// 1.979571
+0x3ffd6291
+// 1.000000
+0x3f800000
+// -0.045561
+0xbd3a9e51
+// -0.009813
+0xbc20c6a3
+// 1.000000
+0x3f800000
+// -0.233140
+0xbe6ebc3f
+// 1.000000
+0x3f800000
+// 0.229830
+0x3e6b5871
+// -0.016231
+0xbc84f62a
+// 1.000000
+0x3f800000
+// -0.438341
+0xbee06e37
+// 1.000000
+0x3f800000
+// 0.204474
+0x3e516193
+// -0.021394
+0xbcaf42f2
+// 1.000000
+0x3f800000
+// 1.640090
+0x3fd1ee78
+// 1.000000
+0x3f800000
+// -0.341116
+0xbeaea6cd
+// -0.087470
+0xbdb3237b
+// 1.000000
+0x3f800000
+// -0.776720
+0xbf46d727
+// 1.000000
+0x3f800000
+// 0.281065
+0x3e8fe7d1
+// -0.156631
+0xbe2063e0
+// 1.000000
+0x3f800000
+// -1.600251
+0xbfccd506
+// 1.000000
+0x3f800000
+// 0.844595
+0x3f583767
+// -0.191939
+0xbe448ba6
+// 1.000000
+0x3f800000
+// 0.040010
+0x3d23e128
+// 1.000000
+0x3f800000
+// -0.210694
+0xbe57c043
+// -0.376728
+0xbec0e285
+// 0.020000
+0x3ca3d70a
+// 0.038789
+0x3d1ee0b2
+// 0.020000
+0x3ca3d70a
+// 0.091082
+0x3dba8964
+// -0.002485
+0xbb22da4f
+// 1.000000
+0x3f800000
+// 1.898529
+0x3ff302fc
+// 1.000000
+0x3f800000
+// 0.093405
+0x3dbf4b31
+// -0.005958
+0xbbc33824
+// 1.000000
+0x3f800000
+// 1.831999
+0x3fea7ef0
+// 1.000000
+0x3f800000
+// -0.055416
+0xbd62fbcc
+// -0.006199
+0xbbcb1d49
+// 1.000000
+0x3f800000
+// 1.808033
+0x3fe76d9e
+// 1.000000
+0x3f800000
+// -0.027387
+0xbce05a56
+// -0.021675
+0xbcb1908b
+// 1.000000
+0x3f800000
+// 1.030738
+0x3f83ef38
+// 1.000000
+0x3f800000
+// 0.318118
+0x3ea2e05d
+// -0.028561
+0xbce9f862
+// 1.000000
+0x3f800000
+// 1.855541
+0x3fed8262
+// 1.000000
+0x3f800000
+// -0.612809
+0xbf1ce115
+// -0.109676
+0xbde09de6
+// 1.000000
+0x3f800000
+// -1.547572
+0xbfc616d5
+// 1.000000
+0x3f800000
+// 0.622561
+0x3f1f602c
+// -0.126454
+0xbe017d15
+// 1.000000
+0x3f800000
+// -0.045237
+0xbd394a0c
+// 1.000000
+0x3f800000
+// 0.243642
+0x3e797d54
+// -0.322207
+0xbea4f84a
+// 0.020000
+0x3ca3d70a
+// 0.038807
+0x3d1ef3ca
+// 0.020000
+0x3ca3d70a
+// 0.083747
+0x3dab83b1
+// -0.003924
+0xbb80940d
+// 1.000000
+0x3f800000
+// 1.781231
+0x3fe3ff5d
+// 1.000000
+0x3f800000
+// -0.188276
+0xbe40cb7e
+// -0.012151
+0xbc4713ed
+// 1.000000
+0x3f800000
+// 1.418355
+0x3fb58cab
+// 1.000000
+0x3f800000
+// 0.187357
+0x3e3fda77
+// -0.049920
+0xbd4c7967
+// 1.000000
+0x3f800000
+// 1.924918
+0x3ff663b4
+// 1.000000
+0x3f800000
+// -0.451611
+0xbee73997
+// -0.058635
+0xbd702bc4
+// 1.000000
+0x3f800000
+// 0.776756
+0x3f46d974
+// 1.000000
+0x3f800000
+// 0.552291
+0x3f0d62f9
+// -0.077941
+0xbd9f9f9a
+// 1.000000
+0x3f800000
+// 1.184366
+0x3f97994d
+// 1.000000
+0x3f800000
+// -0.397430
+0xbecb7be9
+// -0.101465
+0xbdcfccc5
+// 1.000000
+0x3f800000
+// 1.995827
+0x3fff7741
+// 1.000000
+0x3f800000
+// -0.645810
+0xbf2553d1
+// -0.104271
+0xbdd58c04
+// 1.000000
+0x3f800000
+// -1.863420
+0xbfee8488
+// 1.000000
+0x3f800000
+// 0.646199
+0x3f256d44
+// -0.113331
+0xbde819e8
+// 1.000000
+0x3f800000
+// -1.752569
+0xbfe05432
+// 1.000000
+0x3f800000
+// 0.631625
+0x3f21b227
+// -0.134006
+0xbe0938f1
+// 1.000000
+0x3f800000
+// -1.623323
+0xbfcfc90b
+// 1.000000
+0x3f800000
+// 0.602597
+0x3f1a43cf
+// -0.162854
+0xbe26c338
+// 1.000000
+0x3f800000
+// -1.977609
+0xbffd2247
+// 1.000000
+0x3f800000
+// 0.983587
+0x3f7bcc55
+// -0.251309
+0xbe80ab96
+// 0.020000
+0x3ca3d70a
+// -0.017903
+0xbc92a917
+// 0.020000
+0x3ca3d70a
+// -0.034908
+0xbd0efc03
+// -0.003146
+0xbb4e25cb
+// 1.000000
+0x3f800000
+// 0.361548
+0x3eb91cd3
+// 1.000000
+0x3f800000
+// -0.090211
+0xbdb8c052
+// -0.004580
+0xbb9614fd
+// 1.000000
+0x3f800000
+// 0.767944
+0x3f4497fc
+// 1.000000
+0x3f800000
+// -0.079952
+0xbda3be0c
+// -0.012337
+0xbc4a203f
+// 1.000000
+0x3f800000
+// 0.936274
+0x3f6fafa5
+// 1.000000
+0x3f800000
+// -0.178513
+0xbe36cc00
+// -0.034154
+0xbd0be585
+// 1.000000
+0x3f800000
+// 0.231904
+0x3e6d7857
+// 1.000000
+0x3f800000
+// -0.025949
+0xbcd49373
+// -0.059723
+0xbd74a00a
+// 1.000000
+0x3f800000
+// -1.042340
+0xbf856b67
+// 1.000000
+0x3f800000
+// 0.728804
+0x3f3a92ed
+// -0.133781
+0xbe08fde1
+// 1.000000
+0x3f800000
+// 0.957638
+0x3f7527c5
+// 1.000000
+0x3f800000
+// -0.681966
+0xbf2e9558
+// -0.178044
+0xbe365144
+// 1.000000
+0x3f800000
+// -1.374160
+0xbfafe47a
+// 1.000000
+0x3f800000
+// 0.984319
+0x3f7bfc50
+// -0.295302
+0xbe9731c6
+// 1.000000
+0x3f800000
+// -1.502140
+0xbfc0461f
+// 1.000000
+0x3f800000
+// 1.079661
+0x3f8a3254
+// -0.320158
+0xbea3ebb3
+// 1.000000
+0x3f800000
+// -0.176259
+0xbe347d51
+// 1.000000
+0x3f800000
+// 0.075974
+0x3d9b9805
+// -0.336093
+0xbeac1463
+// 1.000000
+0x3f800000
+// -1.997183
+0xbfffa3b5
+// 1.000000
+0x3f800000
+// 1.260405
+0x3fa154f6
+// -0.406372
+0xbed00ffb
+// 0.020000
+0x3ca3d70a
+// 0.002067
+0x3b077d7d
+// 0.020000
+0x3ca3d70a
+// -0.054644
+0xbd5fd22f
+// -0.001188
+0xba9bb410
+// 1.000000
+0x3f800000
+// 0.063542
+0x3d82227c
+// 1.000000
+0x3f800000
+// 0.038380
+0x3d1d349f
+// -0.002330
+0xbb18b85a
+// 1.000000
+0x3f800000
+// -1.308848
+0xbfa78858
+// 1.000000
+0x3f800000
+// 0.201415
+0x3e4e3fb8
+// -0.010154
+0xbc265e7a
+// 1.000000
+0x3f800000
+// 0.324443
+0x3ea61d65
+// 1.000000
+0x3f800000
+// -0.202344
+0xbe4f335c
+// -0.035189
+0xbd1022a9
+// 1.000000
+0x3f800000
+// 0.183186
+0x3e3b9525
+// 1.000000
+0x3f800000
+// -0.037334
+0xbd18ebdd
+// -0.035224
+0xbd104721
+// 1.000000
+0x3f800000
+// 0.371348
+0x3ebe215e
+// 1.000000
+0x3f800000
+// -0.415932
+0xbed4f50b
+// -0.045002
+0xbd385402
+// 1.000000
+0x3f800000
+// 0.620615
+0x3f1ee0a2
+// 1.000000
+0x3f800000
+// -0.438865
+0xbee0b2f1
+// -0.049304
+0xbd49f354
+// 1.000000
+0x3f800000
+// 1.855075
+0x3fed7316
+// 1.000000
+0x3f800000
+// -0.520948
+0xbf055cd5
+// -0.084570
+0xbdad3318
+// 1.000000
+0x3f800000
+// -0.082484
+0xbda8ed71
+// 1.000000
+0x3f800000
+// 0.039669
+0x3d227c25
+// -0.104842
+0xbdd6b75f
+// 1.000000
+0x3f800000
+// 0.710359
+0x3f35da0f
+// 1.000000
+0x3f800000
+// -0.353830
+0xbeb5293e
+// -0.245166
+0xbe7b0caf
+// 1.000000
+0x3f800000
+// 1.961346
+0x3ffb0d63
+// 1.000000
+0x3f800000
+// -1.326857
+0xbfa9d672
+// -0.468162
+0xbeefb2fb

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADF32/AllBiquadConfigs2_s16.txt

@@ -0,0 +1,38 @@
+H
+18
+// 3
+0x0003
+// 3
+0x0003
+// 3
+0x0003
+// 8
+0x0008
+// 3
+0x0003
+// 11
+0x000B
+// 8
+0x0008
+// 3
+0x0003
+// 8
+0x0008
+// 8
+0x0008
+// 8
+0x0008
+// 11
+0x000B
+// 11
+0x000B
+// 3
+0x0003
+// 11
+0x000B
+// 8
+0x0008
+// 11
+0x000B
+// 11
+0x000B

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADF32/AllBiquadInputs2_f32.txt

@@ -0,0 +1,134 @@
+W
+66
+// 1.000000
+0x3f800000
+// 0.512719
+0x3f034193
+// -0.657915
+0xbf286d19
+// -0.447759
+0xbee540a5
+// 0.162976
+0x3e26e33b
+// -0.626536
+0xbf2064a6
+// 0.941290
+0x3f70f85c
+// -0.271793
+0xbe8b287e
+// -1.000000
+0xbf800000
+// 0.239723
+0x3e7579ed
+// -0.367794
+0xbebc4f72
+// -0.669104
+0xbf2b4a68
+// -0.563614
+0xbf104907
+// 0.019646
+0x3ca0f100
+// -0.741586
+0xbf3dd896
+// -0.686987
+0xbf2fde5c
+// 0.632335
+0x3f21e0b3
+// 0.623159
+0x3f1f8754
+// 1.000000
+0x3f800000
+// -0.134520
+0xbe09bfba
+// -0.047935
+0xbd4457e9
+// 0.883679
+0x3f6238c4
+// -0.750073
+0xbf4004c9
+// -1.000000
+0xbf800000
+// 0.956342
+0x3f74d2d6
+// 1.000000
+0x3f800000
+// 0.286657
+0x3e92c4b5
+// 0.276657
+0x3e8da5fa
+// -0.041531
+0xbd2a1c65
+// -0.086568
+0xbdb14ac5
+// -0.272279
+0xbe8b6825
+// -0.075193
+0xbd99fec1
+// -0.135883
+0xbe0b24db
+// 0.128069
+0x3e03246e
+// -0.395272
+0xbeca6126
+// -0.493562
+0xbefcb439
+// 0.241812
+0x3e779dad
+// -0.003724
+0xbb74140c
+// -0.436178
+0xbedf52bc
+// 1.000000
+0x3f800000
+// -0.316548
+0xbea21297
+// -0.356192
+0xbeb65edc
+// -0.537246
+0xbf0988f0
+// 0.401044
+0x3ecd5598
+// 0.135919
+0x3e0b2e78
+// -0.343346
+0xbeafcb0f
+// -1.000000
+0xbf800000
+// -0.055716
+0xbd643694
+// -0.149905
+0xbe1980a7
+// 0.440345
+0x3ee174e4
+// 0.255234
+0x3e82ae0e
+// 0.242254
+0x3e78118b
+// -0.352286
+0xbeb45ecd
+// 0.922015
+0x3f6c0927
+// -1.000000
+0xbf800000
+// -0.212721
+0xbe59d39d
+// -0.464466
+0xbeedce8c
+// -0.719272
+0xbf382234
+// 0.456527
+0x3ee9bde9
+// -1.000000
+0xbf800000
+// 0.117568
+0x3df0c786
+// 0.524351
+0x3f063be1
+// -0.368739
+0xbebccb5b
+// -0.330865
+0xbea9671c
+// -0.137054
+0xbe0c57d3
+// 0.084210
+0x3dac7612

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADF32/AllBiquadRefs2_f32.txt

@@ -0,0 +1,134 @@
+W
+66
+// 0.020000
+0x3ca3d70a
+// 0.055900
+0x3d64f6e7
+// 0.072883
+0x3d9543cc
+// -0.008955
+0xbc12b8bc
+// 0.053821
+0x3d5c7346
+// -0.193340
+0xbe45faed
+// 0.513563
+0x3f0378e3
+// -1.109050
+0xbf8df559
+// 2.009222
+0x40009718
+// -3.098030
+0xc0464621
+// 4.080722
+0x40829547
+// -0.013382
+0xbc5b4085
+// -0.042899
+0xbd2fb6ba
+// -0.041428
+0xbd29b07c
+// 0.002628
+0x3b2c3898
+// 0.015366
+0x3c7bc19a
+// -0.000976
+0xba7fed63
+// 0.036623
+0x3d160196
+// 0.093172
+0x3dbed0f0
+// 0.044981
+0x3d383dcf
+// -0.082501
+0xbda8f659
+// -0.119776
+0xbdf54d25
+// -0.015001
+0xbc75c8af
+// -0.011961
+0xbc43f9a7
+// -0.007406
+0xbbf2b03c
+// 0.020000
+0x3ca3d70a
+// 0.075914
+0x3d9b78d8
+// 0.162109
+0x3e25fff0
+// 0.301184
+0x3e9a34d1
+// 0.474970
+0x3ef32f44
+// 0.621514
+0x3f1f1b8a
+// 0.746168
+0x3f3f04e3
+// 0.832243
+0x3f550dde
+// 0.002561
+0x3b27dcb6
+// 0.016286
+0x3c8569dd
+// 0.023050
+0x3cbcd362
+// -0.120717
+0xbdf73a80
+// -0.705511
+0xbf349c5a
+// -1.904387
+0xbff3c2f2
+// -3.425609
+0xc05b3d2e
+// -4.592662
+0xc092f716
+// -4.868969
+0xc09bce97
+// -4.313825
+0xc08a0adb
+// -3.625409
+0xc06806b5
+// 0.002718
+0x3b322700
+// 0.008925
+0x3c12386f
+// -0.025665
+0xbcd23f35
+// -0.001114
+0xba920e74
+// -0.002224
+0xbb11c874
+// 0.004722
+0x3b9ab905
+// -0.012871
+0xbc52df41
+// 0.045150
+0x3d38eee2
+// -0.053628
+0xbd5ba88b
+// 0.170905
+0x3e2f01be
+// -0.180991
+0xbe3955ce
+// -0.004254
+0xbb8b68b7
+// -0.016652
+0xbc886a6a
+// -0.062913
+0xbd80d8c2
+// -0.132137
+0xbe074ee7
+// -0.316513
+0xbea20e09
+// -0.465959
+0xbeee9221
+// -0.846801
+0xbf58c7f2
+// -0.993027
+0xbf7e3707
+// -1.428914
+0xbfb6e6a5
+// -1.477528
+0xbfbd1fa2
+// -1.685673
+0xbfd7c425

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADF32/AllBiquadStereoInputs2_f32.txt

@@ -0,0 +1,266 @@
+W
+132
+// 1.000000
+0x3f800000
+// 0.561685
+0x3f0fca96
+// 0.512719
+0x3f034193
+// 0.272361
+0x3e8b72e4
+// -0.657915
+0xbf286d19
+// -1.000000
+0xbf800000
+// -0.447759
+0xbee540a5
+// -0.020237
+0xbca5c85b
+// 0.162976
+0x3e26e33b
+// -0.538756
+0xbf09ebf0
+// -0.626536
+0xbf2064a6
+// -0.213121
+0xbe5a3c55
+// 0.941290
+0x3f70f85c
+// -0.471829
+0xbef1939c
+// -0.271793
+0xbe8b287e
+// -0.375274
+0xbec023d9
+// -1.000000
+0xbf800000
+// -0.068524
+0xbd8c5657
+// 0.239723
+0x3e7579ed
+// -1.000000
+0xbf800000
+// -0.367794
+0xbebc4f72
+// -0.280300
+0xbe8f8384
+// -0.669104
+0xbf2b4a68
+// -0.402517
+0xbece16c6
+// -0.563614
+0xbf104907
+// -0.314083
+0xbea0cf77
+// 0.019646
+0x3ca0f100
+// 0.710846
+0x3f35f9fe
+// -0.741586
+0xbf3dd896
+// 1.000000
+0x3f800000
+// -0.686987
+0xbf2fde5c
+// -0.298660
+0xbe98e9f8
+// 0.632335
+0x3f21e0b3
+// -0.750783
+0xbf403348
+// 0.623159
+0x3f1f8754
+// -0.082167
+0xbda8470e
+// 1.000000
+0x3f800000
+// -0.495482
+0xbefdafc7
+// -0.134520
+0xbe09bfba
+// -0.400830
+0xbecd3997
+// -0.047935
+0xbd4457e9
+// 0.428835
+0x3edb9052
+// 0.883679
+0x3f6238c4
+// 0.254721
+0x3e826ac4
+// -0.750073
+0xbf4004c9
+// -1.000000
+0xbf800000
+// -1.000000
+0xbf800000
+// 0.153887
+0x3e1d94a4
+// 0.956342
+0x3f74d2d6
+// 0.133443
+0x3e08a537
+// 1.000000
+0x3f800000
+// -1.000000
+0xbf800000
+// 0.286657
+0x3e92c4b5
+// 0.740608
+0x3f3d9883
+// 0.276657
+0x3e8da5fa
+// -0.135261
+0xbe0a81cb
+// -0.041531
+0xbd2a1c65
+// 0.900548
+0x3f668a53
+// -0.086568
+0xbdb14ac5
+// 0.555311
+0x3f0e28e4
+// -0.272279
+0xbe8b6825
+// 0.776666
+0x3f46d398
+// -0.075193
+0xbd99fec1
+// 0.983008
+0x3f7ba66b
+// -0.135883
+0xbe0b24db
+// 0.932658
+0x3f6ec2a8
+// 0.128069
+0x3e03246e
+// -0.092637
+0xbdbdb8aa
+// -0.395272
+0xbeca6126
+// -0.483020
+0xbef74e68
+// -0.493562
+0xbefcb439
+// -0.737194
+0xbf3cb8bb
+// 0.241812
+0x3e779dad
+// -0.374436
+0xbebfb60b
+// -0.003724
+0xbb74140c
+// 0.075550
+0x3d9ab9ce
+// -0.436178
+0xbedf52bc
+// 0.006722
+0x3bdc4632
+// 1.000000
+0x3f800000
+// -0.652489
+0xbf270982
+// -0.316548
+0xbea21297
+// -0.482437
+0xbef701ef
+// -0.356192
+0xbeb65edc
+// -1.000000
+0xbf800000
+// -0.537246
+0xbf0988f0
+// -0.154000
+0xbe1db24a
+// 0.401044
+0x3ecd5598
+// -0.064194
+0xbd837835
+// 0.135919
+0x3e0b2e78
+// -0.206427
+0xbe536194
+// -0.343346
+0xbeafcb0f
+// -1.000000
+0xbf800000
+// -1.000000
+0xbf800000
+// 0.810755
+0x3f4f8d9f
+// -0.055716
+0xbd643694
+// 1.000000
+0x3f800000
+// -0.149905
+0xbe1980a7
+// -0.693711
+0xbf319706
+// 0.440345
+0x3ee174e4
+// -0.132039
+0xbe07352a
+// 0.255234
+0x3e82ae0e
+// 0.940244
+0x3f70b3d7
+// 0.242254
+0x3e78118b
+// 0.584487
+0x3f15a0f3
+// -0.352286
+0xbeb45ecd
+// 0.542446
+0x3f0addc1
+// 0.922015
+0x3f6c0927
+// -0.291860
+0xbe956eb6
+// -1.000000
+0xbf800000
+// 0.420887
+0x3ed77e8b
+// -0.212721
+0xbe59d39d
+// -0.126301
+0xbe0154f6
+// -0.464466
+0xbeedce8c
+// -0.757766
+0xbf41fcf3
+// -0.719272
+0xbf382234
+// 0.306882
+0x3e9d1fa7
+// 0.456527
+0x3ee9bde9
+// 0.074444
+0x3d987640
+// -1.000000
+0xbf800000
+// 0.811711
+0x3f4fcc49
+// 0.117568
+0x3df0c786
+// -0.007453
+0xbbf43bd0
+// 0.524351
+0x3f063be1
+// 0.380236
+0x3ec2ae50
+// -0.368739
+0xbebccb5b
+// -0.263663
+0xbe86fecd
+// -0.330865
+0xbea9671c
+// -0.355301
+0xbeb5ea0e
+// -0.137054
+0xbe0c57d3
+// -0.277405
+0xbe8e0803
+// 0.084210
+0x3dac7612
+// 1.000000
+0x3f800000

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADF32/AllBiquadStereoRefs2_f32.txt

@@ -0,0 +1,266 @@
+W
+132
+// 0.020000
+0x3ca3d70a
+// 0.011234
+0x3c380d8d
+// 0.055900
+0x3d64f6e7
+// 0.031085
+0x3cfea6d3
+// 0.072883
+0x3d9543cc
+// 0.027615
+0x3ce238d1
+// -0.008955
+0xbc12b8bc
+// -0.000405
+0xb9d433a7
+// 0.053821
+0x3d5c7346
+// -0.008490
+0xbc0b195a
+// -0.193340
+0xbe45faed
+// 0.049234
+0x3d49a9e3
+// 0.513563
+0x3f0378e3
+// -0.164291
+0xbe283bef
+// -1.109050
+0xbf8df559
+// 0.378700
+0x3ec1e4fc
+// 2.009222
+0x40009718
+// -0.681898
+0xbf2e90e4
+// -3.098030
+0xc0464621
+// 0.982403
+0x3f7b7ebf
+// 4.080722
+0x40829547
+// -1.146704
+0xbf92c72f
+// -0.013382
+0xbc5b4085
+// -0.008050
+0xbc03e59d
+// -0.042899
+0xbd2fb6ba
+// -0.025307
+0xbccf519f
+// -0.041428
+0xbd29b07c
+// -0.009761
+0xbc1fed41
+// 0.002628
+0x3b2c3898
+// 0.064111
+0x3d834c90
+// 0.015366
+0x3c7bc19a
+// 0.094655
+0x3dc1da96
+// -0.000976
+0xba7fed63
+// -0.017070
+0xbc8bd574
+// 0.036623
+0x3d160196
+// -0.142240
+0xbe11a765
+// 0.093172
+0x3dbed0f0
+// -0.105422
+0xbdd7e7aa
+// 0.044981
+0x3d383dcf
+// 0.019934
+0x3ca34d54
+// -0.082501
+0xbda8f659
+// 0.082620
+0x3da93489
+// -0.119776
+0xbdf54d25
+// 0.083897
+0x3dabd24b
+// -0.015001
+0xbc75c8af
+// -0.020000
+0xbca3d70a
+// -0.011961
+0xbc43f9a7
+// 0.013795
+0x3c6203de
+// -0.007406
+0xbbf2b03c
+// -0.048643
+0xbd473d5d
+// 0.020000
+0x3ca3d70a
+// -0.020000
+0xbca3d70a
+// 0.075914
+0x3d9b78d8
+// -0.055369
+0xbd62ca5f
+// 0.162109
+0x3e25fff0
+// -0.087187
+0xbdb28ef9
+// 0.301184
+0x3e9a34d1
+// -0.133902
+0xbe091d90
+// 0.474970
+0x3ef32f44
+// -0.135893
+0xbe0b278f
+// 0.621514
+0x3f1f1b8a
+// -0.044669
+0xbd36f73d
+// 0.746168
+0x3f3f04e3
+// 0.110470
+0x3de23de8
+// 0.832243
+0x3f550dde
+// 0.383311
+0x3ec4415f
+// 0.002561
+0x3b27dcb6
+// -0.001853
+0xbaf2d7e4
+// 0.016286
+0x3c8569dd
+// -0.027159
+0xbcde7c77
+// 0.023050
+0x3cbcd362
+// -0.183804
+0xbe3c3722
+// -0.120717
+0xbdf73a80
+// -0.769313
+0xbf44f1b4
+// -0.705511
+0xbf349c5a
+// -2.244718
+0xc00fa974
+// -1.904387
+0xbff3c2f2
+// -4.877386
+0xc09c138c
+// -3.425609
+0xc05b3d2e
+// -8.259460
+0xc10426c0
+// -4.592662
+0xc092f716
+// -11.387343
+0xc136328f
+// -4.868969
+0xc09bce97
+// -13.581676
+0xc1594e8b
+// -4.313825
+0xc08a0adb
+// -15.353149
+0xc175a67f
+// -3.625409
+0xc06806b5
+// -17.998041
+0xc18ffbfd
+// 0.002718
+0x3b322700
+// -0.004129
+0xbb8748b1
+// 0.008925
+0x3c12386f
+// -0.043983
+0xbd3427cc
+// -0.025665
+0xbcd23f35
+// -0.151948
+0xbe1b9858
+// -0.001114
+0xba920e74
+// 0.020000
+0x3ca3d70a
+// -0.002224
+0xbb11c874
+// -0.027759
+0xbce36786
+// 0.004722
+0x3b9ab905
+// 0.117670
+0x3df0fd01
+// -0.012871
+0xbc52df41
+// -0.141039
+0xbe106c81
+// 0.045150
+0x3d38eee2
+// 0.359069
+0x3eb7d7e5
+// -0.053628
+0xbd5ba88b
+// -0.340209
+0xbeae2fd1
+// 0.170905
+0x3e2f01be
+// 0.680563
+0x3f2e3967
+// -0.180991
+0xbe3955ce
+// -0.477400
+0xbef46dc6
+// -0.004254
+0xbb8b68b7
+// -0.002526
+0xbb258b78
+// -0.016652
+0xbc886a6a
+// -0.019527
+0xbc9ff714
+// -0.062913
+0xbd80d8c2
+// -0.039359
+0xbd21368c
+// -0.132137
+0xbe074ee7
+// -0.130513
+0xbe05a51d
+// -0.316513
+0xbea20e09
+// -0.157788
+0xbe21933c
+// -0.465959
+0xbeee9221
+// -0.336363
+0xbeac37ca
+// -0.846801
+0xbf58c7f2
+// -0.256820
+0xbe837de3
+// -0.993027
+0xbf7e3707
+// -0.389138
+0xbec73d0a
+// -1.428914
+0xbfb6e6a5
+// -0.106705
+0xbdda8855
+// -1.477528
+0xbfbd1fa2
+// -0.076535
+0xbd9cbe2c
+// -1.685673
+0xbfd7c425
+// 0.279158
+0x3e8eedc2

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADF32/BiquadCoefs1_f32.txt

@@ -0,0 +1,32 @@
+W
+15
+// 0.020000
+0x3ca3d70a
+// -0.021612
+0xbcb10bd8
+// 0.020000
+0x3ca3d70a
+// 1.744042
+0x3fdf3cc8
+// -0.810000
+0xbf4f5c29
+// 1.000000
+0x3f800000
+// -1.592168
+0xbfcbcc26
+// 1.000000
+0x3f800000
+// 1.746867
+0x3fdf995a
+// -0.940900
+0xbf70ded3
+// 1.000000
+0x3f800000
+// -1.999600
+0xbffff2e5
+// 1.000000
+0x3f800000
+// 1.957551
+0x3ffa9104
+// -0.960400
+0xbf75dcc6

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADF32/BiquadInput1_f32.txt

@@ -0,0 +1,202 @@
+W
+100
+// -0.029936
+0xbcf53bc7
+// 0.284509
+0x3e91ab21
+// 0.668647
+0x3f2b2c74
+// 0.306880
+0x3e9d1f6b
+// 0.213973
+0x3e5b1bd3
+// 0.538225
+0x3f09c922
+// 0.766250
+0x3f4428f3
+// 0.563234
+0x3f103015
+// 0.112109
+0x3de599a3
+// -0.020372
+0xbca6e341
+// -0.042498
+0xbd2e1214
+// -0.016551
+0xbc87968f
+// -0.168763
+0xbe2cd052
+// -0.610973
+0xbf1c68c2
+// -0.835429
+0xbf55dea8
+// -0.638178
+0xbf235faa
+// -0.318169
+0xbea2e717
+// -0.268756
+0xbe899a6f
+// -0.400647
+0xbecd218b
+// -0.380073
+0xbec298f8
+// -0.021168
+0xbcad67b9
+// 0.535375
+0x3f090e58
+// 0.548437
+0x3f0c6656
+// 0.420556
+0x3ed75328
+// 0.390134
+0x3ec7bfac
+// 0.561865
+0x3f0fd65f
+// 0.685807
+0x3f2f9107
+// 0.536016
+0x3f093857
+// 0.159308
+0x3e232195
+// 0.003765
+0x3b76b844
+// 0.156077
+0x3e1fd2af
+// 0.181969
+0x3e3a5613
+// -0.368482
+0xbebca9b8
+// -0.605390
+0xbf1afad6
+// -0.777347
+0xbf47003b
+// -0.556542
+0xbf0e7990
+// -0.451493
+0xbee72a14
+// -0.323351
+0xbea58e41
+// -0.463146
+0xbeed2177
+// -0.353012
+0xbeb4be03
+// 0.174874
+0x3e331239
+// 0.399463
+0x3ecc8678
+// 0.404406
+0x3ecf0e59
+// 0.254541
+0x3e825328
+// 0.455669
+0x3ee94d66
+// 0.860756
+0x3f5c5a80
+// 0.585422
+0x3f15de38
+// 0.568229
+0x3f11777b
+// -0.103649
+0xbdd445fa
+// -0.044666
+0xbd36f3c5
+// 0.276870
+0x3e8dc1e1
+// -0.181632
+0xbe39fdc0
+// -0.381814
+0xbec37d10
+// -0.617524
+0xbf1e1615
+// -0.509072
+0xbf025288
+// -0.454603
+0xbee8c1b9
+// -0.260066
+0xbe852759
+// -0.569666
+0xbf11d5a3
+// -0.268410
+0xbe896cfa
+// -0.266821
+0xbe889cbe
+// 0.137461
+0x3e0cc29d
+// 0.464295
+0x3eedb816
+// 0.189090
+0x3e41a0d4
+// 0.505298
+0x3f015b2f
+// 0.462849
+0x3eecfa87
+// 0.808854
+0x3f4f110d
+// 0.700242
+0x3f33430d
+// 0.584979
+0x3f15c127
+// -0.081238
+0xbda65fed
+// -0.004254
+0xbb8b684e
+// -0.014496
+0xbc6d801f
+// -0.298948
+0xbe990fb9
+// -0.619392
+0xbf1e907d
+// -1.000000
+0xbf800000
+// -0.529186
+0xbf0778bf
+// -0.422518
+0xbed8543d
+// -0.219093
+0xbe605a08
+// -0.475159
+0xbef34813
+// -0.340739
+0xbeae7557
+// -0.209597
+0xbe56a0a4
+// 0.298132
+0x3e98a4c2
+// 0.465727
+0x3eee73cf
+// 0.361978
+0x3eb95539
+// 0.136394
+0x3e0baadd
+// 0.374122
+0x3ebf8ced
+// 0.536019
+0x3f09388c
+// 0.623578
+0x3f1fa2cb
+// 0.434130
+0x3ede4653
+// 0.117249
+0x3df02037
+// 0.199612
+0x3e4c6717
+// -0.080717
+0xbda54f14
+// -0.139196
+0xbe0e8987
+// -0.590724
+0xbf1739b0
+// -0.677539
+0xbf2d733a
+// -0.477806
+0xbef4a308
+// -0.287157
+0xbe930645
+// -0.475920
+0xbef3abd9
+// -0.179729
+0xbe380acc
+// -0.342610
+0xbeaf6a8e
+// 0.096826
+0x3dc64ce8

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADF32/BiquadOutput1_f32.txt

@@ -0,0 +1,202 @@
+W
+100
+// -0.000599
+0xba1cf30f
+// 0.005226
+0x3bab3ad5
+// 0.016770
+0x3c896159
+// 0.024694
+0x3cca4ba9
+// 0.044170
+0x3d34eb78
+// 0.074355
+0x3d98474d
+// 0.109367
+0x3ddffb9d
+// 0.145884
+0x3e156293
+// 0.182184
+0x3e3a8e79
+// 0.218158
+0x3e5f64c3
+// 0.242754
+0x3e78947c
+// 0.251286
+0x3e80a895
+// 0.237083
+0x3e72c5d4
+// 0.194167
+0x3e46d3d5
+// 0.125929
+0x3e00f3a8
+// 0.035255
+0x3d10671d
+// -0.074270
+0xbd981b15
+// -0.195479
+0xbe482bae
+// -0.314589
+0xbea111c9
+// -0.416489
+0xbed53e19
+// -0.487592
+0xbef9a5b1
+// -0.516933
+0xbf0455b7
+// -0.505346
+0xbf015e56
+// -0.444061
+0xbee35bf0
+// -0.337053
+0xbeac923f
+// -0.193626
+0xbe4645ec
+// -0.029830
+0xbcf45f15
+// 0.136365
+0x3e0ba33a
+// 0.287256
+0x3e93132a
+// 0.410479
+0x3ed22a4d
+// 0.493364
+0x3efc9a2d
+// 0.523950
+0x3f06219a
+// 0.494473
+0x3efd2b97
+// 0.419690
+0x3ed6e1a9
+// 0.299752
+0x3e997914
+// 0.153093
+0x3e1cc471
+// -0.010725
+0xbc2fb69f
+// -0.170172
+0xbe2e418b
+// -0.314925
+0xbea13de4
+// -0.425629
+0xbed9ebfe
+// -0.490768
+0xbefb45e4
+// -0.513210
+0xbf0361b8
+// -0.487922
+0xbef9d0de
+// -0.419595
+0xbed6d520
+// -0.310220
+0xbe9ed526
+// -0.171695
+0xbe2fd0ef
+// -0.027309
+0xbcdfb793
+// 0.125358
+0x3e005ddd
+// 0.253911
+0x3e82009b
+// 0.365636
+0x3ebb3497
+// 0.442757
+0x3ee2b0ff
+// 0.466849
+0x3eef06e1
+// 0.452471
+0x3ee7aa3f
+// 0.392128
+0x3ec8c4f8
+// 0.297008
+0x3e98116d
+// 0.171039
+0x3e2f24f4
+// 0.032305
+0x3d045273
+// -0.115669
+0xbdece40e
+// -0.242103
+0xbe77e9f8
+// -0.350754
+0xbeb39607
+// -0.417876
+0xbed5f3cd
+// -0.442701
+0xbee2a9b4
+// -0.429332
+0xbedbd167
+// -0.362003
+0xbeb9586a
+// -0.264328
+0xbe8755f2
+// -0.131543
+0xbe06b345
+// 0.011559
+0x3c3d616e
+// 0.159848
+0x3e23af4b
+// 0.286903
+0x3e92e4fb
+// 0.397047
+0x3ecb49ba
+// 0.465086
+0x3eee1fbb
+// 0.484306
+0x3ef7f6fe
+// 0.454901
+0x3ee8e8ca
+// 0.374406
+0x3ebfb232
+// 0.262631
+0x3e867787
+// 0.113661
+0x3de8c715
+// -0.045224
+0xbd393c7a
+// -0.207083
+0xbe540d98
+// -0.343815
+0xbeb00880
+// -0.449561
+0xbee62ce6
+// -0.504616
+0xbf012e85
+// -0.510836
+0xbf02c62a
+// -0.464376
+0xbeedc2b5
+// -0.371376
+0xbebe2501
+// -0.236285
+0xbe71f4af
+// -0.081845
+0xbda79e2f
+// 0.079134
+0x3da2110d
+// 0.227988
+0x3e6975ac
+// 0.350809
+0x3eb39d35
+// 0.442529
+0x3ee29319
+// 0.483646
+0x3ef7a07e
+// 0.482724
+0x3ef72790
+// 0.430624
+0x3edc7ab2
+// 0.344373
+0x3eb051b3
+// 0.230957
+0x3e6c7fec
+// 0.100415
+0x3dcda67d
+// -0.038467
+0xbd1d8fcf
+// -0.159872
+0xbe23b57d
+// -0.269742
+0xbe8a1b97
+// -0.341214
+0xbeaeb3a0

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADF32/Coefs1_f32.txt

@@ -1,42 +1,42 @@
 W
 20
-// 0.293952
-0x3e9680e0
-// 0.596510
-0x3f18b4da
-// 0.372060
-0x3ebe7ea3
-// -0.779718
-0xbf479b91
-// 0.474235
-0x3ef2cef6
-// -0.070131
-0xbd8fa111
-// -0.254722
-0xbe826adc
-// -0.028591
-0xbcea3887
-// -0.648222
-0xbf25f1e2
-// -0.783965
-0xbf48b1e9
-// 0.368226
-0x3ebc880f
+// 0.268608
+0x3e8986fa
+// -0.018107
+0xbc9455aa
+// 0.102855
+0x3dd2a5b7
+// 0.277061
+0x3e8ddaf5
+// -0.005226
+0xbbab3f0c
+// -0.752882
+0xbf40bcdb
+// -0.341595
+0xbeaee585
+// -0.388553
+0xbec6f05b
+// -0.359456
+0xbeb80a9d
+// 0.971036
+0x3f7895d8
+// 0.120906
+0x3df79d69
+// 0.483238
+0x3ef76aee
+// -0.282184
+0xbe907a73
+// -0.694953
+0xbf31e86a
+// -0.037777
+0xbd1abc68
+// -0.759655
+0xbf4278bf
+// -0.294311
+0xbe96aff6
+// -0.414259
+0xbed419c9
 // 1.000000
 0x3f800000
-// -0.020531
-0xbca831aa
-// 0.678618
-0x3f2db9e4
-// 0.509061
-0x3f0251d9
-// -0.064587
-0xbd84465f
-// -0.095516
-0xbdc39db2
-// 0.490437
-0x3efb1a9a
-// 0.402441
-0x3ece0cc6
-// -0.743290
-0xbf3e483a
+// -0.682920
+0xbf2ed3df

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADF32/Samples1_f32.txt

@@ -1,1026 +1,1026 @@
 W
 512
-// -0.326992
-0xbea76b76
-// -0.084694
-0xbdad741f
-// 0.051074
-0x3d5132aa
-// 0.526066
-0x3f06ac3e
-// 0.308293
-0x3e9dd890
-// -0.436234
-0xbedf5a01
-// -0.185752
-0xbe3e35b1
-// 0.146794
-0x3e165124
-// -0.285832
-0xbe92589e
-// 0.002464
-0x3b217f87
-// -0.347977
-0xbeb22a01
-// 0.132510
-0x3e07b0a0
-// -0.624283
-0xbf1fd0fc
-// 0.277476
-0x3e8e1152
-// -0.015421
-0xbc7ca730
-// 0.102891
-0x3dd2b8a6
-// 0.433368
-0x3edde26c
-// 0.380389
-0x3ec2c268
-// -0.324368
-0xbea61396
-// 0.036102
-0x3d13dfeb
-// 0.459804
-0x3eeb6b70
-// 0.401327
-0x3ecd7abd
-// 0.150263
-0x3e19de8f
-// 0.029527
-0x3cf1e2fd
-// 0.357621
-0x3eb71a2a
-// -0.273434
-0xbe8bff7f
-// 0.351577
-0x3eb401f4
-// 0.022603
-0x3cb929df
-// -0.036399
-0xbd15174b
-// -0.087538
-0xbdb34711
-// -0.153587
-0xbe1d4605
-// -0.225383
-0xbe66cae8
-// -0.163465
-0xbe27636d
-// 0.306898
-0x3e9d21b0
-// 0.371829
-0x3ebe6055
-// -0.123959
-0xbdfdde20
-// 0.305334
-0x3e9c54b6
-// 0.161650
-0x3e258777
-// 0.151887
-0x3e1b882b
-// 0.028669
-0x3ceadc1d
-// 0.166871
-0x3e2ae024
-// 0.069890
-0x3d8f229f
-// 0.571067
-0x3f12317a
-// 0.121325
-0x3df87933
-// 0.014269
-0x3c69c971
-// -0.233874
-0xbe6f7c9c
-// 0.037495
-0x3d199476
-// 0.008059
-0x3c040ada
-// -0.325828
-0xbea6d2f4
-// 0.110935
-0x3de331fa
-// -0.039979
-0xbd23c088
-// 0.346204
-0x3eb141a4
-// 0.227882
-0x3e6959cd
-// -0.179878
-0xbe383210
-// 0.036867
-0x3d170240
-// -0.266150
-0xbe8844d4
-// 0.221238
-0x3e628c54
-// -0.311297
-0xbe9f6244
-// -0.015034
-0xbc7651fd
-// 0.096226
-0x3dc511e7
-// 0.148579
-0x3e182518
-// 0.010813
-0x3c31285a
-// -0.202644
-0xbe4f81e8
-// 0.198433
-0x3e4b3226
-// 0.024458
-0x3cc85d2c
-// -0.072447
-0xbd945f22
-// 0.022582
-0x3cb8fe4d
-// 0.173829
-0x3e32004f
-// -0.290169
-0xbe949104
-// -0.210170
-0xbe5736e7
-// -0.161690
-0xbe25921c
-// 0.023508
-0x3cc094a9
-// -0.229204
-0xbe6ab459
-// 0.256415
-0x3e8348c9
-// -0.017798
-0xbc91cd39
-// 0.085137
-0x3dae5c54
-// 0.266387
-0x3e8863d3
-// -0.107101
-0xbddb57a3
-// -0.053445
-0xbd5ae8ef
-// 0.175609
-0x3e33d2bd
-// -0.129186
-0xbe044939
-// 0.026586
-0x3cd9cb9c
-// -0.000644
-0xba28cf78
-// -0.047425
-0xbd4240ef
-// 0.398268
-0x3ecbe9c7
-// 0.309033
-0x3e9e3983
-// 0.140927
-0x3e104f26
-// 0.043243
-0x3d311f59
-// 0.296059
-0x3e979507
-// -0.176931
-0xbe352d54
+// -0.376881
+0xbec0f69b
+// -0.139476
+0xbe0ed2e3
+// 0.802911
+0x3f4d8b8f
+// -0.289460
+0xbe943429
+// 0.257143
+0x3e83a83e
+// 0.027745
+0x3ce34a18
+// 0.550590
+0x3f0cf37c
+// 0.492097
+0x3efbf423
+// 0.565124
+0x3f10abfe
+// -0.084474
+0xbdad00ad
+// 0.395621
+0x3eca8ed7
+// -0.382876
+0xbec40849
+// 0.274448
+0x3e8c8464
+// -0.024975
+0xbccc97c9
+// 0.157992
+0x3e21c88f
+// 0.053893
+0x3d5cbea9
+// 0.391452
+0x3ec86c5a
+// 0.378254
+0x3ec1aa8c
+// 0.038703
+0x3d1e8782
+// -0.136709
+0xbe0bfd64
+// -0.113659
+0xbde8c5da
+// 0.048820
+0x3d47f737
+// -0.795023
+0xbf4b86a9
+// -0.070301
+0xbd8ff9e2
+// 0.421205
+0x3ed7a839
+// -0.076982
+0xbd9da8b6
+// 0.123813
+0x3dfd91b3
+// 0.346708
+0x3eb183c2
+// 0.476432
+0x3ef3eee1
+// -0.198540
+0xbe4b4e32
+// 0.183234
+0x3e3ba198
+// -0.070030
+0xbd8f6c0a
+// 0.328505
+0x3ea831c6
+// -0.309350
+0xbe9e6310
+// 0.314708
+0x3ea12166
+// 0.311849
+0x3e9faaaf
+// -0.048373
+0xbd4622bb
+// -0.198356
+0xbe4b1de2
+// -0.159997
+0xbe23d64b
+// 0.090245
+0x3db8d29d
+// 0.266345
+0x3e885e6e
+// -0.086948
+0xbdb211d5
+// 0.014760
+0x3c71d4c8
+// 0.094013
+0x3dc08a02
+// 0.124926
+0x3dffd96d
+// 0.024610
+0x3cc99adb
+// -0.193099
+0xbe45bbdf
+// -0.037765
+0xbd1aafa6
+// 0.108787
+0x3ddecbe1
+// -0.348870
+0xbeb29f0f
+// -0.013526
+0xbc5d9c9d
+// -0.107988
+0xbddd28f9
+// -0.142099
+0xbe118275
+// -0.582552
+0xbf15221a
+// 0.574685
+0x3f131e89
+// 0.165677
+0x3e29a74f
+// -0.141857
+0xbe1142e3
+// -0.077820
+0xbd9f5fd8
+// 0.412186
+0x3ed30a17
+// -0.257414
+0xbe83cbd3
+// 0.601989
+0x3f1a1bee
+// -0.278205
+0xbe8e70e5
+// -0.107235
+0xbddb9e38
+// 0.145706
+0x3e15340c
+// 0.514721
+0x3f03c4c4
+// -0.344996
+0xbeb0a340
+// 0.397579
+0x3ecb8f89
+// -0.503485
+0xbf00e45e
+// -0.303878
+0xbe9b95ea
+// -0.598337
+0xbf192c9f
+// 0.236102
+0x3e71c4c0
+// 0.408946
+0x3ed16169
+// -0.456061
+0xbee980d1
+// -0.049326
+0xbd4a0a20
+// -0.355911
+0xbeb63a01
+// 0.473120
+0x3ef23ccf
+// 0.176035
+0x3e34427c
+// -0.364054
+0xbeba6558
+// 0.184308
+0x3e3cbb42
+// -0.403251
+0xbece76e8
+// 0.009518
+0x3c1bf26c
+// -0.193019
+0xbe45a6d0
+// -0.221848
+0xbe632c2e
+// 0.227680
+0x3e692509
+// 0.133171
+0x3e085de7
+// 0.168334
+0x3e2c5fa6
+// -0.104291
+0xbdd5964c
+// 0.036907
+0x3d172bc2
+// 0.084267
+0x3dac93f1
+// -0.297652
+0xbe9865e0
+// -0.363718
+0xbeba393c
+// -0.316188
+0xbea1e35b
+// 0.141795
+0x3e113296
+// 0.164656
+0x3e289b8d
+// 0.312217
+0x3e9fdaeb
+// -0.061779
+0xbd7d0c6b
+// 0.417026
+0x3ed5846b
+// 0.629057
+0x3f2109e0
+// -0.362345
+0xbeb98546
+// 0.071090
+0x3d91976b
+// -0.354211
+0xbeb55b2c
+// 0.321891
+0x3ea4cee8
+// 0.275068
+0x3e8cd5b3
+// 0.065210
+0x3d858cc4
+// -0.210718
+0xbe57c666
+// 0.554147
+0x3f0ddc96
+// -0.179591
+0xbe37e6c7
+// 0.053526
+0x3d5b3df3
+// 0.300618
+0x3e99ea96
+// -0.353360
+0xbeb4eb9e
+// 0.519606
+0x3f0504e9
+// -0.121713
+0xbdf94493
+// -0.241116
+0xbe76e700
+// -0.104401
+0xbdd5d042
+// -0.157823
+0xbe219c6e
+// 0.420757
+0x3ed76d83
+// 0.303495
+0x3e9b63ab
+// 0.039322
+0x3d211044
+// -0.241220
+0xbe770268
+// -0.135523
+0xbe0ac6a1
+// 0.368229
+0x3ebc8877
+// 0.257221
+0x3e83b274
+// -0.274234
+0xbe8c6871
+// 0.237494
+0x3e7331a2
+// 0.058085
+0x3d6deaf8
+// -0.072902
+0xbd954de7
+// -0.218100
+0xbe5f5590
+// -0.389419
+0xbec761e1
+// -0.268845
+0xbe89a61a
+// -0.306930
+0xbe9d25fa
+// 0.743931
+0x3f3e7247
+// 0.499891
+0x3efff1be
+// 0.319296
+0x3ea37abf
+// -0.213231
+0xbe5a593f
+// 0.031138
+0x3cff14ea
+// -0.303447
+0xbe9b5d6a
+// -0.219225
+0xbe607c64
+// -0.018694
+0xbc9923aa
+// -0.373629
+0xbebf4c56
+// -0.093820
+0xbdc024ec
+// 0.231865
+0x3e6d6e1a
+// 0.112742
+0x3de6e588
+// 0.074351
+0x3d984579
+// 0.038926
+0x3d1f70e3
+// 0.351556
+0x3eb3ff27
+// -0.111124
+0xbde394f6
+// -0.086980
+0xbdb2227e
+// -0.122536
+0xbdfaf410
+// 0.593958
+0x3f180d9a
+// 0.283066
+0x3e90ee09
+// 0.036143
+0x3d140a6f
+// 0.247392
+0x3e7d543c
+// 0.261193
+0x3e85bb19
+// -0.106628
+0xbdda5fda
+// 0.191484
+0x3e441483
+// 0.123107
+0x3dfc1f6a
+// 0.136113
+0x3e0b613b
+// -0.764150
+0xbf439f52
+// 0.200548
+0x3e4d5c72
+// -0.067764
+0xbd8ac7f3
+// -0.513379
+0xbf036cc8
+// -0.174552
+0xbe32bdbf
+// -0.091230
+0xbdbad69b
+// -0.163513
+0xbe276fff
+// 0.060386
+0x3d775765
+// 0.134464
+0x3e09b0fb
+// 0.614987
+0x3f1d6fd0
+// -0.093830
+0xbdc02a2c
+// -0.257447
+0xbe83d028
+// -0.209559
+0xbe5696a8
+// 0.278115
+0x3e8e6526
+// -0.153554
+0xbe1d3d48
+// -0.364717
+0xbebabc3c
+// -0.252515
+0xbe81499d
+// -0.259844
+0xbe850a36
+// 0.470649
+0x3ef0f8dd
+// -0.329993
+0xbea8f4e5
+// 0.496021
+0x3efdf678
 // 1.000000
 0x3f800000
-// 0.194566
-0x3e473c67
-// 0.301070
-0x3e9a25e9
-// -0.187625
-0xbe4020cb
-// -0.114179
-0xbde9d69e
-// -0.127595
-0xbe02a84e
-// 0.052722
-0x3d57f29f
-// 0.197518
-0x3e4a4230
-// 0.362364
-0x3eb987b7
-// -0.666260
-0xbf2a9000
-// 0.257335
-0x3e83c169
-// 0.387294
-0x3ec64b5b
-// 0.059862
-0x3d753243
-// -0.274217
-0xbe8c6639
-// -0.261069
-0xbe85aacd
-// -0.475998
-0xbef3b613
-// -0.037324
-0xbd18e0fd
-// 0.350978
-0x3eb3b356
-// -0.467995
-0xbeef9d0f
-// -0.221873
-0xbe6332c0
-// -0.311703
-0xbe9f9782
-// 0.089583
-0x3db77737
-// -0.411136
-0xbed28065
-// -0.246900
-0xbe7cd376
-// -0.155262
-0xbe1efcf4
-// -0.036473
-0xbd156460
-// 0.166830
-0x3e2ad575
-// -0.237221
-0xbe72ea20
-// -0.295958
-0xbe9787cd
-// 0.744244
-0x3f3e86cd
-// 0.083166
-0x3daa52b6
-// 0.342912
-0x3eaf9233
-// -0.016618
-0xbc88234b
-// -0.253283
-0xbe81ae5d
-// -0.260313
-0xbe8547b1
-// -0.057344
-0xbd6ae157
-// 0.095667
-0x3dc3ed04
-// -0.242362
-0xbe782ddc
-// -0.211636
-0xbe58b705
-// 0.099838
-0x3dcc77a1
-// 0.507812
-0x3f01fff4
-// 0.129348
-0x3e0473e9
-// -0.493984
-0xbefceb88
-// -0.066219
-0xbd879dac
-// 0.571169
-0x3f12381b
-// 0.277328
-0x3e8dfdf0
-// -0.039871
-0xbd234f58
-// 0.424759
-0x3ed97a0a
-// -0.357493
-0xbeb7094c
-// -0.042527
-0xbd2e314e
-// -0.135856
-0xbe0b1df7
-// 0.096533
-0x3dc5b306
-// -0.243605
-0xbe797398
-// 0.395483
-0x3eca7cb3
-// -0.168799
-0xbe2cd9a0
-// -0.206060
-0xbe530156
-// 0.031837
-0x3d02678e
-// -0.018829
-0xbc9a3ed8
-// 0.336315
-0x3eac3177
-// -0.009116
-0xbc155c29
-// -0.046866
-0xbd3ff68f
-// -0.044172
-0xbd34ed76
-// -0.319476
-0xbea3924e
-// -0.209988
-0xbe570726
-// 0.132093
-0x3e07437b
-// 0.232802
-0x3e6e6393
-// -0.570599
-0xbf1212c1
-// 0.132801
-0x3e07fce4
-// 0.356644
-0x3eb69a0e
-// 0.003385
-0x3b5dd698
-// -0.330972
-0xbea97531
-// -0.347044
-0xbeb1afbb
-// 0.180587
-0x3e38ebe1
-// -0.341926
-0xbeaf10ec
-// -0.065218
-0xbd859113
-// -0.026260
-0xbcd71ea9
-// 0.007109
-0x3be8f561
-// -0.278848
-0xbe8ec535
-// -0.014780
-0xbc722967
-// 0.481987
-0x3ef6c704
-// -0.480362
-0xbef5f1f3
-// -0.156338
-0xbe201704
-// 0.354503
-0x3eb58166
-// -0.000264
-0xb98a9d13
-// -0.272231
-0xbe8b61da
-// 0.398709
-0x3ecc23a1
-// -0.191867
-0xbe4478ac
-// 0.153040
-0x3e1cb675
-// 0.315072
-0x3ea1511d
-// 0.443318
-0x3ee2fa9e
-// 0.083358
-0x3daab75c
-// -0.080833
-0xbda58c04
-// 0.207862
-0x3e54d9e5
-// 0.106246
-0x3dd997c3
-// 0.012257
-0x3c48d280
-// 0.344848
-0x3eb08ff6
-// -0.019034
-0xbc9becb9
-// 0.339987
-0x3eae12b9
-// -0.135000
-0xbe0a3d88
-// 0.336755
-0x3eac6b16
-// 0.104398
-0x3dd5ceaf
-// 0.138653
-0x3e0dfb27
-// 0.328754
-0x3ea85266
-// -0.227923
-0xbe696485
-// -0.071173
-0xbd91c334
-// -0.096905
-0xbdc67620
-// -0.161371
-0xbe253e7c
-// -0.353228
-0xbeb4da55
-// -0.228033
-0xbe69817c
-// 0.102521
-0x3dd1f647
-// -0.694509
-0xbf31cb53
-// -0.033490
-0xbd092d22
+// -0.266998
+0xbe88b3ef
+// -0.708596
+0xbf356689
+// 0.688771
+0x3f30534a
+// -0.133371
+0xbe089270
+// 0.082140
+0x3da838dd
+// -0.243500
+0xbe795827
+// -0.192751
+0xbe456078
+// 0.249430
+0x3e7f6a83
+// -0.132701
+0xbe07e2d6
+// 0.178585
+0x3e36df11
+// 0.322829
+0x3ea549e5
+// 0.279648
+0x3e8f2e10
+// 0.159377
+0x3e2333b3
+// -0.222747
+0xbe6417e4
+// 0.474410
+0x3ef2e5ee
+// -0.155418
+0xbe1f25e7
+// -0.486570
+0xbef91fb1
+// 0.243684
+0x3e79885b
+// 0.014284
+0x3c6a056e
+// 0.108161
+0x3ddd834a
+// 0.546359
+0x3f0bde31
+// -0.364001
+0xbeba5e53
+// 0.295028
+0x3e970dea
+// -0.226342
+0xbe67c643
+// 0.485186
+0x3ef86a3c
+// 0.387559
+0x3ec66e25
+// 0.218343
+0x3e5f953a
+// 0.351177
+0x3eb3cd72
+// -0.020042
+0xbca42ea5
+// -0.396740
+0xbecb217f
+// 0.012871
+0x3c52df7f
+// 0.062266
+0x3d7f0abf
+// -0.110100
+0xbde17bfb
+// 0.097793
+0x3dc8476f
+// 0.032252
+0x3d041ab9
+// 0.139716
+0x3e0f11b9
+// -0.194894
+0xbe479253
+// -0.256837
+0xbe83801d
+// -0.068141
+0xbd8b8da0
+// 0.191892
+0x3e447f73
+// 0.042102
+0x3d2c72ff
+// -0.233553
+0xbe6f2888
+// 0.037189
+0x3d18539e
+// 0.073313
+0x3d96255b
+// -0.303750
+0xbe9b8529
+// -0.237862
+0xbe739232
+// 0.468067
+0x3eefa670
+// 0.183970
+0x3e3c6281
+// 0.116004
+0x3ded9355
+// -0.031623
+0xbd018768
+// 0.192031
+0x3e44a3e2
+// 0.559992
+0x3f0f5ba0
+// 0.130548
+0x3e05ae6b
+// 0.348970
+0x3eb2ac28
+// 0.015350
+0x3c7b7d7d
+// -0.075323
+0xbd9a42e1
+// -0.734680
+0xbf3c1401
+// 0.162382
+0x3e264775
+// -0.210037
+0xbe5713f9
+// 0.529229
+0x3f077b8b
+// 0.222788
+0x3e6422a5
+// 0.021332
+0x3caec15c
+// -0.295210
+0xbe9725b5
+// 0.167682
+0x3e2bb4f4
+// 0.041847
+0x3d2b67ea
+// 0.114172
+0x3de9d2fd
+// 0.067066
+0x3d8959fd
+// 0.130124
+0x3e053f4f
+// 0.074482
+0x3d9889f6
+// -0.342185
+0xbeaf32e0
+// 0.246922
+0x3e7cd925
+// 0.174923
+0x3e331ef3
+// 0.020938
+0x3cab8585
+// 0.239291
+0x3e7508af
+// 0.466562
+0x3eeee139
+// -0.234110
+0xbe6fba78
+// 0.162483
+0x3e266210
+// 0.690852
+0x3f30dba5
+// 0.133767
+0x3e08fa37
+// 0.300236
+0x3e99b88f
+// 0.267901
+0x3e892a61
+// -0.105654
+0xbdd86134
+// -0.089756
+0xbdb7d1d6
+// -0.221248
+0xbe628ebe
+// -0.061638
+0xbd7c77ca
+// 0.053548
+0x3d5b5594
+// 0.177290
+0x3e358b75
 // 0.262282
-0x3e8649e2
-// -0.013295
-0xbc59d4fc
-// 0.141320
-0x3e10b646
-// 0.160626
-0x3e247b18
-// 0.143554
-0x3e12ffdd
-// 0.165715
-0x3e29b122
-// 0.548141
-0x3f0c52fd
-// 0.206231
-0x3e532e2f
-// -0.448658
-0xbee5b67a
-// -0.008299
-0xbc07f6c4
-// -0.371586
-0xbebe4089
-// -0.071169
-0xbd91c131
-// -0.582282
-0xbf151074
-// -0.357677
-0xbeb72169
-// 0.104820
-0x3dd6aba4
-// -0.145844
-0xbe15582e
-// -0.184228
-0xbe3ca632
-// -0.047446
-0xbd425710
-// 0.380744
-0x3ec2f0d2
-// -0.172229
-0xbe305ce3
-// 0.517013
-0x3f045afa
-// -0.529139
-0xbf0775aa
-// 0.357340
-0x3eb6f53c
-// 0.198675
-0x3e4b7180
-// -0.059888
-0xbd754d29
-// -0.187150
-0xbe3fa43b
-// -0.179740
-0xbe380dd8
-// -0.056811
-0xbd68b2d1
-// -0.279693
-0xbe8f33ec
-// 0.129885
-0x3e05009b
-// -0.687640
-0xbf300929
-// -0.126689
-0xbe01baa6
-// 0.089466
-0x3db73a20
-// 0.362453
-0x3eb99381
-// 0.356861
-0x3eb6b673
-// 0.137701
-0x3e0d0196
-// -0.053366
-0xbd5a96b7
-// -0.186389
-0xbe3edcda
-// -0.042094
-0xbd2c6a65
-// -0.377425
-0xbec13dd3
-// -0.323066
-0xbea568e1
-// 0.073942
-0x3d976edd
-// 0.167208
-0x3e2b3873
-// 0.241256
-0x3e770bb4
-// -0.266358
-0xbe886021
-// -0.224059
-0xbe656fbf
-// 0.070896
-0x3d91320b
-// 0.197815
-0x3e4a9019
-// -0.096890
-0xbdc66e26
-// -0.523402
-0xbf05fdb4
-// 0.272540
-0x3e8b8a6c
-// -0.478714
-0xbef51a07
-// 0.432328
-0x3edd5a28
-// 0.076623
-0x3d9cec71
-// 0.122372
-0x3dfa9e59
-// 0.049789
-0x3d4befd7
-// 0.172085
-0x3e30370e
-// 0.547050
-0x3f0c0b79
-// -0.022880
-0xbcbb6e01
-// -0.352582
-0xbeb48591
-// 0.312922
-0x3ea03756
-// -0.194631
-0xbe474d65
-// 0.600077
-0x3f199ea9
-// -0.594305
-0xbf182460
-// -0.110540
-0xbde262ab
-// -0.452304
-0xbee79455
-// -0.197716
-0xbe4a75f5
-// -0.284537
-0xbe91aee0
-// -0.347890
-0xbeb21eae
-// 0.073866
-0x3d9746cd
-// -0.154811
-0xbe1e86c3
-// -0.141296
-0xbe10aff5
-// 0.413128
-0x3ed38577
-// 0.306511
-0x3e9cef0b
-// -0.288290
-0xbe939ac1
-// 0.126519
-0x3e018e1e
-// -0.263129
-0xbe86b8e8
-// 0.088454
-0x3db5271c
-// 0.691896
-0x3f312019
-// 0.302682
-0x3e9af92f
-// -0.252408
-0xbe813ba0
-// -0.315311
-0xbea1707f
-// 0.088373
-0x3db4fcb3
-// -0.424960
-0xbed99465
-// -0.063001
-0xbd8106ab
-// 0.491658
-0x3efbba8c
-// -0.533554
-0xbf0896fa
-// 0.002854
-0x3b3b041e
-// -0.463664
-0xbeed655c
-// -0.199926
-0xbe4cb94a
-// 0.246942
-0x3e7cde3e
-// 0.064976
-0x3d8511ee
-// 0.544685
-0x3f0b707c
-// -0.362700
-0xbeb9b3d2
-// 0.613122
-0x3f1cf588
-// -0.175146
-0xbe33595a
-// -0.410947
-0xbed267af
-// -0.461193
-0xbeec2185
-// 0.064124
-0x3d835334
-// 0.198007
-0x3e4ac267
-// 0.383020
-0x3ec41b3e
-// -0.360236
-0xbeb870d5
-// -0.044977
-0xbd383995
-// -0.343543
-0xbeafe4d3
-// -0.107000
-0xbddb22ce
-// 0.280896
-0x3e8fd1a7
-// 0.213260
-0x3e5a60c4
-// -0.048248
-0xbd459f88
-// -0.449987
-0xbee664a9
-// 0.083334
-0x3daaaac2
-// 0.620504
-0x3f1ed957
-// -0.078532
-0xbda0d569
-// -0.004300
-0xbb8ce3fd
-// 0.254442
-0x3e82463f
-// -0.194732
-0xbe4767f1
-// -0.211298
-0xbe585e7d
-// -0.223949
-0xbe6552e6
-// -0.276995
-0xbe8dd247
-// 0.466643
-0x3eeeebd1
-// 0.057647
-0x3d6c1fb4
-// -0.428933
-0xbedb9d11
-// -0.313300
-0xbea068da
-// 0.077953
-0x3d9fa5e9
-// 0.207689
-0x3e54ac73
-// -0.922058
-0xbf6c0c00
-// -0.340858
-0xbeae84e7
-// 0.238638
-0x3e745d8e
-// -0.008356
-0xbc08e603
-// -0.532716
-0xbf086014
-// 0.129438
-0x3e048b7b
-// -0.269457
-0xbe89f650
-// -0.249337
-0xbe7f5220
-// -0.169783
-0xbe2ddb86
-// -0.196670
-0xbe4963cb
-// -0.015204
-0xbc791998
-// -0.566971
-0xbf1124fb
-// 0.603256
-0x3f1a6efb
-// -0.088525
-0xbdb54cb2
-// -0.049008
-0xbd48bc53
-// 0.481072
-0x3ef64f11
-// 0.161675
-0x3e258e0b
-// -0.258385
-0xbe844b02
-// 0.398956
-0x3ecc4406
-// -0.301360
-0xbe9a4beb
-// 0.032986
-0x3d071c9d
-// -0.287515
-0xbe93352d
-// 0.057501
-0x3d6b85dd
-// 0.130706
-0x3e05d7aa
-// -0.087742
-0xbdb3b1d9
-// -0.010871
-0xbc321dc6
-// -0.082845
-0xbda9aaa5
-// -0.306511
-0xbe9ceeff
-// 0.442802
-0x3ee2b701
-// -0.495521
-0xbefdb4f1
-// -0.524443
-0xbf0641df
-// 0.417810
-0x3ed5eb29
-// 0.054618
-0x3d5fb762
-// 0.338289
-0x3ead3436
-// -0.046547
-0xbd3ea866
-// -0.106749
-0xbdda9f5b
-// 0.093118
-0x3dbeb485
-// 0.087054
-0x3db24997
-// -0.297823
-0xbe987c3e
-// 0.283356
-0x3e911416
-// 0.061398
-0x3d7b7c57
-// -0.800236
-0xbf4cdc4c
-// -0.067164
-0xbd898d5d
-// -0.412000
-0xbed2f1a5
-// -0.163915
-0xbe27d936
-// -0.247052
-0xbe7cfb4d
-// 0.218699
-0x3e5ff2bd
-// -0.182552
-0xbe3aef02
-// -0.073676
-0xbd96e378
-// 0.202844
-0x3e4fb63e
-// -0.112227
-0xbde5d71e
-// -0.323717
-0xbea5be4c
-// 0.397650
-0x3ecb98d2
-// -0.814670
-0xbf508e31
-// -0.066346
-0xbd87e03e
-// 0.414103
-0x3ed4054f
-// 0.050774
-0x3d4ff8c9
-// 0.261472
-0x3e85dfa3
-// -0.426106
-0xbeda2a96
-// -0.039893
-0xbd2366a3
-// 0.424770
-0x3ed97b7c
-// -0.140598
-0xbe0ff8d8
-// 0.380317
-0x3ec2b8f7
-// -0.090825
-0xbdba028d
-// -0.163920
-0xbe27da8c
-// -0.147520
-0xbe170f8d
-// -0.187854
-0xbe405ce9
-// 0.444916
-0x3ee3cbf8
-// -0.478255
-0xbef4ddd2
-// -0.452746
-0xbee7ce4f
-// -0.902004
-0xbf66e9bd
-// -0.105271
-0xbdd79874
-// 0.512630
-0x3f033bb1
-// -0.020699
-0xbca991f9
-// 0.645618
-0x3f254736
-// 0.379476
-0x3ec24ab2
-// 0.026399
-0x3cd8439e
-// -0.227840
-0xbe694ef0
-// 0.308911
-0x3e9e29a4
-// 0.280940
-0x3e8fd75e
-// -0.910181
-0xbf690197
-// 0.506744
-0x3f01b9f4
-// 0.065877
-0x3d86eab0
-// 0.662500
-0x3f29999e
-// -0.227225
-0xbe68ada5
-// 0.004639
-0x3b980163
-// -0.305746
-0xbe9c8aba
-// -0.266536
-0xbe887767
-// -0.414382
-0xbed429e9
-// 0.194205
-0x3e46dd98
-// -0.191065
-0xbe43a69f
-// -0.083141
-0xbdaa45c6
-// -0.026428
-0xbcd87f7e
-// -0.381845
-0xbec3813a
-// -0.138138
-0xbe0d73fa
-// -0.486749
-0xbef93724
-// 0.051492
-0x3d52e925
-// 0.285761
-0x3e924f33
-// 0.239980
-0x3e75bd6b
-// -0.011428
-0xbc3b3e2b
-// 0.079911
-0x3da3a84d
-// -0.138832
-0xbe0e29da
-// 0.020359
-0x3ca6c86c
-// 0.318485
-0x3ea31076
-// -0.159389
-0xbe2336c3
-// -0.105914
-0xbdd8e965
-// 0.190753
-0x3e4354ac
-// -0.182394
-0xbe3ac57f
-// -0.028919
-0xbcece686
-// -0.350406
-0xbeb36862
-// -0.597603
-0xbf18fc88
-// 0.368403
-0x3ebc9f43
-// -0.413308
-0xbed39d1c
-// 0.048973
-0x3d4897cf
-// -0.353094
-0xbeb4c8c2
-// -0.091675
-0xbdbbbfe5
-// -0.528843
-0xbf076246
-// 0.011833
-0x3c41dfe5
-// -0.451219
-0xbee70628
-// 0.263875
-0x3e871aa5
-// -0.430724
-0xbedc87e7
-// -0.327446
-0xbea7a6f3
-// -0.109134
-0xbddf81e8
-// -0.397829
-0xbecbb047
-// 0.102791
-0x3dd28414
-// -0.271917
-0xbe8b38be
-// 0.335298
-0x3eabac3c
-// -0.193476
-0xbe461ea7
-// 0.259508
-0x3e84de34
-// -0.158022
-0xbe21d09f
-// -0.063122
-0xbd814659
-// -0.113084
-0xbde798ba
-// 0.119174
-0x3df41169
-// -0.387697
-0xbec6802c
-// 0.324595
-0x3ea6314a
-// 0.156652
-0x3e20696e
-// -0.113305
-0xbde80cb1
-// 0.082124
-0x3da830a1
-// 0.151908
-0x3e1b8dbb
-// 0.488103
-0x3ef9e8a4
-// -0.350374
-0xbeb3643b
-// 0.373276
-0x3ebf1e15
-// -0.095450
-0xbdc37b8d
-// -0.215461
-0xbe5ca1bd
-// -0.178500
-0xbe36c8a0
-// 0.195147
-0x3e47d4a5
-// 0.384611
-0x3ec4ebc4
-// -0.363336
-0xbeba072d
-// -0.034229
-0xbd0c3379
-// -0.116293
-0xbdee2af1
-// 0.269612
-0x3e8a0a8e
-// -0.174454
-0xbe32a413
-// -0.294518
-0xbe96cb18
-// -0.553321
-0xbf0da66a
-// -0.537373
-0xbf09913f
-// 0.169808
-0x3e2de236
-// 0.077995
-0x3d9fbbec
-// 0.114759
-0x3deb06fe
-// 0.090784
-0x3db9ecbc
-// 0.136465
-0x3e0bbd92
-// -0.337447
-0xbeacc5d6
-// -0.030947
-0xbcfd842e
-// 0.167165
-0x3e2b2d2d
-// -0.026225
-0xbcd6d688
-// 0.487998
-0x3ef9daef
-// 0.415437
-0x3ed4b430
-// 0.135268
-0x3e0a83bd
-// -0.343441
-0xbeafd784
-// 0.080092
-0x3da40781
-// -0.437286
-0xbedfe3f4
-// 0.260625
-0x3e8570a8
-// -0.066380
-0xbd87f22a
-// 0.039535
-0x3d21efeb
-// -0.230850
-0xbe6c63f0
-// -0.393087
-0xbec942b9
-// 0.508995
-0x3f024d82
-// -0.576843
-0xbf13abfe
-// 0.219687
-0x3e60f5a1
-// -0.169697
-0xbe2dc51f
-// 0.504771
-0x3f0138a6
-// 0.416905
-0x3ed57486
-// 0.048830
-0x3d4801fa
-// 0.176546
-0x3e34c883
-// -0.058313
-0xbd6ed976
-// -0.150475
-0xbe1a1604
-// 0.635616
-0x3f22b7b7
+0x3e8649d9
+// -0.011567
+0xbc3d84d4
+// -0.123031
+0xbdfbf79f
+// 0.131088
+0x3e063be3
+// -0.121891
+0xbdf9a23a
+// -0.318092
+0xbea2dcf9
+// -0.196684
+0xbe49679f
+// 0.488400
+0x3efa0f82
+// -0.559745
+0xbf0f4b6b
+// -0.115287
+0xbdec1bd7
+// -0.210181
+0xbe5739b8
+// -0.037703
+0xbd1a6eba
+// 0.463962
+0x3eed8c71
+// 0.257067
+0x3e839e55
+// -0.348923
+0xbeb2a610
+// 0.332950
+0x3eaa786c
+// 0.125371
+0x3e006148
+// -0.078452
+0xbda0ab63
+// -0.264875
+0xbe879dbd
+// 0.625431
+0x3f201c39
+// 0.001664
+0x3ada1374
+// 0.415496
+0x3ed4bbf5
+// -0.450268
+0xbee6897f
+// -0.304300
+0xbe9bcd2c
+// 0.226605
+0x3e680b1c
+// 0.370914
+0x3ebde87a
+// 0.298095
+0x3e989fe7
+// 0.525568
+0x3f068b9d
+// 0.044312
+0x3d358104
+// 0.043500
+0x3d322cf3
+// -0.050212
+0xbd4dab9c
+// 0.090837
+0x3dba08af
+// 0.448936
+0x3ee5daf2
+// 0.793964
+0x3f4b413c
+// 0.339752
+0x3eadf408
+// 0.344503
+0x3eb062a3
+// -0.163583
+0xbe278259
+// 0.552336
+0x3f0d65e7
+// -0.382670
+0xbec3ed60
+// -0.519642
+0xbf05074a
+// 0.002530
+0x3b25ca70
+// 0.339338
+0x3eadbda6
+// -0.031601
+0xbd01707a
+// -0.166016
+0xbe2a000d
+// -0.106146
+0xbdd96317
+// 0.332596
+0x3eaa4a0b
+// -0.020918
+0xbcab5b91
+// -0.361043
+0xbeb8daaa
+// -0.141736
+0xbe112354
+// 0.243699
+0x3e798c46
+// -0.348164
+0xbeb24298
+// 0.448171
+0x3ee576a1
+// 0.364596
+0x3ebaac55
+// 0.332627
+0x3eaa4e16
+// -0.122883
+0xbdfbaa50
+// 0.051977
+0x3d54e5e7
+// 0.386280
+0x3ec5c686
+// -0.483498
+0xbef78d0d
+// 0.120464
+0x3df6b606
+// -0.549263
+0xbf0c9c7d
+// -0.144689
+0xbe14294f
+// -0.298435
+0xbe98cc6b
+// -0.265148
+0xbe87c173
+// 0.269525
+0x3e89ff34
+// -0.296917
+0xbe98058d
+// -0.161133
+0xbe250000
+// 0.157237
+0x3e2102ad
+// -0.434508
+0xbede77cd
+// -0.057302
+0xbd6ab567
+// -0.016054
+0xbc838397
+// 0.267888
+0x3e8928a3
+// 0.582003
+0x3f14fe1f
+// -0.161243
+0xbe251cdf
+// -0.296417
+0xbe97c404
+// -0.372201
+0xbebe912e
+// 0.144680
+0x3e1426ef
+// 0.353490
+0x3eb4fc99
+// -0.295484
+0xbe9749b4
+// 0.330923
+0x3ea96eb5
+// -0.157516
+0xbe214bfd
+// -0.174752
+0xbe32f225
+// -0.196747
+0xbe497809
+// 0.149634
+0x3e1939b3
+// 0.565782
+0x3f10d70f
+// -0.103771
+0xbdd48612
+// -0.571210
+0xbf123ace
+// 0.532280
+0x3f084378
+// 0.141553
+0x3e10f337
+// -0.107982
+0xbddd2573
+// -0.366569
+0xbebbaef1
+// -0.017940
+0xbc92f7e8
+// -0.114915
+0xbdeb5891
+// -0.113180
+0xbde7cad8
+// -0.025428
+0xbcd04ead
+// -0.400438
+0xbecd0646
+// 0.397748
+0x3ecba5a4
+// -0.821119
+0xbf5234d6
+// -0.303476
+0xbe9b613a
+// 0.430711
+0x3edc8628
+// 0.089621
+0x3db78b26
+// -0.128762
+0xbe03da46
+// -0.160320
+0xbe242aea
+// -0.065031
+0xbd852ee2
+// -0.125484
+0xbe007eef
+// -0.162435
+0xbe26555d
+// 0.269776
+0x3e8a2024
+// 0.123312
+0x3dfc8b2f
+// -0.187439
+0xbe3ff00b
+// -0.256349
+0xbe834039
+// -0.251606
+0xbe80d286
+// 0.218922
+0x3e602d1c
+// -0.186990
+0xbe3f7a33
+// 0.111993
+0x3de55c9b
+// -0.575381
+0xbf134c27
+// -0.109603
+0xbde07796
+// 0.340492
+0x3eae54eb
+// -0.221964
+0xbe634a9e
+// 0.548068
+0x3f0c4e31
+// -0.046312
+0xbd3db12f
+// 0.089914
+0x3db8250f
+// 0.200257
+0x3e4d102f
+// -0.128211
+0xbe0349b4
+// 0.456880
+0x3ee9ec2e
+// 0.092965
+0x3dbe6496
+// -0.323794
+0xbea5c849
+// -0.003704
+0xbb72becc
+// 0.354206
+0x3eb55a75
+// -0.820077
+0xbf51f08f
+// 0.019010
+0x3c9bbbdb
+// 0.030762
+0x3cfc000f
+// -0.265714
+0xbe880bad
+// 0.099857
+0x3dcc81a8
+// 0.313520
+0x3ea085b8
+// -0.340697
+0xbeae6fd0
+// -0.430275
+0xbedc4d02
+// -0.195283
+0xbe47f853
+// -0.093596
+0xbdbfaf70
+// -0.323517
+0xbea5a3f8
+// 0.027657
+0x3ce2910a
+// 0.081555
+0x3da7063d
+// 0.530542
+0x3f07d193
+// 0.098597
+0x3dc9ed50
+// -0.139768
+0xbe0f1f73
+// -0.268498
+0xbe89789f
+// -0.459725
+0xbeeb611b
+// 0.409139
+0x3ed17ab4
+// 0.480077
+0x3ef5cca9
+// 0.020610
+0x3ca8d5d0
+// -0.352861
+0xbeb4aa2d
+// -0.159322
+0xbe232555
+// -0.751074
+0xbf404660
+// 0.410132
+0x3ed1fcdb
+// 0.117124
+0x3defdecf
+// -0.057331
+0xbd6ad3b2
+// 0.190448
+0x3e4304b5
+// -0.301245
+0xbe9a3cc9
+// 0.630601
+0x3f216f10
+// 0.439277
+0x3ee0e8db
+// -0.050220
+0xbd4db3fe
+// -0.040745
+0xbd26e4b4
+// 0.365972
+0x3ebb60ad
+// -0.552439
+0xbf0d6c9f
+// -0.193326
+0xbe45f73e
+// -0.077233
+0xbd9e2c66
+// -0.136472
+0xbe0bbf33
+// -0.112002
+0xbde56177
+// 0.077857
+0x3d9f73b3
+// -0.230060
+0xbe6b94cd
+// -0.588886
+0xbf16c13e
+// -0.266400
+0xbe8865a4
+// -0.141781
+0xbe112eed
+// 0.136075
+0x3e0b5736
+// -0.513446
+0xbf037132
+// -0.206662
+0xbe539f49
+// 0.140837
+0x3e103773
+// -0.346115
+0xbeb135fc
+// -0.122021
+0xbdf9e62e
+// -0.224695
+0xbe66168b
+// 0.030347
+0x3cf89a3e
+// -0.576312
+0xbf13892c
+// -0.093521
+0xbdbf87e0
+// -0.206423
+0xbe53606f
+// -0.012389
+0xbc4afb75
+// -0.067898
+0xbd8b0dfe
+// 0.087146
+0x3db2796e
+// -0.133167
+0xbe085cec
+// 0.284255
+0x3e9189e4
+// -0.172764
+0xbe30e903
+// -0.194248
+0xbe46e8fe
+// -0.224212
+0xbe6597dc
+// 0.150440
+0x3e1a0cf8
+// -0.212532
+0xbe59a214
+// 0.347839
+0x3eb217f6
+// 0.053436
+0x3d5adf3f
+// 0.095940
+0x3dc47bf3
+// 0.432766
+0x3edd937e
+// -0.322547
+0xbea524da
+// -0.023302
+0xbcbee382
+// 0.201819
+0x3e4ea9b3
+// -0.075402
+0xbd9a6c5a
+// 0.071070
+0x3d918d32
+// -0.487904
+0xbef9ce9e
+// 0.030769
+0x3cfc0f95
+// -0.287686
+0xbe934b91
+// -0.203418
+0xbe504cc7
+// 0.096419
+0x3dc57760
+// 0.806066
+0x3f4e5a59
+// 0.353505
+0x3eb4fe92
+// 0.056009
+0x3d656a0c
+// -0.140211
+0xbe0f9374
+// -0.053990
+0xbd5d24ef
+// -0.150413
+0xbe1a05eb
+// -0.069885
+0xbd8f1fc9
+// -0.279426
+0xbe8f10e2
+// 0.184407
+0x3e3cd52e
+// 0.468913
+0x3ef01569
+// 0.232706
+0x3e6e4a87
+// -0.372750
+0xbebed91d
+// 0.358056
+0x3eb75320
+// 0.436492
+0x3edf7bd4
+// 0.463517
+0x3eed5218
+// -0.153684
+0xbe1d5f66
+// 0.266843
+0x3e889f96
+// 0.034249
+0x3d0c483b
+// -0.338078
+0xbead189d
+// 0.053688
+0x3d5be7f0
+// -0.228924
+0xbe6a6b02
+// 0.024149
+0x3cc5d31e
+// -0.006564
+0xbbd71564
+// -0.063320
+0xbd81ade9
+// -0.367003
+0xbebbe7c4
+// 0.041072
+0x3d283b21
+// -0.055684
+0xbd641569
+// -0.033887
+0xbd0accae
+// 0.086853
+0x3db1e021
+// -0.813081
+0xbf50260d
+// -0.124431
+0xbdfed5d3
+// 0.386135
+0x3ec5b379
+// -0.133674
+0xbe08e1df
+// -0.262531
+0xbe866a67
+// 0.068744
+0x3d8cc991
+// 0.306002
+0x3e9cac57
+// -0.105618
+0xbdd84e6c
+// -0.362437
+0xbeb99147
+// 0.090280
+0x3db8e47a
+// 0.588506
+0x3f16a858

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADF64/AllBiquadCoefs2_f64.txt

@@ -0,0 +1,302 @@
+D
+150
+// 0.020000
+0x3f947ae147ae147b
+// 0.024985
+0x3f9995aebc73cbe3
+// 0.020000
+0x3f947ae147ae147b
+// 1.178573
+0x3ff2db6f78b33348
+// -0.355185
+0xbfd6bb5a2b3b3977
+// 0.020000
+0x3f947ae147ae147b
+// 0.015655
+0x3f9007fdbcc2b9ec
+// 0.020000
+0x3f947ae147ae147b
+// 0.171068
+0x3fc5e58c6620ffb6
+// -0.032899
+0xbfa0d826829ac3b4
+// 0.020000
+0x3f947ae147ae147b
+// -0.003369
+0xbf6b9a2f5e019e7f
+// 0.020000
+0x3f947ae147ae147b
+// 0.135686
+0x3fc15e2beced748c
+// -0.004620
+0xbf72ecb758b3c945
+// 0.020000
+0x3f947ae147ae147b
+// -0.032151
+0xbfa07617a3a1d28a
+// 0.020000
+0x3f947ae147ae147b
+// -0.293749
+0xbfd2ccc6f59229c0
+// -0.022241
+0xbf96c6523f98501c
+// 1.000000
+0x3ff0000000000000
+// -1.394798
+0xbff65117cd218cac
+// 1.000000
+0x3ff0000000000000
+// -0.270635
+0xbfd15213e91d8239
+// -0.032534
+0xbfa0a85b3ffd1162
+// 1.000000
+0x3ff0000000000000
+// 0.340872
+0x3fd5d0d7168642e3
+// 1.000000
+0x3ff0000000000000
+// 0.111487
+0x3fbc8a6e3519e694
+// -0.037661
+0xbfa3484d8571cb61
+// 1.000000
+0x3ff0000000000000
+// 1.776720
+0x3ffc6d7219d23ff8
+// 1.000000
+0x3ff0000000000000
+// -0.997088
+0xbfefe825b49f0706
+// -0.397808
+0xbfd975b0a3960ecb
+// 0.020000
+0x3f947ae147ae147b
+// -0.009644
+0xbf83c00877a76c9b
+// 0.020000
+0x3f947ae147ae147c
+// 0.136798
+0x3fc1829b775d4fb8
+// -0.005178
+0xbf7535f5b17edfe7
+// 1.000000
+0x3ff0000000000000
+// -0.408280
+0xbfda21416888ba0f
+// 1.000000
+0x3ff0000000000000
+// -0.459773
+0xbfdd6cecdd6261b2
+// -0.094934
+0xbfb84d9bd150abd2
+// 1.000000
+0x3ff0000000000000
+// -1.999962
+0xbfffffd7a908ca5c
+// 1.000000
+0x3fefffffffffffff
+// 0.671191
+0x3fe57a660ce78538
+// -0.128493
+0xbfc07278a7f21fbc
+// 1.000000
+0x3ff0000000000000
+// 0.003168
+0x3f69f30c1cacf401
+// 1.000000
+0x3ff0000000000000
+// -0.158981
+0xbfc459805153d58c
+// -0.130143
+0xbfc0a8835596898c
+// 0.020000
+0x3f947ae147ae147b
+// -0.038837
+0xbfa3e26b942d71e8
+// 0.020000
+0x3f947ae147ae147b
+// 0.570355
+0x3fe2405a072c65cd
+// -0.292274
+0xbfd2b49d2cc72ae0
+// 1.000000
+0x3ff0000000000000
+// -1.042120
+0xbff0ac85baa1b40c
+// 1.000000
+0x3fefffffffffffff
+// -0.881176
+0xbfec32988c816f9a
+// -0.314065
+0xbfd419a3169ce49c
+// 1.000000
+0x3ff0000000000000
+// -1.502976
+0xbff80c302992f205
+// 1.000000
+0x3ff0000000000000
+// 1.040931
+0x3ff0a7a729309fda
+// -0.396809
+0xbfd965531789dc20
+// 1.000000
+0x3ff0000000000000
+// -0.559472
+0xbfe1e73182790b46
+// 1.000000
+0x3ff0000000000000
+// 0.149845
+0x3fc32e1c080b699a
+// -0.489992
+0xbfdf5c061bd1c764
+// 0.020000
+0x3f947ae147ae147b
+// -0.034816
+0xbfa1d367fd854a38
+// 0.020000
+0x3f947ae147ae147b
+// 0.336632
+0x3fd58b61b8c2ae90
+// -0.028358
+0xbf9d09c221a3f26e
+// 1.000000
+0x3ff0000000000000
+// -0.718477
+0xbfe6fdc299f32beb
+// 1.000000
+0x3ff0000000000000
+// 0.237872
+0x3fce7296e18f02af
+// -0.048446
+0xbfa8cdde379cd8c4
+// 1.000000
+0x3ff0000000000000
+// -1.316793
+0xbff51195142afc43
+// 1.000000
+0x3ff0000000000000
+// 0.390105
+0x3fd8f77cb44a0b50
+// -0.076779
+0xbfb3a7c444bd505e
+// 1.000000
+0x3ff0000000000000
+// 1.999704
+0x3ffffec9390229f8
+// 1.000000
+0x3ff0000000000000
+// -1.072445
+0xbff128bbeeb25e7b
+// -0.307035
+0xbfd3a676036f1bb6
+// 1.000000
+0x3ff0000000000000
+// 0.259996
+0x3fd0a3c55cffd5f9
+// 1.000000
+0x3ff0000000000000
+// -0.454916
+0xbfdd1d588f8debfe
+// -0.489288
+0xbfdf507f401d58d9
+// 0.020000
+0x3f947ae147ae147b
+// -0.034707
+0xbfa1c51976110f1e
+// 0.020000
+0x3f947ae147ae147b
+// -0.000004
+0xbed1e759ff07bf6a
+// -0.000010
+0xbee4c63149ae1ba0
+// 1.000000
+0x3ff0000000000000
+// -1.656296
+0xbffa802fc483d3bd
+// 1.000000
+0x3ff0000000000000
+// 0.253568
+0x3fd03a741b6ed570
+// -0.054533
+0xbfabebb0ef001347
+// 1.000000
+0x3ff0000000000000
+// -0.535121
+0xbfe11fb5f4603257
+// 1.000000
+0x3ff0000000000001
+// -0.127318
+0xbfc04bf839da42d0
+// -0.060924
+0xbfaf3166b0afe73a
+// 1.000000
+0x3ff0000000000000
+// 1.747489
+0x3ffbf5b69b3f30ca
+// 1.000000
+0x3ff0000000000000
+// -0.990165
+0xbfefaf6f0a24fdc2
+// -0.361106
+0xbfd71c5c7ac287f4
+// 1.000000
+0x3ff0000000000000
+// 1.979288
+0x3fffab29f0124803
+// 1.000000
+0x3fefffffffffffff
+// -1.311284
+0xbff4fb05728d9303
+// -0.440256
+0xbfdc2d2861a38b0d
+// 0.020000
+0x3f947ae147ae147b
+// 0.000604
+0x3f43c6f386bb80d0
+// 0.020000
+0x3f947ae147ae147b
+// -0.006600
+0xbf7b0820164f63d6
+// -0.000020
+0xbef53ea77e5c4fa2
+// 1.000000
+0x3ff0000000000000
+// -0.677233
+0xbfe5abe3f80c4718
+// 1.000000
+0x3fefffffffffffff
+// 0.039505
+0x3fa43a013070a814
+// -0.003393
+0xbf6bcbbbdcb73bcf
+// 1.000000
+0x3ff0000000000000
+// 0.535893
+0x3fe1260981a97598
+// 1.000000
+0x3ff0000000000000
+// -0.640404
+0xbfe47e30b26a7183
+// -0.143569
+0xbfc2607689a14bd2
+// 1.000000
+0x3ff0000000000000
+// 1.401147
+0x3ff66b189b2e74a1
+// 1.000000
+0x3ff0000000000000
+// -0.572189
+0xbfe24f5f1123568a
+// -0.161766
+0xbfc4b4c2956701f5
+// 1.000000
+0x3ff0000000000000
+// -1.898816
+0xbffe618cbe2d9672
+// 1.000000
+0x3ff0000000000000
+// 0.875630
+0x3fec0529d05f1810
+// -0.192987
+0xbfc8b3cc14dbe7e2

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADF64/AllBiquadConfigs2_s16.txt

@@ -0,0 +1,38 @@
+H
+18
+// 1
+0x0001
+// 1
+0x0001
+// 1
+0x0001
+// 4
+0x0004
+// 1
+0x0001
+// 5
+0x0005
+// 4
+0x0004
+// 1
+0x0001
+// 4
+0x0004
+// 4
+0x0004
+// 4
+0x0004
+// 5
+0x0005
+// 5
+0x0005
+// 1
+0x0001
+// 5
+0x0005
+// 4
+0x0004
+// 5
+0x0005
+// 5
+0x0005

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADF64/AllBiquadInputs2_f64.txt

@@ -0,0 +1,62 @@
+D
+30
+// 1.000000
+0x3ff0000000000000
+// 0.142363
+0x3fc238f0b99af428
+// 0.245251
+0x3fcf645f0ba9b0da
+// -1.000000
+0xbff0000000000000
+// -0.215667
+0xbfcb9afcf69baa6b
+// 0.880620
+0x3fec2e0ae645e34e
+// 0.424107
+0x3fdb24929f937c13
+// -1.000000
+0xbff0000000000000
+// 0.337660
+0x3fd59c3892e5e8ad
+// -0.054465
+0xbfabe2c897cd2d76
+// -1.000000
+0xbff0000000000000
+// 0.565892
+0x3fe21bca7db13479
+// 0.410710
+0x3fda491158ed8937
+// -1.000000
+0xbff0000000000000
+// -0.154684
+0xbfc3ccacb75ffdde
+// 0.105968
+0x3fbb20b4326308cc
+// -0.356778
+0xbfd6d57214ae01b1
+// -1.000000
+0xbff0000000000000
+// -0.414218
+0xbfda828ac7e95e64
+// -0.424415
+0xbfdb299e0ec9a148
+// 1.000000
+0x3ff0000000000000
+// -0.394876
+0xbfd945a4b0a32fbf
+// -0.542516
+0xbfe15c4a6e2c6b82
+// 1.000000
+0x3ff0000000000000
+// 0.396051
+0x3fd958e61a687112
+// 0.216251
+0x3fcbae1f3862020c
+// 1.000000
+0x3ff0000000000000
+// -0.048996
+0xbfa915f638076ccb
+// -0.048544
+0xbfa8dab28fd8af03
+// 0.072700
+0x3fb29c7360086241

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADF64/AllBiquadRefs2_f64.txt

@@ -0,0 +1,62 @@
+D
+30
+// 0.020000
+0x3f947ae147ae147b
+// 0.002847
+0x3f67531fa5e50f8f
+// 0.007621
+0x3f7f37081f85a02e
+// -0.012103
+0xbf88c992e3b879f1
+// -0.017385
+0xbf91cd6037703fe1
+// 0.017612
+0x3f9208fcbc55b032
+// 0.007905
+0x3f80305abf6f96d8
+// -0.002825
+0xbf67254950f72300
+// 0.018185
+0x3f929f0e34da08c0
+// -0.019747
+0xbf94386e437ad778
+// -0.020000
+0xbf947ae147ae147b
+// 0.011318
+0x3f872dcffd0bc849
+// -0.022322
+0xbf96db782ded7efb
+// 0.019343
+0x3f93ce97ce08e1b4
+// 0.005988
+0x3f788752b7c9a580
+// 0.002119
+0x3f615c9c4935245a
+// -0.015966
+0xbf90595358747562
+// 0.027906
+0x3f9c934dfef9e560
+// -0.008933
+0xbf824ba3126f789d
+// -0.051224
+0xbfaa39fbb6b92c04
+// 0.020000
+0x3f947ae147ae147b
+// -0.007898
+0xbf802c925c91663d
+// 0.007908
+0x3f8031f1feab8ccb
+// 0.031651
+0x3fa03498999db991
+// -0.069518
+0xbfb1cbf219e041e0
+// 0.004325
+0x3f71b71e3890a527
+// 0.016052
+0x3f906fdd9eef716d
+// -0.008381
+0xbf812a2ddd7a9ad4
+// 0.038202
+0x3fa38f266a433f28
+// -0.041095
+0xbfa50a6f8ef9cf14

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADF64/BiquadCoefs1_f64.txt

@@ -0,0 +1,32 @@
+D
+15
+// 0.020000
+0x3f947ae147ae147b
+// -0.021612
+0xbf96217af56297be
+// 0.020000
+0x3f947ae147ae147b
+// 1.744042
+0x3ffbe798f5f156c4
+// -0.810000
+0xbfe9eb851eb851ea
+// 1.000000
+0x3ff0000000000000
+// -1.592168
+0xbff97984baf498c2
+// 1.000000
+0x3ff0000000000000
+// 1.746867
+0x3ffbf32b35561e8f
+// -0.940900
+0xbfee1bda5119ce06
+// 1.000000
+0x3ff0000000000000
+// -1.999600
+0xbffffe5c95658d96
+// 1.000000
+0x3ff0000000000000
+// 1.957551
+0x3fff52207be53342
+// -0.960400
+0xbfeebb98c7e28242

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADF64/BiquadInput1_f64.txt

@@ -0,0 +1,202 @@
+D
+100
+// -0.041118
+0xbfa50d708a3ad40f
+// 0.361952
+0x3fd72a3a6bd8f631
+// 0.552246
+0x3fe1abfece15c872
+// 0.270672
+0x3fd152afa9ce856e
+// 0.426889
+0x3fdb52267db5dae1
+// 0.517975
+0x3fe0933f50d791d4
+// 0.754774
+0x3fe8271b7fa25977
+// 0.418208
+0x3fdac3ea2139aa9b
+// 0.347040
+0x3fd635e7c72072a0
+// 0.101558
+0x3fb9ffb3f59def29
+// 0.039030
+0x3fa3fbb73f222df0
+// 0.011985
+0x3f888b6dafb93976
+// -0.417057
+0xbfdab10f16aaa629
+// -0.720148
+0xbfe70b737613efe8
+// -0.912618
+0xbfed342b433ec346
+// -0.418328
+0xbfdac5e3d9cd3c62
+// -0.188998
+0xbfc83118fbf2bf1a
+// -0.218357
+0xbfcbf3220f539623
+// -0.589503
+0xbfe2dd3605ad94ee
+// -0.382418
+0xbfd8798991c0e769
+// -0.039814
+0xbfa462703e574080
+// 0.223437
+0x3fcc9993cb73fd36
+// 0.348063
+0x3fd646a9eb3911d4
+// 0.391669
+0x3fd91119aae1210a
+// 0.385235
+0x3fd8a7b203011999
+// 0.384636
+0x3fd89de09ace920c
+// 0.620281
+0x3fe3d95696c2513c
+// 0.491295
+0x3fdf71604e1ebecd
+// 0.143750
+0x3fc26667009221d2
+// -0.083635
+0xbfb5691f6ad2e422
+// 0.136440
+0x3fc176df511741f5
+// 0.221979
+0x3fcc69caf692c6c3
+// -0.380066
+0xbfd8530086362859
+// -0.775881
+0xbfe8d404d4ebfd15
+// -1.000000
+0xbff0000000000000
+// -0.628739
+0xbfe41ea0a279277c
+// -0.203384
+0xbfca087eb38e8d97
+// -0.397448
+0xbfd96fca371fb1c7
+// -0.612277
+0xbfe397c603a735e5
+// -0.201576
+0xbfc9cd3d531ad4fa
+// 0.345137
+0x3fd616ba3d805cb7
+// 0.327507
+0x3fd4f5dfe56c1535
+// 0.440284
+0x3fdc2d9cca3e79ff
+// 0.523203
+0x3fe0be14368a4fd6
+// 0.155652
+0x3fc3ec6a3fde5832
+// 0.651310
+0x3fe4d787545f43cb
+// 0.987870
+0x3fef9ca2761780c4
+// 0.326002
+0x3fd4dd375f550730
+// 0.075473
+0x3fb3522c904118cb
+// 0.058404
+0x3fade71d39c952d3
+// 0.177966
+0x3fc6c79328d3d06b
+// 0.029670
+0x3f9e61c378bce0c6
+// -0.374858
+0xbfd7fdad369128f6
+// -0.649199
+0xbfe4c63c310f9f95
+// -0.595384
+0xbfe30d62137357c4
+// -0.460825
+0xbfdd7e278558efec
+// -0.384334
+0xbfd898ececb5f5be
+// -0.544482
+0xbfe16c6665ed08bd
+// -0.566341
+0xbfe21f7706f0dcc4
+// -0.146857
+0xbfc2cc359c87979a
+// 0.198203
+0x3fc95eb39708e94e
+// 0.546501
+0x3fe17cf063d12b1e
+// 0.405216
+0x3fd9ef1018871a58
+// 0.215972
+0x3fcba4f8e2300cae
+// 0.339578
+0x3fd5bba4f0a72a6f
+// 0.618038
+0x3fe3c6f88524aa2b
+// 0.694547
+0x3fe639ba12475dc1
+// 0.317053
+0x3fd44a9a17953c84
+// 0.094718
+0x3fb83f6ce1186608
+// -0.131242
+0xbfc0cc8972f31732
+// -0.033400
+0xbfa119bda59562e1
+// -0.274195
+0xbfd18c6aacfbbcac
+// -0.458580
+0xbfdd59608b38cf24
+// -0.782251
+0xbfe90833454ae370
+// -0.911663
+0xbfed2c589401350a
+// -0.248685
+0xbfcfd4ec4d3636e6
+// -0.280646
+0xbfd1f619f34bebc8
+// -0.530210
+0xbfe0f77bb27f11e1
+// -0.351522
+0xbfd67f561d289ee9
+// 0.096903
+0x3fb8cea64b13008e
+// 0.316001
+0x3fd4395d066056cc
+// 0.483322
+0x3fdeeec04a6cc3ae
+// 0.335549
+0x3fd579a08a08ea4d
+// 0.322066
+0x3fd49cba2d89ea16
+// 0.598175
+0x3fe324405c56e9dd
+// 0.869901
+0x3febd63a26d0e14c
+// 0.729602
+0x3fe758e60957cf54
+// 0.385616
+0x3fd8adf074105858
+// 0.025531
+0x3f9a24d3481a78cc
+// 0.053036
+0x3fab2787b8b1150f
+// 0.215055
+0x3fcb86e8f6bfca3b
+// -0.240515
+0xbfcec9325d6a5d3d
+// -0.610109
+0xbfe38603d2c03bfd
+// -0.694384
+0xbfe6386449126232
+// -0.480613
+0xbfdec25b57e4808e
+// -0.331081
+0xbfd5306ef29e180e
+// -0.145669
+0xbfc2a5479f5fa4b1
+// -0.272600
+0xbfd17246f20085e3
+// -0.178639
+0xbfc6dda28ef1e8a7
+// 0.111300
+0x3fbc7e2c1a958ad6

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADF64/BiquadOutput1_f64.txt

@@ -0,0 +1,202 @@
+D
+100
+// -0.000822
+0xbf4af27b9236d1ff
+// 0.006601
+0x3f7b0976a000280a
+// 0.015263
+0x3f8f4271d4e4f6d8
+// 0.024237
+0x3f98d1881a7736ad
+// 0.047073
+0x3fa819f9271d4aa2
+// 0.074335
+0x3fb307a2b3ae7dbb
+// 0.111719
+0x3fbc99a02c55379c
+// 0.147126
+0x3fc2d504a2c58bbb
+// 0.190176
+0x3fc857ada9567566
+// 0.226168
+0x3fccf31469c9f67a
+// 0.254930
+0x3fd050c48b8ebb6c
+// 0.268258
+0x3fd12b220b132b32
+// 0.254076
+0x3fd042c7671f1d34
+// 0.214576
+0x3fcb773b58b42bfa
+// 0.143796
+0x3fc267e47f4d5bc8
+// 0.053177
+0x3fab3a0735731674
+// -0.062410
+0xbfaff42e3b53ce20
+// -0.188391
+0xbfc81d3557eb0145
+// -0.316047
+0xbfd43a1b4184eefe
+// -0.421579
+0xbfdafb2581e23cb4
+// -0.500500
+0xbfe00418df34614d
+// -0.541488
+0xbfe153df68ca40eb
+// -0.535929
+0xbfe12653bab2da19
+// -0.481005
+0xbfdec8cb2893f7db
+// -0.381452
+0xbfd869b4ce4c1fa2
+// -0.246979
+0xbfcf9cff75d623e6
+// -0.087189
+0xbfb6520aa12370fb
+// 0.073596
+0x3fb2d72f73a310b6
+// 0.221071
+0x3fcc4c0d5fa6c87c
+// 0.341771
+0x3fd5df928da03a84
+// 0.427423
+0x3fdb5ae581dd1e78
+// 0.464370
+0x3fddb83d047559ae
+// 0.444157
+0x3fdc6d1015417d01
+// 0.380516
+0x3fd85a608e449dd6
+// 0.274162
+0x3fd18be0d68c1a58
+// 0.142805
+0x3fc2476be716625f
+// -0.003805
+0xbf6f2b9a8471fa30
+// -0.156373
+0xbfc4040951522739
+// -0.292307
+0xbfd2b52973e2911b
+// -0.393153
+0xbfd9296cbdfe3633
+// -0.455553
+0xbfdd27c654e70d92
+// -0.479646
+0xbfdeb2858347dc55
+// -0.451230
+0xbfdce0f3ac5e1970
+// -0.377595
+0xbfd82a84343ae52c
+// -0.273975
+0xbfd188ce976839e9
+// -0.130832
+0xbfc0bf1c013f0110
+// 0.024720
+0x3f995014f43efc2c
+// 0.169450
+0x3fc5b08958e7f4c1
+// 0.308289
+0x3fd3bb01351c06da
+// 0.419520
+0x3fdad96abbbd15ba
+// 0.493007
+0x3fdf8d6c4eb7d6d2
+// 0.519065
+0x3fe09c2e18cc210a
+// 0.496299
+0x3fdfc35c04b2eb2c
+// 0.429868
+0x3fdb82f717332734
+// 0.326730
+0x3fd4e922dbe82bd4
+// 0.194136
+0x3fc8d9766f939b8e
+// 0.045549
+0x3fa752321d99362a
+// -0.107230
+0xbfbb736d5e0650c8
+// -0.246363
+0xbfcf88ce914952a5
+// -0.355952
+0xbfd6c7ec4c105bba
+// -0.431647
+0xbfdba01985937bd4
+// -0.460794
+0xbfdd7da461db7f2e
+// -0.447250
+0xbfdc9fbd592d11c6
+// -0.387889
+0xbfd8d32aaffa4345
+// -0.287070
+0xbfd25f5bc493737d
+// -0.156915
+0xbfc415cdfc1ab964
+// -0.012004
+0xbf88959f8eaa5930
+// 0.130874
+0x3fc0c07a21706605
+// 0.264290
+0x3fd0ea22b3319440
+// 0.368532
+0x3fd79608ba11bf3c
+// 0.438107
+0x3fdc09f14fdd7912
+// 0.456737
+0x3fdd3b2da4ab761d
+// 0.429458
+0x3fdb7c3f2b581f62
+// 0.353233
+0x3fd69b5d3392a8bd
+// 0.238242
+0x3fce7eb3be851c70
+// 0.105937
+0x3fbb1eb6052a35dc
+// -0.048698
+0xbfa8eef58555ff85
+// -0.199454
+0xbfc987b90c43998b
+// -0.324820
+0xbfd4c9daf624b876
+// -0.414930
+0xbfda8e35a6aeb5c8
+// -0.464127
+0xbfddb4421eddbabe
+// -0.461226
+0xbfdd84b91780f4ec
+// -0.411232
+0xbfda51a06a982b11
+// -0.314637
+0xbfd42303b23b9e5a
+// -0.180634
+0xbfc71f070d004cae
+// -0.024794
+0xbf9963907715f238
+// 0.134359
+0x3fc132abd03d8fd0
+// 0.283895
+0x3fd22b543353908a
+// 0.407881
+0x3fda1ab73d70490b
+// 0.498027
+0x3fdfdfaac4085fee
+// 0.543824
+0x3fe16701e58d9d3d
+// 0.532884
+0x3fe10d62660ec9cc
+// 0.476544
+0x3fde7fb273f1eb36
+// 0.379052
+0x3fd842616554d5e5
+// 0.249924
+0x3fcffd7f43743694
+// 0.098996
+0x3fb957c66ab7282a
+// -0.054453
+0xbfabe1459488c9fa
+// -0.200960
+0xbfc9b912688d9388
+// -0.319869
+0xbfd478bc052cf6bf
+// -0.401935
+0xbfd9b94be34ccc48

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADF64/Coefs1_f64.txt

@@ -1,42 +1,42 @@
 D
 20
-// 0.313959
-0x3fd417e95b54cb40
-// -0.960185
-0xbfeeb9d4dccaa465
-// 0.376911
-0x3fd81f505bbe5025
-// -0.559305
-0xbfe1e5d31ad6a129
-// 0.064376
-0x3fb07aefcfb49bdf
-// 0.668903
-0x3fe567a7fdb21ea0
-// -0.418013
-0xbfdac0b8e63c4762
-// -0.834594
-0xbfeab4ff6f8a99da
-// -0.872058
-0xbfebe7e6f221f2ca
-// 0.266739
-0x3fd11241fd742996
-// -0.117855
-0xbfbe2bc5c03c021f
-// 0.167424
-0x3fc56e2a77a8bb4f
-// -0.403950
-0xbfd9da4f5218bb2e
-// -0.933790
-0xbfede19b0b0acc42
-// 0.806622
-0x3fe9cfd888d8ebe8
-// -0.671400
-0xbfe57c1ae4f8b8af
-// -0.139586
-0xbfc1ddf1b70ca43f
-// 0.315097
-0x3fd42a8b295886d5
+// 0.139008
+0x3fc1cb0749fbdd37
+// 0.224797
+0x3fccc629cc398f15
+// 0.144339
+0x3fc279b66e5fdf00
+// 0.038547
+0x3fa3bc74c20af5ed
+// 0.100676
+0x3fb9c5e99c2ba1d5
+// 0.082084
+0x3fb50376b96af6fa
+// -0.351409
+0xbfd67d7e3641a446
+// 0.291336
+0x3fd2a54021e70e4a
+// 0.193316
+0x3fc8be9083d8b548
+// -0.185961
+0xbfc7cd8e0c405a3a
+// 0.130004
+0x3fc0a3f89328e000
+// -0.257036
+0xbfd07348fdd533c6
 // -1.000000
 0xbff0000000000000
-// -0.865756
-0xbfebb44583b72215
+// -0.626016
+0xbfe40852198f2d21
+// -0.080287
+0xbfb48db51ea64dd3
+// -0.021037
+0xbf958aa7a53a645e
+// 0.106786
+0x3fbb564ccc588b8d
+// -0.253893
+0xbfd03fc867921620
+// 0.507831
+0x3fe040271e52b680
+// -0.223636
+0xbfcca01bf1dc51f5

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADF64/Samples1_f64.txt

@@ -1,1026 +1,1026 @@
 D
 512
-// 0.319823
-0x3fd477fc116ea4c9
-// 0.036859
-0x3fa2df23540c16ee
-// -0.299040
-0xbfd32379d9470b7f
-// -0.420433
-0xbfdae85f80e2e4c0
-// 0.138658
-0x3fc1bf8d84d5dde9
-// 0.123402
-0x3fbf97419272af46
-// -0.073439
-0xbfb2cce68bf57715
-// 0.799643
-0x3fe996abe1ad6e6a
-// -0.924674
-0xbfed96ed5a3e66a2
-// 0.056429
-0x3face44f6c2cb792
-// 0.082119
-0x3fb505bb02e0bd10
-// 0.025301
-0x3f99e870493a1858
-// -0.207950
-0xbfca9e186d0c9158
-// -0.026553
-0xbf9b30bbcdb34823
-// 0.058487
-0x3fadf207cde4d412
-// 0.126469
-0x3fc030233c6a7880
-// -0.186313
-0xbfc7d91864777098
-// -0.201905
-0xbfc9d807364f1afe
-// -0.009882
-0xbf843cc3eb85fa85
-// 0.533976
-0x3fe11655714a3d56
-// -0.198863
-0xbfc97456e0387ebd
-// -0.443148
-0xbfdc5c8b798f4a8d
-// 0.323696
-0x3fd4b76d6f2b2129
-// 0.663828
-0x3fe53e14ee8ebc72
-// -0.237901
-0xbfce738e47c04395
-// -0.022980
-0xbf9787f227f9dc76
-// -0.230279
-0xbfcd79c98955ac6b
-// 0.209460
-0x3fcacf99454f25f3
-// -0.421990
-0xbfdb01e092896a89
-// -0.334987
-0xbfd5706f2bf15f43
-// -0.085060
-0xbfb5c67fa1a6cb3a
-// -0.701962
-0xbfe676798e967195
-// -0.000448
-0xbf3d551aecff8080
-// 0.674558
-0x3fe595fb63f90a56
-// 0.107547
-0x3fbb883421ce36f1
-// -0.292581
-0xbfd2b9a5581f7dbe
-// 0.188103
-0x3fc813c25b912a8b
-// 0.500815
-0x3fe006ac8a2b4d80
-// -0.435241
-0xbfdbdafc15b5a484
-// 0.010025
-0x3f84882ff5f05ba1
-// 0.111837
-0x3fbca158b002a825
-// -0.093474
-0xbfb7ede3aa53b766
-// -0.462308
-0xbfdd9672af218b8e
-// 0.165343
-0x3fc529f6f4278501
-// 0.858825
-0x3feb7b7eaf3431b9
-// 0.571754
-0x3fe24bcf01a927c4
-// 0.047477
-0x3fa84ef4f951d02c
-// 0.461681
-0x3fdd8c2d8f0a0f8f
-// 0.192088
-0x3fc896546f39a02a
-// -0.056007
-0xbfacace6df3dd467
-// 0.463322
-0x3fdda7105c40e369
-// 0.072230
-0x3fb27da5f0497674
-// 0.246654
-0x3fcf925ec971dec3
-// 0.056539
-0x3facf2acfe82acb5
-// -0.212677
-0xbfcb3900b01a275a
-// -0.284367
-0xbfd23310de326f38
-// 0.016232
-0x3f909f3df6562b9d
-// -0.214571
-0xbfcb771057300e31
-// -0.040639
-0xbfa4cead8fe9ed16
-// -0.076431
-0xbfb390fe93f302fc
-// 0.235795
-0x3fce2e853fdf252f
-// 0.087918
-0x3fb681c6bc1434d4
-// 0.036962
-0x3fa2eca18a924c6f
-// -0.245756
-0xbfcf74ebead2dee0
-// 0.234433
-0x3fce01e745d3f7f3
-// -0.246150
-0xbfcf81da9ce5bf75
-// -0.416585
-0xbfdaa952d3ea312a
-// -0.182462
-0xbfc75aeba64b783f
-// -0.121185
-0xbfbf05f8c8bc2db7
-// 0.145378
-0x3fc29bbee993812c
-// 0.253499
-0x3fd039524fc43fe2
-// 0.036937
-0x3fa2e9724686088b
-// -0.460174
-0xbfdd737ddf454119
-// 0.142214
-0x3fc23413a5598888
-// -0.463700
-0xbfddad41874afd95
-// 0.083538
-0x3fb562c4bb7d286a
-// 0.225344
-0x3fccd8106fb4c639
-// -0.025405
-0xbf9a03b9d6a406d8
-// -0.551232
-0xbfe1a3b2217fc64d
-// -0.186884
-0xbfc7ebceb3ebb75a
-// 0.274880
-0x3fd197a33218b7a1
-// -0.290744
-0xbfd29b8d9ed7e728
-// 0.034804
-0x3fa1d1c45ebe1a4a
-// -0.163380
-0xbfc4e9a33544b333
-// -0.105389
-0xbfbafac97a4198b4
-// 0.102985
-0x3fba5d3e4c8e01ff
-// 0.246184
-0x3fcf82f7ef0b5c86
-// -0.023055
-0xbf979bb09061956a
-// 0.116586
-0x3fbdd89bb2457c8d
-// -0.010634
-0xbf85c70892fc8b38
-// 0.274955
-0x3fd198dbe189b7b0
-// 0.197411
-0x3fc944c682355351
-// 0.003962
-0x3f703ab308d273db
-// 0.367949
-0x3fd78c7b8b5ca701
-// -0.177659
-0xbfc6bd87ca496372
-// -0.384858
-0xbfd8a18524bc5402
-// 0.309304
-0x3fd3cba22a77bef1
-// -0.598660
-0xbfe328386bb64dc8
-// 0.072837
-0x3fb2a569cdedf300
-// 0.032344
-0x3fa08f570ecd34b2
-// -0.173726
-0xbfc63ca4bab1ecac
-// 0.193851
-0x3fc8d01848809c1b
-// 0.097246
-0x3fb8e5255ebfff31
-// -0.043587
-0xbfa650fa443227f5
-// 0.018874
-0x3f9353a2ddcf0cb8
-// 0.093744
-0x3fb7ffa1c0561428
-// 0.031987
-0x3fa060a9f7af95e2
-// 0.114350
-0x3fbd460c56d5829d
-// 0.002829
-0x3f672c27027d2691
-// 0.322685
-0x3fd4a6dd576e1437
-// 0.159854
-0x3fc4761ac54019bd
-// -0.443739
-0xbfdc6638e4b29b34
-// -0.216911
-0xbfcbc3c0b6333b8b
-// 0.102121
-0x3fba249b9ffb4862
-// -0.163780
-0xbfc4f6bfb6974fca
-// 0.023282
-0x3f97d73c38b90c1f
-// -0.171378
-0xbfc5efb4bcd7751a
-// -0.259812
-0xbfd0a0c13d8b0021
-// -0.160701
-0xbfc491d5ef061f06
-// 0.361631
-0x3fd724f83078e139
-// -0.063077
-0xbfb025d65ee761e9
-// 0.390488
-0x3fd8fdc1691a60cf
-// -0.148625
-0xbfc306238a43b6c3
-// 0.459759
-0x3fdd6cb007eef5f9
-// 0.052111
-0x3faaae463d7a922d
-// -0.090646
-0xbfb734981b449a0c
-// 0.387899
-0x3fd8d354e32b93df
-// 0.550015
-0x3fe199b984b31dc3
-// 0.151908
-0x3fc371b563a8d75c
-// 0.067876
-0x3fb1604e4361b2fa
-// -0.491867
-0xbfdf7abde76223f7
-// 0.482602
-0x3fdee2f58e5477cb
-// -0.161579
-0xbfc4ae9effb58b7c
-// -0.265145
-0xbfd0f821a62143c8
-// -0.341012
-0xbfd5d32462306134
-// 0.493719
-0x3fdf991583a5648a
-// -0.283122
-0xbfd21eacff4343e3
-// -0.092857
-0xbfb7c57a34969e79
-// 0.188616
-0x3fc8248fa094f9e0
-// -0.020502
-0xbf94fe767f9516e1
-// -0.208036
-0xbfcaa0eb2e29159a
-// 0.149126
-0x3fc3169301d5a541
-// 0.006219
-0x3f7978ca7b9ac83a
-// -0.173552
-0xbfc636efa74de0e1
-// -0.137999
-0xbfc1a9f3244af1d7
-// 0.464042
-0x3fddb2dbe81987a7
-// -0.304320
-0xbfd379fa1bba955c
-// 0.332997
-0x3fd54fd1e1e0c781
-// 0.142518
-0x3fc23e0993880808
-// 0.188384
-0x3fc81cfada6fca6f
-// -0.524396
-0xbfe0c7da1198e7c4
-// -0.269469
-0xbfd13efbc230876b
-// -0.168486
-0xbfc590f0deae4d96
-// -0.146770
-0xbfc2c95920969c6b
-// -0.032998
-0xbfa0e52bdb427ab2
-// 0.772411
-0x3fe8b7965bb17d99
-// 0.287847
-0x3fd26c14e03bef1f
-// 0.045619
-0x3fa75b6feeb7762c
-// 0.048584
-0x3fa8dff78fe63583
-// 0.125382
-0x3fc00c82d3cfb9fb
-// 0.087355
-0x3fb65cdf522ccfe6
-// 0.109600
-0x3fbc0eb7b9fd663d
-// 0.315588
-0x3fd43298c803abf8
-// 0.463137
-0x3fdda408f3f1fb4b
-// -0.178719
-0xbfc6e047113c758b
-// -0.358303
-0xbfd6ee6da01bc19a
-// -0.379375
-0xbfd847afe580c4a8
-// -0.260823
-0xbfd0b153a9287226
-// -0.353833
-0xbfd6a5349fb064f1
-// -0.156916
-0xbfc415d208dd55d1
-// -0.228183
-0xbfcd351817c39eaa
-// 0.120676
-0x3fbee4971f628080
-// 0.121918
-0x3fbf35fcd9b172d1
-// -0.462490
-0xbfdd99714e60a82c
-// -0.023659
-0xbf983a024f6a6208
-// -0.049379
-0xbfa9482bb34ce631
-// 0.284969
-0x3fd23cef7a0394f1
-// -0.215457
-0xbfcb941676b21ff4
-// 0.158263
-0x3fc441f82fad43c4
-// 0.039039
-0x3fa3fce9ff10d65e
-// 0.241583
-0x3fceec34ed4e5bd6
-// -0.039470
-0xbfa4356ed459a73d
-// 0.410016
-0x3fda3db25884972a
-// 0.034964
-0x3fa1e6c23c552e0c
-// 0.334855
-0x3fd56e45c2c3f55f
-// -0.588716
-0xbfe2d6c3b9643240
-// 0.325885
-0x3fd4db4ad41ea56e
-// -0.319349
-0xbfd470363aaef89d
-// 0.353474
-0x3fd69f4ff910a052
-// -0.092071
-0xbfb791f136527160
-// -0.228629
-0xbfcd43baed0efa38
-// 0.797441
-0x3fe984a2bf1ea315
-// 0.008921
-0x3f82450b0de47b58
-// -0.252266
-0xbfd0251fb32493a2
-// -0.166615
-0xbfc553a3e72bc7b9
-// 0.195726
-0x3fc90d90066c8fa7
-// 0.530496
-0x3fe0f9d3718ceabd
-// 0.171870
-0x3fc5ffd7321958a7
-// 0.003362
-0x3f6b8b9f62339f36
-// -0.321703
-0xbfd496c898f2e60f
-// 0.338516
-0x3fd5aa3f162d8921
-// -0.144690
-0xbfc28534ef98dde1
-// 0.213740
-0x3fcb5bd8346d1555
-// -0.551997
-0xbfe1a9f6688014e8
-// -0.414978
-0xbfda8f011f8a43cb
-// -0.357275
-0xbfd6dd976cfd49a5
-// 0.401590
-0x3fd9b3a5f404bdbb
-// -0.295869
-0xbfd2ef8445b94d54
-// 0.178792
-0x3fc6e2a44a28c83e
-// -0.175575
-0xbfc6793f69802ecd
-// -0.096196
-0xbfb8a0459fcf8d65
-// 0.292068
-0x3fd2b13dd19160b2
-// -0.744527
-0xbfe7d32a74c4c599
-// 0.026196
-0x3f9ad33dc819d912
-// -0.421279
-0xbfdaf63ac4a4ce9e
-// 0.097786
-0x3fb908807c030a42
-// 0.159842
-0x3fc475b061339971
-// -0.134538
-0xbfc138881caa2862
-// 0.001829
-0x3f5df70453f40064
-// 0.140018
-0x3fc1ec1d5f4432ae
-// 0.119142
-0x3fbe80122311e5bf
-// -0.295308
-0xbfd2e651a94bafc0
-// 0.138102
-0x3fc1ad5215824e49
-// -0.071856
-0xbfb2652c2fa518cf
-// 0.164842
-0x3fc5198d00828844
-// -0.562544
-0xbfe2005c1eb7bbed
-// -0.030145
-0xbf9ede4560b212bf
-// 0.792818
-0x3fe95ec3a0bc3c6e
-// -0.043695
-0xbfa65f2956ae38e6
-// 0.491053
-0x3fdf6d67e62f09e1
-// -0.255876
-0xbfd06047c0801672
-// -0.248568
-0xbfcfd11788b0c24a
-// -0.449158
-0xbfdcbf01cb3565b0
-// -0.579570
-0xbfe28bd6b80ae2d9
-// -0.200330
-0xbfc9a4698157c997
-// -0.311590
-0xbfd3f118bd56015f
-// 0.219989
-0x3fcc2898aecff1f2
-// 0.341922
-0x3fd5e20b4fba221f
-// 0.037593
-0x3fa33f5b89f5ee3e
-// -0.035029
-0xbfa1ef4b1891df71
-// 0.189725
-0x3fc848e9bd828db4
-// 0.444764
-0x3fdc77040f057df5
-// 0.423554
-0x3fdb1b8361ad1b2f
-// 0.274954
-0x3fd198da0b6aeb31
-// 0.362124
-0x3fd72d09011b5b8e
-// 0.092633
-0x3fb7b6c456c8c67e
-// 0.452699
-0x3fdcf9062abb323e
-// -0.163270
-0xbfc4e6077a06164f
-// -0.403504
-0xbfd9d30258d72497
-// -0.425391
-0xbfdb399b6cb81dcd
-// -0.013585
-0xbf8bd28279b3a699
-// 0.380067
-0x3fd8530509b5ae43
-// 0.018178
-0x3f929d20e25ec1f6
-// 0.342843
-0x3fd5f123b9b13379
-// -0.214292
-0xbfcb6de7c8dee898
-// -0.000485
-0xbf3fca45cbe0b39c
-// 0.181679
-0x3fc74145802fa6fe
-// -0.191007
-0xbfc872e7efefcadc
-// 0.096924
-0x3fb8cffe568741ec
-// 0.034147
-0x3fa17bac4811c890
-// -0.468082
-0xbfddf50d02a86992
-// 0.904888
-0x3fecf4d715a1075a
-// 0.469857
-0x3fde1221f10b65eb
-// 0.151995
-0x3fc37493cf987f71
-// 0.202528
-0x3fc9ec6f5fa063f3
-// 0.521021
-0x3fe0ac33dc9f3ea7
-// -0.090843
-0xbfb7417bc5f5b1f9
-// -0.315025
-0xbfd4295e1defbd15
-// 0.018690
-0x3f932386a11a1d72
-// -0.438320
-0xbfdc0d6dbcd8714e
-// -0.215375
-0xbfcb916643249ceb
-// 0.265409
-0x3fd0fc74718bdfb4
-// -0.254486
-0xbfd049813a814c9d
-// -0.130689
-0xbfc0ba6c09309156
-// -0.312452
-0xbfd3ff38186aca33
-// 0.170246
-0x3fc5caa1e2fdc099
-// -0.006353
-0xbf7a05e16f3a796f
-// -0.279429
-0xbfd1e22bd2cf282d
-// -0.496268
-0xbfdfc2dbec796f21
-// -0.300714
-0xbfd33ee5ca200084
-// 0.068623
-0x3fb1914303e1752e
-// -0.294742
-0xbfd2dd0c78f6a0ee
-// 0.283354
-0x3fd2227877a14947
-// 0.249966
-0x3fcffee57578ef3d
-// 0.478792
-0x3fdea487b34e77cb
-// 0.055156
-0x3fac3d7897801b29
-// 0.454094
-0x3fdd0fe1dfff826d
-// 0.314858
-0x3fd426a170134250
-// 0.086661
-0x3fb62f6e8abc3928
-// 0.644313
-0x3fe49e35ceb34292
-// 0.350263
-0x3fd66ab602615820
-// -0.085190
-0xbfb5cf04347dfd2b
-// 0.123125
-0x3fbf8516de7a3192
-// -0.333833
-0xbfd55d8383ec0670
-// -0.862218
-0xbfeb974b08902f7e
-// 0.325928
-0x3fd4dc00e424c76f
-// 0.496242
-0x3fdfc26bc56b0f1f
-// 0.809032
-0x3fe9e39608e75c23
-// 0.519834
-0x3fe0a27a9a3a99e9
-// -0.111432
-0xbfbc86d287cb5aad
-// 0.536637
-0x3fe12c2098098632
-// 0.075394
-0x3fb34cfd935003b3
-// -0.038917
-0xbfa3ecfb3655a1d3
-// -0.109111
-0xbfbbeeb628e91f16
-// 0.531095
-0x3fe0feba9cd5b352
-// -0.155691
-0xbfc3edb1a9252c85
-// -0.134255
-0xbfc12f4744eb6223
-// 0.967686
-0x3feef7496dc96726
-// -0.332952
-0xbfd54f16fa111c68
-// -0.175148
-0xbfc66b3c56797d24
-// -0.422449
-0xbfdb0969586c6a0d
-// 0.388175
-0x3fd8d7dc70bc0114
-// -0.041955
-0xbfa57b16b5f4a44a
-// 0.505324
-0x3fe02b9d21faf2f2
-// 0.224948
-0x3fcccb154679e2e2
-// 0.304939
-0x3fd3841f85d900da
-// 0.160496
-0x3fc48b22b308c211
-// 0.261102
-0x3fd0b5e688becbcc
-// 0.341031
-0x3fd5d37473119254
-// -1.000000
-0xbff0000000000000
-// -0.360619
-0xbfd71461ded00e01
-// 0.054448
-0x3fabe09555a7f9ce
-// -0.451262
-0xbfdce17bd71b3266
-// -0.588402
-0xbfe2d430b0cd6bbb
-// 0.151041
-0x3fc35550cefaf529
-// -0.243364
-0xbfcf2690360b61b2
-// -0.154318
-0xbfc3c0afccac2880
-// 0.207629
-0x3fca939a290edc48
-// 0.166601
-0x3fc5532b357db433
-// 0.419546
-0x3fdad9d576536eac
-// 0.197817
-0x3fc95212a5be7316
-// -0.034048
-0xbfa16ec20758f98e
-// 0.158986
-0x3fc459aa6623378b
-// 0.073745
-0x3fb2e0f505baab77
-// 0.239713
-0x3fceaeeda74ac518
-// 0.259786
-0x3fd0a056212b96d7
-// -0.134357
-0xbfc1329f990b231c
-// -0.157079
-0xbfc41b2b2918ff7c
-// 0.023523
-0x3f9816761cca3278
-// -0.798980
-0xbfe9913ef4442cf8
-// 0.209946
-0x3fcadf86b804e93e
-// -0.190210
-0xbfc858cd6eddf483
-// 0.822743
-0x3fea53e947b1d452
-// 0.670488
-0x3fe574a306720a96
-// 0.402488
-0x3fd9c25b373385e3
-// 0.272028
-0x3fd168e886f8afd7
-// -0.014500
-0xbf8db1f6416f169f
-// 0.053950
-0x3fab9f5d78f548c6
-// -0.178295
-0xbfc6d25ba7bdd147
-// -0.483475
-0xbfdef140554ae1ae
-// 0.060854
-0x3faf283c185aaaa1
-// 0.030740
-0x3f9f7a35abef1aba
-// -0.351558
-0xbfd67fec66e8b236
-// -0.073362
-0xbfb2c7de2971abce
-// 0.061512
-0x3faf7e70381ec49f
-// 0.048689
-0x3fa8edc6b5fce29d
-// 0.072795
-0x3fb2a2abde27b4c5
-// 0.325317
-0x3fd4d1fda8098dd2
-// 0.557226
-0x3fe1d4cb218e1658
-// 0.025761
-0x3f9a6136a2cae14d
-// 0.293213
-0x3fd2c4011c63f84b
-// 0.229277
-0x3fcd58f5569dd657
-// -0.115837
-0xbfbda7833c95797a
-// -0.652663
-0xbfe4e29d4a6f1cc8
-// 0.484871
-0x3fdf08224d8cdbaf
-// 0.109446
-0x3fbc04a32039daa5
-// 0.114093
-0x3fbd352d571077e8
-// -0.353393
-0xbfd69dfc4a25a6b2
-// -0.374580
-0xbfd7f92013b2e1b4
-// 0.365717
-0x3fd767e97cc6856f
-// -0.199635
-0xbfc98da12e3c0a91
-// -0.231857
-0xbfcdad7a92bddffd
-// 0.338467
-0x3fd5a971c3846afb
-// -0.296884
-0xbfd300240cb2bea9
-// 0.313896
-0x3fd416deccd12f88
-// -0.115361
-0xbfbd8850b72ea16d
-// 0.126240
-0x3fc0289ec9f10553
-// 0.075799
-0x3fb36791c6c9251f
-// -0.440440
-0xbfdc3029624a8d88
-// -0.120164
-0xbfbec30ce978e92a
-// -0.116921
-0xbfbdee9131523a5f
-// 0.217643
-0x3fcbdbba719faec1
-// -0.156211
-0xbfc3feb6296e511e
-// -0.081604
-0xbfb4e40299832f6f
-// 0.064524
-0x3fb084a20759be0d
-// -0.204394
-0xbfca2997db9068ec
-// 0.026287
-0x3f9aeaffea0c85c1
-// -0.388609
-0xbfd8def6f2ac13ef
-// -0.821327
-0xbfea484fde7d64fd
-// -0.260603
-0xbfd0adb76dbeb598
-// -0.160368
-0xbfc486f44e71d2b6
-// -0.164809
-0xbfc51874ad12c867
-// 0.300457
-0x3fd33aaea501c2df
-// 0.207238
-0x3fca86c7caf6591e
-// -0.158629
-0xbfc44df75b41738c
-// 0.091469
-0x3fb76a7d2e236aa4
-// 0.510933
-0x3fe0598f6a043723
-// -0.188685
-0xbfc826d87fe9fc22
-// 0.187694
-0x3fc8065f72664df5
-// 0.050710
-0x3fa9f69bff4358f5
-// -0.083945
-0xbfb57d721b9c48cd
-// 0.164799
-0x3fc51823adb340ea
-// -0.270527
-0xbfd1504e833c77cc
-// 0.016961
-0x3f915e5615d524e7
-// -0.151150
-0xbfc358e53d8151f5
-// 0.101981
-0x3fba1b656348b8e8
-// -0.414474
-0xbfda86bc313d6607
-// -0.199856
-0xbfc994e294da9da1
-// -0.178194
-0xbfc6cf12340957a9
-// -0.113651
-0xbfbd18407ee9ea65
-// -0.166156
-0xbfc54499b2ac8ca1
-// -0.431392
-0xbfdb9beefc96430e
-// 0.221057
-0x3fcc4b94e4dcbf5e
-// -0.304714
-0xbfd38071198f2aba
-// 0.067515
-0x3fb148acae060c2d
-// -0.268386
-0xbfd12d3cb8f973ea
-// -0.491142
-0xbfdf6ee047c65426
-// 0.563238
-0x3fe2060c4b23e4b3
-// 0.361461
-0x3fd7222d4961b35a
-// -0.242032
-0xbfcefaebc19ad22f
-// 0.430264
-0x3fdb897223aa73e2
-// 0.464197
-0x3fddb567a81119aa
-// 0.369835
-0x3fd7ab616fcb0220
-// 0.587243
-0x3fe2cab2ba38a50e
-// 0.098070
-0x3fb91b23ca792c10
-// 0.409656
-0x3fda37cd75caa342
-// 0.067603
-0x3fb14e76261687d3
-// -0.126056
-0xbfc022988847bd07
-// -0.359118
-0xbfd6fbcac7da0bf9
-// 0.100539
-0x3fb9bce4b28ee0a9
-// 0.421012
-0x3fdaf1ddfdd60b25
-// 0.308036
-0x3fd3b6dc66d44ff6
-// 0.349303
-0x3fd65afc88e983ff
-// 0.158635
-0x3fc44e28e1a9c444
-// -0.088072
-0xbfb68be40e1c4853
-// -0.093507
-0xbfb7f01132e71c66
-// -0.083148
-0xbfb54929fd563823
-// 0.163958
-0x3fc4fc964fa8c899
-// -0.665279
-0xbfe549f6c3e11ec8
-// 0.211687
-0x3fcb18911c0888d5
-// 0.029146
-0x3f9dd876482c1394
-// -0.241727
-0xbfcef0e8fc3c153f
-// 0.135632
-0x3fc15c63048c71f0
-// -0.153895
-0xbfc3b2d2b565cee2
-// -0.060371
-0xbfaee8f30d6192ae
-// -0.330045
-0xbfd51f7638dc4bb6
-// -0.252887
-0xbfd02f4c368ccf93
-// 0.315418
-0x3fd42fceba7c449b
-// 0.524268
-0x3fe0c6ccf985f83b
-// 0.246329
-0x3fcf87b9011b3154
-// 0.430482
-0x3fdb8d0311387b44
-// 0.402310
-0x3fd9bf7432bbfc8e
-// 0.189277
-0x3fc83a3d8663d955
-// -0.191763
-0xbfc88bafe34eae38
-// 0.120904
-0x3fbef392f42b0528
-// 0.047982
-0x3fa8910fb9cb69d3
-// -0.273565
-0xbfd1821597b9b594
-// 0.040467
-0x3fa4b81d0ff58426
-// -0.715101
-0xbfe6e21c472a57ae
-// 0.174759
-0x3fc65e7f6d93234d
-// 0.246958
-0x3fcf9c5467b41723
-// -0.389087
-0xbfd8e6cdd5b1cef9
-// 0.366832
-0x3fd77a2ddf4df698
-// 0.015743
-0x3f901eebdd90314e
-// 0.218230
-0x3fcbeef6191bcf36
-// 0.524572
-0x3fe0c94aa450c52b
-// 0.371906
-0x3fd7cd4d23562c40
-// 0.041472
-0x3fa53bc0c5ab9192
-// -0.157300
-0xbfc4226a1cf2b1a8
-// 0.054891
-0x3fac1a9fae5033cc
-// -0.143986
-0xbfc26e24bbf68753
-// -0.052590
-0xbfaaed19e288458d
-// -0.085837
-0xbfb5f970fe51f78d
-// -0.035263
-0xbfa20df82d901039
-// 0.229390
-0x3fcd5ca970b4b533
-// -0.243177
-0xbfcf206b2f73853c
-// -0.314960
-0xbfd4284d87288300
-// 0.178912
-0x3fc6e69297c38b26
-// 0.126799
-0x3fc03aef36872e03
-// -0.356900
-0xbfd6d773c24abdbd
-// -0.744809
-0xbfe7d5799baabc07
-// 0.064570
-0x3fb087ad56c838a6
-// -0.295588
-0xbfd2eae9429bac92
-// 0.059840
-0x3faea3568586b573
-// 0.435461
-0x3fdbde95bba3592c
-// 0.085746
-0x3fb5f3703e205b42
-// -0.326743
-0xbfd4e95b726e2204
-// -0.286892
-0xbfd25c71c087f587
-// -0.181850
-0xbfc746df249d08a3
-// 0.048922
-0x3fa90c596581e3be
-// 0.497612
-0x3fdfd8df711384a5
-// 0.215281
-0x3fcb8e54f746b4da
-// 0.341235
-0x3fd5d6cd0b037121
-// -0.413584
-0xbfda782b08c4160f
-// -0.129148
-0xbfc087efbcc70be2
-// 0.000452
-0x3f3d9942dbb141c1
-// -0.301141
-0xbfd345e4f1696cee
-// 0.372693
-0x3fd7da348362a478
-// 0.462429
-0x3fdd987144759b74
-// -0.165059
-0xbfc520a4fc8f23e6
-// 0.073945
-0x3fb2ee15dce092d0
-// -0.100351
-0xbfb9b09f0dcd4737
-// 0.072044
-0x3fb27181c3279dda
-// -0.015312
-0xbf8f5c240e321c02
-// 0.317699
-0x3fd4552d1c0ea02b
-// 0.193917
-0x3fc8d242df13aa32
-// -0.434065
-0xbfdbc7b9e3905f17
-// -0.091891
-0xbfb78632f5449964
-// -0.210379
-0xbfcaedaff020c8d2
-// 0.562847
-0x3fe202d850b03fee
-// -0.280805
-0xbfd1f8b5f4a1de08
-// 0.089313
-0x3fb6dd36c549dc81
+// 0.211621
+0x3fcb166432781d49
+// -0.846121
+0xbfeb136b536d5a4f
+// -0.347600
+0xbfd63f158e5947d1
+// -0.464259
+0xbfddb66bfd8ae533
+// 0.292649
+0x3fd2bac443be13eb
+// -0.455061
+0xbfdd1fb883456524
+// 0.596124
+0x3fe313731a390517
+// -0.607349
+0xbfe36f675187ba48
+// -0.153221
+0xbfc39cbabf2e6c6e
+// -0.355068
+0xbfd6b96e4284ebec
+// -0.017171
+0xbf919563c862a430
+// 0.123618
+0x3fbfa570ff8973dd
+// 0.369373
+0x3fd7a3d0290341e2
+// 0.271933
+0x3fd167583d4abbf1
+// 0.030461
+0x3f9f310dffd92e5a
+// -0.290704
+0xbfd29ae62d65453a
+// 0.176855
+0x3fc6a32c76213995
+// 0.010642
+0x3f85cba166e55e8a
+// 0.472817
+0x3fde42a03bacd9cb
+// 0.174237
+0x3fc64d64e3807b42
+// 0.484757
+0x3fdf0642c9d410fa
+// -0.445407
+0xbfdc818cc26df7ef
+// -0.427224
+0xbfdb57a171a6daf5
+// -0.365318
+0xbfd76160820ce2af
+// 0.109012
+0x3fbbe83e23849267
+// 0.429871
+0x3fdb83003bbeee71
+// 0.403230
+0x3fd9ce8652471a62
+// -0.330912
+0xbfd52da9676ceb99
+// -0.062812
+0xbfb014762c76f8d7
+// -0.234346
+0xbfcdff0dae2a6999
+// 0.730810
+0x3fe762cb2bdbdeae
+// 0.699894
+0x3fe665871cbe6f4c
+// -0.300422
+0xbfd33a1cf2899a23
+// 0.165081
+0x3fc52161947b40dd
+// 0.100108
+0x3fb9a0af17a302e7
+// 0.233181
+0x3fcdd8e0e85b54f8
+// -0.092008
+0xbfb78dcefff55060
+// 0.573244
+0x3fe2580369917479
+// 0.157028
+0x3fc41981a740978d
+// -0.454123
+0xbfdd105a89508e47
+// -0.187959
+0xbfc80f0ad08d2262
+// 0.244679
+0x3fcf51a206242b69
+// 0.177523
+0x3fc6b911fe933a3b
+// -0.118024
+0xbfbe36d4b45b9e09
+// -0.051926
+0xbfaa95fafba00697
+// -0.084750
+0xbfb5b22fc2b8cfbb
+// 0.532873
+0x3fe10d4c8e199c0c
+// 0.378204
+0x3fd8347d12856fcc
+// 0.263292
+0x3fd0d9c82afb1ff9
+// -0.212959
+0xbfcb423e92e62989
+// 0.131710
+0x3fc0dbdf73fe9077
+// -0.389283
+0xbfd8ea0228477beb
+// 0.041167
+0x3fa513d878c27428
+// -0.053431
+0xbfab5b5729059503
+// -0.145886
+0xbfc2ac62b7fd854b
+// 0.208767
+0x3fcab8e382bc8ff9
+// 0.306160
+0x3fd3981f9f397433
+// -0.319107
+0xbfd46c4080304b50
+// 0.428701
+0x3fdb6fd85b2b9426
+// 0.063649
+0x3fb04b556469f4ce
+// -0.448400
+0xbfdcb297028d6084
+// 0.251347
+0x3fd01613abc6cd25
+// -0.241738
+0xbfcef143ab465456
+// -0.380274
+0xbfd85669a8c72b02
+// 0.243834
+0x3fcf35f53532dbe9
+// 0.601194
+0x3fe33cfa86218269
+// -0.320135
+0xbfd47d193a9caf24
+// -0.448296
+0xbfdcb0e09fbb7f95
+// -0.352541
+0xbfd69007c7b9da0b
+// 0.165700
+0x3fc535a64e5fbf33
+// 0.695077
+0x3fe63e11143d96d3
+// 0.392672
+0x3fd9218a54fd49d3
+// -0.370020
+0xbfd7ae6795dbe787
+// 0.491021
+0x3fdf6ce46af07e28
+// -0.047233
+0xbfa82ee050e183bf
+// -0.091268
+0xbfb75d5ac1270762
+// -0.109506
+0xbfbc0897d02f4d68
+// 0.256298
+0x3fd0672fe19876ff
+// -0.163153
+0xbfc4e2358d6afee8
+// 0.009039
+0x3f82833bd6ce9c01
+// -0.112373
+0xbfbcc4773cf4a1d3
+// 0.875708
+0x3fec05cc6e2ab99d
+// -0.056931
+0xbfad261b5290b050
+// -0.136743
+0xbfc180c7985f6307
+// 0.148719
+0x3fc3093bafad52f0
+// -0.829038
+0xbfea877b50c57942
+// -0.754014
+0xbfe820e2fc605496
+// -0.290130
+0xbfd2917c313f8305
+// 0.030660
+0x3f9f655f38ffee4d
+// 0.420911
+0x3fdaf032de96cd56
+// -0.116305
+0xbfbdc624bd5e09e6
+// -0.729143
+0xbfe75523e88735f0
+// 0.126734
+0x3fc038d5cde8c408
+// -0.706202
+0xbfe69934afe692b7
+// 0.656156
+0x3fe4ff3b4f970d9d
+// 0.796297
+0x3fe97b438ad7ddd6
+// 0.620332
+0x3fe3d9c24e649e7c
+// -0.129642
+0xbfc0981bc94fcb49
+// 0.859122
+0x3feb7dee08ce09ec
+// -0.397117
+0xbfd96a5c209ed347
+// -0.024615
+0xbf9934b8b328c425
+// 0.359652
+0x3fd70489f7040d7d
+// 0.696072
+0x3fe64639b4b1fa2e
+// 0.327947
+0x3fd4fd167027f827
+// -0.304178
+0xbfd377a72853731b
+// -0.200469
+0xbfc9a8f7e61b1318
+// 0.004635
+0x3f72fbab70c135b6
+// -0.470294
+0xbfde194ae24b66bd
+// 0.311850
+0x3fd3f55b14eeaeb9
+// 0.067500
+0x3fb147af6c793aa6
+// -0.025686
+0xbf9a4d5619693565
+// -0.008137
+0xbf80a9ec3ef04f4f
+// -0.512477
+0xbfe0663585af2a71
+// 0.197806
+0x3fc951b9188c717f
+// 0.808347
+0x3fe9ddfa46ae39ee
+// -0.387928
+0xbfd8d3d0c3750193
+// 0.067157
+0x3fb1313a37d130f3
+// 0.467676
+0x3fddee672287cc75
+// -0.077616
+0xbfb3dea319b1873f
+// -0.221721
+0xbfcc615ac7d0cc06
+// -0.068140
+0xbfb171976271ce33
+// 0.458169
+0x3fdd52a494ec8805
+// -0.241653
+0xbfceee78edbde03d
+// 0.318342
+0x3fd45fb50ed425cb
+// -0.258982
+0xbfd093296e2eac95
+// -0.048585
+0xbfa8e01c923f4d9c
+// 0.431375
+0x3fdb9ba4d7bdd3cd
+// -0.275516
+0xbfd1a20ca36c75d8
+// -0.030607
+0xbf9f576ae7e5ed97
+// 0.119848
+0x3fbeae635ed97ca3
+// -0.225636
+0xbfcce1a5d6475ca7
+// -0.074457
+0xbfb30f9d62d8d721
+// -0.014120
+0xbf8ceaec46091bac
+// -0.173373
+0xbfc63119106410f4
+// 0.257720
+0x3fd07e7e19488585
+// 0.274934
+0x3fd198863eec1fc5
+// 0.138216
+0x3fc1b1129d0bafb6
+// 0.306339
+0x3fd39b0d0a04b558
+// 0.664312
+0x3fe5420b04f611c8
+// 0.112972
+0x3fbcebbb6cd56b62
+// 0.047355
+0x3fa83ed9fbeaeafe
+// -0.301014
+0xbfd343d0c81ab5ea
+// 0.168686
+0x3fc597843b7bb5d5
+// -0.439104
+0xbfdc1a46a343e88e
+// 0.081727
+0x3fb4ec10d90304e5
+// -0.615248
+0xbfe3b01cade8e345
+// -0.189014
+0xbfc8319c89e9a44a
+// 0.553624
+0x3fe1b749b2ff962e
+// 0.240803
+0x3fced2a0c59764cf
+// -0.651388
+0xbfe4d82bb7c89e81
+// -0.402896
+0xbfd9c90c5a7b906d
+// -0.358438
+0xbfd6f0a53010cbfd
+// 0.062430
+0x3faff6e1519660c3
+// 0.670480
+0x3fe57491f9ec9497
+// 0.312845
+0x3fd405a89e86b524
+// -0.084168
+0xbfb58c02a55661a1
+// 0.673259
+0x3fe58b56cce85fce
+// -0.272446
+0xbfd16fc0486b5b35
+// -0.018406
+0xbf92d912dda6f21b
+// -0.328635
+0xbfd5085b366d44ce
+// -0.161902
+0xbfc4b93080f88fdd
+// 0.020342
+0x3f94d47eb4b7d1d1
+// -0.639324
+0xbfe47556c920c618
+// 0.269476
+0x3fd13f19149578f1
+// 0.025783
+0x3f9a66e9e539a121
+// 0.129254
+0x3fc08b636b94dd0a
+// -0.154541
+0xbfc3c7fca583f79d
+// 0.091790
+0x3fb77f94b88cfd90
+// 0.244833
+0x3fcf56b342787df0
+// 0.703806
+0x3fe68593a92005da
+// -0.131255
+0xbfc0ccf44ab94fe4
+// 0.225835
+0x3fcce829ca5ffd6e
+// 0.545684
+0x3fe1763dee759d58
+// 0.141094
+0x3fc20f5d8ce5b155
+// -0.039784
+0xbfa45e9564bc2ee4
+// -0.102373
+0xbfba351cd741ea75
+// -0.936293
+0xbfedf61c74338100
+// 0.010321
+0x3f85235074a0582e
+// -0.177893
+0xbfc6c535dfbd4377
+// -0.112461
+0xbfbcca3f5d212b1b
+// 0.097063
+0x3fb8d9183b52a310
+// 0.490508
+0x3fdf647b8111f028
+// -0.145910
+0xbfc2ad2f87f04c2d
+// -0.230138
+0xbfcd75275b6104a3
+// -0.179942
+0xbfc70859b4099c32
+// -0.482982
+0xbfdee92f0ba955bd
+// 0.525778
+0x3fe0d32c7c6d1c5e
+// 0.031098
+0x3f9fd82a91dfb543
+// 0.083381
+0x3fb55878bf18ab3f
+// -0.063516
+0xbfb04291c442a138
+// -0.120046
+0xbfbebb5a77644b71
+// -0.025915
+0xbf9a895680a5747a
+// -0.096319
+0xbfb8a861cc07ddf5
+// 0.671622
+0x3fe57dee09f62d6f
+// 0.076253
+0x3fb385509c898c5d
+// 0.855956
+0x3feb63fd3a7efd38
+// 0.923728
+0x3fed8f2e74da85a3
+// 1.000000
+0x3ff0000000000000
+// -0.163433
+0xbfc4eb5bed7a66bf
+// -0.851124
+0xbfeb3c685c3877d9
+// -0.237857
+0xbfce72187a0dbbdb
+// 0.302762
+0x3fd36074bd70615f
+// -0.496355
+0xbfdfc4476013c30f
+// -0.261503
+0xbfd0bc7656b3a3c9
+// -0.192641
+0xbfc8a8796c2a9b6e
+// -0.524423
+0xbfe0c81271e977f1
+// 0.381330
+0x3fd867b4e8de56c3
+// -0.500737
+0xbfe00609414dccf3
+// 0.503366
+0x3fe01b93df8c1fb1
+// -0.354536
+0xbfd6b0b94609a91b
+// 0.226855
+0x3fcd09972e994a19
+// 0.540799
+0x3fe14e3a40371e33
+// -0.277385
+0xbfd1c0aef861d39d
+// 0.829277
+0x3fea897074adbd23
+// -0.048486
+0xbfa8d318059428c2
+// 0.288334
+0x3fd2741151abe7a4
+// 0.003781
+0x3f6ef9a2f9d412e1
+// -0.135265
+0xbfc1505c364ba138
+// -0.039420
+0xbfa42ed886e367ad
+// 0.335620
+0x3fd57acdc1a674d9
+// -0.808433
+0xbfe9deae7a81b0ad
+// 0.194133
+0x3fc8d95b6ec24050
+// 0.225278
+0x3fccd5e668552cb2
+// -0.356553
+0xbfd6d1c46b576ed7
+// -0.083633
+0xbfb568ff7d7d4721
+// 0.091024
+0x3fb74d5a12087687
+// -0.219913
+0xbfcc261f74e44ad2
+// 0.183097
+0x3fc76fb86c48b3a6
+// 0.630612
+0x3fe42df96447e896
+// 0.336698
+0x3fd58c7499da563a
+// 0.091401
+0x3fb7660dd85d1d2d
+// 0.030388
+0x3f9f1e2027a37849
+// -0.311733
+0xbfd3f37032752f98
+// -0.522557
+0xbfe0b8c939643b91
+// 0.153453
+0x3fc3a458b66d9472
+// -0.281640
+0xbfd2066569442142
+// 0.222789
+0x3fcc845b23b4350a
+// 0.036850
+0x3fa2de088801bb6e
+// -0.276678
+0xbfd1b51794c9bba7
+// 0.085136
+0x3fb5cb7a5c0fa868
+// -0.615655
+0xbfe3b372679b2c6d
+// -0.187860
+0xbfc80bcd7665b746
+// 0.264839
+0x3fd0f31f3e04fdd7
+// -0.111352
+0xbfbc8191efbddf96
+// -0.332771
+0xbfd54c1f33f77a1e
+// 0.383196
+0x3fd886486a88dbbf
+// 0.164542
+0x3fc50fb7447a5f73
+// -0.739791
+0xbfe7ac5d75eade9a
+// 0.027830
+0x3f9c7f58e75a9510
+// -0.012586
+0xbf89c690bce2c7cd
+// -0.090913
+0xbfb746177579d295
+// -0.250252
+0xbfd0041f2df553c9
+// -0.193818
+0xbfc8cf05405f7c59
+// -0.318014
+0xbfd45a5907ce00ec
+// 0.140674
+0x3fc20199b73046b4
+// -0.160372
+0xbfc4871042ef1b32
+// -0.070327
+0xbfb200ebb2757e6c
+// 0.144143
+0x3fc273461fb56969
+// -0.715851
+0xbfe6e840323e2d1a
+// -0.394189
+0xbfd93a64a5d345db
+// 0.689804
+0x3fe612dff4c4a236
+// -0.028806
+0xbf9d7f500e266e97
+// -0.178273
+0xbfc6d1a8d0ca2bec
+// -0.137700
+0xbfc1a02a1aa1d315
+// 0.083695
+0x3fb56d0f0ea34154
+// 0.041523
+0x3fa5428800327464
+// 0.211472
+0x3fcb11865c9c067c
+// -0.012037
+0xbf88a6e6d3ada702
+// -0.420076
+0xbfdae284b76b097c
+// 0.224070
+0x3fccae501d7e3d2c
+// 0.021078
+0x3f959587959700df
+// -0.306550
+0xbfd39e854ccba1c2
+// -0.336229
+0xbfd584c7db5d6d53
+// 0.015999
+0x3f9061f5dd26904d
+// -0.150048
+0xbfc334c3e9a0f3c4
+// -0.441505
+0xbfdc419ea6314c9a
+// 0.089438
+0x3fb6e56870b415a2
+// -0.461003
+0xbfdd81147280d33e
+// 0.283679
+0x3fd227cb2e3e9d88
+// 0.493981
+0x3fdf9d637a68d5d6
+// 0.075276
+0x3fb3454b3fda0da9
+// 0.619328
+0x3fe3d1886f13e088
+// -0.339307
+0xbfd5b733a2400b7a
+// -0.081907
+0xbfb4f7e0e0550441
+// 0.343737
+0x3fd5ffc826d3c485
+// 0.443697
+0x3fdc6589a6040b1c
+// 0.333817
+0x3fd55d40218d5cc9
+// 0.789057
+0x3fe93ff51be7b355
+// -0.033017
+0xbfa0e7a6e9b2df4b
+// -0.417534
+0xbfdab8e1569431f0
+// -0.228496
+0xbfcd3f5c74f11d24
+// -0.433814
+0xbfdbc39bb2649de9
+// 0.267782
+0x3fd12357b6fe6cf3
+// 0.612523
+0x3fe399ca36d21b92
+// -0.225281
+0xbfccd603ca977810
+// 0.403405
+0x3fd9d16362fba28b
+// 0.362093
+0x3fd72c894d1d8b07
+// -0.135037
+0xbfc148e4ff12a954
+// -0.919197
+0xbfed6a1003b09739
+// -0.090135
+0xbfb71311f1790516
+// 0.338640
+0x3fd5ac4525f06512
+// 0.052311
+0x3faac891dda1ef12
+// 0.351695
+0x3fd6822d23f765dd
+// -0.025773
+0xbf9a643196988f54
+// -0.130141
+0xbfc0a87762f92771
+// 0.658785
+0x3fe514c3e65679ec
+// -0.247844
+0xbfcfb95acadc5d12
+// 0.104156
+0x3fbaa9f6ef7506c8
+// 0.302907
+0x3fd362d55d72da8f
+// -0.016345
+0xbf90bcae5c830d7b
+// -0.173804
+0xbfc63f3975274e50
+// -0.108090
+0xbfbbabc99168d2fd
+// -0.065600
+0xbfb0cb26cd74b50f
+// -0.282265
+0xbfd210a1d0dcbcf7
+// 0.091471
+0x3fb76aab62cf975f
+// 0.793256
+0x3fe9625b439c399d
+// -0.702121
+0xbfe677c68bfbe17c
+// -0.421542
+0xbfdafa89db809578
+// 0.263880
+0x3fd0e369bd1fb256
+// -0.679635
+0xbfe5bf91e53782cf
+// -0.330417
+0xbfd5258ce1bec89e
+// -0.408836
+0xbfda2a5ed2db9b56
+// -0.322080
+0xbfd49cf48c969cef
+// 0.321417
+0x3fd4921806e0e706
+// 0.314624
+0x3fd422cd9b72780c
+// -0.212986
+0xbfcb4322dfae0052
+// 0.978966
+0x3fef53af7b4a8834
+// 0.071948
+0x3fb26b336c7d6163
+// 0.245958
+0x3fcf7b9059a0bc10
+// 0.216415
+0x3fcbb37d77187cfd
+// 0.778429
+0x3fe8e8e4251c5753
+// -0.119361
+0xbfbe8e6c0382e5f1
+// -0.198121
+0xbfc95c04ece2107f
+// -0.112998
+0xbfbced75ea9506dd
+// 0.747056
+0x3fe7e7e2cddf1359
+// -0.290087
+0xbfd290cb01ec1210
+// -0.121982
+0xbfbf3a304d43ce74
+// 0.215042
+0x3fcb867b9509dc59
+// 0.630085
+0x3fe429a81763203a
+// 0.766561
+0x3fe887ab7537b0ab
+// 0.195342
+0x3fc900f8cead94af
+// -0.335998
+0xbfd580fe686fceae
+// 0.062317
+0x3fafe8091df61e87
+// 0.010599
+0x3f85b4e596d00c92
+// -0.286243
+0xbfd251cc5cc44861
+// -0.082675
+0xbfb52a2955dc1fe5
+// -0.564542
+0xbfe210bac1b8e428
+// 0.017220
+0x3f91a205c1140630
+// 0.195544
+0x3fc90795b872392d
+// 0.227443
+0x3fcd1cd7e6b6a901
+// 0.258399
+0x3fd0899c17358c2c
+// -0.479021
+0xbfdea8485a16a1bc
+// 0.112099
+0x3fbcb2818e743378
+// -0.261461
+0xbfd0bbc8d0e845d6
+// -0.413722
+0xbfda7a6b82c8cfaa
+// -0.436175
+0xbfdbea4adba3d94e
+// 0.428774
+0x3fdb7108ca62c054
+// -0.661674
+0xbfe52c6e91cadd37
+// -0.937720
+0xbfee01ce5ab8ec71
+// -0.364457
+0xbfd753427d7e1a92
+// -0.136675
+0xbfc17e8e53eaf88d
+// 0.264998
+0x3fd0f5ba442374d9
+// 0.004403
+0x3f72091534a23395
+// -0.253633
+0xbfd03b84e559d959
+// 0.262363
+0x3fd0ca8d720f86ac
+// 0.917436
+0x3fed5ba1e1edb1db
+// 0.345160
+0x3fd6171b161e4c06
+// 0.053631
+0x3fab758dd990ca06
+// 0.042221
+0x3fa59e05a2541e60
+// -0.381878
+0xbfd870af2bc6e5a2
+// -0.001127
+0xbf5278835f84d77a
+// 0.023251
+0x3f97cf05add297e9
+// 0.035708
+0x3fa2485e0c407692
+// 0.290431
+0x3fd2966cb44a96b0
+// -0.209213
+0xbfcac77dffa45a53
+// -0.041404
+0xbfa532f41f5777e1
+// -0.227447
+0xbfcd1cf8ab728f99
+// 0.388621
+0x3fd8df2a8d666ec5
+// 0.317724
+0x3fd45595401e68e0
+// 0.104591
+0x3fbac67668b5e89d
+// 0.168809
+0x3fc59b856cbf2589
+// -0.023986
+0xbf988fc161e7368b
+// -0.107142
+0xbfbb6daf39b9bbe2
+// 0.323308
+0x3fd4b1156afee53c
+// 0.063600
+0x3fb0481194e3eb98
+// 0.037500
+0x3fa333406d0df713
+// 0.017129
+0x3f918a254064576c
+// 0.037080
+0x3fa2fc36152372fe
+// 0.478469
+0x3fde9f3deec1d8a7
+// 0.542853
+0x3fe15f0da27850a0
+// -0.502527
+0xbfe014b30997865f
+// -0.014575
+0xbf8dd95a5d494c5e
+// -0.269996
+0xbfd1479b758685d4
+// -0.338143
+0xbfd5a423c3d85b7f
+// -0.166138
+0xbfc544008e0ab630
+// 0.088327
+0x3fb69c9e49f0093c
+// 0.663021
+0x3fe537777462fbdd
+// 0.031849
+0x3fa04e8d2772c879
+// -0.013462
+0xbf8b923423db4987
+// 0.254680
+0x3fd04caefa2dcb45
+// 0.200609
+0x3fc9ad909d11868f
+// 0.076999
+0x3fb3b639a3044366
+// 0.128364
+0x3fc06e3e7ef8de6b
+// -0.300778
+0xbfd33ff1e201f88e
+// -0.116070
+0xbfbdb6ca96479162
+// -0.302557
+0xbfd35d18d672b9fe
+// 0.075381
+0x3fb34c279ac4388e
+// -0.149789
+0xbfc32c49fe8e7c13
+// -0.247514
+0xbfcfae8d6a2c0b65
+// 0.002256
+0x3f627a56169e2974
+// -0.029653
+0xbf9e5d7c7bf55252
+// 0.639914
+0x3fe47a2c05468eb8
+// 0.014700
+0x3f8e1b4b44d51bc9
+// -0.399469
+0xbfd990e856a8a87e
+// -0.204377
+0xbfca290733044084
+// -0.100304
+0xbfb9ad8951360fb7
+// 0.031644
+0x3fa033b5073af2d8
+// 0.074196
+0x3fb2fe897492b087
+// 0.507520
+0x3fe03d9a72eb33b1
+// -0.052614
+0xbfaaf03b5ed907b2
+// -0.448415
+0xbfdcb2d4b6893615
+// 0.429359
+0x3fdb7a9cf4a2cdab
+// 0.168861
+0x3fc59d3c3e412b09
+// -0.321861
+0xbfd4995e4f03c321
+// -0.354673
+0xbfd6b2f642b04a51
+// 0.488978
+0x3fdf4b6bb28fd78a
+// 0.522829
+0x3fe0bb02dfdb4209
+// 0.597257
+0x3fe31cbba277681a
+// -0.342574
+0xbfd5ecbbdc64f04f
+// 0.164963
+0x3fc51d850f2437b8
+// -0.028278
+0xbf9cf4fcd9c4c2cf
+// -0.540485
+0xbfe14ba6ad8f0cac
+// -0.338267
+0xbfd5a6294fa2bcef
+// -0.342525
+0xbfd5ebed29444109
+// -0.286845
+0xbfd25bac9e0438be
+// 0.480635
+0x3fdec2bae24c68a2
+// -0.046853
+0xbfa7fd18bece7887
+// 0.389456
+0x3fd8ecdadcd8607a
+// 0.359055
+0x3fd6fac2c18a31f7
+// -0.031104
+0xbf9fd9a5d8fc6610
+// -0.321436
+0xbfd492671c241a42
+// -0.125407
+0xbfc00d548f40e808
+// 0.006534
+0x3f7ac3c5417a3b63
+// 0.211922
+0x3fcb203ea1666c8e
+// 0.624157
+0x3fe3f91846b8b043
+// -0.138609
+0xbfc1bdefbdab86f4
+// 0.045011
+0x3fa70bb1c19bc556
+// -0.539569
+0xbfe14425fcc8dff0
+// -0.684859
+0xbfe5ea5d482242f6
+// -0.439539
+0xbfdc2169183f8730
+// 0.092856
+0x3fb7c56fece5018a
+// 0.221594
+0x3fcc5d315730a0c9
+// 0.358397
+0x3fd6eff914e5faa0
+// -0.334673
+0xbfd56b478ca6b563
+// 0.349307
+0x3fd65b0a9e18bebd
+// 0.281000
+0x3fd1fbe95b6e991c
+// 0.214637
+0x3fcb7939ee1b30ff
+// 0.337286
+0x3fd5961785c01ab9
+// 0.175784
+0x3fc68013d161d386
+// -0.150747
+0xbfc34bac3507491d
+// -0.907140
+0xbfed0749830e4046
+// 0.250608
+0x3fd009f5f718dffb
+// -0.257315
+0xbfd077d898ad1c66
+// -0.486060
+0xbfdf1b9d5f35ebb4
+// 0.235348
+0x3fce1fe2e199371f
+// -0.098314
+0xbfb92b1918cfb784
+// -0.245759
+0xbfcf75091cc5c559
+// 0.038842
+0x3fa3e31f816435a3
+// 0.244403
+0x3fcf489566b006cf
+// 0.182842
+0x3fc7675e707ec8a6
+// 0.082337
+0x3fb51410bdfc0d6b
+// -0.352831
+0xbfd694c73f5553d3
+// 0.469105
+0x3fde05d028f2d40e
+// 0.093880
+0x3fb80889d2b7080d
+// -0.481803
+0xbfded5da43d123ee
+// -0.202644
+0xbfc9f03ac601b7c7
+// 0.111088
+0x3fbc703f775004b5
+// 0.021935
+0x3f9676073fde90d4
+// 0.310103
+0x3fd3d8bbfe0ccac8
+// 0.016068
+0x3f9074396e3860a3
+// 0.435467
+0x3fdbdeb063da29a7
+// 0.263541
+0x3fd0dddaaafc2187
+// 0.368496
+0x3fd79570d7a92a06
+// 0.244325
+0x3fcf4607160661d4
+// -0.086509
+0xbfb62579b6340309
+// 0.304072
+0x3fd375ead0f2386c
+// 0.411268
+0x3fda52355900338e
+// -0.353926
+0xbfd6a6b9281cb93e
+// -0.059618
+0xbfae864e70f06fe3
+// -0.236311
+0xbfce3f6c7261a757
+// -0.469585
+0xbfde0daf3bfe24e8
+// -0.823968
+0xbfea5df2bf7526d2
+// 0.067629
+0x3fb15023f53c8d7e
+// -0.936644
+0xbfedf8fc18dfd81e
+// -0.103334
+0xbfba7414ed4f015d
+// -0.394759
+0xbfd943bcb8f1380c
+// 0.311630
+0x3fd3f1be63bbd62c
+// 0.258961
+0x3fd092d094265adb
+// 0.369148
+0x3fd7a01e8f18b77a
+// 0.420413
+0x3fdae80d93a1377e
+// -0.091107
+0xbfb752c25cd8fcf6
+// 0.270663
+0x3fd1528bda7a1bde
+// 0.282948
+0x3fd21bd0bc97f0a9
+// -0.433490
+0xbfdbbe4edc69371e
+// 0.047168
+0x3fa82675fe122b8a
+// -0.875553
+0xbfec0487fb2f427e
+// -0.008599
+0xbf819c5273a3d190
+// -0.362370
+0xbfd731129021a1d3
+// 0.450056
+0x3fdccdb6a35dc0de
+// -0.624468
+0xbfe3fba3b7eafd4d
+// -0.026183
+0xbf9acfa7d5e6bc0e
+// -0.499744
+0xbfdffbccad2fd84e

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADQ15/AllBiquadCoefs2_q15.txt

@@ -0,0 +1,1658 @@
+H
+828
+// 0.005000
+0x00A4
+// 0.000000
+0x0000
+// 0.007335
+0x00F0
+// 0.005000
+0x00A4
+// -0.005257
+0xFF54
+// -0.000144
+0xFFFB
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.237046
+0xE1A8
+// 0.250000
+0x2000
+// 0.006596
+0x00D8
+// -0.001345
+0xFFD4
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.272213
+0xDD28
+// 0.250000
+0x2000
+// 0.028188
+0x039C
+// -0.001788
+0xFFC5
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.497357
+0x3FA9
+// 0.250000
+0x2000
+// -0.090466
+0xF46C
+// -0.008236
+0xFEF2
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.377127
+0xCFBA
+// 0.250000
+0x2000
+// 0.097374
+0x0C77
+// -0.016475
+0xFDE4
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.493952
+0x3F3A
+// 0.250000
+0x2000
+// -0.150237
+0xECC5
+// -0.025412
+0xFCBF
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.455893
+0xC5A5
+// 0.250000
+0x2000
+// 0.242661
+0x1F10
+// -0.066457
+0xF77E
+// 0.005000
+0x00A4
+// 0.000000
+0x0000
+// -0.009856
+0xFEBD
+// 0.005000
+0x00A4
+// 0.046984
+0x0604
+// -0.002209
+0xFFB8
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.490547
+0xC136
+// 0.250000
+0x2000
+// -0.082685
+0xF56B
+// -0.009832
+0xFEBE
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.437043
+0x37F1
+// 0.250000
+0x2000
+// -0.106605
+0xF25B
+// -0.022855
+0xFD13
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.400205
+0xCCC6
+// 0.250000
+0x2000
+// 0.102502
+0x0D1F
+// -0.042796
+0xFA86
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.006512
+0x00D5
+// 0.250000
+0x2000
+// 0.017973
+0x024D
+// -0.050801
+0xF97F
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.032850
+0xFBCC
+// 0.250000
+0x2000
+// 0.123028
+0x0FBF
+// -0.074250
+0xF67F
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.383759
+0x311F
+// 0.250000
+0x2000
+// -0.227404
+0xE2E4
+// -0.093462
+0xF409
+// 0.005000
+0x00A4
+// 0.000000
+0x0000
+// 0.009718
+0x013E
+// 0.005000
+0x00A4
+// 0.053006
+0x06C9
+// -0.003077
+0xFF9B
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.259205
+0x212E
+// 0.250000
+0x2000
+// -0.060225
+0xF84B
+// -0.006893
+0xFF1E
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.433092
+0x3770
+// 0.250000
+0x2000
+// -0.072188
+0xF6C3
+// -0.007146
+0xFF16
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.252005
+0x2042
+// 0.250000
+0x2000
+// 0.012554
+0x019B
+// -0.023651
+0xFCF9
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.092848
+0x0BE2
+// 0.250000
+0x2000
+// -0.044660
+0xFA49
+// -0.030962
+0xFC09
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.145721
+0xED59
+// 0.250000
+0x2000
+// 0.272512
+0x22E2
+// -0.078467
+0xF5F5
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.327261
+0xD61C
+// 0.250000
+0x2000
+// 0.217482
+0x1BD6
+// -0.094888
+0xF3DB
+// 0.005000
+0x00A4
+// 0.000000
+0x0000
+// -0.005526
+0xFF4B
+// 0.005000
+0x00A4
+// -0.017562
+0xFDC1
+// -0.000309
+0xFFF6
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.499817
+0xC006
+// 0.250000
+0x2000
+// 0.020868
+0x02AC
+// -0.000471
+0xFFF1
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.233689
+0xE216
+// 0.250000
+0x2000
+// -0.027654
+0xFC76
+// -0.001392
+0xFFD2
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.175599
+0xE986
+// 0.250000
+0x2000
+// -0.017265
+0xFDCA
+// -0.003733
+0xFF86
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.431741
+0x3743
+// 0.250000
+0x2000
+// -0.023107
+0xFD0B
+// -0.004673
+0xFF67
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.498066
+0xC03F
+// 0.250000
+0x2000
+// 0.066501
+0x0883
+// -0.005026
+0xFF5B
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.131463
+0xEF2C
+// 0.250000
+0x2000
+// 0.006430
+0x00D3
+// -0.007150
+0xFF16
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.001171
+0x0026
+// 0.250000
+0x2000
+// -0.034482
+0xFB96
+// -0.012750
+0xFE5E
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.051063
+0x0689
+// 0.250000
+0x2000
+// -0.070231
+0xF703
+// -0.021836
+0xFD34
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.299581
+0xD9A7
+// 0.250000
+0x2000
+// 0.125296
+0x100A
+// -0.024211
+0xFCE7
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.144024
+0x126F
+// 0.250000
+0x2000
+// -0.046843
+0xFA01
+// -0.029567
+0xFC37
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.278033
+0x2397
+// 0.250000
+0x2000
+// -0.097810
+0xF37B
+// -0.031223
+0xFC01
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.473564
+0x3C9E
+// 0.250000
+0x2000
+// -0.212571
+0xE4CA
+// -0.047859
+0xF9E0
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.396840
+0x32CC
+// 0.250000
+0x2000
+// -0.173385
+0xE9CF
+// -0.059294
+0xF869
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.419930
+0xCA40
+// 0.250000
+0x2000
+// 0.213461
+0x1B53
+// -0.077598
+0xF611
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.068194
+0x08BB
+// 0.250000
+0x2000
+// -0.051443
+0xF96A
+// -0.097001
+0xF395
+// 0.005000
+0x00A4
+// 0.000000
+0x0000
+// -0.009998
+0xFEB8
+// 0.005000
+0x00A4
+// -0.016602
+0xFDE0
+// -0.000278
+0xFFF7
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.493102
+0xC0E2
+// 0.250000
+0x2000
+// -0.006583
+0xFF28
+// -0.000481
+0xFFF0
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.040990
+0xFAC1
+// 0.250000
+0x2000
+// 0.005094
+0x00A7
+// -0.002639
+0xFFAA
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.030899
+0xFC0C
+// 0.250000
+0x2000
+// -0.030882
+0xFC0C
+// -0.002737
+0xFFA6
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.489646
+0xC153
+// 0.250000
+0x2000
+// 0.072906
+0x0955
+// -0.006878
+0xFF1F
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.024666
+0x0328
+// 0.250000
+0x2000
+// -0.037994
+0xFB23
+// -0.011229
+0xFE90
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.133291
+0x1110
+// 0.250000
+0x2000
+// -0.028938
+0xFC4C
+// -0.011851
+0xFE7C
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.253584
+0x2075
+// 0.250000
+0x2000
+// -0.073578
+0xF695
+// -0.013599
+0xFE42
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.363012
+0x2E77
+// 0.250000
+0x2000
+// -0.146283
+0xED47
+// -0.026424
+0xFC9E
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.049975
+0x0666
+// 0.250000
+0x2000
+// -0.016649
+0xFDDE
+// -0.029265
+0xFC41
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.083853
+0xF544
+// 0.250000
+0x2000
+// 0.057873
+0x0768
+// -0.049236
+0xF9B3
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.314802
+0xD7B5
+// 0.250000
+0x2000
+// 0.129733
+0x109B
+// -0.050820
+0xF97F
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.363838
+0x2E92
+// 0.250000
+0x2000
+// -0.254539
+0xDF6B
+// -0.066270
+0xF784
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.474580
+0xC341
+// 0.250000
+0x2000
+// 0.244090
+0x1F3E
+// -0.083167
+0xF55B
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.110079
+0xF1E9
+// 0.250000
+0x2000
+// 0.123807
+0x0FD9
+// -0.107274
+0xF245
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.465644
+0x3B9A
+// 0.250000
+0x2000
+// -0.296959
+0xD9FD
+// -0.108589
+0xF21A
+// 0.005000
+0x00A4
+// 0.000000
+0x0000
+// -0.009607
+0xFEC5
+// 0.005000
+0x00A4
+// -0.000093
+0xFFFD
+// -0.001837
+0xFFC4
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.490419
+0x3EC6
+// 0.250000
+0x2000
+// -0.055055
+0xF8F4
+// -0.003432
+0xFF90
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.401089
+0xCCA9
+// 0.250000
+0x2000
+// 0.049815
+0x0660
+// -0.007146
+0xFF16
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.425926
+0x3685
+// 0.250000
+0x2000
+// -0.020363
+0xFD65
+// -0.008037
+0xFEF9
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.348149
+0xD370
+// 0.250000
+0x2000
+// 0.046563
+0x05F6
+// -0.010046
+0xFEB7
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.411594
+0x34AF
+// 0.250000
+0x2000
+// -0.018934
+0xFD94
+// -0.015917
+0xFDF6
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.211990
+0xE4DE
+// 0.250000
+0x2000
+// -0.019576
+0xFD7F
+// -0.026567
+0xFC99
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.190612
+0xE79A
+// 0.250000
+0x2000
+// 0.076752
+0x09D3
+// -0.036744
+0xFB4C
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.294733
+0x25BA
+// 0.250000
+0x2000
+// -0.059507
+0xF862
+// -0.040167
+0xFADC
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.483525
+0xC21C
+// 0.250000
+0x2000
+// 0.208106
+0x1AA3
+// -0.045731
+0xFA25
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.167520
+0xEA8F
+// 0.250000
+0x2000
+// 0.086873
+0x0B1F
+// -0.076545
+0xF634
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.148527
+0xECFD
+// 0.250000
+0x2000
+// 0.019523
+0x0280
+// -0.082572
+0xF56E
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.118529
+0xF0D4
+// 0.250000
+0x2000
+// -0.027899
+0xFC6E
+// -0.085604
+0xF50B
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.376804
+0xCFC5
+// 0.250000
+0x2000
+// 0.239061
+0x1E9A
+// -0.102748
+0xF2D9
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.269780
+0x2288
+// 0.250000
+0x2000
+// -0.151362
+0xECA0
+// -0.109160
+0xF207
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.268026
+0x224F
+// 0.250000
+0x2000
+// -0.176543
+0xE967
+// -0.121814
+0xF068
+// 0.005000
+0x00A4
+// 0.000000
+0x0000
+// -0.009076
+0xFED7
+// 0.005000
+0x00A4
+// -0.001432
+0xFFD1
+// -0.000003
+0x0000
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.367616
+0xD0F2
+// 0.250000
+0x2000
+// -0.019603
+0xFD7E
+// -0.000522
+0xFFEF
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.309485
+0x279D
+// 0.250000
+0x2000
+// -0.004670
+0xFF67
+// -0.002344
+0xFFB3
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.497644
+0xC04D
+// 0.250000
+0x2000
+// 0.071115
+0x091A
+// -0.005142
+0xFF57
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.323649
+0x296D
+// 0.250000
+0x2000
+// -0.072173
+0xF6C3
+// -0.005370
+0xFF50
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.321100
+0xD6E6
+// 0.250000
+0x2000
+// 0.053244
+0x06D1
+// -0.009970
+0xFEB9
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.248318
+0x1FC9
+// 0.250000
+0x2000
+// -0.072493
+0xF6B9
+// -0.019759
+0xFD79
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.288830
+0xDB08
+// 0.250000
+0x2000
+// 0.026454
+0x0363
+// -0.024399
+0xFCE0
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.218852
+0x1C03
+// 0.250000
+0x2000
+// -0.047750
+0xF9E3
+// -0.024491
+0xFCDD
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.403408
+0x33A3
+// 0.250000
+0x2000
+// -0.164643
+0xEAED
+// -0.029931
+0xFC2B
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.430368
+0x3716
+// 0.250000
+0x2000
+// -0.188734
+0xE7D8
+// -0.035621
+0xFB71
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.498937
+0x3FDD
+// 0.250000
+0x2000
+// -0.182321
+0xE8AA
+// -0.035843
+0xFB69
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.442050
+0xC76B
+// 0.250000
+0x2000
+// 0.168368
+0x158D
+// -0.040046
+0xFAE0
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.220457
+0xE3C8
+// 0.250000
+0x2000
+// 0.029417
+0x03C4
+// -0.046855
+0xFA01
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.217365
+0xE42D
+// 0.250000
+0x2000
+// 0.032403
+0x0426
+// -0.053013
+0xF937
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.499998
+0xC000
+// 0.250000
+0x2000
+// 0.235431
+0x1E23
+// -0.055553
+0xF8E4
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.139619
+0x11DF
+// 0.250000
+0x2000
+// -0.056288
+0xF8CC
+// -0.065767
+0xF795
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.368222
+0xD0DE
+// 0.250000
+0x2000
+// 0.212415
+0x1B30
+// -0.071593
+0xF6D6
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.387716
+0x31A1
+// 0.250000
+0x2000
+// -0.210855
+0xE503
+// -0.072931
+0xF6AA
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.246637
+0xE06E
+// 0.250000
+0x2000
+// 0.136853
+0x1184
+// -0.075143
+0xF662
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.065459
+0xF79F
+// 0.250000
+0x2000
+// 0.078405
+0x0A09
+// -0.075498
+0xF656
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.340387
+0x2B92
+// 0.250000
+0x2000
+// -0.193062
+0xE74A
+// -0.075620
+0xF652
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.467210
+0x3BCE
+// 0.250000
+0x2000
+// -0.285013
+0xDB85
+// -0.098814
+0xF35A
+// 0.005000
+0x00A4
+// 0.000000
+0x0000
+// 0.009776
+0x0140
+// 0.005000
+0x00A4
+// -0.015254
+0xFE0C
+// -0.000240
+0xFFF8
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.457406
+0x3A8C
+// 0.250000
+0x2000
+// 0.020568
+0x02A2
+// -0.001668
+0xFFC9
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.311925
+0x27ED
+// 0.250000
+0x2000
+// 0.015016
+0x01EC
+// -0.001951
+0xFFC0
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.187737
+0x1808
+// 0.250000
+0x2000
+// 0.032323
+0x0423
+// -0.006178
+0xFF36
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.450611
+0x39AE
+// 0.250000
+0x2000
+// -0.066763
+0xF774
+// -0.006256
+0xFF33
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.174186
+0x164C
+// 0.250000
+0x2000
+// 0.142089
+0x1230
+// -0.021811
+0xFD35
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.229703
+0xE299
+// 0.250000
+0x2000
+// 0.100387
+0x0CD9
+// -0.022709
+0xFD18
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.366644
+0x2EEE
+// 0.250000
+0x2000
+// -0.105653
+0xF27A
+// -0.023292
+0xFD05
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.065144
+0x0857
+// 0.250000
+0x2000
+// 0.011393
+0x0175
+// -0.024999
+0xFCCD
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.380973
+0xCF3C
+// 0.250000
+0x2000
+// 0.190894
+0x186F
+// -0.036593
+0xFB51
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.485236
+0x3E1C
+// 0.250000
+0x2000
+// -0.197332
+0xE6BE
+// -0.042764
+0xFA87
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.130190
+0xEF56
+// 0.250000
+0x2000
+// 0.032329
+0x0423
+// -0.044450
+0xFA4F
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.036768
+0x04B5
+// 0.250000
+0x2000
+// 0.016593
+0x0220
+// -0.062930
+0xF7F2
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.398923
+0xCCF0
+// 0.250000
+0x2000
+// 0.252712
+0x2059
+// -0.068602
+0xF738
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.475280
+0x3CD6
+// 0.250000
+0x2000
+// -0.248040
+0xE040
+// -0.069177
+0xF725
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.492566
+0x3F0C
+// 0.250000
+0x2000
+// -0.271372
+0xDD44
+// -0.074715
+0xF670
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.332056
+0xD57F
+// 0.250000
+0x2000
+// 0.173804
+0x163F
+// -0.077542
+0xF613
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.257587
+0x20F9
+// 0.250000
+0x2000
+// -0.133964
+0xEEDA
+// -0.078619
+0xF5F0
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.213716
+0x1B5B
+// 0.250000
+0x2000
+// -0.132529
+0xEF09
+// -0.082690
+0xF56A
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.258527
+0x2117
+// 0.250000
+0x2000
+// -0.164273
+0xEAF9
+// -0.089454
+0xF48D
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.231357
+0xE263
+// 0.250000
+0x2000
+// 0.145873
+0x12AC
+// -0.091539
+0xF448
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.443459
+0xC73D
+// 0.250000
+0x2000
+// 0.280779
+0x23F1
+// -0.103536
+0xF2BF
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.446637
+0x392B
+// 0.250000
+0x2000
+// -0.291363
+0xDAB5
+// -0.109592
+0xF1F9
+// 0.005000
+0x00A4
+// 0.000000
+0x0000
+// -0.007946
+0xFEFC
+// 0.005000
+0x00A4
+// -0.000241
+0xFFF8
+// -0.000001
+0x0000
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.366295
+0xD11D
+// 0.250000
+0x2000
+// 0.006784
+0x00DE
+// -0.000085
+0xFFFD
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.362789
+0xD190
+// 0.250000
+0x2000
+// 0.023240
+0x02FA
+// -0.001073
+0xFFDD
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.348553
+0xD363
+// 0.250000
+0x2000
+// -0.013081
+0xFE53
+// -0.001474
+0xFFD0
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.399700
+0xCCD7
+// 0.250000
+0x2000
+// 0.053822
+0x06E4
+// -0.003177
+0xFF98
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.328068
+0xD602
+// 0.250000
+0x2000
+// -0.045669
+0xFA28
+// -0.004906
+0xFF5F
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.499396
+0x3FEC
+// 0.250000
+0x2000
+// -0.071598
+0xF6D6
+// -0.007317
+0xFF10
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.488795
+0x3E91
+// 0.250000
+0x2000
+// -0.045864
+0xFA21
+// -0.007325
+0xFF10
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.314290
+0xD7C5
+// 0.250000
+0x2000
+// -0.012512
+0xFE66
+// -0.013380
+0xFE4A
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.158485
+0xEBB7
+// 0.250000
+0x2000
+// -0.025740
+0xFCB5
+// -0.018255
+0xFDAA
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.173301
+0xE9D1
+// 0.250000
+0x2000
+// 0.052782
+0x06C2
+// -0.020104
+0xFD6D
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.149601
+0xECDA
+// 0.250000
+0x2000
+// -0.054328
+0xF90C
+// -0.030633
+0xFC14
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.282333
+0x2423
+// 0.250000
+0x2000
+// -0.169749
+0xEA46
+// -0.054895
+0xF8F9
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.286042
+0x249D
+// 0.250000
+0x2000
+// -0.195655
+0xE6F5
+// -0.057624
+0xF8A0
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.402847
+0x3390
+// 0.250000
+0x2000
+// -0.192503
+0xE75C
+// -0.057743
+0xF89C
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.408440
+0xCBB8
+// 0.250000
+0x2000
+// 0.236245
+0x1E3D
+// -0.058001
+0xF893
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.472607
+0x3C7E
+// 0.250000
+0x2000
+// -0.233385
+0xE220
+// -0.064205
+0xF7C8
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.332243
+0x2A87
+// 0.250000
+0x2000
+// -0.208415
+0xE553
+// -0.089194
+0xF495
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.431032
+0xC8D4
+// 0.250000
+0x2000
+// 0.278871
+0x23B2
+// -0.097432
+0xF387
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.269632
+0x2283
+// 0.250000
+0x2000
+// -0.057206
+0xF8AD
+// -0.118077
+0xF0E3
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.361332
+0xD1C0
+// 0.250000
+0x2000
+// 0.247292
+0x1FA7
+// -0.118386
+0xF0D9
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// 0.165165
+0x1524
+// 0.250000
+0x2000
+// -0.090124
+0xF477
+// -0.120726
+0xF08C
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.497975
+0xC042
+// 0.250000
+0x2000
+// 0.342852
+0x2BE3
+// -0.121858
+0xF067

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADQ15/AllBiquadConfigs2_s16.txt

@@ -0,0 +1,38 @@
+H
+18
+// 7
+0x0007
+// 7
+0x0007
+// 7
+0x0007
+// 16
+0x0010
+// 7
+0x0007
+// 23
+0x0017
+// 16
+0x0010
+// 7
+0x0007
+// 16
+0x0010
+// 16
+0x0010
+// 16
+0x0010
+// 23
+0x0017
+// 23
+0x0017
+// 7
+0x0007
+// 23
+0x0017
+// 16
+0x0010
+// 23
+0x0017
+// 23
+0x0017

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADQ15/AllBiquadInputs2_q15.txt

@@ -0,0 +1,278 @@
+H
+138
+// -0.438785
+0xC7D6
+// 0.125249
+0x1008
+// 1.000000
+0x7FFF
+// 0.668377
+0x558D
+// 0.893413
+0x725B
+// 0.740849
+0x5ED4
+// 0.149008
+0x1313
+// -0.306921
+0xD8B7
+// -0.674752
+0xA9A2
+// -0.287488
+0xDB34
+// 1.000000
+0x7FFF
+// 0.453033
+0x39FD
+// -0.192966
+0xE74D
+// -0.425151
+0xC995
+// -0.291402
+0xDAB3
+// 0.428440
+0x36D7
+// -0.063324
+0xF7E5
+// -0.061245
+0xF829
+// 0.735192
+0x5E1B
+// -0.395625
+0xCD5C
+// -0.120679
+0xF08E
+// -0.347571
+0xD383
+// 0.643543
+0x5260
+// 0.100806
+0x0CE7
+// -0.287963
+0xDB24
+// -0.360145
+0xD1E7
+// 0.722579
+0x5C7D
+// 0.666918
+0x555E
+// -0.723339
+0xA36A
+// -0.444314
+0xC721
+// -0.088378
+0xF4B0
+// 0.526319
+0x435E
+// 0.224851
+0x1CC8
+// -0.161671
+0xEB4E
+// 0.807632
+0x6760
+// -0.906526
+0x8BF7
+// 0.136221
+0x1170
+// 0.375770
+0x3019
+// 0.665306
+0x5529
+// 0.856912
+0x6DAF
+// 0.372519
+0x2FAF
+// -0.811254
+0x9829
+// -0.042923
+0xFA82
+// -0.470472
+0xC3C8
+// -0.128958
+0xEF7E
+// -1.000000
+0x8000
+// 1.000000
+0x7FFF
+// 0.479351
+0x3D5B
+// -0.024396
+0xFCE1
+// 0.563442
+0x481F
+// -0.117786
+0xF0EC
+// -0.095863
+0xF3BB
+// 0.815575
+0x6865
+// -0.058673
+0xF87D
+// 0.658781
+0x5453
+// -0.264294
+0xDE2C
+// -0.281959
+0xDBE9
+// 0.994298
+0x7F45
+// 0.731686
+0x5DA8
+// -0.265512
+0xDE04
+// -0.173510
+0xE9CA
+// 0.772049
+0x62D3
+// 0.043154
+0x0586
+// -0.442225
+0xC765
+// 1.000000
+0x7FFF
+// -0.718894
+0xA3FB
+// -0.440985
+0xC78E
+// -0.533559
+0xBBB4
+// -0.152641
+0xEC76
+// -0.022388
+0xFD22
+// 0.266478
+0x221C
+// 0.228816
+0x1D4A
+// -0.232724
+0xE236
+// 0.146508
+0x12C1
+// 0.283953
+0x2459
+// 0.020604
+0x02A3
+// 0.852249
+0x6D16
+// 1.000000
+0x7FFF
+// -0.077329
+0xF61A
+// -0.202675
+0xE60F
+// 0.190580
+0x1865
+// -0.104340
+0xF2A5
+// -0.030138
+0xFC24
+// -0.454100
+0xC5E0
+// 0.076709
+0x09D2
+// 0.679438
+0x56F8
+// 0.184801
+0x17A8
+// 0.333586
+0x2AB3
+// -0.019330
+0xFD87
+// -0.117516
+0xF0F5
+// 0.075335
+0x09A5
+// -0.201782
+0xE62C
+// 0.182891
+0x1769
+// 0.183392
+0x1779
+// -0.685595
+0xA83E
+// 0.210529
+0x1AF3
+// -0.348426
+0xD367
+// -1.000000
+0x8000
+// 0.199265
+0x1982
+// 0.001203
+0x0027
+// -0.728300
+0xA2C7
+// -0.128003
+0xEF9E
+// -0.202011
+0xE625
+// -0.210634
+0xE50A
+// -1.000000
+0x8000
+// 0.231611
+0x1DA5
+// -0.125683
+0xEFEA
+// -0.539727
+0xBAEA
+// -0.059868
+0xF856
+// -0.623104
+0xB03E
+// 0.707506
+0x5A90
+// -0.003863
+0xFF81
+// 0.000302
+0x000A
+// 0.490431
+0x3EC6
+// 0.051700
+0x069E
+// 0.352565
+0x2D21
+// 0.159328
+0x1465
+// -0.545832
+0xBA22
+// 0.054891
+0x0707
+// 0.423053
+0x3627
+// -0.264662
+0xDE20
+// -0.113813
+0xF16F
+// 0.186395
+0x17DC
+// 0.117373
+0x0F06
+// -0.434604
+0xC85F
+// 0.334879
+0x2ADD
+// 1.000000
+0x7FFF
+// 0.536788
+0x44B5
+// -0.679824
+0xA8FC
+// -0.147325
+0xED24
+// 0.439982
+0x3851
+// 0.483700
+0x3DEA
+// -0.008579
+0xFEE7
+// 0.391348
+0x3218
+// 0.357444
+0x2DC1
+// -0.700641
+0xA651
+// -0.121682
+0xF06D
+// 0.786121
+0x64A0

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADQ15/AllBiquadRefs2_q15.txt

@@ -0,0 +1,278 @@
+H
+138
+// -0.008776
+0xFEE0
+// -0.002572
+0xFFAC
+// 0.033400
+0x0446
+// 0.008559
+0x0118
+// -0.024041
+0xFCEC
+// 0.058168
+0x0772
+// 0.071018
+0x0917
+// -0.006138
+0xFF37
+// 0.004068
+0x0085
+// 0.015499
+0x01FC
+// 0.007158
+0x00EB
+// -0.051335
+0xF96E
+// 0.027774
+0x038E
+// -0.008666
+0xFEE4
+// 0.017252
+0x0235
+// 0.024334
+0x031D
+// -0.008475
+0xFEEA
+// -0.063585
+0xF7DC
+// 0.035584
+0x048E
+// -0.021019
+0xFD4F
+// 0.064468
+0x0840
+// -0.020385
+0xFD64
+// 0.005770
+0x00BD
+// 0.002016
+0x0042
+// 0.005761
+0x00BD
+// -0.004028
+0xFF7C
+// -0.049196
+0xF9B4
+// -0.119852
+0xF0A9
+// -0.160757
+0xEB6C
+// -0.117613
+0xF0F2
+// -0.000339
+0xFFF5
+// 0.127092
+0x1045
+// 0.212748
+0x1B3B
+// 0.252129
+0x2046
+// 0.284607
+0x246E
+// 0.357103
+0x2DB6
+// 0.496051
+0x3F7F
+// 0.692431
+0x58A2
+// 0.923388
+0x7632
+// 1.216365
+0x7FFF
+// 1.678595
+0x7FFF
+// 2.409881
+0x7FFF
+// 3.382085
+0x7FFF
+// 4.398612
+0x7FFF
+// 5.196359
+0x7FFF
+// 5.547155
+0x7FFF
+// 0.020000
+0x028F
+// -0.072781
+0xF6AF
+// 0.183292
+0x1776
+// -0.326165
+0xD640
+// 0.454856
+0x3A39
+// -0.517517
+0xBDC2
+// 0.491308
+0x3EE3
+// -0.001173
+0xFFDA
+// 0.018617
+0x0262
+// -0.082322
+0xF576
+// 0.236195
+0x1E3C
+// -0.532805
+0xBBCD
+// 1.006385
+0x7FFF
+// -1.666576
+0x8000
+// 2.491000
+0x7FFF
+// -3.436925
+0x8000
+// 4.423217
+0x7FFF
+// -5.350349
+0x8000
+// 6.149930
+0x7FFF
+// -6.749644
+0x8000
+// 7.185298
+0x7FFF
+// -7.597907
+0x8000
+// 8.128650
+0x7FFF
+// -0.000448
+0xFFF1
+// 0.006349
+0x00D0
+// -0.008496
+0xFEEA
+// -0.004273
+0xFF74
+// 0.028212
+0x039C
+// -0.016761
+0xFDDB
+// -0.031852
+0xFBEC
+// 0.064543
+0x0843
+// 0.010635
+0x015C
+// -0.101980
+0xF2F2
+// 0.061668
+0x07E5
+// 0.119902
+0x0F59
+// -0.158729
+0xEBAF
+// -0.063296
+0xF7E6
+// 0.252109
+0x2045
+// -0.026012
+0xFCAC
+// -0.333998
+0xD540
+// 0.229394
+0x1D5D
+// 0.319430
+0x28E3
+// -0.437947
+0xC7F1
+// -0.150175
+0xECC7
+// 0.594829
+0x4C23
+// -0.083646
+0xF54B
+// 0.003658
+0x0078
+// -0.006225
+0xFF34
+// -0.012470
+0xFE67
+// 0.044475
+0x05B1
+// -0.050164
+0xF994
+// 0.019171
+0x0274
+// -0.037828
+0xFB28
+// 0.000024
+0x0001
+// -0.014296
+0xFE2C
+// -0.164755
+0xEAE9
+// -0.962863
+0x84C1
+// -3.832286
+0x8000
+// -11.755381
+0x8000
+// -29.844188
+0x8000
+// -65.752547
+0x8000
+// -129.951360
+0x8000
+// -235.761311
+0x8000
+// -398.895635
+0x8000
+// -636.448543
+0x8000
+// -965.541932
+0x8000
+// -1401.721756
+0x8000
+// -1956.876759
+0x8000
+// -2636.639112
+0x8000
+// 0.007051
+0x00E7
+// -0.043981
+0xFA5F
+// 0.121095
+0x0F80
+// -0.154074
+0xEC47
+// -0.013364
+0xFE4A
+// 0.346875
+0x2C66
+// -0.445705
+0xC6F3
+// 0.021179
+0x02B6
+// 0.441838
+0x388E
+// -0.182227
+0xE8AD
+// -0.391544
+0xCDE2
+// -0.099182
+0xF34E
+// 1.556348
+0x7FFF
+// -1.679781
+0x8000
+// -0.464863
+0xC47F
+// 1.942746
+0x7FFF
+// -0.131936
+0xEF1D
+// -2.117151
+0x8000
+// 0.405673
+0x33ED
+// 3.078367
+0x7FFF
+// -2.006506
+0x8000
+// -2.795835
+0x8000
+// 3.173353
+0x7FFF

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADQ15/BiquadCoefs1_q15.txt

@@ -0,0 +1,38 @@
+H
+18
+// 0.005000
+0x00A4
+// 0.000000
+0x0000
+// -0.005403
+0xFF4F
+// 0.005000
+0x00A4
+// 0.436011
+0x37CF
+// -0.202500
+0xE614
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.398042
+0xCD0D
+// 0.250000
+0x2000
+// 0.436717
+0x37E6
+// -0.235225
+0xE1E4
+// 0.250000
+0x2000
+// 0.000000
+0x0000
+// -0.499900
+0xC003
+// 0.250000
+0x2000
+// 0.489388
+0x3EA4
+// -0.240100
+0xE144

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADQ15/BiquadInput1_q15.txt

@@ -0,0 +1,202 @@
+H
+100
+// -0.201820
+0xE62B
+// 0.226299
+0x1CF7
+// 0.390882
+0x3208
+// 0.437376
+0x37FC
+// 0.308615
+0x2781
+// 0.459576
+0x3AD3
+// 0.826631
+0x69CF
+// 0.737139
+0x5E5B
+// 0.342011
+0x2BC7
+// -0.096833
+0xF39B
+// -0.040612
+0xFACD
+// -0.027529
+0xFC7A
+// -0.363291
+0xD180
+// -0.527234
+0xBC84
+// -0.633736
+0xAEE2
+// -0.292267
+0xDA97
+// -0.354919
+0xD292
+// -0.297000
+0xD9FC
+// -0.628031
+0xAF9D
+// -0.421176
+0xCA17
+// -0.040383
+0xFAD5
+// 0.525464
+0x4342
+// 0.313499
+0x2821
+// 0.364979
+0x2EB8
+// 0.495219
+0x3F63
+// 0.551911
+0x46A5
+// 0.609641
+0x4E09
+// 0.469418
+0x3C16
+// 0.191115
+0x1876
+// 0.151041
+0x1355
+// 0.037186
+0x04C3
+// 0.165513
+0x1530
+// -0.304827
+0xD8FB
+// -0.829354
+0x95D8
+// -0.766768
+0x9DDB
+// -0.302856
+0xD93C
+// -0.277153
+0xDC86
+// -0.340152
+0xD476
+// -0.451354
+0xC63A
+// -0.392488
+0xCDC3
+// 0.300745
+0x267F
+// 0.446460
+0x3926
+// 0.295008
+0x25C3
+// 0.389734
+0x31E3
+// 0.557411
+0x4759
+// 0.728735
+0x5D47
+// 0.820707
+0x690D
+// 0.480121
+0x3D75
+// 0.147581
+0x12E4
+// -0.073349
+0xF69C
+// -0.077936
+0xF606
+// 0.026947
+0x0373
+// -0.409518
+0xCB95
+// -1.000000
+0x8000
+// -0.679210
+0xA910
+// -0.577345
+0xB61A
+// -0.265647
+0xDDFF
+// -0.749321
+0xA016
+// -0.454440
+0xC5D5
+// -0.253004
+0xDF9E
+// 0.247237
+0x1FA5
+// 0.438008
+0x3811
+// 0.326718
+0x29D2
+// 0.047677
+0x061A
+// 0.321264
+0x291F
+// 0.679984
+0x570A
+// 0.816575
+0x6886
+// 0.439359
+0x383D
+// 0.145739
+0x12A8
+// 0.169996
+0x15C2
+// -0.203689
+0xE5EE
+// -0.165211
+0xEADA
+// -0.616364
+0xB11B
+// -0.751919
+0x9FC1
+// -0.758867
+0x9EDD
+// -0.508549
+0xBEE8
+// -0.424175
+0xC9B5
+// -0.623196
+0xB03B
+// -0.558179
+0xB88E
+// -0.214204
+0xE495
+// 0.293619
+0x2595
+// 0.729098
+0x5D53
+// 0.293721
+0x2599
+// 0.323087
+0x295B
+// 0.595323
+0x4C34
+// 0.821964
+0x6936
+// 0.713891
+0x5B61
+// 0.170568
+0x15D5
+// 0.060102
+0x07B1
+// 0.042446
+0x056F
+// 0.069761
+0x08EE
+// -0.113229
+0xF182
+// -0.321843
+0xD6CE
+// -0.656349
+0xABFD
+// -0.611454
+0xB1BC
+// -0.425183
+0xC994
+// -0.155001
+0xEC29
+// -0.499939
+0xC002
+// -0.448389
+0xC69B
+// 0.176088
+0x168A

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADQ15/BiquadOutput1_q15.txt

@@ -0,0 +1,202 @@
+H
+100
+// -0.004036
+0xFF7C
+// 0.001393
+0x002E
+// 0.004461
+0x0092
+// 0.012364
+0x0195
+// 0.024526
+0x0324
+// 0.047606
+0x0618
+// 0.081761
+0x0A77
+// 0.119065
+0x0F3E
+// 0.160367
+0x1487
+// 0.201002
+0x19BA
+// 0.239996
+0x1EB8
+// 0.262593
+0x219D
+// 0.259810
+0x2141
+// 0.233605
+0x1DE7
+// 0.176597
+0x169B
+// 0.096571
+0x0C5C
+// -0.012953
+0xFE58
+// -0.132519
+0xEF0A
+// -0.260937
+0xDE9A
+// -0.372137
+0xD05E
+// -0.459233
+0xC538
+// -0.505195
+0xBF56
+// -0.513935
+0xBE37
+// -0.466456
+0xC44B
+// -0.372365
+0xD056
+// -0.242063
+0xE104
+// -0.086222
+0xF4F7
+// 0.076181
+0x09C0
+// 0.227816
+0x1D29
+// 0.356482
+0x2DA1
+// 0.443251
+0x38BC
+// 0.486500
+0x3E46
+// 0.470188
+0x3C2F
+// 0.403043
+0x3397
+// 0.297569
+0x2617
+// 0.163384
+0x14EA
+// 0.007537
+0x00F7
+// -0.145497
+0xED60
+// -0.282594
+0xDBD4
+// -0.390197
+0xCE0E
+// -0.450627
+0xC652
+// -0.472988
+0xC375
+// -0.449262
+0xC67F
+// -0.377527
+0xCFAD
+// -0.270147
+0xDD6C
+// -0.137126
+0xEE73
+// 0.010012
+0x0148
+// 0.152758
+0x138E
+// 0.282536
+0x242A
+// 0.385104
+0x314B
+// 0.451787
+0x39D4
+// 0.476999
+0x3D0E
+// 0.450087
+0x399C
+// 0.376306
+0x302B
+// 0.273625
+0x2306
+// 0.133802
+0x1120
+// -0.018008
+0xFDB2
+// -0.183255
+0xE88B
+// -0.323762
+0xD68F
+// -0.442358
+0xC761
+// -0.516870
+0xBDD7
+// -0.545613
+0xBA29
+// -0.523291
+0xBD05
+// -0.453167
+0xC5FF
+// -0.334485
+0xD530
+// -0.185325
+0xE847
+// -0.019742
+0xFD79
+// 0.143261
+0x1256
+// 0.294044
+0x25A3
+// 0.418294
+0x358B
+// 0.492929
+0x3F18
+// 0.525031
+0x4334
+// 0.496870
+0x3F99
+// 0.423698
+0x363C
+// 0.307754
+0x2764
+// 0.164372
+0x150A
+// 0.003772
+0x007C
+// -0.159331
+0xEB9B
+// -0.303238
+0xD930
+// -0.415642
+0xCACC
+// -0.484389
+0xC200
+// -0.500903
+0xBFE2
+// -0.473861
+0xC359
+// -0.388198
+0xCE50
+// -0.259656
+0xDEC4
+// -0.101845
+0xF2F7
+// 0.068927
+0x08D3
+// 0.233162
+0x1DD8
+// 0.383567
+0x3119
+// 0.497150
+0x3FA3
+// 0.564433
+0x483F
+// 0.577069
+0x49DD
+// 0.537325
+0x44C7
+// 0.445863
+0x3912
+// 0.318443
+0x28C3
+// 0.164983
+0x151E
+// 0.004233
+0x008B
+// -0.157086
+0xEBE5
+// -0.289812
+0xDAE7
+// -0.380861
+0xCF40

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADQ15/Coefs1_q15.txt

@@ -1,42 +1,42 @@
 H
 20
-// -1.000000
-0x8000
-// -0.497313
-0xC058
-// -0.149951
-0xECCE
-// 0.287079
-0x24BF
-// -0.024112
-0xFCEA
-// 0.181298
-0x1735
-// -0.484184
-0xC206
-// -0.035577
-0xFB72
-// 0.025463
-0x0342
-// -0.324390
-0xD67A
-// -0.520730
-0xBD59
-// 0.320475
-0x2905
-// -0.365203
-0xD141
-// 0.824743
-0x6991
-// -0.181475
-0xE8C5
-// -0.311678
-0xD81B
-// 0.562703
-0x4807
-// 0.162688
-0x14D3
-// -0.419049
-0xCA5D
-// 0.340761
-0x2B9E
+// -0.359625
+0xD1F8
+// -0.179755
+0xE8FE
+// 1.000000
+0x7FFF
+// -0.427526
+0xC947
+// 0.490941
+0x3ED7
+// -0.460338
+0xC514
+// -0.063866
+0xF7D3
+// 0.230231
+0x1D78
+// 0.482331
+0x3DBD
+// 0.409560
+0x346C
+// -0.799143
+0x99B6
+// -0.123056
+0xF040
+// 0.036159
+0x04A1
+// 0.000783
+0x001A
+// 0.432804
+0x3766
+// 0.260440
+0x2156
+// -0.589585
+0xB488
+// 0.718567
+0x5BFA
+// 0.324921
+0x2997
+// -0.534426
+0xBB98

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADQ15/Samples1_q15.txt

@@ -1,1026 +1,1026 @@
 H
 512
-// 0.024535
-0x0324
-// -0.331871
-0xD585
-// -0.283628
-0xDBB2
-// 0.129497
-0x1093
-// 0.112154
-0x0E5B
-// -0.830043
-0x95C1
-// 0.100856
-0x0CE9
-// -0.636009
-0xAE97
-// 0.035474
-0x048A
-// -0.326881
-0xD629
-// -0.024158
-0xFCE8
-// -0.250875
-0xDFE3
-// 0.461568
-0x3B15
-// 0.109488
-0x0E04
-// 0.741983
-0x5EF9
-// -0.137286
-0xEE6D
-// -0.142917
-0xEDB5
-// -0.627960
-0xAF9F
-// -0.129406
-0xEF70
-// -0.502218
-0xBFB7
-// -0.159429
-0xEB98
-// -0.122471
-0xF053
-// -0.226579
-0xE2FF
-// -0.336310
-0xD4F4
-// 0.077064
-0x09DD
-// 0.038891
-0x04FA
-// 0.271687
-0x22C7
-// -0.003349
-0xFF92
-// -0.125911
-0xEFE2
-// -0.029972
-0xFC2A
-// -0.470263
-0xC3CE
-// -0.260383
-0xDEAC
-// -0.329150
-0xD5DE
-// 0.293621
-0x2595
-// -0.350508
-0xD323
-// -0.175531
-0xE988
-// 0.712615
-0x5B37
-// -0.320377
-0xD6FE
-// 0.023592
-0x0305
-// -0.386869
-0xCE7B
-// -0.714733
-0xA484
-// 0.283302
-0x2443
-// -0.570672
-0xB6F4
-// 0.028403
-0x03A3
-// -0.076826
-0xF62B
-// -0.457951
-0xC562
-// 0.190885
-0x186F
-// 0.309837
-0x27A9
-// 0.105459
-0x0D80
-// 0.106143
-0x0D96
-// -0.451158
-0xC640
-// -0.191779
-0xE774
-// 0.445019
-0x38F6
-// -0.272809
-0xDD15
-// 0.376095
-0x3024
-// -0.401623
-0xCC98
-// -0.143195
-0xEDAC
-// -0.411288
-0xCB5B
-// 0.103440
-0x0D3E
-// -0.024309
-0xFCE3
-// 0.440561
-0x3864
-// 0.293205
-0x2588
-// -0.074241
-0xF67F
-// -0.400047
-0xCCCB
-// -0.130985
-0xEF3C
-// 0.077209
-0x09E2
-// -0.447311
-0xC6BF
-// -0.324778
-0xD66E
-// 0.449111
-0x397C
-// -0.071522
-0xF6D8
-// 0.297304
-0x260E
-// -0.249392
-0xE014
-// 0.178169
-0x16CE
-// -0.283283
-0xDBBD
-// -0.535660
-0xBB70
-// 0.154400
-0x13C3
-// -0.020130
-0xFD6C
-// 0.181117
-0x172F
-// 0.329445
-0x2A2B
-// 0.370792
-0x2F76
-// 0.046203
-0x05EA
-// -0.426237
-0xC971
-// -0.066158
-0xF788
-// 0.438748
-0x3829
-// -0.091559
-0xF448
-// 0.001339
-0x002C
-// -0.165413
-0xEAD4
-// 0.347072
-0x2C6D
-// 0.140295
-0x11F5
-// -0.471209
-0xC3AF
-// 0.296795
-0x25FD
-// 0.637329
-0x5194
-// -0.438411
-0xC7E2
-// -0.669019
-0xAA5E
-// 0.304019
-0x26EA
-// 0.255934
-0x20C2
-// -0.323732
-0xD690
-// -0.135884
-0xEE9B
-// -0.120489
-0xF094
-// 0.516994
-0x422D
-// -0.382106
-0xCF17
-// 0.501500
-0x4031
-// -0.069551
-0xF719
-// 0.316434
-0x2881
-// 0.596570
-0x4C5C
-// 0.690398
-0x585F
-// 0.333913
-0x2ABE
-// 0.185753
-0x17C7
-// -0.121313
-0xF079
-// 0.843905
-0x6C05
-// 0.143652
-0x1263
-// -0.172541
-0xE9EA
-// -0.286584
-0xDB51
-// -0.272088
-0xDD2C
-// 0.009614
-0x013B
-// -0.015945
-0xFDF6
-// -0.574491
-0xB677
-// 0.664571
-0x5511
-// -0.348436
-0xD366
-// -0.075768
-0xF64D
-// -0.157738
-0xEBCF
-// -0.190456
-0xE79F
-// 0.340140
-0x2B8A
-// -0.398833
-0xCCF3
-// 0.259692
-0x213E
-// -0.442659
-0xC757
+// 0.621154
+0x4F82
+// 0.271249
+0x22B8
+// 0.329181
+0x2A23
+// -0.484058
+0xC20A
+// 0.449058
+0x397B
+// 0.078339
+0x0A07
+// -0.487146
+0xC1A5
+// 0.858511
+0x6DE4
+// -0.026081
+0xFCA9
+// -0.038233
+0xFB1B
+// 0.359881
+0x2E11
+// -0.388645
+0xCE41
+// -0.498756
+0xC029
+// 0.011726
+0x0180
+// -0.107744
+0xF235
+// -0.339509
+0xD48B
+// 0.413639
+0x34F2
+// 0.392875
+0x324A
+// 0.175880
+0x1683
+// 0.284555
+0x246C
+// 0.196170
+0x191C
+// -0.421990
+0xC9FC
+// -0.274592
+0xDCDA
+// -0.140836
+0xEDF9
+// 0.427538
+0x36BA
+// -0.163354
+0xEB17
+// -0.318314
+0xD742
+// -0.025080
+0xFCCA
+// -0.687438
+0xA802
+// -0.130008
+0xEF5C
+// 0.343768
+0x2C01
+// -0.589258
+0xB493
+// 0.397462
+0x32E0
+// -0.132668
+0xEF05
+// 0.012286
+0x0193
+// -0.347736
+0xD37D
+// -0.152444
+0xEC7D
+// -0.134845
+0xEEBD
+// 0.001940
+0x0040
+// 0.121494
+0x0F8D
+// 0.430838
+0x3726
+// 0.226480
+0x1CFD
+// -0.127231
+0xEFB7
+// 0.477021
+0x3D0F
+// 0.225539
+0x1CDE
+// 0.570801
+0x4910
+// 0.149363
+0x131E
+// -0.096313
+0xF3AC
+// 0.305670
+0x2720
+// -0.471359
+0xC3AB
+// -0.228965
+0xE2B1
+// 0.108491
+0x0DE3
+// -0.113366
+0xF17D
+// -0.457507
+0xC570
+// 0.190847
+0x186E
+// -0.007353
+0xFF0F
+// 0.322537
+0x2949
+// -0.655110
+0xAC25
+// 0.551322
+0x4692
+// -0.860661
+0x91D6
+// 0.530226
+0x43DE
+// 0.032154
+0x041E
+// 0.070279
+0x08FF
+// 0.145578
+0x12A2
+// 0.087056
+0x0B25
+// -0.598506
+0xB364
+// -0.388776
+0xCE3D
+// -0.125326
+0xEFF5
+// 0.517799
+0x4247
+// -0.501815
+0xBFC5
+// 0.036137
+0x04A0
+// -0.559973
+0xB853
+// -0.259491
+0xDEC9
+// -0.270746
+0xDD58
+// -0.460474
+0xC50F
+// 0.273309
+0x22FC
+// 0.100748
+0x0CE5
+// -0.220652
+0xE3C2
+// -0.978886
+0x82B4
+// 0.097085
+0x0C6D
+// -0.230986
+0xE26F
+// -0.817631
+0x9758
+// 0.342379
+0x2BD3
+// 0.001055
+0x0023
+// 0.291873
+0x255C
+// -0.183385
+0xE887
+// 0.125014
+0x1000
+// 0.218634
+0x1BFC
+// -0.094472
+0xF3E8
+// -0.222815
+0xE37B
+// 0.122699
+0x0FB5
+// 0.094382
+0x0C15
+// 0.018368
+0x025A
+// -0.269330
+0xDD87
+// 0.878870
+0x707F
+// 0.262129
+0x218D
+// 0.073545
+0x096A
+// 0.070176
+0x08FC
+// -0.235046
+0xE1EA
+// 0.254423
+0x2091
+// -0.034945
+0xFB87
+// -0.125404
+0xEFF3
+// 0.504488
+0x4093
+// 0.047580
+0x0617
+// 0.277928
+0x2393
+// 0.177844
+0x16C4
+// -0.263728
+0xDE3E
+// -0.897034
+0x8D2E
+// -0.275724
+0xDCB5
+// -0.401665
+0xCC96
+// -0.467382
+0xC42D
+// 0.483849
+0x3DEF
+// 0.090217
+0x0B8C
+// -0.225375
+0xE327
+// 0.054138
+0x06EE
+// 0.277700
+0x238C
+// -0.278768
+0xDC51
+// -0.694122
+0xA727
+// 0.226611
+0x1D02
+// 0.485133
+0x3E19
+// -0.230536
+0xE27E
+// -0.132032
+0xEF1A
+// -0.055653
+0xF8E0
+// -0.453842
+0xC5E9
+// 0.155105
+0x13DA
+// -0.002960
+0xFF9F
+// 0.762363
+0x6195
+// -0.513547
+0xBE44
+// -0.543290
+0xBA75
+// 0.752206
+0x6048
+// -0.233051
+0xE22B
+// 0.619401
+0x4F49
+// 0.656155
+0x53FD
+// 0.010170
+0x014D
+// -0.374186
+0xD01B
+// 0.991008
+0x7ED9
+// 0.303759
+0x26E2
+// 0.044957
+0x05C1
+// -0.414468
+0xCAF3
+// -0.355520
+0xD27E
+// -0.627460
+0xAFAF
+// -0.193418
+0xE73E
+// -0.537996
+0xBB23
+// -0.152483
+0xEC7B
+// -0.380519
+0xCF4B
+// 0.229817
+0x1D6B
+// 0.266613
+0x2220
+// -0.511765
+0xBE7E
+// -0.432681
+0xC89E
+// 0.757999
+0x6106
+// -0.338661
+0xD4A7
+// 0.351356
+0x2CF9
+// -0.037899
+0xFB26
+// 0.333243
+0x2AA8
+// -0.267967
+0xDDB3
+// -0.563624
+0xB7DB
+// 0.209317
+0x1ACB
+// 0.426341
+0x3692
+// -0.151048
+0xECAA
+// 0.015307
+0x01F6
+// 0.062233
+0x07F7
+// 0.286490
+0x24AC
+// 0.217783
+0x1BE0
+// -0.025649
+0xFCB8
+// 0.110921
+0x0E33
+// 0.452934
+0x39FA
+// -0.217576
+0xE426
+// -0.106754
+0xF256
+// -0.141288
+0xEDEA
+// -0.151868
+0xEC90
+// -0.356124
+0xD26B
+// 0.307759
+0x2765
+// -0.036457
+0xFB55
+// 0.223302
+0x1C95
+// -0.270681
+0xDD5A
+// -0.180459
+0xE8E7
+// -0.143042
+0xEDB1
+// -0.327808
+0xD60A
+// -0.447244
+0xC6C1
+// 0.366789
+0x2EF3
+// 0.479213
+0x3D57
+// 0.058290
+0x0776
+// 0.767960
+0x624D
+// 0.321786
+0x2930
+// -0.149104
+0xECEA
+// 0.080929
+0x0A5C
+// 0.034953
+0x0479
+// -0.727192
+0xA2EB
+// -0.125018
+0xEFFF
+// -0.374586
+0xD00E
+// 0.460888
+0x3AFE
+// 0.093402
+0x0BF5
+// -0.126855
+0xEFC3
+// 0.316807
+0x288D
+// 0.588119
+0x4B47
+// 0.239684
+0x1EAE
+// 0.485803
+0x3E2F
+// -0.128259
+0xEF95
+// -0.045260
+0xFA35
+// 0.439686
+0x3848
+// -0.089455
+0xF48D
+// -0.362855
+0xD18E
+// -0.011139
+0xFE93
+// 0.462077
+0x3B25
+// 0.125772
+0x1019
+// -0.037648
+0xFB2E
+// 0.035828
+0x0496
+// 0.046611
+0x05F7
+// 0.482471
+0x3DC2
+// -0.106451
+0xF260
+// -0.148020
+0xED0E
+// -0.029545
+0xFC38
+// -0.047277
+0xF9F3
+// 0.145118
+0x1293
+// -0.223822
+0xE35A
+// -0.041716
+0xFAA9
+// -0.553948
+0xB918
+// -0.347642
+0xD380
+// 0.453014
+0x39FC
+// -0.366386
+0xD11A
+// 0.819327
+0x68E0
+// -0.064482
+0xF7BF
+// -0.150323
+0xECC2
+// -0.278787
+0xDC51
+// 0.186633
+0x17E4
+// -0.083846
+0xF545
+// -0.066378
+0xF781
+// 0.536107
+0x449F
+// -0.463012
+0xC4BC
+// -0.655035
+0xAC28
+// 0.426786
+0x36A1
+// -0.210799
+0xE505
+// -0.153011
+0xEC6A
+// 0.047817
+0x061F
+// -0.434000
+0xC873
+// -0.032645
+0xFBD2
+// -0.135918
+0xEE9A
+// 0.848794
+0x6CA5
+// 0.149598
+0x1326
+// 0.320341
+0x2901
+// 0.189408
+0x183F
+// 0.458390
+0x3AAD
+// 0.056930
+0x0749
+// 0.375058
+0x3002
+// 0.164056
+0x1500
+// -0.480722
+0xC278
+// 0.149396
+0x131F
+// -0.250343
+0xDFF5
+// -0.116943
+0xF108
+// -0.091737
+0xF442
+// 0.604485
+0x4D60
+// 0.483703
+0x3DEA
+// -0.210998
+0xE4FE
+// -0.684578
+0xA860
+// 0.074009
+0x0979
+// -0.001035
+0xFFDE
+// 0.352009
+0x2D0F
+// 0.054641
+0x06FE
+// -0.061673
+0xF81B
+// 0.073088
+0x095B
+// -0.209687
+0xE529
+// -0.211805
+0xE4E4
+// 0.300416
+0x2674
+// -0.680620
+0xA8E1
+// 0.174932
+0x1664
+// -0.159861
+0xEB8A
+// -0.983503
+0x821D
+// 0.355952
+0x2D90
+// -0.393358
+0xCDA6
+// 0.139236
+0x11D2
+// -0.154422
+0xEC3C
+// 0.196522
+0x1928
+// -0.034651
+0xFB91
+// -0.024993
+0xFCCD
+// 0.089982
+0x0B85
+// 0.262140
+0x218E
+// 0.694559
+0x58E7
+// -0.116911
+0xF109
+// -0.434046
+0xC871
+// -0.387763
+0xCE5E
 // -1.000000
 0x8000
-// -0.679029
-0xA916
-// -0.182676
-0xE89E
-// -0.011440
-0xFE89
-// -0.316711
-0xD776
-// 0.440627
-0x3866
-// -0.166420
-0xEAB3
-// -0.287082
-0xDB41
-// 0.064602
-0x0845
-// -0.122835
-0xF047
-// 0.304468
-0x26F9
-// -0.371819
-0xD068
-// 0.485516
-0x3E25
-// -0.182563
-0xE8A2
-// -0.340023
-0xD47A
-// 0.560400
-0x47BB
-// -0.050878
-0xF97D
-// -0.281726
-0xDBF0
-// 0.033707
-0x0451
-// -0.078098
-0xF601
-// 0.365298
-0x2EC2
-// 0.170575
-0x15D5
-// 0.071606
-0x092A
-// 0.088096
-0x0B47
-// 0.053959
-0x06E8
-// -0.837761
-0x94C4
-// -0.176514
-0xE968
-// 0.404952
-0x33D5
-// -0.016443
-0xFDE5
-// -0.153851
-0xEC4F
-// 0.695062
-0x58F8
-// 0.048404
-0x0632
-// 0.331321
-0x2A69
-// -0.065326
-0xF7A3
-// -0.663700
-0xAB0C
-// 0.171590
-0x15F7
-// 0.525427
-0x4341
-// 0.335835
-0x2AFD
-// -0.480618
-0xC27B
-// -0.259677
-0xDEC3
-// -0.328617
-0xD5F0
-// -0.414602
-0xCAEE
-// -0.097551
-0xF383
-// 0.074638
-0x098E
-// 0.376680
-0x3037
-// -0.286336
-0xDB59
-// 0.193467
-0x18C4
-// 0.145026
-0x1290
-// 0.565266
-0x485B
-// 0.085396
-0x0AEE
-// 0.396637
-0x32C5
-// -0.406391
-0xCBFB
-// 0.365803
-0x2ED3
-// 0.255702
-0x20BB
-// 0.144572
-0x1281
-// -0.134688
-0xEEC3
-// -0.048217
-0xF9D4
-// -0.136015
-0xEE97
-// -0.354300
-0xD2A6
-// -0.218188
-0xE412
-// -0.216156
-0xE455
-// -0.062435
-0xF802
-// 0.117012
-0x0EFA
-// 0.149823
-0x132D
-// 0.174551
-0x1658
-// -0.266043
-0xDDF2
-// 0.310239
-0x27B6
-// -0.020212
-0xFD6A
-// 0.134713
-0x113E
-// 0.258194
-0x210C
-// -0.474404
-0xC347
-// 0.001887
-0x003E
-// 0.079431
-0x0A2B
-// -0.254378
-0xDF71
-// 0.025181
-0x0339
-// 0.141968
-0x122C
-// -0.063963
-0xF7D0
-// -0.409196
-0xCB9F
-// -0.267686
-0xDDBC
-// 0.045706
-0x05DA
-// -0.025373
-0xFCC1
-// 0.083118
-0x0AA4
-// 0.382907
-0x3103
-// -0.059519
-0xF862
-// -0.170231
-0xEA36
-// -0.072129
-0xF6C4
-// 0.269637
-0x2283
-// 0.416961
-0x355F
-// -0.059869
-0xF856
-// -0.020770
-0xFD57
-// 0.114586
-0x0EAB
-// 0.339269
-0x2B6D
-// 0.306724
-0x2743
-// -0.408848
-0xCBAB
-// -0.189638
-0xE7BA
-// 0.222845
-0x1C86
-// -0.238408
-0xE17C
-// 0.272766
-0x22EA
-// 0.592091
-0x4BCA
-// 0.176319
-0x1692
-// 0.063165
-0x0816
-// -0.382562
-0xCF08
-// 0.051302
-0x0691
-// -0.045814
-0xFA23
-// 0.097849
-0x0C86
-// 0.384826
-0x3142
-// -0.214481
-0xE48C
-// -0.059657
-0xF85D
-// -0.159041
-0xEBA5
-// 0.180622
-0x171F
-// 0.316654
-0x2888
-// -0.206928
-0xE583
-// 0.388251
-0x31B2
-// 0.190708
-0x1869
-// -0.396926
-0xCD32
-// -0.385148
-0xCEB3
-// -0.187457
-0xE801
-// -0.300689
-0xD983
-// -0.096380
-0xF3AA
-// 0.465533
-0x3B97
-// 0.025359
-0x033F
-// 0.430461
-0x3719
-// 0.199262
-0x1981
-// -0.263279
-0xDE4D
-// 0.717633
-0x5BDB
-// 0.210120
-0x1AE5
-// 0.274211
-0x2319
-// 0.210866
-0x1AFE
-// 0.309893
-0x27AB
-// -0.090858
-0xF45F
-// 0.083045
-0x0AA1
-// 0.454908
-0x3A3A
-// -0.081515
-0xF591
-// -0.243639
-0xE0D0
-// 0.186180
-0x17D5
-// -0.175369
-0xE98E
-// -0.279839
-0xDC2E
-// -0.207344
-0xE576
-// -0.069404
-0xF71E
-// 0.169215
-0x15A9
-// 0.636033
-0x516A
-// 0.548182
-0x462B
-// 0.214090
-0x1B67
-// 0.267726
-0x2245
-// 0.057144
-0x0751
-// 0.046585
-0x05F7
-// -0.045403
-0xFA30
-// -0.304509
-0xD906
-// -0.151071
-0xECAA
-// -0.392832
-0xCDB8
-// 0.285776
-0x2494
-// -0.464128
-0xC497
-// -0.296938
-0xD9FE
-// -0.104223
-0xF2A9
-// -0.228140
-0xE2CC
-// 0.125637
-0x1015
-// -0.077327
-0xF61A
-// -0.212801
-0xE4C3
-// -0.004004
-0xFF7D
-// 0.342747
-0x2BDF
-// -0.029561
-0xFC37
-// -0.270635
-0xDD5C
-// 0.474119
-0x3CB0
-// 0.088616
-0x0B58
-// 0.235432
-0x1E23
-// 0.146780
-0x12CA
-// -0.014255
-0xFE2D
-// 0.361634
-0x2E4A
-// -0.289783
-0xDAE8
-// 0.098548
-0x0C9D
-// -0.389846
-0xCE1A
-// -0.008849
-0xFEDE
-// 0.183009
-0x176D
-// -0.262236
-0xDE6F
-// -0.451208
-0xC63F
-// 0.329556
-0x2A2F
-// 0.151944
-0x1373
-// -0.335290
-0xD515
-// 0.139252
-0x11D3
-// 0.131444
-0x10D3
-// -0.392820
-0xCDB8
-// 0.499365
-0x3FEB
-// -0.195252
-0xE702
-// -0.361571
-0xD1B8
-// 0.012904
-0x01A7
-// -0.377235
-0xCFB7
-// -0.502332
-0xBFB4
-// -0.170815
-0xEA23
-// -0.025865
-0xFCB0
-// -0.107890
-0xF231
-// 0.343879
-0x2C04
-// -0.520586
-0xBD5D
-// -0.699320
-0xA67D
-// 0.279055
-0x23B8
-// -0.085136
-0xF51A
-// 0.312712
-0x2807
-// 0.414433
-0x350C
-// 0.051385
-0x0694
-// 0.186399
-0x17DC
-// -0.349102
-0xD351
-// 0.280367
-0x23E3
-// 0.201031
-0x19BB
-// 0.092474
-0x0BD6
-// -0.491240
-0xC11F
-// -0.390562
-0xCE02
-// -0.677818
-0xA93D
-// -0.124859
-0xF005
-// 0.006506
-0x00D5
-// -0.134805
-0xEEBF
-// 0.134421
-0x1135
-// 0.503082
-0x4065
-// -0.007397
-0xFF0E
-// -0.994861
-0x80A8
-// -0.131058
-0xEF39
-// -0.165887
-0xEAC4
-// -0.092585
-0xF426
-// -0.329262
-0xD5DB
-// 0.048605
-0x0639
-// 0.430589
-0x371E
-// 0.051810
-0x06A2
-// -0.366349
-0xD11B
-// -0.504869
-0xBF60
-// 0.007112
+// 0.829100
+0x6A20
+// 0.288367
+0x24E9
+// -0.322309
+0xD6BF
+// -0.254986
+0xDF5D
+// 0.307402
+0x2759
+// -0.116107
+0xF123
+// 0.121772
+0x0F96
+// -0.243014
+0xE0E5
+// 0.032764
+0x0432
+// -0.175044
+0xE998
+// 0.456125
+0x3A62
+// 0.075769
+0x09B3
+// -0.086463
+0xF4EF
+// 0.245881
+0x1F79
+// -0.367046
+0xD105
+// -0.262618
+0xDE63
+// -0.502518
+0xBFAD
+// 0.326722
+0x29D2
+// -0.113513
+0xF178
+// 0.574054
+0x497B
+// -0.319652
+0xD716
+// 0.412587
+0x34D0
+// -0.174333
+0xE9AF
+// -0.102641
+0xF2DD
+// 0.007939
+0x0104
+// 0.310540
+0x27C0
+// -0.435172
+0xC84C
+// 0.552961
+0x46C7
+// -0.042265
+0xFA97
+// -0.374043
+0xD01F
+// 0.061147
+0x07D4
+// -0.057867
+0xF898
+// 0.024274
+0x031B
+// 0.295395
+0x25D0
+// 0.220766
+0x1C42
+// -0.063451
+0xF7E1
+// 0.342285
+0x2BD0
+// -0.197513
+0xE6B8
+// -0.000280
+0xFFF7
+// -0.043036
+0xFA7E
+// 0.356655
+0x2DA7
+// -0.388201
+0xCE4F
+// 0.361345
+0x2E41
+// 0.000077
+0x0003
+// 0.087379
+0x0B2F
+// 0.033550
+0x044B
+// -0.056869
+0xF8B9
+// -0.377608
+0xCFAB
+// 0.223807
+0x1CA6
+// -0.007851
+0xFEFF
+// -0.734910
+0xA1EE
+// 0.285219
+0x2482
+// -0.261600
+0xDE84
+// -0.147306
+0xED25
+// -0.677302
+0xA94E
+// 0.362625
+0x2E6A
+// 0.264192
+0x21D1
+// 0.255832
+0x20BF
+// 0.119184
+0x0F41
+// 0.577166
+0x49E1
+// 0.197659
+0x194D
+// 0.120557
+0x0F6E
+// 0.229352
+0x1D5B
+// 0.159375
+0x1466
+// -0.391926
+0xCDD5
+// 0.371894
+0x2F9A
+// -0.545838
+0xBA22
+// -0.176179
+0xE973
+// 0.262094
+0x218C
+// -0.997717
+0x804B
+// -0.315230
+0xD7A7
+// 0.057462
+0x075B
+// -0.289764
+0xDAE9
+// -0.752620
+0x9FAA
+// -0.094889
+0xF3DB
+// -0.593078
+0xB416
+// -0.583289
+0xB557
+// -0.396234
+0xCD48
+// 0.184110
+0x1791
+// -0.382337
+0xCF10
+// -0.079978
+0xF5C3
+// 0.349904
+0x2CCA
+// -0.344432
+0xD3EA
+// -0.405875
+0xCC0C
+// -0.255057
+0xDF5A
+// 0.221422
+0x1C58
+// 0.159084
+0x145D
+// 0.126156
+0x1026
+// -0.401972
+0xCC8C
+// 0.778884
+0x63B2
+// -0.581435
+0xB594
+// -0.707854
+0xA565
+// -0.171008
+0xEA1C
+// 0.092297
+0x0BD0
+// 0.263938
+0x21C9
+// -0.760675
+0x9EA2
+// 0.076240
+0x09C2
+// 0.324595
+0x298C
+// 0.505292
+0x40AD
+// -0.101395
+0xF305
+// -0.654396
+0xAC3D
+// 0.007122
 0x00E9
-// 0.123231
-0x0FC6
-// -0.071163
-0xF6E4
-// 0.167393
-0x156D
-// -0.169156
-0xEA59
-// 0.383295
-0x3110
-// 0.238700
-0x1E8E
-// 0.006277
-0x00CE
-// 0.522985
-0x42F1
-// -0.172697
-0xE9E5
-// 0.327586
-0x29EE
-// -0.210339
-0xE514
-// 0.107260
-0x0DBB
-// 0.587142
-0x4B27
-// -0.685660
-0xA83C
-// -0.265499
-0xDE04
-// 0.152330
-0x1380
-// -0.109888
-0xF1EF
-// -0.299414
-0xD9AD
-// 0.170125
-0x15C7
-// 0.850248
-0x6CD5
-// -0.294722
-0xDA47
-// 0.318884
-0x28D1
-// -0.525588
-0xBCBA
-// 0.436109
-0x37D2
-// 0.308591
-0x2780
-// -0.133818
-0xEEDF
-// 0.441215
-0x387A
-// -0.241989
-0xE106
-// 0.691397
-0x5880
-// 0.290263
-0x2527
-// 0.602982
-0x4D2F
-// 0.243218
-0x1F22
-// 0.335161
-0x2AE7
-// -0.091440
-0xF44C
-// -0.134973
-0xEEB9
-// -0.094716
-0xF3E0
-// 0.185569
-0x17C1
-// -0.234727
-0xE1F4
-// -0.844038
-0x93F7
-// -0.641083
-0xADF1
-// -0.349661
-0xD33E
-// -0.266980
-0xDDD4
-// -0.052150
-0xF953
-// -0.458297
-0xC557
-// -0.099269
-0xF34B
-// 0.186791
-0x17E9
-// 0.768315
-0x6258
-// 0.064372
-0x083D
-// -0.418275
-0xCA76
-// -0.200591
-0xE653
-// -0.572281
-0xB6BF
-// -0.107770
-0xF235
-// 0.208313
-0x1AAA
-// -0.025468
-0xFCBD
-// 0.314524
-0x2842
-// 0.242587
-0x1F0D
-// -0.284241
-0xDB9E
-// 0.047736
-0x061C
-// -0.470063
-0xC3D5
-// 0.029009
-0x03B7
-// 0.654601
-0x53CA
-// 0.295745
-0x25DB
-// -0.279743
-0xDC31
-// -0.125963
-0xEFE0
-// -0.336424
-0xD4F0
-// 0.450954
-0x39B9
-// 0.484506
-0x3E04
-// 0.025726
-0x034B
-// -0.711983
-0xA4DE
-// 0.478858
-0x3D4B
-// -0.168964
-0xEA5F
-// -0.349739
-0xD33C
-// 0.106706
-0x0DA9
-// 0.383887
-0x3123
-// -0.489560
-0xC156
-// 0.273048
-0x22F3
-// -0.166752
-0xEAA8
-// -0.424526
-0xC9A9
-// 0.025814
-0x034E
-// 0.730037
-0x5D72
-// 0.275657
-0x2349
-// 0.212240
-0x1B2B
-// -0.183065
-0xE891
-// 0.167397
-0x156D
-// -0.101508
-0xF302
-// -0.100775
-0xF31A
-// 0.195956
-0x1915
-// -0.425214
-0xC993
-// -0.047558
-0xF9EA
-// 0.051685
-0x069E
-// 0.074611
-0x098D
-// -0.226743
-0xE2FA
-// -0.622417
-0xB055
-// 0.168173
-0x1587
-// -0.295461
-0xDA2E
-// -0.063931
-0xF7D1
-// 0.330765
-0x2A57
-// 0.441284
-0x387C
-// 0.333814
-0x2ABA
-// 0.207582
-0x1A92
-// 0.311518
-0x27E0
-// -0.304375
-0xD90A
-// -0.287249
-0xDB3B
-// -0.014348
-0xFE2A
-// -0.036741
-0xFB4C
-// 0.046348
-0x05EF
-// -0.085779
-0xF505
-// -0.308558
-0xD881
-// 0.131760
-0x10DE
-// -0.124714
-0xF009
-// 0.046202
-0x05EA
-// 0.562028
-0x47F1
-// 0.271896
-0x22CD
-// -0.488663
-0xC173
-// 0.042397
-0x056D
-// 0.159941
-0x1479
-// -0.034761
-0xFB8D
-// 0.358076
-0x2DD5
-// 0.294653
-0x25B7
-// 0.210662
-0x1AF7
-// -0.097664
-0xF380
-// 0.259552
-0x2139
-// -0.255954
-0xDF3D
-// -0.500223
-0xBFF9
-// -0.182944
-0xE895
-// 0.121973
-0x0F9D
-// -0.746058
-0xA081
-// 0.216305
-0x1BB0
-// -0.231668
-0xE259
-// -0.165048
-0xEAE0
-// -0.391811
-0xCDD9
-// -0.123300
-0xF038
-// -0.182196
-0xE8AE
-// -0.137319
-0xEE6C
-// -0.174049
-0xE9B9
-// -0.176221
-0xE972
-// -0.232498
-0xE23E
-// 0.259834
-0x2142
-// 0.745887
-0x5F79
-// 0.002130
-0x0046
-// -0.284380
-0xDB99
-// -0.597390
-0xB389
-// 0.292316
-0x256B
-// -0.198037
-0xE6A7
-// 0.650549
-0x5345
-// 0.433234
-0x3774
-// -0.379124
-0xCF79
-// -0.302098
-0xD955
-// -0.142993
-0xEDB2
-// -0.016859
-0xFDD8
-// -0.095940
-0xF3B8
-// -0.449173
-0xC682
-// -0.274202
+// 0.611350
+0x4E41
+// -0.123842
+0xF026
+// 0.066745
+0x088B
+// 0.049743
+0x065E
+// 0.302120
+0x26AC
+// 0.218991
+0x1C08
+// 0.243275
+0x1F24
+// 0.572077
+0x493A
+// 0.914625
+0x7512
+// 0.055500
+0x071B
+// 0.498011
+0x3FBF
+// -0.409291
+0xCB9C
+// -0.650207
+0xACC6
+// 0.209182
+0x1AC6
+// 0.247588
+0x1FB1
+// 0.161136
+0x14A0
+// -0.253363
+0xDF92
+// -0.700048
+0xA665
+// -0.345365
+0xD3CB
+// -0.445565
+0xC6F8
+// 0.282824
+0x2434
+// -0.099671
+0xF33E
+// -0.135174
+0xEEB3
+// -0.362572
+0xD197
+// -0.280874
+0xDC0C
+// -0.644074
+0xAD8F
+// -0.028077
+0xFC68
+// 0.221003
+0x1C4A
+// -0.164405
+0xEAF5
+// 0.335082
+0x2AE4
+// 0.498361
+0x3FCA
+// 0.100599
+0x0CE0
+// 0.412631
+0x34D1
+// 0.666983
+0x5560
+// -0.176872
+0xE95C
+// 0.109081
+0x0DF6
+// 0.320572
+0x2909
+// -0.413022
+0xCB22
+// -0.138033
+0xEE55
+// -0.196264
+0xE6E1
+// -0.107691
+0xF237
+// 0.021646
+0x02C5
+// 0.114303
+0x0EA1
+// 0.467723
+0x3BDE
+// -0.356824
+0xD254
+// -0.132334
+0xEF10
+// -0.106531
+0xF25D
+// 0.308941
+0x278B
+// 0.174252
+0x164E
+// -0.251909
+0xDFC1
+// -0.529169
+0xBC44
+// -0.026920
+0xFC8E
+// 0.305951
+0x2729
+// 0.150028
+0x1334
+// 0.182796
+0x1766
+// -0.195342
+0xE6FF
+// -0.331388
+0xD595
+// -0.648995
+0xACEE
+// 0.204165
+0x1A22
+// -0.316288
+0xD784
+// 0.247294
+0x1FA7
+// 0.467308
+0x3BD1
+// -0.709741
+0xA527
+// -0.597968
+0xB376
+// -0.122700
+0xF04B
+// -0.344862
+0xD3DC
+// 0.140169
+0x11F1
+// 0.142397
+0x123A
+// 0.590577
+0x4B98
+// 0.054592
+0x06FD
+// 0.182353
+0x1757
+// 0.515744
+0x4204
+// -0.660655
+0xAB70
+// -0.220154
+0xE3D2
+// 0.116753
+0x0EF2
+// 0.405628
+0x33EC
+// 0.050268
+0x066F
+// -0.246576
+0xE070
+// -0.213024
+0xE4BC
+// 0.418032
+0x3582
+// -0.182011
+0xE8B4
+// 0.011687
+0x017F
+// 0.208362
+0x1AAC
+// -0.205155
+0xE5BD
+// -0.097165
+0xF390
+// 0.003530
+0x0074
+// -0.238927
+0xE16B
+// 0.052313
+0x06B2
+// -0.274210
 0xDCE7
-// 0.480808
-0x3D8B
-// 0.131461
-0x10D4
-// 0.310050
-0x27B0
-// 0.479812
-0x3D6A
-// -0.409230
-0xCB9E
-// 0.391295
-0x3216
-// 0.218312
-0x1BF2
-// -0.280703
-0xDC12
-// -0.349535
-0xD342
-// -0.423201
-0xC9D5
+// 0.445228
+0x38FD
+// -0.354902
+0xD293
+// -0.010782
+0xFE9F
+// -0.244090
+0xE0C2
+// 0.224100
+0x1CAF
+// -0.026600
+0xFC98
+// -0.058123
+0xF88F
+// 0.032813
+0x0433
+// 0.085116
+0x0AE5
+// 0.059970
+0x07AD
+// -0.409607
+0xCB92
+// 0.438069
+0x3813
+// 0.228419
+0x1D3D
+// 0.037831
+0x04D8
+// 0.191617
+0x1887
+// -0.068787
+0xF732
+// 0.087885
+0x0B40
+// -0.083119
+0xF55C
+// -0.001874
+0xFFC3
+// -0.763569
+0x9E43
+// 0.049007
+0x0646
+// 0.161997
+0x14BC
+// -0.608376
+0xB221
+// 0.438565
+0x3823
+// -0.424939
+0xC99C
+// -0.013367
+0xFE4A
+// -0.138781
+0xEE3C
+// 0.042496
+0x0571
+// 0.164803
+0x1518
+// 0.168122
+0x1585
+// -0.372722
+0xD04B
+// -0.400499
+0xCCBC
+// 0.171473
+0x15F3
+// 0.202057
+0x19DD
+// -0.009936
+0xFEBA
+// 0.056639
+0x0740
+// 0.638400
+0x51B7
+// -0.029199
+0xFC43
+// -0.083527
+0xF54F
+// 0.125795
+0x101A

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADQ31/AllBiquadCoefs2_q31.txt

@@ -0,0 +1,662 @@
+W
+330
+// 0.005000
+0x00A3D70A
+// 0.006275
+0x00CD9B32
+// 0.005000
+0x00A3D70A
+// -0.019457
+0xFD826D40
+// -0.005549
+0xFF4A2934
+// 0.250000
+0x20000000
+// -0.101629
+0xF2FDCF16
+// 0.250000
+0x20000000
+// 0.297477
+0x2613B995
+// -0.111682
+0xF1B46579
+// 0.250000
+0x20000000
+// -0.484191
+0xC2060711
+// 0.250000
+0x20000000
+// 0.261044
+0x2169E530
+// -0.120469
+0xF0947601
+// 0.005000
+0x00A3D70A
+// -0.007807
+0xFF002B60
+// 0.005000
+0x00A3D70A
+// 0.039563
+0x0510689E
+// -0.001565
+0xFFCCB5B6
+// 0.250000
+0x20000000
+// 0.423925
+0x36432BBD
+// 0.250000
+0x20000000
+// -0.026396
+0xFC9F0E88
+// -0.001887
+0xFFC22E76
+// 0.250000
+0x20000000
+// -0.306935
+0xD8B65D92
+// 0.250000
+0x20000000
+// 0.031176
+0x03FD9082
+// -0.013491
+0xFE45F048
+// 0.005000
+0x00A3D70A
+// 0.008886
+0x012329B9
+// 0.005000
+0x00A3D70A
+// 0.050901
+0x0683EF99
+// -0.002591
+0xFFAB1965
+// 0.250000
+0x20000000
+// 0.037505
+0x04CCF7C2
+// 0.250000
+0x20000000
+// 0.063807
+0x082AD26C
+// -0.011478
+0xFE87E521
+// 0.250000
+0x20000000
+// -0.487650
+0xC194AD9C
+// 0.250000
+0x20000000
+// 0.197690
+0x194DE4BB
+// -0.039897
+0xFAE4A616
+// 0.005000
+0x00A3D70A
+// -0.009966
+0xFEB96ECA
+// 0.005000
+0x00A3D70A
+// -0.046219
+0xFA157B4A
+// -0.003505
+0xFF8D283F
+// 0.250000
+0x20000000
+// 0.229223
+0x1D572B51
+// 0.250000
+0x20000000
+// -0.059571
+0xF85FFA8F
+// -0.003998
+0xFF7CFE0D
+// 0.250000
+0x20000000
+// 0.218747
+0x1BFFE942
+// 0.250000
+0x20000000
+// -0.032634
+0xFBD2A826
+// -0.057033
+0xF8B3287A
+// 0.250000
+0x20000000
+// -0.385024
+0xCEB78755
+// 0.250000
+0x20000000
+// 0.146905
+0x12CDC815
+// -0.059296
+0xF8690074
+// 0.250000
+0x20000000
+// 0.481501
+0x3DA1D405
+// 0.250000
+0x20000000
+// -0.248474
+0xE03200C6
+// -0.076981
+0xF6257FEF
+// 0.250000
+0x20000000
+// 0.214699
+0x1B7B4285
+// 0.250000
+0x20000000
+// -0.077321
+0xF61A5B15
+// -0.077729
+0xF60CF831
+// 0.250000
+0x20000000
+// 0.470658
+0x3C3E8174
+// 0.250000
+0x20000000
+// -0.257234
+0xDF12F660
+// -0.093847
+0xF3FCCF48
+// 0.250000
+0x20000000
+// -0.107721
+0xF2362FE9
+// 0.250000
+0x20000000
+// 0.107785
+0x0DCBE229
+// -0.109853
+0xF1F0578B
+// 0.005000
+0x00A3D70A
+// -0.009997
+0xFEB869C7
+// 0.005000
+0x00A3D70A
+// -0.000035
+0xFFFEDB08
+// -0.000000
+0xFFFFFFA0
+// 0.250000
+0x20000000
+// -0.440366
+0xC7A217BC
+// 0.250000
+0x20000000
+// -0.036645
+0xFB4F335D
+// -0.005902
+0xFF3E9D1C
+// 0.250000
+0x20000000
+// -0.464743
+0xC4834F72
+// 0.250000
+0x20000000
+// 0.082783
+0x0A98A537
+// -0.007784
+0xFF00F2B4
+// 0.250000
+0x20000000
+// -0.288930
+0xDB04585D
+// 0.250000
+0x20000000
+// 0.060186
+0x07B42B71
+// -0.014234
+0xFE2D91B9
+// 0.250000
+0x20000000
+// -0.277862
+0xDC6F074D
+// 0.250000
+0x20000000
+// -0.174586
+0xE9A72BCD
+// -0.037746
+0xFB2B2316
+// 0.250000
+0x20000000
+// -0.259883
+0xDEBC2672
+// 0.250000
+0x20000000
+// -0.037032
+0xFB428966
+// -0.081181
+0xF59BDFF5
+// 0.250000
+0x20000000
+// -0.128824
+0xEF82B5C0
+// 0.250000
+0x20000000
+// -0.188522
+0xE7DE8532
+// -0.089085
+0xF498DA5A
+// 0.250000
+0x20000000
+// -0.037214
+0xFB3C8E98
+// 0.250000
+0x20000000
+// -0.165643
+0xEACC36CE
+// -0.099499
+0xF343A0D1
+// 0.005000
+0x00A3D70A
+// 0.006461
+0x00D3B707
+// 0.005000
+0x00A3D70A
+// 0.017452
+0x023BDC3F
+// -0.015471
+0xFE050D7F
+// 0.250000
+0x20000000
+// 0.052906
+0x06C59BE8
+// 0.250000
+0x20000000
+// -0.014216
+0xFE2E298A
+// -0.020360
+0xFD64D642
+// 0.250000
+0x20000000
+// 0.011523
+0x0179983C
+// 0.250000
+0x20000000
+// 0.171343
+0x15EE9458
+// -0.031070
+0xFC05E5C0
+// 0.250000
+0x20000000
+// -0.378292
+0xCF94227F
+// 0.250000
+0x20000000
+// 0.175702
+0x167D6843
+// -0.031147
+0xFC035EA4
+// 0.250000
+0x20000000
+// -0.418630
+0xCA6A52DA
+// 0.250000
+0x20000000
+// 0.212099
+0x1B260C81
+// -0.049879
+0xF99D8F62
+// 0.250000
+0x20000000
+// -0.244886
+0xE0A796A4
+// 0.250000
+0x20000000
+// 0.119364
+0x0F4755B7
+// -0.058714
+0xF87C1228
+// 0.250000
+0x20000000
+// 0.415234
+0x35266491
+// 0.250000
+0x20000000
+// -0.242908
+0xE0E861D1
+// -0.068097
+0xF7489746
+// 0.250000
+0x20000000
+// 0.372526
+0x2FAEF21C
+// 0.250000
+0x20000000
+// -0.194514
+0xE71A26AF
+// -0.069102
+0xF727AAED
+// 0.005000
+0x00A3D70A
+// -0.008811
+0xFEDF4A2A
+// 0.005000
+0x00A3D70A
+// 0.013802
+0x01C44489
+// -0.000548
+0xFFEE0B5E
+// 0.250000
+0x20000000
+// -0.392011
+0xCDD29844
+// 0.250000
+0x20000000
+// -0.099166
+0xF34E832E
+// -0.020143
+0xFD6BF13C
+// 0.250000
+0x20000000
+// -0.359576
+0xD1F96DB5
+// 0.250000
+0x20000000
+// -0.150459
+0xECBDC422
+// -0.027240
+0xFC836762
+// 0.250000
+0x20000000
+// -0.242043
+0xE104BED9
+// 0.250000
+0x20000000
+// 0.078771
+0x0A152D89
+// -0.027326
+0xFC80925C
+// 0.250000
+0x20000000
+// 0.162035
+0x14BD9229
+// 0.250000
+0x20000000
+// -0.166027
+0xEABFA2EC
+// -0.028923
+0xFC4C4463
+// 0.250000
+0x20000000
+// 0.296552
+0x25F56C5D
+// 0.250000
+0x20000000
+// -0.116415
+0xF1195295
+// -0.035316
+0xFB7ABFCC
+// 0.250000
+0x20000000
+// -0.498708
+0xC02A54F0
+// 0.250000
+0x20000000
+// 0.196084
+0x19194961
+// -0.038768
+0xFB09AA3C
+// 0.250000
+0x20000000
+// -0.487123
+0xC1A5F4ED
+// 0.250000
+0x20000000
+// 0.238528
+0x1E881725
+// -0.058249
+0xF88B49CA
+// 0.250000
+0x20000000
+// 0.495489
+0x3F6C2C18
+// 0.250000
+0x20000000
+// -0.252563
+0xDFAC060D
+// -0.064392
+0xF7C202CC
+// 0.250000
+0x20000000
+// 0.476645
+0x3D02B3E7
+// 0.250000
+0x20000000
+// -0.231966
+0xE24EF12F
+// -0.080259
+0xF5BA137A
+// 0.250000
+0x20000000
+// -0.381540
+0xCF29AFCA
+// 0.250000
+0x20000000
+// 0.266720
+0x2223DFCB
+// -0.122459
+0xF0534760
+// 0.005000
+0x00A3D70A
+// 0.002040
+0x0042D768
+// 0.005000
+0x00A3D70A
+// 0.011096
+0x016B9B50
+// -0.000295
+0xFFF65454
+// 0.250000
+0x20000000
+// 0.034238
+0x0461E7F4
+// 0.250000
+0x20000000
+// 0.018834
+0x02692AB5
+// -0.001008
+0xFFDEF893
+// 0.250000
+0x20000000
+// 0.121612
+0x0F90FAC7
+// 0.250000
+0x20000000
+// -0.024029
+0xFCEC9D99
+// -0.003355
+0xFF9213B3
+// 0.250000
+0x20000000
+// -0.053748
+0xF91EC4FF
+// 0.250000
+0x20000000
+// 0.087103
+0x0B263214
+// -0.011634
+0xFE82C650
+// 0.250000
+0x20000000
+// 0.123428
+0x0FCC7CD9
+// 0.250000
+0x20000000
+// -0.116593
+0xF1137AC6
+// -0.015810
+0xFDF9EE0E
+// 0.250000
+0x20000000
+// -0.055213
+0xF8EEC3DC
+// 0.250000
+0x20000000
+// 0.129635
+0x1097E15E
+// -0.017307
+0xFDC8E11F
+// 0.250000
+0x20000000
+// 0.263980
+0x21CA14F2
+// 0.250000
+0x20000000
+// -0.169406
+0xEA50E5D1
+// -0.037014
+0xFB43237B
+// 0.250000
+0x20000000
+// 0.499193
+0x3FE58F25
+// 0.250000
+0x20000000
+// -0.191926
+0xE76EFA3F
+// -0.038134
+0xFB1E6E77
+// 0.250000
+0x20000000
+// 0.372053
+0x2F9F710A
+// 0.250000
+0x20000000
+// -0.179254
+0xE90E385F
+// -0.054159
+0xF9115258
+// 0.250000
+0x20000000
+// -0.498555
+0xC02F5BE9
+// 0.250000
+0x20000000
+// 0.284338
+0x24653090
+// -0.084022
+0xF53EC106
+// 0.250000
+0x20000000
+// -0.197296
+0xE6BEFD89
+// 0.250000
+0x20000000
+// 0.180676
+0x1720644B
+// -0.094446
+0xF3E931FC
+// 0.005000
+0x00A3D70A
+// 0.007918
+0x01037150
+// 0.005000
+0x00A3D70A
+// -0.020991
+0xFD502D0C
+// -0.000496
+0xFFEFC307
+// 0.250000
+0x20000000
+// -0.001082
+0xFFDC8AAF
+// 0.250000
+0x20000000
+// 0.016376
+0x02189DBD
+// -0.002910
+0xFFA0A7D9
+// 0.250000
+0x20000000
+// 0.497340
+0x3FA8D47C
+// 0.250000
+0x20000000
+// -0.052078
+0xF9557E15
+// -0.003052
+0xFF9BFA99
+// 0.250000
+0x20000000
+// -0.499002
+0xC020B03D
+// 0.250000
+0x20000000
+// 0.080339
+0x0A488E43
+// -0.008263
+0xFEF13CB7
+// 0.250000
+0x20000000
+// -0.061886
+0xF8141B87
+// 0.250000
+0x20000000
+// 0.049334
+0x06509133
+// -0.013298
+0xFE4C4160
+// 0.250000
+0x20000000
+// 0.200663
+0x19AF50B3
+// 0.250000
+0x20000000
+// -0.050624
+0xF98524B3
+// -0.015201
+0xFE0DE801
+// 0.250000
+0x20000000
+// -0.408533
+0xCBB52FE3
+// 0.250000
+0x20000000
+// 0.145736
+0x12A77C97
+// -0.027718
+0xFC73C0AA
+// 0.250000
+0x20000000
+// 0.287281
+0x24C5A028
+// 0.250000
+0x20000000
+// -0.165853
+0xEAC554FD
+// -0.065972
+0xF78E3C42
+// 0.250000
+0x20000000
+// -0.420586
+0xCA2A3EAC
+// 0.250000
+0x20000000
+// 0.258912
+0x21240872
+// -0.085180
+0xF518D234
+// 0.250000
+0x20000000
+// 0.421933
+0x3601E2F2
+// 0.250000
+0x20000000
+// -0.262919
+0xDE58ABAD
+// -0.100050
+0xF3318F63
+// 0.250000
+0x20000000
+// -0.382565
+0xCF08204F
+// 0.250000
+0x20000000
+// 0.238971
+0x1E9696E8
+// -0.112142
+0xF1A554BC

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADQ31/AllBiquadConfigs2_s16.txt

@@ -0,0 +1,38 @@
+H
+18
+// 3
+0x0003
+// 3
+0x0003
+// 3
+0x0003
+// 8
+0x0008
+// 3
+0x0003
+// 11
+0x000B
+// 8
+0x0008
+// 3
+0x0003
+// 8
+0x0008
+// 8
+0x0008
+// 8
+0x0008
+// 11
+0x000B
+// 11
+0x000B
+// 3
+0x0003
+// 11
+0x000B
+// 8
+0x0008
+// 11
+0x000B
+// 11
+0x000B

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADQ31/AllBiquadInputs2_q31.txt

@@ -0,0 +1,134 @@
+W
+66
+// -0.376544
+0xCFCD69E9
+// 0.870654
+0x6F7196A5
+// 1.000000
+0x7FFFFFFF
+// 0.070037
+0x08F6FA8F
+// 0.424359
+0x365162BC
+// -0.760026
+0x9EB77B3F
+// 0.693101
+0x58B78CA9
+// -0.566173
+0xB787A702
+// 0.450168
+0x399F1830
+// 1.000000
+0x7FFFFFFF
+// 0.386696
+0x317F3E6A
+// 1.000000
+0x7FFFFFFF
+// 0.117713
+0x0F113BE1
+// 0.256256
+0x20CCFBDB
+// -0.364327
+0xD15DB7CF
+// 0.463394
+0x3B507E2F
+// -0.518987
+0xBD91D60C
+// -0.018133
+0xFDADD588
+// -0.124172
+0xF01B2319
+// 0.079136
+0x0A21231F
+// 0.287698
+0x24D34D05
+// 0.204968
+0x1A3C6433
+// 0.917457
+0x756F3B55
+// -1.000000
+0x80000000
+// -0.687386
+0xA803BAE6
+// -0.121138
+0xF07E8D1F
+// -0.850806
+0x9318C647
+// -1.000000
+0x80000000
+// -0.407560
+0xCBD5171E
+// -0.205071
+0xE5C03ECF
+// -0.096672
+0xF3A04490
+// -0.621282
+0xB079D8DF
+// -0.166016
+0xEABFF960
+// 0.092381
+0x0BD3247D
+// 0.351918
+0x2D0BA9E6
+// 0.980177
+0x7D766D7E
+// 0.509106
+0x412A6676
+// 0.111844
+0x0E50EABA
+// 0.590812
+0x4B9FB90B
+// -1.000000
+0x80000000
+// -0.686672
+0xA81B2026
+// -0.713068
+0xA4BA2F2C
+// 0.067961
+0x08B2EFA1
+// 0.449181
+0x397EC480
+// -0.839026
+0x949ACDDA
+// 1.000000
+0x7FFFFFFF
+// -0.009718
+0xFEC18D07
+// 0.360962
+0x2E340157
+// 0.181966
+0x174AACC6
+// 0.079150
+0x0A2199F1
+// -0.457283
+0xC577C3B8
+// 0.686644
+0x57E3F3F9
+// -0.070322
+0xF6FFADA8
+// 1.000000
+0x7FFFFFFF
+// 0.065828
+0x086D0FE3
+// 0.214005
+0x1B6485AC
+// 0.776120
+0x6357EA88
+// 0.111056
+0x0E371862
+// -1.000000
+0x80000000
+// -0.907342
+0x8BDC3762
+// -0.331154
+0xD59CBFDA
+// 0.158814
+0x1454053D
+// -0.044871
+0xFA41A7F8
+// -0.275403
+0xDCBF9BE7
+// -0.173892
+0xE9BDE972
+// -0.058313
+0xF8893074

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADQ31/AllBiquadRefs2_q31.txt

@@ -0,0 +1,134 @@
+W
+66
+// -0.007531
+0xFF093A70
+// 0.009371
+0x013310C4
+// 0.030086
+0x03D9DA4B
+// 0.001401
+0x002DE64B
+// 0.007204
+0x00EC0EBF
+// -0.023022
+0xFD0D9FF1
+// 0.029070
+0x03B892FB
+// -0.013535
+0xFE447D32
+// 0.003728
+0x007A266C
+// 0.013578
+0x01BCEA13
+// 0.005366
+0x00AFD3CB
+// 0.020000
+0x028F5C29
+// 0.026877
+0x0370B34E
+// 0.016192
+0x02129766
+// -0.013205
+0xFE4F487E
+// -0.026936
+0xFC8D5876
+// -0.034795
+0xFB8BD690
+// -0.012260
+0xFE6E45D6
+// 0.005622
+0x00B83BC9
+// 0.017953
+0x024C4488
+// 0.022434
+0x02DF1A46
+// 0.032210
+0x041F78CA
+// 0.018349
+0x025943BF
+// -0.008475
+0xFEEA4666
+// -0.033742
+0xFBAE5953
+// -0.002423
+0xFFB09C6C
+// 0.010673
+0x015DBA3F
+// 0.015609
+0x01FF7931
+// -0.289873
+0xDAE5747B
+// 1.318860
+0x7FFFFFFF
+// -3.715964
+0x80000000
+// 7.490299
+0x7FFFFFFF
+// -11.172033
+0x80000000
+// 0.001848
+0x003C8AF8
+// 0.009830
+0x01421D59
+// 0.036015
+0x049C20EB
+// 0.068062
+0x08B63F51
+// 0.112992
+0x0E7689A2
+// 0.162827
+0x14D785AD
+// 0.203362
+0x1A07C287
+// 0.242335
+0x1F04D216
+// 0.256870
+0x20E11DF2
+// 0.288071
+0x24DF86A1
+// 0.271145
+0x22B4DD79
+// -0.016781
+0xFDDA22D6
+// 0.126959
+0x104034A3
+// -0.432734
+0xC89C2C9F
+// 0.007219
+0x00EC8F63
+// 0.025071
+0x0335836C
+// 0.081985
+0x0A7E7DB9
+// 0.163806
+0x14F7962B
+// 0.308868
+0x2788FB04
+// 0.421859
+0x35FF79E7
+// 0.564783
+0x484AD25F
+// 0.566204
+0x48795DDE
+// 0.004280
+0x008C401D
+// 0.020087
+0x029239AF
+// 0.020077
+0x0291E339
+// -0.016634
+0xFDDEF259
+// -0.054988
+0xF8F627A7
+// -0.041523
+0xFAAF5E9A
+// 0.022065
+0x02D30604
+// 0.062931
+0x080E1F79
+// 0.024769
+0x032B9FD9
+// -0.071258
+0xF6E102AC
+// -0.124414
+0xF013351E

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADQ31/BiquadCoefs1_q31.txt

@@ -0,0 +1,32 @@
+W
+15
+// 0.005000
+0x00A3D70A
+// -0.005403
+0xFF4EF428
+// 0.005000
+0x00A3D70A
+// 0.436011
+0x37CF31EC
+// -0.202500
+0xE6147AE1
+// 0.250000
+0x20000000
+// -0.398042
+0xCD0CF68A
+// 0.250000
+0x20000000
+// 0.436717
+0x37E6566B
+// -0.235225
+0xE1E425AF
+// 0.250000
+0x20000000
+// -0.499900
+0xC00346D5
+// 0.250000
+0x20000000
+// 0.489388
+0x3EA440F8
+// -0.240100
+0xE1446738

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADQ31/BiquadInput1_q31.txt

@@ -0,0 +1,202 @@
+W
+100
+// -0.040100
+0xFADDFE77
+// 0.114333
+0x0EA273ED
+// 0.092315
+0x0BD0FC38
+// 0.066698
+0x08898E81
+// 0.069797
+0x08EF1C4C
+// 0.157793
+0x14328DAF
+// 0.188593
+0x1823D2CE
+// 0.166066
+0x1541A8EA
+// 0.027289
+0x037E311A
+// -0.027648
+0xFC7605F2
+// 0.002294
+0x004B29CE
+// 0.014728
+0x01E29C62
+// -0.070237
+0xF70276E2
+// -0.178132
+0xE932FAD3
+// -0.215720
+0xE4634C76
+// -0.131458
+0xEF2C621A
+// -0.039218
+0xFAFAE809
+// -0.100029
+0xF3323DEA
+// -0.093063
+0xF4168628
+// -0.058508
+0xF882CF6E
+// -0.034215
+0xFB9EDAD9
+// 0.078037
+0x09FD1E7C
+// 0.135521
+0x1158BDE2
+// 0.073741
+0x09705BAE
+// 0.063266
+0x08191B4B
+// 0.139260
+0x11D344D0
+// 0.172452
+0x1612EB38
+// 0.126235
+0x10287678
+// 0.055055
+0x070C0BBE
+// -0.008611
+0xFEE5D5A4
+// -0.005580
+0xFF492B6A
+// 0.004446
+0x0091B040
+// -0.069138
+0xF7268050
+// -0.143607
+0xED9E461B
+// -0.128616
+0xEF897FBE
+// -0.160434
+0xEB76E328
+// -0.081085
+0xF59EFE50
+// -0.095875
+0xF3BA5F0F
+// -0.139700
+0xEE1E538F
+// -0.030817
+0xFC0E2D07
+// 0.065929
+0x08705B78
+// 0.130769
+0x10BD0D5E
+// 0.110305
+0x0E1E7D5D
+// 0.111328
+0x0E3FFE2F
+// 0.122101
+0x0FA10156
+// 0.169422
+0x15AF9D24
+// 0.172294
+0x160DB7E0
+// 0.044078
+0x05A456DD
+// -0.007798
+0xFF00781F
+// -0.024147
+0xFCE8BDB7
+// 0.028870
+0x03B203B0
+// -0.014966
+0xFE1597A9
+// -0.097327
+0xF38AC784
+// -0.176275
+0xE96FD3AB
+// -0.196950
+0xE6CA5B52
+// -0.082305
+0xF57704C5
+// -0.071087
+0xF6E69EF4
+// -0.099001
+0xF353EF51
+// -0.091535
+0xF448915C
+// -0.026485
+0xFC9C26E1
+// 0.013840
+0x01C57FFE
+// 0.068706
+0x08CB5E29
+// 0.069525
+0x08E62F2F
+// 0.057027
+0x074CAD4B
+// 0.108258
+0x0DDB6738
+// 0.148480
+0x13016785
+// 0.141675
+0x122268F7
+// 0.111709
+0x0E4C79FC
+// 0.013186
+0x01B0124E
+// 0.000895
+0x001D55C6
+// -0.000653
+0xFFEA9D84
+// -0.009739
+0xFEC0E1A6
+// -0.119914
+0xF0A6A839
+// -0.250000
+0xE0000000
+// -0.158299
+0xEBBCD972
+// -0.067746
+0xF75417CA
+// -0.110366
+0xF1DF8924
+// -0.135593
+0xEEA4E456
+// -0.098202
+0xF36E1BCF
+// 0.038917
+0x04FB3AC5
+// 0.082673
+0x0A950600
+// 0.079453
+0x0A2B8308
+// 0.043835
+0x059C65D0
+// 0.070943
+0x0914A8B0
+// 0.107450
+0x0DC0E9FA
+// 0.173917
+0x1642E8B6
+// 0.200381
+0x19A61684
+// 0.035576
+0x048DBDE6
+// 0.022680
+0x02E72D9C
+// 0.062804
+0x0809F249
+// -0.008478
+0xFEEA3514
+// -0.082872
+0xF56476AF
+// -0.149955
+0xECCE4562
+// -0.145249
+0xED687941
+// -0.118181
+0xF0DF6E7A
+// -0.087923
+0xF4BEF417
+// -0.073454
+0xF69912C1
+// -0.132931
+0xEEFC1FCD
+// -0.110165
+0xF1E61AD3
+// 0.011695
+0x017F3C5E

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADQ31/BiquadOutput1_q31.txt

@@ -0,0 +1,202 @@
+W
+100
+// -0.000802
+0xFFE5B84A
+// 0.001664
+0x0036888B
+// 0.002256
+0x0049ECB0
+// 0.004641
+0x009813B7
+// 0.008718
+0x011DAAF3
+// 0.015481
+0x01FB46FD
+// 0.023367
+0x02FDAE58
+// 0.032912
+0x0436785F
+// 0.041932
+0x055E0AB3
+// 0.051382
+0x0693AD4E
+// 0.059140
+0x0791E722
+// 0.062772
+0x0808E8A2
+// 0.060257
+0x07B68137
+// 0.051172
+0x068CD1FF
+// 0.035312
+0x04851B67
+// 0.013565
+0x01BC8271
+// -0.013479
+0xFE465530
+// -0.045053
+0xFA3BB7B7
+// -0.074825
+0xF66C20B0
+// -0.100937
+0xF3147E66
+// -0.120702
+0xF08CD5CD
+// -0.129415
+0xEF6F5163
+// -0.126945
+0xEFC04633
+// -0.113461
+0xF17A1A33
+// -0.087975
+0xF4BD3B6E
+// -0.052949
+0xF938F9B5
+// -0.013312
+0xFE4BCA4E
+// 0.026931
+0x037277C9
+// 0.064047
+0x0832B364
+// 0.093783
+0x0C01173F
+// 0.113604
+0x0E8A964D
+// 0.121030
+0x0F7DEC60
+// 0.114674
+0x0EADA449
+// 0.096545
+0x0C5B987C
+// 0.069620
+0x08E95093
+// 0.034691
+0x0470BF8B
+// -0.001576
+0xFFCC5E98
+// -0.038414
+0xFB1542D0
+// -0.071191
+0xF6E33A38
+// -0.094636
+0xF3E2F7FB
+// -0.108968
+0xF20D52CB
+// -0.112168
+0xF1A47E25
+// -0.104708
+0xF298EAD1
+// -0.086259
+0xF4F57A89
+// -0.059460
+0xF8639A34
+// -0.026309
+0xFCA1E9ED
+// 0.009343
+0x01322383
+// 0.042847
+0x057C00E3
+// 0.073373
+0x09644984
+// 0.096428
+0x0C57C203
+// 0.110772
+0x0E2DC377
+// 0.113170
+0x0E7C5EF2
+// 0.104498
+0x0D6030B3
+// 0.085289
+0x0AEABDC1
+// 0.057381
+0x07583EDD
+// 0.024849
+0x032E3DB2
+// -0.011815
+0xFE7CD5A8
+// -0.047302
+0xF9F1FF4A
+// -0.077608
+0xF610EFB5
+// -0.099825
+0xF338EE14
+// -0.112853
+0xF18E071C
+// -0.114433
+0xF15A45C1
+// -0.105547
+0xF27D6C88
+// -0.086826
+0xF4E2E101
+// -0.059420
+0xF864EB58
+// -0.027053
+0xFC898475
+// 0.007144
+0x00EA19A8
+// 0.040442
+0x052D3732
+// 0.068599
+0x08C7DC2D
+// 0.090979
+0x0BA5311A
+// 0.104348
+0x0D5B45B2
+// 0.108065
+0x0DD510DA
+// 0.100625
+0x0CE14469
+// 0.083138
+0x0AA44366
+// 0.059970
+0x07AD178E
+// 0.030277
+0x03E01B2E
+// -0.003898
+0xFF804863
+// -0.037232
+0xFB3BFA46
+// -0.066880
+0xF77079EF
+// -0.089201
+0xF4951351
+// -0.103902
+0xF2B354C4
+// -0.107928
+0xF22F6899
+// -0.101040
+0xF3111EF9
+// -0.082934
+0xF5626F1F
+// -0.056249
+0xF8CCD303
+// -0.022571
+0xFD1C62FE
+// 0.014495
+0x01DAF887
+// 0.048896
+0x06423648
+// 0.081494
+0x0A6E6394
+// 0.106733
+0x0DA9700F
+// 0.120322
+0x0F66B617
+// 0.122759
+0x0FB68E73
+// 0.113159
+0x0E7C0145
+// 0.093089
+0x0BEA5A33
+// 0.063988
+0x0830C2F5
+// 0.029158
+0x03BB6F9A
+// -0.007750
+0xFF020E7C
+// -0.044159
+0xFA58FE1F
+// -0.074747
+0xF66EB023
+// -0.096542
+0xF3A481D9

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADQ31/Coefs1_q31.txt

@@ -1,42 +1,42 @@
 W
 20
-// -0.478261
-0xC2C857C1
-// 0.162742
-0x14D4BE72
-// -0.159263
-0xEB9D4861
-// -0.591005
-0xB459EF38
-// -0.208694
-0xE5498405
-// 0.131841
-0x10E02846
-// 0.372655
-0x2FB32A42
-// 0.105486
-0x0D809240
-// -0.395407
-0xCD634C46
-// 0.105301
-0x0D7A7F1C
-// 0.211904
-0x1B1FA882
-// -0.390705
-0xCDFD5E16
-// -0.122044
-0xF060D8A9
-// 0.635511
-0x5158700C
+// -0.133026
+0xEEF904F8
+// 0.796330
+0x65EE2199
+// 0.052331
+0x06B2C76C
+// -0.544680
+0xBA47EB66
+// 0.474263
+0x3CB4A890
+// -0.584324
+0xB534DDFF
+// 0.229337
+0x1D5AEB9C
 // 1.000000
 0x7FFFFFFF
-// 0.999193
-0x7FE5925A
-// 0.626256
-0x50292B72
-// 0.318014
-0x28B4AE86
-// 0.579205
-0x4A236088
-// 0.022005
-0x02D11045
+// 0.153018
+0x139613F2
+// 0.185704
+0x17C5282D
+// -0.825441
+0x9657F39D
+// -0.083543
+0xF54E77DF
+// 0.854415
+0x6D5D7877
+// 0.456865
+0x3A7A89ED
+// 0.341274
+0x2BAEDAF3
+// 0.003689
+0x0078E076
+// 0.569190
+0x48DB34F6
+// 0.697899
+0x5954C1E3
+// 0.044300
+0x05AB9E02
+// 0.404161
+0x33BB882B

CMSIS/DSP/Testing/Patterns/DSP/Filtering/BIQUAD/BIQUADQ31/Samples1_q31.txt

@@ -1,1026 +1,1026 @@
 W
 512
-// -0.229321
-0xE2A59B02
-// 0.075465
-0x09A8D6D7
-// 0.044367
-0x05ADCE03
-// 0.051144
-0x068BE117
-// 0.328750
-0x2A147E49
-// -0.023168
-0xFD08D811
-// 0.156181
-0x13FDBE85
-// 0.008047
-0x0107AFC5
-// 0.268012
-0x224E3639
-// 0.053517
-0x06D9A590
-// -0.033568
-0xFBB40C8C
-// 0.086607
-0x0B15ED7C
-// 0.215914
-0x1BA310C7
-// 0.034311
-0x04644EE2
-// -0.070255
-0xF701E335
-// 0.086596
-0x0B1595F1
-// 0.239156
-0x1E9CA7D2
-// -0.052149
-0xF9532B9E
-// -0.206526
-0xE5908A60
-// -0.229954
-0xE290E008
-// 0.151127
-0x13581D13
-// 0.602250
-0x4D1688E2
-// -0.260565
-0xDEA5D16E
-// -0.157885
-0xEBCA696C
-// -0.189517
-0xE7BDE94C
-// 0.126112
-0x10246E3E
-// 0.122514
-0x0FAE8D82
-// 0.272194
-0x22D7416A
-// -0.136902
-0xEE79FB06
-// -0.147508
-0xED1E77BF
-// 0.162679
-0x14D2A7FC
-// -0.294591
-0xDA4AD614
-// -0.111936
-0xF1AC1348
-// 0.525925
-0x435182F1
-// 0.013861
-0x01C633E7
-// 0.253040
-0x20639C21
-// 0.361073
-0x2E37A58D
-// -0.016494
-0xFDE38341
-// 0.354147
-0x2D54B3ED
-// -0.037074
-0xFB412BB9
-// -0.180302
-0xE8EBDFE9
-// 0.136091
-0x116B7091
-// 0.225750
-0x1CE55C7B
-// -0.255792
-0xDF4236A5
-// -0.002920
-0xFFA05181
-// 0.070605
-0x09099402
-// 0.174083
-0x1648570C
-// 0.326958
-0x29D9C1FB
-// -0.008491
-0xFEE9C2FC
-// 0.006831
-0x00DFD492
-// 0.105460
-0x0D7FB42F
-// 0.376797
-0x303AE592
-// 0.176096
-0x168A4D62
-// -0.059860
-0xF8567E0B
-// -0.005598
-0xFF488FB6
-// -0.094969
-0xF3D80DA2
-// -0.077284
-0xF61B8E17
-// 0.417120
-0x35642FC9
-// 0.548416
-0x46327EEF
-// 0.258703
-0x211D2DCB
-// -0.255963
-0xDF3C9D6A
-// 0.326607
-0x29CE438D
-// 0.370032
-0x2F5D3291
-// 0.006282
-0x00CDD5B5
-// -0.315579
-0xD79B17D0
-// -0.100490
-0xF32328A3
-// -0.196566
-0xE6D6E965
-// 0.093312
-0x0BF1A702
-// -0.282345
-0xDBDC2047
-// 0.217704
-0x1BDDBCE8
-// -0.155533
-0xEC178170
-// 0.001998
-0x00417861
-// -0.122640
-0xF04D5780
-// 0.215524
-0x1B96462D
-// 0.050445
-0x0674FD59
-// 0.075466
-0x09A8E009
-// -0.290984
-0xDAC10C7C
-// 0.181276
-0x1734110D
-// 0.233669
-0x1DE8DBD4
-// -0.142828
-0xEDB7D0DF
-// 0.290263
-0x25275978
-// 0.007316
-0x00EFBB96
-// 0.340599
-0x2B98BBA2
-// 0.204152
-0x1A21A945
-// -0.208679
-0xE549FDD0
-// 0.140225
-0x11F2E1DB
-// -0.298978
-0xD9BB16FC
-// -0.158158
-0xEBC17C3A
-// -0.274963
-0xDCCE068D
-// -0.073430
-0xF699DB60
-// -0.394423
-0xCD83899C
-// 0.367294
-0x2F037B00
-// 0.294055
-0x25A39C46
-// -0.143488
-0xEDA22C0B
-// -0.142539
-0xEDC147A2
-// -0.043458
-0xFA6FFBCA
-// 0.218108
-0x1BEAF4DB
-// -0.235233
-0xE1E3E4E1
-// -0.247281
-0xE05918DC
-// 0.499825
-0x3FFA43F5
-// -0.173326
-0xE9D07618
-// 0.174895
-0x1662F823
-// 0.085435
-0x0AEF8AD1
-// 0.160965
-0x149A8197
-// 0.007489
-0x00F56A75
-// -0.344473
-0xD3E85129
-// -0.100651
-0xF31DDF20
-// 0.229646
-0x1D650C9D
-// -0.102774
-0xF2D85119
-// 0.213965
-0x1B633473
-// 0.084946
-0x0ADF83D4
-// 0.016595
-0x021FC70B
-// 0.372290
-0x2FA73573
-// -0.284442
-0xDB9764DF
-// -0.008380
-0xFEED6A3E
-// -0.059392
-0xF865D589
-// 0.070095
-0x08F8DBAA
-// 0.320755
-0x290E822B
-// 0.272815
-0x22EB9786
-// 0.307622
-0x27602A28
-// 0.207465
-0x1A8E377F
-// -0.152104
-0xEC87DE92
-// 0.123053
-0x0FC036C6
-// -0.255324
-0xDF518F31
-// 0.120787
-0x0F75F6C8
-// 0.126581
-0x1033D16C
-// -0.290632
-0xDACC957F
-// -0.036849
-0xFB4887D5
-// -0.431596
-0xC8C17A5B
-// 0.029746
-0x03CEBBB8
-// -0.274958
-0xDCCE2DA5
-// 0.076460
-0x09C96F26
-// -0.035511
-0xFB74632B
-// -0.027710
-0xFC7401AF
-// -0.138904
-0xEE3866B9
-// 0.084112
-0x0AC42CD3
-// -0.407053
-0xCBE5ADF9
-// 0.170197
-0x15C9043A
-// -0.256072
-0xDF3904C7
-// -0.272704
-0xDD1806DB
-// -0.091042
-0xF458BA84
-// -0.074290
-0xF67DAB8D
-// 0.099803
-0x0CC65527
-// 0.296856
-0x25FF6417
-// 0.455546
-0x3A4F52A7
-// -0.289425
-0xDAF422A2
-// 0.306640
-0x273FFDA2
-// -0.019970
-0xFD719D89
-// -0.255805
-0xDF41CB85
-// -0.088973
-0xF49C8A20
-// 0.055203
-0x0710E148
-// -0.068003
-0xF74BAFFC
-// -0.432817
-0xC8997404
-// 0.324013
-0x2979411C
-// 0.119335
-0x0F465B08
-// -0.207241
-0xE5791CBD
-// 0.073699
-0x096EF7AA
-// 0.163758
-0x14F609CE
-// 0.083275
-0x0AA8BF48
-// 0.045252
-0x05CAD409
-// 0.397434
-0x32DF1A44
-// -0.097590
-0xF3822F15
-// 0.157309
-0x1422B074
-// -0.281534
-0xDBF6B353
-// 0.383340
-0x31114A10
-// -0.282475
-0xDBD7DE70
-// -0.396399
-0xCD42CA4B
-// 0.266164
-0x2211AAE7
-// 0.069856
-0x08F10758
-// -0.173068
-0xE9D8E922
-// -0.107280
-0xF244A20D
-// -0.043505
-0xFA6E6D3C
-// 0.331103
-0x2A61995C
-// 0.036914
-0x04B99C0C
-// -0.316691
-0xD776A8B8
-// 0.111629
-0x0E49DA46
-// -0.092958
-0xF419F2EE
-// 0.105188
-0x0D76CB44
-// -0.224432
-0xE345CC0E
-// 0.126498
-0x10311A51
-// 0.134338
-0x1131FBB9
-// -0.069118
-0xF7272387
-// 0.186002
-0x17CEECF4
-// 0.387553
-0x319B536F
-// 0.183020
-0x176D2F72
-// 0.125083
-0x1002BA55
-// -0.353600
-0xD2BD3EDE
-// 0.033125
-0x043D7302
-// 0.302234
-0x26AF9DA5
-// -0.030467
-0xFC19AA14
-// 0.392950
-0x324C3187
-// 0.038344
-0x04E87525
-// 0.152346
-0x13801159
-// 0.051487
-0x06971F08
-// 0.155263
-0x13DFA9A3
-// 0.119066
-0x0F3D8F91
-// -0.109450
-0xF1FD8995
-// -0.372201
-0xD05BB868
-// 0.112889
-0x0E7321FE
-// 0.233950
-0x1DF21212
-// -0.145564
-0xED5E271E
-// 0.236721
-0x1E4CE1E9
-// 0.082545
-0x0A90D6AA
-// -0.102313
-0xF2E76B99
-// -0.121645
-0xF06DEC10
-// -0.299927
-0xD99BFF48
-// 0.382443
-0x30F3E451
-// -0.194615
-0xE716DB30
-// -0.068952
-0xF72C9877
-// -0.086187
-0xF4F7D59A
-// -0.159878
-0xEB892183
-// 0.600238
-0x4CD49755
-// 0.174310
-0x164FC797
-// 0.110649
-0x0E29BAFE
-// 0.044204
-0x05A876AD
-// 0.348420
-0x2C990AED
-// -0.058294
-0xF889D0B0
-// 0.432943
-0x376AAA84
-// -0.447298
-0xC6BEED53
-// -0.320194
-0xD703E1A4
-// 0.247766
-0x1FB6CB13
-// -0.354731
-0xD2982C31
-// -0.436922
-0xC812F46E
-// -0.290161
-0xDADC00FD
-// -0.114613
-0xF15459F3
-// 0.095760
-0x0C41DE79
-// 0.262313
-0x21937BEF
-// 0.094837
-0x0C239EF4
-// 0.131742
-0x10DCEA78
-// 0.134028
-0x1127D4D9
-// 0.642352
-0x5238956E
-// 0.270533
-0x22A0D71A
-// 0.091504
-0x0BB66A81
-// -0.096358
-0xF3AA8BD2
-// 0.526514
-0x4364D08D
-// -0.179857
-0xE8FA71D5
-// -0.226607
-0xE2FE8976
-// 0.284258
-0x24629057
-// 0.437173
-0x37F5471A
-// -0.344216
-0xD3F0BBFE
-// -0.145689
-0xED5A0F32
-// -0.076076
-0xF6432162
-// -0.353140
-0xD2CC4CA1
-// 0.332717
-0x2A9677F4
-// -0.438399
-0xC7E28CC2
-// -0.062918
-0xF7F250CD
-// -0.245624
-0xE08F65BE
-// 0.115194
-0x0EBEA9B2
-// 0.472507
-0x3C7B1DA6
-// -0.163344
-0xEB178D8D
-// 0.042201
-0x0566D445
-// -0.367525
-0xD0F4F114
-// -0.034525
-0xFB94B14C
-// -0.174857
-0xE99E49F7
-// -0.107493
-0xF23DAC02
-// 0.003771
-0x007B8EDE
-// 0.364962
-0x2EB711AC
-// 0.414951
-0x351D1C56
-// 0.098559
-0x0C9D915A
-// -0.024906
-0xFCCFE34A
-// 0.449160
-0x397E1556
-// 0.274008
-0x2312AE47
-// -0.347279
-0xD38C59EB
-// 0.191804
-0x188D04A6
-// -0.150061
-0xECCACE75
-// -0.577320
-0xB61A64BC
-// 0.016820
-0x02272AB6
-// 0.046248
-0x05EB73E4
-// 0.099454
-0x0CBAEC56
-// 0.267916
-0x224B137E
-// 0.126124
-0x1024D22D
-// 0.137177
-0x118F04EF
-// -0.211141
-0xE4F95548
-// -0.038518
-0xFB11D74B
-// 0.082982
-0x0A9F2363
-// 0.152388
-0x13816FD5
-// -0.322169
-0xD6C328FC
-// -0.152480
-0xEC7B8A5A
-// 0.001338
-0x002BD6AC
-// 0.206585
-0x1A715EC7
-// 0.221564
-0x1C5C328B
-// 0.115845
-0x0ED3FFF5
-// -0.031954
-0xFBE8F249
-// -0.419979
-0xCA3E1DD7
-// 0.516858
-0x422866EF
-// 0.393302
-0x3257B784
-// 0.196907
-0x19344219
-// 0.039151
-0x0502E4B5
-// 0.130919
-0x10C1F275
-// 0.090595
-0x0B989E7F
-// 0.049262
-0x064E3535
-// 0.203956
-0x1A1B377D
-// 0.317543
-0x28A53DD7
-// 0.006525
-0x00D5CF36
-// -0.349395
-0xD34704A7
-// -0.081281
-0xF59894F4
-// 0.020416
-0x029CFA4A
-// 0.024065
-0x031492A5
-// 0.098140
-0x0C8FD938
-// -0.060817
-0xF83724D7
-// 0.088835
-0x0B5EF30A
-// 0.119552
-0x0F4D7E46
-// 0.013139
-0x01AE8680
-// 0.021303
-0x02BA11D4
-// 0.163134
-0x14E191F8
-// 0.488735
-0x3E8EDB61
-// -0.283287
-0xDBBD3DFE
-// -0.341936
-0xD43B736D
-// -0.257637
-0xDF05C187
-// 0.127745
-0x1059F53B
-// 0.544326
-0x45AC7766
-// -0.073417
-0xF69A46F1
-// 0.170587
-0x15D5CC00
-// 0.289288
-0x25076073
-// 0.068412
-0x08C1B92D
-// 0.116995
-0x0EF9AD43
-// -0.309906
-0xD85503C3
-// 0.038800
-0x04F764DB
-// 0.161258
-0x14A41B70
-// 0.509237
-0x412EABD4
-// -0.259942
-0xDEBA3482
-// -0.283514
-0xDBB5CD0B
-// 0.184170
-0x1792E376
-// 0.079451
-0x0A2B75EE
-// 0.414537
-0x350F8BD7
-// -0.107449
-0xF23F1B34
-// -0.131154
-0xEF365CA6
-// 0.002310
-0x004BAE5E
-// 0.453020
-0x39FC8D8F
-// 0.162465
-0x14CBA796
-// -0.092344
-0xF42E1604
-// -0.084822
-0xF524918D
-// -0.574455
-0xB6783FDE
-// -0.409535
-0xCB945F5A
-// -0.249752
-0xE0081FEC
-// -0.069141
-0xF7266052
-// 0.017405
-0x023A50AD
-// -0.023178
-0xFD087D05
-// -0.206241
-0xE599E5B2
-// -0.160401
-0xEB77F79E
-// -0.546200
-0xBA161C4F
-// -0.082552
-0xF56EF2DD
-// 0.288022
-0x24DDE51B
-// 0.363164
-0x2E7C25C6
-// -0.232232
-0xE24634DA
-// -0.315026
-0xD7AD3C42
-// -0.660847
-0xAB695C4B
-// -0.485387
-0xC1DED347
-// 0.194588
-0x18E84382
-// -0.160569
-0xEB7275D7
-// -0.407578
-0xCBD47C05
-// 0.140677
-0x1201B039
-// -0.291827
-0xDAA56D73
-// -0.040279
-0xFAD82149
-// 0.132561
-0x10F7C0FE
-// 0.133088
-0x11090722
-// -0.027279
-0xFC82234A
-// -0.425149
-0xC994BAD6
-// -0.179445
-0xE907EEBE
-// -0.091712
-0xF442CBCA
-// 0.080249
-0x0A4599F0
-// 0.221840
-0x1C653EF0
-// -0.101518
-0xF3017972
-// 0.396201
-0x32B6B371
-// -0.042050
-0xFA9E18A3
-// 0.130791
-0x10BDC033
-// -0.010204
-0xFEB1A16A
-// -0.107513
-0xF23D06CF
-// -0.097652
-0xF3802409
-// 0.106059
-0x0D935511
-// 0.170985
-0x15E2D77D
-// -0.014752
-0xFE1C98F2
-// 0.015475
-0x01FB16DC
-// 0.096068
-0x0C4BF552
-// 0.392824
-0x324812AE
-// 0.208440
-0x1AAE2D41
-// -0.122417
-0xF054A31A
-// 0.070749
-0x090E4F7D
-// -0.140439
-0xEE061C38
-// -0.200762
-0xE64D71CF
-// 0.014651
-0x01E01622
-// -0.170666
-0xEA279F6A
-// -0.073654
-0xF6927EB7
-// 0.091778
-0x0BBF5E43
-// -0.104501
-0xF29FB510
-// 0.077755
-0x09F3E0F6
-// -0.247523
-0xE0512C1D
-// -0.011085
-0xFE94C6B8
-// -0.270641
-0xDD5BA28E
-// -0.110654
-0xF1D612F8
-// 0.155339
-0x13E2275A
-// -0.030896
-0xFC0B9C9F
-// -0.256808
-0xDF20EB6C
-// 0.174197
-0x164C1684
-// -0.010937
-0xFE999C35
-// -0.143250
-0xEDA9F98F
-// -0.355803
-0xD2750D50
-// 0.102580
-0x0D21548B
-// 0.232498
-0x1DC280C7
-// 0.130754
-0x10BC8C6D
-// 0.114533
-0x0EA903F6
-// -0.060696
-0xF83B1D83
-// -0.041282
-0xFAB74594
-// 0.194561
-0x18E75C66
-// -0.136612
-0xEE837B94
-// 0.006030
-0x00C59ABF
-// 0.009633
-0x013BAB64
-// 0.020233
-0x0296FE2B
-// 0.068496
-0x08C47C44
-// -0.544773
-0xBA44E22F
-// -0.095797
-0xF3BCECAB
-// 0.012152
-0x018E3139
-// 0.062968
-0x080F5998
-// 0.382688
-0x30FBE90E
-// -0.346109
-0xD3B2AFAE
-// 0.204801
-0x1A36ECFF
-// 0.298460
-0x2633EFCB
-// 0.189664
-0x1846E839
-// -0.156006
-0xEC07FC47
-// 0.180551
-0x171C4E39
-// -0.509471
-0xBEC9A9DA
-// -0.170615
-0xEA2945B5
-// 0.160062
-0x147CED0F
-// 0.162017
-0x14BCFBD9
-// 0.552189
-0x46AE1D4D
-// 0.031142
-0x03FC74AA
-// 0.363845
-0x2E9277AE
-// 0.122083
-0x0FA06CD6
-// 0.324787
-0x2992A101
-// -0.098958
-0xF3555BCE
-// 0.170695
-0x15D95775
-// -0.190483
-0xE79E40A8
-// 0.077194
-0x09E17AF4
-// -0.025992
-0xFCAC4C92
-// -0.166025
-0xEABFAD39
-// 0.103498
-0x0D3F6AB1
-// 0.409982
-0x347A4A84
-// -0.017836
-0xFDB78F7D
-// 0.286791
-0x24B58EBC
-// -0.323949
-0xD688D43C
-// 0.269286
-0x2277FA2B
-// -0.035594
-0xFB71A892
-// -0.116047
-0xF1256291
-// -0.022586
-0xFD1BE378
-// 0.180179
-0x17101D8D
-// -0.218950
-0xE3F974F4
-// -0.055754
-0xF8DD10FE
-// 0.248303
-0x1FC8641D
-// -0.589146
-0xB496DAEB
-// -0.299872
-0xD99DCAB4
-// -0.028250
-0xFC624E22
-// -0.228510
-0xE2C030A0
-// 0.121524
-0x0F8E1511
-// 0.086505
-0x0B1296A0
-// -0.170134
-0xEA390B29
-// 0.014271
-0x01D39DF9
-// -0.230214
-0xE2885C6B
-// -0.015520
-0xFE036EB4
-// -0.120313
-0xF09996F2
-// 0.050194
-0x066CC3FD
-// -0.033643
-0xFBB197A0
-// 0.075573
-0x09AC60A7
-// 0.132578
-0x10F85186
-// 0.276581
-0x236702B8
-// 0.138870
-0x11C67FD6
-// -0.131021
-0xEF3AB2D6
-// -0.008468
-0xFEEA8714
-// 0.288796
-0x24F740C1
-// 0.055982
-0x072A6DEF
-// -0.496379
-0xC076A542
-// 0.526999
-0x4374B20A
-// 0.171302
-0x15ED38E1
-// 0.210033
-0x1AE25B1C
-// 0.112271
-0x0E5EE7A0
-// 0.194990
-0x18F56F83
-// -0.286470
-0xDB54F050
-// 0.171264
-0x15EBF851
-// 0.155986
-0x13F758D7
-// -0.295547
-0xDA2B81ED
-// -0.468412
-0xC40B13F8
-// -0.105866
-0xF272F7CA
-// 1.000000
-0x7FFFFFFF
-// -0.168467
-0xEA6FAD67
-// -0.218214
-0xE4118DBE
-// 0.375897
-0x301D614B
-// 0.279680
-0x23CC9015
-// -0.063926
-0xF7D148C5
-// 0.488143
-0x3E7B7508
-// 0.117950
-0x0F18FBBC
-// 0.442073
-0x3895DA17
-// 0.043444
-0x058F9603
-// -0.070801
-0xF6EFFF9B
-// -0.108220
-0xF225DA4C
-// -0.195839
-0xE6EEC100
-// 0.058907
-0x078A4267
-// -0.096328
-0xF3AB8438
-// -0.665696
-0xAACA79A6
-// 0.070754
-0x090E798E
-// 0.119959
-0x0F5ACD3F
-// 0.042903
-0x057DD5AB
-// -0.165960
-0xEAC1D1D3
-// -0.039366
-0xFAF60C16
-// 0.312727
-0x28076DA6
-// 0.298051
-0x26268C0F
-// -0.044410
-0xFA50C860
-// -0.026026
-0xFCAB3188
-// 0.645005
-0x528F82DD
-// -0.098876
-0xF35809FB
-// 0.063733
-0x08286366
-// 0.259606
-0x213AC5DD
-// 0.124702
-0x0FF63EA8
-// -0.064061
-0xF7CCD607
+// 0.360659
+0x2E2A1542
+// 0.206330
+0x1A6905C4
+// 0.282289
+0x24220FD7
+// 0.344669
+0x2C1E1AC0
+// -0.138015
+0xEE55873E
+// -0.037064
+0xFB417F3F
+// 0.111492
+0x0E455E80
+// -0.099290
+0xF34A7A9E
+// 0.268193
+0x225428AE
+// -0.173431
+0xE9CD0679
+// 0.060087
+0x07B0F09D
+// 0.131927
+0x10E2FA91
+// 0.467836
+0x3BE20F51
+// -0.066355
+0xF781AAEB
+// 0.077444
+0x09E9AF02
+// 0.491305
+0x3EE311F1
+// -0.326401
+0xD6387FB5
+// 0.207734
+0x1A9705C7
+// -0.316490
+0xD77D3E5C
+// -0.490843
+0xC12C0B25
+// 0.149672
+0x13287436
+// -0.283178
+0xDBC0CEE5
+// 0.144654
+0x128404A6
+// -0.550457
+0xB98AA361
+// 0.297624
+0x26188BF3
+// 0.201532
+0x19CBC93C
+// 0.254142
+0x2087BA38
+// 0.163952
+0x14FC6083
+// -0.196015
+0xE6E8F87A
+// -0.558899
+0xB875FF9E
+// -0.041305
+0xFAB6811D
+// 0.081178
+0x0A640719
+// -0.984035
+0x820B20A8
+// -0.079879
+0xF5C68706
+// -0.181854
+0xE8B905A5
+// -0.434054
+0xC870E8E6
+// -0.144609
+0xED7D74C9
+// 0.026067
+0x035626B5
+// 0.515385
+0x41F822BB
+// -0.560723
+0xB83A3D10
+// -0.635212
+0xAEB162E2
+// 0.156537
+0x14096844
+// 0.616331
+0x4EE3F2F3
+// 0.082373
+0x0A8B3335
+// 0.397724
+0x32E8A240
+// 0.146570
+0x12C2D173
+// -0.330215
+0xD5BB8206
+// -0.054348
+0xF90B1E2A
+// 0.289172
+0x25039612
+// -0.109173
+0xF206A0B3
+// -0.183546
+0xE881924B
+// -0.166476
+0xEAB0ED0C
+// -0.290127
+0xDADD1EF4
+// -0.027489
+0xFC7B3D9F
+// -0.233105
+0xE2299A42
+// -0.219094
+0xE3F4B76E
+// 0.066421
+0x08807D28
+// -0.397886
+0xCD120F41
+// 0.250328
+0x200ABBD8
+// -0.250646
+0xDFEAD348
+// -0.103389
+0xF2C427A7
+// 0.014811
+0x01E557B8
+// 0.472443
+0x3C7902A5
+// 0.667322
+0x556ACB2C
+// 0.200602
+0x19AD55EF
+// -0.144218
+0xED8A42EE
+// 0.168259
+0x15897F47
+// -0.274001
+0xDCED8B89
+// -0.338779
+0xD4A2E70D
+// 0.061615
+0x07E302F1
+// -0.247790
+0xE0486B87
+// 0.264414
+0x21D854CE
+// -0.478707
+0xC2B9BE5A
+// 0.303937
+0x26E76BD1
+// -0.371056
+0xD081391F
+// 0.221221
+0x1C50FB74
+// -0.549210
+0xB9B37AE7
+// -0.235458
+0xE1DC81BD
+// -0.468735
+0xC4007D96
+// -0.412089
+0xCB40AD8E
+// -0.061005
+0xF830FDEF
+// -0.242127
+0xE101F827
+// -0.299953
+0xD99B22B6
+// -0.288382
+0xDB164BA9
+// 0.224093
+0x1CAF17B4
+// -0.280764
+0xDC0FEDC6
+// -0.419650
+0xCA48EB9C
+// -0.055298
+0xF8EBFDF8
+// -0.284107
+0xDBA26390
+// 0.226723
+0x1D053F3B
+// -0.399211
+0xCCE6AA31
+// -0.550664
+0xB983D504
+// 0.181108
+0x172E8800
+// 0.200542
+0x19AB601A
+// -0.195025
+0xE709681E
+// -0.247126
+0xE05E2ECA
+// -0.339444
+0xD48D1937
+// 0.027417
+0x038265E7
+// 0.444605
+0x38E8D153
+// -0.242688
+0xE0EF973A
+// 0.189326
+0x183BD67E
+// 0.130264
+0x10AC7A5D
+// 0.119438
+0x0F49BC11
+// 0.224230
+0x1CB38DFC
+// 0.237992
+0x1E768826
+// -0.316665
+0xD777879E
+// 0.148989
+0x13121502
+// 0.485767
+0x3E2D9F4C
+// 0.590621
+0x4B997B62
+// 0.253261
+0x206ADC4D
+// 0.211945
+0x1B2106EB
+// -0.234213
+0xE2054B08
+// 0.651356
+0x535F9F5D
+// 0.233823
+0x1DEDEA9E
+// 0.154332
+0x13C1260E
+// 0.376747
+0x30393F40
+// -0.546147
+0xBA17D80C
+// -0.503970
+0xBF7DE517
+// -0.162135
+0xEB3F2AC2
+// -0.354749
+0xD29799D6
+// 0.021031
+0x02B12236
+// 0.055241
+0x071223D1
+// 0.411972
+0x34BB8009
+// 0.147031
+0x12D1E6CF
+// 0.131721
+0x10DC37FB
+// -0.419499
+0xCA4DDC7F
+// 0.163839
+0x14F8AB0F
+// 0.584899
+0x4ADDF904
+// 0.245220
+0x1F636091
+// -0.179446
+0xE907EA11
+// -0.022395
+0xFD222C92
+// -0.575852
+0xB64A7CC6
+// -0.209935
+0xE520DA3C
+// -0.532324
+0xBBDCD132
+// 0.358225
+0x2DDA5124
+// 0.022701
+0x02E7DBD1
+// 0.202152
+0x19E020E5
+// -0.041597
+0xFAACF1F4
+// 0.346275
+0x2C52BBAA
+// -0.086425
+0xF4F008B5
+// -0.523069
+0xBD0C172D
+// 0.354638
+0x2D64C4C4
+// 0.834550
+0x6AD285AE
+// -0.355948
+0xD27047E4
+// -0.344624
+0xD3E35B08
+// -0.048596
+0xF9C79A16
+// 0.329066
+0x2A1ED626
+// 0.016744
+0x0224AD5E
+// 0.403679
+0x33ABBFD0
+// -0.024707
+0xFCD663D4
+// -0.277439
+0xDC7CE3FE
+// 0.467884
+0x3BE3A00F
+// -0.004442
+0xFF6E7019
+// 0.700522
+0x59AAB194
+// -0.448546
+0xC6960978
+// -0.332651
+0xD56BB045
+// 0.233131
+0x1DD73DAA
+// 0.074401
+0x0985F74A
+// 0.295798
+0x25DCB27E
+// -0.297155
+0xD9F6D2C4
+// 0.095825
+0x0C43FEEC
+// -0.068454
+0xF73CE58B
+// -0.111946
+0xF1ABC2CD
+// -0.146810
+0xED35535F
+// -0.220660
+0xE3C1666B
+// -0.307243
+0xD8AC4589
+// 0.053659
+0x06DE4E11
+// -0.085845
+0xF50304D6
+// -0.167687
+0xEA89381D
+// -0.354331
+0xD2A54A4F
+// -0.361598
+0xD1B72933
+// 0.045706
+0x05D9B1CA
+// 0.221435
+0x1C57FBF8
+// 0.227884
+0x1D2B518B
+// -0.294943
+0xDA3F5107
+// 0.074537
+0x098A70FD
+// 0.351980
+0x2D0DB188
+// 0.553681
+0x46DF05E7
+// -0.138937
+0xEE375168
+// -0.058029
+0xF8927E94
+// 0.134267
+0x112FAA1F
+// 0.112812
+0x0E709D6F
+// -0.570407
+0xB6FCEAA8
+// -0.232575
+0xE23AFF53
+// -0.392366
+0xCDC6F1B4
+// 0.195832
+0x191101FE
+// -0.408372
+0xCBBA7489
+// 0.386190
+0x316EAEDB
+// -0.500297
+0xBFF64601
+// -0.126359
+0xEFD37731
+// 0.553359
+0x46D47B2F
+// -0.185553
+0xE83FD092
+// -0.272516
+0xDD1E2F29
+// -0.395267
+0xCD67E064
+// -0.181300
+0xE8CB2BC2
+// 0.299682
+0x265BFC15
+// 0.294038
+0x25A308D3
+// -0.113181
+0xF183493F
+// 0.603516
+0x4D40028A
+// -0.065479
+0xF79E61FF
+// -0.195116
+0xE7066CAC
+// 0.488605
+0x3E8A9CC3
+// 0.123235
+0x0FC62A36
+// -0.223163
+0xE36F6358
+// 0.128286
+0x106BAB41
+// 0.340911
+0x2BA2FCA2
+// -0.355645
+0xD27A3C6A
+// 0.073337
+0x09631E97
+// 0.001301
+0x002A9E52
+// 0.007165
+0x00EAC881
+// 0.202805
+0x19F58396
+// -0.519321
+0xBD86E5F3
+// -0.187878
+0xE7F399F9
+// 0.364478
+0x2EA73346
+// -0.383944
+0xCEDAE83A
+// 0.113967
+0x0E96751E
+// 0.067494
+0x08A3A0AF
+// -0.573318
+0xB69D84E5
+// -0.438301
+0xC7E5BCF6
+// -0.555382
+0xB8E9414A
+// 0.048613
+0x0638F3E3
+// 0.560025
+0x47AEE6AA
+// 0.524706
+0x43298E6D
+// 0.022293
+0x02DA7B0B
+// 0.022697
+0x02E7BA62
+// 0.393139
+0x325264F9
+// -0.332042
+0xD57FA9D9
+// 0.225966
+0x1CEC73FE
+// -0.551530
+0xB9677868
+// -0.212365
+0xE4D136D9
+// -0.285600
+0xDB7175D5
+// -0.063552
+0xF7DD8A8A
+// -0.179443
+0xE9080029
+// -0.169627
+0xEA49A5F6
+// -0.227891
+0xE2D479D2
+// 0.422261
+0x360CA7FE
+// -0.232516
+0xE23CED42
+// 0.131439
+0x10D2FAD0
+// 0.129141
+0x1087AF10
+// 0.110357
+0x0E20313D
+// 0.007289
+0x00EEDBB4
+// -0.134706
+0xEEC1F50E
+// -0.067559
+0xF75A3BDA
+// 0.351823
+0x2D088C0F
+// -0.300561
+0xD9873810
+// 0.155686
+0x13ED86F3
+// -0.124794
+0xF006C015
+// 0.377862
+0x305DC6B8
+// -0.066860
+0xF7711F4A
+// -0.596259
+0xB3ADC71F
+// 0.662727
+0x54D43AC7
+// -0.411447
+0xCB55B346
+// -0.213826
+0xE4A158D5
+// 0.023266
+0x02FA613D
+// -0.091106
+0xF456A39E
+// 0.290448
+0x252D623A
+// 0.177525
+0x16B92060
+// 0.206458
+0x1A6D3726
+// 0.373871
+0x2FDAFEDA
+// -0.454671
+0xC5CD54FB
+// -0.281675
+0xDBF21419
+// 0.464184
+0x3B6A63EA
+// 0.023230
+0x02F93412
+// 0.002918
+0x005FA073
+// -0.167554
+0xEA8D96A8
+// 0.160659
+0x14907A8F
+// -0.129304
+0xEF72FA6E
+// -0.430744
+0xC8DD62D2
+// -0.525136
+0xBCC85442
+// -0.058205
+0xF88CBADD
+// 0.855678
+0x6D86D8D7
+// -0.098969
+0xF354FEA4
+// -0.153868
+0xEC4E0F98
+// 0.293505
+0x25918FF3
+// -0.533917
+0xBBA898F2
+// 0.192449
+0x18A22EB6
+// 0.024640
+0x0327684C
+// 0.659330
+0x5464EBA1
+// 0.338167
+0x2B490A38
+// -0.260767
+0xDE9F318B
+// 0.029503
+0x03C6BDEB
+// 0.104613
+0x0D63F6AF
+// 0.139410
+0x11D831C3
+// 0.161790
+0x14B58AF3
+// -0.077259
+0xF61C61EB
+// 0.332270
+0x2A87D3BE
+// -0.020029
+0xFD6FB1A0
+// 0.257324
+0x20EFFFE1
+// 0.203987
+0x1A1C3D53
+// -0.229421
+0xE2A25717
+// 0.050752
+0x067F0C2E
+// 0.036595
+0x04AF2146
+// -0.412832
+0xCB285150
+// 0.197668
+0x194D2C9A
+// 0.102246
+0x0D166248
+// -0.014839
+0xFE19BFA8
+// 0.231528
+0x1DA2B66B
+// -0.391824
+0xCDD8B740
+// -0.138790
+0xEE3C22D6
+// 0.468976
+0x3C0763A3
+// -0.479425
+0xC2A231DF
+// -0.128020
+0xEF9D0BCB
+// 0.495377
+0x3F68838D
+// -0.177692
+0xE9416149
+// 0.079229
+0x0A242DE2
+// -0.081605
+0xF58DF3EE
+// 0.330984
+0x2A5DB2A1
+// -0.227439
+0xE2E345FA
+// -0.249616
+0xE00C9685
+// 0.543093
+0x4584163A
+// -0.182973
+0xE8945B57
+// 0.086999
+0x0B22CBD9
+// 0.068819
+0x08CF1162
+// 0.146746
+0x12C89694
+// -0.274892
+0xDCD05A6D
+// 0.588323
+0x4B4E295E
+// -0.551919
+0xB95AB5A4
+// -0.238040
+0xE187E889
+// 0.519280
+0x4277C2DE
+// -0.151051
+0xECAA5BED
+// -0.121502
+0xF0729B74
+// 0.124789
+0x0FF91414
+// 0.080458
+0x0A4C7499
+// -0.172916
+0xE9DDE078
+// 0.008057
+0x010804BA
+// -0.097856
+0xF3797231
+// -0.396889
+0xCD32C100
+// -0.235504
+0xE1DB01A2
+// -0.377105
+0xCFBB024E
+// 0.358174
+0x2DD8A966
+// 0.249855
+0x1FFB3EDD
+// 0.026015
+0x03547686
+// 0.138529
+0x11BB5391
+// -0.092564
+0xF426DEF6
+// -0.517306
+0xBDC8EB55
+// 0.233219
+0x1DDA1E6E
+// -0.086849
+0xF4E22066
+// 0.942404
+0x78A0B1E7
+// 0.414784
+0x3517A852
+// 0.596478
+0x4C5967B4
+// 0.030461
+0x03E62878
+// 0.436350
+0x37DA4DC8
+// 0.084512
+0x0AD1469C
+// -0.112121
+0xF1A605CE
+// 0.073749
+0x09709A9A
+// -0.338754
+0xD4A3B4F6
+// -0.258709
+0xDEE29C4B
+// 0.113389
+0x0E8383D8
+// -0.211432
+0xE4EFCCA4
+// -0.003966
+0xFF7E0EE5
+// 0.046323
+0x05EDE5F6
+// -0.219552
+0xE3E5B6B8
+// -0.302833
+0xD93CC350
+// -0.207882
+0xE564204C
+// 0.334465
+0x2ACFBF59
+// -0.120590
+0xF090843B
+// 0.660810
+0x54956857
+// -0.688057
+0xA7EDC2AB
+// -0.078424
+0xF5F63501
+// 0.047590
+0x06176C62
+// 0.412399
+0x34C97A41
+// -0.107318
+0xF2436A11
+// 0.098166
+0x0C90B23E
+// 0.146627
+0x12C4AE5D
+// 0.386788
+0x31824531
+// 0.664952
+0x551D28A0
+// -0.020459
+0xFD619626
+// 0.027011
+0x03751B60
+// 0.246400
+0x1F8A092B
+// -0.347975
+0xD3759157
+// 0.259168
+0x212C6DE5
+// 0.671644
+0x55F86CCD
+// 0.076962
+0x09D9E0C9
+// 0.037497
+0x04CCB63D
+// -0.052855
+0xF93C0C8E
+// 0.318676
+0x28CA5C01
+// -0.386057
+0xCE95ACB4
+// 0.051995
+0x06A7C933
+// -0.124526
+0xF00F88BE
+// -1.000000
+0x80000000
+// -0.034630
+0xFB913F2E
+// 0.434708
+0x37A47F76
+// 0.507261
+0x40EDECFB
+// 0.552270
+0x46B0C546
+// -0.096622
+0xF3A1E4A1
+// 0.197285
+0x1940A1DB
+// 0.662049
+0x54BE05B4
+// 0.065890
+0x086F18B6
+// -0.028100
+0xFC67378A
+// 0.730559
+0x5D82F8E7
+// -0.305438
+0xD8E765F8
+// 0.136165
+0x116DDBE4
+// -0.056193
+0xF8CEA6F1
+// 0.507095
+0x40E87A59
+// 0.355493
+0x2D80CCF0
+// 0.348656
+0x2CA0C546
+// 0.088982
+0x0B63BFE8
+// -0.525945
+0xBCADD247
+// 0.135783
+0x11615A0C
+// 0.049436
+0x0653ED7C
+// -0.371687
+0xD06C9282
+// 0.799270
+0x664E7E72
+// 0.375840
+0x301B89AC
+// 0.133631
+0x111AD121
+// -0.237031
+0xE1A8F97A
+// 0.603857
+0x4D4B2F16
+// 0.456446
+0x3A6CD5DF
+// 0.191384
+0x187F44DC
+// -0.272800
+0xDD14E1A7
+// 0.253370
+0x206E6CEE
+// -0.162584
+0xEB30729F
+// -0.211251
+0xE4F5BC49
+// -0.651189
+0xACA5DA50
+// 0.490657
+0x3ECDD5C8
+// 0.300786
+0x2680261A
+// -0.106720
+0xF256FF0E
+// 0.627436
+0x504FD6A5
+// -0.149339
+0xECE27464
+// -0.339172
+0xD495FEDE
+// -0.174305
+0xE9B05CA2
+// 0.152352
+0x138046F1
+// 0.342372
+0x2BD2D475
+// -0.105215
+0xF2885145
+// 0.401902
+0x3371887F
+// -0.095760
+0xF3BE23B9
+// 0.092786
+0x0BE0687E
+// -0.361140
+0xD1C62D6A
+// 0.170159
+0x15C7C477
+// 0.072244
+0x093F4925
+// -0.435549
+0xC83FECCB
+// 0.295717
+0x25DA0FBB
+// 0.630183
+0x50A9D97B
+// -0.191434
+0xE77F18CF
+// 0.146977
+0x12D02179
+// -0.115677
+0xF1317B62
+// -0.021466
+0xFD4099BE
+// -0.296653
+0xDA0743A4
+// -0.572581
+0xB6B5A6EC
+// 0.048108
+0x06286902
+// -0.468919
+0xC3FA7459
+// -0.334853
+0xD5238CAB
+// -0.061798
+0xF816FFF5
+// 0.269825
+0x2289A369
+// -0.606870
+0xB2521232
+// 0.627302
+0x504B6DDF
+// -0.223887
+0xE357A820
+// 0.441703
+0x3889B89C
+// -0.148237
+0xED069170
+// 0.100832
+0x0CE811E4
+// -0.426036
+0xC977A6CB
+// -0.642075
+0xADD07B54
+// 0.790578
+0x6531ACC8
+// 0.227198
+0x1D14D40B
+// 0.619181
+0x4F415511
+// -0.513234
+0xBE4E5703
+// 0.206971
+0x1A7E0454
+// -0.469526
+0xC3E6934E
+// -0.010437
+0xFEAA0108
+// -0.173905
+0xE9BD7A11
+// -0.101924
+0xF2F429FE
+// -0.349876
+0xD33740DA
+// 0.139590
+0x11DE136D
+// -0.551053
+0xB9771AA9
+// -0.669510
+0xAA4D81FD
+// -0.018482
+0xFDA26573
+// 0.294083
+0x25A484BF
+// 0.136350
+0x1173EE3D
+// 0.012901
+0x01A6C155
+// -0.270378
+0xDD644109
+// 0.350670
+0x2CE2C4E3
+// -0.114203
+0xF161CF3C
+// 0.632292
+0x50EEEE60
+// 0.116111
+0x0EDCB9AE
+// -0.269683
+0xDD7B059A
+// 0.164826
+0x15190371
+// -0.561151
+0xB82C37D1
+// 0.048919
+0x0642FC21
+// 0.819454
+0x68E3DDD7
+// -0.417941
+0xCA80E5E9
+// 0.006149
+0x00C97D72
+// -0.036760
+0xFB4B75F8
+// 0.002528
+0x0052D3BC
+// -0.169822
+0xEA434416
+// -0.133378
+0xEEED7B15
+// 0.717442
+0x5BD51FCC
+// 0.102978
+0x0D2E64AB
+// -0.187525
+0xE7FF2A42
+// -0.114543
+0xF156A533
+// 0.061274
+0x07D7D593
+// 0.194382
+0x18E17E8A
+// -0.129354
+0xEF71582C
+// 0.201519
+0x19CB61DF
+// -0.173940
+0xE9BC5343
+// 0.336985
+0x2B225384
+// 0.251066
+0x2022EA61
+// -0.275797
+0xDCB2AB99
+// -0.153848
+0xEC4EB61F
+// -0.019045
+0xFD8FF038
+// 0.106091
+0x0D9463CC
+// -0.074378
+0xF67AC71D
+// 0.148832
+0x130CEBD8
+// 0.759227
+0x612E558F
+// -0.316153
+0xD7884EA5
+// 0.167196
+0x1566AA44
+// 0.049334
+0x0650979A
+// 0.268174
+0x2253838A
+// -0.119346
+0xF0B9411E
+// 0.473448
+0x3C99EE00
+// 0.407836
+0x3433F82C
+// -0.363300
+0xD17F5F8A
+// -0.388872
+0xCE397512
+// 0.352379
+0x2D1AC184

CMSIS/DSP/Testing/Source/Tests/BIQUADF32.cpp

@@ -0,0 +1,488 @@
+#include "BIQUADF32.h"
+#include "Error.h"
+
+#define SNR_THRESHOLD 98
+
+/* 
+
+Reference patterns are generated with
+a double precision computation.
+
+*/
+#define REL_ERROR (1.2e-3)
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+static __ALIGNED(8) float32_t coeffArray[32];
+#endif 
+
+    void BIQUADF32::test_biquad_cascade_df1_ref()
+    {
+
+
+        float32_t *statep = state.ptr();
+        float32_t *debugstatep = debugstate.ptr();
+
+        const float32_t *coefsp = coefs.ptr();
+        
+        const float32_t *inputp = inputs.ptr();
+        float32_t *outp = output.ptr();
+
+        #if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+        arm_biquad_mod_coef_f32 *coefsmodp = (arm_biquad_mod_coef_f32*)vecCoefs.ptr();
+        #endif
+
+        int i,j;
+        int blockSize;
+        int numTaps;
+        int nb=0;
+
+        
+
+        /*
+
+        Python script is generating different tests with
+        different blockSize and numTaps.
+
+        We loop on those configs.
+
+        */
+        
+           blockSize = inputs.nbSamples() >> 1;
+           numTaps = coefs.nbSamples();
+
+           /*
+
+           The filter is initialized with the coefs, blockSize and numTaps.
+
+           */
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+           arm_biquad_cascade_df1_mve_init_f32(&this->Sdf1,3,coefsp,coefsmodp,statep);
+#else
+           arm_biquad_cascade_df1_init_f32(&this->Sdf1,3,coefsp,statep);
+#endif
+
+           /*
+           
+           Python script is filtering a 2*blockSize number of samples.
+           We do the same filtering in two pass to check (indirectly that
+           the state management of the fir is working.)
+
+           */
+
+           arm_biquad_cascade_df1_f32(&this->Sdf1,inputp,outp,blockSize);
+        
+           memcpy(debugstatep,statep,3*4*sizeof(float32_t));
+           debugstatep += 3*4;
+
+           outp += blockSize;
+           
+           inputp += blockSize;
+           arm_biquad_cascade_df1_f32(&this->Sdf1,inputp,outp,blockSize);
+           outp += blockSize;
+          
+           memcpy(debugstatep,statep,3*4*sizeof(float32_t));
+           debugstatep += 3*4;
+
+           ASSERT_EMPTY_TAIL(output);
+
+           ASSERT_SNR(output,ref,(float32_t)SNR_THRESHOLD);
+
+           ASSERT_REL_ERROR(output,ref,REL_ERROR);
+  
+
+    } 
+
+    void BIQUADF32::test_biquad_cascade_df2T_ref()
+    {
+
+
+        float32_t *statep = state.ptr();
+
+#if !defined(ARM_MATH_NEON) 
+        const float32_t *coefsp = coefs.ptr();
+#else
+        float32_t *coefsp = coefs.ptr();
+#endif
+        
+        const float32_t *inputp = inputs.ptr();
+        float32_t *outp = output.ptr();
+
+        int i,j;
+        int blockSize;
+        int numTaps;
+        int nb=0;
+
+        
+
+        /*
+
+        Python script is generating different tests with
+        different blockSize and numTaps.
+
+        We loop on those configs.
+
+        */
+        
+           blockSize = inputs.nbSamples() >> 1;
+           numTaps = coefs.nbSamples();
+
+           /*
+
+           The filter is initialized with the coefs, blockSize and numTaps.
+
+           */
+#if !defined(ARM_MATH_NEON) 
+           arm_biquad_cascade_df2T_init_f32(&this->Sdf2T,3,coefsp,statep);
+#else
+           float32_t *vecCoefsPtr = vecCoefs.ptr();
+
+           arm_biquad_cascade_df2T_init_f32(&this->Sdf2T,
+                    3,
+                    vecCoefsPtr,
+                    statep);
+
+           // Those Neon coefs must be computed from original coefs
+           arm_biquad_cascade_df2T_compute_coefs_f32(&this->Sdf2T,3,coefsp);
+#endif
+
+           /*
+           
+           Python script is filtering a 2*blockSize number of samples.
+           We do the same filtering in two pass to check (indirectly that
+           the state management of the fir is working.)
+
+           */
+
+           arm_biquad_cascade_df2T_f32(&this->Sdf2T,inputp,outp,blockSize);
+           outp += blockSize;
+
+           
+           inputp += blockSize;
+           arm_biquad_cascade_df2T_f32(&this->Sdf2T,inputp,outp,blockSize);
+           outp += blockSize;
+
+
+           ASSERT_EMPTY_TAIL(output);
+
+           ASSERT_SNR(output,ref,(float32_t)SNR_THRESHOLD);
+
+           ASSERT_REL_ERROR(output,ref,REL_ERROR);
+  
+
+    } 
+
+    void BIQUADF32::test_biquad_cascade_df1_rand()
+    {
+
+
+        float32_t *statep = state.ptr();
+
+        const float32_t *coefsp = coefs.ptr();
+        const int16_t *configsp = configs.ptr();
+        
+        const float32_t *inputp = inputs.ptr();
+        float32_t *outp = output.ptr();
+
+        #if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+        arm_biquad_mod_coef_f32 *coefsmodp = (arm_biquad_mod_coef_f32*)vecCoefs.ptr();
+        #endif
+
+        int blockSize;
+        int numStages;
+        int nb=0;
+        int i;
+
+        
+
+        for(i=0;i < configs.nbSamples(); i+=2)
+        {
+        /*
+
+        Python script is generating different tests with
+        different blockSize and numTaps.
+
+        We loop on those configs.
+
+        */
+        
+           
+           numStages = configsp[0];
+           blockSize = configsp[1];
+
+           configsp += 2;
+
+           /*
+
+           The filter is initialized with the coefs, blockSize and numTaps.
+
+           */
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+           arm_biquad_cascade_df1_mve_init_f32(&this->Sdf1,numStages,coefsp,coefsmodp,statep);
+#else
+           arm_biquad_cascade_df1_init_f32(&this->Sdf1,numStages,coefsp,statep);
+#endif
+
+
+           /*
+           
+           Python script is filtering a 2*blockSize number of samples.
+           We do the same filtering in two pass to check (indirectly that
+           the state management of the fir is working.)
+
+           */
+
+           arm_biquad_cascade_df1_f32(&this->Sdf1,inputp,outp,blockSize);
+
+           inputp += blockSize;
+           outp += blockSize;
+           coefsp += numStages * 5;
+
+           
+           
+        }
+           ASSERT_EMPTY_TAIL(output);
+
+           ASSERT_SNR(output,ref,(float32_t)SNR_THRESHOLD);
+
+           ASSERT_REL_ERROR(output,ref,REL_ERROR);
+  
+
+    } 
+
+    void BIQUADF32::test_biquad_cascade_df2T_rand()
+    {
+
+
+        float32_t *statep = state.ptr();
+        const int16_t *configsp = configs.ptr();
+
+#if !defined(ARM_MATH_NEON) 
+        const float32_t *coefsp = coefs.ptr();
+#else
+        float32_t *coefsp = coefs.ptr();
+#endif
+        
+        const float32_t *inputp = inputs.ptr();
+        float32_t *outp = output.ptr();
+
+        int blockSize;
+        int numStages;
+        int nb=0;
+
+        int i;
+
+        
+
+        for(i=0;i < configs.nbSamples(); i+=2)
+        {
+
+        /*
+
+        Python script is generating different tests with
+        different blockSize and numTaps.
+
+        We loop on those configs.
+
+        */
+        
+           numStages = configsp[0];
+           blockSize = configsp[1];
+
+           configsp += 2;
+
+          
+
+           /*
+
+           The filter is initialized with the coefs, blockSize and numTaps.
+
+           */
+#if !defined(ARM_MATH_NEON) 
+           arm_biquad_cascade_df2T_init_f32(&this->Sdf2T,numStages,coefsp,statep);
+#else
+           float32_t *vecCoefsPtr = vecCoefs.ptr();
+
+           arm_biquad_cascade_df2T_init_f32(&this->Sdf2T,
+                    numStages,
+                    vecCoefsPtr,
+                    statep);
+
+           // Those Neon coefs must be computed from original coefs
+           arm_biquad_cascade_df2T_compute_coefs_f32(&this->Sdf2T,numStages,coefsp);
+#endif
+           coefsp += numStages * 5;
+
+           /*
+           
+           Python script is filtering a 2*blockSize number of samples.
+           We do the same filtering in two pass to check (indirectly that
+           the state management of the fir is working.)
+
+           */
+
+           arm_biquad_cascade_df2T_f32(&this->Sdf2T,inputp,outp,blockSize);
+           outp += blockSize;
+           inputp += blockSize;
+           
+        }
+
+           ASSERT_EMPTY_TAIL(output);
+
+           ASSERT_SNR(output,ref,(float32_t)SNR_THRESHOLD);
+
+           ASSERT_REL_ERROR(output,ref,REL_ERROR);
+  
+
+    } 
+
+    void BIQUADF32::test_biquad_cascade_stereo_df2T_rand()
+    {
+
+
+        float32_t *statep = state.ptr();
+        const int16_t *configsp = configs.ptr();
+
+        const float32_t *coefsp = coefs.ptr();
+
+        
+        const float32_t *inputp = inputs.ptr();
+        float32_t *outp = output.ptr();
+
+        int blockSize;
+        int numStages;
+        int nb=0;
+
+        int i;
+
+        
+
+        for(i=0;i < configs.nbSamples(); i+=2)
+        {
+
+        /*
+
+        Python script is generating different tests with
+        different blockSize and numTaps.
+
+        We loop on those configs.
+
+        */
+        
+           numStages = configsp[0];
+           blockSize = configsp[1];
+
+           configsp += 2;
+
+          
+
+           /*
+
+           The filter is initialized with the coefs, blockSize and numTaps.
+
+           */
+           arm_biquad_cascade_stereo_df2T_init_f32(&this->SStereodf2T,numStages,coefsp,statep);
+
+           coefsp += numStages * 5;
+
+           /*
+           
+           Python script is filtering a 2*blockSize number of samples.
+           We do the same filtering in two pass to check (indirectly that
+           the state management of the fir is working.)
+
+           */
+
+           arm_biquad_cascade_stereo_df2T_f32(&this->SStereodf2T,inputp,outp,blockSize);
+           outp += 2*blockSize;
+           inputp += 2*blockSize;
+           
+        }
+
+           ASSERT_EMPTY_TAIL(output);
+
+           ASSERT_SNR(output,ref,(float32_t)SNR_THRESHOLD);
+
+           ASSERT_REL_ERROR(output,ref,REL_ERROR);
+  
+
+    } 
+
+    void BIQUADF32::setUp(Testing::testID_t id,std::vector<Testing::param_t>& params,Client::PatternMgr *mgr)
+    {
+      
+       Testing::nbSamples_t nb=MAX_NB_SAMPLES; 
+
+       
+       switch(id)
+       {
+        case BIQUADF32::TEST_BIQUAD_CASCADE_DF1_REF_1:
+            debugstate.create(2*64,BIQUADF32::STATE_F32_ID,mgr);
+
+            inputs.reload(BIQUADF32::BIQUADINPUTS_F32_ID,mgr);
+            coefs.reload(BIQUADF32::BIQUADCOEFS_F32_ID,mgr);
+            ref.reload(BIQUADF32::BIQUADREFS_F32_ID,mgr);
+            #if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+            /* Max num stages is 47 in Python script */
+            vecCoefs.create(32*47,BIQUADF32::OUT_F32_ID,mgr);
+            #endif
+        break;
+
+        case BIQUADF32::TEST_BIQUAD_CASCADE_DF2T_REF_2:
+           vecCoefs.create(64,BIQUADF32::OUT_F32_ID,mgr);
+
+           inputs.reload(BIQUADF32::BIQUADINPUTS_F32_ID,mgr);
+           coefs.reload(BIQUADF32::BIQUADCOEFS_F32_ID,mgr);
+           ref.reload(BIQUADF32::BIQUADREFS_F32_ID,mgr);
+        break;
+
+        case BIQUADF32::TEST_BIQUAD_CASCADE_DF1_RAND_3:
+
+            inputs.reload(BIQUADF32::ALLBIQUADINPUTS_F32_ID,mgr);
+            coefs.reload(BIQUADF32::ALLBIQUADCOEFS_F32_ID,mgr);
+            ref.reload(BIQUADF32::ALLBIQUADREFS_F32_ID,mgr);
+            configs.reload(BIQUADF32::ALLBIQUADCONFIGS_S16_ID,mgr);
+            #if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+            /* Max num stages is 47 in Python script */
+            vecCoefs.create(32*47,BIQUADF32::OUT_F32_ID,mgr);
+            #endif
+        break;
+
+        case BIQUADF32::TEST_BIQUAD_CASCADE_DF2T_RAND_4:
+           vecCoefs.create(512,BIQUADF32::OUT_F32_ID,mgr);
+
+           inputs.reload(BIQUADF32::ALLBIQUADINPUTS_F32_ID,mgr);
+           coefs.reload(BIQUADF32::ALLBIQUADCOEFS_F32_ID,mgr);
+           ref.reload(BIQUADF32::ALLBIQUADREFS_F32_ID,mgr);
+           configs.reload(BIQUADF32::ALLBIQUADCONFIGS_S16_ID,mgr);
+        break;
+
+        case BIQUADF32::TEST_BIQUAD_CASCADE_STEREO_DF2T_RAND_5:
+
+           inputs.reload(BIQUADF32::ALLBIQUADSTEREOINPUTS_F32_ID,mgr);
+           coefs.reload(BIQUADF32::ALLBIQUADCOEFS_F32_ID,mgr);
+           ref.reload(BIQUADF32::ALLBIQUADSTEREOREFS_F32_ID,mgr);
+           configs.reload(BIQUADF32::ALLBIQUADCONFIGS_S16_ID,mgr);
+        break;
+
+       }
+      
+
+       
+
+       output.create(ref.nbSamples(),BIQUADF32::OUT_F32_ID,mgr);
+      
+       state.create(128,BIQUADF32::STATE_F32_ID,mgr);
+
+       
+    }
+
+    void BIQUADF32::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
+    {
+        output.dump(mgr);
+        switch(id)
+        {
+            case BIQUADF32::TEST_BIQUAD_CASCADE_DF1_REF_1:
+               debugstate.dump(mgr);
+            break;
+        }
+    }

CMSIS/DSP/Testing/Source/Tests/BIQUADF64.cpp

@@ -0,0 +1,197 @@
+#include "BIQUADF64.h"
+#include "Error.h"
+
+#define SNR_THRESHOLD 98
+
+/* 
+
+Reference patterns are generated with
+a double precision computation.
+
+*/
+#define REL_ERROR (1.2e-3)
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+static __ALIGNED(8) float64_t coeffArray[64];
+#endif 
+
+    void BIQUADF64::test_biquad_cascade_df2T_ref()
+    {
+
+
+        float64_t *statep = state.ptr();
+
+
+        float64_t *coefsp = coefs.ptr();
+
+        
+        float64_t *inputp = inputs.ptr();
+        float64_t *outp = output.ptr();
+
+        int i,j;
+        int blockSize;
+        int numTaps;
+        int nb=0;
+
+        
+
+        /*
+
+        Python script is generating different tests with
+        different blockSize and numTaps.
+
+        We loop on those configs.
+
+        */
+        
+           blockSize = inputs.nbSamples() >> 1;
+           numTaps = coefs.nbSamples();
+
+           /*
+
+           The filter is initialized with the coefs, blockSize and numTaps.
+
+           */
+           arm_biquad_cascade_df2T_init_f64(&this->Sdf2T,3,coefsp,statep);
+
+
+           /*
+           
+           Python script is filtering a 2*blockSize number of samples.
+           We do the same filtering in two pass to check (indirectly that
+           the state management of the fir is working.)
+
+           */
+
+           arm_biquad_cascade_df2T_f64(&this->Sdf2T,inputp,outp,blockSize);
+           outp += blockSize;
+
+           
+           inputp += blockSize;
+           arm_biquad_cascade_df2T_f64(&this->Sdf2T,inputp,outp,blockSize);
+           outp += blockSize;
+
+
+           ASSERT_EMPTY_TAIL(output);
+
+           ASSERT_SNR(output,ref,(float64_t)SNR_THRESHOLD);
+
+           ASSERT_REL_ERROR(output,ref,REL_ERROR);
+  
+
+    } 
+
+ 
+
+    void BIQUADF64::test_biquad_cascade_df2T_rand()
+    {
+
+
+        float64_t *statep = state.ptr();
+        const int16_t *configsp = configs.ptr();
+
+        float64_t *coefsp = coefs.ptr();
+
+        
+        float64_t *inputp = inputs.ptr();
+        float64_t *outp = output.ptr();
+
+        int blockSize;
+        int numStages;
+        int nb=0;
+
+        int i;
+
+        
+
+        for(i=0;i < configs.nbSamples(); i+=2)
+        {
+
+        /*
+
+        Python script is generating different tests with
+        different blockSize and numTaps.
+
+        We loop on those configs.
+
+        */
+        
+           numStages = configsp[0];
+           blockSize = configsp[1];
+
+           configsp += 2;
+
+          
+
+           /*
+
+           The filter is initialized with the coefs, blockSize and numTaps.
+
+           */
+           arm_biquad_cascade_df2T_init_f64(&this->Sdf2T,numStages,coefsp,statep);
+
+           coefsp += numStages * 5;
+
+           /*
+           
+           Python script is filtering a 2*blockSize number of samples.
+           We do the same filtering in two pass to check (indirectly that
+           the state management of the fir is working.)
+
+           */
+
+           arm_biquad_cascade_df2T_f64(&this->Sdf2T,inputp,outp,blockSize);
+           outp += blockSize;
+           inputp += blockSize;
+           
+        }
+
+           ASSERT_EMPTY_TAIL(output);
+
+           ASSERT_SNR(output,ref,(float64_t)SNR_THRESHOLD);
+
+           ASSERT_REL_ERROR(output,ref,REL_ERROR);
+  
+
+    } 
+
+    void BIQUADF64::setUp(Testing::testID_t id,std::vector<Testing::param_t>& params,Client::PatternMgr *mgr)
+    {
+      
+       Testing::nbSamples_t nb=MAX_NB_SAMPLES; 
+
+       
+       switch(id)
+       {
+        case BIQUADF64::TEST_BIQUAD_CASCADE_DF2T_REF_1:
+
+           inputs.reload(BIQUADF64::BIQUADINPUTS_F64_ID,mgr);
+           coefs.reload(BIQUADF64::BIQUADCOEFS_F64_ID,mgr);
+           ref.reload(BIQUADF64::BIQUADREFS_F64_ID,mgr);
+        break;
+
+        case BIQUADF64::TEST_BIQUAD_CASCADE_DF2T_RAND_2:
+
+           inputs.reload(BIQUADF64::ALLBIQUADINPUTS_F64_ID,mgr);
+           coefs.reload(BIQUADF64::ALLBIQUADCOEFS_F64_ID,mgr);
+           ref.reload(BIQUADF64::ALLBIQUADREFS_F64_ID,mgr);
+           configs.reload(BIQUADF64::ALLBIQUADCONFIGS_S16_ID,mgr);
+        break;
+
+       }
+      
+
+       
+
+       output.create(ref.nbSamples(),BIQUADF64::OUT_F64_ID,mgr);
+      
+       state.create(128,BIQUADF64::STATE_F64_ID,mgr);
+
+       
+    }
+
+    void BIQUADF64::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
+    {
+        output.dump(mgr);
+       
+    }

CMSIS/DSP/Testing/Source/Tests/BIQUADQ15.cpp

@@ -0,0 +1,114 @@
+#include "BIQUADQ15.h"
+#include "Error.h"
+
+
+/*
+
+Accuracy issues on biquad df1 q15
+It will have to be reworked
+
+*/
+#define SNR_THRESHOLD 30
+
+#define ABS_ERROR_Q15 ((q15_t)500)
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+static __ALIGNED(8) q15_t coeffArray[32];
+#endif 
+
+    void BIQUADQ15::test_biquad_cascade_df1()
+    {
+
+
+        q15_t *statep = state.ptr();
+        const q15_t *coefsp = coefs.ptr();
+        
+        const q15_t *inputp = inputs.ptr();
+        q15_t *outp = output.ptr();
+
+        int i,j;
+        int blockSize;
+        int numTaps;
+        int nb=0;
+
+        
+
+        /*
+
+        Python script is generating different tests with
+        different blockSize and numTaps.
+
+        We loop on those configs.
+
+        */
+        
+           blockSize = inputs.nbSamples() >> 1;
+           numTaps = coefs.nbSamples();
+
+           /*
+
+           The filter is initialized with the coefs, blockSize and numTaps.
+
+           */
+
+           arm_biquad_cascade_df1_init_q15(&this->S,3,coefsp,statep,2);
+
+
+           /*
+           
+           Python script is filtering a 2*blockSize number of samples.
+           We do the same filtering in two pass to check (indirectly that
+           the state management of the fir is working.)
+
+           */
+
+           arm_biquad_cascade_df1_q15(&this->S,inputp,outp,blockSize);
+           outp += blockSize;
+           
+           inputp += blockSize;
+           arm_biquad_cascade_df1_q15(&this->S,inputp,outp,blockSize);
+           outp += blockSize;
+
+
+
+
+           ASSERT_EMPTY_TAIL(output);
+
+           ASSERT_SNR(output,ref,(q15_t)SNR_THRESHOLD);
+
+           ASSERT_NEAR_EQ(output,ref,ABS_ERROR_Q15);
+  
+
+    } 
+
+ 
+    void BIQUADQ15::setUp(Testing::testID_t id,std::vector<Testing::param_t>& params,Client::PatternMgr *mgr)
+    {
+      
+       Testing::nbSamples_t nb=MAX_NB_SAMPLES; 
+
+       
+       switch(id)
+       {
+        case BIQUADQ15::TEST_BIQUAD_CASCADE_DF1_1:
+        break;
+
+       }
+      
+
+       inputs.reload(BIQUADQ15::BIQUADINPUTS_Q15_ID,mgr);
+       coefs.reload(BIQUADQ15::BIQUADCOEFS_Q15_ID,mgr);
+       ref.reload(BIQUADQ15::BIQUADREFS_Q15_ID,mgr);
+
+       output.create(ref.nbSamples(),BIQUADQ15::OUT_Q15_ID,mgr);
+       /* max 4 * nbTaps as generated by Python script */
+       /* Same OUTID is reused. So linked to same output file. If it is dumped
+       it may overwrite the output
+       */
+       state.create(32,BIQUADQ15::OUT_Q15_ID,mgr);
+    }
+
+    void BIQUADQ15::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
+    {
+        output.dump(mgr);
+    }

CMSIS/DSP/Testing/Source/Tests/BIQUADQ31.cpp

@@ -0,0 +1,179 @@
+#include "BIQUADQ31.h"
+#include "Error.h"
+
+
+#define SNR_THRESHOLD 115
+
+#define ABS_ERROR_Q31 ((q31_t)1000)
+
+#define SNR_32x64_THRESHOLD 140
+
+#define ABS_32x64_ERROR_Q31 ((q31_t)25)
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+static __ALIGNED(8) q31_t coeffArray[32];
+#endif 
+
+    void BIQUADQ31::test_biquad_cascade_df1()
+    {
+
+
+        q31_t *statep = state.ptr();
+        const q31_t *coefsp = coefs.ptr();
+        
+        const q31_t *inputp = inputs.ptr();
+        q31_t *outp = output.ptr();
+
+        int i,j;
+        int blockSize;
+        int numTaps;
+        int nb=0;
+
+        
+
+        /*
+
+        Python script is generating different tests with
+        different blockSize and numTaps.
+
+        We loop on those configs.
+
+        */
+        
+           blockSize = inputs.nbSamples() >> 1;
+           numTaps = coefs.nbSamples();
+
+           /*
+
+           The filter is initialized with the coefs, blockSize and numTaps.
+
+           */
+
+           arm_biquad_cascade_df1_init_q31(&this->S,3,coefsp,statep,2);
+
+
+           /*
+           
+           Python script is filtering a 2*blockSize number of samples.
+           We do the same filtering in two pass to check (indirectly that
+           the state management of the fir is working.)
+
+           */
+
+           arm_biquad_cascade_df1_q31(&this->S,inputp,outp,blockSize);
+           outp += blockSize;
+           
+           inputp += blockSize;
+           arm_biquad_cascade_df1_q31(&this->S,inputp,outp,blockSize);
+           outp += blockSize;
+
+
+
+
+           ASSERT_EMPTY_TAIL(output);
+
+           ASSERT_SNR(output,ref,(q31_t)SNR_THRESHOLD);
+
+           ASSERT_NEAR_EQ(output,ref,ABS_ERROR_Q31);
+  
+
+    } 
+
+    void BIQUADQ31::test_biquad_cascade_df1_32x64()
+    {
+        q63_t *statep = state64.ptr();
+        const q31_t *coefsp = coefs.ptr();
+        
+        q31_t *inputp = inputs.ptr();
+        q31_t *outp = output.ptr();
+
+        int i,j;
+        int blockSize;
+        int numTaps;
+        int nb=0;
+
+        
+
+        /*
+
+        Python script is generating different tests with
+        different blockSize and numTaps.
+
+        We loop on those configs.
+
+        */
+        
+           blockSize = inputs.nbSamples() >> 1;
+           numTaps = coefs.nbSamples();
+
+           /*
+
+           The filter is initialized with the coefs, blockSize and numTaps.
+
+           */
+
+           arm_biquad_cas_df1_32x64_init_q31(&this->S32x64,3,coefsp,statep,2);
+
+
+           /*
+           
+           Python script is filtering a 2*blockSize number of samples.
+           We do the same filtering in two pass to check (indirectly that
+           the state management of the fir is working.)
+
+           */
+
+           arm_biquad_cas_df1_32x64_q31(&this->S32x64,inputp,outp,blockSize);
+           outp += blockSize;
+           
+           inputp += blockSize;
+           arm_biquad_cas_df1_32x64_q31(&this->S32x64,inputp,outp,blockSize);
+           outp += blockSize;
+
+
+
+
+           ASSERT_EMPTY_TAIL(output);
+
+           ASSERT_SNR(output,ref,(q31_t)SNR_32x64_THRESHOLD);
+
+           ASSERT_NEAR_EQ(output,ref,ABS_32x64_ERROR_Q31);
+  
+    }
+
+ 
+    void BIQUADQ31::setUp(Testing::testID_t id,std::vector<Testing::param_t>& params,Client::PatternMgr *mgr)
+    {
+      
+       Testing::nbSamples_t nb=MAX_NB_SAMPLES; 
+
+       
+       switch(id)
+       {
+        case BIQUADQ31::TEST_BIQUAD_CASCADE_DF1_1:
+          /* max 4 * nbTaps as generated by Python script */
+          /* Same OUTID is reused. So linked to same output file. If it is dumped
+             it may overwrite the output
+          */
+          state.create(32,BIQUADQ31::OUT_Q31_ID,mgr);
+          
+        break;
+
+        case BIQUADQ31::TEST_BIQUAD_CASCADE_DF1_32X64_2:
+          state64.create(32,BIQUADQ31::STATE_Q64_ID,mgr);
+        break;
+
+       }
+      
+       inputs.reload(BIQUADQ31::BIQUADINPUTS_Q31_ID,mgr);
+       coefs.reload(BIQUADQ31::BIQUADCOEFS_Q31_ID,mgr);
+       ref.reload(BIQUADQ31::BIQUADREFS_Q31_ID,mgr);
+       output.create(ref.nbSamples(),BIQUADQ31::OUT_Q31_ID,mgr);
+
+       
+    }
+
+    void BIQUADQ31::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
+    {
+        output.dump(mgr);
+    }

CMSIS/DSP/Testing/TestScripts/Deprecate.py

@@ -11,6 +11,14 @@ def correctDeprecation(node):
     node.data["deprecated"] = current
     return(current)
 
+def inheritDeprecation(node,deprecated):
+    current = node.data["deprecated"] or deprecated
+    node.data["deprecated"] = current
+    if node.kind != TestScripts.Parser.TreeElem.TEST:
+      for c in node.children:
+        inheritDeprecation(c,current)
+        
+
 def deprecateRec(root,others,deprecated):
     if others:
         newOthers=others.copy()
@@ -35,6 +43,7 @@ def deprecateRec(root,others,deprecated):
                  deprecateRec(c,others,deprecated)
 
 def deprecate(root,others):
+    inheritDeprecation(root,False)
     if others:
        deprecateRec(root,deque(others),True)
        correctDeprecation(root)

CMSIS/DSP/Testing/desc.txt

@@ -1784,6 +1784,98 @@ group Root {
 
              }
            }
+
+           group BIQUAD {
+             class = BIQUAD 
+             folder = BIQUAD
+
+             suite BIQUAD F64 {
+                class = BIQUADF64
+                folder = BIQUADF64
+
+                Pattern BIQUADINPUTS_F64_ID : BiquadInput1_f64.txt
+                Pattern BIQUADCOEFS_F64_ID : BiquadCoefs1_f64.txt
+                Pattern BIQUADREFS_F64_ID : BiquadOutput1_f64.txt
+
+                Pattern ALLBIQUADINPUTS_F64_ID : AllBiquadInputs2_f64.txt
+                Pattern ALLBIQUADCOEFS_F64_ID : AllBiquadCoefs2_f64.txt
+                Pattern ALLBIQUADREFS_F64_ID : AllBiquadRefs2_f64.txt
+                Pattern ALLBIQUADCONFIGS_S16_ID : AllBiquadConfigs2_s16.txt
+
+                Output  OUT_F64_ID : Output
+                Output  STATE_F64_ID : State
+
+                Functions {
+                  arm_biquad_cascade_df2T ref pattern:test_biquad_cascade_df2T_ref
+                  arm_biquad_cascade_df2T random pattern:test_biquad_cascade_df2T_rand
+                }
+             }
+
+             suite BIQUAD F32 {
+                class = BIQUADF32 
+                folder = BIQUADF32
+
+                Pattern BIQUADINPUTS_F32_ID : BiquadInput1_f32.txt
+                Pattern BIQUADCOEFS_F32_ID : BiquadCoefs1_f32.txt
+                Pattern BIQUADREFS_F32_ID : BiquadOutput1_f32.txt
+
+                Pattern ALLBIQUADINPUTS_F32_ID : AllBiquadInputs2_f32.txt
+                Pattern ALLBIQUADSTEREOINPUTS_F32_ID : AllBiquadStereoInputs2_f32.txt
+                Pattern ALLBIQUADCOEFS_F32_ID : AllBiquadCoefs2_f32.txt
+                Pattern ALLBIQUADREFS_F32_ID : AllBiquadRefs2_f32.txt
+                Pattern ALLBIQUADSTEREOREFS_F32_ID : AllBiquadStereoRefs2_f32.txt
+                Pattern ALLBIQUADCONFIGS_S16_ID : AllBiquadConfigs2_s16.txt
+
+                Output  OUT_F32_ID : Output
+                Output  STATE_F32_ID : State
+
+                Functions {
+                  arm_biquad_cascade_df1 ref pattern:test_biquad_cascade_df1_ref
+                  arm_biquad_cascade_df2T ref pattern:test_biquad_cascade_df2T_ref
+                  arm_biquad_cascade_df1 random pattern:test_biquad_cascade_df1_rand
+                  arm_biquad_cascade_df2T random pattern:test_biquad_cascade_df2T_rand
+                  arm_biquad_cascade_stereo_df2T random pattern:test_biquad_cascade_stereo_df2T_rand
+                }
+
+             }
+
+             suite BIQUAD Q31 {
+                class = BIQUADQ31
+                folder = BIQUADQ31
+
+                Pattern BIQUADINPUTS_Q31_ID : BiquadInput1_q31.txt
+                Pattern BIQUADCOEFS_Q31_ID : BiquadCoefs1_q31.txt
+
+                Pattern BIQUADREFS_Q31_ID : BiquadOutput1_q31.txt
+
+                Output  OUT_Q31_ID : Output
+                Output  STATE_Q64_ID : State64
+
+                Functions {
+                  arm_biquad_cascade_df1:test_biquad_cascade_df1
+                  arm_biquad_cascade_df1_32x64:test_biquad_cascade_df1_32x64
+                }
+
+             }
+
+             suite BIQUAD Q15 {
+                class = BIQUADQ15
+                folder = BIQUADQ15
+
+                Pattern BIQUADINPUTS_Q15_ID : BiquadInput1_q15.txt
+                Pattern BIQUADCOEFS_Q15_ID : BiquadCoefs1_q15.txt
+
+                Pattern BIQUADREFS_Q15_ID : BiquadOutput1_q15.txt
+
+                Output  OUT_Q15_ID : Output
+
+                Functions {
+                  arm_biquad_cascade_df1:test_biquad_cascade_df1
+                }
+
+             }
+           }
+
         }
 
         group Matrix Tests {
@@ -2000,7 +2092,7 @@ group Root {
            class = TransformTests
            folder = Transform 
 
-           suite Transform Complex F64 {
+           disabled {suite Transform Complex F64 {
               class = TransformCF64
               folder = TransformF64
 
@@ -2118,8 +2210,9 @@ group Root {
               }
 
             }
+           }
 
-           suite Transform Real F64 {
+           disabled { suite Transform Real F64 {
               class = TransformRF64
               folder = TransformF64
 
@@ -2226,6 +2319,7 @@ group Root {
               }
 
             }
+           }
 
            suite Transform Complex F32 {
               class = TransformCF32