CMSIS-DSP: Added complex math f16

Include/arm_helium_utils.h

@@ -80,6 +80,8 @@ __STATIC_FORCEINLINE float16_t vecAddAcrossF16Mve(float16x8_t in)
 
 /* newton initial guess */
 #define INVSQRT_MAGIC_F32           0x5f3759df
+#define INV_NEWTON_INIT_F32         0x7EF127EA
+
 
 #define INVSQRT_NEWTON_MVE_F32(invSqrt, xHalf, xStart)\
 {                                                     \
@@ -95,6 +97,74 @@ __STATIC_FORCEINLINE float16_t vecAddAcrossF16Mve(float16x8_t in)
 }
 #endif /* defined (ARM_MATH_HELIUM) || defined(ARM_MATH_MVEF) */
 
+
+/***************************************
+
+Definitions available for f16 datatype with HW acceleration only
+
+***************************************/
+#if defined (ARM_MATH_MVE_FLOAT16)
+__STATIC_FORCEINLINE float16x8_t __mve_cmplx_sum_intra_vec_f16(
+    float16x8_t   vecIn)
+{
+    float16x8_t   vecTmp, vecOut;
+    uint32_t    tmp;
+
+    vecTmp = (float16x8_t) vrev64q_s32((int32x4_t) vecIn);
+    // TO TRACK : using canonical addition leads to unefficient code generation for f16
+    // vecTmp = vecTmp + vecAccCpx0;
+    /*
+     * Compute
+     *  re0+re1 | im0+im1 | re0+re1 | im0+im1
+     *  re2+re3 | im2+im3 | re2+re3 | im2+im3
+     */
+    vecTmp = vaddq(vecTmp, vecIn);
+    vecOut = vecTmp;
+    /*
+     * shift left, random tmp insertion in bottom
+     */
+    vecOut = vreinterpretq_f16_s32(vshlcq_s32(vreinterpretq_s32_f16(vecOut)   , &tmp, 32));
+    /*
+     * Compute:
+     *    DONTCARE     |    DONTCARE     | re0+re1+re0+re1 |im0+im1+im0+im1
+     * re0+re1+re2+re3 | im0+im1+im2+im3 | re2+re3+re2+re3 |im2+im3+im2+im3
+     */
+    vecOut = vaddq(vecOut, vecTmp);
+    /*
+     * Cmplx sum is in 4rd & 5th f16 elt
+     * return full vector
+     */
+    return vecOut;
+}
+
+
+#define mve_cmplx_sum_intra_r_i_f16(vec, Re, Im)                \
+{                                                               \
+    float16x8_t   vecOut = __mve_cmplx_sum_intra_vec_f16(vec);    \
+    Re = vgetq_lane(vecOut, 4);                                 \
+    Im = vgetq_lane(vecOut, 5);                                 \
+}
+
+
+#define INVSQRT_MAGIC_F16           0x59ba      /*  ( 0x1ba = 0x3759df >> 13) */
+#define INV_NEWTON_INIT_F16         0x7773
+
+/* canonical version of INVSQRT_NEWTON_MVE_F16 leads to bad performance */
+#define INVSQRT_NEWTON_MVE_F16(invSqrt, xHalf, xStart)                  \
+{                                                                       \
+    float16x8_t tmp;                                                      \
+                                                                        \
+    /* tmp = xhalf * x * x */                                           \
+    tmp = vmulq(xStart, xStart);                                        \
+    tmp = vmulq(tmp, xHalf);                                            \
+    /* (1.5f - xhalf * x * x) */                                        \
+    tmp = vsubq(vdupq_n_f16((float16_t)1.5), tmp);                      \
+    /* x = x*(1.5f-xhalf*x*x); */                                       \
+    invSqrt = vmulq(tmp, xStart);                                       \
+}
+
+#endif
+
 /***************************************
 
 Definitions available for MVEI only

Include/dsp/basic_math_functions_f16.h

@@ -36,6 +36,7 @@ extern "C"
 
 #include "dsp/none.h"
 #include "dsp/utils.h"
+#include "dsp/fast_math_functions_f16.h"
 
 
 #if defined(ARM_FLOAT16_SUPPORTED)

Include/dsp/complex_math_functions_f16.h

@@ -26,12 +26,94 @@
 #ifndef _COMPLEX_MATH_FUNCTIONS_F16_H_
 #define _COMPLEX_MATH_FUNCTIONS_F16_H_
 
+#include "arm_math_types_f16.h"
+#include "arm_math_memory.h"
+
+#include "dsp/none.h"
+#include "dsp/utils.h"
+#include "dsp/fast_math_functions_f16.h"
+
 #ifdef   __cplusplus
 extern "C"
 {
 #endif
 
 #if defined(ARM_FLOAT16_SUPPORTED)
+
+ /**
+   * @brief  Floating-point complex conjugate.
+   * @param[in]  pSrc        points to the input vector
+   * @param[out] pDst        points to the output vector
+   * @param[in]  numSamples  number of complex samples in each vector
+   */
+  void arm_cmplx_conj_f16(
+  const float16_t * pSrc,
+        float16_t * pDst,
+        uint32_t numSamples);
+
+ /**
+   * @brief  Floating-point complex magnitude squared
+   * @param[in]  pSrc        points to the complex input vector
+   * @param[out] pDst        points to the real output vector
+   * @param[in]  numSamples  number of complex samples in the input vector
+   */
+  void arm_cmplx_mag_squared_f16(
+  const float16_t * pSrc,
+        float16_t * pDst,
+        uint32_t numSamples);
+
+  /**
+   * @brief  Floating-point complex magnitude
+   * @param[in]  pSrc        points to the complex input vector
+   * @param[out] pDst        points to the real output vector
+   * @param[in]  numSamples  number of complex samples in the input vector
+   */
+  void arm_cmplx_mag_f16(
+  const float16_t * pSrc,
+        float16_t * pDst,
+        uint32_t numSamples);
+
+  /**
+   * @brief  Floating-point complex dot product
+   * @param[in]  pSrcA       points to the first input vector
+   * @param[in]  pSrcB       points to the second input vector
+   * @param[in]  numSamples  number of complex samples in each vector
+   * @param[out] realResult  real part of the result returned here
+   * @param[out] imagResult  imaginary part of the result returned here
+   */
+  void arm_cmplx_dot_prod_f16(
+  const float16_t * pSrcA,
+  const float16_t * pSrcB,
+        uint32_t numSamples,
+        float16_t * realResult,
+        float16_t * imagResult);
+
+   /**
+   * @brief  Floating-point complex-by-real multiplication
+   * @param[in]  pSrcCmplx   points to the complex input vector
+   * @param[in]  pSrcReal    points to the real input vector
+   * @param[out] pCmplxDst   points to the complex output vector
+   * @param[in]  numSamples  number of samples in each vector
+   */
+  void arm_cmplx_mult_real_f16(
+  const float16_t * pSrcCmplx,
+  const float16_t * pSrcReal,
+        float16_t * pCmplxDst,
+        uint32_t numSamples);
+
+  /**
+   * @brief  Floating-point complex-by-complex multiplication
+   * @param[in]  pSrcA       points to the first input vector
+   * @param[in]  pSrcB       points to the second input vector
+   * @param[out] pDst        points to the output vector
+   * @param[in]  numSamples  number of complex samples in each vector
+   */
+  void arm_cmplx_mult_cmplx_f16(
+  const float16_t * pSrcA,
+  const float16_t * pSrcB,
+        float16_t * pDst,
+        uint32_t numSamples);
+
 #endif /*defined(ARM_FLOAT16_SUPPORTED)*/
 #ifdef   __cplusplus
 }

Include/dsp/fast_math_functions_f16.h

@@ -26,12 +26,46 @@
 #ifndef _FAST_MATH_FUNCTIONS_F16_H_
 #define _FAST_MATH_FUNCTIONS_F16_H_
 
+#include "arm_math_types_f16.h"
+#include "arm_math_memory.h"
+
+#include "dsp/none.h"
+#include "dsp/utils.h"
+#include "dsp/fast_math_functions.h"
+
 #ifdef   __cplusplus
 extern "C"
 {
 #endif
 
 #if defined(ARM_FLOAT16_SUPPORTED)
+
+ /**
+   * @addtogroup SQRT
+   * @{
+   */
+
+/**
+  @brief         Floating-point square root function.
+  @param[in]     in    input value
+  @param[out]    pOut  square root of input value
+  @return        execution status
+                   - \ref ARM_MATH_SUCCESS        : input value is positive
+                   - \ref ARM_MATH_ARGUMENT_ERROR : input value is negative; *pOut is set to 0
+ */
+__STATIC_FORCEINLINE arm_status arm_sqrt_f16(
+  float16_t in,
+  float16_t * pOut)
+  {
+    float32_t r;
+    arm_status status;
+    status=arm_sqrt_f32((float32_t)in,&r);
+    *pOut=(float16_t)r;
+    return(status);
+  }
+
+
+
 #endif /*defined(ARM_FLOAT16_SUPPORTED)*/
 #ifdef   __cplusplus
 }

Source/ComplexMathFunctions/CMakeLists.txt

@@ -5,8 +5,6 @@ project(CMSISDSPComplexMath)
 include(configLib)
 include(configDsp)
 
-file(GLOB SRC "./*_*.c")
-
 add_library(CMSISDSPComplexMath STATIC)
 
 configLib(CMSISDSPComplexMath ${ROOT})
@@ -56,6 +54,14 @@ target_sources(CMSISDSPComplexMath PRIVATE arm_cmplx_mult_real_f32.c)
 target_sources(CMSISDSPComplexMath PRIVATE arm_cmplx_mult_real_q15.c)
 target_sources(CMSISDSPComplexMath PRIVATE arm_cmplx_mult_real_q31.c)
 
+if ((NOT ARMAC5) AND (NOT DISABLEFLOAT16))
+target_sources(CMSISDSPComplexMath PRIVATE arm_cmplx_conj_f16.c)
+target_sources(CMSISDSPComplexMath PRIVATE arm_cmplx_dot_prod_f16.c)
+target_sources(CMSISDSPComplexMath PRIVATE arm_cmplx_mag_f16.c)
+target_sources(CMSISDSPComplexMath PRIVATE arm_cmplx_mag_squared_f16.c)
+target_sources(CMSISDSPComplexMath PRIVATE arm_cmplx_mult_cmplx_f16.c)
+target_sources(CMSISDSPComplexMath PRIVATE arm_cmplx_mult_real_f16.c)
+endif()
 
 ### Includes
 target_include_directories(CMSISDSPComplexMath PUBLIC "${DSP}/Include")

Source/ComplexMathFunctions/ComplexMathFunctionsF16.c

@@ -0,0 +1,32 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        CompexMathFunctionsF16.c
+ * Description:  Combination of all complex math function f16 source files.
+ *
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2020 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "arm_cmplx_conj_f16.c"
+#include "arm_cmplx_dot_prod_f16.c"
+#include "arm_cmplx_mag_f16.c"
+#include "arm_cmplx_mag_squared_f16.c"
+#include "arm_cmplx_mult_cmplx_f16.c"
+#include "arm_cmplx_mult_real_f16.c"

Source/ComplexMathFunctions/arm_cmplx_conj_f16.c

