1 #include "StatsTestsF32.h" 2 #include <stdio.h> 3 #include "Error.h" 4 #include "Test.h" 5 6 7 #define SNR_THRESHOLD 120 8 /* 9 10 Reference patterns are generated with 11 a double precision computation. 12 13 */ 14 #define REL_ERROR (1.0e-5) 15 test_max_f32()16 void StatsTestsF32::test_max_f32() 17 { 18 const float32_t *inp = inputA.ptr(); 19 20 float32_t result; 21 uint32_t indexval; 22 23 float32_t *refp = ref.ptr(); 24 int16_t *refind = maxIndexes.ptr(); 25 26 float32_t *outp = output.ptr(); 27 int16_t *ind = index.ptr(); 28 29 arm_max_f32(inp, 30 inputA.nbSamples(), 31 &result, 32 &indexval); 33 34 outp[0] = result; 35 ind[0] = indexval; 36 37 ASSERT_EQ(result,refp[this->refOffset]); 38 ASSERT_EQ((int16_t)indexval,refind[this->refOffset]); 39 40 } 41 test_absmax_f32()42 void StatsTestsF32::test_absmax_f32() 43 { 44 const float32_t *inp = inputA.ptr(); 45 46 float32_t result; 47 uint32_t indexval; 48 49 float32_t *refp = ref.ptr(); 50 int16_t *refind = maxIndexes.ptr(); 51 52 float32_t *outp = output.ptr(); 53 int16_t *ind = index.ptr(); 54 55 arm_absmax_f32(inp, 56 inputA.nbSamples(), 57 &result, 58 &indexval); 59 60 outp[0] = result; 61 ind[0] = indexval; 62 63 ASSERT_EQ(result,refp[this->refOffset]); 64 ASSERT_EQ((int16_t)indexval,refind[this->refOffset]); 65 66 } 67 test_max_no_idx_f32()68 void StatsTestsF32::test_max_no_idx_f32() 69 { 70 const float32_t *inp = inputA.ptr(); 71 72 float32_t result; 73 74 float32_t *refp = ref.ptr(); 75 76 float32_t *outp = output.ptr(); 77 78 arm_max_no_idx_f32(inp, 79 inputA.nbSamples(), 80 &result); 81 82 outp[0] = result; 83 84 ASSERT_EQ(result,refp[this->refOffset]); 85 86 } 87 test_absmax_no_idx_f32()88 void StatsTestsF32::test_absmax_no_idx_f32() 89 { 90 const float32_t *inp = inputA.ptr(); 91 92 float32_t result; 93 94 float32_t *refp = ref.ptr(); 95 96 float32_t *outp = output.ptr(); 97 98 arm_absmax_no_idx_f32(inp, 99 inputA.nbSamples(), 100 &result); 101 102 outp[0] = result; 103 104 ASSERT_EQ(result,refp[this->refOffset]); 105 106 } 107 test_min_no_idx_f32()108 void StatsTestsF32::test_min_no_idx_f32() 109 { 110 const float32_t *inp = inputA.ptr(); 111 112 float32_t result; 113 114 float32_t *refp = ref.ptr(); 115 116 float32_t *outp = output.ptr(); 117 118 arm_min_no_idx_f32(inp, 119 inputA.nbSamples(), 120 &result); 121 122 outp[0] = result; 123 124 ASSERT_EQ(result,refp[this->refOffset]); 125 126 } 127 test_absmin_no_idx_f32()128 void StatsTestsF32::test_absmin_no_idx_f32() 129 { 130 const float32_t *inp = inputA.ptr(); 131 132 float32_t result; 133 134 float32_t *refp = ref.ptr(); 135 136 float32_t *outp = output.ptr(); 137 138 arm_absmin_no_idx_f32(inp, 139 inputA.nbSamples(), 140 &result); 141 142 outp[0] = result; 143 144 ASSERT_EQ(result,refp[this->refOffset]); 145 146 } 147 test_min_f32()148 void StatsTestsF32::test_min_f32() 149 { 150 const float32_t *inp = inputA.ptr(); 151 152 float32_t result; 153 uint32_t indexval; 154 155 float32_t *refp = ref.ptr(); 156 int16_t *refind = minIndexes.ptr(); 157 158 float32_t *outp = output.ptr(); 159 int16_t *ind = index.ptr(); 160 161 arm_min_f32(inp, 162 inputA.nbSamples(), 163 &result, 164 &indexval); 165 166 outp[0] = result; 167 ind[0] = indexval; 168 169 ASSERT_EQ(result,refp[this->refOffset]); 170 ASSERT_EQ((int16_t)indexval,refind[this->refOffset]); 171 172 } 173 test_absmin_f32()174 void StatsTestsF32::test_absmin_f32() 175 { 176 const float32_t *inp = inputA.ptr(); 177 178 float32_t result; 179 uint32_t indexval; 180 181 float32_t *refp = ref.ptr(); 182 int16_t *refind = minIndexes.ptr(); 183 184 float32_t *outp = output.ptr(); 185 int16_t *ind = index.ptr(); 186 187 arm_absmin_f32(inp, 188 inputA.nbSamples(), 189 &result, 190 &indexval); 191 192 outp[0] = result; 193 ind[0] = indexval; 194 195 ASSERT_EQ(result,refp[this->refOffset]); 196 ASSERT_EQ((int16_t)indexval,refind[this->refOffset]); 197 198 } 199 test_mean_f32()200 void StatsTestsF32::test_mean_f32() 201 { 202 const float32_t *inp = inputA.ptr(); 203 204 float32_t result; 205 206 float32_t *refp = ref.ptr(); 207 208 float32_t *outp = output.ptr(); 209 210 arm_mean_f32(inp, 211 inputA.nbSamples(), 212 &result); 213 214 outp[0] = result; 215 216 ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD); 217 218 ASSERT_REL_ERROR(result,refp[this->refOffset],REL_ERROR); 219 220 } 221 test_power_f32()222 void StatsTestsF32::test_power_f32() 223 { 224 const float32_t *inp = inputA.ptr(); 225 226 float32_t result; 227 228 float32_t *refp = ref.ptr(); 229 230 float32_t *outp = output.ptr(); 231 232 arm_power_f32(inp, 233 inputA.nbSamples(), 234 &result); 235 236 outp[0] = result; 237 238 ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD); 239 240 ASSERT_REL_ERROR(result,refp[this->refOffset],REL_ERROR); 241 242 } 243 test_rms_f32()244 void StatsTestsF32::test_rms_f32() 245 { 246 const float32_t *inp = inputA.ptr(); 247 248 float32_t result; 249 250 float32_t *refp = ref.ptr(); 251 252 float32_t *outp = output.ptr(); 253 254 arm_rms_f32(inp, 255 inputA.nbSamples(), 256 &result); 257 258 outp[0] = result; 259 260 ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD); 261 262 ASSERT_REL_ERROR(result,refp[this->refOffset],REL_ERROR); 263 264 } 265 test_std_f32()266 void StatsTestsF32::test_std_f32() 267 { 268 const float32_t *inp = inputA.ptr(); 269 270 float32_t result; 271 272 float32_t *refp = ref.ptr(); 273 274 float32_t *outp = output.ptr(); 275 276 arm_std_f32(inp, 277 inputA.nbSamples(), 278 &result); 279 280 outp[0] = result; 281 282 ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD); 283 284 ASSERT_REL_ERROR(result,refp[this->refOffset],REL_ERROR); 285 286 } 287 test_var_f32()288 void StatsTestsF32::test_var_f32() 289 { 290 const float32_t *inp = inputA.ptr(); 291 292 float32_t result; 293 294 float32_t *refp = ref.ptr(); 295 296 float32_t *outp = output.ptr(); 297 298 arm_var_f32(inp, 299 inputA.nbSamples(), 300 &result); 301 302 outp[0] = result; 303 304 ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD); 305 306 ASSERT_REL_ERROR(result,refp[this->refOffset],REL_ERROR); 307 308 } 309 310 test_std_stability_f32()311 void StatsTestsF32::test_std_stability_f32() 312 { 313 /* 314 315 With the textbook algorithm, those values will produce a negative 316 value for the variance. 317 318 The CMSIS-DSP variance algorithm is the two pass one so will work 319 with those values. 320 321 So, it should be possible to compute the square root for the standard 322 deviation. 323 324 */ 325 float32_t in[4]={4.0f, 7.0f, 13.0f, 16.0f}; 326 float32_t result; 327 int i; 328 329 /* 330 331 Add bigger offset so that average is much bigger than standard deviation. 332 333 */ 334 for(i=0 ; i < 4; i++) 335 { 336 in[i] += 3.0e4f; 337 } 338 339 arm_std_f32(in,4,&result); 340 341 /* 342 343 If variance is giving a negative value, the square root 344 should return zero. 345 346 We check it is not happening here. 347 348 349 */ 350 351 ASSERT_TRUE(fabs(5.47723f - result) < 1.0e-4f); 352 353 } 354 test_entropy_f32()355 void StatsTestsF32::test_entropy_f32() 356 { 357 const float32_t *inp = inputA.ptr(); 358 const int16_t *dimsp = dims.ptr(); 359 360 float32_t *outp = output.ptr(); 361 362 for(int i=0;i < this->nbPatterns; i++) 363 { 364 *outp = arm_entropy_f32(inp,dimsp[i+1]); 365 outp++; 366 inp += dimsp[i+1]; 367 } 368 369 ASSERT_SNR(ref,output,(float32_t)SNR_THRESHOLD); 370 371 ASSERT_REL_ERROR(ref,output,REL_ERROR); 372 373 } 374 test_logsumexp_f32()375 void StatsTestsF32::test_logsumexp_f32() 376 { 377 const float32_t *inp = inputA.ptr(); 378 const int16_t *dimsp = dims.ptr(); 379 380 float32_t *outp = output.ptr(); 381 382 for(int i=0;i < this->nbPatterns; i++) 383 { 384 *outp = arm_logsumexp_f32(inp,dimsp[i+1]); 385 outp++; 386 inp += dimsp[i+1]; 387 } 388 389 ASSERT_SNR(ref,output,(float32_t)SNR_THRESHOLD); 390 391 ASSERT_REL_ERROR(ref,output,REL_ERROR); 392 } 393 394 test_kullback_leibler_f32()395 void StatsTestsF32::test_kullback_leibler_f32() 396 { 397 const float32_t *inpA = inputA.ptr(); 398 const float32_t *inpB = inputB.ptr(); 399 const int16_t *dimsp = dims.ptr(); 400 401 float32_t *outp = output.ptr(); 402 403 for(int i=0;i < this->nbPatterns; i++) 404 { 405 *outp = arm_kullback_leibler_f32(inpA,inpB,dimsp[i+1]); 406 outp++; 407 inpA += dimsp[i+1]; 408 inpB += dimsp[i+1]; 409 } 410 411 ASSERT_SNR(ref,output,(float32_t)SNR_THRESHOLD); 412 413 ASSERT_REL_ERROR(ref,output,REL_ERROR); 414 } 415 test_logsumexp_dot_prod_f32()416 void StatsTestsF32::test_logsumexp_dot_prod_f32() 417 { 418 const float32_t *inpA = inputA.ptr(); 419 const float32_t *inpB = inputB.ptr(); 420 const int16_t *dimsp = dims.ptr(); 421 422 float32_t *outp = output.ptr(); 423 float32_t *tmpp = tmp.ptr(); 424 425 for(int i=0;i < this->nbPatterns; i++) 426 { 427 *outp = arm_logsumexp_dot_prod_f32(inpA,inpB,dimsp[i+1],tmpp); 428 outp++; 429 inpA += dimsp[i+1]; 430 inpB += dimsp[i+1]; 431 } 432 433 ASSERT_SNR(ref,output,(float32_t)SNR_THRESHOLD); 434 435 ASSERT_REL_ERROR(ref,output,REL_ERROR); 436 } 437 438 test_mse_f32()439 void StatsTestsF32::test_mse_f32() 440 { 441 const float32_t *inpA = inputA.ptr(); 442 const float32_t *inpB = inputB.ptr(); 443 444 float32_t result; 445 446 float32_t *refp = ref.ptr(); 447 448 float32_t *outp = output.ptr(); 449 450 arm_mse_f32(inpA,inpB, 451 inputA.nbSamples(), 452 &result); 453 454 outp[0] = result; 455 456 ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD); 457 458 ASSERT_REL_ERROR(result,refp[this->refOffset],(float32_t)REL_ERROR); 459 460 } 461 test_accumulate_f32()462 void StatsTestsF32::test_accumulate_f32() 463 { 464 const float32_t *inp = inputA.ptr(); 465 const int16_t *dimsp = dims.ptr(); 466 467 float32_t *outp = output.ptr(); 468 469 for(int i=0;i < this->nbPatterns; i++) 470 { 471 arm_accumulate_f32(inp,dimsp[i+1],outp); 472 outp++; 473 } 474 475 ASSERT_SNR(ref,output,(float32_t)SNR_THRESHOLD); 476 477 ASSERT_REL_ERROR(ref,output,REL_ERROR); 478 479 } 480 481 setUp(Testing::testID_t id,std::vector<Testing::param_t> & paramsArgs,Client::PatternMgr * mgr)482 void StatsTestsF32::setUp(Testing::testID_t id,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr) 483 { 484 (void)paramsArgs; 485 switch(id) 486 { 487 case StatsTestsF32::TEST_MAX_F32_1: 488 { 489 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,3); 490 491 maxIndexes.reload(StatsTestsF32::MAXINDEXES_S16_ID,mgr); 492 ref.reload(StatsTestsF32::MAXVALS_F32_ID,mgr); 493 494 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 495 index.create(1,StatsTestsF32::OUT_S16_ID,mgr); 496 497 refOffset = 0; 498 } 499 break; 500 501 case StatsTestsF32::TEST_MAX_F32_2: 502 { 503 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,8); 504 505 maxIndexes.reload(StatsTestsF32::MAXINDEXES_S16_ID,mgr); 506 ref.reload(StatsTestsF32::MAXVALS_F32_ID,mgr); 507 508 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 509 index.create(1,StatsTestsF32::OUT_S16_ID,mgr); 510 511 refOffset = 1; 512 } 513 break; 514 515 case StatsTestsF32::TEST_MAX_F32_3: 516 { 517 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,11); 518 519 maxIndexes.reload(StatsTestsF32::MAXINDEXES_S16_ID,mgr); 520 ref.reload(StatsTestsF32::MAXVALS_F32_ID,mgr); 521 522 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 523 index.create(1,StatsTestsF32::OUT_S16_ID,mgr); 524 525 refOffset = 2; 526 } 527 break; 528 529 case StatsTestsF32::TEST_MEAN_F32_4: 530 { 531 inputA.reload(StatsTestsF32::INPUT2_F32_ID,mgr,3); 532 533 ref.reload(StatsTestsF32::MEANVALS_F32_ID,mgr); 534 535 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 536 537 refOffset = 0; 538 } 539 break; 540 541 case StatsTestsF32::TEST_MEAN_F32_5: 542 { 543 inputA.reload(StatsTestsF32::INPUT2_F32_ID,mgr,8); 544 545 ref.reload(StatsTestsF32::MEANVALS_F32_ID,mgr); 546 547 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 548 549 refOffset = 1; 550 } 551 break; 552 553 case StatsTestsF32::TEST_MEAN_F32_6: 554 { 555 inputA.reload(StatsTestsF32::INPUT2_F32_ID,mgr,11); 556 557 ref.reload(StatsTestsF32::MEANVALS_F32_ID,mgr); 558 559 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 560 561 refOffset = 2; 562 } 563 break; 564 565 case StatsTestsF32::TEST_MIN_F32_7: 566 { 567 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,3); 568 569 minIndexes.reload(StatsTestsF32::MININDEXES_S16_ID,mgr); 570 ref.reload(StatsTestsF32::MINVALS_F32_ID,mgr); 571 572 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 573 index.create(1,StatsTestsF32::OUT_S16_ID,mgr); 574 575 refOffset = 0; 576 } 577 break; 578 579 case StatsTestsF32::TEST_MIN_F32_8: 580 { 581 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,8); 582 583 minIndexes.reload(StatsTestsF32::MININDEXES_S16_ID,mgr); 584 ref.reload(StatsTestsF32::MINVALS_F32_ID,mgr); 585 586 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 587 index.create(1,StatsTestsF32::OUT_S16_ID,mgr); 588 589 refOffset = 1; 590 } 591 break; 592 593 case StatsTestsF32::TEST_MIN_F32_9: 594 { 595 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,11); 596 597 minIndexes.reload(StatsTestsF32::MININDEXES_S16_ID,mgr); 598 ref.reload(StatsTestsF32::MINVALS_F32_ID,mgr); 599 600 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 601 index.create(1,StatsTestsF32::OUT_S16_ID,mgr); 602 603 refOffset = 2; 604 } 605 break; 606 607 case StatsTestsF32::TEST_POWER_F32_10: 608 { 609 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,3); 610 611 ref.reload(StatsTestsF32::POWERVALS_F32_ID,mgr); 612 613 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 614 615 refOffset = 0; 616 } 617 break; 618 619 case StatsTestsF32::TEST_POWER_F32_11: 620 { 621 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,8); 622 623 ref.reload(StatsTestsF32::POWERVALS_F32_ID,mgr); 624 625 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 626 627 refOffset = 1; 628 } 629 break; 630 631 case StatsTestsF32::TEST_POWER_F32_12: 632 { 633 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,11); 634 635 ref.reload(StatsTestsF32::POWERVALS_F32_ID,mgr); 636 637 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 638 639 refOffset = 2; 640 } 641 break; 642 643 case StatsTestsF32::TEST_RMS_F32_13: 644 { 645 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,3); 646 647 ref.reload(StatsTestsF32::RMSVALS_F32_ID,mgr); 648 649 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 650 651 refOffset = 0; 652 } 653 break; 654 655 case StatsTestsF32::TEST_RMS_F32_14: 656 { 657 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,8); 658 659 ref.reload(StatsTestsF32::RMSVALS_F32_ID,mgr); 660 661 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 662 663 refOffset = 1; 664 } 665 break; 666 667 case StatsTestsF32::TEST_RMS_F32_15: 668 { 669 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,11); 670 671 ref.reload(StatsTestsF32::RMSVALS_F32_ID,mgr); 672 673 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 674 675 refOffset = 2; 676 } 677 break; 678 679 case StatsTestsF32::TEST_STD_F32_16: 680 { 681 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,3); 682 683 ref.reload(StatsTestsF32::STDVALS_F32_ID,mgr); 684 685 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 686 687 refOffset = 0; 688 } 689 break; 690 691 case StatsTestsF32::TEST_STD_F32_17: 692 { 693 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,8); 694 695 ref.reload(StatsTestsF32::STDVALS_F32_ID,mgr); 696 697 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 698 699 refOffset = 1; 700 } 701 break; 702 703 case StatsTestsF32::TEST_STD_F32_18: 704 { 705 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,11); 706 707 ref.reload(StatsTestsF32::STDVALS_F32_ID,mgr); 708 709 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 710 711 refOffset = 2; 712 } 713 break; 714 715 case StatsTestsF32::TEST_VAR_F32_19: 716 { 717 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,3); 718 719 ref.reload(StatsTestsF32::VARVALS_F32_ID,mgr); 720 721 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 722 723 refOffset = 0; 724 } 725 break; 726 727 case StatsTestsF32::TEST_VAR_F32_20: 728 { 729 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,8); 730 731 ref.reload(StatsTestsF32::VARVALS_F32_ID,mgr); 732 733 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 734 735 refOffset = 1; 736 } 737 break; 738 739 case StatsTestsF32::TEST_VAR_F32_21: 740 { 741 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,11); 742 743 ref.reload(StatsTestsF32::VARVALS_F32_ID,mgr); 744 745 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 746 747 refOffset = 2; 748 } 749 break; 750 751 case StatsTestsF32::TEST_ENTROPY_F32_22: 752 { 753 inputA.reload(StatsTestsF32::INPUT22_F32_ID,mgr); 754 dims.reload(StatsTestsF32::DIM22_S16_ID,mgr); 755 ref.reload(StatsTestsF32::REF22_ENTROPY_F32_ID,mgr); 756 output.create(ref.nbSamples(),StatsTestsF32::OUT_F32_ID,mgr); 757 758 const int16_t *dimsp = dims.ptr(); 759 this->nbPatterns=dimsp[0]; 760 } 761 break; 762 763 case StatsTestsF32::TEST_LOGSUMEXP_F32_23: 764 { 765 inputA.reload(StatsTestsF32::INPUT23_F32_ID,mgr); 766 dims.reload(StatsTestsF32::DIM23_S16_ID,mgr); 767 ref.reload(StatsTestsF32::REF23_LOGSUMEXP_F32_ID,mgr); 768 output.create(ref.nbSamples(),StatsTestsF32::OUT_F32_ID,mgr); 769 770 const int16_t *dimsp = dims.ptr(); 771 this->nbPatterns=dimsp[0]; 772 } 773 break; 774 775 case StatsTestsF32::TEST_KULLBACK_LEIBLER_F32_24: 776 { 777 inputA.reload(StatsTestsF32::INPUTA24_F32_ID,mgr); 778 inputB.reload(StatsTestsF32::INPUTB24_F32_ID,mgr); 779 dims.reload(StatsTestsF32::DIM24_S16_ID,mgr); 780 ref.reload(StatsTestsF32::REF24_KL_F32_ID,mgr); 781 output.create(ref.nbSamples(),StatsTestsF32::OUT_F32_ID,mgr); 782 783 const int16_t *dimsp = dims.ptr(); 784 this->nbPatterns=dimsp[0]; 785 } 786 break; 787 788 case StatsTestsF32::TEST_LOGSUMEXP_DOT_PROD_F32_25: 789 { 790 inputA.reload(StatsTestsF32::INPUTA25_F32_ID,mgr); 791 inputB.reload(StatsTestsF32::INPUTB25_F32_ID,mgr); 792 dims.reload(StatsTestsF32::DIM25_S16_ID,mgr); 793 ref.reload(StatsTestsF32::REF25_LOGSUMEXP_DOT_F32_ID,mgr); 794 output.create(ref.nbSamples(),StatsTestsF32::OUT_F32_ID,mgr); 795 796 const int16_t *dimsp = dims.ptr(); 797 this->nbPatterns=dimsp[0]; 798 799 /* 12 is max vecDim as defined in Python script generating the data */ 800 tmp.create(12,StatsTestsF32::TMP_F32_ID,mgr); 801 } 802 break; 803 804 case StatsTestsF32::TEST_MAX_NO_IDX_F32_26: 805 { 806 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,3); 807 808 ref.reload(StatsTestsF32::MAXVALS_F32_ID,mgr); 809 810 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 811 812 refOffset = 0; 813 } 814 break; 815 816 case StatsTestsF32::TEST_MAX_NO_IDX_F32_27: 817 { 818 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,8); 819 820 ref.reload(StatsTestsF32::MAXVALS_F32_ID,mgr); 821 822 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 823 824 refOffset = 1; 825 } 826 break; 827 828 case StatsTestsF32::TEST_MAX_NO_IDX_F32_28: 829 { 830 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,11); 831 832 ref.reload(StatsTestsF32::MAXVALS_F32_ID,mgr); 833 834 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 835 836 refOffset = 2; 837 } 838 break; 839 840 case TEST_MEAN_F32_29: 841 inputA.reload(StatsTestsF32::INPUT2_F32_ID,mgr,100); 842 843 ref.reload(StatsTestsF32::MEANVALS_F32_ID,mgr); 844 845 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 846 847 refOffset = 3; 848 break; 849 850 case TEST_RMS_F32_30: 851 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,100); 852 853 ref.reload(StatsTestsF32::RMSVALS_F32_ID,mgr); 854 855 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 856 857 refOffset = 3; 858 break; 859 860 case TEST_STD_F32_31: 861 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,100); 862 863 ref.reload(StatsTestsF32::STDVALS_F32_ID,mgr); 864 865 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 866 867 refOffset = 3; 868 break; 869 870 case TEST_VAR_F32_32: 871 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,100); 872 873 ref.reload(StatsTestsF32::VARVALS_F32_ID,mgr); 874 875 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 876 877 refOffset = 3; 878 break; 879 880 case StatsTestsF32::TEST_ABSMAX_F32_34: 881 { 882 inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,3); 883 884 maxIndexes.reload(StatsTestsF32::ABSMAXINDEXES_S16_ID,mgr); 885 ref.reload(StatsTestsF32::ABSMAXVALS_F32_ID,mgr); 886 887 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 888 index.create(1,StatsTestsF32::OUT_S16_ID,mgr); 889 890 refOffset = 0; 891 } 892 break; 893 894 case StatsTestsF32::TEST_ABSMAX_F32_35: 895 { 896 inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,8); 897 898 maxIndexes.reload(StatsTestsF32::ABSMAXINDEXES_S16_ID,mgr); 899 ref.reload(StatsTestsF32::ABSMAXVALS_F32_ID,mgr); 900 901 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 902 index.create(1,StatsTestsF32::OUT_S16_ID,mgr); 903 904 refOffset = 1; 905 } 906 break; 907 908 case StatsTestsF32::TEST_ABSMAX_F32_36: 909 { 910 inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,11); 911 912 maxIndexes.reload(StatsTestsF32::ABSMAXINDEXES_S16_ID,mgr); 913 ref.reload(StatsTestsF32::ABSMAXVALS_F32_ID,mgr); 914 915 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 916 index.create(1,StatsTestsF32::OUT_S16_ID,mgr); 917 918 refOffset = 2; 919 } 920 break; 921 922 case StatsTestsF32::TEST_ABSMIN_F32_37: 923 { 924 inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,3); 925 926 minIndexes.reload(StatsTestsF32::ABSMININDEXES_S16_ID,mgr); 927 ref.reload(StatsTestsF32::ABSMINVALS_F32_ID,mgr); 928 929 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 930 index.create(1,StatsTestsF32::OUT_S16_ID,mgr); 931 932 refOffset = 0; 933 } 934 break; 935 936 case StatsTestsF32::TEST_ABSMIN_F32_38: 937 { 938 inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,8); 939 940 minIndexes.reload(StatsTestsF32::ABSMININDEXES_S16_ID,mgr); 941 ref.reload(StatsTestsF32::ABSMINVALS_F32_ID,mgr); 942 943 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 944 index.create(1,StatsTestsF32::OUT_S16_ID,mgr); 945 946 refOffset = 1; 947 } 948 break; 949 950 case StatsTestsF32::TEST_ABSMIN_F32_39: 951 { 952 inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,11); 953 954 minIndexes.reload(StatsTestsF32::ABSMININDEXES_S16_ID,mgr); 955 ref.reload(StatsTestsF32::ABSMINVALS_F32_ID,mgr); 956 957 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 958 index.create(1,StatsTestsF32::OUT_S16_ID,mgr); 959 960 refOffset = 2; 961 } 962 break; 963 964 case StatsTestsF32::TEST_MIN_NO_IDX_F32_40: 965 { 966 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,3); 967 968 ref.reload(StatsTestsF32::MINVALS_F32_ID,mgr); 969 970 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 971 972 refOffset = 0; 973 } 974 break; 975 976 case StatsTestsF32::TEST_MIN_NO_IDX_F32_41: 977 { 978 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,8); 979 980 ref.reload(StatsTestsF32::MINVALS_F32_ID,mgr); 981 982 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 983 984 refOffset = 1; 985 } 986 break; 987 988 case StatsTestsF32::TEST_MIN_NO_IDX_F32_42: 989 { 990 inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,11); 991 992 ref.reload(StatsTestsF32::MINVALS_F32_ID,mgr); 993 994 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 995 996 refOffset = 2; 997 } 998 break; 999 1000 case StatsTestsF32::TEST_ABSMAX_NO_IDX_F32_43: 1001 { 1002 inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,3); 1003 1004 ref.reload(StatsTestsF32::ABSMAXVALS_F32_ID,mgr); 1005 1006 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 1007 1008 refOffset = 0; 1009 } 1010 break; 1011 1012 case StatsTestsF32::TEST_ABSMAX_NO_IDX_F32_44: 1013 { 1014 inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,8); 1015 1016 ref.reload(StatsTestsF32::ABSMAXVALS_F32_ID,mgr); 1017 1018 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 1019 1020 refOffset = 1; 1021 } 1022 break; 1023 1024 case StatsTestsF32::TEST_ABSMAX_NO_IDX_F32_45: 1025 { 1026 inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,11); 1027 1028 ref.reload(StatsTestsF32::ABSMAXVALS_F32_ID,mgr); 1029 1030 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 1031 1032 refOffset = 2; 1033 } 1034 break; 1035 1036 case StatsTestsF32::TEST_ABSMIN_NO_IDX_F32_46: 1037 { 1038 inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,3); 1039 1040 ref.reload(StatsTestsF32::ABSMINVALS_F32_ID,mgr); 1041 1042 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 1043 1044 refOffset = 0; 1045 } 1046 break; 1047 1048 case StatsTestsF32::TEST_ABSMIN_NO_IDX_F32_47: 1049 { 1050 inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,8); 1051 1052 ref.reload(StatsTestsF32::ABSMINVALS_F32_ID,mgr); 1053 1054 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 1055 1056 refOffset = 1; 1057 } 1058 break; 1059 1060 case StatsTestsF32::TEST_ABSMIN_NO_IDX_F32_48: 1061 { 1062 inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,11); 1063 1064 ref.reload(StatsTestsF32::ABSMINVALS_F32_ID,mgr); 1065 1066 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 1067 1068 refOffset = 2; 1069 } 1070 break; 1071 1072 case StatsTestsF32::TEST_MSE_F32_49: 1073 { 1074 inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,3); 1075 inputB.reload(StatsTestsF32::INPUTNEW2_F32_ID,mgr,3); 1076 1077 ref.reload(StatsTestsF32::MSE_F32_ID,mgr); 1078 1079 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 1080 1081 refOffset = 0; 1082 } 1083 break; 1084 1085 case StatsTestsF32::TEST_MSE_F32_50: 1086 { 1087 inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,8); 1088 inputB.reload(StatsTestsF32::INPUTNEW2_F32_ID,mgr,8); 1089 1090 ref.reload(StatsTestsF32::MSE_F32_ID,mgr); 1091 1092 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 1093 1094 refOffset = 1; 1095 } 1096 break; 1097 1098 case StatsTestsF32::TEST_MSE_F32_51: 1099 { 1100 inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,11); 1101 inputB.reload(StatsTestsF32::INPUTNEW2_F32_ID,mgr,11); 1102 1103 ref.reload(StatsTestsF32::MSE_F32_ID,mgr); 1104 1105 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 1106 1107 refOffset = 2; 1108 } 1109 break; 1110 1111 case StatsTestsF32::TEST_MSE_F32_52: 1112 { 1113 inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,100); 1114 inputB.reload(StatsTestsF32::INPUTNEW2_F32_ID,mgr,100); 1115 1116 ref.reload(StatsTestsF32::MSE_F32_ID,mgr); 1117 1118 output.create(1,StatsTestsF32::OUT_F32_ID,mgr); 1119 1120 refOffset = 3; 1121 } 1122 break; 1123 1124 case StatsTestsF32::TEST_ACCUMULATE_F32_53: 1125 { 1126 inputA.reload(StatsTestsF32::INPUT_ACCUMULATE_F32_ID,mgr); 1127 ref.reload(StatsTestsF32::REF_ACCUMULATE_F32_ID,mgr); 1128 dims.reload(StatsTestsF32::INPUT_ACCUMULATE_CONFIG_S16_ID,mgr); 1129 output.create(ref.nbSamples(),StatsTestsF32::OUT_F32_ID,mgr); 1130 1131 const int16_t *dimsp = dims.ptr(); 1132 this->nbPatterns=dimsp[0]; 1133 1134 1135 } 1136 break; 1137 1138 1139 } 1140 1141 } 1142 tearDown(Testing::testID_t id,Client::PatternMgr * mgr)1143 void StatsTestsF32::tearDown(Testing::testID_t id,Client::PatternMgr *mgr) 1144 { 1145 (void)id; 1146 switch(id) 1147 { 1148 case StatsTestsF32::TEST_MAX_F32_1: 1149 case StatsTestsF32::TEST_MAX_F32_2: 1150 case StatsTestsF32::TEST_MAX_F32_3: 1151 case StatsTestsF32::TEST_MIN_F32_7: 1152 case StatsTestsF32::TEST_MIN_F32_8: 1153 case StatsTestsF32::TEST_MIN_F32_9: 1154 index.dump(mgr); 1155 output.dump(mgr); 1156 break; 1157 1158 default: 1159 output.dump(mgr); 1160 } 1161 } 1162
