不韋 呂 / F746_SD_GraphicEqualizer

Output the audio signal with filtering by graphic equalizer in the *.wav file on the SD card using onboard CODEC. SD カードの *.wav ファイルのオーディオ信号をグラフィック･イコライザを通して，ボードに搭載されているCODEC で出力する．

Dependencies:   F746_GUI F746_SAI_IO SD_PlayerSkeleton FrequencyResponseDrawer

mbed_src_STM32F7/targets/cmsis/arm_math.h@24:f78f9d0ac262, 2017-04-10 (annotated)

Committer:
MikamiUitOpen
Date:
Mon Apr 10 04:07:35 2017 +0000
Revision:
24:f78f9d0ac262
Parent:
16:cbb726ac20d8 
25

Who changed what in which revision?

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