git.sur5r.net Git - freertos/blob

   1 /* ----------------------------------------------------------------------\r
   2 * Copyright (C) 2010-2014 ARM Limited. All rights reserved.\r
   3 *\r
   4 * $Date:        12. March 2014\r
   5 * $Revision:    V1.4.4\r
   6 *\r
   7 * Project:          CMSIS DSP Library\r
   8 * Title:            arm_math.h\r
   9 *\r
  10 * Description:  Public header file for CMSIS DSP Library\r
  11 *\r
  12 * Target Processor: Cortex-M7/Cortex-M4/Cortex-M3/Cortex-M0\r
  13 *\r
  14 * Redistribution and use in source and binary forms, with or without\r
  15 * modification, are permitted provided that the following conditions\r
  16 * are met:\r
  17 *   - Redistributions of source code must retain the above copyright\r
  18 *     notice, this list of conditions and the following disclaimer.\r
  19 *   - Redistributions in binary form must reproduce the above copyright\r
  20 *     notice, this list of conditions and the following disclaimer in\r
  21 *     the documentation and/or other materials provided with the\r
  22 *     distribution.\r
  23 *   - Neither the name of ARM LIMITED nor the names of its contributors\r
  24 *     may be used to endorse or promote products derived from this\r
  25 *     software without specific prior written permission.\r
  26 *\r
  27 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\r
  28 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\r
  29 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS\r
  30 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE\r
  31 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,\r
  32 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,\r
  33 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\r
  34 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\r
  35 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
  36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN\r
  37 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
  38 * POSSIBILITY OF SUCH DAMAGE.\r
  39  * -------------------------------------------------------------------- */\r
  40 \r
  41 /**\r
  42    \mainpage CMSIS DSP Software Library\r
  43    *\r
  44    * Introduction\r
  45    * ------------\r
  46    *\r
  47    * This user manual describes the CMSIS DSP software library,\r
  48    * a suite of common signal processing functions for use on Cortex-M processor based devices.\r
  49    *\r
  50    * The library is divided into a number of functions each covering a specific category:\r
  51    * - Basic math functions\r
  52    * - Fast math functions\r
  53    * - Complex math functions\r
  54    * - Filters\r
  55    * - Matrix functions\r
  56    * - Transforms\r
  57    * - Motor control functions\r
  58    * - Statistical functions\r
  59    * - Support functions\r
  60    * - Interpolation functions\r
  61    *\r
  62    * The library has separate functions for operating on 8-bit integers, 16-bit integers,\r
  63    * 32-bit integer and 32-bit floating-point values.\r
  64    *\r
  65    * Using the Library\r
  66    * ------------\r
  67    *\r
  68    * The library installer contains prebuilt versions of the libraries in the <code>Lib</code> folder.\r
  69    * - arm_cortexM7lfdp_math.lib (Little endian and Double Precision Floating Point Unit on Cortex-M7)\r
  70    * - arm_cortexM7bfdp_math.lib (Big endian and Double Precision Floating Point Unit on Cortex-M7)\r
  71    * - arm_cortexM7lfsp_math.lib (Little endian and Single Precision Floating Point Unit on Cortex-M7)\r
  72    * - arm_cortexM7bfsp_math.lib (Big endian and Single Precision Floating Point Unit on Cortex-M7)\r
  73    * - arm_cortexM7l_math.lib (Little endian on Cortex-M7)\r
  74    * - arm_cortexM7b_math.lib (Big endian on Cortex-M7)\r
  75    * - arm_cortexM4lf_math.lib (Little endian and Floating Point Unit on Cortex-M4)\r
  76    * - arm_cortexM4bf_math.lib (Big endian and Floating Point Unit on Cortex-M4)\r
  77    * - arm_cortexM4l_math.lib (Little endian on Cortex-M4)\r
  78    * - arm_cortexM4b_math.lib (Big endian on Cortex-M4)\r
  79    * - arm_cortexM3l_math.lib (Little endian on Cortex-M3)\r
  80    * - arm_cortexM3b_math.lib (Big endian on Cortex-M3)\r
  81    * - arm_cortexM0l_math.lib (Little endian on Cortex-M0 / CortexM0+)\r
  82    * - arm_cortexM0b_math.lib (Big endian on Cortex-M0 / CortexM0+)\r
  83    *\r
  84    * The library functions are declared in the public file <code>arm_math.h</code> which is placed in the <code>Include</code> folder.\r
  85    * Simply include this file and link the appropriate library in the application and begin calling the library functions. The Library supports single\r
  86    * public header file <code> arm_math.h</code> for Cortex-M7/M4/M3/M0/M0+ with little endian and big endian. Same header file will be used for floating point unit(FPU) variants.\r
  87    * Define the appropriate pre processor MACRO ARM_MATH_CM7 or ARM_MATH_CM4 or  ARM_MATH_CM3 or\r
  88    * ARM_MATH_CM0 or ARM_MATH_CM0PLUS depending on the target processor in the application.\r
  89    *\r
  90    * Examples\r
  91    * --------\r
  92    *\r
  93    * The library ships with a number of examples which demonstrate how to use the library functions.\r
  94    *\r
  95    * Toolchain Support\r
  96    * ------------\r
  97    *\r
  98    * The library has been developed and tested with MDK-ARM version 4.60.\r
  99    * The library is being tested in GCC and IAR toolchains and updates on this activity will be made available shortly.\r
 100    *\r
 101    * Building the Library\r
 102    * ------------\r
 103    *\r
 104    * The library installer contains a project file to re build libraries on MDK-ARM Tool chain in the <code>CMSIS\\DSP_Lib\\Source\\ARM</code> folder.\r
 105    * - arm_cortexM_math.uvproj\r
 106    *\r
 107    *\r
 108    * The libraries can be built by opening the arm_cortexM_math.uvproj project in MDK-ARM, selecting a specific target, and defining the optional pre processor MACROs detailed above.\r
 109    *\r
 110    * Pre-processor Macros\r
 111    * ------------\r
 112    *\r
 113    * Each library project have differant pre-processor macros.\r
 114    *\r
 115    * - UNALIGNED_SUPPORT_DISABLE:\r
 116    *\r
 117    * Define macro UNALIGNED_SUPPORT_DISABLE, If the silicon does not support unaligned memory access\r
 118    *\r
 119    * - ARM_MATH_BIG_ENDIAN:\r
 120    *\r
 121    * Define macro ARM_MATH_BIG_ENDIAN to build the library for big endian targets. By default library builds for little endian targets.\r
 122    *\r
 123    * - ARM_MATH_MATRIX_CHECK:\r
 124    *\r
 125    * Define macro ARM_MATH_MATRIX_CHECK for checking on the input and output sizes of matrices\r
 126    *\r
 127    * - ARM_MATH_ROUNDING:\r
 128    *\r
 129    * Define macro ARM_MATH_ROUNDING for rounding on support functions\r
 130    *\r
 131    * - ARM_MATH_CMx:\r
 132    *\r
 133    * Define macro ARM_MATH_CM4 for building the library on Cortex-M4 target, ARM_MATH_CM3 for building library on Cortex-M3 target\r
 134    * and ARM_MATH_CM0 for building library on cortex-M0 target, ARM_MATH_CM0PLUS for building library on cortex-M0+ target.\r
 135    *\r
 136    * - __FPU_PRESENT:\r
 137    *\r
 138    * Initialize macro __FPU_PRESENT = 1 when building on FPU supported Targets. Enable this macro for M4bf and M4lf libraries\r
 139    *\r
 140    * <hr>\r
 141    * CMSIS-DSP in ARM::CMSIS Pack\r
 142    * -----------------------------\r
 143    * \r
 144    * The following files relevant to CMSIS-DSP are present in the <b>ARM::CMSIS</b> Pack directories:\r
 145    * |File/Folder                   |Content                                                                 |\r
 146    * |------------------------------|------------------------------------------------------------------------|\r
 147    * |\b CMSIS\\Documentation\\DSP  | This documentation                                                     |\r
 148    * |\b CMSIS\\DSP_Lib             | Software license agreement (license.txt)                               |\r
 149    * |\b CMSIS\\DSP_Lib\\Examples   | Example projects demonstrating the usage of the library functions      |\r
 150    * |\b CMSIS\\DSP_Lib\\Source     | Source files for rebuilding the library                                |\r
 151    * \r
 152    * <hr>\r
 153    * Revision History of CMSIS-DSP\r
 154    * ------------\r
 155    * Please refer to \ref ChangeLog_pg.\r
 156    *\r
 157    * Copyright Notice\r
 158    * ------------\r
 159    *\r
 160    * Copyright (C) 2010-2014 ARM Limited. All rights reserved.\r
 161    */\r
 162 \r
 163 \r
 164 /**\r
 165  * @defgroup groupMath Basic Math Functions\r
 166  */\r
 167 \r
 168 /**\r
 169  * @defgroup groupFastMath Fast Math Functions\r
 170  * This set of functions provides a fast approximation to sine, cosine, and square root.\r
 171  * As compared to most of the other functions in the CMSIS math library, the fast math functions\r
 172  * operate on individual values and not arrays.\r
 173  * There are separate functions for Q15, Q31, and floating-point data.\r
 174  *\r
 175  */\r
 176 \r
 177 /**\r
 178  * @defgroup groupCmplxMath Complex Math Functions\r
 179  * This set of functions operates on complex data vectors.\r
 180  * The data in the complex arrays is stored in an interleaved fashion\r
 181  * (real, imag, real, imag, ...).\r
 182  * In the API functions, the number of samples in a complex array refers\r
 183  * to the number of complex values; the array contains twice this number of\r
 184  * real values.\r
 185  */\r
 186 \r
 187 /**\r
 188  * @defgroup groupFilters Filtering Functions\r
 189  */\r
 190 \r
 191 /**\r
 192  * @defgroup groupMatrix Matrix Functions\r
 193  *\r
 194  * This set of functions provides basic matrix math operations.\r
 195  * The functions operate on matrix data structures.  For example,\r
 196  * the type\r
 197  * definition for the floating-point matrix structure is shown\r
 198  * below:\r
 199  * <pre>\r
 200  *     typedef struct\r
 201  *     {\r
 202  *       uint16_t numRows;     // number of rows of the matrix.\r
 203  *       uint16_t numCols;     // number of columns of the matrix.\r
 204  *       float32_t *pData;     // points to the data of the matrix.\r
 205  *     } arm_matrix_instance_f32;\r
 206  * </pre>\r
 207  * There are similar definitions for Q15 and Q31 data types.\r
 208  *\r
 209  * The structure specifies the size of the matrix and then points to\r
 210  * an array of data.  The array is of size <code>numRows X numCols</code>\r
 211  * and the values are arranged in row order.  That is, the\r
 212  * matrix element (i, j) is stored at:\r
 213  * <pre>\r
 214  *     pData[i*numCols + j]\r
 215  * </pre>\r
 216  *\r
 217  * \par Init Functions\r
 218  * There is an associated initialization function for each type of matrix\r
 219  * data structure.\r
 220  * The initialization function sets the values of the internal structure fields.\r
 221  * Refer to the function <code>arm_mat_init_f32()</code>, <code>arm_mat_init_q31()</code>\r
 222  * and <code>arm_mat_init_q15()</code> for floating-point, Q31 and Q15 types,  respectively.\r
 223  *\r
 224  * \par\r
 225  * Use of the initialization function is optional. However, if initialization function is used\r
 226  * then the instance structure cannot be placed into a const data section.\r
 227  * To place the instance structure in a const data\r
 228  * section, manually initialize the data structure.  For example:\r
 229  * <pre>\r
 230  * <code>arm_matrix_instance_f32 S = {nRows, nColumns, pData};</code>\r
 231  * <code>arm_matrix_instance_q31 S = {nRows, nColumns, pData};</code>\r
 232  * <code>arm_matrix_instance_q15 S = {nRows, nColumns, pData};</code>\r
 233  * </pre>\r
 234  * where <code>nRows</code> specifies the number of rows, <code>nColumns</code>\r
 235  * specifies the number of columns, and <code>pData</code> points to the\r
 236  * data array.\r
 237  *\r
 238  * \par Size Checking\r
 239  * By default all of the matrix functions perform size checking on the input and\r
 240  * output matrices.  For example, the matrix addition function verifies that the\r
 241  * two input matrices and the output matrix all have the same number of rows and\r
 242  * columns.  If the size check fails the functions return:\r
 243  * <pre>\r
 244  *     ARM_MATH_SIZE_MISMATCH\r
 245  * </pre>\r
 246  * Otherwise the functions return\r
 247  * <pre>\r
 248  *     ARM_MATH_SUCCESS\r
 249  * </pre>\r
 250  * There is some overhead associated with this matrix size checking.\r
 251  * The matrix size checking is enabled via the \#define\r
 252  * <pre>\r
 253  *     ARM_MATH_MATRIX_CHECK\r
 254  * </pre>\r
 255  * within the library project settings.  By default this macro is defined\r
 256  * and size checking is enabled.  By changing the project settings and\r
 257  * undefining this macro size checking is eliminated and the functions\r
 258  * run a bit faster.  With size checking disabled the functions always\r
 259  * return <code>ARM_MATH_SUCCESS</code>.\r
 260  */\r
 261 \r
 262 /**\r
 263  * @defgroup groupTransforms Transform Functions\r
 264  */\r
 265 \r
 266 /**\r
 267  * @defgroup groupController Controller Functions\r
 268  */\r
 269 \r
 270 /**\r
 271  * @defgroup groupStats Statistics Functions\r
 272  */\r
 273 /**\r
 274  * @defgroup groupSupport Support Functions\r
 275  */\r
 276 \r
 277 /**\r
 278  * @defgroup groupInterpolation Interpolation Functions\r
 279  * These functions perform 1- and 2-dimensional interpolation of data.\r
 280  * Linear interpolation is used for 1-dimensional data and\r
 281  * bilinear interpolation is used for 2-dimensional data.\r
 282  */\r
 283 \r
 284 /**\r
 285  * @defgroup groupExamples Examples\r
 286  */\r
 287 #ifndef _ARM_MATH_H\r
 288 #define _ARM_MATH_H\r
 289 \r
 290 #define __CMSIS_GENERIC         /* disable NVIC and Systick functions */\r
 291 \r
 292 #if defined(ARM_MATH_CM7)\r
 293   #include "core_cm7.h"\r
 294 #elif defined (ARM_MATH_CM4)\r
 295   #include "core_cm4.h"\r
 296 #elif defined (ARM_MATH_CM3)\r
 297   #include "core_cm3.h"\r
 298 #elif defined (ARM_MATH_CM0)\r
 299   #include "core_cm0.h"\r
 300 #define ARM_MATH_CM0_FAMILY\r
 301   #elif defined (ARM_MATH_CM0PLUS)\r
 302 #include "core_cm0plus.h"\r
 303   #define ARM_MATH_CM0_FAMILY\r
 304 #else\r
 305   #error "Define according the used Cortex core ARM_MATH_CM7, ARM_MATH_CM4, ARM_MATH_CM3, ARM_MATH_CM0PLUS or ARM_MATH_CM0"\r
 306 #endif\r
 307 \r
 308 #undef  __CMSIS_GENERIC         /* enable NVIC and Systick functions */\r
 309 #include "string.h"\r
 310 #include "math.h"\r
 311 #ifdef  __cplusplus\r
 312 extern "C"\r
 313 {\r
 314 #endif\r
 315 \r
 316 \r
 317   /**\r
 318    * @brief Macros required for reciprocal calculation in Normalized LMS\r
 319    */\r
 320 \r
 321 #define DELTA_Q31                       (0x100)\r
 322 #define DELTA_Q15                       0x5\r
 323 #define INDEX_MASK                      0x0000003F\r
 324 #ifndef PI\r
 325 #define PI                                      3.14159265358979f\r
 326 #endif\r
 327 \r
 328   /**\r
 329    * @brief Macros required for SINE and COSINE Fast math approximations\r
 330    */\r
 331 \r
 332 #define FAST_MATH_TABLE_SIZE  512\r
 333 #define FAST_MATH_Q31_SHIFT   (32 - 10)\r
 334 #define FAST_MATH_Q15_SHIFT   (16 - 10)\r
 335 #define CONTROLLER_Q31_SHIFT  (32 - 9)\r
 336 #define TABLE_SIZE  256\r
 337 #define TABLE_SPACING_Q31          0x400000\r
 338 #define TABLE_SPACING_Q15          0x80\r
 339 \r
 340   /**\r
 341    * @brief Macros required for SINE and COSINE Controller functions\r
 342    */\r
 343   /* 1.31(q31) Fixed value of 2/360 */\r
 344   /* -1 to +1 is divided into 360 values so total spacing is (2/360) */\r
 345 #define INPUT_SPACING                   0xB60B61\r
 346 \r
 347   /**\r
 348    * @brief Macro for Unaligned Support\r
 349    */\r
 350 #ifndef UNALIGNED_SUPPORT_DISABLE\r
 351     #define ALIGN4\r
 352 #else\r
 353   #if defined  (__GNUC__)\r
 354     #define ALIGN4 __attribute__((aligned(4)))\r
 355   #else\r
 356     #define ALIGN4 __align(4)\r
 357   #endif\r
 358 #endif  /*      #ifndef UNALIGNED_SUPPORT_DISABLE       */\r
 359 \r
 360   /**\r
 361    * @brief Error status returned by some functions in the library.\r
 362    */\r
 363 \r
 364   typedef enum\r
 365   {\r
 366     ARM_MATH_SUCCESS = 0,                /**< No error */\r
 367     ARM_MATH_ARGUMENT_ERROR = -1,        /**< One or more arguments are incorrect */\r
 368     ARM_MATH_LENGTH_ERROR = -2,          /**< Length of data buffer is incorrect */\r
 369     ARM_MATH_SIZE_MISMATCH = -3,         /**< Size of matrices is not compatible with the operation. */\r
 370     ARM_MATH_NANINF = -4,                /**< Not-a-number (NaN) or infinity is generated */\r
 371     ARM_MATH_SINGULAR = -5,              /**< Generated by matrix inversion if the input matrix is singular and cannot be inverted. */\r
 372     ARM_MATH_TEST_FAILURE = -6           /**< Test Failed  */\r
 373   } arm_status;\r
 374 \r
 375   /**\r
 376    * @brief 8-bit fractional data type in 1.7 format.\r
 377    */\r
 378   typedef int8_t q7_t;\r
 379 \r
 380   /**\r
 381    * @brief 16-bit fractional data type in 1.15 format.\r
 382    */\r
 383   typedef int16_t q15_t;\r
 384 \r
 385   /**\r
 386    * @brief 32-bit fractional data type in 1.31 format.\r
 387    */\r
 388   typedef int32_t q31_t;\r
 389 \r
 390   /**\r
 391    * @brief 64-bit fractional data type in 1.63 format.\r
 392    */\r
 393   typedef int64_t q63_t;\r
 394 \r
 395   /**\r
 396    * @brief 32-bit floating-point type definition.\r
 397    */\r
 398   typedef float float32_t;\r
 399 \r
 400   /**\r
 401    * @brief 64-bit floating-point type definition.\r
 402    */\r
 403   typedef double float64_t;\r
 404 \r
 405   /**\r
 406    * @brief definition to read/write two 16 bit values.\r
 407    */\r
 408 #if defined __CC_ARM\r
 409 #define __SIMD32_TYPE int32_t __packed\r
 410 #define CMSIS_UNUSED __attribute__((unused))\r
 411 #elif defined __ICCARM__\r
 412 #define CMSIS_UNUSED\r
 413 #define __SIMD32_TYPE int32_t __packed\r
 414 #elif defined __GNUC__\r
 415 #define __SIMD32_TYPE int32_t\r
 416 #define CMSIS_UNUSED __attribute__((unused))\r
 417 #elif defined __CSMC__                  /* Cosmic */\r
 418 #define CMSIS_UNUSED\r
 419 #define __SIMD32_TYPE int32_t\r
 420 #else\r
 421 #error Unknown compiler\r
 422 #endif\r
 423 \r
 424 #define __SIMD32(addr)  (*(__SIMD32_TYPE **) & (addr))\r
 425 #define __SIMD32_CONST(addr)  ((__SIMD32_TYPE *)(addr))\r
 426 \r
 427 #define _SIMD32_OFFSET(addr)  (*(__SIMD32_TYPE *)  (addr))\r
 428 \r
 429 #define __SIMD64(addr)  (*(int64_t **) & (addr))\r
 430 \r
 431 #if defined (ARM_MATH_CM3) || defined (ARM_MATH_CM0_FAMILY)\r
 432   /**\r
 433    * @brief definition to pack two 16 bit values.\r
 434    */\r
 435 #define __PKHBT(ARG1, ARG2, ARG3)      ( (((int32_t)(ARG1) <<  0) & (int32_t)0x0000FFFF) | \\r
 436                                          (((int32_t)(ARG2) << ARG3) & (int32_t)0xFFFF0000)  )\r
 437 #define __PKHTB(ARG1, ARG2, ARG3)      ( (((int32_t)(ARG1) <<  0) & (int32_t)0xFFFF0000) | \\r
 438                                          (((int32_t)(ARG2) >> ARG3) & (int32_t)0x0000FFFF)  )\r
 439 \r
 440 #endif\r
 441 \r
 442 \r
 443    /**\r
 444    * @brief definition to pack four 8 bit values.\r
 445    */\r
 446 #ifndef ARM_MATH_BIG_ENDIAN\r
 447 \r
 448 #define __PACKq7(v0,v1,v2,v3) ( (((int32_t)(v0) <<  0) & (int32_t)0x000000FF) | \\r
 449                                 (((int32_t)(v1) <<  8) & (int32_t)0x0000FF00) | \\r
 450                                                             (((int32_t)(v2) << 16) & (int32_t)0x00FF0000) |     \\r
 451                                                             (((int32_t)(v3) << 24) & (int32_t)0xFF000000)  )\r
 452 #else\r
 453 \r
 454 #define __PACKq7(v0,v1,v2,v3) ( (((int32_t)(v3) <<  0) & (int32_t)0x000000FF) | \\r
 455                                 (((int32_t)(v2) <<  8) & (int32_t)0x0000FF00) | \\r
 456                                                             (((int32_t)(v1) << 16) & (int32_t)0x00FF0000) |     \\r
 457                                                             (((int32_t)(v0) << 24) & (int32_t)0xFF000000)  )\r
 458 \r
 459 #endif\r
 460 \r
 461 \r
 462   /**\r
 463    * @brief Clips Q63 to Q31 values.\r
 464    */\r
 465   static __INLINE q31_t clip_q63_to_q31(\r
 466   q63_t x)\r
 467   {\r
 468     return ((q31_t) (x >> 32) != ((q31_t) x >> 31)) ?\r
 469       ((0x7FFFFFFF ^ ((q31_t) (x >> 63)))) : (q31_t) x;\r
 470   }\r
 471 \r
 472   /**\r
 473    * @brief Clips Q63 to Q15 values.\r
 474    */\r
 475   static __INLINE q15_t clip_q63_to_q15(\r
 476   q63_t x)\r
 477   {\r
 478     return ((q31_t) (x >> 32) != ((q31_t) x >> 31)) ?\r
 479       ((0x7FFF ^ ((q15_t) (x >> 63)))) : (q15_t) (x >> 15);\r
 480   }\r
 481 \r
 482   /**\r
 483    * @brief Clips Q31 to Q7 values.\r
 484    */\r
 485   static __INLINE q7_t clip_q31_to_q7(\r
 486   q31_t x)\r
 487   {\r
 488     return ((q31_t) (x >> 24) != ((q31_t) x >> 23)) ?\r
 489       ((0x7F ^ ((q7_t) (x >> 31)))) : (q7_t) x;\r
 490   }\r
 491 \r
 492   /**\r
 493    * @brief Clips Q31 to Q15 values.\r
 494    */\r
 495   static __INLINE q15_t clip_q31_to_q15(\r
 496   q31_t x)\r
 497   {\r
 498     return ((q31_t) (x >> 16) != ((q31_t) x >> 15)) ?\r
 499       ((0x7FFF ^ ((q15_t) (x >> 31)))) : (q15_t) x;\r
 500   }\r
 501 \r
 502   /**\r
 503    * @brief Multiplies 32 X 64 and returns 32 bit result in 2.30 format.\r
 504    */\r
 505 \r
 506   static __INLINE q63_t mult32x64(\r
 507   q63_t x,\r
 508   q31_t y)\r
 509   {\r
 510     return ((((q63_t) (x & 0x00000000FFFFFFFF) * y) >> 32) +\r
 511             (((q63_t) (x >> 32) * y)));\r
 512   }\r
 513 \r
 514 \r
 515 #if defined (ARM_MATH_CM0_FAMILY) && defined ( __CC_ARM   )\r
 516 #define __CLZ __clz\r
 517 #endif\r
 518 \r
 519 #if defined (ARM_MATH_CM0_FAMILY) && ((defined (__ICCARM__)) ||(defined (__GNUC__)) || defined (__TASKING__) )\r
 520 \r
 521   static __INLINE uint32_t __CLZ(\r
 522   q31_t data);\r
 523 \r
 524 \r
 525   static __INLINE uint32_t __CLZ(\r
 526   q31_t data)\r
 527   {\r
 528     uint32_t count = 0;\r
 529     uint32_t mask = 0x80000000;\r
 530 \r
 531     while((data & mask) == 0)\r
 532     {\r
 533       count += 1u;\r
 534       mask = mask >> 1u;\r
 535     }\r
 536 \r
 537     return (count);\r
 538 \r
 539   }\r
 540 \r
 541 #endif\r
 542 \r
 543   /**\r
 544    * @brief Function to Calculates 1/in (reciprocal) value of Q31 Data type.\r
 545    */\r
 546 \r
 547   static __INLINE uint32_t arm_recip_q31(\r
 548   q31_t in,\r
 549   q31_t * dst,\r
 550   q31_t * pRecipTable)\r
 551   {\r
 552 \r
 553     uint32_t out, tempVal;\r
 554     uint32_t index, i;\r
 555     uint32_t signBits;\r
 556 \r
 557     if(in > 0)\r
 558     {\r
 559       signBits = __CLZ(in) - 1;\r
 560     }\r
 561     else\r
 562     {\r
 563       signBits = __CLZ(-in) - 1;\r
 564     }\r
 565 \r
 566     /* Convert input sample to 1.31 format */\r
 567     in = in << signBits;\r
 568 \r
 569     /* calculation of index for initial approximated Val */\r
 570     index = (uint32_t) (in >> 24u);\r
 571     index = (index & INDEX_MASK);\r
 572 \r
 573     /* 1.31 with exp 1 */\r
 574     out = pRecipTable[index];\r
 575 \r
 576     /* calculation of reciprocal value */\r
 577     /* running approximation for two iterations */\r
 578     for (i = 0u; i < 2u; i++)\r
 579     {\r
 580       tempVal = (q31_t) (((q63_t) in * out) >> 31u);\r
 581       tempVal = 0x7FFFFFFF - tempVal;\r
 582       /*      1.31 with exp 1 */\r
 583       //out = (q31_t) (((q63_t) out * tempVal) >> 30u);\r
 584       out = (q31_t) clip_q63_to_q31(((q63_t) out * tempVal) >> 30u);\r
 585     }\r
 586 \r
 587     /* write output */\r
 588     *dst = out;\r
 589 \r
 590     /* return num of signbits of out = 1/in value */\r
 591     return (signBits + 1u);\r
 592 \r
 593   }\r
 594 \r
 595   /**\r
 596    * @brief Function to Calculates 1/in (reciprocal) value of Q15 Data type.\r
 597    */\r
 598   static __INLINE uint32_t arm_recip_q15(\r
 599   q15_t in,\r
 600   q15_t * dst,\r
 601   q15_t * pRecipTable)\r
 602   {\r
 603 \r
 604     uint32_t out = 0, tempVal = 0;\r
 605     uint32_t index = 0, i = 0;\r
 606     uint32_t signBits = 0;\r
 607 \r
 608     if(in > 0)\r
 609     {\r
 610       signBits = __CLZ(in) - 17;\r
 611     }\r
 612     else\r
 613     {\r
 614       signBits = __CLZ(-in) - 17;\r
 615     }\r
 616 \r
 617     /* Convert input sample to 1.15 format */\r
 618     in = in << signBits;\r
 619 \r
 620     /* calculation of index for initial approximated Val */\r
 621     index = in >> 8;\r
 622     index = (index & INDEX_MASK);\r
 623 \r
 624     /*      1.15 with exp 1  */\r
 625     out = pRecipTable[index];\r
 626 \r
 627     /* calculation of reciprocal value */\r
 628     /* running approximation for two iterations */\r
 629     for (i = 0; i < 2; i++)\r
 630     {\r
 631       tempVal = (q15_t) (((q31_t) in * out) >> 15);\r
 632       tempVal = 0x7FFF - tempVal;\r
 633       /*      1.15 with exp 1 */\r
 634       out = (q15_t) (((q31_t) out * tempVal) >> 14);\r
 635     }\r
 636 \r
 637     /* write output */\r
 638     *dst = out;\r
 639 \r
 640     /* return num of signbits of out = 1/in value */\r
 641     return (signBits + 1);\r
 642 \r
 643   }\r
 644 \r
 645 \r
 646   /*\r
 647    * @brief C custom defined intrinisic function for only M0 processors\r
 648    */\r
 649 #if defined(ARM_MATH_CM0_FAMILY)\r
 650 \r
 651   static __INLINE q31_t __SSAT(\r
 652   q31_t x,\r
 653   uint32_t y)\r
 654   {\r
 655     int32_t posMax, negMin;\r
 656     uint32_t i;\r
 657 \r
 658     posMax = 1;\r
 659     for (i = 0; i < (y - 1); i++)\r
 660     {\r
 661       posMax = posMax * 2;\r
 662     }\r
 663 \r
 664     if(x > 0)\r
 665     {\r
 666       posMax = (posMax - 1);\r
 667 \r
 668       if(x > posMax)\r
 669       {\r
 670         x = posMax;\r
 671       }\r
 672     }\r
 673     else\r
 674     {\r
 675       negMin = -posMax;\r
 676 \r
 677       if(x < negMin)\r
 678       {\r
 679         x = negMin;\r
 680       }\r
 681     }\r
 682     return (x);\r
 683 \r
 684 \r
 685   }\r
 686 \r
 687 #endif /* end of ARM_MATH_CM0_FAMILY */\r
 688 \r
 689 \r
 690 \r
 691   /*\r
 692    * @brief C custom defined intrinsic function for M3 and M0 processors\r
 693    */\r
 694 #if defined (ARM_MATH_CM3) || defined (ARM_MATH_CM0_FAMILY)\r
 695 \r
 696   /*\r
 697    * @brief C custom defined QADD8 for M3 and M0 processors\r
 698    */\r
 699   static __INLINE q31_t __QADD8(\r
 700   q31_t x,\r
 701   q31_t y)\r
 702   {\r
 703 \r
 704     q31_t sum;\r
 705     q7_t r, s, t, u;\r
 706 \r
 707     r = (q7_t) x;\r
 708     s = (q7_t) y;\r
 709 \r
 710     r = __SSAT((q31_t) (r + s), 8);\r
 711     s = __SSAT(((q31_t) (((x << 16) >> 24) + ((y << 16) >> 24))), 8);\r
 712     t = __SSAT(((q31_t) (((x << 8) >> 24) + ((y << 8) >> 24))), 8);\r
 713     u = __SSAT(((q31_t) ((x >> 24) + (y >> 24))), 8);\r
 714 \r
 715     sum =\r
 716       (((q31_t) u << 24) & 0xFF000000) | (((q31_t) t << 16) & 0x00FF0000) |\r
 717       (((q31_t) s << 8) & 0x0000FF00) | (r & 0x000000FF);\r
 718 \r
 719     return sum;\r
 720 \r
 721   }\r
 722 \r
 723   /*\r
 724    * @brief C custom defined QSUB8 for M3 and M0 processors\r
 725    */\r
 726   static __INLINE q31_t __QSUB8(\r
 727   q31_t x,\r
 728   q31_t y)\r
 729   {\r
 730 \r
 731     q31_t sum;\r
 732     q31_t r, s, t, u;\r
 733 \r
 734     r = (q7_t) x;\r
 735     s = (q7_t) y;\r
 736 \r
 737     r = __SSAT((r - s), 8);\r
 738     s = __SSAT(((q31_t) (((x << 16) >> 24) - ((y << 16) >> 24))), 8) << 8;\r
 739     t = __SSAT(((q31_t) (((x << 8) >> 24) - ((y << 8) >> 24))), 8) << 16;\r
 740     u = __SSAT(((q31_t) ((x >> 24) - (y >> 24))), 8) << 24;\r
 741 \r
 742     sum =\r
 743       (u & 0xFF000000) | (t & 0x00FF0000) | (s & 0x0000FF00) | (r &\r
 744                                                                 0x000000FF);\r
 745 \r
 746     return sum;\r
 747   }\r
 748 \r
 749   /*\r
 750    * @brief C custom defined QADD16 for M3 and M0 processors\r
 751    */\r
 752 \r
 753   /*\r
 754    * @brief C custom defined QADD16 for M3 and M0 processors\r
 755    */\r
 756   static __INLINE q31_t __QADD16(\r
 757   q31_t x,\r
 758   q31_t y)\r
 759   {\r
 760 \r
 761     q31_t sum;\r
 762     q31_t r, s;\r
 763 \r
 764     r = (q15_t) x;\r
 765     s = (q15_t) y;\r
 766 \r
 767     r = __SSAT(r + s, 16);\r
 768     s = __SSAT(((q31_t) ((x >> 16) + (y >> 16))), 16) << 16;\r
 769 \r
 770     sum = (s & 0xFFFF0000) | (r & 0x0000FFFF);\r
 771 \r
 772     return sum;\r
 773 \r
 774   }\r
 775 \r
 776   /*\r
 777    * @brief C custom defined SHADD16 for M3 and M0 processors\r
 778    */\r
 779   static __INLINE q31_t __SHADD16(\r
 780   q31_t x,\r
 781   q31_t y)\r
 782   {\r
 783 \r
 784     q31_t sum;\r
 785     q31_t r, s;\r
 786 \r
 787     r = (q15_t) x;\r
 788     s = (q15_t) y;\r
 789 \r
 790     r = ((r >> 1) + (s >> 1));\r
 791     s = ((q31_t) ((x >> 17) + (y >> 17))) << 16;\r
 792 \r
 793     sum = (s & 0xFFFF0000) | (r & 0x0000FFFF);\r
 794 \r
 795     return sum;\r
 796 \r
 797   }\r
 798 \r
 799   /*\r
 800    * @brief C custom defined QSUB16 for M3 and M0 processors\r
 801    */\r
 802   static __INLINE q31_t __QSUB16(\r
 803   q31_t x,\r
 804   q31_t y)\r
 805   {\r
 806 \r
 807     q31_t sum;\r
 808     q31_t r, s;\r
 809 \r
 810     r = (q15_t) x;\r
 811     s = (q15_t) y;\r
 812 \r
 813     r = __SSAT(r - s, 16);\r
 814     s = __SSAT(((q31_t) ((x >> 16) - (y >> 16))), 16) << 16;\r
 815 \r
 816     sum = (s & 0xFFFF0000) | (r & 0x0000FFFF);\r
 817 \r
 818     return sum;\r
 819   }\r
 820 \r
 821   /*\r
 822    * @brief C custom defined SHSUB16 for M3 and M0 processors\r
 823    */\r
 824   static __INLINE q31_t __SHSUB16(\r
 825   q31_t x,\r
 826   q31_t y)\r
 827   {\r
 828 \r
 829     q31_t diff;\r
 830     q31_t r, s;\r
 831 \r
 832     r = (q15_t) x;\r
 833     s = (q15_t) y;\r
 834 \r
 835     r = ((r >> 1) - (s >> 1));\r
 836     s = (((x >> 17) - (y >> 17)) << 16);\r
 837 \r
 838     diff = (s & 0xFFFF0000) | (r & 0x0000FFFF);\r
 839 \r
 840     return diff;\r
 841   }\r
 842 \r
 843   /*\r
 844    * @brief C custom defined QASX for M3 and M0 processors\r
 845    */\r
 846   static __INLINE q31_t __QASX(\r
 847   q31_t x,\r
 848   q31_t y)\r
 849   {\r
 850 \r
 851     q31_t sum = 0;\r
 852 \r
 853     sum =\r
 854       ((sum +\r
 855         clip_q31_to_q15((q31_t) ((q15_t) (x >> 16) + (q15_t) y))) << 16) +\r
 856       clip_q31_to_q15((q31_t) ((q15_t) x - (q15_t) (y >> 16)));\r
 857 \r
 858     return sum;\r
 859   }\r
 860 \r
 861   /*\r
 862    * @brief C custom defined SHASX for M3 and M0 processors\r
 863    */\r
 864   static __INLINE q31_t __SHASX(\r
 865   q31_t x,\r
 866   q31_t y)\r
 867   {\r
 868 \r
 869     q31_t sum;\r
 870     q31_t r, s;\r
 871 \r
 872     r = (q15_t) x;\r
 873     s = (q15_t) y;\r
 874 \r
 875     r = ((r >> 1) - (y >> 17));\r
 876     s = (((x >> 17) + (s >> 1)) << 16);\r
 877 \r
 878     sum = (s & 0xFFFF0000) | (r & 0x0000FFFF);\r
 879 \r
 880     return sum;\r
 881   }\r
 882 \r
 883 \r
 884   /*\r
 885    * @brief C custom defined QSAX for M3 and M0 processors\r
 886    */\r
 887   static __INLINE q31_t __QSAX(\r
 888   q31_t x,\r
 889   q31_t y)\r
 890   {\r
 891 \r
 892     q31_t sum = 0;\r
 893 \r
 894     sum =\r
 895       ((sum +\r
 896         clip_q31_to_q15((q31_t) ((q15_t) (x >> 16) - (q15_t) y))) << 16) +\r
 897       clip_q31_to_q15((q31_t) ((q15_t) x + (q15_t) (y >> 16)));\r
 898 \r
 899     return sum;\r
 900   }\r
 901 \r
 902   /*\r
 903    * @brief C custom defined SHSAX for M3 and M0 processors\r
 904    */\r
 905   static __INLINE q31_t __SHSAX(\r
 906   q31_t x,\r
 907   q31_t y)\r
 908   {\r
 909 \r
 910     q31_t sum;\r
 911     q31_t r, s;\r
 912 \r
 913     r = (q15_t) x;\r
 914     s = (q15_t) y;\r
 915 \r
 916     r = ((r >> 1) + (y >> 17));\r
 917     s = (((x >> 17) - (s >> 1)) << 16);\r
 918 \r
 919     sum = (s & 0xFFFF0000) | (r & 0x0000FFFF);\r
 920 \r
 921     return sum;\r
 922   }\r
 923 \r
 924   /*\r
 925    * @brief C custom defined SMUSDX for M3 and M0 processors\r
 926    */\r
 927   static __INLINE q31_t __SMUSDX(\r
 928   q31_t x,\r
 929   q31_t y)\r
 930   {\r
 931 \r
 932     return ((q31_t) (((q15_t) x * (q15_t) (y >> 16)) -\r
 933                      ((q15_t) (x >> 16) * (q15_t) y)));\r
 934   }\r
 935 \r
 936   /*\r
 937    * @brief C custom defined SMUADX for M3 and M0 processors\r
 938    */\r
 939   static __INLINE q31_t __SMUADX(\r
 940   q31_t x,\r
 941   q31_t y)\r
 942   {\r
 943 \r
 944     return ((q31_t) (((q15_t) x * (q15_t) (y >> 16)) +\r
 945                      ((q15_t) (x >> 16) * (q15_t) y)));\r
 946   }\r
 947 \r
 948   /*\r
 949    * @brief C custom defined QADD for M3 and M0 processors\r
 950    */\r
 951   static __INLINE q31_t __QADD(\r
 952   q31_t x,\r
 953   q31_t y)\r
 954   {\r
 955     return clip_q63_to_q31((q63_t) x + y);\r
 956   }\r
 957 \r
 958   /*\r
 959    * @brief C custom defined QSUB for M3 and M0 processors\r
 960    */\r
 961   static __INLINE q31_t __QSUB(\r
 962   q31_t x,\r
 963   q31_t y)\r
 964   {\r
 965     return clip_q63_to_q31((q63_t) x - y);\r
 966   }\r
 967 \r
 968   /*\r
 969    * @brief C custom defined SMLAD for M3 and M0 processors\r
 970    */\r
 971   static __INLINE q31_t __SMLAD(\r
 972   q31_t x,\r
 973   q31_t y,\r
 974   q31_t sum)\r
 975   {\r
 976 \r
 977     return (sum + ((q15_t) (x >> 16) * (q15_t) (y >> 16)) +\r
 978             ((q15_t) x * (q15_t) y));\r
 979   }\r
 980 \r
 981   /*\r
 982    * @brief C custom defined SMLADX for M3 and M0 processors\r
 983    */\r
 984   static __INLINE q31_t __SMLADX(\r
 985   q31_t x,\r
 986   q31_t y,\r
 987   q31_t sum)\r
 988   {\r
 989 \r
 990     return (sum + ((q15_t) (x >> 16) * (q15_t) (y)) +\r
 991             ((q15_t) x * (q15_t) (y >> 16)));\r
 992   }\r
 993 \r
 994   /*\r
 995    * @brief C custom defined SMLSDX for M3 and M0 processors\r
 996    */\r
 997   static __INLINE q31_t __SMLSDX(\r
 998   q31_t x,\r
 999   q31_t y,\r
1000   q31_t sum)\r
1001   {\r
1002 \r
1003     return (sum - ((q15_t) (x >> 16) * (q15_t) (y)) +\r
1004             ((q15_t) x * (q15_t) (y >> 16)));\r
1005   }\r
1006 \r
1007   /*\r
1008    * @brief C custom defined SMLALD for M3 and M0 processors\r
1009    */\r
1010   static __INLINE q63_t __SMLALD(\r
1011   q31_t x,\r
1012   q31_t y,\r
1013   q63_t sum)\r
1014   {\r
1015 \r
1016     return (sum + ((q15_t) (x >> 16) * (q15_t) (y >> 16)) +\r
1017             ((q15_t) x * (q15_t) y));\r
1018   }\r
1019 \r
1020   /*\r
1021    * @brief C custom defined SMLALDX for M3 and M0 processors\r
1022    */\r
1023   static __INLINE q63_t __SMLALDX(\r
1024   q31_t x,\r
1025   q31_t y,\r
1026   q63_t sum)\r
1027   {\r
1028 \r
1029     return (sum + ((q15_t) (x >> 16) * (q15_t) y)) +\r
1030       ((q15_t) x * (q15_t) (y >> 16));\r
1031   }\r
1032 \r
1033   /*\r
1034    * @brief C custom defined SMUAD for M3 and M0 processors\r
1035    */\r
1036   static __INLINE q31_t __SMUAD(\r
1037   q31_t x,\r
1038   q31_t y)\r
1039   {\r
1040 \r
1041     return (((x >> 16) * (y >> 16)) +\r
1042             (((x << 16) >> 16) * ((y << 16) >> 16)));\r
1043   }\r
1044 \r
1045   /*\r
1046    * @brief C custom defined SMUSD for M3 and M0 processors\r
1047    */\r
1048   static __INLINE q31_t __SMUSD(\r
1049   q31_t x,\r
1050   q31_t y)\r
1051   {\r
1052 \r
1053     return (-((x >> 16) * (y >> 16)) +\r
1054             (((x << 16) >> 16) * ((y << 16) >> 16)));\r
1055   }\r
1056 \r
1057 \r
1058   /*\r
1059    * @brief C custom defined SXTB16 for M3 and M0 processors\r
1060    */\r
1061   static __INLINE q31_t __SXTB16(\r
1062   q31_t x)\r
1063   {\r
1064 \r
1065     return ((((x << 24) >> 24) & 0x0000FFFF) |\r
1066             (((x << 8) >> 8) & 0xFFFF0000));\r
1067   }\r
1068 \r
1069 \r
1070 #endif /* defined (ARM_MATH_CM3) || defined (ARM_MATH_CM0_FAMILY) */\r
1071 \r
1072 \r
1073   /**\r
1074    * @brief Instance structure for the Q7 FIR filter.\r
1075    */\r
1076   typedef struct\r
1077   {\r
1078     uint16_t numTaps;        /**< number of filter coefficients in the filter. */\r
1079     q7_t *pState;            /**< points to the state variable array. The array is of length numTaps+blockSize-1. */\r
1080     q7_t *pCoeffs;           /**< points to the coefficient array. The array is of length numTaps.*/\r
1081   } arm_fir_instance_q7;\r
1082 \r
1083   /**\r
1084    * @brief Instance structure for the Q15 FIR filter.\r
1085    */\r
1086   typedef struct\r
1087   {\r
1088     uint16_t numTaps;         /**< number of filter coefficients in the filter. */\r
1089     q15_t *pState;            /**< points to the state variable array. The array is of length numTaps+blockSize-1. */\r
1090     q15_t *pCoeffs;           /**< points to the coefficient array. The array is of length numTaps.*/\r
1091   } arm_fir_instance_q15;\r
1092 \r
1093   /**\r
1094    * @brief Instance structure for the Q31 FIR filter.\r
1095    */\r
1096   typedef struct\r
1097   {\r
1098     uint16_t numTaps;         /**< number of filter coefficients in the filter. */\r
1099     q31_t *pState;            /**< points to the state variable array. The array is of length numTaps+blockSize-1. */\r
1100     q31_t *pCoeffs;           /**< points to the coefficient array. The array is of length numTaps. */\r
1101   } arm_fir_instance_q31;\r
1102 \r
1103   /**\r
1104    * @brief Instance structure for the floating-point FIR filter.\r
1105    */\r
1106   typedef struct\r
1107   {\r
1108     uint16_t numTaps;     /**< number of filter coefficients in the filter. */\r
1109     float32_t *pState;    /**< points to the state variable array. The array is of length numTaps+blockSize-1. */\r
1110     float32_t *pCoeffs;   /**< points to the coefficient array. The array is of length numTaps. */\r
1111   } arm_fir_instance_f32;\r
1112 \r
1113 \r
1114   /**\r
1115    * @brief Processing function for the Q7 FIR filter.\r
1116    * @param[in] *S points to an instance of the Q7 FIR filter structure.\r
1117    * @param[in] *pSrc points to the block of input data.\r
1118    * @param[out] *pDst points to the block of output data.\r
1119    * @param[in] blockSize number of samples to process.\r
1120    * @return none.\r
1121    */\r
1122   void arm_fir_q7(\r
1123   const arm_fir_instance_q7 * S,\r
1124   q7_t * pSrc,\r
1125   q7_t * pDst,\r
1126   uint32_t blockSize);\r
1127 \r
1128 \r
1129   /**\r
1130    * @brief  Initialization function for the Q7 FIR filter.\r
1131    * @param[in,out] *S points to an instance of the Q7 FIR structure.\r
1132    * @param[in] numTaps  Number of filter coefficients in the filter.\r
1133    * @param[in] *pCoeffs points to the filter coefficients.\r
1134    * @param[in] *pState points to the state buffer.\r
1135    * @param[in] blockSize number of samples that are processed.\r
1136    * @return none\r
1137    */\r
1138   void arm_fir_init_q7(\r
1139   arm_fir_instance_q7 * S,\r
1140   uint16_t numTaps,\r
1141   q7_t * pCoeffs,\r
1142   q7_t * pState,\r
1143   uint32_t blockSize);\r
1144 \r
1145 \r
1146   /**\r
1147    * @brief Processing function for the Q15 FIR filter.\r
1148    * @param[in] *S points to an instance of the Q15 FIR structure.\r
1149    * @param[in] *pSrc points to the block of input data.\r
1150    * @param[out] *pDst points to the block of output data.\r
1151    * @param[in] blockSize number of samples to process.\r
1152    * @return none.\r
1153    */\r
1154   void arm_fir_q15(\r
1155   const arm_fir_instance_q15 * S,\r
1156   q15_t * pSrc,\r
1157   q15_t * pDst,\r
1158   uint32_t blockSize);\r
1159 \r
1160   /**\r
1161    * @brief Processing function for the fast Q15 FIR filter for Cortex-M3 and Cortex-M4.\r
1162    * @param[in] *S points to an instance of the Q15 FIR filter structure.\r
1163    * @param[in] *pSrc points to the block of input data.\r
1164    * @param[out] *pDst points to the block of output data.\r
1165    * @param[in] blockSize number of samples to process.\r
1166    * @return none.\r
1167    */\r
1168   void arm_fir_fast_q15(\r
1169   const arm_fir_instance_q15 * S,\r
1170   q15_t * pSrc,\r
1171   q15_t * pDst,\r
1172   uint32_t blockSize);\r
1173 \r
1174   /**\r
1175    * @brief  Initialization function for the Q15 FIR filter.\r
1176    * @param[in,out] *S points to an instance of the Q15 FIR filter structure.\r
1177    * @param[in] numTaps  Number of filter coefficients in the filter. Must be even and greater than or equal to 4.\r
1178    * @param[in] *pCoeffs points to the filter coefficients.\r
1179    * @param[in] *pState points to the state buffer.\r
1180    * @param[in] blockSize number of samples that are processed at a time.\r
1181    * @return The function returns ARM_MATH_SUCCESS if initialization was successful or ARM_MATH_ARGUMENT_ERROR if\r
1182    * <code>numTaps</code> is not a supported value.\r
1183    */\r
1184 \r
1185   arm_status arm_fir_init_q15(\r
1186   arm_fir_instance_q15 * S,\r
1187   uint16_t numTaps,\r
1188   q15_t * pCoeffs,\r
1189   q15_t * pState,\r
1190   uint32_t blockSize);\r
1191 \r
1192   /**\r
1193    * @brief Processing function for the Q31 FIR filter.\r
1194    * @param[in] *S points to an instance of the Q31 FIR filter structure.\r
1195    * @param[in] *pSrc points to the block of input data.\r
1196    * @param[out] *pDst points to the block of output data.\r
1197    * @param[in] blockSize number of samples to process.\r
1198    * @return none.\r
1199    */\r
1200   void arm_fir_q31(\r
1201   const arm_fir_instance_q31 * S,\r
1202   q31_t * pSrc,\r
1203   q31_t * pDst,\r
1204   uint32_t blockSize);\r
1205 \r
1206   /**\r
1207    * @brief Processing function for the fast Q31 FIR filter for Cortex-M3 and Cortex-M4.\r
1208    * @param[in] *S points to an instance of the Q31 FIR structure.\r
1209    * @param[in] *pSrc points to the block of input data.\r
1210    * @param[out] *pDst points to the block of output data.\r
1211    * @param[in] blockSize number of samples to process.\r
1212    * @return none.\r
1213    */\r
1214   void arm_fir_fast_q31(\r
1215   const arm_fir_instance_q31 * S,\r
1216   q31_t * pSrc,\r
1217   q31_t * pDst,\r
1218   uint32_t blockSize);\r
1219 \r
1220   /**\r
1221    * @brief  Initialization function for the Q31 FIR filter.\r
1222    * @param[in,out] *S points to an instance of the Q31 FIR structure.\r
1223    * @param[in]         numTaps  Number of filter coefficients in the filter.\r
1224    * @param[in]         *pCoeffs points to the filter coefficients.\r
1225    * @param[in]         *pState points to the state buffer.\r
1226    * @param[in]         blockSize number of samples that are processed at a time.\r
1227    * @return            none.\r
1228    */\r
1229   void arm_fir_init_q31(\r
1230   arm_fir_instance_q31 * S,\r
1231   uint16_t numTaps,\r
1232   q31_t * pCoeffs,\r
1233   q31_t * pState,\r
1234   uint32_t blockSize);\r
1235 \r
1236   /**\r
1237    * @brief Processing function for the floating-point FIR filter.\r
1238    * @param[in] *S points to an instance of the floating-point FIR structure.\r
1239    * @param[in] *pSrc points to the block of input data.\r
1240    * @param[out] *pDst points to the block of output data.\r
1241    * @param[in] blockSize number of samples to process.\r
1242    * @return none.\r
1243    */\r
1244   void arm_fir_f32(\r
1245   const arm_fir_instance_f32 * S,\r
1246   float32_t * pSrc,\r
1247   float32_t * pDst,\r
1248   uint32_t blockSize);\r
1249 \r
1250   /**\r
1251    * @brief  Initialization function for the floating-point FIR filter.\r
1252    * @param[in,out] *S points to an instance of the floating-point FIR filter structure.\r
1253    * @param[in]         numTaps  Number of filter coefficients in the filter.\r
1254    * @param[in]         *pCoeffs points to the filter coefficients.\r
1255    * @param[in]         *pState points to the state buffer.\r
1256    * @param[in]         blockSize number of samples that are processed at a time.\r
1257    * @return            none.\r
1258    */\r
1259   void arm_fir_init_f32(\r
1260   arm_fir_instance_f32 * S,\r
1261   uint16_t numTaps,\r
1262   float32_t * pCoeffs,\r
1263   float32_t * pState,\r
1264   uint32_t blockSize);\r
1265 \r
1266 \r
1267   /**\r
1268    * @brief Instance structure for the Q15 Biquad cascade filter.\r
1269    */\r
1270   typedef struct\r
1271   {\r
1272     int8_t numStages;         /**< number of 2nd order stages in the filter.  Overall order is 2*numStages. */\r
1273     q15_t *pState;            /**< Points to the array of state coefficients.  The array is of length 4*numStages. */\r
1274     q15_t *pCoeffs;           /**< Points to the array of coefficients.  The array is of length 5*numStages. */\r
1275     int8_t postShift;         /**< Additional shift, in bits, applied to each output sample. */\r
1276 \r
1277   } arm_biquad_casd_df1_inst_q15;\r
1278 \r
1279 \r
1280   /**\r
1281    * @brief Instance structure for the Q31 Biquad cascade filter.\r
1282    */\r
1283   typedef struct\r
1284   {\r
1285     uint32_t numStages;      /**< number of 2nd order stages in the filter.  Overall order is 2*numStages. */\r
1286     q31_t *pState;           /**< Points to the array of state coefficients.  The array is of length 4*numStages. */\r
1287     q31_t *pCoeffs;          /**< Points to the array of coefficients.  The array is of length 5*numStages. */\r
1288     uint8_t postShift;       /**< Additional shift, in bits, applied to each output sample. */\r
1289 \r
1290   } arm_biquad_casd_df1_inst_q31;\r
1291 \r
1292   /**\r
1293    * @brief Instance structure for the floating-point Biquad cascade filter.\r
1294    */\r
1295   typedef struct\r
1296   {\r
1297     uint32_t numStages;         /**< number of 2nd order stages in the filter.  Overall order is 2*numStages. */\r
1298     float32_t *pState;          /**< Points to the array of state coefficients.  The array is of length 4*numStages. */\r
1299     float32_t *pCoeffs;         /**< Points to the array of coefficients.  The array is of length 5*numStages. */\r
1300 \r
1301 \r
1302   } arm_biquad_casd_df1_inst_f32;\r
1303 \r
1304 \r
1305 \r
1306   /**\r
1307    * @brief Processing function for the Q15 Biquad cascade filter.\r
1308    * @param[in]  *S points to an instance of the Q15 Biquad cascade structure.\r
1309    * @param[in]  *pSrc points to the block of input data.\r
1310    * @param[out] *pDst points to the block of output data.\r
1311    * @param[in]  blockSize number of samples to process.\r
1312    * @return     none.\r
1313    */\r
1314 \r
1315   void arm_biquad_cascade_df1_q15(\r
1316   const arm_biquad_casd_df1_inst_q15 * S,\r
1317   q15_t * pSrc,\r
1318   q15_t * pDst,\r
1319   uint32_t blockSize);\r
1320 \r
1321   /**\r
1322    * @brief  Initialization function for the Q15 Biquad cascade filter.\r
1323    * @param[in,out] *S           points to an instance of the Q15 Biquad cascade structure.\r
1324    * @param[in]     numStages    number of 2nd order stages in the filter.\r
1325    * @param[in]     *pCoeffs     points to the filter coefficients.\r
1326    * @param[in]     *pState      points to the state buffer.\r
1327    * @param[in]     postShift    Shift to be applied to the output. Varies according to the coefficients format\r
1328    * @return        none\r
1329    */\r
1330 \r
1331   void arm_biquad_cascade_df1_init_q15(\r
1332   arm_biquad_casd_df1_inst_q15 * S,\r
1333   uint8_t numStages,\r
1334   q15_t * pCoeffs,\r
1335   q15_t * pState,\r
1336   int8_t postShift);\r
1337 \r
1338 \r
1339   /**\r
1340    * @brief Fast but less precise processing function for the Q15 Biquad cascade filter for Cortex-M3 and Cortex-M4.\r
1341    * @param[in]  *S points to an instance of the Q15 Biquad cascade structure.\r
1342    * @param[in]  *pSrc points to the block of input data.\r
1343    * @param[out] *pDst points to the block of output data.\r
1344    * @param[in]  blockSize number of samples to process.\r
1345    * @return     none.\r
1346    */\r
1347 \r
1348   void arm_biquad_cascade_df1_fast_q15(\r
1349   const arm_biquad_casd_df1_inst_q15 * S,\r
1350   q15_t * pSrc,\r
1351   q15_t * pDst,\r
1352   uint32_t blockSize);\r
1353 \r
1354 \r
1355   /**\r
1356    * @brief Processing function for the Q31 Biquad cascade filter\r
1357    * @param[in]  *S         points to an instance of the Q31 Biquad cascade structure.\r
1358    * @param[in]  *pSrc      points to the block of input data.\r
1359    * @param[out] *pDst      points to the block of output data.\r
1360    * @param[in]  blockSize  number of samples to process.\r
1361    * @return     none.\r
1362    */\r
1363 \r
1364   void arm_biquad_cascade_df1_q31(\r
1365   const arm_biquad_casd_df1_inst_q31 * S,\r
1366   q31_t * pSrc,\r
1367   q31_t * pDst,\r
1368   uint32_t blockSize);\r
1369 \r
1370   /**\r
1371    * @brief Fast but less precise processing function for the Q31 Biquad cascade filter for Cortex-M3 and Cortex-M4.\r
1372    * @param[in]  *S         points to an instance of the Q31 Biquad cascade structure.\r
1373    * @param[in]  *pSrc      points to the block of input data.\r
1374    * @param[out] *pDst      points to the block of output data.\r
1375    * @param[in]  blockSize  number of samples to process.\r
1376    * @return     none.\r
1377    */\r
1378 \r
1379   void arm_biquad_cascade_df1_fast_q31(\r
1380   const arm_biquad_casd_df1_inst_q31 * S,\r
1381   q31_t * pSrc,\r
1382   q31_t * pDst,\r
1383   uint32_t blockSize);\r
1384 \r
1385   /**\r
1386    * @brief  Initialization function for the Q31 Biquad cascade filter.\r
1387    * @param[in,out] *S           points to an instance of the Q31 Biquad cascade structure.\r
1388    * @param[in]     numStages      number of 2nd order stages in the filter.\r
1389    * @param[in]     *pCoeffs     points to the filter coefficients.\r
1390    * @param[in]     *pState      points to the state buffer.\r
1391    * @param[in]     postShift    Shift to be applied to the output. Varies according to the coefficients format\r
1392    * @return        none\r
1393    */\r
1394 \r
1395   void arm_biquad_cascade_df1_init_q31(\r
1396   arm_biquad_casd_df1_inst_q31 * S,\r
1397   uint8_t numStages,\r
1398   q31_t * pCoeffs,\r
1399   q31_t * pState,\r
1400   int8_t postShift);\r
1401 \r
1402   /**\r
1403    * @brief Processing function for the floating-point Biquad cascade filter.\r
1404    * @param[in]  *S         points to an instance of the floating-point Biquad cascade structure.\r
1405    * @param[in]  *pSrc      points to the block of input data.\r
1406    * @param[out] *pDst      points to the block of output data.\r
1407    * @param[in]  blockSize  number of samples to process.\r
1408    * @return     none.\r
1409    */\r
1410 \r
1411   void arm_biquad_cascade_df1_f32(\r
1412   const arm_biquad_casd_df1_inst_f32 * S,\r
1413   float32_t * pSrc,\r
1414   float32_t * pDst,\r
1415   uint32_t blockSize);\r
1416 \r
1417   /**\r
1418    * @brief  Initialization function for the floating-point Biquad cascade filter.\r
1419    * @param[in,out] *S           points to an instance of the floating-point Biquad cascade structure.\r
1420    * @param[in]     numStages    number of 2nd order stages in the filter.\r
1421    * @param[in]     *pCoeffs     points to the filter coefficients.\r
1422    * @param[in]     *pState      points to the state buffer.\r
1423    * @return        none\r
1424    */\r
1425 \r
1426   void arm_biquad_cascade_df1_init_f32(\r
1427   arm_biquad_casd_df1_inst_f32 * S,\r
1428   uint8_t numStages,\r
1429   float32_t * pCoeffs,\r
1430   float32_t * pState);\r
1431 \r
1432 \r
1433   /**\r
1434    * @brief Instance structure for the floating-point matrix structure.\r
1435    */\r
1436 \r
1437   typedef struct\r
1438   {\r
1439     uint16_t numRows;     /**< number of rows of the matrix.     */\r
1440     uint16_t numCols;     /**< number of columns of the matrix.  */\r
1441     float32_t *pData;     /**< points to the data of the matrix. */\r
1442   } arm_matrix_instance_f32;\r
1443 \r
1444 \r
1445   /**\r
1446    * @brief Instance structure for the floating-point matrix structure.\r
1447    */\r
1448 \r
1449   typedef struct\r
1450   {\r
1451     uint16_t numRows;     /**< number of rows of the matrix.     */\r
1452     uint16_t numCols;     /**< number of columns of the matrix.  */\r
1453     float64_t *pData;     /**< points to the data of the matrix. */\r
1454   } arm_matrix_instance_f64;\r
1455 \r
1456   /**\r
1457    * @brief Instance structure for the Q15 matrix structure.\r
1458    */\r
1459 \r
1460   typedef struct\r
1461   {\r
1462     uint16_t numRows;     /**< number of rows of the matrix.     */\r
1463     uint16_t numCols;     /**< number of columns of the matrix.  */\r
1464     q15_t *pData;         /**< points to the data of the matrix. */\r
1465 \r
1466   } arm_matrix_instance_q15;\r
1467 \r
1468   /**\r
1469    * @brief Instance structure for the Q31 matrix structure.\r
1470    */\r
1471 \r
1472   typedef struct\r
1473   {\r
1474     uint16_t numRows;     /**< number of rows of the matrix.     */\r
1475     uint16_t numCols;     /**< number of columns of the matrix.  */\r
1476     q31_t *pData;         /**< points to the data of the matrix. */\r
1477 \r
1478   } arm_matrix_instance_q31;\r
1479 \r
1480 \r
1481 \r
1482   /**\r
1483    * @brief Floating-point matrix addition.\r
1484    * @param[in]       *pSrcA points to the first input matrix structure\r
1485    * @param[in]       *pSrcB points to the second input matrix structure\r
1486    * @param[out]      *pDst points to output matrix structure\r
1487    * @return     The function returns either\r
1488    * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.\r
1489    */\r
1490 \r
1491   arm_status arm_mat_add_f32(\r
1492   const arm_matrix_instance_f32 * pSrcA,\r
1493   const arm_matrix_instance_f32 * pSrcB,\r
1494   arm_matrix_instance_f32 * pDst);\r
1495 \r
1496   /**\r
1497    * @brief Q15 matrix addition.\r
1498    * @param[in]       *pSrcA points to the first input matrix structure\r
1499    * @param[in]       *pSrcB points to the second input matrix structure\r
1500    * @param[out]      *pDst points to output matrix structure\r
1501    * @return     The function returns either\r
1502    * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.\r
1503    */\r
1504 \r
1505   arm_status arm_mat_add_q15(\r
1506   const arm_matrix_instance_q15 * pSrcA,\r
1507   const arm_matrix_instance_q15 * pSrcB,\r
1508   arm_matrix_instance_q15 * pDst);\r
1509 \r
1510   /**\r
1511    * @brief Q31 matrix addition.\r
1512    * @param[in]       *pSrcA points to the first input matrix structure\r
1513    * @param[in]       *pSrcB points to the second input matrix structure\r
1514    * @param[out]      *pDst points to output matrix structure\r
1515    * @return     The function returns either\r
1516    * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.\r
1517    */\r
1518 \r
1519   arm_status arm_mat_add_q31(\r
1520   const arm_matrix_instance_q31 * pSrcA,\r
1521   const arm_matrix_instance_q31 * pSrcB,\r
1522   arm_matrix_instance_q31 * pDst);\r
1523 \r
1524   /**\r
1525    * @brief Floating-point, complex, matrix multiplication.\r
1526    * @param[in]       *pSrcA points to the first input matrix structure\r
1527    * @param[in]       *pSrcB points to the second input matrix structure\r
1528    * @param[out]      *pDst points to output matrix structure\r
1529    * @return     The function returns either\r
1530    * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.\r
1531    */\r
1532 \r
1533   arm_status arm_mat_cmplx_mult_f32(\r
1534   const arm_matrix_instance_f32 * pSrcA,\r
1535   const arm_matrix_instance_f32 * pSrcB,\r
1536   arm_matrix_instance_f32 * pDst);\r
1537 \r
1538   /**\r
1539    * @brief Q15, complex,  matrix multiplication.\r
1540    * @param[in]       *pSrcA points to the first input matrix structure\r
1541    * @param[in]       *pSrcB points to the second input matrix structure\r
1542    * @param[out]      *pDst points to output matrix structure\r
1543    * @return     The function returns either\r
1544    * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.\r
1545    */\r
1546 \r
1547   arm_status arm_mat_cmplx_mult_q15(\r
1548   const arm_matrix_instance_q15 * pSrcA,\r
1549   const arm_matrix_instance_q15 * pSrcB,\r
1550   arm_matrix_instance_q15 * pDst,\r
1551   q15_t * pScratch);\r
1552 \r
1553   /**\r
1554    * @brief Q31, complex, matrix multiplication.\r
1555    * @param[in]       *pSrcA points to the first input matrix structure\r
1556    * @param[in]       *pSrcB points to the second input matrix structure\r
1557    * @param[out]      *pDst points to output matrix structure\r
1558    * @return     The function returns either\r
1559    * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.\r
1560    */\r
1561 \r
1562   arm_status arm_mat_cmplx_mult_q31(\r
1563   const arm_matrix_instance_q31 * pSrcA,\r
1564   const arm_matrix_instance_q31 * pSrcB,\r
1565   arm_matrix_instance_q31 * pDst);\r
1566 \r
1567 \r
1568   /**\r
1569    * @brief Floating-point matrix transpose.\r
1570    * @param[in]  *pSrc points to the input matrix\r
1571    * @param[out] *pDst points to the output matrix\r
1572    * @return    The function returns either  <code>ARM_MATH_SIZE_MISMATCH</code>\r
1573    * or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.\r
1574    */\r
1575 \r
1576   arm_status arm_mat_trans_f32(\r
1577   const arm_matrix_instance_f32 * pSrc,\r
1578   arm_matrix_instance_f32 * pDst);\r
1579 \r
1580 \r
1581   /**\r
1582    * @brief Q15 matrix transpose.\r
1583    * @param[in]  *pSrc points to the input matrix\r
1584    * @param[out] *pDst points to the output matrix\r
1585    * @return    The function returns either  <code>ARM_MATH_SIZE_MISMATCH</code>\r
1586    * or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.\r
1587    */\r
1588 \r
1589   arm_status arm_mat_trans_q15(\r
1590   const arm_matrix_instance_q15 * pSrc,\r
1591   arm_matrix_instance_q15 * pDst);\r
1592 \r
1593   /**\r
1594    * @brief Q31 matrix transpose.\r
1595    * @param[in]  *pSrc points to the input matrix\r
1596    * @param[out] *pDst points to the output matrix\r
1597    * @return    The function returns either  <code>ARM_MATH_SIZE_MISMATCH</code>\r
1598    * or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.\r
1599    */\r
1600 \r
1601   arm_status arm_mat_trans_q31(\r
1602   const arm_matrix_instance_q31 * pSrc,\r
1603   arm_matrix_instance_q31 * pDst);\r
1604 \r
1605 \r
1606   /**\r
1607    * @brief Floating-point matrix multiplication\r
1608    * @param[in]       *pSrcA points to the first input matrix structure\r
1609    * @param[in]       *pSrcB points to the second input matrix structure\r
1610    * @param[out]      *pDst points to output matrix structure\r
1611    * @return     The function returns either\r
1612    * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.\r
1613    */\r
1614 \r
1615   arm_status arm_mat_mult_f32(\r
1616   const arm_matrix_instance_f32 * pSrcA,\r
1617   const arm_matrix_instance_f32 * pSrcB,\r
1618   arm_matrix_instance_f32 * pDst);\r
1619 \r
1620   /**\r
1621    * @brief Q15 matrix multiplication\r
1622    * @param[in]       *pSrcA points to the first input matrix structure\r
1623    * @param[in]       *pSrcB points to the second input matrix structure\r
1624    * @param[out]      *pDst points to output matrix structure\r
1625    * @param[in]          *pState points to the array for storing intermediate results\r
1626    * @return     The function returns either\r
1627    * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.\r
1628    */\r
1629 \r
1630   arm_status arm_mat_mult_q15(\r
1631   const arm_matrix_instance_q15 * pSrcA,\r
1632   const arm_matrix_instance_q15 * pSrcB,\r
1633   arm_matrix_instance_q15 * pDst,\r
1634   q15_t * pState);\r
1635 \r
1636   /**\r
1637    * @brief Q15 matrix multiplication (fast variant) for Cortex-M3 and Cortex-M4\r
1638    * @param[in]       *pSrcA  points to the first input matrix structure\r
1639    * @param[in]       *pSrcB  points to the second input matrix structure\r
1640    * @param[out]      *pDst   points to output matrix structure\r
1641    * @param[in]           *pState points to the array for storing intermediate results\r
1642    * @return     The function returns either\r
1643    * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.\r
1644    */\r
1645 \r
1646   arm_status arm_mat_mult_fast_q15(\r
1647   const arm_matrix_instance_q15 * pSrcA,\r
1648   const arm_matrix_instance_q15 * pSrcB,\r
1649   arm_matrix_instance_q15 * pDst,\r
1650   q15_t * pState);\r
1651 \r
1652   /**\r
1653    * @brief Q31 matrix multiplication\r
1654    * @param[in]       *pSrcA points to the first input matrix structure\r
1655    * @param[in]       *pSrcB points to the second input matrix structure\r
1656    * @param[out]      *pDst points to output matrix structure\r
1657    * @return     The function returns either\r
1658    * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.\r
1659    */\r
1660 \r
1661   arm_status arm_mat_mult_q31(\r
1662   const arm_matrix_instance_q31 * pSrcA,\r
1663   const arm_matrix_instance_q31 * pSrcB,\r
1664   arm_matrix_instance_q31 * pDst);\r
1665 \r
1666   /**\r
1667    * @brief Q31 matrix multiplication (fast variant) for Cortex-M3 and Cortex-M4\r
1668    * @param[in]       *pSrcA points to the first input matrix structure\r
1669    * @param[in]       *pSrcB points to the second input matrix structure\r
1670    * @param[out]      *pDst points to output matrix structure\r
1671    * @return     The function returns either\r
1672    * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.\r
1673    */\r
1674 \r
1675   arm_status arm_mat_mult_fast_q31(\r
1676   const arm_matrix_instance_q31 * pSrcA,\r
1677   const arm_matrix_instance_q31 * pSrcB,\r
1678   arm_matrix_instance_q31 * pDst);\r
1679 \r
1680 \r
1681   /**\r
1682    * @brief Floating-point matrix subtraction\r
1683    * @param[in]       *pSrcA points to the first input matrix structure\r
1684    * @param[in]       *pSrcB points to the second input matrix structure\r
1685    * @param[out]      *pDst points to output matrix structure\r
1686    * @return     The function returns either\r
1687    * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.\r
1688    */\r
1689 \r
1690   arm_status arm_mat_sub_f32(\r
1691   const arm_matrix_instance_f32 * pSrcA,\r
1692   const arm_matrix_instance_f32 * pSrcB,\r
1693   arm_matrix_instance_f32 * pDst);\r
1694 \r
1695   /**\r
1696    * @brief Q15 matrix subtraction\r
1697    * @param[in]       *pSrcA points to the first input matrix structure\r
1698    * @param[in]       *pSrcB points to the second input matrix structure\r
1699    * @param[out]      *pDst points to output matrix structure\r
1700    * @return     The function returns either\r
1701    * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.\r
1702    */\r
1703 \r
1704   arm_status arm_mat_sub_q15(\r
1705   const arm_matrix_instance_q15 * pSrcA,\r
1706   const arm_matrix_instance_q15 * pSrcB,\r
1707   arm_matrix_instance_q15 * pDst);\r
1708 \r
1709   /**\r
1710    * @brief Q31 matrix subtraction\r
1711    * @param[in]       *pSrcA points to the first input matrix structure\r
1712    * @param[in]       *pSrcB points to the second input matrix structure\r
1713    * @param[out]      *pDst points to output matrix structure\r
1714    * @return     The function returns either\r
1715    * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.\r
1716    */\r
1717 \r
1718   arm_status arm_mat_sub_q31(\r
1719   const arm_matrix_instance_q31 * pSrcA,\r
1720   const arm_matrix_instance_q31 * pSrcB,\r
1721   arm_matrix_instance_q31 * pDst);\r
1722 \r
1723   /**\r
1724    * @brief Floating-point matrix scaling.\r
1725    * @param[in]  *pSrc points to the input matrix\r
1726    * @param[in]  scale scale factor\r
1727    * @param[out] *pDst points to the output matrix\r
1728    * @return     The function returns either\r
1729    * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.\r
1730    */\r
1731 \r
1732   arm_status arm_mat_scale_f32(\r
1733   const arm_matrix_instance_f32 * pSrc,\r
1734   float32_t scale,\r
1735   arm_matrix_instance_f32 * pDst);\r
1736 \r
1737   /**\r
1738    * @brief Q15 matrix scaling.\r
1739    * @param[in]       *pSrc points to input matrix\r
1740    * @param[in]       scaleFract fractional portion of the scale factor\r
1741    * @param[in]       shift number of bits to shift the result by\r
1742    * @param[out]      *pDst points to output matrix\r
1743    * @return     The function returns either\r
1744    * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.\r
1745    */\r
1746 \r
1747   arm_status arm_mat_scale_q15(\r
1748   const arm_matrix_instance_q15 * pSrc,\r
1749   q15_t scaleFract,\r
1750   int32_t shift,\r
1751   arm_matrix_instance_q15 * pDst);\r
1752 \r
1753   /**\r
1754    * @brief Q31 matrix scaling.\r
1755    * @param[in]       *pSrc points to input matrix\r
1756    * @param[in]       scaleFract fractional portion of the scale factor\r
1757    * @param[in]       shift number of bits to shift the result by\r
1758    * @param[out]      *pDst points to output matrix structure\r
1759    * @return     The function returns either\r
1760    * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.\r
1761    */\r
1762 \r
1763   arm_status arm_mat_scale_q31(\r
1764   const arm_matrix_instance_q31 * pSrc,\r
1765   q31_t scaleFract,\r
1766   int32_t shift,\r
1767   arm_matrix_instance_q31 * pDst);\r
1768 \r
1769 \r
1770   /**\r
1771    * @brief  Q31 matrix initialization.\r
1772    * @param[in,out] *S             points to an instance of the floating-point matrix structure.\r
1773    * @param[in]     nRows          number of rows in the matrix.\r
1774    * @param[in]     nColumns       number of columns in the matrix.\r
1775    * @param[in]     *pData             points to the matrix data array.\r
1776    * @return        none\r
1777    */\r
1778 \r
1779   void arm_mat_init_q31(\r
1780   arm_matrix_instance_q31 * S,\r
1781   uint16_t nRows,\r
1782   uint16_t nColumns,\r
1783   q31_t * pData);\r
1784 \r
1785   /**\r
1786    * @brief  Q15 matrix initialization.\r
1787    * @param[in,out] *S             points to an instance of the floating-point matrix structure.\r
1788    * @param[in]     nRows          number of rows in the matrix.\r
1789    * @param[in]     nColumns       number of columns in the matrix.\r
1790    * @param[in]     *pData             points to the matrix data array.\r
1791    * @return        none\r
1792    */\r
1793 \r
1794   void arm_mat_init_q15(\r
1795   arm_matrix_instance_q15 * S,\r
1796   uint16_t nRows,\r
1797   uint16_t nColumns,\r
1798   q15_t * pData);\r
1799 \r
1800   /**\r
1801    * @brief  Floating-point matrix initialization.\r
1802    * @param[in,out] *S             points to an instance of the floating-point matrix structure.\r
1803    * @param[in]     nRows          number of rows in the matrix.\r
1804    * @param[in]     nColumns       number of columns in the matrix.\r
1805    * @param[in]     *pData             points to the matrix data array.\r
1806    * @return        none\r
1807    */\r
1808 \r
1809   void arm_mat_init_f32(\r
1810   arm_matrix_instance_f32 * S,\r
1811   uint16_t nRows,\r
1812   uint16_t nColumns,\r
1813   float32_t * pData);\r
1814 \r
1815 \r
1816 \r
1817   /**\r
1818    * @brief Instance structure for the Q15 PID Control.\r
1819    */\r
1820   typedef struct\r
1821   {\r
1822     q15_t A0;    /**< The derived gain, A0 = Kp + Ki + Kd . */\r
1823 #ifdef ARM_MATH_CM0_FAMILY\r
1824     q15_t A1;\r
1825     q15_t A2;\r
1826 #else\r
1827     q31_t A1;           /**< The derived gain A1 = -Kp - 2Kd | Kd.*/\r
1828 #endif\r
1829     q15_t state[3];       /**< The state array of length 3. */\r
1830     q15_t Kp;           /**< The proportional gain. */\r
1831     q15_t Ki;           /**< The integral gain. */\r
1832     q15_t Kd;           /**< The derivative gain. */\r
1833   } arm_pid_instance_q15;\r
1834 \r
1835   /**\r
1836    * @brief Instance structure for the Q31 PID Control.\r
1837    */\r
1838   typedef struct\r
1839   {\r
1840     q31_t A0;            /**< The derived gain, A0 = Kp + Ki + Kd . */\r
1841     q31_t A1;            /**< The derived gain, A1 = -Kp - 2Kd. */\r
1842     q31_t A2;            /**< The derived gain, A2 = Kd . */\r
1843     q31_t state[3];      /**< The state array of length 3. */\r
1844     q31_t Kp;            /**< The proportional gain. */\r
1845     q31_t Ki;            /**< The integral gain. */\r
1846     q31_t Kd;            /**< The derivative gain. */\r
1847 \r
1848   } arm_pid_instance_q31;\r
1849 \r
1850   /**\r
1851    * @brief Instance structure for the floating-point PID Control.\r
1852    */\r
1853   typedef struct\r
1854   {\r
1855     float32_t A0;          /**< The derived gain, A0 = Kp + Ki + Kd . */\r
1856     float32_t A1;          /**< The derived gain, A1 = -Kp - 2Kd. */\r
1857     float32_t A2;          /**< The derived gain, A2 = Kd . */\r
1858     float32_t state[3];    /**< The state array of length 3. */\r
1859     float32_t Kp;               /**< The proportional gain. */\r
1860     float32_t Ki;               /**< The integral gain. */\r
1861     float32_t Kd;               /**< The derivative gain. */\r
1862   } arm_pid_instance_f32;\r
1863 \r
1864 \r
1865 \r
1866   /**\r
1867    * @brief  Initialization function for the floating-point PID Control.\r
1868    * @param[in,out] *S      points to an instance of the PID structure.\r
1869    * @param[in]     resetStateFlag  flag to reset the state. 0 = no change in state 1 = reset the state.\r
1870    * @return none.\r
1871    */\r
1872   void arm_pid_init_f32(\r
1873   arm_pid_instance_f32 * S,\r
1874   int32_t resetStateFlag);\r
1875 \r
1876   /**\r
1877    * @brief  Reset function for the floating-point PID Control.\r
1878    * @param[in,out] *S is an instance of the floating-point PID Control structure\r
1879    * @return none\r
1880    */\r
1881   void arm_pid_reset_f32(\r
1882   arm_pid_instance_f32 * S);\r
1883 \r
1884 \r
1885   /**\r
1886    * @brief  Initialization function for the Q31 PID Control.\r
1887    * @param[in,out] *S points to an instance of the Q15 PID structure.\r
1888    * @param[in]     resetStateFlag  flag to reset the state. 0 = no change in state 1 = reset the state.\r
1889    * @return none.\r
1890    */\r
1891   void arm_pid_init_q31(\r
1892   arm_pid_instance_q31 * S,\r
1893   int32_t resetStateFlag);\r
1894 \r
1895 \r
1896   /**\r
1897    * @brief  Reset function for the Q31 PID Control.\r
1898    * @param[in,out] *S points to an instance of the Q31 PID Control structure\r
1899    * @return none\r
1900    */\r
1901 \r
1902   void arm_pid_reset_q31(\r
1903   arm_pid_instance_q31 * S);\r
1904 \r
1905   /**\r
1906    * @brief  Initialization function for the Q15 PID Control.\r
1907    * @param[in,out] *S points to an instance of the Q15 PID structure.\r
1908    * @param[in] resetStateFlag  flag to reset the state. 0 = no change in state 1 = reset the state.\r
1909    * @return none.\r
1910    */\r
1911   void arm_pid_init_q15(\r
1912   arm_pid_instance_q15 * S,\r
1913   int32_t resetStateFlag);\r
1914 \r
1915   /**\r
1916    * @brief  Reset function for the Q15 PID Control.\r
1917    * @param[in,out] *S points to an instance of the q15 PID Control structure\r
1918    * @return none\r
1919    */\r
1920   void arm_pid_reset_q15(\r
1921   arm_pid_instance_q15 * S);\r
1922 \r
1923 \r
1924   /**\r
1925    * @brief Instance structure for the floating-point Linear Interpolate function.\r
1926    */\r
1927   typedef struct\r
1928   {\r
1929     uint32_t nValues;           /**< nValues */\r
1930     float32_t x1;               /**< x1 */\r
1931     float32_t xSpacing;         /**< xSpacing */\r
1932     float32_t *pYData;          /**< pointer to the table of Y values */\r
1933   } arm_linear_interp_instance_f32;\r
1934 \r
1935   /**\r
1936    * @brief Instance structure for the floating-point bilinear interpolation function.\r
1937    */\r
1938 \r
1939   typedef struct\r
1940   {\r
1941     uint16_t numRows;   /**< number of rows in the data table. */\r
1942     uint16_t numCols;   /**< number of columns in the data table. */\r
1943     float32_t *pData;   /**< points to the data table. */\r
1944   } arm_bilinear_interp_instance_f32;\r
1945 \r
1946    /**\r
1947    * @brief Instance structure for the Q31 bilinear interpolation function.\r
1948    */\r
1949 \r
1950   typedef struct\r
1951   {\r
1952     uint16_t numRows;   /**< number of rows in the data table. */\r
1953     uint16_t numCols;   /**< number of columns in the data table. */\r
1954     q31_t *pData;       /**< points to the data table. */\r
1955   } arm_bilinear_interp_instance_q31;\r
1956 \r
1957    /**\r
1958    * @brief Instance structure for the Q15 bilinear interpolation function.\r
1959    */\r
1960 \r
1961   typedef struct\r
1962   {\r
1963     uint16_t numRows;   /**< number of rows in the data table. */\r
1964     uint16_t numCols;   /**< number of columns in the data table. */\r
1965     q15_t *pData;       /**< points to the data table. */\r
1966   } arm_bilinear_interp_instance_q15;\r
1967 \r
1968    /**\r
1969    * @brief Instance structure for the Q15 bilinear interpolation function.\r
1970    */\r
1971 \r
1972   typedef struct\r
1973   {\r
1974     uint16_t numRows;   /**< number of rows in the data table. */\r
1975     uint16_t numCols;   /**< number of columns in the data table. */\r
1976     q7_t *pData;                /**< points to the data table. */\r
1977   } arm_bilinear_interp_instance_q7;\r
1978 \r
1979 \r
1980   /**\r
1981    * @brief Q7 vector multiplication.\r
1982    * @param[in]       *pSrcA points to the first input vector\r
1983    * @param[in]       *pSrcB points to the second input vector\r
1984    * @param[out]      *pDst  points to the output vector\r
1985    * @param[in]       blockSize number of samples in each vector\r
1986    * @return none.\r
1987    */\r
1988 \r
1989   void arm_mult_q7(\r
1990   q7_t * pSrcA,\r
1991   q7_t * pSrcB,\r
1992   q7_t * pDst,\r
1993   uint32_t blockSize);\r
1994 \r
1995   /**\r
1996    * @brief Q15 vector multiplication.\r
1997    * @param[in]       *pSrcA points to the first input vector\r
1998    * @param[in]       *pSrcB points to the second input vector\r
1999    * @param[out]      *pDst  points to the output vector\r
2000    * @param[in]       blockSize number of samples in each vector\r
2001    * @return none.\r
2002    */\r
2003 \r
2004   void arm_mult_q15(\r
2005   q15_t * pSrcA,\r
2006   q15_t * pSrcB,\r
2007   q15_t * pDst,\r
2008   uint32_t blockSize);\r
2009 \r
2010   /**\r
2011    * @brief Q31 vector multiplication.\r
2012    * @param[in]       *pSrcA points to the first input vector\r
2013    * @param[in]       *pSrcB points to the second input vector\r
2014    * @param[out]      *pDst points to the output vector\r
2015    * @param[in]       blockSize number of samples in each vector\r
2016    * @return none.\r
2017    */\r
2018 \r
2019   void arm_mult_q31(\r
2020   q31_t * pSrcA,\r
2021   q31_t * pSrcB,\r
2022   q31_t * pDst,\r
2023   uint32_t blockSize);\r
2024 \r
2025   /**\r
2026    * @brief Floating-point vector multiplication.\r
2027    * @param[in]       *pSrcA points to the first input vector\r
2028    * @param[in]       *pSrcB points to the second input vector\r
2029    * @param[out]      *pDst points to the output vector\r
2030    * @param[in]       blockSize number of samples in each vector\r
2031    * @return none.\r
2032    */\r
2033 \r
2034   void arm_mult_f32(\r
2035   float32_t * pSrcA,\r
2036   float32_t * pSrcB,\r
2037   float32_t * pDst,\r
2038   uint32_t blockSize);\r
2039 \r
2040 \r
2041 \r
2042 \r
2043 \r
2044 \r
2045   /**\r
2046    * @brief Instance structure for the Q15 CFFT/CIFFT function.\r
2047    */\r
2048 \r
2049   typedef struct\r
2050   {\r
2051     uint16_t fftLen;                 /**< length of the FFT. */\r
2052     uint8_t ifftFlag;                /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */\r
2053     uint8_t bitReverseFlag;          /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */\r
2054     q15_t *pTwiddle;                     /**< points to the Sin twiddle factor table. */\r
2055     uint16_t *pBitRevTable;          /**< points to the bit reversal table. */\r
2056     uint16_t twidCoefModifier;       /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */\r
2057     uint16_t bitRevFactor;           /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */\r
2058   } arm_cfft_radix2_instance_q15;\r
2059 \r
2060 /* Deprecated */\r
2061   arm_status arm_cfft_radix2_init_q15(\r
2062   arm_cfft_radix2_instance_q15 * S,\r
2063   uint16_t fftLen,\r
2064   uint8_t ifftFlag,\r
2065   uint8_t bitReverseFlag);\r
2066 \r
2067 /* Deprecated */\r
2068   void arm_cfft_radix2_q15(\r
2069   const arm_cfft_radix2_instance_q15 * S,\r
2070   q15_t * pSrc);\r
2071 \r
2072 \r
2073 \r
2074   /**\r
2075    * @brief Instance structure for the Q15 CFFT/CIFFT function.\r
2076    */\r
2077 \r
2078   typedef struct\r
2079   {\r
2080     uint16_t fftLen;                 /**< length of the FFT. */\r
2081     uint8_t ifftFlag;                /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */\r
2082     uint8_t bitReverseFlag;          /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */\r
2083     q15_t *pTwiddle;                 /**< points to the twiddle factor table. */\r
2084     uint16_t *pBitRevTable;          /**< points to the bit reversal table. */\r
2085     uint16_t twidCoefModifier;       /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */\r
2086     uint16_t bitRevFactor;           /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */\r
2087   } arm_cfft_radix4_instance_q15;\r
2088 \r
2089 /* Deprecated */\r
2090   arm_status arm_cfft_radix4_init_q15(\r
2091   arm_cfft_radix4_instance_q15 * S,\r
2092   uint16_t fftLen,\r
2093   uint8_t ifftFlag,\r
2094   uint8_t bitReverseFlag);\r
2095 \r
2096 /* Deprecated */\r
2097   void arm_cfft_radix4_q15(\r
2098   const arm_cfft_radix4_instance_q15 * S,\r
2099   q15_t * pSrc);\r
2100 \r
2101   /**\r
2102    * @brief Instance structure for the Radix-2 Q31 CFFT/CIFFT function.\r
2103    */\r
2104 \r
2105   typedef struct\r
2106   {\r
2107     uint16_t fftLen;                 /**< length of the FFT. */\r
2108     uint8_t ifftFlag;                /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */\r
2109     uint8_t bitReverseFlag;          /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */\r
2110     q31_t *pTwiddle;                     /**< points to the Twiddle factor table. */\r
2111     uint16_t *pBitRevTable;          /**< points to the bit reversal table. */\r
2112     uint16_t twidCoefModifier;       /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */\r
2113     uint16_t bitRevFactor;           /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */\r
2114   } arm_cfft_radix2_instance_q31;\r
2115 \r
2116 /* Deprecated */\r
2117   arm_status arm_cfft_radix2_init_q31(\r
2118   arm_cfft_radix2_instance_q31 * S,\r
2119   uint16_t fftLen,\r
2120   uint8_t ifftFlag,\r
2121   uint8_t bitReverseFlag);\r
2122 \r
2123 /* Deprecated */\r
2124   void arm_cfft_radix2_q31(\r
2125   const arm_cfft_radix2_instance_q31 * S,\r
2126   q31_t * pSrc);\r
2127 \r
2128   /**\r
2129    * @brief Instance structure for the Q31 CFFT/CIFFT function.\r
2130    */\r
2131 \r
2132   typedef struct\r
2133   {\r
2134     uint16_t fftLen;                 /**< length of the FFT. */\r
2135     uint8_t ifftFlag;                /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */\r
2136     uint8_t bitReverseFlag;          /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */\r
2137     q31_t *pTwiddle;                 /**< points to the twiddle factor table. */\r
2138     uint16_t *pBitRevTable;          /**< points to the bit reversal table. */\r
2139     uint16_t twidCoefModifier;       /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */\r
2140     uint16_t bitRevFactor;           /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */\r
2141   } arm_cfft_radix4_instance_q31;\r
2142 \r
2143 /* Deprecated */\r
2144   void arm_cfft_radix4_q31(\r
2145   const arm_cfft_radix4_instance_q31 * S,\r
2146   q31_t * pSrc);\r
2147 \r
2148 /* Deprecated */\r
2149   arm_status arm_cfft_radix4_init_q31(\r
2150   arm_cfft_radix4_instance_q31 * S,\r
2151   uint16_t fftLen,\r
2152   uint8_t ifftFlag,\r
2153   uint8_t bitReverseFlag);\r
2154 \r
2155   /**\r
2156    * @brief Instance structure for the floating-point CFFT/CIFFT function.\r
2157    */\r
2158 \r
2159   typedef struct\r
2160   {\r
2161     uint16_t fftLen;                   /**< length of the FFT. */\r
2162     uint8_t ifftFlag;                  /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */\r
2163     uint8_t bitReverseFlag;            /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */\r
2164     float32_t *pTwiddle;               /**< points to the Twiddle factor table. */\r
2165     uint16_t *pBitRevTable;            /**< points to the bit reversal table. */\r
2166     uint16_t twidCoefModifier;         /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */\r
2167     uint16_t bitRevFactor;             /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */\r
2168     float32_t onebyfftLen;                 /**< value of 1/fftLen. */\r
2169   } arm_cfft_radix2_instance_f32;\r
2170 \r
2171 /* Deprecated */\r
2172   arm_status arm_cfft_radix2_init_f32(\r
2173   arm_cfft_radix2_instance_f32 * S,\r
2174   uint16_t fftLen,\r
2175   uint8_t ifftFlag,\r
2176   uint8_t bitReverseFlag);\r
2177 \r
2178 /* Deprecated */\r
2179   void arm_cfft_radix2_f32(\r
2180   const arm_cfft_radix2_instance_f32 * S,\r
2181   float32_t * pSrc);\r
2182 \r
2183   /**\r
2184    * @brief Instance structure for the floating-point CFFT/CIFFT function.\r
2185    */\r
2186 \r
2187   typedef struct\r
2188   {\r
2189     uint16_t fftLen;                   /**< length of the FFT. */\r
2190     uint8_t ifftFlag;                  /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */\r
2191     uint8_t bitReverseFlag;            /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */\r
2192     float32_t *pTwiddle;               /**< points to the Twiddle factor table. */\r
2193     uint16_t *pBitRevTable;            /**< points to the bit reversal table. */\r
2194     uint16_t twidCoefModifier;         /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */\r
2195     uint16_t bitRevFactor;             /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */\r
2196     float32_t onebyfftLen;                 /**< value of 1/fftLen. */\r
2197   } arm_cfft_radix4_instance_f32;\r
2198 \r
2199 /* Deprecated */\r
2200   arm_status arm_cfft_radix4_init_f32(\r
2201   arm_cfft_radix4_instance_f32 * S,\r
2202   uint16_t fftLen,\r
2203   uint8_t ifftFlag,\r
2204   uint8_t bitReverseFlag);\r
2205 \r
2206 /* Deprecated */\r
2207   void arm_cfft_radix4_f32(\r
2208   const arm_cfft_radix4_instance_f32 * S,\r
2209   float32_t * pSrc);\r
2210 \r
2211   /**\r
2212    * @brief Instance structure for the fixed-point CFFT/CIFFT function.\r
2213    */\r
2214 \r
2215   typedef struct\r
2216   {\r
2217     uint16_t fftLen;                   /**< length of the FFT. */\r
2218     const q15_t *pTwiddle;             /**< points to the Twiddle factor table. */\r
2219     const uint16_t *pBitRevTable;      /**< points to the bit reversal table. */\r
2220     uint16_t bitRevLength;             /**< bit reversal table length. */\r
2221   } arm_cfft_instance_q15;\r
2222 \r
2223 void arm_cfft_q15( \r
2224     const arm_cfft_instance_q15 * S, \r
2225     q15_t * p1,\r
2226     uint8_t ifftFlag,\r
2227     uint8_t bitReverseFlag);  \r
2228 \r
2229   /**\r
2230    * @brief Instance structure for the fixed-point CFFT/CIFFT function.\r
2231    */\r
2232 \r
2233   typedef struct\r
2234   {\r
2235     uint16_t fftLen;                   /**< length of the FFT. */\r
2236     const q31_t *pTwiddle;             /**< points to the Twiddle factor table. */\r
2237     const uint16_t *pBitRevTable;      /**< points to the bit reversal table. */\r
2238     uint16_t bitRevLength;             /**< bit reversal table length. */\r
2239   } arm_cfft_instance_q31;\r
2240 \r
2241 void arm_cfft_q31( \r
2242     const arm_cfft_instance_q31 * S, \r
2243     q31_t * p1,\r
2244     uint8_t ifftFlag,\r
2245     uint8_t bitReverseFlag);  \r
2246   \r
2247   /**\r
2248    * @brief Instance structure for the floating-point CFFT/CIFFT function.\r
2249    */\r
2250 \r
2251   typedef struct\r
2252   {\r
2253     uint16_t fftLen;                   /**< length of the FFT. */\r
2254     const float32_t *pTwiddle;         /**< points to the Twiddle factor table. */\r
2255     const uint16_t *pBitRevTable;      /**< points to the bit reversal table. */\r
2256     uint16_t bitRevLength;             /**< bit reversal table length. */\r
2257   } arm_cfft_instance_f32;\r
2258 \r
2259   void arm_cfft_f32(\r
2260   const arm_cfft_instance_f32 * S,\r
2261   float32_t * p1,\r
2262   uint8_t ifftFlag,\r
2263   uint8_t bitReverseFlag);\r
2264 \r
2265   /**\r
2266    * @brief Instance structure for the Q15 RFFT/RIFFT function.\r
2267    */\r
2268 \r
2269   typedef struct\r
2270   {\r
2271     uint32_t fftLenReal;                      /**< length of the real FFT. */\r
2272     uint8_t ifftFlagR;                        /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */\r
2273     uint8_t bitReverseFlagR;                  /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */\r
2274     uint32_t twidCoefRModifier;               /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */\r
2275     q15_t *pTwiddleAReal;                     /**< points to the real twiddle factor table. */\r
2276     q15_t *pTwiddleBReal;                     /**< points to the imag twiddle factor table. */\r
2277     const arm_cfft_instance_q15 *pCfft;       /**< points to the complex FFT instance. */\r
2278   } arm_rfft_instance_q15;\r
2279 \r
2280   arm_status arm_rfft_init_q15(\r
2281   arm_rfft_instance_q15 * S,\r
2282   uint32_t fftLenReal,\r
2283   uint32_t ifftFlagR,\r
2284   uint32_t bitReverseFlag);\r
2285 \r
2286   void arm_rfft_q15(\r
2287   const arm_rfft_instance_q15 * S,\r
2288   q15_t * pSrc,\r
2289   q15_t * pDst);\r
2290 \r
2291   /**\r
2292    * @brief Instance structure for the Q31 RFFT/RIFFT function.\r
2293    */\r
2294 \r
2295   typedef struct\r
2296   {\r
2297     uint32_t fftLenReal;                        /**< length of the real FFT. */\r
2298     uint8_t ifftFlagR;                          /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */\r
2299     uint8_t bitReverseFlagR;                    /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */\r
2300     uint32_t twidCoefRModifier;                 /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */\r
2301     q31_t *pTwiddleAReal;                       /**< points to the real twiddle factor table. */\r
2302     q31_t *pTwiddleBReal;                       /**< points to the imag twiddle factor table. */\r
2303     const arm_cfft_instance_q31 *pCfft;         /**< points to the complex FFT instance. */\r
2304   } arm_rfft_instance_q31;\r
2305 \r
2306   arm_status arm_rfft_init_q31(\r
2307   arm_rfft_instance_q31 * S,\r
2308   uint32_t fftLenReal,\r
2309   uint32_t ifftFlagR,\r
2310   uint32_t bitReverseFlag);\r
2311 \r
2312   void arm_rfft_q31(\r
2313   const arm_rfft_instance_q31 * S,\r
2314   q31_t * pSrc,\r
2315   q31_t * pDst);\r
2316 \r
2317   /**\r
2318    * @brief Instance structure for the floating-point RFFT/RIFFT function.\r
2319    */\r
2320 \r
2321   typedef struct\r
2322   {\r
2323     uint32_t fftLenReal;                        /**< length of the real FFT. */\r
2324     uint16_t fftLenBy2;                         /**< length of the complex FFT. */\r
2325     uint8_t ifftFlagR;                          /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */\r
2326     uint8_t bitReverseFlagR;                    /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */\r
2327     uint32_t twidCoefRModifier;                     /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */\r
2328     float32_t *pTwiddleAReal;                   /**< points to the real twiddle factor table. */\r
2329     float32_t *pTwiddleBReal;                   /**< points to the imag twiddle factor table. */\r
2330     arm_cfft_radix4_instance_f32 *pCfft;        /**< points to the complex FFT instance. */\r
2331   } arm_rfft_instance_f32;\r
2332 \r
2333   arm_status arm_rfft_init_f32(\r
2334   arm_rfft_instance_f32 * S,\r
2335   arm_cfft_radix4_instance_f32 * S_CFFT,\r
2336   uint32_t fftLenReal,\r
2337   uint32_t ifftFlagR,\r
2338   uint32_t bitReverseFlag);\r
2339 \r
2340   void arm_rfft_f32(\r
2341   const arm_rfft_instance_f32 * S,\r
2342   float32_t * pSrc,\r
2343   float32_t * pDst);\r
2344 \r
2345   /**\r
2346    * @brief Instance structure for the floating-point RFFT/RIFFT function.\r
2347    */\r
2348 \r
2349 typedef struct\r
2350   {\r
2351     arm_cfft_instance_f32 Sint;      /**< Internal CFFT structure. */\r
2352     uint16_t fftLenRFFT;                        /**< length of the real sequence */\r
2353         float32_t * pTwiddleRFFT;                                       /**< Twiddle factors real stage  */\r
2354   } arm_rfft_fast_instance_f32 ;\r
2355 \r
2356 arm_status arm_rfft_fast_init_f32 (\r
2357         arm_rfft_fast_instance_f32 * S,\r
2358         uint16_t fftLen);\r
2359 \r
2360 void arm_rfft_fast_f32(\r
2361   arm_rfft_fast_instance_f32 * S,\r
2362   float32_t * p, float32_t * pOut,\r
2363   uint8_t ifftFlag);\r
2364 \r
2365   /**\r
2366    * @brief Instance structure for the floating-point DCT4/IDCT4 function.\r
2367    */\r
2368 \r
2369   typedef struct\r
2370   {\r
2371     uint16_t N;                         /**< length of the DCT4. */\r
2372     uint16_t Nby2;                      /**< half of the length of the DCT4. */\r
2373     float32_t normalize;                /**< normalizing factor. */\r
2374     float32_t *pTwiddle;                /**< points to the twiddle factor table. */\r
2375     float32_t *pCosFactor;              /**< points to the cosFactor table. */\r
2376     arm_rfft_instance_f32 *pRfft;        /**< points to the real FFT instance. */\r
2377     arm_cfft_radix4_instance_f32 *pCfft; /**< points to the complex FFT instance. */\r
2378   } arm_dct4_instance_f32;\r
2379 \r
2380   /**\r
2381    * @brief  Initialization function for the floating-point DCT4/IDCT4.\r
2382    * @param[in,out] *S         points to an instance of floating-point DCT4/IDCT4 structure.\r
2383    * @param[in]     *S_RFFT    points to an instance of floating-point RFFT/RIFFT structure.\r
2384    * @param[in]     *S_CFFT    points to an instance of floating-point CFFT/CIFFT structure.\r
2385    * @param[in]     N          length of the DCT4.\r
2386    * @param[in]     Nby2       half of the length of the DCT4.\r
2387    * @param[in]     normalize  normalizing factor.\r
2388    * @return            arm_status function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_ARGUMENT_ERROR if <code>fftLenReal</code> is not a supported transform length.\r
2389    */\r
2390 \r
2391   arm_status arm_dct4_init_f32(\r
2392   arm_dct4_instance_f32 * S,\r
2393   arm_rfft_instance_f32 * S_RFFT,\r
2394   arm_cfft_radix4_instance_f32 * S_CFFT,\r
2395   uint16_t N,\r
2396   uint16_t Nby2,\r
2397   float32_t normalize);\r
2398 \r
2399   /**\r
2400    * @brief Processing function for the floating-point DCT4/IDCT4.\r
2401    * @param[in]       *S             points to an instance of the floating-point DCT4/IDCT4 structure.\r
2402    * @param[in]       *pState        points to state buffer.\r
2403    * @param[in,out]   *pInlineBuffer points to the in-place input and output buffer.\r
2404    * @return none.\r
2405    */\r
2406 \r
2407   void arm_dct4_f32(\r
2408   const arm_dct4_instance_f32 * S,\r
2409   float32_t * pState,\r
2410   float32_t * pInlineBuffer);\r
2411 \r
2412   /**\r
2413    * @brief Instance structure for the Q31 DCT4/IDCT4 function.\r
2414    */\r
2415 \r
2416   typedef struct\r
2417   {\r
2418     uint16_t N;                         /**< length of the DCT4. */\r
2419     uint16_t Nby2;                      /**< half of the length of the DCT4. */\r
2420     q31_t normalize;                    /**< normalizing factor. */\r
2421     q31_t *pTwiddle;                    /**< points to the twiddle factor table. */\r
2422     q31_t *pCosFactor;                  /**< points to the cosFactor table. */\r
2423     arm_rfft_instance_q31 *pRfft;        /**< points to the real FFT instance. */\r
2424     arm_cfft_radix4_instance_q31 *pCfft; /**< points to the complex FFT instance. */\r
2425   } arm_dct4_instance_q31;\r
2426 \r
2427   /**\r
2428    * @brief  Initialization function for the Q31 DCT4/IDCT4.\r
2429    * @param[in,out] *S         points to an instance of Q31 DCT4/IDCT4 structure.\r
2430    * @param[in]     *S_RFFT    points to an instance of Q31 RFFT/RIFFT structure\r
2431    * @param[in]     *S_CFFT    points to an instance of Q31 CFFT/CIFFT structure\r
2432    * @param[in]     N          length of the DCT4.\r
2433    * @param[in]     Nby2       half of the length of the DCT4.\r
2434    * @param[in]     normalize  normalizing factor.\r
2435    * @return            arm_status function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_ARGUMENT_ERROR if <code>N</code> is not a supported transform length.\r
2436    */\r
2437 \r
2438   arm_status arm_dct4_init_q31(\r
2439   arm_dct4_instance_q31 * S,\r
2440   arm_rfft_instance_q31 * S_RFFT,\r
2441   arm_cfft_radix4_instance_q31 * S_CFFT,\r
2442   uint16_t N,\r
2443   uint16_t Nby2,\r
2444   q31_t normalize);\r
2445 \r
2446   /**\r
2447    * @brief Processing function for the Q31 DCT4/IDCT4.\r
2448    * @param[in]       *S             points to an instance of the Q31 DCT4 structure.\r
2449    * @param[in]       *pState        points to state buffer.\r
2450    * @param[in,out]   *pInlineBuffer points to the in-place input and output buffer.\r
2451    * @return none.\r
2452    */\r
2453 \r
2454   void arm_dct4_q31(\r
2455   const arm_dct4_instance_q31 * S,\r
2456   q31_t * pState,\r
2457   q31_t * pInlineBuffer);\r
2458 \r
2459   /**\r
2460    * @brief Instance structure for the Q15 DCT4/IDCT4 function.\r
2461    */\r
2462 \r
2463   typedef struct\r
2464   {\r
2465     uint16_t N;                         /**< length of the DCT4. */\r
2466     uint16_t Nby2;                      /**< half of the length of the DCT4. */\r
2467     q15_t normalize;                    /**< normalizing factor. */\r
2468     q15_t *pTwiddle;                    /**< points to the twiddle factor table. */\r
2469     q15_t *pCosFactor;                  /**< points to the cosFactor table. */\r
2470     arm_rfft_instance_q15 *pRfft;        /**< points to the real FFT instance. */\r
2471     arm_cfft_radix4_instance_q15 *pCfft; /**< points to the complex FFT instance. */\r
2472   } arm_dct4_instance_q15;\r
2473 \r
2474   /**\r
2475    * @brief  Initialization function for the Q15 DCT4/IDCT4.\r
2476    * @param[in,out] *S         points to an instance of Q15 DCT4/IDCT4 structure.\r
2477    * @param[in]     *S_RFFT    points to an instance of Q15 RFFT/RIFFT structure.\r
2478    * @param[in]     *S_CFFT    points to an instance of Q15 CFFT/CIFFT structure.\r
2479    * @param[in]     N          length of the DCT4.\r
2480    * @param[in]     Nby2       half of the length of the DCT4.\r
2481    * @param[in]     normalize  normalizing factor.\r
2482    * @return            arm_status function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_ARGUMENT_ERROR if <code>N</code> is not a supported transform length.\r
2483    */\r
2484 \r
2485   arm_status arm_dct4_init_q15(\r
2486   arm_dct4_instance_q15 * S,\r
2487   arm_rfft_instance_q15 * S_RFFT,\r
2488   arm_cfft_radix4_instance_q15 * S_CFFT,\r
2489   uint16_t N,\r
2490   uint16_t Nby2,\r
2491   q15_t normalize);\r
2492 \r
2493   /**\r
2494    * @brief Processing function for the Q15 DCT4/IDCT4.\r
2495    * @param[in]       *S             points to an instance of the Q15 DCT4 structure.\r
2496    * @param[in]       *pState        points to state buffer.\r
2497    * @param[in,out]   *pInlineBuffer points to the in-place input and output buffer.\r
2498    * @return none.\r
2499    */\r
2500 \r
2501   void arm_dct4_q15(\r
2502   const arm_dct4_instance_q15 * S,\r
2503   q15_t * pState,\r
2504   q15_t * pInlineBuffer);\r
2505 \r
2506   /**\r
2507    * @brief Floating-point vector addition.\r
2508    * @param[in]       *pSrcA points to the first input vector\r
2509    * @param[in]       *pSrcB points to the second input vector\r
2510    * @param[out]      *pDst points to the output vector\r
2511    * @param[in]       blockSize number of samples in each vector\r
2512    * @return none.\r
2513    */\r
2514 \r
2515   void arm_add_f32(\r
2516   float32_t * pSrcA,\r
2517   float32_t * pSrcB,\r
2518   float32_t * pDst,\r
2519   uint32_t blockSize);\r
2520 \r
2521   /**\r
2522    * @brief Q7 vector addition.\r
2523    * @param[in]       *pSrcA points to the first input vector\r
2524    * @param[in]       *pSrcB points to the second input vector\r
2525    * @param[out]      *pDst points to the output vector\r
2526    * @param[in]       blockSize number of samples in each vector\r
2527    * @return none.\r
2528    */\r
2529 \r
2530   void arm_add_q7(\r
2531   q7_t * pSrcA,\r
2532   q7_t * pSrcB,\r
2533   q7_t * pDst,\r
2534   uint32_t blockSize);\r
2535 \r
2536   /**\r
2537    * @brief Q15 vector addition.\r
2538    * @param[in]       *pSrcA points to the first input vector\r
2539    * @param[in]       *pSrcB points to the second input vector\r
2540    * @param[out]      *pDst points to the output vector\r
2541    * @param[in]       blockSize number of samples in each vector\r
2542    * @return none.\r
2543    */\r
2544 \r
2545   void arm_add_q15(\r
2546   q15_t * pSrcA,\r
2547   q15_t * pSrcB,\r
2548   q15_t * pDst,\r
2549   uint32_t blockSize);\r
2550 \r
2551   /**\r
2552    * @brief Q31 vector addition.\r
2553    * @param[in]       *pSrcA points to the first input vector\r
2554    * @param[in]       *pSrcB points to the second input vector\r
2555    * @param[out]      *pDst points to the output vector\r
2556    * @param[in]       blockSize number of samples in each vector\r
2557    * @return none.\r
2558    */\r
2559 \r
2560   void arm_add_q31(\r
2561   q31_t * pSrcA,\r
2562   q31_t * pSrcB,\r
2563   q31_t * pDst,\r
2564   uint32_t blockSize);\r
2565 \r
2566   /**\r
2567    * @brief Floating-point vector subtraction.\r
2568    * @param[in]       *pSrcA points to the first input vector\r
2569    * @param[in]       *pSrcB points to the second input vector\r
2570    * @param[out]      *pDst points to the output vector\r
2571    * @param[in]       blockSize number of samples in each vector\r
2572    * @return none.\r
2573    */\r
2574 \r
2575   void arm_sub_f32(\r
2576   float32_t * pSrcA,\r
2577   float32_t * pSrcB,\r
2578   float32_t * pDst,\r
2579   uint32_t blockSize);\r
2580 \r
2581   /**\r
2582    * @brief Q7 vector subtraction.\r
2583    * @param[in]       *pSrcA points to the first input vector\r
2584    * @param[in]       *pSrcB points to the second input vector\r
2585    * @param[out]      *pDst points to the output vector\r
2586    * @param[in]       blockSize number of samples in each vector\r
2587    * @return none.\r
2588    */\r
2589 \r
2590   void arm_sub_q7(\r
2591   q7_t * pSrcA,\r
2592   q7_t * pSrcB,\r
2593   q7_t * pDst,\r
2594   uint32_t blockSize);\r
2595 \r
2596   /**\r
2597    * @brief Q15 vector subtraction.\r
2598    * @param[in]       *pSrcA points to the first input vector\r
2599    * @param[in]       *pSrcB points to the second input vector\r
2600    * @param[out]      *pDst points to the output vector\r
2601    * @param[in]       blockSize number of samples in each vector\r
2602    * @return none.\r
2603    */\r
2604 \r
2605   void arm_sub_q15(\r
2606   q15_t * pSrcA,\r
2607   q15_t * pSrcB,\r
2608   q15_t * pDst,\r
2609   uint32_t blockSize);\r
2610 \r
2611   /**\r
2612    * @brief Q31 vector subtraction.\r
2613    * @param[in]       *pSrcA points to the first input vector\r
2614    * @param[in]       *pSrcB points to the second input vector\r
2615    * @param[out]      *pDst points to the output vector\r
2616    * @param[in]       blockSize number of samples in each vector\r
2617    * @return none.\r
2618    */\r
2619 \r
2620   void arm_sub_q31(\r
2621   q31_t * pSrcA,\r
2622   q31_t * pSrcB,\r
2623   q31_t * pDst,\r
2624   uint32_t blockSize);\r
2625 \r
2626   /**\r
2627    * @brief Multiplies a floating-point vector by a scalar.\r
2628    * @param[in]       *pSrc points to the input vector\r
2629    * @param[in]       scale scale factor to be applied\r
2630    * @param[out]      *pDst points to the output vector\r
2631    * @param[in]       blockSize number of samples in the vector\r
2632    * @return none.\r
2633    */\r
2634 \r
2635   void arm_scale_f32(\r
2636   float32_t * pSrc,\r
2637   float32_t scale,\r
2638   float32_t * pDst,\r
2639   uint32_t blockSize);\r
2640 \r
2641   /**\r
2642    * @brief Multiplies a Q7 vector by a scalar.\r
2643    * @param[in]       *pSrc points to the input vector\r
2644    * @param[in]       scaleFract fractional portion of the scale value\r
2645    * @param[in]       shift number of bits to shift the result by\r
2646    * @param[out]      *pDst points to the output vector\r
2647    * @param[in]       blockSize number of samples in the vector\r
2648    * @return none.\r
2649    */\r
2650 \r
2651   void arm_scale_q7(\r
2652   q7_t * pSrc,\r
2653   q7_t scaleFract,\r
2654   int8_t shift,\r
2655   q7_t * pDst,\r
2656   uint32_t blockSize);\r
2657 \r
2658   /**\r
2659    * @brief Multiplies a Q15 vector by a scalar.\r
2660    * @param[in]       *pSrc points to the input vector\r
2661    * @param[in]       scaleFract fractional portion of the scale value\r
2662    * @param[in]       shift number of bits to shift the result by\r
2663    * @param[out]      *pDst points to the output vector\r
2664    * @param[in]       blockSize number of samples in the vector\r
2665    * @return none.\r
2666    */\r
2667 \r
2668   void arm_scale_q15(\r
2669   q15_t * pSrc,\r
2670   q15_t scaleFract,\r
2671   int8_t shift,\r
2672   q15_t * pDst,\r
2673   uint32_t blockSize);\r
2674 \r
2675   /**\r
2676    * @brief Multiplies a Q31 vector by a scalar.\r
2677    * @param[in]       *pSrc points to the input vector\r
2678    * @param[in]       scaleFract fractional portion of the scale value\r
2679    * @param[in]       shift number of bits to shift the result by\r
2680    * @param[out]      *pDst points to the output vector\r
2681    * @param[in]       blockSize number of samples in the vector\r
2682    * @return none.\r
2683    */\r
2684 \r
2685   void arm_scale_q31(\r
2686   q31_t * pSrc,\r
2687   q31_t scaleFract,\r
2688   int8_t shift,\r
2689   q31_t * pDst,\r
2690   uint32_t blockSize);\r
2691 \r
2692   /**\r
2693    * @brief Q7 vector absolute value.\r
2694    * @param[in]       *pSrc points to the input buffer\r
2695    * @param[out]      *pDst points to the output buffer\r
2696    * @param[in]       blockSize number of samples in each vector\r
2697    * @return none.\r
2698    */\r
2699 \r
2700   void arm_abs_q7(\r
2701   q7_t * pSrc,\r
2702   q7_t * pDst,\r
2703   uint32_t blockSize);\r
2704 \r
2705   /**\r
2706    * @brief Floating-point vector absolute value.\r
2707    * @param[in]       *pSrc points to the input buffer\r
2708    * @param[out]      *pDst points to the output buffer\r
2709    * @param[in]       blockSize number of samples in each vector\r
2710    * @return none.\r
2711    */\r
2712 \r
2713   void arm_abs_f32(\r
2714   float32_t * pSrc,\r
2715   float32_t * pDst,\r
2716   uint32_t blockSize);\r
2717 \r
2718   /**\r
2719    * @brief Q15 vector absolute value.\r
2720    * @param[in]       *pSrc points to the input buffer\r
2721    * @param[out]      *pDst points to the output buffer\r
2722    * @param[in]       blockSize number of samples in each vector\r
2723    * @return none.\r
2724    */\r
2725 \r
2726   void arm_abs_q15(\r
2727   q15_t * pSrc,\r
2728   q15_t * pDst,\r
2729   uint32_t blockSize);\r
2730 \r
2731   /**\r
2732    * @brief Q31 vector absolute value.\r
2733    * @param[in]       *pSrc points to the input buffer\r
2734    * @param[out]      *pDst points to the output buffer\r
2735    * @param[in]       blockSize number of samples in each vector\r
2736    * @return none.\r
2737    */\r
2738 \r
2739   void arm_abs_q31(\r
2740   q31_t * pSrc,\r
2741   q31_t * pDst,\r
2742   uint32_t blockSize);\r
2743 \r
2744   /**\r
2745    * @brief Dot product of floating-point vectors.\r
2746    * @param[in]       *pSrcA points to the first input vector\r
2747    * @param[in]       *pSrcB points to the second input vector\r
2748    * @param[in]       blockSize number of samples in each vector\r
2749    * @param[out]      *result output result returned here\r
2750    * @return none.\r
2751    */\r
2752 \r
2753   void arm_dot_prod_f32(\r
2754   float32_t * pSrcA,\r
2755   float32_t * pSrcB,\r
2756   uint32_t blockSize,\r
2757   float32_t * result);\r
2758 \r
2759   /**\r
2760    * @brief Dot product of Q7 vectors.\r
2761    * @param[in]       *pSrcA points to the first input vector\r
2762    * @param[in]       *pSrcB points to the second input vector\r
2763    * @param[in]       blockSize number of samples in each vector\r
2764    * @param[out]      *result output result returned here\r
2765    * @return none.\r
2766    */\r
2767 \r
2768   void arm_dot_prod_q7(\r
2769   q7_t * pSrcA,\r
2770   q7_t * pSrcB,\r
2771   uint32_t blockSize,\r
2772   q31_t * result);\r
2773 \r
2774   /**\r
2775    * @brief Dot product of Q15 vectors.\r
2776    * @param[in]       *pSrcA points to the first input vector\r
2777    * @param[in]       *pSrcB points to the second input vector\r
2778    * @param[in]       blockSize number of samples in each vector\r
2779    * @param[out]      *result output result returned here\r
2780    * @return none.\r
2781    */\r
2782 \r
2783   void arm_dot_prod_q15(\r
2784   q15_t * pSrcA,\r
2785   q15_t * pSrcB,\r
2786   uint32_t blockSize,\r
2787   q63_t * result);\r
2788 \r
2789   /**\r
2790    * @brief Dot product of Q31 vectors.\r
2791    * @param[in]       *pSrcA points to the first input vector\r
2792    * @param[in]       *pSrcB points to the second input vector\r
2793    * @param[in]       blockSize number of samples in each vector\r
2794    * @param[out]      *result output result returned here\r
2795    * @return none.\r
2796    */\r
2797 \r
2798   void arm_dot_prod_q31(\r
2799   q31_t * pSrcA,\r
2800   q31_t * pSrcB,\r
2801   uint32_t blockSize,\r
2802   q63_t * result);\r
2803 \r
2804   /**\r
2805    * @brief  Shifts the elements of a Q7 vector a specified number of bits.\r
2806    * @param[in]  *pSrc points to the input vector\r
2807    * @param[in]  shiftBits number of bits to shift.  A positive value shifts left; a negative value shifts right.\r
2808    * @param[out]  *pDst points to the output vector\r
2809    * @param[in]  blockSize number of samples in the vector\r
2810    * @return none.\r
2811    */\r
2812 \r
2813   void arm_shift_q7(\r
2814   q7_t * pSrc,\r
2815   int8_t shiftBits,\r
2816   q7_t * pDst,\r
2817   uint32_t blockSize);\r
2818 \r
2819   /**\r
2820    * @brief  Shifts the elements of a Q15 vector a specified number of bits.\r
2821    * @param[in]  *pSrc points to the input vector\r
2822    * @param[in]  shiftBits number of bits to shift.  A positive value shifts left; a negative value shifts right.\r
2823    * @param[out]  *pDst points to the output vector\r
2824    * @param[in]  blockSize number of samples in the vector\r
2825    * @return none.\r
2826    */\r
2827 \r
2828   void arm_shift_q15(\r
2829   q15_t * pSrc,\r
2830   int8_t shiftBits,\r
2831   q15_t * pDst,\r
2832   uint32_t blockSize);\r
2833 \r
2834   /**\r
2835    * @brief  Shifts the elements of a Q31 vector a specified number of bits.\r
2836    * @param[in]  *pSrc points to the input vector\r
2837    * @param[in]  shiftBits number of bits to shift.  A positive value shifts left; a negative value shifts right.\r
2838    * @param[out]  *pDst points to the output vector\r
2839    * @param[in]  blockSize number of samples in the vector\r
2840    * @return none.\r
2841    */\r
2842 \r
2843   void arm_shift_q31(\r
2844   q31_t * pSrc,\r
2845   int8_t shiftBits,\r
2846   q31_t * pDst,\r
2847   uint32_t blockSize);\r
2848 \r
2849   /**\r
2850    * @brief  Adds a constant offset to a floating-point vector.\r
2851    * @param[in]  *pSrc points to the input vector\r
2852    * @param[in]  offset is the offset to be added\r
2853    * @param[out]  *pDst points to the output vector\r
2854    * @param[in]  blockSize number of samples in the vector\r
2855    * @return none.\r
2856    */\r
2857 \r
2858   void arm_offset_f32(\r
2859   float32_t * pSrc,\r
2860   float32_t offset,\r
2861   float32_t * pDst,\r
2862   uint32_t blockSize);\r
2863 \r
2864   /**\r
2865    * @brief  Adds a constant offset to a Q7 vector.\r
2866    * @param[in]  *pSrc points to the input vector\r
2867    * @param[in]  offset is the offset to be added\r
2868    * @param[out]  *pDst points to the output vector\r
2869    * @param[in]  blockSize number of samples in the vector\r
2870    * @return none.\r
2871    */\r
2872 \r
2873   void arm_offset_q7(\r
2874   q7_t * pSrc,\r
2875   q7_t offset,\r
2876   q7_t * pDst,\r
2877   uint32_t blockSize);\r
2878 \r
2879   /**\r
2880    * @brief  Adds a constant offset to a Q15 vector.\r
2881    * @param[in]  *pSrc points to the input vector\r
2882    * @param[in]  offset is the offset to be added\r
2883    * @param[out]  *pDst points to the output vector\r
2884    * @param[in]  blockSize number of samples in the vector\r
2885    * @return none.\r
2886    */\r
2887 \r
2888   void arm_offset_q15(\r
2889   q15_t * pSrc,\r
2890   q15_t offset,\r
2891   q15_t * pDst,\r
2892   uint32_t blockSize);\r
2893 \r
2894   /**\r
2895    * @brief  Adds a constant offset to a Q31 vector.\r
2896    * @param[in]  *pSrc points to the input vector\r
2897    * @param[in]  offset is the offset to be added\r
2898    * @param[out]  *pDst points to the output vector\r
2899    * @param[in]  blockSize number of samples in the vector\r
2900    * @return none.\r
2901    */\r
2902 \r
2903   void arm_offset_q31(\r
2904   q31_t * pSrc,\r
2905   q31_t offset,\r
2906   q31_t * pDst,\r
2907   uint32_t blockSize);\r
2908 \r
2909   /**\r
2910    * @brief  Negates the elements of a floating-point vector.\r
2911    * @param[in]  *pSrc points to the input vector\r
2912    * @param[out]  *pDst points to the output vector\r
2913    * @param[in]  blockSize number of samples in the vector\r
2914    * @return none.\r
2915    */\r
2916 \r
2917   void arm_negate_f32(\r
2918   float32_t * pSrc,\r
2919   float32_t * pDst,\r
2920   uint32_t blockSize);\r
2921 \r
2922   /**\r
2923    * @brief  Negates the elements of a Q7 vector.\r
2924    * @param[in]  *pSrc points to the input vector\r
2925    * @param[out]  *pDst points to the output vector\r
2926    * @param[in]  blockSize number of samples in the vector\r
2927    * @return none.\r
2928    */\r
2929 \r
2930   void arm_negate_q7(\r
2931   q7_t * pSrc,\r
2932   q7_t * pDst,\r
2933   uint32_t blockSize);\r
2934 \r
2935   /**\r
2936    * @brief  Negates the elements of a Q15 vector.\r
2937    * @param[in]  *pSrc points to the input vector\r
2938    * @param[out]  *pDst points to the output vector\r
2939    * @param[in]  blockSize number of samples in the vector\r
2940    * @return none.\r
2941    */\r
2942 \r
2943   void arm_negate_q15(\r
2944   q15_t * pSrc,\r
2945   q15_t * pDst,\r
2946   uint32_t blockSize);\r
2947 \r
2948   /**\r
2949    * @brief  Negates the elements of a Q31 vector.\r
2950    * @param[in]  *pSrc points to the input vector\r
2951    * @param[out]  *pDst points to the output vector\r
2952    * @param[in]  blockSize number of samples in the vector\r
2953    * @return none.\r
2954    */\r
2955 \r
2956   void arm_negate_q31(\r
2957   q31_t * pSrc,\r
2958   q31_t * pDst,\r
2959   uint32_t blockSize);\r
2960   /**\r
2961    * @brief  Copies the elements of a floating-point vector.\r
2962    * @param[in]  *pSrc input pointer\r
2963    * @param[out]  *pDst output pointer\r
2964    * @param[in]  blockSize number of samples to process\r
2965    * @return none.\r
2966    */\r
2967   void arm_copy_f32(\r
2968   float32_t * pSrc,\r
2969   float32_t * pDst,\r
2970   uint32_t blockSize);\r
2971 \r
2972   /**\r
2973    * @brief  Copies the elements of a Q7 vector.\r
2974    * @param[in]  *pSrc input pointer\r
2975    * @param[out]  *pDst output pointer\r
2976    * @param[in]  blockSize number of samples to process\r
2977    * @return none.\r
2978    */\r
2979   void arm_copy_q7(\r
2980   q7_t * pSrc,\r
2981   q7_t * pDst,\r
2982   uint32_t blockSize);\r
2983 \r
2984   /**\r
2985    * @brief  Copies the elements of a Q15 vector.\r
2986    * @param[in]  *pSrc input pointer\r
2987    * @param[out]  *pDst output pointer\r
2988    * @param[in]  blockSize number of samples to process\r
2989    * @return none.\r
2990    */\r
2991   void arm_copy_q15(\r
2992   q15_t * pSrc,\r
2993   q15_t * pDst,\r
2994   uint32_t blockSize);\r
2995 \r
2996   /**\r
2997    * @brief  Copies the elements of a Q31 vector.\r
2998    * @param[in]  *pSrc input pointer\r
2999    * @param[out]  *pDst output pointer\r
3000    * @param[in]  blockSize number of samples to process\r
3001    * @return none.\r
3002    */\r
3003   void arm_copy_q31(\r
3004   q31_t * pSrc,\r
3005   q31_t * pDst,\r
3006   uint32_t blockSize);\r
3007   /**\r
3008    * @brief  Fills a constant value into a floating-point vector.\r
3009    * @param[in]  value input value to be filled\r
3010    * @param[out]  *pDst output pointer\r
3011    * @param[in]  blockSize number of samples to process\r
3012    * @return none.\r
3013    */\r
3014   void arm_fill_f32(\r
3015   float32_t value,\r
3016   float32_t * pDst,\r
3017   uint32_t blockSize);\r
3018 \r
3019   /**\r
3020    * @brief  Fills a constant value into a Q7 vector.\r
3021    * @param[in]  value input value to be filled\r
3022    * @param[out]  *pDst output pointer\r
3023    * @param[in]  blockSize number of samples to process\r
3024    * @return none.\r
3025    */\r
3026   void arm_fill_q7(\r
3027   q7_t value,\r
3028   q7_t * pDst,\r
3029   uint32_t blockSize);\r
3030 \r
3031   /**\r
3032    * @brief  Fills a constant value into a Q15 vector.\r
3033    * @param[in]  value input value to be filled\r
3034    * @param[out]  *pDst output pointer\r
3035    * @param[in]  blockSize number of samples to process\r
3036    * @return none.\r
3037    */\r
3038   void arm_fill_q15(\r
3039   q15_t value,\r
3040   q15_t * pDst,\r
3041   uint32_t blockSize);\r
3042 \r
3043   /**\r
3044    * @brief  Fills a constant value into a Q31 vector.\r
3045    * @param[in]  value input value to be filled\r
3046    * @param[out]  *pDst output pointer\r
3047    * @param[in]  blockSize number of samples to process\r
3048    * @return none.\r
3049    */\r
3050   void arm_fill_q31(\r
3051   q31_t value,\r
3052   q31_t * pDst,\r
3053   uint32_t blockSize);\r
3054 \r
3055 /**\r
3056  * @brief Convolution of floating-point sequences.\r
3057  * @param[in] *pSrcA points to the first input sequence.\r
3058  * @param[in] srcALen length of the first input sequence.\r
3059  * @param[in] *pSrcB points to the second input sequence.\r
3060  * @param[in] srcBLen length of the second input sequence.\r
3061  * @param[out] *pDst points to the location where the output result is written.  Length srcALen+srcBLen-1.\r
3062  * @return none.\r
3063  */\r
3064 \r
3065   void arm_conv_f32(\r
3066   float32_t * pSrcA,\r
3067   uint32_t srcALen,\r
3068   float32_t * pSrcB,\r
3069   uint32_t srcBLen,\r
3070   float32_t * pDst);\r
3071 \r
3072 \r
3073   /**\r
3074    * @brief Convolution of Q15 sequences.\r
3075    * @param[in] *pSrcA points to the first input sequence.\r
3076    * @param[in] srcALen length of the first input sequence.\r
3077    * @param[in] *pSrcB points to the second input sequence.\r
3078    * @param[in] srcBLen length of the second input sequence.\r
3079    * @param[out] *pDst points to the block of output data  Length srcALen+srcBLen-1.\r
3080    * @param[in]  *pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.\r
3081    * @param[in]  *pScratch2 points to scratch buffer of size min(srcALen, srcBLen).\r
3082    * @return none.\r
3083    */\r
3084 \r
3085 \r
3086   void arm_conv_opt_q15(\r
3087   q15_t * pSrcA,\r
3088   uint32_t srcALen,\r
3089   q15_t * pSrcB,\r
3090   uint32_t srcBLen,\r
3091   q15_t * pDst,\r
3092   q15_t * pScratch1,\r
3093   q15_t * pScratch2);\r
3094 \r
3095 \r
3096 /**\r
3097  * @brief Convolution of Q15 sequences.\r
3098  * @param[in] *pSrcA points to the first input sequence.\r
3099  * @param[in] srcALen length of the first input sequence.\r
3100  * @param[in] *pSrcB points to the second input sequence.\r
3101  * @param[in] srcBLen length of the second input sequence.\r
3102  * @param[out] *pDst points to the location where the output result is written.  Length srcALen+srcBLen-1.\r
3103  * @return none.\r
3104  */\r
3105 \r
3106   void arm_conv_q15(\r
3107   q15_t * pSrcA,\r
3108   uint32_t srcALen,\r
3109   q15_t * pSrcB,\r
3110   uint32_t srcBLen,\r
3111   q15_t * pDst);\r
3112 \r
3113   /**\r
3114    * @brief Convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4\r
3115    * @param[in] *pSrcA points to the first input sequence.\r
3116    * @param[in] srcALen length of the first input sequence.\r
3117    * @param[in] *pSrcB points to the second input sequence.\r
3118    * @param[in] srcBLen length of the second input sequence.\r
3119    * @param[out] *pDst points to the block of output data  Length srcALen+srcBLen-1.\r
3120    * @return none.\r
3121    */\r
3122 \r
3123   void arm_conv_fast_q15(\r
3124                           q15_t * pSrcA,\r
3125                          uint32_t srcALen,\r
3126                           q15_t * pSrcB,\r
3127                          uint32_t srcBLen,\r
3128                          q15_t * pDst);\r
3129 \r
3130   /**\r
3131    * @brief Convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4\r
3132    * @param[in] *pSrcA points to the first input sequence.\r
3133    * @param[in] srcALen length of the first input sequence.\r
3134    * @param[in] *pSrcB points to the second input sequence.\r
3135    * @param[in] srcBLen length of the second input sequence.\r
3136    * @param[out] *pDst points to the block of output data  Length srcALen+srcBLen-1.\r
3137    * @param[in]  *pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.\r
3138    * @param[in]  *pScratch2 points to scratch buffer of size min(srcALen, srcBLen).\r
3139    * @return none.\r
3140    */\r
3141 \r
3142   void arm_conv_fast_opt_q15(\r
3143   q15_t * pSrcA,\r
3144   uint32_t srcALen,\r
3145   q15_t * pSrcB,\r
3146   uint32_t srcBLen,\r
3147   q15_t * pDst,\r
3148   q15_t * pScratch1,\r
3149   q15_t * pScratch2);\r
3150 \r
3151 \r
3152 \r
3153   /**\r
3154    * @brief Convolution of Q31 sequences.\r
3155    * @param[in] *pSrcA points to the first input sequence.\r
3156    * @param[in] srcALen length of the first input sequence.\r
3157    * @param[in] *pSrcB points to the second input sequence.\r
3158    * @param[in] srcBLen length of the second input sequence.\r
3159    * @param[out] *pDst points to the block of output data  Length srcALen+srcBLen-1.\r
3160    * @return none.\r
3161    */\r
3162 \r
3163   void arm_conv_q31(\r
3164   q31_t * pSrcA,\r
3165   uint32_t srcALen,\r
3166   q31_t * pSrcB,\r
3167   uint32_t srcBLen,\r
3168   q31_t * pDst);\r
3169 \r
3170   /**\r
3171    * @brief Convolution of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4\r
3172    * @param[in] *pSrcA points to the first input sequence.\r
3173    * @param[in] srcALen length of the first input sequence.\r
3174    * @param[in] *pSrcB points to the second input sequence.\r
3175    * @param[in] srcBLen length of the second input sequence.\r
3176    * @param[out] *pDst points to the block of output data  Length srcALen+srcBLen-1.\r
3177    * @return none.\r
3178    */\r
3179 \r
3180   void arm_conv_fast_q31(\r
3181   q31_t * pSrcA,\r
3182   uint32_t srcALen,\r
3183   q31_t * pSrcB,\r
3184   uint32_t srcBLen,\r
3185   q31_t * pDst);\r
3186 \r
3187 \r
3188     /**\r
3189    * @brief Convolution of Q7 sequences.\r
3190    * @param[in] *pSrcA points to the first input sequence.\r
3191    * @param[in] srcALen length of the first input sequence.\r
3192    * @param[in] *pSrcB points to the second input sequence.\r
3193    * @param[in] srcBLen length of the second input sequence.\r
3194    * @param[out] *pDst points to the block of output data  Length srcALen+srcBLen-1.\r
3195    * @param[in]  *pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.\r
3196    * @param[in]  *pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen).\r
3197    * @return none.\r
3198    */\r
3199 \r
3200   void arm_conv_opt_q7(\r
3201   q7_t * pSrcA,\r
3202   uint32_t srcALen,\r
3203   q7_t * pSrcB,\r
3204   uint32_t srcBLen,\r
3205   q7_t * pDst,\r
3206   q15_t * pScratch1,\r
3207   q15_t * pScratch2);\r
3208 \r
3209 \r
3210 \r
3211   /**\r
3212    * @brief Convolution of Q7 sequences.\r
3213    * @param[in] *pSrcA points to the first input sequence.\r
3214    * @param[in] srcALen length of the first input sequence.\r
3215    * @param[in] *pSrcB points to the second input sequence.\r
3216    * @param[in] srcBLen length of the second input sequence.\r
3217    * @param[out] *pDst points to the block of output data  Length srcALen+srcBLen-1.\r
3218    * @return none.\r
3219    */\r
3220 \r
3221   void arm_conv_q7(\r
3222   q7_t * pSrcA,\r
3223   uint32_t srcALen,\r
3224   q7_t * pSrcB,\r
3225   uint32_t srcBLen,\r
3226   q7_t * pDst);\r
3227 \r
3228 \r
3229   /**\r
3230    * @brief Partial convolution of floating-point sequences.\r
3231    * @param[in]       *pSrcA points to the first input sequence.\r
3232    * @param[in]       srcALen length of the first input sequence.\r
3233    * @param[in]       *pSrcB points to the second input sequence.\r
3234    * @param[in]       srcBLen length of the second input sequence.\r
3235    * @param[out]      *pDst points to the block of output data\r
3236    * @param[in]       firstIndex is the first output sample to start with.\r
3237    * @param[in]       numPoints is the number of output points to be computed.\r
3238    * @return  Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].\r
3239    */\r
3240 \r
3241   arm_status arm_conv_partial_f32(\r
3242   float32_t * pSrcA,\r
3243   uint32_t srcALen,\r
3244   float32_t * pSrcB,\r
3245   uint32_t srcBLen,\r
3246   float32_t * pDst,\r
3247   uint32_t firstIndex,\r
3248   uint32_t numPoints);\r
3249 \r
3250     /**\r
3251    * @brief Partial convolution of Q15 sequences.\r
3252    * @param[in]       *pSrcA points to the first input sequence.\r
3253    * @param[in]       srcALen length of the first input sequence.\r
3254    * @param[in]       *pSrcB points to the second input sequence.\r
3255    * @param[in]       srcBLen length of the second input sequence.\r
3256    * @param[out]      *pDst points to the block of output data\r
3257    * @param[in]       firstIndex is the first output sample to start with.\r
3258    * @param[in]       numPoints is the number of output points to be computed.\r
3259    * @param[in]       * pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.\r
3260    * @param[in]       * pScratch2 points to scratch buffer of size min(srcALen, srcBLen).\r
3261    * @return  Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].\r
3262    */\r
3263 \r
3264   arm_status arm_conv_partial_opt_q15(\r
3265   q15_t * pSrcA,\r
3266   uint32_t srcALen,\r
3267   q15_t * pSrcB,\r
3268   uint32_t srcBLen,\r
3269   q15_t * pDst,\r
3270   uint32_t firstIndex,\r
3271   uint32_t numPoints,\r
3272   q15_t * pScratch1,\r
3273   q15_t * pScratch2);\r
3274 \r
3275 \r
3276 /**\r
3277    * @brief Partial convolution of Q15 sequences.\r
3278    * @param[in]       *pSrcA points to the first input sequence.\r
3279    * @param[in]       srcALen length of the first input sequence.\r
3280    * @param[in]       *pSrcB points to the second input sequence.\r
3281    * @param[in]       srcBLen length of the second input sequence.\r
3282    * @param[out]      *pDst points to the block of output data\r
3283    * @param[in]       firstIndex is the first output sample to start with.\r
3284    * @param[in]       numPoints is the number of output points to be computed.\r
3285    * @return  Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].\r
3286    */\r
3287 \r
3288   arm_status arm_conv_partial_q15(\r
3289   q15_t * pSrcA,\r
3290   uint32_t srcALen,\r
3291   q15_t * pSrcB,\r
3292   uint32_t srcBLen,\r
3293   q15_t * pDst,\r
3294   uint32_t firstIndex,\r
3295   uint32_t numPoints);\r
3296 \r
3297   /**\r
3298    * @brief Partial convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4\r
3299    * @param[in]       *pSrcA points to the first input sequence.\r
3300    * @param[in]       srcALen length of the first input sequence.\r
3301    * @param[in]       *pSrcB points to the second input sequence.\r
3302    * @param[in]       srcBLen length of the second input sequence.\r
3303    * @param[out]      *pDst points to the block of output data\r
3304    * @param[in]       firstIndex is the first output sample to start with.\r
3305    * @param[in]       numPoints is the number of output points to be computed.\r
3306    * @return  Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].\r
3307    */\r
3308 \r
3309   arm_status arm_conv_partial_fast_q15(\r
3310                                         q15_t * pSrcA,\r
3311                                        uint32_t srcALen,\r
3312                                         q15_t * pSrcB,\r
3313                                        uint32_t srcBLen,\r
3314                                        q15_t * pDst,\r
3315                                        uint32_t firstIndex,\r
3316                                        uint32_t numPoints);\r
3317 \r
3318 \r
3319   /**\r
3320    * @brief Partial convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4\r
3321    * @param[in]       *pSrcA points to the first input sequence.\r
3322    * @param[in]       srcALen length of the first input sequence.\r
3323    * @param[in]       *pSrcB points to the second input sequence.\r
3324    * @param[in]       srcBLen length of the second input sequence.\r
3325    * @param[out]      *pDst points to the block of output data\r
3326    * @param[in]       firstIndex is the first output sample to start with.\r
3327    * @param[in]       numPoints is the number of output points to be computed.\r
3328    * @param[in]       * pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.\r
3329    * @param[in]       * pScratch2 points to scratch buffer of size min(srcALen, srcBLen).\r
3330    * @return  Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].\r
3331    */\r
3332 \r
3333   arm_status arm_conv_partial_fast_opt_q15(\r
3334   q15_t * pSrcA,\r
3335   uint32_t srcALen,\r
3336   q15_t * pSrcB,\r
3337   uint32_t srcBLen,\r
3338   q15_t * pDst,\r
3339   uint32_t firstIndex,\r
3340   uint32_t numPoints,\r
3341   q15_t * pScratch1,\r
3342   q15_t * pScratch2);\r
3343 \r
3344 \r
3345   /**\r
3346    * @brief Partial convolution of Q31 sequences.\r
3347    * @param[in]       *pSrcA points to the first input sequence.\r
3348    * @param[in]       srcALen length of the first input sequence.\r
3349    * @param[in]       *pSrcB points to the second input sequence.\r
3350    * @param[in]       srcBLen length of the second input sequence.\r
3351    * @param[out]      *pDst points to the block of output data\r
3352    * @param[in]       firstIndex is the first output sample to start with.\r
3353    * @param[in]       numPoints is the number of output points to be computed.\r
3354    * @return  Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].\r
3355    */\r
3356 \r
3357   arm_status arm_conv_partial_q31(\r
3358   q31_t * pSrcA,\r
3359   uint32_t srcALen,\r
3360   q31_t * pSrcB,\r
3361   uint32_t srcBLen,\r
3362   q31_t * pDst,\r
3363   uint32_t firstIndex,\r
3364   uint32_t numPoints);\r
3365 \r
3366 \r
3367   /**\r
3368    * @brief Partial convolution of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4\r
3369    * @param[in]       *pSrcA points to the first input sequence.\r
3370    * @param[in]       srcALen length of the first input sequence.\r
3371    * @param[in]       *pSrcB points to the second input sequence.\r
3372    * @param[in]       srcBLen length of the second input sequence.\r
3373    * @param[out]      *pDst points to the block of output data\r
3374    * @param[in]       firstIndex is the first output sample to start with.\r
3375    * @param[in]       numPoints is the number of output points to be computed.\r
3376    * @return  Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].\r
3377    */\r
3378 \r
3379   arm_status arm_conv_partial_fast_q31(\r
3380   q31_t * pSrcA,\r
3381   uint32_t srcALen,\r
3382   q31_t * pSrcB,\r
3383   uint32_t srcBLen,\r
3384   q31_t * pDst,\r
3385   uint32_t firstIndex,\r
3386   uint32_t numPoints);\r
3387 \r
3388 \r
3389   /**\r
3390    * @brief Partial convolution of Q7 sequences\r
3391    * @param[in]       *pSrcA points to the first input sequence.\r
3392    * @param[in]       srcALen length of the first input sequence.\r
3393    * @param[in]       *pSrcB points to the second input sequence.\r
3394    * @param[in]       srcBLen length of the second input sequence.\r
3395    * @param[out]      *pDst points to the block of output data\r
3396    * @param[in]       firstIndex is the first output sample to start with.\r
3397    * @param[in]       numPoints is the number of output points to be computed.\r
3398    * @param[in]  *pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.\r
3399    * @param[in]  *pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen).\r
3400    * @return  Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].\r
3401    */\r
3402 \r
3403   arm_status arm_conv_partial_opt_q7(\r
3404   q7_t * pSrcA,\r
3405   uint32_t srcALen,\r
3406   q7_t * pSrcB,\r
3407   uint32_t srcBLen,\r
3408   q7_t * pDst,\r
3409   uint32_t firstIndex,\r
3410   uint32_t numPoints,\r
3411   q15_t * pScratch1,\r
3412   q15_t * pScratch2);\r
3413 \r
3414 \r
3415 /**\r
3416    * @brief Partial convolution of Q7 sequences.\r
3417    * @param[in]       *pSrcA points to the first input sequence.\r
3418    * @param[in]       srcALen length of the first input sequence.\r
3419    * @param[in]       *pSrcB points to the second input sequence.\r
3420    * @param[in]       srcBLen length of the second input sequence.\r
3421    * @param[out]      *pDst points to the block of output data\r
3422    * @param[in]       firstIndex is the first output sample to start with.\r
3423    * @param[in]       numPoints is the number of output points to be computed.\r
3424    * @return  Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].\r
3425    */\r
3426 \r
3427   arm_status arm_conv_partial_q7(\r
3428   q7_t * pSrcA,\r
3429   uint32_t srcALen,\r
3430   q7_t * pSrcB,\r
3431   uint32_t srcBLen,\r
3432   q7_t * pDst,\r
3433   uint32_t firstIndex,\r
3434   uint32_t numPoints);\r
3435 \r
3436 \r
3437 \r
3438   /**\r
3439    * @brief Instance structure for the Q15 FIR decimator.\r
3440    */\r
3441 \r
3442   typedef struct\r
3443   {\r
3444     uint8_t M;                      /**< decimation factor. */\r
3445     uint16_t numTaps;               /**< number of coefficients in the filter. */\r
3446     q15_t *pCoeffs;                  /**< points to the coefficient array. The array is of length numTaps.*/\r
3447     q15_t *pState;                   /**< points to the state variable array. The array is of length numTaps+blockSize-1. */\r
3448   } arm_fir_decimate_instance_q15;\r
3449 \r
3450   /**\r
3451    * @brief Instance structure for the Q31 FIR decimator.\r
3452    */\r
3453 \r
3454   typedef struct\r
3455   {\r
3456     uint8_t M;                  /**< decimation factor. */\r
3457     uint16_t numTaps;           /**< number of coefficients in the filter. */\r
3458     q31_t *pCoeffs;              /**< points to the coefficient array. The array is of length numTaps.*/\r
3459     q31_t *pState;               /**< points to the state variable array. The array is of length numTaps+blockSize-1. */\r
3460 \r
3461   } arm_fir_decimate_instance_q31;\r
3462 \r
3463   /**\r
3464    * @brief Instance structure for the floating-point FIR decimator.\r
3465    */\r
3466 \r
3467   typedef struct\r
3468   {\r
3469     uint8_t M;                          /**< decimation factor. */\r
3470     uint16_t numTaps;                   /**< number of coefficients in the filter. */\r
3471     float32_t *pCoeffs;                  /**< points to the coefficient array. The array is of length numTaps.*/\r
3472     float32_t *pState;                   /**< points to the state variable array. The array is of length numTaps+blockSize-1. */\r
3473 \r
3474   } arm_fir_decimate_instance_f32;\r
3475 \r
3476 \r
3477 \r
3478   /**\r
3479    * @brief Processing function for the floating-point FIR decimator.\r
3480    * @param[in] *S points to an instance of the floating-point FIR decimator structure.\r
3481    * @param[in] *pSrc points to the block of input data.\r
3482    * @param[out] *pDst points to the block of output data\r
3483    * @param[in] blockSize number of input samples to process per call.\r
3484    * @return none\r
3485    */\r
3486 \r
3487   void arm_fir_decimate_f32(\r
3488   const arm_fir_decimate_instance_f32 * S,\r
3489   float32_t * pSrc,\r
3490   float32_t * pDst,\r
3491   uint32_t blockSize);\r
3492 \r
3493 \r
3494   /**\r
3495    * @brief  Initialization function for the floating-point FIR decimator.\r
3496    * @param[in,out] *S points to an instance of the floating-point FIR decimator structure.\r
3497    * @param[in] numTaps  number of coefficients in the filter.\r
3498    * @param[in] M  decimation factor.\r
3499    * @param[in] *pCoeffs points to the filter coefficients.\r
3500    * @param[in] *pState points to the state buffer.\r
3501    * @param[in] blockSize number of input samples to process per call.\r
3502    * @return    The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if\r
3503    * <code>blockSize</code> is not a multiple of <code>M</code>.\r
3504    */\r
3505 \r
3506   arm_status arm_fir_decimate_init_f32(\r
3507   arm_fir_decimate_instance_f32 * S,\r
3508   uint16_t numTaps,\r
3509   uint8_t M,\r
3510   float32_t * pCoeffs,\r
3511   float32_t * pState,\r
3512   uint32_t blockSize);\r
3513 \r
3514   /**\r
3515    * @brief Processing function for the Q15 FIR decimator.\r
3516    * @param[in] *S points to an instance of the Q15 FIR decimator structure.\r
3517    * @param[in] *pSrc points to the block of input data.\r
3518    * @param[out] *pDst points to the block of output data\r
3519    * @param[in] blockSize number of input samples to process per call.\r
3520    * @return none\r
3521    */\r
3522 \r
3523   void arm_fir_decimate_q15(\r
3524   const arm_fir_decimate_instance_q15 * S,\r
3525   q15_t * pSrc,\r
3526   q15_t * pDst,\r
3527   uint32_t blockSize);\r
3528 \r
3529   /**\r
3530    * @brief Processing function for the Q15 FIR decimator (fast variant) for Cortex-M3 and Cortex-M4.\r
3531    * @param[in] *S points to an instance of the Q15 FIR decimator structure.\r
3532    * @param[in] *pSrc points to the block of input data.\r
3533    * @param[out] *pDst points to the block of output data\r
3534    * @param[in] blockSize number of input samples to process per call.\r
3535    * @return none\r
3536    */\r
3537 \r
3538   void arm_fir_decimate_fast_q15(\r
3539   const arm_fir_decimate_instance_q15 * S,\r
3540   q15_t * pSrc,\r
3541   q15_t * pDst,\r
3542   uint32_t blockSize);\r
3543 \r
3544 \r
3545 \r
3546   /**\r
3547    * @brief  Initialization function for the Q15 FIR decimator.\r
3548    * @param[in,out] *S points to an instance of the Q15 FIR decimator structure.\r
3549    * @param[in] numTaps  number of coefficients in the filter.\r
3550    * @param[in] M  decimation factor.\r
3551    * @param[in] *pCoeffs points to the filter coefficients.\r
3552    * @param[in] *pState points to the state buffer.\r
3553    * @param[in] blockSize number of input samples to process per call.\r
3554    * @return    The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if\r
3555    * <code>blockSize</code> is not a multiple of <code>M</code>.\r
3556    */\r
3557 \r
3558   arm_status arm_fir_decimate_init_q15(\r
3559   arm_fir_decimate_instance_q15 * S,\r
3560   uint16_t numTaps,\r
3561   uint8_t M,\r
3562   q15_t * pCoeffs,\r
3563   q15_t * pState,\r
3564   uint32_t blockSize);\r
3565 \r
3566   /**\r
3567    * @brief Processing function for the Q31 FIR decimator.\r
3568    * @param[in] *S points to an instance of the Q31 FIR decimator structure.\r
3569    * @param[in] *pSrc points to the block of input data.\r
3570    * @param[out] *pDst points to the block of output data\r
3571    * @param[in] blockSize number of input samples to process per call.\r
3572    * @return none\r
3573    */\r
3574 \r
3575   void arm_fir_decimate_q31(\r
3576   const arm_fir_decimate_instance_q31 * S,\r
3577   q31_t * pSrc,\r
3578   q31_t * pDst,\r
3579   uint32_t blockSize);\r
3580 \r
3581   /**\r
3582    * @brief Processing function for the Q31 FIR decimator (fast variant) for Cortex-M3 and Cortex-M4.\r
3583    * @param[in] *S points to an instance of the Q31 FIR decimator structure.\r
3584    * @param[in] *pSrc points to the block of input data.\r
3585    * @param[out] *pDst points to the block of output data\r
3586    * @param[in] blockSize number of input samples to process per call.\r
3587    * @return none\r
3588    */\r
3589 \r
3590   void arm_fir_decimate_fast_q31(\r
3591   arm_fir_decimate_instance_q31 * S,\r
3592   q31_t * pSrc,\r
3593   q31_t * pDst,\r
3594   uint32_t blockSize);\r
3595 \r
3596 \r
3597   /**\r
3598    * @brief  Initialization function for the Q31 FIR decimator.\r
3599    * @param[in,out] *S points to an instance of the Q31 FIR decimator structure.\r
3600    * @param[in] numTaps  number of coefficients in the filter.\r
3601    * @param[in] M  decimation factor.\r
3602    * @param[in] *pCoeffs points to the filter coefficients.\r
3603    * @param[in] *pState points to the state buffer.\r
3604    * @param[in] blockSize number of input samples to process per call.\r
3605    * @return    The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if\r
3606    * <code>blockSize</code> is not a multiple of <code>M</code>.\r
3607    */\r
3608 \r
3609   arm_status arm_fir_decimate_init_q31(\r
3610   arm_fir_decimate_instance_q31 * S,\r
3611   uint16_t numTaps,\r
3612   uint8_t M,\r
3613   q31_t * pCoeffs,\r
3614   q31_t * pState,\r
3615   uint32_t blockSize);\r
3616 \r
3617 \r
3618 \r
3619   /**\r
3620    * @brief Instance structure for the Q15 FIR interpolator.\r
3621    */\r
3622 \r
3623   typedef struct\r
3624   {\r
3625     uint8_t L;                      /**< upsample factor. */\r
3626     uint16_t phaseLength;           /**< length of each polyphase filter component. */\r
3627     q15_t *pCoeffs;                 /**< points to the coefficient array. The array is of length L*phaseLength. */\r
3628     q15_t *pState;                  /**< points to the state variable array. The array is of length blockSize+phaseLength-1. */\r
3629   } arm_fir_interpolate_instance_q15;\r
3630 \r
3631   /**\r
3632    * @brief Instance structure for the Q31 FIR interpolator.\r
3633    */\r
3634 \r
3635   typedef struct\r
3636   {\r
3637     uint8_t L;                      /**< upsample factor. */\r
3638     uint16_t phaseLength;           /**< length of each polyphase filter component. */\r
3639     q31_t *pCoeffs;                  /**< points to the coefficient array. The array is of length L*phaseLength. */\r
3640     q31_t *pState;                   /**< points to the state variable array. The array is of length blockSize+phaseLength-1. */\r
3641   } arm_fir_interpolate_instance_q31;\r
3642 \r
3643   /**\r
3644    * @brief Instance structure for the floating-point FIR interpolator.\r
3645    */\r
3646 \r
3647   typedef struct\r
3648   {\r
3649     uint8_t L;                     /**< upsample factor. */\r
3650     uint16_t phaseLength;          /**< length of each polyphase filter component. */\r
3651     float32_t *pCoeffs;             /**< points to the coefficient array. The array is of length L*phaseLength. */\r
3652     float32_t *pState;              /**< points to the state variable array. The array is of length phaseLength+numTaps-1. */\r
3653   } arm_fir_interpolate_instance_f32;\r
3654 \r
3655 \r
3656   /**\r
3657    * @brief Processing function for the Q15 FIR interpolator.\r
3658    * @param[in] *S        points to an instance of the Q15 FIR interpolator structure.\r
3659    * @param[in] *pSrc     points to the block of input data.\r
3660    * @param[out] *pDst    points to the block of output data.\r
3661    * @param[in] blockSize number of input samples to process per call.\r
3662    * @return none.\r
3663    */\r
3664 \r
3665   void arm_fir_interpolate_q15(\r
3666   const arm_fir_interpolate_instance_q15 * S,\r
3667   q15_t * pSrc,\r
3668   q15_t * pDst,\r
3669   uint32_t blockSize);\r
3670 \r
3671 \r
3672   /**\r
3673    * @brief  Initialization function for the Q15 FIR interpolator.\r
3674    * @param[in,out] *S        points to an instance of the Q15 FIR interpolator structure.\r
3675    * @param[in]     L         upsample factor.\r
3676    * @param[in]     numTaps   number of filter coefficients in the filter.\r
3677    * @param[in]     *pCoeffs  points to the filter coefficient buffer.\r
3678    * @param[in]     *pState   points to the state buffer.\r
3679    * @param[in]     blockSize number of input samples to process per call.\r
3680    * @return        The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if\r
3681    * the filter length <code>numTaps</code> is not a multiple of the interpolation factor <code>L</code>.\r
3682    */\r
3683 \r
3684   arm_status arm_fir_interpolate_init_q15(\r
3685   arm_fir_interpolate_instance_q15 * S,\r
3686   uint8_t L,\r
3687   uint16_t numTaps,\r
3688   q15_t * pCoeffs,\r
3689   q15_t * pState,\r
3690   uint32_t blockSize);\r
3691 \r
3692   /**\r
3693    * @brief Processing function for the Q31 FIR interpolator.\r
3694    * @param[in] *S        points to an instance of the Q15 FIR interpolator structure.\r
3695    * @param[in] *pSrc     points to the block of input data.\r
3696    * @param[out] *pDst    points to the block of output data.\r
3697    * @param[in] blockSize number of input samples to process per call.\r
3698    * @return none.\r
3699    */\r
3700 \r
3701   void arm_fir_interpolate_q31(\r
3702   const arm_fir_interpolate_instance_q31 * S,\r
3703   q31_t * pSrc,\r
3704   q31_t * pDst,\r
3705   uint32_t blockSize);\r
3706 \r
3707   /**\r
3708    * @brief  Initialization function for the Q31 FIR interpolator.\r
3709    * @param[in,out] *S        points to an instance of the Q31 FIR interpolator structure.\r
3710    * @param[in]     L         upsample factor.\r
3711    * @param[in]     numTaps   number of filter coefficients in the filter.\r
3712    * @param[in]     *pCoeffs  points to the filter coefficient buffer.\r
3713    * @param[in]     *pState   points to the state buffer.\r
3714    * @param[in]     blockSize number of input samples to process per call.\r
3715    * @return        The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if\r
3716    * the filter length <code>numTaps</code> is not a multiple of the interpolation factor <code>L</code>.\r
3717    */\r
3718 \r
3719   arm_status arm_fir_interpolate_init_q31(\r
3720   arm_fir_interpolate_instance_q31 * S,\r
3721   uint8_t L,\r
3722   uint16_t numTaps,\r
3723   q31_t * pCoeffs,\r
3724   q31_t * pState,\r
3725   uint32_t blockSize);\r
3726 \r
3727 \r
3728   /**\r
3729    * @brief Processing function for the floating-point FIR interpolator.\r
3730    * @param[in] *S        points to an instance of the floating-point FIR interpolator structure.\r
3731    * @param[in] *pSrc     points to the block of input data.\r
3732    * @param[out] *pDst    points to the block of output data.\r
3733    * @param[in] blockSize number of input samples to process per call.\r
3734    * @return none.\r
3735    */\r
3736 \r
3737   void arm_fir_interpolate_f32(\r
3738   const arm_fir_interpolate_instance_f32 * S,\r
3739   float32_t * pSrc,\r
3740   float32_t * pDst,\r
3741   uint32_t blockSize);\r
3742 \r
3743   /**\r
3744    * @brief  Initialization function for the floating-point FIR interpolator.\r
3745    * @param[in,out] *S        points to an instance of the floating-point FIR interpolator structure.\r
3746    * @param[in]     L         upsample factor.\r
3747    * @param[in]     numTaps   number of filter coefficients in the filter.\r
3748    * @param[in]     *pCoeffs  points to the filter coefficient buffer.\r
3749    * @param[in]     *pState   points to the state buffer.\r
3750    * @param[in]     blockSize number of input samples to process per call.\r
3751    * @return        The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if\r
3752    * the filter length <code>numTaps</code> is not a multiple of the interpolation factor <code>L</code>.\r
3753    */\r
3754 \r
3755   arm_status arm_fir_interpolate_init_f32(\r
3756   arm_fir_interpolate_instance_f32 * S,\r
3757   uint8_t L,\r
3758   uint16_t numTaps,\r
3759   float32_t * pCoeffs,\r
3760   float32_t * pState,\r
3761   uint32_t blockSize);\r
3762 \r
3763   /**\r
3764    * @brief Instance structure for the high precision Q31 Biquad cascade filter.\r
3765    */\r
3766 \r
3767   typedef struct\r
3768   {\r
3769     uint8_t numStages;       /**< number of 2nd order stages in the filter.  Overall order is 2*numStages. */\r
3770     q63_t *pState;           /**< points to the array of state coefficients.  The array is of length 4*numStages. */\r
3771     q31_t *pCoeffs;          /**< points to the array of coefficients.  The array is of length 5*numStages. */\r
3772     uint8_t postShift;       /**< additional shift, in bits, applied to each output sample. */\r
3773 \r
3774   } arm_biquad_cas_df1_32x64_ins_q31;\r
3775 \r
3776 \r
3777   /**\r
3778    * @param[in]  *S        points to an instance of the high precision Q31 Biquad cascade filter structure.\r
3779    * @param[in]  *pSrc     points to the block of input data.\r
3780    * @param[out] *pDst     points to the block of output data\r
3781    * @param[in]  blockSize number of samples to process.\r
3782    * @return none.\r
3783    */\r
3784 \r
3785   void arm_biquad_cas_df1_32x64_q31(\r
3786   const arm_biquad_cas_df1_32x64_ins_q31 * S,\r
3787   q31_t * pSrc,\r
3788   q31_t * pDst,\r
3789   uint32_t blockSize);\r
3790 \r
3791 \r
3792   /**\r
3793    * @param[in,out] *S           points to an instance of the high precision Q31 Biquad cascade filter structure.\r
3794    * @param[in]     numStages    number of 2nd order stages in the filter.\r
3795    * @param[in]     *pCoeffs     points to the filter coefficients.\r
3796    * @param[in]     *pState      points to the state buffer.\r
3797    * @param[in]     postShift    shift to be applied to the output. Varies according to the coefficients format\r
3798    * @return        none\r
3799    */\r
3800 \r
3801   void arm_biquad_cas_df1_32x64_init_q31(\r
3802   arm_biquad_cas_df1_32x64_ins_q31 * S,\r
3803   uint8_t numStages,\r
3804   q31_t * pCoeffs,\r
3805   q63_t * pState,\r
3806   uint8_t postShift);\r
3807 \r
3808 \r
3809 \r
3810   /**\r
3811    * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter.\r
3812    */\r
3813 \r
3814   typedef struct\r
3815   {\r
3816     uint8_t numStages;         /**< number of 2nd order stages in the filter.  Overall order is 2*numStages. */\r
3817     float32_t *pState;         /**< points to the array of state coefficients.  The array is of length 2*numStages. */\r
3818     float32_t *pCoeffs;        /**< points to the array of coefficients.  The array is of length 5*numStages. */\r
3819   } arm_biquad_cascade_df2T_instance_f32;\r
3820 \r
3821 \r
3822 \r
3823   /**\r
3824    * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter.\r
3825    */\r
3826 \r
3827   typedef struct\r
3828   {\r
3829     uint8_t numStages;         /**< number of 2nd order stages in the filter.  Overall order is 2*numStages. */\r
3830     float32_t *pState;         /**< points to the array of state coefficients.  The array is of length 4*numStages. */\r
3831     float32_t *pCoeffs;        /**< points to the array of coefficients.  The array is of length 5*numStages. */\r
3832   } arm_biquad_cascade_stereo_df2T_instance_f32;\r
3833 \r
3834 \r
3835 \r
3836   /**\r
3837    * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter.\r
3838    */\r
3839 \r
3840   typedef struct\r
3841   {\r
3842     uint8_t numStages;         /**< number of 2nd order stages in the filter.  Overall order is 2*numStages. */\r
3843     float64_t *pState;         /**< points to the array of state coefficients.  The array is of length 2*numStages. */\r
3844     float64_t *pCoeffs;        /**< points to the array of coefficients.  The array is of length 5*numStages. */\r
3845   } arm_biquad_cascade_df2T_instance_f64;\r
3846 \r
3847 \r
3848   /**\r
3849    * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter.\r
3850    * @param[in]  *S        points to an instance of the filter data structure.\r
3851    * @param[in]  *pSrc     points to the block of input data.\r
3852    * @param[out] *pDst     points to the block of output data\r
3853    * @param[in]  blockSize number of samples to process.\r
3854    * @return none.\r
3855    */\r
3856 \r
3857   void arm_biquad_cascade_df2T_f32(\r
3858   const arm_biquad_cascade_df2T_instance_f32 * S,\r
3859   float32_t * pSrc,\r
3860   float32_t * pDst,\r
3861   uint32_t blockSize);\r
3862 \r
3863 \r
3864   /**\r
3865    * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter. 2 channels\r
3866    * @param[in]  *S        points to an instance of the filter data structure.\r
3867    * @param[in]  *pSrc     points to the block of input data.\r
3868    * @param[out] *pDst     points to the block of output data\r
3869    * @param[in]  blockSize number of samples to process.\r
3870    * @return none.\r
3871    */\r
3872 \r
3873   void arm_biquad_cascade_stereo_df2T_f32(\r
3874   const arm_biquad_cascade_stereo_df2T_instance_f32 * S,\r
3875   float32_t * pSrc,\r
3876   float32_t * pDst,\r
3877   uint32_t blockSize);\r
3878 \r
3879   /**\r
3880    * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter.\r
3881    * @param[in]  *S        points to an instance of the filter data structure.\r
3882    * @param[in]  *pSrc     points to the block of input data.\r
3883    * @param[out] *pDst     points to the block of output data\r
3884    * @param[in]  blockSize number of samples to process.\r
3885    * @return none.\r
3886    */\r
3887 \r
3888   void arm_biquad_cascade_df2T_f64(\r
3889   const arm_biquad_cascade_df2T_instance_f64 * S,\r
3890   float64_t * pSrc,\r
3891   float64_t * pDst,\r
3892   uint32_t blockSize);\r
3893 \r
3894 \r
3895   /**\r
3896    * @brief  Initialization function for the floating-point transposed direct form II Biquad cascade filter.\r
3897    * @param[in,out] *S           points to an instance of the filter data structure.\r
3898    * @param[in]     numStages    number of 2nd order stages in the filter.\r
3899    * @param[in]     *pCoeffs     points to the filter coefficients.\r
3900    * @param[in]     *pState      points to the state buffer.\r
3901    * @return        none\r
3902    */\r
3903 \r
3904   void arm_biquad_cascade_df2T_init_f32(\r
3905   arm_biquad_cascade_df2T_instance_f32 * S,\r
3906   uint8_t numStages,\r
3907   float32_t * pCoeffs,\r
3908   float32_t * pState);\r
3909 \r
3910 \r
3911   /**\r
3912    * @brief  Initialization function for the floating-point transposed direct form II Biquad cascade filter.\r
3913    * @param[in,out] *S           points to an instance of the filter data structure.\r
3914    * @param[in]     numStages    number of 2nd order stages in the filter.\r
3915    * @param[in]     *pCoeffs     points to the filter coefficients.\r
3916    * @param[in]     *pState      points to the state buffer.\r
3917    * @return        none\r
3918    */\r
3919 \r
3920   void arm_biquad_cascade_stereo_df2T_init_f32(\r
3921   arm_biquad_cascade_stereo_df2T_instance_f32 * S,\r
3922   uint8_t numStages,\r
3923   float32_t * pCoeffs,\r
3924   float32_t * pState);\r
3925 \r
3926 \r
3927   /**\r
3928    * @brief  Initialization function for the floating-point transposed direct form II Biquad cascade filter.\r
3929    * @param[in,out] *S           points to an instance of the filter data structure.\r
3930    * @param[in]     numStages    number of 2nd order stages in the filter.\r
3931    * @param[in]     *pCoeffs     points to the filter coefficients.\r
3932    * @param[in]     *pState      points to the state buffer.\r
3933    * @return        none\r
3934    */\r
3935 \r
3936   void arm_biquad_cascade_df2T_init_f64(\r
3937   arm_biquad_cascade_df2T_instance_f64 * S,\r
3938   uint8_t numStages,\r
3939   float64_t * pCoeffs,\r
3940   float64_t * pState);\r
3941 \r
3942 \r
3943 \r
3944   /**\r
3945    * @brief Instance structure for the Q15 FIR lattice filter.\r
3946    */\r
3947 \r
3948   typedef struct\r
3949   {\r
3950     uint16_t numStages;                          /**< number of filter stages. */\r
3951     q15_t *pState;                               /**< points to the state variable array. The array is of length numStages. */\r
3952     q15_t *pCoeffs;                              /**< points to the coefficient array. The array is of length numStages. */\r
3953   } arm_fir_lattice_instance_q15;\r
3954 \r
3955   /**\r
3956    * @brief Instance structure for the Q31 FIR lattice filter.\r
3957    */\r
3958 \r
3959   typedef struct\r
3960   {\r
3961     uint16_t numStages;                          /**< number of filter stages. */\r
3962     q31_t *pState;                               /**< points to the state variable array. The array is of length numStages. */\r
3963     q31_t *pCoeffs;                              /**< points to the coefficient array. The array is of length numStages. */\r
3964   } arm_fir_lattice_instance_q31;\r
3965 \r
3966   /**\r
3967    * @brief Instance structure for the floating-point FIR lattice filter.\r
3968    */\r
3969 \r
3970   typedef struct\r
3971   {\r
3972     uint16_t numStages;                  /**< number of filter stages. */\r
3973     float32_t *pState;                   /**< points to the state variable array. The array is of length numStages. */\r
3974     float32_t *pCoeffs;                  /**< points to the coefficient array. The array is of length numStages. */\r
3975   } arm_fir_lattice_instance_f32;\r
3976 \r
3977   /**\r
3978    * @brief Initialization function for the Q15 FIR lattice filter.\r
3979    * @param[in] *S points to an instance of the Q15 FIR lattice structure.\r
3980    * @param[in] numStages  number of filter stages.\r
3981    * @param[in] *pCoeffs points to the coefficient buffer.  The array is of length numStages.\r
3982    * @param[in] *pState points to the state buffer.  The array is of length numStages.\r
3983    * @return none.\r
3984    */\r
3985 \r
3986   void arm_fir_lattice_init_q15(\r
3987   arm_fir_lattice_instance_q15 * S,\r
3988   uint16_t numStages,\r
3989   q15_t * pCoeffs,\r
3990   q15_t * pState);\r
3991 \r
3992 \r
3993   /**\r
3994    * @brief Processing function for the Q15 FIR lattice filter.\r
3995    * @param[in] *S points to an instance of the Q15 FIR lattice structure.\r
3996    * @param[in] *pSrc points to the block of input data.\r
3997    * @param[out] *pDst points to the block of output data.\r
3998    * @param[in] blockSize number of samples to process.\r
3999    * @return none.\r
4000    */\r
4001   void arm_fir_lattice_q15(\r
4002   const arm_fir_lattice_instance_q15 * S,\r
4003   q15_t * pSrc,\r
4004   q15_t * pDst,\r
4005   uint32_t blockSize);\r
4006 \r
4007   /**\r
4008    * @brief Initialization function for the Q31 FIR lattice filter.\r
4009    * @param[in] *S points to an instance of the Q31 FIR lattice structure.\r
4010    * @param[in] numStages  number of filter stages.\r
4011    * @param[in] *pCoeffs points to the coefficient buffer.  The array is of length numStages.\r
4012    * @param[in] *pState points to the state buffer.   The array is of length numStages.\r
4013    * @return none.\r
4014    */\r
4015 \r
4016   void arm_fir_lattice_init_q31(\r
4017   arm_fir_lattice_instance_q31 * S,\r
4018   uint16_t numStages,\r
4019   q31_t * pCoeffs,\r
4020   q31_t * pState);\r
4021 \r
4022 \r
4023   /**\r
4024    * @brief Processing function for the Q31 FIR lattice filter.\r
4025    * @param[in]  *S        points to an instance of the Q31 FIR lattice structure.\r
4026    * @param[in]  *pSrc     points to the block of input data.\r
4027    * @param[out] *pDst     points to the block of output data\r
4028    * @param[in]  blockSize number of samples to process.\r
4029    * @return none.\r
4030    */\r
4031 \r
4032   void arm_fir_lattice_q31(\r
4033   const arm_fir_lattice_instance_q31 * S,\r
4034   q31_t * pSrc,\r
4035   q31_t * pDst,\r
4036   uint32_t blockSize);\r
4037 \r
4038 /**\r
4039  * @brief Initialization function for the floating-point FIR lattice filter.\r
4040  * @param[in] *S points to an instance of the floating-point FIR lattice structure.\r
4041  * @param[in] numStages  number of filter stages.\r
4042  * @param[in] *pCoeffs points to the coefficient buffer.  The array is of length numStages.\r
4043  * @param[in] *pState points to the state buffer.  The array is of length numStages.\r
4044  * @return none.\r
4045  */\r
4046 \r
4047   void arm_fir_lattice_init_f32(\r
4048   arm_fir_lattice_instance_f32 * S,\r
4049   uint16_t numStages,\r
4050   float32_t * pCoeffs,\r
4051   float32_t * pState);\r
4052 \r
4053   /**\r
4054    * @brief Processing function for the floating-point FIR lattice filter.\r
4055    * @param[in]  *S        points to an instance of the floating-point FIR lattice structure.\r
4056    * @param[in]  *pSrc     points to the block of input data.\r
4057    * @param[out] *pDst     points to the block of output data\r
4058    * @param[in]  blockSize number of samples to process.\r
4059    * @return none.\r
4060    */\r
4061 \r
4062   void arm_fir_lattice_f32(\r
4063   const arm_fir_lattice_instance_f32 * S,\r
4064   float32_t * pSrc,\r
4065   float32_t * pDst,\r
4066   uint32_t blockSize);\r
4067 \r
4068   /**\r
4069    * @brief Instance structure for the Q15 IIR lattice filter.\r
4070    */\r
4071   typedef struct\r
4072   {\r
4073     uint16_t numStages;                         /**< number of stages in the filter. */\r
4074     q15_t *pState;                              /**< points to the state variable array. The array is of length numStages+blockSize. */\r
4075     q15_t *pkCoeffs;                            /**< points to the reflection coefficient array. The array is of length numStages. */\r
4076     q15_t *pvCoeffs;                            /**< points to the ladder coefficient array. The array is of length numStages+1. */\r
4077   } arm_iir_lattice_instance_q15;\r
4078 \r
4079   /**\r
4080    * @brief Instance structure for the Q31 IIR lattice filter.\r
4081    */\r
4082   typedef struct\r
4083   {\r
4084     uint16_t numStages;                         /**< number of stages in the filter. */\r
4085     q31_t *pState;                              /**< points to the state variable array. The array is of length numStages+blockSize. */\r
4086     q31_t *pkCoeffs;                            /**< points to the reflection coefficient array. The array is of length numStages. */\r
4087     q31_t *pvCoeffs;                            /**< points to the ladder coefficient array. The array is of length numStages+1. */\r
4088   } arm_iir_lattice_instance_q31;\r
4089 \r
4090   /**\r
4091    * @brief Instance structure for the floating-point IIR lattice filter.\r
4092    */\r
4093   typedef struct\r
4094   {\r
4095     uint16_t numStages;                         /**< number of stages in the filter. */\r
4096     float32_t *pState;                          /**< points to the state variable array. The array is of length numStages+blockSize. */\r
4097     float32_t *pkCoeffs;                        /**< points to the reflection coefficient array. The array is of length numStages. */\r
4098     float32_t *pvCoeffs;                        /**< points to the ladder coefficient array. The array is of length numStages+1. */\r
4099   } arm_iir_lattice_instance_f32;\r
4100 \r
4101   /**\r
4102    * @brief Processing function for the floating-point IIR lattice filter.\r
4103    * @param[in] *S points to an instance of the floating-point IIR lattice structure.\r
4104    * @param[in] *pSrc points to the block of input data.\r
4105    * @param[out] *pDst points to the block of output data.\r
4106    * @param[in] blockSize number of samples to process.\r
4107    * @return none.\r
4108    */\r
4109 \r
4110   void arm_iir_lattice_f32(\r
4111   const arm_iir_lattice_instance_f32 * S,\r
4112   float32_t * pSrc,\r
4113   float32_t * pDst,\r
4114   uint32_t blockSize);\r
4115 \r
4116   /**\r
4117    * @brief Initialization function for the floating-point IIR lattice filter.\r
4118    * @param[in] *S points to an instance of the floating-point IIR lattice structure.\r
4119    * @param[in] numStages number of stages in the filter.\r
4120    * @param[in] *pkCoeffs points to the reflection coefficient buffer.  The array is of length numStages.\r
4121    * @param[in] *pvCoeffs points to the ladder coefficient buffer.  The array is of length numStages+1.\r
4122    * @param[in] *pState points to the state buffer.  The array is of length numStages+blockSize-1.\r
4123    * @param[in] blockSize number of samples to process.\r
4124    * @return none.\r
4125    */\r
4126 \r
4127   void arm_iir_lattice_init_f32(\r
4128   arm_iir_lattice_instance_f32 * S,\r
4129   uint16_t numStages,\r
4130   float32_t * pkCoeffs,\r
4131   float32_t * pvCoeffs,\r
4132   float32_t * pState,\r
4133   uint32_t blockSize);\r
4134 \r
4135 \r
4136   /**\r
4137    * @brief Processing function for the Q31 IIR lattice filter.\r
4138    * @param[in] *S points to an instance of the Q31 IIR lattice structure.\r
4139    * @param[in] *pSrc points to the block of input data.\r
4140    * @param[out] *pDst points to the block of output data.\r
4141    * @param[in] blockSize number of samples to process.\r
4142    * @return none.\r
4143    */\r
4144 \r
4145   void arm_iir_lattice_q31(\r
4146   const arm_iir_lattice_instance_q31 * S,\r
4147   q31_t * pSrc,\r
4148   q31_t * pDst,\r
4149   uint32_t blockSize);\r
4150 \r
4151 \r
4152   /**\r
4153    * @brief Initialization function for the Q31 IIR lattice filter.\r
4154    * @param[in] *S points to an instance of the Q31 IIR lattice structure.\r
4155    * @param[in] numStages number of stages in the filter.\r
4156    * @param[in] *pkCoeffs points to the reflection coefficient buffer.  The array is of length numStages.\r
4157    * @param[in] *pvCoeffs points to the ladder coefficient buffer.  The array is of length numStages+1.\r
4158    * @param[in] *pState points to the state buffer.  The array is of length numStages+blockSize.\r
4159    * @param[in] blockSize number of samples to process.\r
4160    * @return none.\r
4161    */\r
4162 \r
4163   void arm_iir_lattice_init_q31(\r
4164   arm_iir_lattice_instance_q31 * S,\r
4165   uint16_t numStages,\r
4166   q31_t * pkCoeffs,\r
4167   q31_t * pvCoeffs,\r
4168   q31_t * pState,\r
4169   uint32_t blockSize);\r
4170 \r
4171 \r
4172   /**\r
4173    * @brief Processing function for the Q15 IIR lattice filter.\r
4174    * @param[in] *S points to an instance of the Q15 IIR lattice structure.\r
4175    * @param[in] *pSrc points to the block of input data.\r
4176    * @param[out] *pDst points to the block of output data.\r
4177    * @param[in] blockSize number of samples to process.\r
4178    * @return none.\r
4179    */\r
4180 \r
4181   void arm_iir_lattice_q15(\r
4182   const arm_iir_lattice_instance_q15 * S,\r
4183   q15_t * pSrc,\r
4184   q15_t * pDst,\r
4185   uint32_t blockSize);\r
4186 \r
4187 \r
4188 /**\r
4189  * @brief Initialization function for the Q15 IIR lattice filter.\r
4190  * @param[in] *S points to an instance of the fixed-point Q15 IIR lattice structure.\r
4191  * @param[in] numStages  number of stages in the filter.\r
4192  * @param[in] *pkCoeffs points to reflection coefficient buffer.  The array is of length numStages.\r
4193  * @param[in] *pvCoeffs points to ladder coefficient buffer.  The array is of length numStages+1.\r
4194  * @param[in] *pState points to state buffer.  The array is of length numStages+blockSize.\r
4195  * @param[in] blockSize number of samples to process per call.\r
4196  * @return none.\r
4197  */\r
4198 \r
4199   void arm_iir_lattice_init_q15(\r
4200   arm_iir_lattice_instance_q15 * S,\r
4201   uint16_t numStages,\r
4202   q15_t * pkCoeffs,\r
4203   q15_t * pvCoeffs,\r
4204   q15_t * pState,\r
4205   uint32_t blockSize);\r
4206 \r
4207   /**\r
4208    * @brief Instance structure for the floating-point LMS filter.\r
4209    */\r
4210 \r
4211   typedef struct\r
4212   {\r
4213     uint16_t numTaps;    /**< number of coefficients in the filter. */\r
4214     float32_t *pState;   /**< points to the state variable array. The array is of length numTaps+blockSize-1. */\r
4215     float32_t *pCoeffs;  /**< points to the coefficient array. The array is of length numTaps. */\r
4216     float32_t mu;        /**< step size that controls filter coefficient updates. */\r
4217   } arm_lms_instance_f32;\r
4218 \r
4219   /**\r
4220    * @brief Processing function for floating-point LMS filter.\r
4221    * @param[in]  *S points to an instance of the floating-point LMS filter structure.\r
4222    * @param[in]  *pSrc points to the block of input data.\r
4223    * @param[in]  *pRef points to the block of reference data.\r
4224    * @param[out] *pOut points to the block of output data.\r
4225    * @param[out] *pErr points to the block of error data.\r
4226    * @param[in]  blockSize number of samples to process.\r
4227    * @return     none.\r
4228    */\r
4229 \r
4230   void arm_lms_f32(\r
4231   const arm_lms_instance_f32 * S,\r
4232   float32_t * pSrc,\r
4233   float32_t * pRef,\r
4234   float32_t * pOut,\r
4235   float32_t * pErr,\r
4236   uint32_t blockSize);\r
4237 \r
4238   /**\r
4239    * @brief Initialization function for floating-point LMS filter.\r
4240    * @param[in] *S points to an instance of the floating-point LMS filter structure.\r
4241    * @param[in] numTaps  number of filter coefficients.\r
4242    * @param[in] *pCoeffs points to the coefficient buffer.\r
4243    * @param[in] *pState points to state buffer.\r
4244    * @param[in] mu step size that controls filter coefficient updates.\r
4245    * @param[in] blockSize number of samples to process.\r
4246    * @return none.\r
4247    */\r
4248 \r
4249   void arm_lms_init_f32(\r
4250   arm_lms_instance_f32 * S,\r
4251   uint16_t numTaps,\r
4252   float32_t * pCoeffs,\r
4253   float32_t * pState,\r
4254   float32_t mu,\r
4255   uint32_t blockSize);\r
4256 \r
4257   /**\r
4258    * @brief Instance structure for the Q15 LMS filter.\r
4259    */\r
4260 \r
4261   typedef struct\r
4262   {\r
4263     uint16_t numTaps;    /**< number of coefficients in the filter. */\r
4264     q15_t *pState;       /**< points to the state variable array. The array is of length numTaps+blockSize-1. */\r
4265     q15_t *pCoeffs;      /**< points to the coefficient array. The array is of length numTaps. */\r
4266     q15_t mu;            /**< step size that controls filter coefficient updates. */\r
4267     uint32_t postShift;  /**< bit shift applied to coefficients. */\r
4268   } arm_lms_instance_q15;\r
4269 \r
4270 \r
4271   /**\r
4272    * @brief Initialization function for the Q15 LMS filter.\r
4273    * @param[in] *S points to an instance of the Q15 LMS filter structure.\r
4274    * @param[in] numTaps  number of filter coefficients.\r
4275    * @param[in] *pCoeffs points to the coefficient buffer.\r
4276    * @param[in] *pState points to the state buffer.\r
4277    * @param[in] mu step size that controls filter coefficient updates.\r
4278    * @param[in] blockSize number of samples to process.\r
4279    * @param[in] postShift bit shift applied to coefficients.\r
4280    * @return    none.\r
4281    */\r
4282 \r
4283   void arm_lms_init_q15(\r
4284   arm_lms_instance_q15 * S,\r
4285   uint16_t numTaps,\r
4286   q15_t * pCoeffs,\r
4287   q15_t * pState,\r
4288   q15_t mu,\r
4289   uint32_t blockSize,\r
4290   uint32_t postShift);\r
4291 \r
4292   /**\r
4293    * @brief Processing function for Q15 LMS filter.\r
4294    * @param[in] *S points to an instance of the Q15 LMS filter structure.\r
4295    * @param[in] *pSrc points to the block of input data.\r
4296    * @param[in] *pRef points to the block of reference data.\r
4297    * @param[out] *pOut points to the block of output data.\r
4298    * @param[out] *pErr points to the block of error data.\r
4299    * @param[in] blockSize number of samples to process.\r
4300    * @return none.\r
4301    */\r
4302 \r
4303   void arm_lms_q15(\r
4304   const arm_lms_instance_q15 * S,\r
4305   q15_t * pSrc,\r
4306   q15_t * pRef,\r
4307   q15_t * pOut,\r
4308   q15_t * pErr,\r
4309   uint32_t blockSize);\r
4310 \r
4311 \r
4312   /**\r
4313    * @brief Instance structure for the Q31 LMS filter.\r
4314    */\r
4315 \r
4316   typedef struct\r
4317   {\r
4318     uint16_t numTaps;    /**< number of coefficients in the filter. */\r
4319     q31_t *pState;       /**< points to the state variable array. The array is of length numTaps+blockSize-1. */\r
4320     q31_t *pCoeffs;      /**< points to the coefficient array. The array is of length numTaps. */\r
4321     q31_t mu;            /**< step size that controls filter coefficient updates. */\r
4322     uint32_t postShift;  /**< bit shift applied to coefficients. */\r
4323 \r
4324   } arm_lms_instance_q31;\r
4325 \r
4326   /**\r
4327    * @brief Processing function for Q31 LMS filter.\r
4328    * @param[in]  *S points to an instance of the Q15 LMS filter structure.\r
4329    * @param[in]  *pSrc points to the block of input data.\r
4330    * @param[in]  *pRef points to the block of reference data.\r
4331    * @param[out] *pOut points to the block of output data.\r
4332    * @param[out] *pErr points to the block of error data.\r
4333    * @param[in]  blockSize number of samples to process.\r
4334    * @return     none.\r
4335    */\r
4336 \r
4337   void arm_lms_q31(\r
4338   const arm_lms_instance_q31 * S,\r
4339   q31_t * pSrc,\r
4340   q31_t * pRef,\r
4341   q31_t * pOut,\r
4342   q31_t * pErr,\r
4343   uint32_t blockSize);\r
4344 \r
4345   /**\r
4346    * @brief Initialization function for Q31 LMS filter.\r
4347    * @param[in] *S points to an instance of the Q31 LMS filter structure.\r
4348    * @param[in] numTaps  number of filter coefficients.\r
4349    * @param[in] *pCoeffs points to coefficient buffer.\r
4350    * @param[in] *pState points to state buffer.\r
4351    * @param[in] mu step size that controls filter coefficient updates.\r
4352    * @param[in] blockSize number of samples to process.\r
4353    * @param[in] postShift bit shift applied to coefficients.\r
4354    * @return none.\r
4355    */\r
4356 \r
4357   void arm_lms_init_q31(\r
4358   arm_lms_instance_q31 * S,\r
4359   uint16_t numTaps,\r
4360   q31_t * pCoeffs,\r
4361   q31_t * pState,\r
4362   q31_t mu,\r
4363   uint32_t blockSize,\r
4364   uint32_t postShift);\r
4365 \r
4366   /**\r
4367    * @brief Instance structure for the floating-point normalized LMS filter.\r
4368    */\r
4369 \r
4370   typedef struct\r
4371   {\r
4372     uint16_t numTaps;     /**< number of coefficients in the filter. */\r
4373     float32_t *pState;    /**< points to the state variable array. The array is of length numTaps+blockSize-1. */\r
4374     float32_t *pCoeffs;   /**< points to the coefficient array. The array is of length numTaps. */\r
4375     float32_t mu;        /**< step size that control filter coefficient updates. */\r
4376     float32_t energy;    /**< saves previous frame energy. */\r
4377     float32_t x0;        /**< saves previous input sample. */\r
4378   } arm_lms_norm_instance_f32;\r
4379 \r
4380   /**\r
4381    * @brief Processing function for floating-point normalized LMS filter.\r
4382    * @param[in] *S points to an instance of the floating-point normalized LMS filter structure.\r
4383    * @param[in] *pSrc points to the block of input data.\r
4384    * @param[in] *pRef points to the block of reference data.\r
4385    * @param[out] *pOut points to the block of output data.\r
4386    * @param[out] *pErr points to the block of error data.\r
4387    * @param[in] blockSize number of samples to process.\r
4388    * @return none.\r
4389    */\r
4390 \r
4391   void arm_lms_norm_f32(\r
4392   arm_lms_norm_instance_f32 * S,\r
4393   float32_t * pSrc,\r
4394   float32_t * pRef,\r
4395   float32_t * pOut,\r
4396   float32_t * pErr,\r
4397   uint32_t blockSize);\r
4398 \r
4399   /**\r
4400    * @brief Initialization function for floating-point normalized LMS filter.\r
4401    * @param[in] *S points to an instance of the floating-point LMS filter structure.\r
4402    * @param[in] numTaps  number of filter coefficients.\r
4403    * @param[in] *pCoeffs points to coefficient buffer.\r
4404    * @param[in] *pState points to state buffer.\r
4405    * @param[in] mu step size that controls filter coefficient updates.\r
4406    * @param[in] blockSize number of samples to process.\r
4407    * @return none.\r
4408    */\r
4409 \r
4410   void arm_lms_norm_init_f32(\r
4411   arm_lms_norm_instance_f32 * S,\r
4412   uint16_t numTaps,\r
4413   float32_t * pCoeffs,\r
4414   float32_t * pState,\r
4415   float32_t mu,\r
4416   uint32_t blockSize);\r
4417 \r
4418 \r
4419   /**\r
4420    * @brief Instance structure for the Q31 normalized LMS filter.\r
4421    */\r
4422   typedef struct\r
4423   {\r
4424     uint16_t numTaps;     /**< number of coefficients in the filter. */\r
4425     q31_t *pState;        /**< points to the state variable array. The array is of length numTaps+blockSize-1. */\r
4426     q31_t *pCoeffs;       /**< points to the coefficient array. The array is of length numTaps. */\r
4427     q31_t mu;             /**< step size that controls filter coefficient updates. */\r
4428     uint8_t postShift;    /**< bit shift applied to coefficients. */\r
4429     q31_t *recipTable;    /**< points to the reciprocal initial value table. */\r
4430     q31_t energy;         /**< saves previous frame energy. */\r
4431     q31_t x0;             /**< saves previous input sample. */\r
4432   } arm_lms_norm_instance_q31;\r
4433 \r
4434   /**\r
4435    * @brief Processing function for Q31 normalized LMS filter.\r
4436    * @param[in] *S points to an instance of the Q31 normalized LMS filter structure.\r
4437    * @param[in] *pSrc points to the block of input data.\r
4438    * @param[in] *pRef points to the block of reference data.\r
4439    * @param[out] *pOut points to the block of output data.\r
4440    * @param[out] *pErr points to the block of error data.\r
4441    * @param[in] blockSize number of samples to process.\r
4442    * @return none.\r
4443    */\r
4444 \r
4445   void arm_lms_norm_q31(\r
4446   arm_lms_norm_instance_q31 * S,\r
4447   q31_t * pSrc,\r
4448   q31_t * pRef,\r
4449   q31_t * pOut,\r
4450   q31_t * pErr,\r
4451   uint32_t blockSize);\r
4452 \r
4453   /**\r
4454    * @brief Initialization function for Q31 normalized LMS filter.\r
4455    * @param[in] *S points to an instance of the Q31 normalized LMS filter structure.\r
4456    * @param[in] numTaps  number of filter coefficients.\r
4457    * @param[in] *pCoeffs points to coefficient buffer.\r
4458    * @param[in] *pState points to state buffer.\r
4459    * @param[in] mu step size that controls filter coefficient updates.\r
4460    * @param[in] blockSize number of samples to process.\r
4461    * @param[in] postShift bit shift applied to coefficients.\r
4462    * @return none.\r
4463    */\r
4464 \r
4465   void arm_lms_norm_init_q31(\r
4466   arm_lms_norm_instance_q31 * S,\r
4467   uint16_t numTaps,\r
4468   q31_t * pCoeffs,\r
4469   q31_t * pState,\r
4470   q31_t mu,\r
4471   uint32_t blockSize,\r
4472   uint8_t postShift);\r
4473 \r
4474   /**\r
4475    * @brief Instance structure for the Q15 normalized LMS filter.\r
4476    */\r
4477 \r
4478   typedef struct\r
4479   {\r
4480     uint16_t numTaps;    /**< Number of coefficients in the filter. */\r
4481     q15_t *pState;        /**< points to the state variable array. The array is of length numTaps+blockSize-1. */\r
4482     q15_t *pCoeffs;       /**< points to the coefficient array. The array is of length numTaps. */\r
4483     q15_t mu;            /**< step size that controls filter coefficient updates. */\r
4484     uint8_t postShift;   /**< bit shift applied to coefficients. */\r
4485     q15_t *recipTable;   /**< Points to the reciprocal initial value table. */\r
4486     q15_t energy;        /**< saves previous frame energy. */\r
4487     q15_t x0;            /**< saves previous input sample. */\r
4488   } arm_lms_norm_instance_q15;\r
4489 \r
4490   /**\r
4491    * @brief Processing function for Q15 normalized LMS filter.\r
4492    * @param[in] *S points to an instance of the Q15 normalized LMS filter structure.\r
4493    * @param[in] *pSrc points to the block of input data.\r
4494    * @param[in] *pRef points to the block of reference data.\r
4495    * @param[out] *pOut points to the block of output data.\r
4496    * @param[out] *pErr points to the block of error data.\r
4497    * @param[in] blockSize number of samples to process.\r
4498    * @return none.\r
4499    */\r
4500 \r
4501   void arm_lms_norm_q15(\r
4502   arm_lms_norm_instance_q15 * S,\r
4503   q15_t * pSrc,\r
4504   q15_t * pRef,\r
4505   q15_t * pOut,\r
4506   q15_t * pErr,\r
4507   uint32_t blockSize);\r
4508 \r
4509 \r
4510   /**\r
4511    * @brief Initialization function for Q15 normalized LMS filter.\r
4512    * @param[in] *S points to an instance of the Q15 normalized LMS filter structure.\r
4513    * @param[in] numTaps  number of filter coefficients.\r
4514    * @param[in] *pCoeffs points to coefficient buffer.\r
4515    * @param[in] *pState points to state buffer.\r
4516    * @param[in] mu step size that controls filter coefficient updates.\r
4517    * @param[in] blockSize number of samples to process.\r
4518    * @param[in] postShift bit shift applied to coefficients.\r
4519    * @return none.\r
4520    */\r
4521 \r
4522   void arm_lms_norm_init_q15(\r
4523   arm_lms_norm_instance_q15 * S,\r
4524   uint16_t numTaps,\r
4525   q15_t * pCoeffs,\r
4526   q15_t * pState,\r
4527   q15_t mu,\r
4528   uint32_t blockSize,\r
4529   uint8_t postShift);\r
4530 \r
4531   /**\r
4532    * @brief Correlation of floating-point sequences.\r
4533    * @param[in] *pSrcA points to the first input sequence.\r
4534    * @param[in] srcALen length of the first input sequence.\r
4535    * @param[in] *pSrcB points to the second input sequence.\r
4536    * @param[in] srcBLen length of the second input sequence.\r
4537    * @param[out] *pDst points to the block of output data  Length 2 * max(srcALen, srcBLen) - 1.\r
4538    * @return none.\r
4539    */\r
4540 \r
4541   void arm_correlate_f32(\r
4542   float32_t * pSrcA,\r
4543   uint32_t srcALen,\r
4544   float32_t * pSrcB,\r
4545   uint32_t srcBLen,\r
4546   float32_t * pDst);\r
4547 \r
4548 \r
4549    /**\r
4550    * @brief Correlation of Q15 sequences\r
4551    * @param[in] *pSrcA points to the first input sequence.\r
4552    * @param[in] srcALen length of the first input sequence.\r
4553    * @param[in] *pSrcB points to the second input sequence.\r
4554    * @param[in] srcBLen length of the second input sequence.\r
4555    * @param[out] *pDst points to the block of output data  Length 2 * max(srcALen, srcBLen) - 1.\r
4556    * @param[in]  *pScratch points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.\r
4557    * @return none.\r
4558    */\r
4559   void arm_correlate_opt_q15(\r
4560   q15_t * pSrcA,\r
4561   uint32_t srcALen,\r
4562   q15_t * pSrcB,\r
4563   uint32_t srcBLen,\r
4564   q15_t * pDst,\r
4565   q15_t * pScratch);\r
4566 \r
4567 \r
4568   /**\r
4569    * @brief Correlation of Q15 sequences.\r
4570    * @param[in] *pSrcA points to the first input sequence.\r
4571    * @param[in] srcALen length of the first input sequence.\r
4572    * @param[in] *pSrcB points to the second input sequence.\r
4573    * @param[in] srcBLen length of the second input sequence.\r
4574    * @param[out] *pDst points to the block of output data  Length 2 * max(srcALen, srcBLen) - 1.\r
4575    * @return none.\r
4576    */\r
4577 \r
4578   void arm_correlate_q15(\r
4579   q15_t * pSrcA,\r
4580   uint32_t srcALen,\r
4581   q15_t * pSrcB,\r
4582   uint32_t srcBLen,\r
4583   q15_t * pDst);\r
4584 \r
4585   /**\r
4586    * @brief Correlation of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4.\r
4587    * @param[in] *pSrcA points to the first input sequence.\r
4588    * @param[in] srcALen length of the first input sequence.\r
4589    * @param[in] *pSrcB points to the second input sequence.\r
4590    * @param[in] srcBLen length of the second input sequence.\r
4591    * @param[out] *pDst points to the block of output data  Length 2 * max(srcALen, srcBLen) - 1.\r
4592    * @return none.\r
4593    */\r
4594 \r
4595   void arm_correlate_fast_q15(\r
4596                                q15_t * pSrcA,\r
4597                               uint32_t srcALen,\r
4598                                q15_t * pSrcB,\r
4599                               uint32_t srcBLen,\r
4600                               q15_t * pDst);\r
4601 \r
4602 \r
4603 \r
4604   /**\r
4605    * @brief Correlation of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4.\r
4606    * @param[in] *pSrcA points to the first input sequence.\r
4607    * @param[in] srcALen length of the first input sequence.\r
4608    * @param[in] *pSrcB points to the second input sequence.\r
4609    * @param[in] srcBLen length of the second input sequence.\r
4610    * @param[out] *pDst points to the block of output data  Length 2 * max(srcALen, srcBLen) - 1.\r
4611    * @param[in]  *pScratch points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.\r
4612    * @return none.\r
4613    */\r
4614 \r
4615   void arm_correlate_fast_opt_q15(\r
4616   q15_t * pSrcA,\r
4617   uint32_t srcALen,\r
4618   q15_t * pSrcB,\r
4619   uint32_t srcBLen,\r
4620   q15_t * pDst,\r
4621   q15_t * pScratch);\r
4622 \r
4623   /**\r
4624    * @brief Correlation of Q31 sequences.\r
4625    * @param[in] *pSrcA points to the first input sequence.\r
4626    * @param[in] srcALen length of the first input sequence.\r
4627    * @param[in] *pSrcB points to the second input sequence.\r
4628    * @param[in] srcBLen length of the second input sequence.\r
4629    * @param[out] *pDst points to the block of output data  Length 2 * max(srcALen, srcBLen) - 1.\r
4630    * @return none.\r
4631    */\r
4632 \r
4633   void arm_correlate_q31(\r
4634   q31_t * pSrcA,\r
4635   uint32_t srcALen,\r
4636   q31_t * pSrcB,\r
4637   uint32_t srcBLen,\r
4638   q31_t * pDst);\r
4639 \r
4640   /**\r
4641    * @brief Correlation of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4\r
4642    * @param[in] *pSrcA points to the first input sequence.\r
4643    * @param[in] srcALen length of the first input sequence.\r
4644    * @param[in] *pSrcB points to the second input sequence.\r
4645    * @param[in] srcBLen length of the second input sequence.\r
4646    * @param[out] *pDst points to the block of output data  Length 2 * max(srcALen, srcBLen) - 1.\r
4647    * @return none.\r
4648    */\r
4649 \r
4650   void arm_correlate_fast_q31(\r
4651   q31_t * pSrcA,\r
4652   uint32_t srcALen,\r
4653   q31_t * pSrcB,\r
4654   uint32_t srcBLen,\r
4655   q31_t * pDst);\r
4656 \r
4657 \r
4658 \r
4659  /**\r
4660    * @brief Correlation of Q7 sequences.\r
4661    * @param[in] *pSrcA points to the first input sequence.\r
4662    * @param[in] srcALen length of the first input sequence.\r
4663    * @param[in] *pSrcB points to the second input sequence.\r
4664    * @param[in] srcBLen length of the second input sequence.\r
4665    * @param[out] *pDst points to the block of output data  Length 2 * max(srcALen, srcBLen) - 1.\r
4666    * @param[in]  *pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.\r
4667    * @param[in]  *pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen).\r
4668    * @return none.\r
4669    */\r
4670 \r
4671   void arm_correlate_opt_q7(\r
4672   q7_t * pSrcA,\r
4673   uint32_t srcALen,\r
4674   q7_t * pSrcB,\r
4675   uint32_t srcBLen,\r
4676   q7_t * pDst,\r
4677   q15_t * pScratch1,\r
4678   q15_t * pScratch2);\r
4679 \r
4680 \r
4681   /**\r
4682    * @brief Correlation of Q7 sequences.\r
4683    * @param[in] *pSrcA points to the first input sequence.\r
4684    * @param[in] srcALen length of the first input sequence.\r
4685    * @param[in] *pSrcB points to the second input sequence.\r
4686    * @param[in] srcBLen length of the second input sequence.\r
4687    * @param[out] *pDst points to the block of output data  Length 2 * max(srcALen, srcBLen) - 1.\r
4688    * @return none.\r
4689    */\r
4690 \r
4691   void arm_correlate_q7(\r
4692   q7_t * pSrcA,\r
4693   uint32_t srcALen,\r
4694   q7_t * pSrcB,\r
4695   uint32_t srcBLen,\r
4696   q7_t * pDst);\r
4697 \r
4698 \r
4699   /**\r
4700    * @brief Instance structure for the floating-point sparse FIR filter.\r
4701    */\r
4702   typedef struct\r
4703   {\r
4704     uint16_t numTaps;             /**< number of coefficients in the filter. */\r
4705     uint16_t stateIndex;          /**< state buffer index.  Points to the oldest sample in the state buffer. */\r
4706     float32_t *pState;            /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */\r
4707     float32_t *pCoeffs;           /**< points to the coefficient array. The array is of length numTaps.*/\r
4708     uint16_t maxDelay;            /**< maximum offset specified by the pTapDelay array. */\r
4709     int32_t *pTapDelay;           /**< points to the array of delay values.  The array is of length numTaps. */\r
4710   } arm_fir_sparse_instance_f32;\r
4711 \r
4712   /**\r
4713    * @brief Instance structure for the Q31 sparse FIR filter.\r
4714    */\r
4715 \r
4716   typedef struct\r
4717   {\r
4718     uint16_t numTaps;             /**< number of coefficients in the filter. */\r
4719     uint16_t stateIndex;          /**< state buffer index.  Points to the oldest sample in the state buffer. */\r
4720     q31_t *pState;                /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */\r
4721     q31_t *pCoeffs;               /**< points to the coefficient array. The array is of length numTaps.*/\r
4722     uint16_t maxDelay;            /**< maximum offset specified by the pTapDelay array. */\r
4723     int32_t *pTapDelay;           /**< points to the array of delay values.  The array is of length numTaps. */\r
4724   } arm_fir_sparse_instance_q31;\r
4725 \r
4726   /**\r
4727    * @brief Instance structure for the Q15 sparse FIR filter.\r
4728    */\r
4729 \r
4730   typedef struct\r
4731   {\r
4732     uint16_t numTaps;             /**< number of coefficients in the filter. */\r
4733     uint16_t stateIndex;          /**< state buffer index.  Points to the oldest sample in the state buffer. */\r
4734     q15_t *pState;                /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */\r
4735     q15_t *pCoeffs;               /**< points to the coefficient array. The array is of length numTaps.*/\r
4736     uint16_t maxDelay;            /**< maximum offset specified by the pTapDelay array. */\r
4737     int32_t *pTapDelay;           /**< points to the array of delay values.  The array is of length numTaps. */\r
4738   } arm_fir_sparse_instance_q15;\r
4739 \r
4740   /**\r
4741    * @brief Instance structure for the Q7 sparse FIR filter.\r
4742    */\r
4743 \r
4744   typedef struct\r
4745   {\r
4746     uint16_t numTaps;             /**< number of coefficients in the filter. */\r
4747     uint16_t stateIndex;          /**< state buffer index.  Points to the oldest sample in the state buffer. */\r
4748     q7_t *pState;                 /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */\r
4749     q7_t *pCoeffs;                /**< points to the coefficient array. The array is of length numTaps.*/\r
4750     uint16_t maxDelay;            /**< maximum offset specified by the pTapDelay array. */\r
4751     int32_t *pTapDelay;           /**< points to the array of delay values.  The array is of length numTaps. */\r
4752   } arm_fir_sparse_instance_q7;\r
4753 \r
4754   /**\r
4755    * @brief Processing function for the floating-point sparse FIR filter.\r
4756    * @param[in]  *S          points to an instance of the floating-point sparse FIR structure.\r
4757    * @param[in]  *pSrc       points to the block of input data.\r
4758    * @param[out] *pDst       points to the block of output data\r
4759    * @param[in]  *pScratchIn points to a temporary buffer of size blockSize.\r
4760    * @param[in]  blockSize   number of input samples to process per call.\r
4761    * @return none.\r
4762    */\r
4763 \r
4764   void arm_fir_sparse_f32(\r
4765   arm_fir_sparse_instance_f32 * S,\r
4766   float32_t * pSrc,\r
4767   float32_t * pDst,\r
4768   float32_t * pScratchIn,\r
4769   uint32_t blockSize);\r
4770 \r
4771   /**\r
4772    * @brief  Initialization function for the floating-point sparse FIR filter.\r
4773    * @param[in,out] *S         points to an instance of the floating-point sparse FIR structure.\r
4774    * @param[in]     numTaps    number of nonzero coefficients in the filter.\r
4775    * @param[in]     *pCoeffs   points to the array of filter coefficients.\r
4776    * @param[in]     *pState    points to the state buffer.\r
4777    * @param[in]     *pTapDelay points to the array of offset times.\r
4778    * @param[in]     maxDelay   maximum offset time supported.\r
4779    * @param[in]     blockSize  number of samples that will be processed per block.\r
4780    * @return none\r
4781    */\r
4782 \r
4783   void arm_fir_sparse_init_f32(\r
4784   arm_fir_sparse_instance_f32 * S,\r
4785   uint16_t numTaps,\r
4786   float32_t * pCoeffs,\r
4787   float32_t * pState,\r
4788   int32_t * pTapDelay,\r
4789   uint16_t maxDelay,\r
4790   uint32_t blockSize);\r
4791 \r
4792   /**\r
4793    * @brief Processing function for the Q31 sparse FIR filter.\r
4794    * @param[in]  *S          points to an instance of the Q31 sparse FIR structure.\r
4795    * @param[in]  *pSrc       points to the block of input data.\r
4796    * @param[out] *pDst       points to the block of output data\r
4797    * @param[in]  *pScratchIn points to a temporary buffer of size blockSize.\r
4798    * @param[in]  blockSize   number of input samples to process per call.\r
4799    * @return none.\r
4800    */\r
4801 \r
4802   void arm_fir_sparse_q31(\r
4803   arm_fir_sparse_instance_q31 * S,\r
4804   q31_t * pSrc,\r
4805   q31_t * pDst,\r
4806   q31_t * pScratchIn,\r
4807   uint32_t blockSize);\r
4808 \r
4809   /**\r
4810    * @brief  Initialization function for the Q31 sparse FIR filter.\r
4811    * @param[in,out] *S         points to an instance of the Q31 sparse FIR structure.\r
4812    * @param[in]     numTaps    number of nonzero coefficients in the filter.\r
4813    * @param[in]     *pCoeffs   points to the array of filter coefficients.\r
4814    * @param[in]     *pState    points to the state buffer.\r
4815    * @param[in]     *pTapDelay points to the array of offset times.\r
4816    * @param[in]     maxDelay   maximum offset time supported.\r
4817    * @param[in]     blockSize  number of samples that will be processed per block.\r
4818    * @return none\r
4819    */\r
4820 \r
4821   void arm_fir_sparse_init_q31(\r
4822   arm_fir_sparse_instance_q31 * S,\r
4823   uint16_t numTaps,\r
4824   q31_t * pCoeffs,\r
4825   q31_t * pState,\r
4826   int32_t * pTapDelay,\r
4827   uint16_t maxDelay,\r
4828   uint32_t blockSize);\r
4829 \r
4830   /**\r
4831    * @brief Processing function for the Q15 sparse FIR filter.\r
4832    * @param[in]  *S           points to an instance of the Q15 sparse FIR structure.\r
4833    * @param[in]  *pSrc        points to the block of input data.\r
4834    * @param[out] *pDst        points to the block of output data\r
4835    * @param[in]  *pScratchIn  points to a temporary buffer of size blockSize.\r
4836    * @param[in]  *pScratchOut points to a temporary buffer of size blockSize.\r
4837    * @param[in]  blockSize    number of input samples to process per call.\r
4838    * @return none.\r
4839    */\r
4840 \r
4841   void arm_fir_sparse_q15(\r
4842   arm_fir_sparse_instance_q15 * S,\r
4843   q15_t * pSrc,\r
4844   q15_t * pDst,\r
4845   q15_t * pScratchIn,\r
4846   q31_t * pScratchOut,\r
4847   uint32_t blockSize);\r
4848 \r
4849 \r
4850   /**\r
4851    * @brief  Initialization function for the Q15 sparse FIR filter.\r
4852    * @param[in,out] *S         points to an instance of the Q15 sparse FIR structure.\r
4853    * @param[in]     numTaps    number of nonzero coefficients in the filter.\r
4854    * @param[in]     *pCoeffs   points to the array of filter coefficients.\r
4855    * @param[in]     *pState    points to the state buffer.\r
4856    * @param[in]     *pTapDelay points to the array of offset times.\r
4857    * @param[in]     maxDelay   maximum offset time supported.\r
4858    * @param[in]     blockSize  number of samples that will be processed per block.\r
4859    * @return none\r
4860    */\r
4861 \r
4862   void arm_fir_sparse_init_q15(\r
4863   arm_fir_sparse_instance_q15 * S,\r
4864   uint16_t numTaps,\r
4865   q15_t * pCoeffs,\r
4866   q15_t * pState,\r
4867   int32_t * pTapDelay,\r
4868   uint16_t maxDelay,\r
4869   uint32_t blockSize);\r
4870 \r
4871   /**\r
4872    * @brief Processing function for the Q7 sparse FIR filter.\r
4873    * @param[in]  *S           points to an instance of the Q7 sparse FIR structure.\r
4874    * @param[in]  *pSrc        points to the block of input data.\r
4875    * @param[out] *pDst        points to the block of output data\r
4876    * @param[in]  *pScratchIn  points to a temporary buffer of size blockSize.\r
4877    * @param[in]  *pScratchOut points to a temporary buffer of size blockSize.\r
4878    * @param[in]  blockSize    number of input samples to process per call.\r
4879    * @return none.\r
4880    */\r
4881 \r
4882   void arm_fir_sparse_q7(\r
4883   arm_fir_sparse_instance_q7 * S,\r
4884   q7_t * pSrc,\r
4885   q7_t * pDst,\r
4886   q7_t * pScratchIn,\r
4887   q31_t * pScratchOut,\r
4888   uint32_t blockSize);\r
4889 \r
4890   /**\r
4891    * @brief  Initialization function for the Q7 sparse FIR filter.\r
4892    * @param[in,out] *S         points to an instance of the Q7 sparse FIR structure.\r
4893    * @param[in]     numTaps    number of nonzero coefficients in the filter.\r
4894    * @param[in]     *pCoeffs   points to the array of filter coefficients.\r
4895    * @param[in]     *pState    points to the state buffer.\r
4896    * @param[in]     *pTapDelay points to the array of offset times.\r
4897    * @param[in]     maxDelay   maximum offset time supported.\r
4898    * @param[in]     blockSize  number of samples that will be processed per block.\r
4899    * @return none\r
4900    */\r
4901 \r
4902   void arm_fir_sparse_init_q7(\r
4903   arm_fir_sparse_instance_q7 * S,\r
4904   uint16_t numTaps,\r
4905   q7_t * pCoeffs,\r
4906   q7_t * pState,\r
4907   int32_t * pTapDelay,\r
4908   uint16_t maxDelay,\r
4909   uint32_t blockSize);\r
4910 \r
4911 \r
4912   /*\r
4913    * @brief  Floating-point sin_cos function.\r
4914    * @param[in]  theta    input value in degrees\r
4915    * @param[out] *pSinVal points to the processed sine output.\r
4916    * @param[out] *pCosVal points to the processed cos output.\r
4917    * @return none.\r
4918    */\r
4919 \r
4920   void arm_sin_cos_f32(\r
4921   float32_t theta,\r
4922   float32_t * pSinVal,\r
4923   float32_t * pCcosVal);\r
4924 \r
4925   /*\r
4926    * @brief  Q31 sin_cos function.\r
4927    * @param[in]  theta    scaled input value in degrees\r
4928    * @param[out] *pSinVal points to the processed sine output.\r
4929    * @param[out] *pCosVal points to the processed cosine output.\r
4930    * @return none.\r
4931    */\r
4932 \r
4933   void arm_sin_cos_q31(\r
4934   q31_t theta,\r
4935   q31_t * pSinVal,\r
4936   q31_t * pCosVal);\r
4937 \r
4938 \r
4939   /**\r
4940    * @brief  Floating-point complex conjugate.\r
4941    * @param[in]  *pSrc points to the input vector\r
4942    * @param[out]  *pDst points to the output vector\r
4943    * @param[in]  numSamples number of complex samples in each vector\r
4944    * @return none.\r
4945    */\r
4946 \r
4947   void arm_cmplx_conj_f32(\r
4948   float32_t * pSrc,\r
4949   float32_t * pDst,\r
4950   uint32_t numSamples);\r
4951 \r
4952   /**\r
4953    * @brief  Q31 complex conjugate.\r
4954    * @param[in]  *pSrc points to the input vector\r
4955    * @param[out]  *pDst points to the output vector\r
4956    * @param[in]  numSamples number of complex samples in each vector\r
4957    * @return none.\r
4958    */\r
4959 \r
4960   void arm_cmplx_conj_q31(\r
4961   q31_t * pSrc,\r
4962   q31_t * pDst,\r
4963   uint32_t numSamples);\r
4964 \r
4965   /**\r
4966    * @brief  Q15 complex conjugate.\r
4967    * @param[in]  *pSrc points to the input vector\r
4968    * @param[out]  *pDst points to the output vector\r
4969    * @param[in]  numSamples number of complex samples in each vector\r
4970    * @return none.\r
4971    */\r
4972 \r
4973   void arm_cmplx_conj_q15(\r
4974   q15_t * pSrc,\r
4975   q15_t * pDst,\r
4976   uint32_t numSamples);\r
4977 \r
4978 \r
4979 \r
4980   /**\r
4981    * @brief  Floating-point complex magnitude squared\r
4982    * @param[in]  *pSrc points to the complex input vector\r
4983    * @param[out]  *pDst points to the real output vector\r
4984    * @param[in]  numSamples number of complex samples in the input vector\r
4985    * @return none.\r
4986    */\r
4987 \r
4988   void arm_cmplx_mag_squared_f32(\r
4989   float32_t * pSrc,\r
4990   float32_t * pDst,\r
4991   uint32_t numSamples);\r
4992 \r
4993   /**\r
4994    * @brief  Q31 complex magnitude squared\r
4995    * @param[in]  *pSrc points to the complex input vector\r
4996    * @param[out]  *pDst points to the real output vector\r
4997    * @param[in]  numSamples number of complex samples in the input vector\r
4998    * @return none.\r
4999    */\r
5000 \r
5001   void arm_cmplx_mag_squared_q31(\r
5002   q31_t * pSrc,\r
5003   q31_t * pDst,\r
5004   uint32_t numSamples);\r
5005 \r
5006   /**\r
5007    * @brief  Q15 complex magnitude squared\r
5008    * @param[in]  *pSrc points to the complex input vector\r
5009    * @param[out]  *pDst points to the real output vector\r
5010    * @param[in]  numSamples number of complex samples in the input vector\r
5011    * @return none.\r
5012    */\r
5013 \r
5014   void arm_cmplx_mag_squared_q15(\r
5015   q15_t * pSrc,\r
5016   q15_t * pDst,\r
5017   uint32_t numSamples);\r
5018 \r
5019 \r
5020  /**\r
5021    * @ingroup groupController\r
5022    */\r
5023 \r
5024   /**\r
5025    * @defgroup PID PID Motor Control\r
5026    *\r
5027    * A Proportional Integral Derivative (PID) controller is a generic feedback control\r
5028    * loop mechanism widely used in industrial control systems.\r
5029    * A PID controller is the most commonly used type of feedback controller.\r
5030    *\r
5031    * This set of functions implements (PID) controllers\r
5032    * for Q15, Q31, and floating-point data types.  The functions operate on a single sample\r
5033    * of data and each call to the function returns a single processed value.\r
5034    * <code>S</code> points to an instance of the PID control data structure.  <code>in</code>\r
5035    * is the input sample value. The functions return the output value.\r
5036    *\r
5037    * \par Algorithm:\r
5038    * <pre>\r
5039    *    y[n] = y[n-1] + A0 * x[n] + A1 * x[n-1] + A2 * x[n-2]\r
5040    *    A0 = Kp + Ki + Kd\r
5041    *    A1 = (-Kp ) - (2 * Kd )\r
5042    *    A2 = Kd  </pre>\r
5043    *\r
5044    * \par\r
5045    * where \c Kp is proportional constant, \c Ki is Integral constant and \c Kd is Derivative constant\r
5046    *\r
5047    * \par\r
5048    * \image html PID.gif "Proportional Integral Derivative Controller"\r
5049    *\r
5050    * \par\r
5051    * The PID controller calculates an "error" value as the difference between\r
5052    * the measured output and the reference input.\r
5053    * The controller attempts to minimize the error by adjusting the process control inputs.\r
5054    * The proportional value determines the reaction to the current error,\r
5055    * the integral value determines the reaction based on the sum of recent errors,\r
5056    * and the derivative value determines the reaction based on the rate at which the error has been changing.\r
5057    *\r
5058    * \par Instance Structure\r
5059    * The Gains A0, A1, A2 and state variables for a PID controller are stored together in an instance data structure.\r
5060    * A separate instance structure must be defined for each PID Controller.\r
5061    * There are separate instance structure declarations for each of the 3 supported data types.\r
5062    *\r
5063    * \par Reset Functions\r
5064    * There is also an associated reset function for each data type which clears the state array.\r
5065    *\r
5066    * \par Initialization Functions\r
5067    * There is also an associated initialization function for each data type.\r
5068    * The initialization function performs the following operations:\r
5069    * - Initializes the Gains A0, A1, A2 from Kp,Ki, Kd gains.\r
5070    * - Zeros out the values in the state buffer.\r
5071    *\r
5072    * \par\r
5073    * Instance structure cannot be placed into a const data section and it is recommended to use the initialization function.\r
5074    *\r
5075    * \par Fixed-Point Behavior\r
5076    * Care must be taken when using the fixed-point versions of the PID Controller functions.\r
5077    * In particular, the overflow and saturation behavior of the accumulator used in each function must be considered.\r
5078    * Refer to the function specific documentation below for usage guidelines.\r
5079    */\r
5080 \r
5081   /**\r
5082    * @addtogroup PID\r
5083    * @{\r
5084    */\r
5085 \r
5086   /**\r
5087    * @brief  Process function for the floating-point PID Control.\r
5088    * @param[in,out] *S is an instance of the floating-point PID Control structure\r
5089    * @param[in] in input sample to process\r
5090    * @return out processed output sample.\r
5091    */\r
5092 \r
5093 \r
5094   static __INLINE float32_t arm_pid_f32(\r
5095   arm_pid_instance_f32 * S,\r
5096   float32_t in)\r
5097   {\r
5098     float32_t out;\r
5099 \r
5100     /* y[n] = y[n-1] + A0 * x[n] + A1 * x[n-1] + A2 * x[n-2]  */\r
5101     out = (S->A0 * in) +\r
5102       (S->A1 * S->state[0]) + (S->A2 * S->state[1]) + (S->state[2]);\r
5103 \r
5104     /* Update state */\r
5105     S->state[1] = S->state[0];\r
5106     S->state[0] = in;\r
5107     S->state[2] = out;\r
5108 \r
5109     /* return to application */\r
5110     return (out);\r
5111 \r
5112   }\r
5113 \r
5114   /**\r
5115    * @brief  Process function for the Q31 PID Control.\r
5116    * @param[in,out] *S points to an instance of the Q31 PID Control structure\r
5117    * @param[in] in input sample to process\r
5118    * @return out processed output sample.\r
5119    *\r
5120    * <b>Scaling and Overflow Behavior:</b>\r
5121    * \par\r
5122    * The function is implemented using an internal 64-bit accumulator.\r
5123    * The accumulator has a 2.62 format and maintains full precision of the intermediate multiplication results but provides only a single guard bit.\r
5124    * Thus, if the accumulator result overflows it wraps around rather than clip.\r
5125    * In order to avoid overflows completely the input signal must be scaled down by 2 bits as there are four additions.\r
5126    * After all multiply-accumulates are performed, the 2.62 accumulator is truncated to 1.32 format and then saturated to 1.31 format.\r
5127    */\r
5128 \r
5129   static __INLINE q31_t arm_pid_q31(\r
5130   arm_pid_instance_q31 * S,\r
5131   q31_t in)\r
5132   {\r
5133     q63_t acc;\r
5134     q31_t out;\r
5135 \r
5136     /* acc = A0 * x[n]  */\r
5137     acc = (q63_t) S->A0 * in;\r
5138 \r
5139     /* acc += A1 * x[n-1] */\r
5140     acc += (q63_t) S->A1 * S->state[0];\r
5141 \r
5142     /* acc += A2 * x[n-2]  */\r
5143     acc += (q63_t) S->A2 * S->state[1];\r
5144 \r
5145     /* convert output to 1.31 format to add y[n-1] */\r
5146     out = (q31_t) (acc >> 31u);\r
5147 \r
5148     /* out += y[n-1] */\r
5149     out += S->state[2];\r
5150 \r
5151     /* Update state */\r
5152     S->state[1] = S->state[0];\r
5153     S->state[0] = in;\r
5154     S->state[2] = out;\r
5155 \r
5156     /* return to application */\r
5157     return (out);\r
5158 \r
5159   }\r
5160 \r
5161   /**\r
5162    * @brief  Process function for the Q15 PID Control.\r
5163    * @param[in,out] *S points to an instance of the Q15 PID Control structure\r
5164    * @param[in] in input sample to process\r
5165    * @return out processed output sample.\r
5166    *\r
5167    * <b>Scaling and Overflow Behavior:</b>\r
5168    * \par\r
5169    * The function is implemented using a 64-bit internal accumulator.\r
5170    * Both Gains and state variables are represented in 1.15 format and multiplications yield a 2.30 result.\r
5171    * The 2.30 intermediate results are accumulated in a 64-bit accumulator in 34.30 format.\r
5172    * There is no risk of internal overflow with this approach and the full precision of intermediate multiplications is preserved.\r
5173    * After all additions have been performed, the accumulator is truncated to 34.15 format by discarding low 15 bits.\r
5174    * Lastly, the accumulator is saturated to yield a result in 1.15 format.\r
5175    */\r
5176 \r
5177   static __INLINE q15_t arm_pid_q15(\r
5178   arm_pid_instance_q15 * S,\r
5179   q15_t in)\r
5180   {\r
5181     q63_t acc;\r
5182     q15_t out;\r
5183 \r
5184 #ifndef ARM_MATH_CM0_FAMILY\r
5185     __SIMD32_TYPE *vstate;\r
5186 \r
5187     /* Implementation of PID controller */\r
5188 \r
5189     /* acc = A0 * x[n]  */\r
5190     acc = (q31_t) __SMUAD(S->A0, in);\r
5191 \r
5192     /* acc += A1 * x[n-1] + A2 * x[n-2]  */\r
5193     vstate = __SIMD32_CONST(S->state);\r
5194     acc = __SMLALD(S->A1, (q31_t) *vstate, acc);\r
5195 \r
5196 #else\r
5197     /* acc = A0 * x[n]  */\r
5198     acc = ((q31_t) S->A0) * in;\r
5199 \r
5200     /* acc += A1 * x[n-1] + A2 * x[n-2]  */\r
5201     acc += (q31_t) S->A1 * S->state[0];\r
5202     acc += (q31_t) S->A2 * S->state[1];\r
5203 \r
5204 #endif\r
5205 \r
5206     /* acc += y[n-1] */\r
5207     acc += (q31_t) S->state[2] << 15;\r
5208 \r
5209     /* saturate the output */\r
5210     out = (q15_t) (__SSAT((acc >> 15), 16));\r
5211 \r
5212     /* Update state */\r
5213     S->state[1] = S->state[0];\r
5214     S->state[0] = in;\r
5215     S->state[2] = out;\r
5216 \r
5217     /* return to application */\r
5218     return (out);\r
5219 \r
5220   }\r
5221 \r
5222   /**\r
5223    * @} end of PID group\r
5224    */\r
5225 \r
5226 \r
5227   /**\r
5228    * @brief Floating-point matrix inverse.\r
5229    * @param[in]  *src points to the instance of the input floating-point matrix structure.\r
5230    * @param[out] *dst points to the instance of the output floating-point matrix structure.\r
5231    * @return The function returns ARM_MATH_SIZE_MISMATCH, if the dimensions do not match.\r
5232    * If the input matrix is singular (does not have an inverse), then the algorithm terminates and returns error status ARM_MATH_SINGULAR.\r
5233    */\r
5234 \r
5235   arm_status arm_mat_inverse_f32(\r
5236   const arm_matrix_instance_f32 * src,\r
5237   arm_matrix_instance_f32 * dst);\r
5238 \r
5239 \r
5240   /**\r
5241    * @brief Floating-point matrix inverse.\r
5242    * @param[in]  *src points to the instance of the input floating-point matrix structure.\r
5243    * @param[out] *dst points to the instance of the output floating-point matrix structure.\r
5244    * @return The function returns ARM_MATH_SIZE_MISMATCH, if the dimensions do not match.\r
5245    * If the input matrix is singular (does not have an inverse), then the algorithm terminates and returns error status ARM_MATH_SINGULAR.\r
5246    */\r
5247 \r
5248   arm_status arm_mat_inverse_f64(\r
5249   const arm_matrix_instance_f64 * src,\r
5250   arm_matrix_instance_f64 * dst);\r
5251 \r
5252 \r
5253 \r
5254   /**\r
5255    * @ingroup groupController\r
5256    */\r
5257 \r
5258 \r
5259   /**\r
5260    * @defgroup clarke Vector Clarke Transform\r
5261    * Forward Clarke transform converts the instantaneous stator phases into a two-coordinate time invariant vector.\r
5262    * Generally the Clarke transform uses three-phase currents <code>Ia, Ib and Ic</code> to calculate currents\r
5263    * in the two-phase orthogonal stator axis <code>Ialpha</code> and <code>Ibeta</code>.\r
5264    * When <code>Ialpha</code> is superposed with <code>Ia</code> as shown in the figure below\r
5265    * \image html clarke.gif Stator current space vector and its components in (a,b).\r
5266    * and <code>Ia + Ib + Ic = 0</code>, in this condition <code>Ialpha</code> and <code>Ibeta</code>\r
5267    * can be calculated using only <code>Ia</code> and <code>Ib</code>.\r
5268    *\r
5269    * The function operates on a single sample of data and each call to the function returns the processed output.\r
5270    * The library provides separate functions for Q31 and floating-point data types.\r
5271    * \par Algorithm\r
5272    * \image html clarkeFormula.gif\r
5273    * where <code>Ia</code> and <code>Ib</code> are the instantaneous stator phases and\r
5274    * <code>pIalpha</code> and <code>pIbeta</code> are the two coordinates of time invariant vector.\r
5275    * \par Fixed-Point Behavior\r
5276    * Care must be taken when using the Q31 version of the Clarke transform.\r
5277    * In particular, the overflow and saturation behavior of the accumulator used must be considered.\r
5278    * Refer to the function specific documentation below for usage guidelines.\r
5279    */\r
5280 \r
5281   /**\r
5282    * @addtogroup clarke\r
5283    * @{\r
5284    */\r
5285 \r
5286   /**\r
5287    *\r
5288    * @brief  Floating-point Clarke transform\r
5289    * @param[in]       Ia       input three-phase coordinate <code>a</code>\r
5290    * @param[in]       Ib       input three-phase coordinate <code>b</code>\r
5291    * @param[out]      *pIalpha points to output two-phase orthogonal vector axis alpha\r
5292    * @param[out]      *pIbeta  points to output two-phase orthogonal vector axis beta\r
5293    * @return none.\r
5294    */\r
5295 \r
5296   static __INLINE void arm_clarke_f32(\r
5297   float32_t Ia,\r
5298   float32_t Ib,\r
5299   float32_t * pIalpha,\r
5300   float32_t * pIbeta)\r
5301   {\r
5302     /* Calculate pIalpha using the equation, pIalpha = Ia */\r
5303     *pIalpha = Ia;\r
5304 \r
5305     /* Calculate pIbeta using the equation, pIbeta = (1/sqrt(3)) * Ia + (2/sqrt(3)) * Ib */\r
5306     *pIbeta =\r
5307       ((float32_t) 0.57735026919 * Ia + (float32_t) 1.15470053838 * Ib);\r
5308 \r
5309   }\r
5310 \r
5311   /**\r
5312    * @brief  Clarke transform for Q31 version\r
5313    * @param[in]       Ia       input three-phase coordinate <code>a</code>\r
5314    * @param[in]       Ib       input three-phase coordinate <code>b</code>\r
5315    * @param[out]      *pIalpha points to output two-phase orthogonal vector axis alpha\r
5316    * @param[out]      *pIbeta  points to output two-phase orthogonal vector axis beta\r
5317    * @return none.\r
5318    *\r
5319    * <b>Scaling and Overflow Behavior:</b>\r
5320    * \par\r
5321    * The function is implemented using an internal 32-bit accumulator.\r
5322    * The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format.\r
5323    * There is saturation on the addition, hence there is no risk of overflow.\r
5324    */\r
5325 \r
5326   static __INLINE void arm_clarke_q31(\r
5327   q31_t Ia,\r
5328   q31_t Ib,\r
5329   q31_t * pIalpha,\r
5330   q31_t * pIbeta)\r
5331   {\r
5332     q31_t product1, product2;                    /* Temporary variables used to store intermediate results */\r
5333 \r
5334     /* Calculating pIalpha from Ia by equation pIalpha = Ia */\r
5335     *pIalpha = Ia;\r
5336 \r
5337     /* Intermediate product is calculated by (1/(sqrt(3)) * Ia) */\r
5338     product1 = (q31_t) (((q63_t) Ia * 0x24F34E8B) >> 30);\r
5339 \r
5340     /* Intermediate product is calculated by (2/sqrt(3) * Ib) */\r
5341     product2 = (q31_t) (((q63_t) Ib * 0x49E69D16) >> 30);\r
5342 \r
5343     /* pIbeta is calculated by adding the intermediate products */\r
5344     *pIbeta = __QADD(product1, product2);\r
5345   }\r
5346 \r
5347   /**\r
5348    * @} end of clarke group\r
5349    */\r
5350 \r
5351   /**\r
5352    * @brief  Converts the elements of the Q7 vector to Q31 vector.\r
5353    * @param[in]  *pSrc     input pointer\r
5354    * @param[out]  *pDst    output pointer\r
5355    * @param[in]  blockSize number of samples to process\r
5356    * @return none.\r
5357    */\r
5358   void arm_q7_to_q31(\r
5359   q7_t * pSrc,\r
5360   q31_t * pDst,\r
5361   uint32_t blockSize);\r
5362 \r
5363 \r
5364 \r
5365 \r
5366   /**\r
5367    * @ingroup groupController\r
5368    */\r
5369 \r
5370   /**\r
5371    * @defgroup inv_clarke Vector Inverse Clarke Transform\r
5372    * Inverse Clarke transform converts the two-coordinate time invariant vector into instantaneous stator phases.\r
5373    *\r
5374    * The function operates on a single sample of data and each call to the function returns the processed output.\r
5375    * The library provides separate functions for Q31 and floating-point data types.\r
5376    * \par Algorithm\r
5377    * \image html clarkeInvFormula.gif\r
5378    * where <code>pIa</code> and <code>pIb</code> are the instantaneous stator phases and\r
5379    * <code>Ialpha</code> and <code>Ibeta</code> are the two coordinates of time invariant vector.\r
5380    * \par Fixed-Point Behavior\r
5381    * Care must be taken when using the Q31 version of the Clarke transform.\r
5382    * In particular, the overflow and saturation behavior of the accumulator used must be considered.\r
5383    * Refer to the function specific documentation below for usage guidelines.\r
5384    */\r
5385 \r
5386   /**\r
5387    * @addtogroup inv_clarke\r
5388    * @{\r
5389    */\r
5390 \r
5391    /**\r
5392    * @brief  Floating-point Inverse Clarke transform\r
5393    * @param[in]       Ialpha  input two-phase orthogonal vector axis alpha\r
5394    * @param[in]       Ibeta   input two-phase orthogonal vector axis beta\r
5395    * @param[out]      *pIa    points to output three-phase coordinate <code>a</code>\r
5396    * @param[out]      *pIb    points to output three-phase coordinate <code>b</code>\r
5397    * @return none.\r
5398    */\r
5399 \r
5400 \r
5401   static __INLINE void arm_inv_clarke_f32(\r
5402   float32_t Ialpha,\r
5403   float32_t Ibeta,\r
5404   float32_t * pIa,\r
5405   float32_t * pIb)\r
5406   {\r
5407     /* Calculating pIa from Ialpha by equation pIa = Ialpha */\r
5408     *pIa = Ialpha;\r
5409 \r
5410     /* Calculating pIb from Ialpha and Ibeta by equation pIb = -(1/2) * Ialpha + (sqrt(3)/2) * Ibeta */\r
5411     *pIb = -0.5 * Ialpha + (float32_t) 0.8660254039 *Ibeta;\r
5412 \r
5413   }\r
5414 \r
5415   /**\r
5416    * @brief  Inverse Clarke transform for Q31 version\r
5417    * @param[in]       Ialpha  input two-phase orthogonal vector axis alpha\r
5418    * @param[in]       Ibeta   input two-phase orthogonal vector axis beta\r
5419    * @param[out]      *pIa    points to output three-phase coordinate <code>a</code>\r
5420    * @param[out]      *pIb    points to output three-phase coordinate <code>b</code>\r
5421    * @return none.\r
5422    *\r
5423    * <b>Scaling and Overflow Behavior:</b>\r
5424    * \par\r
5425    * The function is implemented using an internal 32-bit accumulator.\r
5426    * The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format.\r
5427    * There is saturation on the subtraction, hence there is no risk of overflow.\r
5428    */\r
5429 \r
5430   static __INLINE void arm_inv_clarke_q31(\r
5431   q31_t Ialpha,\r
5432   q31_t Ibeta,\r
5433   q31_t * pIa,\r
5434   q31_t * pIb)\r
5435   {\r
5436     q31_t product1, product2;                    /* Temporary variables used to store intermediate results */\r
5437 \r
5438     /* Calculating pIa from Ialpha by equation pIa = Ialpha */\r
5439     *pIa = Ialpha;\r
5440 \r
5441     /* Intermediate product is calculated by (1/(2*sqrt(3)) * Ia) */\r
5442     product1 = (q31_t) (((q63_t) (Ialpha) * (0x40000000)) >> 31);\r
5443 \r
5444     /* Intermediate product is calculated by (1/sqrt(3) * pIb) */\r
5445     product2 = (q31_t) (((q63_t) (Ibeta) * (0x6ED9EBA1)) >> 31);\r
5446 \r
5447     /* pIb is calculated by subtracting the products */\r
5448     *pIb = __QSUB(product2, product1);\r
5449 \r
5450   }\r
5451 \r
5452   /**\r
5453    * @} end of inv_clarke group\r
5454    */\r
5455 \r
5456   /**\r
5457    * @brief  Converts the elements of the Q7 vector to Q15 vector.\r
5458    * @param[in]  *pSrc     input pointer\r
5459    * @param[out] *pDst     output pointer\r
5460    * @param[in]  blockSize number of samples to process\r
5461    * @return none.\r
5462    */\r
5463   void arm_q7_to_q15(\r
5464   q7_t * pSrc,\r
5465   q15_t * pDst,\r
5466   uint32_t blockSize);\r
5467 \r
5468 \r
5469 \r
5470   /**\r
5471    * @ingroup groupController\r
5472    */\r
5473 \r
5474   /**\r
5475    * @defgroup park Vector Park Transform\r
5476    *\r
5477    * Forward Park transform converts the input two-coordinate vector to flux and torque components.\r
5478    * The Park transform can be used to realize the transformation of the <code>Ialpha</code> and the <code>Ibeta</code> currents\r
5479    * from the stationary to the moving reference frame and control the spatial relationship between\r
5480    * the stator vector current and rotor flux vector.\r
5481    * If we consider the d axis aligned with the rotor flux, the diagram below shows the\r
5482    * current vector and the relationship from the two reference frames:\r
5483    * \image html park.gif "Stator current space vector and its component in (a,b) and in the d,q rotating reference frame"\r
5484    *\r
5485    * The function operates on a single sample of data and each call to the function returns the processed output.\r
5486    * The library provides separate functions for Q31 and floating-point data types.\r
5487    * \par Algorithm\r
5488    * \image html parkFormula.gif\r
5489    * where <code>Ialpha</code> and <code>Ibeta</code> are the stator vector components,\r
5490    * <code>pId</code> and <code>pIq</code> are rotor vector components and <code>cosVal</code> and <code>sinVal</code> are the\r
5491    * cosine and sine values of theta (rotor flux position).\r
5492    * \par Fixed-Point Behavior\r
5493    * Care must be taken when using the Q31 version of the Park transform.\r
5494    * In particular, the overflow and saturation behavior of the accumulator used must be considered.\r
5495    * Refer to the function specific documentation below for usage guidelines.\r
5496    */\r
5497 \r
5498   /**\r
5499    * @addtogroup park\r
5500    * @{\r
5501    */\r
5502 \r
5503   /**\r
5504    * @brief Floating-point Park transform\r
5505    * @param[in]       Ialpha input two-phase vector coordinate alpha\r
5506    * @param[in]       Ibeta  input two-phase vector coordinate beta\r
5507    * @param[out]      *pId   points to output   rotor reference frame d\r
5508    * @param[out]      *pIq   points to output   rotor reference frame q\r
5509    * @param[in]       sinVal sine value of rotation angle theta\r
5510    * @param[in]       cosVal cosine value of rotation angle theta\r
5511    * @return none.\r
5512    *\r
5513    * The function implements the forward Park transform.\r
5514    *\r
5515    */\r
5516 \r
5517   static __INLINE void arm_park_f32(\r
5518   float32_t Ialpha,\r
5519   float32_t Ibeta,\r
5520   float32_t * pId,\r
5521   float32_t * pIq,\r
5522   float32_t sinVal,\r
5523   float32_t cosVal)\r
5524   {\r
5525     /* Calculate pId using the equation, pId = Ialpha * cosVal + Ibeta * sinVal */\r
5526     *pId = Ialpha * cosVal + Ibeta * sinVal;\r
5527 \r
5528     /* Calculate pIq using the equation, pIq = - Ialpha * sinVal + Ibeta * cosVal */\r
5529     *pIq = -Ialpha * sinVal + Ibeta * cosVal;\r
5530 \r
5531   }\r
5532 \r
5533   /**\r
5534    * @brief  Park transform for Q31 version\r
5535    * @param[in]       Ialpha input two-phase vector coordinate alpha\r
5536    * @param[in]       Ibeta  input two-phase vector coordinate beta\r
5537    * @param[out]      *pId   points to output rotor reference frame d\r
5538    * @param[out]      *pIq   points to output rotor reference frame q\r
5539    * @param[in]       sinVal sine value of rotation angle theta\r
5540    * @param[in]       cosVal cosine value of rotation angle theta\r
5541    * @return none.\r
5542    *\r
5543    * <b>Scaling and Overflow Behavior:</b>\r
5544    * \par\r
5545    * The function is implemented using an internal 32-bit accumulator.\r
5546    * The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format.\r
5547    * There is saturation on the addition and subtraction, hence there is no risk of overflow.\r
5548    */\r
5549 \r
5550 \r
5551   static __INLINE void arm_park_q31(\r
5552   q31_t Ialpha,\r
5553   q31_t Ibeta,\r
5554   q31_t * pId,\r
5555   q31_t * pIq,\r
5556   q31_t sinVal,\r
5557   q31_t cosVal)\r
5558   {\r
5559     q31_t product1, product2;                    /* Temporary variables used to store intermediate results */\r
5560     q31_t product3, product4;                    /* Temporary variables used to store intermediate results */\r
5561 \r
5562     /* Intermediate product is calculated by (Ialpha * cosVal) */\r
5563     product1 = (q31_t) (((q63_t) (Ialpha) * (cosVal)) >> 31);\r
5564 \r
5565     /* Intermediate product is calculated by (Ibeta * sinVal) */\r
5566     product2 = (q31_t) (((q63_t) (Ibeta) * (sinVal)) >> 31);\r
5567 \r
5568 \r
5569     /* Intermediate product is calculated by (Ialpha * sinVal) */\r
5570     product3 = (q31_t) (((q63_t) (Ialpha) * (sinVal)) >> 31);\r
5571 \r
5572     /* Intermediate product is calculated by (Ibeta * cosVal) */\r
5573     product4 = (q31_t) (((q63_t) (Ibeta) * (cosVal)) >> 31);\r
5574 \r
5575     /* Calculate pId by adding the two intermediate products 1 and 2 */\r
5576     *pId = __QADD(product1, product2);\r
5577 \r
5578     /* Calculate pIq by subtracting the two intermediate products 3 from 4 */\r
5579     *pIq = __QSUB(product4, product3);\r
5580   }\r
5581 \r
5582   /**\r
5583    * @} end of park group\r
5584    */\r
5585 \r
5586   /**\r
5587    * @brief  Converts the elements of the Q7 vector to floating-point vector.\r
5588    * @param[in]  *pSrc is input pointer\r
5589    * @param[out]  *pDst is output pointer\r
5590    * @param[in]  blockSize is the number of samples to process\r
5591    * @return none.\r
5592    */\r
5593   void arm_q7_to_float(\r
5594   q7_t * pSrc,\r
5595   float32_t * pDst,\r
5596   uint32_t blockSize);\r
5597 \r
5598 \r
5599   /**\r
5600    * @ingroup groupController\r
5601    */\r
5602 \r
5603   /**\r
5604    * @defgroup inv_park Vector Inverse Park transform\r
5605    * Inverse Park transform converts the input flux and torque components to two-coordinate vector.\r
5606    *\r
5607    * The function operates on a single sample of data and each call to the function returns the processed output.\r
5608    * The library provides separate functions for Q31 and floating-point data types.\r
5609    * \par Algorithm\r
5610    * \image html parkInvFormula.gif\r
5611    * where <code>pIalpha</code> and <code>pIbeta</code> are the stator vector components,\r
5612    * <code>Id</code> and <code>Iq</code> are rotor vector components and <code>cosVal</code> and <code>sinVal</code> are the\r
5613    * cosine and sine values of theta (rotor flux position).\r
5614    * \par Fixed-Point Behavior\r
5615    * Care must be taken when using the Q31 version of the Park transform.\r
5616    * In particular, the overflow and saturation behavior of the accumulator used must be considered.\r
5617    * Refer to the function specific documentation below for usage guidelines.\r
5618    */\r
5619 \r
5620   /**\r
5621    * @addtogroup inv_park\r
5622    * @{\r
5623    */\r
5624 \r
5625    /**\r
5626    * @brief  Floating-point Inverse Park transform\r
5627    * @param[in]       Id        input coordinate of rotor reference frame d\r
5628    * @param[in]       Iq        input coordinate of rotor reference frame q\r
5629    * @param[out]      *pIalpha  points to output two-phase orthogonal vector axis alpha\r
5630    * @param[out]      *pIbeta   points to output two-phase orthogonal vector axis beta\r
5631    * @param[in]       sinVal    sine value of rotation angle theta\r
5632    * @param[in]       cosVal    cosine value of rotation angle theta\r
5633    * @return none.\r
5634    */\r
5635 \r
5636   static __INLINE void arm_inv_park_f32(\r
5637   float32_t Id,\r
5638   float32_t Iq,\r
5639   float32_t * pIalpha,\r
5640   float32_t * pIbeta,\r
5641   float32_t sinVal,\r
5642   float32_t cosVal)\r
5643   {\r
5644     /* Calculate pIalpha using the equation, pIalpha = Id * cosVal - Iq * sinVal */\r
5645     *pIalpha = Id * cosVal - Iq * sinVal;\r
5646 \r
5647     /* Calculate pIbeta using the equation, pIbeta = Id * sinVal + Iq * cosVal */\r
5648     *pIbeta = Id * sinVal + Iq * cosVal;\r
5649 \r
5650   }\r
5651 \r
5652 \r
5653   /**\r
5654    * @brief  Inverse Park transform for Q31 version\r
5655    * @param[in]       Id        input coordinate of rotor reference frame d\r
5656    * @param[in]       Iq        input coordinate of rotor reference frame q\r
5657    * @param[out]      *pIalpha  points to output two-phase orthogonal vector axis alpha\r
5658    * @param[out]      *pIbeta   points to output two-phase orthogonal vector axis beta\r
5659    * @param[in]       sinVal    sine value of rotation angle theta\r
5660    * @param[in]       cosVal    cosine value of rotation angle theta\r
5661    * @return none.\r
5662    *\r
5663    * <b>Scaling and Overflow Behavior:</b>\r
5664    * \par\r
5665    * The function is implemented using an internal 32-bit accumulator.\r
5666    * The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format.\r
5667    * There is saturation on the addition, hence there is no risk of overflow.\r
5668    */\r
5669 \r
5670 \r
5671   static __INLINE void arm_inv_park_q31(\r
5672   q31_t Id,\r
5673   q31_t Iq,\r
5674   q31_t * pIalpha,\r
5675   q31_t * pIbeta,\r
5676   q31_t sinVal,\r
5677   q31_t cosVal)\r
5678   {\r
5679     q31_t product1, product2;                    /* Temporary variables used to store intermediate results */\r
5680     q31_t product3, product4;                    /* Temporary variables used to store intermediate results */\r
5681 \r
5682     /* Intermediate product is calculated by (Id * cosVal) */\r
5683     product1 = (q31_t) (((q63_t) (Id) * (cosVal)) >> 31);\r
5684 \r
5685     /* Intermediate product is calculated by (Iq * sinVal) */\r
5686     product2 = (q31_t) (((q63_t) (Iq) * (sinVal)) >> 31);\r
5687 \r
5688 \r
5689     /* Intermediate product is calculated by (Id * sinVal) */\r
5690     product3 = (q31_t) (((q63_t) (Id) * (sinVal)) >> 31);\r
5691 \r
5692     /* Intermediate product is calculated by (Iq * cosVal) */\r
5693     product4 = (q31_t) (((q63_t) (Iq) * (cosVal)) >> 31);\r
5694 \r
5695     /* Calculate pIalpha by using the two intermediate products 1 and 2 */\r
5696     *pIalpha = __QSUB(product1, product2);\r
5697 \r
5698     /* Calculate pIbeta by using the two intermediate products 3 and 4 */\r
5699     *pIbeta = __QADD(product4, product3);\r
5700 \r
5701   }\r
5702 \r
5703   /**\r
5704    * @} end of Inverse park group\r
5705    */\r
5706 \r
5707 \r
5708   /**\r
5709    * @brief  Converts the elements of the Q31 vector to floating-point vector.\r
5710    * @param[in]  *pSrc is input pointer\r
5711    * @param[out]  *pDst is output pointer\r
5712    * @param[in]  blockSize is the number of samples to process\r
5713    * @return none.\r
5714    */\r
5715   void arm_q31_to_float(\r
5716   q31_t * pSrc,\r
5717   float32_t * pDst,\r
5718   uint32_t blockSize);\r
5719 \r
5720   /**\r
5721    * @ingroup groupInterpolation\r
5722    */\r
5723 \r
5724   /**\r
5725    * @defgroup LinearInterpolate Linear Interpolation\r
5726    *\r
5727    * Linear interpolation is a method of curve fitting using linear polynomials.\r
5728    * Linear interpolation works by effectively drawing a straight line between two neighboring samples and returning the appropriate point along that line\r
5729    *\r
5730    * \par\r
5731    * \image html LinearInterp.gif "Linear interpolation"\r
5732    *\r
5733    * \par\r
5734    * A  Linear Interpolate function calculates an output value(y), for the input(x)\r
5735    * using linear interpolation of the input values x0, x1( nearest input values) and the output values y0 and y1(nearest output values)\r
5736    *\r
5737    * \par Algorithm:\r
5738    * <pre>\r
5739    *       y = y0 + (x - x0) * ((y1 - y0)/(x1-x0))\r
5740    *       where x0, x1 are nearest values of input x\r
5741    *             y0, y1 are nearest values to output y\r
5742    * </pre>\r
5743    *\r
5744    * \par\r
5745    * This set of functions implements Linear interpolation process\r
5746    * for Q7, Q15, Q31, and floating-point data types.  The functions operate on a single\r
5747    * sample of data and each call to the function returns a single processed value.\r
5748    * <code>S</code> points to an instance of the Linear Interpolate function data structure.\r
5749    * <code>x</code> is the input sample value. The functions returns the output value.\r
5750    *\r
5751    * \par\r
5752    * if x is outside of the table boundary, Linear interpolation returns first value of the table\r
5753    * if x is below input range and returns last value of table if x is above range.\r
5754    */\r
5755 \r
5756   /**\r
5757    * @addtogroup LinearInterpolate\r
5758    * @{\r
5759    */\r
5760 \r
5761   /**\r
5762    * @brief  Process function for the floating-point Linear Interpolation Function.\r
5763    * @param[in,out] *S is an instance of the floating-point Linear Interpolation structure\r
5764    * @param[in] x input sample to process\r
5765    * @return y processed output sample.\r
5766    *\r
5767    */\r
5768 \r
5769   static __INLINE float32_t arm_linear_interp_f32(\r
5770   arm_linear_interp_instance_f32 * S,\r
5771   float32_t x)\r
5772   {\r
5773 \r
5774     float32_t y;\r
5775     float32_t x0, x1;                            /* Nearest input values */\r
5776     float32_t y0, y1;                            /* Nearest output values */\r
5777     float32_t xSpacing = S->xSpacing;            /* spacing between input values */\r
5778     int32_t i;                                   /* Index variable */\r
5779     float32_t *pYData = S->pYData;               /* pointer to output table */\r
5780 \r
5781     /* Calculation of index */\r
5782     i = (int32_t) ((x - S->x1) / xSpacing);\r
5783 \r
5784     if(i < 0)\r
5785     {\r
5786       /* Iniatilize output for below specified range as least output value of table */\r
5787       y = pYData[0];\r
5788     }\r
5789     else if((uint32_t)i >= S->nValues)\r
5790     {\r
5791       /* Iniatilize output for above specified range as last output value of table */\r
5792       y = pYData[S->nValues - 1];\r
5793     }\r
5794     else\r
5795     {\r
5796       /* Calculation of nearest input values */\r
5797       x0 = S->x1 + i * xSpacing;\r
5798       x1 = S->x1 + (i + 1) * xSpacing;\r
5799 \r
5800       /* Read of nearest output values */\r
5801       y0 = pYData[i];\r
5802       y1 = pYData[i + 1];\r
5803 \r
5804       /* Calculation of output */\r
5805       y = y0 + (x - x0) * ((y1 - y0) / (x1 - x0));\r
5806 \r
5807     }\r
5808 \r
5809     /* returns output value */\r
5810     return (y);\r
5811   }\r
5812 \r
5813    /**\r
5814    *\r
5815    * @brief  Process function for the Q31 Linear Interpolation Function.\r
5816    * @param[in] *pYData  pointer to Q31 Linear Interpolation table\r
5817    * @param[in] x input sample to process\r
5818    * @param[in] nValues number of table values\r
5819    * @return y processed output sample.\r
5820    *\r
5821    * \par\r
5822    * Input sample <code>x</code> is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part.\r
5823    * This function can support maximum of table size 2^12.\r
5824    *\r
5825    */\r
5826 \r
5827 \r
5828   static __INLINE q31_t arm_linear_interp_q31(\r
5829   q31_t * pYData,\r
5830   q31_t x,\r
5831   uint32_t nValues)\r
5832   {\r
5833     q31_t y;                                     /* output */\r
5834     q31_t y0, y1;                                /* Nearest output values */\r
5835     q31_t fract;                                 /* fractional part */\r
5836     int32_t index;                               /* Index to read nearest output values */\r
5837 \r
5838     /* Input is in 12.20 format */\r
5839     /* 12 bits for the table index */\r
5840     /* Index value calculation */\r
5841     index = ((x & 0xFFF00000) >> 20);\r
5842 \r
5843     if(index >= (int32_t)(nValues - 1))\r
5844     {\r
5845       return (pYData[nValues - 1]);\r
5846     }\r
5847     else if(index < 0)\r
5848     {\r
5849       return (pYData[0]);\r
5850     }\r
5851     else\r
5852     {\r
5853 \r
5854       /* 20 bits for the fractional part */\r
5855       /* shift left by 11 to keep fract in 1.31 format */\r
5856       fract = (x & 0x000FFFFF) << 11;\r
5857 \r
5858       /* Read two nearest output values from the index in 1.31(q31) format */\r
5859       y0 = pYData[index];\r
5860       y1 = pYData[index + 1u];\r
5861 \r
5862       /* Calculation of y0 * (1-fract) and y is in 2.30 format */\r
5863       y = ((q31_t) ((q63_t) y0 * (0x7FFFFFFF - fract) >> 32));\r
5864 \r
5865       /* Calculation of y0 * (1-fract) + y1 *fract and y is in 2.30 format */\r
5866       y += ((q31_t) (((q63_t) y1 * fract) >> 32));\r
5867 \r
5868       /* Convert y to 1.31 format */\r
5869       return (y << 1u);\r
5870 \r
5871     }\r
5872 \r
5873   }\r
5874 \r
5875   /**\r
5876    *\r
5877    * @brief  Process function for the Q15 Linear Interpolation Function.\r
5878    * @param[in] *pYData  pointer to Q15 Linear Interpolation table\r
5879    * @param[in] x input sample to process\r
5880    * @param[in] nValues number of table values\r
5881    * @return y processed output sample.\r
5882    *\r
5883    * \par\r
5884    * Input sample <code>x</code> is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part.\r
5885    * This function can support maximum of table size 2^12.\r
5886    *\r
5887    */\r
5888 \r
5889 \r
5890   static __INLINE q15_t arm_linear_interp_q15(\r
5891   q15_t * pYData,\r
5892   q31_t x,\r
5893   uint32_t nValues)\r
5894   {\r
5895     q63_t y;                                     /* output */\r
5896     q15_t y0, y1;                                /* Nearest output values */\r
5897     q31_t fract;                                 /* fractional part */\r
5898     int32_t index;                               /* Index to read nearest output values */\r
5899 \r
5900     /* Input is in 12.20 format */\r
5901     /* 12 bits for the table index */\r
5902     /* Index value calculation */\r
5903     index = ((x & 0xFFF00000) >> 20u);\r
5904 \r
5905     if(index >= (int32_t)(nValues - 1))\r
5906     {\r
5907       return (pYData[nValues - 1]);\r
5908     }\r
5909     else if(index < 0)\r
5910     {\r
5911       return (pYData[0]);\r
5912     }\r
5913     else\r
5914     {\r
5915       /* 20 bits for the fractional part */\r
5916       /* fract is in 12.20 format */\r
5917       fract = (x & 0x000FFFFF);\r
5918 \r
5919       /* Read two nearest output values from the index */\r
5920       y0 = pYData[index];\r
5921       y1 = pYData[index + 1u];\r
5922 \r
5923       /* Calculation of y0 * (1-fract) and y is in 13.35 format */\r
5924       y = ((q63_t) y0 * (0xFFFFF - fract));\r
5925 \r
5926       /* Calculation of (y0 * (1-fract) + y1 * fract) and y is in 13.35 format */\r
5927       y += ((q63_t) y1 * (fract));\r
5928 \r
5929       /* convert y to 1.15 format */\r
5930       return (y >> 20);\r
5931     }\r
5932 \r
5933 \r
5934   }\r
5935 \r
5936   /**\r
5937    *\r
5938    * @brief  Process function for the Q7 Linear Interpolation Function.\r
5939    * @param[in] *pYData  pointer to Q7 Linear Interpolation table\r
5940    * @param[in] x input sample to process\r
5941    * @param[in] nValues number of table values\r
5942    * @return y processed output sample.\r
5943    *\r
5944    * \par\r
5945    * Input sample <code>x</code> is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part.\r
5946    * This function can support maximum of table size 2^12.\r
5947    */\r
5948 \r
5949 \r
5950   static __INLINE q7_t arm_linear_interp_q7(\r
5951   q7_t * pYData,\r
5952   q31_t x,\r
5953   uint32_t nValues)\r
5954   {\r
5955     q31_t y;                                     /* output */\r
5956     q7_t y0, y1;                                 /* Nearest output values */\r
5957     q31_t fract;                                 /* fractional part */\r
5958     uint32_t index;                              /* Index to read nearest output values */\r
5959 \r
5960     /* Input is in 12.20 format */\r
5961     /* 12 bits for the table index */\r
5962     /* Index value calculation */\r
5963     if (x < 0)\r
5964     {\r
5965       return (pYData[0]);\r
5966     }\r
5967     index = (x >> 20) & 0xfff;\r
5968 \r
5969 \r
5970     if(index >= (nValues - 1))\r
5971     {\r
5972       return (pYData[nValues - 1]);\r
5973     }\r
5974     else\r
5975     {\r
5976 \r
5977       /* 20 bits for the fractional part */\r
5978       /* fract is in 12.20 format */\r
5979       fract = (x & 0x000FFFFF);\r
5980 \r
5981       /* Read two nearest output values from the index and are in 1.7(q7) format */\r
5982       y0 = pYData[index];\r
5983       y1 = pYData[index + 1u];\r
5984 \r
5985       /* Calculation of y0 * (1-fract ) and y is in 13.27(q27) format */\r
5986       y = ((y0 * (0xFFFFF - fract)));\r
5987 \r
5988       /* Calculation of y1 * fract + y0 * (1-fract) and y is in 13.27(q27) format */\r
5989       y += (y1 * fract);\r
5990 \r
5991       /* convert y to 1.7(q7) format */\r
5992       return (y >> 20u);\r
5993 \r
5994     }\r
5995 \r
5996   }\r
5997   /**\r
5998    * @} end of LinearInterpolate group\r
5999    */\r
6000 \r
6001   /**\r
6002    * @brief  Fast approximation to the trigonometric sine function for floating-point data.\r
6003    * @param[in] x input value in radians.\r
6004    * @return  sin(x).\r
6005    */\r
6006 \r
6007   float32_t arm_sin_f32(\r
6008   float32_t x);\r
6009 \r
6010   /**\r
6011    * @brief  Fast approximation to the trigonometric sine function for Q31 data.\r
6012    * @param[in] x Scaled input value in radians.\r
6013    * @return  sin(x).\r
6014    */\r
6015 \r
6016   q31_t arm_sin_q31(\r
6017   q31_t x);\r
6018 \r
6019   /**\r
6020    * @brief  Fast approximation to the trigonometric sine function for Q15 data.\r
6021    * @param[in] x Scaled input value in radians.\r
6022    * @return  sin(x).\r
6023    */\r
6024 \r
6025   q15_t arm_sin_q15(\r
6026   q15_t x);\r
6027 \r
6028   /**\r
6029    * @brief  Fast approximation to the trigonometric cosine function for floating-point data.\r
6030    * @param[in] x input value in radians.\r
6031    * @return  cos(x).\r
6032    */\r
6033 \r
6034   float32_t arm_cos_f32(\r
6035   float32_t x);\r
6036 \r
6037   /**\r
6038    * @brief Fast approximation to the trigonometric cosine function for Q31 data.\r
6039    * @param[in] x Scaled input value in radians.\r
6040    * @return  cos(x).\r
6041    */\r
6042 \r
6043   q31_t arm_cos_q31(\r
6044   q31_t x);\r
6045 \r
6046   /**\r
6047    * @brief  Fast approximation to the trigonometric cosine function for Q15 data.\r
6048    * @param[in] x Scaled input value in radians.\r
6049    * @return  cos(x).\r
6050    */\r
6051 \r
6052   q15_t arm_cos_q15(\r
6053   q15_t x);\r
6054 \r
6055 \r
6056   /**\r
6057    * @ingroup groupFastMath\r
6058    */\r
6059 \r
6060 \r
6061   /**\r
6062    * @defgroup SQRT Square Root\r
6063    *\r
6064    * Computes the square root of a number.\r
6065    * There are separate functions for Q15, Q31, and floating-point data types.\r
6066    * The square root function is computed using the Newton-Raphson algorithm.\r
6067    * This is an iterative algorithm of the form:\r
6068    * <pre>\r
6069    *      x1 = x0 - f(x0)/f'(x0)\r
6070    * </pre>\r
6071    * where <code>x1</code> is the current estimate,\r
6072    * <code>x0</code> is the previous estimate, and\r
6073    * <code>f'(x0)</code> is the derivative of <code>f()</code> evaluated at <code>x0</code>.\r
6074    * For the square root function, the algorithm reduces to:\r
6075    * <pre>\r
6076    *     x0 = in/2                         [initial guess]\r
6077    *     x1 = 1/2 * ( x0 + in / x0)        [each iteration]\r
6078    * </pre>\r
6079    */\r
6080 \r
6081 \r
6082   /**\r
6083    * @addtogroup SQRT\r
6084    * @{\r
6085    */\r
6086 \r
6087   /**\r
6088    * @brief  Floating-point square root function.\r
6089    * @param[in]  in     input value.\r
6090    * @param[out] *pOut  square root of input value.\r
6091    * @return The function returns ARM_MATH_SUCCESS if input value is positive value or ARM_MATH_ARGUMENT_ERROR if\r
6092    * <code>in</code> is negative value and returns zero output for negative values.\r
6093    */\r
6094 \r
6095   static __INLINE arm_status arm_sqrt_f32(\r
6096   float32_t in,\r
6097   float32_t * pOut)\r
6098   {\r
6099     if(in > 0)\r
6100     {\r
6101 \r
6102 //      #if __FPU_USED\r
6103 #if (__FPU_USED == 1) && defined ( __CC_ARM   )\r
6104       *pOut = __sqrtf(in);\r
6105 #else\r
6106       *pOut = sqrtf(in);\r
6107 #endif\r
6108 \r
6109       return (ARM_MATH_SUCCESS);\r
6110     }\r
6111     else\r
6112     {\r
6113       *pOut = 0.0f;\r
6114       return (ARM_MATH_ARGUMENT_ERROR);\r
6115     }\r
6116 \r
6117   }\r
6118 \r
6119 \r
6120   /**\r
6121    * @brief Q31 square root function.\r
6122    * @param[in]   in    input value.  The range of the input value is [0 +1) or 0x00000000 to 0x7FFFFFFF.\r
6123    * @param[out]  *pOut square root of input value.\r
6124    * @return The function returns ARM_MATH_SUCCESS if input value is positive value or ARM_MATH_ARGUMENT_ERROR if\r
6125    * <code>in</code> is negative value and returns zero output for negative values.\r
6126    */\r
6127   arm_status arm_sqrt_q31(\r
6128   q31_t in,\r
6129   q31_t * pOut);\r
6130 \r
6131   /**\r
6132    * @brief  Q15 square root function.\r
6133    * @param[in]   in     input value.  The range of the input value is [0 +1) or 0x0000 to 0x7FFF.\r
6134    * @param[out]  *pOut  square root of input value.\r
6135    * @return The function returns ARM_MATH_SUCCESS if input value is positive value or ARM_MATH_ARGUMENT_ERROR if\r
6136    * <code>in</code> is negative value and returns zero output for negative values.\r
6137    */\r
6138   arm_status arm_sqrt_q15(\r
6139   q15_t in,\r
6140   q15_t * pOut);\r
6141 \r
6142   /**\r
6143    * @} end of SQRT group\r
6144    */\r
6145 \r
6146 \r
6147 \r
6148 \r
6149 \r
6150 \r
6151   /**\r
6152    * @brief floating-point Circular write function.\r
6153    */\r
6154 \r
6155   static __INLINE void arm_circularWrite_f32(\r
6156   int32_t * circBuffer,\r
6157   int32_t L,\r
6158   uint16_t * writeOffset,\r
6159   int32_t bufferInc,\r
6160   const int32_t * src,\r
6161   int32_t srcInc,\r
6162   uint32_t blockSize)\r
6163   {\r
6164     uint32_t i = 0u;\r
6165     int32_t wOffset;\r
6166 \r
6167     /* Copy the value of Index pointer that points\r
6168      * to the current location where the input samples to be copied */\r
6169     wOffset = *writeOffset;\r
6170 \r
6171     /* Loop over the blockSize */\r
6172     i = blockSize;\r
6173 \r
6174     while(i > 0u)\r
6175     {\r
6176       /* copy the input sample to the circular buffer */\r
6177       circBuffer[wOffset] = *src;\r
6178 \r
6179       /* Update the input pointer */\r
6180       src += srcInc;\r
6181 \r
6182       /* Circularly update wOffset.  Watch out for positive and negative value */\r
6183       wOffset += bufferInc;\r
6184       if(wOffset >= L)\r
6185         wOffset -= L;\r
6186 \r
6187       /* Decrement the loop counter */\r
6188       i--;\r
6189     }\r
6190 \r
6191     /* Update the index pointer */\r
6192     *writeOffset = wOffset;\r
6193   }\r
6194 \r
6195 \r
6196 \r
6197   /**\r
6198    * @brief floating-point Circular Read function.\r
6199    */\r
6200   static __INLINE void arm_circularRead_f32(\r
6201   int32_t * circBuffer,\r
6202   int32_t L,\r
6203   int32_t * readOffset,\r
6204   int32_t bufferInc,\r
6205   int32_t * dst,\r
6206   int32_t * dst_base,\r
6207   int32_t dst_length,\r
6208   int32_t dstInc,\r
6209   uint32_t blockSize)\r
6210   {\r
6211     uint32_t i = 0u;\r
6212     int32_t rOffset, dst_end;\r
6213 \r
6214     /* Copy the value of Index pointer that points\r
6215      * to the current location from where the input samples to be read */\r
6216     rOffset = *readOffset;\r
6217     dst_end = (int32_t) (dst_base + dst_length);\r
6218 \r
6219     /* Loop over the blockSize */\r
6220     i = blockSize;\r
6221 \r
6222     while(i > 0u)\r
6223     {\r
6224       /* copy the sample from the circular buffer to the destination buffer */\r
6225       *dst = circBuffer[rOffset];\r
6226 \r
6227       /* Update the input pointer */\r
6228       dst += dstInc;\r
6229 \r
6230       if(dst == (int32_t *) dst_end)\r
6231       {\r
6232         dst = dst_base;\r
6233       }\r
6234 \r
6235       /* Circularly update rOffset.  Watch out for positive and negative value  */\r
6236       rOffset += bufferInc;\r
6237 \r
6238       if(rOffset >= L)\r
6239       {\r
6240         rOffset -= L;\r
6241       }\r
6242 \r
6243       /* Decrement the loop counter */\r
6244       i--;\r
6245     }\r
6246 \r
6247     /* Update the index pointer */\r
6248     *readOffset = rOffset;\r
6249   }\r
6250 \r
6251   /**\r
6252    * @brief Q15 Circular write function.\r
6253    */\r
6254 \r
6255   static __INLINE void arm_circularWrite_q15(\r
6256   q15_t * circBuffer,\r
6257   int32_t L,\r
6258   uint16_t * writeOffset,\r
6259   int32_t bufferInc,\r
6260   const q15_t * src,\r
6261   int32_t srcInc,\r
6262   uint32_t blockSize)\r
6263   {\r
6264     uint32_t i = 0u;\r
6265     int32_t wOffset;\r
6266 \r
6267     /* Copy the value of Index pointer that points\r
6268      * to the current location where the input samples to be copied */\r
6269     wOffset = *writeOffset;\r
6270 \r
6271     /* Loop over the blockSize */\r
6272     i = blockSize;\r
6273 \r
6274     while(i > 0u)\r
6275     {\r
6276       /* copy the input sample to the circular buffer */\r
6277       circBuffer[wOffset] = *src;\r
6278 \r
6279       /* Update the input pointer */\r
6280       src += srcInc;\r
6281 \r
6282       /* Circularly update wOffset.  Watch out for positive and negative value */\r
6283       wOffset += bufferInc;\r
6284       if(wOffset >= L)\r
6285         wOffset -= L;\r
6286 \r
6287       /* Decrement the loop counter */\r
6288       i--;\r
6289     }\r
6290 \r
6291     /* Update the index pointer */\r
6292     *writeOffset = wOffset;\r
6293   }\r
6294 \r
6295 \r
6296 \r
6297   /**\r
6298    * @brief Q15 Circular Read function.\r
6299    */\r
6300   static __INLINE void arm_circularRead_q15(\r
6301   q15_t * circBuffer,\r
6302   int32_t L,\r
6303   int32_t * readOffset,\r
6304   int32_t bufferInc,\r
6305   q15_t * dst,\r
6306   q15_t * dst_base,\r
6307   int32_t dst_length,\r
6308   int32_t dstInc,\r
6309   uint32_t blockSize)\r
6310   {\r
6311     uint32_t i = 0;\r
6312     int32_t rOffset, dst_end;\r
6313 \r
6314     /* Copy the value of Index pointer that points\r
6315      * to the current location from where the input samples to be read */\r
6316     rOffset = *readOffset;\r
6317 \r
6318     dst_end = (int32_t) (dst_base + dst_length);\r
6319 \r
6320     /* Loop over the blockSize */\r
6321     i = blockSize;\r
6322 \r
6323     while(i > 0u)\r
6324     {\r
6325       /* copy the sample from the circular buffer to the destination buffer */\r
6326       *dst = circBuffer[rOffset];\r
6327 \r
6328       /* Update the input pointer */\r
6329       dst += dstInc;\r
6330 \r
6331       if(dst == (q15_t *) dst_end)\r
6332       {\r
6333         dst = dst_base;\r
6334       }\r
6335 \r
6336       /* Circularly update wOffset.  Watch out for positive and negative value */\r
6337       rOffset += bufferInc;\r
6338 \r
6339       if(rOffset >= L)\r
6340       {\r
6341         rOffset -= L;\r
6342       }\r
6343 \r
6344       /* Decrement the loop counter */\r
6345       i--;\r
6346     }\r
6347 \r
6348     /* Update the index pointer */\r
6349     *readOffset = rOffset;\r
6350   }\r
6351 \r
6352 \r
6353   /**\r
6354    * @brief Q7 Circular write function.\r
6355    */\r
6356 \r
6357   static __INLINE void arm_circularWrite_q7(\r
6358   q7_t * circBuffer,\r
6359   int32_t L,\r
6360   uint16_t * writeOffset,\r
6361   int32_t bufferInc,\r
6362   const q7_t * src,\r
6363   int32_t srcInc,\r
6364   uint32_t blockSize)\r
6365   {\r
6366     uint32_t i = 0u;\r
6367     int32_t wOffset;\r
6368 \r
6369     /* Copy the value of Index pointer that points\r
6370      * to the current location where the input samples to be copied */\r
6371     wOffset = *writeOffset;\r
6372 \r
6373     /* Loop over the blockSize */\r
6374     i = blockSize;\r
6375 \r
6376     while(i > 0u)\r
6377     {\r
6378       /* copy the input sample to the circular buffer */\r
6379       circBuffer[wOffset] = *src;\r
6380 \r
6381       /* Update the input pointer */\r
6382       src += srcInc;\r
6383 \r
6384       /* Circularly update wOffset.  Watch out for positive and negative value */\r
6385       wOffset += bufferInc;\r
6386       if(wOffset >= L)\r
6387         wOffset -= L;\r
6388 \r
6389       /* Decrement the loop counter */\r
6390       i--;\r
6391     }\r
6392 \r
6393     /* Update the index pointer */\r
6394     *writeOffset = wOffset;\r
6395   }\r
6396 \r
6397 \r
6398 \r
6399   /**\r
6400    * @brief Q7 Circular Read function.\r
6401    */\r
6402   static __INLINE void arm_circularRead_q7(\r
6403   q7_t * circBuffer,\r
6404   int32_t L,\r
6405   int32_t * readOffset,\r
6406   int32_t bufferInc,\r
6407   q7_t * dst,\r
6408   q7_t * dst_base,\r
6409   int32_t dst_length,\r
6410   int32_t dstInc,\r
6411   uint32_t blockSize)\r
6412   {\r
6413     uint32_t i = 0;\r
6414     int32_t rOffset, dst_end;\r
6415 \r
6416     /* Copy the value of Index pointer that points\r
6417      * to the current location from where the input samples to be read */\r
6418     rOffset = *readOffset;\r
6419 \r
6420     dst_end = (int32_t) (dst_base + dst_length);\r
6421 \r
6422     /* Loop over the blockSize */\r
6423     i = blockSize;\r
6424 \r
6425     while(i > 0u)\r
6426     {\r
6427       /* copy the sample from the circular buffer to the destination buffer */\r
6428       *dst = circBuffer[rOffset];\r
6429 \r
6430       /* Update the input pointer */\r
6431       dst += dstInc;\r
6432 \r
6433       if(dst == (q7_t *) dst_end)\r
6434       {\r
6435         dst = dst_base;\r
6436       }\r
6437 \r
6438       /* Circularly update rOffset.  Watch out for positive and negative value */\r
6439       rOffset += bufferInc;\r
6440 \r
6441       if(rOffset >= L)\r
6442       {\r
6443         rOffset -= L;\r
6444       }\r
6445 \r
6446       /* Decrement the loop counter */\r
6447       i--;\r
6448     }\r
6449 \r
6450     /* Update the index pointer */\r
6451     *readOffset = rOffset;\r
6452   }\r
6453 \r
6454 \r
6455   /**\r
6456    * @brief  Sum of the squares of the elements of a Q31 vector.\r
6457    * @param[in]  *pSrc is input pointer\r
6458    * @param[in]  blockSize is the number of samples to process\r
6459    * @param[out]  *pResult is output value.\r
6460    * @return none.\r
6461    */\r
6462 \r
6463   void arm_power_q31(\r
6464   q31_t * pSrc,\r
6465   uint32_t blockSize,\r
6466   q63_t * pResult);\r
6467 \r
6468   /**\r
6469    * @brief  Sum of the squares of the elements of a floating-point vector.\r
6470    * @param[in]  *pSrc is input pointer\r
6471    * @param[in]  blockSize is the number of samples to process\r
6472    * @param[out]  *pResult is output value.\r
6473    * @return none.\r
6474    */\r
6475 \r
6476   void arm_power_f32(\r
6477   float32_t * pSrc,\r
6478   uint32_t blockSize,\r
6479   float32_t * pResult);\r
6480 \r
6481   /**\r
6482    * @brief  Sum of the squares of the elements of a Q15 vector.\r
6483    * @param[in]  *pSrc is input pointer\r
6484    * @param[in]  blockSize is the number of samples to process\r
6485    * @param[out]  *pResult is output value.\r
6486    * @return none.\r
6487    */\r
6488 \r
6489   void arm_power_q15(\r
6490   q15_t * pSrc,\r
6491   uint32_t blockSize,\r
6492   q63_t * pResult);\r
6493 \r
6494   /**\r
6495    * @brief  Sum of the squares of the elements of a Q7 vector.\r
6496    * @param[in]  *pSrc is input pointer\r
6497    * @param[in]  blockSize is the number of samples to process\r
6498    * @param[out]  *pResult is output value.\r
6499    * @return none.\r
6500    */\r
6501 \r
6502   void arm_power_q7(\r
6503   q7_t * pSrc,\r
6504   uint32_t blockSize,\r
6505   q31_t * pResult);\r
6506 \r
6507   /**\r
6508    * @brief  Mean value of a Q7 vector.\r
6509    * @param[in]  *pSrc is input pointer\r
6510    * @param[in]  blockSize is the number of samples to process\r
6511    * @param[out]  *pResult is output value.\r
6512    * @return none.\r
6513    */\r
6514 \r
6515   void arm_mean_q7(\r
6516   q7_t * pSrc,\r
6517   uint32_t blockSize,\r
6518   q7_t * pResult);\r
6519 \r
6520   /**\r
6521    * @brief  Mean value of a Q15 vector.\r
6522    * @param[in]  *pSrc is input pointer\r
6523    * @param[in]  blockSize is the number of samples to process\r
6524    * @param[out]  *pResult is output value.\r
6525    * @return none.\r
6526    */\r
6527   void arm_mean_q15(\r
6528   q15_t * pSrc,\r
6529   uint32_t blockSize,\r
6530   q15_t * pResult);\r
6531 \r
6532   /**\r
6533    * @brief  Mean value of a Q31 vector.\r
6534    * @param[in]  *pSrc is input pointer\r
6535    * @param[in]  blockSize is the number of samples to process\r
6536    * @param[out]  *pResult is output value.\r
6537    * @return none.\r
6538    */\r
6539   void arm_mean_q31(\r
6540   q31_t * pSrc,\r
6541   uint32_t blockSize,\r
6542   q31_t * pResult);\r
6543 \r
6544   /**\r
6545    * @brief  Mean value of a floating-point vector.\r
6546    * @param[in]  *pSrc is input pointer\r
6547    * @param[in]  blockSize is the number of samples to process\r
6548    * @param[out]  *pResult is output value.\r
6549    * @return none.\r
6550    */\r
6551   void arm_mean_f32(\r
6552   float32_t * pSrc,\r
6553   uint32_t blockSize,\r
6554   float32_t * pResult);\r
6555 \r
6556   /**\r
6557    * @brief  Variance of the elements of a floating-point vector.\r
6558    * @param[in]  *pSrc is input pointer\r
6559    * @param[in]  blockSize is the number of samples to process\r
6560    * @param[out]  *pResult is output value.\r
6561    * @return none.\r
6562    */\r
6563 \r
6564   void arm_var_f32(\r
6565   float32_t * pSrc,\r
6566   uint32_t blockSize,\r
6567   float32_t * pResult);\r
6568 \r
6569   /**\r
6570    * @brief  Variance of the elements of a Q31 vector.\r
6571    * @param[in]  *pSrc is input pointer\r
6572    * @param[in]  blockSize is the number of samples to process\r
6573    * @param[out]  *pResult is output value.\r
6574    * @return none.\r
6575    */\r
6576 \r
6577   void arm_var_q31(\r
6578   q31_t * pSrc,\r
6579   uint32_t blockSize,\r
6580   q31_t * pResult);\r
6581 \r
6582   /**\r
6583    * @brief  Variance of the elements of a Q15 vector.\r
6584    * @param[in]  *pSrc is input pointer\r
6585    * @param[in]  blockSize is the number of samples to process\r
6586    * @param[out]  *pResult is output value.\r
6587    * @return none.\r
6588    */\r
6589 \r
6590   void arm_var_q15(\r
6591   q15_t * pSrc,\r
6592   uint32_t blockSize,\r
6593   q15_t * pResult);\r
6594 \r
6595   /**\r
6596    * @brief  Root Mean Square of the elements of a floating-point vector.\r
6597    * @param[in]  *pSrc is input pointer\r
6598    * @param[in]  blockSize is the number of samples to process\r
6599    * @param[out]  *pResult is output value.\r
6600    * @return none.\r
6601    */\r
6602 \r
6603   void arm_rms_f32(\r
6604   float32_t * pSrc,\r
6605   uint32_t blockSize,\r
6606   float32_t * pResult);\r
6607 \r
6608   /**\r
6609    * @brief  Root Mean Square of the elements of a Q31 vector.\r
6610    * @param[in]  *pSrc is input pointer\r
6611    * @param[in]  blockSize is the number of samples to process\r
6612    * @param[out]  *pResult is output value.\r
6613    * @return none.\r
6614    */\r
6615 \r
6616   void arm_rms_q31(\r
6617   q31_t * pSrc,\r
6618   uint32_t blockSize,\r
6619   q31_t * pResult);\r
6620 \r
6621   /**\r
6622    * @brief  Root Mean Square of the elements of a Q15 vector.\r
6623    * @param[in]  *pSrc is input pointer\r
6624    * @param[in]  blockSize is the number of samples to process\r
6625    * @param[out]  *pResult is output value.\r
6626    * @return none.\r
6627    */\r
6628 \r
6629   void arm_rms_q15(\r
6630   q15_t * pSrc,\r
6631   uint32_t blockSize,\r
6632   q15_t * pResult);\r
6633 \r
6634   /**\r
6635    * @brief  Standard deviation of the elements of a floating-point vector.\r
6636    * @param[in]  *pSrc is input pointer\r
6637    * @param[in]  blockSize is the number of samples to process\r
6638    * @param[out]  *pResult is output value.\r
6639    * @return none.\r
6640    */\r
6641 \r
6642   void arm_std_f32(\r
6643   float32_t * pSrc,\r
6644   uint32_t blockSize,\r
6645   float32_t * pResult);\r
6646 \r
6647   /**\r
6648    * @brief  Standard deviation of the elements of a Q31 vector.\r
6649    * @param[in]  *pSrc is input pointer\r
6650    * @param[in]  blockSize is the number of samples to process\r
6651    * @param[out]  *pResult is output value.\r
6652    * @return none.\r
6653    */\r
6654 \r
6655   void arm_std_q31(\r
6656   q31_t * pSrc,\r
6657   uint32_t blockSize,\r
6658   q31_t * pResult);\r
6659 \r
6660   /**\r
6661    * @brief  Standard deviation of the elements of a Q15 vector.\r
6662    * @param[in]  *pSrc is input pointer\r
6663    * @param[in]  blockSize is the number of samples to process\r
6664    * @param[out]  *pResult is output value.\r
6665    * @return none.\r
6666    */\r
6667 \r
6668   void arm_std_q15(\r
6669   q15_t * pSrc,\r
6670   uint32_t blockSize,\r
6671   q15_t * pResult);\r
6672 \r
6673   /**\r
6674    * @brief  Floating-point complex magnitude\r
6675    * @param[in]  *pSrc points to the complex input vector\r
6676    * @param[out]  *pDst points to the real output vector\r
6677    * @param[in]  numSamples number of complex samples in the input vector\r
6678    * @return none.\r
6679    */\r
6680 \r
6681   void arm_cmplx_mag_f32(\r
6682   float32_t * pSrc,\r
6683   float32_t * pDst,\r
6684   uint32_t numSamples);\r
6685 \r
6686   /**\r
6687    * @brief  Q31 complex magnitude\r
6688    * @param[in]  *pSrc points to the complex input vector\r
6689    * @param[out]  *pDst points to the real output vector\r
6690    * @param[in]  numSamples number of complex samples in the input vector\r
6691    * @return none.\r
6692    */\r
6693 \r
6694   void arm_cmplx_mag_q31(\r
6695   q31_t * pSrc,\r
6696   q31_t * pDst,\r
6697   uint32_t numSamples);\r
6698 \r
6699   /**\r
6700    * @brief  Q15 complex magnitude\r
6701    * @param[in]  *pSrc points to the complex input vector\r
6702    * @param[out]  *pDst points to the real output vector\r
6703    * @param[in]  numSamples number of complex samples in the input vector\r
6704    * @return none.\r
6705    */\r
6706 \r
6707   void arm_cmplx_mag_q15(\r
6708   q15_t * pSrc,\r
6709   q15_t * pDst,\r
6710   uint32_t numSamples);\r
6711 \r
6712   /**\r
6713    * @brief  Q15 complex dot product\r
6714    * @param[in]  *pSrcA points to the first input vector\r
6715    * @param[in]  *pSrcB points to the second input vector\r
6716    * @param[in]  numSamples number of complex samples in each vector\r
6717    * @param[out]  *realResult real part of the result returned here\r
6718    * @param[out]  *imagResult imaginary part of the result returned here\r
6719    * @return none.\r
6720    */\r
6721 \r
6722   void arm_cmplx_dot_prod_q15(\r
6723   q15_t * pSrcA,\r
6724   q15_t * pSrcB,\r
6725   uint32_t numSamples,\r
6726   q31_t * realResult,\r
6727   q31_t * imagResult);\r
6728 \r
6729   /**\r
6730    * @brief  Q31 complex dot product\r
6731    * @param[in]  *pSrcA points to the first input vector\r
6732    * @param[in]  *pSrcB points to the second input vector\r
6733    * @param[in]  numSamples number of complex samples in each vector\r
6734    * @param[out]  *realResult real part of the result returned here\r
6735    * @param[out]  *imagResult imaginary part of the result returned here\r
6736    * @return none.\r
6737    */\r
6738 \r
6739   void arm_cmplx_dot_prod_q31(\r
6740   q31_t * pSrcA,\r
6741   q31_t * pSrcB,\r
6742   uint32_t numSamples,\r
6743   q63_t * realResult,\r
6744   q63_t * imagResult);\r
6745 \r
6746   /**\r
6747    * @brief  Floating-point complex dot product\r
6748    * @param[in]  *pSrcA points to the first input vector\r
6749    * @param[in]  *pSrcB points to the second input vector\r
6750    * @param[in]  numSamples number of complex samples in each vector\r
6751    * @param[out]  *realResult real part of the result returned here\r
6752    * @param[out]  *imagResult imaginary part of the result returned here\r
6753    * @return none.\r
6754    */\r
6755 \r
6756   void arm_cmplx_dot_prod_f32(\r
6757   float32_t * pSrcA,\r
6758   float32_t * pSrcB,\r
6759   uint32_t numSamples,\r
6760   float32_t * realResult,\r
6761   float32_t * imagResult);\r
6762 \r
6763   /**\r
6764    * @brief  Q15 complex-by-real multiplication\r
6765    * @param[in]  *pSrcCmplx points to the complex input vector\r
6766    * @param[in]  *pSrcReal points to the real input vector\r
6767    * @param[out]  *pCmplxDst points to the complex output vector\r
6768    * @param[in]  numSamples number of samples in each vector\r
6769    * @return none.\r
6770    */\r
6771 \r
6772   void arm_cmplx_mult_real_q15(\r
6773   q15_t * pSrcCmplx,\r
6774   q15_t * pSrcReal,\r
6775   q15_t * pCmplxDst,\r
6776   uint32_t numSamples);\r
6777 \r
6778   /**\r
6779    * @brief  Q31 complex-by-real multiplication\r
6780    * @param[in]  *pSrcCmplx points to the complex input vector\r
6781    * @param[in]  *pSrcReal points to the real input vector\r
6782    * @param[out]  *pCmplxDst points to the complex output vector\r
6783    * @param[in]  numSamples number of samples in each vector\r
6784    * @return none.\r
6785    */\r
6786 \r
6787   void arm_cmplx_mult_real_q31(\r
6788   q31_t * pSrcCmplx,\r
6789   q31_t * pSrcReal,\r
6790   q31_t * pCmplxDst,\r
6791   uint32_t numSamples);\r
6792 \r
6793   /**\r
6794    * @brief  Floating-point complex-by-real multiplication\r
6795    * @param[in]  *pSrcCmplx points to the complex input vector\r
6796    * @param[in]  *pSrcReal points to the real input vector\r
6797    * @param[out]  *pCmplxDst points to the complex output vector\r
6798    * @param[in]  numSamples number of samples in each vector\r
6799    * @return none.\r
6800    */\r
6801 \r
6802   void arm_cmplx_mult_real_f32(\r
6803   float32_t * pSrcCmplx,\r
6804   float32_t * pSrcReal,\r
6805   float32_t * pCmplxDst,\r
6806   uint32_t numSamples);\r
6807 \r
6808   /**\r
6809    * @brief  Minimum value of a Q7 vector.\r
6810    * @param[in]  *pSrc is input pointer\r
6811    * @param[in]  blockSize is the number of samples to process\r
6812    * @param[out]  *result is output pointer\r
6813    * @param[in]  index is the array index of the minimum value in the input buffer.\r
6814    * @return none.\r
6815    */\r
6816 \r
6817   void arm_min_q7(\r
6818   q7_t * pSrc,\r
6819   uint32_t blockSize,\r
6820   q7_t * result,\r
6821   uint32_t * index);\r
6822 \r
6823   /**\r
6824    * @brief  Minimum value of a Q15 vector.\r
6825    * @param[in]  *pSrc is input pointer\r
6826    * @param[in]  blockSize is the number of samples to process\r
6827    * @param[out]  *pResult is output pointer\r
6828    * @param[in]  *pIndex is the array index of the minimum value in the input buffer.\r
6829    * @return none.\r
6830    */\r
6831 \r
6832   void arm_min_q15(\r
6833   q15_t * pSrc,\r
6834   uint32_t blockSize,\r
6835   q15_t * pResult,\r
6836   uint32_t * pIndex);\r
6837 \r
6838   /**\r
6839    * @brief  Minimum value of a Q31 vector.\r
6840    * @param[in]  *pSrc is input pointer\r
6841    * @param[in]  blockSize is the number of samples to process\r
6842    * @param[out]  *pResult is output pointer\r
6843    * @param[out]  *pIndex is the array index of the minimum value in the input buffer.\r
6844    * @return none.\r
6845    */\r
6846   void arm_min_q31(\r
6847   q31_t * pSrc,\r
6848   uint32_t blockSize,\r
6849   q31_t * pResult,\r
6850   uint32_t * pIndex);\r
6851 \r
6852   /**\r
6853    * @brief  Minimum value of a floating-point vector.\r
6854    * @param[in]  *pSrc is input pointer\r
6855    * @param[in]  blockSize is the number of samples to process\r
6856    * @param[out]  *pResult is output pointer\r
6857    * @param[out]  *pIndex is the array index of the minimum value in the input buffer.\r
6858    * @return none.\r
6859    */\r
6860 \r
6861   void arm_min_f32(\r
6862   float32_t * pSrc,\r
6863   uint32_t blockSize,\r
6864   float32_t * pResult,\r
6865   uint32_t * pIndex);\r
6866 \r
6867 /**\r
6868  * @brief Maximum value of a Q7 vector.\r
6869  * @param[in]       *pSrc points to the input buffer\r
6870  * @param[in]       blockSize length of the input vector\r
6871  * @param[out]      *pResult maximum value returned here\r
6872  * @param[out]      *pIndex index of maximum value returned here\r
6873  * @return none.\r
6874  */\r
6875 \r
6876   void arm_max_q7(\r
6877   q7_t * pSrc,\r
6878   uint32_t blockSize,\r
6879   q7_t * pResult,\r
6880   uint32_t * pIndex);\r
6881 \r
6882 /**\r
6883  * @brief Maximum value of a Q15 vector.\r
6884  * @param[in]       *pSrc points to the input buffer\r
6885  * @param[in]       blockSize length of the input vector\r
6886  * @param[out]      *pResult maximum value returned here\r
6887  * @param[out]      *pIndex index of maximum value returned here\r
6888  * @return none.\r
6889  */\r
6890 \r
6891   void arm_max_q15(\r
6892   q15_t * pSrc,\r
6893   uint32_t blockSize,\r
6894   q15_t * pResult,\r
6895   uint32_t * pIndex);\r
6896 \r
6897 /**\r
6898  * @brief Maximum value of a Q31 vector.\r
6899  * @param[in]       *pSrc points to the input buffer\r
6900  * @param[in]       blockSize length of the input vector\r
6901  * @param[out]      *pResult maximum value returned here\r
6902  * @param[out]      *pIndex index of maximum value returned here\r
6903  * @return none.\r
6904  */\r
6905 \r
6906   void arm_max_q31(\r
6907   q31_t * pSrc,\r
6908   uint32_t blockSize,\r
6909   q31_t * pResult,\r
6910   uint32_t * pIndex);\r
6911 \r
6912 /**\r
6913  * @brief Maximum value of a floating-point vector.\r
6914  * @param[in]       *pSrc points to the input buffer\r
6915  * @param[in]       blockSize length of the input vector\r
6916  * @param[out]      *pResult maximum value returned here\r
6917  * @param[out]      *pIndex index of maximum value returned here\r
6918  * @return none.\r
6919  */\r
6920 \r
6921   void arm_max_f32(\r
6922   float32_t * pSrc,\r
6923   uint32_t blockSize,\r
6924   float32_t * pResult,\r
6925   uint32_t * pIndex);\r
6926 \r
6927   /**\r
6928    * @brief  Q15 complex-by-complex multiplication\r
6929    * @param[in]  *pSrcA points to the first input vector\r
6930    * @param[in]  *pSrcB points to the second input vector\r
6931    * @param[out]  *pDst  points to the output vector\r
6932    * @param[in]  numSamples number of complex samples in each vector\r
6933    * @return none.\r
6934    */\r
6935 \r
6936   void arm_cmplx_mult_cmplx_q15(\r
6937   q15_t * pSrcA,\r
6938   q15_t * pSrcB,\r
6939   q15_t * pDst,\r
6940   uint32_t numSamples);\r
6941 \r
6942   /**\r
6943    * @brief  Q31 complex-by-complex multiplication\r
6944    * @param[in]  *pSrcA points to the first input vector\r
6945    * @param[in]  *pSrcB points to the second input vector\r
6946    * @param[out]  *pDst  points to the output vector\r
6947    * @param[in]  numSamples number of complex samples in each vector\r
6948    * @return none.\r
6949    */\r
6950 \r
6951   void arm_cmplx_mult_cmplx_q31(\r
6952   q31_t * pSrcA,\r
6953   q31_t * pSrcB,\r
6954   q31_t * pDst,\r
6955   uint32_t numSamples);\r
6956 \r
6957   /**\r
6958    * @brief  Floating-point complex-by-complex multiplication\r
6959    * @param[in]  *pSrcA points to the first input vector\r
6960    * @param[in]  *pSrcB points to the second input vector\r
6961    * @param[out]  *pDst  points to the output vector\r
6962    * @param[in]  numSamples number of complex samples in each vector\r
6963    * @return none.\r
6964    */\r
6965 \r
6966   void arm_cmplx_mult_cmplx_f32(\r
6967   float32_t * pSrcA,\r
6968   float32_t * pSrcB,\r
6969   float32_t * pDst,\r
6970   uint32_t numSamples);\r
6971 \r
6972   /**\r
6973    * @brief Converts the elements of the floating-point vector to Q31 vector.\r
6974    * @param[in]       *pSrc points to the floating-point input vector\r
6975    * @param[out]      *pDst points to the Q31 output vector\r
6976    * @param[in]       blockSize length of the input vector\r
6977    * @return none.\r
6978    */\r
6979   void arm_float_to_q31(\r
6980   float32_t * pSrc,\r
6981   q31_t * pDst,\r
6982   uint32_t blockSize);\r
6983 \r
6984   /**\r
6985    * @brief Converts the elements of the floating-point vector to Q15 vector.\r
6986    * @param[in]       *pSrc points to the floating-point input vector\r
6987    * @param[out]      *pDst points to the Q15 output vector\r
6988    * @param[in]       blockSize length of the input vector\r
6989    * @return          none\r
6990    */\r
6991   void arm_float_to_q15(\r
6992   float32_t * pSrc,\r
6993   q15_t * pDst,\r
6994   uint32_t blockSize);\r
6995 \r
6996   /**\r
6997    * @brief Converts the elements of the floating-point vector to Q7 vector.\r
6998    * @param[in]       *pSrc points to the floating-point input vector\r
6999    * @param[out]      *pDst points to the Q7 output vector\r
7000    * @param[in]       blockSize length of the input vector\r
7001    * @return          none\r
7002    */\r
7003   void arm_float_to_q7(\r
7004   float32_t * pSrc,\r
7005   q7_t * pDst,\r
7006   uint32_t blockSize);\r
7007 \r
7008 \r
7009   /**\r
7010    * @brief  Converts the elements of the Q31 vector to Q15 vector.\r
7011    * @param[in]  *pSrc is input pointer\r
7012    * @param[out]  *pDst is output pointer\r
7013    * @param[in]  blockSize is the number of samples to process\r
7014    * @return none.\r
7015    */\r
7016   void arm_q31_to_q15(\r
7017   q31_t * pSrc,\r
7018   q15_t * pDst,\r
7019   uint32_t blockSize);\r
7020 \r
7021   /**\r
7022    * @brief  Converts the elements of the Q31 vector to Q7 vector.\r
7023    * @param[in]  *pSrc is input pointer\r
7024    * @param[out]  *pDst is output pointer\r
7025    * @param[in]  blockSize is the number of samples to process\r
7026    * @return none.\r
7027    */\r
7028   void arm_q31_to_q7(\r
7029   q31_t * pSrc,\r
7030   q7_t * pDst,\r
7031   uint32_t blockSize);\r
7032 \r
7033   /**\r
7034    * @brief  Converts the elements of the Q15 vector to floating-point vector.\r
7035    * @param[in]  *pSrc is input pointer\r
7036    * @param[out]  *pDst is output pointer\r
7037    * @param[in]  blockSize is the number of samples to process\r
7038    * @return none.\r
7039    */\r
7040   void arm_q15_to_float(\r
7041   q15_t * pSrc,\r
7042   float32_t * pDst,\r
7043   uint32_t blockSize);\r
7044 \r
7045 \r
7046   /**\r
7047    * @brief  Converts the elements of the Q15 vector to Q31 vector.\r
7048    * @param[in]  *pSrc is input pointer\r
7049    * @param[out]  *pDst is output pointer\r
7050    * @param[in]  blockSize is the number of samples to process\r
7051    * @return none.\r
7052    */\r
7053   void arm_q15_to_q31(\r
7054   q15_t * pSrc,\r
7055   q31_t * pDst,\r
7056   uint32_t blockSize);\r
7057 \r
7058 \r
7059   /**\r
7060    * @brief  Converts the elements of the Q15 vector to Q7 vector.\r
7061    * @param[in]  *pSrc is input pointer\r
7062    * @param[out]  *pDst is output pointer\r
7063    * @param[in]  blockSize is the number of samples to process\r
7064    * @return none.\r
7065    */\r
7066   void arm_q15_to_q7(\r
7067   q15_t * pSrc,\r
7068   q7_t * pDst,\r
7069   uint32_t blockSize);\r
7070 \r
7071 \r
7072   /**\r
7073    * @ingroup groupInterpolation\r
7074    */\r
7075 \r
7076   /**\r
7077    * @defgroup BilinearInterpolate Bilinear Interpolation\r
7078    *\r
7079    * Bilinear interpolation is an extension of linear interpolation applied to a two dimensional grid.\r
7080    * The underlying function <code>f(x, y)</code> is sampled on a regular grid and the interpolation process\r
7081    * determines values between the grid points.\r
7082    * Bilinear interpolation is equivalent to two step linear interpolation, first in the x-dimension and then in the y-dimension.\r
7083    * Bilinear interpolation is often used in image processing to rescale images.\r
7084    * The CMSIS DSP library provides bilinear interpolation functions for Q7, Q15, Q31, and floating-point data types.\r
7085    *\r
7086    * <b>Algorithm</b>\r
7087    * \par\r
7088    * The instance structure used by the bilinear interpolation functions describes a two dimensional data table.\r
7089    * For floating-point, the instance structure is defined as:\r
7090    * <pre>\r
7091    *   typedef struct\r
7092    *   {\r
7093    *     uint16_t numRows;\r
7094    *     uint16_t numCols;\r
7095    *     float32_t *pData;\r
7096    * } arm_bilinear_interp_instance_f32;\r
7097    * </pre>\r
7098    *\r
7099    * \par\r
7100    * where <code>numRows</code> specifies the number of rows in the table;\r
7101    * <code>numCols</code> specifies the number of columns in the table;\r
7102    * and <code>pData</code> points to an array of size <code>numRows*numCols</code> values.\r
7103    * The data table <code>pTable</code> is organized in row order and the supplied data values fall on integer indexes.\r
7104    * That is, table element (x,y) is located at <code>pTable[x + y*numCols]</code> where x and y are integers.\r
7105    *\r
7106    * \par\r
7107    * Let <code>(x, y)</code> specify the desired interpolation point.  Then define:\r
7108    * <pre>\r
7109    *     XF = floor(x)\r
7110    *     YF = floor(y)\r
7111    * </pre>\r
7112    * \par\r
7113    * The interpolated output point is computed as:\r
7114    * <pre>\r
7115    *  f(x, y) = f(XF, YF) * (1-(x-XF)) * (1-(y-YF))\r
7116    *           + f(XF+1, YF) * (x-XF)*(1-(y-YF))\r
7117    *           + f(XF, YF+1) * (1-(x-XF))*(y-YF)\r
7118    *           + f(XF+1, YF+1) * (x-XF)*(y-YF)\r
7119    * </pre>\r
7120    * Note that the coordinates (x, y) contain integer and fractional components.\r
7121    * The integer components specify which portion of the table to use while the\r
7122    * fractional components control the interpolation processor.\r
7123    *\r
7124    * \par\r
7125    * if (x,y) are outside of the table boundary, Bilinear interpolation returns zero output.\r
7126    */\r
7127 \r
7128   /**\r
7129    * @addtogroup BilinearInterpolate\r
7130    * @{\r
7131    */\r
7132 \r
7133   /**\r
7134   *\r
7135   * @brief  Floating-point bilinear interpolation.\r
7136   * @param[in,out] *S points to an instance of the interpolation structure.\r
7137   * @param[in] X interpolation coordinate.\r
7138   * @param[in] Y interpolation coordinate.\r
7139   * @return out interpolated value.\r
7140   */\r
7141 \r
7142 \r
7143   static __INLINE float32_t arm_bilinear_interp_f32(\r
7144   const arm_bilinear_interp_instance_f32 * S,\r
7145   float32_t X,\r
7146   float32_t Y)\r
7147   {\r
7148     float32_t out;\r
7149     float32_t f00, f01, f10, f11;\r
7150     float32_t *pData = S->pData;\r
7151     int32_t xIndex, yIndex, index;\r
7152     float32_t xdiff, ydiff;\r
7153     float32_t b1, b2, b3, b4;\r
7154 \r
7155     xIndex = (int32_t) X;\r
7156     yIndex = (int32_t) Y;\r
7157 \r
7158     /* Care taken for table outside boundary */\r
7159     /* Returns zero output when values are outside table boundary */\r
7160     if(xIndex < 0 || xIndex > (S->numRows - 1) || yIndex < 0\r
7161        || yIndex > (S->numCols - 1))\r
7162     {\r
7163       return (0);\r
7164     }\r
7165 \r
7166     /* Calculation of index for two nearest points in X-direction */\r
7167     index = (xIndex - 1) + (yIndex - 1) * S->numCols;\r
7168 \r
7169 \r
7170     /* Read two nearest points in X-direction */\r
7171     f00 = pData[index];\r
7172     f01 = pData[index + 1];\r
7173 \r
7174     /* Calculation of index for two nearest points in Y-direction */\r
7175     index = (xIndex - 1) + (yIndex) * S->numCols;\r
7176 \r
7177 \r
7178     /* Read two nearest points in Y-direction */\r
7179     f10 = pData[index];\r
7180     f11 = pData[index + 1];\r
7181 \r
7182     /* Calculation of intermediate values */\r
7183     b1 = f00;\r
7184     b2 = f01 - f00;\r
7185     b3 = f10 - f00;\r
7186     b4 = f00 - f01 - f10 + f11;\r
7187 \r
7188     /* Calculation of fractional part in X */\r
7189     xdiff = X - xIndex;\r
7190 \r
7191     /* Calculation of fractional part in Y */\r
7192     ydiff = Y - yIndex;\r
7193 \r
7194     /* Calculation of bi-linear interpolated output */\r
7195     out = b1 + b2 * xdiff + b3 * ydiff + b4 * xdiff * ydiff;\r
7196 \r
7197     /* return to application */\r
7198     return (out);\r
7199 \r
7200   }\r
7201 \r
7202   /**\r
7203   *\r
7204   * @brief  Q31 bilinear interpolation.\r
7205   * @param[in,out] *S points to an instance of the interpolation structure.\r
7206   * @param[in] X interpolation coordinate in 12.20 format.\r
7207   * @param[in] Y interpolation coordinate in 12.20 format.\r
7208   * @return out interpolated value.\r
7209   */\r
7210 \r
7211   static __INLINE q31_t arm_bilinear_interp_q31(\r
7212   arm_bilinear_interp_instance_q31 * S,\r
7213   q31_t X,\r
7214   q31_t Y)\r
7215   {\r
7216     q31_t out;                                   /* Temporary output */\r
7217     q31_t acc = 0;                               /* output */\r
7218     q31_t xfract, yfract;                        /* X, Y fractional parts */\r
7219     q31_t x1, x2, y1, y2;                        /* Nearest output values */\r
7220     int32_t rI, cI;                              /* Row and column indices */\r
7221     q31_t *pYData = S->pData;                    /* pointer to output table values */\r
7222     uint32_t nCols = S->numCols;                 /* num of rows */\r
7223 \r
7224 \r
7225     /* Input is in 12.20 format */\r
7226     /* 12 bits for the table index */\r
7227     /* Index value calculation */\r
7228     rI = ((X & 0xFFF00000) >> 20u);\r
7229 \r
7230     /* Input is in 12.20 format */\r
7231     /* 12 bits for the table index */\r
7232     /* Index value calculation */\r
7233     cI = ((Y & 0xFFF00000) >> 20u);\r
7234 \r
7235     /* Care taken for table outside boundary */\r
7236     /* Returns zero output when values are outside table boundary */\r
7237     if(rI < 0 || rI > (S->numRows - 1) || cI < 0 || cI > (S->numCols - 1))\r
7238     {\r
7239       return (0);\r
7240     }\r
7241 \r
7242     /* 20 bits for the fractional part */\r
7243     /* shift left xfract by 11 to keep 1.31 format */\r
7244     xfract = (X & 0x000FFFFF) << 11u;\r
7245 \r
7246     /* Read two nearest output values from the index */\r
7247     x1 = pYData[(rI) + nCols * (cI)];\r
7248     x2 = pYData[(rI) + nCols * (cI) + 1u];\r
7249 \r
7250     /* 20 bits for the fractional part */\r
7251     /* shift left yfract by 11 to keep 1.31 format */\r
7252     yfract = (Y & 0x000FFFFF) << 11u;\r
7253 \r
7254     /* Read two nearest output values from the index */\r
7255     y1 = pYData[(rI) + nCols * (cI + 1)];\r
7256     y2 = pYData[(rI) + nCols * (cI + 1) + 1u];\r
7257 \r
7258     /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 3.29(q29) format */\r
7259     out = ((q31_t) (((q63_t) x1 * (0x7FFFFFFF - xfract)) >> 32));\r
7260     acc = ((q31_t) (((q63_t) out * (0x7FFFFFFF - yfract)) >> 32));\r
7261 \r
7262     /* x2 * (xfract) * (1-yfract)  in 3.29(q29) and adding to acc */\r
7263     out = ((q31_t) ((q63_t) x2 * (0x7FFFFFFF - yfract) >> 32));\r
7264     acc += ((q31_t) ((q63_t) out * (xfract) >> 32));\r
7265 \r
7266     /* y1 * (1 - xfract) * (yfract)  in 3.29(q29) and adding to acc */\r
7267     out = ((q31_t) ((q63_t) y1 * (0x7FFFFFFF - xfract) >> 32));\r
7268     acc += ((q31_t) ((q63_t) out * (yfract) >> 32));\r
7269 \r
7270     /* y2 * (xfract) * (yfract)  in 3.29(q29) and adding to acc */\r
7271     out = ((q31_t) ((q63_t) y2 * (xfract) >> 32));\r
7272     acc += ((q31_t) ((q63_t) out * (yfract) >> 32));\r
7273 \r
7274     /* Convert acc to 1.31(q31) format */\r
7275     return (acc << 2u);\r
7276 \r
7277   }\r
7278 \r
7279   /**\r
7280   * @brief  Q15 bilinear interpolation.\r
7281   * @param[in,out] *S points to an instance of the interpolation structure.\r
7282   * @param[in] X interpolation coordinate in 12.20 format.\r
7283   * @param[in] Y interpolation coordinate in 12.20 format.\r
7284   * @return out interpolated value.\r
7285   */\r
7286 \r
7287   static __INLINE q15_t arm_bilinear_interp_q15(\r
7288   arm_bilinear_interp_instance_q15 * S,\r
7289   q31_t X,\r
7290   q31_t Y)\r
7291   {\r
7292     q63_t acc = 0;                               /* output */\r
7293     q31_t out;                                   /* Temporary output */\r
7294     q15_t x1, x2, y1, y2;                        /* Nearest output values */\r
7295     q31_t xfract, yfract;                        /* X, Y fractional parts */\r
7296     int32_t rI, cI;                              /* Row and column indices */\r
7297     q15_t *pYData = S->pData;                    /* pointer to output table values */\r
7298     uint32_t nCols = S->numCols;                 /* num of rows */\r
7299 \r
7300     /* Input is in 12.20 format */\r
7301     /* 12 bits for the table index */\r
7302     /* Index value calculation */\r
7303     rI = ((X & 0xFFF00000) >> 20);\r
7304 \r
7305     /* Input is in 12.20 format */\r
7306     /* 12 bits for the table index */\r
7307     /* Index value calculation */\r
7308     cI = ((Y & 0xFFF00000) >> 20);\r
7309 \r
7310     /* Care taken for table outside boundary */\r
7311     /* Returns zero output when values are outside table boundary */\r
7312     if(rI < 0 || rI > (S->numRows - 1) || cI < 0 || cI > (S->numCols - 1))\r
7313     {\r
7314       return (0);\r
7315     }\r
7316 \r
7317     /* 20 bits for the fractional part */\r
7318     /* xfract should be in 12.20 format */\r
7319     xfract = (X & 0x000FFFFF);\r
7320 \r
7321     /* Read two nearest output values from the index */\r
7322     x1 = pYData[(rI) + nCols * (cI)];\r
7323     x2 = pYData[(rI) + nCols * (cI) + 1u];\r
7324 \r
7325 \r
7326     /* 20 bits for the fractional part */\r
7327     /* yfract should be in 12.20 format */\r
7328     yfract = (Y & 0x000FFFFF);\r
7329 \r
7330     /* Read two nearest output values from the index */\r
7331     y1 = pYData[(rI) + nCols * (cI + 1)];\r
7332     y2 = pYData[(rI) + nCols * (cI + 1) + 1u];\r
7333 \r
7334     /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 13.51 format */\r
7335 \r
7336     /* x1 is in 1.15(q15), xfract in 12.20 format and out is in 13.35 format */\r
7337     /* convert 13.35 to 13.31 by right shifting  and out is in 1.31 */\r
7338     out = (q31_t) (((q63_t) x1 * (0xFFFFF - xfract)) >> 4u);\r
7339     acc = ((q63_t) out * (0xFFFFF - yfract));\r
7340 \r
7341     /* x2 * (xfract) * (1-yfract)  in 1.51 and adding to acc */\r
7342     out = (q31_t) (((q63_t) x2 * (0xFFFFF - yfract)) >> 4u);\r
7343     acc += ((q63_t) out * (xfract));\r
7344 \r
7345     /* y1 * (1 - xfract) * (yfract)  in 1.51 and adding to acc */\r
7346     out = (q31_t) (((q63_t) y1 * (0xFFFFF - xfract)) >> 4u);\r
7347     acc += ((q63_t) out * (yfract));\r
7348 \r
7349     /* y2 * (xfract) * (yfract)  in 1.51 and adding to acc */\r
7350     out = (q31_t) (((q63_t) y2 * (xfract)) >> 4u);\r
7351     acc += ((q63_t) out * (yfract));\r
7352 \r
7353     /* acc is in 13.51 format and down shift acc by 36 times */\r
7354     /* Convert out to 1.15 format */\r
7355     return (acc >> 36);\r
7356 \r
7357   }\r
7358 \r
7359   /**\r
7360   * @brief  Q7 bilinear interpolation.\r
7361   * @param[in,out] *S points to an instance of the interpolation structure.\r
7362   * @param[in] X interpolation coordinate in 12.20 format.\r
7363   * @param[in] Y interpolation coordinate in 12.20 format.\r
7364   * @return out interpolated value.\r
7365   */\r
7366 \r
7367   static __INLINE q7_t arm_bilinear_interp_q7(\r
7368   arm_bilinear_interp_instance_q7 * S,\r
7369   q31_t X,\r
7370   q31_t Y)\r
7371   {\r
7372     q63_t acc = 0;                               /* output */\r
7373     q31_t out;                                   /* Temporary output */\r
7374     q31_t xfract, yfract;                        /* X, Y fractional parts */\r
7375     q7_t x1, x2, y1, y2;                         /* Nearest output values */\r
7376     int32_t rI, cI;                              /* Row and column indices */\r
7377     q7_t *pYData = S->pData;                     /* pointer to output table values */\r
7378     uint32_t nCols = S->numCols;                 /* num of rows */\r
7379 \r
7380     /* Input is in 12.20 format */\r
7381     /* 12 bits for the table index */\r
7382     /* Index value calculation */\r
7383     rI = ((X & 0xFFF00000) >> 20);\r
7384 \r
7385     /* Input is in 12.20 format */\r
7386     /* 12 bits for the table index */\r
7387     /* Index value calculation */\r
7388     cI = ((Y & 0xFFF00000) >> 20);\r
7389 \r
7390     /* Care taken for table outside boundary */\r
7391     /* Returns zero output when values are outside table boundary */\r
7392     if(rI < 0 || rI > (S->numRows - 1) || cI < 0 || cI > (S->numCols - 1))\r
7393     {\r
7394       return (0);\r
7395     }\r
7396 \r
7397     /* 20 bits for the fractional part */\r
7398     /* xfract should be in 12.20 format */\r
7399     xfract = (X & 0x000FFFFF);\r
7400 \r
7401     /* Read two nearest output values from the index */\r
7402     x1 = pYData[(rI) + nCols * (cI)];\r
7403     x2 = pYData[(rI) + nCols * (cI) + 1u];\r
7404 \r
7405 \r
7406     /* 20 bits for the fractional part */\r
7407     /* yfract should be in 12.20 format */\r
7408     yfract = (Y & 0x000FFFFF);\r
7409 \r
7410     /* Read two nearest output values from the index */\r
7411     y1 = pYData[(rI) + nCols * (cI + 1)];\r
7412     y2 = pYData[(rI) + nCols * (cI + 1) + 1u];\r
7413 \r
7414     /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 16.47 format */\r
7415     out = ((x1 * (0xFFFFF - xfract)));\r
7416     acc = (((q63_t) out * (0xFFFFF - yfract)));\r
7417 \r
7418     /* x2 * (xfract) * (1-yfract)  in 2.22 and adding to acc */\r
7419     out = ((x2 * (0xFFFFF - yfract)));\r
7420     acc += (((q63_t) out * (xfract)));\r
7421 \r
7422     /* y1 * (1 - xfract) * (yfract)  in 2.22 and adding to acc */\r
7423     out = ((y1 * (0xFFFFF - xfract)));\r
7424     acc += (((q63_t) out * (yfract)));\r
7425 \r
7426     /* y2 * (xfract) * (yfract)  in 2.22 and adding to acc */\r
7427     out = ((y2 * (yfract)));\r
7428     acc += (((q63_t) out * (xfract)));\r
7429 \r
7430     /* acc in 16.47 format and down shift by 40 to convert to 1.7 format */\r
7431     return (acc >> 40);\r
7432 \r
7433   }\r
7434 \r
7435   /**\r
7436    * @} end of BilinearInterpolate group\r
7437    */\r
7438    \r
7439 \r
7440 //SMMLAR\r
7441 #define multAcc_32x32_keep32_R(a, x, y) \\r
7442     a = (q31_t) (((((q63_t) a) << 32) + ((q63_t) x * y) + 0x80000000LL ) >> 32)\r
7443 \r
7444 //SMMLSR\r
7445 #define multSub_32x32_keep32_R(a, x, y) \\r
7446     a = (q31_t) (((((q63_t) a) << 32) - ((q63_t) x * y) + 0x80000000LL ) >> 32)\r
7447 \r
7448 //SMMULR\r
7449 #define mult_32x32_keep32_R(a, x, y) \\r
7450     a = (q31_t) (((q63_t) x * y + 0x80000000LL ) >> 32)\r
7451 \r
7452 //SMMLA\r
7453 #define multAcc_32x32_keep32(a, x, y) \\r
7454     a += (q31_t) (((q63_t) x * y) >> 32)\r
7455 \r
7456 //SMMLS\r
7457 #define multSub_32x32_keep32(a, x, y) \\r
7458     a -= (q31_t) (((q63_t) x * y) >> 32)\r
7459 \r
7460 //SMMUL\r
7461 #define mult_32x32_keep32(a, x, y) \\r
7462     a = (q31_t) (((q63_t) x * y ) >> 32)\r
7463 \r
7464 \r
7465 #if defined ( __CC_ARM ) //Keil\r
7466 \r
7467 //Enter low optimization region - place directly above function definition\r
7468     #ifdef ARM_MATH_CM4\r
7469       #define LOW_OPTIMIZATION_ENTER \\r
7470          _Pragma ("push")         \\r
7471          _Pragma ("O1")\r
7472     #else\r
7473       #define LOW_OPTIMIZATION_ENTER \r
7474     #endif\r
7475 \r
7476 //Exit low optimization region - place directly after end of function definition\r
7477     #ifdef ARM_MATH_CM4\r
7478       #define LOW_OPTIMIZATION_EXIT \\r
7479          _Pragma ("pop")\r
7480     #else\r
7481       #define LOW_OPTIMIZATION_EXIT  \r
7482     #endif\r
7483 \r
7484 //Enter low optimization region - place directly above function definition\r
7485   #define IAR_ONLY_LOW_OPTIMIZATION_ENTER\r
7486 \r
7487 //Exit low optimization region - place directly after end of function definition\r
7488   #define IAR_ONLY_LOW_OPTIMIZATION_EXIT\r
7489 \r
7490 #elif defined(__ICCARM__) //IAR\r
7491 \r
7492 //Enter low optimization region - place directly above function definition\r
7493     #ifdef ARM_MATH_CM4\r
7494       #define LOW_OPTIMIZATION_ENTER \\r
7495          _Pragma ("optimize=low")\r
7496     #else\r
7497       #define LOW_OPTIMIZATION_ENTER   \r
7498     #endif\r
7499 \r
7500 //Exit low optimization region - place directly after end of function definition\r
7501   #define LOW_OPTIMIZATION_EXIT\r
7502 \r
7503 //Enter low optimization region - place directly above function definition\r
7504     #ifdef ARM_MATH_CM4\r
7505       #define IAR_ONLY_LOW_OPTIMIZATION_ENTER \\r
7506          _Pragma ("optimize=low")\r
7507     #else\r
7508       #define IAR_ONLY_LOW_OPTIMIZATION_ENTER   \r
7509     #endif\r
7510 \r
7511 //Exit low optimization region - place directly after end of function definition\r
7512   #define IAR_ONLY_LOW_OPTIMIZATION_EXIT\r
7513 \r
7514 #elif defined(__GNUC__)\r
7515 \r
7516   #define LOW_OPTIMIZATION_ENTER __attribute__(( optimize("-O1") ))\r
7517 \r
7518   #define LOW_OPTIMIZATION_EXIT\r
7519 \r
7520   #define IAR_ONLY_LOW_OPTIMIZATION_ENTER\r
7521 \r
7522   #define IAR_ONLY_LOW_OPTIMIZATION_EXIT\r
7523 \r
7524 #elif defined(__CSMC__)         // Cosmic\r
7525 \r
7526 #define LOW_OPTIMIZATION_ENTER\r
7527 #define LOW_OPTIMIZATION_EXIT\r
7528 #define IAR_ONLY_LOW_OPTIMIZATION_ENTER\r
7529 #define IAR_ONLY_LOW_OPTIMIZATION_EXIT\r
7530 \r
7531 #endif\r
7532 \r
7533 \r
7534 #ifdef  __cplusplus\r
7535 }\r
7536 #endif\r
7537 \r
7538 \r
7539 #endif /* _ARM_MATH_H */\r
7540 \r
7541 /**\r
7542  *\r
7543  * End of file.\r
7544  */\r