CMSIS-DSP/Testing/Source/Tests/StatsTestsF64.cpp

#include "StatsTestsF64.h"
#include <stdio.h>
#include "Error.h"
#include "Test.h"


#define SNR_THRESHOLD 300
/* 

Reference patterns are generated with
a double precision computation.

*/
#define REL_ERROR (4.0e-15)

    void StatsTestsF64::test_max_f64()
    {
        const float64_t *inp  = inputA.ptr();

        float64_t result;
        uint32_t  indexval;

        float64_t *refp  = ref.ptr();
        int16_t  *refind = maxIndexes.ptr();

        float64_t *outp  = output.ptr();
        int16_t  *ind    = index.ptr();

        arm_max_f64(inp,
              inputA.nbSamples(),
              &result,
              &indexval);

        outp[0] = result;
        ind[0] = indexval;

        ASSERT_EQ(result,refp[this->refOffset]);
        ASSERT_EQ((int16_t)indexval,refind[this->refOffset]);

    }

    void StatsTestsF64::test_absmax_f64()
    {
        const float64_t *inp  = inputA.ptr();

        float64_t result;
        uint32_t  indexval;

        float64_t *refp  = ref.ptr();
        int16_t  *refind = maxIndexes.ptr();

        float64_t *outp  = output.ptr();
        int16_t  *ind    = index.ptr();

        arm_absmax_f64(inp,
              inputA.nbSamples(),
              &result,
              &indexval);

        outp[0] = result;
        ind[0] = indexval;

        ASSERT_EQ(result,refp[this->refOffset]);
        ASSERT_EQ((int16_t)indexval,refind[this->refOffset]);

    }

    void StatsTestsF64::test_max_no_idx_f64()
    {
        const float64_t *inp  = inputA.ptr();

        float64_t result;

        float64_t *refp  = ref.ptr();

        float64_t *outp  = output.ptr();

        arm_max_no_idx_f64(inp,
              inputA.nbSamples(),
              &result);

        outp[0] = result;

        ASSERT_EQ(result,refp[this->refOffset]);

    }

    void StatsTestsF64::test_absmax_no_idx_f64()
    {
        const float64_t *inp  = inputA.ptr();

        float64_t result;

        float64_t *refp  = ref.ptr();

        float64_t *outp  = output.ptr();

        arm_absmax_no_idx_f64(inp,
              inputA.nbSamples(),
              &result);

        outp[0] = result;

        ASSERT_EQ(result,refp[this->refOffset]);

    }

    void StatsTestsF64::test_min_no_idx_f64()
    {
        const float64_t *inp  = inputA.ptr();

        float64_t result;

        float64_t *refp  = ref.ptr();

        float64_t *outp  = output.ptr();

        arm_min_no_idx_f64(inp,
              inputA.nbSamples(),
              &result);

        outp[0] = result;

        ASSERT_EQ(result,refp[this->refOffset]);

    }

    void StatsTestsF64::test_absmin_no_idx_f64()
    {
        const float64_t *inp  = inputA.ptr();

        float64_t result;

        float64_t *refp  = ref.ptr();

        float64_t *outp  = output.ptr();

        arm_absmin_no_idx_f64(inp,
              inputA.nbSamples(),
              &result);

        outp[0] = result;

        ASSERT_EQ(result,refp[this->refOffset]);

    }

    void StatsTestsF64::test_min_f64()
    {
        const float64_t *inp  = inputA.ptr();

        float64_t result;
        uint32_t  indexval;

        float64_t *refp  = ref.ptr();
        int16_t  *refind = minIndexes.ptr();

        float64_t *outp  = output.ptr();
        int16_t  *ind    = index.ptr();

        arm_min_f64(inp,
              inputA.nbSamples(),
              &result,
              &indexval);

        outp[0] = result;
        ind[0] = indexval;

        ASSERT_EQ(result,refp[this->refOffset]);
        ASSERT_EQ((int16_t)indexval,refind[this->refOffset]);

    }

    void StatsTestsF64::test_absmin_f64()
    {
        const float64_t *inp  = inputA.ptr();

        float64_t result;
        uint32_t  indexval;

        float64_t *refp  = ref.ptr();
        int16_t  *refind = minIndexes.ptr();

        float64_t *outp  = output.ptr();
        int16_t  *ind    = index.ptr();

        arm_absmin_f64(inp,
              inputA.nbSamples(),
              &result,
              &indexval);

        outp[0] = result;
        ind[0] = indexval;

        ASSERT_EQ(result,refp[this->refOffset]);
        ASSERT_EQ((int16_t)indexval,refind[this->refOffset]);

    }

    void StatsTestsF64::test_mean_f64()
    {
        const float64_t *inp  = inputA.ptr();

        float64_t result;

        float64_t *refp  = ref.ptr();

        float64_t *outp  = output.ptr();

        arm_mean_f64(inp,
              inputA.nbSamples(),
              &result);

        outp[0] = result;

        ASSERT_SNR(result,refp[this->refOffset],(float64_t)SNR_THRESHOLD);

        ASSERT_REL_ERROR(result,refp[this->refOffset],REL_ERROR);

    }

    void StatsTestsF64::test_power_f64()
    {
        const float64_t *inp  = inputA.ptr();

        float64_t result;

        float64_t *refp  = ref.ptr();

        float64_t *outp  = output.ptr();

        arm_power_f64(inp,
              inputA.nbSamples(),
              &result);

        outp[0] = result;

        ASSERT_SNR(result,refp[this->refOffset],(float64_t)SNR_THRESHOLD);

        ASSERT_REL_ERROR(result,refp[this->refOffset],REL_ERROR);

    }