@@ -0,0 +1,183 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_cmplx_conj_f16.c
+ * Description:  Floating-point complex conjugate
+ *
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2020 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "dsp/complex_math_functions_f16.h"
+
+#if defined(ARM_FLOAT16_SUPPORTED)
+/**
+  @ingroup groupCmplxMath
+ */
+
+/**
+  @defgroup cmplx_conj Complex Conjugate
+
+  Conjugates the elements of a complex data vector.
+
+  The <code>pSrc</code> points to the source data and
+  <code>pDst</code> points to the destination data where the result should be written.
+  <code>numSamples</code> specifies the number of complex samples
+  and the data in each array is stored in an interleaved fashion
+  (real, imag, real, imag, ...).
+  Each array has a total of <code>2*numSamples</code> values.
+
+  The underlying algorithm is used:
+  <pre>
+  for (n = 0; n < numSamples; n++) {
+      pDst[(2*n)  ] =  pSrc[(2*n)  ];    // real part
+      pDst[(2*n)+1] = -pSrc[(2*n)+1];    // imag part
+  }
+  </pre>
+
+  There are separate functions for floating-point, Q15, and Q31 data types.
+ */
+
+/**
+  @addtogroup cmplx_conj
+  @{
+ */
+
+/**
+  @brief         Floating-point complex conjugate.
+  @param[in]     pSrc        points to the input vector
+  @param[out]    pDst        points to the output vector
+  @param[in]     numSamples  number of samples in each vector
+  @return        none
+ */
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+void arm_cmplx_conj_f16(
+    const float16_t * pSrc,
+    float16_t * pDst,
+    uint32_t numSamples)
+{
+    static const float16_t cmplx_conj_sign[8] = { 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f };
+    uint32_t blockSize = numSamples * CMPLX_DIM;   /* loop counters */
+    uint32_t blkCnt;
+    f16x8_t vecSrc;
+    f16x8_t vecSign;
+
+    /*
+     * load sign vector
+     */
+    vecSign = *(f16x8_t *) cmplx_conj_sign;
+
+    /* Compute 4 real samples at a time */
+    blkCnt = blockSize >> 3U;
+
+    while (blkCnt > 0U)
+    {
+        vecSrc = vld1q(pSrc);
+        vst1q(pDst,vmulq(vecSrc, vecSign));
+        /*
+         * Decrement the blkCnt loop counter
+         * Advance vector source and destination pointers
+         */
+        pSrc += 8;
+        pDst += 8;
+        blkCnt--;
+    }
+
+     /* Tail */
+    blkCnt = (blockSize & 0x7) >> 1;
+
+    while (blkCnt > 0U)
+    {
+      /* C[0] + jC[1] = A[0]+ j(-1)A[1] */
+  
+      /* Calculate Complex Conjugate and store result in destination buffer. */
+      *pDst++ =  *pSrc++;
+      *pDst++ = -*pSrc++;
+  
+      /* Decrement loop counter */
+      blkCnt--;
+    }
+
+}
+
+#else
+void arm_cmplx_conj_f16(
+  const float16_t * pSrc,
+        float16_t * pDst,
+        uint32_t numSamples)
+{
+        uint32_t blkCnt;                               /* Loop counter */
+
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+  /* Loop unrolling: Compute 4 outputs at a time */
+  blkCnt = numSamples >> 2U;
+
+  while (blkCnt > 0U)
+  {
+    /* C[0] + jC[1] = A[0]+ j(-1)A[1] */
+
+    /* Calculate Complex Conjugate and store result in destination buffer. */
+    *pDst++ =  *pSrc++;
+    *pDst++ = -*pSrc++;
+
+    *pDst++ =  *pSrc++;
+    *pDst++ = -*pSrc++;
+
+    *pDst++ =  *pSrc++;
+    *pDst++ = -*pSrc++;
+
+    *pDst++ =  *pSrc++;
+    *pDst++ = -*pSrc++;
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+  /* Loop unrolling: Compute remaining outputs */
+  blkCnt = numSamples % 0x4U;
+
+#else
+
+  /* Initialize blkCnt with number of samples */
+  blkCnt = numSamples;
+
+#endif /* #if defined (ARM_MATH_LOOPUNROLL) */
+
+  while (blkCnt > 0U)
+  {
+    /* C[0] + jC[1] = A[0]+ j(-1)A[1] */
+
+    /* Calculate Complex Conjugate and store result in destination buffer. */
+    *pDst++ =  *pSrc++;
+    *pDst++ = -*pSrc++;
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+}
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
+
+/**
+  @} end of cmplx_conj group
+ */
+#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */

Source/ComplexMathFunctions/arm_cmplx_dot_prod_f16.c

@@ -0,0 +1,236 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_cmplx_dot_prod_f16.c
+ * Description:  Floating-point complex dot product
+ *
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2020 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "dsp/complex_math_functions_f16.h"
+
+#if defined(ARM_FLOAT16_SUPPORTED)
+
+
+/**
+  @ingroup groupCmplxMath
+ */
+
+/**
+  @defgroup cmplx_dot_prod Complex Dot Product
+
+  Computes the dot product of two complex vectors.
+  The vectors are multiplied element-by-element and then summed.
+
+  The <code>pSrcA</code> points to the first complex input vector and
+  <code>pSrcB</code> points to the second complex input vector.
+  <code>numSamples</code> specifies the number of complex samples
+  and the data in each array is stored in an interleaved fashion
+  (real, imag, real, imag, ...).
+  Each array has a total of <code>2*numSamples</code> values.
+
+  The underlying algorithm is used:
+
+  <pre>
+  realResult = 0;
+  imagResult = 0;
+  for (n = 0; n < numSamples; n++) {
+      realResult += pSrcA[(2*n)+0] * pSrcB[(2*n)+0] - pSrcA[(2*n)+1] * pSrcB[(2*n)+1];
+      imagResult += pSrcA[(2*n)+0] * pSrcB[(2*n)+1] + pSrcA[(2*n)+1] * pSrcB[(2*n)+0];
+  }
+  </pre>
+
+  There are separate functions for floating-point, Q15, and Q31 data types.
+ */
+
+/**
+  @addtogroup cmplx_dot_prod
+  @{
+ */
+
+/**
+  @brief         Floating-point complex dot product.
+  @param[in]     pSrcA       points to the first input vector
+  @param[in]     pSrcB       points to the second input vector
+  @param[in]     numSamples  number of samples in each vector
+  @param[out]    realResult  real part of the result returned here
+  @param[out]    imagResult  imaginary part of the result returned here
+  @return        none
+ */
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_cmplx_dot_prod_f16(
+    const float16_t * pSrcA,
+    const float16_t * pSrcB,
+    uint32_t numSamples,
+    float16_t * realResult,
+    float16_t * imagResult)
+{
+    uint32_t blockSize = numSamples * CMPLX_DIM;  /* loop counters */
+    uint32_t blkCnt;
+    float16_t real_sum, imag_sum;
+    f16x8_t vecSrcA, vecSrcB;
+    f16x8_t vec_acc = vdupq_n_f16(0.0f);
+
+    /* Compute 2 complex samples at a time */
+    blkCnt = blockSize >> 3U;
+
+    while (blkCnt > 0U)
+    {
+        vecSrcA = vld1q(pSrcA);
+        vecSrcB = vld1q(pSrcB);
+
+        vec_acc = vcmlaq(vec_acc, vecSrcA, vecSrcB);
+        vec_acc = vcmlaq_rot90(vec_acc, vecSrcA, vecSrcB);
+
+        /*
+         * Decrement the blkCnt loop counter
+         * Advance vector source and destination pointers
+         */
+        pSrcA += 8;
+        pSrcB += 8;
+        blkCnt--;
+    }
+   
+    /* Tail */
+    blkCnt = (blockSize & 7);
+
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp16q(blkCnt);
+        vecSrcA = vld1q(pSrcA);
+        vecSrcB = vld1q(pSrcB);
+        vec_acc = vcmlaq_m(vec_acc, vecSrcA, vecSrcB, p0);
+        vec_acc = vcmlaq_rot90_m(vec_acc, vecSrcA, vecSrcB, p0);
+    }
+
+    /* Sum the partial parts */
+    mve_cmplx_sum_intra_r_i_f16(vec_acc, real_sum, imag_sum);
+
+    /*
+     * Store the real and imaginary results in the destination buffers
+     */
+    *realResult = real_sum;
+    *imagResult = imag_sum;
+}
+
+#else
+void arm_cmplx_dot_prod_f16(
+  const float16_t * pSrcA,
+  const float16_t * pSrcB,
+        uint32_t numSamples,
+        float16_t * realResult,
+        float16_t * imagResult)
+{
+        uint32_t blkCnt;                               /* Loop counter */
+        float16_t real_sum = 0.0f, imag_sum = 0.0f;    /* Temporary result variables */
+        float16_t a0,b0,c0,d0;
+
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+  /* Loop unrolling: Compute 4 outputs at a time */
+  blkCnt = numSamples >> 2U;
+
+  while (blkCnt > 0U)
+  {
+    a0 = *pSrcA++;
+    b0 = *pSrcA++;
+    c0 = *pSrcB++;
+    d0 = *pSrcB++;
+
+    real_sum += a0 * c0;
+    imag_sum += a0 * d0;
+    real_sum -= b0 * d0;
+    imag_sum += b0 * c0;
+
+    a0 = *pSrcA++;
+    b0 = *pSrcA++;
+    c0 = *pSrcB++;
+    d0 = *pSrcB++;
+
+    real_sum += a0 * c0;
+    imag_sum += a0 * d0;
+    real_sum -= b0 * d0;
+    imag_sum += b0 * c0;
+
+    a0 = *pSrcA++;
+    b0 = *pSrcA++;
+    c0 = *pSrcB++;
+    d0 = *pSrcB++;
+
+    real_sum += a0 * c0;
+    imag_sum += a0 * d0;
+    real_sum -= b0 * d0;
+    imag_sum += b0 * c0;
+
+    a0 = *pSrcA++;
+    b0 = *pSrcA++;
+    c0 = *pSrcB++;
+    d0 = *pSrcB++;
+
+    real_sum += a0 * c0;
+    imag_sum += a0 * d0;
+    real_sum -= b0 * d0;
+    imag_sum += b0 * c0;
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+  /* Loop unrolling: Compute remaining outputs */
+  blkCnt = numSamples % 0x4U;
+
+#else
+
+  /* Initialize blkCnt with number of samples */
+  blkCnt = numSamples;
+
+#endif /* #if defined (ARM_MATH_LOOPUNROLL) */
+
+  while (blkCnt > 0U)
+  {
+    a0 = *pSrcA++;
+    b0 = *pSrcA++;
+    c0 = *pSrcB++;
+    d0 = *pSrcB++;
+
+    real_sum += a0 * c0;
+    imag_sum += a0 * d0;
+    real_sum -= b0 * d0;
+    imag_sum += b0 * c0;
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+  /* Store real and imaginary result in destination buffer. */
+  *realResult = real_sum;
+  *imagResult = imag_sum;
+}
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
+
+/**
+  @} end of cmplx_dot_prod group
+ */
+
+#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */

Source/ComplexMathFunctions/arm_cmplx_mag_f16.c

@@ -0,0 +1,239 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_cmplx_mag_f16.c
+ * Description:  Floating-point complex magnitude
+ *
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2020 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "dsp/complex_math_functions_f16.h"
+
+#if defined(ARM_FLOAT16_SUPPORTED)
+/**
+  @ingroup groupCmplxMath
+ */
+
+/**
+  @defgroup cmplx_mag Complex Magnitude
+
+  Computes the magnitude of the elements of a complex data vector.
+
+  The <code>pSrc</code> points to the source data and
+  <code>pDst</code> points to the where the result should be written.
+  <code>numSamples</code> specifies the number of complex samples
+  in the input array and the data is stored in an interleaved fashion
+  (real, imag, real, imag, ...).
+  The input array has a total of <code>2*numSamples</code> values;
+  the output array has a total of <code>numSamples</code> values.
+
+  The underlying algorithm is used:
+
+  <pre>
+  for (n = 0; n < numSamples; n++) {
+      pDst[n] = sqrt(pSrc[(2*n)+0]^2 + pSrc[(2*n)+1]^2);
+  }
+  </pre>
+
+  There are separate functions for floating-point, Q15, and Q31 data types.
+ */
+
+/**
+  @addtogroup cmplx_mag
+  @{
+ */
+
+/**
+  @brief         Floating-point complex magnitude.
+  @param[in]     pSrc        points to input vector
+  @param[out]    pDst        points to output vector
+  @param[in]     numSamples  number of samples in each vector
+  @return        none
+ */
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+
+void arm_cmplx_mag_f16(
+  const float16_t * pSrc,
+        float16_t * pDst,
+        uint32_t numSamples)
+{
+    int32_t blockSize = numSamples;  /* loop counters */
+    uint32_t  blkCnt;           /* loop counters */
+    f16x8x2_t vecSrc;
+    f16x8_t sum;
+
+    /* Compute 4 complex samples at a time */
+    blkCnt = blockSize >> 3;
+    while (blkCnt > 0U)
+    {
+        q15x8_t newtonStartVec;
+        f16x8_t sumHalf, invSqrt;
+
+        vecSrc = vld2q(pSrc);  
+        pSrc += 16;
+        sum = vmulq(vecSrc.val[0], vecSrc.val[0]);
+        sum = vfmaq(sum, vecSrc.val[1], vecSrc.val[1]);
+
+        /*
+         * inlined Fast SQRT using inverse SQRT newton-raphson method
+         */
+
+        /* compute initial value */
+        newtonStartVec = vdupq_n_s16(INVSQRT_MAGIC_F16) - vshrq((q15x8_t) sum, 1);
+        sumHalf = sum * 0.5f;
+        /*
+         * compute 3 x iterations
+         *
+         * The more iterations, the more accuracy.
+         * If you need to trade a bit of accuracy for more performance,
+         * you can comment out the 3rd use of the macro.
+         */
+        INVSQRT_NEWTON_MVE_F16(invSqrt, sumHalf, (f16x8_t) newtonStartVec);
+        INVSQRT_NEWTON_MVE_F16(invSqrt, sumHalf, invSqrt);
+        INVSQRT_NEWTON_MVE_F16(invSqrt, sumHalf, invSqrt);
+        /*
+         * set negative values to 0
+         */
+        invSqrt = vdupq_m(invSqrt, (float16_t)0.0f, vcmpltq(invSqrt, (float16_t)0.0f));
+        /*
+         * sqrt(x) = x * invSqrt(x)
+         */
+        sum = vmulq(sum, invSqrt);
+        vstrhq_f16(pDst, sum); 
+        pDst += 8;
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 7;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp16q(blkCnt);
+        q15x8_t newtonStartVec;
+        f16x8_t sumHalf, invSqrt;
+
+        vecSrc = vld2q((float16_t const *)pSrc);
+        sum = vmulq(vecSrc.val[0], vecSrc.val[0]);
+        sum = vfmaq(sum, vecSrc.val[1], vecSrc.val[1]);
+
+        /*
+         * inlined Fast SQRT using inverse SQRT newton-raphson method
+         */
+
+        /* compute initial value */
+        newtonStartVec = vdupq_n_s16(INVSQRT_MAGIC_F16) - vshrq((q15x8_t) sum, 1);
+        sumHalf = vmulq(sum, (float16_t)0.5);
+        /*
+         * compute 2 x iterations
+         */
+        INVSQRT_NEWTON_MVE_F16(invSqrt, sumHalf, (f16x8_t) newtonStartVec);
+        INVSQRT_NEWTON_MVE_F16(invSqrt, sumHalf, invSqrt);
+        /*
+         * set negative values to 0
+         */
+        invSqrt = vdupq_m(invSqrt, (float16_t)0.0, vcmpltq(invSqrt, (float16_t)0.0));
+        /*
+         * sqrt(x) = x * invSqrt(x)
+         */
+        sum = vmulq(sum, invSqrt);
+        vstrhq_p_f16(pDst, sum, p0);
+    }
+}
+
+#else
+void arm_cmplx_mag_f16(
+  const float16_t * pSrc,
+        float16_t * pDst,
+        uint32_t numSamples)
+{
+  uint32_t blkCnt;                               /* loop counter */
+  float16_t real, imag;                      /* Temporary variables to hold input values */
+
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+  /* Loop unrolling: Compute 4 outputs at a time */
+  blkCnt = numSamples >> 2U;
+
+  while (blkCnt > 0U)
+  {
+    /* C[0] = sqrt(A[0] * A[0] + A[1] * A[1]) */
+
+    real = *pSrc++;
+    imag = *pSrc++;
+
+    /* store result in destination buffer. */
+    arm_sqrt_f16((real * real) + (imag * imag), pDst++);
+
+    real = *pSrc++;
+    imag = *pSrc++;
+    arm_sqrt_f16((real * real) + (imag * imag), pDst++);
+
+    real = *pSrc++;
+    imag = *pSrc++;
+    arm_sqrt_f16((real * real) + (imag * imag), pDst++);
+
+    real = *pSrc++;
+    imag = *pSrc++;
+    arm_sqrt_f16((real * real) + (imag * imag), pDst++);
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+  /* Loop unrolling: Compute remaining outputs */
+  blkCnt = numSamples % 0x4U;
+
+#else
+
+  /* Initialize blkCnt with number of samples */
+  blkCnt = numSamples;
+
+#endif /* #if defined (ARM_MATH_LOOPUNROLL) */
+
+  while (blkCnt > 0U)
+  {
+    /* C[0] = sqrt(A[0] * A[0] + A[1] * A[1]) */
+
+    real = *pSrc++;
+    imag = *pSrc++;
+
+    /* store result in destination buffer. */
+    arm_sqrt_f16((real * real) + (imag * imag), pDst++);
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+}
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
+
+/**
+  @} end of cmplx_mag group
+ */
+
+#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */

Source/ComplexMathFunctions/arm_cmplx_mag_squared_f16.c

@@ -0,0 +1,172 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_cmplx_mag_squared_f16.c
+ * Description:  Floating-point complex magnitude squared
+ *
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2020 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "dsp/complex_math_functions_f16.h"
+
+#if defined(ARM_FLOAT16_SUPPORTED)
+
+/**
+  @ingroup groupCmplxMath
+ */
+
+/**
+  @defgroup cmplx_mag_squared Complex Magnitude Squared
+
+  Computes the magnitude squared of the elements of a complex data vector.
+
+  The <code>pSrc</code> points to the source data and
+  <code>pDst</code> points to the where the result should be written.
+  <code>numSamples</code> specifies the number of complex samples
+  in the input array and the data is stored in an interleaved fashion
+  (real, imag, real, imag, ...).
+  The input array has a total of <code>2*numSamples</code> values;
+  the output array has a total of <code>numSamples</code> values.
+
+  The underlying algorithm is used:
+
+  <pre>
+  for (n = 0; n < numSamples; n++) {
+      pDst[n] = pSrc[(2*n)+0]^2 + pSrc[(2*n)+1]^2;
+  }
+  </pre>
+
+  There are separate functions for floating-point, Q15, and Q31 data types.
+ */
+
+/**
+  @addtogroup cmplx_mag_squared
+  @{
+ */
+
+/**
+  @brief         Floating-point complex magnitude squared.
+  @param[in]     pSrc        points to input vector
+  @param[out]    pDst        points to output vector
+  @param[in]     numSamples  number of samples in each vector
+  @return        none
+ */
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+void arm_cmplx_mag_squared_f16(
+  const float16_t * pSrc,
+        float16_t * pDst,
+        uint32_t numSamples)
+{
+    int32_t blockSize = numSamples;  /* loop counters */
+    f16x8x2_t vecSrc;
+    f16x8_t sum;
+
+    /* Compute 4 complex samples at a time */
+    while (blockSize > 0)
+    {
+        mve_pred16_t p = vctp16q(blockSize);
+        vecSrc = vld2q(pSrc);
+        sum = vmulq_m(vuninitializedq_f16(),vecSrc.val[0], vecSrc.val[0],p);
+        sum = vfmaq_m(sum, vecSrc.val[1], vecSrc.val[1],p);
+        vstrhq_p_f16(pDst, sum,p);
+
+        pSrc += 16;
+        pDst += 8;
+        
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blockSize-= 8;
+    }
+
+}
+
+#else
+void arm_cmplx_mag_squared_f16(
+  const float16_t * pSrc,
+        float16_t * pDst,
+        uint32_t numSamples)
+{
+        uint32_t blkCnt;                               /* Loop counter */
+        float16_t real, imag;                          /* Temporary input variables */
+
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+  /* Loop unrolling: Compute 4 outputs at a time */
+  blkCnt = numSamples >> 2U;
+
+  while (blkCnt > 0U)
+  {
+    /* C[0] = (A[0] * A[0] + A[1] * A[1]) */
+
+    real = *pSrc++;
+    imag = *pSrc++;
+    *pDst++ = (real * real) + (imag * imag);
+
+    real = *pSrc++;
+    imag = *pSrc++;
+    *pDst++ = (real * real) + (imag * imag);
+
+    real = *pSrc++;
+    imag = *pSrc++;
+    *pDst++ = (real * real) + (imag * imag);
+
+    real = *pSrc++;
+    imag = *pSrc++;
+    *pDst++ = (real * real) + (imag * imag);
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+  /* Loop unrolling: Compute remaining outputs */
+  blkCnt = numSamples % 0x4U;
+
+#else
+
+  /* Initialize blkCnt with number of samples */
+  blkCnt = numSamples;
+
+#endif /* #if defined (ARM_MATH_LOOPUNROLL) */
+
+  while (blkCnt > 0U)
+  {
+    /* C[0] = (A[0] * A[0] + A[1] * A[1]) */
+
+    real = *pSrc++;
+    imag = *pSrc++;
+
+    /* store result in destination buffer. */
+    *pDst++ = (real * real) + (imag * imag);
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+}
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
+
+/**
+  @} end of cmplx_mag_squared group
+ */
+
+#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */

Source/ComplexMathFunctions/arm_cmplx_mult_cmplx_f16.c

@@ -0,0 +1,217 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_cmplx_mult_cmplx_f16.c
+ * Description:  Floating-point complex-by-complex multiplication
+ *
+ * $Date:        18. March 2019
+ * $Revision:    V1.6.0
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "dsp/complex_math_functions_f16.h"
+
+#if defined(ARM_FLOAT16_SUPPORTED)
+
+/**
+  @ingroup groupCmplxMath
+ */
+
+/**
+  @defgroup CmplxByCmplxMult Complex-by-Complex Multiplication
+
+  Multiplies a complex vector by another complex vector and generates a complex result.
+  The data in the complex arrays is stored in an interleaved fashion
+  (real, imag, real, imag, ...).
+  The parameter <code>numSamples</code> represents the number of complex
+  samples processed.  The complex arrays have a total of <code>2*numSamples</code>
+  real values.
+
+  The underlying algorithm is used:
+
+  <pre>
+  for (n = 0; n < numSamples; n++) {
+      pDst[(2*n)+0] = pSrcA[(2*n)+0] * pSrcB[(2*n)+0] - pSrcA[(2*n)+1] * pSrcB[(2*n)+1];
+      pDst[(2*n)+1] = pSrcA[(2*n)+0] * pSrcB[(2*n)+1] + pSrcA[(2*n)+1] * pSrcB[(2*n)+0];
+  }
+  </pre>
+
+  There are separate functions for floating-point, Q15, and Q31 data types.
+ */
+
+/**
+  @addtogroup CmplxByCmplxMult
+  @{
+ */
+
+/**
+  @brief         Floating-point complex-by-complex multiplication.
+  @param[in]     pSrcA       points to first input vector
+  @param[in]     pSrcB       points to second input vector
+  @param[out]    pDst        points to output vector
+  @param[in]     numSamples  number of samples in each vector
+  @return        none
+ */
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+void arm_cmplx_mult_cmplx_f16(
+  const float16_t * pSrcA,
+  const float16_t * pSrcB,
+        float16_t * pDst,
+        uint32_t numSamples)
+{
+    int32_t  blkCnt;           /* loop counters */
+    int32_t  blockSize = numSamples;
+    f16x8_t vecA;
+    f16x8_t vecB;
+    f16x8_t vecDst;
+
+    blkCnt = blockSize * CMPLX_DIM;
+    blkCnt = blkCnt >> 3;
+
+    while (blkCnt > 0) 
+    {
+        vecA = vldrhq_f16(pSrcA);
+        vecB = vldrhq_f16(pSrcB);
+        /* C[2 * i] = A[2 * i] * B[2 * i] - A[2 * i + 1] * B[2 * i + 1].  */
+        vecDst = vcmulq(vecA, vecB);
+        /* C[2 * i + 1] = A[2 * i] * B[2 * i + 1] + A[2 * i + 1] * B[2 * i].  */
+        vecDst = vcmlaq_rot90(vecDst, vecA, vecB);
+        vstrhq_f16(pDst, vecDst);
+
+        blkCnt--;
+        pSrcA += 8;
+        pSrcB += 8;
+        pDst += 8;
+    }
+
+    float16_t a, b, c, d;  /* Temporary variables to store real and imaginary values */
+        /* Tail */
+    blkCnt = (blockSize & 7) >> 1;
+    while (blkCnt > 0)
+    {
+      /* C[2 * i    ] = A[2 * i] * B[2 * i    ] - A[2 * i + 1] * B[2 * i + 1]. */
+      /* C[2 * i + 1] = A[2 * i] * B[2 * i + 1] + A[2 * i + 1] * B[2 * i    ]. */
+
+      a = *pSrcA++;
+      b = *pSrcA++;
+      c = *pSrcB++;
+      d = *pSrcB++;
+
+      /* store result in destination buffer. */
+      *pDst++ = (a * c) - (b * d);
+      *pDst++ = (a * d) + (b * c);
+
+      /* Decrement loop counter */
+      blkCnt--;
+    }
+}
+
+
+#else
+void arm_cmplx_mult_cmplx_f16(
+  const float16_t * pSrcA,
+  const float16_t * pSrcB,
+        float16_t * pDst,
+        uint32_t numSamples)
+{
+    uint32_t blkCnt;                               /* Loop counter */
+    float16_t a, b, c, d;  /* Temporary variables to store real and imaginary values */
+
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+  /* Loop unrolling: Compute 4 outputs at a time */
+  blkCnt = numSamples >> 2U;
+
+  while (blkCnt > 0U)
+  {
+    /* C[2 * i    ] = A[2 * i] * B[2 * i    ] - A[2 * i + 1] * B[2 * i + 1]. */
+    /* C[2 * i + 1] = A[2 * i] * B[2 * i + 1] + A[2 * i + 1] * B[2 * i    ]. */
+
+    a = *pSrcA++;
+    b = *pSrcA++;
+    c = *pSrcB++;
+    d = *pSrcB++;
+    /* store result in destination buffer. */
+    *pDst++ = (a * c) - (b * d);
+    *pDst++ = (a * d) + (b * c);
+
+    a = *pSrcA++;
+    b = *pSrcA++;
+    c = *pSrcB++;
+    d = *pSrcB++;
+    *pDst++ = (a * c) - (b * d);
+    *pDst++ = (a * d) + (b * c);
+
+    a = *pSrcA++;
+    b = *pSrcA++;
+    c = *pSrcB++;
+    d = *pSrcB++;
+    *pDst++ = (a * c) - (b * d);
+    *pDst++ = (a * d) + (b * c);
+
+    a = *pSrcA++;
+    b = *pSrcA++;
+    c = *pSrcB++;
+    d = *pSrcB++;
+    *pDst++ = (a * c) - (b * d);
+    *pDst++ = (a * d) + (b * c);
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+  /* Loop unrolling: Compute remaining outputs */
+  blkCnt = numSamples % 0x4U;
+
+#else
+
+  /* Initialize blkCnt with number of samples */
+  blkCnt = numSamples;
+
+#endif /* #if defined (ARM_MATH_LOOPUNROLL) */
+
+  while (blkCnt > 0U)
+  {
+    /* C[2 * i    ] = A[2 * i] * B[2 * i    ] - A[2 * i + 1] * B[2 * i + 1]. */
+    /* C[2 * i + 1] = A[2 * i] * B[2 * i + 1] + A[2 * i + 1] * B[2 * i    ]. */
+
+    a = *pSrcA++;
+    b = *pSrcA++;
+    c = *pSrcB++;
+    d = *pSrcB++;
+
+    /* store result in destination buffer. */
+    *pDst++ = (a * c) - (b * d);
+    *pDst++ = (a * d) + (b * c);
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+}
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
+
+/**
+  @} end of CmplxByCmplxMult group
+ */
+
+#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */

Source/ComplexMathFunctions/arm_cmplx_mult_real_f16.c

@@ -0,0 +1,192 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_cmplx_mult_real_f16.c
+ * Description:  Floating-point complex by real multiplication
+ *
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2020 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "dsp/complex_math_functions_f16.h"
+
+#if defined(ARM_FLOAT16_SUPPORTED)
+
+/**
+  @ingroup groupCmplxMath
+ */
+
+/**
+  @defgroup CmplxByRealMult Complex-by-Real Multiplication
+
+  Multiplies a complex vector by a real vector and generates a complex result.
+  The data in the complex arrays is stored in an interleaved fashion
+  (real, imag, real, imag, ...).
+  The parameter <code>numSamples</code> represents the number of complex
+  samples processed.  The complex arrays have a total of <code>2*numSamples</code>
+  real values while the real array has a total of <code>numSamples</code>
+  real values.
+
+  The underlying algorithm is used:
+
+  <pre>
+  for (n = 0; n < numSamples; n++) {
+      pCmplxDst[(2*n)+0] = pSrcCmplx[(2*n)+0] * pSrcReal[n];
+      pCmplxDst[(2*n)+1] = pSrcCmplx[(2*n)+1] * pSrcReal[n];
+  }
+  </pre>
+
+  There are separate functions for floating-point, Q15, and Q31 data types.
+ */
+
+/**
+  @addtogroup CmplxByRealMult
+  @{
+ */
+
+/**
+  @brief         Floating-point complex-by-real multiplication.
+  @param[in]     pSrcCmplx   points to complex input vector
+  @param[in]     pSrcReal    points to real input vector
+  @param[out]    pCmplxDst   points to complex output vector
+  @param[in]     numSamples  number of samples in each vector
+  @return        none
+ */
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+void arm_cmplx_mult_real_f16(
+  const float16_t * pSrcCmplx,
+  const float16_t * pSrcReal,
+        float16_t * pCmplxDst,
+        uint32_t numSamples)
+{
+    const static uint16_t stride_cmplx_x_real_16[8] = {
+        0, 0, 1, 1, 2, 2, 3, 3
+        };
+    uint32_t blockSizeC = numSamples * CMPLX_DIM;   /* loop counters */
+    uint32_t blkCnt;
+    f16x8_t rVec;
+    f16x8_t cmplxVec;
+    f16x8_t dstVec;
+    uint16x8_t strideVec;
+
+
+    /* stride vector for pairs of real generation */
+    strideVec = vld1q(stride_cmplx_x_real_16);
+
+    /* Compute 4 complex outputs at a time */
+    blkCnt = blockSizeC >> 3;
+    while (blkCnt > 0U) 
+    {
+        cmplxVec = vld1q(pSrcCmplx);
+        rVec = vldrhq_gather_shifted_offset_f16(pSrcReal, strideVec);
+        dstVec = vmulq(cmplxVec, rVec);
+        vst1q(pCmplxDst, dstVec);
+
+        pSrcReal += 4;
+        pSrcCmplx += 8;
+        pCmplxDst += 8;
+        blkCnt--;
+    }
+
+    blkCnt = blockSizeC & 7;
+    if (blkCnt > 0U) {
+        mve_pred16_t p0 = vctp16q(blkCnt);
+
+        cmplxVec = vld1q(pSrcCmplx);
+        rVec = vldrhq_gather_shifted_offset_f16(pSrcReal, strideVec);
+        dstVec = vmulq(cmplxVec, rVec);
+        vstrhq_p_f16(pCmplxDst, dstVec, p0);
+    }
+}
+
+#else
+void arm_cmplx_mult_real_f16(
+  const float16_t * pSrcCmplx,
+  const float16_t * pSrcReal,
+        float16_t * pCmplxDst,
+        uint32_t numSamples)
+{
+        uint32_t blkCnt;                               /* Loop counter */
+        float16_t in;                                  /* Temporary variable */
+
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+  /* Loop unrolling: Compute 4 outputs at a time */
+  blkCnt = numSamples >> 2U;
+
+  while (blkCnt > 0U)
+  {
+    /* C[2 * i    ] = A[2 * i    ] * B[i]. */
+    /* C[2 * i + 1] = A[2 * i + 1] * B[i]. */
+
+    in = *pSrcReal++;
+    /* store result in destination buffer. */
+    *pCmplxDst++ = *pSrcCmplx++ * in;
+    *pCmplxDst++ = *pSrcCmplx++ * in;
+
+    in = *pSrcReal++;
+    *pCmplxDst++ = *pSrcCmplx++ * in;
+    *pCmplxDst++ = *pSrcCmplx++ * in;
+
+    in = *pSrcReal++;
+    *pCmplxDst++ = *pSrcCmplx++ * in;
+    *pCmplxDst++ = *pSrcCmplx++ * in;
+
+    in = *pSrcReal++;
+    *pCmplxDst++ = *pSrcCmplx++* in;
+    *pCmplxDst++ = *pSrcCmplx++ * in;
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+  /* Loop unrolling: Compute remaining outputs */
+  blkCnt = numSamples % 0x4U;
+
+#else
+
+  /* Initialize blkCnt with number of samples */
+  blkCnt = numSamples;
+
+#endif /* #if defined (ARM_MATH_LOOPUNROLL) */
+
+  while (blkCnt > 0U)
+  {
+    /* C[2 * i    ] = A[2 * i    ] * B[i]. */
+    /* C[2 * i + 1] = A[2 * i + 1] * B[i]. */
+
+    in = *pSrcReal++;
+    /* store result in destination buffer. */
+    *pCmplxDst++ = *pSrcCmplx++ * in;
+    *pCmplxDst++ = *pSrcCmplx++ * in;
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+}
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
+
+/**
+  @} end of CmplxByRealMult group
+ */
+
+#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */

Testing/CMakeLists.txt

@@ -327,6 +327,7 @@ set(TESTSRC
 if ((NOT ARMAC5) AND (FLOAT16TESTS) AND ((FLOAT16) OR (MVEF) OR (HELIUM) OR (NEON) OR (NEONEXPERIMENTAL)))
 set(TESTSRC16 
   Source/Tests/BasicTestsF16.cpp
+  Source/Tests/ComplexTestsF16.cpp
   Source/Tests/TransformCF16.cpp
   Source/Tests/TransformRF16.cpp
   )

Testing/Include/Tests/ComplexTestsF16.h

@@ -0,0 +1,21 @@
+#include "Test.h"
+#include "Pattern.h"
+
+#include "dsp/complex_math_functions_f16.h"
+
+
+class ComplexTestsF16:public Client::Suite
+    {
+        public:
+            ComplexTestsF16(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 "ComplexTestsF16_decl.h"
+            
+            Client::Pattern<float16_t> input1;
+            Client::Pattern<float16_t> input2;
+            Client::LocalPattern<float16_t> output;
+            // Reference patterns are not loaded when we are in dump mode
+            Client::RefPattern<float16_t> ref;
+    };

Testing/PatternGeneration/ComplexMaths.py

@@ -105,11 +105,13 @@ def  generatePatterns():
      PARAMDIR = os.path.join("Parameters","DSP","ComplexMaths","ComplexMaths")
      
      configf32=Tools.Config(PATTERNDIR,PARAMDIR,"f32")
+     configf16=Tools.Config(PATTERNDIR,PARAMDIR,"f16")
      configq31=Tools.Config(PATTERNDIR,PARAMDIR,"q31")
      configq15=Tools.Config(PATTERNDIR,PARAMDIR,"q15")
      
      
      writeTests(configf32,0)
+     writeTests(configf16,16)
      writeTests(configq31,31)
      writeTests(configq15,15)
 

Testing/Patterns/DSP/ComplexMaths/ComplexMathsF16/Input1_f16.txt

@@ -0,0 +1,1026 @@
+H
+512
+// -0.190784
+0xb21b
+// -0.091654
+0xadde
+// 0.071822
+0x2c99
+// 0.147638
+0x30b9
+// 0.286048
+0x3494
+// -0.271081
+0xb456
+// -0.697050
+0xb994
+// -0.463404
+0xb76a
+// 0.194499
+0x3239
+// -0.058274
+0xab76
+// 0.114183
+0x2f4f
+// 0.583218
+0x38aa
+// 0.330052
+0x3548
+// 0.268445
+0x344c
+// -0.557581
+0xb876
+// -0.410190
+0xb690
+// 0.272990
+0x345e
+// -0.393479
+0xb64c
+// -0.116202
+0xaf70
+// -0.721886
+0xb9c6
+// -0.213211
+0xb2d3
+// 0.083483
+0x2d58
+// -0.374075
+0xb5fc
+// 0.198101
+0x3257
+// -0.398395
+0xb660
+// -0.560209
+0xb87b
+// 0.048614
+0x2a39
+// 0.635820
+0x3916
+// -0.091076
+0xadd4
+// -0.390076
+0xb63e
+// 0.073176
+0x2caf
+// -0.275342
+0xb468
+// -0.212389
+0xb2cc
+// -0.772148
+0xba2d
+// -0.172327
+0xb184
+// 0.502172
+0x3804
+// 0.111732
+0x2f27
+// 0.892060
+0x3b23
+// 0.050152
+0x2a6b
+// -0.045235
+0xa9ca
+// -0.345404
+0xb587
+// -0.236645
+0xb393
+// 0.071838
+0x2c99
+// 0.415857
+0x36a7
+// 0.599356
+0x38cb
+// -0.030207
+0xa7bc
+// -0.094837
+0xae12
+// -0.018655
+0xa4c7
+// 0.310711
+0x34f9
+// -0.223677
+0xb328
+// -0.553400
+0xb86d
+// 0.001849
+0x1793
+// 0.074133
+0x2cbf
+// 0.080981
+0x2d2f
+// 0.293681
+0x34b3
+// 0.679882
+0x3970
+// -0.628950
+0xb908
+// 0.543036
+0x3858
+// 0.288096
+0x349c
+// -0.314617
+0xb509
+// 0.008941
+0x2094
+// -0.281210
+0xb480
+// 0.134949
+0x3051
+// 0.234598
+0x3382
+// -0.047845
+0xaa20
+// -0.350960
+0xb59e
+// 0.848249
+0x3ac9
+// 0.613374
+0x38e8
+// -0.438045
+0xb702
+// 0.829299
+0x3aa2
+// -0.392637
+0xb648
+// -0.269273
+0xb44f
+// 0.339954
+0x3570
+// 0.145916
+0x30ab
+// 0.022215
+0x25b0
+// 0.334099
+0x3558
+// 0.312490
+0x3500
+// -0.066518
+0xac42
+// -0.009386
+0xa0ce
+// 0.119294
+0x2fa3
+// -0.515181
+0xb81f
+// -0.420252
+0xb6b9
+// -0.634564
+0xb914
+// -0.093181
+0xadf7
+// -0.245987
+0xb3df
+// 0.334221
+0x3559
+// 0.300029
+0x34cd
+// -0.767856
+0xba25
+// -0.383899
+0xb624
+// 0.127684
+0x3016
+// 0.203534
+0x3283
+// 0.197151
+0x324f
+// 0.461939
+0x3764
+// 0.073480
+0x2cb4
+// -0.358199
+0xb5bb
+// -0.300925
+0xb4d1
+// -0.095023
+0xae15
+// -0.103263
+0xae9c
+// -0.106033
+0xaec9
+// 0.388054
+0x3635
+// -1.000000
+0xbc00
+// 0.082423
+0x2d46
+// -0.044897
+0xa9bf
+// -0.137322
+0xb065
+// -0.179832
+0xb1c1
+// 0.424530
+0x36cb
+// 0.140982
+0x3083
+// 0.446902
+0x3727
+// -0.035516
+0xa88c
+// 0.608230
+0x38de
+// 0.195101
+0x323e
+// -0.525550
+0xb834
+// -0.303026
+0xb4d9
+// 0.277534
+0x3471
+// -0.092106
+0xade5
+// -0.174064
+0xb192
+// -0.200301
+0xb269
+// 0.160421
+0x3122
+// -0.259599
+0xb427
+// 0.349249
+0x3597
+// -0.152659
+0xb0e3
+// 0.286340
+0x3495
+// -0.008274
+0xa03d
+// 0.371525
+0x35f2
+// 0.074143
+0x2cbf
+// 0.205714
+0x3295
+// -0.169983
+0xb171
+// 0.276524
+0x346d
+// -0.025333
+0xa67c
+// 0.092119
+0x2de5
+// -0.265870
+0xb441
+// -0.037141
+0xa8c1
+// 0.384053
+0x3625
+// 0.108276
+0x2eee
+// -0.409038
+0xb68b
+// -0.035318
+0xa885
+// 0.528830
+0x383b
+// -0.082829
+0xad4d
+// 0.291412
+0x34aa
+// 0.073902
+0x2cbb
+// 0.413185
+0x369c
+// -0.025412
+0xa681
+// 0.260122
+0x3429
+// -0.044555
+0xa9b4
+// 0.123585
+0x2fe9
+// -0.190842
+0xb21b
+// -0.233187
+0xb376
+// -0.078043
+0xacff
+// 0.423401
+0x36c6
+// -0.136719
+0xb060
+// 0.469315
+0x3782
+// 0.129213
+0x3023
+// 0.207801
+0x32a6
+// 0.327814
+0x353f
+// -0.056665
+0xab41
+// 0.298600
+0x34c7
+// -0.293294
+0xb4b1
+// 0.129624
+0x3026
+// 0.195203
+0x323f
+// 0.112247
+0x2f2f
+// 0.263289
+0x3436
+// 0.773798
+0x3a31
+// 0.256735
+0x341c
+// 0.404828
+0x367a
+// 0.676366
+0x3969
+// 0.526304
+0x3836
+// 0.151284
+0x30d7
+// 0.322640
+0x352a
+// 0.065563
+0x2c32
+// -0.117193
+0xaf80
+// -0.026112
+0xa6af
+// -0.323225
+0xb52c
+// 0.384034
+0x3625
+// -0.419571
+0xb6b7
+// -0.161330
+0xb12a
+// 0.255380
+0x3416
+// 0.076765
+0x2cea
+// -0.210946
+0xb2c0
+// 0.329633
+0x3546
+// 0.216146
+0x32eb
+// -0.566272
+0xb888
+// 0.113051
+0x2f3c
+// 0.217060
+0x32f2
+// -0.124587
+0xaff9
+// 0.138246
+0x306d
+// 0.513390
+0x381b
+// 0.400914
+0x366a
+// -0.140241
+0xb07d
+// -0.643821
+0xb927
+// -0.111858
+0xaf29
+// -0.082079
+0xad41
+// -0.305358
+0xb4e3
+// -0.018046
+0xa49f
+// 0.227073
+0x3344
+// -0.015413
+0xa3e4
+// -0.183604
+0xb1e0
+// -0.069889
+0xac79
+// -0.057719
+0xab63
+// -0.251284
+0xb405
+// -0.388552
+0xb638
+// -0.290348
+0xb4a5
+// -0.184703
+0xb1e9
+// -0.098634
+0xae50
+// 0.224607
+0x3330
+// 0.065603
+0x2c33
+// -0.075874
+0xacdb
+// -0.446554
+0xb725
+// -0.031660
+0xa80d
+// 0.194868
+0x323c
+// -0.663546
+0xb94f
+// -0.344696
+0xb584
+// 0.115373
+0x2f62
+// -0.376122
+0xb605
+// 0.264123
+0x343a
+// -0.190886
+0xb21c
+// 0.525617
+0x3834
+// 0.067548
+0x2c53
+// -0.098252
+0xae4a
+// -0.569751
+0xb88f
+// 0.391645
+0x3644
+// 0.388041
+0x3635
+// 0.170622
+0x3176
+// 0.076320
+0x2ce2
+// 0.052063
+0x2aaa
+// -0.013621
+0xa2f9
+// -0.009318
+0xa0c5
+// -0.086077
+0xad82
+// 0.380233
+0x3615
+// -0.101300
+0xae7c
+// -0.294013
+0xb4b4
+// -0.083146
+0xad52
+// 0.501720
+0x3804
+// -0.428573
+0xb6db
+// 0.125989
+0x3008
+// 0.277520
+0x3471
+// 0.090883
+0x2dd1
+// -0.122190
+0xafd2
+// 0.252426
+0x340a
+// 0.363431
+0x35d1
+// 0.077910
+0x2cfc
+// -0.093576
+0xadfd
+// -0.211400
+0xb2c4
+// -0.364776
+0xb5d6
+// 0.294128
+0x34b5
+// 0.016042
+0x241b
+// 0.033808
+0x2854
+// 0.176922
+0x31a9
+// 0.450358
+0x3735
+// 0.375269
+0x3601
+// 0.218647
+0x32ff
+// -0.116245
+0xaf71
+// -0.115976
+0xaf6c
+// -0.431688
+0xb6e8
+// -0.394426
+0xb650
+// -0.157245
+0xb108
+// -0.213304
+0xb2d3
+// -0.337097
+0xb565
+// 0.156474
+0x3102
+// 0.657004
+0x3942
+// -0.081579
+0xad39
+// -0.280747
+0xb47e
+// 0.492273
+0x37e0
+// -0.484703
+0xb7c1
+// 0.108728
+0x2ef5
+// -0.294784
+0xb4b7
+// 0.439698
+0x3709
+// -0.022943
+0xa5e0
+// 0.397221
+0x365b
+// 0.226002
+0x333b
+// 0.449882
+0x3733
+// 0.026734
+0x26d8
+// 0.151814
+0x30dc
+// -0.052161
+0xaaad
+// 0.432675
+0x36ec
+// 0.702654
+0x399f
+// 0.623854
+0x38fe
+// -0.294212
+0xb4b5
+// 0.184520
+0x31e8
+// -0.176992
+0xb1aa
+// 0.098278
+0x2e4a
+// 0.722656
+0x39c8
+// -0.417647
+0xb6af
+// 0.397952
+0x365e
+// -0.339095
+0xb56d
+// 0.363564
+0x35d1
+// -0.398928
+0xb662
+// -0.096797
+0xae32
+// -0.378620
+0xb60f
+// 0.197204
+0x324f
+// 0.184326
+0x31e6
+// 0.401392
+0x366c
+// 0.343814
+0x3580
+// 0.121889
+0x2fcd
+// -0.073084
+0xacad
+// -0.289407
+0xb4a1
+// 0.416686
+0x36ab
+// 0.098654
+0x2e50
+// 0.181763
+0x31d1
+// -0.345023
+0xb585
+// 0.715047
+0x39b8
+// -0.789478
+0xba51
+// 0.273947
+0x3462
+// 0.578569
+0x38a1
+// 0.338427
+0x356a
+// 0.088798
+0x2daf
+// 0.071466
+0x2c93
+// 0.049715
+0x2a5d
+// -0.469836
+0xb784
+// -0.489806
+0xb7d6
+// 0.301345
+0x34d2
+// -0.175808
+0xb1a0
+// -0.711336
+0xb9b1
+// -0.549467
+0xb865
+// 0.219787
+0x3308
+// 0.497011
+0x37f4
+// 0.227910
+0x334b
+// -0.292937
+0xb4b0
+// -0.046002
+0xa9e3
+// 0.010423
+0x2156
+// 0.261211
+0x342e
+// -0.548199
+0xb863
+// -0.160683
+0xb124
+// 0.209818
+0x32b7
+// -0.550566
+0xb868
+// 0.797021
+0x3a60
+// -0.202658
+0xb27c
+// 0.351454
+0x35a0
+// 0.083937
+0x2d5f
+// -0.036793
+0xa8b6
+// -0.149267
+0xb0c7
+// 0.407582
+0x3685
+// 0.227306
+0x3346
+// -0.273277
+0xb45f
+// -0.283114
+0xb488
+// 0.071705
+0x2c97
+// -0.718338
+0xb9bf
+// -0.019170
+0xa4e8
+// -0.083900
+0xad5f
+// 0.330361
+0x3549
+// -0.025872
+0xa6a0
+// 0.094594
+0x2e0e
+// -0.614355
+0xb8ea
+// -0.312080
+0xb4fe
+// -0.411203
+0xb694
+// -0.736344
+0xb9e4
+// -0.230057
+0xb35d
+// -0.193205
+0xb22f
+// 0.373161
+0x35f8
+// 0.358530
+0x35bd
+// -0.223042
+0xb323
+// 0.271586
+0x3458
+// 0.201713
+0x3274
+// 0.553892
+0x386e
+// 0.499516
+0x37fe
+// 0.153245
+0x30e7
+// 0.632118
+0x390f
+// 0.307657
+0x34ec
+// -0.456707
+0xb74f
+// 0.399091
+0x3663
+// -0.104631
+0xaeb2
+// -0.118470
+0xaf95
+// 0.263137
+0x3436
+// -0.337336
+0xb566
+// 0.105794
+0x2ec5
+// 0.123551
+0x2fe8
+// 0.188344
+0x3207
+// -0.015292
+0xa3d4
+// -0.193681
+0xb233
+// -0.042520
+0xa971
+// 0.546278
+0x385f
+// 0.259574
+0x3427
+// -0.152328
+0xb0e0
+// -0.223776
+0xb329
+// -0.451761
+0xb73a
+// 0.340963
+0x3575
+// -0.968638
+0xbbc0
+// 0.149531
+0x30c9
+// 0.390706
+0x3640
+// 0.122773
+0x2fdc
+// -0.615072
+0xb8ec
+// -0.178641
+0xb1b7
+// -0.146106
+0xb0ad
+// 0.144296
+0x309e
+// 0.015980
+0x2417
+// -0.156654
+0xb103
+// 0.351210
+0x359f
+// -0.161396
+0xb12a
+// -0.226911
+0xb343
+// -0.333825
+0xb557
+// 0.073161
+0x2caf
+// -0.438871
+0xb706
+// -0.094606
+0xae0e
+// -0.146133
+0xb0ad
+// -0.182126
+0xb1d4
+// -0.207079
+0xb2a0
+// 0.097876
+0x2e44
+// 0.170079
+0x3171
+// 0.198173
+0x3257
+// -0.519419
+0xb828
+// -0.263240
+0xb436
+// 0.164928
+0x3147
+// -0.137044
+0xb063
+// 0.183169
+0x31dd
+// 0.067706
+0x2c55
+// 0.324084
+0x352f
+// 0.270302
+0x3453
+// 0.672390
+0x3961
+// -0.999477
+0xbbff
+// 0.508191
+0x3811
+// -0.454539
+0xb746
+// 0.101257
+0x2e7b
+// 0.039380
+0x290a
+// -0.010900
+0xa195
+// 0.053376
+0x2ad5
+// 0.249514
+0x33fc
+// 0.102622
+0x2e91
+// 0.075160
+0x2ccf
+// 0.116287
+0x2f71
+// 0.287541
+0x349a
+// 0.250758
+0x3403
+// -0.169049
+0xb169
+// 0.148688
+0x30c2
+// 0.038436
+0x28eb
+// -0.200481
+0xb26a
+// -0.132620
+0xb03e
+// 0.252988
+0x340c
+// 0.520093
+0x3829
+// 0.043818
+0x299c
+// -0.456629
+0xb74e
+// -0.491368
+0xb7dd
+// 0.187781
+0x3202
+// -0.571819
+0xb893
+// 0.086144
+0x2d83
+// -0.079532
+0xad17
+// 0.206830
+0x329e
+// 0.777274
+0x3a38
+// -0.460378
+0xb75e
+// 0.246283
+0x33e2
+// 0.451236
+0x3738
+// 0.067690
+0x2c55
+// -0.145176
+0xb0a5
+// -0.291766
+0xb4ab
+// -0.031768
+0xa811
+// 0.041433
+0x294e
+// -0.231346
+0xb367
+// 0.411317
+0x3695
+// -0.478339
+0xb7a7
+// -0.394970
+0xb652
+// 0.141944
+0x308b
+// 0.116654
+0x2f77
+// -0.106792
+0xaed6
+// 0.603278
+0x38d4
+// -0.034937
+0xa879
+// -0.362453
+0xb5cd
+// -0.405721
+0xb67e
+// 0.326659
+0x353a
+// -0.674510
+0xb965
+// -0.162588
+0xb134
+// 0.141424
+0x3087
+// -0.039243
+0xa906
+// 0.203445
+0x3283
+// 0.285691
+0x3492
+// 0.572381
+0x3894
+// 0.006298
+0x1e73
+// -0.122980
+0xafdf
+// 0.078596
+0x2d08
+// -0.060939
+0xabcd
+// 0.656393
+0x3940
+// -0.055303
+0xab14
+// 0.225767
+0x3339
+// -0.081245
+0xad33
+// -0.356775
+0xb5b5
+// -0.498355
+0xb7f9
+// -0.190823
+0xb21b
+// -0.352964
+0xb5a6
+// 0.458288
+0x3755
+// 0.018507
+0x24bd
+// 0.165896
+0x314f
+// 0.185519
+0x31f0
+// -0.398649
+0xb661
+// -0.195572
+0xb242
+// -0.380126
+0xb615
+// 0.087167
+0x2d94
+// 0.453483
+0x3741
+// 0.205076
+0x3290
+// 0.208113
+0x32a9
+// -0.316211
+0xb50f
+// -0.335887
+0xb560
+// -0.230632
+0xb361
+// -0.492176
+0xb7e0
+// 0.145569
+0x30a8
+// 0.410567
+0x3692
+// -0.071840
+0xac99
+// -0.226223
+0xb33d
+// -0.178560
+0xb1b7
+// 0.319551
+0x351d
+// -0.132067
+0xb03a
+// -0.145485
+0xb0a8
+// -0.013931
+0xa322
+// -0.018219
+0xa4aa
+// 0.055701
+0x2b21
+// -0.354940
+0xb5ae
+// -0.409432
+0xb68d
+// 0.006190
+0x1e57
+// 0.060895
+0x2bcb
+// -0.220102
+0xb30b
+// 0.083354
+0x2d56
+// 0.092191
+0x2de6
+// -0.377024
+0xb608
+// 0.216495
+0x32ee
+// -0.230554
+0xb361
+// -0.586293
+0xb8b1

Testing/Patterns/DSP/ComplexMaths/ComplexMathsF16/Input2_f16.txt

@@ -0,0 +1,1026 @@
+H
+512
+// -0.136327
+0xb05d
+// 0.002487
+0x1918
+// 0.158631
+0x3114
+// -0.046417
+0xa9f1
+// -0.433417
+0xb6ef
+// -0.322174
+0xb528
+// -0.021124
+0xa568
+// -0.254795
+0xb414
+// -0.143098
+0xb094
+// -0.379628
+0xb613
+// -0.235023
+0xb385
+// 0.010499
+0x2160
+// -0.445558
+0xb721
+// 0.314063
+0x3506
+// -0.150208
+0xb0cf
+// 0.041733
+0x2958
+// -0.326321
+0xb539
+// -0.069398
+0xac71
+// 0.028418
+0x2746
+// -0.146403
+0xb0af
+// -0.037652
+0xa8d2
+// -0.347842
+0xb591
+// 0.187554
+0x3200
+// 0.724639
+0x39cc
+// 0.302814
+0x34d8
+// -0.449019
+0xb72f
+// 0.365506
+0x35d9
+// -0.042639
+0xa975
+// 0.167378
+0x315b
+// 0.479737
+0x37ad
+// -0.240554
+0xb3b3
+// -0.016445
+0xa436
+// 0.280810
+0x347e
+// 0.115661
+0x2f67
+// 0.188267
+0x3206
+// 0.391718
+0x3644
+// -0.057858
+0xab68
+// 0.471820
+0x378d
+// 0.356567
+0x35b4
+// -0.080676
+0xad2a
+// 0.235529
+0x3389
+// -0.323560
+0xb52d
+// 0.115456
+0x2f64
+// -0.082526
+0xad48
+// -0.368407
+0xb5e5
+// -0.273690
+0xb461
+// 0.237919
+0x339d
+// 0.297566
+0x34c3
+// 0.197158
+0x324f
+// -0.151135
+0xb0d6
+// -0.074513
+0xacc5
+// 0.657725
+0x3943
+// 0.227349
+0x3346
+// 0.551002
+0x3868
+// -0.018499
+0xa4bc
+// -0.451276
+0xb738
+// 0.058834
+0x2b88
+// 0.193334
+0x3230
+// 0.117035
+0x2f7e
+// 0.116648
+0x2f77
+// 0.379746
+0x3613
+// -0.204914
+0xb28f
+// 0.136971
+0x3062
+// 0.262435
+0x3433
+// 0.043015
+0x2981
+// -0.903903
+0xbb3b
+// 0.080348
+0x2d24
+// 0.756331
+0x3a0d
+// 0.065196
+0x2c2c
+// 0.359886
+0x35c2
+// 0.035668
+0x2891
+// 0.097286
+0x2e3a
+// 0.203548
+0x3283
+// 0.383326
+0x3622
+// 0.102214
+0x2e8b
+// -0.271961
+0xb45a
+// 0.520209
+0x3829
+// 0.175801
+0x31a0
+// 0.215512
+0x32e5
+// -0.060275
+0xabb7
+// -0.291604
+0xb4aa
+// 0.181262
+0x31cd
+// -0.394388
+0xb64f
+// -0.204597
+0xb28c
+// -0.186168
+0xb1f5
+// -0.433331
+0xb6ef
+// 1.000000
+0x3c00
+// -0.277926
+0xb472
+// -0.552433
+0xb86b
+// 0.147785
+0x30bb
+// 0.012844
+0x2293
+// -0.685576
+0xb97c
+// -0.412083
+0xb698
+// 0.464563
+0x376f
+// -0.089898
+0xadc1
+// 0.008374
+0x204a
+// 0.957260
+0x3ba8
+// -0.039609
+0xa912
+// -0.334544
+0xb55a
+// 0.367057
+0x35df
+// 0.091596
+0x2ddd
+// -0.122583
+0xafd8
+// -0.276067
+0xb46b
+// 0.000961
+0x13e0
+// 0.464556
+0x376f
+// -0.383796
+0xb624
+// -0.362262
+0xb5cc
+// 0.090594
+0x2dcc
+// 0.594868
+0x38c2
+// -0.000350
+0x8dba
+// 0.011897
+0x2217
+// -0.421294
+0xb6be
+// 0.147449
+0x30b8
+// -0.749168
+0xb9fe
+// 0.695259
+0x3990
+// -0.341492
+0xb577
+// -0.046404
+0xa9f1
+// -0.342203
+0xb57a
+// 0.103168
+0x2e9a
+// 0.262795
+0x3434
+// -0.159030
+0xb117
+// -0.435814
+0xb6f9
+// 0.304264
+0x34de
+// -0.007924
+0xa00f
+// -0.295647
+0xb4bb
+// -0.076998
+0xacee
+// -0.002737
+0x999b
+// -0.273467
+0xb460
+// 0.000397
+0xe81
+// -0.115117
+0xaf5e
+// -0.239175
+0xb3a7
+// -0.402187
+0xb66f
+// 0.201359
+0x3272
+// -0.070794
+0xac88
+// 0.336778
+0x3563
+// 0.191315
+0x321f
+// -0.246483
+0xb3e3
+// -0.438430
+0xb704
+// 0.491004
+0x37db
+// -0.015050
+0xa3b5
+// -0.075847
+0xacdb
+// -0.767878
+0xba25
+// 0.403624
+0x3675
+// -0.605853
+0xb8d9
+// 0.057564
+0x2b5e
+// -0.047635
+0xaa19
+// -0.165931
+0xb14f
+// 0.268011
+0x344a
+// 0.155828
+0x30fd
+// -0.133412
+0xb045
+// 0.427530
+0x36d7
+// -0.131869
+0xb038
+// 0.171288
+0x317b
+// 0.048301
+0x2a2f
+// -0.200045
+0xb267
+// -0.342164
+0xb57a
+// -0.035383
+0xa887
+// -0.277260
+0xb470
+// -0.014876
+0xa39e
+// 0.268502
+0x344c
+// 0.054338
+0x2af5
+// -0.157017
+0xb106
+// -0.021514
+0xa582
+// 0.012999
+0x22a8
+// -0.259269
+0xb426
+// 0.048917
+0x2a43
+// -0.345012
+0xb585
+// -0.263408
+0xb437
+// -0.024475
+0xa644
+// -0.105127
+0xaeba
+// -0.032099
+0xa81c
+// 0.101817
+0x2e84
+// -0.049457
+0xaa55
+// 0.206011
+0x3298
+// -0.084667
+0xad6b
+// 0.255844
+0x3418
+// -0.035792
+0xa895
+// 0.671957
+0x3960
+// 0.051137
+0x2a8c
+// 0.430038
+0x36e1
+// -0.364477
+0xb5d5
+// -0.487285
+0xb7cc
+// -0.327183
+0xb53c
+// 0.267047
+0x3446
+// 0.379839
+0x3614
+// 0.060559
+0x2bc0
+// -0.033995
+0xa85a
+// 0.263289
+0x3436
+// 0.192639
+0x322a
+// 0.686130
+0x397d
+// -0.188304
+0xb207
+// 0.142996
+0x3093
+// -0.119730
+0xafaa
+// -0.326390
+0xb539
+// -0.068929
+0xac69
+// -0.450207
+0xb734
+// 0.040377
+0x292b
+// 0.392410
+0x3647
+// -0.567974
+0xb88b
+// 0.094520
+0x2e0d
+// -0.098305
+0xae4b
+// -0.034548
+0xa86c
+// 0.263707
+0x3438
+// 0.060668
+0x2bc4
+// 0.094133
+0x2e06
+// 0.539427
+0x3851
+// -0.613264
+0xb8e8
+// 0.023656
+0x260e
+// -0.455023
+0xb748
+// -0.134404
+0xb04d
+// 0.024512
+0x2646
+// 0.122551
+0x2fd8
+// -0.013500
+0xa2ea
+// 0.122304
+0x2fd4
+// -0.123919
+0xafee
+// 0.365122
+0x35d8
+// -0.132947
+0xb041
+// 0.051676
+0x2a9d
+// 0.323227
+0x352c
+// -0.203404
+0xb282
+// 0.200335
+0x3269
+// -0.395629
+0xb654
+// 0.430534
+0x36e3
+// -0.608546
+0xb8de
+// 0.003170
+0x1a7e
+// -0.014118
+0xa33b
+// 0.181678
+0x31d0
+// 0.366790
+0x35de
+// -0.081825
+0xad3d
+// -0.452362
+0xb73d
+// 0.165220
+0x3149
+// -0.438691
+0xb705
+// -0.120422
+0xafb5
+// -0.204965
+0xb28f
+// -0.102682
+0xae92
+// 0.212684
+0x32ce
+// 0.502628
+0x3805
+// 0.346394
+0x358b
+// -0.134359
+0xb04d
+// 0.268597
+0x344c
+// -0.225055
+0xb334
+// 0.382820
+0x3620
+// 0.062510
+0x2c00
+// 0.071935
+0x2c9b
+// 0.318492
+0x3519
+// -0.542096
+0xb856
+// 0.121915
+0x2fcd
+// 0.407057
+0x3683
+// 0.104229
+0x2eac
+// -0.042382
+0xa96d
+// -0.023420
+0xa5ff
+// -0.438498
+0xb704
+// -0.013504
+0xa2ea
+// -0.679454
+0xb970
+// -0.110081
+0xaf0c
+// -0.156483
+0xb102
+// 0.036715
+0x28b3
+// -0.073413
+0xacb3
+// 0.116192
+0x2f70
+// 0.013164
+0x22bd
+// -0.064727
+0xac24
+// 0.039457
+0x290d
+// -0.006633
+0x9ecb
+// 0.410719
+0x3692
+// 0.332376
+0x3551
+// 0.250389
+0x3402
+// -0.084063
+0xad61
+// 0.478170
+0x37a7
+// -0.408526
+0xb689
+// 0.097517
+0x2e3e
+// 0.611958
+0x38e5
+// 0.187715
+0x3202
+// -0.220617
+0xb30f
+// -0.368429
+0xb5e5
+// -0.760754
+0xba16
+// -0.586018
+0xb8b0
+// -0.725631
+0xb9ce
+// -0.236288
+0xb390
+// -0.060205
+0xabb5
+// -0.313300
+0xb503
+// 0.118642
+0x2f98
+// 0.148740
+0x30c2
+// 0.016657
+0x2444
+// 0.331963
+0x3550
+// 0.247718
+0x33ed
+// 0.276307
+0x346c
+// 0.327026
+0x353b
+// -0.485895
+0xb7c6
+// 0.261835
+0x3430
+// -0.090156
+0xadc5
+// -0.066699
+0xac45
+// 0.246578
+0x33e4
+// 0.123857
+0x2fed
+// -0.486446
+0xb7c8
+// 0.232038
+0x336d
+// 0.088638
+0x2dac
+// 0.160530
+0x3123
+// -0.135827
+0xb059
+// 0.156123
+0x30ff
+// -0.182059
+0xb1d3
+// -0.048326
+0xaa30
+// 0.069405
+0x2c71
+// -0.389648
+0xb63c
+// 0.541492
+0x3855
+// 0.062301
+0x2bf9
+// 0.512336
+0x3819
+// -0.406121
+0xb67f
+// 0.594512
+0x38c2
+// 0.250713
+0x3403
+// 0.002386
+0x18e3
+// 0.076706
+0x2ce9
+// 0.391636
+0x3644
+// 0.023965
+0x2623
+// 0.447086
+0x3727
+// -0.156969
+0xb106
+// 0.249194
+0x33f9
+// -0.116854
+0xaf7b
+// 0.162683
+0x3135
+// 0.176715
+0x31a8
+// 0.443006
+0x3717
+// 0.565424
+0x3886
+// 0.075217
+0x2cd0
+// 0.652901
+0x3939
+// -0.044474
+0xa9b1
+// 0.272541
+0x345c
+// -0.501781
+0xb804
+// 0.010911
+0x2196
+// -0.624908
+0xb900
+// 0.542801
+0x3858
+// 0.472937
+0x3791
+// -0.575649
+0xb89b
+// 0.087769
+0x2d9e
+// -0.157550
+0xb10b
+// 0.431380
+0x36e7
+// 0.355180
+0x35af
+// -0.752745
+0xba06
+// -0.249531
+0xb3fc
+// 0.394660
+0x3651
+// 0.847950
+0x3ac9
+// -0.525746
+0xb835
+// -0.116332
+0xaf72
+// -0.137532
+0xb067
+// 0.136958
+0x3062
+// 0.045451
+0x29d1
+// 0.116576
+0x2f76
+// 0.206234
+0x3299
+// -0.190265
+0xb217
+// 0.008046
+0x201f
+// -0.094838
+0xae12
+// -0.220380
+0xb30d
+// -0.554339
+0xb86f
+// 0.056220
+0x2b32
+// 0.945897
+0x3b91
+// 0.025354
+0x267e
+// -0.449642
+0xb732
+// -0.426757
+0xb6d4
+// -0.546110
+0xb85e
+// -0.248527
+0xb3f4
+// 0.057529
+0x2b5d
+// 0.351200
+0x359f
+// -0.932758
+0xbb76
+// -0.593891
+0xb8c0
+// -0.511933
+0xb818
+// -0.008967
+0xa097
+// 0.169866
+0x3170
+// -0.093065
+0xadf5
+// 0.295918
+0x34bc
+// -0.230464
+0xb360
+// 0.174953
+0x3199
+// 0.072011
+0x2c9c
+// -0.188409
+0xb207
+// 0.815054
+0x3a85
+// -0.421432
+0xb6be
+// -0.257168
+0xb41d
+// 0.561029
+0x387d
+// 0.110907
+0x2f19
+// -0.142914
+0xb093
+// -0.359279
+0xb5c0
+// -0.350847
+0xb59d
+// 0.375826
+0x3603
+// 0.306459
+0x34e7
+// 0.003598
+0x1b5e
+// 0.093925
+0x2e03
+// 0.507386
+0x380f
+// -0.412223
+0xb698
+// 0.284996
+0x348f
+// -0.495992
+0xb7f0
+// -0.493705
+0xb7e6
+// -0.089822
+0xadc0
+// -0.016787
+0xa44c
+// 0.057582
+0x2b5f
+// 0.255849
+0x3418
+// 0.355097
+0x35ae
+// 0.298262
+0x34c6
+// -0.274712
+0xb465
+// 0.216263
+0x32ec
+// 0.391042
+0x3642
+// -0.247972
+0xb3ef
+// -0.041098
+0xa943
+// -0.079005
+0xad0e
+// 0.404707
+0x367a
+// -0.193725
+0xb233
+// 0.030661
+0x27d9
+// 0.048908
+0x2a43
+// 0.000743
+0x1217
+// 0.095915
+0x2e23
+// -0.074204
+0xacc0
+// -0.024350
+0xa63c
+// -0.471145
+0xb78a
+// -0.111655
+0xaf25
+// -0.000858
+0x9308
+// -0.099305
+0xae5b
+// -0.038519
+0xa8ee
+// 0.034059
+0x285c
+// 0.586581
+0x38b1
+// 0.282921
+0x3487
+// -0.028124
+0xa733
+// 0.284650
+0x348e
+// -0.491390
+0xb7dd
+// -0.614040
+0xb8ea
+// 0.249266
+0x33fa
+// 0.043102
+0x2984
+// 0.554090
+0x386f
+// 0.055339
+0x2b15
+// 0.275726
+0x3469
+// -0.194496
+0xb239
+// 0.150181
+0x30ce
+// 0.351031
+0x359e
+// -0.018526
+0xa4be
+// 0.124970
+0x3000
+// 0.077830
+0x2cfb
+// -0.023867
+0xa61c
+// -0.693939
+0xb98d
+// 0.238625
+0x33a3
+// 0.570634
+0x3891
+// 0.169426
+0x316c
+// 0.393119
+0x364a
+// 0.072328
+0x2ca1
+// -0.301546
+0xb4d3
+// -0.585389
+0xb8af
+// 0.124334
+0x2ff5
+// -0.129373
+0xb024
+// 0.132026
+0x303a
+// -0.035180
+0xa881
+// 0.742286
+0x39f0
+// 0.072240
+0x2ca0
+// -0.582060
+0xb8a8
+// 0.620366
+0x38f7
+// 0.311039
+0x34fa
+// 0.296495
+0x34be
+// 0.540607
+0x3853
+// -0.316665
+0xb511
+// 0.189075
+0x320d
+// -0.361669
+0xb5c9
+// 0.135531
+0x3056
+// -0.015931
+0xa414
+// -0.412700
+0xb69a
+// -0.155228
+0xb0f8
+// -0.236869
+0xb394
+// -0.690747
+0xb987
+// 0.010279
+0x2143
+// -0.249852
+0xb3ff
+// -0.090229
+0xadc6
+// -0.565051
+0xb885
+// -0.051660
+0xaa9d
+// -0.559201
+0xb879
+// -0.818089
+0xba8b
+// 0.290178
+0x34a5
+// 0.291850
+0x34ab
+// -0.436680
+0xb6fd
+// -0.256151
+0xb419
+// 0.215719
+0x32e7
+// -0.312275
+0xb4ff
+// 0.129801
+0x3027
+// -0.489300
+0xb7d4
+// 0.112882
+0x2f39
+// -0.256930
+0xb41c
+// -0.226937
+0xb343
+// 0.182197
+0x31d5
+// 0.223685
+0x3328
+// 0.250796
+0x3403
+// 0.074953
+0x2ccc
+// 0.228017
+0x334c
+// 0.202336
+0x327a
+// 0.123149
+0x2fe2
+// 0.610221
+0x38e2
+// -0.028930
+0xa768
+// -0.294705
+0xb4b7
+// -0.396663
+0xb659
+// 0.598431
+0x38ca
+// 0.257927
+0x3420
+// -0.416903
+0xb6ac
+// -0.023941
+0xa621
+// -0.161364
+0xb12a
+// 0.132637
+0x303f
+// -0.297962
+0xb4c4
+// -0.481870
+0xb7b6
+// -0.333021
+0xb554
+// -0.017865
+0xa493
+// 0.039556
+0x2910
+// 0.462636
+0x3767
+// 0.135040
+0x3052
+// 0.289186
+0x34a1
+// -0.251829
+0xb407
+// -0.290504
+0xb4a6
+// -0.177618
+0xb1af
+// 0.316665
+0x3511
+// 0.219219
+0x3304
+// -0.372783
+0xb5f7
+// 0.091626
+0x2ddd
+// -0.114957
+0xaf5b
+// -0.467696
+0xb77c

Testing/Patterns/DSP/ComplexMaths/ComplexMathsF16/Input3_f16.txt

@@ -0,0 +1,514 @@
+H
+256
+// 0.606399
+0x38da
+// 0.073125
+0x2cae
+// -0.140834
+0xb082
+// -0.900755
+0xbb35
+// 0.148560
+0x30c1
+// -0.261878
+0xb431
+// -0.545170
+0xb85d
+// -0.628326
+0xb907
+// 0.495511
+0x37ee
+// 0.063174
+0x2c0b
+// -0.169679
+0xb16e
+// 0.145953
+0x30ac
+// 0.496673
+0x37f2
+// 1.000000
+0x3c00
+// 0.131807
+0x3038
+// 0.036478
+0x28ab
+// 0.427452
+0x36d7
+// -0.526852
+0xb837
+// -0.153413
+0xb0e9
+// -0.180253
+0xb1c5
+// 0.192358
+0x3228
+// 0.534224
+0x3846
+// -0.143569
+0xb098
+// -0.378102
+0xb60d
+// -0.387182
+0xb632
+// -0.181926
+0xb1d2
+// 0.627082
+0x3904
+// -0.782546
+0xba43
+// 0.227872
+0x334b
+// -0.920057
+0xbb5c
+// 0.028790
+0x275f
+// -0.002111
+0x9853
+// -0.448033
+0xb72b
+// 0.259638
+0x3427
+// -0.284893
+0xb48f
+// -0.172468
+0xb185
+// 0.304282
+0x34de
+// 0.130491
+0x302d
+// -0.206776
+0xb29e
+// 0.384068
+0x3625
+// 0.208473
+0x32ac
+// -0.097562
+0xae3e
+// 0.121821
+0x2fcc
+// -0.611990
+0xb8e5
+// -0.062335
+0xabfb
+// 0.614710
+0x38eb
+// 0.438926
+0x3706
+// 0.195912
+0x3245
+// 0.081082
+0x2d30
+// 0.012720
+0x2283
+// 0.258657
+0x3423
+// -0.268801
+0xb44d
+// -0.183050
+0xb1dc
+// 0.087615
+0x2d9b
+// -0.427434
+0xb6d7
+// 0.301905
+0x34d5
+// -0.236141
+0xb38e
+// 0.188230
+0x3206
+// -0.089373
+0xadb8
+// -0.294443
+0xb4b6
+// 0.506253
+0x380d
+// 0.841140
+0x3abb
+// 0.104046
+0x2ea9
+// 0.285712
+0x3492
+// -0.725796
+0xb9ce
+// 0.649891
+0x3933
+// 0.663543
+0x394f
+// -0.062934
+0xac07
+// -0.387710
+0xb634
+// 0.531890
+0x3841
+// 0.277675
+0x3471
+// 0.319026
+0x351b
+// 0.072518
+0x2ca4
+// 0.637432
+0x3919
+// -0.316837
+0xb512
+// 0.031885
+0x2815
+// -0.109017
+0xaefa
+// -0.531561
+0xb841
+// -0.116513
+0xaf75
+// 0.005209
+0x1d56
+// -0.178215
+0xb1b4
+// 0.096452
+0x2e2c
+// -0.089155
+0xadb5
+// -0.193966
+0xb235
+// -0.318435
+0xb518
+// -0.137340
+0xb065
+// 0.325371
+0x3535
+// -0.413025
+0xb69c
+// -0.007530
+0x9fb6
+// -0.011499
+0xa1e3
+// -0.359144
+0xb5bf
+// -0.317911
+0xb516
+// 0.018568
+0x24c1
+// -0.366742
+0xb5de
+// 0.221775
+0x3319
+// 0.420017
+0x36b8
+// -0.040939
+0xa93d
+// -0.362740
+0xb5ce
+// 0.471219
+0x378a
+// -0.099621
+0xae60
+// 0.326052
+0x3538
+// 0.311047
+0x34fa
+// 0.156421
+0x3101
+// -0.068640
+0xac65
+// -0.095922
+0xae24
+// -0.013959
+0xa326
+// 0.607825
+0x38dd
+// 0.093427
+0x2dfb
+// 0.329927
+0x3547
+// 0.084851
+0x2d6e
+// 0.726006
+0x39cf
+// 0.248801
+0x33f6
+// 0.620044
+0x38f6
+// 0.164699
+0x3145
+// 0.045769
+0x29dc
+// 0.264445
+0x343b
+// -0.238087
+0xb39e
+// 0.220883
+0x3311
+// 0.018551
+0x24c0
+// -0.057134
+0xab50
+// -0.155357
+0xb0f9
+// 0.038525
+0x28ee
+// 0.208492
+0x32ac
+// -0.098819
+0xae53
+// 0.027140
+0x26f3
+// -0.333135
+0xb555
+// -0.423594
+0xb6c7
+// 0.521231
+0x382b
+// 0.406043
+0x367f
+// -0.457325
+0xb751
+// 0.089960
+0x2dc2
+// -0.107212
+0xaedd
+// 0.089652
+0x2dbd
+// -0.269460
+0xb450
+// 0.155036
+0x30f6
+// 0.024048
+0x2628
+// 0.220735
+0x3310
+// 0.032031
+0x281a
+// -0.567049
+0xb889
+// 0.145897
+0x30ab
+// -0.094783
+0xae11
+// 0.319032
+0x351b
+// -0.091891
+0xade2
+// 0.416962
+0x36ac
+// 0.093970
+0x2e04
+// 0.564895
+0x3885
+// -0.296964
+0xb4c0
+// -0.209322
+0xb2b3
+// 0.265009
+0x343d
+// 0.093215
+0x2df7
+// 0.622832
+0x38fc
+// -0.085788
+0xad7e
+// 0.670554
+0x395d
+// 0.032468
+0x2828
+// 0.118023
+0x2f8e
+// -0.269207
+0xb44f
+// 0.217617
+0x32f7
+// 0.213691
+0x32d7
+// 0.439040
+0x3706
+// 0.241885
+0x33be
+// -0.424515
+0xb6cb
+// 0.352380
+0x35a3
+// 0.588583
+0x38b5
+// -0.264797
+0xb43d
+// 0.329184
+0x3544
+// 0.034001
+0x285a
+// -0.423064
+0xb6c5
+// -0.608316
+0xb8de
+// -0.338928
+0xb56c
+// 0.419995
+0x36b8
+// 0.200555
+0x326b
+// 0.329638
+0x3546
+// -0.294240
+0xb4b5
+// -0.897858
+0xbb2f
+// 0.160219
+0x3121
+// 0.131756
+0x3037
+// 0.206411
+0x329b
+// 0.109237
+0x2efe
+// -0.367268
+0xb5e0
+// 0.292430
+0x34ae
+// -0.414400
+0xb6a1
+// -0.642448
+0xb924
+// 0.238399
+0x33a1
+// 0.090387
+0x2dc9
+// -0.512754
+0xb81a
+// 0.301373
+0x34d2
+// -0.466867
+0xb778
+// 0.204287
+0x328a
+// -0.229499
+0xb358
+// -0.119896
+0xafac
+// 0.440248
+0x370b
+// 0.649995
+0x3933
+// 0.129477
+0x3025
+// 0.241037
+0x33b7
+// -0.411964
+0xb697
+// 0.228133
+0x334d
+// 0.942283
+0x3b8a
+// -0.390976
+0xb641
+// 0.182779
+0x31d9
+// 0.228995
+0x3354
+// 0.126382
+0x300b
+// 0.225140
+0x3334
+// -0.214251
+0xb2db
+// 0.439711
+0x3709
+// -0.638072
+0xb91b
+// -0.667301
+0xb957
+// -0.353387
+0xb5a7
+// 0.329438
+0x3545
+// -0.543036
+0xb858
+// -0.195706
+0xb243
+// -0.000314
+0x8d26
+// -0.346311
+0xb58a
+// -0.040030
+0xa920
+// 0.309919
+0x34f5
+// 0.214685
+0x32df
+// -0.256227
+0xb41a
+// 0.256241
+0x341a
+// 0.423187
+0x36c5
+// -0.070894
+0xac8a
+// -0.408192
+0xb688
+// 0.258732
+0x3424
+// 0.743039
+0x39f2
+// -0.328534
+0xb542
+// -0.502412
+0xb805
+// -0.550943
+0xb868
+// 0.461636
+0x3763
+// -0.098335
+0xae4b
+// -0.331961
+0xb550
+// 0.502005
+0x3804
+// -0.060550
+0xabc0
+// -0.218616
+0xb2ff
+// 0.206607
+0x329d
+// 0.509390
+0x3813
+// 0.331278
+0x354d
+// -0.143708
+0xb099
+// 0.008236
+0x2038
+// -0.256486
+0xb41b
+// -0.154828
+0xb0f4
+// -0.606731
+0xb8db
+// 0.043363
+0x298d
+// 0.416313
+0x36a9
+// 0.132691
+0x303f
+// 0.716789
+0x39bc
+// 0.827380
+0x3a9e
+// 0.109746
+0x2f06
+// 0.480993
+0x37b2
+// -0.424777
+0xb6cc
+// -0.169704
+0xb16e
+// -0.095902
+0xae23
+// 0.022081
+0x25a7
+// -0.227175
+0xb345
+// 0.382023
+0x361d
+// 0.316215
+0x350f
+// -0.027787
+0xa71d
+// 0.107868
+0x2ee7
+// -0.091834
+0xade1

Testing/Patterns/DSP/ComplexMaths/ComplexMathsF16/Reference1_f16.txt

@@ -0,0 +1,1026 @@
+H
+512
+// -0.190784
+0xb21b
+// 0.091654
+0x2dde
+// 0.071822
+0x2c99
+// -0.147638
+0xb0b9
+// 0.286048
+0x3494
+// 0.271081
+0x3456
+// -0.697050
+0xb994
+// 0.463404
+0x376a
+// 0.194499
+0x3239
+// 0.058274
+0x2b76
+// 0.114183
+0x2f4f
+// -0.583218
+0xb8aa
+// 0.330052
+0x3548
+// -0.268445
+0xb44c
+// -0.557581
+0xb876
+// 0.410190
+0x3690
+// 0.272990
+0x345e
+// 0.393479
+0x364c
+// -0.116202
+0xaf70
+// 0.721886
+0x39c6
+// -0.213211
+0xb2d3
+// -0.083483
+0xad58
+// -0.374075
+0xb5fc
+// -0.198101
+0xb257
+// -0.398395
+0xb660
+// 0.560209
+0x387b
+// 0.048614
+0x2a39
+// -0.635820
+0xb916
+// -0.091076
+0xadd4
+// 0.390076
+0x363e
+// 0.073176
+0x2caf
+// 0.275342
+0x3468
+// -0.212389
+0xb2cc
+// 0.772148
+0x3a2d
+// -0.172327
+0xb184
+// -0.502172
+0xb804
+// 0.111732
+0x2f27
+// -0.892060
+0xbb23
+// 0.050152
+0x2a6b
+// 0.045235
+0x29ca
+// -0.345404
+0xb587
+// 0.236645
+0x3393
+// 0.071838
+0x2c99
+// -0.415857
+0xb6a7
+// 0.599356
+0x38cb
+// 0.030207
+0x27bc
+// -0.094837
+0xae12
+// 0.018655
+0x24c7
+// 0.310711
+0x34f9
+// 0.223677
+0x3328
+// -0.553400
+0xb86d
+// -0.001849
+0x9793
+// 0.074133
+0x2cbf
+// -0.080981
+0xad2f
+// 0.293681
+0x34b3
+// -0.679882
+0xb970
+// -0.628950
+0xb908
+// -0.543036
+0xb858
+// 0.288096
+0x349c
+// 0.314617
+0x3509
+// 0.008941
+0x2094
+// 0.281210
+0x3480
+// 0.134949
+0x3051
+// -0.234598
+0xb382
+// -0.047845
+0xaa20
+// 0.350960
+0x359e
+// 0.848249
+0x3ac9
+// -0.613374
+0xb8e8
+// -0.438045
+0xb702
+// -0.829299
+0xbaa2
+// -0.392637
+0xb648
+// 0.269273
+0x344f
+// 0.339954
+0x3570
+// -0.145916
+0xb0ab
+// 0.022215
+0x25b0
+// -0.334099
+0xb558
+// 0.312490
+0x3500
+// 0.066518
+0x2c42
+// -0.009386
+0xa0ce
+// -0.119294
+0xafa3
+// -0.515181
+0xb81f
+// 0.420252
+0x36b9
+// -0.634564
+0xb914
+// 0.093181
+0x2df7
+// -0.245987
+0xb3df
+// -0.334221
+0xb559
+// 0.300029
+0x34cd
+// 0.767856
+0x3a25
+// -0.383899
+0xb624
+// -0.127684
+0xb016
+// 0.203534
+0x3283
+// -0.197151
+0xb24f
+// 0.461939
+0x3764
+// -0.073480
+0xacb4
+// -0.358199
+0xb5bb
+// 0.300925
+0x34d1
+// -0.095023
+0xae15
+// 0.103263
+0x2e9c
+// -0.106033
+0xaec9
+// -0.388054
+0xb635
+// -1.000000
+0xbc00
+// -0.082423
+0xad46
+// -0.044897
+0xa9bf
+// 0.137322
+0x3065
+// -0.179832
+0xb1c1
+// -0.424530
+0xb6cb
+// 0.140982
+0x3083
+// -0.446902
+0xb727
+// -0.035516
+0xa88c
+// -0.608230
+0xb8de
+// 0.195101
+0x323e
+// 0.525550
+0x3834
+// -0.303026
+0xb4d9
+// -0.277534
+0xb471
+// -0.092106
+0xade5
+// 0.174064
+0x3192
+// -0.200301
+0xb269
+// -0.160421
+0xb122
+// -0.259599
+0xb427
+// -0.349249
+0xb597
+// -0.152659
+0xb0e3
+// -0.286340
+0xb495
+// -0.008274
+0xa03d
+// -0.371525
+0xb5f2
+// 0.074143
+0x2cbf
+// -0.205714
+0xb295
+// -0.169983
+0xb171
+// -0.276524
+0xb46d
+// -0.025333
+0xa67c
+// -0.092119
+0xade5
+// -0.265870
+0xb441
+// 0.037141
+0x28c1
+// 0.384053
+0x3625
+// -0.108276
+0xaeee
+// -0.409038
+0xb68b
+// 0.035318
+0x2885
+// 0.528830
+0x383b
+// 0.082829
+0x2d4d
+// 0.291412
+0x34aa
+// -0.073902
+0xacbb
+// 0.413185
+0x369c
+// 0.025412
+0x2681
+// 0.260122
+0x3429
+// 0.044555
+0x29b4
+// 0.123585
+0x2fe9
+// 0.190842
+0x321b
+// -0.233187
+0xb376
+// 0.078043
+0x2cff
+// 0.423401
+0x36c6
+// 0.136719
+0x3060
+// 0.469315
+0x3782
+// -0.129213
+0xb023
+// 0.207801
+0x32a6
+// -0.327814
+0xb53f
+// -0.056665
+0xab41
+// -0.298600
+0xb4c7
+// -0.293294
+0xb4b1
+// -0.129624
+0xb026
+// 0.195203
+0x323f
+// -0.112247
+0xaf2f
+// 0.263289
+0x3436
+// -0.773798
+0xba31
+// 0.256735
+0x341c
+// -0.404828
+0xb67a
+// 0.676366
+0x3969
+// -0.526304
+0xb836
+// 0.151284
+0x30d7
+// -0.322640
+0xb52a
+// 0.065563
+0x2c32
+// 0.117193
+0x2f80
+// -0.026112
+0xa6af
+// 0.323225
+0x352c
+// 0.384034
+0x3625
+// 0.419571
+0x36b7
+// -0.161330
+0xb12a
+// -0.255380
+0xb416
+// 0.076765
+0x2cea
+// 0.210946
+0x32c0
+// 0.329633
+0x3546
+// -0.216146
+0xb2eb
+// -0.566272
+0xb888
+// -0.113051
+0xaf3c
+// 0.217060
+0x32f2
+// 0.124587
+0x2ff9
+// 0.138246
+0x306d
+// -0.513390
+0xb81b
+// 0.400914
+0x366a
+// 0.140241
+0x307d
+// -0.643821
+0xb927
+// 0.111858
+0x2f29
+// -0.082079
+0xad41
+// 0.305358
+0x34e3
+// -0.018046
+0xa49f
+// -0.227073
+0xb344
+// -0.015413
+0xa3e4
+// 0.183604
+0x31e0
+// -0.069889
+0xac79
+// 0.057719
+0x2b63
+// -0.251284
+0xb405
+// 0.388552
+0x3638
+// -0.290348
+0xb4a5
+// 0.184703
+0x31e9
+// -0.098634
+0xae50
+// -0.224607
+0xb330
+// 0.065603
+0x2c33
+// 0.075874
+0x2cdb
+// -0.446554
+0xb725
+// 0.031660
+0x280d
+// 0.194868
+0x323c
+// 0.663546
+0x394f
+// -0.344696
+0xb584
+// -0.115373
+0xaf62
+// -0.376122
+0xb605
+// -0.264123
+0xb43a
+// -0.190886
+0xb21c
+// -0.525617
+0xb834
+// 0.067548
+0x2c53
+// 0.098252
+0x2e4a
+// -0.569751
+0xb88f
+// -0.391645
+0xb644
+// 0.388041
+0x3635
+// -0.170622
+0xb176
+// 0.076320
+0x2ce2
+// -0.052063
+0xaaaa
+// -0.013621
+0xa2f9
+// 0.009318
+0x20c5
+// -0.086077
+0xad82
+// -0.380233
+0xb615
+// -0.101300
+0xae7c
+// 0.294013
+0x34b4
+// -0.083146
+0xad52
+// -0.501720
+0xb804
+// -0.428573
+0xb6db
+// -0.125989
+0xb008
+// 0.277520
+0x3471
+// -0.090883
+0xadd1
+// -0.122190
+0xafd2
+// -0.252426
+0xb40a
+// 0.363431
+0x35d1
+// -0.077910
+0xacfc
+// -0.093576
+0xadfd
+// 0.211400
+0x32c4
+// -0.364776
+0xb5d6
+// -0.294128
+0xb4b5
+// 0.016042
+0x241b
+// -0.033808
+0xa854
+// 0.176922
+0x31a9
+// -0.450358
+0xb735
+// 0.375269
+0x3601
+// -0.218647
+0xb2ff
+// -0.116245
+0xaf71
+// 0.115976
+0x2f6c
+// -0.431688
+0xb6e8
+// 0.394426
+0x3650
+// -0.157245
+0xb108
+// 0.213304
+0x32d3
+// -0.337097
+0xb565
+// -0.156474
+0xb102
+// 0.657004
+0x3942
+// 0.081579
+0x2d39
+// -0.280747
+0xb47e
+// -0.492273
+0xb7e0
+// -0.484703
+0xb7c1
+// -0.108728
+0xaef5
+// -0.294784
+0xb4b7
+// -0.439698
+0xb709
+// -0.022943
+0xa5e0
+// -0.397221
+0xb65b
+// 0.226002
+0x333b
+// -0.449882
+0xb733
+// 0.026734
+0x26d8
+// -0.151814
+0xb0dc
+// -0.052161
+0xaaad
+// -0.432675
+0xb6ec
+// 0.702654
+0x399f
+// -0.623854
+0xb8fe
+// -0.294212
+0xb4b5
+// -0.184520
+0xb1e8
+// -0.176992
+0xb1aa
+// -0.098278
+0xae4a
+// 0.722656
+0x39c8
+// 0.417647
+0x36af
+// 0.397952
+0x365e
+// 0.339095
+0x356d
+// 0.363564
+0x35d1
+// 0.398928
+0x3662
+// -0.096797
+0xae32
+// 0.378620
+0x360f
+// 0.197204
+0x324f
+// -0.184326
+0xb1e6
+// 0.401392
+0x366c
+// -0.343814
+0xb580
+// 0.121889
+0x2fcd
+// 0.073084
+0x2cad
+// -0.289407
+0xb4a1
+// -0.416686
+0xb6ab
+// 0.098654
+0x2e50
+// -0.181763
+0xb1d1
+// -0.345023
+0xb585
+// -0.715047
+0xb9b8
+// -0.789478
+0xba51
+// -0.273947
+0xb462
+// 0.578569
+0x38a1
+// -0.338427
+0xb56a
+// 0.088798
+0x2daf
+// -0.071466
+0xac93
+// 0.049715
+0x2a5d
+// 0.469836
+0x3784
+// -0.489806
+0xb7d6
+// -0.301345
+0xb4d2
+// -0.175808
+0xb1a0
+// 0.711336
+0x39b1
+// -0.549467
+0xb865
+// -0.219787
+0xb308
+// 0.497011
+0x37f4
+// -0.227910
+0xb34b
+// -0.292937
+0xb4b0
+// 0.046002
+0x29e3
+// 0.010423
+0x2156
+// -0.261211
+0xb42e
+// -0.548199
+0xb863
+// 0.160683
+0x3124
+// 0.209818
+0x32b7
+// 0.550566
+0x3868
+// 0.797021
+0x3a60
+// 0.202658
+0x327c
+// 0.351454
+0x35a0
+// -0.083937
+0xad5f
+// -0.036793
+0xa8b6
+// 0.149267
+0x30c7
+// 0.407582
+0x3685
+// -0.227306
+0xb346
+// -0.273277
+0xb45f
+// 0.283114
+0x3488
+// 0.071705
+0x2c97
+// 0.718338
+0x39bf
+// -0.019170
+0xa4e8
+// 0.083900
+0x2d5f
+// 0.330361
+0x3549
+// 0.025872
+0x26a0
+// 0.094594
+0x2e0e
+// 0.614355
+0x38ea
+// -0.312080
+0xb4fe
+// 0.411203
+0x3694
+// -0.736344
+0xb9e4
+// 0.230057
+0x335d
+// -0.193205
+0xb22f
+// -0.373161
+0xb5f8
+// 0.358530
+0x35bd
+// 0.223042
+0x3323
+// 0.271586
+0x3458
+// -0.201713
+0xb274
+// 0.553892
+0x386e
+// -0.499516
+0xb7fe
+// 0.153245
+0x30e7
+// -0.632118
+0xb90f
+// 0.307657
+0x34ec
+// 0.456707
+0x374f
+// 0.399091
+0x3663
+// 0.104631
+0x2eb2
+// -0.118470
+0xaf95
+// -0.263137
+0xb436
+// -0.337336
+0xb566
+// -0.105794
+0xaec5
+// 0.123551
+0x2fe8
+// -0.188344
+0xb207
+// -0.015292
+0xa3d4
+// 0.193681
+0x3233
+// -0.042520
+0xa971
+// -0.546278
+0xb85f
+// 0.259574
+0x3427
+// 0.152328
+0x30e0
+// -0.223776
+0xb329
+// 0.451761
+0x373a
+// 0.340963
+0x3575
+// 0.968638
+0x3bc0
+// 0.149531
+0x30c9
+// -0.390706
+0xb640
+// 0.122773
+0x2fdc
+// 0.615072
+0x38ec
+// -0.178641
+0xb1b7
+// 0.146106
+0x30ad
+// 0.144296
+0x309e
+// -0.015980
+0xa417
+// -0.156654
+0xb103
+// -0.351210
+0xb59f
+// -0.161396
+0xb12a
+// 0.226911
+0x3343
+// -0.333825
+0xb557
+// -0.073161
+0xacaf
+// -0.438871
+0xb706
+// 0.094606
+0x2e0e
+// -0.146133
+0xb0ad
+// 0.182126
+0x31d4
+// -0.207079
+0xb2a0
+// -0.097876
+0xae44
+// 0.170079
+0x3171
+// -0.198173
+0xb257
+// -0.519419
+0xb828
+// 0.263240
+0x3436
+// 0.164928
+0x3147
+// 0.137044
+0x3063
+// 0.183169
+0x31dd
+// -0.067706
+0xac55
+// 0.324084
+0x352f
+// -0.270302
+0xb453
+// 0.672390
+0x3961
+// 0.999477
+0x3bff
+// 0.508191
+0x3811
+// 0.454539
+0x3746
+// 0.101257
+0x2e7b
+// -0.039380
+0xa90a
+// -0.010900
+0xa195
+// -0.053376
+0xaad5
+// 0.249514
+0x33fc
+// -0.102622
+0xae91
+// 0.075160
+0x2ccf
+// -0.116287
+0xaf71
+// 0.287541
+0x349a
+// -0.250758
+0xb403
+// -0.169049
+0xb169
+// -0.148688
+0xb0c2
+// 0.038436
+0x28eb
+// 0.200481
+0x326a
+// -0.132620
+0xb03e
+// -0.252988
+0xb40c
+// 0.520093
+0x3829
+// -0.043818
+0xa99c
+// -0.456629
+0xb74e
+// 0.491368
+0x37dd
+// 0.187781
+0x3202
+// 0.571819
+0x3893
+// 0.086144
+0x2d83
+// 0.079532
+0x2d17
+// 0.206830
+0x329e
+// -0.777274
+0xba38
+// -0.460378
+0xb75e
+// -0.246283
+0xb3e2
+// 0.451236
+0x3738
+// -0.067690
+0xac55
+// -0.145176
+0xb0a5
+// 0.291766
+0x34ab
+// -0.031768
+0xa811
+// -0.041433
+0xa94e
+// -0.231346
+0xb367
+// -0.411317
+0xb695
+// -0.478339
+0xb7a7
+// 0.394970
+0x3652
+// 0.141944
+0x308b
+// -0.116654
+0xaf77
+// -0.106792
+0xaed6
+// -0.603278
+0xb8d4
+// -0.034937
+0xa879
+// 0.362453
+0x35cd
+// -0.405721
+0xb67e
+// -0.326659
+0xb53a
+// -0.674510
+0xb965
+// 0.162588
+0x3134
+// 0.141424
+0x3087
+// 0.039243
+0x2906
+// 0.203445
+0x3283
+// -0.285691
+0xb492
+// 0.572381
+0x3894
+// -0.006298
+0x9e73
+// -0.122980
+0xafdf
+// -0.078596
+0xad08
+// -0.060939
+0xabcd
+// -0.656393
+0xb940
+// -0.055303
+0xab14
+// -0.225767
+0xb339
+// -0.081245
+0xad33
+// 0.356775
+0x35b5
+// -0.498355
+0xb7f9
+// 0.190823
+0x321b
+// -0.352964
+0xb5a6
+// -0.458288
+0xb755
+// 0.018507
+0x24bd
+// -0.165896
+0xb14f
+// 0.185519
+0x31f0
+// 0.398649
+0x3661
+// -0.195572
+0xb242
+// 0.380126
+0x3615
+// 0.087167
+0x2d94
+// -0.453483
+0xb741
+// 0.205076
+0x3290
+// -0.208113
+0xb2a9
+// -0.316211
+0xb50f
+// 0.335887
+0x3560
+// -0.230632
+0xb361
+// 0.492176
+0x37e0
+// 0.145569
+0x30a8
+// -0.410567
+0xb692
+// -0.071840
+0xac99
+// 0.226223
+0x333d
+// -0.178560
+0xb1b7
+// -0.319551
+0xb51d
+// -0.132067
+0xb03a
+// 0.145485
+0x30a8
+// -0.013931
+0xa322
+// 0.018219
+0x24aa
+// 0.055701
+0x2b21
+// 0.354940
+0x35ae
+// -0.409432
+0xb68d
+// -0.006190
+0x9e57
+// 0.060895
+0x2bcb
+// 0.220102
+0x330b
+// 0.083354
+0x2d56
+// -0.092191
+0xade6
+// -0.377024
+0xb608
+// -0.216495
+0xb2ee
+// -0.230554
+0xb361
+// 0.586293
+0x38b1

Testing/Patterns/DSP/ComplexMaths/ComplexMathsF16/Reference2_f16.txt

@@ -0,0 +1,6 @@
+H
+2
+// -0.584459
+0xb8ad
+// 0.027514
+0x270b

Testing/Patterns/DSP/ComplexMaths/ComplexMathsF16/Reference3_f16.txt

@@ -0,0 +1,6 @@
+H
+2
+// -1.063155
+0xbc41
+// 0.204536
+0x328c

Testing/Patterns/DSP/ComplexMaths/ComplexMathsF16/Reference4_f16.txt

@@ -0,0 +1,6 @@
+H
+2
+// -2.020148
+0xc00a
+// -0.083691
+0xad5b

Testing/Patterns/DSP/ComplexMaths/ComplexMathsF16/Reference5_f16.txt

@@ -0,0 +1,514 @@
+H
+256
+// 0.211657
+0x32c6
+// 0.164180
+0x3141
+// 0.394092
+0x364e
+// 0.837031
+0x3ab2
+// 0.203042
+0x327f
+// 0.594290
+0x38c1
+// 0.425438
+0x36cf
+// 0.692208
+0x398a
+// 0.478904
+0x37aa
+// 0.731179
+0x39d9
+// 0.228972
+0x3354
+// 0.423292
+0x36c6
+// 0.687425
+0x3980
+// 0.637676
+0x391a
+// 0.400567
+0x3669
+// 0.284900
+0x348f
+// 0.800826
+0x3a68
+// 0.530918
+0x383f
+// 0.899030
+0x3b31
+// 0.067538
+0x2c53
+// 0.418694
+0x36b3
+// 0.422016
+0x36c1
+// 0.600117
+0x38cd
+// 0.096654
+0x2e30
+// 0.382849
+0x3620
+// 0.553403
+0x386d
+// 0.109789
+0x2f07
+// 0.740600
+0x39ed
+// 0.830944
+0x3aa6
+// 0.426594
+0x36d3
+// 0.281352
+0x3480
+// 0.270642
+0x3455
+// 0.354207
+0x35ab
+// 1.046783
+0x3c30
+// 0.937881
+0x3b81
+// 0.476101
+0x379e
+// 0.369946
+0x35eb
+// 0.334837
+0x355b
+// 0.319491
+0x351d
+// 0.119662
+0x2fa9
+// 0.664848
+0x3952
+// 0.641369
+0x3922
+// 0.414986
+0x36a4
+// 0.824391
+0x3a98
+// 0.404576
+0x3679
+// 0.283363
+0x3489
+// 0.467747
+0x377c
+// 0.467828
+0x377c
+// 0.140330
+0x307e
+// 0.402280
+0x3670
+// 1.003391
+0x3c03
+// 0.144475
+0x30a0
+// 0.461048
+0x3760
+// 0.468613
+0x377f
+// 0.609266
+0x38e0
+// 0.560596
+0x387c
+// 0.410914
+0x3693
+// 0.196930
+0x324d
+// 0.256623
+0x341b
+// 0.435163
+0x36f6
+// 0.324492
+0x3531
+// 0.371618
+0x35f2
+// 0.218667
+0x32ff
+// 0.324592
+0x3532
+// 0.095539
+0x2e1d
+// 0.268452
+0x344c
+// 0.399025
+0x3662
+// 0.410560
+0x3692
+// 0.535278
+0x3848
+// 0.300637
+0x34cf
+// 0.413966
+0x36a0
+// 0.263911
+0x3439
+// 0.227363
+0x3347
+// 0.245900
+0x33de
+// 0.444928
+0x371e
+// 0.486777
+0x37ca
+// 0.388128
+0x3636
+// 0.303929
+0x34dd
+// 0.320661
+0x3521
+// 0.225175
+0x3335
+// 0.817364
+0x3a8a
+// 0.479373
+0x37ac
+// 0.857010
+0x3adb
+// 0.356348
+0x35b4
+// 0.134285
+0x304c
+// 0.324278
+0x3530
+// 0.568790
+0x388d
+// 0.302070
+0x34d5
+// 0.224479
+0x332f
+// 0.394179
+0x364f
+// 0.577446
+0x389f
+// 0.250274
+0x3401
+// 0.531677
+0x3841
+// 0.424735
+0x36cc
+// 0.653466
+0x393a
+// 0.316197
+0x350f
+// 0.227789
+0x334a
+// 0.184250
+0x31e5
+// 0.090642
+0x2dcd
+// 0.462727
+0x3767
+// 0.344118
+0x3582
+// 0.245310
+0x33da
+// 0.100303
+0x2e6b
+// 0.447675
+0x372a
+// 0.691568
+0x3988
+// 0.363492
+0x35d1
+// 0.459596
+0x375b
+// 0.559206
+0x3879
+// 0.119232
+0x2fa1
+// 0.691377
+0x3988
+// 0.423896
+0x36c8
+// 0.092387
+0x2dea
+// 0.016503
+0x243a
+// 0.389855
+0x363d
+// 0.310975
+0x34fa
+// 0.508563
+0x3812
+// 0.446708
+0x3726
+// 0.292022
+0x34ac
+// 0.280445
+0x347d
+// 0.371688
+0x35f2
+// 0.231185
+0x3366
+// 0.468586
+0x377f
+// 0.037421
+0x28ca
+// 0.483864
+0x37be
+// 0.434319
+0x36f3
+// 0.164206
+0x3141
+// 0.584744
+0x38ae
+// 0.264999
+0x343d
+// 0.371643
+0x35f2
+// 0.662050
+0x394c
+// 0.566702
+0x3889
+// 0.496748
+0x37f3
+// 0.529369
+0x383c
+// 0.397883
+0x365e
+// 0.503458
+0x3807
+// 0.154150
+0x30ef
+// 0.435808
+0x36f9
+// 0.939636
+0x3b84
+// 0.347287
+0x358e
+// 0.202447
+0x327a
+// 0.834662
+0x3aad
+// 0.522830
+0x382f
+// 0.539743
+0x3851
+// 0.390797
+0x3641
+// 0.269937
+0x3452
+// 0.528511
+0x383a
+// 0.142120
+0x308c
+// 0.507329
+0x380f
+// 0.206810
+0x329e
+// 0.793935
+0x3a5a
+// 0.835657
+0x3aaf
+// 0.670280
+0x395d
+// 0.113984
+0x2f4c
+// 0.472458
+0x378f
+// 0.575082
+0x389a
+// 0.732740
+0x39dd
+// 0.591795
+0x38bc
+// 0.546775
+0x3860
+// 0.296527
+0x34bf
+// 0.261418
+0x342f
+// 0.571263
+0x3892
+// 0.589192
+0x38b7
+// 0.822382
+0x3a94
+// 0.361338
+0x35c8
+// 0.153735
+0x30eb
+// 0.466681
+0x3778
+// 0.393489
+0x364c
+// 0.721908
+0x39c6
+// 0.086062
+0x2d82
+// 0.331373
+0x354d
+// 0.621595
+0x38f9
+// 0.516218
+0x3821
+// 0.771446
+0x3a2c
+// 0.420211
+0x36b9
+// 0.422246
+0x36c2
+// 0.338301
+0x356a
+// 0.745863
+0x39f8
+// 0.650429
+0x3934
+// 0.550667
+0x3868
+// 0.412579
+0x369a
+// 0.288576
+0x349e
+// 0.353537
+0x35a8
+// 0.225252
+0x3335
+// 0.194284
+0x3238
+// 0.547930
+0x3862
+// 0.300970
+0x34d1
+// 0.504146
+0x3808
+// 1.026896
+0x3c1c
+// 0.418343
+0x36b2
+// 0.627205
+0x3905
+// 0.230780
+0x3363
+// 0.145178
+0x30a5
+// 0.384564
+0x3627
+// 0.278455
+0x3475
+// 0.341747
+0x3578
+// 0.448953
+0x372f
+// 0.233506
+0x3379
+// 0.229044
+0x3354
+// 0.261151
+0x342e
+// 0.582315
+0x38a9
+// 0.214435
+0x32dd
+// 0.195282
+0x3240
+// 0.422011
+0x36c1
+// 1.204601
+0x3cd2
+// 0.681809
+0x3974
+// 0.108645
+0x2ef4
+// 0.054477
+0x2af9
+// 0.269794
+0x3451
+// 0.138462
+0x306e
+// 0.381523
+0x361b
+// 0.225135
+0x3334
+// 0.204132
+0x3288
+// 0.285641
+0x3492
+// 0.521935
+0x382d
+// 0.670786
+0x395e
+// 0.601863
+0x38d1
+// 0.117244
+0x2f81
+// 0.804322
+0x3a6f
+// 0.522114
+0x382d
+// 0.456285
+0x374d
+// 0.325889
+0x3537
+// 0.052211
+0x2aaf
+// 0.471914
+0x378d
+// 0.620330
+0x38f6
+// 0.183729
+0x31e1
+// 0.612658
+0x38e7
+// 0.364133
+0x35d3
+// 0.520880
+0x382b
+// 0.693829
+0x398d
+// 0.146768
+0x30b2
+// 0.350727
+0x359d
+// 0.572416
+0x3894
+// 0.145950
+0x30ac
+// 0.659216
+0x3946
+// 0.232441
+0x3370
+// 0.365908
+0x35db
+// 0.533640
+0x3845
+// 0.578456
+0x38a1
+// 0.166925
+0x3157
+// 0.439703
+0x3709
+// 0.427486
+0x36d7
+// 0.461784
+0x3763
+// 0.292177
+0x34ad
+// 0.461312
+0x3762
+// 0.543533
+0x3859
+// 0.435610
+0x36f8
+// 0.237356
+0x3398
+// 0.366056
+0x35db
+// 0.196488
+0x324a
+// 0.022935
+0x25df
+// 0.359284
+0x35c0
+// 0.409479
+0x368d
+// 0.228371
+0x334f
+// 0.124286
+0x2ff4
+// 0.434761
+0x36f5
+// 0.629995
+0x390a

Testing/Patterns/DSP/ComplexMaths/ComplexMathsF16/Reference6_f16.txt

@@ -0,0 +1,514 @@
+H
+256
+// 0.044799
+0x29bc
+// 0.026955
+0x26e7
+// 0.155308
+0x30f8
+// 0.700622
+0x399b
+// 0.041226
+0x2947
+// 0.353181
+0x35a7
+// 0.180997
+0x31cb
+// 0.479153
+0x37ab
+// 0.229349
+0x3357
+// 0.534623
+0x3847
+// 0.052428
+0x2ab6
+// 0.179176
+0x31bc
+// 0.472553
+0x3790
+// 0.406630
+0x3682
+// 0.160454
+0x3122
+// 0.081168
+0x2d32
+// 0.641322
+0x3921
+// 0.281874
+0x3483
+// 0.808254
+0x3a77
+// 0.004561
+0x1cac
+// 0.175304
+0x319c
+// 0.178098
+0x31b3
+// 0.360140
+0x35c3
+// 0.009342
+0x20c8
+// 0.146573
+0x30b1
+// 0.306255
+0x34e6
+// 0.012054
+0x222c
+// 0.548488
+0x3863
+// 0.690467
+0x3986
+// 0.181983
+0x31d3
+// 0.079159
+0x2d11
+// 0.073247
+0x2cb0
+// 0.125462
+0x3004
+// 1.095754
+0x3c62
+// 0.879620
+0x3b09
+// 0.226672
+0x3341
+// 0.136860
+0x3061
+// 0.112116
+0x2f2d
+// 0.102075
+0x2e88
+// 0.014319
+0x2355
+// 0.442023
+0x3713
+// 0.411355
+0x3695
+// 0.172214
+0x3183
+// 0.679620
+0x3970
+// 0.163681
+0x313d
+// 0.080295
+0x2d24
+// 0.218787
+0x3300
+// 0.218863
+0x3301
+// 0.019693
+0x250b
+// 0.161829
+0x312e
+// 1.006794
+0x3c07
+// 0.020873
+0x2558
+// 0.212565
+0x32cd
+// 0.219598
+0x3307
+// 0.371205
+0x35f0
+// 0.314268
+0x3507
+// 0.168850
+0x3167
+// 0.038782
+0x28f7
+// 0.065855
+0x2c37
+// 0.189367
+0x320f
+// 0.105295
+0x2ebd
+// 0.138100
+0x306b
+// 0.047815
+0x2a1f
+// 0.105360
+0x2ebe
+// 0.009128
+0x20ac
+// 0.072067
+0x2c9d
+// 0.159221
+0x3118
+// 0.168559
+0x3165
+// 0.286522
+0x3496
+// 0.090382
+0x2dc9
+// 0.171368
+0x317c
+// 0.069649
+0x2c75
+// 0.051694
+0x2a9e
+// 0.060467
+0x2bbd
+// 0.197961
+0x3256
+// 0.236952
+0x3395
+// 0.150644
+0x30d2
+// 0.092373
+0x2de9
+// 0.102823
+0x2e95
+// 0.050704
+0x2a7d
+// 0.668084
+0x3958
+// 0.229798
+0x335b
+// 0.734466
+0x39e0
+// 0.126984
+0x3010
+// 0.018033
+0x249e
+// 0.105157
+0x2ebb
+// 0.323522
+0x352d
+// 0.091246
+0x2dd7
+// 0.050391
+0x2a73
+// 0.155377
+0x30f9
+// 0.333444
+0x3556
+// 0.062637
+0x2c02
+// 0.282681
+0x3486
+// 0.180400
+0x31c6
+// 0.427018
+0x36d5
+// 0.099980
+0x2e66
+// 0.051888
+0x2aa4
+// 0.033948
+0x2858
+// 0.008216
+0x2035
+// 0.214116
+0x32da
+// 0.118417
+0x2f94
+// 0.060177
+0x2bb4
+// 0.010061
+0x2127
+// 0.200412
+0x326a
+// 0.478267
+0x37a7
+// 0.132127
+0x303a
+// 0.211228
+0x32c2
+// 0.312711
+0x3501
+// 0.014216
+0x2347
+// 0.478003
+0x37a6
+// 0.179688
+0x31c0
+// 0.008535
+0x205f
+// 0.000272
+0xc76
+// 0.151987
+0x30dd
+// 0.096705
+0x2e30
+// 0.258636
+0x3423
+// 0.199548
+0x3263
+// 0.085277
+0x2d75
+// 0.078650
+0x2d09
+// 0.138152
+0x306c
+// 0.053447
+0x2ad7
+// 0.219573
+0x3307
+// 0.001400
+0x15bc
+// 0.234124
+0x337e
+// 0.188633
+0x3209
+// 0.026963
+0x26e7
+// 0.341926
+0x3579
+// 0.070225
+0x2c7f
+// 0.138118
+0x306b
+// 0.438310
+0x3703
+// 0.321151
+0x3523
+// 0.246759
+0x33e5
+// 0.280232
+0x347c
+// 0.158311
+0x3111
+// 0.253470
+0x340e
+// 0.023762
+0x2615
+// 0.189928
+0x3214
+// 0.882917
+0x3b10
+// 0.120608
+0x2fb8
+// 0.040985
+0x293f
+// 0.696661
+0x3993
+// 0.273351
+0x3460
+// 0.291322
+0x34a9
+// 0.152722
+0x30e3
+// 0.072866
+0x2caa
+// 0.279324
+0x3478
+// 0.020198
+0x252c
+// 0.257383
+0x341e
+// 0.042770
+0x2979
+// 0.630333
+0x390b
+// 0.698322
+0x3996
+// 0.449275
+0x3730
+// 0.012992
+0x22a7
+// 0.223217
+0x3325
+// 0.330719
+0x354b
+// 0.536907
+0x384c
+// 0.350221
+0x359b
+// 0.298963
+0x34c9
+// 0.087928
+0x2da1
+// 0.068340
+0x2c60
+// 0.326342
+0x3539
+// 0.347147
+0x358e
+// 0.676312
+0x3969
+// 0.130565
+0x302e
+// 0.023634
+0x260d
+// 0.217791
+0x32f8
+// 0.154834
+0x30f4
+// 0.521151
+0x382b
+// 0.007407
+0x1f96
+// 0.109808
+0x2f07
+// 0.386380
+0x362f
+// 0.266481
+0x3444
+// 0.595129
+0x38c3
+// 0.176577
+0x31a7
+// 0.178291
+0x31b5
+// 0.114447
+0x2f53
+// 0.556312
+0x3873
+// 0.423058
+0x36c5
+// 0.303234
+0x34da
+// 0.170221
+0x3172
+// 0.083276
+0x2d54
+// 0.124988
+0x3000
+// 0.050738
+0x2a7f
+// 0.037746
+0x28d5
+// 0.300227
+0x34ce
+// 0.090583
+0x2dcc
+// 0.254164
+0x3411
+// 1.054516
+0x3c38
+// 0.175011
+0x319a
+// 0.393386
+0x364b
+// 0.053260
+0x2ad1
+// 0.021077
+0x2565
+// 0.147889
+0x30bc
+// 0.077537
+0x2cf6
+// 0.116791
+0x2f7a
+// 0.201558
+0x3273
+// 0.054525
+0x2afb
+// 0.052461
+0x2ab7
+// 0.068200
+0x2c5d
+// 0.339091
+0x356d
+// 0.045982
+0x29e3
+// 0.038135
+0x28e2
+// 0.178093
+0x31b3
+// 1.451062
+0x3dce
+// 0.464864
+0x3770
+// 0.011804
+0x220b
+// 0.002968
+0x1a14
+// 0.072789
+0x2ca9
+// 0.019172
+0x24e8
+// 0.145560
+0x30a8
+// 0.050686
+0x2a7d
+// 0.041670
+0x2955
+// 0.081591
+0x2d39
+// 0.272416
+0x345c
+// 0.449953
+0x3733
+// 0.362239
+0x35cc
+// 0.013746
+0x230a
+// 0.646934
+0x392d
+// 0.272603
+0x345d
+// 0.208196
+0x32aa
+// 0.106203
+0x2ecc
+// 0.002726
+0x1995
+// 0.222703
+0x3320
+// 0.384809
+0x3628
+// 0.033756
+0x2852
+// 0.375349
+0x3601
+// 0.132593
+0x303e
+// 0.271316
+0x3457
+// 0.481399
+0x37b4
+// 0.021541
+0x2584
+// 0.123010
+0x2fdf
+// 0.327660
+0x353e
+// 0.021302
+0x2574
+// 0.434565
+0x36f4
+// 0.054029
+0x2aea
+// 0.133889
+0x3049
+// 0.284771
+0x348e
+// 0.334612
+0x355b
+// 0.027864
+0x2722
+// 0.193338
+0x3230
+// 0.182744
+0x31d9
+// 0.213245
+0x32d3
+// 0.085367
+0x2d77
+// 0.212809
+0x32cf
+// 0.295428
+0x34ba
+// 0.189756
+0x3212
+// 0.056338
+0x2b36
+// 0.133997
+0x304a
+// 0.038607
+0x28f1
+// 0.000526
+0x104f
+// 0.129085
+0x3021
+// 0.167673
+0x315e
+// 0.052153
+0x2aad
+// 0.015447
+0x23e9
+// 0.189017
+0x320c
+// 0.396894
+0x365a

Testing/Patterns/DSP/ComplexMaths/ComplexMathsF16/Reference7_f16.txt

@@ -0,0 +1,1026 @@
+H
+512
+// 0.026237
+0x26b7
+// 0.012021
+0x2228
+// 0.018246
+0x24ac
+// 0.020086
+0x2524
+// -0.211313
+0xb2c3
+// 0.025334
+0x267c
+// -0.103349
+0xae9d
+// 0.187393
+0x31ff
+// -0.049955
+0xaa65
+// -0.065499
+0xac31
+// -0.032959
+0xa838
+// -0.135871
+0xb059
+// -0.231366
+0xb367
+// -0.015951
+0xa415
+// 0.100871
+0x2e75
+// 0.038344
+0x28e8
+// -0.116389
+0xaf73
+// 0.109456
+0x2f01
+// -0.108988
+0xaefa
+// -0.003503
+0x9b2c
+// 0.037067
+0x28bf
+// 0.071020
+0x2c8c
+// -0.213711
+0xb2d7
+// -0.233915
+0xb37c
+// -0.372184
+0xb5f4
+// 0.009248
+0x20bc
+// 0.044880
+0x29bf
+// 0.230323
+0x335f
+// 0.171890
+0x3180
+// -0.108983
+0xaefa
+// -0.022131
+0xa5aa
+// 0.065031
+0x2c29
+// 0.029666
+0x2798
+// -0.241392
+0xb3b9
+// -0.229154
+0xb355
+// 0.027039
+0x26ec
+// -0.427357
+0xb6d6
+// 0.001104
+0x1486
+// 0.014233
+0x234a
+// -0.020175
+0xa52a
+// -0.157922
+0xb10e
+// 0.056022
+0x2b2c
+// 0.042613
+0x2974
+// 0.042085
+0x2963
+// -0.229074
+0xb355
+// -0.152909
+0xb0e5
+// -0.017012
+0xa45b
+// -0.032659
+0xa82e
+// 0.027454
+0x2707
+// -0.091059
+0xadd4
+// 0.040019
+0x291f
+// -0.364123
+0xb5d3
+// -0.027766
+0xa71c
+// 0.059258
+0x2b96
+// 0.301382
+0x34d2
+// -0.145108
+0xb0a5
+// -0.141991
+0xb08b
+// -0.089648
+0xadbd
+// 0.070417
+0x2c82
+// -0.003216
+0x9a96
+// -0.054228
+0xaaf1
+// -0.108621
+0xaef4
+// -0.043083
+0xa984
+// 0.067548
+0x2c53
+// -0.319292
+0xb51c
+// 0.028150
+0x2735
+// -0.395759
+0xb655
+// 0.690840
+0x3987
+// -0.327012
+0xb53b
+// -0.103580
+0xaea1
+// 0.012192
+0x223e
+// -0.047802
+0xaa1e
+// 0.013264
+0x22cb
+// 0.160014
+0x311f
+// 0.093133
+0x2df6
+// 0.028108
+0x2732
+// 0.174254
+0x3193
+// 0.020333
+0x2535
+// 0.005168
+0x1d4b
+// 0.026275
+0x26ba
+// 0.226404
+0x333f
+// 0.029164
+0x2777
+// 0.231200
+0x3366
+// 0.166580
+0x3155
+// 0.190623
+0x321a
+// 0.044373
+0x29ae
+// 0.086622
+0x2d8b
+// -0.851242
+0xbacf
+// 0.193208
+0x322f
+// -0.127271
+0xb013
+// 0.137776
+0x3069
+// -0.137006
+0xb062
+// -0.224493
+0xb32f
+// 0.184320
+0x31e6
+// 0.034721
+0x2872
+// 0.024053
+0x2628
+// -0.095052
+0xae15
+// -0.095085
+0xae16
+// -0.106965
+0xaed9
+// -0.168741
+0xb166
+// -0.081492
+0xad37
+// 0.130133
+0x302a
+// 0.012527
+0x226a
+// 0.037867
+0x28d9
+// 0.079391
+0x2d15
+// 0.266237
+0x3443
+// -0.091559
+0xaddc
+// -0.149124
+0xb0c6
+// -0.020915
+0xa55b
+// 0.361829
+0x35ca
+// -0.219090
+0xb303
+// -0.088448
+0xada9
+// 0.163238
+0x3139
+// 0.267940
+0x3449
+// -0.123479
+0xafe7
+// -0.089566
+0xadbb
+// 0.064191
+0x2c1c
+// 0.061100
+0x2bd2
+// -0.118563
+0xaf97
+// -0.032190
+0xa81f
+// 0.149068
+0x30c5
+// 0.020994
+0x2560
+// 0.000426
+0xefd
+// 0.113108
+0x2f3d
+// -0.006081
+0x9e3a
+// -0.066528
+0xac42
+// 0.076086
+0x2cdf
+// 0.045728
+0x29da
+// 0.010594
+0x216d
+// 0.002953
+0x1a0c
+// 0.048652
+0x2a3a
+// 0.115813
+0x2f69
+// 0.084998
+0x2d71
+// -0.005386
+0x9d84
+// -0.130998
+0xb031
+// -0.090149
+0xadc5
+// -0.166663
+0xb155
+// -0.211439
+0xb2c4
+// 0.144196
+0x309d
+// 0.031900
+0x2815
+// -0.050852
+0xaa82
+// -0.315348
+0xb50c
+// 0.077998
+0x2cfe
+// -0.175579
+0xb19e
+// -0.001977
+0x980c
+// -0.016873
+0xa452
+// 0.059609
+0x2ba1
+// -0.049547
+0xaa58
+// 0.047738
+0x2a1c
+// -0.077792
+0xacfb
+// 0.217685
+0x32f7
+// -0.006646
+0x9ece
+// 0.019760
+0x250f
+// 0.066188
+0x2c3c
+// 0.113506
+0x2f44
+// -0.040345
+0xa92a
+// 0.046317
+0x29ee
+// 0.076732
+0x2ce9
+// -0.033042
+0xa83b
+// 0.050743
+0x2a7f
+// 0.135806
+0x3059
+// 0.000706
+0x11c8
+// -0.010786
+0xa186
+// -0.005372
+0x9d80
+// -0.201106
+0xb26f
+// -0.103368
+0xae9e
+// 0.032791
+0x2833
+// -0.151164
+0xb0d6
+// -0.013925
+0xa321
+// -0.004024
+0x9c1f
+// 0.033748
+0x2852
+// 0.007717
+0x1fe7
+// 0.067443
+0x2c51
+// 0.099866
+0x2e64
+// -0.051678
+0xaa9d
+// -0.062898
+0xac07
+// 0.138999
+0x3073
+// 0.059133
+0x2b92
+// -0.076095
+0xacdf
+// 0.152808
+0x30e4
+// 0.261481
+0x342f
+// 0.234731
+0x3383
+// -0.037748
+0xa8d5
+// 0.098728
+0x2e52
+// 0.021421
+0x257c
+// 0.203378
+0x3282
+// 0.023295
+0x25f7
+// 0.110324
+0x2f10
+// -0.047276
+0xaa0d
+// -0.463293
+0xb76a
+// 0.059121
+0x2b91
+// 0.045763
+0x29dc
+// 0.076275
+0x2ce2
+// -0.021298
+0xa574
+// -0.081597
+0xad39
+// 0.019595
+0x2504
+// 0.019828
+0x2513
+// -0.029756
+0xa79e
+// 0.179449
+0x31be
+// 0.196936
+0x324d
+// 0.022162
+0x25ac
+// 0.028188
+0x2737
+// -0.039637
+0xa913
+// 0.053246
+0x2ad1
+// 0.047104
+0x2a08
+// 0.028246
+0x273b
+// 0.274604
+0x3465
+// 0.008853
+0x2088
+// -0.177853
+0xb1b1
+// 0.275737
+0x3469
+// -0.022588
+0xa5c8
+// -0.039415
+0xa90c
+// -0.027226
+0xa6f8
+// -0.049567
+0xaa58
+// -0.168260
+0xb162
+// -0.134831
+0xb051
+// -0.003903
+0x9bfe
+// 0.016553
+0x243d
+// -0.104497
+0xaeb0
+// 0.242480
+0x33c2
+// 0.145241
+0x30a6
+// -0.119339
+0xafa3
+// 0.064541
+0x2c21
+// -0.024029
+0xa627
+// -0.000175
+0x89ba
+// 0.000163
+0x955
+// -0.155104
+0xb0f7
+// 0.037508
+0x28cd
+// -0.124711
+0xaffb
+// 0.069882
+0x2c79
+// 0.206363
+0x329b
+// 0.119370
+0x2fa4
+// 0.077433
+0x2cf5
+// 0.072671
+0x2ca7
+// -0.047825
+0xaa1f
+// 0.049692
+0x2a5c
+// -0.148855
+0xb0c3
+// 0.084551
+0x2d69
+// -0.069756
+0xac77
+// 0.087149
+0x2d94
+// 0.101988
+0x2e87
+// 0.011754
+0x2205
+// -0.043960
+0xa9a0
+// -0.007854
+0xa005
+// 0.023436
+0x2600
+// 0.002071
+0x183e
+// -0.161752
+0xb12d
+// 0.126923
+0x3010
+// 0.048381
+0x2a31
+// 0.006885
+0x1f0d
+// -0.048133
+0xaa29
+// 0.053689
+0x2adf
+// -0.262164
+0xb432
+// 0.298638
+0x34c7
+// -0.016069
+0xa41d
+// 0.048087
+0x2a28
+// -0.000889
+0x9349
+// 0.030492
+0x27ce
+// 0.077412
+0x2cf4
+// -0.000830
+0x92cd
+// -0.001252
+0x9521
+// -0.042941
+0xa97f
+// -0.041442
+0xa94e
+// -0.199798
+0xb265
+// -0.208075
+0xb2a9
+// 0.072334
+0x2ca1
+// -0.188010
+0xb204
+// -0.044362
+0xa9ae
+// -0.136199
+0xb05c
+// -0.161749
+0xb12d
+// -0.012138
+0xa237
+// 0.097922
+0x2e44
+// 0.170918
+0x3178
+// -0.076238
+0xace1
+// -0.168957
+0xb168
+// -0.886368
+0xbb17
+// 0.257089
+0x341d
+// -0.064374
+0xac1f
+// 0.041446
+0x294e
+// 0.049535
+0x2a57
+// 0.147859
+0x30bb
+// 0.057937
+0x2b6a
+// 0.119196
+0x2fa1
+// 0.126457
+0x300c
+// 0.200288
+0x3269
+// 0.001634
+0x16b1
+// -0.215625
+0xb2e6
+// -0.076785
+0xacea
+// 0.068253
+0x2c5e
+// 0.030484
+0x27ce
+// -0.111549
+0xaf24
+// 0.076042
+0x2cde
+// -0.020455
+0xa53d
+// -0.068344
+0xac60
+// -0.104087
+0xaea9
+// 0.071034
+0x2c8c
+// 0.040525
+0x2930
+// 0.015778
+0x240a
+// 0.076314
+0x2ce2
+// 0.174450
+0x3195
+// 0.019139
+0x24e6
+// -0.068032
+0xac5b
+// -0.408694
+0xb68a
+// 0.181423
+0x31ce
+// -0.031082
+0xa7f5
+// 0.049947
+0x2a65
+// 0.259133
+0x3425
+// 0.220366
+0x330d
+// -0.123520
+0xafe8
+// 0.074383
+0x2cc3
+// 0.265099
+0x343e
+// -0.123416
+0xafe6
+// -0.111432
+0xaf22
+// -0.240392
+0xb3b1
+// -0.134809
+0xb050
+// 0.088077
+0x2da3
+// 0.041715
+0x2957
+// -0.042280
+0xa969
+// -0.113876
+0xaf4a
+// 0.050777
+0x2a80
+// -0.297879
+0xb4c4
+// -0.132088
+0xb03a
+// 0.112504
+0x2f33
+// -0.368797
+0xb5e7
+// 0.115531
+0x2f65
+// -0.455162
+0xb748
+// 0.056287
+0x2b34
+// -0.218710
+0xb300
+// 0.050622
+0x2a7b
+// -0.098423
+0xae4d
+// -0.254574
+0xb413
+// -0.095075
+0xae16
+// 0.165185
+0x3149
+// -0.073282
+0xacb1
+// -0.515258
+0xb81f
+// -0.309115
+0xb4f2
+// 0.037895
+0x28da
+// 0.013370
+0x22d8
+// 0.266528
+0x3444
+// -0.195624
+0xb243
+// -0.095498
+0xae1d
+// 0.058459
+0x2b7c
+// -0.024052
+0xa628
+// -0.070502
+0xac83
+// -0.038394
+0xa8ea
+// -0.178678
+0xb1b8
+// 0.033758
+0x2852
+// -0.072554
+0xaca5
+// -0.083156
+0xad52
+// -0.057860
+0xab68
+// -0.161891
+0xb12e
+// -0.096549
+0xae2e
+// 0.511260
+0x3817
+// 0.486534
+0x37c9
+// 0.200856
+0x326d
+// -0.349625
+0xb598
+// -0.281519
+0xb481
+// 0.172951
+0x3189
+// 0.059706
+0x2ba4
+// 0.134141
+0x304b
+// 0.266779
+0x3445
+// -0.175085
+0xb19a
+// 0.173642
+0x318e
+// -0.051135
+0xaa8c
+// 0.038515
+0x28ee
+// 0.020495
+0x253f
+// -0.049162
+0xaa4b
+// -0.053789
+0xaae3
+// -0.046777
+0xa9fd
+// 0.092511
+0x2dec
+// 0.075250
+0x2cd1
+// 0.240267
+0x33b0
+// -0.021872
+0xa599
+// 0.247934
+0x33ef
+// 0.298719
+0x34c8
+// -0.505620
+0xb80c
+// 0.119002
+0x2f9e
+// -0.109561
+0xaf03
+// 0.188085
+0x3205
+// 0.261937
+0x3431
+// -0.054221
+0xaaf1
+// -0.045418
+0xa9d0
+// 0.005445
+0x1d93
+// 0.074715
+0x2cc8
+// -0.035517
+0xa88c
+// -0.189423
+0xb210
+// -0.031976
+0xa818
+// 0.192228
+0x3227
+// 0.031213
+0x27fe
+// -0.000968
+0x93ed
+// -0.001066
+0x945e
+// -0.117732
+0xaf89
+// 0.002430
+0x18fa
+// -0.108259
+0xaeee
+// 0.035720
+0x2892
+// -0.071671
+0xac96
+// 0.115649
+0x2f67
+// 0.035319
+0x2885
+// 0.000550
+0x1081
+// 0.051855
+0x2aa3
+// 0.040199
+0x2925
+// -0.087413
+0xad98
+// 0.002305
+0x18b8
+// 0.011034
+0x21a6
+// -0.025685
+0xa693
+// 0.031285
+0x2801
+// -0.074231
+0xacc0
+// 0.057793
+0x2b66
+// -0.290183
+0xb4a5
+// 0.157412
+0x310a
+// 0.003824
+0x1bd5
+// -0.010089
+0xa12a
+// -0.001398
+0x95ba
+// -0.002427
+0x98f9
+// 0.117326
+0x2f82
+// 0.130789
+0x302f
+// -0.035215
+0xa882
+// 0.018124
+0x24a4
+// 0.012680
+0x227e
+// -0.299782
+0xb4cc
+// -0.048547
+0xaa37
+// 0.029777
+0x279f
+// 0.032391
+0x2825
+// -0.108958
+0xaef9
+// 0.012638
+0x2279
+// 0.095549
+0x2e1d
+// 0.062726
+0x2c04
+// 0.189149
+0x320e
+// 0.069866
+0x2c79
+// -0.047962
+0xaa24
+// 0.000967
+0x13ed
+// -0.048987
+0xaa45
+// -0.040801
+0xa939
+// 0.075747
+0x2cd9
+// -0.013666
+0xa2ff
+// 0.478582
+0x37a8
+// -0.198797
+0xb25d
+// 0.063520
+0x2c11
+// -0.096443
+0xae2c
+// -0.284561
+0xb48e
+// -0.055797
+0xab24
+// -0.017494
+0xa47b
+// -0.002737
+0x999b
+// 0.006588
+0x1ebf
+// -0.201439
+0xb272
+// 0.288603
+0x349e
+// 0.523448
+0x3830
+// -0.066849
+0xac47
+// 0.009563
+0x20e5
+// 0.078370
+0x2d04
+// 0.133304
+0x3044
+// 0.359954
+0x35c2
+// -0.137694
+0xb068
+// -0.055895
+0xab28
+// -0.049784
+0xaa5f
+// 0.050736
+0x2a7f
+// 0.253132
+0x340d
+// 0.171803
+0x317f
+// -0.060606
+0xabc2
+// -0.088393
+0xada8
+// 0.073472
+0x2cb4
+// -0.047895
+0xaa21
+// -0.048087
+0xaa28
+// -0.323992
+0xb52f
+// 0.050304
+0x2a70
+// 0.064710
+0x2c24
+// -0.140617
+0xb080
+// -0.554671
+0xb870
+// 0.082448
+0x2d47
+// 0.090040
+0x2dc3
+// 0.097774
+0x2e42
+// 0.073862
+0x2cba
+// 0.180393
+0x31c6
+// -0.005098
+0x9d38
+// 0.120973
+0x2fbe
+// -0.264083
+0xb43a
+// 0.032893
+0x2836
+// -0.046823
+0xa9fe
+// 0.122973
+0x2fdf
+// -0.031135
+0xa7f8
+// -0.020557
+0xa543
+// -0.109993
+0xaf0a
+// -0.071880
+0xac9a
+// 0.121039
+0x2fbf
+// -0.101740
+0xae83
+// 0.150771
+0x30d3
+// -0.089840
+0xadc0
+// 0.102906
+0x2e96
+// 0.386017
+0x362d
+// 0.057210
+0x2b53
+// 0.208713
+0x32ae
+// 0.045209
+0x29c9
+// -0.034784
+0xa874
+// 0.017008
+0x245b
+// 0.071530
+0x2c94
+// 0.095589
+0x2e1e
+// 0.015190
+0x23c7
+// 0.114086
+0x2f4d
+// 0.000970
+0x13f1
+// -0.000226
+0x8b64
+// 0.073700
+0x2cb8
+// -0.156686
+0xb104
+// -0.116843
+0xaf7a
+// 0.104897
+0x2eb7
+// -0.056784
+0xab45
+// 0.053125
+0x2acd
+// 0.006185
+0x1e55
+// 0.047466
+0x2a13
+// 0.120711
+0x2fba
+// -0.115251
+0xaf60
+// -0.247703
+0xb3ed
+// 0.175228
+0x319b

Testing/Patterns/DSP/ComplexMaths/ComplexMathsF16/Reference8_f16.txt

@@ -0,0 +1,1026 @@
+H
+512
+// -0.115691
+0xaf67
+// -0.055579
+0xab1d
+// 0.005252
+0x1d61
+// 0.010796
+0x2187
+// -0.040285
+0xa928
+// 0.038178
+0x28e3
+// 0.627871
+0x3906
+// 0.417413
+0x36ae
+// 0.028895
+0x2766
+// -0.008657
+0xa06f
+// -0.029902
+0xa7a8
+// -0.152732
+0xb0e3
+// -0.179934
+0xb1c2
+// -0.146348
+0xb0af
+// 0.350343
+0x359b
+// 0.257733
+0x3420
+// 0.135270
+0x3054
+// -0.194973
+0xb23d
+// -0.007341
+0x9f84
+// -0.045605
+0xa9d6
+// 0.036177
+0x28a1
+// -0.014165
+0xa341
+// -0.054597
+0xaafd
+// 0.028913
+0x2767
+// -0.197872
+0xb255
+// -0.278241
+0xb474
+// 0.048614
+0x2a39
+// 0.635820
+0x3916
+// -0.012004
+0xa225
+// -0.051415
+0xaa95
+// 0.002669
+0x1977
+// -0.010044
+0xa124
+// -0.090786
+0xadcf
+// -0.330056
+0xb548
+// 0.090791
+0x2dd0
+// -0.264571
+0xb43c
+// -0.017141
+0xa463
+// -0.136853
+0xb061
+// -0.009040
+0xa0a1
+// 0.008154
+0x202d
+// -0.066441
+0xac41
+// -0.045520
+0xa9d4
+// 0.038378
+0x28ea
+// 0.222161
+0x331c
+// -0.086049
+0xad82
+// 0.004337
+0x1c71
+// 0.035858
+0x2897
+// 0.007054
+0x1f39
+// -0.120302
+0xafb3
+// 0.086604
+0x2d8b
+// 0.100678
+0x2e72
+// -0.000336
+0x8d83
+// 0.046487
+0x29f3
+// 0.050781
+0x2a80
+// -0.229819
+0xb35b
+// -0.532039
+0xb842
+// -0.143320
+0xb096
+// 0.123743
+0x2feb
+// -0.265065
+0xb43e
+// 0.289465
+0x34a2
+// 0.000257
+0xc38
+// -0.008096
+0xa025
+// -0.000285
+0x8cab
+// -0.000495
+0x900f
+// 0.021436
+0x257d
+// 0.157242
+0x3108
+// 0.220238
+0x330c
+// 0.159255
+0x3119
+// 0.124796
+0x2ffd
+// -0.236261
+0xb38f
+// 0.067717
+0x2c55
+// 0.046441
+0x29f2
+// 0.103442
+0x2e9f
+// 0.044400
+0x29af
+// 0.002899
+0x19f0
+// 0.043597
+0x2995
+// -0.064616
+0xac23
+// 0.013754
+0x230b
+// -0.003605
+0x9b62
+// 0.045817
+0x29dd
+// -0.107401
+0xaee0
+// -0.087611
+0xad9b
+// 0.061909
+0x2bed
+// 0.009091
+0x20a8
+// -0.029966
+0xa7ac
+// 0.040715
+0x2936
+// -0.183614
+0xb1e0
+// 0.469920
+0x3785
+// 0.023930
+0x2620
+// -0.007959
+0xa013
+// 0.125114
+0x3001
+// 0.121191
+0x2fc2
+// 0.202757
+0x327d
+// 0.032252
+0x2821
+// -0.070176
+0xac7e
+// -0.058955
+0xab8c
+// -0.007705
+0x9fe4
+// -0.008373
+0xa049
+// -0.001349
+0x9586
+// 0.004936
+0x1d0e
+// -0.258657
+0xb423
+// 0.021319
+0x2575
+// 0.012068
+0x222e
+// 0.036912
+0x28ba
+// 0.032918
+0x2837
+// -0.077710
+0xacf9
+// 0.012352
+0x2253
+// 0.039155
+0x2903
+// 0.015181
+0x23c6
+// -0.259978
+0xb429
+// 0.058902
+0x2b8a
+// -0.158666
+0xb114
+// 0.071557
+0x2c94
+// -0.065537
+0xac32
+// -0.017337
+0xa470
+// -0.032764
+0xa832
+// 0.017901
+0x2495
+// -0.014337
+0xa357
+// 0.076437
+0x2ce4
+// -0.102834
+0xae95
+// -0.077284
+0xacf2
+// 0.144961
+0x30a4
+// -0.006960
+0x9f21
+// 0.312505
+0x3500
+// 0.007714
+0x1fe6
+// 0.021404
+0x257b
+// -0.048566
+0xaa37
+// 0.079006
+0x2d0e
+// 0.018386
+0x24b5
+// -0.066860
+0xac47
+// -0.172787
+0xb187
+// -0.024137
+0xa62e
+// 0.254836
+0x3414
+// 0.071846
+0x2c99
+// 0.025742
+0x2697
+// 0.002223
+0x188d
+// -0.205033
+0xb290
+// 0.032114
+0x281c
+// 0.154999
+0x30f6
+// 0.039308
+0x2908
+// 0.114731
+0x2f58
+// -0.007056
+0x9f3a
+// 0.082986
+0x2d50
+// -0.014214
+0xa347
+// 0.008962
+0x2097
+// -0.013840
+0xa316
+// -0.148641
+0xb0c2
+// -0.049747
+0xaa5e
+// -0.134149
+0xb04b
+// 0.043318
+0x298b
+// 0.014964
+0x23a9
+// 0.004120
+0x1c38
+// -0.022654
+0xa5cd
+// -0.035737
+0xa893
+// 0.030121
+0x27b6
+// -0.158724
+0xb114
+// 0.034173
+0x2860
+// -0.015103
+0xa3bc
+// 0.001017
+0x142a
+// 0.000585
+0x10ca
+// -0.046922
+0xaa02
+// -0.137902
+0xb06a
+// 0.024763
+0x2657
+// 0.039046
+0x28ff
+// -0.060301
+0xabb8
+// -0.046923
+0xaa02
+// -0.029344
+0xa783
+// -0.062581
+0xac01
+// -0.020877
+0xa558
+// 0.037318
+0x28c7
+// 0.003586
+0x1b58
+// 0.044392
+0x29af
+// 0.124953
+0x2fff
+// -0.136516
+0xb05e
+// 0.066633
+0x2c44
+// -0.105478
+0xaec0
+// -0.000578
+0x90bc
+// 0.001589
+0x1682
+// -0.003790
+0x9bc3
+// -0.002485
+0x9917
+// 0.203373
+0x3282
+// -0.040602
+0xa932
+// -0.069006
+0xac6b
+// 0.039608
+0x2912
+// 0.002567
+0x1942
+// 0.009533
+0x20e1
+// -0.147032
+0xb0b4
+// 0.051432
+0x2a95
+// -0.142784
+0xb092
+// -0.024807
+0xa65a
+// -0.034475
+0xa86a
+// -0.128255
+0xb01b
+// 0.000739
+0x120d
+// -0.009296
+0xa0c2
+// 0.005591
+0x1dba
+// 0.066601
+0x2c43
+// -0.032933
+0xa837
+// -0.027199
+0xa6f6
+// 0.025033
+0x2669
+// 0.038708
+0x28f4
+// -0.094668
+0xae0f
+// -0.060223
+0xabb5
+// -0.030680
+0xa7db
+// 0.069863
+0x2c79
+// 0.010262
+0x2141
+// -0.011868
+0xa214
+// 0.030652
+0x27d9
+// 0.002173
+0x1873
+// -0.018692
+0xa4c9
+// 0.063648
+0x2c13
+// 0.004812
+0x1ced
+// -0.001610
+0x9699
+// -0.228616
+0xb351
+// 0.160540
+0x3123
+// -0.017834
+0xa491
+// 0.049107
+0x2a49
+// 0.022286
+0x25b5
+// -0.032416
+0xa826
+// -0.048344
+0xaa30
+// 0.033231
+0x2841
+// 0.281720
+0x3482
+// 0.123873
+0x2fee
+// 0.018989
+0x24dc
+// 0.012953
+0x22a2
+// -0.008445
+0xa053
+// -0.005778
+0x9deb
+// -0.014177
+0xa342
+// 0.062624
+0x2c02
+// -0.004636
+0x9cbf
+// -0.013457
+0xa2e4
+// -0.021988
+0xa5a1
+// 0.132677
+0x303f
+// 0.102038
+0x2e88
+// -0.029996
+0xa7ae
+// 0.061299
+0x2bd9
+// 0.020074
+0x2524
+// -0.002267
+0x98a4
+// 0.004683
+0x1ccc
+// -0.020764
+0xa551
+// -0.004451
+0x9c8f
+// 0.014538
+0x2371
+// 0.032843
+0x2834
+// -0.014053
+0xa332
+// 0.011331
+0x21cd
+// 0.003345
+0x1ada
+// 0.007049
+0x1f38
+// -0.017483
+0xa47a
+// -0.044504
+0xa9b2
+// 0.010185
+0x2137
+// 0.005934
+0x1e14
+// 0.038725
+0x28f5
+// 0.038636
+0x28f2
+// 0.182860
+0x31da
+// 0.167076
+0x3159
+// -0.081961
+0xad3f
+// -0.111181
+0xaf1e
+// -0.136876
+0xb061
+// 0.063535
+0x2c11
+// -0.300464
+0xb4cf
+// 0.037308
+0x28c7
+// -0.025256
+0xa677
+// 0.044285
+0x29ab
+// 0.051966
+0x2aa7
+// -0.011657
+0xa1f8
+// -0.026428
+0xa6c4
+// 0.039420
+0x290c
+// 0.006182
+0x1e55
+// -0.107035
+0xaeda
+// 0.035038
+0x287c
+// 0.069748
+0x2c77
+// 0.000643
+0x1144
+// 0.003651
+0x1b7a
+// -0.011514
+0xa1e5
+// 0.095507
+0x2e1d
+// 0.022507
+0x25c3
+// 0.019983
+0x251e
+// 0.166833
+0x3157
+// -0.104632
+0xaeb2
+// -0.025823
+0xa69c
+// 0.014339
+0x2357
+// -0.068495
+0xac62
+// 0.039586
+0x2911
+// 0.126959
+0x3010
+// -0.108182
+0xaeec
+// -0.033408
+0xa847
+// 0.036658
+0x28b1
+// -0.040361
+0xa92b
+// -0.157870
+0xb10d
+// 0.018531
+0x24be
+// 0.017321
+0x246f
+// 0.226744
+0x3341
+// 0.194219
+0x3237
+// -0.036197
+0xa8a2
+// 0.021703
+0x258e
+// 0.060579
+0x2bc1
+// -0.087221
+0xad95
+// 0.026144
+0x26b1
+// 0.048169
+0x2a2a
+// -0.032161
+0xa81e
+// 0.066653
+0x2c44
+// -0.491712
+0xb7de
+// 0.170623
+0x3176
+// -0.049634
+0xaa5a
+// -0.029033
+0xa76f
+// 0.059544
+0x2b9f
+// 0.047922
+0x2a22
+// 0.001614
+0x169d
+// -0.015255
+0xa3cf
+// -0.057808
+0xab66
+// 0.035566
+0x288d
+// 0.047329
+0x2a0f
+// 0.191497
+0x3221
+// -0.119573
+0xafa7
+// 0.047829
+0x2a1f
+// 0.106207
+0x2ecc
+// 0.048702
+0x2a3c
+// -0.128611
+0xb01e
+// -0.020197
+0xa52c
+// 0.002521
+0x192a
+// 0.063183
+0x2c0b
+// 0.232719
+0x3372
+// 0.068212
+0x2c5e
+// 0.073936
+0x2cbb
+// -0.194009
+0xb235
+// 0.469113
+0x3781
+// -0.119281
+0xafa2
+// -0.093064
+0xadf5
+// -0.022226
+0xa5b1
+// -0.012112
+0xa234
+// -0.049136
+0xaa4a
+// 0.013858
+0x2318
+// 0.007729
+0x1fea
+// 0.115614
+0x2f66
+// 0.119776
+0x2faa
+// -0.043619
+0xa995
+// 0.436977
+0x36fe
+// 0.006497
+0x1ea7
+// 0.028436
+0x2748
+// 0.138750
+0x3071
+// -0.010866
+0xa190
+// 0.018971
+0x24db
+// -0.123212
+0xafe3
+// -0.102873
+0xae95
+// -0.135548
+0xb056
+// 0.216662
+0x32ef
+// 0.067692
+0x2c55
+// 0.173470
+0x318d
+// -0.335046
+0xb55c
+// 0.057443
+0x2b5a
+// -0.035736
+0xa893
+// 0.035783
+0x2895
+// 0.026577
+0x26ce
+// 0.114329
+0x2f51
+// 0.103105
+0x2e99
+// 0.016740
+0x2449
+// 0.069051
+0x2c6b
+// -0.112993
+0xaf3b
+// 0.167734
+0x315e
+// 0.116706
+0x2f78
+// -0.030597
+0xa7d5
+// 0.049094
+0x2a49
+// -0.109044
+0xaefb
+// 0.216721
+0x32ef
+// -0.067967
+0xac5a
+// 0.029454
+0x278a
+// 0.044901
+0x29bf
+// -0.001382
+0x95a9
+// -0.017506
+0xa47b
+// 0.021803
+0x2595
+// -0.280106
+0xb47b
+// 0.078229
+0x2d02
+// -0.045908
+0xa9e0
+// 0.104473
+0x2eb0
+// 0.210912
+0x32c0
+// 0.069654
+0x2c75
+// -0.197880
+0xb255
+// -0.034317
+0xa865
+// -0.089667
+0xadbd
+// -0.014720
+0xa389
+// 0.073745
+0x2cb8
+// -0.078647
+0xad09
+// -0.064323
+0xac1e
+// 0.093792
+0x2e01
+// 0.010387
+0x2151
+// -0.020283
+0xa531
+// 0.045474
+0x29d2
+// -0.038902
+0xa8fb
+// -0.054694
+0xab00
+// 0.137524
+0x3067
+// -0.030140
+0xa7b7
+// -0.100121
+0xae68
+// -0.021583
+0xa586
+// -0.137699
+0xb068
+// -0.171615
+0xb17e
+// 0.080963
+0x2d2e
+// -0.038267
+0xa8e6
+// 0.031087
+0x27f5
+// 0.036222
+0x28a3
+// -0.118944
+0xaf9d
+// -0.060280
+0xabb7
+// 0.020844
+0x2556
+// -0.017320
+0xa46f
+// 0.041239
+0x2947
+// 0.015243
+0x23ce
+// -0.069435
+0xac72
+// -0.057912
+0xab6a
+// 0.295657
+0x34bb
+// -0.439481
+0xb708
+// -0.324263
+0xb530
+// 0.290029
+0x34a4
+// -0.067569
+0xac53
+// -0.026278
+0xa6ba
+// 0.003852
+0x1be3
+// -0.018862
+0xa4d4
+// 0.082200
+0x2d43
+// 0.033808
+0x2854
+// -0.040815
+0xa939
+// -0.063148
+0xac0b
+// -0.056274
+0xab34
+// -0.049075
+0xaa48
+// 0.000053
+0x37b
+// -0.000047
+0x8310
+// -0.013311
+0xa2d1
+// 0.069429
+0x2c72
+// 0.005309
+0x1d70
+// -0.010127
+0xa12f
+// 0.161187
+0x3128
+// 0.013580
+0x22f4
+// -0.098031
+0xae46
+// -0.105489
+0xaec0
+// -0.048115
+0xaa29
+// 0.146516
+0x30b0
+// 0.022074
+0x25a7
+// -0.020379
+0xa538
+// 0.087528
+0x2d9a
+// 0.328932
+0x3543
+// 0.032638
+0x282d
+// -0.017460
+0xa478
+// -0.184191
+0xb1e5
+// -0.027631
+0xa713
+// -0.037562
+0xa8cf
+// -0.075489
+0xacd5
+// -0.023605
+0xa60b
+// 0.030787
+0x27e2
+// 0.076005
+0x2cdd
+// -0.135132
+0xb053
+// 0.240323
+0x33b1
+// 0.198437
+0x325a
+// -0.078203
+0xad01
+// -0.064270
+0xac1d
+// -0.049299
+0xaa4f
+// 0.278495
+0x3475
+// 0.003436
+0x1b09
+// 0.035642
+0x2890
+// 0.134684
+0x304f
+// -0.108438
+0xaef1
+// -0.338608
+0xb56b
+// -0.081620
+0xad39
+// -0.008563
+0xa062
+// 0.002376
+0x18de
+// -0.044476
+0xa9b1
+// -0.062457
+0xabff
+// 0.118258
+0x2f92
+// 0.001301
+0x1554
+// -0.062645
+0xac02
+// 0.040036
+0x2920
+// -0.020188
+0xa52b
+// 0.217449
+0x32f5
+// 0.007948
+0x2012
+// -0.032445
+0xa827
+// -0.000669
+0x917b
+// -0.002938
+0x9a05
+// 0.127821
+0x3017
+// 0.048944
+0x2a44
+// 0.054649
+0x2aff
+// -0.070956
+0xac8b
+// -0.011229
+0xa1c0
+// -0.100654
+0xae71
+// 0.008045
+0x201e
+// -0.017287
+0xa46d
+// -0.081419
+0xad36
+// -0.158251
+0xb110
+// 0.011566
+0x21ec
+// 0.060173
+0x2bb4
+// 0.146997
+0x30b4
+// 0.149173
+0x30c6
+// -0.261626
+0xb430
+// -0.277906
+0xb472
+// -0.025311
+0xa67b
+// -0.054014
+0xaaea
+// 0.070018
+0x2c7b
+// 0.197480
+0x3252
+// 0.030516
+0x27d0
+// 0.096094
+0x2e26
+// 0.030302
+0x27c2
+// -0.054229
+0xaaf1
+// 0.012666
+0x227c
+// 0.013952
+0x2325
+// -0.000308
+0x8d0a
+// -0.000402
+0x8e97
+// -0.012654
+0xa27b
+// 0.080634
+0x2d29
+// -0.156413
+0xb101
+// 0.002365
+0x18d8
+// 0.019256
+0x24ee
+// -0.069600
+0xac74
+// -0.002316
+0x98be
+// -0.002562
+0x993f
+// -0.040669
+0xa935
+// 0.023353
+0x25fa
+// 0.021173
+0x256c
+// 0.053842
+0x2ae4

Testing/Patterns/DSP/ComplexMaths/ComplexMathsF16/Reference9_f16.txt

@@ -0,0 +1,6 @@
+H
+2
+// -0.368091
+0xb5e4
+// -0.861249
+0xbae4

Testing/Source/Tests/ComplexTestsF16.cpp

@@ -0,0 +1,308 @@
+#include "ComplexTestsF16.h"
+#include <stdio.h>
+#include "Error.h"
+
+#define SNR_THRESHOLD 40
+
+#define REL_ERROR (6.0e-2)
+
+    void ComplexTestsF16::test_cmplx_conj_f16()
+    {
+        const float16_t *inp1=input1.ptr();
+        float16_t *outp=output.ptr();
+
+
+        arm_cmplx_conj_f16(inp1,outp,input1.nbSamples() >> 1 );
+
+        ASSERT_EMPTY_TAIL(output);
+
+        ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD);
+
+        ASSERT_REL_ERROR(output,ref,REL_ERROR);
+
+
+    } 
+
+
+    void ComplexTestsF16::test_cmplx_dot_prod_f16()
+    {
+        float16_t re,im;
+
+        const float16_t *inp1=input1.ptr();
+        const float16_t *inp2=input2.ptr();
+        float16_t *outp=output.ptr();
+
+        arm_cmplx_dot_prod_f16(inp1,inp2,input1.nbSamples() >> 1,&re,&im);
+
+        outp[0] = re;
+        outp[1] = im;
+
+        ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD);
+
+        ASSERT_REL_ERROR(output,ref,REL_ERROR);
+
+        ASSERT_EMPTY_TAIL(output);
+    } 
+
+    void ComplexTestsF16::test_cmplx_mag_f16()
+    {
+        const float16_t *inp1=input1.ptr();
+        float16_t *outp=output.ptr();
+
+        arm_cmplx_mag_f16(inp1,outp,input1.nbSamples() >> 1 );
+        
+        ASSERT_EMPTY_TAIL(output);
+
+        ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD);
+
+        ASSERT_REL_ERROR(output,ref,REL_ERROR);
+    } 
+
+    void ComplexTestsF16::test_cmplx_mag_squared_f16()
+    {
+        const float16_t *inp1=input1.ptr();
+        float16_t *outp=output.ptr();
+
+        arm_cmplx_mag_squared_f16(inp1,outp,input1.nbSamples() >> 1 );
+
+        ASSERT_EMPTY_TAIL(output);
+        
+
+        ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD);
+
+        ASSERT_REL_ERROR(output,ref,REL_ERROR);
+    } 
+
+    void ComplexTestsF16::test_cmplx_mult_cmplx_f16()
+    {
+        const float16_t *inp1=input1.ptr();
+        const float16_t *inp2=input2.ptr();
+        float16_t *outp=output.ptr();
+
+        arm_cmplx_mult_cmplx_f16(inp1,inp2,outp,input1.nbSamples() >> 1 );
+
+        ASSERT_EMPTY_TAIL(output);
+        
+
+        ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD);
+
+        ASSERT_REL_ERROR(output,ref,REL_ERROR);
+    } 
+
+    void ComplexTestsF16::test_cmplx_mult_real_f16()
+    {
+        const float16_t *inp1=input1.ptr();
+        const float16_t *inp2=input2.ptr();
+        float16_t *outp=output.ptr();
+
+        arm_cmplx_mult_real_f16(inp1,inp2,outp,input1.nbSamples() >> 1 );
+
+        ASSERT_EMPTY_TAIL(output);
+        
+
+        ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD);
+
+        ASSERT_REL_ERROR(output,ref,REL_ERROR);
+    } 
+ 
+    void ComplexTestsF16::setUp(Testing::testID_t id,std::vector<Testing::param_t>& params,Client::PatternMgr *mgr)
+    {
+      
+       Testing::nbSamples_t nb=MAX_NB_SAMPLES; 
+       (void)params;
+
+       
+       switch(id)
+       {
+        case ComplexTestsF16::TEST_CMPLX_CONJ_F16_1:
+          nb = 7;
+          ref.reload(ComplexTestsF16::REF_CONJ_F16_ID,mgr,nb << 1);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+          break;
+        case ComplexTestsF16::TEST_CMPLX_CONJ_F16_2:
+          nb = 16;
+          ref.reload(ComplexTestsF16::REF_CONJ_F16_ID,mgr,nb << 1);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+          break;
+        case ComplexTestsF16::TEST_CMPLX_CONJ_F16_3:
+          nb = 23;
+          ref.reload(ComplexTestsF16::REF_CONJ_F16_ID,mgr,nb << 1);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+          break;
+        case ComplexTestsF16::TEST_CMPLX_DOT_PROD_F16_4:
+          nb = 7;
+          ref.reload(ComplexTestsF16::REF_DOT_PROD_3_F16_ID,mgr);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+          input2.reload(ComplexTestsF16::INPUT2_F16_ID,mgr,nb << 1);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+          break;
+
+        case ComplexTestsF16::TEST_CMPLX_DOT_PROD_F16_5:
+          nb = 16;
+          ref.reload(ComplexTestsF16::REF_DOT_PROD_4N_F16_ID,mgr);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+          input2.reload(ComplexTestsF16::INPUT2_F16_ID,mgr,nb << 1);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+          break;
+
+        case ComplexTestsF16::TEST_CMPLX_DOT_PROD_F16_6:
+          nb = 23;
+          ref.reload(ComplexTestsF16::REF_DOT_PROD_4N1_F16_ID,mgr);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+          input2.reload(ComplexTestsF16::INPUT2_F16_ID,mgr,nb << 1);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+          break;
+        case ComplexTestsF16::TEST_CMPLX_MAG_F16_7:
+          nb = 7;
+          ref.reload(ComplexTestsF16::REF_MAG_F16_ID,mgr,nb);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+          break;
+        case ComplexTestsF16::TEST_CMPLX_MAG_F16_8:
+          nb = 16;
+          ref.reload(ComplexTestsF16::REF_MAG_F16_ID,mgr,nb);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+          break;
+        case ComplexTestsF16::TEST_CMPLX_MAG_F16_9:
+          nb = 23;
+          ref.reload(ComplexTestsF16::REF_MAG_F16_ID,mgr,nb);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+          break;
+        case ComplexTestsF16::TEST_CMPLX_MAG_SQUARED_F16_10:
+          nb = 7;
+          ref.reload(ComplexTestsF16::REF_MAG_SQUARED_F16_ID,mgr,nb);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+          break;
+        case ComplexTestsF16::TEST_CMPLX_MAG_SQUARED_F16_11:
+          nb = 16;
+          ref.reload(ComplexTestsF16::REF_MAG_SQUARED_F16_ID,mgr,nb);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+          break;
+        case ComplexTestsF16::TEST_CMPLX_MAG_SQUARED_F16_12:
+          nb = 23;
+          ref.reload(ComplexTestsF16::REF_MAG_SQUARED_F16_ID,mgr,nb);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+          break;
+        case ComplexTestsF16::TEST_CMPLX_MULT_CMPLX_F16_13:
+          nb = 7;
+          ref.reload(ComplexTestsF16::REF_CMPLX_MULT_CMPLX_F16_ID,mgr,nb << 1);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+          input2.reload(ComplexTestsF16::INPUT2_F16_ID,mgr,nb << 1);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+          break;
+        case ComplexTestsF16::TEST_CMPLX_MULT_CMPLX_F16_14:
+          nb = 16;
+          ref.reload(ComplexTestsF16::REF_CMPLX_MULT_CMPLX_F16_ID,mgr,nb << 1);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+          input2.reload(ComplexTestsF16::INPUT2_F16_ID,mgr,nb << 1);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+          break;
+        case ComplexTestsF16::TEST_CMPLX_MULT_CMPLX_F16_15:
+          nb = 23;
+          ref.reload(ComplexTestsF16::REF_CMPLX_MULT_CMPLX_F16_ID,mgr,nb << 1);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+          input2.reload(ComplexTestsF16::INPUT2_F16_ID,mgr,nb << 1);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+          break;
+        case ComplexTestsF16::TEST_CMPLX_MULT_REAL_F16_16:
+          nb = 7;
+          ref.reload(ComplexTestsF16::REF_CMPLX_MULT_REAL_F16_ID,mgr,nb << 1);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+          input2.reload(ComplexTestsF16::INPUT3_F16_ID,mgr,nb);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+          break;
+        case ComplexTestsF16::TEST_CMPLX_MULT_REAL_F16_17:
+          nb = 16;
+          ref.reload(ComplexTestsF16::REF_CMPLX_MULT_REAL_F16_ID,mgr,nb << 1);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+          input2.reload(ComplexTestsF16::INPUT3_F16_ID,mgr,nb);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+          break;
+        case ComplexTestsF16::TEST_CMPLX_MULT_REAL_F16_18:
+          nb = 23;
+          ref.reload(ComplexTestsF16::REF_CMPLX_MULT_REAL_F16_ID,mgr,nb << 1);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+          input2.reload(ComplexTestsF16::INPUT3_F16_ID,mgr,nb);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+          break;
+
+        case ComplexTestsF16::TEST_CMPLX_CONJ_F16_19:
+          ref.reload(ComplexTestsF16::REF_CONJ_F16_ID,mgr,nb << 1);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+        break;
+
+        case ComplexTestsF16::TEST_CMPLX_DOT_PROD_F16_20:
+          ref.reload(ComplexTestsF16::REF_DOT_PROD_LONG_F16_ID,mgr);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+          input2.reload(ComplexTestsF16::INPUT2_F16_ID,mgr,nb << 1);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+        break;
+        
+        case ComplexTestsF16::TEST_CMPLX_MAG_F16_21:
+          ref.reload(ComplexTestsF16::REF_MAG_F16_ID,mgr,nb);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+        break;
+        
+        case ComplexTestsF16::TEST_CMPLX_MAG_SQUARED_F16_22:
+          ref.reload(ComplexTestsF16::REF_MAG_SQUARED_F16_ID,mgr,nb);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+        break;
+        
+        case ComplexTestsF16::TEST_CMPLX_MULT_CMPLX_F16_23:
+          ref.reload(ComplexTestsF16::REF_CMPLX_MULT_CMPLX_F16_ID,mgr,nb << 1);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+          input2.reload(ComplexTestsF16::INPUT2_F16_ID,mgr,nb << 1);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+        break;
+        
+        case ComplexTestsF16::TEST_CMPLX_MULT_REAL_F16_24:
+          ref.reload(ComplexTestsF16::REF_CMPLX_MULT_REAL_F16_ID,mgr,nb << 1);
+          input1.reload(ComplexTestsF16::INPUT1_F16_ID,mgr,nb << 1);
+          input2.reload(ComplexTestsF16::INPUT3_F16_ID,mgr,nb);
+
+          output.create(ref.nbSamples(),ComplexTestsF16::OUT_SAMPLES_F16_ID,mgr);
+        break;
+        
+       }
+      
+    }
+
+    void ComplexTestsF16::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
+    {
+        (void)id;
+        output.dump(mgr);
+    }

Testing/desc_f16.txt

@@ -77,6 +77,69 @@ group Root {
 
         }
 
+        group Complex Tests {
+           class = ComplexTests
+           folder = ComplexMaths
+
+           suite Complex Tests F16{
+              class = ComplexTestsF16
+              folder = ComplexMathsF16
+
+              Pattern INPUT1_F16_ID : Input1_f16.txt 
+              Pattern INPUT2_F16_ID : Input2_f16.txt 
+              Pattern INPUT3_F16_ID : Input3_f16.txt 
+
+              Pattern REF_CONJ_F16_ID : Reference1_f16.txt
+              Pattern REF_DOT_PROD_3_F16_ID : Reference2_f16.txt
+              Pattern REF_DOT_PROD_4N_F16_ID : Reference3_f16.txt
+              Pattern REF_DOT_PROD_4N1_F16_ID : Reference4_f16.txt
+              Pattern REF_MAG_F16_ID : Reference5_f16.txt
+              Pattern REF_MAG_SQUARED_F16_ID : Reference6_f16.txt
+              Pattern REF_CMPLX_MULT_CMPLX_F16_ID : Reference7_f16.txt
+              Pattern REF_CMPLX_MULT_REAL_F16_ID : Reference8_f16.txt
+              Pattern REF_DOT_PROD_LONG_F16_ID : Reference9_f16.txt
+
+              Output  OUT_SAMPLES_F16_ID : Output
+              Output  OUT_STATE_F16_ID : State
+
+              Functions {
+                Test nb=3    arm_cmplx_conj_f16:test_cmplx_conj_f16
+                Test nb=4n   arm_cmplx_conj_f16:test_cmplx_conj_f16
+                Test nb=4n+1 arm_cmplx_conj_f16:test_cmplx_conj_f16
+
+                Test nb=3    arm_cmplx_dot_prod_f16:test_cmplx_dot_prod_f16
+                Test nb=4n   arm_cmplx_dot_prod_f16:test_cmplx_dot_prod_f16
+                Test nb=4n+1 arm_cmplx_dot_prod_f16:test_cmplx_dot_prod_f16
+
+                Test nb=3    arm_cmplx_mag_f16:test_cmplx_mag_f16
+                Test nb=4n   arm_cmplx_mag_f16:test_cmplx_mag_f16
+                Test nb=4n+1 arm_cmplx_mag_f16:test_cmplx_mag_f16
+
+                Test nb=3    arm_cmplx_mag_squared_f16:test_cmplx_mag_squared_f16
+                Test nb=4n   arm_cmplx_mag_squared_f16:test_cmplx_mag_squared_f16
+                Test nb=4n+1 arm_cmplx_mag_squared_f16:test_cmplx_mag_squared_f16
+
+                Test nb=3    arm_cmplx_mult_cmplx_f16:test_cmplx_mult_cmplx_f16
+                Test nb=4n   arm_cmplx_mult_cmplx_f16:test_cmplx_mult_cmplx_f16
+                Test nb=4n+1 arm_cmplx_mult_cmplx_f16:test_cmplx_mult_cmplx_f16
+
+                Test nb=3    arm_cmplx_mult_real_f16:test_cmplx_mult_real_f16
+                Test nb=4n   arm_cmplx_mult_real_f16:test_cmplx_mult_real_f16
+                Test nb=4n+1 arm_cmplx_mult_real_f16:test_cmplx_mult_real_f16
+
+                Test long    arm_cmplx_conj_f16:test_cmplx_conj_f16
+                Test long    arm_cmplx_dot_prod_f16:test_cmplx_dot_prod_f16
+                Test long    arm_cmplx_mag_f16:test_cmplx_mag_f16
+                Test long    arm_cmplx_mag_squared_f16:test_cmplx_mag_squared_f16
+                Test long    arm_cmplx_mult_cmplx_f16:test_cmplx_mult_cmplx_f16
+                Test long    arm_cmplx_mult_real_f16:test_cmplx_mult_real_f16
+
+              }
+
+           }
+
+        }
+
         group Transform Tests {
            class = TransformTests
            folder = Transform