1 /****************************************************************************** 2 * @file statistics_functions.h 3 * @brief Public header file for CMSIS DSP Library 4 * @version V1.10.1 5 * @date 14 July 2022 6 * Target Processor: Cortex-M and Cortex-A cores 7 ******************************************************************************/ 8 /* 9 * Copyright (c) 2010-2020 Arm Limited or its affiliates. All rights reserved. 10 * 11 * SPDX-License-Identifier: Apache-2.0 12 * 13 * Licensed under the Apache License, Version 2.0 (the License); you may 14 * not use this file except in compliance with the License. 15 * You may obtain a copy of the License at 16 * 17 * www.apache.org/licenses/LICENSE-2.0 18 * 19 * Unless required by applicable law or agreed to in writing, software 20 * distributed under the License is distributed on an AS IS BASIS, WITHOUT 21 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 22 * See the License for the specific language governing permissions and 23 * limitations under the License. 24 */ 25 26 27 #ifndef STATISTICS_FUNCTIONS_H_ 28 #define STATISTICS_FUNCTIONS_H_ 29 30 #include "arm_math_types.h" 31 #include "arm_math_memory.h" 32 33 #include "dsp/none.h" 34 #include "dsp/utils.h" 35 36 #include "dsp/basic_math_functions.h" 37 #include "dsp/fast_math_functions.h" 38 39 #ifdef __cplusplus 40 extern "C" 41 { 42 #endif 43 44 45 /** 46 * @defgroup groupStats Statistics Functions 47 */ 48 49 /** 50 * @brief Computation of the LogSumExp 51 * 52 * In probabilistic computations, the dynamic of the probability values can be very 53 * wide because they come from gaussian functions. 54 * To avoid underflow and overflow issues, the values are represented by their log. 55 * In this representation, multiplying the original exp values is easy : their logs are added. 56 * But adding the original exp values is requiring some special handling and it is the 57 * goal of the LogSumExp function. 58 * 59 * If the values are x1...xn, the function is computing: 60 * 61 * ln(exp(x1) + ... + exp(xn)) and the computation is done in such a way that 62 * rounding issues are minimised. 63 * 64 * The max xm of the values is extracted and the function is computing: 65 * xm + ln(exp(x1 - xm) + ... + exp(xn - xm)) 66 * 67 * @param[in] *in Pointer to an array of input values. 68 * @param[in] blockSize Number of samples in the input array. 69 * @return LogSumExp 70 * 71 */ 72 73 74 float32_t arm_logsumexp_f32(const float32_t *in, uint32_t blockSize); 75 76 /** 77 * @brief Dot product with log arithmetic 78 * 79 * Vectors are containing the log of the samples 80 * 81 * @param[in] pSrcA points to the first input vector 82 * @param[in] pSrcB points to the second input vector 83 * @param[in] blockSize number of samples in each vector 84 * @param[in] pTmpBuffer temporary buffer of length blockSize 85 * @return The log of the dot product . 86 * 87 */ 88 89 90 float32_t arm_logsumexp_dot_prod_f32(const float32_t * pSrcA, 91 const float32_t * pSrcB, 92 uint32_t blockSize, 93 float32_t *pTmpBuffer); 94 95 /** 96 * @brief Entropy 97 * 98 * @param[in] pSrcA Array of input values. 99 * @param[in] blockSize Number of samples in the input array. 100 * @return Entropy -Sum(p ln p) 101 * 102 */ 103 104 105 float32_t arm_entropy_f32(const float32_t * pSrcA,uint32_t blockSize); 106 107 108 /** 109 * @brief Entropy 110 * 111 * @param[in] pSrcA Array of input values. 112 * @param[in] blockSize Number of samples in the input array. 113 * @return Entropy -Sum(p ln p) 114 * 115 */ 116 117 118 float64_t arm_entropy_f64(const float64_t * pSrcA, uint32_t blockSize); 119 120 121 /** 122 * @brief Kullback-Leibler 123 * 124 * @param[in] pSrcA Pointer to an array of input values for probability distribution A. 125 * @param[in] pSrcB Pointer to an array of input values for probability distribution B. 126 * @param[in] blockSize Number of samples in the input array. 127 * @return Kullback-Leibler Divergence D(A || B) 128 * 129 */ 130 float32_t arm_kullback_leibler_f32(const float32_t * pSrcA 131 ,const float32_t * pSrcB 132 ,uint32_t blockSize); 133 134 135 /** 136 * @brief Kullback-Leibler 137 * 138 * @param[in] pSrcA Pointer to an array of input values for probability distribution A. 139 * @param[in] pSrcB Pointer to an array of input values for probability distribution B. 140 * @param[in] blockSize Number of samples in the input array. 141 * @return Kullback-Leibler Divergence D(A || B) 142 * 143 */ 144 float64_t arm_kullback_leibler_f64(const float64_t * pSrcA, 145 const float64_t * pSrcB, 146 uint32_t blockSize); 147 148 149 /** 150 * @brief Sum of the squares of the elements of a Q31 vector. 151 * @param[in] pSrc is input pointer 152 * @param[in] blockSize is the number of samples to process 153 * @param[out] pResult is output value. 154 */ 155 void arm_power_q31( 156 const q31_t * pSrc, 157 uint32_t blockSize, 158 q63_t * pResult); 159 160 161 /** 162 * @brief Sum of the squares of the elements of a floating-point vector. 163 * @param[in] pSrc is input pointer 164 * @param[in] blockSize is the number of samples to process 165 * @param[out] pResult is output value. 166 */ 167 void arm_power_f32( 168 const float32_t * pSrc, 169 uint32_t blockSize, 170 float32_t * pResult); 171 172 173 /** 174 * @brief Sum of the squares of the elements of a floating-point vector. 175 * @param[in] pSrc is input pointer 176 * @param[in] blockSize is the number of samples to process 177 * @param[out] pResult is output value. 178 */ 179 void arm_power_f64( 180 const float64_t * pSrc, 181 uint32_t blockSize, 182 float64_t * pResult); 183 184 185 /** 186 * @brief Sum of the squares of the elements of a Q15 vector. 187 * @param[in] pSrc is input pointer 188 * @param[in] blockSize is the number of samples to process 189 * @param[out] pResult is output value. 190 */ 191 void arm_power_q15( 192 const q15_t * pSrc, 193 uint32_t blockSize, 194 q63_t * pResult); 195 196 197 /** 198 * @brief Sum of the squares of the elements of a Q7 vector. 199 * @param[in] pSrc is input pointer 200 * @param[in] blockSize is the number of samples to process 201 * @param[out] pResult is output value. 202 */ 203 void arm_power_q7( 204 const q7_t * pSrc, 205 uint32_t blockSize, 206 q31_t * pResult); 207 208 209 /** 210 * @brief Mean value of a Q7 vector. 211 * @param[in] pSrc is input pointer 212 * @param[in] blockSize is the number of samples to process 213 * @param[out] pResult is output value. 214 */ 215 void arm_mean_q7( 216 const q7_t * pSrc, 217 uint32_t blockSize, 218 q7_t * pResult); 219 220 221 /** 222 * @brief Mean value of a Q15 vector. 223 * @param[in] pSrc is input pointer 224 * @param[in] blockSize is the number of samples to process 225 * @param[out] pResult is output value. 226 */ 227 void arm_mean_q15( 228 const q15_t * pSrc, 229 uint32_t blockSize, 230 q15_t * pResult); 231 232 233 /** 234 * @brief Mean value of a Q31 vector. 235 * @param[in] pSrc is input pointer 236 * @param[in] blockSize is the number of samples to process 237 * @param[out] pResult is output value. 238 */ 239 void arm_mean_q31( 240 const q31_t * pSrc, 241 uint32_t blockSize, 242 q31_t * pResult); 243 244 245 /** 246 * @brief Mean value of a floating-point vector. 247 * @param[in] pSrc is input pointer 248 * @param[in] blockSize is the number of samples to process 249 * @param[out] pResult is output value. 250 */ 251 void arm_mean_f32( 252 const float32_t * pSrc, 253 uint32_t blockSize, 254 float32_t * pResult); 255 256 257 /** 258 * @brief Mean value of a floating-point vector. 259 * @param[in] pSrc is input pointer 260 * @param[in] blockSize is the number of samples to process 261 * @param[out] pResult is output value. 262 */ 263 void arm_mean_f64( 264 const float64_t * pSrc, 265 uint32_t blockSize, 266 float64_t * pResult); 267 268 269 /** 270 * @brief Variance of the elements of a floating-point vector. 271 * @param[in] pSrc is input pointer 272 * @param[in] blockSize is the number of samples to process 273 * @param[out] pResult is output value. 274 */ 275 void arm_var_f32( 276 const float32_t * pSrc, 277 uint32_t blockSize, 278 float32_t * pResult); 279 280 281 /** 282 * @brief Variance of the elements of a floating-point vector. 283 * @param[in] pSrc is input pointer 284 * @param[in] blockSize is the number of samples to process 285 * @param[out] pResult is output value. 286 */ 287 void arm_var_f64( 288 const float64_t * pSrc, 289 uint32_t blockSize, 290 float64_t * pResult); 291 292 293 /** 294 * @brief Variance of the elements of a Q31 vector. 295 * @param[in] pSrc is input pointer 296 * @param[in] blockSize is the number of samples to process 297 * @param[out] pResult is output value. 298 */ 299 void arm_var_q31( 300 const q31_t * pSrc, 301 uint32_t blockSize, 302 q31_t * pResult); 303 304 305 /** 306 * @brief Variance of the elements of a Q15 vector. 307 * @param[in] pSrc is input pointer 308 * @param[in] blockSize is the number of samples to process 309 * @param[out] pResult is output value. 310 */ 311 void arm_var_q15( 312 const q15_t * pSrc, 313 uint32_t blockSize, 314 q15_t * pResult); 315 316 317 /** 318 * @brief Root Mean Square of the elements of a floating-point vector. 319 * @param[in] pSrc is input pointer 320 * @param[in] blockSize is the number of samples to process 321 * @param[out] pResult is output value. 322 */ 323 void arm_rms_f32( 324 const float32_t * pSrc, 325 uint32_t blockSize, 326 float32_t * pResult); 327 328 329 /** 330 * @brief Root Mean Square of the elements of a Q31 vector. 331 * @param[in] pSrc is input pointer 332 * @param[in] blockSize is the number of samples to process 333 * @param[out] pResult is output value. 334 */ 335 void arm_rms_q31( 336 const q31_t * pSrc, 337 uint32_t blockSize, 338 q31_t * pResult); 339 340 341 /** 342 * @brief Root Mean Square of the elements of a Q15 vector. 343 * @param[in] pSrc is input pointer 344 * @param[in] blockSize is the number of samples to process 345 * @param[out] pResult is output value. 346 */ 347 void arm_rms_q15( 348 const q15_t * pSrc, 349 uint32_t blockSize, 350 q15_t * pResult); 351 352 353 /** 354 * @brief Standard deviation of the elements of a floating-point vector. 355 * @param[in] pSrc is input pointer 356 * @param[in] blockSize is the number of samples to process 357 * @param[out] pResult is output value. 358 */ 359 void arm_std_f32( 360 const float32_t * pSrc, 361 uint32_t blockSize, 362 float32_t * pResult); 363 364 365 /** 366 * @brief Standard deviation of the elements of a floating-point vector. 367 * @param[in] pSrc is input pointer 368 * @param[in] blockSize is the number of samples to process 369 * @param[out] pResult is output value. 370 */ 371 void arm_std_f64( 372 const float64_t * pSrc, 373 uint32_t blockSize, 374 float64_t * pResult); 375 376 377 /** 378 * @brief Standard deviation of the elements of a Q31 vector. 379 * @param[in] pSrc is input pointer 380 * @param[in] blockSize is the number of samples to process 381 * @param[out] pResult is output value. 382 */ 383 void arm_std_q31( 384 const q31_t * pSrc, 385 uint32_t blockSize, 386 q31_t * pResult); 387 388 389 /** 390 * @brief Standard deviation of the elements of a Q15 vector. 391 * @param[in] pSrc is input pointer 392 * @param[in] blockSize is the number of samples to process 393 * @param[out] pResult is output value. 394 */ 395 void arm_std_q15( 396 const q15_t * pSrc, 397 uint32_t blockSize, 398 q15_t * pResult); 399 400 401 402 /** 403 * @brief Minimum value of a Q7 vector. 404 * @param[in] pSrc is input pointer 405 * @param[in] blockSize is the number of samples to process 406 * @param[out] pResult is output pointer 407 * @param[in] pIndex is the array index of the minimum value in the input buffer. 408 */ 409 void arm_min_q7( 410 const q7_t * pSrc, 411 uint32_t blockSize, 412 q7_t * pResult, 413 uint32_t * pIndex); 414 415 /** 416 * @brief Minimum value of absolute values of a Q7 vector. 417 * @param[in] pSrc is input pointer 418 * @param[in] blockSize is the number of samples to process 419 * @param[out] pResult is output pointer 420 * @param[in] pIndex is the array index of the minimum value in the input buffer. 421 */ 422 void arm_absmin_q7( 423 const q7_t * pSrc, 424 uint32_t blockSize, 425 q7_t * pResult, 426 uint32_t * pIndex); 427 428 /** 429 * @brief Minimum value of absolute values of a Q7 vector. 430 * @param[in] pSrc is input pointer 431 * @param[in] blockSize is the number of samples to process 432 * @param[out] pResult is output pointer 433 */ 434 void arm_absmin_no_idx_q7( 435 const q7_t * pSrc, 436 uint32_t blockSize, 437 q7_t * pResult); 438 439 440 /** 441 * @brief Minimum value of a Q15 vector. 442 * @param[in] pSrc is input pointer 443 * @param[in] blockSize is the number of samples to process 444 * @param[out] pResult is output pointer 445 * @param[in] pIndex is the array index of the minimum value in the input buffer. 446 */ 447 void arm_min_q15( 448 const q15_t * pSrc, 449 uint32_t blockSize, 450 q15_t * pResult, 451 uint32_t * pIndex); 452 453 /** 454 * @brief Minimum value of absolute values of a Q15 vector. 455 * @param[in] pSrc is input pointer 456 * @param[in] blockSize is the number of samples to process 457 * @param[out] pResult is output pointer 458 * @param[in] pIndex is the array index of the minimum value in the input buffer. 459 */ 460 void arm_absmin_q15( 461 const q15_t * pSrc, 462 uint32_t blockSize, 463 q15_t * pResult, 464 uint32_t * pIndex); 465 466 /** 467 * @brief Minimum value of absolute values of a Q15 vector. 468 * @param[in] pSrc is input pointer 469 * @param[in] blockSize is the number of samples to process 470 * @param[out] pResult is output pointer 471 */ 472 void arm_absmin_no_idx_q15( 473 const q15_t * pSrc, 474 uint32_t blockSize, 475 q15_t * pResult); 476 477 478 /** 479 * @brief Minimum value of a Q31 vector. 480 * @param[in] pSrc is input pointer 481 * @param[in] blockSize is the number of samples to process 482 * @param[out] pResult is output pointer 483 * @param[out] pIndex is the array index of the minimum value in the input buffer. 484 */ 485 void arm_min_q31( 486 const q31_t * pSrc, 487 uint32_t blockSize, 488 q31_t * pResult, 489 uint32_t * pIndex); 490 491 /** 492 * @brief Minimum value of absolute values of a Q31 vector. 493 * @param[in] pSrc is input pointer 494 * @param[in] blockSize is the number of samples to process 495 * @param[out] pResult is output pointer 496 * @param[out] pIndex is the array index of the minimum value in the input buffer. 497 */ 498 void arm_absmin_q31( 499 const q31_t * pSrc, 500 uint32_t blockSize, 501 q31_t * pResult, 502 uint32_t * pIndex); 503 504 /** 505 * @brief Minimum value of absolute values of a Q31 vector. 506 * @param[in] pSrc is input pointer 507 * @param[in] blockSize is the number of samples to process 508 * @param[out] pResult is output pointer 509 */ 510 void arm_absmin_no_idx_q31( 511 const q31_t * pSrc, 512 uint32_t blockSize, 513 q31_t * pResult); 514 515 516 /** 517 * @brief Minimum value of a floating-point vector. 518 * @param[in] pSrc is input pointer 519 * @param[in] blockSize is the number of samples to process 520 * @param[out] pResult is output pointer 521 * @param[out] pIndex is the array index of the minimum value in the input buffer. 522 */ 523 void arm_min_f32( 524 const float32_t * pSrc, 525 uint32_t blockSize, 526 float32_t * pResult, 527 uint32_t * pIndex); 528 529 /** 530 * @brief Minimum value of absolute values of a floating-point vector. 531 * @param[in] pSrc is input pointer 532 * @param[in] blockSize is the number of samples to process 533 * @param[out] pResult is output pointer 534 * @param[out] pIndex is the array index of the minimum value in the input buffer. 535 */ 536 void arm_absmin_f32( 537 const float32_t * pSrc, 538 uint32_t blockSize, 539 float32_t * pResult, 540 uint32_t * pIndex); 541 542 /** 543 * @brief Minimum value of absolute values of a floating-point vector. 544 * @param[in] pSrc is input pointer 545 * @param[in] blockSize is the number of samples to process 546 * @param[out] pResult is output pointer 547 */ 548 void arm_absmin_no_idx_f32( 549 const float32_t * pSrc, 550 uint32_t blockSize, 551 float32_t * pResult); 552 553 554 /** 555 * @brief Minimum value of a floating-point vector. 556 * @param[in] pSrc is input pointer 557 * @param[in] blockSize is the number of samples to process 558 * @param[out] pResult is output pointer 559 * @param[out] pIndex is the array index of the minimum value in the input buffer. 560 */ 561 void arm_min_f64( 562 const float64_t * pSrc, 563 uint32_t blockSize, 564 float64_t * pResult, 565 uint32_t * pIndex); 566 567 /** 568 * @brief Minimum value of absolute values of a floating-point vector. 569 * @param[in] pSrc is input pointer 570 * @param[in] blockSize is the number of samples to process 571 * @param[out] pResult is output pointer 572 * @param[out] pIndex is the array index of the minimum value in the input buffer. 573 */ 574 void arm_absmin_f64( 575 const float64_t * pSrc, 576 uint32_t blockSize, 577 float64_t * pResult, 578 uint32_t * pIndex); 579 580 /** 581 * @brief Minimum value of absolute values of a floating-point vector. 582 * @param[in] pSrc is input pointer 583 * @param[in] blockSize is the number of samples to process 584 * @param[out] pResult is output pointer 585 */ 586 void arm_absmin_no_idx_f64( 587 const float64_t * pSrc, 588 uint32_t blockSize, 589 float64_t * pResult); 590 591 592 /** 593 * @brief Maximum value of a Q7 vector. 594 * @param[in] pSrc points to the input buffer 595 * @param[in] blockSize length of the input vector 596 * @param[out] pResult maximum value returned here 597 * @param[out] pIndex index of maximum value returned here 598 */ 599 void arm_max_q7( 600 const q7_t * pSrc, 601 uint32_t blockSize, 602 q7_t * pResult, 603 uint32_t * pIndex); 604 605 /** 606 * @brief Maximum value of absolute values of a Q7 vector. 607 * @param[in] pSrc points to the input buffer 608 * @param[in] blockSize length of the input vector 609 * @param[out] pResult maximum value returned here 610 * @param[out] pIndex index of maximum value returned here 611 */ 612 void arm_absmax_q7( 613 const q7_t * pSrc, 614 uint32_t blockSize, 615 q7_t * pResult, 616 uint32_t * pIndex); 617 618 /** 619 * @brief Maximum value of absolute values of a Q7 vector. 620 * @param[in] pSrc points to the input buffer 621 * @param[in] blockSize length of the input vector 622 * @param[out] pResult maximum value returned here 623 */ 624 void arm_absmax_no_idx_q7( 625 const q7_t * pSrc, 626 uint32_t blockSize, 627 q7_t * pResult); 628 629 630 /** 631 * @brief Maximum value of a Q15 vector. 632 * @param[in] pSrc points to the input buffer 633 * @param[in] blockSize length of the input vector 634 * @param[out] pResult maximum value returned here 635 * @param[out] pIndex index of maximum value returned here 636 */ 637 void arm_max_q15( 638 const q15_t * pSrc, 639 uint32_t blockSize, 640 q15_t * pResult, 641 uint32_t * pIndex); 642 643 /** 644 * @brief Maximum value of absolute values of a Q15 vector. 645 * @param[in] pSrc points to the input buffer 646 * @param[in] blockSize length of the input vector 647 * @param[out] pResult maximum value returned here 648 * @param[out] pIndex index of maximum value returned here 649 */ 650 void arm_absmax_q15( 651 const q15_t * pSrc, 652 uint32_t blockSize, 653 q15_t * pResult, 654 uint32_t * pIndex); 655 656 /** 657 * @brief Maximum value of absolute values of a Q15 vector. 658 * @param[in] pSrc points to the input buffer 659 * @param[in] blockSize length of the input vector 660 * @param[out] pResult maximum value returned here 661 */ 662 void arm_absmax_no_idx_q15( 663 const q15_t * pSrc, 664 uint32_t blockSize, 665 q15_t * pResult); 666 667 /** 668 * @brief Maximum value of a Q31 vector. 669 * @param[in] pSrc points to the input buffer 670 * @param[in] blockSize length of the input vector 671 * @param[out] pResult maximum value returned here 672 * @param[out] pIndex index of maximum value returned here 673 */ 674 void arm_max_q31( 675 const q31_t * pSrc, 676 uint32_t blockSize, 677 q31_t * pResult, 678 uint32_t * pIndex); 679 680 /** 681 * @brief Maximum value of absolute values of a Q31 vector. 682 * @param[in] pSrc points to the input buffer 683 * @param[in] blockSize length of the input vector 684 * @param[out] pResult maximum value returned here 685 * @param[out] pIndex index of maximum value returned here 686 */ 687 void arm_absmax_q31( 688 const q31_t * pSrc, 689 uint32_t blockSize, 690 q31_t * pResult, 691 uint32_t * pIndex); 692 693 /** 694 * @brief Maximum value of absolute values of a Q31 vector. 695 * @param[in] pSrc points to the input buffer 696 * @param[in] blockSize length of the input vector 697 * @param[out] pResult maximum value returned here 698 */ 699 void arm_absmax_no_idx_q31( 700 const q31_t * pSrc, 701 uint32_t blockSize, 702 q31_t * pResult); 703 704 /** 705 * @brief Maximum value of a floating-point vector. 706 * @param[in] pSrc points to the input buffer 707 * @param[in] blockSize length of the input vector 708 * @param[out] pResult maximum value returned here 709 * @param[out] pIndex index of maximum value returned here 710 */ 711 void arm_max_f32( 712 const float32_t * pSrc, 713 uint32_t blockSize, 714 float32_t * pResult, 715 uint32_t * pIndex); 716 717 /** 718 * @brief Maximum value of absolute values of a floating-point vector. 719 * @param[in] pSrc points to the input buffer 720 * @param[in] blockSize length of the input vector 721 * @param[out] pResult maximum value returned here 722 * @param[out] pIndex index of maximum value returned here 723 */ 724 void arm_absmax_f32( 725 const float32_t * pSrc, 726 uint32_t blockSize, 727 float32_t * pResult, 728 uint32_t * pIndex); 729 730 /** 731 * @brief Maximum value of absolute values of a floating-point vector. 732 * @param[in] pSrc points to the input buffer 733 * @param[in] blockSize length of the input vector 734 * @param[out] pResult maximum value returned here 735 */ 736 void arm_absmax_no_idx_f32( 737 const float32_t * pSrc, 738 uint32_t blockSize, 739 float32_t * pResult); 740 741 /** 742 * @brief Maximum value of a floating-point vector. 743 * @param[in] pSrc points to the input buffer 744 * @param[in] blockSize length of the input vector 745 * @param[out] pResult maximum value returned here 746 * @param[out] pIndex index of maximum value returned here 747 */ 748 void arm_max_f64( 749 const float64_t * pSrc, 750 uint32_t blockSize, 751 float64_t * pResult, 752 uint32_t * pIndex); 753 754 /** 755 * @brief Maximum value of absolute values of a floating-point vector. 756 * @param[in] pSrc points to the input buffer 757 * @param[in] blockSize length of the input vector 758 * @param[out] pResult maximum value returned here 759 * @param[out] pIndex index of maximum value returned here 760 */ 761 void arm_absmax_f64( 762 const float64_t * pSrc, 763 uint32_t blockSize, 764 float64_t * pResult, 765 uint32_t * pIndex); 766 767 /** 768 * @brief Maximum value of absolute values of a floating-point vector. 769 * @param[in] pSrc points to the input buffer 770 * @param[in] blockSize length of the input vector 771 * @param[out] pResult maximum value returned here 772 */ 773 void arm_absmax_no_idx_f64( 774 const float64_t * pSrc, 775 uint32_t blockSize, 776 float64_t * pResult); 777 778 /** 779 @brief Maximum value of a floating-point vector. 780 @param[in] pSrc points to the input vector 781 @param[in] blockSize number of samples in input vector 782 @param[out] pResult maximum value returned here 783 */ 784 void arm_max_no_idx_f32( 785 const float32_t *pSrc, 786 uint32_t blockSize, 787 float32_t *pResult); 788 789 /** 790 @brief Minimum value of a floating-point vector. 791 @param[in] pSrc points to the input vector 792 @param[in] blockSize number of samples in input vector 793 @param[out] pResult minimum value returned here 794 */ 795 void arm_min_no_idx_f32( 796 const float32_t *pSrc, 797 uint32_t blockSize, 798 float32_t *pResult); 799 800 /** 801 @brief Maximum value of a floating-point vector. 802 @param[in] pSrc points to the input vector 803 @param[in] blockSize number of samples in input vector 804 @param[out] pResult maximum value returned here 805 */ 806 void arm_max_no_idx_f64( 807 const float64_t *pSrc, 808 uint32_t blockSize, 809 float64_t *pResult); 810 811 /** 812 @brief Maximum value of a q31 vector. 813 @param[in] pSrc points to the input vector 814 @param[in] blockSize number of samples in input vector 815 @param[out] pResult maximum value returned here 816 */ 817 void arm_max_no_idx_q31( 818 const q31_t *pSrc, 819 uint32_t blockSize, 820 q31_t *pResult); 821 822 /** 823 @brief Maximum value of a q15 vector. 824 @param[in] pSrc points to the input vector 825 @param[in] blockSize number of samples in input vector 826 @param[out] pResult maximum value returned here 827 */ 828 void arm_max_no_idx_q15( 829 const q15_t *pSrc, 830 uint32_t blockSize, 831 q15_t *pResult); 832 833 /** 834 @brief Maximum value of a q7 vector. 835 @param[in] pSrc points to the input vector 836 @param[in] blockSize number of samples in input vector 837 @param[out] pResult maximum value returned here 838 */ 839 void arm_max_no_idx_q7( 840 const q7_t *pSrc, 841 uint32_t blockSize, 842 q7_t *pResult); 843 844 /** 845 @brief Minimum value of a floating-point vector. 846 @param[in] pSrc points to the input vector 847 @param[in] blockSize number of samples in input vector 848 @param[out] pResult minimum value returned here 849 */ 850 void arm_min_no_idx_f64( 851 const float64_t *pSrc, 852 uint32_t blockSize, 853 float64_t *pResult); 854 855 /** 856 @brief Minimum value of a q31 vector. 857 @param[in] pSrc points to the input vector 858 @param[in] blockSize number of samples in input vector 859 @param[out] pResult minimum value returned here 860 */ 861 void arm_min_no_idx_q31( 862 const q31_t *pSrc, 863 uint32_t blockSize, 864 q31_t *pResult); 865 866 /** 867 @brief Minimum value of a q15 vector. 868 @param[in] pSrc points to the input vector 869 @param[in] blockSize number of samples in input vector 870 @param[out] pResult minimum value returned here 871 */ 872 void arm_min_no_idx_q15( 873 const q15_t *pSrc, 874 uint32_t blockSize, 875 q15_t *pResult); 876 877 /** 878 @brief Minimum value of a q7 vector. 879 @param[in] pSrc points to the input vector 880 @param[in] blockSize number of samples in input vector 881 @param[out] pResult minimum value returned here 882 */ 883 void arm_min_no_idx_q7( 884 const q7_t *pSrc, 885 uint32_t blockSize, 886 q7_t *pResult); 887 888 /** 889 @brief Mean square error between two Q7 vectors. 890 @param[in] pSrcA points to the first input vector 891 @param[in] pSrcB points to the second input vector 892 @param[in] blockSize number of samples in input vector 893 @param[out] pResult mean square error 894 */ 895 896 void arm_mse_q7( 897 const q7_t * pSrcA, 898 const q7_t * pSrcB, 899 uint32_t blockSize, 900 q7_t * pResult); 901 902 /** 903 @brief Mean square error between two Q15 vectors. 904 @param[in] pSrcA points to the first input vector 905 @param[in] pSrcB points to the second input vector 906 @param[in] blockSize number of samples in input vector 907 @param[out] pResult mean square error 908 */ 909 910 void arm_mse_q15( 911 const q15_t * pSrcA, 912 const q15_t * pSrcB, 913 uint32_t blockSize, 914 q15_t * pResult); 915 916 /** 917 @brief Mean square error between two Q31 vectors. 918 @param[in] pSrcA points to the first input vector 919 @param[in] pSrcB points to the second input vector 920 @param[in] blockSize number of samples in input vector 921 @param[out] pResult mean square error 922 */ 923 924 void arm_mse_q31( 925 const q31_t * pSrcA, 926 const q31_t * pSrcB, 927 uint32_t blockSize, 928 q31_t * pResult); 929 930 /** 931 @brief Mean square error between two single precision float vectors. 932 @param[in] pSrcA points to the first input vector 933 @param[in] pSrcB points to the second input vector 934 @param[in] blockSize number of samples in input vector 935 @param[out] pResult mean square error 936 */ 937 938 void arm_mse_f32( 939 const float32_t * pSrcA, 940 const float32_t * pSrcB, 941 uint32_t blockSize, 942 float32_t * pResult); 943 944 /** 945 @brief Mean square error between two double precision float vectors. 946 @param[in] pSrcA points to the first input vector 947 @param[in] pSrcB points to the second input vector 948 @param[in] blockSize number of samples in input vector 949 @param[out] pResult mean square error 950 */ 951 952 void arm_mse_f64( 953 const float64_t * pSrcA, 954 const float64_t * pSrcB, 955 uint32_t blockSize, 956 float64_t * pResult); 957 958 959 /** 960 * @brief Accumulation value of a floating-point vector. 961 * @param[in] pSrc is input pointer 962 * @param[in] blockSize is the number of samples to process 963 * @param[out] pResult is output value. 964 */ 965 966 void arm_accumulate_f32( 967 const float32_t * pSrc, 968 uint32_t blockSize, 969 float32_t * pResult); 970 971 /** 972 * @brief Accumulation value of a floating-point vector. 973 * @param[in] pSrc is input pointer 974 * @param[in] blockSize is the number of samples to process 975 * @param[out] pResult is output value. 976 */ 977 978 void arm_accumulate_f64( 979 const float64_t * pSrc, 980 uint32_t blockSize, 981 float64_t * pResult); 982 983 984 #ifdef __cplusplus 985 } 986 #endif 987 988 #endif /* ifndef _STATISTICS_FUNCTIONS_H_ */ 989