/*
    void StatsTestsF64::test_rms_f64()
    {
        const float64_t *inp  = inputA.ptr();

        float64_t result;

        float64_t *refp  = ref.ptr();

        float64_t *outp  = output.ptr();

        arm_rms_f64(inp,
              inputA.nbSamples(),
              &result);

        outp[0] = result;

        ASSERT_SNR(result,refp[this->refOffset],(float64_t)SNR_THRESHOLD);

        ASSERT_REL_ERROR(result,refp[this->refOffset],REL_ERROR);

    }
*/
    void StatsTestsF64::test_std_f64()
    {
        const float64_t *inp  = inputA.ptr();

        float64_t result;

        float64_t *refp  = ref.ptr();

        float64_t *outp  = output.ptr();

        arm_std_f64(inp,
              inputA.nbSamples(),
              &result);

        outp[0] = result;

        ASSERT_SNR(result,refp[this->refOffset],(float64_t)SNR_THRESHOLD);

        ASSERT_REL_ERROR(result,refp[this->refOffset],REL_ERROR);

    }

    void StatsTestsF64::test_var_f64()
    {
        const float64_t *inp  = inputA.ptr();

        float64_t result;

        float64_t *refp  = ref.ptr();

        float64_t *outp  = output.ptr();

        arm_var_f64(inp,
              inputA.nbSamples(),
              &result);

        outp[0] = result;

        ASSERT_SNR(result,refp[this->refOffset],(float64_t)SNR_THRESHOLD);

        ASSERT_REL_ERROR(result,refp[this->refOffset],REL_ERROR);

    }


    void StatsTestsF64::test_std_stability_f64()
    {
      /*

      With the textbook algorithm, those values will produce a negative
      value for the variance.

      The CMSIS-DSP variance algorithm is the two pass one so will work
      with those values.

      So, it should be possible to compute the square root for the standard
      deviation.

      */
      float64_t in[4]={4.0f, 7.0f, 13.0f, 16.0f};
      float64_t result;
      int i;

      /*

      Add bigger offset so that average is much bigger than standard deviation.

      */
      for(i=0 ; i < 4; i++)
      {
        in[i] += 3.0e4f;
      }

      arm_std_f64(in,4,&result);

      /*

      If variance is giving a negative value, the square root
      should return zero.

      We check it is not happening here.


      */

      ASSERT_TRUE(fabs(5.47723f - result) < 1.0e-4f);

    }

    void StatsTestsF64::test_entropy_f64()
    {
      const float64_t *inp  = inputA.ptr();
      const int16_t *dimsp  = dims.ptr();

      float64_t *outp         = output.ptr();

      for(int i=0;i < this->nbPatterns; i++)
      {
         *outp = arm_entropy_f64(inp,dimsp[i+1]);
         outp++;
         inp += dimsp[i+1];
      }

      ASSERT_SNR(ref,output,(float64_t)SNR_THRESHOLD);

      ASSERT_REL_ERROR(ref,output,REL_ERROR);

    } 
