CMSIS_5/CMSIS/DSP/Testing/bench.txt

group Root {
    class = Root

    group DSP Benchmarks {
        class = DSPBenchmarks
        folder = DSP

        group Statistics Benchmarks {
           class = Stats
           folder = Stats

           suite Statistics Benchmarks F32 {
              class = StatsF32
              folder = StatsF32

              ParamList {
                  NB
                  Summary NB
                  Names "NB Samples"
                  Formula "NB"
              }

              Pattern INPUT1_F32_ID : InputBench1_f32.txt 
              Pattern INPUT2_F32_ID : InputBench2_f32.txt 
              
              Output  OUT_F32_ID : Output
              Output  OUT_S16_ID : Index
              Output  TMP_F32_ID : Temp

              Params PARAM1_ID = {
                  A = [16,32,64,128,256]
              }

              Functions {
                Vector maximum:test_max_f32
                Vector average:test_mean_f32
                Vector minimum:test_min_f32
                Vector energy:test_power_f32
                Vector root mean square:test_rms_f32
                Vector standard deviation:test_std_f32
                Vector variance:test_var_f32
                Entropy:test_entropy_f32
                Vector logsumexp:test_logsumexp_f32
                Kullback Leibler divergence:test_kullback_leibler_f32
                Vector logsumexp dot product:test_logsumexp_dot_prod_f32
                Vector max with no index:test_max_no_idx_f32
              } -> PARAM1_ID

           }

           suite Statistics Benchmarks F64 {
              class = StatsF64
              folder = StatsF64

              ParamList {
                  NB
                  Summary NB
                  Names "NB Samples"
                  Formula "NB"
              }

              Pattern INPUT1_F64_ID : InputBench1_f64.txt 
              Pattern INPUT2_F64_ID : InputBench2_f64.txt 

              Output  OUT_F64_ID : Output
              Output  OUT_S16_ID : Index
              Output  TMP_F64_ID : Temp

              Params PARAM1_ID = {
                  A = [16,32,64,128,256]
              }

              Functions {
                Entropy:test_entropy_f64
                Kullback Leibler divergence:test_kullback_leibler_f64
              } -> PARAM1_ID

           }

           suite Statistics Benchmarks Q31 {
              class = StatsQ31
              folder = StatsQ31

              ParamList {
                  NB
                  Summary NB
                  Names "NB Samples"
                  Formula "NB"
              }

              Pattern INPUT1_Q31_ID : InputBench1_q31.txt 
              Pattern INPUT2_Q31_ID : InputBench2_q31.txt 
              
              Output  OUT_Q31_ID : Output
              Output  OUT_Q63_ID : Output
              Output  OUT_S16_ID : Index
              Output  TMP_Q31_ID : Temp

              Params PARAM1_ID = {
                  A = [16,32,64,128,256]
              }

              Functions {
                Vector maximum:test_max_q31
                Vector average:test_mean_q31
                Vector minimum:test_min_q31
                Vector energy:test_power_q31
                Vector root mean square:test_rms_q31
                Vector standard deviation:test_std_q31
                Vector variance:test_var_q31
              } -> PARAM1_ID

           }

           suite Statistics Benchmarks Q15 {
              class = StatsQ15
              folder = StatsQ15

              ParamList {
                  NB
                  Summary NB
                  Names "NB Samples"
                  Formula "NB"
              }

              Pattern INPUT1_Q15_ID : InputBench1_q15.txt 
              Pattern INPUT2_Q15_ID : InputBench2_q15.txt 
              

              Output  OUT_Q15_ID : Output
              Output  OUT_Q63_ID : Output
              Output  OUT_S16_ID : Index
              Output  TMP_Q15_ID : Temp

              Params PARAM1_ID = {
                  A = [16,32,64,128,256]
              }

              Functions {
                Vector maximum:test_max_q15
                Vector average:test_mean_q15
                Vector minimum:test_min_q15
                Vector energy:test_power_q15
                Vector root mean square:test_rms_q15
                Vector standard deviation:test_std_q15
                Vector variance:test_var_q15
              } -> PARAM1_ID

           }

           suite Statistics Benchmarks Q7 {
              class = StatsQ7
              folder = StatsQ7

              ParamList {
                  NB
                  Summary NB
                  Names "NB Samples"
                  Formula "NB"
              }

              Pattern INPUT1_Q7_ID : InputBench1_q7.txt 
              Pattern INPUT2_Q7_ID : InputBench2_q7.txt 
              

              Output  OUT_Q7_ID : Output
              Output  OUT_Q31_ID : Output
              Output  OUT_S16_ID : Index
              Output  TMP_Q7_ID : Temp

              Params PARAM1_ID = {
                  A = [16,32,64,128,256]
              }

              Functions {
                Vector maximum:test_max_q7
                Vector average:test_mean_q7
                Vector minimum:test_min_q7
                Vector energy:test_power_q7
              } -> PARAM1_ID

           }
        }

        group Basic Maths {
           class = BasicBenchmarks
           folder = BasicMaths

           suite Basic Maths Benchmarks F32 {
              class = BasicMathsBenchmarksF32
              folder = BasicMathsF32
  
              ParamList {
                  NB
                  Summary NB
                  Names "NB Samples"
                  Formula "NB"
              }
  
              Pattern INPUT1_F32_ID : Input1_f32.txt 
              Pattern INPUT2_F32_ID : Input2_f32.txt 
              Output  OUT_SAMPLES_F32_ID : Output
              Params PARAM1_ID = {
                  A = [16,32,64,128,256]
              }
  
              Functions {
                 Elementwise multiplication:vec_mult_f32
                 Vector addition:vec_add_f32
                 Vector substraction:vec_sub_f32
                 Elementwise absolute value:vec_abs_f32
                 Elementwise negation:vec_negate_f32
                 Elementwise offset:vec_offset_f32
                 Vector scaling:vec_scale_f32
                 Dot product:vec_dot_f32
              } -> PARAM1_ID
           }

           suite Basic Maths Benchmarks Q31 {
              class = BasicMathsBenchmarksQ31
              folder = BasicMathsQ31
  
              ParamList {
                  NB
                  Summary NB
                  Names "NB Samples"
                  Formula "NB"
              }
  
              Pattern INPUT1_Q31_ID : Input1_q31.txt 
              Pattern INPUT2_Q31_ID : Input2_q31.txt 
              Output  OUT_SAMPLES_Q31_ID : Output
              Params PARAM1_ID = {
                  A = [16,32,64,128,256]
              }
  
              Functions {
                 Elementwise multiplication:vec_mult_q31
                 Vector addition:vec_add_q31
                 Vector substraction:vec_sub_q31
                 Elementwise absolute value:vec_abs_q31
                 Elementwise negation:vec_negate_q31
                 Elementwise offset:vec_offset_q31
                 Vector scaling:vec_scale_q31
                 Dot product:vec_dot_q31
              } -> PARAM1_ID
           }

           suite Basic Maths Benchmarks Q15 {
              class = BasicMathsBenchmarksQ15
              folder = BasicMathsQ15
  
              ParamList {
                  NB
                  Summary NB
                  Names "NB Samples"
                  Formula "NB"
              }
  
              Pattern INPUT1_Q15_ID : Input1_q15.txt 
              Pattern INPUT2_Q15_ID : Input2_q15.txt 
              Output  OUT_SAMPLES_Q15_ID : Output
              Params PARAM1_ID = {
                  A = [16,32,64,128,256]
              }
  
              Functions {
                 Elementwise multiplication:vec_mult_q15
                 Vector addition:vec_add_q15
                 Vector substraction:vec_sub_q15
                 Elementwise absolute value:vec_abs_q15
                 Elementwise negation:vec_negate_q15
                 Elementwise offset:vec_offset_q15
                 Vector scaling:vec_scale_q15
                 Dot product:vec_dot_q15
              } -> PARAM1_ID
           }

           suite Basic Maths Benchmarks Q7 {
              class = BasicMathsBenchmarksQ7
              folder = BasicMathsQ7
  
              ParamList {
                  NB
                  Summary NB
                  Names "NB Samples"
                  Formula "NB"
              }
  
              Pattern INPUT1_Q7_ID : Input1_q7.txt 
              Pattern INPUT2_Q7_ID : Input2_q7.txt 
              Output  OUT_SAMPLES_Q7_ID : Output
              Params PARAM1_ID = {
                  A = [16,32,64,128,256]
              }
  
              Functions {
                 Elementwise multiplication:vec_mult_q7
                 Vector addition:vec_add_q7
                 Vector substraction:vec_sub_q7
                 Elementwise absolute value:vec_abs_q7
                 Elementwise negation:vec_negate_q7
                 Elementwise offset:vec_offset_q7
                 Vector scaling:vec_scale_q7
                 Dot product:vec_dot_q7
              } -> PARAM1_ID
           }
        }

        group Complex Maths {
           class = ComplexBenchmarks
           folder = ComplexMaths

           suite ComplexMaths Benchmarks F32 {
              class = ComplexMathsBenchmarksF32
              folder = ComplexMathsF32
  
              ParamList {
                  NB
                  Summary NB
                  Names "NB Samples"
                  Formula "NB"
              }
  
              Pattern INPUT1_F32_ID : Input1_f32.txt 
              Pattern INPUT2_F32_ID : Input2_f32.txt 
              Pattern INPUT3_F32_ID : Input3_f32.txt 
              Output  OUT_SAMPLES_F32_ID : Output
              Params PARAM1_ID = {
                  A = [16,32,64,128,256]
              }
  
              Functions {
                 Elementwise conjugate:vec_conj_f32
                 Complex dot product:vec_dot_prod_f32
                 Elementwise modulus:vec_mag_f32
                 Elementwise modulus squared:vec_mag_squared_f32
                 Elementwise complex multiplication:vec_mult_cmplx_f32
                 Vector scaling by real number:vec_mult_real_f32
              } -> PARAM1_ID
           }

           suite ComplexMaths Benchmarks Q31 {
              class = ComplexMathsBenchmarksQ31
              folder = ComplexMathsQ31
  
              ParamList {
                  NB
                  Summary NB
                  Names "NB Samples"
                  Formula "NB"
              }
  
              Pattern INPUT1_Q31_ID : Input1_q31.txt 
              Pattern INPUT2_Q31_ID : Input2_q31.txt 
              Pattern INPUT3_Q31_ID : Input3_q31.txt 
              Output  OUT_SAMPLES_Q31_ID : Output
              Params PARAM1_ID = {
                  A = [16,32,64,128,256]
              }
  
              Functions {
                 Elementwise conjugate:vec_conj_q31
                 Complex dot product:vec_dot_prod_q31
                 Elementwise modulus:vec_mag_q31
                 Elementwise modulus squared:vec_mag_squared_q31
                 Elementwise complex multiplication:vec_mult_cmplx_q31
                 Vector scaling by real number:vec_mult_real_q31
              } -> PARAM1_ID
           }

           suite ComplexMaths Benchmarks Q15 {
              class = ComplexMathsBenchmarksQ15
              folder = ComplexMathsQ15
  
              ParamList {
                  NB
                  Summary NB
                  Names "NB Samples"
                  Formula "NB"
              }
  
              Pattern INPUT1_Q15_ID : Input1_q15.txt 
              Pattern INPUT2_Q15_ID : Input2_q15.txt 
              Pattern INPUT3_Q15_ID : Input3_q15.txt 
              Output  OUT_SAMPLES_Q15_ID : Output
              Params PARAM1_ID = {
                  A = [16,32,64,128,256]
              }
  
              Functions {
                 Elementwise conjugate:vec_conj_q15
                 Complex dot product:vec_dot_prod_q15
                 Elementwise modulus:vec_mag_q15
                 Elementwise modulus squared:vec_mag_squared_q15
                 Elementwise complex multiplication:vec_mult_cmplx_q15
                 Vector scaling by real number:vec_mult_real_q15
              } -> PARAM1_ID
           }
        }

        group Quaternion Maths {
           class = QuaternionBenchmarks
           folder = QuaternionMaths

           suite Quaternion Maths Benchmarks F32 {
              class = QuaternionMathsBenchmarksF32
              folder = QuaternionMathsF32
  
              ParamList {
                  NB
                  Summary NB
                  Names "NB Samples"
                  Formula "NB"
              }
  
              Pattern INPUT1_F32_ID : Input1_f32.txt 
              Pattern INPUT2_F32_ID : Input2_f32.txt 
              Pattern INPUT_ROT_F32_ID : Input7_f32.txt 

              Output  OUT_SAMPLES_F32_ID : Output
              Params PARAM1_ID = {
                  A = [16,32,64,128]
              }
  
              Functions {
                Quaternion Norm:test_quaternion_norm_f32
                Quaternion inverse:test_quaternion_inverse_f32
                Quaternion conjugate:test_quaternion_conjugate_f32
                Quaternion normalization:test_quaternion_normalize_f32
                Quaternion product:test_quaternion_prod_single_f32
                Quaternion Elementwise product:test_quaternion_product_f32
                Quaternion to rotation:test_quaternion2rotation_f32
                Rotation to quaternion:test_rotation2quaternion_f32
              } -> PARAM1_ID
           }
        }

        group Filtering {
           class = DSPFiltering 
           folder = Filtering 

           group FIR {
             class = FIR 
             folder = FIR

             suite FIR F32 {
                class = FIRF32 
                folder = FIRF32

                ParamList {
                  NumTaps, NB
                  Summary NumTaps, NB
                  Names "Number of taps","Number of samples"
                  Formula "NumTaps * NB"
                }

                Pattern SAMPLES1_F32_ID : Samples1_f32.txt 
                Pattern REFS1_F32_ID : Refs1_f32.txt 
                Pattern COEFS1_F32_ID : Coefs1_f32.txt 

                Output  OUT_SAMPLES_F32_ID : Output
                Output  STATE_F32_ID : State
                Output  ERR_F32_ID : Err

                Params PARAM1_ID = {
                  NumTaps = [16,32,64]
                  NB = [64,128,256]
                }

                Functions {
                   FIR Filter:test_fir_f32
                   LMS Filter:test_lms_f32
                   Normalized LMS Filter:test_lms_norm_f32
                } -> PARAM1_ID
             }

             suite FIR Q31 {
                class = FIRQ31
                folder = FIRQ31

                ParamList {
                  NumTaps, NB
                  Summary NumTaps, NB
                  Names "Number of taps","Number of samples"
                  Formula "NumTaps * NB"
                }

                Pattern SAMPLES1_Q31_ID : Samples1_q31.txt 
                Pattern REFS1_Q31_ID : Refs1_q31.txt 
                Pattern COEFS1_Q31_ID : Coefs1_q31.txt 

                Output  OUT_SAMPLES_Q31_ID : Output
                Output  STATE_Q31_ID : State
                Output  ERR_Q31_ID : Err

                Params PARAM1_ID = {
                  NumTaps = [16,32,64]
                  NB = [64,128,256]
                }

                Functions {
                   FIR Filter:test_fir_q31
                   LMS Filter:test_lms_q31
                   Normalized LMS Filter:test_lms_norm_q31
                } -> PARAM1_ID
             }

             suite FIR Q15 {
                class = FIRQ15
                folder = FIRQ15

                ParamList {
                  NumTaps, NB
                  Summary NumTaps, NB
                  Names "Number of taps","Number of samples"
                  Formula "NumTaps * NB"
                }

                Pattern SAMPLES1_Q15_ID : Samples1_q15.txt 
                Pattern REFS1_Q15_ID : Refs1_q15.txt 
                Pattern COEFS1_Q15_ID : Coefs1_q15.txt 

                Output  OUT_SAMPLES_Q15_ID : Output
                Output  STATE_Q15_ID : State
                Output  ERR_Q15_ID : Err

                Params PARAM1_ID = {
                  NumTaps = [16,32,64]
                  NB = [64,128,256]
                }

                Functions {
                   FIR Filter:test_fir_q15
                   LMS Filter:test_lms_q15
                   Normalized LMS Filter:test_lms_norm_q15
                } -> PARAM1_ID
             }

             suite FIR Q7 {
                class = FIRQ7
                folder = FIRQ7

                ParamList {
                  NumTaps, NB
                  Summary NumTaps, NB
                  Names "Number of taps","Number of samples"
                  Formula "NumTaps * NB"
                }

                Pattern SAMPLES1_Q7_ID : Samples1_q7.txt 
                Pattern REFS1_Q7_ID : Refs1_q7.txt 
                Pattern COEFS1_Q7_ID : Coefs1_q7.txt 

                Output  OUT_SAMPLES_Q7_ID : Output
                Output  STATE_Q7_ID : State
                Output  ERR_Q7_ID : Err

                Params PARAM1_ID = {
                  NumTaps = [16,32,64]
                  NB = [64,128,256]
                }

                Functions {
                   FIR Filter:test_fir_q7
                } -> PARAM1_ID
             }
           }

           group Convolutions / Correlations {
             class = MISC 
             folder = MISC

             suite Convolutions / Correlations F32 {
                class = MISCF32 
                folder = MISCF32

                ParamList {
                  NBA, NBB
                  Summary NBA, NBB
                  Names "Number of samples A,Number of samples B"
                  Formula "NBA * NBB"
                }

                Pattern INPUTSA1_F32_ID : InputsA1_f32.txt 
                Pattern INPUTSB1_F32_ID : InputsB1_f32.txt 

                Output  OUT_SAMPLES_F32_ID : Output

                Params PARAM1_ID = {
                  NBA = [9,16,64]
                  NBB = [9,16,128]
                }

                Functions {
                   Convolution:test_conv_f32
                   Correlation:test_correlate_f32
                } -> PARAM1_ID
              }

             suite Convolutions / Correlations Q31 {
                class = MISCQ31 
                folder = MISCQ31

                ParamList {
                  NBA, NBB
                  Summary NBA, NBB
                  Names "Number of samples A,Number of samples B"
                  Formula "NBA * NBB"
                }

                Pattern INPUTSA1_Q31_ID : InputsA1_q31.txt 
                Pattern INPUTSB1_Q31_ID : InputsB1_q31.txt 

                Output  OUT_SAMPLES_Q31_ID : Output

                Params PARAM1_ID = {
                  NBA = [9,16,64]
                  NBB = [9,16,128]
                }

                Functions {
                   Convolution:test_conv_q31
                   Correlation:test_correlate_q31
                } -> PARAM1_ID
              }

             suite Convolutions / Correlations Q15 {
                class = MISCQ15 
                folder = MISCQ15

                ParamList {
                  NBA, NBB
                  Summary NBA, NBB
                  Names "Number of samples A,Number of samples B"
                  Formula "NBA * NBB"
                }

                Pattern INPUTSA1_Q15_ID : InputsA1_q15.txt 
                Pattern INPUTSB1_Q15_ID : InputsB1_q15.txt 

                Output  OUT_SAMPLES_Q15_ID : Output

                Params PARAM1_ID = {
                  NBA = [9,16,64]
                  NBB = [9,16,128]
                }

                Functions {
                   Convolution:test_conv_q15
                   Correlation:test_correlate_q15
                } -> PARAM1_ID
              }

             suite Convolutions / Correlations Q7 {
                class = MISCQ7 
                folder = MISCQ7

                ParamList {
                  NBA, NBB
                  Summary NBA, NBB
                  Names "Number of samples A,Number of samples B"
                  Formula "NBA * NBB"
                }

                Pattern INPUTSA1_Q7_ID : InputsA1_q7.txt 
                Pattern INPUTSB1_Q7_ID : InputsB1_q7.txt 

                Output  OUT_SAMPLES_Q7_ID : Output

                Params PARAM1_ID = {
                  NBA = [9,16,64]
                  NBB = [9,16,128]
                }

                Functions {
                   Convolution:test_conv_q7
                   Correlation:test_correlate_q7
                } -> PARAM1_ID
              }
           }

           group Decimations / Interpolations {
             class = DECIM 
             folder = DECIM

             suite Decimations / Interpolations F32 {
                class = DECIMF32 
                folder = DECIMF32

                ParamList {
                  NumTaps, NB, Factor
                  Summary NumTaps, NB, Factor
                  Names "Number of taps","Number of samples","Decimation or Interpolation factor"
                  Formula "NumTaps * NB * Factor"
                }

                Pattern SAMPLES1_F32_ID : Samples1_f32.txt 
                Pattern COEFS1_F32_ID : Coefs1_f32.txt 

                Output  OUT_SAMPLES_F32_ID : Output
                Output  STATE_F32_ID : State

                Params PARAM_DECIM_ID : Params1.txt
                Params PARAM_INTERPOL_ID : Params2.txt

                Functions {
                   Decimation:test_fir_decimate_f32 -> PARAM_DECIM_ID
                   Interpolation:test_fir_interpolate_f32 -> PARAM_INTERPOL_ID
                }
              }

             suite Decimations / Interpolations Q31 {
                class = DECIMQ31
                folder = DECIMQ31

                ParamList {
                  NumTaps, NB, Factor
                  Summary NumTaps, NB, Factor
                  Names "Number of taps","Number of samples","Decimation or Interpolation factor"
                  Formula "NumTaps * NB * Factor"
                }

                Pattern SAMPLES1_Q31_ID : Samples1_q31.txt 
                Pattern COEFS1_Q31_ID : Coefs1_q31.txt 

                Output  OUT_SAMPLES_Q31_ID : Output
                Output  STATE_Q31_ID : State

                Params PARAM_DECIM_ID : Params1.txt
                Params PARAM_INTERPOL_ID : Params2.txt

                Functions {
                   Decimation:test_fir_decimate_q31 -> PARAM_DECIM_ID
                   Interpolation:test_fir_interpolate_q31 -> PARAM_INTERPOL_ID
                }
              }

             suite Decimations / Interpolations Q15 {
                class = DECIMQ15
                folder = DECIMQ15

                ParamList {
                  NumTaps, NB, Factor
                  Summary NumTaps, NB, Factor
                  Names "Number of taps","Number of samples","Decimation or Interpolation factor"
                  Formula "NumTaps * NB * Factor"
                }

                Pattern SAMPLES1_Q15_ID : Samples1_q15.txt 
                Pattern COEFS1_Q15_ID : Coefs1_q15.txt 

                Output  OUT_SAMPLES_Q15_ID : Output
                Output  STATE_Q15_ID : State

                Params PARAM_DECIM_ID : Params1.txt
                Params PARAM_INTERPOL_ID : Params2.txt

                Functions {
                   Decimation:test_fir_decimate_q15 -> PARAM_DECIM_ID
                   Interpolation:test_fir_interpolate_q15 -> PARAM_INTERPOL_ID
                }
              }
           }

           group BiQuads {
             class = BIQUAD 
             folder = BIQUAD

             suite BiQuads F32 {
                class = BIQUADF32 
                folder = BIQUADF32

                ParamList {
                  NumStages, NB
                  Summary NumStages, NB
                  Names "Number of stages","Number of samples"
                  Formula "NumStages * NB"
                }

                Pattern SAMPLES1_F32_ID : Samples1_f32.txt 
                Pattern COEFS1_F32_ID : Coefs1_f32.txt 

                Output  OUT_SAMPLES_F32_ID : Output
                Output  STATE_F32_ID : State
                Output  NEON_COEFS_F32_ID : NeonCoefs

                Params PARAM1_ID = {
                  NumStages = [1,2,4]
                  NB = [16,128,256]
                }

                Functions {
                   Cascaded BiQuad Filter DF1:test_biquad_cascade_df1_f32
                   Cascaded BiQuad Filter DF2T:test_biquad_cascade_df2T_f32
                   Cascaded BiQuad Filter Stereo DF2T:test_biquad_cascade_stereo_df2T_f32
                } -> PARAM1_ID
              }

             suite BiQuads F64 {
                class = BIQUADF64 
                folder = BIQUADF64

                ParamList {
                  NumStages, NB
                  Summary NumStages, NB
                  Names "Number of stages","Number of samples"
                  Formula "NumStages * NB"
                }

                Pattern SAMPLES1_F64_ID : Samples1_f64.txt 
                Pattern COEFS1_F64_ID : Coefs1_f64.txt 

                Output  OUT_SAMPLES_F64_ID : Output
                Output  STATE_F64_ID : State

                Params PARAM1_ID = {
                  NumStages = [1,2,4]
                  NB = [16,128,256]
                }

                Functions {
                   Cascaded BiQuad Filter DF2T:test_biquad_cascade_df2T_f64
                } -> PARAM1_ID
              }
           }
        }

        group Controller {
           class = Controller 
           folder = Controller 

           suite Controller F32 {
                class = ControllerF32 
                folder = ControllerF32

                ParamList {
                  NB
                  Summary NB
                  Names "Number of samples"
                  Formula "NB"
                }

                Pattern SAMPLES_F32_ID : Samples1_f32.txt 
                Output  OUT_SAMPLES_F32_ID : Output

                Params PARAM1_ID = {
                  NB = [64,128,256]
                }

                Functions {
                   PID:test_pid_f32
                   Clarke Transform:test_clarke_f32
                   Inverse Clarke Transform:test_inv_clarke_f32
                   Park Transform:test_park_f32
                   Inverse Park Transform:test_inv_park_f32
                   Sin Cos:test_sin_cos_f32
                } -> PARAM1_ID
             }

           suite Controller Q31 {
                class = ControllerQ31 
                folder = ControllerQ31

                ParamList {
                  NB
                  Summary NB
                  Names "Number of samples"
                  Formula "NB"
                }

                Pattern SAMPLES_Q31_ID : Samples1_q31.txt 
                Output  OUT_SAMPLES_Q31_ID : Output

                Params PARAM1_ID = {
                  NB = [64,128,256]
                }

                Functions {
                   PID:test_pid_q31
                   Clarke Transform:test_clarke_q31
                   Inverse Clarke Transform:test_inv_clarke_q31
                   Park Transform:test_park_q31
                   Inverse Park Transform:test_inv_park_q31
                   Sin Cos:test_sin_cos_q31
                } -> PARAM1_ID
             }

           suite Controller Q15 {
                class = ControllerQ15
                folder = ControllerQ15

                ParamList {
                  NB
                  Summary NB
                  Names "Number of samples"
                  Formula "NB"
                }

                Pattern SAMPLES_Q15_ID : Samples1_q15.txt 
                Output  OUT_SAMPLES_Q15_ID : Output

                Params PARAM1_ID = {
                  NB = [64,128,256]
                }

                Functions {
                   PID:test_pid_q15
                } -> PARAM1_ID
             }
        }

        group Fast Maths {
           class = FastMath 
           folder = FastMath 

           suite Fast Maths F32 {
                class = FastMathF32 
                folder = FastMathF32

                ParamList {
                  NB
                  Summary NB
                  Names "Number of samples"
                  Formula "NB"
                }

                Pattern SAMPLES_F32_ID : Samples1_f32.txt 
                Output  OUT_SAMPLES_F32_ID : Output

                Params PARAM1_ID = {
                  NB = [64,128,256]
                }

                Functions {
                   Cosine:test_cos_f32
                   Sine:test_sin_f32
                   Square Root:test_sqrt_f32
                } -> PARAM1_ID
             }

           suite Fast Maths Q31 {
                class = FastMathQ31 
                folder = FastMathQ31

                ParamList {
                  NB
                  Summary NB
                  Names "Number of samples"
                  Formula "NB"
                }

                Pattern SAMPLES_Q31_ID : Samples1_q31.txt 
                Output  OUT_SAMPLES_Q31_ID : Output

                Params PARAM1_ID = {
                  NB = [64,128,256]
                }

                Functions {
                   Cosine:test_cos_q31
                   Sine:test_sin_q31
                   Square Root:test_sqrt_q31
                } -> PARAM1_ID
             }

           suite Fast Maths Q15 {
                class = FastMathQ15
                folder = FastMathQ15

                ParamList {
                  NB
                  Summary NB
                  Names "Number of samples"
                  Formula "NB"
                }

                Pattern SAMPLES_Q15_ID : Samples1_q15.txt 
                Output  OUT_SAMPLES_Q15_ID : Output

                Params PARAM1_ID = {
                  NB = [64,128,256]
                }

                Functions {
                   Cosine:test_cos_q15
                   Sine:test_sin_q15
                   Square Root:test_sqrt_q15
                } -> PARAM1_ID
             }
        }

        group Bayes{
           class = Bayes
           folder = Bayes 

           suite Bayes F32 {
              class = BayesF32
              folder = BayesF32

              ParamList {
                  VECDIM,NBCLASSES
                  Summary VECDIM,NBCLASSES
                  Names "Vector dimension","Number of classes"
                  Formula "VECDIM*NBCLASSES"
                }

              Pattern DIMS2_S16_ID : DimsBench2_s16.txt 
              Pattern INPUTS2_F32_ID : Inputs2_f32.txt 
              Pattern PARAMS2_F32_ID : Params2_f32.txt 
              Pattern PREDICTS2_S16_ID : Predicts2_s16.txt

              Output  OUT_PROBA_F32_ID : Probas
              Output  OUT_PREDICT_S16_ID : Predicts

              // Must be consistent with the Python script
              Params PARAM1_ID = {
                  VECDIM = [12,14,20]
                  NBCLASSES = [3,5,4]
                }

              Functions {
                 Naive Gaussian Bayes Predictor:test_gaussian_naive_bayes_predict_f32
              } -> PARAM1_ID
           }
        }

        group Distance  {
           class = Distance
           folder = Distance

           suite Distance F32 {
              class = DistanceF32
              folder = DistanceF32

              ParamList {
                  NB
                  Summary NB
                  Names "NB Samples"
                  Formula "NB"
              }
              
              Pattern INPUTA_F32_ID : InputBenchA1_f32.txt
              Pattern INPUTB_F32_ID : InputBenchB1_f32.txt

              Pattern INPUTA_PROBA_F32_ID : InputBenchProbaA1_f32.txt
              Pattern INPUTB_PROBA_F32_ID : InputBenchProbaB1_f32.txt

              Output  TMPA_F32_ID : TmpA
              Output  TMPB_F32_ID : TmpB

              Params PARAM1_ID = {
                  NB = [16,32,64,128,256]
              }

              Functions {
                 Bray Curtis distance:test_braycurtis_distance_f32
                 Canberra distance:test_canberra_distance_f32
                 Chebyshev distance:test_chebyshev_distance_f32
                 Cityblock distance:test_cityblock_distance_f32
                 Correlation distance:test_correlation_distance_f32
                 Cosine distance:test_cosine_distance_f32
                 Euclidean distance:test_euclidean_distance_f32
                 Jensen Shannon distance:test_jensenshannon_distance_f32
                 Minkowski distance:test_minkowski_distance_f32
              } -> PARAM1_ID
           }

           suite Distance  U32 {
              class = DistanceU32
              folder = DistanceU32

              ParamList {
                  NB
                  Summary NB
                  Names "NB Bits"
                  Formula "NB"
              }
              
              Pattern INPUTA_U32_ID : InputBenchA1_u32.txt
              Pattern INPUTB_U32_ID : InputBenchB1_u32.txt

        
              Params PARAM1_ID = {
                  NB = [512, 1024, 2048, 4096, 8192]
              }


              Functions {
                 Dice distance:test_dice_distance_u32
                 Hamming distance:test_hamming_distance_u32
                 Jaccard distance:test_jaccard_distance_u32
                 Kulsinski distance:test_kulsinski_distance_u32
                 Roger Stanimoto distance:test_rogerstanimoto_distance_u32
                 Russell Rao distance:test_russellrao_distance_u32
                 Sokal Michener distance:test_sokalmichener_distance_u32
                 Sokal Sneath distance:test_sokalsneath_distance_u32
                 Yule distance:test_yule_distance_u32
              } -> PARAM1_ID
           }
        }

        group SVM  {
           class = SVM
           folder = SVM 

           suite SVM F32 {
              class = SVMF32
              folder = SVMF32

              ParamList {
                  VECDIM,NBVECS
                  Summary VECDIM,NBVECS
                  Names "Vector dimension","Number of suppot vectors"
                  Formula "VECDIM*NBVECS"
              }

              Pattern INPUT_F32_ID : InputsBench6_f32.txt 
              
              Pattern DIMS_LINEAR_S16_ID : DimsLinear6_s16.txt 
              Pattern PARAMS_LINEAR_F32_ID : ParamsLinear6_f32.txt

              Pattern DIMS_POLY_S16_ID : DimsPoly6_s16.txt 
              Pattern PARAMS_POLY_F32_ID : ParamsPoly6_f32.txt

              Pattern DIMS_RBF_S16_ID : DimsRBF6_s16.txt 
              Pattern PARAMS_RBF_F32_ID : ParamsRBF6_f32.txt

              Pattern DIMS_SIGMOID_S16_ID : DimsSigmoid6_s16.txt 
              Pattern PARAMS_SIGMOID_F32_ID : ParamsSigmoid6_f32.txt

              Output  OUT_S32_ID : Output

              // Must be consistent with the Python script
              Params PARAM1_ID = {
                  VECDIM = [16,32,64]
                  NBVECS = [8,16,32]
                }

              Functions {
                 Linear SVM:test_svm_linear_predict_f32
                 Polynomial SVM:test_svm_polynomial_predict_f32
                 RBF SVM:test_svm_rbf_predict_f32
                 Sigmoid SVM:test_svm_sigmoid_predict_f32
              } -> PARAM1_ID
           }
        }

        group Barycenter {
           class = Barycenter 
           
           suite Barycenter {
                class = SupportBarF32 
                folder = SupportBarF32

                ParamList {
                  NB,VECDIM
                  Summary NB,VECDIM
                  Names "Number of samples","Vector dimension"
                  Formula "NB*VECDIM"
                }

                Pattern SAMPLES_F32_ID : Samples1_f32.txt 
                Pattern COEFS_F32_ID : Coefs1_f32.txt 
                Output  OUT_SAMPLES_F32_ID : Output

                Params PARAM1_ID = {
                  NB = [16,64,128]
                  VECDIM = [5,10,15]
                }

                Functions {
                   Barycenter:test_barycenter_f32
                } -> PARAM1_ID
   
           }

        }

        group Support Functions {
           class = Support 
           folder = Support 

           suite Support Functions F32 {
                class = SupportF32 
                folder = SupportF32

                ParamList {
                  NB
                  Summary NB
                  Names "Number of samples"
                  Formula "NB"
                }

                Pattern SAMPLES_F32_ID : Samples1_f32.txt 
                Pattern SAMPLES_Q15_ID : Samples3_q15.txt 
                Pattern SAMPLES_Q31_ID : Samples4_q31.txt 
                Pattern SAMPLES_Q7_ID : Samples5_q7.txt 

                Pattern INPUTS6_F32_ID : Inputs6_f32.txt 
                Pattern WEIGHTS6_F32_ID : Weights6_f32.txt 
                Pattern REF6_F32_ID : Ref6_f32.txt

                Output  OUT_SAMPLES_F32_ID : Output

                Params PARAM1_ID = {
                  NB = [64,128,256]
                }

                Functions {
                   Vector Copy:test_copy_f32
                   Vector Filling:test_fill_f32
                   Elementwise q15 to f32:test_q15_to_f32
                   Elementwise q31 to f32:test_q31_to_f32
                   Elementwise q7 to f32:test_q7_to_f32
                   Weighted sum:test_weighted_sum_f32
                } -> PARAM1_ID
             }

           suite Support Functions Q31 {
                class = SupportQ31 
                folder = SupportQ31

                ParamList {
                  NB
                  Summary NB
                  Names "Number of samples"
                  Formula "NB"
                }

                Pattern SAMPLES_Q31_ID : Samples4_q31.txt 
                Pattern SAMPLES_Q15_ID : Samples3_q15.txt 
                Pattern SAMPLES_Q7_ID : Samples5_q7.txt 
                Output  OUT_SAMPLES_Q31_ID : Output

                Params PARAM1_ID = {
                  NB = [64,128,256]
                }

                Functions {
                   Vector Copy:test_copy_q31
                   Vector Filling:test_fill_q31
                   Elementwise q15 to q31:test_q15_to_q31
                   Elementwise q7 to q31:test_q7_to_q31
                } -> PARAM1_ID
             }

           suite Support Functions Q15 {
                class = SupportQ15
                folder = SupportQ15

                ParamList {
                  NB
                  Summary NB
                  Names "Number of samples"
                  Formula "NB"
                }

                Pattern SAMPLES_Q15_ID : Samples3_q15.txt 
                Pattern SAMPLES_Q31_ID : Samples4_q31.txt 
                Pattern SAMPLES_Q7_ID : Samples5_q7.txt 
                Output  OUT_SAMPLES_Q15_ID : Output

                Params PARAM1_ID = {
                  NB = [64,128,256]
                }

                Functions {
                   Vector Copy:test_copy_q15
                   Vector Filling:test_fill_q15
                   Elementwise q31 to q15:test_q31_to_q15
                   Elementwise q7 to q15:test_q7_to_q15
                } -> PARAM1_ID
             }

           suite Support Functions Q7 {
                class = SupportQ7
                folder = SupportQ7

                ParamList {
                  NB
                  Summary NB
                  Names "Number of samples"
                  Formula "NB"
                }

                Pattern SAMPLES_Q7_ID : Samples5_q7.txt 
                Pattern SAMPLES_Q31_ID : Samples4_q31.txt 
                Pattern SAMPLES_Q15_ID : Samples3_q15.txt 
                Output  OUT_SAMPLES_Q7_ID : Output

                Params PARAM1_ID = {
                  NB = [64,128,256]
                }

                Functions {
                   Vector Copy:test_copy_q7
                   Vector Filling:test_fill_q7
                   Elementwise q31 to q7:test_q31_to_q7
                   Elementwise q15 to q7:test_q15_to_q7
                } -> PARAM1_ID
             }
        }

        group Matrix {
           class = Matrix 
           folder = Matrix 

           group Matrix Operators with one matrix size {
              class = Unary 
              folder = Unary 

              suite Unary Matrix Operators F32 {
                class = UnaryF32 
                folder = UnaryF32

                ParamList {
                  NBR,NBC
                  Summary NBR,NBC
                  Names "Number of rows","Number of columns"
                  Formula "NBR*NBC"
                }

                Pattern INPUTA_F32_ID : InputA1_f32.txt 
                Pattern INPUTAC_F32_ID : InputAC1_f32.txt 
                Pattern INPUTVEC1_F32_ID : InputVec1_f32.txt 

                Pattern DIMSCHOLESKY1_DPO_S16_ID : DimsCholeskyDPO1_s16.txt 
                Pattern DIMSCHOLESKY1_SDPO_S16_ID : DimsCholeskySDPO1_s16.txt 
                Pattern INPUTSCHOLESKY1_DPO_F32_ID : InputCholeskyDPO1_f32.txt 
                Pattern INPUTSCHOLESKY1_SDPO_F32_ID : InputCholeskySDPO1_f32.txt 

                Pattern REFCHOLESKY1_DPO_F32_ID : RefCholeskyDPO1_f32.txt

                Pattern REFLDLT_D_DPO1_F32_ID : RefLDLT_D_DPO1_f32.txt
                Pattern REFLDLT_LL_DPO1_F32_ID : RefLDLT_LL_DPO1_f32.txt
                Pattern REFLDLT_PERM_DPO1_F32_ID : RefLDLT_PERM_DPO1_s16.txt

                Pattern REFLDLT_D_SDPO1_F32_ID : RefLDLT_D_SDPO1_f32.txt
                Pattern REFLDLT_LL_SDPO1_F32_ID : RefLDLT_LL_SDPO1_f32.txt
                Pattern REFLDLT_PERM_SDPO1_F32_ID : RefLDLT_PERM_SDPO1_s16.txt

                Pattern INPUT_UT_DPO_F32_ID : InputUTDPO1_f32.txt
                Pattern INPUT_LT_DPO_F32_ID : InputLTDPO1_f32.txt
                Pattern INPUT_RNDA_DPO_F32_ID : InputRNDA1_f32.txt
            
                Pattern REF_UTINV_DPO_F32_ID : Ref_UTINV_DPO1_f32.txt
                Pattern REF_LTINV_DPO_F32_ID : Ref_LTINV_DPO1_f32.txt
                Pattern REF_CHOLINV_DPO_F32_ID : Ref_CHOLINV_DPO1_f32.txt

                Output  D_F32_ID : Output
                Output  LL_F32_ID : Output
                Output  PERM_S16_ID : Output
                
                Output  TMPA_F32_ID : TempA
                Output  TMPB_F32_ID : TempB
                Output  OUT_F32_ID : Output

                Params PARAM1_ID = {
                  NBR = [5,10,40]
                  NBC = [5,10,40]
                }

                Params PARAM_CHOLESKY_ID : ParamsCholesky1.txt

                Functions {
                   Matrix Scaling:test_mat_scale_f32
                   Matrix Inversion:test_mat_inverse_f32
                   Matrix Transpose:test_mat_trans_f32
                   Matrix Addition:test_mat_add_f32
                   Matrix Substraction:test_mat_sub_f32
                   Matrix Vector Multiplication:test_mat_vec_mult_f32
                   Matrix Complex Transpose:test_mat_cmplx_trans_f32
                   Cholesky decomposition:test_mat_cholesky_dpo_f32 -> PARAM_CHOLESKY_ID
                   Backward substitution:test_solve_upper_triangular_f32 -> PARAM_CHOLESKY_ID
                   Foward substitution:test_solve_lower_triangular_f32 -> PARAM_CHOLESKY_ID
                   LDLT decomposition:test_ldlt_decomposition_f32 -> PARAM_CHOLESKY_ID
                } -> PARAM1_ID
              }

              suite Unary Matrix Operators Q31 {
                class = UnaryQ31 
                folder = UnaryQ31

                ParamList {
                  NBR,NBC
                  Summary NBR,NBC
                  Names "Number of rows","Number of columns"
                  Formula "NBR*NBC"
                }

                Pattern INPUTA_Q31_ID : InputA1_q31.txt 
                Pattern INPUTAC_Q31_ID : InputAC1_q31.txt 
                Pattern INPUTVEC1_Q31_ID : InputVec1_q31.txt 

                Output  OUT_Q31_ID : Output

                Params PARAM1_ID = {
                  NBR = [5,10,40]
                  NBC = [5,10,40]
                }

                Functions {
                   Matrix Scaling:test_mat_scale_q31
                   Matrix Transpose:test_mat_trans_q31
                   Matrix Addition:test_mat_add_q31
                   Matrix Substraction:test_mat_sub_q31
                   Matrix Vector Multiplication:test_mat_vec_mult_q31
                   Matrix Complex Transpose:test_mat_cmplx_trans_q31
                } -> PARAM1_ID
              }

              suite Unary Matrix Operators Q15 {
                class = UnaryQ15 
                folder = UnaryQ15

                ParamList {
                  NBR,NBC
                  Summary NBR,NBC
                  Names "Number of rows","Number of columns"
                  Formula "NBR*NBC"
                }

                Pattern INPUTA_Q15_ID : InputA1_q15.txt 
                Pattern INPUTAC_Q15_ID : InputAC1_q15.txt 
                Pattern INPUTVEC1_Q15_ID : InputVec1_q15.txt 
                Output  OUT_Q15_ID : Output

                Params PARAM1_ID = {
                  NBR = [5,10,40]
                  NBC = [5,10,40]
                }

                Functions {
                   Matrix Scaling:test_mat_scale_q15
                   Matrix Transpose:test_mat_trans_q15
                   Matrix Addition:test_mat_add_q15
                   Matrix Substraction:test_mat_sub_q15
                   Matrix Vector Multiplication:test_mat_vec_mult_q15
                   Matrix Complex Transpose:test_mat_cmplx_trans_q15
                } -> PARAM1_ID
              }

              suite Unary Matrix Operators Q7 {
                class = UnaryQ7 
                folder = UnaryQ7

                ParamList {
                  NBR,NBC
                  Summary NBR,NBC
                  Names "Number of rows","Number of columns"
                  Formula "NBR*NBC"
                }

                Pattern INPUTA_Q7_ID : InputA1_q7.txt 
                Pattern INPUTVEC1_Q7_ID : InputVec1_q7.txt 
                Output  OUT_Q7_ID : Output

                Params PARAM1_ID = {
                  NBR = [5,10,40]
                  NBC = [5,10,40]
                }

                Functions {
                   Matrix Transpose:test_mat_trans_q7
                   Matrix Vector Multiplication:test_mat_vec_mult_q7
                } -> PARAM1_ID
              }


              suite Unary Matrix Operators F64 {
                class = UnaryF64 
                folder = UnaryF64

                ParamList {
                  NBR,NBC
                  Summary NBR,NBC
                  Names "Number of rows","Number of columns"
                  Formula "NBR*NBC"
                }

                Pattern INPUTA_F64_ID : InputA1_f64.txt 

                Pattern DIMSCHOLESKY1_DPO_S16_ID : DimsCholeskyDPO1_s16.txt 
                Pattern DIMSCHOLESKY1_SDPO_S16_ID : DimsCholeskySDPO1_s16.txt 
                Pattern INPUTSCHOLESKY1_DPO_F64_ID : InputCholeskyDPO1_f64.txt 
                Pattern INPUTSCHOLESKY1_SDPO_F64_ID : InputCholeskySDPO1_f64.txt 

                Pattern REFCHOLESKY1_DPO_F64_ID : RefCholeskyDPO1_f64.txt

                Pattern REFLDLT_D_DPO1_F64_ID : RefLDLT_D_DPO1_f64.txt
                Pattern REFLDLT_LL_DPO1_F64_ID : RefLDLT_LL_DPO1_f64.txt
                Pattern REFLDLT_PERM_DPO1_F64_ID : RefLDLT_PERM_DPO1_s16.txt

                Pattern REFLDLT_D_SDPO1_F64_ID : RefLDLT_D_SDPO1_f64.txt
                Pattern REFLDLT_LL_SDPO1_F64_ID : RefLDLT_LL_SDPO1_f64.txt
                Pattern REFLDLT_PERM_SDPO1_F64_ID : RefLDLT_PERM_SDPO1_s16.txt

                Pattern INPUT_UT_DPO_F64_ID : InputUTDPO1_f64.txt
                Pattern INPUT_LT_DPO_F64_ID : InputLTDPO1_f64.txt
                Pattern INPUT_RNDA_DPO_F64_ID : InputRNDA1_f64.txt
            
                Pattern REF_UTINV_DPO_F64_ID : Ref_UTINV_DPO1_f64.txt
                Pattern REF_LTINV_DPO_F64_ID : Ref_LTINV_DPO1_f64.txt
                Pattern REF_CHOLINV_DPO_F64_ID : Ref_CHOLINV_DPO1_f64.txt

                Output  TMPA_F64_ID : TempA
                Output  TMPB_F64_ID : TempB
                Output  OUT_F64_ID : Output

                Params PARAM1_ID = {
                  NBR = [5,10,40]
                  NBC = [5,10,40]
                }

                Params PARAM_CHOLESKY_ID : ParamsCholesky1.txt

                Functions {
                   Matrix Inversion:test_mat_inverse_f64
                   Cholesky decomposition:test_mat_cholesky_dpo_f64 -> PARAM_CHOLESKY_ID
                   Backward substitution:test_solve_upper_triangular_f64 -> PARAM_CHOLESKY_ID
                   Foward substitution:test_solve_lower_triangular_f64 -> PARAM_CHOLESKY_ID
                } -> PARAM1_ID
              }
           }

           group Matrix Operators with two matrix sizes {
              class = Binary 
              folder = Binary 

             suite Binary Matrix Operators F32 {
                class = BinaryF32 
                folder = BinaryF32

                ParamList {
                  NBR,NBI,NBC
                  Summary NBR,NBI,NBC
                  Names "Number of rows","Inner dimensions","Number of columns"
                  Formula "NBR*NBI*NBC"
                }

                Pattern INPUTA_F32_ID : InputA1_f32.txt 
                Pattern INPUTB_F32_ID : InputB1_f32.txt 

                Pattern INPUTAC_F32_ID : InputAC1_f32.txt 
                Pattern INPUTBC_F32_ID : InputBC1_f32.txt 
                Output  OUT_F32_ID : Output

                Params PARAM1_ID = {
                  NBR = [5,10,40]
                  NBI = [5,10,40]
                  NBC = [5,10,40]
                }


                Functions {
                   Matrix Multiplication:test_mat_mult_f32
                   Complex Matrix Multiplication:test_mat_cmplx_mult_f32
                } -> PARAM1_ID
             }

             suite Binary Matrix Operators Q31 {
                class = BinaryQ31 
                folder = BinaryQ31

                ParamList {
                  NBR,NBI,NBC
                  Summary NBR,NBI,NBC
                  Names "Number of rows","Inner dimensions","Number of columns"
                  Formula "NBR*NBI*NBC"
                }

                Pattern INPUTA_Q31_ID : InputA1_q31.txt 
                Pattern INPUTB_Q31_ID : InputB1_q31.txt 
                Pattern INPUTAC_Q31_ID : InputAC1_q31.txt 
                Pattern INPUTBC_Q31_ID : InputBC1_q31.txt 
                Output  OUT_Q31_ID : Output

                Params PARAM1_ID = {
                  NBR = [5,10,40]
                  NBI = [5,10,40]
                  NBC = [5,10,40]
                }


                Functions {
                   Matrix Multiplication:test_mat_mult_q31
                   Complex Matrix Multiplication:test_mat_cmplx_mult_q31
                   Fast Matrix Multiplication:test_mat_mult_fast_q31
                } -> PARAM1_ID
             }

             suite Binary Matrix Operators Q15 {
                class = BinaryQ15 
                folder = BinaryQ15

                ParamList {
                  NBR,NBI,NBC
                  Summary NBR,NBI,NBC
                  Names "Number of rows","Inner dimensions","Number of columns"
                  Formula "NBR*NBI*NBC"
                }

                Pattern INPUTA_Q15_ID : InputA1_q15.txt 
                Pattern INPUTB_Q15_ID : InputB1_q15.txt 
                Pattern INPUTAC_Q15_ID : InputAC1_q15.txt 
                Pattern INPUTBC_Q15_ID : InputBC1_q15.txt 
                Output  OUT_Q15_ID : Output

                Params PARAM1_ID = {
                  NBR = [5,10,40]
                  NBI = [5,10,40]
                  NBC = [5,10,40]
                }

                Functions {
                   Matrix Multiplication:test_mat_mult_q15
                   Complex Matrix Multiplication:test_mat_cmplx_mult_q15
                   Fast Matrix Multiplication:test_mat_mult_fast_q15
                } -> PARAM1_ID
             }

             suite Binary Matrix Operators Q7 {
                class = BinaryQ7 
                folder = BinaryQ7

                ParamList {
                  NBR,NBI,NBC
                  Summary NBR,NBI,NBC
                  Names "Number of rows","Inner dimensions","Number of columns"
                  Formula "NBR*NBI*NBC"
                }

                Pattern INPUTA_Q7_ID : InputA1_q7.txt 
                Pattern INPUTB_Q7_ID : InputB1_q7.txt 
                Pattern INPUTAC_Q7_ID : InputAC1_q7.txt 
                Pattern INPUTBC_Q7_ID : InputBC1_q7.txt 
                Output  OUT_Q7_ID : Output

                Params PARAM1_ID = {
                  NBR = [5,10,40]
                  NBI = [5,10,40]
                  NBC = [5,10,40]
                }


                Functions {
                   Matrix Multiplication:test_mat_mult_q7
                } -> PARAM1_ID
             }
           }
        }

        group Spectral Transformations {
           class = Transform 
           folder = Transform 

           suite Spectral Transformations F32 {
                class = TransformF32 
                folder = TransformF32

                ParamList {
                  NB,IFFT,BITREV
                  Summary NB
                  Names "Number of samples,Inverse FFT, Bit Reversal"
                  Formula "I(NB*log2(NB))"
                }

                Pattern INPUTR_F32_ID : RealInputSamples19_f32.txt 
                Pattern INPUTC_F32_ID : ComplexInputSamples_Noisy_512_6_f32.txt 
                
                Output  TMP_F32_ID : Temp
                Output  OUT_F32_ID : Output
                Output  STATE_F32_ID : Output

                
                Params CFFT_PARAM_ID = {
                  NB = [64,128,256]
                  IFFT = [0,1]
                  REV = [0,1]
                }

                Params CFFT4_PARAM_ID = {
                  NB = [16,64,256]
                  IFFT = [0,1]
                  REV = [0,1]
                }

                Params RFFT_PARAM_ID = {
                  NB = [64,128,256]
                  IFFT = [0,1]
                  REV = [1]
                }

                Params DCT_PARAM_ID = {
                  NB = [128,512,2048]
                  IFFT = [0]
                  REV = [1]
                }

                Functions {
                   Complex FFT:test_cfft_f32 -> CFFT_PARAM_ID
                   Real FFT:test_rfft_f32 -> RFFT_PARAM_ID
                   DCT4:test_dct4_f32 -> DCT_PARAM_ID
                   Scalar Radix 4 Complex FFT:test_cfft_radix4_f32 -> CFFT4_PARAM_ID
                   Scalar Radix 2 Complex FFT:test_cfft_radix2_f32 -> CFFT_PARAM_ID
                }
           }

           suite Spectral Transformations Q31 {
                class = TransformQ31 
                folder = TransformQ31

                ParamList {
                  NB,IFFT,BITREV
                  Summary NB
                  Names "Number of samples,Inverse FFT, Bit Reversal"
                  Formula "I(NB*log2(NB))"
                }

                Pattern INPUTR_Q31_ID : RealInputSamples19_q31.txt 
                Pattern INPUTC_Q31_ID : ComplexInputSamples_Noisy_512_6_q31.txt 
                Output  OUT_Q31_ID : Output
                Output  STATE_Q31_ID : Output

                
                Params CFFT_PARAM_ID = {
                  NB = [64,128,256]
                  IFFT = [0,1]
                  REV = [0,1]
                }

                Params CFFT4_PARAM_ID = {
                  NB = [16,64,256]
                  IFFT = [0,1]
                  REV = [0,1]
                }

                Params RFFT_PARAM_ID = {
                  NB = [64,128,256]
                  IFFT = [0,1]
                  REV = [1]
                }

                Params DCT_PARAM_ID = {
                  NB = [128,512,2048]
                  IFFT = [0]
                  REV = [1]
                }

                Functions {
                   Complex FFT:test_cfft_q31 -> CFFT_PARAM_ID
                   Real FFT:test_rfft_q31 -> RFFT_PARAM_ID
                   DCT4:test_dct4_q31 -> DCT_PARAM_ID
                   Scalar Radix 4 Complex FFT:test_cfft_radix4_q31 -> CFFT4_PARAM_ID
                   Scalar Radix 2 Complex FFT:test_cfft_radix2_q31 -> CFFT_PARAM_ID
                }
           }

           suite Spectral Transformations Q15 {
                class = TransformQ15 
                folder = TransformQ15

                ParamList {
                  NB,IFFT,BITREV
                  Summary NB
                  Names "Number of samples,Inverse FFT, Bit Reversal"
                  Formula "I(NB*log2(NB))"
                }

                Pattern INPUTR_Q15_ID : RealInputSamples19_q15.txt 
                Pattern INPUTC_Q15_ID : ComplexInputSamples_Noisy_512_6_q15.txt 
                Output  OUT_Q15_ID : Output
                Output  STATE_Q15_ID : Output

                
                Params CFFT_PARAM_ID = {
                  NB = [64,128,256]
                  IFFT = [0,1]
                  REV = [0,1]
                }

                Params CFFT4_PARAM_ID = {
                  NB = [16,64,256]
                  IFFT = [0,1]
                  REV = [0,1]
                }

                Params RFFT_PARAM_ID = {
                  NB = [64,128,256]
                  IFFT = [0,1]
                  REV = [1]
                }

                Params DCT_PARAM_ID = {
                  NB = [128,512,2048]
                  IFFT = [0]
                  REV = [1]
                }

                Functions {
                   Complex FFT:test_cfft_q15 -> CFFT_PARAM_ID
                   Real FFT:test_rfft_q15 -> RFFT_PARAM_ID
                   DCT4:test_dct4_q15 -> DCT_PARAM_ID
                   Scalar Radix 4 Complex FFT:test_cfft_radix4_q15 -> CFFT4_PARAM_ID
                   Scalar Radix 2 Complex FFT:test_cfft_radix2_q15 -> CFFT_PARAM_ID
                }
           }
        }

    }

    group NN Benchmarks
    {
       class = NNBenchmarks
       folder = NN

       suite Fully Connected Benchmarks {
         class = FullyConnectedBench 
         folder = FullyConnected

         ParamList {
                NB
                Summary NB
                Names "Repetition"
                Formula "NB"
            }

         Pattern INPUT13_S8_ID : TestCase_8_8_5_input_13.txt
         Pattern BIAS13_S8_ID : TestCase_8_8_5_bias_13.txt
         Pattern WEIGHT13_S8_ID : TestCase_8_8_5_weights_13.txt
         Pattern REF13_S8_ID : TestCase_8_8_5_output_13.txt

         Output  OUTPUT_S8_ID : Output
         Output  TEMP_S16_ID : Temp

         Params PARAM1_ID = {
                NB = [10,20,40,50]
            }

         Functions {
            arm_fully_connected_tflite_s8:test_fully_connected_tflite_s8  -> PARAM1_ID
         }
       }

       suite Pooling Benchmarks {
         class = PoolingBench 
         folder = Pooling

         ParamList {
                NB
                Summary NB
                Names "Repetition"
                Formula "NB"
          }

         Pattern INPUT1_S8_ID : Input1.txt
         Pattern REF1_S8_ID : Ref1.txt

         Output  OUTPUT_S8_ID : Output
         Output  TEMP_S8_ID : Temp
         Output  TEMPINPUT_S8_ID : TempInput

         Params PARAM1_ID = {
                NB = [1]
            }

         Functions {
            arm_avgpool_s8 Test 1:test_avgpool_s8  -> PARAM1_ID
         }
       }
    }

    group Compiler Benchmarks {
      class = CompilerBenchmarks
      folder = DSP 

      group Micro Benchmarks {
        class = MicroBenchmarks
        folder = BasicMaths 

        suite MicroBenchmarksF32 {
          class = MicroBenchmarksF32
          folder = BasicMathsF32
  
          ParamList {
                    NB
                    Summary NB
                    Names "NB Samples"
                    Formula "NB"
          }
  
          Pattern INPUT1_F32_ID : Input1_f32.txt 
          Pattern INPUT2_F32_ID : Input2_f32.txt 
          Output  OUT_SAMPLES_F32_ID : Output
  
          Params PARAM1_ID = {
                    A = [16,32,64,128,256]
          }
  
          Functions {
                  While loop:test_while_f32
                  For loop:test_for_f32
                  For loop and array:test_array_f32
          } -> PARAM1_ID
        }

        suite MicroBenchmarksQ31 {
          class = MicroBenchmarksQ31
          folder = BasicMathsQ31
  
          ParamList {
                    NB
                    Summary NB
                    Names "NB Samples"
                    Formula "NB"
          }
  
          Pattern INPUT1_Q31_ID : Input1_q31.txt 
          Pattern INPUT2_Q31_ID : Input2_q31.txt 
          Output  OUT_SAMPLES_Q31_ID : Output
  
          Params PARAM1_ID = {
                    A = [16,32,64,128,256]
          }
  
          Functions {
                  While loop:test_while_q31
                  For loop:test_for_q31
                  For loop and array:test_array_q31
          } -> PARAM1_ID
        }

        suite MicroBenchmarksQ15 {
          class = MicroBenchmarksQ15
          folder = BasicMathsQ15
  
          ParamList {
                    NB
                    Summary NB
                    Names "NB Samples"
                    Formula "NB"
          }
  
          Pattern INPUT1_Q15_ID : Input1_q15.txt 
          Pattern INPUT2_Q15_ID : Input2_q15.txt 
          Output  OUT_SAMPLES_Q15_ID : Output
  
          Params PARAM1_ID = {
                    A = [16,32,64,128,256]
          }
  
          Functions {
                  While loop:test_while_q15
                  For loop:test_for_q15
                  For loop and array:test_array_q15
          } -> PARAM1_ID
        }

        suite MicroBenchmarksQ7 {
          class = MicroBenchmarksQ7
          folder = BasicMathsQ7
  
          ParamList {
                    NB
                    Summary NB
                    Names "NB Samples"
                    Formula "NB"
          }
  
          Pattern INPUT1_Q7_ID : Input1_q7.txt 
          Pattern INPUT2_Q7_ID : Input2_q7.txt 
          Output  OUT_SAMPLES_Q7_ID : Output
  
          Params PARAM1_ID = {
                    A = [16,32,64,128,256]
          }
  
          Functions {
                  While loop:test_while_q7
                  For loop:test_for_q7
                  For loop and array:test_array_q7
          } -> PARAM1_ID
        }
      }
    }
}