1 #pragma once
2 
3 
4 extern "C" {
5 #include "arm_math_types.h"
6 #include "arm_math_types_f16.h"
7 #include "dsp/filtering_functions.h"
8 #include "dsp/matrix_functions.h"
9 #include "dsp/matrix_functions_f16.h"
10 
11 }
12 
13 template<typename T>
14 struct NameOfType;
15 
16 template<typename T>
17 struct TailForTests;
18 
19 template<>
20 struct NameOfType<float64_t>
21 {
22     constexpr static const char* v="float64_t";
23     constexpr static const char* xls="f64";
24 };
25 
26 template<>
27 struct NameOfType<float32_t>
28 {
29     constexpr static const char* v="float32_t";
30     constexpr static const char* xls="f32";
31 
32 };
33 
34 #if !defined(DISABLEFLOAT16)
35 template<>
36 struct NameOfType<float16_t>
37 {
38     constexpr static const char* v="float16_t";
39     constexpr static const char* xls="f16";
40 
41 };
42 #endif
43 
44 template<>
45 struct NameOfType<Q31>
46 {
47     constexpr static const char* v="q31";
48     constexpr static const char* xls="q31";
49 
50 };
51 
52 template<>
53 struct NameOfType<Q15>
54 {
55     constexpr static const char* v="q15";
56     constexpr static const char* xls="q15";
57 
58 };
59 
60 template<>
61 struct NameOfType<Q7>
62 {
63     constexpr static const char* v="q7";
64     constexpr static const char* xls="q7";
65 
66 };
67 
68 template<>
69 struct TailForTests<double>
70 {
71     constexpr static const int tail = 1;
72     constexpr static const int loop = 2;
73 
74 };
75 
76 template<>
77 struct TailForTests<float>
78 {
79     constexpr static const int tail = 3;
80     constexpr static const int loop = 2*4;
81 };
82 
83 #if !defined(DISABLEFLOAT16)
84 template<>
85 struct TailForTests<float16_t>
86 {
87     constexpr static const int tail = 7;
88     constexpr static const int loop = 2*8;
89 
90 };
91 #endif
92 
93 template<>
94 struct TailForTests<Q31>
95 {
96     constexpr static const int tail = 3;
97     constexpr static const int loop = 2*4;
98 };
99 
100 template<>
101 struct TailForTests<Q15>
102 {
103     constexpr static const int tail = 7;
104     constexpr static const int loop = 2*8;
105 };
106 
107 template<>
108 struct TailForTests<Q7>
109 {
110     constexpr static const int tail = 15;
111     constexpr static const int loop = 2*16;
112 };
113 
114 #include "common_tests.h"
115 
116 #if !defined(DISABLEFLOAT16)
117 extern void cmsisdsp_add(const float16_t* a,
118               const float16_t* b,
119                     float16_t* c,
120               uint32_t l);
121 #endif
122 
123 extern void cmsisdsp_add(const float64_t* a,
124               const float64_t* b,
125                     float64_t* c,
126               uint32_t l);
127 
128 extern void cmsisdsp_add(const float32_t* a,
129               const float32_t* b,
130                     float32_t* c,
131               uint32_t l);
132 
133 extern void cmsisdsp_add(const Q31* a,
134               const Q31* b,
135                     Q31* c,
136               uint32_t l);
137 
138 extern void cmsisdsp_add(const Q15* a,
139               const Q15* b,
140                     Q15* c,
141               uint32_t l);
142 
143 extern void cmsisdsp_add(const Q7* a,
144               const Q7* b,
145                     Q7* c,
146               uint32_t l);
147 
148 extern void cmsisdsp_mat_add(const float32_t* a,
149               const float32_t* b,
150                     float32_t* c,
151               uint32_t row,uint32_t col);
152 
153 #if !defined(DISABLEFLOAT16)
154 extern void cmsisdsp_mat_add(const float16_t* a,
155               const float16_t* b,
156                     float16_t* c,
157               uint32_t row,uint32_t col);
158 #endif
159 
160 extern void cmsisdsp_mat_add(const Q31* a,
161               const Q31* b,
162                     Q31* c,
163               uint32_t row,uint32_t col);
164 
165 extern void cmsisdsp_mat_add(const Q15* a,
166               const Q15* b,
167                     Q15* c,
168               uint32_t row,uint32_t col);
169 
170 extern void cmsisdsp_mat_add(const Q7* a,
171               const Q7* b,
172                     Q7* c,
173              uint32_t row,uint32_t col);
174 
175 #if !defined(DISABLEFLOAT16)
176 extern void cmsisdsp_dot(const float16_t* a,
177               const float16_t* b,
178                     float16_t &c,
179               uint32_t l);
180 #endif
181 
182 extern void cmsisdsp_dot(const float64_t* a,
183               const float64_t* b,
184                     float64_t &c,
185               uint32_t l);
186 
187 extern void cmsisdsp_dot(const float32_t* a,
188               const float32_t* b,
189                     float32_t &c,
190               uint32_t l);
191 
192 extern void cmsisdsp_dot(const Q31* a,
193               const Q31* b,
194                     Q<15,48> &c,
195               uint32_t l);
196 
197 extern void cmsisdsp_dot(const Q15* a,
198               const Q15* b,
199                     Q<33,30> &c,
200               uint32_t l);
201 
202 extern void cmsisdsp_dot(const Q7* a,
203               const Q7* b,
204                     Q<17,14> &c,
205               uint32_t l);
206 
207 extern void cmsisdsp_dot_expr(const double* a,
208                               const double* b,
209                               const double* c,
210                               const double* d,
211                               double* tmp1,
212                               double* tmp2,
213                               const double scale,
214                               double &r,
215                               uint32_t l);
216 
217 extern void cmsisdsp_dot_expr(const float32_t* a,
218                               const float32_t* b,
219                               const float32_t* c,
220                               const float32_t* d,
221                               float32_t* tmp1,
222                               float32_t* tmp2,
223                               const float32_t scale,
224                               float32_t &r,
225                               uint32_t l);
226 
227 #if !defined(DISABLEFLOAT16)
228 extern void cmsisdsp_dot_expr(const float16_t* a,
229                               const float16_t* b,
230                               const float16_t* c,
231                               const float16_t* d,
232                               float16_t* tmp1,
233                               float16_t* tmp2,
234                               const float16_t scale,
235                               float16_t &r,
236                               uint32_t l);
237 #endif
238 
239 extern void cmsisdsp_dot_expr(const Q7* a,
240                               const Q7* b,
241                               const Q7* c,
242                               const Q7* d,
243                               Q7* tmp1,
244                               Q7* tmp2,
245                               const Q7 scale,
246                               Q<17,14> &r,
247                               uint32_t l);
248 
249 extern void cmsisdsp_dot_expr(const Q15* a,
250                               const Q15* b,
251                               const Q15* c,
252                               const Q15* d,
253                               Q15* tmp1,
254                               Q15* tmp2,
255                               const Q15 scale,
256                               Q<33,30> &r,
257                               uint32_t l);
258 
259 extern void cmsisdsp_dot_expr(const Q31* a,
260                               const Q31* b,
261                               const Q31* c,
262                               const Q31* d,
263                               Q31* tmp1,
264                               Q31* tmp2,
265                               const Q31 scale,
266                               Q<15,48> &r,
267                               uint32_t l);
268 
269 extern void cmsisdsp_fir(const arm_fir_instance_f32 * S,
270                          const float32_t * pSrc,
271                          float32_t * pDst,
272                          uint32_t blockSize);
273 
274 extern void cmsisdsp_fir(const arm_fir_instance_q7 * S,
275                          const Q7 * pSrc,
276                          Q7 * pDst,
277                          uint32_t blockSize);
278 
279 extern void cmsisdsp_fir(const arm_fir_instance_q15 * S,
280                          const Q15 * pSrc,
281                          Q15 * pDst,
282                          uint32_t blockSize);
283 
284 extern void cmsisdsp_fir(const arm_fir_instance_q31 * S,
285                          const Q31 * pSrc,
286                          Q31 * pDst,
287                          uint32_t blockSize);
288 
289 template<typename T>
290 struct CMSISOuter {
291     static void run(const T *a,
292              const T *b,
293                    T *res,
294                    const uint32_t r,const uint32_t c)
295     {
296        DISABLE_LOOP_UNROLL
297        for(unsigned int row=0; row<r ; row ++ )
298        {
299            DISABLE_LOOP_UNROLL
300            for(unsigned int col=0; col<c ; col ++ )
301            {
302               res[row*c+col] = a[row]*b[col];
303            }
304        }
305     }
306 };
307 
308 #if defined(ARM_MATH_MVEI) || defined(ARM_MATH_MVEF)
309 extern void _cmsis_outer(const float32_t *a,
310                         const float32_t *b,
311                         float32_t *res,
312                         const uint32_t r,const uint32_t c);
313 
314 #if !defined(DISABLEFLOAT16)
315 extern void _cmsis_outer(const float16_t *a,
316                         const float16_t *b,
317                         float16_t *res,
318                         const uint32_t r,const uint32_t c);
319 #endif
320 
321 extern void _cmsis_outer(const Q7 *a,
322                         const Q7 *b,
323                         Q7 *res,
324                         const uint32_t r,const uint32_t c);
325 
326 extern void _cmsis_outer(const Q15 *a,
327                         const Q15 *b,
328                         Q15 *res,
329                         const uint32_t r,const uint32_t c);
330 
331 extern void _cmsis_outer(const Q31 *a,
332                         const Q31 *b,
333                         Q31 *res,
334                         const uint32_t r,const uint32_t c);
335 template<>
336 struct CMSISOuter<float32_t> {
337     static void run(const float32_t *a,
338              const float32_t *b,
339                    float32_t *res,
340             const uint32_t r,const uint32_t c)
341     {
342         _cmsis_outer(a,b,res,r,c);
343     }
344 };
345 
346 #if !defined(DISABLEFLOAT16)
347 template<>
348 struct CMSISOuter<float16_t> {
349     static void run(const float16_t *a,
350              const float16_t *b,
351                    float16_t *res,
352             const uint32_t r,const uint32_t c)
353     {
354         _cmsis_outer(a,b,res,r,c);
355     }
356 };
357 #endif
358 
359 template<>
360 struct CMSISOuter<Q31> {
361     static void run(const Q31 *a,
362              const Q31 *b,
363                    Q31 *res,
364             const uint32_t r,const uint32_t c)
365     {
366         _cmsis_outer(a,b,res,r,c);
367     }
368 };
369 
370 template<>
371 struct CMSISOuter<Q15> {
372     static void run(const Q15 *a,
373              const Q15 *b,
374                    Q15 *res,
375             const uint32_t r,const uint32_t c)
376     {
377         _cmsis_outer(a,b,res,r,c);
378     }
379 };
380 
381 template<>
382 struct CMSISOuter<Q7> {
383     static void run(const Q7 *a,
384              const Q7 *b,
385                    Q7 *res,
386             const uint32_t r,const uint32_t c)
387     {
388         _cmsis_outer(a,b,res,r,c);
389     }
390 };
391 
392 #endif
393 
394 extern void cmsis_init_householder(double *f,const int nb);
395 extern void cmsis_init_householder(float32_t *f,const int nb);
396 
397 #if !defined(DISABLEFLOAT16)
398 extern void cmsis_init_householder(float16_t *f,const int nb);
399 #endif
400 
401 extern void cmsis_init_qr(double *f,const int r,const int c);
402 extern void cmsis_init_qr(float32_t *f,const int r,const int c);
403 
404 #if !defined(DISABLEFLOAT16)
405 extern void cmsis_init_qr(float16_t *f,const int r,const int c);
406 #endif
407 
408 extern void cmsis_init_cholesky(double *f,const int r,const int c);
409 extern void cmsis_init_cholesky(float32_t *f,const int r,const int c);
410 
411 #if !defined(DISABLEFLOAT16)
412 extern void cmsis_init_cholesky(float16_t *f,const int r,const int c);
413 #endif
414 
415 extern void cmsis_mat_mult(const arm_matrix_instance_f64* a,
416                            const arm_matrix_instance_f64* b,
417                                  arm_matrix_instance_f64 *c,
418                                  double *pState);
419 
420 extern void cmsis_mat_mult(const arm_matrix_instance_f32* a,
421                            const arm_matrix_instance_f32* b,
422                                  arm_matrix_instance_f32 *c,
423                                  float32_t *pState);
424 #if !defined(DISABLEFLOAT16)
425 extern void cmsis_mat_mult(const arm_matrix_instance_f16* a,
426                            const arm_matrix_instance_f16* b,
427                                  arm_matrix_instance_f16 *c,
428                                  float16_t *pState);
429 #endif
430 
431 extern void cmsis_mat_mult(const arm_matrix_instance_q7* a,
432                            const arm_matrix_instance_q7* b,
433                                  arm_matrix_instance_q7 *c,
434                                  q7_t *pState);
435 
436 extern void cmsis_mat_mult(const arm_matrix_instance_q15* a,
437                            const arm_matrix_instance_q15* b,
438                                  arm_matrix_instance_q15 *c,
439                                  q15_t *pState);
440 
441 extern void cmsis_mat_mult(const arm_matrix_instance_q31* a,
442                            const arm_matrix_instance_q31* b,
443                                  arm_matrix_instance_q31 *c,
444                                  q31_t *pState);
445 
446 extern void cmsis_mat_trans(const arm_matrix_instance_q7* a,
447                             arm_matrix_instance_q7* b);
448 
449 extern void cmsis_mat_trans(const arm_matrix_instance_q15* a,
450                             arm_matrix_instance_q15* b);
451 
452 extern void cmsis_mat_trans(const arm_matrix_instance_q31* a,
453                             arm_matrix_instance_q31* b);
454 
455 #if !defined(DISABLEFLOAT16)
456 extern void cmsis_mat_trans(const arm_matrix_instance_f16* a,
457                             arm_matrix_instance_f16* b);
458 #endif
459 
460 extern void cmsis_mat_trans(const arm_matrix_instance_f64* a,
461                             arm_matrix_instance_f64* b);
462 
463 extern void cmsis_mat_trans(const arm_matrix_instance_f32* a,
464                             arm_matrix_instance_f32* b);
465 
466 extern double cmsis_householder(const double *,double* ,uint32_t);
467 
468 extern float32_t cmsis_householder(const float32_t *,float32_t* ,uint32_t);
469 
470 #if !defined(DISABLEFLOAT16)
471 extern float16_t cmsis_householder(const float16_t *,float16_t* ,uint32_t);
472 #endif
473 
474 extern void cmsis_mat_vec_mult(
475   const arm_matrix_instance_f64 *pSrcMat,
476   const double *pVec,
477   double *pDst);
478 
479 extern void cmsis_mat_vec_mult(
480   const arm_matrix_instance_f32 *pSrcMat,
481   const float32_t *pVec,
482   float32_t *pDst);
483 
484 #if !defined(DISABLEFLOAT16)
485 extern void cmsis_mat_vec_mult(
486   const arm_matrix_instance_f16 *pSrcMat,
487   const float16_t *pVec,
488   float16_t *pDst);
489 #endif
490 
491 extern void cmsis_mat_vec_mult(
492   const arm_matrix_instance_q31 *pSrcMat,
493   const Q31 *pVec,
494   Q31 *pDst);
495 
496 extern void cmsis_mat_vec_mult(
497   const arm_matrix_instance_q15 *pSrcMat,
498   const Q15 *pVec,
499   Q15 *pDst);
500 
501 extern void cmsis_mat_vec_mult(
502   const arm_matrix_instance_q7 *pSrcMat,
503   const Q7 *pVec,
504   Q7 *pDst);
505 
506 extern arm_status cmsis_qr(
507     const arm_matrix_instance_f64 * pSrc,
508     const double threshold,
509     arm_matrix_instance_f64 * pOutR,
510     arm_matrix_instance_f64 * pOutQ,
511     double * pOutTau,
512     double *pTmpA,
513     double *pTmpB
514     );
515 
516 extern arm_status cmsis_qr(
517     const arm_matrix_instance_f32 * pSrc,
518     const float32_t threshold,
519     arm_matrix_instance_f32 * pOutR,
520     arm_matrix_instance_f32 * pOutQ,
521     float32_t * pOutTau,
522     float32_t *pTmpA,
523     float32_t *pTmpB
524     );
525 
526 #if !defined(DISABLEFLOAT16)
527 extern arm_status cmsis_qr(
528     const arm_matrix_instance_f16 * pSrc,
529     const float16_t threshold,
530     arm_matrix_instance_f16 * pOutR,
531     arm_matrix_instance_f16 * pOutQ,
532     float16_t * pOutTau,
533     float16_t *pTmpA,
534     float16_t *pTmpB
535     );
536 #endif
537 
538 extern arm_status cmsis_cholesky(
539   const arm_matrix_instance_f64 * src,
540   arm_matrix_instance_f64 * dst);
541 
542 extern arm_status cmsis_cholesky(
543   const arm_matrix_instance_f32 * src,
544   arm_matrix_instance_f32 * dst);
545 
546 #if !defined(DISABLEFLOAT16)
547 extern arm_status cmsis_cholesky(
548   const arm_matrix_instance_f16 * src,
549   arm_matrix_instance_f16 * dst);
550 #endif
551 
552 extern void cmsis_complex_mat_vec(
553   const arm_matrix_instance_f64 * src,
554   const double * a,
555   const double * b,
556   const double scalar,
557   double * tmp,
558   double * dst);
559 
560 extern void cmsis_complex_mat_vec(
561   const arm_matrix_instance_f32 * src,
562   const float32_t * a,
563   const float32_t * b,
564   const float32_t scalar,
565   float32_t * tmp,
566   float32_t * dst);
567 
568 #if !defined(DISABLEFLOAT16)
569 extern void cmsis_complex_mat_vec(
570   const arm_matrix_instance_f16 * src,
571   const float16_t * a,
572   const float16_t * b,
573   const float16_t scalar,
574   float16_t * tmp,
575   float16_t * dst);
576 #endif
577 
578 extern void cmsis_complex_mat_vec(
579   const arm_matrix_instance_q31 * src,
580   const Q31 * a,
581   const Q31 * b,
582   const Q31 scalar,
583   Q31 * tmp,
584   Q31 * dst);
585 
586 extern void cmsis_complex_mat_vec(
587   const arm_matrix_instance_q15 * src,
588   const Q15 * a,
589   const Q15 * b,
590   const Q15 scalar,
591   Q15 * tmp,
592   Q15 * dst);
593 
594 extern void cmsis_complex_mat_vec(
595   const arm_matrix_instance_q7 * src,
596   const Q7 * a,
597   const Q7 * b,
598   const Q7 scalar,
599   Q7 * tmp,
600   Q7 * dst);
601 
602 template<typename T>
603 struct CMSISMatrixType;
604 
605 template<>
606 struct CMSISMatrixType<double>
607 {
608    typedef arm_matrix_instance_f64 type;
609    typedef double scalar;
610 };
611 
612 template<>
613 struct CMSISMatrixType<float32_t>
614 {
615    typedef arm_matrix_instance_f32 type;
616    typedef float32_t scalar;
617 };
618 
619 #if !defined(DISABLEFLOAT16)
620 template<>
621 struct CMSISMatrixType<float16_t>
622 {
623    typedef arm_matrix_instance_f16 type;
624    typedef float16_t scalar;
625 };
626 #endif
627 
628 template<>
629 struct CMSISMatrixType<Q7>
630 {
631    typedef arm_matrix_instance_q7 type;
632    typedef q7_t scalar;
633 
634 };
635 
636 template<>
637 struct CMSISMatrixType<Q15>
638 {
639    typedef arm_matrix_instance_q15 type;
640    typedef q15_t scalar;
641 
642 };
643 
644 template<>
645 struct CMSISMatrixType<Q31>
646 {
647    typedef arm_matrix_instance_q31 type;
648    typedef q31_t scalar;
649 
650 };
651 
652 template<typename T>
653 struct TestConstant;
654 
655 template<>
656 struct TestConstant<double>
657 {
658    constexpr static double v = 0.2;
659    constexpr static double small = 0.001;
660 };
661 
662 template<>
663 struct TestConstant<float32_t>
664 {
665    constexpr static float v = 0.2f;
666    constexpr static float small = 0.001f;
667 };
668 
669 #if !defined(DISABLEFLOAT16)
670 template<>
671 struct TestConstant<float16_t>
672 {
673    constexpr static float16_t v = 0.2f;
674    constexpr static float16_t small = 0.001f;
675 
676 };
677 #endif
678 
679 template<>
680 struct TestConstant<Q7>
681 {
682    constexpr static Q7 v = 0.2_q7;
683    constexpr static Q7 small = 0.001_q7;
684 };
685 
686 
687 template<>
688 struct TestConstant<Q15>
689 {
690    constexpr static Q15 v = 0.2_q15;
691    constexpr static Q15 small = 0.001_q15;
692 };
693 
694 template<>
695 struct TestConstant<Q31>
696 {
697    constexpr static Q31 v = 0.2_q31;
698    constexpr static Q31 small = 0.001_q31;
699 };