/*
    void StatsTestsF64::test_logsumexp_f64()
    {
      const float64_t *inp  = inputA.ptr();
      const int16_t *dimsp  = dims.ptr();

      float64_t *outp         = output.ptr();

      for(int i=0;i < this->nbPatterns; i++)
      {
         *outp = arm_logsumexp_f64(inp,dimsp[i+1]);
         outp++;
         inp += dimsp[i+1];
      }

      ASSERT_SNR(ref,output,(float64_t)SNR_THRESHOLD);

      ASSERT_REL_ERROR(ref,output,REL_ERROR);
    } 

*/
    void StatsTestsF64::test_kullback_leibler_f64()
    {
      const float64_t *inpA  = inputA.ptr();
      const float64_t *inpB  = inputB.ptr();
      const int16_t *dimsp  = dims.ptr();

      float64_t *outp         = output.ptr();

      for(int i=0;i < this->nbPatterns; i++)
      {
         *outp = arm_kullback_leibler_f64(inpA,inpB,dimsp[i+1]);
         outp++;
         inpA += dimsp[i+1];
         inpB += dimsp[i+1];
      }

      ASSERT_SNR(ref,output,(float64_t)SNR_THRESHOLD);

      ASSERT_REL_ERROR(ref,output,REL_ERROR);
    } 

