1 #include "UnaryTestsF16.h"
2 #include <stdio.h>
3 #include "Error.h"
4
5 #define SNR_THRESHOLD 57
6
7 /*
8
9 Reference patterns are generated with
10 a double precision computation.
11
12 */
13 #define REL_ERROR (1.1e-3)
14 #define ABS_ERROR (1.1e-3)
15
16 /*
17
18 Comparisons for QR
19
20 */
21
22 #define SNR_QR_THRESHOLD 20
23 #define REL_QR_ERROR (3.0e-2)
24 #define ABS_QR_ERROR (3.0e-2)
25
26 /*
27
28 Comparisons for inverse
29
30 */
31
32 /* Not very accurate for big matrix.
33 But big matrix needed for checking the vectorized code */
34
35 #define SNR_THRESHOLD_INV 51
36 #define REL_ERROR_INV (3.0e-3)
37 #define ABS_ERROR_INV (2.0e-2)
38
39 #define REL_ERROR_SOLVE (6.0e-2)
40 #define ABS_ERROR_SOLVE (2.0e-2)
41
42 /*
43
44 Comparison for Cholesky
45
46 */
47 #define SNR_THRESHOLD_CHOL 45
48 #define REL_ERROR_CHOL (3.0e-3)
49 #define ABS_ERROR_CHOL (3.0e-2)
50
51 /* Upper bound of maximum matrix dimension used by Python */
52 #define MAXMATRIXDIM 40
53
54 #define LOADDATA2() \
55 const float16_t *inp1=input1.ptr(); \
56 const float16_t *inp2=input2.ptr(); \
57 \
58 float16_t *ap=a.ptr(); \
59 float16_t *bp=b.ptr(); \
60 \
61 float16_t *outp=output.ptr(); \
62 int16_t *dimsp = dims.ptr(); \
63 int nbMatrixes = dims.nbSamples() >> 1;\
64 int rows,columns; \
65 int i;
66
67 #define LOADDATA1() \
68 const float16_t *inp1=input1.ptr(); \
69 \
70 float16_t *ap=a.ptr(); \
71 \
72 float16_t *outp=output.ptr(); \
73 int16_t *dimsp = dims.ptr(); \
74 int nbMatrixes = dims.nbSamples() >> 1;\
75 int rows,columns; \
76 int i;
77
78 #define PREPAREDATA2() \
79 in1.numRows=rows; \
80 in1.numCols=columns; \
81 memcpy((void*)ap,(const void*)inp1,sizeof(float16_t)*rows*columns);\
82 in1.pData = ap; \
83 \
84 in2.numRows=rows; \
85 in2.numCols=columns; \
86 memcpy((void*)bp,(const void*)inp2,sizeof(float16_t)*rows*columns);\
87 in2.pData = bp; \
88 \
89 out.numRows=rows; \
90 out.numCols=columns; \
91 out.pData = outp;
92
93 #define PREPAREDATALT() \
94 in1.numRows=rows; \
95 in1.numCols=rows; \
96 memcpy((void*)ap,(const void*)inp1,sizeof(float16_t)*rows*rows); \
97 in1.pData = ap; \
98 \
99 in2.numRows=rows; \
100 in2.numCols=columns; \
101 memcpy((void*)bp,(const void*)inp2,sizeof(float16_t)*rows*columns);\
102 in2.pData = bp; \
103 \
104 out.numRows=rows; \
105 out.numCols=columns; \
106 out.pData = outp;
107
108 #define PREPAREDATA1(TRANSPOSED) \
109 in1.numRows=rows; \
110 in1.numCols=columns; \
111 memcpy((void*)ap,(const void*)inp1,sizeof(float16_t)*rows*columns);\
112 in1.pData = ap; \
113 \
114 if (TRANSPOSED) \
115 { \
116 out.numRows=columns; \
117 out.numCols=rows; \
118 } \
119 else \
120 { \
121 out.numRows=rows; \
122 out.numCols=columns; \
123 } \
124 out.pData = outp;
125
126 #define PREPAREDATA1C(TRANSPOSED) \
127 in1.numRows=rows; \
128 in1.numCols=columns; \
129 memcpy((void*)ap,(const void*)inp1,2*sizeof(float16_t)*rows*columns);\
130 in1.pData = ap; \
131 \
132 if (TRANSPOSED) \
133 { \
134 out.numRows=columns; \
135 out.numCols=rows; \
136 } \
137 else \
138 { \
139 out.numRows=rows; \
140 out.numCols=columns; \
141 } \
142 out.pData = outp;
143
144 #define LOADVECDATA2() \
145 const float16_t *inp1=input1.ptr(); \
146 const float16_t *inp2=input2.ptr(); \
147 \
148 float16_t *ap=a.ptr(); \
149 float16_t *bp=b.ptr(); \
150 \
151 float16_t *outp=output.ptr(); \
152 int16_t *dimsp = dims.ptr(); \
153 int nbMatrixes = dims.nbSamples() / 2;\
154 int rows,internal; \
155 int i;
156
157 #define PREPAREVECDATA2() \
158 in1.numRows=rows; \
159 in1.numCols=internal; \
160 memcpy((void*)ap,(const void*)inp1,sizeof(float16_t)*rows*internal);\
161 in1.pData = ap; \
162 \
163 memcpy((void*)bp,(const void*)inp2,sizeof(float16_t)*internal);
164
165
checkInnerTailOverflow(float16_t * b)166 static void checkInnerTailOverflow(float16_t *b)
167 {
168 ASSERT_TRUE(b[0] == 0);
169 ASSERT_TRUE(b[1] == 0);
170 ASSERT_TRUE(b[2] == 0);
171 ASSERT_TRUE(b[3] == 0);
172 ASSERT_TRUE(b[4] == 0);
173 ASSERT_TRUE(b[5] == 0);
174 ASSERT_TRUE(b[6] == 0);
175 ASSERT_TRUE(b[7] == 0);
176 }
177
178
test_householder_f16()179 void UnaryTestsF16::test_householder_f16()
180 {
181 int16_t vecDim;
182 const int16_t *dimsp = dims.ptr();
183 const int nbVectors = dims.nbSamples();
184 const float16_t *inp1=input1.ptr();
185
186 float16_t *outp=output.ptr();
187 float16_t *outBetap=outputBeta.ptr();
188
189
190 for(int i=0; i < nbVectors ; i++)
191 {
192 vecDim = *dimsp++;
193
194 float16_t beta = arm_householder_f16(inp1,DEFAULT_HOUSEHOLDER_THRESHOLD_F16,vecDim,outp);
195 *outBetap = beta;
196
197 outp += vecDim;
198 inp1 += vecDim;
199 outBetap++;
200 checkInnerTailOverflow(outp);
201 checkInnerTailOverflow(outBetap);
202
203 }
204
205 ASSERT_EMPTY_TAIL(output);
206 ASSERT_EMPTY_TAIL(outputBeta);
207
208 ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD);
209 ASSERT_SNR(outputBeta,refBeta,(float16_t)SNR_THRESHOLD);
210
211 ASSERT_CLOSE_ERROR(output,ref,ABS_ERROR,REL_ERROR);
212 ASSERT_CLOSE_ERROR(outputBeta,refBeta,ABS_ERROR,REL_ERROR);
213
214
215 }
216
test_mat_qr_f16()217 void UnaryTestsF16::test_mat_qr_f16()
218 {
219 int16_t rows, columns, rank;
220 const int16_t *dimsp = dims.ptr();
221 const int nbMatrixes = dims.nbSamples() / 3;
222 const float16_t *inp1=input1.ptr();
223
224 float16_t *outTaup=outputTau.ptr();
225 float16_t *outRp=outputR.ptr();
226 float16_t *outQp=outputQ.ptr();
227 float16_t *pTmpA=a.ptr();
228 float16_t *pTmpB=b.ptr();
229
230 (void) outTaup;
231 (void) outRp;
232
233 for(int i=0; i < nbMatrixes ; i++)
234 {
235 rows = *dimsp++;
236 columns = *dimsp++;
237 rank = *dimsp++;
238 (void)rank;
239
240
241 in1.numRows=rows;
242 in1.numCols=columns;
243 in1.pData = (float16_t*)inp1;
244
245
246 outR.numRows = rows;
247 outR.numCols = columns;
248 outR.pData = (float16_t*)outRp;
249
250 outQ.numRows = rows;
251 outQ.numCols = rows;
252 outQ.pData = (float16_t*)outQp;
253
254 arm_status status=arm_mat_qr_f16(&in1,DEFAULT_HOUSEHOLDER_THRESHOLD_F16,&outR,&outQ,outTaup,pTmpA,pTmpB);
255 ASSERT_TRUE(status==ARM_MATH_SUCCESS);
256
257
258 inp1 += rows * columns;
259 outRp += rows * columns;
260 outQp += rows * rows;
261 outTaup += columns;
262
263 checkInnerTailOverflow(outRp);
264 checkInnerTailOverflow(outQp);
265 checkInnerTailOverflow(outTaup);
266
267
268 }
269
270 ASSERT_EMPTY_TAIL(outputR);
271 ASSERT_EMPTY_TAIL(outputQ);
272 ASSERT_EMPTY_TAIL(outputTau);
273
274 //ASSERT_SNR(refQ,outputQ,(float16_t)SNR_QR_THRESHOLD);
275 //ASSERT_SNR(refR,outputR,(float16_t)SNR_QR_THRESHOLD);
276 //ASSERT_SNR(refTau,outputTau,(float16_t)SNR_QR_THRESHOLD);
277
278 ASSERT_CLOSE_ERROR(refQ,outputQ,ABS_QR_ERROR,REL_QR_ERROR);
279 ASSERT_CLOSE_ERROR(refR,outputR,ABS_QR_ERROR,REL_QR_ERROR);
280 ASSERT_CLOSE_ERROR(refTau,outputTau,ABS_QR_ERROR,REL_QR_ERROR);
281 }
282
test_mat_vec_mult_f16()283 void UnaryTestsF16::test_mat_vec_mult_f16()
284 {
285 LOADVECDATA2();
286
287 for(i=0;i < nbMatrixes ; i ++)
288 {
289 rows = *dimsp++;
290 internal = *dimsp++;
291
292 PREPAREVECDATA2();
293
294 arm_mat_vec_mult_f16(&this->in1, bp, outp);
295
296 outp += rows ;
297
298 }
299
300 ASSERT_EMPTY_TAIL(output);
301
302 ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD);
303
304 ASSERT_CLOSE_ERROR(output,ref,ABS_ERROR,REL_ERROR);
305
306 }
307
test_mat_add_f16()308 void UnaryTestsF16::test_mat_add_f16()
309 {
310 LOADDATA2();
311 arm_status status;
312
313 for(i=0;i < nbMatrixes ; i ++)
314 {
315 rows = *dimsp++;
316 columns = *dimsp++;
317
318 PREPAREDATA2();
319
320 status=arm_mat_add_f16(&this->in1,&this->in2,&this->out);
321 ASSERT_TRUE(status==ARM_MATH_SUCCESS);
322
323 outp += (rows * columns);
324
325 }
326
327 ASSERT_EMPTY_TAIL(output);
328
329 ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD);
330
331 ASSERT_CLOSE_ERROR(output,ref,ABS_ERROR,REL_ERROR);
332
333 }
334
test_mat_sub_f16()335 void UnaryTestsF16::test_mat_sub_f16()
336 {
337 LOADDATA2();
338 arm_status status;
339
340 for(i=0;i < nbMatrixes ; i ++)
341 {
342 rows = *dimsp++;
343 columns = *dimsp++;
344
345 PREPAREDATA2();
346
347 status=arm_mat_sub_f16(&this->in1,&this->in2,&this->out);
348 ASSERT_TRUE(status==ARM_MATH_SUCCESS);
349
350 outp += (rows * columns);
351
352 }
353
354 ASSERT_EMPTY_TAIL(output);
355
356 ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD);
357
358 ASSERT_CLOSE_ERROR(output,ref,ABS_ERROR,REL_ERROR);
359
360 }
361
test_mat_scale_f16()362 void UnaryTestsF16::test_mat_scale_f16()
363 {
364 LOADDATA1();
365 arm_status status;
366
367 for(i=0;i < nbMatrixes ; i ++)
368 {
369 rows = *dimsp++;
370 columns = *dimsp++;
371
372 PREPAREDATA1(false);
373
374 status=arm_mat_scale_f16(&this->in1,0.5f,&this->out);
375 ASSERT_TRUE(status==ARM_MATH_SUCCESS);
376
377 outp += (rows * columns);
378
379 }
380
381 ASSERT_EMPTY_TAIL(output);
382
383 ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD);
384
385 ASSERT_CLOSE_ERROR(output,ref,ABS_ERROR,REL_ERROR);
386
387 }
388
test_mat_trans_f16()389 void UnaryTestsF16::test_mat_trans_f16()
390 {
391 LOADDATA1();
392 arm_status status;
393
394 for(i=0;i < nbMatrixes ; i ++)
395 {
396 rows = *dimsp++;
397 columns = *dimsp++;
398
399 PREPAREDATA1(true);
400
401 status=arm_mat_trans_f16(&this->in1,&this->out);
402 ASSERT_TRUE(status==ARM_MATH_SUCCESS);
403
404 outp += (rows * columns);
405
406 }
407
408 ASSERT_EMPTY_TAIL(output);
409
410 ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD);
411
412 ASSERT_CLOSE_ERROR(output,ref,ABS_ERROR,REL_ERROR);
413
414 }
415
test_mat_cmplx_trans_f16()416 void UnaryTestsF16::test_mat_cmplx_trans_f16()
417 {
418 LOADDATA1();
419 arm_status status;
420
421 for(i=0;i < nbMatrixes ; i ++)
422 {
423 rows = *dimsp++;
424 columns = *dimsp++;
425
426 PREPAREDATA1C(true);
427
428 status=arm_mat_cmplx_trans_f16(&this->in1,&this->out);
429 ASSERT_TRUE(status==ARM_MATH_SUCCESS);
430
431 outp += 2*(rows * columns);
432
433 }
434
435 ASSERT_EMPTY_TAIL(output);
436
437 ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD);
438
439 ASSERT_CLOSE_ERROR(output,ref,ABS_ERROR,REL_ERROR);
440
441 }
442
refInnerTail(float16_t * b)443 static void refInnerTail(float16_t *b)
444 {
445 b[0] = 1.0f;
446 b[1] = -2.0f;
447 b[2] = 3.0f;
448 b[3] = -4.0f;
449 }
450
checkInnerTail(float16_t * b)451 static void checkInnerTail(float16_t *b)
452 {
453 ASSERT_TRUE(b[0] == 1.0f);
454 ASSERT_TRUE(b[1] == -2.0f);
455 ASSERT_TRUE(b[2] == 3.0f);
456 ASSERT_TRUE(b[3] == -4.0f);
457 }
458
test_mat_inverse_f16()459 void UnaryTestsF16::test_mat_inverse_f16()
460 {
461 const float16_t *inp1=input1.ptr();
462
463 float16_t *ap=a.ptr();
464
465 float16_t *outp=output.ptr();
466 int16_t *dimsp = dims.ptr();
467 int nbMatrixes = dims.nbSamples();
468 int rows,columns;
469 int i;
470 arm_status status;
471
472 // Non singular matrixes
473 // Last matrix is singular
474 for(i=0;i < nbMatrixes-1 ; i ++)
475 {
476 rows = *dimsp++;
477 columns = rows;
478
479 PREPAREDATA1(false);
480
481 refInnerTail(outp+(rows * columns));
482
483 status=arm_mat_inverse_f16(&this->in1,&this->out);
484 ASSERT_TRUE(status==ARM_MATH_SUCCESS);
485
486 outp += (rows * columns);
487 inp1 += (rows * columns);
488
489 checkInnerTail(outp);
490
491 }
492 /*** Singular matrix **/
493 rows = *dimsp++;
494 columns = rows;
495
496 PREPAREDATA1(false);
497
498 refInnerTail(outp+(rows * columns));
499
500 status=arm_mat_inverse_f16(&this->in1,&this->out);
501 ASSERT_TRUE(status==ARM_MATH_SINGULAR);
502
503 outp += (rows * columns);
504 inp1 += (rows * columns);
505
506 checkInnerTail(outp);
507 /**********************/
508
509
510 ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD_INV);
511
512 ASSERT_CLOSE_ERROR(output,ref,ABS_ERROR_INV,REL_ERROR_INV);
513
514 }
515
test_mat_cholesky_dpo_f16()516 void UnaryTestsF16::test_mat_cholesky_dpo_f16()
517 {
518 float16_t *ap=a.ptr();
519 const float16_t *inp1=input1.ptr();
520
521
522 float16_t *outp=output.ptr();
523 int16_t *dimsp = dims.ptr();
524 int nbMatrixes = dims.nbSamples();
525
526 int rows,columns;
527 int i;
528 arm_status status;
529
530 for(i=0;i < nbMatrixes ; i ++)
531 {
532 rows = *dimsp++;
533 columns = rows;
534
535 PREPAREDATA1(false);
536
537 status=arm_mat_cholesky_f16(&this->in1,&this->out);
538 ASSERT_TRUE(status==ARM_MATH_SUCCESS);
539
540 outp += (rows * columns);
541 inp1 += (rows * columns);
542
543 }
544
545 ASSERT_EMPTY_TAIL(output);
546
547 ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD_CHOL);
548
549 ASSERT_CLOSE_ERROR(ref,output,ABS_ERROR_CHOL,REL_ERROR_CHOL);
550 }
551
test_solve_upper_triangular_f16()552 void UnaryTestsF16::test_solve_upper_triangular_f16()
553 {
554 float16_t *ap=a.ptr();
555 const float16_t *inp1=input1.ptr();
556
557 float16_t *bp=b.ptr();
558 const float16_t *inp2=input2.ptr();
559
560
561 float16_t *outp=output.ptr();
562 int16_t *dimsp = dims.ptr();
563 int nbMatrixes = dims.nbSamples() >> 1;
564
565 int rows,columns;
566 int i;
567 arm_status status;
568
569 for(i=0;i < nbMatrixes ; i ++)
570 {
571 rows = *dimsp++;
572 columns = *dimsp++;
573
574 PREPAREDATALT();
575
576 status=arm_mat_solve_upper_triangular_f16(&this->in1,&this->in2,&this->out);
577 ASSERT_TRUE(status==ARM_MATH_SUCCESS);
578
579 outp += (rows * columns);
580 inp1 += (rows * rows);
581 inp2 += (rows * columns);
582
583
584 }
585
586 ASSERT_EMPTY_TAIL(output);
587
588 ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD);
589
590 ASSERT_CLOSE_ERROR(ref,output,ABS_ERROR_SOLVE,REL_ERROR_SOLVE);
591 }
592
test_solve_lower_triangular_f16()593 void UnaryTestsF16::test_solve_lower_triangular_f16()
594 {
595 float16_t *ap=a.ptr();
596 const float16_t *inp1=input1.ptr();
597
598 float16_t *bp=b.ptr();
599 const float16_t *inp2=input2.ptr();
600
601
602 float16_t *outp=output.ptr();
603 int16_t *dimsp = dims.ptr();
604 int nbMatrixes = dims.nbSamples()>>1;
605
606 int rows,columns;
607 int i;
608 arm_status status;
609
610 for(i=0;i < nbMatrixes ; i ++)
611 {
612 rows = *dimsp++;
613 columns = *dimsp++;
614
615 PREPAREDATALT();
616
617 status=arm_mat_solve_lower_triangular_f16(&this->in1,&this->in2,&this->out);
618 ASSERT_TRUE(status==ARM_MATH_SUCCESS);
619
620 outp += (rows * columns);
621 inp1 += (rows * rows);
622 inp2 += (rows * columns);
623
624 }
625
626 ASSERT_EMPTY_TAIL(output);
627
628 ASSERT_SNR(output,ref,(float16_t)SNR_THRESHOLD);
629
630 ASSERT_CLOSE_ERROR(ref,output,ABS_ERROR_SOLVE,REL_ERROR_SOLVE);
631 }
632
setUp(Testing::testID_t id,std::vector<Testing::param_t> & params,Client::PatternMgr * mgr)633 void UnaryTestsF16::setUp(Testing::testID_t id,std::vector<Testing::param_t>& params,Client::PatternMgr *mgr)
634 {
635
636
637 (void)params;
638 switch(id)
639 {
640 case TEST_MAT_ADD_F16_1:
641 input1.reload(UnaryTestsF16::INPUTS1_F16_ID,mgr);
642 input2.reload(UnaryTestsF16::INPUTS2_F16_ID,mgr);
643 dims.reload(UnaryTestsF16::DIMSUNARY1_S16_ID,mgr);
644
645 ref.reload(UnaryTestsF16::REFADD1_F16_ID,mgr);
646
647 output.create(ref.nbSamples(),UnaryTestsF16::OUT_F16_ID,mgr);
648 a.create(MAXMATRIXDIM*MAXMATRIXDIM,UnaryTestsF16::TMPA_F16_ID,mgr);
649 b.create(MAXMATRIXDIM*MAXMATRIXDIM,UnaryTestsF16::TMPB_F16_ID,mgr);
650 break;
651
652 case TEST_MAT_SUB_F16_2:
653 input1.reload(UnaryTestsF16::INPUTS1_F16_ID,mgr);
654 input2.reload(UnaryTestsF16::INPUTS2_F16_ID,mgr);
655 dims.reload(UnaryTestsF16::DIMSUNARY1_S16_ID,mgr);
656
657 ref.reload(UnaryTestsF16::REFSUB1_F16_ID,mgr);
658
659 output.create(ref.nbSamples(),UnaryTestsF16::OUT_F16_ID,mgr);
660 a.create(MAXMATRIXDIM*MAXMATRIXDIM,UnaryTestsF16::TMPA_F16_ID,mgr);
661 b.create(MAXMATRIXDIM*MAXMATRIXDIM,UnaryTestsF16::TMPB_F16_ID,mgr);
662 break;
663
664 case TEST_MAT_SCALE_F16_3:
665 input1.reload(UnaryTestsF16::INPUTS1_F16_ID,mgr);
666 dims.reload(UnaryTestsF16::DIMSUNARY1_S16_ID,mgr);
667
668 ref.reload(UnaryTestsF16::REFSCALE1_F16_ID,mgr);
669
670 output.create(ref.nbSamples(),UnaryTestsF16::OUT_F16_ID,mgr);
671 a.create(MAXMATRIXDIM*MAXMATRIXDIM,UnaryTestsF16::TMPA_F16_ID,mgr);
672 break;
673
674 case TEST_MAT_TRANS_F16_4:
675 input1.reload(UnaryTestsF16::INPUTS1_F16_ID,mgr);
676 dims.reload(UnaryTestsF16::DIMSUNARY1_S16_ID,mgr);
677
678 ref.reload(UnaryTestsF16::REFTRANS1_F16_ID,mgr);
679
680 output.create(ref.nbSamples(),UnaryTestsF16::OUT_F16_ID,mgr);
681 a.create(MAXMATRIXDIM*MAXMATRIXDIM,UnaryTestsF16::TMPA_F16_ID,mgr);
682 break;
683
684 case TEST_MAT_INVERSE_F16_5:
685 input1.reload(UnaryTestsF16::INPUTSINV_F16_ID,mgr);
686 dims.reload(UnaryTestsF16::DIMSINVERT1_S16_ID,mgr);
687
688 ref.reload(UnaryTestsF16::REFINV1_F16_ID,mgr);
689
690 output.create(ref.nbSamples(),UnaryTestsF16::OUT_F16_ID,mgr);
691 a.create(MAXMATRIXDIM*MAXMATRIXDIM,UnaryTestsF16::TMPA_F16_ID,mgr);
692 break;
693
694 case TEST_MAT_VEC_MULT_F16_6:
695 input1.reload(UnaryTestsF16::INPUTS1_F16_ID,mgr);
696 input2.reload(UnaryTestsF16::INPUTVEC1_F16_ID,mgr);
697 dims.reload(UnaryTestsF16::DIMSUNARY1_S16_ID,mgr);
698
699 ref.reload(UnaryTestsF16::REFVECMUL1_F16_ID,mgr);
700
701 output.create(ref.nbSamples(),UnaryTestsF16::OUT_F16_ID,mgr);
702 a.create(MAXMATRIXDIM*MAXMATRIXDIM,UnaryTestsF16::TMPA_F16_ID,mgr);
703 b.create(MAXMATRIXDIM,UnaryTestsF16::TMPB_F16_ID,mgr);
704 break;
705
706 case TEST_MAT_CMPLX_TRANS_F16_7:
707 input1.reload(UnaryTestsF16::INPUTSC1_F16_ID,mgr);
708 dims.reload(UnaryTestsF16::DIMSUNARY1_S16_ID,mgr);
709
710 ref.reload(UnaryTestsF16::REFTRANSC1_F16_ID,mgr);
711
712 output.create(ref.nbSamples(),UnaryTestsF16::OUT_F16_ID,mgr);
713 a.create(MAXMATRIXDIM*MAXMATRIXDIM,UnaryTestsF16::TMPA_F16_ID,mgr);
714 break;
715
716 case TEST_MAT_CHOLESKY_DPO_F16_8:
717 input1.reload(UnaryTestsF16::INPUTSCHOLESKY1_DPO_F16_ID,mgr);
718 dims.reload(UnaryTestsF16::DIMSCHOLESKY1_DPO_S16_ID,mgr);
719
720 ref.reload(UnaryTestsF16::REFCHOLESKY1_DPO_F16_ID,mgr);
721
722 output.create(ref.nbSamples(),UnaryTestsF16::OUT_F16_ID,mgr);
723 a.create(MAXMATRIXDIM*MAXMATRIXDIM,UnaryTestsF16::TMPA_F16_ID,mgr);
724 break;
725
726 case TEST_SOLVE_UPPER_TRIANGULAR_F16_9:
727 input1.reload(UnaryTestsF16::INPUT_MAT_UTSOLVE_F16_ID,mgr);
728 input2.reload(UnaryTestsF16::INPUT_VEC_LTSOLVE_F16_ID,mgr);
729 dims.reload(UnaryTestsF16::DIM_LTSOLVE_F16_ID,mgr);
730
731 ref.reload(UnaryTestsF16::REF_UT_SOLVE_F16_ID,mgr);
732
733 output.create(ref.nbSamples(),UnaryTestsF16::OUT_F16_ID,mgr);
734 a.create(MAXMATRIXDIM*MAXMATRIXDIM,UnaryTestsF16::TMPA_F16_ID,mgr);
735 b.create(MAXMATRIXDIM*MAXMATRIXDIM,UnaryTestsF16::TMPB_F16_ID,mgr);
736 break;
737
738 case TEST_SOLVE_LOWER_TRIANGULAR_F16_10:
739 input1.reload(UnaryTestsF16::INPUT_MAT_LTSOLVE_F16_ID,mgr);
740 input2.reload(UnaryTestsF16::INPUT_VEC_LTSOLVE_F16_ID,mgr);
741 dims.reload(UnaryTestsF16::DIM_LTSOLVE_F16_ID,mgr);
742
743 ref.reload(UnaryTestsF16::REF_LT_SOLVE_F16_ID,mgr);
744
745 output.create(ref.nbSamples(),UnaryTestsF16::OUT_F16_ID,mgr);
746 a.create(MAXMATRIXDIM*MAXMATRIXDIM,UnaryTestsF16::TMPA_F16_ID,mgr);
747 b.create(MAXMATRIXDIM*MAXMATRIXDIM,UnaryTestsF16::TMPB_F16_ID,mgr);
748 break;
749
750 case TEST_HOUSEHOLDER_F16_11:
751 input1.reload(UnaryTestsF16::INPUTS_HOUSEHOLDER_F16_ID,mgr);
752 dims.reload(UnaryTestsF16::DIMS_HOUSEHOLDER_S16_ID,mgr);
753 ref.reload(UnaryTestsF16::REF_HOUSEHOLDER_V_F16_ID,mgr);
754 refBeta.reload(UnaryTestsF16::REF_HOUSEHOLDER_BETA_F16_ID,mgr);
755
756
757 output.create(ref.nbSamples(),UnaryTestsF16::TMPA_F16_ID,mgr);
758 outputBeta.create(refBeta.nbSamples(),UnaryTestsF16::TMPB_F16_ID,mgr);
759 break;
760
761
762 case TEST_MAT_QR_F16_12:
763 input1.reload(UnaryTestsF16::INPUTS_QR_F16_ID,mgr);
764 dims.reload(UnaryTestsF16::DIMS_QR_S16_ID,mgr);
765 refTau.reload(UnaryTestsF16::REF_QR_TAU_F16_ID,mgr);
766 refR.reload(UnaryTestsF16::REF_QR_R_F16_ID,mgr);
767 refQ.reload(UnaryTestsF16::REF_QR_Q_F16_ID,mgr);
768
769
770 outputTau.create(refTau.nbSamples(),UnaryTestsF16::TMPA_F16_ID,mgr);
771 outputR.create(refR.nbSamples(),UnaryTestsF16::TMPB_F16_ID,mgr);
772 outputQ.create(refQ.nbSamples(),UnaryTestsF16::TMPC_F16_ID,mgr);
773
774 a.create(47,UnaryTestsF16::TMPC_F16_ID,mgr);
775 b.create(47,UnaryTestsF16::TMPD_F16_ID,mgr);
776 break;
777 }
778
779
780
781 }
782
tearDown(Testing::testID_t id,Client::PatternMgr * mgr)783 void UnaryTestsF16::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
784 {
785 (void)id;
786 //output.dump(mgr);
787 (void)mgr;
788 }
789