/*
    void StatsTestsF64::test_logsumexp_dot_prod_f64()
    {
      const float64_t *inpA  = inputA.ptr();
      const float64_t *inpB  = inputB.ptr();
      const int16_t *dimsp  = dims.ptr();

      float64_t *outp         = output.ptr();
      float64_t *tmpp         = tmp.ptr();

      for(int i=0;i < this->nbPatterns; i++)
      {
         *outp = arm_logsumexp_dot_prod_f64(inpA,inpB,dimsp[i+1],tmpp);
         outp++;
         inpA += dimsp[i+1];
         inpB += dimsp[i+1];
      }

      ASSERT_SNR(ref,output,(float64_t)SNR_THRESHOLD);

      ASSERT_REL_ERROR(ref,output,REL_ERROR);
    } 

*/
  
    void StatsTestsF64::test_mse_f64()
    {
        const float64_t *inpA  = inputA.ptr();
        const float64_t *inpB  = inputB.ptr();

        float64_t result;

        float64_t *refp  = ref.ptr();

        float64_t *outp  = output.ptr();

        arm_mse_f64(inpA,inpB,
              inputA.nbSamples(),
              &result);

        outp[0] = result;

        ASSERT_SNR(result,refp[this->refOffset],(float64_t)SNR_THRESHOLD);

        ASSERT_REL_ERROR(result,refp[this->refOffset],(float64_t)REL_ERROR);

    }

    void StatsTestsF64::test_accumulate_f64()
    {
      const float64_t *inp  = inputA.ptr();
      const int16_t *dimsp  = dims.ptr();

      float64_t *outp         = output.ptr();

      for(int i=0;i < this->nbPatterns; i++)
      {
         arm_accumulate_f64(inp,dimsp[i+1],outp);
         outp++;
      }

      ASSERT_SNR(ref,output,(float64_t)SNR_THRESHOLD);

      ASSERT_REL_ERROR(ref,output,REL_ERROR);

    } 

    void StatsTestsF64::setUp(Testing::testID_t id,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr)
    {
        (void)paramsArgs;
        switch(id)
        {
            case StatsTestsF64::TEST_MAX_F64_1:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,2);
              
               maxIndexes.reload(StatsTestsF64::MAXINDEXES_S16_ID,mgr);
               ref.reload(StatsTestsF64::MAXVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
               index.create(1,StatsTestsF64::OUT_S16_ID,mgr);

               refOffset = 0;
            }
            break;

            case StatsTestsF64::TEST_MAX_F64_2:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,4);
              
               maxIndexes.reload(StatsTestsF64::MAXINDEXES_S16_ID,mgr);
               ref.reload(StatsTestsF64::MAXVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
               index.create(1,StatsTestsF64::OUT_S16_ID,mgr);

               refOffset = 1;
            }
            break;

            case StatsTestsF64::TEST_MAX_F64_3:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,5);
              
               maxIndexes.reload(StatsTestsF64::MAXINDEXES_S16_ID,mgr);
               ref.reload(StatsTestsF64::MAXVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
               index.create(1,StatsTestsF64::OUT_S16_ID,mgr);

               refOffset = 2;
            }
            break;

            case StatsTestsF64::TEST_MEAN_F64_4:
            {
               inputA.reload(StatsTestsF64::INPUT2_F64_ID,mgr,2);
              
               ref.reload(StatsTestsF64::MEANVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 0;
            }
            break;

            case StatsTestsF64::TEST_MEAN_F64_5:
            {
               inputA.reload(StatsTestsF64::INPUT2_F64_ID,mgr,4);
              
               ref.reload(StatsTestsF64::MEANVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 1;
            }
            break;

            case StatsTestsF64::TEST_MEAN_F64_6:
            {
               inputA.reload(StatsTestsF64::INPUT2_F64_ID,mgr,5);
              
               ref.reload(StatsTestsF64::MEANVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 2;
            }
            break;

            case StatsTestsF64::TEST_MIN_F64_7:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,2);
              
               minIndexes.reload(StatsTestsF64::MININDEXES_S16_ID,mgr);
               ref.reload(StatsTestsF64::MINVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
               index.create(1,StatsTestsF64::OUT_S16_ID,mgr);

               refOffset = 0;
            }
            break;

            case StatsTestsF64::TEST_MIN_F64_8:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,4);
              
               minIndexes.reload(StatsTestsF64::MININDEXES_S16_ID,mgr);
               ref.reload(StatsTestsF64::MINVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
               index.create(1,StatsTestsF64::OUT_S16_ID,mgr);

               refOffset = 1;
            }
            break;

            case StatsTestsF64::TEST_MIN_F64_9:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,5);
              
               minIndexes.reload(StatsTestsF64::MININDEXES_S16_ID,mgr);
               ref.reload(StatsTestsF64::MINVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
               index.create(1,StatsTestsF64::OUT_S16_ID,mgr);

               refOffset = 2;
            }
            break;

            case StatsTestsF64::TEST_POWER_F64_10:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,2);
              
               ref.reload(StatsTestsF64::POWERVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 0;
            }
            break;

            case StatsTestsF64::TEST_POWER_F64_11:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,4);
              
               ref.reload(StatsTestsF64::POWERVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 1;
            }
            break;

            case StatsTestsF64::TEST_POWER_F64_12:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,5);
              
               ref.reload(StatsTestsF64::POWERVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 2;
            }
            break;

            case StatsTestsF64::TEST_RMS_F64_13:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,2);
              
               ref.reload(StatsTestsF64::RMSVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 0;
            }
            break;

            case StatsTestsF64::TEST_RMS_F64_14:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,4);
              
               ref.reload(StatsTestsF64::RMSVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 1;
            }
            break;

            case StatsTestsF64::TEST_RMS_F64_15:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,5);
              
               ref.reload(StatsTestsF64::RMSVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 2;
            }
            break;

            case StatsTestsF64::TEST_STD_F64_16:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,2);
              
               ref.reload(StatsTestsF64::STDVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 0;
            }
            break;

            case StatsTestsF64::TEST_STD_F64_17:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,4);
              
               ref.reload(StatsTestsF64::STDVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 1;
            }
            break;

            case StatsTestsF64::TEST_STD_F64_18:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,5);
              
               ref.reload(StatsTestsF64::STDVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 2;
            }
            break;

            case StatsTestsF64::TEST_VAR_F64_19:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,2);
              
               ref.reload(StatsTestsF64::VARVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 0;
            }
            break;

            case StatsTestsF64::TEST_VAR_F64_20:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,4);
              
               ref.reload(StatsTestsF64::VARVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 1;
            }
            break;

            case StatsTestsF64::TEST_VAR_F64_21:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,5);
              
               ref.reload(StatsTestsF64::VARVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 2;
            }
            break;

            case StatsTestsF64::TEST_ENTROPY_F64_22:
            {
               inputA.reload(StatsTestsF64::INPUT22_F64_ID,mgr);
               dims.reload(StatsTestsF64::DIM22_S16_ID,mgr);
               ref.reload(StatsTestsF64::REF22_ENTROPY_F64_ID,mgr);
               output.create(ref.nbSamples(),StatsTestsF64::OUT_F64_ID,mgr);

               const int16_t *dimsp  = dims.ptr();
               this->nbPatterns=dimsp[0];
            }
            break;

            case StatsTestsF64::TEST_LOGSUMEXP_F64_23:
            {
               inputA.reload(StatsTestsF64::INPUT23_F64_ID,mgr);
               dims.reload(StatsTestsF64::DIM23_S16_ID,mgr);
               ref.reload(StatsTestsF64::REF23_LOGSUMEXP_F64_ID,mgr);
               output.create(ref.nbSamples(),StatsTestsF64::OUT_F64_ID,mgr);

               const int16_t *dimsp  = dims.ptr();
               this->nbPatterns=dimsp[0];
            }
            break;

            case StatsTestsF64::TEST_KULLBACK_LEIBLER_F64_24:
            {
               inputA.reload(StatsTestsF64::INPUTA24_F64_ID,mgr);
               inputB.reload(StatsTestsF64::INPUTB24_F64_ID,mgr);
               dims.reload(StatsTestsF64::DIM24_S16_ID,mgr);
               ref.reload(StatsTestsF64::REF24_KL_F64_ID,mgr);
               output.create(ref.nbSamples(),StatsTestsF64::OUT_F64_ID,mgr);

               const int16_t *dimsp  = dims.ptr();
               this->nbPatterns=dimsp[0];
            }
            break;

            case StatsTestsF64::TEST_LOGSUMEXP_DOT_PROD_F64_25:
            {
               inputA.reload(StatsTestsF64::INPUTA25_F64_ID,mgr);
               inputB.reload(StatsTestsF64::INPUTB25_F64_ID,mgr);
               dims.reload(StatsTestsF64::DIM25_S16_ID,mgr);
               ref.reload(StatsTestsF64::REF25_LOGSUMEXP_DOT_F64_ID,mgr);
               output.create(ref.nbSamples(),StatsTestsF64::OUT_F64_ID,mgr);

               const int16_t *dimsp  = dims.ptr();
               this->nbPatterns=dimsp[0];

               /* 12 is max vecDim as defined in Python script generating the data */
               tmp.create(12,StatsTestsF64::TMP_F64_ID,mgr);
            }
            break;

            case StatsTestsF64::TEST_MAX_NO_IDX_F64_26:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,2);
              
               ref.reload(StatsTestsF64::MAXVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 0;
            }
            break;

            case StatsTestsF64::TEST_MAX_NO_IDX_F64_27:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,4);
              
               ref.reload(StatsTestsF64::MAXVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 1;
            }
            break;

            case StatsTestsF64::TEST_MAX_NO_IDX_F64_28:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,5);
              
               ref.reload(StatsTestsF64::MAXVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 2;
            }
            break;

            case TEST_MEAN_F64_29:
               inputA.reload(StatsTestsF64::INPUT2_F64_ID,mgr,100);
              
               ref.reload(StatsTestsF64::MEANVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 3;
            break;

            case TEST_RMS_F64_30:
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,100);
              
               ref.reload(StatsTestsF64::RMSVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 3;
            break;

            case TEST_STD_F64_31:
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,100);
              
               ref.reload(StatsTestsF64::STDVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 3;
            break;

            case TEST_VAR_F64_32:
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,100);
              
               ref.reload(StatsTestsF64::VARVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 3;
            break;

            case StatsTestsF64::TEST_ABSMAX_F64_34:
            {
               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,2);
              
               maxIndexes.reload(StatsTestsF64::ABSMAXINDEXES_S16_ID,mgr);
               ref.reload(StatsTestsF64::ABSMAXVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
               index.create(1,StatsTestsF64::OUT_S16_ID,mgr);

               refOffset = 0;
            }
            break;

            case StatsTestsF64::TEST_ABSMAX_F64_35:
            {
               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,4);
              
               maxIndexes.reload(StatsTestsF64::ABSMAXINDEXES_S16_ID,mgr);
               ref.reload(StatsTestsF64::ABSMAXVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
               index.create(1,StatsTestsF64::OUT_S16_ID,mgr);

               refOffset = 1;
            }
            break;

            case StatsTestsF64::TEST_ABSMAX_F64_36:
            {
               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,5);
              
               maxIndexes.reload(StatsTestsF64::ABSMAXINDEXES_S16_ID,mgr);
               ref.reload(StatsTestsF64::ABSMAXVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
               index.create(1,StatsTestsF64::OUT_S16_ID,mgr);

               refOffset = 2;
            }
            break;

            case StatsTestsF64::TEST_ABSMIN_F64_37:
            {
               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,2);
              
               minIndexes.reload(StatsTestsF64::ABSMININDEXES_S16_ID,mgr);
               ref.reload(StatsTestsF64::ABSMINVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
               index.create(1,StatsTestsF64::OUT_S16_ID,mgr);

               refOffset = 0;
            }
            break;

            case StatsTestsF64::TEST_ABSMIN_F64_38:
            {
               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,4);
              
               minIndexes.reload(StatsTestsF64::ABSMININDEXES_S16_ID,mgr);
               ref.reload(StatsTestsF64::ABSMINVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
               index.create(1,StatsTestsF64::OUT_S16_ID,mgr);

               refOffset = 1;
            }
            break;

            case StatsTestsF64::TEST_ABSMIN_F64_39:
            {
               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,5);
              
               minIndexes.reload(StatsTestsF64::ABSMININDEXES_S16_ID,mgr);
               ref.reload(StatsTestsF64::ABSMINVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
               index.create(1,StatsTestsF64::OUT_S16_ID,mgr);

               refOffset = 2;
            }
            break;

            case StatsTestsF64::TEST_MIN_NO_IDX_F64_40:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,2);
              
               ref.reload(StatsTestsF64::MINVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 0;
            }
            break;

            case StatsTestsF64::TEST_MIN_NO_IDX_F64_41:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,4);
              
               ref.reload(StatsTestsF64::MINVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 1;
            }
            break;

            case StatsTestsF64::TEST_MIN_NO_IDX_F64_42:
            {
               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,5);
              
               ref.reload(StatsTestsF64::MINVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 2;
            }
            break;


            case StatsTestsF64::TEST_ABSMAX_NO_IDX_F64_43:
            {
               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,2);
              
               ref.reload(StatsTestsF64::ABSMAXVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 0;
            }
            break;

            case StatsTestsF64::TEST_ABSMAX_NO_IDX_F64_44:
            {
               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,4);
              
               ref.reload(StatsTestsF64::ABSMAXVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 1;
            }
            break;

            case StatsTestsF64::TEST_ABSMAX_NO_IDX_F64_45:
            {
               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,5);
              
               ref.reload(StatsTestsF64::ABSMAXVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 2;
            }
            break;

            case StatsTestsF64::TEST_ABSMIN_NO_IDX_F64_46:
            {
               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,2);
              
               ref.reload(StatsTestsF64::ABSMINVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 0;
            }
            break;

            case StatsTestsF64::TEST_ABSMIN_NO_IDX_F64_47:
            {
               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,4);
              
               ref.reload(StatsTestsF64::ABSMINVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 1;
            }
            break;

            case StatsTestsF64::TEST_ABSMIN_NO_IDX_F64_48:
            {
               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,5);
              
               ref.reload(StatsTestsF64::ABSMINVALS_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 2;
            }
            break;

            case StatsTestsF64::TEST_MSE_F64_49:
            {
               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,2);
               inputB.reload(StatsTestsF64::INPUTNEW2_F64_ID,mgr,2);
              
               ref.reload(StatsTestsF64::MSE_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 0;
            }
            break;

            case StatsTestsF64::TEST_MSE_F64_50:
            {
               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,4);
               inputB.reload(StatsTestsF64::INPUTNEW2_F64_ID,mgr,4);
              
               ref.reload(StatsTestsF64::MSE_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 1;
            }
            break;

            case StatsTestsF64::TEST_MSE_F64_51:
            {
               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,5);
               inputB.reload(StatsTestsF64::INPUTNEW2_F64_ID,mgr,5);
              
               ref.reload(StatsTestsF64::MSE_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 2;
            }
            break;

            case StatsTestsF64::TEST_MSE_F64_52:
            {
               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,100);
               inputB.reload(StatsTestsF64::INPUTNEW2_F64_ID,mgr,100);
              
               ref.reload(StatsTestsF64::MSE_F64_ID,mgr);
               
               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);

               refOffset = 3;
            }
            break;

            case StatsTestsF64::TEST_ACCUMULATE_F64_53:
            {
               inputA.reload(StatsTestsF64::INPUT_ACCUMULATE_F64_ID,mgr);
               ref.reload(StatsTestsF64::REF_ACCUMULATE_F64_ID,mgr);
               dims.reload(StatsTestsF64::INPUT_ACCUMULATE_CONFIG_S16_ID,mgr);
               output.create(ref.nbSamples(),StatsTestsF64::OUT_F64_ID,mgr);

               const int16_t *dimsp  = dims.ptr();
               this->nbPatterns=dimsp[0];
               

            }
            break;


        }
        
    }

    void StatsTestsF64::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
    {
      (void)id;
      switch(id)
      {
            case StatsTestsF64::TEST_MAX_F64_1:
            case StatsTestsF64::TEST_MAX_F64_2:
            case StatsTestsF64::TEST_MAX_F64_3:
            case StatsTestsF64::TEST_MIN_F64_7:
            case StatsTestsF64::TEST_MIN_F64_8:
            case StatsTestsF64::TEST_MIN_F64_9:
              index.dump(mgr);
              output.dump(mgr);
            break;

            default:
              output.dump(mgr);
      }
    }