CMSIS-DSP: Refactoring of the PythonWrapper and SDF

Refactoring to enable improvements to the wrapper and to be able to
upload it to the Python repository.

.gitignore

@@ -17,3 +17,5 @@ Projects/ARM/IntermediateFiles/
 Examples/ARM/*/RTE/
 Examples/ARM/*/MTICoverageOut.cov
 CMSISDSP.egg-info/
+dist/
+

LICENSE.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

MANIFEST.in

@@ -0,0 +1,5 @@
+include PythonWrapper_README.md
+recursive-include Include *.h 
+recursive-include PrivateInclude *.h 
+recursive-include PythonWrapper/cmsisdsp_pkg/src *.h 
+include cmsisdsp/sdf/scheduler/templates/*

PythonWrapper/.gitignore

@@ -0,0 +1,4 @@
+dist/
+build/
+
+

PythonWrapper/README.md

@@ -1,244 +0,0 @@
-# README
-
-This Python wrapper for CMSIS-DSP is compatible with numpy.
-
-It is a very experimental wrapper with lots of limitations as described in the corresponding section below.
-
-But even with those limitations, it can be very useful to test a CMSIS-DSP implemention of an algorithm with all the power of numpy and scipy.
-
-A tutorial is also available but with less details than this README:
-https://developer.arm.com/documentation/102463/latest/
-
-# How to build and install
-
-## Tested configurations
-
-The building of this package has been tested on Windows with the Python install from python.org and Microsoft Visual 2017. 
-
-It has also been tested with cygwin. In that case, python-devel must be installed too. To run the examples, scipy and matplotlib must also be installed in cygwin.
-
-On Linux, it worked with standard installation.
-
-Other configurations should work but the setup.py file would have to be improved. It is a first version and the build process will have to be improved.
-
-The package is working with Python 2 and 3.
-
-## Building
-
-
-Since the CMSIS-DSP wrapper is using numpy, you must first install it if not already done. So, for instance to install it locally you could do:
-
-    > pip install numpy --user
-
-Once numpy is installed, you can build the CMSIS-DSP python wrapper. Go to folder CMSIS/DSP/PythonWrapper.
-
-Following command will build in place if you have the right compiler and if Python can find it.
-
-    > python setup.py build_ext --inplace
-
-Then, if you launch Python from same directory you'll be able to play with the test scripts. You'll need to install a few additional Python packages to run the examples (scipy and matplotlib). See below.
-
-If you want to install the cmsisdsp package, it is advised to install it into a virtualenv
-
-With Python 3 you could:
-
-Create a folder for this virtual environment. For instance : cmsisdsp_tests
-
-Go to this folder.
-
-Type:
-
-    > python -m venv env
-
-Activate the environment:
-
-    > env\Scripts\activate
-
-Install some packages to be able to run the examples
-
-    > pip install numpy
-    > pip install scipy
-    > pip install matplotlib
-
-Now, you can install the cmsisdsp package in editable mode:
-
-    > pip install -e "Path To The Folder Containing setup.py"
-
-Then you can copy the scripts testdsp.py and example.py and try to run them from this virtual environment. example.y is requiring a data file to be downloaded from the web. See below in this document for the link.
-
-It is also possible to compile and install directly from a Jupyter notebook by doing something like:
-
-    !pip install git+https://github.com/ARM-software/
-    CMSIS_5.git@5.8.0#egg=CMSISDSP\&subdirectory=CMSIS/DSP/PythonWrapper
-
-This will download, compile and install the PythonWrapper from the version 5.8.0 of the CMSIS-DSP (so not from the develop branch).
-
-It will work only if the compiler can be found and run from Jupyter.
-
-Note that due to the great number of possible configurations (OS, Compiler, Python), we can't give any support if you have problems compiling the PythonWrapper on your specific configuration. But, generally people manage to do it and solve all the problems.
-
-# Usage
-
-You can look at testdsp.py and example.py for some examples.
-
-The idea is to follow as closely as possible the CMSIS-DSP API to ease the migration to the final implementation on a board.
-
-First you need to import the module
-
-    > import cmsisdsp as dsp
-
-If you use numpy:
-
-    > import numpy as np
-
-If you use scipy signal processing functions:
-
-    > from scipy import signal
-
-## Functions with no instance arguments
-
-You can use a CMSIS-DSP function with numpy arrays:
-
-    > r = dsp.arm_add_f32(np.array([1.,2,3]),np.array([4.,5,7]))
-
-The function can also be called more simply with
-
-    > r = dsp.arm_add_f32([1.,2,3],[4.,5,7])
-
-The result of a CMSIS-DSP function will always be a numpy array whatever the arguments were (numpy array or list).
-
-## Functions with instance arguments 
-
-When the CMSIS-DSP function is requiring an instance data structure, it is just a bit more complex to use it:
-
-First you need to create this instance:
-
-    > firf32 = dsp.arm_fir_instance_f32()
-
-Although the initialization function on Python side can also be used to initialize some of the fields of the corresponding instance using named arguments, it is not advised to do so. In CMSIS-DSP there are initialization functions for this and they may do some additional processing.
-
-So, you need to call an init function:
-
-    > dsp.arm_fir_init_f32(firf32,3,[1.,2,3],[0,0,0,0,0,0,0])
-
-The third argument in this function is the state. Since all arguments (except the instance ones) are read-only in this Python API, this state will never be changed ! It is just used to communicate the length of the state array which must be allocated by the init function. This argument is required because it is present in the CMSIS-DSP API and in the final C implementation you'll need to allocate a state array with the right dimension.
-
-Since the goal is to be as close as possible to the C API, the API is forcing the use of this argument.
-
-The only change compared to the C API is that the size variables (like blockSize for filter) are computed automatically from the other arguments. This choice was made to make it a bit easier the use of numpy array with the API.
-
-Now, you can check that the instance was initialized correctly.
-
-    > print(firf32.numTaps())
-
-Then, you can filter with CMSIS-DSP.:
-
-    > print(dsp.arm_fir_f32(firf32,[1,2,3,4,5]))
-
-The size of this signal should be blockSize. blockSize was inferred from the size of the state array : numTaps + blockSize - 1 according to CMSIS-DSP. So here the signal must have 5 samples.
-
-If you want to filter more than 5 samples, then you can just call the function again. The state variable inside firf32 will ensure that it works like in the CMSIS-DSP C code. 
-
-    > print(dsp.arm_fir_f32(firf32,[6,7,8,9,10]))
-
-If you want to compare with scipy it is easy but warning : coefficients for the filter are in opposite order in scipy :
-
-    > filtered_x = signal.lfilter([3,2,1.], 1.0, [1,2,3,4,5,6,7,8,9,10])
-    > print(filtered_x)
-
-The principles are the same for all other APIs.
-
-## FFT 
-
-For Fourier transforms there are no init functions in the CMSIS-DSP for the instance variables. They must be initialized from a C struct. To make it simpler to use them from Python, the wrapper is introducing its own init functions.
-
-Here is an example for using FFT from the Python interface:
-
-Let's define a signal you will use for the FFT.
-
-    > nb = 16
-    > signal = np.cos(2 * np.pi * np.arange(nb) / nb)
-
-The CMSIS-DSP cfft is requiring complex signals with a specific layout in memory.
-
-To remain as close as possible to the C API, we are not using complex numbers in the wrapper. So a complex signal must be converted into a real one. The function imToReal1D is defined in testdsp.py 
-
-    > signalR = imToReal1D(signal)
-
-Then, you create the FFT instance with:
-
-    > cfftf32=dsp.arm_cfft_instance_f32()
-
-You initialize the instance with the init function provided by the wrapper:
-
-    > status=dsp.arm_cfft_init_f32(cfftf32, nb)
-    > print(status)
-
-You compute the FFT of the signal with:
-
-    > resultR = dsp.arm_cfft_f32(cfftf32,signalR,0,1)
-
-You convert back to a complex format to compare with scipy:
-
-    > resultI = realToIm1D(resultR)
-    > print(resultI)
-
-## Matrix 
-
-For matrix, the instance variables are masked by the Python API. We decided that for matrix only there was no use for having the CMSIS-DSP instance visibles since they contain the same information as the numpy array (samples and dimension).
-
-So to use a CMSIS-DSP matrix function, it is very simple:
-
-    > a=np.array([[1.,2,3,4],[5,6,7,8],[9,10,11,12]])
-    > b=np.array([[1.,2,3],[5.1,6,7],[9.1,10,11],[5,8,4]])
-
-Numpy result as reference:
-
-    > print(np.dot(a , b))
-
-CMSIS-DSP result:
-
-    > v=dsp.arm_mat_mult_f32(a,b)
-    > print(v)
-
-In a real C code, a pointer to a data structure for the result v would have to be passed as argument of the function.
-
-## example.py
-
-This example depends on a data file which can be downloaded here:
-
-https://archive.physionet.org/pn3/ecgiddb/Person_87/rec_2.dat
-
-This signal was created for a master thesis:
-
-Lugovaya T.S. Biometric human identification based on electrocardiogram. [Master's thesis] Faculty of Computing Technologies and Informatics, Electrotechnical University "LETI", Saint-Petersburg, Russian Federation; June 2005. 
-
-and it is part of the PhysioNet database
-
-Goldberger AL, Amaral LAN, Glass L, Hausdorff JM, Ivanov PCh, Mark RG, Mietus JE, Moody GB, Peng C-K, Stanley HE. PhysioBank, PhysioToolkit, and PhysioNet: Components of a New Research Resource for Complex Physiologic Signals. Circulation 101(23):e215-e220 [Circulation Electronic Pages; http://circ.ahajournals.org/cgi/content/full/101/23/e215]; 2000 (June 13). 
-
-Note that the example file
-
-## Submodules
-
-The Python wrapper is containing two submodules : fixedpoint and mfcc
-
-fixedpoint is proving some tools to help generating the fixedpoint values expected
-by CMSIS-DSP.
-
-mfcc is generating some tools to generate the MEL filters, DCT and window coefficients
-expected by the CMSIS-DSP MFCC implemetation.
-
-MEL filters are represented as 3 arrays to encode a sparse array.
-
-# LIMITATIONS
-
-Due to the high number of functions in the CMSIS-DSP, the first version of the wrapper was generated automatically from a custom script.
-
-Only a subset of the functions has been tested.
-
-It is likely that some problems are present. The API is quite regular in CMSIS-DSP but there are a few exceptions and the generation script is not managing all of them.
-
-So, the API may crash due to unallocated variables or wrong data conversions.
-
-The generated C code is a first version for bootstrapping the process. Now that this C file exists, the improvements will be done on the C code rather than on the generation script.

PythonWrapper/cmsisdsp/__init__.py

@@ -1,2 +0,0 @@
-from internal import *
-

PythonWrapper/cmsisdsp/fixedpoint.py

@@ -1,49 +0,0 @@
-import numpy as np
-
-def q31sat(x):
-     if x > 0x7FFFFFFF:
-          return(np.int32(0x7FFFFFFF))
-     elif x < -0x80000000:
-          return(np.int32(0x80000000))
-     else:
-          return(np.int32(x))
-
-q31satV=np.vectorize(q31sat)
-
-def toQ31(x):
-     return(q31satV(np.round(np.array(x) * (1<<31))))
-
-def q15sat(x):
-     if x > 0x7FFF:
-          return(np.int16(0x7FFF))
-     elif x < -0x8000:
-          return(np.int16(0x8000))
-     else:
-          return(np.int16(x))
-
-q15satV=np.vectorize(q15sat)
-
-def toQ15(x):
-     return(q15satV(np.round(np.array(x) * (1<<15))))
-
-def q7sat(x):
-     if x > 0x7F:
-          return(np.int8(0x7F))
-     elif x < -0x80:
-          return(np.int8(0x80))
-     else:
-          return(np.int8(x))
-
-q7satV=np.vectorize(q7sat)
-
-def toQ7(x):
-     return(q7satV(np.round(np.array(x) * (1<<7))))
-
-def Q31toF32(x):
-     return(1.0*np.array(x) / 2**31)
-
-def Q15toF32(x):
-     return(1.0*np.array(x) / 2**15)
-
-def Q7toF32(x):
-     return(1.0*np.array(x) / 2**7)

PythonWrapper/cmsisdsp_pkg/src/cmsisdsp_basic.c

@@ -0,0 +1,1727 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Python Wrapper
+ * Title:        cmsismodule.h
+ * Description:  C code for the CMSIS-DSP Python wrapper
+ *
+ * $Date:        27 April 2021
+ * $Revision:    V1.0
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define MODNAME "cmsisdsp_basic"
+#define MODINITNAME cmsisdsp_basic
+
+#include "cmsisdsp_module.h"
+
+
+NUMPYVECTORFROMBUFFER(f32,float32_t,NPY_FLOAT);
+
+
+void typeRegistration(PyObject *module) {
+
+ 
+}
+
+
+static PyObject *
+cmsis_arm_recip_q31(PyObject *obj, PyObject *args)
+{
+
+  q31_t in; // input
+  q31_t *dst=NULL; // output
+  PyObject *pRecipTable=NULL; // input
+  q31_t *pRecipTable_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"iO",&in,&pRecipTable))
+  {
+
+    GETARGUMENT(pRecipTable,NPY_INT32,int32_t,int32_t);
+
+    dst=PyMem_Malloc(sizeof(q31_t)*1);
+
+
+    uint32_t returnValue = arm_recip_q31(in,dst,pRecipTable_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* dstOBJ=Py_BuildValue("i",*dst);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,dstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    Py_DECREF(dstOBJ);
+    FREEARGUMENT(pRecipTable_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_recip_q15(PyObject *obj, PyObject *args)
+{
+
+  q15_t in; // input
+  q15_t *dst=NULL; // output
+  PyObject *pRecipTable=NULL; // input
+  q15_t *pRecipTable_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"hO",&in,&pRecipTable))
+  {
+
+    GETARGUMENT(pRecipTable,NPY_INT16,int16_t,int16_t);
+
+    dst=PyMem_Malloc(sizeof(q15_t)*1);
+
+
+    uint32_t returnValue = arm_recip_q15(in,dst,pRecipTable_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* dstOBJ=Py_BuildValue("h",*dst);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,dstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    Py_DECREF(dstOBJ);
+    FREEARGUMENT(pRecipTable_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mult_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q7_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  q7_t *pSrcB_converted=NULL; // input
+  q7_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
+    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrcA ;
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
+
+
+    arm_mult_q7(pSrcA_converted,pSrcB_converted,pDst,blockSize);
+ INT8ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mult_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q15_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  q15_t *pSrcB_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrcA ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_mult_q15(pSrcA_converted,pSrcB_converted,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mult_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q31_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  q31_t *pSrcB_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrcA ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_mult_q31(pSrcA_converted,pSrcB_converted,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mult_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  float32_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  float32_t *pSrcB_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrcA ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_mult_f32(pSrcA_converted,pSrcB_converted,pDst,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+static PyObject *
+cmsis_arm_add_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  float32_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  float32_t *pSrcB_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrcA ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_add_f32(pSrcA_converted,pSrcB_converted,pDst,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+/*
+
+For the arm_(and|xor|or)_u(32|16|8)
+
+*/
+
+#define U_UN_OP(OP,TYP,EXT,NPYTYPE)                     \
+static PyObject *                                       \
+cmsis_arm_##OP##_##EXT(PyObject *obj, PyObject *args)   \
+{                                                       \
+                                                        \
+  PyObject *pSrcA=NULL;                                 \
+  TYP *pSrcA_converted=NULL;                            \
+  TYP *pDst=NULL;                                       \
+  uint32_t blockSize;                                   \
+                                                        \
+  if (PyArg_ParseTuple(args,"O",&pSrcA))                \
+  {                                                     \
+                                                        \
+    GETARGUMENT(pSrcA,NPYTYPE,TYP,TYP);                 \
+    blockSize = arraySizepSrcA ;                        \
+                                                        \
+    pDst=PyMem_Malloc(sizeof(TYP)*blockSize);           \
+                                                        \
+                                                        \
+    arm_##OP##_##EXT(pSrcA_converted,pDst,blockSize);   \
+ TYP_ARRAY1(pDstOBJ,blockSize,pDst,NPYTYPE);            \
+                                                        \
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);\
+                                                        \
+    FREEARGUMENT(pSrcA_converted);                      \
+    Py_DECREF(pDstOBJ);                                 \
+    return(pythonResult);                               \
+                                                        \
+  }                                                     \
+  return(NULL);                                         \
+}
+
+#define U_BIN_OP(OP,TYP,EXT,NPYTYPE)                                 \
+static PyObject *                                                    \
+cmsis_arm_##OP##_##EXT(PyObject *obj, PyObject *args)                \
+{                                                                    \
+                                                                     \
+  PyObject *pSrcA=NULL;                                              \
+  TYP *pSrcA_converted=NULL;                                         \
+  PyObject *pSrcB=NULL;                                              \
+  TYP *pSrcB_converted=NULL;                                         \
+  TYP *pDst=NULL;                                                    \
+  uint32_t blockSize;                                                \
+                                                                     \
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))                     \
+  {                                                                  \
+                                                                     \
+    GETARGUMENT(pSrcA,NPYTYPE,TYP,TYP);                              \
+    GETARGUMENT(pSrcB,NPYTYPE,TYP,TYP);                              \
+    blockSize = arraySizepSrcA ;                                     \
+                                                                     \
+    pDst=PyMem_Malloc(sizeof(TYP)*blockSize);                        \
+                                                                     \
+                                                                     \
+    arm_##OP##_##EXT(pSrcA_converted,pSrcB_converted,pDst,blockSize);\
+ TYP_ARRAY1(pDstOBJ,blockSize,pDst,NPYTYPE);                         \
+                                                                     \
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);             \
+                                                                     \
+    FREEARGUMENT(pSrcA_converted);                                   \
+    FREEARGUMENT(pSrcB_converted);                                   \
+    Py_DECREF(pDstOBJ);                                              \
+    return(pythonResult);                                            \
+                                                                     \
+  }                                                                  \
+  return(NULL);                                                      \
+}
+
+U_BIN_OP(and,uint32_t,u32,NPY_UINT32);
+U_BIN_OP(and,uint16_t,u16,NPY_UINT16);
+U_BIN_OP(and,uint8_t,u8,NPY_UINT8);
+
+U_BIN_OP(or,uint32_t,u32,NPY_UINT32);
+U_BIN_OP(or,uint16_t,u16,NPY_UINT16);
+U_BIN_OP(or,uint8_t,u8,NPY_UINT8);
+
+U_BIN_OP(xor,uint32_t,u32,NPY_UINT32);
+U_BIN_OP(xor,uint16_t,u16,NPY_UINT16);
+U_BIN_OP(xor,uint8_t,u8,NPY_UINT8);
+
+U_UN_OP(not,uint32_t,u32,NPY_UINT32);
+U_UN_OP(not,uint16_t,u16,NPY_UINT16);
+U_UN_OP(not,uint8_t,u8,NPY_UINT8);
+
+static PyObject *
+cmsis_arm_add_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q7_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  q7_t *pSrcB_converted=NULL; // input
+  q7_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
+    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrcA ;
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
+
+
+    arm_add_q7(pSrcA_converted,pSrcB_converted,pDst,blockSize);
+ INT8ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_add_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q15_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  q15_t *pSrcB_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrcA ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_add_q15(pSrcA_converted,pSrcB_converted,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_add_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q31_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  q31_t *pSrcB_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrcA ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_add_q31(pSrcA_converted,pSrcB_converted,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_sub_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  float32_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  float32_t *pSrcB_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrcA ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_sub_f32(pSrcA_converted,pSrcB_converted,pDst,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_sub_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q7_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  q7_t *pSrcB_converted=NULL; // input
+  q7_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
+    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrcA ;
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
+
+
+    arm_sub_q7(pSrcA_converted,pSrcB_converted,pDst,blockSize);
+ INT8ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_sub_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q15_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  q15_t *pSrcB_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrcA ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_sub_q15(pSrcA_converted,pSrcB_converted,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_sub_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q31_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  q31_t *pSrcB_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrcA ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_sub_q31(pSrcA_converted,pSrcB_converted,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_scale_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t scale; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"Of",&pSrc,&scale))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_scale_f32(pSrc_converted,scale,pDst,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_scale_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  int32_t scaleFract; // input
+  int32_t shift; // input
+  q7_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"Oii",&pSrc,&scaleFract,&shift))
+  {
+
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
+
+
+    arm_scale_q7(pSrc_converted,(q7_t)scaleFract,(int8_t)shift,pDst,blockSize);
+ INT8ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_scale_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t scaleFract; // input
+  int32_t shift; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"Ohi",&pSrc,&scaleFract,&shift))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_scale_q15(pSrc_converted,scaleFract,(int8_t)shift,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_scale_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t scaleFract; // input
+  int32_t shift; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"Oii",&pSrc,&scaleFract,&shift))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_scale_q31(pSrc_converted,scaleFract,(int8_t)shift,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_abs_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  q7_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
+
+
+    arm_abs_q7(pSrc_converted,pDst,blockSize);
+ INT8ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_abs_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_abs_f32(pSrc_converted,pDst,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_abs_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_abs_q15(pSrc_converted,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_abs_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_abs_q31(pSrc_converted,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+
+
+static PyObject *
+cmsis_arm_dot_prod_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  float32_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  float32_t *pSrcB_converted=NULL; // input
+  uint32_t blockSize; // input
+  float32_t *result=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrcA ;
+
+    result=PyMem_Malloc(sizeof(float32_t)*1);
+
+
+    arm_dot_prod_f32(pSrcA_converted,pSrcB_converted,blockSize,result);
+    PyObject* resultOBJ=Py_BuildValue("f",*result);
+
+    PyObject *pythonResult = Py_BuildValue("O",resultOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(resultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_dot_prod_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q7_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  q7_t *pSrcB_converted=NULL; // input
+  uint32_t blockSize; // input
+  q31_t *result=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
+    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrcA ;
+
+    result=PyMem_Malloc(sizeof(q31_t)*1);
+
+
+    arm_dot_prod_q7(pSrcA_converted,pSrcB_converted,blockSize,result);
+    PyObject* resultOBJ=Py_BuildValue("i",*result);
+
+    PyObject *pythonResult = Py_BuildValue("O",resultOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(resultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_dot_prod_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q15_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  q15_t *pSrcB_converted=NULL; // input
+  uint32_t blockSize; // input
+  q63_t *result=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrcA ;
+
+    result=PyMem_Malloc(sizeof(q63_t)*1);
+
+
+    arm_dot_prod_q15(pSrcA_converted,pSrcB_converted,blockSize,result);
+    PyObject* resultOBJ=Py_BuildValue("L",*result);
+
+    PyObject *pythonResult = Py_BuildValue("O",resultOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(resultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_dot_prod_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q31_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  q31_t *pSrcB_converted=NULL; // input
+  uint32_t blockSize; // input
+  q63_t *result=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrcA ;
+
+    result=PyMem_Malloc(sizeof(q63_t)*1);
+
+
+    arm_dot_prod_q31(pSrcA_converted,pSrcB_converted,blockSize,result);
+    PyObject* resultOBJ=Py_BuildValue("L",*result);
+
+    PyObject *pythonResult = Py_BuildValue("O",resultOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(resultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_shift_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  int32_t shiftBits; // input
+  q7_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"Oi",&pSrc,&shiftBits))
+  {
+
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
+
+
+    arm_shift_q7(pSrc_converted,(int8_t)shiftBits,pDst,blockSize);
+ INT8ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_shift_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  int32_t shiftBits; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"Oi",&pSrc,&shiftBits))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_shift_q15(pSrc_converted,(int8_t)shiftBits,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_shift_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  int32_t shiftBits; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"Oi",&pSrc,&shiftBits))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_shift_q31(pSrc_converted,(int8_t)shiftBits,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_clip_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t low,high; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"Off",&pSrc,&low,&high))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_clip_f32(pSrc_converted,pDst,low,high,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_clip_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t low,high; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"Oii",&pSrc,&low,&high))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_clip_q31(pSrc_converted,pDst,low,high,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_clip_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t low,high; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"Ohh",&pSrc,&low,&high))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_clip_q15(pSrc_converted,pDst,low,high,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_clip_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  int32_t low,high; // input
+  q7_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"Oii",&pSrc,&low,&high))
+  {
+
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
+
+
+    arm_clip_q7(pSrc_converted,pDst,(q7_t)low,(q7_t)high,blockSize);
+ INT8ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_offset_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t offset; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"Of",&pSrc,&offset))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_offset_f32(pSrc_converted,offset,pDst,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_offset_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  int32_t offset; // input
+  q7_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"Oi",&pSrc,&offset))
+  {
+
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
+
+
+    arm_offset_q7(pSrc_converted,(q7_t)offset,pDst,blockSize);
+ INT8ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_offset_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t offset; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"Oh",&pSrc,&offset))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_offset_q15(pSrc_converted,offset,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_offset_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t offset; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"Oi",&pSrc,&offset))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_offset_q31(pSrc_converted,offset,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_negate_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_negate_f32(pSrc_converted,pDst,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_negate_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  q7_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
+
+
+    arm_negate_q7(pSrc_converted,pDst,blockSize);
+ INT8ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_negate_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_negate_q15(pSrc_converted,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_negate_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_negate_q31(pSrc_converted,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+static PyObject *
+cmsis_ssat(PyObject *obj, PyObject *args)
+{
+
+  int32_t val; // input
+  uint32_t sat;
+
+  if (PyArg_ParseTuple(args,"iI",&val,&sat))
+  {
+
+    int32_t result = __SSAT(val,sat);
+    PyObject* theReturnOBJ=Py_BuildValue("i",result);
+
+    return(theReturnOBJ);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_usat(PyObject *obj, PyObject *args)
+{
+
+  int32_t val; // input
+  uint32_t sat;
+  q15_t pOut,shift; // output
+
+  if (PyArg_ParseTuple(args,"iI",&val,&sat))
+  {
+
+    uint32_t result = __USAT(val,sat);
+    PyObject* theReturnOBJ=Py_BuildValue("I",result);
+
+    return(theReturnOBJ);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_clz(PyObject *obj, PyObject *args)
+{
+
+  uint32_t val;
+
+  if (PyArg_ParseTuple(args,"I",&val))
+  {
+
+    uint8_t result = __CLZ(val);
+    PyObject* theReturnOBJ=Py_BuildValue("B",result);
+
+    return(theReturnOBJ);
+
+  }
+  return(NULL);
+}
+
+static PyMethodDef CMSISDSPMethods[] = {
+
+{"arm_recip_q31",  cmsis_arm_recip_q31, METH_VARARGS,""},
+{"arm_recip_q15",  cmsis_arm_recip_q15, METH_VARARGS,""},
+
+
+
+
+{"arm_mult_q7",  cmsis_arm_mult_q7, METH_VARARGS,""},
+{"arm_mult_q15",  cmsis_arm_mult_q15, METH_VARARGS,""},
+{"arm_mult_q31",  cmsis_arm_mult_q31, METH_VARARGS,""},
+{"arm_mult_f32",  cmsis_arm_mult_f32, METH_VARARGS,""},
+
+
+{"arm_add_f32",  cmsis_arm_add_f32, METH_VARARGS,""},
+{"arm_add_q7",  cmsis_arm_add_q7, METH_VARARGS,""},
+{"arm_add_q15",  cmsis_arm_add_q15, METH_VARARGS,""},
+{"arm_add_q31",  cmsis_arm_add_q31, METH_VARARGS,""},
+{"arm_sub_f32",  cmsis_arm_sub_f32, METH_VARARGS,""},
+{"arm_sub_q7",  cmsis_arm_sub_q7, METH_VARARGS,""},
+{"arm_sub_q15",  cmsis_arm_sub_q15, METH_VARARGS,""},
+{"arm_sub_q31",  cmsis_arm_sub_q31, METH_VARARGS,""},
+{"arm_scale_f32",  cmsis_arm_scale_f32, METH_VARARGS,""},
+{"arm_scale_q7",  cmsis_arm_scale_q7, METH_VARARGS,""},
+{"arm_scale_q15",  cmsis_arm_scale_q15, METH_VARARGS,""},
+{"arm_scale_q31",  cmsis_arm_scale_q31, METH_VARARGS,""},
+{"arm_abs_q7",  cmsis_arm_abs_q7, METH_VARARGS,""},
+{"arm_abs_f32",  cmsis_arm_abs_f32, METH_VARARGS,""},
+{"arm_abs_q15",  cmsis_arm_abs_q15, METH_VARARGS,""},
+{"arm_abs_q31",  cmsis_arm_abs_q31, METH_VARARGS,""},
+{"arm_dot_prod_f32",  cmsis_arm_dot_prod_f32, METH_VARARGS,""},
+{"arm_dot_prod_q7",  cmsis_arm_dot_prod_q7, METH_VARARGS,""},
+{"arm_dot_prod_q15",  cmsis_arm_dot_prod_q15, METH_VARARGS,""},
+{"arm_dot_prod_q31",  cmsis_arm_dot_prod_q31, METH_VARARGS,""},
+{"arm_shift_q7",  cmsis_arm_shift_q7, METH_VARARGS,""},
+{"arm_shift_q15",  cmsis_arm_shift_q15, METH_VARARGS,""},
+{"arm_shift_q31",  cmsis_arm_shift_q31, METH_VARARGS,""},
+{"arm_clip_f32",  cmsis_arm_clip_f32, METH_VARARGS,""},
+{"arm_clip_q31",  cmsis_arm_clip_q31, METH_VARARGS,""},
+{"arm_clip_q15",  cmsis_arm_clip_q15, METH_VARARGS,""},
+{"arm_clip_q7",  cmsis_arm_clip_q7, METH_VARARGS,""},
+{"arm_offset_f32",  cmsis_arm_offset_f32, METH_VARARGS,""},
+{"arm_offset_q7",  cmsis_arm_offset_q7, METH_VARARGS,""},
+{"arm_offset_q15",  cmsis_arm_offset_q15, METH_VARARGS,""},
+{"arm_offset_q31",  cmsis_arm_offset_q31, METH_VARARGS,""},
+{"arm_negate_f32",  cmsis_arm_negate_f32, METH_VARARGS,""},
+{"arm_negate_q7",  cmsis_arm_negate_q7, METH_VARARGS,""},
+{"arm_negate_q15",  cmsis_arm_negate_q15, METH_VARARGS,""},
+{"arm_negate_q31",  cmsis_arm_negate_q31, METH_VARARGS,""},
+
+
+
+
+
+
+{"arm_and_u32",  cmsis_arm_and_u32, METH_VARARGS,""},
+{"arm_and_u16",  cmsis_arm_and_u16, METH_VARARGS,""},
+{"arm_and_u8" ,  cmsis_arm_and_u8, METH_VARARGS,""},
+
+{"arm_or_u32",  cmsis_arm_or_u32, METH_VARARGS,""},
+{"arm_or_u16",  cmsis_arm_or_u16, METH_VARARGS,""},
+{"arm_or_u8" ,  cmsis_arm_or_u8, METH_VARARGS,""},
+
+{"arm_xor_u32",  cmsis_arm_xor_u32, METH_VARARGS,""},
+{"arm_xor_u16",  cmsis_arm_xor_u16, METH_VARARGS,""},
+{"arm_xor_u8" ,  cmsis_arm_xor_u8, METH_VARARGS,""},
+
+{"arm_not_u32",  cmsis_arm_not_u32, METH_VARARGS,""},
+{"arm_not_u16",  cmsis_arm_not_u16, METH_VARARGS,""},
+{"arm_not_u8" ,  cmsis_arm_not_u8, METH_VARARGS,""},
+
+   
+    {"ssat",  cmsis_ssat, METH_VARARGS,""},
+    {"usat",  cmsis_usat, METH_VARARGS,""},
+    {"clz",  cmsis_clz, METH_VARARGS,""},
+    {"error_out", (PyCFunction)error_out, METH_NOARGS, NULL},
+    {NULL, NULL, 0, NULL}        /* Sentinel */
+};
+
+#ifdef IS_PY3K
+static int cmsisdsp_traverse(PyObject *m, visitproc visit, void *arg) {
+    Py_VISIT(GETSTATE(m)->error);
+    return 0;
+}
+
+static int cmsisdsp_clear(PyObject *m) {
+    Py_CLEAR(GETSTATE(m)->error);
+    return 0;
+}
+
+
+static struct PyModuleDef moduledef = {
+        PyModuleDef_HEAD_INIT,
+        MODNAME,
+        NULL,
+        sizeof(struct module_state),
+        CMSISDSPMethods,
+        NULL,
+        cmsisdsp_traverse,
+        cmsisdsp_clear,
+        NULL
+};
+
+#define INITERROR return NULL
+
+PyMODINIT_FUNC
+CAT(PyInit_,MODINITNAME)(void)
+
+
+#else
+#define INITERROR return
+
+void CAT(init,MODINITNAME)(void)
+#endif
+{
+    import_array();
+
+  #ifdef IS_PY3K
+    PyObject *module = PyModule_Create(&moduledef);
+  #else
+    PyObject *module = Py_InitModule(MODNAME, CMSISDSPMethods);
+  #endif
+
+  if (module == NULL)
+      INITERROR;
+  struct module_state *st = GETSTATE(module);
+  
+  st->error = PyErr_NewException(MODNAME".Error", NULL, NULL);
+  if (st->error == NULL) {
+      Py_DECREF(module);
+      INITERROR;
+  }
+
+
+  typeRegistration(module);
+
+  #ifdef IS_PY3K
+    return module;
+  #endif
+}

PythonWrapper/cmsisdsp_pkg/src/cmsisdsp_complexf.c

@@ -0,0 +1,830 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Python Wrapper
+ * Title:        cmsismodule.h
+ * Description:  C code for the CMSIS-DSP Python wrapper
+ *
+ * $Date:        27 April 2021
+ * $Revision:    V1.0
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define MODNAME "cmsisdsp_complexf"
+#define MODINITNAME cmsisdsp_complexf
+
+#include "cmsisdsp_module.h"
+
+
+NUMPYVECTORFROMBUFFER(f32,float32_t,NPY_FLOAT);
+
+
+void typeRegistration(PyObject *module) {
+
+ 
+}
+
+
+
+
+
+
+
+
+
+
+
+static PyObject *
+cmsis_arm_cmplx_conj_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t numSamples; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    numSamples = arraySizepSrc ;
+    numSamples = numSamples / 2;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*2*numSamples);
+
+
+    arm_cmplx_conj_f32(pSrc_converted,pDst,numSamples);
+ FLOATARRAY1(pDstOBJ,2*numSamples,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cmplx_conj_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t numSamples; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    numSamples = arraySizepSrc ;
+    numSamples = numSamples / 2;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*2*numSamples);
+
+
+    arm_cmplx_conj_q31(pSrc_converted,pDst,numSamples);
+ INT32ARRAY1(pDstOBJ,2*numSamples,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cmplx_conj_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t numSamples; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    numSamples = arraySizepSrc ;
+    numSamples = numSamples / 2;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*2*numSamples);
+
+
+    arm_cmplx_conj_q15(pSrc_converted,pDst,numSamples);
+ INT16ARRAY1(pDstOBJ,2*numSamples,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cmplx_mag_squared_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t numSamples; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    numSamples = arraySizepSrc ;
+    numSamples = numSamples / 2;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*2*numSamples);
+
+
+    arm_cmplx_mag_squared_f32(pSrc_converted,pDst,numSamples);
+ FLOATARRAY1(pDstOBJ,numSamples,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cmplx_mag_squared_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t numSamples; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    numSamples = arraySizepSrc ;
+    numSamples = numSamples / 2;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*2*numSamples);
+
+
+    arm_cmplx_mag_squared_q31(pSrc_converted,pDst,numSamples);
+ INT32ARRAY1(pDstOBJ,numSamples,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cmplx_mag_squared_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t numSamples; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    numSamples = arraySizepSrc ;
+    numSamples = numSamples / 2;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*2*numSamples);
+
+
+    arm_cmplx_mag_squared_q15(pSrc_converted,pDst,numSamples);
+ INT16ARRAY1(pDstOBJ,numSamples,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+
+
+
+
+static PyObject *
+cmsis_arm_cmplx_mag_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t numSamples; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    numSamples = arraySizepSrc ;
+    numSamples = numSamples / 2;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*2*numSamples);
+
+
+    arm_cmplx_mag_f32(pSrc_converted,pDst,numSamples);
+ FLOATARRAY1(pDstOBJ,numSamples,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cmplx_mag_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t numSamples; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    numSamples = arraySizepSrc ;
+    numSamples = numSamples / 2;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*2*numSamples);
+
+
+    arm_cmplx_mag_q31(pSrc_converted,pDst,numSamples);
+ INT32ARRAY1(pDstOBJ,numSamples,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cmplx_mag_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t numSamples; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    numSamples = arraySizepSrc ;
+    numSamples = numSamples / 2;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*2*numSamples);
+
+
+    arm_cmplx_mag_q15(pSrc_converted,pDst,numSamples);
+ INT16ARRAY1(pDstOBJ,numSamples,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_cmplx_mag_fast_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t numSamples; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    numSamples = arraySizepSrc ;
+    numSamples = numSamples / 2;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*2*numSamples);
+
+
+    arm_cmplx_mag_fast_q15(pSrc_converted,pDst,numSamples);
+ INT16ARRAY1(pDstOBJ,numSamples,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_cmplx_dot_prod_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q15_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  q15_t *pSrcB_converted=NULL; // input
+  uint32_t numSamples; // input
+  q31_t *realResult=NULL; // output
+  q31_t *imagResult=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
+    numSamples = arraySizepSrcA ;
+    numSamples = numSamples / 2;
+
+    realResult=PyMem_Malloc(sizeof(q31_t)*1);
+
+
+    imagResult=PyMem_Malloc(sizeof(q31_t)*1);
+
+
+    arm_cmplx_dot_prod_q15(pSrcA_converted,pSrcB_converted,numSamples,realResult,imagResult);
+    PyObject* realResultOBJ=Py_BuildValue("i",*realResult);
+    PyObject* imagResultOBJ=Py_BuildValue("i",*imagResult);
+
+    PyObject *pythonResult = Py_BuildValue("OO",realResultOBJ,imagResultOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(realResultOBJ);
+    Py_DECREF(imagResultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cmplx_dot_prod_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q31_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  q31_t *pSrcB_converted=NULL; // input
+  uint32_t numSamples; // input
+  q63_t *realResult=NULL; // output
+  q63_t *imagResult=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
+    numSamples = arraySizepSrcA ;
+    numSamples = numSamples / 2;
+
+    realResult=PyMem_Malloc(sizeof(q63_t)*1);
+
+
+    imagResult=PyMem_Malloc(sizeof(q63_t)*1);
+
+
+    arm_cmplx_dot_prod_q31(pSrcA_converted,pSrcB_converted,numSamples,realResult,imagResult);
+    PyObject* realResultOBJ=Py_BuildValue("L",*realResult);
+    PyObject* imagResultOBJ=Py_BuildValue("L",*imagResult);
+
+    PyObject *pythonResult = Py_BuildValue("OO",realResultOBJ,imagResultOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(realResultOBJ);
+    Py_DECREF(imagResultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cmplx_dot_prod_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  float32_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  float32_t *pSrcB_converted=NULL; // input
+  uint32_t numSamples; // input
+  float32_t *realResult=NULL; // output
+  float32_t *imagResult=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
+    numSamples = arraySizepSrcA ;
+    numSamples = numSamples / 2;
+
+    realResult=PyMem_Malloc(sizeof(float32_t)*1);
+
+
+    imagResult=PyMem_Malloc(sizeof(float32_t)*1);
+
+
+    arm_cmplx_dot_prod_f32(pSrcA_converted,pSrcB_converted,numSamples,realResult,imagResult);
+    PyObject* realResultOBJ=Py_BuildValue("f",*realResult);
+    PyObject* imagResultOBJ=Py_BuildValue("f",*imagResult);
+
+    PyObject *pythonResult = Py_BuildValue("OO",realResultOBJ,imagResultOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(realResultOBJ);
+    Py_DECREF(imagResultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cmplx_mult_real_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcCmplx=NULL; // input
+  q15_t *pSrcCmplx_converted=NULL; // input
+  PyObject *pSrcReal=NULL; // input
+  q15_t *pSrcReal_converted=NULL; // input
+  q15_t *pCmplxDst=NULL; // output
+  uint32_t numSamples; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcCmplx,&pSrcReal))
+  {
+
+    GETARGUMENT(pSrcCmplx,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pSrcReal,NPY_INT16,int16_t,int16_t);
+    numSamples = arraySizepSrcCmplx ;
+    numSamples = numSamples / 2;
+
+    pCmplxDst=PyMem_Malloc(sizeof(q15_t)*2*numSamples);
+
+
+    arm_cmplx_mult_real_q15(pSrcCmplx_converted,pSrcReal_converted,pCmplxDst,numSamples);
+ INT16ARRAY1(pCmplxDstOBJ,2*numSamples,pCmplxDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pCmplxDstOBJ);
+
+    FREEARGUMENT(pSrcCmplx_converted);
+    FREEARGUMENT(pSrcReal_converted);
+    Py_DECREF(pCmplxDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cmplx_mult_real_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcCmplx=NULL; // input
+  q31_t *pSrcCmplx_converted=NULL; // input
+  PyObject *pSrcReal=NULL; // input
+  q31_t *pSrcReal_converted=NULL; // input
+  q31_t *pCmplxDst=NULL; // output
+  uint32_t numSamples; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcCmplx,&pSrcReal))
+  {
+
+    GETARGUMENT(pSrcCmplx,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pSrcReal,NPY_INT32,int32_t,int32_t);
+    numSamples = arraySizepSrcCmplx ;
+    numSamples = numSamples / 2;
+
+    pCmplxDst=PyMem_Malloc(sizeof(q31_t)*2*numSamples);
+
+
+    arm_cmplx_mult_real_q31(pSrcCmplx_converted,pSrcReal_converted,pCmplxDst,numSamples);
+ INT32ARRAY1(pCmplxDstOBJ,2*numSamples,pCmplxDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pCmplxDstOBJ);
+
+    FREEARGUMENT(pSrcCmplx_converted);
+    FREEARGUMENT(pSrcReal_converted);
+    Py_DECREF(pCmplxDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cmplx_mult_real_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcCmplx=NULL; // input
+  float32_t *pSrcCmplx_converted=NULL; // input
+  PyObject *pSrcReal=NULL; // input
+  float32_t *pSrcReal_converted=NULL; // input
+  float32_t *pCmplxDst=NULL; // output
+  uint32_t numSamples; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcCmplx,&pSrcReal))
+  {
+
+    GETARGUMENT(pSrcCmplx,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pSrcReal,NPY_DOUBLE,double,float32_t);
+    numSamples = arraySizepSrcCmplx ;
+    numSamples = numSamples / 2;
+
+    pCmplxDst=PyMem_Malloc(sizeof(float32_t)*2*numSamples);
+
+
+    arm_cmplx_mult_real_f32(pSrcCmplx_converted,pSrcReal_converted,pCmplxDst,numSamples);
+ FLOATARRAY1(pCmplxDstOBJ,2*numSamples,pCmplxDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pCmplxDstOBJ);
+
+    FREEARGUMENT(pSrcCmplx_converted);
+    FREEARGUMENT(pSrcReal_converted);
+    Py_DECREF(pCmplxDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+
+static PyObject *
+cmsis_arm_cmplx_mult_cmplx_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q15_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  q15_t *pSrcB_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t numSamples; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
+    numSamples = arraySizepSrcA ;
+    numSamples = numSamples / 2;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*2*numSamples);
+
+
+    arm_cmplx_mult_cmplx_q15(pSrcA_converted,pSrcB_converted,pDst,numSamples);
+ INT16ARRAY1(pDstOBJ,2*numSamples,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cmplx_mult_cmplx_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q31_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  q31_t *pSrcB_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t numSamples; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
+    numSamples = arraySizepSrcA ;
+    numSamples = numSamples / 2;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*2*numSamples);
+
+
+    arm_cmplx_mult_cmplx_q31(pSrcA_converted,pSrcB_converted,pDst,numSamples);
+ INT32ARRAY1(pDstOBJ,2*numSamples,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cmplx_mult_cmplx_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  float32_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  float32_t *pSrcB_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t numSamples; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
+    numSamples = arraySizepSrcA ;
+    numSamples = numSamples / 2;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*2*numSamples);
+
+
+    arm_cmplx_mult_cmplx_f32(pSrcA_converted,pSrcB_converted,pDst,numSamples);
+ FLOATARRAY1(pDstOBJ,2*numSamples,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+
+static PyMethodDef CMSISDSPMethods[] = {
+
+
+{"arm_cmplx_conj_f32",  cmsis_arm_cmplx_conj_f32, METH_VARARGS,""},
+{"arm_cmplx_conj_q31",  cmsis_arm_cmplx_conj_q31, METH_VARARGS,""},
+{"arm_cmplx_conj_q15",  cmsis_arm_cmplx_conj_q15, METH_VARARGS,""},
+{"arm_cmplx_mag_squared_f32",  cmsis_arm_cmplx_mag_squared_f32, METH_VARARGS,""},
+{"arm_cmplx_mag_squared_q31",  cmsis_arm_cmplx_mag_squared_q31, METH_VARARGS,""},
+{"arm_cmplx_mag_squared_q15",  cmsis_arm_cmplx_mag_squared_q15, METH_VARARGS,""},
+
+
+{"arm_cmplx_mag_f32",  cmsis_arm_cmplx_mag_f32, METH_VARARGS,""},
+{"arm_cmplx_mag_q31",  cmsis_arm_cmplx_mag_q31, METH_VARARGS,""},
+{"arm_cmplx_mag_q15",  cmsis_arm_cmplx_mag_q15, METH_VARARGS,""},
+{"arm_cmplx_mag_fast_q15",  cmsis_arm_cmplx_mag_fast_q15, METH_VARARGS,""},
+{"arm_cmplx_dot_prod_q15",  cmsis_arm_cmplx_dot_prod_q15, METH_VARARGS,""},
+{"arm_cmplx_dot_prod_q31",  cmsis_arm_cmplx_dot_prod_q31, METH_VARARGS,""},
+{"arm_cmplx_dot_prod_f32",  cmsis_arm_cmplx_dot_prod_f32, METH_VARARGS,""},
+{"arm_cmplx_mult_real_q15",  cmsis_arm_cmplx_mult_real_q15, METH_VARARGS,""},
+{"arm_cmplx_mult_real_q31",  cmsis_arm_cmplx_mult_real_q31, METH_VARARGS,""},
+{"arm_cmplx_mult_real_f32",  cmsis_arm_cmplx_mult_real_f32, METH_VARARGS,""},
+{"arm_cmplx_mult_cmplx_q15",  cmsis_arm_cmplx_mult_cmplx_q15, METH_VARARGS,""},
+{"arm_cmplx_mult_cmplx_q31",  cmsis_arm_cmplx_mult_cmplx_q31, METH_VARARGS,""},
+{"arm_cmplx_mult_cmplx_f32",  cmsis_arm_cmplx_mult_cmplx_f32, METH_VARARGS,""},
+
+    {"error_out", (PyCFunction)error_out, METH_NOARGS, NULL},
+    {NULL, NULL, 0, NULL}        /* Sentinel */
+};
+
+#ifdef IS_PY3K
+static int cmsisdsp_traverse(PyObject *m, visitproc visit, void *arg) {
+    Py_VISIT(GETSTATE(m)->error);
+    return 0;
+}
+
+static int cmsisdsp_clear(PyObject *m) {
+    Py_CLEAR(GETSTATE(m)->error);
+    return 0;
+}
+
+
+static struct PyModuleDef moduledef = {
+        PyModuleDef_HEAD_INIT,
+        MODNAME,
+        NULL,
+        sizeof(struct module_state),
+        CMSISDSPMethods,
+        NULL,
+        cmsisdsp_traverse,
+        cmsisdsp_clear,
+        NULL
+};
+
+#define INITERROR return NULL
+
+PyMODINIT_FUNC
+CAT(PyInit_,MODINITNAME)(void)
+
+
+#else
+#define INITERROR return
+
+void CAT(init,MODINITNAME)(void)
+#endif
+{
+    import_array();
+
+  #ifdef IS_PY3K
+    PyObject *module = PyModule_Create(&moduledef);
+  #else
+    PyObject *module = Py_InitModule(MODNAME, CMSISDSPMethods);
+  #endif
+
+  if (module == NULL)
+      INITERROR;
+  struct module_state *st = GETSTATE(module);
+  
+  st->error = PyErr_NewException(MODNAME".Error", NULL, NULL);
+  if (st->error == NULL) {
+      Py_DECREF(module);
+      INITERROR;
+  }
+
+
+  typeRegistration(module);
+
+  #ifdef IS_PY3K
+    return module;
+  #endif
+}

PythonWrapper/cmsisdsp_pkg/src/cmsisdsp_controller.c

@@ -0,0 +1,906 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Python Wrapper
+ * Title:        cmsismodule.h
+ * Description:  C code for the CMSIS-DSP Python wrapper
+ *
+ * $Date:        27 April 2021
+ * $Revision:    V1.0
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define MODNAME "cmsisdsp_controller"
+#define MODINITNAME cmsisdsp_controller
+
+#include "cmsisdsp_module.h"
+
+
+
+NUMPYVECTORFROMBUFFER(f32,float32_t,NPY_FLOAT);
+
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_pid_instance_q15 *instance;
+} dsp_arm_pid_instance_q15Object;
+
+
+static void
+arm_pid_instance_q15_dealloc(dsp_arm_pid_instance_q15Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_pid_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_pid_instance_q15Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_pid_instance_q15Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_pid_instance_q15));
+
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_pid_instance_q15_init(dsp_arm_pid_instance_q15Object *self, PyObject *args, PyObject *kwds)
+{
+
+char *kwlist[] = {
+"A0","A1","A2","state","Kp","Ki","Kd",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhhhhhh", kwlist,&self->instance->A0
+,&self->instance->A1
+,&self->instance->A2
+,&self->instance->state
+,&self->instance->Kp
+,&self->instance->Ki
+,&self->instance->Kd
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_pid_instance_q15,A0,"h");
+GETFIELD(arm_pid_instance_q15,A1,"h");
+GETFIELD(arm_pid_instance_q15,A2,"h");
+GETFIELD(arm_pid_instance_q15,state,"h");
+GETFIELD(arm_pid_instance_q15,Kp,"h");
+GETFIELD(arm_pid_instance_q15,Ki,"h");
+GETFIELD(arm_pid_instance_q15,Kd,"h");
+
+
+static PyMethodDef arm_pid_instance_q15_methods[] = {
+
+    {"A0", (PyCFunction) Method_arm_pid_instance_q15_A0,METH_NOARGS,"A0"},
+    {"A1", (PyCFunction) Method_arm_pid_instance_q15_A1,METH_NOARGS,"A1"},
+    {"A2", (PyCFunction) Method_arm_pid_instance_q15_A2,METH_NOARGS,"A2"},
+    {"state", (PyCFunction) Method_arm_pid_instance_q15_state,METH_NOARGS,"state"},
+    {"Kp", (PyCFunction) Method_arm_pid_instance_q15_Kp,METH_NOARGS,"Kp"},
+    {"Ki", (PyCFunction) Method_arm_pid_instance_q15_Ki,METH_NOARGS,"Ki"},
+    {"Kd", (PyCFunction) Method_arm_pid_instance_q15_Kd,METH_NOARGS,"Kd"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_pid_instance_q15,arm_pid_instance_q15_new,arm_pid_instance_q15_dealloc,arm_pid_instance_q15_init,arm_pid_instance_q15_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_pid_instance_q31 *instance;
+} dsp_arm_pid_instance_q31Object;
+
+
+static void
+arm_pid_instance_q31_dealloc(dsp_arm_pid_instance_q31Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_pid_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_pid_instance_q31Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_pid_instance_q31Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_pid_instance_q31));
+
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_pid_instance_q31_init(dsp_arm_pid_instance_q31Object *self, PyObject *args, PyObject *kwds)
+{
+
+char *kwlist[] = {
+"A0","A1","A2","state","Kp","Ki","Kd",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|iiiiiii", kwlist,&self->instance->A0
+,&self->instance->A1
+,&self->instance->A2
+,&self->instance->state
+,&self->instance->Kp
+,&self->instance->Ki
+,&self->instance->Kd
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_pid_instance_q31,A0,"i");
+GETFIELD(arm_pid_instance_q31,A1,"i");
+GETFIELD(arm_pid_instance_q31,A2,"i");
+GETFIELD(arm_pid_instance_q31,state,"i");
+GETFIELD(arm_pid_instance_q31,Kp,"i");
+GETFIELD(arm_pid_instance_q31,Ki,"i");
+GETFIELD(arm_pid_instance_q31,Kd,"i");
+
+
+static PyMethodDef arm_pid_instance_q31_methods[] = {
+
+    {"A0", (PyCFunction) Method_arm_pid_instance_q31_A0,METH_NOARGS,"A0"},
+    {"A1", (PyCFunction) Method_arm_pid_instance_q31_A1,METH_NOARGS,"A1"},
+    {"A2", (PyCFunction) Method_arm_pid_instance_q31_A2,METH_NOARGS,"A2"},
+    {"state", (PyCFunction) Method_arm_pid_instance_q31_state,METH_NOARGS,"state"},
+    {"Kp", (PyCFunction) Method_arm_pid_instance_q31_Kp,METH_NOARGS,"Kp"},
+    {"Ki", (PyCFunction) Method_arm_pid_instance_q31_Ki,METH_NOARGS,"Ki"},
+    {"Kd", (PyCFunction) Method_arm_pid_instance_q31_Kd,METH_NOARGS,"Kd"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_pid_instance_q31,arm_pid_instance_q31_new,arm_pid_instance_q31_dealloc,arm_pid_instance_q31_init,arm_pid_instance_q31_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_pid_instance_f32 *instance;
+} dsp_arm_pid_instance_f32Object;
+
+
+static void
+arm_pid_instance_f32_dealloc(dsp_arm_pid_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_pid_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_pid_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_pid_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_pid_instance_f32));
+
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_pid_instance_f32_init(dsp_arm_pid_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+char *kwlist[] = {
+"A0","A1","A2","state","Kp","Ki","Kd",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|fffffff", kwlist,&self->instance->A0
+,&self->instance->A1
+,&self->instance->A2
+,&self->instance->state
+,&self->instance->Kp
+,&self->instance->Ki
+,&self->instance->Kd
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_pid_instance_f32,A0,"f");
+GETFIELD(arm_pid_instance_f32,A1,"f");
+GETFIELD(arm_pid_instance_f32,A2,"f");
+GETFIELD(arm_pid_instance_f32,state,"f");
+GETFIELD(arm_pid_instance_f32,Kp,"f");
+GETFIELD(arm_pid_instance_f32,Ki,"f");
+GETFIELD(arm_pid_instance_f32,Kd,"f");
+
+
+static PyMethodDef arm_pid_instance_f32_methods[] = {
+
+    {"A0", (PyCFunction) Method_arm_pid_instance_f32_A0,METH_NOARGS,"A0"},
+    {"A1", (PyCFunction) Method_arm_pid_instance_f32_A1,METH_NOARGS,"A1"},
+    {"A2", (PyCFunction) Method_arm_pid_instance_f32_A2,METH_NOARGS,"A2"},
+    {"state", (PyCFunction) Method_arm_pid_instance_f32_state,METH_NOARGS,"state"},
+    {"Kp", (PyCFunction) Method_arm_pid_instance_f32_Kp,METH_NOARGS,"Kp"},
+    {"Ki", (PyCFunction) Method_arm_pid_instance_f32_Ki,METH_NOARGS,"Ki"},
+    {"Kd", (PyCFunction) Method_arm_pid_instance_f32_Kd,METH_NOARGS,"Kd"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_pid_instance_f32,arm_pid_instance_f32_new,arm_pid_instance_f32_dealloc,arm_pid_instance_f32_init,arm_pid_instance_f32_methods);
+
+
+
+
+void typeRegistration(PyObject *module) {
+
+  
+  
+  ADDTYPE(arm_pid_instance_q15);
+  ADDTYPE(arm_pid_instance_q31);
+  ADDTYPE(arm_pid_instance_f32);
+  
+  
+}
+
+
+static PyObject *
+cmsis_arm_pid_init_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  int32_t resetStateFlag; // input
+
+  if (PyArg_ParseTuple(args,"Oi",&S,&resetStateFlag))
+  {
+
+    dsp_arm_pid_instance_f32Object *selfS = (dsp_arm_pid_instance_f32Object *)S;
+
+    arm_pid_init_f32(selfS->instance,resetStateFlag);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_pid_reset_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+
+  if (PyArg_ParseTuple(args,"O",&S))
+  {
+
+    dsp_arm_pid_instance_f32Object *selfS = (dsp_arm_pid_instance_f32Object *)S;
+
+    arm_pid_reset_f32(selfS->instance);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_pid_init_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  int32_t resetStateFlag; // input
+
+  if (PyArg_ParseTuple(args,"Oi",&S,&resetStateFlag))
+  {
+
+    dsp_arm_pid_instance_q31Object *selfS = (dsp_arm_pid_instance_q31Object *)S;
+
+    arm_pid_init_q31(selfS->instance,resetStateFlag);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_pid_reset_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+
+  if (PyArg_ParseTuple(args,"O",&S))
+  {
+
+    dsp_arm_pid_instance_q31Object *selfS = (dsp_arm_pid_instance_q31Object *)S;
+
+    arm_pid_reset_q31(selfS->instance);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_pid_init_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  int32_t resetStateFlag; // input
+
+  if (PyArg_ParseTuple(args,"Oi",&S,&resetStateFlag))
+  {
+
+    dsp_arm_pid_instance_q15Object *selfS = (dsp_arm_pid_instance_q15Object *)S;
+
+    arm_pid_init_q15(selfS->instance,resetStateFlag);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_pid_reset_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+
+  if (PyArg_ParseTuple(args,"O",&S))
+  {
+
+    dsp_arm_pid_instance_q15Object *selfS = (dsp_arm_pid_instance_q15Object *)S;
+
+    arm_pid_reset_q15(selfS->instance);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+
+
+
+static PyObject *
+cmsis_arm_sin_cos_f32(PyObject *obj, PyObject *args)
+{
+
+  float32_t theta; // input
+  float32_t pS;
+  float32_t pC;
+
+  if (PyArg_ParseTuple(args,"f",&theta))
+  {
+
+
+    
+    arm_sin_cos_f32(theta,&pS,&pC);
+    
+    PyObject* retS=Py_BuildValue("f",pS);
+    PyObject* retC=Py_BuildValue("f",pC);
+
+    PyObject *pythonResult = Py_BuildValue("OO",retS,retC);
+
+    Py_DECREF(retS);
+    Py_DECREF(retC);
+
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_sin_cos_q31(PyObject *obj, PyObject *args)
+{
+
+  q31_t theta; // input
+  q31_t pS;
+  q31_t pC;
+
+  if (PyArg_ParseTuple(args,"i",&theta))
+  {
+
+    arm_sin_cos_q31(theta,&pS,&pC);
+    
+    PyObject* retS=Py_BuildValue("i",pS);
+    PyObject* retC=Py_BuildValue("i",pC);
+
+    PyObject *pythonResult = Py_BuildValue("OO",retS,retC);
+
+    Py_DECREF(retS);
+    Py_DECREF(retC);
+
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+
+static PyObject *
+cmsis_arm_pid_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  float32_t in; // input
+
+  if (PyArg_ParseTuple(args,"Of",&S,&in))
+  {
+
+    dsp_arm_pid_instance_f32Object *selfS = (dsp_arm_pid_instance_f32Object *)S;
+
+    float32_t returnValue = arm_pid_f32(selfS->instance,in);
+    PyObject* theReturnOBJ=Py_BuildValue("f",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_pid_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  q31_t in; // input
+
+  if (PyArg_ParseTuple(args,"Oi",&S,&in))
+  {
+
+    dsp_arm_pid_instance_q31Object *selfS = (dsp_arm_pid_instance_q31Object *)S;
+
+    q31_t returnValue = arm_pid_q31(selfS->instance,in);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_pid_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  q15_t in; // input
+
+  if (PyArg_ParseTuple(args,"Oh",&S,&in))
+  {
+
+    dsp_arm_pid_instance_q15Object *selfS = (dsp_arm_pid_instance_q15Object *)S;
+
+    q15_t returnValue = arm_pid_q15(selfS->instance,in);
+    PyObject* theReturnOBJ=Py_BuildValue("h",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+static PyObject *
+cmsis_arm_clarke_f32(PyObject *obj, PyObject *args)
+{
+
+  float32_t Ia; // input
+  float32_t Ib; // input
+  PyObject *pIalpha=NULL; // input
+  float32_t *pIalpha_converted=NULL; // input
+  PyObject *pIbeta=NULL; // input
+  float32_t *pIbeta_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"ffOO",&Ia,&Ib,&pIalpha,&pIbeta))
+  {
+
+    GETARGUMENT(pIalpha,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pIbeta,NPY_DOUBLE,double,float32_t);
+
+    arm_clarke_f32(Ia,Ib,pIalpha_converted,pIbeta_converted);
+    FREEARGUMENT(pIalpha_converted);
+    FREEARGUMENT(pIbeta_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_clarke_q31(PyObject *obj, PyObject *args)
+{
+
+  q31_t Ia; // input
+  q31_t Ib; // input
+  PyObject *pIalpha=NULL; // input
+  q31_t *pIalpha_converted=NULL; // input
+  PyObject *pIbeta=NULL; // input
+  q31_t *pIbeta_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"iiOO",&Ia,&Ib,&pIalpha,&pIbeta))
+  {
+
+    GETARGUMENT(pIalpha,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pIbeta,NPY_INT32,int32_t,int32_t);
+
+    arm_clarke_q31(Ia,Ib,pIalpha_converted,pIbeta_converted);
+    FREEARGUMENT(pIalpha_converted);
+    FREEARGUMENT(pIbeta_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+
+
+static PyObject *
+cmsis_arm_inv_clarke_f32(PyObject *obj, PyObject *args)
+{
+
+  float32_t Ialpha; // input
+  float32_t Ibeta; // input
+  PyObject *pIa=NULL; // input
+  float32_t *pIa_converted=NULL; // input
+  PyObject *pIb=NULL; // input
+  float32_t *pIb_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"ffOO",&Ialpha,&Ibeta,&pIa,&pIb))
+  {
+
+    GETARGUMENT(pIa,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pIb,NPY_DOUBLE,double,float32_t);
+
+    arm_inv_clarke_f32(Ialpha,Ibeta,pIa_converted,pIb_converted);
+    FREEARGUMENT(pIa_converted);
+    FREEARGUMENT(pIb_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_inv_clarke_q31(PyObject *obj, PyObject *args)
+{
+
+  q31_t Ialpha; // input
+  q31_t Ibeta; // input
+  PyObject *pIa=NULL; // input
+  q31_t *pIa_converted=NULL; // input
+  PyObject *pIb=NULL; // input
+  q31_t *pIb_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"iiOO",&Ialpha,&Ibeta,&pIa,&pIb))
+  {
+
+    GETARGUMENT(pIa,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pIb,NPY_INT32,int32_t,int32_t);
+
+    arm_inv_clarke_q31(Ialpha,Ibeta,pIa_converted,pIb_converted);
+    FREEARGUMENT(pIa_converted);
+    FREEARGUMENT(pIb_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+
+
+static PyObject *
+cmsis_arm_park_f32(PyObject *obj, PyObject *args)
+{
+
+  float32_t Ialpha; // input
+  float32_t Ibeta; // input
+  PyObject *pId=NULL; // input
+  float32_t *pId_converted=NULL; // input
+  PyObject *pIq=NULL; // input
+  float32_t *pIq_converted=NULL; // input
+  float32_t sinVal; // input
+  float32_t cosVal; // input
+
+  if (PyArg_ParseTuple(args,"ffOOff",&Ialpha,&Ibeta,&pId,&pIq,&sinVal,&cosVal))
+  {
+
+    GETARGUMENT(pId,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pIq,NPY_DOUBLE,double,float32_t);
+
+    arm_park_f32(Ialpha,Ibeta,pId_converted,pIq_converted,sinVal,cosVal);
+    FREEARGUMENT(pId_converted);
+    FREEARGUMENT(pIq_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_park_q31(PyObject *obj, PyObject *args)
+{
+
+  q31_t Ialpha; // input
+  q31_t Ibeta; // input
+  PyObject *pId=NULL; // input
+  q31_t *pId_converted=NULL; // input
+  PyObject *pIq=NULL; // input
+  q31_t *pIq_converted=NULL; // input
+  q31_t sinVal; // input
+  q31_t cosVal; // input
+
+  if (PyArg_ParseTuple(args,"iiOOii",&Ialpha,&Ibeta,&pId,&pIq,&sinVal,&cosVal))
+  {
+
+    GETARGUMENT(pId,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pIq,NPY_INT32,int32_t,int32_t);
+
+    arm_park_q31(Ialpha,Ibeta,pId_converted,pIq_converted,sinVal,cosVal);
+    FREEARGUMENT(pId_converted);
+    FREEARGUMENT(pIq_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+
+
+
+static PyObject *
+cmsis_arm_inv_park_f32(PyObject *obj, PyObject *args)
+{
+
+  float32_t Id; // input
+  float32_t Iq; // input
+  PyObject *pIalpha=NULL; // input
+  float32_t *pIalpha_converted=NULL; // input
+  PyObject *pIbeta=NULL; // input
+  float32_t *pIbeta_converted=NULL; // input
+  float32_t sinVal; // input
+  float32_t cosVal; // input
+
+  if (PyArg_ParseTuple(args,"ffOOff",&Id,&Iq,&pIalpha,&pIbeta,&sinVal,&cosVal))
+  {
+
+    GETARGUMENT(pIalpha,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pIbeta,NPY_DOUBLE,double,float32_t);
+
+    arm_inv_park_f32(Id,Iq,pIalpha_converted,pIbeta_converted,sinVal,cosVal);
+    FREEARGUMENT(pIalpha_converted);
+    FREEARGUMENT(pIbeta_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_inv_park_q31(PyObject *obj, PyObject *args)
+{
+
+  q31_t Id; // input
+  q31_t Iq; // input
+  PyObject *pIalpha=NULL; // input
+  q31_t *pIalpha_converted=NULL; // input
+  PyObject *pIbeta=NULL; // input
+  q31_t *pIbeta_converted=NULL; // input
+  q31_t sinVal; // input
+  q31_t cosVal; // input
+
+  if (PyArg_ParseTuple(args,"iiOOii",&Id,&Iq,&pIalpha,&pIbeta,&sinVal,&cosVal))
+  {
+
+    GETARGUMENT(pIalpha,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pIbeta,NPY_INT32,int32_t,int32_t);
+
+    arm_inv_park_q31(Id,Iq,pIalpha_converted,pIbeta_converted,sinVal,cosVal);
+    FREEARGUMENT(pIalpha_converted);
+    FREEARGUMENT(pIbeta_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+
+
+static PyMethodDef CMSISDSPMethods[] = {
+
+
+
+{"arm_pid_init_f32",  cmsis_arm_pid_init_f32, METH_VARARGS,""},
+{"arm_pid_reset_f32",  cmsis_arm_pid_reset_f32, METH_VARARGS,""},
+{"arm_pid_init_q31",  cmsis_arm_pid_init_q31, METH_VARARGS,""},
+{"arm_pid_reset_q31",  cmsis_arm_pid_reset_q31, METH_VARARGS,""},
+{"arm_pid_init_q15",  cmsis_arm_pid_init_q15, METH_VARARGS,""},
+{"arm_pid_reset_q15",  cmsis_arm_pid_reset_q15, METH_VARARGS,""},
+
+
+{"arm_sin_cos_f32",  cmsis_arm_sin_cos_f32, METH_VARARGS,""},
+{"arm_sin_cos_q31",  cmsis_arm_sin_cos_q31, METH_VARARGS,""},
+
+{"arm_pid_f32",  cmsis_arm_pid_f32, METH_VARARGS,""},
+{"arm_pid_q31",  cmsis_arm_pid_q31, METH_VARARGS,""},
+{"arm_pid_q15",  cmsis_arm_pid_q15, METH_VARARGS,""},
+
+{"arm_clarke_f32",  cmsis_arm_clarke_f32, METH_VARARGS,""},
+{"arm_clarke_q31",  cmsis_arm_clarke_q31, METH_VARARGS,""},
+{"arm_inv_clarke_f32",  cmsis_arm_inv_clarke_f32, METH_VARARGS,""},
+{"arm_inv_clarke_q31",  cmsis_arm_inv_clarke_q31, METH_VARARGS,""},
+{"arm_park_f32",  cmsis_arm_park_f32, METH_VARARGS,""},
+{"arm_park_q31",  cmsis_arm_park_q31, METH_VARARGS,""},
+{"arm_inv_park_f32",  cmsis_arm_inv_park_f32, METH_VARARGS,""},
+{"arm_inv_park_q31",  cmsis_arm_inv_park_q31, METH_VARARGS,""},
+
+
+    {"error_out", (PyCFunction)error_out, METH_NOARGS, NULL},
+    {NULL, NULL, 0, NULL}        /* Sentinel */
+};
+
+#ifdef IS_PY3K
+static int cmsisdsp_traverse(PyObject *m, visitproc visit, void *arg) {
+    Py_VISIT(GETSTATE(m)->error);
+    return 0;
+}
+
+static int cmsisdsp_clear(PyObject *m) {
+    Py_CLEAR(GETSTATE(m)->error);
+    return 0;
+}
+
+
+static struct PyModuleDef moduledef = {
+        PyModuleDef_HEAD_INIT,
+        MODNAME,
+        NULL,
+        sizeof(struct module_state),
+        CMSISDSPMethods,
+        NULL,
+        cmsisdsp_traverse,
+        cmsisdsp_clear,
+        NULL
+};
+
+#define INITERROR return NULL
+
+PyMODINIT_FUNC
+CAT(PyInit_,MODINITNAME)(void)
+
+
+#else
+#define INITERROR return
+
+void CAT(init,MODINITNAME)(void)
+#endif
+{
+    import_array();
+
+  #ifdef IS_PY3K
+    PyObject *module = PyModule_Create(&moduledef);
+  #else
+    PyObject *module = Py_InitModule(MODNAME, CMSISDSPMethods);
+  #endif
+
+  if (module == NULL)
+      INITERROR;
+  struct module_state *st = GETSTATE(module);
+  
+  st->error = PyErr_NewException(MODNAME".Error", NULL, NULL);
+  if (st->error == NULL) {
+      Py_DECREF(module);
+      INITERROR;
+  }
+
+
+  typeRegistration(module);
+
+  #ifdef IS_PY3K
+    return module;
+  #endif
+}

PythonWrapper/cmsisdsp_pkg/src/cmsisdsp_fastmath.c

@@ -0,0 +1,479 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Python Wrapper
+ * Title:        cmsismodule.h
+ * Description:  C code for the CMSIS-DSP Python wrapper
+ *
+ * $Date:        27 April 2021
+ * $Revision:    V1.0
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define MODNAME "cmsisdsp_fastmath"
+#define MODINITNAME cmsisdsp_fastmath
+
+#include "cmsisdsp_module.h"
+
+
+NUMPYVECTORFROMBUFFER(f32,float32_t,NPY_FLOAT);
+
+
+
+
+void typeRegistration(PyObject *module) {
+
+ 
+}
+
+
+
+static PyObject *
+cmsis_arm_vlog_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_vlog_q15(pSrc_converted,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+
+static PyObject *
+cmsis_arm_vlog_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_vlog_q31(pSrc_converted,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+static PyObject *
+cmsis_arm_sin_f32(PyObject *obj, PyObject *args)
+{
+
+  float32_t x; // input
+
+  if (PyArg_ParseTuple(args,"f",&x))
+  {
+
+
+    float32_t returnValue = arm_sin_f32(x);
+    PyObject* theReturnOBJ=Py_BuildValue("f",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_sin_q31(PyObject *obj, PyObject *args)
+{
+
+  q31_t x; // input
+
+  if (PyArg_ParseTuple(args,"i",&x))
+  {
+
+
+    q31_t returnValue = arm_sin_q31(x);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_sin_q15(PyObject *obj, PyObject *args)
+{
+
+  q15_t x; // input
+
+  if (PyArg_ParseTuple(args,"h",&x))
+  {
+
+
+    q15_t returnValue = arm_sin_q15(x);
+    PyObject* theReturnOBJ=Py_BuildValue("h",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cos_f32(PyObject *obj, PyObject *args)
+{
+
+  float32_t x; // input
+
+  if (PyArg_ParseTuple(args,"f",&x))
+  {
+
+
+    float32_t returnValue = arm_cos_f32(x);
+    PyObject* theReturnOBJ=Py_BuildValue("f",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cos_q31(PyObject *obj, PyObject *args)
+{
+
+  q31_t x; // input
+
+  if (PyArg_ParseTuple(args,"i",&x))
+  {
+
+
+    q31_t returnValue = arm_cos_q31(x);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cos_q15(PyObject *obj, PyObject *args)
+{
+
+  q15_t x; // input
+
+  if (PyArg_ParseTuple(args,"h",&x))
+  {
+
+
+    q15_t returnValue = arm_cos_q15(x);
+    PyObject* theReturnOBJ=Py_BuildValue("h",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_sqrt_f32(PyObject *obj, PyObject *args)
+{
+
+  float32_t in; // input
+  float32_t pOut; // output
+
+  if (PyArg_ParseTuple(args,"f",&in))
+  {
+
+
+    arm_status returnValue = arm_sqrt_f32(in,&pOut);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pOutOBJ=Py_BuildValue("f",pOut);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pOutOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    Py_DECREF(pOutOBJ);
+
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_sqrt_q31(PyObject *obj, PyObject *args)
+{
+
+  q31_t in; // input
+  q31_t pOut; // output
+
+  if (PyArg_ParseTuple(args,"i",&in))
+  {
+
+
+
+
+    arm_status returnValue = arm_sqrt_q31(in,&pOut);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pOutOBJ=Py_BuildValue("i",pOut);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pOutOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    Py_DECREF(pOutOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_divide_q31(PyObject *obj, PyObject *args)
+{
+
+  q31_t num,den; // input
+  q31_t pOut;
+  int16_t shift; // output
+
+  if (PyArg_ParseTuple(args,"ii",&num,&den))
+  {
+
+
+
+    arm_status returnValue = arm_divide_q31(num,den,&pOut,&shift);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pOutOBJ=Py_BuildValue("i",pOut);
+    PyObject* pShiftOBJ=Py_BuildValue("h",shift);
+
+    PyObject *pythonResult = Py_BuildValue("OOO",theReturnOBJ,pOutOBJ,pShiftOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    Py_DECREF(pOutOBJ);
+    Py_DECREF(pShiftOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_divide_q15(PyObject *obj, PyObject *args)
+{
+
+  q15_t num,den; // input
+  q15_t pOut;
+  int16_t shift; // output
+
+  if (PyArg_ParseTuple(args,"hh",&num,&den))
+  {
+
+
+
+    arm_status returnValue = arm_divide_q15(num,den,&pOut,&shift);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pOutOBJ=Py_BuildValue("h",pOut);
+    PyObject* pShiftOBJ=Py_BuildValue("h",shift);
+
+    PyObject *pythonResult = Py_BuildValue("OOO",theReturnOBJ,pOutOBJ,pShiftOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    Py_DECREF(pOutOBJ);
+    Py_DECREF(pShiftOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_sqrt_q15(PyObject *obj, PyObject *args)
+{
+
+  q15_t in; // input
+  q15_t pOut; // output
+
+  if (PyArg_ParseTuple(args,"h",&in))
+  {
+
+
+
+    arm_status returnValue = arm_sqrt_q15(in,&pOut);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pOutOBJ=Py_BuildValue("h",pOut);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pOutOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    Py_DECREF(pOutOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+
+
+static PyMethodDef CMSISDSPMethods[] = {
+
+
+
+
+{"arm_vlog_q15",  cmsis_arm_vlog_q15, METH_VARARGS,""},
+{"arm_vlog_q31",  cmsis_arm_vlog_q31, METH_VARARGS,""},
+
+
+{"arm_sin_f32",  cmsis_arm_sin_f32, METH_VARARGS,""},
+{"arm_sin_q31",  cmsis_arm_sin_q31, METH_VARARGS,""},
+{"arm_sin_q15",  cmsis_arm_sin_q15, METH_VARARGS,""},
+{"arm_cos_f32",  cmsis_arm_cos_f32, METH_VARARGS,""},
+{"arm_cos_q31",  cmsis_arm_cos_q31, METH_VARARGS,""},
+{"arm_cos_q15",  cmsis_arm_cos_q15, METH_VARARGS,""},
+{"arm_sqrt_f32",  cmsis_arm_sqrt_f32, METH_VARARGS,""},
+{"arm_sqrt_q31",  cmsis_arm_sqrt_q31, METH_VARARGS,""},
+{"arm_sqrt_q15",  cmsis_arm_sqrt_q15, METH_VARARGS,""},
+{"arm_divide_q31",  cmsis_arm_divide_q31, METH_VARARGS,""},
+{"arm_divide_q15",  cmsis_arm_divide_q15, METH_VARARGS,""},
+
+    {"error_out", (PyCFunction)error_out, METH_NOARGS, NULL},
+    {NULL, NULL, 0, NULL}        /* Sentinel */
+};
+
+#ifdef IS_PY3K
+static int cmsisdsp_traverse(PyObject *m, visitproc visit, void *arg) {
+    Py_VISIT(GETSTATE(m)->error);
+    return 0;
+}
+
+static int cmsisdsp_clear(PyObject *m) {
+    Py_CLEAR(GETSTATE(m)->error);
+    return 0;
+}
+
+
+static struct PyModuleDef moduledef = {
+        PyModuleDef_HEAD_INIT,
+        MODNAME,
+        NULL,
+        sizeof(struct module_state),
+        CMSISDSPMethods,
+        NULL,
+        cmsisdsp_traverse,
+        cmsisdsp_clear,
+        NULL
+};
+
+#define INITERROR return NULL
+
+PyMODINIT_FUNC
+CAT(PyInit_,MODINITNAME)(void)
+
+
+#else
+#define INITERROR return
+
+void CAT(init,MODINITNAME)(void)
+#endif
+{
+    import_array();
+
+  #ifdef IS_PY3K
+    PyObject *module = PyModule_Create(&moduledef);
+  #else
+    PyObject *module = Py_InitModule(MODNAME, CMSISDSPMethods);
+  #endif
+
+  if (module == NULL)
+      INITERROR;
+  struct module_state *st = GETSTATE(module);
+  
+  st->error = PyErr_NewException(MODNAME".Error", NULL, NULL);
+  if (st->error == NULL) {
+      Py_DECREF(module);
+      INITERROR;
+  }
+
+
+  typeRegistration(module);
+
+  #ifdef IS_PY3K
+    return module;
+  #endif
+}

PythonWrapper/cmsisdsp_pkg/src/cmsisdsp_filtering.c

@@ -0,0 +1,6878 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Python Wrapper
+ * Title:        cmsismodule.h
+ * Description:  C code for the CMSIS-DSP Python wrapper
+ *
+ * $Date:        27 April 2021
+ * $Revision:    V1.0
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define MODNAME "cmsisdsp_filtering"
+#define MODINITNAME cmsisdsp_filtering
+
+#include "cmsisdsp_module.h"
+
+NUMPYVECTORFROMBUFFER(f32,float32_t,NPY_FLOAT);
+
+typedef struct {
+    PyObject_HEAD
+    arm_fir_instance_q7 *instance;
+} dsp_arm_fir_instance_q7Object;
+
+
+static void
+arm_fir_instance_q7_dealloc(dsp_arm_fir_instance_q7Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((q7_t*)self->instance->pCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_fir_instance_q7_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_fir_instance_q7Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_fir_instance_q7Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_fir_instance_q7));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_fir_instance_q7_init(dsp_arm_fir_instance_q7Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+char *kwlist[] = {
+"numTaps",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|h", kwlist,&self->instance->numTaps
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_fir_instance_q7,numTaps,"h");
+
+
+static PyMethodDef arm_fir_instance_q7_methods[] = {
+
+    {"numTaps", (PyCFunction) Method_arm_fir_instance_q7_numTaps,METH_NOARGS,"numTaps"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_fir_instance_q7,arm_fir_instance_q7_new,arm_fir_instance_q7_dealloc,arm_fir_instance_q7_init,arm_fir_instance_q7_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_fir_instance_q15 *instance;
+} dsp_arm_fir_instance_q15Object;
+
+
+static void
+arm_fir_instance_q15_dealloc(dsp_arm_fir_instance_q15Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((q15_t*)self->instance->pCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_fir_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_fir_instance_q15Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_fir_instance_q15Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_fir_instance_q15));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_fir_instance_q15_init(dsp_arm_fir_instance_q15Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+char *kwlist[] = {
+"numTaps",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|h", kwlist,&self->instance->numTaps
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_fir_instance_q15,numTaps,"h");
+
+
+static PyMethodDef arm_fir_instance_q15_methods[] = {
+
+    {"numTaps", (PyCFunction) Method_arm_fir_instance_q15_numTaps,METH_NOARGS,"numTaps"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_fir_instance_q15,arm_fir_instance_q15_new,arm_fir_instance_q15_dealloc,arm_fir_instance_q15_init,arm_fir_instance_q15_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_fir_instance_q31 *instance;
+} dsp_arm_fir_instance_q31Object;
+
+
+static void
+arm_fir_instance_q31_dealloc(dsp_arm_fir_instance_q31Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((q31_t*)self->instance->pCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_fir_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_fir_instance_q31Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_fir_instance_q31Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_fir_instance_q31));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_fir_instance_q31_init(dsp_arm_fir_instance_q31Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+char *kwlist[] = {
+"numTaps",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|h", kwlist,&self->instance->numTaps
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_fir_instance_q31,numTaps,"h");
+
+
+static PyMethodDef arm_fir_instance_q31_methods[] = {
+
+    {"numTaps", (PyCFunction) Method_arm_fir_instance_q31_numTaps,METH_NOARGS,"numTaps"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_fir_instance_q31,arm_fir_instance_q31_new,arm_fir_instance_q31_dealloc,arm_fir_instance_q31_init,arm_fir_instance_q31_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_fir_instance_f32 *instance;
+} dsp_arm_fir_instance_f32Object;
+
+
+static void
+arm_fir_instance_f32_dealloc(dsp_arm_fir_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((float32_t*)self->instance->pCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_fir_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_fir_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_fir_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_fir_instance_f32));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_fir_instance_f32_init(dsp_arm_fir_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+char *kwlist[] = {
+"numTaps",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|h", kwlist,&self->instance->numTaps
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_fir_instance_f32,numTaps,"h");
+
+
+static PyMethodDef arm_fir_instance_f32_methods[] = {
+
+    {"numTaps", (PyCFunction) Method_arm_fir_instance_f32_numTaps,METH_NOARGS,"numTaps"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_fir_instance_f32,arm_fir_instance_f32_new,arm_fir_instance_f32_dealloc,arm_fir_instance_f32_init,arm_fir_instance_f32_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_biquad_casd_df1_inst_q15 *instance;
+} dsp_arm_biquad_casd_df1_inst_q15Object;
+
+
+static void
+arm_biquad_casd_df1_inst_q15_dealloc(dsp_arm_biquad_casd_df1_inst_q15Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((q15_t*)self->instance->pCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_biquad_casd_df1_inst_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_biquad_casd_df1_inst_q15Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_biquad_casd_df1_inst_q15Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_biquad_casd_df1_inst_q15));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_biquad_casd_df1_inst_q15_init(dsp_arm_biquad_casd_df1_inst_q15Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+char *kwlist[] = {
+"numStages","postShift",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|ii", kwlist,&self->instance->numStages
+,&self->instance->postShift
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_biquad_casd_df1_inst_q15,numStages,"i");
+GETFIELD(arm_biquad_casd_df1_inst_q15,postShift,"i");
+
+
+static PyMethodDef arm_biquad_casd_df1_inst_q15_methods[] = {
+
+    {"numStages", (PyCFunction) Method_arm_biquad_casd_df1_inst_q15_numStages,METH_NOARGS,"numStages"},
+    {"postShift", (PyCFunction) Method_arm_biquad_casd_df1_inst_q15_postShift,METH_NOARGS,"postShift"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_biquad_casd_df1_inst_q15,arm_biquad_casd_df1_inst_q15_new,arm_biquad_casd_df1_inst_q15_dealloc,arm_biquad_casd_df1_inst_q15_init,arm_biquad_casd_df1_inst_q15_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_biquad_casd_df1_inst_q31 *instance;
+} dsp_arm_biquad_casd_df1_inst_q31Object;
+
+
+static void
+arm_biquad_casd_df1_inst_q31_dealloc(dsp_arm_biquad_casd_df1_inst_q31Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((q31_t*)self->instance->pCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_biquad_casd_df1_inst_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_biquad_casd_df1_inst_q31Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_biquad_casd_df1_inst_q31Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_biquad_casd_df1_inst_q31));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_biquad_casd_df1_inst_q31_init(dsp_arm_biquad_casd_df1_inst_q31Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+char *kwlist[] = {
+"numStages","postShift",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|ii", kwlist,&self->instance->numStages
+,&self->instance->postShift
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_biquad_casd_df1_inst_q31,numStages,"i");
+GETFIELD(arm_biquad_casd_df1_inst_q31,postShift,"i");
+
+
+static PyMethodDef arm_biquad_casd_df1_inst_q31_methods[] = {
+
+    {"numStages", (PyCFunction) Method_arm_biquad_casd_df1_inst_q31_numStages,METH_NOARGS,"numStages"},
+    {"postShift", (PyCFunction) Method_arm_biquad_casd_df1_inst_q31_postShift,METH_NOARGS,"postShift"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_biquad_casd_df1_inst_q31,arm_biquad_casd_df1_inst_q31_new,arm_biquad_casd_df1_inst_q31_dealloc,arm_biquad_casd_df1_inst_q31_init,arm_biquad_casd_df1_inst_q31_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_biquad_casd_df1_inst_f32 *instance;
+} dsp_arm_biquad_casd_df1_inst_f32Object;
+
+
+static void
+arm_biquad_casd_df1_inst_f32_dealloc(dsp_arm_biquad_casd_df1_inst_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((float32_t*)self->instance->pCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_biquad_casd_df1_inst_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_biquad_casd_df1_inst_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_biquad_casd_df1_inst_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_biquad_casd_df1_inst_f32));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_biquad_casd_df1_inst_f32_init(dsp_arm_biquad_casd_df1_inst_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+char *kwlist[] = {
+"numStages",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|i", kwlist,&self->instance->numStages
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_biquad_casd_df1_inst_f32,numStages,"i");
+
+
+static PyMethodDef arm_biquad_casd_df1_inst_f32_methods[] = {
+
+    {"numStages", (PyCFunction) Method_arm_biquad_casd_df1_inst_f32_numStages,METH_NOARGS,"numStages"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_biquad_casd_df1_inst_f32,arm_biquad_casd_df1_inst_f32_new,arm_biquad_casd_df1_inst_f32_dealloc,arm_biquad_casd_df1_inst_f32_init,arm_biquad_casd_df1_inst_f32_methods);
+
+
+
+
+
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_fir_decimate_instance_q15 *instance;
+} dsp_arm_fir_decimate_instance_q15Object;
+
+
+static void
+arm_fir_decimate_instance_q15_dealloc(dsp_arm_fir_decimate_instance_q15Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((q15_t*)self->instance->pCoeffs);
+       }
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_fir_decimate_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_fir_decimate_instance_q15Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_fir_decimate_instance_q15Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_fir_decimate_instance_q15));
+
+        self->instance->pCoeffs = NULL;
+        self->instance->pState = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_fir_decimate_instance_q15_init(dsp_arm_fir_decimate_instance_q15Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pCoeffs=NULL;
+    PyObject *pState=NULL;
+char *kwlist[] = {
+"M","numTaps",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|ih", kwlist,&self->instance->M
+,&self->instance->numTaps
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_fir_decimate_instance_q15,M,"i");
+GETFIELD(arm_fir_decimate_instance_q15,numTaps,"h");
+
+
+static PyMethodDef arm_fir_decimate_instance_q15_methods[] = {
+
+    {"M", (PyCFunction) Method_arm_fir_decimate_instance_q15_M,METH_NOARGS,"M"},
+    {"numTaps", (PyCFunction) Method_arm_fir_decimate_instance_q15_numTaps,METH_NOARGS,"numTaps"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_fir_decimate_instance_q15,arm_fir_decimate_instance_q15_new,arm_fir_decimate_instance_q15_dealloc,arm_fir_decimate_instance_q15_init,arm_fir_decimate_instance_q15_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_fir_decimate_instance_q31 *instance;
+} dsp_arm_fir_decimate_instance_q31Object;
+
+
+static void
+arm_fir_decimate_instance_q31_dealloc(dsp_arm_fir_decimate_instance_q31Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((q31_t*)self->instance->pCoeffs);
+       }
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_fir_decimate_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_fir_decimate_instance_q31Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_fir_decimate_instance_q31Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_fir_decimate_instance_q31));
+
+        self->instance->pCoeffs = NULL;
+        self->instance->pState = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_fir_decimate_instance_q31_init(dsp_arm_fir_decimate_instance_q31Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pCoeffs=NULL;
+    PyObject *pState=NULL;
+char *kwlist[] = {
+"M","numTaps",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|ih", kwlist,&self->instance->M
+,&self->instance->numTaps
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_fir_decimate_instance_q31,M,"i");
+GETFIELD(arm_fir_decimate_instance_q31,numTaps,"h");
+
+
+static PyMethodDef arm_fir_decimate_instance_q31_methods[] = {
+
+    {"M", (PyCFunction) Method_arm_fir_decimate_instance_q31_M,METH_NOARGS,"M"},
+    {"numTaps", (PyCFunction) Method_arm_fir_decimate_instance_q31_numTaps,METH_NOARGS,"numTaps"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_fir_decimate_instance_q31,arm_fir_decimate_instance_q31_new,arm_fir_decimate_instance_q31_dealloc,arm_fir_decimate_instance_q31_init,arm_fir_decimate_instance_q31_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_fir_decimate_instance_f32 *instance;
+} dsp_arm_fir_decimate_instance_f32Object;
+
+
+static void
+arm_fir_decimate_instance_f32_dealloc(dsp_arm_fir_decimate_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((float32_t*)self->instance->pCoeffs);
+       }
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_fir_decimate_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_fir_decimate_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_fir_decimate_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_fir_decimate_instance_f32));
+
+        self->instance->pCoeffs = NULL;
+        self->instance->pState = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_fir_decimate_instance_f32_init(dsp_arm_fir_decimate_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pCoeffs=NULL;
+    PyObject *pState=NULL;
+char *kwlist[] = {
+"M","numTaps",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|ih", kwlist,&self->instance->M
+,&self->instance->numTaps
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_fir_decimate_instance_f32,M,"i");
+GETFIELD(arm_fir_decimate_instance_f32,numTaps,"h");
+
+
+static PyMethodDef arm_fir_decimate_instance_f32_methods[] = {
+
+    {"M", (PyCFunction) Method_arm_fir_decimate_instance_f32_M,METH_NOARGS,"M"},
+    {"numTaps", (PyCFunction) Method_arm_fir_decimate_instance_f32_numTaps,METH_NOARGS,"numTaps"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_fir_decimate_instance_f32,arm_fir_decimate_instance_f32_new,arm_fir_decimate_instance_f32_dealloc,arm_fir_decimate_instance_f32_init,arm_fir_decimate_instance_f32_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_fir_interpolate_instance_q15 *instance;
+} dsp_arm_fir_interpolate_instance_q15Object;
+
+
+static void
+arm_fir_interpolate_instance_q15_dealloc(dsp_arm_fir_interpolate_instance_q15Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((q15_t*)self->instance->pCoeffs);
+       }
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_fir_interpolate_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_fir_interpolate_instance_q15Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_fir_interpolate_instance_q15Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_fir_interpolate_instance_q15));
+
+        self->instance->pCoeffs = NULL;
+        self->instance->pState = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_fir_interpolate_instance_q15_init(dsp_arm_fir_interpolate_instance_q15Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pCoeffs=NULL;
+    PyObject *pState=NULL;
+char *kwlist[] = {
+"L","phaseLength",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|ih", kwlist,&self->instance->L
+,&self->instance->phaseLength
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_fir_interpolate_instance_q15,L,"i");
+GETFIELD(arm_fir_interpolate_instance_q15,phaseLength,"h");
+
+
+static PyMethodDef arm_fir_interpolate_instance_q15_methods[] = {
+
+    {"L", (PyCFunction) Method_arm_fir_interpolate_instance_q15_L,METH_NOARGS,"L"},
+    {"phaseLength", (PyCFunction) Method_arm_fir_interpolate_instance_q15_phaseLength,METH_NOARGS,"phaseLength"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_fir_interpolate_instance_q15,arm_fir_interpolate_instance_q15_new,arm_fir_interpolate_instance_q15_dealloc,arm_fir_interpolate_instance_q15_init,arm_fir_interpolate_instance_q15_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_fir_interpolate_instance_q31 *instance;
+} dsp_arm_fir_interpolate_instance_q31Object;
+
+
+static void
+arm_fir_interpolate_instance_q31_dealloc(dsp_arm_fir_interpolate_instance_q31Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((q31_t*)self->instance->pCoeffs);
+       }
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_fir_interpolate_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_fir_interpolate_instance_q31Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_fir_interpolate_instance_q31Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_fir_interpolate_instance_q31));
+
+        self->instance->pCoeffs = NULL;
+        self->instance->pState = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_fir_interpolate_instance_q31_init(dsp_arm_fir_interpolate_instance_q31Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pCoeffs=NULL;
+    PyObject *pState=NULL;
+char *kwlist[] = {
+"L","phaseLength",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|ih", kwlist,&self->instance->L
+,&self->instance->phaseLength
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_fir_interpolate_instance_q31,L,"i");
+GETFIELD(arm_fir_interpolate_instance_q31,phaseLength,"h");
+
+
+static PyMethodDef arm_fir_interpolate_instance_q31_methods[] = {
+
+    {"L", (PyCFunction) Method_arm_fir_interpolate_instance_q31_L,METH_NOARGS,"L"},
+    {"phaseLength", (PyCFunction) Method_arm_fir_interpolate_instance_q31_phaseLength,METH_NOARGS,"phaseLength"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_fir_interpolate_instance_q31,arm_fir_interpolate_instance_q31_new,arm_fir_interpolate_instance_q31_dealloc,arm_fir_interpolate_instance_q31_init,arm_fir_interpolate_instance_q31_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_fir_interpolate_instance_f32 *instance;
+} dsp_arm_fir_interpolate_instance_f32Object;
+
+
+static void
+arm_fir_interpolate_instance_f32_dealloc(dsp_arm_fir_interpolate_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((float32_t*)self->instance->pCoeffs);
+       }
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_fir_interpolate_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_fir_interpolate_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_fir_interpolate_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_fir_interpolate_instance_f32));
+
+        self->instance->pCoeffs = NULL;
+        self->instance->pState = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_fir_interpolate_instance_f32_init(dsp_arm_fir_interpolate_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pCoeffs=NULL;
+    PyObject *pState=NULL;
+char *kwlist[] = {
+"L","phaseLength",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|ih", kwlist,&self->instance->L
+,&self->instance->phaseLength
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_fir_interpolate_instance_f32,L,"i");
+GETFIELD(arm_fir_interpolate_instance_f32,phaseLength,"h");
+
+
+static PyMethodDef arm_fir_interpolate_instance_f32_methods[] = {
+
+    {"L", (PyCFunction) Method_arm_fir_interpolate_instance_f32_L,METH_NOARGS,"L"},
+    {"phaseLength", (PyCFunction) Method_arm_fir_interpolate_instance_f32_phaseLength,METH_NOARGS,"phaseLength"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_fir_interpolate_instance_f32,arm_fir_interpolate_instance_f32_new,arm_fir_interpolate_instance_f32_dealloc,arm_fir_interpolate_instance_f32_init,arm_fir_interpolate_instance_f32_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_biquad_cas_df1_32x64_ins_q31 *instance;
+} dsp_arm_biquad_cas_df1_32x64_ins_q31Object;
+
+
+static void
+arm_biquad_cas_df1_32x64_ins_q31_dealloc(dsp_arm_biquad_cas_df1_32x64_ins_q31Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((q31_t*)self->instance->pCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_biquad_cas_df1_32x64_ins_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_biquad_cas_df1_32x64_ins_q31Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_biquad_cas_df1_32x64_ins_q31Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_biquad_cas_df1_32x64_ins_q31));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_biquad_cas_df1_32x64_ins_q31_init(dsp_arm_biquad_cas_df1_32x64_ins_q31Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+char *kwlist[] = {
+"numStages","postShift",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|ii", kwlist,&self->instance->numStages
+,&self->instance->postShift
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_biquad_cas_df1_32x64_ins_q31,numStages,"i");
+GETFIELD(arm_biquad_cas_df1_32x64_ins_q31,postShift,"i");
+
+
+static PyMethodDef arm_biquad_cas_df1_32x64_ins_q31_methods[] = {
+
+    {"numStages", (PyCFunction) Method_arm_biquad_cas_df1_32x64_ins_q31_numStages,METH_NOARGS,"numStages"},
+    {"postShift", (PyCFunction) Method_arm_biquad_cas_df1_32x64_ins_q31_postShift,METH_NOARGS,"postShift"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_biquad_cas_df1_32x64_ins_q31,arm_biquad_cas_df1_32x64_ins_q31_new,arm_biquad_cas_df1_32x64_ins_q31_dealloc,arm_biquad_cas_df1_32x64_ins_q31_init,arm_biquad_cas_df1_32x64_ins_q31_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_biquad_cascade_df2T_instance_f32 *instance;
+} dsp_arm_biquad_cascade_df2T_instance_f32Object;
+
+
+static void
+arm_biquad_cascade_df2T_instance_f32_dealloc(dsp_arm_biquad_cascade_df2T_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((float32_t*)self->instance->pCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_biquad_cascade_df2T_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_biquad_cascade_df2T_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_biquad_cascade_df2T_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_biquad_cascade_df2T_instance_f32));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_biquad_cascade_df2T_instance_f32_init(dsp_arm_biquad_cascade_df2T_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+char *kwlist[] = {
+"numStages",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|i", kwlist,&self->instance->numStages
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_biquad_cascade_df2T_instance_f32,numStages,"i");
+
+static PyObject *                                                             
+Method_arm_biquad_cascade_df2T_instance_f32_state(dsp_arm_biquad_cascade_df2T_instance_f32Object *self, PyObject *ignored)
+{                
+    float32_t *state=self->instance->pState;
+    return(NumpyVectorFromf32Buffer(state,self->instance->numStages * 2));                                                  
+} 
+
+static PyMethodDef arm_biquad_cascade_df2T_instance_f32_methods[] = {
+
+    {"numStages", (PyCFunction) Method_arm_biquad_cascade_df2T_instance_f32_numStages,METH_NOARGS,"numStages"},
+    {"state", (PyCFunction) Method_arm_biquad_cascade_df2T_instance_f32_state,METH_NOARGS,"state"},
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_biquad_cascade_df2T_instance_f32,arm_biquad_cascade_df2T_instance_f32_new,arm_biquad_cascade_df2T_instance_f32_dealloc,arm_biquad_cascade_df2T_instance_f32_init,arm_biquad_cascade_df2T_instance_f32_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_biquad_cascade_stereo_df2T_instance_f32 *instance;
+} dsp_arm_biquad_cascade_stereo_df2T_instance_f32Object;
+
+
+static void
+arm_biquad_cascade_stereo_df2T_instance_f32_dealloc(dsp_arm_biquad_cascade_stereo_df2T_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((float32_t*)self->instance->pCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_biquad_cascade_stereo_df2T_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_biquad_cascade_stereo_df2T_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_biquad_cascade_stereo_df2T_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_biquad_cascade_stereo_df2T_instance_f32));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_biquad_cascade_stereo_df2T_instance_f32_init(dsp_arm_biquad_cascade_stereo_df2T_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+char *kwlist[] = {
+"numStages",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|i", kwlist,&self->instance->numStages
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_biquad_cascade_stereo_df2T_instance_f32,numStages,"i");
+
+
+static PyMethodDef arm_biquad_cascade_stereo_df2T_instance_f32_methods[] = {
+
+    {"numStages", (PyCFunction) Method_arm_biquad_cascade_stereo_df2T_instance_f32_numStages,METH_NOARGS,"numStages"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_biquad_cascade_stereo_df2T_instance_f32,arm_biquad_cascade_stereo_df2T_instance_f32_new,arm_biquad_cascade_stereo_df2T_instance_f32_dealloc,arm_biquad_cascade_stereo_df2T_instance_f32_init,arm_biquad_cascade_stereo_df2T_instance_f32_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_biquad_cascade_df2T_instance_f64 *instance;
+} dsp_arm_biquad_cascade_df2T_instance_f64Object;
+
+
+static void
+arm_biquad_cascade_df2T_instance_f64_dealloc(dsp_arm_biquad_cascade_df2T_instance_f64Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((float64_t*)self->instance->pCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_biquad_cascade_df2T_instance_f64_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_biquad_cascade_df2T_instance_f64Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_biquad_cascade_df2T_instance_f64Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_biquad_cascade_df2T_instance_f64));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_biquad_cascade_df2T_instance_f64_init(dsp_arm_biquad_cascade_df2T_instance_f64Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+char *kwlist[] = {
+"numStages",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|i", kwlist,&self->instance->numStages
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_biquad_cascade_df2T_instance_f64,numStages,"i");
+
+
+static PyMethodDef arm_biquad_cascade_df2T_instance_f64_methods[] = {
+
+    {"numStages", (PyCFunction) Method_arm_biquad_cascade_df2T_instance_f64_numStages,METH_NOARGS,"numStages"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_biquad_cascade_df2T_instance_f64,arm_biquad_cascade_df2T_instance_f64_new,arm_biquad_cascade_df2T_instance_f64_dealloc,arm_biquad_cascade_df2T_instance_f64_init,arm_biquad_cascade_df2T_instance_f64_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_fir_lattice_instance_q15 *instance;
+} dsp_arm_fir_lattice_instance_q15Object;
+
+
+static void
+arm_fir_lattice_instance_q15_dealloc(dsp_arm_fir_lattice_instance_q15Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((q15_t*)self->instance->pCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_fir_lattice_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_fir_lattice_instance_q15Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_fir_lattice_instance_q15Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_fir_lattice_instance_q15));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_fir_lattice_instance_q15_init(dsp_arm_fir_lattice_instance_q15Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+char *kwlist[] = {
+"numStages",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|h", kwlist,&self->instance->numStages
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_fir_lattice_instance_q15,numStages,"h");
+
+
+static PyMethodDef arm_fir_lattice_instance_q15_methods[] = {
+
+    {"numStages", (PyCFunction) Method_arm_fir_lattice_instance_q15_numStages,METH_NOARGS,"numStages"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_fir_lattice_instance_q15,arm_fir_lattice_instance_q15_new,arm_fir_lattice_instance_q15_dealloc,arm_fir_lattice_instance_q15_init,arm_fir_lattice_instance_q15_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_fir_lattice_instance_q31 *instance;
+} dsp_arm_fir_lattice_instance_q31Object;
+
+
+static void
+arm_fir_lattice_instance_q31_dealloc(dsp_arm_fir_lattice_instance_q31Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((q31_t*)self->instance->pCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_fir_lattice_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_fir_lattice_instance_q31Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_fir_lattice_instance_q31Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_fir_lattice_instance_q31));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_fir_lattice_instance_q31_init(dsp_arm_fir_lattice_instance_q31Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+char *kwlist[] = {
+"numStages",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|h", kwlist,&self->instance->numStages
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_fir_lattice_instance_q31,numStages,"h");
+
+
+static PyMethodDef arm_fir_lattice_instance_q31_methods[] = {
+
+    {"numStages", (PyCFunction) Method_arm_fir_lattice_instance_q31_numStages,METH_NOARGS,"numStages"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_fir_lattice_instance_q31,arm_fir_lattice_instance_q31_new,arm_fir_lattice_instance_q31_dealloc,arm_fir_lattice_instance_q31_init,arm_fir_lattice_instance_q31_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_fir_lattice_instance_f32 *instance;
+} dsp_arm_fir_lattice_instance_f32Object;
+
+
+static void
+arm_fir_lattice_instance_f32_dealloc(dsp_arm_fir_lattice_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((float32_t*)self->instance->pCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_fir_lattice_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_fir_lattice_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_fir_lattice_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_fir_lattice_instance_f32));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_fir_lattice_instance_f32_init(dsp_arm_fir_lattice_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+char *kwlist[] = {
+"numStages",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|h", kwlist,&self->instance->numStages
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_fir_lattice_instance_f32,numStages,"h");
+
+
+static PyMethodDef arm_fir_lattice_instance_f32_methods[] = {
+
+    {"numStages", (PyCFunction) Method_arm_fir_lattice_instance_f32_numStages,METH_NOARGS,"numStages"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_fir_lattice_instance_f32,arm_fir_lattice_instance_f32_new,arm_fir_lattice_instance_f32_dealloc,arm_fir_lattice_instance_f32_init,arm_fir_lattice_instance_f32_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_iir_lattice_instance_q15 *instance;
+} dsp_arm_iir_lattice_instance_q15Object;
+
+
+static void
+arm_iir_lattice_instance_q15_dealloc(dsp_arm_iir_lattice_instance_q15Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pkCoeffs)
+       {
+          PyMem_Free((q15_t*)self->instance->pkCoeffs);
+       }
+
+
+       if (self->instance->pvCoeffs)
+       {
+          PyMem_Free((q15_t*)self->instance->pvCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_iir_lattice_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_iir_lattice_instance_q15Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_iir_lattice_instance_q15Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_iir_lattice_instance_q15));
+
+        self->instance->pState = NULL;
+        self->instance->pkCoeffs = NULL;
+        self->instance->pvCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_iir_lattice_instance_q15_init(dsp_arm_iir_lattice_instance_q15Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pkCoeffs=NULL;
+    PyObject *pvCoeffs=NULL;
+char *kwlist[] = {
+"numStages","pkCoeffs","pvCoeffs",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hOO", kwlist,&self->instance->numStages
+,&pkCoeffs
+,&pvCoeffs
+))
+    {
+
+    INITARRAYFIELD(pkCoeffs,NPY_INT16,int16_t,int16_t);
+    INITARRAYFIELD(pvCoeffs,NPY_INT16,int16_t,int16_t);
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_iir_lattice_instance_q15,numStages,"h");
+
+
+static PyMethodDef arm_iir_lattice_instance_q15_methods[] = {
+
+    {"numStages", (PyCFunction) Method_arm_iir_lattice_instance_q15_numStages,METH_NOARGS,"numStages"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_iir_lattice_instance_q15,arm_iir_lattice_instance_q15_new,arm_iir_lattice_instance_q15_dealloc,arm_iir_lattice_instance_q15_init,arm_iir_lattice_instance_q15_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_iir_lattice_instance_q31 *instance;
+} dsp_arm_iir_lattice_instance_q31Object;
+
+
+static void
+arm_iir_lattice_instance_q31_dealloc(dsp_arm_iir_lattice_instance_q31Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pkCoeffs)
+       {
+          PyMem_Free((q31_t*)self->instance->pkCoeffs);
+       }
+
+
+       if (self->instance->pvCoeffs)
+       {
+          PyMem_Free((q31_t*)self->instance->pvCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_iir_lattice_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_iir_lattice_instance_q31Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_iir_lattice_instance_q31Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_iir_lattice_instance_q31));
+
+        self->instance->pState = NULL;
+        self->instance->pkCoeffs = NULL;
+        self->instance->pvCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_iir_lattice_instance_q31_init(dsp_arm_iir_lattice_instance_q31Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pkCoeffs=NULL;
+    PyObject *pvCoeffs=NULL;
+char *kwlist[] = {
+"numStages","pkCoeffs","pvCoeffs",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hOO", kwlist,&self->instance->numStages
+,&pkCoeffs
+,&pvCoeffs
+))
+    {
+
+    INITARRAYFIELD(pkCoeffs,NPY_INT32,int32_t,int32_t);
+    INITARRAYFIELD(pvCoeffs,NPY_INT32,int32_t,int32_t);
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_iir_lattice_instance_q31,numStages,"h");
+
+
+static PyMethodDef arm_iir_lattice_instance_q31_methods[] = {
+
+    {"numStages", (PyCFunction) Method_arm_iir_lattice_instance_q31_numStages,METH_NOARGS,"numStages"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_iir_lattice_instance_q31,arm_iir_lattice_instance_q31_new,arm_iir_lattice_instance_q31_dealloc,arm_iir_lattice_instance_q31_init,arm_iir_lattice_instance_q31_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_iir_lattice_instance_f32 *instance;
+} dsp_arm_iir_lattice_instance_f32Object;
+
+
+static void
+arm_iir_lattice_instance_f32_dealloc(dsp_arm_iir_lattice_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pkCoeffs)
+       {
+          PyMem_Free((float32_t*)self->instance->pkCoeffs);
+       }
+
+
+       if (self->instance->pvCoeffs)
+       {
+          PyMem_Free((float32_t*)self->instance->pvCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_iir_lattice_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_iir_lattice_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_iir_lattice_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_iir_lattice_instance_f32));
+
+        self->instance->pState = NULL;
+        self->instance->pkCoeffs = NULL;
+        self->instance->pvCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_iir_lattice_instance_f32_init(dsp_arm_iir_lattice_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pkCoeffs=NULL;
+    PyObject *pvCoeffs=NULL;
+char *kwlist[] = {
+"numStages","pkCoeffs","pvCoeffs",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hOO", kwlist,&self->instance->numStages
+,&pkCoeffs
+,&pvCoeffs
+))
+    {
+
+    INITARRAYFIELD(pkCoeffs,NPY_DOUBLE,double,float32_t);
+    INITARRAYFIELD(pvCoeffs,NPY_DOUBLE,double,float32_t);
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_iir_lattice_instance_f32,numStages,"h");
+
+
+static PyMethodDef arm_iir_lattice_instance_f32_methods[] = {
+
+    {"numStages", (PyCFunction) Method_arm_iir_lattice_instance_f32_numStages,METH_NOARGS,"numStages"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_iir_lattice_instance_f32,arm_iir_lattice_instance_f32_new,arm_iir_lattice_instance_f32_dealloc,arm_iir_lattice_instance_f32_init,arm_iir_lattice_instance_f32_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_lms_instance_f32 *instance;
+} dsp_arm_lms_instance_f32Object;
+
+
+static void
+arm_lms_instance_f32_dealloc(dsp_arm_lms_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((float32_t*)self->instance->pCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_lms_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_lms_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_lms_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_lms_instance_f32));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_lms_instance_f32_init(dsp_arm_lms_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+char *kwlist[] = {
+"numTaps","mu",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hf", kwlist,&self->instance->numTaps
+,&self->instance->mu
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_lms_instance_f32,numTaps,"h");
+GETFIELD(arm_lms_instance_f32,mu,"f");
+
+
+static PyMethodDef arm_lms_instance_f32_methods[] = {
+
+    {"numTaps", (PyCFunction) Method_arm_lms_instance_f32_numTaps,METH_NOARGS,"numTaps"},
+    {"mu", (PyCFunction) Method_arm_lms_instance_f32_mu,METH_NOARGS,"mu"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_lms_instance_f32,arm_lms_instance_f32_new,arm_lms_instance_f32_dealloc,arm_lms_instance_f32_init,arm_lms_instance_f32_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_lms_instance_q15 *instance;
+} dsp_arm_lms_instance_q15Object;
+
+
+static void
+arm_lms_instance_q15_dealloc(dsp_arm_lms_instance_q15Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((q15_t*)self->instance->pCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_lms_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_lms_instance_q15Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_lms_instance_q15Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_lms_instance_q15));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_lms_instance_q15_init(dsp_arm_lms_instance_q15Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+char *kwlist[] = {
+"numTaps","mu","postShift",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhi", kwlist,&self->instance->numTaps
+,&self->instance->mu
+,&self->instance->postShift
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_lms_instance_q15,numTaps,"h");
+GETFIELD(arm_lms_instance_q15,mu,"h");
+GETFIELD(arm_lms_instance_q15,postShift,"i");
+
+
+static PyMethodDef arm_lms_instance_q15_methods[] = {
+
+    {"numTaps", (PyCFunction) Method_arm_lms_instance_q15_numTaps,METH_NOARGS,"numTaps"},
+    {"mu", (PyCFunction) Method_arm_lms_instance_q15_mu,METH_NOARGS,"mu"},
+    {"postShift", (PyCFunction) Method_arm_lms_instance_q15_postShift,METH_NOARGS,"postShift"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_lms_instance_q15,arm_lms_instance_q15_new,arm_lms_instance_q15_dealloc,arm_lms_instance_q15_init,arm_lms_instance_q15_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_lms_instance_q31 *instance;
+} dsp_arm_lms_instance_q31Object;
+
+
+static void
+arm_lms_instance_q31_dealloc(dsp_arm_lms_instance_q31Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((q31_t*)self->instance->pCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_lms_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_lms_instance_q31Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_lms_instance_q31Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_lms_instance_q31));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_lms_instance_q31_init(dsp_arm_lms_instance_q31Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+char *kwlist[] = {
+"numTaps","mu","postShift",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hii", kwlist,&self->instance->numTaps
+,&self->instance->mu
+,&self->instance->postShift
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_lms_instance_q31,numTaps,"h");
+GETFIELD(arm_lms_instance_q31,mu,"i");
+GETFIELD(arm_lms_instance_q31,postShift,"i");
+
+
+static PyMethodDef arm_lms_instance_q31_methods[] = {
+
+    {"numTaps", (PyCFunction) Method_arm_lms_instance_q31_numTaps,METH_NOARGS,"numTaps"},
+    {"mu", (PyCFunction) Method_arm_lms_instance_q31_mu,METH_NOARGS,"mu"},
+    {"postShift", (PyCFunction) Method_arm_lms_instance_q31_postShift,METH_NOARGS,"postShift"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_lms_instance_q31,arm_lms_instance_q31_new,arm_lms_instance_q31_dealloc,arm_lms_instance_q31_init,arm_lms_instance_q31_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_lms_norm_instance_f32 *instance;
+} dsp_arm_lms_norm_instance_f32Object;
+
+
+static void
+arm_lms_norm_instance_f32_dealloc(dsp_arm_lms_norm_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((float32_t*)self->instance->pCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_lms_norm_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_lms_norm_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_lms_norm_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_lms_norm_instance_f32));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_lms_norm_instance_f32_init(dsp_arm_lms_norm_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+char *kwlist[] = {
+"numTaps","mu","energy","x0",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hfff", kwlist,&self->instance->numTaps
+,&self->instance->mu
+,&self->instance->energy
+,&self->instance->x0
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_lms_norm_instance_f32,numTaps,"h");
+GETFIELD(arm_lms_norm_instance_f32,mu,"f");
+GETFIELD(arm_lms_norm_instance_f32,energy,"f");
+GETFIELD(arm_lms_norm_instance_f32,x0,"f");
+
+
+static PyMethodDef arm_lms_norm_instance_f32_methods[] = {
+
+    {"numTaps", (PyCFunction) Method_arm_lms_norm_instance_f32_numTaps,METH_NOARGS,"numTaps"},
+    {"mu", (PyCFunction) Method_arm_lms_norm_instance_f32_mu,METH_NOARGS,"mu"},
+    {"energy", (PyCFunction) Method_arm_lms_norm_instance_f32_energy,METH_NOARGS,"energy"},
+    {"x0", (PyCFunction) Method_arm_lms_norm_instance_f32_x0,METH_NOARGS,"x0"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_lms_norm_instance_f32,arm_lms_norm_instance_f32_new,arm_lms_norm_instance_f32_dealloc,arm_lms_norm_instance_f32_init,arm_lms_norm_instance_f32_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_lms_norm_instance_q31 *instance;
+} dsp_arm_lms_norm_instance_q31Object;
+
+
+static void
+arm_lms_norm_instance_q31_dealloc(dsp_arm_lms_norm_instance_q31Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((q31_t*)self->instance->pCoeffs);
+       }
+
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_lms_norm_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_lms_norm_instance_q31Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_lms_norm_instance_q31Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_lms_norm_instance_q31));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+        self->instance->recipTable = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_lms_norm_instance_q31_init(dsp_arm_lms_norm_instance_q31Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+    PyObject *recipTable=NULL;
+char *kwlist[] = {
+"numTaps","mu","postShift","energy","x0",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hiiii", kwlist,&self->instance->numTaps
+,&self->instance->mu
+,&self->instance->postShift
+,&self->instance->energy
+,&self->instance->x0
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_lms_norm_instance_q31,numTaps,"h");
+GETFIELD(arm_lms_norm_instance_q31,mu,"i");
+GETFIELD(arm_lms_norm_instance_q31,postShift,"i");
+GETFIELD(arm_lms_norm_instance_q31,energy,"i");
+GETFIELD(arm_lms_norm_instance_q31,x0,"i");
+
+
+static PyMethodDef arm_lms_norm_instance_q31_methods[] = {
+
+    {"numTaps", (PyCFunction) Method_arm_lms_norm_instance_q31_numTaps,METH_NOARGS,"numTaps"},
+    {"mu", (PyCFunction) Method_arm_lms_norm_instance_q31_mu,METH_NOARGS,"mu"},
+    {"postShift", (PyCFunction) Method_arm_lms_norm_instance_q31_postShift,METH_NOARGS,"postShift"},
+    {"energy", (PyCFunction) Method_arm_lms_norm_instance_q31_energy,METH_NOARGS,"energy"},
+    {"x0", (PyCFunction) Method_arm_lms_norm_instance_q31_x0,METH_NOARGS,"x0"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_lms_norm_instance_q31,arm_lms_norm_instance_q31_new,arm_lms_norm_instance_q31_dealloc,arm_lms_norm_instance_q31_init,arm_lms_norm_instance_q31_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_lms_norm_instance_q15 *instance;
+} dsp_arm_lms_norm_instance_q15Object;
+
+
+static void
+arm_lms_norm_instance_q15_dealloc(dsp_arm_lms_norm_instance_q15Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((q15_t*)self->instance->pCoeffs);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_lms_norm_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_lms_norm_instance_q15Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_lms_norm_instance_q15Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_lms_norm_instance_q15));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+        self->instance->recipTable = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_lms_norm_instance_q15_init(dsp_arm_lms_norm_instance_q15Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+    PyObject *recipTable=NULL;
+char *kwlist[] = {
+"numTaps","mu","postShift","energy","x0",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhihh", kwlist,&self->instance->numTaps
+,&self->instance->mu
+,&self->instance->postShift
+,&self->instance->energy
+,&self->instance->x0
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_lms_norm_instance_q15,numTaps,"h");
+GETFIELD(arm_lms_norm_instance_q15,mu,"h");
+GETFIELD(arm_lms_norm_instance_q15,postShift,"i");
+GETFIELD(arm_lms_norm_instance_q15,energy,"h");
+GETFIELD(arm_lms_norm_instance_q15,x0,"h");
+
+
+static PyMethodDef arm_lms_norm_instance_q15_methods[] = {
+
+    {"numTaps", (PyCFunction) Method_arm_lms_norm_instance_q15_numTaps,METH_NOARGS,"numTaps"},
+    {"mu", (PyCFunction) Method_arm_lms_norm_instance_q15_mu,METH_NOARGS,"mu"},
+    {"postShift", (PyCFunction) Method_arm_lms_norm_instance_q15_postShift,METH_NOARGS,"postShift"},
+    {"energy", (PyCFunction) Method_arm_lms_norm_instance_q15_energy,METH_NOARGS,"energy"},
+    {"x0", (PyCFunction) Method_arm_lms_norm_instance_q15_x0,METH_NOARGS,"x0"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_lms_norm_instance_q15,arm_lms_norm_instance_q15_new,arm_lms_norm_instance_q15_dealloc,arm_lms_norm_instance_q15_init,arm_lms_norm_instance_q15_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_fir_sparse_instance_f32 *instance;
+} dsp_arm_fir_sparse_instance_f32Object;
+
+
+static void
+arm_fir_sparse_instance_f32_dealloc(dsp_arm_fir_sparse_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((q15_t*)self->instance->pCoeffs);
+       }
+
+
+       if (self->instance->pTapDelay)
+       {
+          PyMem_Free(self->instance->pTapDelay);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_fir_sparse_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_fir_sparse_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_fir_sparse_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_fir_sparse_instance_f32));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+        self->instance->pTapDelay = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_fir_sparse_instance_f32_init(dsp_arm_fir_sparse_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+    PyObject *pTapDelay=NULL;
+char *kwlist[] = {
+"numTaps","stateIndex","maxDelay","pTapDelay",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhhO", kwlist,&self->instance->numTaps
+,&self->instance->stateIndex
+,&self->instance->maxDelay
+,&pTapDelay
+))
+    {
+
+    INITARRAYFIELD(pTapDelay,NPY_INT32,int32_t,int32_t);
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_fir_sparse_instance_f32,numTaps,"h");
+GETFIELD(arm_fir_sparse_instance_f32,stateIndex,"h");
+GETFIELD(arm_fir_sparse_instance_f32,maxDelay,"h");
+
+
+static PyMethodDef arm_fir_sparse_instance_f32_methods[] = {
+
+    {"numTaps", (PyCFunction) Method_arm_fir_sparse_instance_f32_numTaps,METH_NOARGS,"numTaps"},
+    {"stateIndex", (PyCFunction) Method_arm_fir_sparse_instance_f32_stateIndex,METH_NOARGS,"stateIndex"},
+    {"maxDelay", (PyCFunction) Method_arm_fir_sparse_instance_f32_maxDelay,METH_NOARGS,"maxDelay"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_fir_sparse_instance_f32,arm_fir_sparse_instance_f32_new,arm_fir_sparse_instance_f32_dealloc,arm_fir_sparse_instance_f32_init,arm_fir_sparse_instance_f32_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_fir_sparse_instance_q31 *instance;
+} dsp_arm_fir_sparse_instance_q31Object;
+
+
+static void
+arm_fir_sparse_instance_q31_dealloc(dsp_arm_fir_sparse_instance_q31Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((float32_t*)self->instance->pCoeffs);
+       }
+
+
+       if (self->instance->pTapDelay)
+       {
+          PyMem_Free(self->instance->pTapDelay);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_fir_sparse_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_fir_sparse_instance_q31Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_fir_sparse_instance_q31Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_fir_sparse_instance_q31));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+        self->instance->pTapDelay = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_fir_sparse_instance_q31_init(dsp_arm_fir_sparse_instance_q31Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+    PyObject *pTapDelay=NULL;
+char *kwlist[] = {
+"numTaps","stateIndex","maxDelay","pTapDelay",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhhO", kwlist,&self->instance->numTaps
+,&self->instance->stateIndex
+,&self->instance->maxDelay
+,&pTapDelay
+))
+    {
+
+    INITARRAYFIELD(pTapDelay,NPY_INT32,int32_t,int32_t);
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_fir_sparse_instance_q31,numTaps,"h");
+GETFIELD(arm_fir_sparse_instance_q31,stateIndex,"h");
+GETFIELD(arm_fir_sparse_instance_q31,maxDelay,"h");
+
+
+static PyMethodDef arm_fir_sparse_instance_q31_methods[] = {
+
+    {"numTaps", (PyCFunction) Method_arm_fir_sparse_instance_q31_numTaps,METH_NOARGS,"numTaps"},
+    {"stateIndex", (PyCFunction) Method_arm_fir_sparse_instance_q31_stateIndex,METH_NOARGS,"stateIndex"},
+    {"maxDelay", (PyCFunction) Method_arm_fir_sparse_instance_q31_maxDelay,METH_NOARGS,"maxDelay"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_fir_sparse_instance_q31,arm_fir_sparse_instance_q31_new,arm_fir_sparse_instance_q31_dealloc,arm_fir_sparse_instance_q31_init,arm_fir_sparse_instance_q31_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_fir_sparse_instance_q15 *instance;
+} dsp_arm_fir_sparse_instance_q15Object;
+
+
+static void
+arm_fir_sparse_instance_q15_dealloc(dsp_arm_fir_sparse_instance_q15Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((q15_t*)self->instance->pCoeffs);
+       }
+
+
+       if (self->instance->pTapDelay)
+       {
+          PyMem_Free(self->instance->pTapDelay);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_fir_sparse_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_fir_sparse_instance_q15Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_fir_sparse_instance_q15Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_fir_sparse_instance_q15));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+        self->instance->pTapDelay = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_fir_sparse_instance_q15_init(dsp_arm_fir_sparse_instance_q15Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+    PyObject *pTapDelay=NULL;
+char *kwlist[] = {
+"numTaps","stateIndex","maxDelay","pTapDelay",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhhO", kwlist,&self->instance->numTaps
+,&self->instance->stateIndex
+,&self->instance->maxDelay
+,&pTapDelay
+))
+    {
+
+    INITARRAYFIELD(pTapDelay,NPY_INT32,int32_t,int32_t);
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_fir_sparse_instance_q15,numTaps,"h");
+GETFIELD(arm_fir_sparse_instance_q15,stateIndex,"h");
+GETFIELD(arm_fir_sparse_instance_q15,maxDelay,"h");
+
+
+static PyMethodDef arm_fir_sparse_instance_q15_methods[] = {
+
+    {"numTaps", (PyCFunction) Method_arm_fir_sparse_instance_q15_numTaps,METH_NOARGS,"numTaps"},
+    {"stateIndex", (PyCFunction) Method_arm_fir_sparse_instance_q15_stateIndex,METH_NOARGS,"stateIndex"},
+    {"maxDelay", (PyCFunction) Method_arm_fir_sparse_instance_q15_maxDelay,METH_NOARGS,"maxDelay"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_fir_sparse_instance_q15,arm_fir_sparse_instance_q15_new,arm_fir_sparse_instance_q15_dealloc,arm_fir_sparse_instance_q15_init,arm_fir_sparse_instance_q15_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_fir_sparse_instance_q7 *instance;
+} dsp_arm_fir_sparse_instance_q7Object;
+
+
+static void
+arm_fir_sparse_instance_q7_dealloc(dsp_arm_fir_sparse_instance_q7Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pState)
+       {
+          PyMem_Free(self->instance->pState);
+       }
+
+
+       if (self->instance->pCoeffs)
+       {
+          PyMem_Free((q7_t*)self->instance->pCoeffs);
+       }
+
+
+       if (self->instance->pTapDelay)
+       {
+          PyMem_Free(self->instance->pTapDelay);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_fir_sparse_instance_q7_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_fir_sparse_instance_q7Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_fir_sparse_instance_q7Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_fir_sparse_instance_q7));
+
+        self->instance->pState = NULL;
+        self->instance->pCoeffs = NULL;
+        self->instance->pTapDelay = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_fir_sparse_instance_q7_init(dsp_arm_fir_sparse_instance_q7Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pState=NULL;
+    PyObject *pCoeffs=NULL;
+    PyObject *pTapDelay=NULL;
+char *kwlist[] = {
+"numTaps","stateIndex","maxDelay","pTapDelay",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhhO", kwlist,&self->instance->numTaps
+,&self->instance->stateIndex
+,&self->instance->maxDelay
+,&pTapDelay
+))
+    {
+
+    INITARRAYFIELD(pTapDelay,NPY_INT32,int32_t,int32_t);
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_fir_sparse_instance_q7,numTaps,"h");
+GETFIELD(arm_fir_sparse_instance_q7,stateIndex,"h");
+GETFIELD(arm_fir_sparse_instance_q7,maxDelay,"h");
+
+
+static PyMethodDef arm_fir_sparse_instance_q7_methods[] = {
+
+    {"numTaps", (PyCFunction) Method_arm_fir_sparse_instance_q7_numTaps,METH_NOARGS,"numTaps"},
+    {"stateIndex", (PyCFunction) Method_arm_fir_sparse_instance_q7_stateIndex,METH_NOARGS,"stateIndex"},
+    {"maxDelay", (PyCFunction) Method_arm_fir_sparse_instance_q7_maxDelay,METH_NOARGS,"maxDelay"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_fir_sparse_instance_q7,arm_fir_sparse_instance_q7_new,arm_fir_sparse_instance_q7_dealloc,arm_fir_sparse_instance_q7_init,arm_fir_sparse_instance_q7_methods);
+
+
+
+void typeRegistration(PyObject *module) {
+
+  ADDTYPE(arm_fir_instance_q7);
+  ADDTYPE(arm_fir_instance_q15);
+  ADDTYPE(arm_fir_instance_q31);
+  ADDTYPE(arm_fir_instance_f32);
+  ADDTYPE(arm_biquad_casd_df1_inst_q15);
+  ADDTYPE(arm_biquad_casd_df1_inst_q31);
+  ADDTYPE(arm_biquad_casd_df1_inst_f32);
+  ADDTYPE(arm_fir_decimate_instance_q15);
+  ADDTYPE(arm_fir_decimate_instance_q31);
+  ADDTYPE(arm_fir_decimate_instance_f32);
+  ADDTYPE(arm_fir_interpolate_instance_q15);
+  ADDTYPE(arm_fir_interpolate_instance_q31);
+  ADDTYPE(arm_fir_interpolate_instance_f32);
+  ADDTYPE(arm_biquad_cas_df1_32x64_ins_q31);
+  ADDTYPE(arm_biquad_cascade_df2T_instance_f32);
+  ADDTYPE(arm_biquad_cascade_stereo_df2T_instance_f32);
+  ADDTYPE(arm_biquad_cascade_df2T_instance_f64);
+  ADDTYPE(arm_fir_lattice_instance_q15);
+  ADDTYPE(arm_fir_lattice_instance_q31);
+  ADDTYPE(arm_fir_lattice_instance_f32);
+  ADDTYPE(arm_iir_lattice_instance_q15);
+  ADDTYPE(arm_iir_lattice_instance_q31);
+  ADDTYPE(arm_iir_lattice_instance_f32);
+  ADDTYPE(arm_lms_instance_f32);
+  ADDTYPE(arm_lms_instance_q15);
+  ADDTYPE(arm_lms_instance_q31);
+  ADDTYPE(arm_lms_norm_instance_f32);
+  ADDTYPE(arm_lms_norm_instance_q31);
+  ADDTYPE(arm_lms_norm_instance_q15);
+  ADDTYPE(arm_fir_sparse_instance_f32);
+  ADDTYPE(arm_fir_sparse_instance_q31);
+  ADDTYPE(arm_fir_sparse_instance_q15);
+  ADDTYPE(arm_fir_sparse_instance_q7);
+}
+
+
+
+
+
+
+
+static PyObject *
+cmsis_arm_fir_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  q7_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_fir_instance_q7Object *selfS = (dsp_arm_fir_instance_q7Object *)S;
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
+
+
+    arm_fir_q7(selfS->instance,pSrc_converted,pDst,blockSize);
+ INT8ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_init_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numTaps; // input
+  PyObject *pCoeffs=NULL; // input
+  q7_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q7_t *pState_converted=NULL; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OhOO",&S,&numTaps,&pCoeffs,&pState))
+  {
+
+    dsp_arm_fir_instance_q7Object *selfS = (dsp_arm_fir_instance_q7Object *)S;
+    GETARGUMENT(pCoeffs,NPY_BYTE,int8_t,q7_t);
+    GETARGUMENT(pState,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepState - arraySizepCoeffs + 1;
+
+    arm_fir_init_q7(selfS->instance,numTaps,pCoeffs_converted,pState_converted,blockSize);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_fir_instance_q15Object *selfS = (dsp_arm_fir_instance_q15Object *)S;
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_fir_q15(selfS->instance,pSrc_converted,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_fast_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_fir_instance_q15Object *selfS = (dsp_arm_fir_instance_q15Object *)S;
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_fir_fast_q15(selfS->instance,pSrc_converted,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_init_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numTaps; // input
+  PyObject *pCoeffs=NULL; // input
+  q15_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q15_t *pState_converted=NULL; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OhOO",&S,&numTaps,&pCoeffs,&pState))
+  {
+
+    dsp_arm_fir_instance_q15Object *selfS = (dsp_arm_fir_instance_q15Object *)S;
+    GETARGUMENT(pCoeffs,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepState - arraySizepCoeffs + 1;
+
+    arm_status returnValue = arm_fir_init_q15(selfS->instance,numTaps,pCoeffs_converted,pState_converted,blockSize);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_fir_instance_q31Object *selfS = (dsp_arm_fir_instance_q31Object *)S;
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_fir_q31(selfS->instance,pSrc_converted,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_fast_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_fir_instance_q31Object *selfS = (dsp_arm_fir_instance_q31Object *)S;
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_fir_fast_q31(selfS->instance,pSrc_converted,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_init_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numTaps; // input
+  PyObject *pCoeffs=NULL; // input
+  q31_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q31_t *pState_converted=NULL; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OhOO",&S,&numTaps,&pCoeffs,&pState))
+  {
+
+    dsp_arm_fir_instance_q31Object *selfS = (dsp_arm_fir_instance_q31Object *)S;
+    GETARGUMENT(pCoeffs,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepState - arraySizepCoeffs + 1;
+
+    arm_fir_init_q31(selfS->instance,numTaps,pCoeffs_converted,pState_converted,blockSize);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_fir_instance_f32Object *selfS = (dsp_arm_fir_instance_f32Object *)S;
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_fir_f32(selfS->instance,pSrc_converted,pDst,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_init_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numTaps; // input
+  PyObject *pCoeffs=NULL; // input
+  float32_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  float32_t *pState_converted=NULL; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OhOO",&S,&numTaps,&pCoeffs,&pState))
+  {
+
+    dsp_arm_fir_instance_f32Object *selfS = (dsp_arm_fir_instance_f32Object *)S;
+    GETARGUMENT(pCoeffs,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepState - arraySizepCoeffs + 1;
+
+    arm_fir_init_f32(selfS->instance,numTaps,pCoeffs_converted,pState_converted,blockSize);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_biquad_cascade_df1_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_biquad_casd_df1_inst_q15Object *selfS = (dsp_arm_biquad_casd_df1_inst_q15Object *)S;
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_biquad_cascade_df1_q15(selfS->instance,pSrc_converted,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_biquad_cascade_df1_init_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint32_t numStages; // input
+  PyObject *pCoeffs=NULL; // input
+  q15_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q15_t *pState_converted=NULL; // input
+  int32_t postShift; // input
+
+  if (PyArg_ParseTuple(args,"OiOOi",&S,&numStages,&pCoeffs,&pState,&postShift))
+  {
+
+    dsp_arm_biquad_casd_df1_inst_q15Object *selfS = (dsp_arm_biquad_casd_df1_inst_q15Object *)S;
+    GETARGUMENT(pCoeffs,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
+
+    arm_biquad_cascade_df1_init_q15(selfS->instance,(uint8_t)numStages,pCoeffs_converted,pState_converted,(int8_t)postShift);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_biquad_cascade_df1_fast_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_biquad_casd_df1_inst_q15Object *selfS = (dsp_arm_biquad_casd_df1_inst_q15Object *)S;
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_biquad_cascade_df1_fast_q15(selfS->instance,pSrc_converted,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_biquad_cascade_df1_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_biquad_casd_df1_inst_q31Object *selfS = (dsp_arm_biquad_casd_df1_inst_q31Object *)S;
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_biquad_cascade_df1_q31(selfS->instance,pSrc_converted,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_biquad_cascade_df1_fast_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_biquad_casd_df1_inst_q31Object *selfS = (dsp_arm_biquad_casd_df1_inst_q31Object *)S;
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_biquad_cascade_df1_fast_q31(selfS->instance,pSrc_converted,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_biquad_cascade_df1_init_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint32_t numStages; // input
+  PyObject *pCoeffs=NULL; // input
+  q31_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q31_t *pState_converted=NULL; // input
+  int32_t postShift; // input
+
+  if (PyArg_ParseTuple(args,"OiOOi",&S,&numStages,&pCoeffs,&pState,&postShift))
+  {
+
+    dsp_arm_biquad_casd_df1_inst_q31Object *selfS = (dsp_arm_biquad_casd_df1_inst_q31Object *)S;
+    GETARGUMENT(pCoeffs,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
+
+    arm_biquad_cascade_df1_init_q31(selfS->instance,(uint8_t)numStages,pCoeffs_converted,pState_converted,(int8_t)postShift);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_biquad_cascade_df1_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_biquad_casd_df1_inst_f32Object *selfS = (dsp_arm_biquad_casd_df1_inst_f32Object *)S;
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_biquad_cascade_df1_f32(selfS->instance,pSrc_converted,pDst,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_biquad_cascade_df1_init_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint32_t numStages; // input
+  PyObject *pCoeffs=NULL; // input
+  float32_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  float32_t *pState_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OiOO",&S,&numStages,&pCoeffs,&pState))
+  {
+
+    dsp_arm_biquad_casd_df1_inst_f32Object *selfS = (dsp_arm_biquad_casd_df1_inst_f32Object *)S;
+    GETARGUMENT(pCoeffs,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
+
+    arm_biquad_cascade_df1_init_f32(selfS->instance,(uint8_t)numStages,pCoeffs_converted,pState_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+
+static PyObject *
+cmsis_arm_levinson_durbin_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pPhi=NULL; // input
+  q31_t *pPhi_converted=NULL; // input
+  q31_t *pA=NULL; // output
+  q31_t err; // output
+  uint32_t nbCoefs; // input
+
+  if (PyArg_ParseTuple(args,"Oi",&pPhi,&nbCoefs))
+  {
+
+    GETARGUMENT(pPhi,NPY_INT32,int32_t,q31_t);
+
+    pA=PyMem_Malloc(sizeof(q31_t)*nbCoefs);
+
+
+    arm_levinson_durbin_q31(pPhi_converted,pA,&err,nbCoefs);
+    
+    INT32ARRAY1(pAOBJ,nbCoefs,pA);
+
+    PyObject *pythonResult = Py_BuildValue("Oi",pAOBJ,err);
+
+    FREEARGUMENT(pPhi_converted);
+    Py_DECREF(pAOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_levinson_durbin_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pPhi=NULL; // input
+  float32_t *pPhi_converted=NULL; // input
+  float32_t *pA=NULL; // output
+  float32_t err; // output
+  uint32_t nbCoefs; // input
+
+  if (PyArg_ParseTuple(args,"Oi",&pPhi,&nbCoefs))
+  {
+
+    GETARGUMENT(pPhi,NPY_DOUBLE,double,float32_t);
+
+    pA=PyMem_Malloc(sizeof(float32_t)*nbCoefs);
+
+
+    arm_levinson_durbin_f32(pPhi_converted,pA,&err,nbCoefs);
+    
+    FLOATARRAY1(pAOBJ,nbCoefs,pA);
+
+    PyObject *pythonResult = Py_BuildValue("Of",pAOBJ,err);
+
+    FREEARGUMENT(pPhi_converted);
+    Py_DECREF(pAOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+static PyObject *
+cmsis_arm_conv_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  float32_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  float32_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  float32_t *pDst=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
+  {
+
+    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
+    uint32_t outputLength = srcALen + srcBLen - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*outputLength);
+
+
+    arm_conv_f32(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
+ FLOATARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_conv_opt_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q15_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q15_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q15_t *pDst=NULL; // output
+  PyObject *pScratch1=NULL; // input
+  q15_t *pScratch1_converted=NULL; // input
+  PyObject *pScratch2=NULL; // input
+  q15_t *pScratch2_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OiOiOO",&pSrcA,&srcALen,&pSrcB,&srcBLen,&pScratch1,&pScratch2))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pScratch1,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pScratch2,NPY_INT16,int16_t,int16_t);
+    uint32_t outputLength = srcALen + srcBLen - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
+
+
+    arm_conv_opt_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,pScratch1_converted,pScratch2_converted);
+ INT16ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    FREEARGUMENT(pScratch1_converted);
+    FREEARGUMENT(pScratch2_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_conv_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q15_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q15_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q15_t *pDst=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
+    uint32_t outputLength = srcALen + srcBLen - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
+
+
+    arm_conv_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
+ INT16ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_conv_fast_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q15_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q15_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q15_t *pDst=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
+    uint32_t outputLength = srcALen + srcBLen - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
+
+
+    arm_conv_fast_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
+ INT16ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_conv_fast_opt_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q15_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q15_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q15_t *pDst=NULL; // output
+  PyObject *pScratch1=NULL; // input
+  q15_t *pScratch1_converted=NULL; // input
+  PyObject *pScratch2=NULL; // input
+  q15_t *pScratch2_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OiOiOO",&pSrcA,&srcALen,&pSrcB,&srcBLen,&pScratch1,&pScratch2))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pScratch1,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pScratch2,NPY_INT16,int16_t,int16_t);
+    uint32_t outputLength = srcALen + srcBLen - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
+
+
+    arm_conv_fast_opt_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,pScratch1_converted,pScratch2_converted);
+ INT16ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    FREEARGUMENT(pScratch1_converted);
+    FREEARGUMENT(pScratch2_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_conv_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q31_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q31_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q31_t *pDst=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
+    uint32_t outputLength = srcALen + srcBLen - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*outputLength);
+
+
+    arm_conv_q31(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
+ INT32ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_conv_fast_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q31_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q31_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q31_t *pDst=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
+    uint32_t outputLength = srcALen + srcBLen - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*outputLength);
+
+
+    arm_conv_fast_q31(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
+ INT32ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_conv_opt_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q7_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q7_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q7_t *pDst=NULL; // output
+  PyObject *pScratch1=NULL; // input
+  q15_t *pScratch1_converted=NULL; // input
+  PyObject *pScratch2=NULL; // input
+  q15_t *pScratch2_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OiOiOO",&pSrcA,&srcALen,&pSrcB,&srcBLen,&pScratch1,&pScratch2))
+  {
+
+    GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
+    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
+    GETARGUMENT(pScratch1,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pScratch2,NPY_INT16,int16_t,int16_t);
+    uint32_t outputLength = srcALen + srcBLen - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*outputLength);
+
+
+    arm_conv_opt_q7(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,pScratch1_converted,pScratch2_converted);
+ INT8ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    FREEARGUMENT(pScratch1_converted);
+    FREEARGUMENT(pScratch2_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_conv_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q7_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q7_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q7_t *pDst=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
+  {
+
+    GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
+    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
+    uint32_t outputLength = srcALen + srcBLen - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*outputLength);
+
+
+    arm_conv_q7(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
+ INT8ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_conv_partial_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  float32_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  float32_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  float32_t *pDst=NULL; // output
+  uint32_t firstIndex; // input
+  uint32_t numPoints; // input
+
+  if (PyArg_ParseTuple(args,"OiOiii",&pSrcA,&srcALen,&pSrcB,&srcBLen,&firstIndex,&numPoints))
+  {
+
+    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
+    uint32_t outputLength = srcALen + srcBLen - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*outputLength);
+
+
+    arm_status returnValue = arm_conv_partial_f32(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,firstIndex,numPoints);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+ FLOATARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_conv_partial_opt_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q15_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q15_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q15_t *pDst=NULL; // output
+  uint32_t firstIndex; // input
+  uint32_t numPoints; // input
+  PyObject *pScratch1=NULL; // input
+  q15_t *pScratch1_converted=NULL; // input
+  PyObject *pScratch2=NULL; // input
+  q15_t *pScratch2_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OiOiiiOO",&pSrcA,&srcALen,&pSrcB,&srcBLen,&firstIndex,&numPoints,&pScratch1,&pScratch2))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pScratch1,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pScratch2,NPY_INT16,int16_t,int16_t);
+    uint32_t outputLength = srcALen + srcBLen - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
+
+
+    arm_status returnValue = arm_conv_partial_opt_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,firstIndex,numPoints,pScratch1_converted,pScratch2_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+ INT16ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    FREEARGUMENT(pScratch1_converted);
+    FREEARGUMENT(pScratch2_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_conv_partial_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q15_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q15_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q15_t *pDst=NULL; // output
+  uint32_t firstIndex; // input
+  uint32_t numPoints; // input
+
+  if (PyArg_ParseTuple(args,"OiOiii",&pSrcA,&srcALen,&pSrcB,&srcBLen,&firstIndex,&numPoints))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
+    uint32_t outputLength = srcALen + srcBLen - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
+
+
+    arm_status returnValue = arm_conv_partial_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,firstIndex,numPoints);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+ INT16ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_conv_partial_fast_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q15_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q15_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q15_t *pDst=NULL; // output
+  uint32_t firstIndex; // input
+  uint32_t numPoints; // input
+
+  if (PyArg_ParseTuple(args,"OiOiii",&pSrcA,&srcALen,&pSrcB,&srcBLen,&firstIndex,&numPoints))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
+    uint32_t outputLength = srcALen + srcBLen - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
+
+
+    arm_status returnValue = arm_conv_partial_fast_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,firstIndex,numPoints);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+ INT16ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_conv_partial_fast_opt_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q15_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q15_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q15_t *pDst=NULL; // output
+  uint32_t firstIndex; // input
+  uint32_t numPoints; // input
+  PyObject *pScratch1=NULL; // input
+  q15_t *pScratch1_converted=NULL; // input
+  PyObject *pScratch2=NULL; // input
+  q15_t *pScratch2_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OiOiiiOO",&pSrcA,&srcALen,&pSrcB,&srcBLen,&firstIndex,&numPoints,&pScratch1,&pScratch2))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pScratch1,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pScratch2,NPY_INT16,int16_t,int16_t);
+    uint32_t outputLength = srcALen + srcBLen - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
+
+
+    arm_status returnValue = arm_conv_partial_fast_opt_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,firstIndex,numPoints,pScratch1_converted,pScratch2_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+ INT16ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    FREEARGUMENT(pScratch1_converted);
+    FREEARGUMENT(pScratch2_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_conv_partial_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q31_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q31_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q31_t *pDst=NULL; // output
+  uint32_t firstIndex; // input
+  uint32_t numPoints; // input
+
+  if (PyArg_ParseTuple(args,"OiOiii",&pSrcA,&srcALen,&pSrcB,&srcBLen,&firstIndex,&numPoints))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
+    uint32_t outputLength = srcALen + srcBLen - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*outputLength);
+
+
+    arm_status returnValue = arm_conv_partial_q31(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,firstIndex,numPoints);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+ INT32ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_conv_partial_fast_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q31_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q31_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q31_t *pDst=NULL; // output
+  uint32_t firstIndex; // input
+  uint32_t numPoints; // input
+
+  if (PyArg_ParseTuple(args,"OiOiii",&pSrcA,&srcALen,&pSrcB,&srcBLen,&firstIndex,&numPoints))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
+    uint32_t outputLength = srcALen + srcBLen - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*outputLength);
+
+
+    arm_status returnValue = arm_conv_partial_fast_q31(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,firstIndex,numPoints);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+ INT32ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_conv_partial_opt_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q7_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q7_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q7_t *pDst=NULL; // output
+  uint32_t firstIndex; // input
+  uint32_t numPoints; // input
+  PyObject *pScratch1=NULL; // input
+  q15_t *pScratch1_converted=NULL; // input
+  PyObject *pScratch2=NULL; // input
+  q15_t *pScratch2_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OiOiiiOO",&pSrcA,&srcALen,&pSrcB,&srcBLen,&firstIndex,&numPoints,&pScratch1,&pScratch2))
+  {
+
+    GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
+    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
+    GETARGUMENT(pScratch1,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pScratch2,NPY_INT16,int16_t,int16_t);
+    uint32_t outputLength = srcALen + srcBLen - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*outputLength);
+
+
+    arm_status returnValue = arm_conv_partial_opt_q7(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,firstIndex,numPoints,pScratch1_converted,pScratch2_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+ INT8ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    FREEARGUMENT(pScratch1_converted);
+    FREEARGUMENT(pScratch2_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_conv_partial_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q7_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q7_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q7_t *pDst=NULL; // output
+  uint32_t firstIndex; // input
+  uint32_t numPoints; // input
+
+  if (PyArg_ParseTuple(args,"OiOiii",&pSrcA,&srcALen,&pSrcB,&srcBLen,&firstIndex,&numPoints))
+  {
+
+    GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
+    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
+    uint32_t outputLength = srcALen + srcBLen - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*outputLength);
+
+
+    arm_status returnValue = arm_conv_partial_q7(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,firstIndex,numPoints);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+ INT8ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_decimate_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_fir_decimate_instance_f32Object *selfS = (dsp_arm_fir_decimate_instance_f32Object *)S;
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_fir_decimate_f32(selfS->instance,pSrc_converted,pDst,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_decimate_init_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numTaps; // input
+  uint32_t M; // input
+  PyObject *pCoeffs=NULL; // input
+  float32_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  float32_t *pState_converted=NULL; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OhiOO",&S,&numTaps,&M,&pCoeffs,&pState))
+  {
+
+    dsp_arm_fir_decimate_instance_f32Object *selfS = (dsp_arm_fir_decimate_instance_f32Object *)S;
+    GETARGUMENT(pCoeffs,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepState - arraySizepCoeffs + 1;
+
+    arm_status returnValue = arm_fir_decimate_init_f32(selfS->instance,numTaps,(uint8_t)M,pCoeffs_converted,pState_converted,blockSize);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_decimate_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_fir_decimate_instance_q15Object *selfS = (dsp_arm_fir_decimate_instance_q15Object *)S;
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_fir_decimate_q15(selfS->instance,pSrc_converted,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_decimate_fast_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_fir_decimate_instance_q15Object *selfS = (dsp_arm_fir_decimate_instance_q15Object *)S;
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_fir_decimate_fast_q15(selfS->instance,pSrc_converted,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_decimate_init_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numTaps; // input
+  uint32_t M; // input
+  PyObject *pCoeffs=NULL; // input
+  q15_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q15_t *pState_converted=NULL; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OhiOO",&S,&numTaps,&M,&pCoeffs,&pState))
+  {
+
+    dsp_arm_fir_decimate_instance_q15Object *selfS = (dsp_arm_fir_decimate_instance_q15Object *)S;
+    GETARGUMENT(pCoeffs,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepState - arraySizepCoeffs + 1;
+
+    arm_status returnValue = arm_fir_decimate_init_q15(selfS->instance,numTaps,(uint8_t)M,pCoeffs_converted,pState_converted,blockSize);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_decimate_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_fir_decimate_instance_q31Object *selfS = (dsp_arm_fir_decimate_instance_q31Object *)S;
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_fir_decimate_q31(selfS->instance,pSrc_converted,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_decimate_fast_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_fir_decimate_instance_q31Object *selfS = (dsp_arm_fir_decimate_instance_q31Object *)S;
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_fir_decimate_fast_q31(selfS->instance,pSrc_converted,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_decimate_init_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numTaps; // input
+  uint32_t M; // input
+  PyObject *pCoeffs=NULL; // input
+  q31_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q31_t *pState_converted=NULL; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OhiOO",&S,&numTaps,&M,&pCoeffs,&pState))
+  {
+
+    dsp_arm_fir_decimate_instance_q31Object *selfS = (dsp_arm_fir_decimate_instance_q31Object *)S;
+    GETARGUMENT(pCoeffs,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepState - arraySizepCoeffs + 1;
+
+    arm_status returnValue = arm_fir_decimate_init_q31(selfS->instance,numTaps,(uint8_t)M,pCoeffs_converted,pState_converted,blockSize);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_interpolate_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_fir_interpolate_instance_q15Object *selfS = (dsp_arm_fir_interpolate_instance_q15Object *)S;
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_fir_interpolate_q15(selfS->instance,pSrc_converted,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_interpolate_init_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint32_t L; // input
+  uint16_t numTaps; // input
+  PyObject *pCoeffs=NULL; // input
+  q15_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q15_t *pState_converted=NULL; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OihOO",&S,&L,&numTaps,&pCoeffs,&pState))
+  {
+
+    dsp_arm_fir_interpolate_instance_q15Object *selfS = (dsp_arm_fir_interpolate_instance_q15Object *)S;
+    GETARGUMENT(pCoeffs,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepState - arraySizepCoeffs + 1;
+
+    arm_status returnValue = arm_fir_interpolate_init_q15(selfS->instance,(uint8_t)L,numTaps,pCoeffs_converted,pState_converted,blockSize);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_interpolate_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_fir_interpolate_instance_q31Object *selfS = (dsp_arm_fir_interpolate_instance_q31Object *)S;
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_fir_interpolate_q31(selfS->instance,pSrc_converted,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_interpolate_init_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint32_t L; // input
+  uint16_t numTaps; // input
+  PyObject *pCoeffs=NULL; // input
+  q31_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q31_t *pState_converted=NULL; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OihOO",&S,&L,&numTaps,&pCoeffs,&pState))
+  {
+
+    dsp_arm_fir_interpolate_instance_q31Object *selfS = (dsp_arm_fir_interpolate_instance_q31Object *)S;
+    GETARGUMENT(pCoeffs,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepState - arraySizepCoeffs + 1;
+
+    arm_status returnValue = arm_fir_interpolate_init_q31(selfS->instance,(uint8_t)L,numTaps,pCoeffs_converted,pState_converted,blockSize);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_interpolate_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_fir_interpolate_instance_f32Object *selfS = (dsp_arm_fir_interpolate_instance_f32Object *)S;
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_fir_interpolate_f32(selfS->instance,pSrc_converted,pDst,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_interpolate_init_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint32_t L; // input
+  uint16_t numTaps; // input
+  PyObject *pCoeffs=NULL; // input
+  float32_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  float32_t *pState_converted=NULL; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OihOO",&S,&L,&numTaps,&pCoeffs,&pState))
+  {
+
+    dsp_arm_fir_interpolate_instance_f32Object *selfS = (dsp_arm_fir_interpolate_instance_f32Object *)S;
+    GETARGUMENT(pCoeffs,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepState - arraySizepCoeffs + 1;
+
+    arm_status returnValue = arm_fir_interpolate_init_f32(selfS->instance,(uint8_t)L,numTaps,pCoeffs_converted,pState_converted,blockSize);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_biquad_cas_df1_32x64_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  arm_biquad_cas_df1_32x64_ins_q31 *S_converted=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_biquad_cas_df1_32x64_q31(S_converted,pSrc_converted,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_biquad_cas_df1_32x64_init_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  arm_biquad_cas_df1_32x64_ins_q31 *S_converted=NULL; // input
+  uint32_t numStages; // input
+  PyObject *pCoeffs=NULL; // input
+  q31_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q63_t *pState_converted=NULL; // input
+  uint32_t postShift; // input
+
+  if (PyArg_ParseTuple(args,"OiOOi",&S,&numStages,&pCoeffs,&pState,&postShift))
+  {
+
+    GETARGUMENT(pCoeffs,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pState,NPY_INT64,q63_t,q63_t);
+
+    arm_biquad_cas_df1_32x64_init_q31(S_converted,(uint8_t)numStages,pCoeffs_converted,pState_converted,(uint8_t)postShift);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_biquad_cascade_df2T_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_biquad_cascade_df2T_instance_f32Object *selfS = (dsp_arm_biquad_cascade_df2T_instance_f32Object *)S;
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_biquad_cascade_df2T_f32(selfS->instance,pSrc_converted,pDst,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_biquad_cascade_stereo_df2T_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_biquad_cascade_stereo_df2T_instance_f32Object *selfS = (dsp_arm_biquad_cascade_stereo_df2T_instance_f32Object *)S;
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_biquad_cascade_stereo_df2T_f32(selfS->instance,pSrc_converted,pDst,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_biquad_cascade_df2T_f64(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  float64_t *pSrc_converted=NULL; // input
+  float64_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_biquad_cascade_df2T_instance_f64Object *selfS = (dsp_arm_biquad_cascade_df2T_instance_f64Object *)S;
+    GETARGUMENT(pSrc,NPY_FLOAT64,float64_t,float64_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(float64_t)*blockSize);
+
+
+    arm_biquad_cascade_df2T_f64(selfS->instance,pSrc_converted,pDst,blockSize);
+ FLOAT64ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_biquad_cascade_df2T_init_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint32_t numStages; // input
+  PyObject *pCoeffs=NULL; // input
+  float32_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  float32_t *pState_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OiOO",&S,&numStages,&pCoeffs,&pState))
+  {
+
+    dsp_arm_biquad_cascade_df2T_instance_f32Object *selfS = (dsp_arm_biquad_cascade_df2T_instance_f32Object *)S;
+    GETARGUMENT(pCoeffs,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
+
+    arm_biquad_cascade_df2T_init_f32(selfS->instance,(uint8_t)numStages,pCoeffs_converted,pState_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_biquad_cascade_stereo_df2T_init_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint32_t numStages; // input
+  PyObject *pCoeffs=NULL; // input
+  float32_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  float32_t *pState_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OiOO",&S,&numStages,&pCoeffs,&pState))
+  {
+
+    dsp_arm_biquad_cascade_stereo_df2T_instance_f32Object *selfS = (dsp_arm_biquad_cascade_stereo_df2T_instance_f32Object *)S;
+    GETARGUMENT(pCoeffs,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
+
+    arm_biquad_cascade_stereo_df2T_init_f32(selfS->instance,(uint8_t)numStages,pCoeffs_converted,pState_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_biquad_cascade_df2T_init_f64(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint32_t numStages; // input
+  PyObject *pCoeffs=NULL; // input
+  float64_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  float64_t *pState_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OiOO",&S,&numStages,&pCoeffs,&pState))
+  {
+
+    dsp_arm_biquad_cascade_df2T_instance_f64Object *selfS = (dsp_arm_biquad_cascade_df2T_instance_f64Object *)S;
+    GETARGUMENT(pCoeffs,NPY_FLOAT64,float64_t,float64_t);
+    GETARGUMENT(pState,NPY_FLOAT64,float64_t,float64_t);
+
+    arm_biquad_cascade_df2T_init_f64(selfS->instance,(uint8_t)numStages,pCoeffs_converted,pState_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_lattice_init_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numStages; // input
+  PyObject *pCoeffs=NULL; // input
+  q15_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q15_t *pState_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OhOO",&S,&numStages,&pCoeffs,&pState))
+  {
+
+    dsp_arm_fir_lattice_instance_q15Object *selfS = (dsp_arm_fir_lattice_instance_q15Object *)S;
+    GETARGUMENT(pCoeffs,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
+
+    arm_fir_lattice_init_q15(selfS->instance,numStages,pCoeffs_converted,pState_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_lattice_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_fir_lattice_instance_q15Object *selfS = (dsp_arm_fir_lattice_instance_q15Object *)S;
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_fir_lattice_q15(selfS->instance,pSrc_converted,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_lattice_init_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numStages; // input
+  PyObject *pCoeffs=NULL; // input
+  q31_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q31_t *pState_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OhOO",&S,&numStages,&pCoeffs,&pState))
+  {
+
+    dsp_arm_fir_lattice_instance_q31Object *selfS = (dsp_arm_fir_lattice_instance_q31Object *)S;
+    GETARGUMENT(pCoeffs,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
+
+    arm_fir_lattice_init_q31(selfS->instance,numStages,pCoeffs_converted,pState_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_lattice_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_fir_lattice_instance_q31Object *selfS = (dsp_arm_fir_lattice_instance_q31Object *)S;
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_fir_lattice_q31(selfS->instance,pSrc_converted,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_lattice_init_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numStages; // input
+  PyObject *pCoeffs=NULL; // input
+  float32_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  float32_t *pState_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OhOO",&S,&numStages,&pCoeffs,&pState))
+  {
+
+    dsp_arm_fir_lattice_instance_f32Object *selfS = (dsp_arm_fir_lattice_instance_f32Object *)S;
+    GETARGUMENT(pCoeffs,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
+
+    arm_fir_lattice_init_f32(selfS->instance,numStages,pCoeffs_converted,pState_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_lattice_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_fir_lattice_instance_f32Object *selfS = (dsp_arm_fir_lattice_instance_f32Object *)S;
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_fir_lattice_f32(selfS->instance,pSrc_converted,pDst,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_iir_lattice_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_iir_lattice_instance_f32Object *selfS = (dsp_arm_iir_lattice_instance_f32Object *)S;
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_iir_lattice_f32(selfS->instance,pSrc_converted,pDst,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_iir_lattice_init_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numStages; // input
+  PyObject *pkCoeffs=NULL; // input
+  float32_t *pkCoeffs_converted=NULL; // input
+  PyObject *pvCoeffs=NULL; // input
+  float32_t *pvCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  float32_t *pState_converted=NULL; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OhOOO",&S,&numStages,&pkCoeffs,&pvCoeffs,&pState))
+  {
+
+    dsp_arm_iir_lattice_instance_f32Object *selfS = (dsp_arm_iir_lattice_instance_f32Object *)S;
+    GETARGUMENT(pkCoeffs,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pvCoeffs,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepkCoeffs ;
+
+    arm_iir_lattice_init_f32(selfS->instance,numStages,pkCoeffs_converted,pvCoeffs_converted,pState_converted,blockSize);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_iir_lattice_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_iir_lattice_instance_q31Object *selfS = (dsp_arm_iir_lattice_instance_q31Object *)S;
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_iir_lattice_q31(selfS->instance,pSrc_converted,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_iir_lattice_init_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numStages; // input
+  PyObject *pkCoeffs=NULL; // input
+  q31_t *pkCoeffs_converted=NULL; // input
+  PyObject *pvCoeffs=NULL; // input
+  q31_t *pvCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q31_t *pState_converted=NULL; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OhOOO",&S,&numStages,&pkCoeffs,&pvCoeffs,&pState))
+  {
+
+    dsp_arm_iir_lattice_instance_q31Object *selfS = (dsp_arm_iir_lattice_instance_q31Object *)S;
+    GETARGUMENT(pkCoeffs,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pvCoeffs,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepkCoeffs ;
+
+    arm_iir_lattice_init_q31(selfS->instance,numStages,pkCoeffs_converted,pvCoeffs_converted,pState_converted,blockSize);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_iir_lattice_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_iir_lattice_instance_q15Object *selfS = (dsp_arm_iir_lattice_instance_q15Object *)S;
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_iir_lattice_q15(selfS->instance,pSrc_converted,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_iir_lattice_init_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numStages; // input
+  PyObject *pkCoeffs=NULL; // input
+  q15_t *pkCoeffs_converted=NULL; // input
+  PyObject *pvCoeffs=NULL; // input
+  q15_t *pvCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q15_t *pState_converted=NULL; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OhOOO",&S,&numStages,&pkCoeffs,&pvCoeffs,&pState))
+  {
+
+    dsp_arm_iir_lattice_instance_q15Object *selfS = (dsp_arm_iir_lattice_instance_q15Object *)S;
+    GETARGUMENT(pkCoeffs,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pvCoeffs,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepkCoeffs ;
+
+    arm_iir_lattice_init_q15(selfS->instance,numStages,pkCoeffs_converted,pvCoeffs_converted,pState_converted,blockSize);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+
+static PyObject *
+cmsis_arm_lms_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  PyObject *pRef=NULL; // input
+  float32_t *pRef_converted=NULL; // input
+  float32_t *pOut=NULL; // output
+  PyObject *pErr=NULL; // input
+  float32_t *pErr_converted=NULL; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OOOO",&S,&pSrc,&pRef,&pErr))
+  {
+
+    dsp_arm_lms_instance_f32Object *selfS = (dsp_arm_lms_instance_f32Object *)S;
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pRef,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pErr,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pOut=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_lms_f32(selfS->instance,pSrc_converted,pRef_converted,pOut,pErr_converted,blockSize);
+ FLOATARRAY1(pOutOBJ,blockSize,pOut);
+
+    PyObject *pythonResult = Py_BuildValue("O",pOutOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    FREEARGUMENT(pRef_converted);
+    Py_DECREF(pOutOBJ);
+    FREEARGUMENT(pErr_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_lms_init_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numTaps; // input
+  PyObject *pCoeffs=NULL; // input
+  float32_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  float32_t *pState_converted=NULL; // input
+  float32_t mu; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OhOOf",&S,&numTaps,&pCoeffs,&pState,&mu))
+  {
+
+    dsp_arm_lms_instance_f32Object *selfS = (dsp_arm_lms_instance_f32Object *)S;
+    GETARGUMENT(pCoeffs,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepState - arraySizepCoeffs + 1 ;
+
+    arm_lms_init_f32(selfS->instance,numTaps,pCoeffs_converted,pState_converted,mu,blockSize);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_lms_init_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numTaps; // input
+  PyObject *pCoeffs=NULL; // input
+  q15_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q15_t *pState_converted=NULL; // input
+  q15_t mu; // input
+  uint32_t blockSize; // input
+  uint32_t postShift; // input
+
+  if (PyArg_ParseTuple(args,"OhOOhi",&S,&numTaps,&pCoeffs,&pState,&mu,&postShift))
+  {
+
+    dsp_arm_lms_instance_q15Object *selfS = (dsp_arm_lms_instance_q15Object *)S;
+    GETARGUMENT(pCoeffs,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepState - arraySizepCoeffs + 1 ;
+
+    arm_lms_init_q15(selfS->instance,numTaps,pCoeffs_converted,pState_converted,mu,blockSize,postShift);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_lms_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  PyObject *pRef=NULL; // input
+  q15_t *pRef_converted=NULL; // input
+  q15_t *pOut=NULL; // output
+  PyObject *pErr=NULL; // input
+  q15_t *pErr_converted=NULL; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OOOO",&S,&pSrc,&pRef,&pErr))
+  {
+
+    dsp_arm_lms_instance_q15Object *selfS = (dsp_arm_lms_instance_q15Object *)S;
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pRef,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pErr,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pOut=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_lms_q15(selfS->instance,pSrc_converted,pRef_converted,pOut,pErr_converted,blockSize);
+ INT16ARRAY1(pOutOBJ,blockSize,pOut);
+
+    PyObject *pythonResult = Py_BuildValue("O",pOutOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    FREEARGUMENT(pRef_converted);
+    Py_DECREF(pOutOBJ);
+    FREEARGUMENT(pErr_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_lms_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  PyObject *pRef=NULL; // input
+  q31_t *pRef_converted=NULL; // input
+  q31_t *pOut=NULL; // output
+  PyObject *pErr=NULL; // input
+  q31_t *pErr_converted=NULL; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OOOO",&S,&pSrc,&pRef,&pErr))
+  {
+
+    dsp_arm_lms_instance_q31Object *selfS = (dsp_arm_lms_instance_q31Object *)S;
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pRef,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pErr,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pOut=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_lms_q31(selfS->instance,pSrc_converted,pRef_converted,pOut,pErr_converted,blockSize);
+ INT32ARRAY1(pOutOBJ,blockSize,pOut);
+
+    PyObject *pythonResult = Py_BuildValue("O",pOutOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    FREEARGUMENT(pRef_converted);
+    Py_DECREF(pOutOBJ);
+    FREEARGUMENT(pErr_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_lms_init_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numTaps; // input
+  PyObject *pCoeffs=NULL; // input
+  q31_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q31_t *pState_converted=NULL; // input
+  q31_t mu; // input
+  uint32_t blockSize; // input
+  uint32_t postShift; // input
+
+  if (PyArg_ParseTuple(args,"OhOOii",&S,&numTaps,&pCoeffs,&pState,&mu,&postShift))
+  {
+
+    dsp_arm_lms_instance_q31Object *selfS = (dsp_arm_lms_instance_q31Object *)S;
+    GETARGUMENT(pCoeffs,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepState - arraySizepCoeffs + 1 ;
+
+    arm_lms_init_q31(selfS->instance,numTaps,pCoeffs_converted,pState_converted,mu,blockSize,postShift);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_lms_norm_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  PyObject *pRef=NULL; // input
+  float32_t *pRef_converted=NULL; // input
+  float32_t *pOut=NULL; // output
+  PyObject *pErr=NULL; // input
+  float32_t *pErr_converted=NULL; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OOOO",&S,&pSrc,&pRef,&pErr))
+  {
+
+    dsp_arm_lms_norm_instance_f32Object *selfS = (dsp_arm_lms_norm_instance_f32Object *)S;
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pRef,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pErr,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pOut=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_lms_norm_f32(selfS->instance,pSrc_converted,pRef_converted,pOut,pErr_converted,blockSize);
+ FLOATARRAY1(pOutOBJ,blockSize,pOut);
+
+    PyObject *pythonResult = Py_BuildValue("O",pOutOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    FREEARGUMENT(pRef_converted);
+    Py_DECREF(pOutOBJ);
+    FREEARGUMENT(pErr_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_lms_norm_init_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numTaps; // input
+  PyObject *pCoeffs=NULL; // input
+  float32_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  float32_t *pState_converted=NULL; // input
+  float32_t mu; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OhOOf",&S,&numTaps,&pCoeffs,&pState,&mu))
+  {
+
+    dsp_arm_lms_norm_instance_f32Object *selfS = (dsp_arm_lms_norm_instance_f32Object *)S;
+    GETARGUMENT(pCoeffs,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepState - arraySizepCoeffs + 1 ;
+
+    arm_lms_norm_init_f32(selfS->instance,numTaps,pCoeffs_converted,pState_converted,mu,blockSize);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_lms_norm_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  PyObject *pRef=NULL; // input
+  q31_t *pRef_converted=NULL; // input
+  q31_t *pOut=NULL; // output
+  PyObject *pErr=NULL; // input
+  q31_t *pErr_converted=NULL; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OOOO",&S,&pSrc,&pRef,&pErr))
+  {
+
+    dsp_arm_lms_norm_instance_q31Object *selfS = (dsp_arm_lms_norm_instance_q31Object *)S;
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pRef,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pErr,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pOut=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_lms_norm_q31(selfS->instance,pSrc_converted,pRef_converted,pOut,pErr_converted,blockSize);
+ INT32ARRAY1(pOutOBJ,blockSize,pOut);
+
+    PyObject *pythonResult = Py_BuildValue("O",pOutOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    FREEARGUMENT(pRef_converted);
+    Py_DECREF(pOutOBJ);
+    FREEARGUMENT(pErr_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_lms_norm_init_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numTaps; // input
+  PyObject *pCoeffs=NULL; // input
+  q31_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q31_t *pState_converted=NULL; // input
+  q31_t mu; // input
+  uint32_t blockSize; // input
+  uint32_t postShift; // input
+
+  if (PyArg_ParseTuple(args,"OhOOii",&S,&numTaps,&pCoeffs,&pState,&mu,&postShift))
+  {
+
+    dsp_arm_lms_norm_instance_q31Object *selfS = (dsp_arm_lms_norm_instance_q31Object *)S;
+    GETARGUMENT(pCoeffs,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepState - arraySizepCoeffs + 1 ;
+
+    arm_lms_norm_init_q31(selfS->instance,numTaps,pCoeffs_converted,pState_converted,mu,blockSize,(uint8_t)postShift);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_lms_norm_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  PyObject *pRef=NULL; // input
+  q15_t *pRef_converted=NULL; // input
+  q15_t *pOut=NULL; // output
+  PyObject *pErr=NULL; // input
+  q15_t *pErr_converted=NULL; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OOOO",&S,&pSrc,&pRef,&pErr))
+  {
+
+    dsp_arm_lms_norm_instance_q15Object *selfS = (dsp_arm_lms_norm_instance_q15Object *)S;
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pRef,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pErr,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pOut=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_lms_norm_q15(selfS->instance,pSrc_converted,pRef_converted,pOut,pErr_converted,blockSize);
+ INT16ARRAY1(pOutOBJ,blockSize,pOut);
+
+    PyObject *pythonResult = Py_BuildValue("O",pOutOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    FREEARGUMENT(pRef_converted);
+    Py_DECREF(pOutOBJ);
+    FREEARGUMENT(pErr_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_lms_norm_init_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numTaps; // input
+  PyObject *pCoeffs=NULL; // input
+  q15_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q15_t *pState_converted=NULL; // input
+  q15_t mu; // input
+  uint32_t blockSize; // input
+  uint32_t postShift; // input
+
+  if (PyArg_ParseTuple(args,"OhOOhi",&S,&numTaps,&pCoeffs,&pState,&mu,&postShift))
+  {
+
+    dsp_arm_lms_norm_instance_q15Object *selfS = (dsp_arm_lms_norm_instance_q15Object *)S;
+    GETARGUMENT(pCoeffs,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepState - arraySizepCoeffs + 1 ;
+
+    arm_lms_norm_init_q15(selfS->instance,numTaps,pCoeffs_converted,pState_converted,mu,blockSize,(uint8_t)postShift);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_correlate_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  float32_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  float32_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  float32_t *pDst=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
+  {
+
+    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
+    uint32_t outputLength = 2*MAX(srcALen,srcBLen) - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*outputLength);
+
+
+    arm_correlate_f32(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
+ FLOATARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_correlate_opt_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q15_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q15_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q15_t *pDst=NULL; // output
+  PyObject *pScratch=NULL; // input
+  q15_t *pScratch_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OiOiO",&pSrcA,&srcALen,&pSrcB,&srcBLen,&pScratch))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pScratch,NPY_INT16,int16_t,int16_t);
+    uint32_t outputLength = 2*MAX(srcALen,srcBLen) - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
+
+
+    arm_correlate_opt_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,pScratch_converted);
+ INT16ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    FREEARGUMENT(pScratch_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_correlate_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q15_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q15_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q15_t *pDst=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
+    uint32_t outputLength = 2*MAX(srcALen,srcBLen) - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
+
+
+    arm_correlate_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
+ INT16ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_correlate_fast_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q15_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q15_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q15_t *pDst=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
+    uint32_t outputLength = 2*MAX(srcALen,srcBLen) - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
+
+
+    arm_correlate_fast_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
+ INT16ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_correlate_fast_opt_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q15_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q15_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q15_t *pDst=NULL; // output
+  PyObject *pScratch=NULL; // input
+  q15_t *pScratch_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OiOiO",&pSrcA,&srcALen,&pSrcB,&srcBLen,&pScratch))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pScratch,NPY_INT16,int16_t,int16_t);
+    uint32_t outputLength = 2*MAX(srcALen,srcBLen) - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
+
+
+    arm_correlate_fast_opt_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,pScratch_converted);
+ INT16ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    FREEARGUMENT(pScratch_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_correlate_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q31_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q31_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q31_t *pDst=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
+    uint32_t outputLength = 2*MAX(srcALen,srcBLen) - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*outputLength);
+
+
+    arm_correlate_q31(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
+ INT32ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_correlate_fast_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q31_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q31_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q31_t *pDst=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
+  {
+
+    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
+    uint32_t outputLength = 2*MAX(srcALen,srcBLen) - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*outputLength);
+
+
+    arm_correlate_fast_q31(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
+ INT32ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_correlate_opt_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q7_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q7_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q7_t *pDst=NULL; // output
+  PyObject *pScratch1=NULL; // input
+  q15_t *pScratch1_converted=NULL; // input
+  PyObject *pScratch2=NULL; // input
+  q15_t *pScratch2_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OiOiOO",&pSrcA,&srcALen,&pSrcB,&srcBLen,&pScratch1,&pScratch2))
+  {
+
+    GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
+    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
+    GETARGUMENT(pScratch1,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pScratch2,NPY_INT16,int16_t,int16_t);
+    uint32_t outputLength = 2*MAX(srcALen,srcBLen) - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*outputLength);
+
+
+    arm_correlate_opt_q7(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,pScratch1_converted,pScratch2_converted);
+ INT8ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    FREEARGUMENT(pScratch1_converted);
+    FREEARGUMENT(pScratch2_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_correlate_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  q7_t *pSrcA_converted=NULL; // input
+  uint32_t srcALen; // input
+  PyObject *pSrcB=NULL; // input
+  q7_t *pSrcB_converted=NULL; // input
+  uint32_t srcBLen; // input
+  q7_t *pDst=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
+  {
+
+    GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
+    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
+    uint32_t outputLength = 2*MAX(srcALen,srcBLen) - 1 ;
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*outputLength);
+
+
+    arm_correlate_q7(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
+ INT8ARRAY1(pDstOBJ,outputLength,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_sparse_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  PyObject *pScratchIn=NULL; // input
+  float32_t *pScratchIn_converted=NULL; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OOO",&S,&pSrc,&pScratchIn))
+  {
+
+    dsp_arm_fir_sparse_instance_f32Object *selfS = (dsp_arm_fir_sparse_instance_f32Object *)S;
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pScratchIn,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_fir_sparse_f32(selfS->instance,pSrc_converted,pDst,pScratchIn_converted,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    FREEARGUMENT(pScratchIn_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_sparse_init_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numTaps; // input
+  PyObject *pCoeffs=NULL; // input
+  float32_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  float32_t *pState_converted=NULL; // input
+  PyObject *pTapDelay=NULL; // input
+  int32_t *pTapDelay_converted=NULL; // input
+  uint16_t maxDelay; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OhOOOh",&S,&numTaps,&pCoeffs,&pState,&pTapDelay,&maxDelay))
+  {
+
+    dsp_arm_fir_sparse_instance_f32Object *selfS = (dsp_arm_fir_sparse_instance_f32Object *)S;
+    GETARGUMENT(pCoeffs,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pTapDelay,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepState - arraySizepCoeffs + 1;
+
+    arm_fir_sparse_init_f32(selfS->instance,numTaps,pCoeffs_converted,pState_converted,pTapDelay_converted,maxDelay,blockSize);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_sparse_init_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numTaps; // input
+  PyObject *pCoeffs=NULL; // input
+  q31_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q31_t *pState_converted=NULL; // input
+  PyObject *pTapDelay=NULL; // input
+  int32_t *pTapDelay_converted=NULL; // input
+  uint16_t maxDelay; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OhOOOh",&S,&numTaps,&pCoeffs,&pState,&pTapDelay,&maxDelay))
+  {
+
+    dsp_arm_fir_sparse_instance_q31Object *selfS = (dsp_arm_fir_sparse_instance_q31Object *)S;
+    GETARGUMENT(pCoeffs,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pTapDelay,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepState - arraySizepCoeffs + 1;
+
+    arm_fir_sparse_init_q31(selfS->instance,numTaps,pCoeffs_converted,pState_converted,pTapDelay_converted,maxDelay,blockSize);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_sparse_init_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numTaps; // input
+  PyObject *pCoeffs=NULL; // input
+  q15_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q15_t *pState_converted=NULL; // input
+  PyObject *pTapDelay=NULL; // input
+  int32_t *pTapDelay_converted=NULL; // input
+  uint16_t maxDelay; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OhOOOh",&S,&numTaps,&pCoeffs,&pState,&pTapDelay,&maxDelay))
+  {
+
+    dsp_arm_fir_sparse_instance_q15Object *selfS = (dsp_arm_fir_sparse_instance_q15Object *)S;
+    GETARGUMENT(pCoeffs,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pTapDelay,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepState - arraySizepCoeffs + 1;
+
+    arm_fir_sparse_init_q15(selfS->instance,numTaps,pCoeffs_converted,pState_converted,pTapDelay_converted,maxDelay,blockSize);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_fir_sparse_init_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t numTaps; // input
+  PyObject *pCoeffs=NULL; // input
+  q7_t *pCoeffs_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q7_t *pState_converted=NULL; // input
+  PyObject *pTapDelay=NULL; // input
+  int32_t *pTapDelay_converted=NULL; // input
+  uint16_t maxDelay; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OhOOOh",&S,&numTaps,&pCoeffs,&pState,&pTapDelay,&maxDelay))
+  {
+
+    dsp_arm_fir_sparse_instance_q7Object *selfS = (dsp_arm_fir_sparse_instance_q7Object *)S;
+    GETARGUMENT(pCoeffs,NPY_BYTE,int8_t,q7_t);
+    GETARGUMENT(pState,NPY_BYTE,int8_t,q7_t);
+    GETARGUMENT(pTapDelay,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepState - arraySizepCoeffs + 1;
+
+    arm_fir_sparse_init_q7(selfS->instance,numTaps,pCoeffs_converted,pState_converted,pTapDelay_converted,maxDelay,blockSize);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_circularWrite_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *circBuffer=NULL; // input
+  int32_t *circBuffer_converted=NULL; // input
+  int32_t L; // input
+  PyObject *writeOffset=NULL; // input
+  uint16_t *writeOffset_converted=NULL; // input
+  int32_t bufferInc; // input
+  PyObject *src=NULL; // input
+  int32_t *src_converted=NULL; // input
+  int32_t srcInc; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OiOiOi",&circBuffer,&L,&writeOffset,&bufferInc,&src,&srcInc))
+  {
+
+    GETARGUMENT(circBuffer,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(writeOffset,NPY_UINT16,uint16_t,uint16_t);
+    GETARGUMENT(src,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizecircBuffer ;
+
+    arm_circularWrite_f32(circBuffer_converted,L,writeOffset_converted,bufferInc,src_converted,srcInc,blockSize);
+    FREEARGUMENT(circBuffer_converted);
+    FREEARGUMENT(writeOffset_converted);
+    FREEARGUMENT(src_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_circularWrite_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *circBuffer=NULL; // input
+  q15_t *circBuffer_converted=NULL; // input
+  int32_t L; // input
+  PyObject *writeOffset=NULL; // input
+  uint16_t *writeOffset_converted=NULL; // input
+  int32_t bufferInc; // input
+  PyObject *src=NULL; // input
+  q15_t *src_converted=NULL; // input
+  int32_t srcInc; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OiOiOi",&circBuffer,&L,&writeOffset,&bufferInc,&src,&srcInc))
+  {
+
+    GETARGUMENT(circBuffer,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(writeOffset,NPY_UINT16,uint16_t,uint16_t);
+    GETARGUMENT(src,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizecircBuffer ;
+
+    arm_circularWrite_q15(circBuffer_converted,L,writeOffset_converted,bufferInc,src_converted,srcInc,blockSize);
+    FREEARGUMENT(circBuffer_converted);
+    FREEARGUMENT(writeOffset_converted);
+    FREEARGUMENT(src_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_circularWrite_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *circBuffer=NULL; // input
+  q7_t *circBuffer_converted=NULL; // input
+  int32_t L; // input
+  PyObject *writeOffset=NULL; // input
+  uint16_t *writeOffset_converted=NULL; // input
+  int32_t bufferInc; // input
+  PyObject *src=NULL; // input
+  q7_t *src_converted=NULL; // input
+  int32_t srcInc; // input
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"OiOiOi",&circBuffer,&L,&writeOffset,&bufferInc,&src,&srcInc))
+  {
+
+    GETARGUMENT(circBuffer,NPY_BYTE,int8_t,q7_t);
+    GETARGUMENT(writeOffset,NPY_UINT16,uint16_t,uint16_t);
+    GETARGUMENT(src,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizecircBuffer ;
+
+    arm_circularWrite_q7(circBuffer_converted,L,writeOffset_converted,bufferInc,src_converted,srcInc,blockSize);
+    FREEARGUMENT(circBuffer_converted);
+    FREEARGUMENT(writeOffset_converted);
+    FREEARGUMENT(src_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+static PyMethodDef CMSISDSPMethods[] = {
+
+
+{"arm_fir_q7",  cmsis_arm_fir_q7, METH_VARARGS,""},
+{"arm_fir_init_q7",  cmsis_arm_fir_init_q7, METH_VARARGS,""},
+{"arm_fir_q15",  cmsis_arm_fir_q15, METH_VARARGS,""},
+{"arm_fir_fast_q15",  cmsis_arm_fir_fast_q15, METH_VARARGS,""},
+{"arm_fir_init_q15",  cmsis_arm_fir_init_q15, METH_VARARGS,""},
+{"arm_fir_q31",  cmsis_arm_fir_q31, METH_VARARGS,""},
+{"arm_fir_fast_q31",  cmsis_arm_fir_fast_q31, METH_VARARGS,""},
+{"arm_fir_init_q31",  cmsis_arm_fir_init_q31, METH_VARARGS,""},
+{"arm_fir_f32",  cmsis_arm_fir_f32, METH_VARARGS,""},
+{"arm_fir_init_f32",  cmsis_arm_fir_init_f32, METH_VARARGS,""},
+{"arm_biquad_cascade_df1_q15",  cmsis_arm_biquad_cascade_df1_q15, METH_VARARGS,""},
+{"arm_biquad_cascade_df1_init_q15",  cmsis_arm_biquad_cascade_df1_init_q15, METH_VARARGS,""},
+{"arm_biquad_cascade_df1_fast_q15",  cmsis_arm_biquad_cascade_df1_fast_q15, METH_VARARGS,""},
+{"arm_biquad_cascade_df1_q31",  cmsis_arm_biquad_cascade_df1_q31, METH_VARARGS,""},
+{"arm_biquad_cascade_df1_fast_q31",  cmsis_arm_biquad_cascade_df1_fast_q31, METH_VARARGS,""},
+{"arm_biquad_cascade_df1_init_q31",  cmsis_arm_biquad_cascade_df1_init_q31, METH_VARARGS,""},
+{"arm_biquad_cascade_df1_f32",  cmsis_arm_biquad_cascade_df1_f32, METH_VARARGS,""},
+{"arm_biquad_cascade_df1_init_f32",  cmsis_arm_biquad_cascade_df1_init_f32, METH_VARARGS,""},
+
+
+
+{"arm_conv_f32",  cmsis_arm_conv_f32, METH_VARARGS,""},
+{"arm_conv_opt_q15",  cmsis_arm_conv_opt_q15, METH_VARARGS,""},
+{"arm_conv_q15",  cmsis_arm_conv_q15, METH_VARARGS,""},
+{"arm_conv_fast_q15",  cmsis_arm_conv_fast_q15, METH_VARARGS,""},
+{"arm_conv_fast_opt_q15",  cmsis_arm_conv_fast_opt_q15, METH_VARARGS,""},
+{"arm_conv_q31",  cmsis_arm_conv_q31, METH_VARARGS,""},
+{"arm_conv_fast_q31",  cmsis_arm_conv_fast_q31, METH_VARARGS,""},
+{"arm_conv_opt_q7",  cmsis_arm_conv_opt_q7, METH_VARARGS,""},
+{"arm_conv_q7",  cmsis_arm_conv_q7, METH_VARARGS,""},
+{"arm_conv_partial_f32",  cmsis_arm_conv_partial_f32, METH_VARARGS,""},
+{"arm_conv_partial_opt_q15",  cmsis_arm_conv_partial_opt_q15, METH_VARARGS,""},
+{"arm_conv_partial_q15",  cmsis_arm_conv_partial_q15, METH_VARARGS,""},
+{"arm_conv_partial_fast_q15",  cmsis_arm_conv_partial_fast_q15, METH_VARARGS,""},
+{"arm_conv_partial_fast_opt_q15",  cmsis_arm_conv_partial_fast_opt_q15, METH_VARARGS,""},
+{"arm_conv_partial_q31",  cmsis_arm_conv_partial_q31, METH_VARARGS,""},
+{"arm_conv_partial_fast_q31",  cmsis_arm_conv_partial_fast_q31, METH_VARARGS,""},
+{"arm_conv_partial_opt_q7",  cmsis_arm_conv_partial_opt_q7, METH_VARARGS,""},
+{"arm_conv_partial_q7",  cmsis_arm_conv_partial_q7, METH_VARARGS,""},
+{"arm_fir_decimate_f32",  cmsis_arm_fir_decimate_f32, METH_VARARGS,""},
+{"arm_fir_decimate_init_f32",  cmsis_arm_fir_decimate_init_f32, METH_VARARGS,""},
+{"arm_fir_decimate_q15",  cmsis_arm_fir_decimate_q15, METH_VARARGS,""},
+{"arm_fir_decimate_fast_q15",  cmsis_arm_fir_decimate_fast_q15, METH_VARARGS,""},
+{"arm_fir_decimate_init_q15",  cmsis_arm_fir_decimate_init_q15, METH_VARARGS,""},
+{"arm_fir_decimate_q31",  cmsis_arm_fir_decimate_q31, METH_VARARGS,""},
+{"arm_fir_decimate_fast_q31",  cmsis_arm_fir_decimate_fast_q31, METH_VARARGS,""},
+{"arm_fir_decimate_init_q31",  cmsis_arm_fir_decimate_init_q31, METH_VARARGS,""},
+{"arm_fir_interpolate_q15",  cmsis_arm_fir_interpolate_q15, METH_VARARGS,""},
+{"arm_fir_interpolate_init_q15",  cmsis_arm_fir_interpolate_init_q15, METH_VARARGS,""},
+{"arm_fir_interpolate_q31",  cmsis_arm_fir_interpolate_q31, METH_VARARGS,""},
+{"arm_fir_interpolate_init_q31",  cmsis_arm_fir_interpolate_init_q31, METH_VARARGS,""},
+{"arm_fir_interpolate_f32",  cmsis_arm_fir_interpolate_f32, METH_VARARGS,""},
+{"arm_fir_interpolate_init_f32",  cmsis_arm_fir_interpolate_init_f32, METH_VARARGS,""},
+{"arm_biquad_cas_df1_32x64_q31",  cmsis_arm_biquad_cas_df1_32x64_q31, METH_VARARGS,""},
+{"arm_biquad_cas_df1_32x64_init_q31",  cmsis_arm_biquad_cas_df1_32x64_init_q31, METH_VARARGS,""},
+{"arm_biquad_cascade_df2T_f32",  cmsis_arm_biquad_cascade_df2T_f32, METH_VARARGS,""},
+{"arm_biquad_cascade_stereo_df2T_f32",  cmsis_arm_biquad_cascade_stereo_df2T_f32, METH_VARARGS,""},
+{"arm_biquad_cascade_df2T_f64",  cmsis_arm_biquad_cascade_df2T_f64, METH_VARARGS,""},
+{"arm_biquad_cascade_df2T_init_f32",  cmsis_arm_biquad_cascade_df2T_init_f32, METH_VARARGS,""},
+{"arm_biquad_cascade_stereo_df2T_init_f32",  cmsis_arm_biquad_cascade_stereo_df2T_init_f32, METH_VARARGS,""},
+{"arm_biquad_cascade_df2T_init_f64",  cmsis_arm_biquad_cascade_df2T_init_f64, METH_VARARGS,""},
+{"arm_fir_lattice_init_q15",  cmsis_arm_fir_lattice_init_q15, METH_VARARGS,""},
+{"arm_fir_lattice_q15",  cmsis_arm_fir_lattice_q15, METH_VARARGS,""},
+{"arm_fir_lattice_init_q31",  cmsis_arm_fir_lattice_init_q31, METH_VARARGS,""},
+{"arm_fir_lattice_q31",  cmsis_arm_fir_lattice_q31, METH_VARARGS,""},
+{"arm_fir_lattice_init_f32",  cmsis_arm_fir_lattice_init_f32, METH_VARARGS,""},
+{"arm_fir_lattice_f32",  cmsis_arm_fir_lattice_f32, METH_VARARGS,""},
+{"arm_iir_lattice_f32",  cmsis_arm_iir_lattice_f32, METH_VARARGS,""},
+{"arm_iir_lattice_init_f32",  cmsis_arm_iir_lattice_init_f32, METH_VARARGS,""},
+{"arm_iir_lattice_q31",  cmsis_arm_iir_lattice_q31, METH_VARARGS,""},
+{"arm_iir_lattice_init_q31",  cmsis_arm_iir_lattice_init_q31, METH_VARARGS,""},
+{"arm_iir_lattice_q15",  cmsis_arm_iir_lattice_q15, METH_VARARGS,""},
+{"arm_iir_lattice_init_q15",  cmsis_arm_iir_lattice_init_q15, METH_VARARGS,""},
+{"arm_lms_f32",  cmsis_arm_lms_f32, METH_VARARGS,""},
+{"arm_lms_init_f32",  cmsis_arm_lms_init_f32, METH_VARARGS,""},
+{"arm_lms_init_q15",  cmsis_arm_lms_init_q15, METH_VARARGS,""},
+{"arm_lms_q15",  cmsis_arm_lms_q15, METH_VARARGS,""},
+{"arm_lms_q31",  cmsis_arm_lms_q31, METH_VARARGS,""},
+{"arm_lms_init_q31",  cmsis_arm_lms_init_q31, METH_VARARGS,""},
+{"arm_lms_norm_f32",  cmsis_arm_lms_norm_f32, METH_VARARGS,""},
+{"arm_lms_norm_init_f32",  cmsis_arm_lms_norm_init_f32, METH_VARARGS,""},
+{"arm_lms_norm_q31",  cmsis_arm_lms_norm_q31, METH_VARARGS,""},
+{"arm_lms_norm_init_q31",  cmsis_arm_lms_norm_init_q31, METH_VARARGS,""},
+{"arm_lms_norm_q15",  cmsis_arm_lms_norm_q15, METH_VARARGS,""},
+{"arm_lms_norm_init_q15",  cmsis_arm_lms_norm_init_q15, METH_VARARGS,""},
+{"arm_correlate_f32",  cmsis_arm_correlate_f32, METH_VARARGS,""},
+{"arm_correlate_opt_q15",  cmsis_arm_correlate_opt_q15, METH_VARARGS,""},
+{"arm_correlate_q15",  cmsis_arm_correlate_q15, METH_VARARGS,""},
+{"arm_correlate_fast_q15",  cmsis_arm_correlate_fast_q15, METH_VARARGS,""},
+{"arm_correlate_fast_opt_q15",  cmsis_arm_correlate_fast_opt_q15, METH_VARARGS,""},
+{"arm_correlate_q31",  cmsis_arm_correlate_q31, METH_VARARGS,""},
+{"arm_correlate_fast_q31",  cmsis_arm_correlate_fast_q31, METH_VARARGS,""},
+{"arm_correlate_opt_q7",  cmsis_arm_correlate_opt_q7, METH_VARARGS,""},
+{"arm_correlate_q7",  cmsis_arm_correlate_q7, METH_VARARGS,""},
+{"arm_fir_sparse_f32",  cmsis_arm_fir_sparse_f32, METH_VARARGS,""},
+{"arm_fir_sparse_init_f32",  cmsis_arm_fir_sparse_init_f32, METH_VARARGS,""},
+{"arm_fir_sparse_init_q31",  cmsis_arm_fir_sparse_init_q31, METH_VARARGS,""},
+{"arm_fir_sparse_init_q15",  cmsis_arm_fir_sparse_init_q15, METH_VARARGS,""},
+{"arm_fir_sparse_init_q7",  cmsis_arm_fir_sparse_init_q7, METH_VARARGS,""},
+
+{"arm_circularWrite_f32",  cmsis_arm_circularWrite_f32, METH_VARARGS,""},
+{"arm_circularWrite_q15",  cmsis_arm_circularWrite_q15, METH_VARARGS,""},
+{"arm_circularWrite_q7",  cmsis_arm_circularWrite_q7, METH_VARARGS,""},
+
+{"arm_levinson_durbin_f32",  cmsis_arm_levinson_durbin_f32, METH_VARARGS,""},
+{"arm_levinson_durbin_q31",  cmsis_arm_levinson_durbin_q31, METH_VARARGS,""},
+
+
+    {"error_out", (PyCFunction)error_out, METH_NOARGS, NULL},
+    {NULL, NULL, 0, NULL}        /* Sentinel */
+};
+
+#ifdef IS_PY3K
+static int cmsisdsp_traverse(PyObject *m, visitproc visit, void *arg) {
+    Py_VISIT(GETSTATE(m)->error);
+    return 0;
+}
+
+static int cmsisdsp_clear(PyObject *m) {
+    Py_CLEAR(GETSTATE(m)->error);
+    return 0;
+}
+
+
+static struct PyModuleDef moduledef = {
+        PyModuleDef_HEAD_INIT,
+        MODNAME,
+        NULL,
+        sizeof(struct module_state),
+        CMSISDSPMethods,
+        NULL,
+        cmsisdsp_traverse,
+        cmsisdsp_clear,
+        NULL
+};
+
+#define INITERROR return NULL
+
+PyMODINIT_FUNC
+CAT(PyInit_,MODINITNAME)(void)
+
+
+#else
+#define INITERROR return
+
+void CAT(init,MODINITNAME)(void)
+#endif
+{
+    import_array();
+
+  #ifdef IS_PY3K
+    PyObject *module = PyModule_Create(&moduledef);
+  #else
+    PyObject *module = Py_InitModule(MODNAME, CMSISDSPMethods);
+  #endif
+
+  if (module == NULL)
+      INITERROR;
+  struct module_state *st = GETSTATE(module);
+  
+  st->error = PyErr_NewException(MODNAME".Error", NULL, NULL);
+  if (st->error == NULL) {
+      Py_DECREF(module);
+      INITERROR;
+  }
+
+
+  typeRegistration(module);
+
+  #ifdef IS_PY3K
+    return module;
+  #endif
+}

PythonWrapper/cmsisdsp_pkg/src/cmsisdsp_interpolation.c

@@ -0,0 +1,779 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Python Wrapper
+ * Title:        cmsismodule.h
+ * Description:  C code for the CMSIS-DSP Python wrapper
+ *
+ * $Date:        27 April 2021
+ * $Revision:    V1.0
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define MODNAME "cmsisdsp_interpolation"
+#define MODINITNAME cmsisdsp_interpolation
+
+#include "cmsisdsp_module.h"
+
+
+NUMPYVECTORFROMBUFFER(f32,float32_t,NPY_FLOAT);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_linear_interp_instance_f32 *instance;
+} dsp_arm_linear_interp_instance_f32Object;
+
+
+static void
+arm_linear_interp_instance_f32_dealloc(dsp_arm_linear_interp_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pYData)
+       {
+          PyMem_Free(self->instance->pYData);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_linear_interp_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_linear_interp_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_linear_interp_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_linear_interp_instance_f32));
+
+        self->instance->pYData = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_linear_interp_instance_f32_init(dsp_arm_linear_interp_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pYData=NULL;
+char *kwlist[] = {
+"nValues","x1","xSpacing","pYData",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|iffO", kwlist,&self->instance->nValues
+,&self->instance->x1
+,&self->instance->xSpacing
+,&pYData
+))
+    {
+
+    INITARRAYFIELD(pYData,NPY_DOUBLE,double,float32_t);
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_linear_interp_instance_f32,nValues,"i");
+GETFIELD(arm_linear_interp_instance_f32,x1,"f");
+GETFIELD(arm_linear_interp_instance_f32,xSpacing,"f");
+
+
+static PyMethodDef arm_linear_interp_instance_f32_methods[] = {
+
+    {"nValues", (PyCFunction) Method_arm_linear_interp_instance_f32_nValues,METH_NOARGS,"nValues"},
+    {"x1", (PyCFunction) Method_arm_linear_interp_instance_f32_x1,METH_NOARGS,"x1"},
+    {"xSpacing", (PyCFunction) Method_arm_linear_interp_instance_f32_xSpacing,METH_NOARGS,"xSpacing"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_linear_interp_instance_f32,arm_linear_interp_instance_f32_new,arm_linear_interp_instance_f32_dealloc,arm_linear_interp_instance_f32_init,arm_linear_interp_instance_f32_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_bilinear_interp_instance_f32 *instance;
+} dsp_arm_bilinear_interp_instance_f32Object;
+
+
+static void
+arm_bilinear_interp_instance_f32_dealloc(dsp_arm_bilinear_interp_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pData)
+       {
+          PyMem_Free(self->instance->pData);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_bilinear_interp_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_bilinear_interp_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_bilinear_interp_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_bilinear_interp_instance_f32));
+
+        self->instance->pData = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_bilinear_interp_instance_f32_init(dsp_arm_bilinear_interp_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pData=NULL;
+char *kwlist[] = {
+"numRows","numCols","pData",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhO", kwlist,&self->instance->numRows
+,&self->instance->numCols
+,&pData
+))
+    {
+
+    INITARRAYFIELD(pData,NPY_DOUBLE,double,float32_t);
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_bilinear_interp_instance_f32,numRows,"h");
+GETFIELD(arm_bilinear_interp_instance_f32,numCols,"h");
+
+
+static PyMethodDef arm_bilinear_interp_instance_f32_methods[] = {
+
+    {"numRows", (PyCFunction) Method_arm_bilinear_interp_instance_f32_numRows,METH_NOARGS,"numRows"},
+    {"numCols", (PyCFunction) Method_arm_bilinear_interp_instance_f32_numCols,METH_NOARGS,"numCols"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_bilinear_interp_instance_f32,arm_bilinear_interp_instance_f32_new,arm_bilinear_interp_instance_f32_dealloc,arm_bilinear_interp_instance_f32_init,arm_bilinear_interp_instance_f32_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_bilinear_interp_instance_q31 *instance;
+} dsp_arm_bilinear_interp_instance_q31Object;
+
+
+static void
+arm_bilinear_interp_instance_q31_dealloc(dsp_arm_bilinear_interp_instance_q31Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pData)
+       {
+          PyMem_Free(self->instance->pData);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_bilinear_interp_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_bilinear_interp_instance_q31Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_bilinear_interp_instance_q31Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_bilinear_interp_instance_q31));
+
+        self->instance->pData = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_bilinear_interp_instance_q31_init(dsp_arm_bilinear_interp_instance_q31Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pData=NULL;
+char *kwlist[] = {
+"numRows","numCols","pData",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhO", kwlist,&self->instance->numRows
+,&self->instance->numCols
+,&pData
+))
+    {
+
+    INITARRAYFIELD(pData,NPY_INT32,int32_t,int32_t);
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_bilinear_interp_instance_q31,numRows,"h");
+GETFIELD(arm_bilinear_interp_instance_q31,numCols,"h");
+
+
+static PyMethodDef arm_bilinear_interp_instance_q31_methods[] = {
+
+    {"numRows", (PyCFunction) Method_arm_bilinear_interp_instance_q31_numRows,METH_NOARGS,"numRows"},
+    {"numCols", (PyCFunction) Method_arm_bilinear_interp_instance_q31_numCols,METH_NOARGS,"numCols"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_bilinear_interp_instance_q31,arm_bilinear_interp_instance_q31_new,arm_bilinear_interp_instance_q31_dealloc,arm_bilinear_interp_instance_q31_init,arm_bilinear_interp_instance_q31_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_bilinear_interp_instance_q15 *instance;
+} dsp_arm_bilinear_interp_instance_q15Object;
+
+
+static void
+arm_bilinear_interp_instance_q15_dealloc(dsp_arm_bilinear_interp_instance_q15Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pData)
+       {
+          PyMem_Free(self->instance->pData);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_bilinear_interp_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_bilinear_interp_instance_q15Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_bilinear_interp_instance_q15Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_bilinear_interp_instance_q15));
+
+        self->instance->pData = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_bilinear_interp_instance_q15_init(dsp_arm_bilinear_interp_instance_q15Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pData=NULL;
+char *kwlist[] = {
+"numRows","numCols","pData",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhO", kwlist,&self->instance->numRows
+,&self->instance->numCols
+,&pData
+))
+    {
+
+    INITARRAYFIELD(pData,NPY_INT16,int16_t,int16_t);
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_bilinear_interp_instance_q15,numRows,"h");
+GETFIELD(arm_bilinear_interp_instance_q15,numCols,"h");
+
+
+static PyMethodDef arm_bilinear_interp_instance_q15_methods[] = {
+
+    {"numRows", (PyCFunction) Method_arm_bilinear_interp_instance_q15_numRows,METH_NOARGS,"numRows"},
+    {"numCols", (PyCFunction) Method_arm_bilinear_interp_instance_q15_numCols,METH_NOARGS,"numCols"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_bilinear_interp_instance_q15,arm_bilinear_interp_instance_q15_new,arm_bilinear_interp_instance_q15_dealloc,arm_bilinear_interp_instance_q15_init,arm_bilinear_interp_instance_q15_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_bilinear_interp_instance_q7 *instance;
+} dsp_arm_bilinear_interp_instance_q7Object;
+
+
+static void
+arm_bilinear_interp_instance_q7_dealloc(dsp_arm_bilinear_interp_instance_q7Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pData)
+       {
+          PyMem_Free(self->instance->pData);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_bilinear_interp_instance_q7_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_bilinear_interp_instance_q7Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_bilinear_interp_instance_q7Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_bilinear_interp_instance_q7));
+
+        self->instance->pData = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_bilinear_interp_instance_q7_init(dsp_arm_bilinear_interp_instance_q7Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pData=NULL;
+char *kwlist[] = {
+"numRows","numCols","pData",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhO", kwlist,&self->instance->numRows
+,&self->instance->numCols
+,&pData
+))
+    {
+
+    INITARRAYFIELD(pData,NPY_BYTE,int8_t,q7_t);
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_bilinear_interp_instance_q7,numRows,"h");
+GETFIELD(arm_bilinear_interp_instance_q7,numCols,"h");
+
+
+static PyMethodDef arm_bilinear_interp_instance_q7_methods[] = {
+
+    {"numRows", (PyCFunction) Method_arm_bilinear_interp_instance_q7_numRows,METH_NOARGS,"numRows"},
+    {"numCols", (PyCFunction) Method_arm_bilinear_interp_instance_q7_numCols,METH_NOARGS,"numCols"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_bilinear_interp_instance_q7,arm_bilinear_interp_instance_q7_new,arm_bilinear_interp_instance_q7_dealloc,arm_bilinear_interp_instance_q7_init,arm_bilinear_interp_instance_q7_methods);
+
+
+
+void typeRegistration(PyObject *module) {
+
+  
+  
+ 
+  ADDTYPE(arm_linear_interp_instance_f32);
+  ADDTYPE(arm_bilinear_interp_instance_f32);
+  ADDTYPE(arm_bilinear_interp_instance_q31);
+  ADDTYPE(arm_bilinear_interp_instance_q15);
+  ADDTYPE(arm_bilinear_interp_instance_q7);
+  
+}
+
+
+
+
+
+static PyObject *
+cmsis_arm_linear_interp_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  float32_t x; // input
+
+  if (PyArg_ParseTuple(args,"Of",&S,&x))
+  {
+
+    dsp_arm_linear_interp_instance_f32Object *selfS = (dsp_arm_linear_interp_instance_f32Object *)S;
+
+    float32_t returnValue = arm_linear_interp_f32(selfS->instance,x);
+    PyObject* theReturnOBJ=Py_BuildValue("f",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_linear_interp_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pYData=NULL; // input
+  q31_t *pYData_converted=NULL; // input
+  q31_t x; // input
+  uint32_t nValues; // input
+
+  if (PyArg_ParseTuple(args,"Oii",&pYData,&x,&nValues))
+  {
+
+    GETARGUMENT(pYData,NPY_INT32,int32_t,int32_t);
+
+    q31_t returnValue = arm_linear_interp_q31(pYData_converted,x,nValues);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pYData_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_linear_interp_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pYData=NULL; // input
+  q15_t *pYData_converted=NULL; // input
+  q31_t x; // input
+  uint32_t nValues; // input
+
+  if (PyArg_ParseTuple(args,"Oii",&pYData,&x,&nValues))
+  {
+
+    GETARGUMENT(pYData,NPY_INT16,int16_t,int16_t);
+
+    q15_t returnValue = arm_linear_interp_q15(pYData_converted,x,nValues);
+    PyObject* theReturnOBJ=Py_BuildValue("h",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pYData_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_linear_interp_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pYData=NULL; // input
+  q7_t *pYData_converted=NULL; // input
+  q31_t x; // input
+  uint32_t nValues; // input
+
+  if (PyArg_ParseTuple(args,"Oii",&pYData,&x,&nValues))
+  {
+
+    GETARGUMENT(pYData,NPY_BYTE,int8_t,q7_t);
+
+    q7_t returnValue = arm_linear_interp_q7(pYData_converted,x,nValues);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pYData_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+
+static PyObject *
+cmsis_arm_bilinear_interp_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  float32_t X; // input
+  float32_t Y; // input
+
+  if (PyArg_ParseTuple(args,"Off",&S,&X,&Y))
+  {
+
+    dsp_arm_bilinear_interp_instance_f32Object *selfS = (dsp_arm_bilinear_interp_instance_f32Object *)S;
+
+    float32_t returnValue = arm_bilinear_interp_f32(selfS->instance,X,Y);
+    PyObject* theReturnOBJ=Py_BuildValue("f",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_bilinear_interp_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  q31_t X; // input
+  q31_t Y; // input
+
+  if (PyArg_ParseTuple(args,"Oii",&S,&X,&Y))
+  {
+
+    dsp_arm_bilinear_interp_instance_q31Object *selfS = (dsp_arm_bilinear_interp_instance_q31Object *)S;
+
+    q31_t returnValue = arm_bilinear_interp_q31(selfS->instance,X,Y);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_bilinear_interp_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  q31_t X; // input
+  q31_t Y; // input
+
+  if (PyArg_ParseTuple(args,"Oii",&S,&X,&Y))
+  {
+
+    dsp_arm_bilinear_interp_instance_q15Object *selfS = (dsp_arm_bilinear_interp_instance_q15Object *)S;
+
+    q15_t returnValue = arm_bilinear_interp_q15(selfS->instance,X,Y);
+    PyObject* theReturnOBJ=Py_BuildValue("h",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_bilinear_interp_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  q31_t X; // input
+  q31_t Y; // input
+
+  if (PyArg_ParseTuple(args,"Oii",&S,&X,&Y))
+  {
+
+    dsp_arm_bilinear_interp_instance_q7Object *selfS = (dsp_arm_bilinear_interp_instance_q7Object *)S;
+
+    q7_t returnValue = arm_bilinear_interp_q7(selfS->instance,X,Y);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+
+
+static PyMethodDef CMSISDSPMethods[] = {
+
+
+
+{"arm_linear_interp_f32",  cmsis_arm_linear_interp_f32, METH_VARARGS,""},
+{"arm_linear_interp_q31",  cmsis_arm_linear_interp_q31, METH_VARARGS,""},
+{"arm_linear_interp_q15",  cmsis_arm_linear_interp_q15, METH_VARARGS,""},
+{"arm_linear_interp_q7",  cmsis_arm_linear_interp_q7, METH_VARARGS,""},
+
+{"arm_bilinear_interp_f32",  cmsis_arm_bilinear_interp_f32, METH_VARARGS,""},
+{"arm_bilinear_interp_q31",  cmsis_arm_bilinear_interp_q31, METH_VARARGS,""},
+{"arm_bilinear_interp_q15",  cmsis_arm_bilinear_interp_q15, METH_VARARGS,""},
+{"arm_bilinear_interp_q7",  cmsis_arm_bilinear_interp_q7, METH_VARARGS,""},
+    {"error_out", (PyCFunction)error_out, METH_NOARGS, NULL},
+    {NULL, NULL, 0, NULL}        /* Sentinel */
+};
+
+#ifdef IS_PY3K
+static int cmsisdsp_traverse(PyObject *m, visitproc visit, void *arg) {
+    Py_VISIT(GETSTATE(m)->error);
+    return 0;
+}
+
+static int cmsisdsp_clear(PyObject *m) {
+    Py_CLEAR(GETSTATE(m)->error);
+    return 0;
+}
+
+
+static struct PyModuleDef moduledef = {
+        PyModuleDef_HEAD_INIT,
+        MODNAME,
+        NULL,
+        sizeof(struct module_state),
+        CMSISDSPMethods,
+        NULL,
+        cmsisdsp_traverse,
+        cmsisdsp_clear,
+        NULL
+};
+
+#define INITERROR return NULL
+
+PyMODINIT_FUNC
+CAT(PyInit_,MODINITNAME)(void)
+
+
+#else
+#define INITERROR return
+
+void CAT(init,MODINITNAME)(void)
+#endif
+{
+    import_array();
+
+  #ifdef IS_PY3K
+    PyObject *module = PyModule_Create(&moduledef);
+  #else
+    PyObject *module = Py_InitModule(MODNAME, CMSISDSPMethods);
+  #endif
+
+  if (module == NULL)
+      INITERROR;
+  struct module_state *st = GETSTATE(module);
+  
+  st->error = PyErr_NewException(MODNAME".Error", NULL, NULL);
+  if (st->error == NULL) {
+      Py_DECREF(module);
+      INITERROR;
+  }
+
+
+  typeRegistration(module);
+
+  #ifdef IS_PY3K
+    return module;
+  #endif
+}

PythonWrapper/cmsisdsp_pkg/src/cmsisdsp_matrix.c

@@ -0,0 +1,1642 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Python Wrapper
+ * Title:        cmsismodule.h
+ * Description:  C code for the CMSIS-DSP Python wrapper
+ *
+ * $Date:        27 April 2021
+ * $Revision:    V1.0
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define MODNAME "cmsisdsp_matrix"
+#define MODINITNAME cmsisdsp_matrix
+
+#include "cmsisdsp_module.h"
+
+MATRIXFROMNUMPY(f32,float32_t,double,NPY_DOUBLE);
+MATRIXFROMNUMPY(f64,float64_t,double,NPY_DOUBLE);
+MATRIXFROMNUMPY(q31,q31_t,int32_t,NPY_INT32);
+MATRIXFROMNUMPY(q15,q15_t,int16_t,NPY_INT16);
+MATRIXFROMNUMPY(q7,q7_t,int8_t,NPY_BYTE);
+
+CREATEMATRIX(f32,float32_t);
+CREATEMATRIX(f64,float64_t);
+CREATEMATRIX(q31,q31_t);
+CREATEMATRIX(q15,q15_t);
+CREATEMATRIX(q7,q7_t);
+
+NUMPYVECTORFROMBUFFER(f32,float32_t,NPY_FLOAT);
+
+NUMPYARRAYFROMMATRIX(f32,NPY_FLOAT);
+NUMPYARRAYFROMMATRIX(f64,NPY_DOUBLE);
+NUMPYARRAYFROMMATRIX(q31,NPY_INT32);
+NUMPYARRAYFROMMATRIX(q15,NPY_INT16);
+NUMPYARRAYFROMMATRIX(q7,NPY_BYTE);
+
+
+
+
+
+
+
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_matrix_instance_f32 *instance;
+} dsp_arm_matrix_instance_f32Object;
+
+
+static void
+arm_matrix_instance_f32_dealloc(dsp_arm_matrix_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pData)
+       {
+          PyMem_Free(self->instance->pData);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_matrix_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_matrix_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_matrix_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_matrix_instance_f32));
+
+        self->instance->pData = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_matrix_instance_f32_init(dsp_arm_matrix_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pData=NULL;
+char *kwlist[] = {
+"numRows","numCols","pData",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhO", kwlist,&self->instance->numRows
+,&self->instance->numCols
+,&pData
+))
+    {
+
+    INITARRAYFIELD(pData,NPY_DOUBLE,double,float32_t);
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_matrix_instance_f32,numRows,"h");
+GETFIELD(arm_matrix_instance_f32,numCols,"h");
+
+
+static PyMethodDef arm_matrix_instance_f32_methods[] = {
+
+    {"numRows", (PyCFunction) Method_arm_matrix_instance_f32_numRows,METH_NOARGS,"numRows"},
+    {"numCols", (PyCFunction) Method_arm_matrix_instance_f32_numCols,METH_NOARGS,"numCols"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_matrix_instance_f32,arm_matrix_instance_f32_new,arm_matrix_instance_f32_dealloc,arm_matrix_instance_f32_init,arm_matrix_instance_f32_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_matrix_instance_f64 *instance;
+} dsp_arm_matrix_instance_f64Object;
+
+
+static void
+arm_matrix_instance_f64_dealloc(dsp_arm_matrix_instance_f64Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pData)
+       {
+          PyMem_Free(self->instance->pData);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_matrix_instance_f64_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_matrix_instance_f64Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_matrix_instance_f64Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_matrix_instance_f64));
+
+        self->instance->pData = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_matrix_instance_f64_init(dsp_arm_matrix_instance_f64Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pData=NULL;
+char *kwlist[] = {
+"numRows","numCols","pData",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhO", kwlist,&self->instance->numRows
+,&self->instance->numCols
+,&pData
+))
+    {
+
+    INITARRAYFIELD(pData,NPY_FLOAT64,float64_t,float64_t);
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_matrix_instance_f64,numRows,"h");
+GETFIELD(arm_matrix_instance_f64,numCols,"h");
+
+
+static PyMethodDef arm_matrix_instance_f64_methods[] = {
+
+    {"numRows", (PyCFunction) Method_arm_matrix_instance_f64_numRows,METH_NOARGS,"numRows"},
+    {"numCols", (PyCFunction) Method_arm_matrix_instance_f64_numCols,METH_NOARGS,"numCols"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_matrix_instance_f64,arm_matrix_instance_f64_new,arm_matrix_instance_f64_dealloc,arm_matrix_instance_f64_init,arm_matrix_instance_f64_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_matrix_instance_q15 *instance;
+} dsp_arm_matrix_instance_q15Object;
+
+
+static void
+arm_matrix_instance_q15_dealloc(dsp_arm_matrix_instance_q15Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pData)
+       {
+          PyMem_Free(self->instance->pData);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_matrix_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_matrix_instance_q15Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_matrix_instance_q15Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_matrix_instance_q15));
+
+        self->instance->pData = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_matrix_instance_q15_init(dsp_arm_matrix_instance_q15Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pData=NULL;
+char *kwlist[] = {
+"numRows","numCols","pData",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhO", kwlist,&self->instance->numRows
+,&self->instance->numCols
+,&pData
+))
+    {
+
+    INITARRAYFIELD(pData,NPY_INT16,int16_t,int16_t);
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_matrix_instance_q15,numRows,"h");
+GETFIELD(arm_matrix_instance_q15,numCols,"h");
+
+
+static PyMethodDef arm_matrix_instance_q15_methods[] = {
+
+    {"numRows", (PyCFunction) Method_arm_matrix_instance_q15_numRows,METH_NOARGS,"numRows"},
+    {"numCols", (PyCFunction) Method_arm_matrix_instance_q15_numCols,METH_NOARGS,"numCols"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_matrix_instance_q15,arm_matrix_instance_q15_new,arm_matrix_instance_q15_dealloc,arm_matrix_instance_q15_init,arm_matrix_instance_q15_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_matrix_instance_q31 *instance;
+} dsp_arm_matrix_instance_q31Object;
+
+
+static void
+arm_matrix_instance_q31_dealloc(dsp_arm_matrix_instance_q31Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       if (self->instance->pData)
+       {
+          PyMem_Free(self->instance->pData);
+       }
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_matrix_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_matrix_instance_q31Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_matrix_instance_q31Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_matrix_instance_q31));
+
+        self->instance->pData = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_matrix_instance_q31_init(dsp_arm_matrix_instance_q31Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pData=NULL;
+char *kwlist[] = {
+"numRows","numCols","pData",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhO", kwlist,&self->instance->numRows
+,&self->instance->numCols
+,&pData
+))
+    {
+
+    INITARRAYFIELD(pData,NPY_INT32,int32_t,int32_t);
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_matrix_instance_q31,numRows,"h");
+GETFIELD(arm_matrix_instance_q31,numCols,"h");
+
+
+static PyMethodDef arm_matrix_instance_q31_methods[] = {
+
+    {"numRows", (PyCFunction) Method_arm_matrix_instance_q31_numRows,METH_NOARGS,"numRows"},
+    {"numCols", (PyCFunction) Method_arm_matrix_instance_q31_numCols,METH_NOARGS,"numCols"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_matrix_instance_q31,arm_matrix_instance_q31_new,arm_matrix_instance_q31_dealloc,arm_matrix_instance_q31_init,arm_matrix_instance_q31_methods);
+
+
+
+
+void typeRegistration(PyObject *module) {
+
+  
+  ADDTYPE(arm_matrix_instance_f32);
+  ADDTYPE(arm_matrix_instance_f64);
+  ADDTYPE(arm_matrix_instance_q15);
+  ADDTYPE(arm_matrix_instance_q31);
+
+  
+}
+
+
+
+
+
+
+static PyObject *
+cmsis_arm_mat_add_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  arm_matrix_instance_f32 *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  arm_matrix_instance_f32 *pSrcB_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    arm_matrix_instance_f32 *pSrcA_converted = f32MatrixFromNumpy(pSrcA);
+    arm_matrix_instance_f32 *pSrcB_converted = f32MatrixFromNumpy(pSrcB);
+    uint32_t row = pSrcA_converted->numRows ;
+    uint32_t column = pSrcB_converted->numCols ;
+    arm_matrix_instance_f32 *pDst_converted = createf32Matrix(row,column);
+
+    arm_status returnValue = arm_mat_add_f32(pSrcA_converted,pSrcB_converted,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromf32Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mat_add_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  arm_matrix_instance_q15 *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  arm_matrix_instance_q15 *pSrcB_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    arm_matrix_instance_q15 *pSrcA_converted = q15MatrixFromNumpy(pSrcA);
+    arm_matrix_instance_q15 *pSrcB_converted = q15MatrixFromNumpy(pSrcB);
+    uint32_t row = pSrcA_converted->numRows ;
+    uint32_t column = pSrcB_converted->numCols ;
+    arm_matrix_instance_q15 *pDst_converted = createq15Matrix(row,column);
+
+    arm_status returnValue = arm_mat_add_q15(pSrcA_converted,pSrcB_converted,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromq15Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mat_add_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  arm_matrix_instance_q31 *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  arm_matrix_instance_q31 *pSrcB_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    arm_matrix_instance_q31 *pSrcA_converted = q31MatrixFromNumpy(pSrcA);
+    arm_matrix_instance_q31 *pSrcB_converted = q31MatrixFromNumpy(pSrcB);
+    uint32_t row = pSrcA_converted->numRows ;
+    uint32_t column = pSrcB_converted->numCols ;
+    arm_matrix_instance_q31 *pDst_converted = createq31Matrix(row,column);
+
+    arm_status returnValue = arm_mat_add_q31(pSrcA_converted,pSrcB_converted,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromq31Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mat_cmplx_trans_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  arm_matrix_instance_f32 *pSrc_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    arm_matrix_instance_f32 *pSrc_converted = f32MatrixFromNumpy(pSrc);
+    pSrc_converted->numCols = pSrc_converted->numCols / 2;
+
+    uint32_t row = pSrc_converted->numCols ;
+    uint32_t column = pSrc_converted->numRows*2 ;
+    arm_matrix_instance_f32 *pDst_converted = createf32Matrix(row,column);
+    /*
+    Dimensions in matrix instance are not correct but they are not used
+    by CMSIS-DSP since the library is not compiled with ARM_MATRIX_CHECK.
+    So only source dimensions are used for the computation.
+
+    The dimensions are correct for createf32Matrix since we need to create
+    a bigger buffer and createf32Matrix only knows real.
+
+    */
+
+    arm_status returnValue = arm_mat_cmplx_trans_f32(pSrc_converted,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromf32Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mat_cmplx_trans_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  arm_matrix_instance_q31 *pSrc_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    arm_matrix_instance_q31 *pSrc_converted = q31MatrixFromNumpy(pSrc);
+    pSrc_converted->numCols = pSrc_converted->numCols / 2;
+
+    uint32_t row = pSrc_converted->numCols ;
+    uint32_t column = pSrc_converted->numRows*2 ;
+    arm_matrix_instance_q31 *pDst_converted = createq31Matrix(row,column);
+    /*
+    Dimensions in matrix instance are not correct but they are not used
+    by CMSIS-DSP since the library is not compiled with ARM_MATRIX_CHECK.
+    So only source dimensions are used for the computation.
+
+    The dimensions are correct for createf32Matrix since we need to create
+    a bigger buffer and createf32Matrix only knows real.
+
+    */
+
+    arm_status returnValue = arm_mat_cmplx_trans_q31(pSrc_converted,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromq31Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mat_cmplx_trans_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  arm_matrix_instance_q15 *pSrc_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    arm_matrix_instance_q15 *pSrc_converted = q15MatrixFromNumpy(pSrc);
+    pSrc_converted->numCols = pSrc_converted->numCols / 2;
+
+    uint32_t row = pSrc_converted->numCols ;
+    uint32_t column = pSrc_converted->numRows*2 ;
+    arm_matrix_instance_q15 *pDst_converted = createq15Matrix(row,column);
+    /*
+    Dimensions in matrix instance are not correct but they are not used
+    by CMSIS-DSP since the library is not compiled with ARM_MATRIX_CHECK.
+    So only source dimensions are used for the computation.
+
+    The dimensions are correct for createf32Matrix since we need to create
+    a bigger buffer and createf32Matrix only knows real.
+
+    */
+
+    arm_status returnValue = arm_mat_cmplx_trans_q15(pSrc_converted,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromq15Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mat_cmplx_mult_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  arm_matrix_instance_f32 *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  arm_matrix_instance_f32 *pSrcB_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    arm_matrix_instance_f32 *pSrcA_converted = f32MatrixFromNumpy(pSrcA);
+    arm_matrix_instance_f32 *pSrcB_converted = f32MatrixFromNumpy(pSrcB);
+    pSrcA_converted->numCols = pSrcA_converted->numCols / 2;
+    pSrcB_converted->numCols = pSrcB_converted->numCols / 2;
+    uint32_t row = pSrcA_converted->numRows ;
+    uint32_t column = pSrcB_converted->numCols * 2;
+    arm_matrix_instance_f32 *pDst_converted = createf32Matrix(row,column);
+
+    arm_status returnValue = arm_mat_cmplx_mult_f32(pSrcA_converted,pSrcB_converted,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromf32Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mat_cmplx_mult_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  arm_matrix_instance_q15 *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  arm_matrix_instance_q15 *pSrcB_converted=NULL; // input
+  PyObject *pScratch=NULL; // input
+  q15_t *pScratch_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OOO",&pSrcA,&pSrcB,&pScratch))
+  {
+
+    arm_matrix_instance_q15 *pSrcA_converted = q15MatrixFromNumpy(pSrcA);
+    arm_matrix_instance_q15 *pSrcB_converted = q15MatrixFromNumpy(pSrcB);
+    GETARGUMENT(pScratch,NPY_INT16,int16_t,int16_t);
+    pSrcA_converted->numCols = pSrcA_converted->numCols / 2;
+    pSrcB_converted->numCols = pSrcB_converted->numCols / 2;
+    uint32_t row = pSrcA_converted->numRows ;
+    uint32_t column = pSrcB_converted->numCols * 2;
+    arm_matrix_instance_q15 *pDst_converted = createq15Matrix(row,column);
+
+    arm_status returnValue = arm_mat_cmplx_mult_q15(pSrcA_converted,pSrcB_converted,pDst_converted,pScratch_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromq15Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    FREEARGUMENT(pScratch_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mat_cmplx_mult_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  arm_matrix_instance_q31 *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  arm_matrix_instance_q31 *pSrcB_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    arm_matrix_instance_q31 *pSrcA_converted = q31MatrixFromNumpy(pSrcA);
+    arm_matrix_instance_q31 *pSrcB_converted = q31MatrixFromNumpy(pSrcB);
+    pSrcA_converted->numCols = pSrcA_converted->numCols / 2;
+    pSrcB_converted->numCols = pSrcB_converted->numCols / 2;
+    uint32_t row = pSrcA_converted->numRows ;
+    uint32_t column = pSrcB_converted->numCols * 2;
+    arm_matrix_instance_q31 *pDst_converted = createq31Matrix(row,column);
+
+    arm_status returnValue = arm_mat_cmplx_mult_q31(pSrcA_converted,pSrcB_converted,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromq31Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mat_trans_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  arm_matrix_instance_f32 *pSrc_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    arm_matrix_instance_f32 *pSrc_converted = f32MatrixFromNumpy(pSrc);
+    uint32_t row = pSrc_converted->numCols ;
+    uint32_t column = pSrc_converted->numRows ;
+    arm_matrix_instance_f32 *pDst_converted = createf32Matrix(row,column);
+
+    arm_status returnValue = arm_mat_trans_f32(pSrc_converted,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromf32Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mat_trans_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  arm_matrix_instance_q7 *pSrc_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    arm_matrix_instance_q7 *pSrc_converted = q7MatrixFromNumpy(pSrc);
+    uint32_t row = pSrc_converted->numCols ;
+    uint32_t column = pSrc_converted->numRows ;
+    arm_matrix_instance_q7 *pDst_converted = createq7Matrix(row,column);
+
+    arm_status returnValue = arm_mat_trans_q7(pSrc_converted,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromq7Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mat_trans_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  arm_matrix_instance_q15 *pSrc_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    arm_matrix_instance_q15 *pSrc_converted = q15MatrixFromNumpy(pSrc);
+    uint32_t row = pSrc_converted->numCols ;
+    uint32_t column = pSrc_converted->numRows ;
+    arm_matrix_instance_q15 *pDst_converted = createq15Matrix(row,column);
+
+    arm_status returnValue = arm_mat_trans_q15(pSrc_converted,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromq15Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mat_trans_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  arm_matrix_instance_q31 *pSrc_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    arm_matrix_instance_q31 *pSrc_converted = q31MatrixFromNumpy(pSrc);
+    uint32_t row = pSrc_converted->numCols ;
+    uint32_t column = pSrc_converted->numRows ;
+    arm_matrix_instance_q31 *pDst_converted = createq31Matrix(row,column);
+
+    arm_status returnValue = arm_mat_trans_q31(pSrc_converted,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromq31Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mat_vec_mult_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  arm_matrix_instance_f32 *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  float32_t *pSrcB_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    arm_matrix_instance_f32 *pSrcA_converted = f32MatrixFromNumpy(pSrcA);
+    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
+    uint32_t row = pSrcA_converted->numRows ;
+    uint32_t column = pSrcA_converted->numCols ;
+    pDst=PyMem_Malloc(sizeof(float32_t)*row);
+
+    arm_mat_vec_mult_f32(pSrcA_converted,pSrcB_converted,pDst);
+    FLOATARRAY1(pDstOBJ,row,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mat_mult_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  arm_matrix_instance_f32 *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  arm_matrix_instance_f32 *pSrcB_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    arm_matrix_instance_f32 *pSrcA_converted = f32MatrixFromNumpy(pSrcA);
+    arm_matrix_instance_f32 *pSrcB_converted = f32MatrixFromNumpy(pSrcB);
+    uint32_t row = pSrcA_converted->numRows ;
+    uint32_t column = pSrcB_converted->numCols ;
+    arm_matrix_instance_f32 *pDst_converted = createf32Matrix(row,column);
+
+    arm_status returnValue = arm_mat_mult_f32(pSrcA_converted,pSrcB_converted,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromf32Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mat_vec_mult_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  arm_matrix_instance_q15 *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  q15_t *pSrcB_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    arm_matrix_instance_q15 *pSrcA_converted = q15MatrixFromNumpy(pSrcA);
+    GETARGUMENT(pSrcB,NPY_INT16,int16_t,q15_t);
+    uint32_t row = pSrcA_converted->numRows ;
+    uint32_t column = pSrcA_converted->numCols ;
+    pDst=PyMem_Malloc(sizeof(q15_t)*row);
+
+    arm_mat_vec_mult_q15(pSrcA_converted,pSrcB_converted,pDst);
+    INT16ARRAY1(pDstOBJ,row,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mat_vec_mult_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  arm_matrix_instance_q7 *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  q7_t *pSrcB_converted=NULL; // input
+  q7_t *pDst=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    arm_matrix_instance_q7 *pSrcA_converted = q7MatrixFromNumpy(pSrcA);
+    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
+    uint32_t row = pSrcA_converted->numRows ;
+    uint32_t column = pSrcA_converted->numCols ;
+    pDst=PyMem_Malloc(sizeof(q7_t)*row);
+
+    arm_mat_vec_mult_q7(pSrcA_converted,pSrcB_converted,pDst);
+    INT8ARRAY1(pDstOBJ,row,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mat_mult_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  arm_matrix_instance_q7 *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  arm_matrix_instance_q7 *pSrcB_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q7_t *pState_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OOO",&pSrcA,&pSrcB,&pState))
+  {
+
+    arm_matrix_instance_q7 *pSrcA_converted = q7MatrixFromNumpy(pSrcA);
+    arm_matrix_instance_q7 *pSrcB_converted = q7MatrixFromNumpy(pSrcB);
+    GETARGUMENT(pState,NPY_BYTE,int8_t,q7_t);
+    uint32_t row = pSrcA_converted->numRows ;
+    uint32_t column = pSrcB_converted->numCols ;
+    arm_matrix_instance_q7 *pDst_converted = createq7Matrix(row,column);
+
+    arm_status returnValue = arm_mat_mult_q7(pSrcA_converted,pSrcB_converted,pDst_converted,pState_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromq7Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    FREEARGUMENT(pState_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mat_mult_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  arm_matrix_instance_q15 *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  arm_matrix_instance_q15 *pSrcB_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q15_t *pState_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OOO",&pSrcA,&pSrcB,&pState))
+  {
+
+    arm_matrix_instance_q15 *pSrcA_converted = q15MatrixFromNumpy(pSrcA);
+    arm_matrix_instance_q15 *pSrcB_converted = q15MatrixFromNumpy(pSrcB);
+    
+    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
+    uint32_t row = pSrcA_converted->numRows ;
+    uint32_t column = pSrcB_converted->numCols ;
+    arm_matrix_instance_q15 *pDst_converted = createq15Matrix(row,column);
+
+    arm_status returnValue = arm_mat_mult_q15(pSrcA_converted,pSrcB_converted,pDst_converted,pState_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromq15Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    FREEARGUMENT(pState_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mat_mult_fast_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  arm_matrix_instance_q15 *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  arm_matrix_instance_q15 *pSrcB_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q15_t *pState_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OOO",&pSrcA,&pSrcB,&pState))
+  {
+
+    arm_matrix_instance_q15 *pSrcA_converted = q15MatrixFromNumpy(pSrcA);
+    arm_matrix_instance_q15 *pSrcB_converted = q15MatrixFromNumpy(pSrcB);
+    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
+    uint32_t row = pSrcA_converted->numRows ;
+    uint32_t column = pSrcB_converted->numCols ;
+    arm_matrix_instance_q15 *pDst_converted = createq15Matrix(row,column);
+
+    arm_status returnValue = arm_mat_mult_fast_q15(pSrcA_converted,pSrcB_converted,pDst_converted,pState_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromq15Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    FREEARGUMENT(pState_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mat_vec_mult_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  arm_matrix_instance_q31 *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  q31_t *pSrcB_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    arm_matrix_instance_q31 *pSrcA_converted = q31MatrixFromNumpy(pSrcA);
+    GETARGUMENT(pSrcB,NPY_INT32,int32_t,q31_t);
+    uint32_t row = pSrcA_converted->numRows ;
+    uint32_t column = pSrcA_converted->numCols ;
+    pDst=PyMem_Malloc(sizeof(q31_t)*row);
+
+    arm_mat_vec_mult_q31(pSrcA_converted,pSrcB_converted,pDst);
+    INT32ARRAY1(pDstOBJ,row,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mat_mult_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  arm_matrix_instance_q31 *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  arm_matrix_instance_q31 *pSrcB_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    arm_matrix_instance_q31 *pSrcA_converted = q31MatrixFromNumpy(pSrcA);
+    arm_matrix_instance_q31 *pSrcB_converted = q31MatrixFromNumpy(pSrcB);
+    uint32_t row = pSrcA_converted->numRows ;
+    uint32_t column = pSrcB_converted->numCols ;
+    arm_matrix_instance_q31 *pDst_converted = createq31Matrix(row,column);
+
+    arm_status returnValue = arm_mat_mult_q31(pSrcA_converted,pSrcB_converted,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromq31Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mat_mult_opt_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  arm_matrix_instance_q31 *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  arm_matrix_instance_q31 *pSrcB_converted=NULL; // input
+  PyObject *pState=NULL; // input
+  q31_t *pState_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OOO",&pSrcA,&pSrcB,&pState))
+  {
+
+    arm_matrix_instance_q31 *pSrcA_converted = q31MatrixFromNumpy(pSrcA);
+    arm_matrix_instance_q31 *pSrcB_converted = q31MatrixFromNumpy(pSrcB);
+    
+    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
+    uint32_t row = pSrcA_converted->numRows ;
+    uint32_t column = pSrcB_converted->numCols ;
+    arm_matrix_instance_q31 *pDst_converted = createq31Matrix(row,column);
+
+    arm_status returnValue = arm_mat_mult_opt_q31(pSrcA_converted,pSrcB_converted,pDst_converted,pState_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromq31Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    FREEARGUMENT(pState_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mat_mult_fast_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  arm_matrix_instance_q31 *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  arm_matrix_instance_q31 *pSrcB_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    arm_matrix_instance_q31 *pSrcA_converted = q31MatrixFromNumpy(pSrcA);
+    arm_matrix_instance_q31 *pSrcB_converted = q31MatrixFromNumpy(pSrcB);
+    uint32_t row = pSrcA_converted->numRows ;
+    uint32_t column = pSrcB_converted->numCols ;
+    arm_matrix_instance_q31 *pDst_converted = createq31Matrix(row,column);
+
+    arm_status returnValue = arm_mat_mult_fast_q31(pSrcA_converted,pSrcB_converted,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromq31Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mat_sub_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  arm_matrix_instance_f32 *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  arm_matrix_instance_f32 *pSrcB_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    arm_matrix_instance_f32 *pSrcA_converted = f32MatrixFromNumpy(pSrcA);
+    arm_matrix_instance_f32 *pSrcB_converted = f32MatrixFromNumpy(pSrcB);
+    uint32_t row = pSrcA_converted->numRows ;
+    uint32_t column = pSrcB_converted->numCols ;
+    arm_matrix_instance_f32 *pDst_converted = createf32Matrix(row,column);
+
+    arm_status returnValue = arm_mat_sub_f32(pSrcA_converted,pSrcB_converted,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromf32Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mat_sub_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  arm_matrix_instance_q15 *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  arm_matrix_instance_q15 *pSrcB_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    arm_matrix_instance_q15 *pSrcA_converted = q15MatrixFromNumpy(pSrcA);
+    arm_matrix_instance_q15 *pSrcB_converted = q15MatrixFromNumpy(pSrcB);
+    uint32_t row = pSrcA_converted->numRows ;
+    uint32_t column = pSrcB_converted->numCols ;
+    arm_matrix_instance_q15 *pDst_converted = createq15Matrix(row,column);
+
+    arm_status returnValue = arm_mat_sub_q15(pSrcA_converted,pSrcB_converted,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromq15Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mat_sub_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  arm_matrix_instance_q31 *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  arm_matrix_instance_q31 *pSrcB_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    arm_matrix_instance_q31 *pSrcA_converted = q31MatrixFromNumpy(pSrcA);
+    arm_matrix_instance_q31 *pSrcB_converted = q31MatrixFromNumpy(pSrcB);
+    uint32_t row = pSrcA_converted->numRows ;
+    uint32_t column = pSrcB_converted->numCols ;
+    arm_matrix_instance_q31 *pDst_converted = createq31Matrix(row,column);
+
+    arm_status returnValue = arm_mat_sub_q31(pSrcA_converted,pSrcB_converted,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromq31Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mat_scale_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  arm_matrix_instance_f32 *pSrc_converted=NULL; // input
+  float32_t scale; // input
+
+  if (PyArg_ParseTuple(args,"Of",&pSrc,&scale))
+  {
+
+    arm_matrix_instance_f32 *pSrc_converted = f32MatrixFromNumpy(pSrc);
+    uint32_t row = pSrc_converted->numRows ;
+    uint32_t column = pSrc_converted->numCols ;
+    arm_matrix_instance_f32 *pDst_converted = createf32Matrix(row,column);
+
+    arm_status returnValue = arm_mat_scale_f32(pSrc_converted,scale,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromf32Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mat_scale_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  arm_matrix_instance_q15 *pSrc_converted=NULL; // input
+  q15_t scaleFract; // input
+  int32_t shift; // input
+
+  if (PyArg_ParseTuple(args,"Ohi",&pSrc,&scaleFract,&shift))
+  {
+
+    arm_matrix_instance_q15 *pSrc_converted = q15MatrixFromNumpy(pSrc);
+    uint32_t row = pSrc_converted->numRows ;
+    uint32_t column = pSrc_converted->numCols ;
+    arm_matrix_instance_q15 *pDst_converted = createq15Matrix(row,column);
+
+    arm_status returnValue = arm_mat_scale_q15(pSrc_converted,scaleFract,shift,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromq15Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mat_scale_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  arm_matrix_instance_q31 *pSrc_converted=NULL; // input
+  q31_t scaleFract; // input
+  int32_t shift; // input
+
+  if (PyArg_ParseTuple(args,"Oii",&pSrc,&scaleFract,&shift))
+  {
+
+    arm_matrix_instance_q31 *pSrc_converted = q31MatrixFromNumpy(pSrc);
+    uint32_t row = pSrc_converted->numRows ;
+    uint32_t column = pSrc_converted->numCols ;
+    arm_matrix_instance_q31 *pDst_converted = createq31Matrix(row,column);
+
+    arm_status returnValue = arm_mat_scale_q31(pSrc_converted,scaleFract,shift,pDst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* pDstOBJ=NumpyArrayFromq31Matrix(pDst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+static PyObject *
+cmsis_arm_mat_inverse_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *src=NULL; // input
+  arm_matrix_instance_f32 *src_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"O",&src))
+  {
+
+    arm_matrix_instance_f32 *src_converted = f32MatrixFromNumpy(src);
+    uint32_t row = src_converted->numCols ;
+    uint32_t column = src_converted->numRows ;
+    arm_matrix_instance_f32 *dst_converted = createf32Matrix(row,column);
+
+    arm_status returnValue = arm_mat_inverse_f32(src_converted,dst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* dstOBJ=NumpyArrayFromf32Matrix(dst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,dstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(src_converted);
+    Py_DECREF(dstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mat_inverse_f64(PyObject *obj, PyObject *args)
+{
+
+  PyObject *src=NULL; // input
+  arm_matrix_instance_f64 *src_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"O",&src))
+  {
+
+    arm_matrix_instance_f64 *src_converted = f64MatrixFromNumpy(src);
+    uint32_t row = src_converted->numCols ;
+    uint32_t column = src_converted->numRows ;
+    arm_matrix_instance_f64 *dst_converted = createf64Matrix(row,column);
+
+    arm_status returnValue = arm_mat_inverse_f64(src_converted,dst_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+    PyObject* dstOBJ=NumpyArrayFromf64Matrix(dst_converted);
+
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,dstOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    FREEARGUMENT(src_converted);
+    Py_DECREF(dstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+
+static PyMethodDef CMSISDSPMethods[] = {
+
+{"arm_mat_add_f32",  cmsis_arm_mat_add_f32, METH_VARARGS,""},
+{"arm_mat_add_q15",  cmsis_arm_mat_add_q15, METH_VARARGS,""},
+{"arm_mat_add_q31",  cmsis_arm_mat_add_q31, METH_VARARGS,""},
+{"arm_mat_cmplx_mult_f32",  cmsis_arm_mat_cmplx_mult_f32, METH_VARARGS,""},
+{"arm_mat_cmplx_mult_q15",  cmsis_arm_mat_cmplx_mult_q15, METH_VARARGS,""},
+{"arm_mat_cmplx_mult_q31",  cmsis_arm_mat_cmplx_mult_q31, METH_VARARGS,""},
+{"arm_mat_trans_f32",  cmsis_arm_mat_trans_f32, METH_VARARGS,""},
+{"arm_mat_trans_q15",  cmsis_arm_mat_trans_q15, METH_VARARGS,""},
+{"arm_mat_trans_q31",  cmsis_arm_mat_trans_q31, METH_VARARGS,""},
+{"arm_mat_trans_q7",  cmsis_arm_mat_trans_q7, METH_VARARGS,""},
+
+
+{"arm_mat_vec_mult_f32",  cmsis_arm_mat_vec_mult_f32, METH_VARARGS,""},
+{"arm_mat_vec_mult_q31",  cmsis_arm_mat_vec_mult_q31, METH_VARARGS,""},
+{"arm_mat_vec_mult_q15",  cmsis_arm_mat_vec_mult_q15, METH_VARARGS,""},
+{"arm_mat_vec_mult_q7",  cmsis_arm_mat_vec_mult_q7, METH_VARARGS,""},
+
+{"arm_mat_mult_f32",  cmsis_arm_mat_mult_f32, METH_VARARGS,""},
+{"arm_mat_mult_q7",  cmsis_arm_mat_mult_q7, METH_VARARGS,""},
+{"arm_mat_mult_q15",  cmsis_arm_mat_mult_q15, METH_VARARGS,""},
+{"arm_mat_mult_fast_q15",  cmsis_arm_mat_mult_fast_q15, METH_VARARGS,""},
+{"arm_mat_mult_q31",  cmsis_arm_mat_mult_q31, METH_VARARGS,""},
+{"arm_mat_mult_opt_q31",  cmsis_arm_mat_mult_opt_q31, METH_VARARGS,""},
+{"arm_mat_mult_fast_q31",  cmsis_arm_mat_mult_fast_q31, METH_VARARGS,""},
+{"arm_mat_sub_f32",  cmsis_arm_mat_sub_f32, METH_VARARGS,""},
+{"arm_mat_sub_q15",  cmsis_arm_mat_sub_q15, METH_VARARGS,""},
+{"arm_mat_sub_q31",  cmsis_arm_mat_sub_q31, METH_VARARGS,""},
+{"arm_mat_scale_f32",  cmsis_arm_mat_scale_f32, METH_VARARGS,""},
+{"arm_mat_scale_q15",  cmsis_arm_mat_scale_q15, METH_VARARGS,""},
+{"arm_mat_scale_q31",  cmsis_arm_mat_scale_q31, METH_VARARGS,""},
+{"arm_mat_inverse_f32",  cmsis_arm_mat_inverse_f32, METH_VARARGS,""},
+{"arm_mat_inverse_f64",  cmsis_arm_mat_inverse_f64, METH_VARARGS,""},
+{"arm_mat_cmplx_trans_f32",  cmsis_arm_mat_cmplx_trans_f32, METH_VARARGS,""},
+{"arm_mat_cmplx_trans_q31",  cmsis_arm_mat_cmplx_trans_q31, METH_VARARGS,""},
+{"arm_mat_cmplx_trans_q15",  cmsis_arm_mat_cmplx_trans_q15, METH_VARARGS,""},
+{"error_out", (PyCFunction)error_out, METH_NOARGS, NULL},
+    {NULL, NULL, 0, NULL}        /* Sentinel */
+};
+
+#ifdef IS_PY3K
+static int cmsisdsp_traverse(PyObject *m, visitproc visit, void *arg) {
+    Py_VISIT(GETSTATE(m)->error);
+    return 0;
+}
+
+static int cmsisdsp_clear(PyObject *m) {
+    Py_CLEAR(GETSTATE(m)->error);
+    return 0;
+}
+
+
+static struct PyModuleDef moduledef = {
+        PyModuleDef_HEAD_INIT,
+        MODNAME,
+        NULL,
+        sizeof(struct module_state),
+        CMSISDSPMethods,
+        NULL,
+        cmsisdsp_traverse,
+        cmsisdsp_clear,
+        NULL
+};
+
+#define INITERROR return NULL
+
+PyMODINIT_FUNC
+CAT(PyInit_,MODINITNAME)(void)
+
+
+#else
+#define INITERROR return
+
+void CAT(init,MODINITNAME)(void)
+#endif
+{
+    import_array();
+
+  #ifdef IS_PY3K
+    PyObject *module = PyModule_Create(&moduledef);
+  #else
+    PyObject *module = Py_InitModule(MODNAME, CMSISDSPMethods);
+  #endif
+
+  if (module == NULL)
+      INITERROR;
+  struct module_state *st = GETSTATE(module);
+  
+  st->error = PyErr_NewException(MODNAME".Error", NULL, NULL);
+  if (st->error == NULL) {
+      Py_DECREF(module);
+      INITERROR;
+  }
+
+
+  typeRegistration(module);
+
+  #ifdef IS_PY3K
+    return module;
+  #endif
+}

PythonWrapper/cmsisdsp_pkg/src/cmsismodule.c → PythonWrapper/cmsisdsp_pkg/src/cmsisdsp_module.h

@@ -25,6 +25,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#ifndef CMSISMODULE_H
+#define CMSISMODULE_H
 #define NPY_NO_DEPRECATED_API NPY_1_15_API_VERSION
 
 #ifdef WIN
@@ -39,11 +41,8 @@
 #define CAT(A,B) CAT1(A,B)
 
 
-#ifdef CMSISDSP
 #include "arm_math.h"
-#define MODNAME "internal"
-#define MODINITNAME internal
-#endif 
+
 
 #include <numpy/arrayobject.h>
 #include <numpy/ndarraytypes.h>
@@ -70,11 +69,11 @@ error_out(PyObject *m) {
     return NULL;
 }
 
-#define MLTYPE(name,thenewfunc,deallocfunc,initfunc,methods)\
-static PyTypeObject ml_##name##Type = {          \
+#define DSPType(name,thenewfunc,deallocfunc,initfunc,methods)\
+static PyTypeObject dsp_##name##Type = {          \
     PyVarObject_HEAD_INIT(NULL, 0)               \
-    .tp_name=MODNAME".##name",                   \
-    .tp_basicsize = sizeof(ml_##name##Object),   \
+    .tp_name=MODNAME"." #name,                   \
+    .tp_basicsize = sizeof(dsp_##name##Object),   \
     .tp_itemsize = 0,                            \
     .tp_dealloc = (destructor)deallocfunc,       \
     .tp_flags =  Py_TPFLAGS_DEFAULT,           \
@@ -93,14 +92,14 @@ for(memCpyIndex = 0; memCpyIndex < (NB) ; memCpyIndex++)\
 
 #define GETFIELD(NAME,FIELD,FORMAT)                                           \
 static PyObject *                                                             \
-Method_##NAME##_##FIELD(ml_##NAME##Object *self, PyObject *ignored)\
+Method_##NAME##_##FIELD(dsp_##NAME##Object *self, PyObject *ignored)\
 {                                                                             \
     return(Py_BuildValue(FORMAT,self->instance->FIELD));                      \
 }                                                                             
     
 #define GETFIELDARRAY(NAME,FIELD,FORMAT)                                           \
 static PyObject *                                                             \
-Method_##NAME##_##FIELD(ml_##NAME##Object *self, PyObject *ignored)\
+Method_##NAME##_##FIELD(dsp_##NAME##Object *self, PyObject *ignored)\
 {                                                                             \
     return(specific_##NAME##_##FIELD(self->instance));                      \
 }  
@@ -164,18 +163,18 @@ Method_##NAME##_##FIELD(ml_##NAME##Object *self, PyObject *ignored)\
 
 #ifdef IS_PY3K
 #define ADDTYPE(name)                                               \
-    if (PyType_Ready(&ml_##name##Type) < 0)                         \
+    if (PyType_Ready(&dsp_##name##Type) < 0)                         \
         return;                                              \
                                                                     \
-    Py_INCREF(&ml_##name##Type);                                    \
-    PyModule_AddObject(module, #name, (PyObject *)&ml_##name##Type);
+    Py_INCREF(&dsp_##name##Type);                                    \
+    PyModule_AddObject(module, #name, (PyObject *)&dsp_##name##Type);
 #else
 #define ADDTYPE(name)                                               \
-    if (PyType_Ready(&ml_##name##Type) < 0)                         \
+    if (PyType_Ready(&dsp_##name##Type) < 0)                         \
         return;                                                     \
                                                                     \
-    Py_INCREF(&ml_##name##Type);                                    \
-    PyModule_AddObject(module, #name, (PyObject *)&ml_##name##Type);
+    Py_INCREF(&dsp_##name##Type);                                    \
+    PyModule_AddObject(module, #name, (PyObject *)&dsp_##name##Type);
 #endif
 
 void capsule_cleanup(PyObject *capsule) {
@@ -282,11 +281,7 @@ arm_matrix_instance_##EXT *EXT##MatrixFromNumpy(PyObject *o)                   \
                                                                              \
 }
 
-MATRIXFROMNUMPY(f32,float32_t,double,NPY_DOUBLE);
-MATRIXFROMNUMPY(f64,float64_t,double,NPY_DOUBLE);
-MATRIXFROMNUMPY(q31,q31_t,int32_t,NPY_INT32);
-MATRIXFROMNUMPY(q15,q15_t,int16_t,NPY_INT16);
-MATRIXFROMNUMPY(q7,q7_t,int8_t,NPY_BYTE);
+
 
 #define CREATEMATRIX(EXT,TYP)                                        \
 arm_matrix_instance_##EXT *create##EXT##Matrix(uint32_t r,uint32_t c)\
@@ -300,11 +295,7 @@ arm_matrix_instance_##EXT *create##EXT##Matrix(uint32_t r,uint32_t c)\
     return(s);                                                       \
 }
 
-CREATEMATRIX(f32,float32_t);
-CREATEMATRIX(f64,float64_t);
-CREATEMATRIX(q31,q31_t);
-CREATEMATRIX(q15,q15_t);
-CREATEMATRIX(q7,q7_t);
+
 
 #define NUMPYVECTORFROMBUFFER(EXT,CTYPE,NUMPYTYPE_FROMC)                                          \
 PyObject *NumpyVectorFrom##EXT##Buffer(CTYPE *ptr,int nb)                                         \
@@ -324,7 +315,6 @@ PyObject *NumpyVectorFrom##EXT##Buffer(CTYPE *ptr,int nb)
     return(pythonResult);                                                                         \
 }
 
-NUMPYVECTORFROMBUFFER(f32,float32_t,NPY_FLOAT);
 
 
 
@@ -336,129 +326,16 @@ PyObject *NumpyArrayFrom##EXT##Matrix(arm_matrix_instance_##EXT *mat)
     dims[1]=mat->numCols;                                                                               \
     const int ND=2;                                                                                     \
     PyArrayObject *OBJ=(PyArrayObject*)PyArray_SimpleNewFromData(ND, dims, NUMPYTYPE_FROMC, mat->pData);\
-    PyObject *capsule = PyCapsule_New(mat->pData, "cmsisdsp capsule",capsule_cleanup);                             \
+    PyObject *capsule = PyCapsule_New(mat->pData, "cmsisdsp capsule",capsule_cleanup);                  \
     PyArray_SetBaseObject(OBJ, capsule);                                                                \
-    return(OBJ);                                                                                        \
-}
-
-NUMPYARRAYFROMMATRIX(f32,NPY_FLOAT);
-NUMPYARRAYFROMMATRIX(f64,NPY_DOUBLE);
-NUMPYARRAYFROMMATRIX(q31,NPY_INT32);
-NUMPYARRAYFROMMATRIX(q15,NPY_INT16);
-NUMPYARRAYFROMMATRIX(q7,NPY_BYTE);
-
-//#include "specific.h"
-#include "cmsismodule.h"
-
-#if 0
-static PyObject *cmsisml_test(PyObject *obj, PyObject *args)
-{
-    ml_arm_svm_linear_instance_f32Object *self=NULL;
-    PyObject *svm, *vector=NULL;
-
-    if (!PyArg_ParseTuple(args, "OO", &svm,&vector))
-        return NULL;
-
-    self=(ml_arm_svm_linear_instance_f32Object*)svm;
-    if (self)
-    {
-        if (self->instance)
-        {
-            int result;
-            float32_t *input=NULL;
-            GETCARRAY(vector,input,NPY_DOUBLE,double,float32_t);
-            
-            arm_svm_linear_predict_f32(self->instance,input,&result);
-            /*
-            printf("Dual\n");
-            for(int i = 0 ; i < self->instance->nbOfSupportVectors ; i++)
-            {
-                printf("%f\n",self->instance->dualCoefficients[i]);
-            }
-            printf("Vectors\n");
-            int k=0;
-            for(int i = 0 ; i < self->instance->nbOfSupportVectors ; i++)
-            {
-                printf("Vector %d\n",i);
-                for(int j = 0 ; j < self->instance->vectorDimension ; j++)
-                {
-                    printf("%f\n",self->instance->supportVectors[k]);
-                    k++;
-                }
-            }
-            printf("Classes\n");
-            for(int i = 0 ; i < 2 ; i++)
-            {
-                printf("%d\n",self->instance->classes[i]);
-            }
-            printf("Intercept %f\n",self->instance->intercept);
-*/
-            PyMem_Free(input);
-            return(Py_BuildValue("i",result));
-        }
-    }
-    return(Py_BuildValue("i",-1));
-}
-#endif
-
-#ifdef IS_PY3K
-static int cmsisml_traverse(PyObject *m, visitproc visit, void *arg) {
-    Py_VISIT(GETSTATE(m)->error);
-    return 0;
-}
-
-static int cmsisml_clear(PyObject *m) {
-    Py_CLEAR(GETSTATE(m)->error);
-    return 0;
+    PyObject *pythonResult = Py_BuildValue("O",OBJ);                                                    \
+    Py_DECREF(OBJ);                                                                                     \
+    return(pythonResult);                                                                               \
 }
 
 
-static struct PyModuleDef moduledef = {
-        PyModuleDef_HEAD_INIT,
-        MODNAME,
-        NULL,
-        sizeof(struct module_state),
-        CMSISMLMethods,
-        NULL,
-        cmsisml_traverse,
-        cmsisml_clear,
-        NULL
-};
-
-#define INITERROR return NULL
 
-PyMODINIT_FUNC
-CAT(PyInit_,MODINITNAME)(void)
 
 
-#else
-#define INITERROR return
 
-void CAT(init,MODINITNAME)(void)
-#endif
-{
-    import_array();
-
-  #ifdef IS_PY3K
-    PyObject *module = PyModule_Create(&moduledef);
-  #else
-    PyObject *module = Py_InitModule(MODNAME, CMSISMLMethods);
-  #endif
-
-  if (module == NULL)
-      INITERROR;
-  struct module_state *st = GETSTATE(module);
-  
-  st->error = PyErr_NewException(MODNAME".Error", NULL, NULL);
-  if (st->error == NULL) {
-      Py_DECREF(module);
-      INITERROR;
-  }
-
-
-  typeRegistration(module);
-
-  #ifdef IS_PY3K
-    return module;
-  #endif
-}
+#endif /* #ifndef CMSISMODULE_H */

PythonWrapper/cmsisdsp_pkg/src/cmsisdsp_quaternion.c

@@ -0,0 +1,392 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Python Wrapper
+ * Title:        cmsismodule.h
+ * Description:  C code for the CMSIS-DSP Python wrapper
+ *
+ * $Date:        27 April 2021
+ * $Revision:    V1.0
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define MODNAME "cmsisdsp_quaternion"
+#define MODINITNAME cmsisdsp_quaternion
+
+#include "cmsisdsp_module.h"
+
+
+NUMPYVECTORFROMBUFFER(f32,float32_t,NPY_FLOAT);
+
+
+void typeRegistration(PyObject *module) {
+
+ 
+}
+
+
+
+
+
+
+
+static PyObject *
+cmsis_arm_quaternion_product_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  float32_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  float32_t *pSrcB_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t nbQuaternions; // input
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
+    nbQuaternions = arraySizepSrcA / 4 ;
+
+    pDst=PyMem_Malloc(4*sizeof(float32_t)*nbQuaternions);
+
+
+    arm_quaternion_product_f32(pSrcA_converted,pSrcB_converted,pDst,nbQuaternions);
+ FLOATARRAY1(pDstOBJ,4*nbQuaternions,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_quaternion_product_single_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrcA=NULL; // input
+  float32_t *pSrcA_converted=NULL; // input
+  PyObject *pSrcB=NULL; // input
+  float32_t *pSrcB_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
+  {
+
+    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
+
+    pDst=PyMem_Malloc(4*sizeof(float32_t));
+
+
+    arm_quaternion_product_single_f32(pSrcA_converted,pSrcB_converted,pDst);
+ FLOATARRAY1(pDstOBJ,4,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrcA_converted);
+    FREEARGUMENT(pSrcB_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+static PyObject *
+cmsis_arm_quaternion2rotation_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t nbQuaternions; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    nbQuaternions = arraySizepSrc / 4 ;
+
+    pDst=PyMem_Malloc(9*sizeof(float32_t)*nbQuaternions);
+
+
+    arm_quaternion2rotation_f32(pSrc_converted,pDst,nbQuaternions);
+ FLOATARRAY1(pDstOBJ,9*nbQuaternions,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_rotation2quaternion_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t nbQuaternions; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    nbQuaternions = arraySizepSrc / 9 ;
+
+    pDst=PyMem_Malloc(4*sizeof(float32_t)*nbQuaternions);
+
+
+    arm_rotation2quaternion_f32(pSrc_converted,pDst,nbQuaternions);
+ FLOATARRAY1(pDstOBJ,4*nbQuaternions,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_quaternion_normalize_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t nbQuaternions; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    nbQuaternions = arraySizepSrc / 4 ;
+
+    pDst=PyMem_Malloc(4*sizeof(float32_t)*nbQuaternions);
+
+
+    arm_quaternion_normalize_f32(pSrc_converted,pDst,nbQuaternions);
+ FLOATARRAY1(pDstOBJ,4*nbQuaternions,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_quaternion_norm_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t nbQuaternions; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    nbQuaternions = arraySizepSrc / 4 ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*nbQuaternions);
+
+
+    arm_quaternion_norm_f32(pSrc_converted,pDst,nbQuaternions);
+ FLOATARRAY1(pDstOBJ,nbQuaternions,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_quaternion_conjugate_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t nbQuaternions; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    nbQuaternions = arraySizepSrc / 4 ;
+
+    pDst=PyMem_Malloc(4*sizeof(float32_t)*nbQuaternions);
+
+
+    arm_quaternion_conjugate_f32(pSrc_converted,pDst,nbQuaternions);
+ FLOATARRAY1(pDstOBJ,4*nbQuaternions,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_quaternion_inverse_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t nbQuaternions; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    nbQuaternions = arraySizepSrc / 4 ;
+
+    pDst=PyMem_Malloc(4*sizeof(float32_t)*nbQuaternions);
+
+
+    arm_quaternion_inverse_f32(pSrc_converted,pDst,nbQuaternions);
+ FLOATARRAY1(pDstOBJ,4*nbQuaternions,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+
+
+
+static PyMethodDef CMSISDSPMethods[] = {
+
+
+
+
+
+
+{"arm_quaternion_normalize_f32" ,  cmsis_arm_quaternion_normalize_f32, METH_VARARGS,""},
+{"arm_quaternion_conjugate_f32" ,  cmsis_arm_quaternion_conjugate_f32, METH_VARARGS,""},
+{"arm_quaternion_inverse_f32" ,  cmsis_arm_quaternion_inverse_f32, METH_VARARGS,""},
+{"arm_quaternion_norm_f32" ,  cmsis_arm_quaternion_norm_f32, METH_VARARGS,""},
+{"arm_quaternion2rotation_f32" ,  cmsis_arm_quaternion2rotation_f32, METH_VARARGS,""},
+{"arm_rotation2quaternion_f32" ,  cmsis_arm_rotation2quaternion_f32, METH_VARARGS,""},
+{"arm_quaternion_product_f32" ,  cmsis_arm_quaternion_product_f32, METH_VARARGS,""},
+{"arm_quaternion_product_single_f32" ,  cmsis_arm_quaternion_product_single_f32, METH_VARARGS,""},
+
+
+   
+    {"error_out", (PyCFunction)error_out, METH_NOARGS, NULL},
+    {NULL, NULL, 0, NULL}        /* Sentinel */
+};
+
+#ifdef IS_PY3K
+static int cmsisdsp_traverse(PyObject *m, visitproc visit, void *arg) {
+    Py_VISIT(GETSTATE(m)->error);
+    return 0;
+}
+
+static int cmsisdsp_clear(PyObject *m) {
+    Py_CLEAR(GETSTATE(m)->error);
+    return 0;
+}
+
+
+static struct PyModuleDef moduledef = {
+        PyModuleDef_HEAD_INIT,
+        MODNAME,
+        NULL,
+        sizeof(struct module_state),
+        CMSISDSPMethods,
+        NULL,
+        cmsisdsp_traverse,
+        cmsisdsp_clear,
+        NULL
+};
+
+#define INITERROR return NULL
+
+PyMODINIT_FUNC
+CAT(PyInit_,MODINITNAME)(void)
+
+
+#else
+#define INITERROR return
+
+void CAT(init,MODINITNAME)(void)
+#endif
+{
+    import_array();
+
+  #ifdef IS_PY3K
+    PyObject *module = PyModule_Create(&moduledef);
+  #else
+    PyObject *module = Py_InitModule(MODNAME, CMSISDSPMethods);
+  #endif
+
+  if (module == NULL)
+      INITERROR;
+  struct module_state *st = GETSTATE(module);
+  
+  st->error = PyErr_NewException(MODNAME".Error", NULL, NULL);
+  if (st->error == NULL) {
+      Py_DECREF(module);
+      INITERROR;
+  }
+
+
+  typeRegistration(module);
+
+  #ifdef IS_PY3K
+    return module;
+  #endif
+}

PythonWrapper/cmsisdsp_pkg/src/cmsisdsp_statistics.c

@@ -0,0 +1,1663 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Python Wrapper
+ * Title:        cmsismodule.h
+ * Description:  C code for the CMSIS-DSP Python wrapper
+ *
+ * $Date:        27 April 2021
+ * $Revision:    V1.0
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define MODNAME "cmsisdsp_statistics"
+#define MODINITNAME cmsisdsp_statistics
+
+#include "cmsisdsp_module.h"
+
+
+NUMPYVECTORFROMBUFFER(f32,float32_t,NPY_FLOAT);
+
+
+
+void typeRegistration(PyObject *module) {
+
+ 
+}
+
+
+
+
+static PyObject *
+cmsis_arm_power_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q63_t *pResult=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q63_t)*1);
+
+
+    arm_power_q31(pSrc_converted,blockSize,pResult);
+    PyObject* pResultOBJ=Py_BuildValue("L",*pResult);
+
+    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_power_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  float32_t *pResult=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(float32_t)*1);
+
+
+    arm_power_f32(pSrc_converted,blockSize,pResult);
+    PyObject* pResultOBJ=Py_BuildValue("f",*pResult);
+
+    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_power_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q63_t *pResult=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q63_t)*1);
+
+
+    arm_power_q15(pSrc_converted,blockSize,pResult);
+    PyObject* pResultOBJ=Py_BuildValue("L",*pResult);
+
+    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_power_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q31_t *pResult=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q31_t)*1);
+
+
+    arm_power_q7(pSrc_converted,blockSize,pResult);
+    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
+
+    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mean_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q7_t *pResult=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q7_t)*1);
+
+
+    arm_mean_q7(pSrc_converted,blockSize,pResult);
+    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
+
+    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mean_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q15_t *pResult=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q15_t)*1);
+
+
+    arm_mean_q15(pSrc_converted,blockSize,pResult);
+    PyObject* pResultOBJ=Py_BuildValue("h",*pResult);
+
+    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mean_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q31_t *pResult=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q31_t)*1);
+
+
+    arm_mean_q31(pSrc_converted,blockSize,pResult);
+    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
+
+    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_mean_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  float32_t *pResult=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(float32_t)*1);
+
+
+    arm_mean_f32(pSrc_converted,blockSize,pResult);
+    PyObject* pResultOBJ=Py_BuildValue("f",*pResult);
+
+    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_var_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  float32_t *pResult=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(float32_t)*1);
+
+
+    arm_var_f32(pSrc_converted,blockSize,pResult);
+    PyObject* pResultOBJ=Py_BuildValue("f",*pResult);
+
+    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_var_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q31_t *pResult=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q31_t)*1);
+
+
+    arm_var_q31(pSrc_converted,blockSize,pResult);
+    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
+
+    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_var_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q15_t *pResult=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q15_t)*1);
+
+
+    arm_var_q15(pSrc_converted,blockSize,pResult);
+    PyObject* pResultOBJ=Py_BuildValue("h",*pResult);
+
+    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_rms_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  float32_t *pResult=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(float32_t)*1);
+
+
+    arm_rms_f32(pSrc_converted,blockSize,pResult);
+    PyObject* pResultOBJ=Py_BuildValue("f",*pResult);
+
+    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_rms_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q31_t *pResult=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q31_t)*1);
+
+
+    arm_rms_q31(pSrc_converted,blockSize,pResult);
+    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
+
+    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_rms_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q15_t *pResult=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q15_t)*1);
+
+
+    arm_rms_q15(pSrc_converted,blockSize,pResult);
+    PyObject* pResultOBJ=Py_BuildValue("h",*pResult);
+
+    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_std_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  float32_t *pResult=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(float32_t)*1);
+
+
+    arm_std_f32(pSrc_converted,blockSize,pResult);
+    PyObject* pResultOBJ=Py_BuildValue("f",*pResult);
+
+    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_std_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q31_t *pResult=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q31_t)*1);
+
+
+    arm_std_q31(pSrc_converted,blockSize,pResult);
+    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
+
+    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_std_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q15_t *pResult=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q15_t)*1);
+
+
+    arm_std_q15(pSrc_converted,blockSize,pResult);
+    PyObject* pResultOBJ=Py_BuildValue("h",*pResult);
+
+    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+
+static PyObject *
+cmsis_arm_min_q7(PyObject *obj, PyObject *args)
+{
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q7_t *pResult=NULL; // output
+  uint32_t *pIndex=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q7_t)*1);
+
+
+    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
+
+
+    arm_min_q7(pSrc_converted,blockSize,pResult,pIndex);
+    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
+    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
+
+    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    Py_DECREF(pIndexOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_min_no_idx_q7(PyObject *obj, PyObject *args)
+{
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q7_t pResult;
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+
+
+    arm_min_no_idx_q7(pSrc_converted,blockSize,&pResult);
+    PyObject* pResultOBJ=Py_BuildValue("i",pResult);
+
+
+    FREEARGUMENT(pSrc_converted);
+    return(pResultOBJ);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_absmin_q7(PyObject *obj, PyObject *args)
+{
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q7_t *pResult=NULL; // output
+  uint32_t *pIndex=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q7_t)*1);
+
+
+    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
+
+
+    arm_absmin_q7(pSrc_converted,blockSize,pResult,pIndex);
+    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
+    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
+
+    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    Py_DECREF(pIndexOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_absmin_no_idx_q7(PyObject *obj, PyObject *args)
+{
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q7_t pResult; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+
+
+
+
+    arm_absmin_no_idx_q7(pSrc_converted,blockSize,&pResult);
+    PyObject* pResultOBJ=Py_BuildValue("i",pResult);
+
+
+    FREEARGUMENT(pSrc_converted);
+    return(pResultOBJ);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_min_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q15_t *pResult=NULL; // output
+  uint32_t *pIndex=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q15_t)*1);
+
+
+    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
+
+
+    arm_min_q15(pSrc_converted,blockSize,pResult,pIndex);
+    PyObject* pResultOBJ=Py_BuildValue("h",*pResult);
+    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
+
+    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    Py_DECREF(pIndexOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_min_no_idx_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q15_t pResult; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+
+
+
+
+    arm_min_no_idx_q15(pSrc_converted,blockSize,&pResult);
+    PyObject* pResultOBJ=Py_BuildValue("h",pResult);
+
+
+    FREEARGUMENT(pSrc_converted);
+    return(pResultOBJ);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_absmin_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q15_t *pResult=NULL; // output
+  uint32_t *pIndex=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q15_t)*1);
+
+
+    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
+
+
+    arm_absmin_q15(pSrc_converted,blockSize,pResult,pIndex);
+    PyObject* pResultOBJ=Py_BuildValue("h",*pResult);
+    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
+
+    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    Py_DECREF(pIndexOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_absmin_no_idx_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q15_t pResult; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+
+
+
+
+    arm_absmin_no_idx_q15(pSrc_converted,blockSize,&pResult);
+    PyObject* pResultOBJ=Py_BuildValue("h",pResult);
+
+
+    FREEARGUMENT(pSrc_converted);
+    return(pResultOBJ);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_min_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q31_t *pResult=NULL; // output
+  uint32_t *pIndex=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q31_t)*1);
+
+
+    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
+
+
+    arm_min_q31(pSrc_converted,blockSize,pResult,pIndex);
+    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
+    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
+
+    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    Py_DECREF(pIndexOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_min_no_idx_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q31_t pResult; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+
+
+
+
+    arm_min_no_idx_q31(pSrc_converted,blockSize,&pResult);
+    PyObject* pResultOBJ=Py_BuildValue("i",pResult);
+
+
+    FREEARGUMENT(pSrc_converted);
+    return(pResultOBJ);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_absmin_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q31_t *pResult=NULL; // output
+  uint32_t *pIndex=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q31_t)*1);
+
+
+    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
+
+
+    arm_absmin_q31(pSrc_converted,blockSize,pResult,pIndex);
+    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
+    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
+
+    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    Py_DECREF(pIndexOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_absmin_no_idx_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q31_t pResult; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+
+
+
+    arm_absmin_no_idx_q31(pSrc_converted,blockSize,&pResult);
+    PyObject* pResultOBJ=Py_BuildValue("i",pResult);
+
+
+    FREEARGUMENT(pSrc_converted);
+    return(pResultOBJ);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_min_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  float32_t *pResult=NULL; // output
+  uint32_t *pIndex=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(float32_t)*1);
+
+
+    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
+
+
+    arm_min_f32(pSrc_converted,blockSize,pResult,pIndex);
+    PyObject* pResultOBJ=Py_BuildValue("f",*pResult);
+    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
+
+    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    Py_DECREF(pIndexOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_absmin_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  float32_t *pResult=NULL; // output
+  uint32_t *pIndex=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(float32_t)*1);
+
+
+    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
+
+
+    arm_absmin_f32(pSrc_converted,blockSize,pResult,pIndex);
+    PyObject* pResultOBJ=Py_BuildValue("f",*pResult);
+    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
+
+    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    Py_DECREF(pIndexOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_max_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q7_t *pResult=NULL; // output
+  uint32_t *pIndex=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q7_t)*1);
+
+
+    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
+
+
+    arm_max_q7(pSrc_converted,blockSize,pResult,pIndex);
+    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
+    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
+
+    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    Py_DECREF(pIndexOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_max_no_idx_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q7_t pResult; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+
+
+
+
+    arm_max_no_idx_q7(pSrc_converted,blockSize,&pResult);
+    PyObject* pResultOBJ=Py_BuildValue("i",pResult);
+
+
+    FREEARGUMENT(pSrc_converted);
+    return(pResultOBJ);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_absmax_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q7_t *pResult=NULL; // output
+  uint32_t *pIndex=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q7_t)*1);
+
+
+    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
+
+
+    arm_absmax_q7(pSrc_converted,blockSize,pResult,pIndex);
+    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
+    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
+
+    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    Py_DECREF(pIndexOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_absmax_no_idx_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q7_t pResult; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+
+
+
+
+    arm_absmax_no_idx_q7(pSrc_converted,blockSize,&pResult);
+    PyObject* pResultOBJ=Py_BuildValue("i",pResult);
+
+
+    FREEARGUMENT(pSrc_converted);
+    return(pResultOBJ);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_max_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q15_t *pResult=NULL; // output
+  uint32_t *pIndex=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q15_t)*1);
+
+
+    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
+
+
+    arm_max_q15(pSrc_converted,blockSize,pResult,pIndex);
+    PyObject* pResultOBJ=Py_BuildValue("h",*pResult);
+    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
+
+    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    Py_DECREF(pIndexOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_max_no_idx_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q15_t pResult; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+
+
+
+
+    arm_max_no_idx_q15(pSrc_converted,blockSize,&pResult);
+    PyObject* pResultOBJ=Py_BuildValue("h",pResult);
+
+
+    FREEARGUMENT(pSrc_converted);
+    return(pResultOBJ);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_absmax_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q15_t *pResult=NULL; // output
+  uint32_t *pIndex=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q15_t)*1);
+
+
+    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
+
+
+    arm_absmax_q15(pSrc_converted,blockSize,pResult,pIndex);
+    PyObject* pResultOBJ=Py_BuildValue("h",*pResult);
+    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
+
+    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    Py_DECREF(pIndexOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_absmax_no_idx_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q15_t pResult; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+
+
+
+    arm_absmax_no_idx_q15(pSrc_converted,blockSize,&pResult);
+    PyObject* pResultOBJ=Py_BuildValue("h",pResult);
+
+
+    FREEARGUMENT(pSrc_converted);
+    return(pResultOBJ);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_max_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q31_t *pResult=NULL; // output
+  uint32_t *pIndex=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q31_t)*1);
+
+
+    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
+
+
+    arm_max_q31(pSrc_converted,blockSize,pResult,pIndex);
+    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
+    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
+
+    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    Py_DECREF(pIndexOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_max_no_idx_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q31_t pResult; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+
+
+
+
+    arm_max_no_idx_q31(pSrc_converted,blockSize,&pResult);
+    PyObject* pResultOBJ=Py_BuildValue("i",pResult);
+
+
+    FREEARGUMENT(pSrc_converted);
+    return(pResultOBJ);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_absmax_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q31_t *pResult=NULL; // output
+  uint32_t *pIndex=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(q31_t)*1);
+
+
+    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
+
+
+    arm_absmax_q31(pSrc_converted,blockSize,pResult,pIndex);
+    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
+    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
+
+    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    Py_DECREF(pIndexOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_absmax_no_idx_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  q31_t pResult; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+
+
+
+    arm_absmax_no_idx_q31(pSrc_converted,blockSize,&pResult);
+    PyObject* pResultOBJ=Py_BuildValue("i",pResult);
+
+
+    FREEARGUMENT(pSrc_converted);
+    return(pResultOBJ);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_max_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  float32_t *pResult=NULL; // output
+  uint32_t *pIndex=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(float32_t)*1);
+
+
+    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
+
+
+    arm_max_f32(pSrc_converted,blockSize,pResult,pIndex);
+    PyObject* pResultOBJ=Py_BuildValue("f",*pResult);
+    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
+
+    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    Py_DECREF(pIndexOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_absmax_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  uint32_t blockSize; // input
+  float32_t *pResult=NULL; // output
+  uint32_t *pIndex=NULL; // output
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pResult=PyMem_Malloc(sizeof(float32_t)*1);
+
+
+    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
+
+
+    arm_absmax_f32(pSrc_converted,blockSize,pResult,pIndex);
+    PyObject* pResultOBJ=Py_BuildValue("f",*pResult);
+    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
+
+    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pResultOBJ);
+    Py_DECREF(pIndexOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+
+
+
+
+static PyMethodDef CMSISDSPMethods[] = {
+
+
+{"arm_power_q31",  cmsis_arm_power_q31, METH_VARARGS,""},
+{"arm_power_f32",  cmsis_arm_power_f32, METH_VARARGS,""},
+{"arm_power_q15",  cmsis_arm_power_q15, METH_VARARGS,""},
+{"arm_power_q7",  cmsis_arm_power_q7, METH_VARARGS,""},
+{"arm_mean_q7",  cmsis_arm_mean_q7, METH_VARARGS,""},
+{"arm_mean_q15",  cmsis_arm_mean_q15, METH_VARARGS,""},
+{"arm_mean_q31",  cmsis_arm_mean_q31, METH_VARARGS,""},
+{"arm_mean_f32",  cmsis_arm_mean_f32, METH_VARARGS,""},
+{"arm_var_f32",  cmsis_arm_var_f32, METH_VARARGS,""},
+{"arm_var_q31",  cmsis_arm_var_q31, METH_VARARGS,""},
+{"arm_var_q15",  cmsis_arm_var_q15, METH_VARARGS,""},
+{"arm_rms_f32",  cmsis_arm_rms_f32, METH_VARARGS,""},
+{"arm_rms_q31",  cmsis_arm_rms_q31, METH_VARARGS,""},
+{"arm_rms_q15",  cmsis_arm_rms_q15, METH_VARARGS,""},
+{"arm_std_f32",  cmsis_arm_std_f32, METH_VARARGS,""},
+{"arm_std_q31",  cmsis_arm_std_q31, METH_VARARGS,""},
+{"arm_std_q15",  cmsis_arm_std_q15, METH_VARARGS,""},
+
+{"arm_min_q7",  cmsis_arm_min_q7, METH_VARARGS,""},
+{"arm_min_no_idx_q7",  cmsis_arm_min_no_idx_q7, METH_VARARGS,""},
+{"arm_min_no_idx_q15",  cmsis_arm_min_no_idx_q15, METH_VARARGS,""},
+{"arm_min_no_idx_q31",  cmsis_arm_min_no_idx_q31, METH_VARARGS,""},
+{"arm_min_q15",  cmsis_arm_min_q15, METH_VARARGS,""},
+{"arm_min_q31",  cmsis_arm_min_q31, METH_VARARGS,""},
+{"arm_min_f32",  cmsis_arm_min_f32, METH_VARARGS,""},
+{"arm_absmin_q7",   cmsis_arm_absmin_q7, METH_VARARGS,""},
+{"arm_absmin_q15",  cmsis_arm_absmin_q15, METH_VARARGS,""},
+{"arm_absmin_q31",  cmsis_arm_absmin_q31, METH_VARARGS,""},
+{"arm_absmin_no_idx_q7",   cmsis_arm_absmin_no_idx_q7, METH_VARARGS,""},
+{"arm_absmin_no_idx_q15",  cmsis_arm_absmin_no_idx_q15, METH_VARARGS,""},
+{"arm_absmin_no_idx_q31",  cmsis_arm_absmin_no_idx_q31, METH_VARARGS,""},
+{"arm_absmin_f32",  cmsis_arm_absmin_f32, METH_VARARGS,""},
+{"arm_max_q7",  cmsis_arm_max_q7, METH_VARARGS,""},
+{"arm_max_q15",  cmsis_arm_max_q15, METH_VARARGS,""},
+{"arm_max_q31",  cmsis_arm_max_q31, METH_VARARGS,""},
+{"arm_absmax_q7",  cmsis_arm_absmax_q7, METH_VARARGS,""},
+{"arm_absmax_q15", cmsis_arm_absmax_q15, METH_VARARGS,""},
+{"arm_absmax_q31", cmsis_arm_absmax_q31, METH_VARARGS,""},
+{"arm_max_f32",  cmsis_arm_max_f32, METH_VARARGS,""},
+{"arm_absmax_f32",  cmsis_arm_absmax_f32, METH_VARARGS,""},
+{"arm_max_no_idx_q7",  cmsis_arm_max_no_idx_q7, METH_VARARGS,""},
+{"arm_max_no_idx_q15",  cmsis_arm_max_no_idx_q15, METH_VARARGS,""},
+{"arm_max_no_idx_q31",  cmsis_arm_max_no_idx_q31, METH_VARARGS,""},
+{"arm_absmax_no_idx_q7",  cmsis_arm_absmax_no_idx_q7, METH_VARARGS,""},
+{"arm_absmax_no_idx_q15", cmsis_arm_absmax_no_idx_q15, METH_VARARGS,""},
+{"arm_absmax_no_idx_q31", cmsis_arm_absmax_no_idx_q31, METH_VARARGS,""},
+
+    {"error_out", (PyCFunction)error_out, METH_NOARGS, NULL},
+    {NULL, NULL, 0, NULL}        /* Sentinel */
+};
+
+#ifdef IS_PY3K
+static int cmsisdsp_traverse(PyObject *m, visitproc visit, void *arg) {
+    Py_VISIT(GETSTATE(m)->error);
+    return 0;
+}
+
+static int cmsisdsp_clear(PyObject *m) {
+    Py_CLEAR(GETSTATE(m)->error);
+    return 0;
+}
+
+
+static struct PyModuleDef moduledef = {
+        PyModuleDef_HEAD_INIT,
+        MODNAME,
+        NULL,
+        sizeof(struct module_state),
+        CMSISDSPMethods,
+        NULL,
+        cmsisdsp_traverse,
+        cmsisdsp_clear,
+        NULL
+};
+
+#define INITERROR return NULL
+
+PyMODINIT_FUNC
+CAT(PyInit_,MODINITNAME)(void)
+
+
+#else
+#define INITERROR return
+
+void CAT(init,MODINITNAME)(void)
+#endif
+{
+    import_array();
+
+  #ifdef IS_PY3K
+    PyObject *module = PyModule_Create(&moduledef);
+  #else
+    PyObject *module = Py_InitModule(MODNAME, CMSISDSPMethods);
+  #endif
+
+  if (module == NULL)
+      INITERROR;
+  struct module_state *st = GETSTATE(module);
+  
+  st->error = PyErr_NewException(MODNAME".Error", NULL, NULL);
+  if (st->error == NULL) {
+      Py_DECREF(module);
+      INITERROR;
+  }
+
+
+  typeRegistration(module);
+
+  #ifdef IS_PY3K
+    return module;
+  #endif
+}

PythonWrapper/cmsisdsp_pkg/src/cmsisdsp_support.c

@@ -0,0 +1,781 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Python Wrapper
+ * Title:        cmsismodule.h
+ * Description:  C code for the CMSIS-DSP Python wrapper
+ *
+ * $Date:        27 April 2021
+ * $Revision:    V1.0
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define MODNAME "cmsisdsp_support"
+#define MODINITNAME cmsisdsp_support
+
+#include "cmsisdsp_module.h"
+
+
+
+NUMPYVECTORFROMBUFFER(f32,float32_t,NPY_FLOAT);
+
+
+void typeRegistration(PyObject *module) {
+
+ 
+}
+
+
+
+
+static PyObject *
+cmsis_arm_fill_f32(PyObject *obj, PyObject *args)
+{
+
+  float32_t value; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"fi",&value,&blockSize))
+  {
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_fill_f32(value,pDst,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_fill_q31(PyObject *obj, PyObject *args)
+{
+
+  q31_t value; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"ii",&value,&blockSize))
+  {
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_fill_q31(value,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_fill_q15(PyObject *obj, PyObject *args)
+{
+
+  q15_t value; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"hi",&value,&blockSize))
+  {
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_fill_q15(value,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_fill_q7(PyObject *obj, PyObject *args)
+{
+
+  q31_t value; // input
+  q7_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"ii",&value,&blockSize))
+  {
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
+
+
+    arm_fill_q7((q7_t)value,pDst,blockSize);
+ INT8ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+static PyObject *
+cmsis_arm_copy_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_copy_f32(pSrc_converted,pDst,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_copy_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  q7_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
+
+
+    arm_copy_q7(pSrc_converted,pDst,blockSize);
+ INT8ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_copy_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_copy_q15(pSrc_converted,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_copy_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_copy_q31(pSrc_converted,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+
+
+
+
+
+
+static PyObject *
+cmsis_arm_q7_to_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_q7_to_q31(pSrc_converted,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+
+static PyObject *
+cmsis_arm_q7_to_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_q7_to_q15(pSrc_converted,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+
+static PyObject *
+cmsis_arm_q7_to_float(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q7_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_q7_to_float(pSrc_converted,pDst,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+
+
+
+static PyObject *
+cmsis_arm_q31_to_float(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_q31_to_float(pSrc_converted,pDst,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+
+
+
+static PyObject *
+cmsis_arm_float_to_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_float_to_q31(pSrc_converted,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_float_to_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_float_to_q15(pSrc_converted,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_float_to_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  q7_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
+
+
+    arm_float_to_q7(pSrc_converted,pDst,blockSize);
+ INT8ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_q31_to_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
+
+
+    arm_q31_to_q15(pSrc_converted,pDst,blockSize);
+ INT16ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_q31_to_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q7_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
+
+
+    arm_q31_to_q7(pSrc_converted,pDst,blockSize);
+ INT8ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_q15_to_float(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
+
+
+    arm_q15_to_float(pSrc_converted,pDst,blockSize);
+ FLOATARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_q15_to_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
+
+
+    arm_q15_to_q31(pSrc_converted,pDst,blockSize);
+ INT32ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_q15_to_q7(PyObject *obj, PyObject *args)
+{
+
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q7_t *pDst=NULL; // output
+  uint32_t blockSize; // input
+
+  if (PyArg_ParseTuple(args,"O",&pSrc))
+  {
+
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+    blockSize = arraySizepSrc ;
+
+    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
+
+
+    arm_q15_to_q7(pSrc_converted,pDst,blockSize);
+ INT8ARRAY1(pDstOBJ,blockSize,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+
+static PyMethodDef CMSISDSPMethods[] = {
+
+
+{"arm_copy_f32",  cmsis_arm_copy_f32, METH_VARARGS,""},
+{"arm_copy_q7",  cmsis_arm_copy_q7, METH_VARARGS,""},
+{"arm_copy_q15",  cmsis_arm_copy_q15, METH_VARARGS,""},
+{"arm_copy_q31",  cmsis_arm_copy_q31, METH_VARARGS,""},
+
+
+{"arm_q7_to_q31",  cmsis_arm_q7_to_q31, METH_VARARGS,""},
+{"arm_q7_to_q15",  cmsis_arm_q7_to_q15, METH_VARARGS,""},
+{"arm_q7_to_float",  cmsis_arm_q7_to_float, METH_VARARGS,""},
+{"arm_q31_to_float",  cmsis_arm_q31_to_float, METH_VARARGS,""},
+
+
+
+{"arm_float_to_q31",  cmsis_arm_float_to_q31, METH_VARARGS,""},
+{"arm_float_to_q15",  cmsis_arm_float_to_q15, METH_VARARGS,""},
+{"arm_float_to_q7",  cmsis_arm_float_to_q7, METH_VARARGS,""},
+{"arm_q31_to_q15",  cmsis_arm_q31_to_q15, METH_VARARGS,""},
+{"arm_q31_to_q7",  cmsis_arm_q31_to_q7, METH_VARARGS,""},
+{"arm_q15_to_float",  cmsis_arm_q15_to_float, METH_VARARGS,""},
+{"arm_q15_to_q31",  cmsis_arm_q15_to_q31, METH_VARARGS,""},
+{"arm_q15_to_q7",  cmsis_arm_q15_to_q7, METH_VARARGS,""},
+
+
+{"arm_fill_f32",  cmsis_arm_fill_f32, METH_VARARGS,""},
+{"arm_fill_q31",  cmsis_arm_fill_q31, METH_VARARGS,""},
+{"arm_fill_q15",  cmsis_arm_fill_q15, METH_VARARGS,""},
+{"arm_fill_q7",  cmsis_arm_fill_q7, METH_VARARGS,""},
+
+    {"error_out", (PyCFunction)error_out, METH_NOARGS, NULL},
+    {NULL, NULL, 0, NULL}        /* Sentinel */
+};
+
+#ifdef IS_PY3K
+static int cmsisdsp_traverse(PyObject *m, visitproc visit, void *arg) {
+    Py_VISIT(GETSTATE(m)->error);
+    return 0;
+}
+
+static int cmsisdsp_clear(PyObject *m) {
+    Py_CLEAR(GETSTATE(m)->error);
+    return 0;
+}
+
+
+static struct PyModuleDef moduledef = {
+        PyModuleDef_HEAD_INIT,
+        MODNAME,
+        NULL,
+        sizeof(struct module_state),
+        CMSISDSPMethods,
+        NULL,
+        cmsisdsp_traverse,
+        cmsisdsp_clear,
+        NULL
+};
+
+#define INITERROR return NULL
+
+PyMODINIT_FUNC
+CAT(PyInit_,MODINITNAME)(void)
+
+
+#else
+#define INITERROR return
+
+void CAT(init,MODINITNAME)(void)
+#endif
+{
+    import_array();
+
+  #ifdef IS_PY3K
+    PyObject *module = PyModule_Create(&moduledef);
+  #else
+    PyObject *module = Py_InitModule(MODNAME, CMSISDSPMethods);
+  #endif
+
+  if (module == NULL)
+      INITERROR;
+  struct module_state *st = GETSTATE(module);
+  
+  st->error = PyErr_NewException(MODNAME".Error", NULL, NULL);
+  if (st->error == NULL) {
+      Py_DECREF(module);
+      INITERROR;
+  }
+
+
+  typeRegistration(module);
+
+  #ifdef IS_PY3K
+    return module;
+  #endif
+}

PythonWrapper/cmsisdsp_pkg/src/cmsisdsp_transform.c

@@ -0,0 +1,3233 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Python Wrapper
+ * Title:        cmsismodule.h
+ * Description:  C code for the CMSIS-DSP Python wrapper
+ *
+ * $Date:        27 April 2021
+ * $Revision:    V1.0
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define MODNAME "cmsisdsp_transform"
+#define MODINITNAME cmsisdsp_transform
+
+#include "cmsisdsp_module.h"
+
+
+
+NUMPYVECTORFROMBUFFER(f32,float32_t,NPY_FLOAT);
+
+
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_cfft_radix2_instance_q15 *instance;
+} dsp_arm_cfft_radix2_instance_q15Object;
+
+
+static void
+arm_cfft_radix2_instance_q15_dealloc(dsp_arm_cfft_radix2_instance_q15Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_cfft_radix2_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_cfft_radix2_instance_q15Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_cfft_radix2_instance_q15Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_cfft_radix2_instance_q15));
+
+        self->instance->pTwiddle = NULL;
+        self->instance->pBitRevTable = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_cfft_radix2_instance_q15_init(dsp_arm_cfft_radix2_instance_q15Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddle=NULL;
+    PyObject *pBitRevTable=NULL;
+char *kwlist[] = {
+"fftLen","ifftFlag","bitReverseFlag","twidCoefModifier","bitRevFactor",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hiihh", kwlist,&self->instance->fftLen
+,&self->instance->ifftFlag
+,&self->instance->bitReverseFlag
+,&self->instance->twidCoefModifier
+,&self->instance->bitRevFactor
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_cfft_radix2_instance_q15,fftLen,"h");
+GETFIELD(arm_cfft_radix2_instance_q15,ifftFlag,"i");
+GETFIELD(arm_cfft_radix2_instance_q15,bitReverseFlag,"i");
+GETFIELD(arm_cfft_radix2_instance_q15,twidCoefModifier,"h");
+GETFIELD(arm_cfft_radix2_instance_q15,bitRevFactor,"h");
+
+
+static PyMethodDef arm_cfft_radix2_instance_q15_methods[] = {
+
+    {"fftLen", (PyCFunction) Method_arm_cfft_radix2_instance_q15_fftLen,METH_NOARGS,"fftLen"},
+    {"ifftFlag", (PyCFunction) Method_arm_cfft_radix2_instance_q15_ifftFlag,METH_NOARGS,"ifftFlag"},
+    {"bitReverseFlag", (PyCFunction) Method_arm_cfft_radix2_instance_q15_bitReverseFlag,METH_NOARGS,"bitReverseFlag"},
+    {"twidCoefModifier", (PyCFunction) Method_arm_cfft_radix2_instance_q15_twidCoefModifier,METH_NOARGS,"twidCoefModifier"},
+    {"bitRevFactor", (PyCFunction) Method_arm_cfft_radix2_instance_q15_bitRevFactor,METH_NOARGS,"bitRevFactor"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_cfft_radix2_instance_q15,arm_cfft_radix2_instance_q15_new,arm_cfft_radix2_instance_q15_dealloc,arm_cfft_radix2_instance_q15_init,arm_cfft_radix2_instance_q15_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_cfft_radix4_instance_q15 *instance;
+} dsp_arm_cfft_radix4_instance_q15Object;
+
+
+static void
+arm_cfft_radix4_instance_q15_dealloc(dsp_arm_cfft_radix4_instance_q15Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_cfft_radix4_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_cfft_radix4_instance_q15Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_cfft_radix4_instance_q15Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_cfft_radix4_instance_q15));
+
+        self->instance->pTwiddle = NULL;
+        self->instance->pBitRevTable = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_cfft_radix4_instance_q15_init(dsp_arm_cfft_radix4_instance_q15Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddle=NULL;
+    PyObject *pBitRevTable=NULL;
+char *kwlist[] = {
+"fftLen","ifftFlag","bitReverseFlag","twidCoefModifier","bitRevFactor",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hiihh", kwlist,&self->instance->fftLen
+,&self->instance->ifftFlag
+,&self->instance->bitReverseFlag
+,&self->instance->twidCoefModifier
+,&self->instance->bitRevFactor
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_cfft_radix4_instance_q15,fftLen,"h");
+GETFIELD(arm_cfft_radix4_instance_q15,ifftFlag,"i");
+GETFIELD(arm_cfft_radix4_instance_q15,bitReverseFlag,"i");
+GETFIELD(arm_cfft_radix4_instance_q15,twidCoefModifier,"h");
+GETFIELD(arm_cfft_radix4_instance_q15,bitRevFactor,"h");
+
+
+static PyMethodDef arm_cfft_radix4_instance_q15_methods[] = {
+
+    {"fftLen", (PyCFunction) Method_arm_cfft_radix4_instance_q15_fftLen,METH_NOARGS,"fftLen"},
+    {"ifftFlag", (PyCFunction) Method_arm_cfft_radix4_instance_q15_ifftFlag,METH_NOARGS,"ifftFlag"},
+    {"bitReverseFlag", (PyCFunction) Method_arm_cfft_radix4_instance_q15_bitReverseFlag,METH_NOARGS,"bitReverseFlag"},
+    {"twidCoefModifier", (PyCFunction) Method_arm_cfft_radix4_instance_q15_twidCoefModifier,METH_NOARGS,"twidCoefModifier"},
+    {"bitRevFactor", (PyCFunction) Method_arm_cfft_radix4_instance_q15_bitRevFactor,METH_NOARGS,"bitRevFactor"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_cfft_radix4_instance_q15,arm_cfft_radix4_instance_q15_new,arm_cfft_radix4_instance_q15_dealloc,arm_cfft_radix4_instance_q15_init,arm_cfft_radix4_instance_q15_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_cfft_radix2_instance_q31 *instance;
+} dsp_arm_cfft_radix2_instance_q31Object;
+
+
+static void
+arm_cfft_radix2_instance_q31_dealloc(dsp_arm_cfft_radix2_instance_q31Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_cfft_radix2_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_cfft_radix2_instance_q31Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_cfft_radix2_instance_q31Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_cfft_radix2_instance_q31));
+
+        self->instance->pTwiddle = NULL;
+        self->instance->pBitRevTable = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_cfft_radix2_instance_q31_init(dsp_arm_cfft_radix2_instance_q31Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddle=NULL;
+    PyObject *pBitRevTable=NULL;
+char *kwlist[] = {
+"fftLen","ifftFlag","bitReverseFlag","twidCoefModifier","bitRevFactor",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hiihh", kwlist,&self->instance->fftLen
+,&self->instance->ifftFlag
+,&self->instance->bitReverseFlag
+,&self->instance->twidCoefModifier
+,&self->instance->bitRevFactor
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_cfft_radix2_instance_q31,fftLen,"h");
+GETFIELD(arm_cfft_radix2_instance_q31,ifftFlag,"i");
+GETFIELD(arm_cfft_radix2_instance_q31,bitReverseFlag,"i");
+GETFIELD(arm_cfft_radix2_instance_q31,twidCoefModifier,"h");
+GETFIELD(arm_cfft_radix2_instance_q31,bitRevFactor,"h");
+
+
+static PyMethodDef arm_cfft_radix2_instance_q31_methods[] = {
+
+    {"fftLen", (PyCFunction) Method_arm_cfft_radix2_instance_q31_fftLen,METH_NOARGS,"fftLen"},
+    {"ifftFlag", (PyCFunction) Method_arm_cfft_radix2_instance_q31_ifftFlag,METH_NOARGS,"ifftFlag"},
+    {"bitReverseFlag", (PyCFunction) Method_arm_cfft_radix2_instance_q31_bitReverseFlag,METH_NOARGS,"bitReverseFlag"},
+    {"twidCoefModifier", (PyCFunction) Method_arm_cfft_radix2_instance_q31_twidCoefModifier,METH_NOARGS,"twidCoefModifier"},
+    {"bitRevFactor", (PyCFunction) Method_arm_cfft_radix2_instance_q31_bitRevFactor,METH_NOARGS,"bitRevFactor"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_cfft_radix2_instance_q31,arm_cfft_radix2_instance_q31_new,arm_cfft_radix2_instance_q31_dealloc,arm_cfft_radix2_instance_q31_init,arm_cfft_radix2_instance_q31_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_cfft_radix4_instance_q31 *instance;
+} dsp_arm_cfft_radix4_instance_q31Object;
+
+
+static void
+arm_cfft_radix4_instance_q31_dealloc(dsp_arm_cfft_radix4_instance_q31Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_cfft_radix4_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_cfft_radix4_instance_q31Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_cfft_radix4_instance_q31Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_cfft_radix4_instance_q31));
+
+        self->instance->pTwiddle = NULL;
+        self->instance->pBitRevTable = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_cfft_radix4_instance_q31_init(dsp_arm_cfft_radix4_instance_q31Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddle=NULL;
+    PyObject *pBitRevTable=NULL;
+char *kwlist[] = {
+"fftLen","ifftFlag","bitReverseFlag","twidCoefModifier","bitRevFactor",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hiihh", kwlist,&self->instance->fftLen
+,&self->instance->ifftFlag
+,&self->instance->bitReverseFlag
+,&self->instance->twidCoefModifier
+,&self->instance->bitRevFactor
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_cfft_radix4_instance_q31,fftLen,"h");
+GETFIELD(arm_cfft_radix4_instance_q31,ifftFlag,"i");
+GETFIELD(arm_cfft_radix4_instance_q31,bitReverseFlag,"i");
+GETFIELD(arm_cfft_radix4_instance_q31,twidCoefModifier,"h");
+GETFIELD(arm_cfft_radix4_instance_q31,bitRevFactor,"h");
+
+
+static PyMethodDef arm_cfft_radix4_instance_q31_methods[] = {
+
+    {"fftLen", (PyCFunction) Method_arm_cfft_radix4_instance_q31_fftLen,METH_NOARGS,"fftLen"},
+    {"ifftFlag", (PyCFunction) Method_arm_cfft_radix4_instance_q31_ifftFlag,METH_NOARGS,"ifftFlag"},
+    {"bitReverseFlag", (PyCFunction) Method_arm_cfft_radix4_instance_q31_bitReverseFlag,METH_NOARGS,"bitReverseFlag"},
+    {"twidCoefModifier", (PyCFunction) Method_arm_cfft_radix4_instance_q31_twidCoefModifier,METH_NOARGS,"twidCoefModifier"},
+    {"bitRevFactor", (PyCFunction) Method_arm_cfft_radix4_instance_q31_bitRevFactor,METH_NOARGS,"bitRevFactor"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_cfft_radix4_instance_q31,arm_cfft_radix4_instance_q31_new,arm_cfft_radix4_instance_q31_dealloc,arm_cfft_radix4_instance_q31_init,arm_cfft_radix4_instance_q31_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_cfft_radix2_instance_f32 *instance;
+} dsp_arm_cfft_radix2_instance_f32Object;
+
+
+static void
+arm_cfft_radix2_instance_f32_dealloc(dsp_arm_cfft_radix2_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_cfft_radix2_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_cfft_radix2_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_cfft_radix2_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_cfft_radix2_instance_f32));
+
+        self->instance->pTwiddle = NULL;
+        self->instance->pBitRevTable = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_cfft_radix2_instance_f32_init(dsp_arm_cfft_radix2_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddle=NULL;
+    PyObject *pBitRevTable=NULL;
+char *kwlist[] = {
+"fftLen","ifftFlag","bitReverseFlag","twidCoefModifier","bitRevFactor","onebyfftLen",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hiihhf", kwlist,&self->instance->fftLen
+,&self->instance->ifftFlag
+,&self->instance->bitReverseFlag
+,&self->instance->twidCoefModifier
+,&self->instance->bitRevFactor
+,&self->instance->onebyfftLen
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_cfft_radix2_instance_f32,fftLen,"h");
+GETFIELD(arm_cfft_radix2_instance_f32,ifftFlag,"i");
+GETFIELD(arm_cfft_radix2_instance_f32,bitReverseFlag,"i");
+GETFIELD(arm_cfft_radix2_instance_f32,twidCoefModifier,"h");
+GETFIELD(arm_cfft_radix2_instance_f32,bitRevFactor,"h");
+GETFIELD(arm_cfft_radix2_instance_f32,onebyfftLen,"f");
+
+
+static PyMethodDef arm_cfft_radix2_instance_f32_methods[] = {
+
+    {"fftLen", (PyCFunction) Method_arm_cfft_radix2_instance_f32_fftLen,METH_NOARGS,"fftLen"},
+    {"ifftFlag", (PyCFunction) Method_arm_cfft_radix2_instance_f32_ifftFlag,METH_NOARGS,"ifftFlag"},
+    {"bitReverseFlag", (PyCFunction) Method_arm_cfft_radix2_instance_f32_bitReverseFlag,METH_NOARGS,"bitReverseFlag"},
+    {"twidCoefModifier", (PyCFunction) Method_arm_cfft_radix2_instance_f32_twidCoefModifier,METH_NOARGS,"twidCoefModifier"},
+    {"bitRevFactor", (PyCFunction) Method_arm_cfft_radix2_instance_f32_bitRevFactor,METH_NOARGS,"bitRevFactor"},
+    {"onebyfftLen", (PyCFunction) Method_arm_cfft_radix2_instance_f32_onebyfftLen,METH_NOARGS,"onebyfftLen"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_cfft_radix2_instance_f32,arm_cfft_radix2_instance_f32_new,arm_cfft_radix2_instance_f32_dealloc,arm_cfft_radix2_instance_f32_init,arm_cfft_radix2_instance_f32_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_cfft_radix4_instance_f32 *instance;
+} dsp_arm_cfft_radix4_instance_f32Object;
+
+
+static void
+arm_cfft_radix4_instance_f32_dealloc(dsp_arm_cfft_radix4_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_cfft_radix4_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_cfft_radix4_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_cfft_radix4_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_cfft_radix4_instance_f32));
+
+        self->instance->pTwiddle = NULL;
+        self->instance->pBitRevTable = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_cfft_radix4_instance_f32_init(dsp_arm_cfft_radix4_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddle=NULL;
+    PyObject *pBitRevTable=NULL;
+char *kwlist[] = {
+"fftLen","ifftFlag","bitReverseFlag","twidCoefModifier","bitRevFactor","onebyfftLen",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hiihhf", kwlist,&self->instance->fftLen
+,&self->instance->ifftFlag
+,&self->instance->bitReverseFlag
+,&self->instance->twidCoefModifier
+,&self->instance->bitRevFactor
+,&self->instance->onebyfftLen
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_cfft_radix4_instance_f32,fftLen,"h");
+GETFIELD(arm_cfft_radix4_instance_f32,ifftFlag,"i");
+GETFIELD(arm_cfft_radix4_instance_f32,bitReverseFlag,"i");
+GETFIELD(arm_cfft_radix4_instance_f32,twidCoefModifier,"h");
+GETFIELD(arm_cfft_radix4_instance_f32,bitRevFactor,"h");
+GETFIELD(arm_cfft_radix4_instance_f32,onebyfftLen,"f");
+
+
+static PyMethodDef arm_cfft_radix4_instance_f32_methods[] = {
+
+    {"fftLen", (PyCFunction) Method_arm_cfft_radix4_instance_f32_fftLen,METH_NOARGS,"fftLen"},
+    {"ifftFlag", (PyCFunction) Method_arm_cfft_radix4_instance_f32_ifftFlag,METH_NOARGS,"ifftFlag"},
+    {"bitReverseFlag", (PyCFunction) Method_arm_cfft_radix4_instance_f32_bitReverseFlag,METH_NOARGS,"bitReverseFlag"},
+    {"twidCoefModifier", (PyCFunction) Method_arm_cfft_radix4_instance_f32_twidCoefModifier,METH_NOARGS,"twidCoefModifier"},
+    {"bitRevFactor", (PyCFunction) Method_arm_cfft_radix4_instance_f32_bitRevFactor,METH_NOARGS,"bitRevFactor"},
+    {"onebyfftLen", (PyCFunction) Method_arm_cfft_radix4_instance_f32_onebyfftLen,METH_NOARGS,"onebyfftLen"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_cfft_radix4_instance_f32,arm_cfft_radix4_instance_f32_new,arm_cfft_radix4_instance_f32_dealloc,arm_cfft_radix4_instance_f32_init,arm_cfft_radix4_instance_f32_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_cfft_instance_q15 *instance;
+} dsp_arm_cfft_instance_q15Object;
+
+
+static void
+arm_cfft_instance_q15_dealloc(dsp_arm_cfft_instance_q15Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_cfft_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_cfft_instance_q15Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_cfft_instance_q15Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_cfft_instance_q15));
+
+        self->instance->pTwiddle = NULL;
+        self->instance->pBitRevTable = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_cfft_instance_q15_init(dsp_arm_cfft_instance_q15Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddle=NULL;
+    PyObject *pBitRevTable=NULL;
+char *kwlist[] = {
+"fftLen","bitRevLength",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hh", kwlist,&self->instance->fftLen
+,&self->instance->bitRevLength
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_cfft_instance_q15,fftLen,"h");
+GETFIELD(arm_cfft_instance_q15,bitRevLength,"h");
+
+
+static PyMethodDef arm_cfft_instance_q15_methods[] = {
+
+    {"fftLen", (PyCFunction) Method_arm_cfft_instance_q15_fftLen,METH_NOARGS,"fftLen"},
+    {"bitRevLength", (PyCFunction) Method_arm_cfft_instance_q15_bitRevLength,METH_NOARGS,"bitRevLength"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_cfft_instance_q15,arm_cfft_instance_q15_new,arm_cfft_instance_q15_dealloc,arm_cfft_instance_q15_init,arm_cfft_instance_q15_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_cfft_instance_q31 *instance;
+} dsp_arm_cfft_instance_q31Object;
+
+
+static void
+arm_cfft_instance_q31_dealloc(dsp_arm_cfft_instance_q31Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_cfft_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_cfft_instance_q31Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_cfft_instance_q31Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_cfft_instance_q31));
+
+        self->instance->pTwiddle = NULL;
+        self->instance->pBitRevTable = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_cfft_instance_q31_init(dsp_arm_cfft_instance_q31Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddle=NULL;
+    PyObject *pBitRevTable=NULL;
+char *kwlist[] = {
+"fftLen","bitRevLength",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hh", kwlist,&self->instance->fftLen
+,&self->instance->bitRevLength
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_cfft_instance_q31,fftLen,"h");
+GETFIELD(arm_cfft_instance_q31,bitRevLength,"h");
+
+
+static PyMethodDef arm_cfft_instance_q31_methods[] = {
+
+    {"fftLen", (PyCFunction) Method_arm_cfft_instance_q31_fftLen,METH_NOARGS,"fftLen"},
+    {"bitRevLength", (PyCFunction) Method_arm_cfft_instance_q31_bitRevLength,METH_NOARGS,"bitRevLength"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_cfft_instance_q31,arm_cfft_instance_q31_new,arm_cfft_instance_q31_dealloc,arm_cfft_instance_q31_init,arm_cfft_instance_q31_methods);
+
+typedef struct {
+    PyObject_HEAD
+    arm_cfft_instance_f64 *instance;
+} dsp_arm_cfft_instance_f64Object;
+
+
+static void
+arm_cfft_instance_f64_dealloc(dsp_arm_cfft_instance_f64Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_cfft_instance_f64_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_cfft_instance_f64Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_cfft_instance_f64Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_cfft_instance_f64));
+
+        self->instance->pTwiddle = NULL;
+        self->instance->pBitRevTable = NULL;
+
+    }
+
+    return (PyObject *)self;
+}
+
+static int
+arm_cfft_instance_f64_init(dsp_arm_cfft_instance_f64Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddle=NULL;
+    PyObject *pBitRevTable=NULL;
+    char *kwlist[] = {
+        "fftLen","bitRevLength",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hh", kwlist,&self->instance->fftLen
+,&self->instance->bitRevLength
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_cfft_instance_f64,fftLen,"h");
+GETFIELD(arm_cfft_instance_f64,bitRevLength,"h");
+
+
+static PyMethodDef arm_cfft_instance_f64_methods[] = {
+
+    {"fftLen", (PyCFunction) Method_arm_cfft_instance_f64_fftLen,METH_NOARGS,"fftLen"},
+    {"bitRevLength", (PyCFunction) Method_arm_cfft_instance_f64_bitRevLength,METH_NOARGS,"bitRevLength"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_cfft_instance_f64,arm_cfft_instance_f64_new,arm_cfft_instance_f64_dealloc,arm_cfft_instance_f64_init,arm_cfft_instance_f64_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_cfft_instance_f32 *instance;
+} dsp_arm_cfft_instance_f32Object;
+
+
+static void
+arm_cfft_instance_f32_dealloc(dsp_arm_cfft_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_cfft_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_cfft_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_cfft_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_cfft_instance_f32));
+
+        self->instance->pTwiddle = NULL;
+        self->instance->pBitRevTable = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_cfft_instance_f32_init(dsp_arm_cfft_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddle=NULL;
+    PyObject *pBitRevTable=NULL;
+char *kwlist[] = {
+"fftLen","bitRevLength",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hh", kwlist,&self->instance->fftLen
+,&self->instance->bitRevLength
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_cfft_instance_f32,fftLen,"h");
+GETFIELD(arm_cfft_instance_f32,bitRevLength,"h");
+
+
+static PyMethodDef arm_cfft_instance_f32_methods[] = {
+
+    {"fftLen", (PyCFunction) Method_arm_cfft_instance_f32_fftLen,METH_NOARGS,"fftLen"},
+    {"bitRevLength", (PyCFunction) Method_arm_cfft_instance_f32_bitRevLength,METH_NOARGS,"bitRevLength"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_cfft_instance_f32,arm_cfft_instance_f32_new,arm_cfft_instance_f32_dealloc,arm_cfft_instance_f32_init,arm_cfft_instance_f32_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_rfft_instance_q15 *instance;
+} dsp_arm_rfft_instance_q15Object;
+
+
+static void
+arm_rfft_instance_q15_dealloc(dsp_arm_rfft_instance_q15Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_rfft_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_rfft_instance_q15Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_rfft_instance_q15Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_rfft_instance_q15));
+
+        self->instance->pTwiddleAReal = NULL;
+        self->instance->pTwiddleBReal = NULL;
+        self->instance->pCfft = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_rfft_instance_q15_init(dsp_arm_rfft_instance_q15Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddleAReal=NULL;
+    PyObject *pTwiddleBReal=NULL;
+    PyObject *pCfft=NULL;
+char *kwlist[] = {
+"fftLenReal","ifftFlagR","bitReverseFlagR","twidCoefRModifier",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|iiii", kwlist,&self->instance->fftLenReal
+,&self->instance->ifftFlagR
+,&self->instance->bitReverseFlagR
+,&self->instance->twidCoefRModifier
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_rfft_instance_q15,fftLenReal,"i");
+GETFIELD(arm_rfft_instance_q15,ifftFlagR,"i");
+GETFIELD(arm_rfft_instance_q15,bitReverseFlagR,"i");
+GETFIELD(arm_rfft_instance_q15,twidCoefRModifier,"i");
+
+
+static PyMethodDef arm_rfft_instance_q15_methods[] = {
+
+    {"fftLenReal", (PyCFunction) Method_arm_rfft_instance_q15_fftLenReal,METH_NOARGS,"fftLenReal"},
+    {"ifftFlagR", (PyCFunction) Method_arm_rfft_instance_q15_ifftFlagR,METH_NOARGS,"ifftFlagR"},
+    {"bitReverseFlagR", (PyCFunction) Method_arm_rfft_instance_q15_bitReverseFlagR,METH_NOARGS,"bitReverseFlagR"},
+    {"twidCoefRModifier", (PyCFunction) Method_arm_rfft_instance_q15_twidCoefRModifier,METH_NOARGS,"twidCoefRModifier"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_rfft_instance_q15,arm_rfft_instance_q15_new,arm_rfft_instance_q15_dealloc,arm_rfft_instance_q15_init,arm_rfft_instance_q15_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_rfft_instance_q31 *instance;
+} dsp_arm_rfft_instance_q31Object;
+
+
+static void
+arm_rfft_instance_q31_dealloc(dsp_arm_rfft_instance_q31Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_rfft_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_rfft_instance_q31Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_rfft_instance_q31Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_rfft_instance_q31));
+
+        self->instance->pTwiddleAReal = NULL;
+        self->instance->pTwiddleBReal = NULL;
+        self->instance->pCfft = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_rfft_instance_q31_init(dsp_arm_rfft_instance_q31Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddleAReal=NULL;
+    PyObject *pTwiddleBReal=NULL;
+    PyObject *pCfft=NULL;
+char *kwlist[] = {
+"fftLenReal","ifftFlagR","bitReverseFlagR","twidCoefRModifier",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|iiii", kwlist,&self->instance->fftLenReal
+,&self->instance->ifftFlagR
+,&self->instance->bitReverseFlagR
+,&self->instance->twidCoefRModifier
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_rfft_instance_q31,fftLenReal,"i");
+GETFIELD(arm_rfft_instance_q31,ifftFlagR,"i");
+GETFIELD(arm_rfft_instance_q31,bitReverseFlagR,"i");
+GETFIELD(arm_rfft_instance_q31,twidCoefRModifier,"i");
+
+
+static PyMethodDef arm_rfft_instance_q31_methods[] = {
+
+    {"fftLenReal", (PyCFunction) Method_arm_rfft_instance_q31_fftLenReal,METH_NOARGS,"fftLenReal"},
+    {"ifftFlagR", (PyCFunction) Method_arm_rfft_instance_q31_ifftFlagR,METH_NOARGS,"ifftFlagR"},
+    {"bitReverseFlagR", (PyCFunction) Method_arm_rfft_instance_q31_bitReverseFlagR,METH_NOARGS,"bitReverseFlagR"},
+    {"twidCoefRModifier", (PyCFunction) Method_arm_rfft_instance_q31_twidCoefRModifier,METH_NOARGS,"twidCoefRModifier"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_rfft_instance_q31,arm_rfft_instance_q31_new,arm_rfft_instance_q31_dealloc,arm_rfft_instance_q31_init,arm_rfft_instance_q31_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_rfft_instance_f32 *instance;
+} dsp_arm_rfft_instance_f32Object;
+
+
+static void
+arm_rfft_instance_f32_dealloc(dsp_arm_rfft_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_rfft_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_rfft_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_rfft_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_rfft_instance_f32));
+
+        self->instance->pTwiddleAReal = NULL;
+        self->instance->pTwiddleBReal = NULL;
+        self->instance->pCfft = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_rfft_instance_f32_init(dsp_arm_rfft_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddleAReal=NULL;
+    PyObject *pTwiddleBReal=NULL;
+    PyObject *pCfft=NULL;
+char *kwlist[] = {
+"fftLenReal","fftLenBy2","ifftFlagR","bitReverseFlagR","twidCoefRModifier",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|ihiii", kwlist,&self->instance->fftLenReal
+,&self->instance->fftLenBy2
+,&self->instance->ifftFlagR
+,&self->instance->bitReverseFlagR
+,&self->instance->twidCoefRModifier
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_rfft_instance_f32,fftLenReal,"i");
+GETFIELD(arm_rfft_instance_f32,fftLenBy2,"h");
+GETFIELD(arm_rfft_instance_f32,ifftFlagR,"i");
+GETFIELD(arm_rfft_instance_f32,bitReverseFlagR,"i");
+GETFIELD(arm_rfft_instance_f32,twidCoefRModifier,"i");
+
+
+static PyMethodDef arm_rfft_instance_f32_methods[] = {
+
+    {"fftLenReal", (PyCFunction) Method_arm_rfft_instance_f32_fftLenReal,METH_NOARGS,"fftLenReal"},
+    {"fftLenBy2", (PyCFunction) Method_arm_rfft_instance_f32_fftLenBy2,METH_NOARGS,"fftLenBy2"},
+    {"ifftFlagR", (PyCFunction) Method_arm_rfft_instance_f32_ifftFlagR,METH_NOARGS,"ifftFlagR"},
+    {"bitReverseFlagR", (PyCFunction) Method_arm_rfft_instance_f32_bitReverseFlagR,METH_NOARGS,"bitReverseFlagR"},
+    {"twidCoefRModifier", (PyCFunction) Method_arm_rfft_instance_f32_twidCoefRModifier,METH_NOARGS,"twidCoefRModifier"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_rfft_instance_f32,arm_rfft_instance_f32_new,arm_rfft_instance_f32_dealloc,arm_rfft_instance_f32_init,arm_rfft_instance_f32_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_rfft_fast_instance_f64 *instance;
+} dsp_arm_rfft_fast_instance_f64Object;
+
+
+static void
+arm_rfft_fast_instance_f64_dealloc(dsp_arm_rfft_fast_instance_f64Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_rfft_fast_instance_f64_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_rfft_fast_instance_f64Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_rfft_fast_instance_f64Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_rfft_fast_instance_f64));
+
+        self->instance->pTwiddleRFFT = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_rfft_fast_instance_f64_init(dsp_arm_rfft_fast_instance_f64Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddleRFFT=NULL;
+char *kwlist[] = {
+"Sint","fftLenRFFT",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|?h", kwlist,&self->instance->Sint
+,&self->instance->fftLenRFFT
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_rfft_fast_instance_f64,Sint,"?");
+GETFIELD(arm_rfft_fast_instance_f64,fftLenRFFT,"h");
+
+
+static PyMethodDef arm_rfft_fast_instance_f64_methods[] = {
+
+    {"Sint", (PyCFunction) Method_arm_rfft_fast_instance_f64_Sint,METH_NOARGS,"Sint"},
+    {"fftLenRFFT", (PyCFunction) Method_arm_rfft_fast_instance_f64_fftLenRFFT,METH_NOARGS,"fftLenRFFT"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_rfft_fast_instance_f64,arm_rfft_fast_instance_f64_new,arm_rfft_fast_instance_f64_dealloc,arm_rfft_fast_instance_f64_init,arm_rfft_fast_instance_f64_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_rfft_fast_instance_f32 *instance;
+} dsp_arm_rfft_fast_instance_f32Object;
+
+
+static void
+arm_rfft_fast_instance_f32_dealloc(dsp_arm_rfft_fast_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_rfft_fast_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_rfft_fast_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_rfft_fast_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_rfft_fast_instance_f32));
+
+        self->instance->pTwiddleRFFT = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_rfft_fast_instance_f32_init(dsp_arm_rfft_fast_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddleRFFT=NULL;
+char *kwlist[] = {
+"Sint","fftLenRFFT",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|?h", kwlist,&self->instance->Sint
+,&self->instance->fftLenRFFT
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_rfft_fast_instance_f32,Sint,"?");
+GETFIELD(arm_rfft_fast_instance_f32,fftLenRFFT,"h");
+
+
+static PyMethodDef arm_rfft_fast_instance_f32_methods[] = {
+
+    {"Sint", (PyCFunction) Method_arm_rfft_fast_instance_f32_Sint,METH_NOARGS,"Sint"},
+    {"fftLenRFFT", (PyCFunction) Method_arm_rfft_fast_instance_f32_fftLenRFFT,METH_NOARGS,"fftLenRFFT"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_rfft_fast_instance_f32,arm_rfft_fast_instance_f32_new,arm_rfft_fast_instance_f32_dealloc,arm_rfft_fast_instance_f32_init,arm_rfft_fast_instance_f32_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_dct4_instance_f32 *instance;
+} dsp_arm_dct4_instance_f32Object;
+
+
+static void
+arm_dct4_instance_f32_dealloc(dsp_arm_dct4_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_dct4_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_dct4_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_dct4_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_dct4_instance_f32));
+
+        self->instance->pTwiddle = NULL;
+        self->instance->pCosFactor = NULL;
+        self->instance->pRfft = NULL;
+        self->instance->pCfft = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_dct4_instance_f32_init(dsp_arm_dct4_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddle=NULL;
+    PyObject *pCosFactor=NULL;
+    PyObject *pRfft=NULL;
+    PyObject *pCfft=NULL;
+char *kwlist[] = {
+"N","Nby2","normalize",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhf", kwlist,&self->instance->N
+,&self->instance->Nby2
+,&self->instance->normalize
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_dct4_instance_f32,N,"h");
+GETFIELD(arm_dct4_instance_f32,Nby2,"h");
+GETFIELD(arm_dct4_instance_f32,normalize,"f");
+
+
+static PyMethodDef arm_dct4_instance_f32_methods[] = {
+
+    {"N", (PyCFunction) Method_arm_dct4_instance_f32_N,METH_NOARGS,"N"},
+    {"Nby2", (PyCFunction) Method_arm_dct4_instance_f32_Nby2,METH_NOARGS,"Nby2"},
+    {"normalize", (PyCFunction) Method_arm_dct4_instance_f32_normalize,METH_NOARGS,"normalize"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_dct4_instance_f32,arm_dct4_instance_f32_new,arm_dct4_instance_f32_dealloc,arm_dct4_instance_f32_init,arm_dct4_instance_f32_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_dct4_instance_q31 *instance;
+} dsp_arm_dct4_instance_q31Object;
+
+
+static void
+arm_dct4_instance_q31_dealloc(dsp_arm_dct4_instance_q31Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_dct4_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_dct4_instance_q31Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_dct4_instance_q31Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_dct4_instance_q31));
+
+        self->instance->pTwiddle = NULL;
+        self->instance->pCosFactor = NULL;
+        self->instance->pRfft = NULL;
+        self->instance->pCfft = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_dct4_instance_q31_init(dsp_arm_dct4_instance_q31Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddle=NULL;
+    PyObject *pCosFactor=NULL;
+    PyObject *pRfft=NULL;
+    PyObject *pCfft=NULL;
+char *kwlist[] = {
+"N","Nby2","normalize",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhi", kwlist,&self->instance->N
+,&self->instance->Nby2
+,&self->instance->normalize
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_dct4_instance_q31,N,"h");
+GETFIELD(arm_dct4_instance_q31,Nby2,"h");
+GETFIELD(arm_dct4_instance_q31,normalize,"i");
+
+
+static PyMethodDef arm_dct4_instance_q31_methods[] = {
+
+    {"N", (PyCFunction) Method_arm_dct4_instance_q31_N,METH_NOARGS,"N"},
+    {"Nby2", (PyCFunction) Method_arm_dct4_instance_q31_Nby2,METH_NOARGS,"Nby2"},
+    {"normalize", (PyCFunction) Method_arm_dct4_instance_q31_normalize,METH_NOARGS,"normalize"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_dct4_instance_q31,arm_dct4_instance_q31_new,arm_dct4_instance_q31_dealloc,arm_dct4_instance_q31_init,arm_dct4_instance_q31_methods);
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_dct4_instance_q15 *instance;
+} dsp_arm_dct4_instance_q15Object;
+
+
+static void
+arm_dct4_instance_q15_dealloc(dsp_arm_dct4_instance_q15Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+
+static PyObject *
+arm_dct4_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_dct4_instance_q15Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_dct4_instance_q15Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_dct4_instance_q15));
+
+        self->instance->pTwiddle = NULL;
+        self->instance->pCosFactor = NULL;
+        self->instance->pRfft = NULL;
+        self->instance->pCfft = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_dct4_instance_q15_init(dsp_arm_dct4_instance_q15Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddle=NULL;
+    PyObject *pCosFactor=NULL;
+    PyObject *pRfft=NULL;
+    PyObject *pCfft=NULL;
+char *kwlist[] = {
+"N","Nby2","normalize",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhh", kwlist,&self->instance->N
+,&self->instance->Nby2
+,&self->instance->normalize
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_dct4_instance_q15,N,"h");
+GETFIELD(arm_dct4_instance_q15,Nby2,"h");
+GETFIELD(arm_dct4_instance_q15,normalize,"h");
+
+
+static PyMethodDef arm_dct4_instance_q15_methods[] = {
+
+    {"N", (PyCFunction) Method_arm_dct4_instance_q15_N,METH_NOARGS,"N"},
+    {"Nby2", (PyCFunction) Method_arm_dct4_instance_q15_Nby2,METH_NOARGS,"Nby2"},
+    {"normalize", (PyCFunction) Method_arm_dct4_instance_q15_normalize,METH_NOARGS,"normalize"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_dct4_instance_q15,arm_dct4_instance_q15_new,arm_dct4_instance_q15_dealloc,arm_dct4_instance_q15_init,arm_dct4_instance_q15_methods);
+
+
+
+typedef struct {
+    PyObject_HEAD
+    arm_mfcc_instance_f32 *instance;
+} dsp_arm_mfcc_instance_f32Object;
+
+typedef struct {
+    PyObject_HEAD
+    arm_mfcc_instance_q31 *instance;
+} dsp_arm_mfcc_instance_q31Object;
+
+typedef struct {
+    PyObject_HEAD
+    arm_mfcc_instance_q15 *instance;
+} dsp_arm_mfcc_instance_q15Object;
+
+static void
+arm_mfcc_instance_f32_dealloc(dsp_arm_mfcc_instance_f32Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+static void
+arm_mfcc_instance_q31_dealloc(dsp_arm_mfcc_instance_q31Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+static void
+arm_mfcc_instance_q15_dealloc(dsp_arm_mfcc_instance_q15Object* self)
+{
+    //printf("Dealloc called\n");
+    if (self->instance)
+    {
+
+
+       PyMem_Free(self->instance);
+    }
+
+    Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+static PyObject *
+arm_mfcc_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_mfcc_instance_f32Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_mfcc_instance_f32Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_mfcc_instance_f32));
+
+        self->instance->dctCoefs = NULL;
+        self->instance->filterCoefs = NULL;
+        self->instance->windowCoefs = NULL;
+        self->instance->filterPos = NULL;
+        self->instance->filterLengths = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static PyObject *
+arm_mfcc_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_mfcc_instance_q31Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_mfcc_instance_q31Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_mfcc_instance_q31));
+
+        self->instance->dctCoefs = NULL;
+        self->instance->filterCoefs = NULL;
+        self->instance->windowCoefs = NULL;
+        self->instance->filterPos = NULL;
+        self->instance->filterLengths = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static PyObject *
+arm_mfcc_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    dsp_arm_mfcc_instance_q15Object *self;
+    //printf("New called\n");
+
+    self = (dsp_arm_mfcc_instance_q15Object *)type->tp_alloc(type, 0);
+    //printf("alloc called\n");
+
+    if (self != NULL) {
+
+        self->instance = PyMem_Malloc(sizeof(arm_mfcc_instance_q15));
+
+        self->instance->dctCoefs = NULL;
+        self->instance->filterCoefs = NULL;
+        self->instance->windowCoefs = NULL;
+        self->instance->filterPos = NULL;
+        self->instance->filterLengths = NULL;
+
+    }
+
+
+    return (PyObject *)self;
+}
+
+static int
+arm_mfcc_instance_f32_init(dsp_arm_mfcc_instance_f32Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddle=NULL;
+    PyObject *pBitRevTable=NULL;
+char *kwlist[] = {
+"fftLen","nbMelFilters","nbDctOutputs",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|iii", kwlist,&self->instance->fftLen
+,&self->instance->nbMelFilters,&self->instance->nbDctOutputs
+))
+    {
+
+
+    }
+    return 0;
+}
+
+static int
+arm_mfcc_instance_q31_init(dsp_arm_mfcc_instance_q31Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddle=NULL;
+    PyObject *pBitRevTable=NULL;
+char *kwlist[] = {
+"fftLen","nbMelFilters","nbDctOutputs",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|iii", kwlist,&self->instance->fftLen
+,&self->instance->nbMelFilters,&self->instance->nbDctOutputs
+))
+    {
+
+
+    }
+    return 0;
+}
+
+static int
+arm_mfcc_instance_q15_init(dsp_arm_mfcc_instance_q15Object *self, PyObject *args, PyObject *kwds)
+{
+
+    PyObject *pTwiddle=NULL;
+    PyObject *pBitRevTable=NULL;
+char *kwlist[] = {
+"fftLen","nbMelFilters","nbDctOutputs",NULL
+};
+
+if (PyArg_ParseTupleAndKeywords(args, kwds, "|iii", kwlist,&self->instance->fftLen
+,&self->instance->nbMelFilters,&self->instance->nbDctOutputs
+))
+    {
+
+
+    }
+    return 0;
+}
+
+GETFIELD(arm_mfcc_instance_f32,fftLen,"i");
+GETFIELD(arm_mfcc_instance_f32,nbMelFilters,"i");
+GETFIELD(arm_mfcc_instance_f32,nbDctOutputs,"i");
+
+GETFIELD(arm_mfcc_instance_q31,fftLen,"i");
+GETFIELD(arm_mfcc_instance_q31,nbMelFilters,"i");
+GETFIELD(arm_mfcc_instance_q31,nbDctOutputs,"i");
+
+GETFIELD(arm_mfcc_instance_q15,fftLen,"i");
+GETFIELD(arm_mfcc_instance_q15,nbMelFilters,"i");
+GETFIELD(arm_mfcc_instance_q15,nbDctOutputs,"i");
+
+
+static PyMethodDef arm_mfcc_instance_f32_methods[] = {
+
+    {"fftLen", (PyCFunction) Method_arm_mfcc_instance_f32_fftLen,METH_NOARGS,"fftLen"},
+    {"nbMelFilters", (PyCFunction) Method_arm_mfcc_instance_f32_nbMelFilters,METH_NOARGS,"nbMelFilters"},
+    {"nbDctOutputs", (PyCFunction) Method_arm_mfcc_instance_f32_nbDctOutputs,METH_NOARGS,"nbDctOutputs"},
+
+    {NULL}  /* Sentinel */
+};
+
+static PyMethodDef arm_mfcc_instance_q31_methods[] = {
+
+    {"fftLen", (PyCFunction) Method_arm_mfcc_instance_q31_fftLen,METH_NOARGS,"fftLen"},
+    {"nbMelFilters", (PyCFunction) Method_arm_mfcc_instance_q31_nbMelFilters,METH_NOARGS,"nbMelFilters"},
+    {"nbDctOutputs", (PyCFunction) Method_arm_mfcc_instance_q31_nbDctOutputs,METH_NOARGS,"nbDctOutputs"},
+
+    {NULL}  /* Sentinel */
+};
+
+static PyMethodDef arm_mfcc_instance_q15_methods[] = {
+
+    {"fftLen", (PyCFunction) Method_arm_mfcc_instance_q15_fftLen,METH_NOARGS,"fftLen"},
+    {"nbMelFilters", (PyCFunction) Method_arm_mfcc_instance_q15_nbMelFilters,METH_NOARGS,"nbMelFilters"},
+    {"nbDctOutputs", (PyCFunction) Method_arm_mfcc_instance_q15_nbDctOutputs,METH_NOARGS,"nbDctOutputs"},
+
+    {NULL}  /* Sentinel */
+};
+
+
+DSPType(arm_mfcc_instance_f32,arm_mfcc_instance_f32_new,arm_mfcc_instance_f32_dealloc,arm_mfcc_instance_f32_init,arm_mfcc_instance_f32_methods);
+DSPType(arm_mfcc_instance_q31,arm_mfcc_instance_q31_new,arm_mfcc_instance_q31_dealloc,arm_mfcc_instance_q31_init,arm_mfcc_instance_q31_methods);
+DSPType(arm_mfcc_instance_q15,arm_mfcc_instance_q15_new,arm_mfcc_instance_q15_dealloc,arm_mfcc_instance_q15_init,arm_mfcc_instance_q15_methods);
+
+
+
+void typeRegistration(PyObject *module) {
+
+  
+  
+  ADDTYPE(arm_cfft_radix2_instance_q15);
+  ADDTYPE(arm_cfft_radix4_instance_q15);
+  ADDTYPE(arm_cfft_radix2_instance_q31);
+  ADDTYPE(arm_cfft_radix4_instance_q31);
+  ADDTYPE(arm_cfft_radix2_instance_f32);
+  ADDTYPE(arm_cfft_radix4_instance_f32);
+  ADDTYPE(arm_cfft_instance_q15);
+  ADDTYPE(arm_cfft_instance_q31);
+  ADDTYPE(arm_cfft_instance_f32);
+  ADDTYPE(arm_rfft_instance_q15);
+  ADDTYPE(arm_rfft_instance_q31);
+  ADDTYPE(arm_rfft_instance_f32);
+  ADDTYPE(arm_rfft_fast_instance_f32);
+  ADDTYPE(arm_dct4_instance_f32);
+  ADDTYPE(arm_dct4_instance_q31);
+  ADDTYPE(arm_dct4_instance_q15);
+
+  
+  ADDTYPE(arm_mfcc_instance_f32);
+  ADDTYPE(arm_mfcc_instance_q31);
+  ADDTYPE(arm_mfcc_instance_q15);
+}
+
+
+
+
+static PyObject *
+cmsis_arm_cfft_radix2_init_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t fftLen; // input
+  uint32_t ifftFlag; // input
+  uint32_t bitReverseFlag; // input
+
+  if (PyArg_ParseTuple(args,"Ohii",&S,&fftLen,&ifftFlag,&bitReverseFlag))
+  {
+
+    dsp_arm_cfft_radix2_instance_q15Object *selfS = (dsp_arm_cfft_radix2_instance_q15Object *)S;
+
+    arm_status returnValue = arm_cfft_radix2_init_q15(selfS->instance,fftLen,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cfft_radix2_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_cfft_radix2_instance_q15Object *selfS = (dsp_arm_cfft_radix2_instance_q15Object *)S;
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+
+    arm_cfft_radix2_q15(selfS->instance,pSrc_converted);
+    FREEARGUMENT(pSrc_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cfft_radix4_init_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t fftLen; // input
+  uint32_t ifftFlag; // input
+  uint32_t bitReverseFlag; // input
+
+  if (PyArg_ParseTuple(args,"Ohii",&S,&fftLen,&ifftFlag,&bitReverseFlag))
+  {
+
+    dsp_arm_cfft_radix4_instance_q15Object *selfS = (dsp_arm_cfft_radix4_instance_q15Object *)S;
+
+    arm_status returnValue = arm_cfft_radix4_init_q15(selfS->instance,fftLen,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cfft_radix4_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_cfft_radix4_instance_q15Object *selfS = (dsp_arm_cfft_radix4_instance_q15Object *)S;
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+
+    arm_cfft_radix4_q15(selfS->instance,pSrc_converted);
+    FREEARGUMENT(pSrc_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cfft_radix2_init_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t fftLen; // input
+  uint32_t ifftFlag; // input
+  uint32_t bitReverseFlag; // input
+
+  if (PyArg_ParseTuple(args,"Ohii",&S,&fftLen,&ifftFlag,&bitReverseFlag))
+  {
+
+    dsp_arm_cfft_radix2_instance_q31Object *selfS = (dsp_arm_cfft_radix2_instance_q31Object *)S;
+
+    arm_status returnValue = arm_cfft_radix2_init_q31(selfS->instance,fftLen,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cfft_radix2_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_cfft_radix2_instance_q31Object *selfS = (dsp_arm_cfft_radix2_instance_q31Object *)S;
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+
+    arm_cfft_radix2_q31(selfS->instance,pSrc_converted);
+    FREEARGUMENT(pSrc_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cfft_radix4_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_cfft_radix4_instance_q31Object *selfS = (dsp_arm_cfft_radix4_instance_q31Object *)S;
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+
+    arm_cfft_radix4_q31(selfS->instance,pSrc_converted);
+    FREEARGUMENT(pSrc_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cfft_radix4_init_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t fftLen; // input
+  uint32_t ifftFlag; // input
+  uint32_t bitReverseFlag; // input
+
+  if (PyArg_ParseTuple(args,"Ohii",&S,&fftLen,&ifftFlag,&bitReverseFlag))
+  {
+
+    dsp_arm_cfft_radix4_instance_q31Object *selfS = (dsp_arm_cfft_radix4_instance_q31Object *)S;
+
+    arm_status returnValue = arm_cfft_radix4_init_q31(selfS->instance,fftLen,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cfft_radix2_init_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t fftLen; // input
+  uint32_t ifftFlag; // input
+  uint32_t bitReverseFlag; // input
+
+  if (PyArg_ParseTuple(args,"Ohii",&S,&fftLen,&ifftFlag,&bitReverseFlag))
+  {
+
+    dsp_arm_cfft_radix2_instance_f32Object *selfS = (dsp_arm_cfft_radix2_instance_f32Object *)S;
+
+    arm_status returnValue = arm_cfft_radix2_init_f32(selfS->instance,fftLen,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cfft_radix2_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_cfft_radix2_instance_f32Object *selfS = (dsp_arm_cfft_radix2_instance_f32Object *)S;
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+
+    arm_cfft_radix2_f32(selfS->instance,pSrc_converted);
+    FREEARGUMENT(pSrc_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cfft_radix4_init_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t fftLen; // input
+  uint32_t ifftFlag; // input
+  uint32_t bitReverseFlag; // input
+
+  if (PyArg_ParseTuple(args,"Ohii",&S,&fftLen,&ifftFlag,&bitReverseFlag))
+  {
+
+    dsp_arm_cfft_radix4_instance_f32Object *selfS = (dsp_arm_cfft_radix4_instance_f32Object *)S;
+
+    arm_status returnValue = arm_cfft_radix4_init_f32(selfS->instance,fftLen,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cfft_radix4_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_cfft_radix4_instance_f32Object *selfS = (dsp_arm_cfft_radix4_instance_f32Object *)S;
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+
+    arm_cfft_radix4_f32(selfS->instance,pSrc_converted);
+    FREEARGUMENT(pSrc_converted);
+    Py_RETURN_NONE;
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cfft_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *p1=NULL; // input
+  q15_t *p1_converted=NULL; // input
+  uint32_t ifftFlag; // input
+  uint32_t bitReverseFlag; // input
+
+  if (PyArg_ParseTuple(args,"OOii",&S,&p1,&ifftFlag,&bitReverseFlag))
+  {
+
+    dsp_arm_cfft_instance_q15Object *selfS = (dsp_arm_cfft_instance_q15Object *)S;
+    GETARGUMENT(p1,NPY_INT16,int16_t,int16_t);
+
+    arm_cfft_q15(selfS->instance,p1_converted,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
+ INT16ARRAY1(p1OBJ,2*selfS->instance->fftLen,p1_converted);
+
+    PyObject *pythonResult = Py_BuildValue("O",p1OBJ);
+
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cfft_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *p1=NULL; // input
+  q31_t *p1_converted=NULL; // input
+  uint32_t ifftFlag; // input
+  uint32_t bitReverseFlag; // input
+
+  if (PyArg_ParseTuple(args,"OOii",&S,&p1,&ifftFlag,&bitReverseFlag))
+  {
+
+    dsp_arm_cfft_instance_q31Object *selfS = (dsp_arm_cfft_instance_q31Object *)S;
+    GETARGUMENT(p1,NPY_INT32,int32_t,int32_t);
+
+    arm_cfft_q31(selfS->instance,p1_converted,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
+ INT32ARRAY1(p1OBJ,2*selfS->instance->fftLen,p1_converted);
+
+    PyObject *pythonResult = Py_BuildValue("O",p1OBJ);
+
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+static PyObject *
+cmsis_arm_cfft_f64(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *p1=NULL; // input
+  float64_t *p1_converted=NULL; // input
+  uint32_t ifftFlag; // input
+  uint32_t bitReverseFlag; // input
+
+  if (PyArg_ParseTuple(args,"OOii",&S,&p1,&ifftFlag,&bitReverseFlag))
+  {
+
+    dsp_arm_cfft_instance_f64Object *selfS = (dsp_arm_cfft_instance_f64Object *)S;
+    GETARGUMENT(p1,NPY_DOUBLE,double,float64_t);
+
+    arm_cfft_f64(selfS->instance,p1_converted,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
+    FLOATARRAY1(p1OBJ,2*selfS->instance->fftLen,p1_converted);
+
+    PyObject *pythonResult = Py_BuildValue("O",p1OBJ);
+
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cfft_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *p1=NULL; // input
+  float32_t *p1_converted=NULL; // input
+  uint32_t ifftFlag; // input
+  uint32_t bitReverseFlag; // input
+
+  if (PyArg_ParseTuple(args,"OOii",&S,&p1,&ifftFlag,&bitReverseFlag))
+  {
+
+    dsp_arm_cfft_instance_f32Object *selfS = (dsp_arm_cfft_instance_f32Object *)S;
+    GETARGUMENT(p1,NPY_DOUBLE,double,float32_t);
+
+    arm_cfft_f32(selfS->instance,p1_converted,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
+ FLOATARRAY1(p1OBJ,2*selfS->instance->fftLen,p1_converted);
+
+    PyObject *pythonResult = Py_BuildValue("O",p1OBJ);
+
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_rfft_init_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint32_t fftLenReal; // input
+  uint32_t ifftFlagR; // input
+  uint32_t bitReverseFlag; // input
+
+  if (PyArg_ParseTuple(args,"Oiii",&S,&fftLenReal,&ifftFlagR,&bitReverseFlag))
+  {
+
+    dsp_arm_rfft_instance_q15Object *selfS = (dsp_arm_rfft_instance_q15Object *)S;
+
+    arm_status returnValue = arm_rfft_init_q15(selfS->instance,fftLenReal,ifftFlagR,bitReverseFlag);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_rfft_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q15_t *pSrc_converted=NULL; // input
+  q15_t *pDst=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_rfft_instance_q15Object *selfS = (dsp_arm_rfft_instance_q15Object *)S;
+    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*2*selfS->instance->fftLenReal);
+
+
+    arm_rfft_q15(selfS->instance,pSrc_converted,pDst);
+ INT16ARRAY1(pDstOBJ,2*selfS->instance->fftLenReal,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_rfft_init_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint32_t fftLenReal; // input
+  uint32_t ifftFlagR; // input
+  uint32_t bitReverseFlag; // input
+
+  if (PyArg_ParseTuple(args,"Oiii",&S,&fftLenReal,&ifftFlagR,&bitReverseFlag))
+  {
+
+    dsp_arm_rfft_instance_q31Object *selfS = (dsp_arm_rfft_instance_q31Object *)S;
+
+    arm_status returnValue = arm_rfft_init_q31(selfS->instance,fftLenReal,ifftFlagR,bitReverseFlag);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_rfft_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  q31_t *pSrc_converted=NULL; // input
+  q31_t *pDst=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_rfft_instance_q31Object *selfS = (dsp_arm_rfft_instance_q31Object *)S;
+    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*2*selfS->instance->fftLenReal);
+
+
+    arm_rfft_q31(selfS->instance,pSrc_converted,pDst);
+ INT32ARRAY1(pDstOBJ,2*selfS->instance->fftLenReal,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_rfft_init_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *S_CFFT=NULL; // input
+  uint32_t fftLenReal; // input
+  uint32_t ifftFlagR; // input
+  uint32_t bitReverseFlag; // input
+
+  if (PyArg_ParseTuple(args,"OOiii",&S,&S_CFFT,&fftLenReal,&ifftFlagR,&bitReverseFlag))
+  {
+
+    dsp_arm_rfft_instance_f32Object *selfS = (dsp_arm_rfft_instance_f32Object *)S;
+    dsp_arm_cfft_radix4_instance_f32Object *selfS_CFFT = (dsp_arm_cfft_radix4_instance_f32Object *)S_CFFT;
+
+    arm_status returnValue = arm_rfft_init_f32(selfS->instance,selfS_CFFT->instance,fftLenReal,ifftFlagR,bitReverseFlag);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_rfft_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pSrc=NULL; // input
+  float32_t *pSrc_converted=NULL; // input
+  float32_t *pDst=NULL; // output
+
+  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
+  {
+
+    dsp_arm_rfft_instance_f32Object *selfS = (dsp_arm_rfft_instance_f32Object *)S;
+    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*2*selfS->instance->fftLenReal);
+
+
+    arm_rfft_f32(selfS->instance,pSrc_converted,pDst);
+ FLOATARRAY1(pDstOBJ,selfS->instance->fftLenReal+1,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+
+    FREEARGUMENT(pSrc_converted);
+    Py_DECREF(pDstOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_rfft_fast_init_f64(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t fftLen; // input
+
+  if (PyArg_ParseTuple(args,"Oh",&S,&fftLen))
+  {
+
+    dsp_arm_rfft_fast_instance_f64Object *selfS = (dsp_arm_rfft_fast_instance_f64Object *)S;
+
+    arm_status returnValue = arm_rfft_fast_init_f64(selfS->instance,fftLen);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+static PyObject *
+cmsis_arm_rfft_fast_f64(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *p=NULL; // input
+  float64_t *p_converted=NULL; // input
+  float64_t *pOut=NULL; // output
+  uint32_t ifftFlag; // input
+
+  if (PyArg_ParseTuple(args,"OOi",&S,&p,&ifftFlag))
+  {
+
+    dsp_arm_rfft_fast_instance_f64Object *selfS = (dsp_arm_rfft_fast_instance_f64Object *)S;
+    GETARGUMENT(p,NPY_DOUBLE,double,float64_t);
+
+    pOut=PyMem_Malloc(sizeof(float64_t)*2*selfS->instance->fftLenRFFT);
+
+
+    arm_rfft_fast_f64(selfS->instance,p_converted,pOut,(uint8_t)ifftFlag);
+ FLOATARRAY1(pOutOBJ,2*selfS->instance->fftLenRFFT,pOut);
+
+    PyObject *pythonResult = Py_BuildValue("O",pOutOBJ);
+
+    FREEARGUMENT(p_converted);
+    Py_DECREF(pOutOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+static PyObject *
+cmsis_arm_rfft_fast_init_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t fftLen; // input
+
+  if (PyArg_ParseTuple(args,"Oh",&S,&fftLen))
+  {
+
+    dsp_arm_rfft_fast_instance_f32Object *selfS = (dsp_arm_rfft_fast_instance_f32Object *)S;
+
+    arm_status returnValue = arm_rfft_fast_init_f32(selfS->instance,fftLen);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+static PyObject *
+cmsis_arm_rfft_fast_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *p=NULL; // input
+  float32_t *p_converted=NULL; // input
+  float32_t *pOut=NULL; // output
+  uint32_t ifftFlag; // input
+
+  if (PyArg_ParseTuple(args,"OOi",&S,&p,&ifftFlag))
+  {
+
+    dsp_arm_rfft_fast_instance_f32Object *selfS = (dsp_arm_rfft_fast_instance_f32Object *)S;
+    GETARGUMENT(p,NPY_DOUBLE,double,float32_t);
+
+    pOut=PyMem_Malloc(sizeof(float32_t)*(selfS->instance->fftLenRFFT));
+
+
+    arm_rfft_fast_f32(selfS->instance,p_converted,pOut,(uint8_t)ifftFlag);
+ FLOATARRAY1(pOutOBJ,(selfS->instance->fftLenRFFT),pOut);
+
+    PyObject *pythonResult = Py_BuildValue("O",pOutOBJ);
+
+    FREEARGUMENT(p_converted);
+    Py_DECREF(pOutOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_dct4_init_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *S_RFFT=NULL; // input
+  PyObject *S_CFFT=NULL; // input
+  uint16_t N; // input
+  uint16_t Nby2; // input
+  float32_t normalize; // input
+
+  if (PyArg_ParseTuple(args,"OOOhhf",&S,&S_RFFT,&S_CFFT,&N,&Nby2,&normalize))
+  {
+
+    dsp_arm_dct4_instance_f32Object *selfS = (dsp_arm_dct4_instance_f32Object *)S;
+    dsp_arm_rfft_instance_f32Object *selfS_RFFT = (dsp_arm_rfft_instance_f32Object *)S_RFFT;
+    dsp_arm_cfft_radix4_instance_f32Object *selfS_CFFT = (dsp_arm_cfft_radix4_instance_f32Object *)S_CFFT;
+    uint32_t outputLength = selfS->instance->N ;
+
+    arm_status returnValue = arm_dct4_init_f32(selfS->instance,selfS_RFFT->instance,selfS_CFFT->instance,N,Nby2,normalize);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_dct4_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pState=NULL; // input
+  float32_t *pState_converted=NULL; // input
+  PyObject *pInlineBuffer=NULL; // input
+  float32_t *pInlineBuffer_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OOO",&S,&pState,&pInlineBuffer))
+  {
+
+    dsp_arm_dct4_instance_f32Object *selfS = (dsp_arm_dct4_instance_f32Object *)S;
+    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pInlineBuffer,NPY_DOUBLE,double,float32_t);
+    uint32_t outputLength = selfS->instance->N ;
+
+    arm_dct4_f32(selfS->instance,pState_converted,pInlineBuffer_converted);
+ FLOATARRAY1(pInlineBufferOBJ,outputLength,pInlineBuffer_converted);
+
+    PyObject *pythonResult = Py_BuildValue("O",pInlineBufferOBJ);
+
+    FREEARGUMENT(pState_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_dct4_init_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *S_RFFT=NULL; // input
+  PyObject *S_CFFT=NULL; // input
+  uint16_t N; // input
+  uint16_t Nby2; // input
+  q31_t normalize; // input
+
+  if (PyArg_ParseTuple(args,"OOOhhi",&S,&S_RFFT,&S_CFFT,&N,&Nby2,&normalize))
+  {
+
+    dsp_arm_dct4_instance_q31Object *selfS = (dsp_arm_dct4_instance_q31Object *)S;
+    dsp_arm_rfft_instance_q31Object *selfS_RFFT = (dsp_arm_rfft_instance_q31Object *)S_RFFT;
+    dsp_arm_cfft_radix4_instance_q31Object *selfS_CFFT = (dsp_arm_cfft_radix4_instance_q31Object *)S_CFFT;
+    uint32_t outputLength = selfS->instance->N ;
+
+    arm_status returnValue = arm_dct4_init_q31(selfS->instance,selfS_RFFT->instance,selfS_CFFT->instance,N,Nby2,normalize);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_dct4_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pState=NULL; // input
+  q31_t *pState_converted=NULL; // input
+  PyObject *pInlineBuffer=NULL; // input
+  q31_t *pInlineBuffer_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OOO",&S,&pState,&pInlineBuffer))
+  {
+
+    dsp_arm_dct4_instance_q31Object *selfS = (dsp_arm_dct4_instance_q31Object *)S;
+    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pInlineBuffer,NPY_INT32,int32_t,int32_t);
+    uint32_t outputLength = selfS->instance->N ;
+
+    arm_dct4_q31(selfS->instance,pState_converted,pInlineBuffer_converted);
+ INT32ARRAY1(pInlineBufferOBJ,outputLength,pInlineBuffer_converted);
+
+    PyObject *pythonResult = Py_BuildValue("O",pInlineBufferOBJ);
+
+    FREEARGUMENT(pState_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_dct4_init_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *S_RFFT=NULL; // input
+  PyObject *S_CFFT=NULL; // input
+  uint16_t N; // input
+  uint16_t Nby2; // input
+  q15_t normalize; // input
+
+  if (PyArg_ParseTuple(args,"OOOhhh",&S,&S_RFFT,&S_CFFT,&N,&Nby2,&normalize))
+  {
+
+    dsp_arm_dct4_instance_q15Object *selfS = (dsp_arm_dct4_instance_q15Object *)S;
+    dsp_arm_rfft_instance_q15Object *selfS_RFFT = (dsp_arm_rfft_instance_q15Object *)S_RFFT;
+    dsp_arm_cfft_radix4_instance_q15Object *selfS_CFFT = (dsp_arm_cfft_radix4_instance_q15Object *)S_CFFT;
+    uint32_t outputLength = selfS->instance->N ;
+
+    arm_status returnValue = arm_dct4_init_q15(selfS->instance,selfS_RFFT->instance,selfS_CFFT->instance,N,Nby2,normalize);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_dct4_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *pState=NULL; // input
+  q15_t *pState_converted=NULL; // input
+  PyObject *pInlineBuffer=NULL; // input
+  q15_t *pInlineBuffer_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OOO",&S,&pState,&pInlineBuffer))
+  {
+
+    dsp_arm_dct4_instance_q15Object *selfS = (dsp_arm_dct4_instance_q15Object *)S;
+    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pInlineBuffer,NPY_INT16,int16_t,int16_t);
+    uint32_t outputLength = selfS->instance->N ;
+
+    arm_dct4_q15(selfS->instance,pState_converted,pInlineBuffer_converted);
+ INT16ARRAY1(pInlineBufferOBJ,outputLength,pInlineBuffer_converted);
+
+    PyObject *pythonResult = Py_BuildValue("O",pInlineBufferOBJ);
+
+    FREEARGUMENT(pState_converted);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+
+static PyObject *
+cmsis_arm_cfft_init_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t fftLen; // input
+
+  if (PyArg_ParseTuple(args,"Oh",&S,&fftLen))
+  {
+
+    dsp_arm_cfft_instance_f32Object *selfS = (dsp_arm_cfft_instance_f32Object *)S;
+
+    arm_status returnValue = arm_cfft_init_f32(selfS->instance,fftLen);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_cfft_init_f64(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t fftLen; // input
+
+  if (PyArg_ParseTuple(args,"Oh",&S,&fftLen))
+  {
+
+    dsp_arm_cfft_instance_f64Object *selfS = (dsp_arm_cfft_instance_f64Object *)S;
+
+    arm_status returnValue = arm_cfft_init_f64(selfS->instance,fftLen);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_cfft_init_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t fftLen; // input
+
+  if (PyArg_ParseTuple(args,"Oh",&S,&fftLen))
+  {
+
+    dsp_arm_cfft_instance_q31Object *selfS = (dsp_arm_cfft_instance_q31Object *)S;
+
+    arm_status returnValue = arm_cfft_init_q31(selfS->instance,fftLen);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyObject *
+cmsis_arm_cfft_init_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint16_t fftLen; // input
+
+  if (PyArg_ParseTuple(args,"Oh",&S,&fftLen))
+  {
+
+    dsp_arm_cfft_instance_q15Object *selfS = (dsp_arm_cfft_instance_q15Object *)S;
+
+    arm_status returnValue = arm_cfft_init_q15(selfS->instance,fftLen);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+
+/*
+
+MFCC
+
+*/
+
+static PyObject *
+cmsis_arm_mfcc_init_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint32_t fftLen,nbMelFilters,nbDctOutputs; // input
+
+  PyObject *pdctCoefs=NULL; // input
+  float32_t *pdctCoefs_converted=NULL; // input
+
+  PyObject *pfilterCoefs=NULL; // input
+  float32_t *pfilterCoefs_converted=NULL; // input
+
+  PyObject *pwindowCoefs=NULL; // input
+  float32_t *pwindowCoefs_converted=NULL; // input
+
+  PyObject *pfilterPos=NULL; // input
+  uint32_t *pfilterPos_converted=NULL; // input
+
+  PyObject *pfilterLengths=NULL; // input
+  uint32_t *pfilterLengths_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OiiiOOOOO",&S,&fftLen,&nbMelFilters,&nbDctOutputs,
+    &pdctCoefs,&pfilterPos,&pfilterLengths,&pfilterCoefs,&pwindowCoefs))
+  {
+
+    dsp_arm_mfcc_instance_f32Object *selfS = (dsp_arm_mfcc_instance_f32Object *)S;
+
+    GETARGUMENT(pdctCoefs,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pfilterPos,NPY_UINT32,uint32_t,uint32_t);
+    GETARGUMENT(pfilterLengths,NPY_UINT32,uint32_t,uint32_t);
+    GETARGUMENT(pfilterCoefs,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(pwindowCoefs,NPY_DOUBLE,double,float32_t);
+
+
+    arm_status returnValue = arm_mfcc_init_f32(selfS->instance,
+        fftLen,nbMelFilters,nbDctOutputs,
+        pdctCoefs_converted,
+        pfilterPos_converted,pfilterLengths_converted,pfilterCoefs_converted,
+        pwindowCoefs_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mfcc_f32(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *p1=NULL; // input
+  float32_t *p1_converted=NULL; // input
+
+  PyObject *tmp=NULL; // input
+  float32_t *tmp_converted=NULL; // input
+
+  float32_t *pDst;
+  if (PyArg_ParseTuple(args,"OOO",&S,&p1,&tmp))
+  {
+
+    dsp_arm_mfcc_instance_f32Object *selfS = (dsp_arm_mfcc_instance_f32Object *)S;
+    GETARGUMENT(p1,NPY_DOUBLE,double,float32_t);
+    GETARGUMENT(tmp,NPY_DOUBLE,double,float32_t);
+
+    pDst=PyMem_Malloc(sizeof(float32_t)*selfS->instance->nbDctOutputs);
+
+    arm_mfcc_f32(selfS->instance,p1_converted,pDst,tmp_converted);
+
+    FLOATARRAY1(pDstOBJ,selfS->instance->nbDctOutputs,pDst);
+
+    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
+    Py_DECREF(pDstOBJ);
+
+    FREEARGUMENT(p1_converted);
+    FREEARGUMENT(tmp_converted);
+
+    
+
+
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mfcc_init_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint32_t fftLen,nbMelFilters,nbDctOutputs; // input
+
+  PyObject *pdctCoefs=NULL; // input
+  q15_t *pdctCoefs_converted=NULL; // input
+
+  PyObject *pfilterCoefs=NULL; // input
+  q15_t *pfilterCoefs_converted=NULL; // input
+
+  PyObject *pwindowCoefs=NULL; // input
+  q15_t *pwindowCoefs_converted=NULL; // input
+
+  PyObject *pfilterPos=NULL; // input
+  uint32_t *pfilterPos_converted=NULL; // input
+
+  PyObject *pfilterLengths=NULL; // input
+  uint32_t *pfilterLengths_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OiiiOOOOO",&S,&fftLen,&nbMelFilters,&nbDctOutputs,
+    &pdctCoefs,&pfilterPos,&pfilterLengths,&pfilterCoefs,&pwindowCoefs))
+  {
+
+    dsp_arm_mfcc_instance_q15Object *selfS = (dsp_arm_mfcc_instance_q15Object *)S;
+
+    GETARGUMENT(pdctCoefs,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pfilterPos,NPY_UINT32,uint32_t,uint32_t);
+    GETARGUMENT(pfilterLengths,NPY_UINT32,uint32_t,uint32_t);
+    GETARGUMENT(pfilterCoefs,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(pwindowCoefs,NPY_INT16,int16_t,int16_t);
+
+
+    arm_status returnValue = arm_mfcc_init_q15(selfS->instance,
+        fftLen,nbMelFilters,nbDctOutputs,
+        pdctCoefs_converted,
+        pfilterPos_converted,pfilterLengths_converted,pfilterCoefs_converted,
+        pwindowCoefs_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mfcc_q15(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *p1=NULL; // input
+  q15_t *p1_converted=NULL; // input
+
+  PyObject *tmp=NULL; // input
+  q31_t *tmp_converted=NULL; // input
+
+  q15_t *pDst;
+  if (PyArg_ParseTuple(args,"OOO",&S,&p1,&tmp))
+  {
+
+    dsp_arm_mfcc_instance_q15Object *selfS = (dsp_arm_mfcc_instance_q15Object *)S;
+    GETARGUMENT(p1,NPY_INT16,int16_t,int16_t);
+    GETARGUMENT(tmp,NPY_INT32,int32_t,int32_t);
+
+    pDst=PyMem_Malloc(sizeof(q15_t)*selfS->instance->nbDctOutputs);
+
+    arm_status status = arm_mfcc_q15(selfS->instance,p1_converted,pDst,tmp_converted);
+
+    INT16ARRAY1(pDstOBJ,selfS->instance->nbDctOutputs,pDst);
+
+    PyObject* theReturnOBJ=Py_BuildValue("i",status);
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+    Py_DECREF(pDstOBJ);
+    Py_DECREF(theReturnOBJ);
+
+    FREEARGUMENT(p1_converted);
+    FREEARGUMENT(tmp_converted);
+
+
+
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mfcc_init_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  uint32_t fftLen,nbMelFilters,nbDctOutputs; // input
+
+  PyObject *pdctCoefs=NULL; // input
+  q31_t *pdctCoefs_converted=NULL; // input
+
+  PyObject *pfilterCoefs=NULL; // input
+  q31_t *pfilterCoefs_converted=NULL; // input
+
+  PyObject *pwindowCoefs=NULL; // input
+  q31_t *pwindowCoefs_converted=NULL; // input
+
+  PyObject *pfilterPos=NULL; // input
+  uint32_t *pfilterPos_converted=NULL; // input
+
+  PyObject *pfilterLengths=NULL; // input
+  uint32_t *pfilterLengths_converted=NULL; // input
+
+  if (PyArg_ParseTuple(args,"OiiiOOOOO",&S,&fftLen,&nbMelFilters,&nbDctOutputs,
+    &pdctCoefs,&pfilterPos,&pfilterLengths,&pfilterCoefs,&pwindowCoefs))
+  {
+
+    dsp_arm_mfcc_instance_q31Object *selfS = (dsp_arm_mfcc_instance_q31Object *)S;
+
+    GETARGUMENT(pdctCoefs,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pfilterPos,NPY_UINT32,uint32_t,uint32_t);
+    GETARGUMENT(pfilterLengths,NPY_UINT32,uint32_t,uint32_t);
+    GETARGUMENT(pfilterCoefs,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(pwindowCoefs,NPY_INT32,int32_t,int32_t);
+
+
+    arm_status returnValue = arm_mfcc_init_q31(selfS->instance,
+        fftLen,nbMelFilters,nbDctOutputs,
+        pdctCoefs_converted,
+        pfilterPos_converted,pfilterLengths_converted,pfilterCoefs_converted,
+        pwindowCoefs_converted);
+    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
+
+    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
+
+    Py_DECREF(theReturnOBJ);
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+static PyObject *
+cmsis_arm_mfcc_q31(PyObject *obj, PyObject *args)
+{
+
+  PyObject *S=NULL; // input
+  PyObject *p1=NULL; // input
+  q31_t *p1_converted=NULL; // input
+
+  PyObject *tmp=NULL; // input
+  q31_t *tmp_converted=NULL; // input
+
+  q31_t *pDst;
+  if (PyArg_ParseTuple(args,"OOO",&S,&p1,&tmp))
+  {
+
+    dsp_arm_mfcc_instance_q31Object *selfS = (dsp_arm_mfcc_instance_q31Object *)S;
+    GETARGUMENT(p1,NPY_INT32,int32_t,int32_t);
+    GETARGUMENT(tmp,NPY_INT32,int32_t,int32_t);
+
+    pDst=PyMem_Malloc(sizeof(q31_t)*selfS->instance->nbDctOutputs);
+
+    arm_status status = arm_mfcc_q31(selfS->instance,p1_converted,pDst,tmp_converted);
+
+    INT32ARRAY1(pDstOBJ,selfS->instance->nbDctOutputs,pDst);
+
+    PyObject* theReturnOBJ=Py_BuildValue("i",status);
+    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
+    Py_DECREF(pDstOBJ);
+    Py_DECREF(theReturnOBJ);
+
+    FREEARGUMENT(p1_converted);
+    FREEARGUMENT(tmp_converted);
+
+
+
+    return(pythonResult);
+
+  }
+  return(NULL);
+}
+
+
+static PyMethodDef CMSISDSPMethods[] = {
+
+
+
+
+{"arm_cfft_radix2_init_q15",  cmsis_arm_cfft_radix2_init_q15, METH_VARARGS,""},
+{"arm_cfft_radix2_q15",  cmsis_arm_cfft_radix2_q15, METH_VARARGS,""},
+{"arm_cfft_radix4_init_q15",  cmsis_arm_cfft_radix4_init_q15, METH_VARARGS,""},
+{"arm_cfft_radix4_q15",  cmsis_arm_cfft_radix4_q15, METH_VARARGS,""},
+{"arm_cfft_radix2_init_q31",  cmsis_arm_cfft_radix2_init_q31, METH_VARARGS,""},
+{"arm_cfft_radix2_q31",  cmsis_arm_cfft_radix2_q31, METH_VARARGS,""},
+{"arm_cfft_radix4_q31",  cmsis_arm_cfft_radix4_q31, METH_VARARGS,""},
+{"arm_cfft_radix4_init_q31",  cmsis_arm_cfft_radix4_init_q31, METH_VARARGS,""},
+{"arm_cfft_radix2_init_f32",  cmsis_arm_cfft_radix2_init_f32, METH_VARARGS,""},
+{"arm_cfft_radix2_f32",  cmsis_arm_cfft_radix2_f32, METH_VARARGS,""},
+{"arm_cfft_radix4_init_f32",  cmsis_arm_cfft_radix4_init_f32, METH_VARARGS,""},
+{"arm_cfft_radix4_f32",  cmsis_arm_cfft_radix4_f32, METH_VARARGS,""},
+{"arm_cfft_q15",  cmsis_arm_cfft_q15, METH_VARARGS,""},
+{"arm_cfft_q31",  cmsis_arm_cfft_q31, METH_VARARGS,""},
+{"arm_cfft_f64",  cmsis_arm_cfft_f64, METH_VARARGS,""},
+{"arm_cfft_f32",  cmsis_arm_cfft_f32, METH_VARARGS,""},
+{"arm_rfft_init_q15",  cmsis_arm_rfft_init_q15, METH_VARARGS,""},
+{"arm_rfft_q15",  cmsis_arm_rfft_q15, METH_VARARGS,""},
+{"arm_rfft_init_q31",  cmsis_arm_rfft_init_q31, METH_VARARGS,""},
+{"arm_rfft_q31",  cmsis_arm_rfft_q31, METH_VARARGS,""},
+{"arm_rfft_init_f32",  cmsis_arm_rfft_init_f32, METH_VARARGS,""},
+{"arm_rfft_f32",  cmsis_arm_rfft_f32, METH_VARARGS,""},
+{"arm_rfft_fast_init_f64",  cmsis_arm_rfft_fast_init_f64, METH_VARARGS,""},
+{"arm_rfft_fast_f32",  cmsis_arm_rfft_fast_f32, METH_VARARGS,""},
+{"arm_rfft_fast_init_f32",  cmsis_arm_rfft_fast_init_f32, METH_VARARGS,""},
+{"arm_rfft_fast_f32",  cmsis_arm_rfft_fast_f32, METH_VARARGS,""},
+{"arm_dct4_init_f32",  cmsis_arm_dct4_init_f32, METH_VARARGS,""},
+{"arm_dct4_f32",  cmsis_arm_dct4_f32, METH_VARARGS,""},
+{"arm_dct4_init_q31",  cmsis_arm_dct4_init_q31, METH_VARARGS,""},
+{"arm_dct4_q31",  cmsis_arm_dct4_q31, METH_VARARGS,""},
+{"arm_dct4_init_q15",  cmsis_arm_dct4_init_q15, METH_VARARGS,""},
+{"arm_dct4_q15",  cmsis_arm_dct4_q15, METH_VARARGS,""},
+
+
+{"arm_cfft_init_f32",  cmsis_arm_cfft_init_f32, METH_VARARGS,""},
+{"arm_cfft_init_f64",  cmsis_arm_cfft_init_f64, METH_VARARGS,""},
+{"arm_cfft_init_q31",  cmsis_arm_cfft_init_q31, METH_VARARGS,""},
+{"arm_cfft_init_q15",  cmsis_arm_cfft_init_q15, METH_VARARGS,""},
+
+
+    {"arm_mfcc_init_f32",  cmsis_arm_mfcc_init_f32, METH_VARARGS,""},
+    {"arm_mfcc_f32",  cmsis_arm_mfcc_f32, METH_VARARGS,""},
+    {"arm_mfcc_init_q15",  cmsis_arm_mfcc_init_q15, METH_VARARGS,""},
+    {"arm_mfcc_q15",  cmsis_arm_mfcc_q15, METH_VARARGS,""},
+    {"arm_mfcc_init_q31",  cmsis_arm_mfcc_init_q31, METH_VARARGS,""},
+    {"arm_mfcc_q31",  cmsis_arm_mfcc_q31, METH_VARARGS,""},
+   
+    {"error_out", (PyCFunction)error_out, METH_NOARGS, NULL},
+    {NULL, NULL, 0, NULL}        /* Sentinel */
+};
+
+#ifdef IS_PY3K
+static int cmsisdsp_traverse(PyObject *m, visitproc visit, void *arg) {
+    Py_VISIT(GETSTATE(m)->error);
+    return 0;
+}
+
+static int cmsisdsp_clear(PyObject *m) {
+    Py_CLEAR(GETSTATE(m)->error);
+    return 0;
+}
+
+
+static struct PyModuleDef moduledef = {
+        PyModuleDef_HEAD_INIT,
+        MODNAME,
+        NULL,
+        sizeof(struct module_state),
+        CMSISDSPMethods,
+        NULL,
+        cmsisdsp_traverse,
+        cmsisdsp_clear,
+        NULL
+};
+
+#define INITERROR return NULL
+
+PyMODINIT_FUNC
+CAT(PyInit_,MODINITNAME)(void)
+
+
+#else
+#define INITERROR return
+
+void CAT(init,MODINITNAME)(void)
+#endif
+{
+    import_array();
+
+  #ifdef IS_PY3K
+    PyObject *module = PyModule_Create(&moduledef);
+  #else
+    PyObject *module = Py_InitModule(MODNAME, CMSISDSPMethods);
+  #endif
+
+  if (module == NULL)
+      INITERROR;
+  struct module_state *st = GETSTATE(module);
+  
+  st->error = PyErr_NewException(MODNAME".Error", NULL, NULL);
+  if (st->error == NULL) {
+      Py_DECREF(module);
+      INITERROR;
+  }
+
+
+  typeRegistration(module);
+
+  #ifdef IS_PY3K
+    return module;
+  #endif
+}

PythonWrapper/cmsisdsp_pkg/src/cmsismodule.h

@@ -1,18334 +0,0 @@
-/* ----------------------------------------------------------------------
- * Project:      CMSIS DSP Python Wrapper
- * Title:        cmsismodule.h
- * Description:  C code for the CMSIS-DSP Python wrapper
- *
- * $Date:        27 April 2021
- * $Revision:    V1.0
- *
- * Target Processor: Cortex-M cores
- * -------------------------------------------------------------------- */
-/*
- * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
- *
- * SPDX-License-Identifier: Apache-2.0
- *
- * Licensed under the Apache License, Version 2.0 (the License); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-typedef struct {
-    PyObject_HEAD
-    arm_fir_instance_q7 *instance;
-} ml_arm_fir_instance_q7Object;
-
-
-static void
-arm_fir_instance_q7_dealloc(ml_arm_fir_instance_q7Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_fir_instance_q7_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_fir_instance_q7Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_fir_instance_q7Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_fir_instance_q7));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_fir_instance_q7_init(ml_arm_fir_instance_q7Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-char *kwlist[] = {
-"numTaps",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|h", kwlist,&self->instance->numTaps
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_fir_instance_q7,numTaps,"h");
-
-
-static PyMethodDef arm_fir_instance_q7_methods[] = {
-
-    {"numTaps", (PyCFunction) Method_arm_fir_instance_q7_numTaps,METH_NOARGS,"numTaps"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_fir_instance_q7,arm_fir_instance_q7_new,arm_fir_instance_q7_dealloc,arm_fir_instance_q7_init,arm_fir_instance_q7_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_fir_instance_q15 *instance;
-} ml_arm_fir_instance_q15Object;
-
-
-static void
-arm_fir_instance_q15_dealloc(ml_arm_fir_instance_q15Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_fir_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_fir_instance_q15Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_fir_instance_q15Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_fir_instance_q15));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_fir_instance_q15_init(ml_arm_fir_instance_q15Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-char *kwlist[] = {
-"numTaps",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|h", kwlist,&self->instance->numTaps
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_fir_instance_q15,numTaps,"h");
-
-
-static PyMethodDef arm_fir_instance_q15_methods[] = {
-
-    {"numTaps", (PyCFunction) Method_arm_fir_instance_q15_numTaps,METH_NOARGS,"numTaps"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_fir_instance_q15,arm_fir_instance_q15_new,arm_fir_instance_q15_dealloc,arm_fir_instance_q15_init,arm_fir_instance_q15_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_fir_instance_q31 *instance;
-} ml_arm_fir_instance_q31Object;
-
-
-static void
-arm_fir_instance_q31_dealloc(ml_arm_fir_instance_q31Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_fir_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_fir_instance_q31Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_fir_instance_q31Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_fir_instance_q31));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_fir_instance_q31_init(ml_arm_fir_instance_q31Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-char *kwlist[] = {
-"numTaps",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|h", kwlist,&self->instance->numTaps
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_fir_instance_q31,numTaps,"h");
-
-
-static PyMethodDef arm_fir_instance_q31_methods[] = {
-
-    {"numTaps", (PyCFunction) Method_arm_fir_instance_q31_numTaps,METH_NOARGS,"numTaps"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_fir_instance_q31,arm_fir_instance_q31_new,arm_fir_instance_q31_dealloc,arm_fir_instance_q31_init,arm_fir_instance_q31_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_fir_instance_f32 *instance;
-} ml_arm_fir_instance_f32Object;
-
-
-static void
-arm_fir_instance_f32_dealloc(ml_arm_fir_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_fir_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_fir_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_fir_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_fir_instance_f32));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_fir_instance_f32_init(ml_arm_fir_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-char *kwlist[] = {
-"numTaps",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|h", kwlist,&self->instance->numTaps
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_fir_instance_f32,numTaps,"h");
-
-
-static PyMethodDef arm_fir_instance_f32_methods[] = {
-
-    {"numTaps", (PyCFunction) Method_arm_fir_instance_f32_numTaps,METH_NOARGS,"numTaps"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_fir_instance_f32,arm_fir_instance_f32_new,arm_fir_instance_f32_dealloc,arm_fir_instance_f32_init,arm_fir_instance_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_biquad_casd_df1_inst_q15 *instance;
-} ml_arm_biquad_casd_df1_inst_q15Object;
-
-
-static void
-arm_biquad_casd_df1_inst_q15_dealloc(ml_arm_biquad_casd_df1_inst_q15Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_biquad_casd_df1_inst_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_biquad_casd_df1_inst_q15Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_biquad_casd_df1_inst_q15Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_biquad_casd_df1_inst_q15));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_biquad_casd_df1_inst_q15_init(ml_arm_biquad_casd_df1_inst_q15Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-char *kwlist[] = {
-"numStages","postShift",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|ii", kwlist,&self->instance->numStages
-,&self->instance->postShift
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_biquad_casd_df1_inst_q15,numStages,"i");
-GETFIELD(arm_biquad_casd_df1_inst_q15,postShift,"i");
-
-
-static PyMethodDef arm_biquad_casd_df1_inst_q15_methods[] = {
-
-    {"numStages", (PyCFunction) Method_arm_biquad_casd_df1_inst_q15_numStages,METH_NOARGS,"numStages"},
-    {"postShift", (PyCFunction) Method_arm_biquad_casd_df1_inst_q15_postShift,METH_NOARGS,"postShift"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_biquad_casd_df1_inst_q15,arm_biquad_casd_df1_inst_q15_new,arm_biquad_casd_df1_inst_q15_dealloc,arm_biquad_casd_df1_inst_q15_init,arm_biquad_casd_df1_inst_q15_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_biquad_casd_df1_inst_q31 *instance;
-} ml_arm_biquad_casd_df1_inst_q31Object;
-
-
-static void
-arm_biquad_casd_df1_inst_q31_dealloc(ml_arm_biquad_casd_df1_inst_q31Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_biquad_casd_df1_inst_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_biquad_casd_df1_inst_q31Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_biquad_casd_df1_inst_q31Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_biquad_casd_df1_inst_q31));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_biquad_casd_df1_inst_q31_init(ml_arm_biquad_casd_df1_inst_q31Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-char *kwlist[] = {
-"numStages","postShift",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|ii", kwlist,&self->instance->numStages
-,&self->instance->postShift
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_biquad_casd_df1_inst_q31,numStages,"i");
-GETFIELD(arm_biquad_casd_df1_inst_q31,postShift,"i");
-
-
-static PyMethodDef arm_biquad_casd_df1_inst_q31_methods[] = {
-
-    {"numStages", (PyCFunction) Method_arm_biquad_casd_df1_inst_q31_numStages,METH_NOARGS,"numStages"},
-    {"postShift", (PyCFunction) Method_arm_biquad_casd_df1_inst_q31_postShift,METH_NOARGS,"postShift"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_biquad_casd_df1_inst_q31,arm_biquad_casd_df1_inst_q31_new,arm_biquad_casd_df1_inst_q31_dealloc,arm_biquad_casd_df1_inst_q31_init,arm_biquad_casd_df1_inst_q31_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_biquad_casd_df1_inst_f32 *instance;
-} ml_arm_biquad_casd_df1_inst_f32Object;
-
-
-static void
-arm_biquad_casd_df1_inst_f32_dealloc(ml_arm_biquad_casd_df1_inst_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_biquad_casd_df1_inst_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_biquad_casd_df1_inst_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_biquad_casd_df1_inst_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_biquad_casd_df1_inst_f32));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_biquad_casd_df1_inst_f32_init(ml_arm_biquad_casd_df1_inst_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-char *kwlist[] = {
-"numStages",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|i", kwlist,&self->instance->numStages
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_biquad_casd_df1_inst_f32,numStages,"i");
-
-
-static PyMethodDef arm_biquad_casd_df1_inst_f32_methods[] = {
-
-    {"numStages", (PyCFunction) Method_arm_biquad_casd_df1_inst_f32_numStages,METH_NOARGS,"numStages"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_biquad_casd_df1_inst_f32,arm_biquad_casd_df1_inst_f32_new,arm_biquad_casd_df1_inst_f32_dealloc,arm_biquad_casd_df1_inst_f32_init,arm_biquad_casd_df1_inst_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_matrix_instance_f32 *instance;
-} ml_arm_matrix_instance_f32Object;
-
-
-static void
-arm_matrix_instance_f32_dealloc(ml_arm_matrix_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pData)
-       {
-          PyMem_Free(self->instance->pData);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_matrix_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_matrix_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_matrix_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_matrix_instance_f32));
-
-        self->instance->pData = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_matrix_instance_f32_init(ml_arm_matrix_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pData=NULL;
-char *kwlist[] = {
-"numRows","numCols","pData",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhO", kwlist,&self->instance->numRows
-,&self->instance->numCols
-,&pData
-))
-    {
-
-    INITARRAYFIELD(pData,NPY_DOUBLE,double,float32_t);
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_matrix_instance_f32,numRows,"h");
-GETFIELD(arm_matrix_instance_f32,numCols,"h");
-
-
-static PyMethodDef arm_matrix_instance_f32_methods[] = {
-
-    {"numRows", (PyCFunction) Method_arm_matrix_instance_f32_numRows,METH_NOARGS,"numRows"},
-    {"numCols", (PyCFunction) Method_arm_matrix_instance_f32_numCols,METH_NOARGS,"numCols"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_matrix_instance_f32,arm_matrix_instance_f32_new,arm_matrix_instance_f32_dealloc,arm_matrix_instance_f32_init,arm_matrix_instance_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_matrix_instance_f64 *instance;
-} ml_arm_matrix_instance_f64Object;
-
-
-static void
-arm_matrix_instance_f64_dealloc(ml_arm_matrix_instance_f64Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pData)
-       {
-          PyMem_Free(self->instance->pData);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_matrix_instance_f64_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_matrix_instance_f64Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_matrix_instance_f64Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_matrix_instance_f64));
-
-        self->instance->pData = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_matrix_instance_f64_init(ml_arm_matrix_instance_f64Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pData=NULL;
-char *kwlist[] = {
-"numRows","numCols","pData",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhO", kwlist,&self->instance->numRows
-,&self->instance->numCols
-,&pData
-))
-    {
-
-    INITARRAYFIELD(pData,NPY_FLOAT64,float64_t,float64_t);
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_matrix_instance_f64,numRows,"h");
-GETFIELD(arm_matrix_instance_f64,numCols,"h");
-
-
-static PyMethodDef arm_matrix_instance_f64_methods[] = {
-
-    {"numRows", (PyCFunction) Method_arm_matrix_instance_f64_numRows,METH_NOARGS,"numRows"},
-    {"numCols", (PyCFunction) Method_arm_matrix_instance_f64_numCols,METH_NOARGS,"numCols"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_matrix_instance_f64,arm_matrix_instance_f64_new,arm_matrix_instance_f64_dealloc,arm_matrix_instance_f64_init,arm_matrix_instance_f64_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_matrix_instance_q15 *instance;
-} ml_arm_matrix_instance_q15Object;
-
-
-static void
-arm_matrix_instance_q15_dealloc(ml_arm_matrix_instance_q15Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pData)
-       {
-          PyMem_Free(self->instance->pData);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_matrix_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_matrix_instance_q15Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_matrix_instance_q15Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_matrix_instance_q15));
-
-        self->instance->pData = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_matrix_instance_q15_init(ml_arm_matrix_instance_q15Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pData=NULL;
-char *kwlist[] = {
-"numRows","numCols","pData",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhO", kwlist,&self->instance->numRows
-,&self->instance->numCols
-,&pData
-))
-    {
-
-    INITARRAYFIELD(pData,NPY_INT16,int16_t,int16_t);
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_matrix_instance_q15,numRows,"h");
-GETFIELD(arm_matrix_instance_q15,numCols,"h");
-
-
-static PyMethodDef arm_matrix_instance_q15_methods[] = {
-
-    {"numRows", (PyCFunction) Method_arm_matrix_instance_q15_numRows,METH_NOARGS,"numRows"},
-    {"numCols", (PyCFunction) Method_arm_matrix_instance_q15_numCols,METH_NOARGS,"numCols"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_matrix_instance_q15,arm_matrix_instance_q15_new,arm_matrix_instance_q15_dealloc,arm_matrix_instance_q15_init,arm_matrix_instance_q15_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_matrix_instance_q31 *instance;
-} ml_arm_matrix_instance_q31Object;
-
-
-static void
-arm_matrix_instance_q31_dealloc(ml_arm_matrix_instance_q31Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pData)
-       {
-          PyMem_Free(self->instance->pData);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_matrix_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_matrix_instance_q31Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_matrix_instance_q31Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_matrix_instance_q31));
-
-        self->instance->pData = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_matrix_instance_q31_init(ml_arm_matrix_instance_q31Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pData=NULL;
-char *kwlist[] = {
-"numRows","numCols","pData",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhO", kwlist,&self->instance->numRows
-,&self->instance->numCols
-,&pData
-))
-    {
-
-    INITARRAYFIELD(pData,NPY_INT32,int32_t,int32_t);
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_matrix_instance_q31,numRows,"h");
-GETFIELD(arm_matrix_instance_q31,numCols,"h");
-
-
-static PyMethodDef arm_matrix_instance_q31_methods[] = {
-
-    {"numRows", (PyCFunction) Method_arm_matrix_instance_q31_numRows,METH_NOARGS,"numRows"},
-    {"numCols", (PyCFunction) Method_arm_matrix_instance_q31_numCols,METH_NOARGS,"numCols"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_matrix_instance_q31,arm_matrix_instance_q31_new,arm_matrix_instance_q31_dealloc,arm_matrix_instance_q31_init,arm_matrix_instance_q31_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_pid_instance_q15 *instance;
-} ml_arm_pid_instance_q15Object;
-
-
-static void
-arm_pid_instance_q15_dealloc(ml_arm_pid_instance_q15Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_pid_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_pid_instance_q15Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_pid_instance_q15Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_pid_instance_q15));
-
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_pid_instance_q15_init(ml_arm_pid_instance_q15Object *self, PyObject *args, PyObject *kwds)
-{
-
-char *kwlist[] = {
-"A0","A1","A2","state","Kp","Ki","Kd",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhhhhhh", kwlist,&self->instance->A0
-,&self->instance->A1
-,&self->instance->A2
-,&self->instance->state
-,&self->instance->Kp
-,&self->instance->Ki
-,&self->instance->Kd
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_pid_instance_q15,A0,"h");
-GETFIELD(arm_pid_instance_q15,A1,"h");
-GETFIELD(arm_pid_instance_q15,A2,"h");
-GETFIELD(arm_pid_instance_q15,state,"h");
-GETFIELD(arm_pid_instance_q15,Kp,"h");
-GETFIELD(arm_pid_instance_q15,Ki,"h");
-GETFIELD(arm_pid_instance_q15,Kd,"h");
-
-
-static PyMethodDef arm_pid_instance_q15_methods[] = {
-
-    {"A0", (PyCFunction) Method_arm_pid_instance_q15_A0,METH_NOARGS,"A0"},
-    {"A1", (PyCFunction) Method_arm_pid_instance_q15_A1,METH_NOARGS,"A1"},
-    {"A2", (PyCFunction) Method_arm_pid_instance_q15_A2,METH_NOARGS,"A2"},
-    {"state", (PyCFunction) Method_arm_pid_instance_q15_state,METH_NOARGS,"state"},
-    {"Kp", (PyCFunction) Method_arm_pid_instance_q15_Kp,METH_NOARGS,"Kp"},
-    {"Ki", (PyCFunction) Method_arm_pid_instance_q15_Ki,METH_NOARGS,"Ki"},
-    {"Kd", (PyCFunction) Method_arm_pid_instance_q15_Kd,METH_NOARGS,"Kd"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_pid_instance_q15,arm_pid_instance_q15_new,arm_pid_instance_q15_dealloc,arm_pid_instance_q15_init,arm_pid_instance_q15_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_pid_instance_q31 *instance;
-} ml_arm_pid_instance_q31Object;
-
-
-static void
-arm_pid_instance_q31_dealloc(ml_arm_pid_instance_q31Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_pid_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_pid_instance_q31Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_pid_instance_q31Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_pid_instance_q31));
-
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_pid_instance_q31_init(ml_arm_pid_instance_q31Object *self, PyObject *args, PyObject *kwds)
-{
-
-char *kwlist[] = {
-"A0","A1","A2","state","Kp","Ki","Kd",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|iiiiiii", kwlist,&self->instance->A0
-,&self->instance->A1
-,&self->instance->A2
-,&self->instance->state
-,&self->instance->Kp
-,&self->instance->Ki
-,&self->instance->Kd
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_pid_instance_q31,A0,"i");
-GETFIELD(arm_pid_instance_q31,A1,"i");
-GETFIELD(arm_pid_instance_q31,A2,"i");
-GETFIELD(arm_pid_instance_q31,state,"i");
-GETFIELD(arm_pid_instance_q31,Kp,"i");
-GETFIELD(arm_pid_instance_q31,Ki,"i");
-GETFIELD(arm_pid_instance_q31,Kd,"i");
-
-
-static PyMethodDef arm_pid_instance_q31_methods[] = {
-
-    {"A0", (PyCFunction) Method_arm_pid_instance_q31_A0,METH_NOARGS,"A0"},
-    {"A1", (PyCFunction) Method_arm_pid_instance_q31_A1,METH_NOARGS,"A1"},
-    {"A2", (PyCFunction) Method_arm_pid_instance_q31_A2,METH_NOARGS,"A2"},
-    {"state", (PyCFunction) Method_arm_pid_instance_q31_state,METH_NOARGS,"state"},
-    {"Kp", (PyCFunction) Method_arm_pid_instance_q31_Kp,METH_NOARGS,"Kp"},
-    {"Ki", (PyCFunction) Method_arm_pid_instance_q31_Ki,METH_NOARGS,"Ki"},
-    {"Kd", (PyCFunction) Method_arm_pid_instance_q31_Kd,METH_NOARGS,"Kd"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_pid_instance_q31,arm_pid_instance_q31_new,arm_pid_instance_q31_dealloc,arm_pid_instance_q31_init,arm_pid_instance_q31_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_pid_instance_f32 *instance;
-} ml_arm_pid_instance_f32Object;
-
-
-static void
-arm_pid_instance_f32_dealloc(ml_arm_pid_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_pid_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_pid_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_pid_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_pid_instance_f32));
-
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_pid_instance_f32_init(ml_arm_pid_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-char *kwlist[] = {
-"A0","A1","A2","state","Kp","Ki","Kd",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|fffffff", kwlist,&self->instance->A0
-,&self->instance->A1
-,&self->instance->A2
-,&self->instance->state
-,&self->instance->Kp
-,&self->instance->Ki
-,&self->instance->Kd
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_pid_instance_f32,A0,"f");
-GETFIELD(arm_pid_instance_f32,A1,"f");
-GETFIELD(arm_pid_instance_f32,A2,"f");
-GETFIELD(arm_pid_instance_f32,state,"f");
-GETFIELD(arm_pid_instance_f32,Kp,"f");
-GETFIELD(arm_pid_instance_f32,Ki,"f");
-GETFIELD(arm_pid_instance_f32,Kd,"f");
-
-
-static PyMethodDef arm_pid_instance_f32_methods[] = {
-
-    {"A0", (PyCFunction) Method_arm_pid_instance_f32_A0,METH_NOARGS,"A0"},
-    {"A1", (PyCFunction) Method_arm_pid_instance_f32_A1,METH_NOARGS,"A1"},
-    {"A2", (PyCFunction) Method_arm_pid_instance_f32_A2,METH_NOARGS,"A2"},
-    {"state", (PyCFunction) Method_arm_pid_instance_f32_state,METH_NOARGS,"state"},
-    {"Kp", (PyCFunction) Method_arm_pid_instance_f32_Kp,METH_NOARGS,"Kp"},
-    {"Ki", (PyCFunction) Method_arm_pid_instance_f32_Ki,METH_NOARGS,"Ki"},
-    {"Kd", (PyCFunction) Method_arm_pid_instance_f32_Kd,METH_NOARGS,"Kd"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_pid_instance_f32,arm_pid_instance_f32_new,arm_pid_instance_f32_dealloc,arm_pid_instance_f32_init,arm_pid_instance_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_linear_interp_instance_f32 *instance;
-} ml_arm_linear_interp_instance_f32Object;
-
-
-static void
-arm_linear_interp_instance_f32_dealloc(ml_arm_linear_interp_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pYData)
-       {
-          PyMem_Free(self->instance->pYData);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_linear_interp_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_linear_interp_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_linear_interp_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_linear_interp_instance_f32));
-
-        self->instance->pYData = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_linear_interp_instance_f32_init(ml_arm_linear_interp_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pYData=NULL;
-char *kwlist[] = {
-"nValues","x1","xSpacing","pYData",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|iffO", kwlist,&self->instance->nValues
-,&self->instance->x1
-,&self->instance->xSpacing
-,&pYData
-))
-    {
-
-    INITARRAYFIELD(pYData,NPY_DOUBLE,double,float32_t);
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_linear_interp_instance_f32,nValues,"i");
-GETFIELD(arm_linear_interp_instance_f32,x1,"f");
-GETFIELD(arm_linear_interp_instance_f32,xSpacing,"f");
-
-
-static PyMethodDef arm_linear_interp_instance_f32_methods[] = {
-
-    {"nValues", (PyCFunction) Method_arm_linear_interp_instance_f32_nValues,METH_NOARGS,"nValues"},
-    {"x1", (PyCFunction) Method_arm_linear_interp_instance_f32_x1,METH_NOARGS,"x1"},
-    {"xSpacing", (PyCFunction) Method_arm_linear_interp_instance_f32_xSpacing,METH_NOARGS,"xSpacing"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_linear_interp_instance_f32,arm_linear_interp_instance_f32_new,arm_linear_interp_instance_f32_dealloc,arm_linear_interp_instance_f32_init,arm_linear_interp_instance_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_bilinear_interp_instance_f32 *instance;
-} ml_arm_bilinear_interp_instance_f32Object;
-
-
-static void
-arm_bilinear_interp_instance_f32_dealloc(ml_arm_bilinear_interp_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pData)
-       {
-          PyMem_Free(self->instance->pData);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_bilinear_interp_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_bilinear_interp_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_bilinear_interp_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_bilinear_interp_instance_f32));
-
-        self->instance->pData = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_bilinear_interp_instance_f32_init(ml_arm_bilinear_interp_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pData=NULL;
-char *kwlist[] = {
-"numRows","numCols","pData",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhO", kwlist,&self->instance->numRows
-,&self->instance->numCols
-,&pData
-))
-    {
-
-    INITARRAYFIELD(pData,NPY_DOUBLE,double,float32_t);
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_bilinear_interp_instance_f32,numRows,"h");
-GETFIELD(arm_bilinear_interp_instance_f32,numCols,"h");
-
-
-static PyMethodDef arm_bilinear_interp_instance_f32_methods[] = {
-
-    {"numRows", (PyCFunction) Method_arm_bilinear_interp_instance_f32_numRows,METH_NOARGS,"numRows"},
-    {"numCols", (PyCFunction) Method_arm_bilinear_interp_instance_f32_numCols,METH_NOARGS,"numCols"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_bilinear_interp_instance_f32,arm_bilinear_interp_instance_f32_new,arm_bilinear_interp_instance_f32_dealloc,arm_bilinear_interp_instance_f32_init,arm_bilinear_interp_instance_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_bilinear_interp_instance_q31 *instance;
-} ml_arm_bilinear_interp_instance_q31Object;
-
-
-static void
-arm_bilinear_interp_instance_q31_dealloc(ml_arm_bilinear_interp_instance_q31Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pData)
-       {
-          PyMem_Free(self->instance->pData);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_bilinear_interp_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_bilinear_interp_instance_q31Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_bilinear_interp_instance_q31Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_bilinear_interp_instance_q31));
-
-        self->instance->pData = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_bilinear_interp_instance_q31_init(ml_arm_bilinear_interp_instance_q31Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pData=NULL;
-char *kwlist[] = {
-"numRows","numCols","pData",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhO", kwlist,&self->instance->numRows
-,&self->instance->numCols
-,&pData
-))
-    {
-
-    INITARRAYFIELD(pData,NPY_INT32,int32_t,int32_t);
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_bilinear_interp_instance_q31,numRows,"h");
-GETFIELD(arm_bilinear_interp_instance_q31,numCols,"h");
-
-
-static PyMethodDef arm_bilinear_interp_instance_q31_methods[] = {
-
-    {"numRows", (PyCFunction) Method_arm_bilinear_interp_instance_q31_numRows,METH_NOARGS,"numRows"},
-    {"numCols", (PyCFunction) Method_arm_bilinear_interp_instance_q31_numCols,METH_NOARGS,"numCols"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_bilinear_interp_instance_q31,arm_bilinear_interp_instance_q31_new,arm_bilinear_interp_instance_q31_dealloc,arm_bilinear_interp_instance_q31_init,arm_bilinear_interp_instance_q31_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_bilinear_interp_instance_q15 *instance;
-} ml_arm_bilinear_interp_instance_q15Object;
-
-
-static void
-arm_bilinear_interp_instance_q15_dealloc(ml_arm_bilinear_interp_instance_q15Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pData)
-       {
-          PyMem_Free(self->instance->pData);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_bilinear_interp_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_bilinear_interp_instance_q15Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_bilinear_interp_instance_q15Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_bilinear_interp_instance_q15));
-
-        self->instance->pData = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_bilinear_interp_instance_q15_init(ml_arm_bilinear_interp_instance_q15Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pData=NULL;
-char *kwlist[] = {
-"numRows","numCols","pData",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhO", kwlist,&self->instance->numRows
-,&self->instance->numCols
-,&pData
-))
-    {
-
-    INITARRAYFIELD(pData,NPY_INT16,int16_t,int16_t);
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_bilinear_interp_instance_q15,numRows,"h");
-GETFIELD(arm_bilinear_interp_instance_q15,numCols,"h");
-
-
-static PyMethodDef arm_bilinear_interp_instance_q15_methods[] = {
-
-    {"numRows", (PyCFunction) Method_arm_bilinear_interp_instance_q15_numRows,METH_NOARGS,"numRows"},
-    {"numCols", (PyCFunction) Method_arm_bilinear_interp_instance_q15_numCols,METH_NOARGS,"numCols"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_bilinear_interp_instance_q15,arm_bilinear_interp_instance_q15_new,arm_bilinear_interp_instance_q15_dealloc,arm_bilinear_interp_instance_q15_init,arm_bilinear_interp_instance_q15_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_bilinear_interp_instance_q7 *instance;
-} ml_arm_bilinear_interp_instance_q7Object;
-
-
-static void
-arm_bilinear_interp_instance_q7_dealloc(ml_arm_bilinear_interp_instance_q7Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pData)
-       {
-          PyMem_Free(self->instance->pData);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_bilinear_interp_instance_q7_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_bilinear_interp_instance_q7Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_bilinear_interp_instance_q7Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_bilinear_interp_instance_q7));
-
-        self->instance->pData = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_bilinear_interp_instance_q7_init(ml_arm_bilinear_interp_instance_q7Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pData=NULL;
-char *kwlist[] = {
-"numRows","numCols","pData",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhO", kwlist,&self->instance->numRows
-,&self->instance->numCols
-,&pData
-))
-    {
-
-    INITARRAYFIELD(pData,NPY_BYTE,int8_t,q7_t);
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_bilinear_interp_instance_q7,numRows,"h");
-GETFIELD(arm_bilinear_interp_instance_q7,numCols,"h");
-
-
-static PyMethodDef arm_bilinear_interp_instance_q7_methods[] = {
-
-    {"numRows", (PyCFunction) Method_arm_bilinear_interp_instance_q7_numRows,METH_NOARGS,"numRows"},
-    {"numCols", (PyCFunction) Method_arm_bilinear_interp_instance_q7_numCols,METH_NOARGS,"numCols"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_bilinear_interp_instance_q7,arm_bilinear_interp_instance_q7_new,arm_bilinear_interp_instance_q7_dealloc,arm_bilinear_interp_instance_q7_init,arm_bilinear_interp_instance_q7_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_cfft_radix2_instance_q15 *instance;
-} ml_arm_cfft_radix2_instance_q15Object;
-
-
-static void
-arm_cfft_radix2_instance_q15_dealloc(ml_arm_cfft_radix2_instance_q15Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_cfft_radix2_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_cfft_radix2_instance_q15Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_cfft_radix2_instance_q15Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_cfft_radix2_instance_q15));
-
-        self->instance->pTwiddle = NULL;
-        self->instance->pBitRevTable = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_cfft_radix2_instance_q15_init(ml_arm_cfft_radix2_instance_q15Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddle=NULL;
-    PyObject *pBitRevTable=NULL;
-char *kwlist[] = {
-"fftLen","ifftFlag","bitReverseFlag","twidCoefModifier","bitRevFactor",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hiihh", kwlist,&self->instance->fftLen
-,&self->instance->ifftFlag
-,&self->instance->bitReverseFlag
-,&self->instance->twidCoefModifier
-,&self->instance->bitRevFactor
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_cfft_radix2_instance_q15,fftLen,"h");
-GETFIELD(arm_cfft_radix2_instance_q15,ifftFlag,"i");
-GETFIELD(arm_cfft_radix2_instance_q15,bitReverseFlag,"i");
-GETFIELD(arm_cfft_radix2_instance_q15,twidCoefModifier,"h");
-GETFIELD(arm_cfft_radix2_instance_q15,bitRevFactor,"h");
-
-
-static PyMethodDef arm_cfft_radix2_instance_q15_methods[] = {
-
-    {"fftLen", (PyCFunction) Method_arm_cfft_radix2_instance_q15_fftLen,METH_NOARGS,"fftLen"},
-    {"ifftFlag", (PyCFunction) Method_arm_cfft_radix2_instance_q15_ifftFlag,METH_NOARGS,"ifftFlag"},
-    {"bitReverseFlag", (PyCFunction) Method_arm_cfft_radix2_instance_q15_bitReverseFlag,METH_NOARGS,"bitReverseFlag"},
-    {"twidCoefModifier", (PyCFunction) Method_arm_cfft_radix2_instance_q15_twidCoefModifier,METH_NOARGS,"twidCoefModifier"},
-    {"bitRevFactor", (PyCFunction) Method_arm_cfft_radix2_instance_q15_bitRevFactor,METH_NOARGS,"bitRevFactor"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_cfft_radix2_instance_q15,arm_cfft_radix2_instance_q15_new,arm_cfft_radix2_instance_q15_dealloc,arm_cfft_radix2_instance_q15_init,arm_cfft_radix2_instance_q15_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_cfft_radix4_instance_q15 *instance;
-} ml_arm_cfft_radix4_instance_q15Object;
-
-
-static void
-arm_cfft_radix4_instance_q15_dealloc(ml_arm_cfft_radix4_instance_q15Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_cfft_radix4_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_cfft_radix4_instance_q15Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_cfft_radix4_instance_q15Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_cfft_radix4_instance_q15));
-
-        self->instance->pTwiddle = NULL;
-        self->instance->pBitRevTable = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_cfft_radix4_instance_q15_init(ml_arm_cfft_radix4_instance_q15Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddle=NULL;
-    PyObject *pBitRevTable=NULL;
-char *kwlist[] = {
-"fftLen","ifftFlag","bitReverseFlag","twidCoefModifier","bitRevFactor",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hiihh", kwlist,&self->instance->fftLen
-,&self->instance->ifftFlag
-,&self->instance->bitReverseFlag
-,&self->instance->twidCoefModifier
-,&self->instance->bitRevFactor
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_cfft_radix4_instance_q15,fftLen,"h");
-GETFIELD(arm_cfft_radix4_instance_q15,ifftFlag,"i");
-GETFIELD(arm_cfft_radix4_instance_q15,bitReverseFlag,"i");
-GETFIELD(arm_cfft_radix4_instance_q15,twidCoefModifier,"h");
-GETFIELD(arm_cfft_radix4_instance_q15,bitRevFactor,"h");
-
-
-static PyMethodDef arm_cfft_radix4_instance_q15_methods[] = {
-
-    {"fftLen", (PyCFunction) Method_arm_cfft_radix4_instance_q15_fftLen,METH_NOARGS,"fftLen"},
-    {"ifftFlag", (PyCFunction) Method_arm_cfft_radix4_instance_q15_ifftFlag,METH_NOARGS,"ifftFlag"},
-    {"bitReverseFlag", (PyCFunction) Method_arm_cfft_radix4_instance_q15_bitReverseFlag,METH_NOARGS,"bitReverseFlag"},
-    {"twidCoefModifier", (PyCFunction) Method_arm_cfft_radix4_instance_q15_twidCoefModifier,METH_NOARGS,"twidCoefModifier"},
-    {"bitRevFactor", (PyCFunction) Method_arm_cfft_radix4_instance_q15_bitRevFactor,METH_NOARGS,"bitRevFactor"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_cfft_radix4_instance_q15,arm_cfft_radix4_instance_q15_new,arm_cfft_radix4_instance_q15_dealloc,arm_cfft_radix4_instance_q15_init,arm_cfft_radix4_instance_q15_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_cfft_radix2_instance_q31 *instance;
-} ml_arm_cfft_radix2_instance_q31Object;
-
-
-static void
-arm_cfft_radix2_instance_q31_dealloc(ml_arm_cfft_radix2_instance_q31Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_cfft_radix2_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_cfft_radix2_instance_q31Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_cfft_radix2_instance_q31Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_cfft_radix2_instance_q31));
-
-        self->instance->pTwiddle = NULL;
-        self->instance->pBitRevTable = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_cfft_radix2_instance_q31_init(ml_arm_cfft_radix2_instance_q31Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddle=NULL;
-    PyObject *pBitRevTable=NULL;
-char *kwlist[] = {
-"fftLen","ifftFlag","bitReverseFlag","twidCoefModifier","bitRevFactor",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hiihh", kwlist,&self->instance->fftLen
-,&self->instance->ifftFlag
-,&self->instance->bitReverseFlag
-,&self->instance->twidCoefModifier
-,&self->instance->bitRevFactor
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_cfft_radix2_instance_q31,fftLen,"h");
-GETFIELD(arm_cfft_radix2_instance_q31,ifftFlag,"i");
-GETFIELD(arm_cfft_radix2_instance_q31,bitReverseFlag,"i");
-GETFIELD(arm_cfft_radix2_instance_q31,twidCoefModifier,"h");
-GETFIELD(arm_cfft_radix2_instance_q31,bitRevFactor,"h");
-
-
-static PyMethodDef arm_cfft_radix2_instance_q31_methods[] = {
-
-    {"fftLen", (PyCFunction) Method_arm_cfft_radix2_instance_q31_fftLen,METH_NOARGS,"fftLen"},
-    {"ifftFlag", (PyCFunction) Method_arm_cfft_radix2_instance_q31_ifftFlag,METH_NOARGS,"ifftFlag"},
-    {"bitReverseFlag", (PyCFunction) Method_arm_cfft_radix2_instance_q31_bitReverseFlag,METH_NOARGS,"bitReverseFlag"},
-    {"twidCoefModifier", (PyCFunction) Method_arm_cfft_radix2_instance_q31_twidCoefModifier,METH_NOARGS,"twidCoefModifier"},
-    {"bitRevFactor", (PyCFunction) Method_arm_cfft_radix2_instance_q31_bitRevFactor,METH_NOARGS,"bitRevFactor"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_cfft_radix2_instance_q31,arm_cfft_radix2_instance_q31_new,arm_cfft_radix2_instance_q31_dealloc,arm_cfft_radix2_instance_q31_init,arm_cfft_radix2_instance_q31_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_cfft_radix4_instance_q31 *instance;
-} ml_arm_cfft_radix4_instance_q31Object;
-
-
-static void
-arm_cfft_radix4_instance_q31_dealloc(ml_arm_cfft_radix4_instance_q31Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_cfft_radix4_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_cfft_radix4_instance_q31Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_cfft_radix4_instance_q31Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_cfft_radix4_instance_q31));
-
-        self->instance->pTwiddle = NULL;
-        self->instance->pBitRevTable = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_cfft_radix4_instance_q31_init(ml_arm_cfft_radix4_instance_q31Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddle=NULL;
-    PyObject *pBitRevTable=NULL;
-char *kwlist[] = {
-"fftLen","ifftFlag","bitReverseFlag","twidCoefModifier","bitRevFactor",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hiihh", kwlist,&self->instance->fftLen
-,&self->instance->ifftFlag
-,&self->instance->bitReverseFlag
-,&self->instance->twidCoefModifier
-,&self->instance->bitRevFactor
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_cfft_radix4_instance_q31,fftLen,"h");
-GETFIELD(arm_cfft_radix4_instance_q31,ifftFlag,"i");
-GETFIELD(arm_cfft_radix4_instance_q31,bitReverseFlag,"i");
-GETFIELD(arm_cfft_radix4_instance_q31,twidCoefModifier,"h");
-GETFIELD(arm_cfft_radix4_instance_q31,bitRevFactor,"h");
-
-
-static PyMethodDef arm_cfft_radix4_instance_q31_methods[] = {
-
-    {"fftLen", (PyCFunction) Method_arm_cfft_radix4_instance_q31_fftLen,METH_NOARGS,"fftLen"},
-    {"ifftFlag", (PyCFunction) Method_arm_cfft_radix4_instance_q31_ifftFlag,METH_NOARGS,"ifftFlag"},
-    {"bitReverseFlag", (PyCFunction) Method_arm_cfft_radix4_instance_q31_bitReverseFlag,METH_NOARGS,"bitReverseFlag"},
-    {"twidCoefModifier", (PyCFunction) Method_arm_cfft_radix4_instance_q31_twidCoefModifier,METH_NOARGS,"twidCoefModifier"},
-    {"bitRevFactor", (PyCFunction) Method_arm_cfft_radix4_instance_q31_bitRevFactor,METH_NOARGS,"bitRevFactor"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_cfft_radix4_instance_q31,arm_cfft_radix4_instance_q31_new,arm_cfft_radix4_instance_q31_dealloc,arm_cfft_radix4_instance_q31_init,arm_cfft_radix4_instance_q31_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_cfft_radix2_instance_f32 *instance;
-} ml_arm_cfft_radix2_instance_f32Object;
-
-
-static void
-arm_cfft_radix2_instance_f32_dealloc(ml_arm_cfft_radix2_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_cfft_radix2_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_cfft_radix2_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_cfft_radix2_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_cfft_radix2_instance_f32));
-
-        self->instance->pTwiddle = NULL;
-        self->instance->pBitRevTable = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_cfft_radix2_instance_f32_init(ml_arm_cfft_radix2_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddle=NULL;
-    PyObject *pBitRevTable=NULL;
-char *kwlist[] = {
-"fftLen","ifftFlag","bitReverseFlag","twidCoefModifier","bitRevFactor","onebyfftLen",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hiihhf", kwlist,&self->instance->fftLen
-,&self->instance->ifftFlag
-,&self->instance->bitReverseFlag
-,&self->instance->twidCoefModifier
-,&self->instance->bitRevFactor
-,&self->instance->onebyfftLen
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_cfft_radix2_instance_f32,fftLen,"h");
-GETFIELD(arm_cfft_radix2_instance_f32,ifftFlag,"i");
-GETFIELD(arm_cfft_radix2_instance_f32,bitReverseFlag,"i");
-GETFIELD(arm_cfft_radix2_instance_f32,twidCoefModifier,"h");
-GETFIELD(arm_cfft_radix2_instance_f32,bitRevFactor,"h");
-GETFIELD(arm_cfft_radix2_instance_f32,onebyfftLen,"f");
-
-
-static PyMethodDef arm_cfft_radix2_instance_f32_methods[] = {
-
-    {"fftLen", (PyCFunction) Method_arm_cfft_radix2_instance_f32_fftLen,METH_NOARGS,"fftLen"},
-    {"ifftFlag", (PyCFunction) Method_arm_cfft_radix2_instance_f32_ifftFlag,METH_NOARGS,"ifftFlag"},
-    {"bitReverseFlag", (PyCFunction) Method_arm_cfft_radix2_instance_f32_bitReverseFlag,METH_NOARGS,"bitReverseFlag"},
-    {"twidCoefModifier", (PyCFunction) Method_arm_cfft_radix2_instance_f32_twidCoefModifier,METH_NOARGS,"twidCoefModifier"},
-    {"bitRevFactor", (PyCFunction) Method_arm_cfft_radix2_instance_f32_bitRevFactor,METH_NOARGS,"bitRevFactor"},
-    {"onebyfftLen", (PyCFunction) Method_arm_cfft_radix2_instance_f32_onebyfftLen,METH_NOARGS,"onebyfftLen"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_cfft_radix2_instance_f32,arm_cfft_radix2_instance_f32_new,arm_cfft_radix2_instance_f32_dealloc,arm_cfft_radix2_instance_f32_init,arm_cfft_radix2_instance_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_cfft_radix4_instance_f32 *instance;
-} ml_arm_cfft_radix4_instance_f32Object;
-
-
-static void
-arm_cfft_radix4_instance_f32_dealloc(ml_arm_cfft_radix4_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_cfft_radix4_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_cfft_radix4_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_cfft_radix4_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_cfft_radix4_instance_f32));
-
-        self->instance->pTwiddle = NULL;
-        self->instance->pBitRevTable = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_cfft_radix4_instance_f32_init(ml_arm_cfft_radix4_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddle=NULL;
-    PyObject *pBitRevTable=NULL;
-char *kwlist[] = {
-"fftLen","ifftFlag","bitReverseFlag","twidCoefModifier","bitRevFactor","onebyfftLen",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hiihhf", kwlist,&self->instance->fftLen
-,&self->instance->ifftFlag
-,&self->instance->bitReverseFlag
-,&self->instance->twidCoefModifier
-,&self->instance->bitRevFactor
-,&self->instance->onebyfftLen
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_cfft_radix4_instance_f32,fftLen,"h");
-GETFIELD(arm_cfft_radix4_instance_f32,ifftFlag,"i");
-GETFIELD(arm_cfft_radix4_instance_f32,bitReverseFlag,"i");
-GETFIELD(arm_cfft_radix4_instance_f32,twidCoefModifier,"h");
-GETFIELD(arm_cfft_radix4_instance_f32,bitRevFactor,"h");
-GETFIELD(arm_cfft_radix4_instance_f32,onebyfftLen,"f");
-
-
-static PyMethodDef arm_cfft_radix4_instance_f32_methods[] = {
-
-    {"fftLen", (PyCFunction) Method_arm_cfft_radix4_instance_f32_fftLen,METH_NOARGS,"fftLen"},
-    {"ifftFlag", (PyCFunction) Method_arm_cfft_radix4_instance_f32_ifftFlag,METH_NOARGS,"ifftFlag"},
-    {"bitReverseFlag", (PyCFunction) Method_arm_cfft_radix4_instance_f32_bitReverseFlag,METH_NOARGS,"bitReverseFlag"},
-    {"twidCoefModifier", (PyCFunction) Method_arm_cfft_radix4_instance_f32_twidCoefModifier,METH_NOARGS,"twidCoefModifier"},
-    {"bitRevFactor", (PyCFunction) Method_arm_cfft_radix4_instance_f32_bitRevFactor,METH_NOARGS,"bitRevFactor"},
-    {"onebyfftLen", (PyCFunction) Method_arm_cfft_radix4_instance_f32_onebyfftLen,METH_NOARGS,"onebyfftLen"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_cfft_radix4_instance_f32,arm_cfft_radix4_instance_f32_new,arm_cfft_radix4_instance_f32_dealloc,arm_cfft_radix4_instance_f32_init,arm_cfft_radix4_instance_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_cfft_instance_q15 *instance;
-} ml_arm_cfft_instance_q15Object;
-
-
-static void
-arm_cfft_instance_q15_dealloc(ml_arm_cfft_instance_q15Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_cfft_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_cfft_instance_q15Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_cfft_instance_q15Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_cfft_instance_q15));
-
-        self->instance->pTwiddle = NULL;
-        self->instance->pBitRevTable = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_cfft_instance_q15_init(ml_arm_cfft_instance_q15Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddle=NULL;
-    PyObject *pBitRevTable=NULL;
-char *kwlist[] = {
-"fftLen","bitRevLength",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hh", kwlist,&self->instance->fftLen
-,&self->instance->bitRevLength
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_cfft_instance_q15,fftLen,"h");
-GETFIELD(arm_cfft_instance_q15,bitRevLength,"h");
-
-
-static PyMethodDef arm_cfft_instance_q15_methods[] = {
-
-    {"fftLen", (PyCFunction) Method_arm_cfft_instance_q15_fftLen,METH_NOARGS,"fftLen"},
-    {"bitRevLength", (PyCFunction) Method_arm_cfft_instance_q15_bitRevLength,METH_NOARGS,"bitRevLength"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_cfft_instance_q15,arm_cfft_instance_q15_new,arm_cfft_instance_q15_dealloc,arm_cfft_instance_q15_init,arm_cfft_instance_q15_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_cfft_instance_q31 *instance;
-} ml_arm_cfft_instance_q31Object;
-
-
-static void
-arm_cfft_instance_q31_dealloc(ml_arm_cfft_instance_q31Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_cfft_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_cfft_instance_q31Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_cfft_instance_q31Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_cfft_instance_q31));
-
-        self->instance->pTwiddle = NULL;
-        self->instance->pBitRevTable = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_cfft_instance_q31_init(ml_arm_cfft_instance_q31Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddle=NULL;
-    PyObject *pBitRevTable=NULL;
-char *kwlist[] = {
-"fftLen","bitRevLength",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hh", kwlist,&self->instance->fftLen
-,&self->instance->bitRevLength
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_cfft_instance_q31,fftLen,"h");
-GETFIELD(arm_cfft_instance_q31,bitRevLength,"h");
-
-
-static PyMethodDef arm_cfft_instance_q31_methods[] = {
-
-    {"fftLen", (PyCFunction) Method_arm_cfft_instance_q31_fftLen,METH_NOARGS,"fftLen"},
-    {"bitRevLength", (PyCFunction) Method_arm_cfft_instance_q31_bitRevLength,METH_NOARGS,"bitRevLength"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_cfft_instance_q31,arm_cfft_instance_q31_new,arm_cfft_instance_q31_dealloc,arm_cfft_instance_q31_init,arm_cfft_instance_q31_methods);
-
-typedef struct {
-    PyObject_HEAD
-    arm_cfft_instance_f64 *instance;
-} ml_arm_cfft_instance_f64Object;
-
-
-static void
-arm_cfft_instance_f64_dealloc(ml_arm_cfft_instance_f64Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_cfft_instance_f64_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_cfft_instance_f64Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_cfft_instance_f64Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_cfft_instance_f64));
-
-        self->instance->pTwiddle = NULL;
-        self->instance->pBitRevTable = NULL;
-
-    }
-
-    return (PyObject *)self;
-}
-
-static int
-arm_cfft_instance_f64_init(ml_arm_cfft_instance_f64Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddle=NULL;
-    PyObject *pBitRevTable=NULL;
-    char *kwlist[] = {
-        "fftLen","bitRevLength",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hh", kwlist,&self->instance->fftLen
-,&self->instance->bitRevLength
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_cfft_instance_f64,fftLen,"h");
-GETFIELD(arm_cfft_instance_f64,bitRevLength,"h");
-
-
-static PyMethodDef arm_cfft_instance_f64_methods[] = {
-
-    {"fftLen", (PyCFunction) Method_arm_cfft_instance_f64_fftLen,METH_NOARGS,"fftLen"},
-    {"bitRevLength", (PyCFunction) Method_arm_cfft_instance_f64_bitRevLength,METH_NOARGS,"bitRevLength"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_cfft_instance_f64,arm_cfft_instance_f64_new,arm_cfft_instance_f64_dealloc,arm_cfft_instance_f64_init,arm_cfft_instance_f64_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_cfft_instance_f32 *instance;
-} ml_arm_cfft_instance_f32Object;
-
-
-static void
-arm_cfft_instance_f32_dealloc(ml_arm_cfft_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_cfft_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_cfft_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_cfft_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_cfft_instance_f32));
-
-        self->instance->pTwiddle = NULL;
-        self->instance->pBitRevTable = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_cfft_instance_f32_init(ml_arm_cfft_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddle=NULL;
-    PyObject *pBitRevTable=NULL;
-char *kwlist[] = {
-"fftLen","bitRevLength",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hh", kwlist,&self->instance->fftLen
-,&self->instance->bitRevLength
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_cfft_instance_f32,fftLen,"h");
-GETFIELD(arm_cfft_instance_f32,bitRevLength,"h");
-
-
-static PyMethodDef arm_cfft_instance_f32_methods[] = {
-
-    {"fftLen", (PyCFunction) Method_arm_cfft_instance_f32_fftLen,METH_NOARGS,"fftLen"},
-    {"bitRevLength", (PyCFunction) Method_arm_cfft_instance_f32_bitRevLength,METH_NOARGS,"bitRevLength"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_cfft_instance_f32,arm_cfft_instance_f32_new,arm_cfft_instance_f32_dealloc,arm_cfft_instance_f32_init,arm_cfft_instance_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_rfft_instance_q15 *instance;
-} ml_arm_rfft_instance_q15Object;
-
-
-static void
-arm_rfft_instance_q15_dealloc(ml_arm_rfft_instance_q15Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_rfft_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_rfft_instance_q15Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_rfft_instance_q15Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_rfft_instance_q15));
-
-        self->instance->pTwiddleAReal = NULL;
-        self->instance->pTwiddleBReal = NULL;
-        self->instance->pCfft = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_rfft_instance_q15_init(ml_arm_rfft_instance_q15Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddleAReal=NULL;
-    PyObject *pTwiddleBReal=NULL;
-    PyObject *pCfft=NULL;
-char *kwlist[] = {
-"fftLenReal","ifftFlagR","bitReverseFlagR","twidCoefRModifier",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|iiii", kwlist,&self->instance->fftLenReal
-,&self->instance->ifftFlagR
-,&self->instance->bitReverseFlagR
-,&self->instance->twidCoefRModifier
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_rfft_instance_q15,fftLenReal,"i");
-GETFIELD(arm_rfft_instance_q15,ifftFlagR,"i");
-GETFIELD(arm_rfft_instance_q15,bitReverseFlagR,"i");
-GETFIELD(arm_rfft_instance_q15,twidCoefRModifier,"i");
-
-
-static PyMethodDef arm_rfft_instance_q15_methods[] = {
-
-    {"fftLenReal", (PyCFunction) Method_arm_rfft_instance_q15_fftLenReal,METH_NOARGS,"fftLenReal"},
-    {"ifftFlagR", (PyCFunction) Method_arm_rfft_instance_q15_ifftFlagR,METH_NOARGS,"ifftFlagR"},
-    {"bitReverseFlagR", (PyCFunction) Method_arm_rfft_instance_q15_bitReverseFlagR,METH_NOARGS,"bitReverseFlagR"},
-    {"twidCoefRModifier", (PyCFunction) Method_arm_rfft_instance_q15_twidCoefRModifier,METH_NOARGS,"twidCoefRModifier"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_rfft_instance_q15,arm_rfft_instance_q15_new,arm_rfft_instance_q15_dealloc,arm_rfft_instance_q15_init,arm_rfft_instance_q15_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_rfft_instance_q31 *instance;
-} ml_arm_rfft_instance_q31Object;
-
-
-static void
-arm_rfft_instance_q31_dealloc(ml_arm_rfft_instance_q31Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_rfft_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_rfft_instance_q31Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_rfft_instance_q31Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_rfft_instance_q31));
-
-        self->instance->pTwiddleAReal = NULL;
-        self->instance->pTwiddleBReal = NULL;
-        self->instance->pCfft = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_rfft_instance_q31_init(ml_arm_rfft_instance_q31Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddleAReal=NULL;
-    PyObject *pTwiddleBReal=NULL;
-    PyObject *pCfft=NULL;
-char *kwlist[] = {
-"fftLenReal","ifftFlagR","bitReverseFlagR","twidCoefRModifier",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|iiii", kwlist,&self->instance->fftLenReal
-,&self->instance->ifftFlagR
-,&self->instance->bitReverseFlagR
-,&self->instance->twidCoefRModifier
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_rfft_instance_q31,fftLenReal,"i");
-GETFIELD(arm_rfft_instance_q31,ifftFlagR,"i");
-GETFIELD(arm_rfft_instance_q31,bitReverseFlagR,"i");
-GETFIELD(arm_rfft_instance_q31,twidCoefRModifier,"i");
-
-
-static PyMethodDef arm_rfft_instance_q31_methods[] = {
-
-    {"fftLenReal", (PyCFunction) Method_arm_rfft_instance_q31_fftLenReal,METH_NOARGS,"fftLenReal"},
-    {"ifftFlagR", (PyCFunction) Method_arm_rfft_instance_q31_ifftFlagR,METH_NOARGS,"ifftFlagR"},
-    {"bitReverseFlagR", (PyCFunction) Method_arm_rfft_instance_q31_bitReverseFlagR,METH_NOARGS,"bitReverseFlagR"},
-    {"twidCoefRModifier", (PyCFunction) Method_arm_rfft_instance_q31_twidCoefRModifier,METH_NOARGS,"twidCoefRModifier"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_rfft_instance_q31,arm_rfft_instance_q31_new,arm_rfft_instance_q31_dealloc,arm_rfft_instance_q31_init,arm_rfft_instance_q31_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_rfft_instance_f32 *instance;
-} ml_arm_rfft_instance_f32Object;
-
-
-static void
-arm_rfft_instance_f32_dealloc(ml_arm_rfft_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_rfft_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_rfft_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_rfft_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_rfft_instance_f32));
-
-        self->instance->pTwiddleAReal = NULL;
-        self->instance->pTwiddleBReal = NULL;
-        self->instance->pCfft = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_rfft_instance_f32_init(ml_arm_rfft_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddleAReal=NULL;
-    PyObject *pTwiddleBReal=NULL;
-    PyObject *pCfft=NULL;
-char *kwlist[] = {
-"fftLenReal","fftLenBy2","ifftFlagR","bitReverseFlagR","twidCoefRModifier",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|ihiii", kwlist,&self->instance->fftLenReal
-,&self->instance->fftLenBy2
-,&self->instance->ifftFlagR
-,&self->instance->bitReverseFlagR
-,&self->instance->twidCoefRModifier
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_rfft_instance_f32,fftLenReal,"i");
-GETFIELD(arm_rfft_instance_f32,fftLenBy2,"h");
-GETFIELD(arm_rfft_instance_f32,ifftFlagR,"i");
-GETFIELD(arm_rfft_instance_f32,bitReverseFlagR,"i");
-GETFIELD(arm_rfft_instance_f32,twidCoefRModifier,"i");
-
-
-static PyMethodDef arm_rfft_instance_f32_methods[] = {
-
-    {"fftLenReal", (PyCFunction) Method_arm_rfft_instance_f32_fftLenReal,METH_NOARGS,"fftLenReal"},
-    {"fftLenBy2", (PyCFunction) Method_arm_rfft_instance_f32_fftLenBy2,METH_NOARGS,"fftLenBy2"},
-    {"ifftFlagR", (PyCFunction) Method_arm_rfft_instance_f32_ifftFlagR,METH_NOARGS,"ifftFlagR"},
-    {"bitReverseFlagR", (PyCFunction) Method_arm_rfft_instance_f32_bitReverseFlagR,METH_NOARGS,"bitReverseFlagR"},
-    {"twidCoefRModifier", (PyCFunction) Method_arm_rfft_instance_f32_twidCoefRModifier,METH_NOARGS,"twidCoefRModifier"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_rfft_instance_f32,arm_rfft_instance_f32_new,arm_rfft_instance_f32_dealloc,arm_rfft_instance_f32_init,arm_rfft_instance_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_rfft_fast_instance_f64 *instance;
-} ml_arm_rfft_fast_instance_f64Object;
-
-
-static void
-arm_rfft_fast_instance_f64_dealloc(ml_arm_rfft_fast_instance_f64Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_rfft_fast_instance_f64_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_rfft_fast_instance_f64Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_rfft_fast_instance_f64Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_rfft_fast_instance_f64));
-
-        self->instance->pTwiddleRFFT = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_rfft_fast_instance_f64_init(ml_arm_rfft_fast_instance_f64Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddleRFFT=NULL;
-char *kwlist[] = {
-"Sint","fftLenRFFT",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|?h", kwlist,&self->instance->Sint
-,&self->instance->fftLenRFFT
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_rfft_fast_instance_f64,Sint,"?");
-GETFIELD(arm_rfft_fast_instance_f64,fftLenRFFT,"h");
-
-
-static PyMethodDef arm_rfft_fast_instance_f64_methods[] = {
-
-    {"Sint", (PyCFunction) Method_arm_rfft_fast_instance_f64_Sint,METH_NOARGS,"Sint"},
-    {"fftLenRFFT", (PyCFunction) Method_arm_rfft_fast_instance_f64_fftLenRFFT,METH_NOARGS,"fftLenRFFT"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_rfft_fast_instance_f64,arm_rfft_fast_instance_f64_new,arm_rfft_fast_instance_f64_dealloc,arm_rfft_fast_instance_f64_init,arm_rfft_fast_instance_f64_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_rfft_fast_instance_f32 *instance;
-} ml_arm_rfft_fast_instance_f32Object;
-
-
-static void
-arm_rfft_fast_instance_f32_dealloc(ml_arm_rfft_fast_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_rfft_fast_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_rfft_fast_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_rfft_fast_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_rfft_fast_instance_f32));
-
-        self->instance->pTwiddleRFFT = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_rfft_fast_instance_f32_init(ml_arm_rfft_fast_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddleRFFT=NULL;
-char *kwlist[] = {
-"Sint","fftLenRFFT",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|?h", kwlist,&self->instance->Sint
-,&self->instance->fftLenRFFT
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_rfft_fast_instance_f32,Sint,"?");
-GETFIELD(arm_rfft_fast_instance_f32,fftLenRFFT,"h");
-
-
-static PyMethodDef arm_rfft_fast_instance_f32_methods[] = {
-
-    {"Sint", (PyCFunction) Method_arm_rfft_fast_instance_f32_Sint,METH_NOARGS,"Sint"},
-    {"fftLenRFFT", (PyCFunction) Method_arm_rfft_fast_instance_f32_fftLenRFFT,METH_NOARGS,"fftLenRFFT"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_rfft_fast_instance_f32,arm_rfft_fast_instance_f32_new,arm_rfft_fast_instance_f32_dealloc,arm_rfft_fast_instance_f32_init,arm_rfft_fast_instance_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_dct4_instance_f32 *instance;
-} ml_arm_dct4_instance_f32Object;
-
-
-static void
-arm_dct4_instance_f32_dealloc(ml_arm_dct4_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_dct4_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_dct4_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_dct4_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_dct4_instance_f32));
-
-        self->instance->pTwiddle = NULL;
-        self->instance->pCosFactor = NULL;
-        self->instance->pRfft = NULL;
-        self->instance->pCfft = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_dct4_instance_f32_init(ml_arm_dct4_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddle=NULL;
-    PyObject *pCosFactor=NULL;
-    PyObject *pRfft=NULL;
-    PyObject *pCfft=NULL;
-char *kwlist[] = {
-"N","Nby2","normalize",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhf", kwlist,&self->instance->N
-,&self->instance->Nby2
-,&self->instance->normalize
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_dct4_instance_f32,N,"h");
-GETFIELD(arm_dct4_instance_f32,Nby2,"h");
-GETFIELD(arm_dct4_instance_f32,normalize,"f");
-
-
-static PyMethodDef arm_dct4_instance_f32_methods[] = {
-
-    {"N", (PyCFunction) Method_arm_dct4_instance_f32_N,METH_NOARGS,"N"},
-    {"Nby2", (PyCFunction) Method_arm_dct4_instance_f32_Nby2,METH_NOARGS,"Nby2"},
-    {"normalize", (PyCFunction) Method_arm_dct4_instance_f32_normalize,METH_NOARGS,"normalize"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_dct4_instance_f32,arm_dct4_instance_f32_new,arm_dct4_instance_f32_dealloc,arm_dct4_instance_f32_init,arm_dct4_instance_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_dct4_instance_q31 *instance;
-} ml_arm_dct4_instance_q31Object;
-
-
-static void
-arm_dct4_instance_q31_dealloc(ml_arm_dct4_instance_q31Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_dct4_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_dct4_instance_q31Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_dct4_instance_q31Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_dct4_instance_q31));
-
-        self->instance->pTwiddle = NULL;
-        self->instance->pCosFactor = NULL;
-        self->instance->pRfft = NULL;
-        self->instance->pCfft = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_dct4_instance_q31_init(ml_arm_dct4_instance_q31Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddle=NULL;
-    PyObject *pCosFactor=NULL;
-    PyObject *pRfft=NULL;
-    PyObject *pCfft=NULL;
-char *kwlist[] = {
-"N","Nby2","normalize",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhi", kwlist,&self->instance->N
-,&self->instance->Nby2
-,&self->instance->normalize
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_dct4_instance_q31,N,"h");
-GETFIELD(arm_dct4_instance_q31,Nby2,"h");
-GETFIELD(arm_dct4_instance_q31,normalize,"i");
-
-
-static PyMethodDef arm_dct4_instance_q31_methods[] = {
-
-    {"N", (PyCFunction) Method_arm_dct4_instance_q31_N,METH_NOARGS,"N"},
-    {"Nby2", (PyCFunction) Method_arm_dct4_instance_q31_Nby2,METH_NOARGS,"Nby2"},
-    {"normalize", (PyCFunction) Method_arm_dct4_instance_q31_normalize,METH_NOARGS,"normalize"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_dct4_instance_q31,arm_dct4_instance_q31_new,arm_dct4_instance_q31_dealloc,arm_dct4_instance_q31_init,arm_dct4_instance_q31_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_dct4_instance_q15 *instance;
-} ml_arm_dct4_instance_q15Object;
-
-
-static void
-arm_dct4_instance_q15_dealloc(ml_arm_dct4_instance_q15Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_dct4_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_dct4_instance_q15Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_dct4_instance_q15Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_dct4_instance_q15));
-
-        self->instance->pTwiddle = NULL;
-        self->instance->pCosFactor = NULL;
-        self->instance->pRfft = NULL;
-        self->instance->pCfft = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_dct4_instance_q15_init(ml_arm_dct4_instance_q15Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddle=NULL;
-    PyObject *pCosFactor=NULL;
-    PyObject *pRfft=NULL;
-    PyObject *pCfft=NULL;
-char *kwlist[] = {
-"N","Nby2","normalize",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhh", kwlist,&self->instance->N
-,&self->instance->Nby2
-,&self->instance->normalize
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_dct4_instance_q15,N,"h");
-GETFIELD(arm_dct4_instance_q15,Nby2,"h");
-GETFIELD(arm_dct4_instance_q15,normalize,"h");
-
-
-static PyMethodDef arm_dct4_instance_q15_methods[] = {
-
-    {"N", (PyCFunction) Method_arm_dct4_instance_q15_N,METH_NOARGS,"N"},
-    {"Nby2", (PyCFunction) Method_arm_dct4_instance_q15_Nby2,METH_NOARGS,"Nby2"},
-    {"normalize", (PyCFunction) Method_arm_dct4_instance_q15_normalize,METH_NOARGS,"normalize"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_dct4_instance_q15,arm_dct4_instance_q15_new,arm_dct4_instance_q15_dealloc,arm_dct4_instance_q15_init,arm_dct4_instance_q15_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_fir_decimate_instance_q15 *instance;
-} ml_arm_fir_decimate_instance_q15Object;
-
-
-static void
-arm_fir_decimate_instance_q15_dealloc(ml_arm_fir_decimate_instance_q15Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_fir_decimate_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_fir_decimate_instance_q15Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_fir_decimate_instance_q15Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_fir_decimate_instance_q15));
-
-        self->instance->pCoeffs = NULL;
-        self->instance->pState = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_fir_decimate_instance_q15_init(ml_arm_fir_decimate_instance_q15Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pCoeffs=NULL;
-    PyObject *pState=NULL;
-char *kwlist[] = {
-"M","numTaps",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|ih", kwlist,&self->instance->M
-,&self->instance->numTaps
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_fir_decimate_instance_q15,M,"i");
-GETFIELD(arm_fir_decimate_instance_q15,numTaps,"h");
-
-
-static PyMethodDef arm_fir_decimate_instance_q15_methods[] = {
-
-    {"M", (PyCFunction) Method_arm_fir_decimate_instance_q15_M,METH_NOARGS,"M"},
-    {"numTaps", (PyCFunction) Method_arm_fir_decimate_instance_q15_numTaps,METH_NOARGS,"numTaps"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_fir_decimate_instance_q15,arm_fir_decimate_instance_q15_new,arm_fir_decimate_instance_q15_dealloc,arm_fir_decimate_instance_q15_init,arm_fir_decimate_instance_q15_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_fir_decimate_instance_q31 *instance;
-} ml_arm_fir_decimate_instance_q31Object;
-
-
-static void
-arm_fir_decimate_instance_q31_dealloc(ml_arm_fir_decimate_instance_q31Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_fir_decimate_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_fir_decimate_instance_q31Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_fir_decimate_instance_q31Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_fir_decimate_instance_q31));
-
-        self->instance->pCoeffs = NULL;
-        self->instance->pState = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_fir_decimate_instance_q31_init(ml_arm_fir_decimate_instance_q31Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pCoeffs=NULL;
-    PyObject *pState=NULL;
-char *kwlist[] = {
-"M","numTaps",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|ih", kwlist,&self->instance->M
-,&self->instance->numTaps
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_fir_decimate_instance_q31,M,"i");
-GETFIELD(arm_fir_decimate_instance_q31,numTaps,"h");
-
-
-static PyMethodDef arm_fir_decimate_instance_q31_methods[] = {
-
-    {"M", (PyCFunction) Method_arm_fir_decimate_instance_q31_M,METH_NOARGS,"M"},
-    {"numTaps", (PyCFunction) Method_arm_fir_decimate_instance_q31_numTaps,METH_NOARGS,"numTaps"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_fir_decimate_instance_q31,arm_fir_decimate_instance_q31_new,arm_fir_decimate_instance_q31_dealloc,arm_fir_decimate_instance_q31_init,arm_fir_decimate_instance_q31_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_fir_decimate_instance_f32 *instance;
-} ml_arm_fir_decimate_instance_f32Object;
-
-
-static void
-arm_fir_decimate_instance_f32_dealloc(ml_arm_fir_decimate_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_fir_decimate_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_fir_decimate_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_fir_decimate_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_fir_decimate_instance_f32));
-
-        self->instance->pCoeffs = NULL;
-        self->instance->pState = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_fir_decimate_instance_f32_init(ml_arm_fir_decimate_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pCoeffs=NULL;
-    PyObject *pState=NULL;
-char *kwlist[] = {
-"M","numTaps",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|ih", kwlist,&self->instance->M
-,&self->instance->numTaps
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_fir_decimate_instance_f32,M,"i");
-GETFIELD(arm_fir_decimate_instance_f32,numTaps,"h");
-
-
-static PyMethodDef arm_fir_decimate_instance_f32_methods[] = {
-
-    {"M", (PyCFunction) Method_arm_fir_decimate_instance_f32_M,METH_NOARGS,"M"},
-    {"numTaps", (PyCFunction) Method_arm_fir_decimate_instance_f32_numTaps,METH_NOARGS,"numTaps"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_fir_decimate_instance_f32,arm_fir_decimate_instance_f32_new,arm_fir_decimate_instance_f32_dealloc,arm_fir_decimate_instance_f32_init,arm_fir_decimate_instance_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_fir_interpolate_instance_q15 *instance;
-} ml_arm_fir_interpolate_instance_q15Object;
-
-
-static void
-arm_fir_interpolate_instance_q15_dealloc(ml_arm_fir_interpolate_instance_q15Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_fir_interpolate_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_fir_interpolate_instance_q15Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_fir_interpolate_instance_q15Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_fir_interpolate_instance_q15));
-
-        self->instance->pCoeffs = NULL;
-        self->instance->pState = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_fir_interpolate_instance_q15_init(ml_arm_fir_interpolate_instance_q15Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pCoeffs=NULL;
-    PyObject *pState=NULL;
-char *kwlist[] = {
-"L","phaseLength",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|ih", kwlist,&self->instance->L
-,&self->instance->phaseLength
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_fir_interpolate_instance_q15,L,"i");
-GETFIELD(arm_fir_interpolate_instance_q15,phaseLength,"h");
-
-
-static PyMethodDef arm_fir_interpolate_instance_q15_methods[] = {
-
-    {"L", (PyCFunction) Method_arm_fir_interpolate_instance_q15_L,METH_NOARGS,"L"},
-    {"phaseLength", (PyCFunction) Method_arm_fir_interpolate_instance_q15_phaseLength,METH_NOARGS,"phaseLength"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_fir_interpolate_instance_q15,arm_fir_interpolate_instance_q15_new,arm_fir_interpolate_instance_q15_dealloc,arm_fir_interpolate_instance_q15_init,arm_fir_interpolate_instance_q15_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_fir_interpolate_instance_q31 *instance;
-} ml_arm_fir_interpolate_instance_q31Object;
-
-
-static void
-arm_fir_interpolate_instance_q31_dealloc(ml_arm_fir_interpolate_instance_q31Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_fir_interpolate_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_fir_interpolate_instance_q31Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_fir_interpolate_instance_q31Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_fir_interpolate_instance_q31));
-
-        self->instance->pCoeffs = NULL;
-        self->instance->pState = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_fir_interpolate_instance_q31_init(ml_arm_fir_interpolate_instance_q31Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pCoeffs=NULL;
-    PyObject *pState=NULL;
-char *kwlist[] = {
-"L","phaseLength",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|ih", kwlist,&self->instance->L
-,&self->instance->phaseLength
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_fir_interpolate_instance_q31,L,"i");
-GETFIELD(arm_fir_interpolate_instance_q31,phaseLength,"h");
-
-
-static PyMethodDef arm_fir_interpolate_instance_q31_methods[] = {
-
-    {"L", (PyCFunction) Method_arm_fir_interpolate_instance_q31_L,METH_NOARGS,"L"},
-    {"phaseLength", (PyCFunction) Method_arm_fir_interpolate_instance_q31_phaseLength,METH_NOARGS,"phaseLength"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_fir_interpolate_instance_q31,arm_fir_interpolate_instance_q31_new,arm_fir_interpolate_instance_q31_dealloc,arm_fir_interpolate_instance_q31_init,arm_fir_interpolate_instance_q31_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_fir_interpolate_instance_f32 *instance;
-} ml_arm_fir_interpolate_instance_f32Object;
-
-
-static void
-arm_fir_interpolate_instance_f32_dealloc(ml_arm_fir_interpolate_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_fir_interpolate_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_fir_interpolate_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_fir_interpolate_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_fir_interpolate_instance_f32));
-
-        self->instance->pCoeffs = NULL;
-        self->instance->pState = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_fir_interpolate_instance_f32_init(ml_arm_fir_interpolate_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pCoeffs=NULL;
-    PyObject *pState=NULL;
-char *kwlist[] = {
-"L","phaseLength",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|ih", kwlist,&self->instance->L
-,&self->instance->phaseLength
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_fir_interpolate_instance_f32,L,"i");
-GETFIELD(arm_fir_interpolate_instance_f32,phaseLength,"h");
-
-
-static PyMethodDef arm_fir_interpolate_instance_f32_methods[] = {
-
-    {"L", (PyCFunction) Method_arm_fir_interpolate_instance_f32_L,METH_NOARGS,"L"},
-    {"phaseLength", (PyCFunction) Method_arm_fir_interpolate_instance_f32_phaseLength,METH_NOARGS,"phaseLength"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_fir_interpolate_instance_f32,arm_fir_interpolate_instance_f32_new,arm_fir_interpolate_instance_f32_dealloc,arm_fir_interpolate_instance_f32_init,arm_fir_interpolate_instance_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_biquad_cas_df1_32x64_ins_q31 *instance;
-} ml_arm_biquad_cas_df1_32x64_ins_q31Object;
-
-
-static void
-arm_biquad_cas_df1_32x64_ins_q31_dealloc(ml_arm_biquad_cas_df1_32x64_ins_q31Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_biquad_cas_df1_32x64_ins_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_biquad_cas_df1_32x64_ins_q31Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_biquad_cas_df1_32x64_ins_q31Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_biquad_cas_df1_32x64_ins_q31));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_biquad_cas_df1_32x64_ins_q31_init(ml_arm_biquad_cas_df1_32x64_ins_q31Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-char *kwlist[] = {
-"numStages","postShift",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|ii", kwlist,&self->instance->numStages
-,&self->instance->postShift
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_biquad_cas_df1_32x64_ins_q31,numStages,"i");
-GETFIELD(arm_biquad_cas_df1_32x64_ins_q31,postShift,"i");
-
-
-static PyMethodDef arm_biquad_cas_df1_32x64_ins_q31_methods[] = {
-
-    {"numStages", (PyCFunction) Method_arm_biquad_cas_df1_32x64_ins_q31_numStages,METH_NOARGS,"numStages"},
-    {"postShift", (PyCFunction) Method_arm_biquad_cas_df1_32x64_ins_q31_postShift,METH_NOARGS,"postShift"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_biquad_cas_df1_32x64_ins_q31,arm_biquad_cas_df1_32x64_ins_q31_new,arm_biquad_cas_df1_32x64_ins_q31_dealloc,arm_biquad_cas_df1_32x64_ins_q31_init,arm_biquad_cas_df1_32x64_ins_q31_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_biquad_cascade_df2T_instance_f32 *instance;
-} ml_arm_biquad_cascade_df2T_instance_f32Object;
-
-
-static void
-arm_biquad_cascade_df2T_instance_f32_dealloc(ml_arm_biquad_cascade_df2T_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_biquad_cascade_df2T_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_biquad_cascade_df2T_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_biquad_cascade_df2T_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_biquad_cascade_df2T_instance_f32));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_biquad_cascade_df2T_instance_f32_init(ml_arm_biquad_cascade_df2T_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-char *kwlist[] = {
-"numStages",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|i", kwlist,&self->instance->numStages
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_biquad_cascade_df2T_instance_f32,numStages,"i");
-
-static PyObject *                                                             
-Method_arm_biquad_cascade_df2T_instance_f32_state(ml_arm_biquad_cascade_df2T_instance_f32Object *self, PyObject *ignored)
-{                
-    float32_t *state=self->instance->pState;
-    return(NumpyVectorFromf32Buffer(state,self->instance->numStages * 2));                                                  
-} 
-
-static PyMethodDef arm_biquad_cascade_df2T_instance_f32_methods[] = {
-
-    {"numStages", (PyCFunction) Method_arm_biquad_cascade_df2T_instance_f32_numStages,METH_NOARGS,"numStages"},
-    {"state", (PyCFunction) Method_arm_biquad_cascade_df2T_instance_f32_state,METH_NOARGS,"state"},
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_biquad_cascade_df2T_instance_f32,arm_biquad_cascade_df2T_instance_f32_new,arm_biquad_cascade_df2T_instance_f32_dealloc,arm_biquad_cascade_df2T_instance_f32_init,arm_biquad_cascade_df2T_instance_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_biquad_cascade_stereo_df2T_instance_f32 *instance;
-} ml_arm_biquad_cascade_stereo_df2T_instance_f32Object;
-
-
-static void
-arm_biquad_cascade_stereo_df2T_instance_f32_dealloc(ml_arm_biquad_cascade_stereo_df2T_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_biquad_cascade_stereo_df2T_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_biquad_cascade_stereo_df2T_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_biquad_cascade_stereo_df2T_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_biquad_cascade_stereo_df2T_instance_f32));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_biquad_cascade_stereo_df2T_instance_f32_init(ml_arm_biquad_cascade_stereo_df2T_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-char *kwlist[] = {
-"numStages",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|i", kwlist,&self->instance->numStages
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_biquad_cascade_stereo_df2T_instance_f32,numStages,"i");
-
-
-static PyMethodDef arm_biquad_cascade_stereo_df2T_instance_f32_methods[] = {
-
-    {"numStages", (PyCFunction) Method_arm_biquad_cascade_stereo_df2T_instance_f32_numStages,METH_NOARGS,"numStages"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_biquad_cascade_stereo_df2T_instance_f32,arm_biquad_cascade_stereo_df2T_instance_f32_new,arm_biquad_cascade_stereo_df2T_instance_f32_dealloc,arm_biquad_cascade_stereo_df2T_instance_f32_init,arm_biquad_cascade_stereo_df2T_instance_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_biquad_cascade_df2T_instance_f64 *instance;
-} ml_arm_biquad_cascade_df2T_instance_f64Object;
-
-
-static void
-arm_biquad_cascade_df2T_instance_f64_dealloc(ml_arm_biquad_cascade_df2T_instance_f64Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_biquad_cascade_df2T_instance_f64_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_biquad_cascade_df2T_instance_f64Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_biquad_cascade_df2T_instance_f64Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_biquad_cascade_df2T_instance_f64));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_biquad_cascade_df2T_instance_f64_init(ml_arm_biquad_cascade_df2T_instance_f64Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-char *kwlist[] = {
-"numStages",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|i", kwlist,&self->instance->numStages
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_biquad_cascade_df2T_instance_f64,numStages,"i");
-
-
-static PyMethodDef arm_biquad_cascade_df2T_instance_f64_methods[] = {
-
-    {"numStages", (PyCFunction) Method_arm_biquad_cascade_df2T_instance_f64_numStages,METH_NOARGS,"numStages"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_biquad_cascade_df2T_instance_f64,arm_biquad_cascade_df2T_instance_f64_new,arm_biquad_cascade_df2T_instance_f64_dealloc,arm_biquad_cascade_df2T_instance_f64_init,arm_biquad_cascade_df2T_instance_f64_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_fir_lattice_instance_q15 *instance;
-} ml_arm_fir_lattice_instance_q15Object;
-
-
-static void
-arm_fir_lattice_instance_q15_dealloc(ml_arm_fir_lattice_instance_q15Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_fir_lattice_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_fir_lattice_instance_q15Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_fir_lattice_instance_q15Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_fir_lattice_instance_q15));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_fir_lattice_instance_q15_init(ml_arm_fir_lattice_instance_q15Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-char *kwlist[] = {
-"numStages",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|h", kwlist,&self->instance->numStages
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_fir_lattice_instance_q15,numStages,"h");
-
-
-static PyMethodDef arm_fir_lattice_instance_q15_methods[] = {
-
-    {"numStages", (PyCFunction) Method_arm_fir_lattice_instance_q15_numStages,METH_NOARGS,"numStages"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_fir_lattice_instance_q15,arm_fir_lattice_instance_q15_new,arm_fir_lattice_instance_q15_dealloc,arm_fir_lattice_instance_q15_init,arm_fir_lattice_instance_q15_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_fir_lattice_instance_q31 *instance;
-} ml_arm_fir_lattice_instance_q31Object;
-
-
-static void
-arm_fir_lattice_instance_q31_dealloc(ml_arm_fir_lattice_instance_q31Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_fir_lattice_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_fir_lattice_instance_q31Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_fir_lattice_instance_q31Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_fir_lattice_instance_q31));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_fir_lattice_instance_q31_init(ml_arm_fir_lattice_instance_q31Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-char *kwlist[] = {
-"numStages",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|h", kwlist,&self->instance->numStages
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_fir_lattice_instance_q31,numStages,"h");
-
-
-static PyMethodDef arm_fir_lattice_instance_q31_methods[] = {
-
-    {"numStages", (PyCFunction) Method_arm_fir_lattice_instance_q31_numStages,METH_NOARGS,"numStages"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_fir_lattice_instance_q31,arm_fir_lattice_instance_q31_new,arm_fir_lattice_instance_q31_dealloc,arm_fir_lattice_instance_q31_init,arm_fir_lattice_instance_q31_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_fir_lattice_instance_f32 *instance;
-} ml_arm_fir_lattice_instance_f32Object;
-
-
-static void
-arm_fir_lattice_instance_f32_dealloc(ml_arm_fir_lattice_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_fir_lattice_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_fir_lattice_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_fir_lattice_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_fir_lattice_instance_f32));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_fir_lattice_instance_f32_init(ml_arm_fir_lattice_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-char *kwlist[] = {
-"numStages",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|h", kwlist,&self->instance->numStages
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_fir_lattice_instance_f32,numStages,"h");
-
-
-static PyMethodDef arm_fir_lattice_instance_f32_methods[] = {
-
-    {"numStages", (PyCFunction) Method_arm_fir_lattice_instance_f32_numStages,METH_NOARGS,"numStages"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_fir_lattice_instance_f32,arm_fir_lattice_instance_f32_new,arm_fir_lattice_instance_f32_dealloc,arm_fir_lattice_instance_f32_init,arm_fir_lattice_instance_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_iir_lattice_instance_q15 *instance;
-} ml_arm_iir_lattice_instance_q15Object;
-
-
-static void
-arm_iir_lattice_instance_q15_dealloc(ml_arm_iir_lattice_instance_q15Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pkCoeffs)
-       {
-          PyMem_Free(self->instance->pkCoeffs);
-       }
-
-
-       if (self->instance->pvCoeffs)
-       {
-          PyMem_Free(self->instance->pvCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_iir_lattice_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_iir_lattice_instance_q15Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_iir_lattice_instance_q15Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_iir_lattice_instance_q15));
-
-        self->instance->pState = NULL;
-        self->instance->pkCoeffs = NULL;
-        self->instance->pvCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_iir_lattice_instance_q15_init(ml_arm_iir_lattice_instance_q15Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pkCoeffs=NULL;
-    PyObject *pvCoeffs=NULL;
-char *kwlist[] = {
-"numStages","pkCoeffs","pvCoeffs",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hOO", kwlist,&self->instance->numStages
-,&pkCoeffs
-,&pvCoeffs
-))
-    {
-
-    INITARRAYFIELD(pkCoeffs,NPY_INT16,int16_t,int16_t);
-    INITARRAYFIELD(pvCoeffs,NPY_INT16,int16_t,int16_t);
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_iir_lattice_instance_q15,numStages,"h");
-
-
-static PyMethodDef arm_iir_lattice_instance_q15_methods[] = {
-
-    {"numStages", (PyCFunction) Method_arm_iir_lattice_instance_q15_numStages,METH_NOARGS,"numStages"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_iir_lattice_instance_q15,arm_iir_lattice_instance_q15_new,arm_iir_lattice_instance_q15_dealloc,arm_iir_lattice_instance_q15_init,arm_iir_lattice_instance_q15_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_iir_lattice_instance_q31 *instance;
-} ml_arm_iir_lattice_instance_q31Object;
-
-
-static void
-arm_iir_lattice_instance_q31_dealloc(ml_arm_iir_lattice_instance_q31Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pkCoeffs)
-       {
-          PyMem_Free(self->instance->pkCoeffs);
-       }
-
-
-       if (self->instance->pvCoeffs)
-       {
-          PyMem_Free(self->instance->pvCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_iir_lattice_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_iir_lattice_instance_q31Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_iir_lattice_instance_q31Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_iir_lattice_instance_q31));
-
-        self->instance->pState = NULL;
-        self->instance->pkCoeffs = NULL;
-        self->instance->pvCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_iir_lattice_instance_q31_init(ml_arm_iir_lattice_instance_q31Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pkCoeffs=NULL;
-    PyObject *pvCoeffs=NULL;
-char *kwlist[] = {
-"numStages","pkCoeffs","pvCoeffs",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hOO", kwlist,&self->instance->numStages
-,&pkCoeffs
-,&pvCoeffs
-))
-    {
-
-    INITARRAYFIELD(pkCoeffs,NPY_INT32,int32_t,int32_t);
-    INITARRAYFIELD(pvCoeffs,NPY_INT32,int32_t,int32_t);
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_iir_lattice_instance_q31,numStages,"h");
-
-
-static PyMethodDef arm_iir_lattice_instance_q31_methods[] = {
-
-    {"numStages", (PyCFunction) Method_arm_iir_lattice_instance_q31_numStages,METH_NOARGS,"numStages"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_iir_lattice_instance_q31,arm_iir_lattice_instance_q31_new,arm_iir_lattice_instance_q31_dealloc,arm_iir_lattice_instance_q31_init,arm_iir_lattice_instance_q31_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_iir_lattice_instance_f32 *instance;
-} ml_arm_iir_lattice_instance_f32Object;
-
-
-static void
-arm_iir_lattice_instance_f32_dealloc(ml_arm_iir_lattice_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pkCoeffs)
-       {
-          PyMem_Free(self->instance->pkCoeffs);
-       }
-
-
-       if (self->instance->pvCoeffs)
-       {
-          PyMem_Free(self->instance->pvCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_iir_lattice_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_iir_lattice_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_iir_lattice_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_iir_lattice_instance_f32));
-
-        self->instance->pState = NULL;
-        self->instance->pkCoeffs = NULL;
-        self->instance->pvCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_iir_lattice_instance_f32_init(ml_arm_iir_lattice_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pkCoeffs=NULL;
-    PyObject *pvCoeffs=NULL;
-char *kwlist[] = {
-"numStages","pkCoeffs","pvCoeffs",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hOO", kwlist,&self->instance->numStages
-,&pkCoeffs
-,&pvCoeffs
-))
-    {
-
-    INITARRAYFIELD(pkCoeffs,NPY_DOUBLE,double,float32_t);
-    INITARRAYFIELD(pvCoeffs,NPY_DOUBLE,double,float32_t);
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_iir_lattice_instance_f32,numStages,"h");
-
-
-static PyMethodDef arm_iir_lattice_instance_f32_methods[] = {
-
-    {"numStages", (PyCFunction) Method_arm_iir_lattice_instance_f32_numStages,METH_NOARGS,"numStages"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_iir_lattice_instance_f32,arm_iir_lattice_instance_f32_new,arm_iir_lattice_instance_f32_dealloc,arm_iir_lattice_instance_f32_init,arm_iir_lattice_instance_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_lms_instance_f32 *instance;
-} ml_arm_lms_instance_f32Object;
-
-
-static void
-arm_lms_instance_f32_dealloc(ml_arm_lms_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_lms_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_lms_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_lms_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_lms_instance_f32));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_lms_instance_f32_init(ml_arm_lms_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-char *kwlist[] = {
-"numTaps","mu",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hf", kwlist,&self->instance->numTaps
-,&self->instance->mu
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_lms_instance_f32,numTaps,"h");
-GETFIELD(arm_lms_instance_f32,mu,"f");
-
-
-static PyMethodDef arm_lms_instance_f32_methods[] = {
-
-    {"numTaps", (PyCFunction) Method_arm_lms_instance_f32_numTaps,METH_NOARGS,"numTaps"},
-    {"mu", (PyCFunction) Method_arm_lms_instance_f32_mu,METH_NOARGS,"mu"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_lms_instance_f32,arm_lms_instance_f32_new,arm_lms_instance_f32_dealloc,arm_lms_instance_f32_init,arm_lms_instance_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_lms_instance_q15 *instance;
-} ml_arm_lms_instance_q15Object;
-
-
-static void
-arm_lms_instance_q15_dealloc(ml_arm_lms_instance_q15Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_lms_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_lms_instance_q15Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_lms_instance_q15Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_lms_instance_q15));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_lms_instance_q15_init(ml_arm_lms_instance_q15Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-char *kwlist[] = {
-"numTaps","mu","postShift",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhi", kwlist,&self->instance->numTaps
-,&self->instance->mu
-,&self->instance->postShift
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_lms_instance_q15,numTaps,"h");
-GETFIELD(arm_lms_instance_q15,mu,"h");
-GETFIELD(arm_lms_instance_q15,postShift,"i");
-
-
-static PyMethodDef arm_lms_instance_q15_methods[] = {
-
-    {"numTaps", (PyCFunction) Method_arm_lms_instance_q15_numTaps,METH_NOARGS,"numTaps"},
-    {"mu", (PyCFunction) Method_arm_lms_instance_q15_mu,METH_NOARGS,"mu"},
-    {"postShift", (PyCFunction) Method_arm_lms_instance_q15_postShift,METH_NOARGS,"postShift"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_lms_instance_q15,arm_lms_instance_q15_new,arm_lms_instance_q15_dealloc,arm_lms_instance_q15_init,arm_lms_instance_q15_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_lms_instance_q31 *instance;
-} ml_arm_lms_instance_q31Object;
-
-
-static void
-arm_lms_instance_q31_dealloc(ml_arm_lms_instance_q31Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_lms_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_lms_instance_q31Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_lms_instance_q31Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_lms_instance_q31));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_lms_instance_q31_init(ml_arm_lms_instance_q31Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-char *kwlist[] = {
-"numTaps","mu","postShift",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hii", kwlist,&self->instance->numTaps
-,&self->instance->mu
-,&self->instance->postShift
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_lms_instance_q31,numTaps,"h");
-GETFIELD(arm_lms_instance_q31,mu,"i");
-GETFIELD(arm_lms_instance_q31,postShift,"i");
-
-
-static PyMethodDef arm_lms_instance_q31_methods[] = {
-
-    {"numTaps", (PyCFunction) Method_arm_lms_instance_q31_numTaps,METH_NOARGS,"numTaps"},
-    {"mu", (PyCFunction) Method_arm_lms_instance_q31_mu,METH_NOARGS,"mu"},
-    {"postShift", (PyCFunction) Method_arm_lms_instance_q31_postShift,METH_NOARGS,"postShift"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_lms_instance_q31,arm_lms_instance_q31_new,arm_lms_instance_q31_dealloc,arm_lms_instance_q31_init,arm_lms_instance_q31_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_lms_norm_instance_f32 *instance;
-} ml_arm_lms_norm_instance_f32Object;
-
-
-static void
-arm_lms_norm_instance_f32_dealloc(ml_arm_lms_norm_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_lms_norm_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_lms_norm_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_lms_norm_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_lms_norm_instance_f32));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_lms_norm_instance_f32_init(ml_arm_lms_norm_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-char *kwlist[] = {
-"numTaps","mu","energy","x0",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hfff", kwlist,&self->instance->numTaps
-,&self->instance->mu
-,&self->instance->energy
-,&self->instance->x0
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_lms_norm_instance_f32,numTaps,"h");
-GETFIELD(arm_lms_norm_instance_f32,mu,"f");
-GETFIELD(arm_lms_norm_instance_f32,energy,"f");
-GETFIELD(arm_lms_norm_instance_f32,x0,"f");
-
-
-static PyMethodDef arm_lms_norm_instance_f32_methods[] = {
-
-    {"numTaps", (PyCFunction) Method_arm_lms_norm_instance_f32_numTaps,METH_NOARGS,"numTaps"},
-    {"mu", (PyCFunction) Method_arm_lms_norm_instance_f32_mu,METH_NOARGS,"mu"},
-    {"energy", (PyCFunction) Method_arm_lms_norm_instance_f32_energy,METH_NOARGS,"energy"},
-    {"x0", (PyCFunction) Method_arm_lms_norm_instance_f32_x0,METH_NOARGS,"x0"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_lms_norm_instance_f32,arm_lms_norm_instance_f32_new,arm_lms_norm_instance_f32_dealloc,arm_lms_norm_instance_f32_init,arm_lms_norm_instance_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_lms_norm_instance_q31 *instance;
-} ml_arm_lms_norm_instance_q31Object;
-
-
-static void
-arm_lms_norm_instance_q31_dealloc(ml_arm_lms_norm_instance_q31Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_lms_norm_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_lms_norm_instance_q31Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_lms_norm_instance_q31Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_lms_norm_instance_q31));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-        self->instance->recipTable = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_lms_norm_instance_q31_init(ml_arm_lms_norm_instance_q31Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-    PyObject *recipTable=NULL;
-char *kwlist[] = {
-"numTaps","mu","postShift","energy","x0",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hiiii", kwlist,&self->instance->numTaps
-,&self->instance->mu
-,&self->instance->postShift
-,&self->instance->energy
-,&self->instance->x0
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_lms_norm_instance_q31,numTaps,"h");
-GETFIELD(arm_lms_norm_instance_q31,mu,"i");
-GETFIELD(arm_lms_norm_instance_q31,postShift,"i");
-GETFIELD(arm_lms_norm_instance_q31,energy,"i");
-GETFIELD(arm_lms_norm_instance_q31,x0,"i");
-
-
-static PyMethodDef arm_lms_norm_instance_q31_methods[] = {
-
-    {"numTaps", (PyCFunction) Method_arm_lms_norm_instance_q31_numTaps,METH_NOARGS,"numTaps"},
-    {"mu", (PyCFunction) Method_arm_lms_norm_instance_q31_mu,METH_NOARGS,"mu"},
-    {"postShift", (PyCFunction) Method_arm_lms_norm_instance_q31_postShift,METH_NOARGS,"postShift"},
-    {"energy", (PyCFunction) Method_arm_lms_norm_instance_q31_energy,METH_NOARGS,"energy"},
-    {"x0", (PyCFunction) Method_arm_lms_norm_instance_q31_x0,METH_NOARGS,"x0"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_lms_norm_instance_q31,arm_lms_norm_instance_q31_new,arm_lms_norm_instance_q31_dealloc,arm_lms_norm_instance_q31_init,arm_lms_norm_instance_q31_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_lms_norm_instance_q15 *instance;
-} ml_arm_lms_norm_instance_q15Object;
-
-
-static void
-arm_lms_norm_instance_q15_dealloc(ml_arm_lms_norm_instance_q15Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_lms_norm_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_lms_norm_instance_q15Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_lms_norm_instance_q15Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_lms_norm_instance_q15));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-        self->instance->recipTable = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_lms_norm_instance_q15_init(ml_arm_lms_norm_instance_q15Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-    PyObject *recipTable=NULL;
-char *kwlist[] = {
-"numTaps","mu","postShift","energy","x0",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhihh", kwlist,&self->instance->numTaps
-,&self->instance->mu
-,&self->instance->postShift
-,&self->instance->energy
-,&self->instance->x0
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_lms_norm_instance_q15,numTaps,"h");
-GETFIELD(arm_lms_norm_instance_q15,mu,"h");
-GETFIELD(arm_lms_norm_instance_q15,postShift,"i");
-GETFIELD(arm_lms_norm_instance_q15,energy,"h");
-GETFIELD(arm_lms_norm_instance_q15,x0,"h");
-
-
-static PyMethodDef arm_lms_norm_instance_q15_methods[] = {
-
-    {"numTaps", (PyCFunction) Method_arm_lms_norm_instance_q15_numTaps,METH_NOARGS,"numTaps"},
-    {"mu", (PyCFunction) Method_arm_lms_norm_instance_q15_mu,METH_NOARGS,"mu"},
-    {"postShift", (PyCFunction) Method_arm_lms_norm_instance_q15_postShift,METH_NOARGS,"postShift"},
-    {"energy", (PyCFunction) Method_arm_lms_norm_instance_q15_energy,METH_NOARGS,"energy"},
-    {"x0", (PyCFunction) Method_arm_lms_norm_instance_q15_x0,METH_NOARGS,"x0"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_lms_norm_instance_q15,arm_lms_norm_instance_q15_new,arm_lms_norm_instance_q15_dealloc,arm_lms_norm_instance_q15_init,arm_lms_norm_instance_q15_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_fir_sparse_instance_f32 *instance;
-} ml_arm_fir_sparse_instance_f32Object;
-
-
-static void
-arm_fir_sparse_instance_f32_dealloc(ml_arm_fir_sparse_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       if (self->instance->pTapDelay)
-       {
-          PyMem_Free(self->instance->pTapDelay);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_fir_sparse_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_fir_sparse_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_fir_sparse_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_fir_sparse_instance_f32));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-        self->instance->pTapDelay = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_fir_sparse_instance_f32_init(ml_arm_fir_sparse_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-    PyObject *pTapDelay=NULL;
-char *kwlist[] = {
-"numTaps","stateIndex","maxDelay","pTapDelay",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhhO", kwlist,&self->instance->numTaps
-,&self->instance->stateIndex
-,&self->instance->maxDelay
-,&pTapDelay
-))
-    {
-
-    INITARRAYFIELD(pTapDelay,NPY_INT32,int32_t,int32_t);
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_fir_sparse_instance_f32,numTaps,"h");
-GETFIELD(arm_fir_sparse_instance_f32,stateIndex,"h");
-GETFIELD(arm_fir_sparse_instance_f32,maxDelay,"h");
-
-
-static PyMethodDef arm_fir_sparse_instance_f32_methods[] = {
-
-    {"numTaps", (PyCFunction) Method_arm_fir_sparse_instance_f32_numTaps,METH_NOARGS,"numTaps"},
-    {"stateIndex", (PyCFunction) Method_arm_fir_sparse_instance_f32_stateIndex,METH_NOARGS,"stateIndex"},
-    {"maxDelay", (PyCFunction) Method_arm_fir_sparse_instance_f32_maxDelay,METH_NOARGS,"maxDelay"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_fir_sparse_instance_f32,arm_fir_sparse_instance_f32_new,arm_fir_sparse_instance_f32_dealloc,arm_fir_sparse_instance_f32_init,arm_fir_sparse_instance_f32_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_fir_sparse_instance_q31 *instance;
-} ml_arm_fir_sparse_instance_q31Object;
-
-
-static void
-arm_fir_sparse_instance_q31_dealloc(ml_arm_fir_sparse_instance_q31Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       if (self->instance->pTapDelay)
-       {
-          PyMem_Free(self->instance->pTapDelay);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_fir_sparse_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_fir_sparse_instance_q31Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_fir_sparse_instance_q31Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_fir_sparse_instance_q31));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-        self->instance->pTapDelay = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_fir_sparse_instance_q31_init(ml_arm_fir_sparse_instance_q31Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-    PyObject *pTapDelay=NULL;
-char *kwlist[] = {
-"numTaps","stateIndex","maxDelay","pTapDelay",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhhO", kwlist,&self->instance->numTaps
-,&self->instance->stateIndex
-,&self->instance->maxDelay
-,&pTapDelay
-))
-    {
-
-    INITARRAYFIELD(pTapDelay,NPY_INT32,int32_t,int32_t);
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_fir_sparse_instance_q31,numTaps,"h");
-GETFIELD(arm_fir_sparse_instance_q31,stateIndex,"h");
-GETFIELD(arm_fir_sparse_instance_q31,maxDelay,"h");
-
-
-static PyMethodDef arm_fir_sparse_instance_q31_methods[] = {
-
-    {"numTaps", (PyCFunction) Method_arm_fir_sparse_instance_q31_numTaps,METH_NOARGS,"numTaps"},
-    {"stateIndex", (PyCFunction) Method_arm_fir_sparse_instance_q31_stateIndex,METH_NOARGS,"stateIndex"},
-    {"maxDelay", (PyCFunction) Method_arm_fir_sparse_instance_q31_maxDelay,METH_NOARGS,"maxDelay"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_fir_sparse_instance_q31,arm_fir_sparse_instance_q31_new,arm_fir_sparse_instance_q31_dealloc,arm_fir_sparse_instance_q31_init,arm_fir_sparse_instance_q31_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_fir_sparse_instance_q15 *instance;
-} ml_arm_fir_sparse_instance_q15Object;
-
-
-static void
-arm_fir_sparse_instance_q15_dealloc(ml_arm_fir_sparse_instance_q15Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       if (self->instance->pTapDelay)
-       {
-          PyMem_Free(self->instance->pTapDelay);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_fir_sparse_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_fir_sparse_instance_q15Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_fir_sparse_instance_q15Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_fir_sparse_instance_q15));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-        self->instance->pTapDelay = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_fir_sparse_instance_q15_init(ml_arm_fir_sparse_instance_q15Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-    PyObject *pTapDelay=NULL;
-char *kwlist[] = {
-"numTaps","stateIndex","maxDelay","pTapDelay",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhhO", kwlist,&self->instance->numTaps
-,&self->instance->stateIndex
-,&self->instance->maxDelay
-,&pTapDelay
-))
-    {
-
-    INITARRAYFIELD(pTapDelay,NPY_INT32,int32_t,int32_t);
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_fir_sparse_instance_q15,numTaps,"h");
-GETFIELD(arm_fir_sparse_instance_q15,stateIndex,"h");
-GETFIELD(arm_fir_sparse_instance_q15,maxDelay,"h");
-
-
-static PyMethodDef arm_fir_sparse_instance_q15_methods[] = {
-
-    {"numTaps", (PyCFunction) Method_arm_fir_sparse_instance_q15_numTaps,METH_NOARGS,"numTaps"},
-    {"stateIndex", (PyCFunction) Method_arm_fir_sparse_instance_q15_stateIndex,METH_NOARGS,"stateIndex"},
-    {"maxDelay", (PyCFunction) Method_arm_fir_sparse_instance_q15_maxDelay,METH_NOARGS,"maxDelay"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_fir_sparse_instance_q15,arm_fir_sparse_instance_q15_new,arm_fir_sparse_instance_q15_dealloc,arm_fir_sparse_instance_q15_init,arm_fir_sparse_instance_q15_methods);
-
-
-typedef struct {
-    PyObject_HEAD
-    arm_fir_sparse_instance_q7 *instance;
-} ml_arm_fir_sparse_instance_q7Object;
-
-
-static void
-arm_fir_sparse_instance_q7_dealloc(ml_arm_fir_sparse_instance_q7Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       if (self->instance->pState)
-       {
-          PyMem_Free(self->instance->pState);
-       }
-
-
-       if (self->instance->pCoeffs)
-       {
-          PyMem_Free(self->instance->pCoeffs);
-       }
-
-
-       if (self->instance->pTapDelay)
-       {
-          PyMem_Free(self->instance->pTapDelay);
-       }
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-
-static PyObject *
-arm_fir_sparse_instance_q7_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_fir_sparse_instance_q7Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_fir_sparse_instance_q7Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_fir_sparse_instance_q7));
-
-        self->instance->pState = NULL;
-        self->instance->pCoeffs = NULL;
-        self->instance->pTapDelay = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_fir_sparse_instance_q7_init(ml_arm_fir_sparse_instance_q7Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pState=NULL;
-    PyObject *pCoeffs=NULL;
-    PyObject *pTapDelay=NULL;
-char *kwlist[] = {
-"numTaps","stateIndex","maxDelay","pTapDelay",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhhO", kwlist,&self->instance->numTaps
-,&self->instance->stateIndex
-,&self->instance->maxDelay
-,&pTapDelay
-))
-    {
-
-    INITARRAYFIELD(pTapDelay,NPY_INT32,int32_t,int32_t);
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_fir_sparse_instance_q7,numTaps,"h");
-GETFIELD(arm_fir_sparse_instance_q7,stateIndex,"h");
-GETFIELD(arm_fir_sparse_instance_q7,maxDelay,"h");
-
-
-static PyMethodDef arm_fir_sparse_instance_q7_methods[] = {
-
-    {"numTaps", (PyCFunction) Method_arm_fir_sparse_instance_q7_numTaps,METH_NOARGS,"numTaps"},
-    {"stateIndex", (PyCFunction) Method_arm_fir_sparse_instance_q7_stateIndex,METH_NOARGS,"stateIndex"},
-    {"maxDelay", (PyCFunction) Method_arm_fir_sparse_instance_q7_maxDelay,METH_NOARGS,"maxDelay"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_fir_sparse_instance_q7,arm_fir_sparse_instance_q7_new,arm_fir_sparse_instance_q7_dealloc,arm_fir_sparse_instance_q7_init,arm_fir_sparse_instance_q7_methods);
-
-typedef struct {
-    PyObject_HEAD
-    arm_mfcc_instance_f32 *instance;
-} ml_arm_mfcc_instance_f32Object;
-
-typedef struct {
-    PyObject_HEAD
-    arm_mfcc_instance_q31 *instance;
-} ml_arm_mfcc_instance_q31Object;
-
-typedef struct {
-    PyObject_HEAD
-    arm_mfcc_instance_q15 *instance;
-} ml_arm_mfcc_instance_q15Object;
-
-static void
-arm_mfcc_instance_f32_dealloc(ml_arm_mfcc_instance_f32Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-static void
-arm_mfcc_instance_q31_dealloc(ml_arm_mfcc_instance_q31Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-static void
-arm_mfcc_instance_q15_dealloc(ml_arm_mfcc_instance_q15Object* self)
-{
-    //printf("Dealloc called\n");
-    if (self->instance)
-    {
-
-
-       PyMem_Free(self->instance);
-    }
-
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-static PyObject *
-arm_mfcc_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_mfcc_instance_f32Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_mfcc_instance_f32Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_mfcc_instance_f32));
-
-        self->instance->dctCoefs = NULL;
-        self->instance->filterCoefs = NULL;
-        self->instance->windowCoefs = NULL;
-        self->instance->filterPos = NULL;
-        self->instance->filterLengths = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static PyObject *
-arm_mfcc_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_mfcc_instance_q31Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_mfcc_instance_q31Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_mfcc_instance_q31));
-
-        self->instance->dctCoefs = NULL;
-        self->instance->filterCoefs = NULL;
-        self->instance->windowCoefs = NULL;
-        self->instance->filterPos = NULL;
-        self->instance->filterLengths = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static PyObject *
-arm_mfcc_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    ml_arm_mfcc_instance_q15Object *self;
-    //printf("New called\n");
-
-    self = (ml_arm_mfcc_instance_q15Object *)type->tp_alloc(type, 0);
-    //printf("alloc called\n");
-
-    if (self != NULL) {
-
-        self->instance = PyMem_Malloc(sizeof(arm_mfcc_instance_q15));
-
-        self->instance->dctCoefs = NULL;
-        self->instance->filterCoefs = NULL;
-        self->instance->windowCoefs = NULL;
-        self->instance->filterPos = NULL;
-        self->instance->filterLengths = NULL;
-
-    }
-
-
-    return (PyObject *)self;
-}
-
-static int
-arm_mfcc_instance_f32_init(ml_arm_mfcc_instance_f32Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddle=NULL;
-    PyObject *pBitRevTable=NULL;
-char *kwlist[] = {
-"fftLen","nbMelFilters","nbDctOutputs",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|iii", kwlist,&self->instance->fftLen
-,&self->instance->nbMelFilters,&self->instance->nbDctOutputs
-))
-    {
-
-
-    }
-    return 0;
-}
-
-static int
-arm_mfcc_instance_q31_init(ml_arm_mfcc_instance_q31Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddle=NULL;
-    PyObject *pBitRevTable=NULL;
-char *kwlist[] = {
-"fftLen","nbMelFilters","nbDctOutputs",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|iii", kwlist,&self->instance->fftLen
-,&self->instance->nbMelFilters,&self->instance->nbDctOutputs
-))
-    {
-
-
-    }
-    return 0;
-}
-
-static int
-arm_mfcc_instance_q15_init(ml_arm_mfcc_instance_q15Object *self, PyObject *args, PyObject *kwds)
-{
-
-    PyObject *pTwiddle=NULL;
-    PyObject *pBitRevTable=NULL;
-char *kwlist[] = {
-"fftLen","nbMelFilters","nbDctOutputs",NULL
-};
-
-if (PyArg_ParseTupleAndKeywords(args, kwds, "|iii", kwlist,&self->instance->fftLen
-,&self->instance->nbMelFilters,&self->instance->nbDctOutputs
-))
-    {
-
-
-    }
-    return 0;
-}
-
-GETFIELD(arm_mfcc_instance_f32,fftLen,"i");
-GETFIELD(arm_mfcc_instance_f32,nbMelFilters,"i");
-GETFIELD(arm_mfcc_instance_f32,nbDctOutputs,"i");
-
-GETFIELD(arm_mfcc_instance_q31,fftLen,"i");
-GETFIELD(arm_mfcc_instance_q31,nbMelFilters,"i");
-GETFIELD(arm_mfcc_instance_q31,nbDctOutputs,"i");
-
-GETFIELD(arm_mfcc_instance_q15,fftLen,"i");
-GETFIELD(arm_mfcc_instance_q15,nbMelFilters,"i");
-GETFIELD(arm_mfcc_instance_q15,nbDctOutputs,"i");
-
-
-static PyMethodDef arm_mfcc_instance_f32_methods[] = {
-
-    {"fftLen", (PyCFunction) Method_arm_mfcc_instance_f32_fftLen,METH_NOARGS,"fftLen"},
-    {"nbMelFilters", (PyCFunction) Method_arm_mfcc_instance_f32_nbMelFilters,METH_NOARGS,"nbMelFilters"},
-    {"nbDctOutputs", (PyCFunction) Method_arm_mfcc_instance_f32_nbDctOutputs,METH_NOARGS,"nbDctOutputs"},
-
-    {NULL}  /* Sentinel */
-};
-
-static PyMethodDef arm_mfcc_instance_q31_methods[] = {
-
-    {"fftLen", (PyCFunction) Method_arm_mfcc_instance_q31_fftLen,METH_NOARGS,"fftLen"},
-    {"nbMelFilters", (PyCFunction) Method_arm_mfcc_instance_q31_nbMelFilters,METH_NOARGS,"nbMelFilters"},
-    {"nbDctOutputs", (PyCFunction) Method_arm_mfcc_instance_q31_nbDctOutputs,METH_NOARGS,"nbDctOutputs"},
-
-    {NULL}  /* Sentinel */
-};
-
-static PyMethodDef arm_mfcc_instance_q15_methods[] = {
-
-    {"fftLen", (PyCFunction) Method_arm_mfcc_instance_q15_fftLen,METH_NOARGS,"fftLen"},
-    {"nbMelFilters", (PyCFunction) Method_arm_mfcc_instance_q15_nbMelFilters,METH_NOARGS,"nbMelFilters"},
-    {"nbDctOutputs", (PyCFunction) Method_arm_mfcc_instance_q15_nbDctOutputs,METH_NOARGS,"nbDctOutputs"},
-
-    {NULL}  /* Sentinel */
-};
-
-
-MLTYPE(arm_mfcc_instance_f32,arm_mfcc_instance_f32_new,arm_mfcc_instance_f32_dealloc,arm_mfcc_instance_f32_init,arm_mfcc_instance_f32_methods);
-MLTYPE(arm_mfcc_instance_q31,arm_mfcc_instance_q31_new,arm_mfcc_instance_q31_dealloc,arm_mfcc_instance_q31_init,arm_mfcc_instance_q31_methods);
-MLTYPE(arm_mfcc_instance_q15,arm_mfcc_instance_q15_new,arm_mfcc_instance_q15_dealloc,arm_mfcc_instance_q15_init,arm_mfcc_instance_q15_methods);
-
-
-
-void typeRegistration(PyObject *module) {
-
-  ADDTYPE(arm_fir_instance_q7);
-  ADDTYPE(arm_fir_instance_q15);
-  ADDTYPE(arm_fir_instance_q31);
-  ADDTYPE(arm_fir_instance_f32);
-  ADDTYPE(arm_biquad_casd_df1_inst_q15);
-  ADDTYPE(arm_biquad_casd_df1_inst_q31);
-  ADDTYPE(arm_biquad_casd_df1_inst_f32);
-  ADDTYPE(arm_matrix_instance_f32);
-  ADDTYPE(arm_matrix_instance_f64);
-  ADDTYPE(arm_matrix_instance_q15);
-  ADDTYPE(arm_matrix_instance_q31);
-  ADDTYPE(arm_pid_instance_q15);
-  ADDTYPE(arm_pid_instance_q31);
-  ADDTYPE(arm_pid_instance_f32);
-  ADDTYPE(arm_linear_interp_instance_f32);
-  ADDTYPE(arm_bilinear_interp_instance_f32);
-  ADDTYPE(arm_bilinear_interp_instance_q31);
-  ADDTYPE(arm_bilinear_interp_instance_q15);
-  ADDTYPE(arm_bilinear_interp_instance_q7);
-  ADDTYPE(arm_cfft_radix2_instance_q15);
-  ADDTYPE(arm_cfft_radix4_instance_q15);
-  ADDTYPE(arm_cfft_radix2_instance_q31);
-  ADDTYPE(arm_cfft_radix4_instance_q31);
-  ADDTYPE(arm_cfft_radix2_instance_f32);
-  ADDTYPE(arm_cfft_radix4_instance_f32);
-  ADDTYPE(arm_cfft_instance_q15);
-  ADDTYPE(arm_cfft_instance_q31);
-  ADDTYPE(arm_cfft_instance_f32);
-  ADDTYPE(arm_rfft_instance_q15);
-  ADDTYPE(arm_rfft_instance_q31);
-  ADDTYPE(arm_rfft_instance_f32);
-  ADDTYPE(arm_rfft_fast_instance_f32);
-  ADDTYPE(arm_dct4_instance_f32);
-  ADDTYPE(arm_dct4_instance_q31);
-  ADDTYPE(arm_dct4_instance_q15);
-  ADDTYPE(arm_fir_decimate_instance_q15);
-  ADDTYPE(arm_fir_decimate_instance_q31);
-  ADDTYPE(arm_fir_decimate_instance_f32);
-  ADDTYPE(arm_fir_interpolate_instance_q15);
-  ADDTYPE(arm_fir_interpolate_instance_q31);
-  ADDTYPE(arm_fir_interpolate_instance_f32);
-  ADDTYPE(arm_biquad_cas_df1_32x64_ins_q31);
-  ADDTYPE(arm_biquad_cascade_df2T_instance_f32);
-  ADDTYPE(arm_biquad_cascade_stereo_df2T_instance_f32);
-  ADDTYPE(arm_biquad_cascade_df2T_instance_f64);
-  ADDTYPE(arm_fir_lattice_instance_q15);
-  ADDTYPE(arm_fir_lattice_instance_q31);
-  ADDTYPE(arm_fir_lattice_instance_f32);
-  ADDTYPE(arm_iir_lattice_instance_q15);
-  ADDTYPE(arm_iir_lattice_instance_q31);
-  ADDTYPE(arm_iir_lattice_instance_f32);
-  ADDTYPE(arm_lms_instance_f32);
-  ADDTYPE(arm_lms_instance_q15);
-  ADDTYPE(arm_lms_instance_q31);
-  ADDTYPE(arm_lms_norm_instance_f32);
-  ADDTYPE(arm_lms_norm_instance_q31);
-  ADDTYPE(arm_lms_norm_instance_q15);
-  ADDTYPE(arm_fir_sparse_instance_f32);
-  ADDTYPE(arm_fir_sparse_instance_q31);
-  ADDTYPE(arm_fir_sparse_instance_q15);
-  ADDTYPE(arm_fir_sparse_instance_q7);
-  ADDTYPE(arm_mfcc_instance_f32);
-  ADDTYPE(arm_mfcc_instance_q31);
-  ADDTYPE(arm_mfcc_instance_q15);
-}
-
-
-static PyObject *
-cmsis_arm_recip_q31(PyObject *obj, PyObject *args)
-{
-
-  q31_t in; // input
-  q31_t *dst=NULL; // output
-  PyObject *pRecipTable=NULL; // input
-  q31_t *pRecipTable_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"iO",&in,&pRecipTable))
-  {
-
-    GETARGUMENT(pRecipTable,NPY_INT32,int32_t,int32_t);
-
-    dst=PyMem_Malloc(sizeof(q31_t)*1);
-
-
-    uint32_t returnValue = arm_recip_q31(in,dst,pRecipTable_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* dstOBJ=Py_BuildValue("i",*dst);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,dstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    Py_DECREF(dstOBJ);
-    FREEARGUMENT(pRecipTable_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_recip_q15(PyObject *obj, PyObject *args)
-{
-
-  q15_t in; // input
-  q15_t *dst=NULL; // output
-  PyObject *pRecipTable=NULL; // input
-  q15_t *pRecipTable_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"hO",&in,&pRecipTable))
-  {
-
-    GETARGUMENT(pRecipTable,NPY_INT16,int16_t,int16_t);
-
-    dst=PyMem_Malloc(sizeof(q15_t)*1);
-
-
-    uint32_t returnValue = arm_recip_q15(in,dst,pRecipTable_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* dstOBJ=Py_BuildValue("h",*dst);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,dstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    Py_DECREF(dstOBJ);
-    FREEARGUMENT(pRecipTable_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  q7_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_fir_instance_q7Object *selfS = (ml_arm_fir_instance_q7Object *)S;
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
-
-
-    arm_fir_q7(selfS->instance,pSrc_converted,pDst,blockSize);
- INT8ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_init_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numTaps; // input
-  PyObject *pCoeffs=NULL; // input
-  q7_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q7_t *pState_converted=NULL; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OhOO",&S,&numTaps,&pCoeffs,&pState))
-  {
-
-    ml_arm_fir_instance_q7Object *selfS = (ml_arm_fir_instance_q7Object *)S;
-    GETARGUMENT(pCoeffs,NPY_BYTE,int8_t,q7_t);
-    GETARGUMENT(pState,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepState - arraySizepCoeffs + 1;
-
-    arm_fir_init_q7(selfS->instance,numTaps,pCoeffs_converted,pState_converted,blockSize);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_fir_instance_q15Object *selfS = (ml_arm_fir_instance_q15Object *)S;
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_fir_q15(selfS->instance,pSrc_converted,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_fast_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_fir_instance_q15Object *selfS = (ml_arm_fir_instance_q15Object *)S;
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_fir_fast_q15(selfS->instance,pSrc_converted,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_init_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numTaps; // input
-  PyObject *pCoeffs=NULL; // input
-  q15_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q15_t *pState_converted=NULL; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OhOO",&S,&numTaps,&pCoeffs,&pState))
-  {
-
-    ml_arm_fir_instance_q15Object *selfS = (ml_arm_fir_instance_q15Object *)S;
-    GETARGUMENT(pCoeffs,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepState - arraySizepCoeffs + 1;
-
-    arm_status returnValue = arm_fir_init_q15(selfS->instance,numTaps,pCoeffs_converted,pState_converted,blockSize);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_fir_instance_q31Object *selfS = (ml_arm_fir_instance_q31Object *)S;
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_fir_q31(selfS->instance,pSrc_converted,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_fast_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_fir_instance_q31Object *selfS = (ml_arm_fir_instance_q31Object *)S;
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_fir_fast_q31(selfS->instance,pSrc_converted,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_init_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numTaps; // input
-  PyObject *pCoeffs=NULL; // input
-  q31_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q31_t *pState_converted=NULL; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OhOO",&S,&numTaps,&pCoeffs,&pState))
-  {
-
-    ml_arm_fir_instance_q31Object *selfS = (ml_arm_fir_instance_q31Object *)S;
-    GETARGUMENT(pCoeffs,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepState - arraySizepCoeffs + 1;
-
-    arm_fir_init_q31(selfS->instance,numTaps,pCoeffs_converted,pState_converted,blockSize);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_fir_instance_f32Object *selfS = (ml_arm_fir_instance_f32Object *)S;
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_fir_f32(selfS->instance,pSrc_converted,pDst,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numTaps; // input
-  PyObject *pCoeffs=NULL; // input
-  float32_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  float32_t *pState_converted=NULL; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OhOO",&S,&numTaps,&pCoeffs,&pState))
-  {
-
-    ml_arm_fir_instance_f32Object *selfS = (ml_arm_fir_instance_f32Object *)S;
-    GETARGUMENT(pCoeffs,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepState - arraySizepCoeffs + 1;
-
-    arm_fir_init_f32(selfS->instance,numTaps,pCoeffs_converted,pState_converted,blockSize);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_biquad_cascade_df1_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_biquad_casd_df1_inst_q15Object *selfS = (ml_arm_biquad_casd_df1_inst_q15Object *)S;
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_biquad_cascade_df1_q15(selfS->instance,pSrc_converted,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_biquad_cascade_df1_init_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint32_t numStages; // input
-  PyObject *pCoeffs=NULL; // input
-  q15_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q15_t *pState_converted=NULL; // input
-  int32_t postShift; // input
-
-  if (PyArg_ParseTuple(args,"OiOOi",&S,&numStages,&pCoeffs,&pState,&postShift))
-  {
-
-    ml_arm_biquad_casd_df1_inst_q15Object *selfS = (ml_arm_biquad_casd_df1_inst_q15Object *)S;
-    GETARGUMENT(pCoeffs,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
-
-    arm_biquad_cascade_df1_init_q15(selfS->instance,(uint8_t)numStages,pCoeffs_converted,pState_converted,(int8_t)postShift);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_biquad_cascade_df1_fast_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_biquad_casd_df1_inst_q15Object *selfS = (ml_arm_biquad_casd_df1_inst_q15Object *)S;
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_biquad_cascade_df1_fast_q15(selfS->instance,pSrc_converted,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_biquad_cascade_df1_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_biquad_casd_df1_inst_q31Object *selfS = (ml_arm_biquad_casd_df1_inst_q31Object *)S;
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_biquad_cascade_df1_q31(selfS->instance,pSrc_converted,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_biquad_cascade_df1_fast_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_biquad_casd_df1_inst_q31Object *selfS = (ml_arm_biquad_casd_df1_inst_q31Object *)S;
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_biquad_cascade_df1_fast_q31(selfS->instance,pSrc_converted,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_biquad_cascade_df1_init_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint32_t numStages; // input
-  PyObject *pCoeffs=NULL; // input
-  q31_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q31_t *pState_converted=NULL; // input
-  int32_t postShift; // input
-
-  if (PyArg_ParseTuple(args,"OiOOi",&S,&numStages,&pCoeffs,&pState,&postShift))
-  {
-
-    ml_arm_biquad_casd_df1_inst_q31Object *selfS = (ml_arm_biquad_casd_df1_inst_q31Object *)S;
-    GETARGUMENT(pCoeffs,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
-
-    arm_biquad_cascade_df1_init_q31(selfS->instance,(uint8_t)numStages,pCoeffs_converted,pState_converted,(int8_t)postShift);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_biquad_cascade_df1_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_biquad_casd_df1_inst_f32Object *selfS = (ml_arm_biquad_casd_df1_inst_f32Object *)S;
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_biquad_cascade_df1_f32(selfS->instance,pSrc_converted,pDst,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_biquad_cascade_df1_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint32_t numStages; // input
-  PyObject *pCoeffs=NULL; // input
-  float32_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  float32_t *pState_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OiOO",&S,&numStages,&pCoeffs,&pState))
-  {
-
-    ml_arm_biquad_casd_df1_inst_f32Object *selfS = (ml_arm_biquad_casd_df1_inst_f32Object *)S;
-    GETARGUMENT(pCoeffs,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
-
-    arm_biquad_cascade_df1_init_f32(selfS->instance,(uint8_t)numStages,pCoeffs_converted,pState_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mat_add_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  arm_matrix_instance_f32 *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  arm_matrix_instance_f32 *pSrcB_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    arm_matrix_instance_f32 *pSrcA_converted = f32MatrixFromNumpy(pSrcA);
-    arm_matrix_instance_f32 *pSrcB_converted = f32MatrixFromNumpy(pSrcB);
-    uint32_t row = pSrcA_converted->numRows ;
-    uint32_t column = pSrcB_converted->numCols ;
-    arm_matrix_instance_f32 *pDst_converted = createf32Matrix(row,column);
-
-    arm_status returnValue = arm_mat_add_f32(pSrcA_converted,pSrcB_converted,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromf32Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mat_add_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  arm_matrix_instance_q15 *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  arm_matrix_instance_q15 *pSrcB_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    arm_matrix_instance_q15 *pSrcA_converted = q15MatrixFromNumpy(pSrcA);
-    arm_matrix_instance_q15 *pSrcB_converted = q15MatrixFromNumpy(pSrcB);
-    uint32_t row = pSrcA_converted->numRows ;
-    uint32_t column = pSrcB_converted->numCols ;
-    arm_matrix_instance_q15 *pDst_converted = createq15Matrix(row,column);
-
-    arm_status returnValue = arm_mat_add_q15(pSrcA_converted,pSrcB_converted,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromq15Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mat_add_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  arm_matrix_instance_q31 *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  arm_matrix_instance_q31 *pSrcB_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    arm_matrix_instance_q31 *pSrcA_converted = q31MatrixFromNumpy(pSrcA);
-    arm_matrix_instance_q31 *pSrcB_converted = q31MatrixFromNumpy(pSrcB);
-    uint32_t row = pSrcA_converted->numRows ;
-    uint32_t column = pSrcB_converted->numCols ;
-    arm_matrix_instance_q31 *pDst_converted = createq31Matrix(row,column);
-
-    arm_status returnValue = arm_mat_add_q31(pSrcA_converted,pSrcB_converted,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromq31Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mat_cmplx_trans_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  arm_matrix_instance_f32 *pSrc_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    arm_matrix_instance_f32 *pSrc_converted = f32MatrixFromNumpy(pSrc);
-    pSrc_converted->numCols = pSrc_converted->numCols / 2;
-
-    uint32_t row = pSrc_converted->numCols ;
-    uint32_t column = pSrc_converted->numRows*2 ;
-    arm_matrix_instance_f32 *pDst_converted = createf32Matrix(row,column);
-    /*
-    Dimensions in matrix instance are not correct but they are not used
-    by CMSIS-DSP since the library is not compiled with ARM_MATRIX_CHECK.
-    So only source dimensions are used for the computation.
-
-    The dimensions are correct for createf32Matrix since we need to create
-    a bigger buffer and createf32Matrix only knows real.
-
-    */
-
-    arm_status returnValue = arm_mat_cmplx_trans_f32(pSrc_converted,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromf32Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mat_cmplx_trans_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  arm_matrix_instance_q31 *pSrc_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    arm_matrix_instance_q31 *pSrc_converted = q31MatrixFromNumpy(pSrc);
-    pSrc_converted->numCols = pSrc_converted->numCols / 2;
-
-    uint32_t row = pSrc_converted->numCols ;
-    uint32_t column = pSrc_converted->numRows*2 ;
-    arm_matrix_instance_q31 *pDst_converted = createq31Matrix(row,column);
-    /*
-    Dimensions in matrix instance are not correct but they are not used
-    by CMSIS-DSP since the library is not compiled with ARM_MATRIX_CHECK.
-    So only source dimensions are used for the computation.
-
-    The dimensions are correct for createf32Matrix since we need to create
-    a bigger buffer and createf32Matrix only knows real.
-
-    */
-
-    arm_status returnValue = arm_mat_cmplx_trans_q31(pSrc_converted,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromq31Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mat_cmplx_trans_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  arm_matrix_instance_q15 *pSrc_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    arm_matrix_instance_q15 *pSrc_converted = q15MatrixFromNumpy(pSrc);
-    pSrc_converted->numCols = pSrc_converted->numCols / 2;
-
-    uint32_t row = pSrc_converted->numCols ;
-    uint32_t column = pSrc_converted->numRows*2 ;
-    arm_matrix_instance_q15 *pDst_converted = createq15Matrix(row,column);
-    /*
-    Dimensions in matrix instance are not correct but they are not used
-    by CMSIS-DSP since the library is not compiled with ARM_MATRIX_CHECK.
-    So only source dimensions are used for the computation.
-
-    The dimensions are correct for createf32Matrix since we need to create
-    a bigger buffer and createf32Matrix only knows real.
-
-    */
-
-    arm_status returnValue = arm_mat_cmplx_trans_q15(pSrc_converted,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromq15Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mat_cmplx_mult_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  arm_matrix_instance_f32 *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  arm_matrix_instance_f32 *pSrcB_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    arm_matrix_instance_f32 *pSrcA_converted = f32MatrixFromNumpy(pSrcA);
-    arm_matrix_instance_f32 *pSrcB_converted = f32MatrixFromNumpy(pSrcB);
-    pSrcA_converted->numCols = pSrcA_converted->numCols / 2;
-    pSrcB_converted->numCols = pSrcB_converted->numCols / 2;
-    uint32_t row = pSrcA_converted->numRows ;
-    uint32_t column = pSrcB_converted->numCols * 2;
-    arm_matrix_instance_f32 *pDst_converted = createf32Matrix(row,column);
-
-    arm_status returnValue = arm_mat_cmplx_mult_f32(pSrcA_converted,pSrcB_converted,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromf32Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mat_cmplx_mult_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  arm_matrix_instance_q15 *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  arm_matrix_instance_q15 *pSrcB_converted=NULL; // input
-  PyObject *pScratch=NULL; // input
-  q15_t *pScratch_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OOO",&pSrcA,&pSrcB,&pScratch))
-  {
-
-    arm_matrix_instance_q15 *pSrcA_converted = q15MatrixFromNumpy(pSrcA);
-    arm_matrix_instance_q15 *pSrcB_converted = q15MatrixFromNumpy(pSrcB);
-    GETARGUMENT(pScratch,NPY_INT16,int16_t,int16_t);
-    pSrcA_converted->numCols = pSrcA_converted->numCols / 2;
-    pSrcB_converted->numCols = pSrcB_converted->numCols / 2;
-    uint32_t row = pSrcA_converted->numRows ;
-    uint32_t column = pSrcB_converted->numCols * 2;
-    arm_matrix_instance_q15 *pDst_converted = createq15Matrix(row,column);
-
-    arm_status returnValue = arm_mat_cmplx_mult_q15(pSrcA_converted,pSrcB_converted,pDst_converted,pScratch_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromq15Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    FREEARGUMENT(pScratch_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mat_cmplx_mult_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  arm_matrix_instance_q31 *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  arm_matrix_instance_q31 *pSrcB_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    arm_matrix_instance_q31 *pSrcA_converted = q31MatrixFromNumpy(pSrcA);
-    arm_matrix_instance_q31 *pSrcB_converted = q31MatrixFromNumpy(pSrcB);
-    pSrcA_converted->numCols = pSrcA_converted->numCols / 2;
-    pSrcB_converted->numCols = pSrcB_converted->numCols / 2;
-    uint32_t row = pSrcA_converted->numRows ;
-    uint32_t column = pSrcB_converted->numCols * 2;
-    arm_matrix_instance_q31 *pDst_converted = createq31Matrix(row,column);
-
-    arm_status returnValue = arm_mat_cmplx_mult_q31(pSrcA_converted,pSrcB_converted,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromq31Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mat_trans_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  arm_matrix_instance_f32 *pSrc_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    arm_matrix_instance_f32 *pSrc_converted = f32MatrixFromNumpy(pSrc);
-    uint32_t row = pSrc_converted->numCols ;
-    uint32_t column = pSrc_converted->numRows ;
-    arm_matrix_instance_f32 *pDst_converted = createf32Matrix(row,column);
-
-    arm_status returnValue = arm_mat_trans_f32(pSrc_converted,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromf32Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mat_trans_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  arm_matrix_instance_q7 *pSrc_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    arm_matrix_instance_q7 *pSrc_converted = q7MatrixFromNumpy(pSrc);
-    uint32_t row = pSrc_converted->numCols ;
-    uint32_t column = pSrc_converted->numRows ;
-    arm_matrix_instance_q7 *pDst_converted = createq7Matrix(row,column);
-
-    arm_status returnValue = arm_mat_trans_q7(pSrc_converted,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromq7Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mat_trans_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  arm_matrix_instance_q15 *pSrc_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    arm_matrix_instance_q15 *pSrc_converted = q15MatrixFromNumpy(pSrc);
-    uint32_t row = pSrc_converted->numCols ;
-    uint32_t column = pSrc_converted->numRows ;
-    arm_matrix_instance_q15 *pDst_converted = createq15Matrix(row,column);
-
-    arm_status returnValue = arm_mat_trans_q15(pSrc_converted,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromq15Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mat_trans_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  arm_matrix_instance_q31 *pSrc_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    arm_matrix_instance_q31 *pSrc_converted = q31MatrixFromNumpy(pSrc);
-    uint32_t row = pSrc_converted->numCols ;
-    uint32_t column = pSrc_converted->numRows ;
-    arm_matrix_instance_q31 *pDst_converted = createq31Matrix(row,column);
-
-    arm_status returnValue = arm_mat_trans_q31(pSrc_converted,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromq31Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mat_vec_mult_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  arm_matrix_instance_f32 *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  float32_t *pSrcB_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    arm_matrix_instance_f32 *pSrcA_converted = f32MatrixFromNumpy(pSrcA);
-    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
-    uint32_t row = pSrcA_converted->numRows ;
-    uint32_t column = pSrcA_converted->numCols ;
-    pDst=PyMem_Malloc(sizeof(float32_t)*row);
-
-    arm_mat_vec_mult_f32(pSrcA_converted,pSrcB_converted,pDst);
-    FLOATARRAY1(pDstOBJ,row,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mat_mult_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  arm_matrix_instance_f32 *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  arm_matrix_instance_f32 *pSrcB_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    arm_matrix_instance_f32 *pSrcA_converted = f32MatrixFromNumpy(pSrcA);
-    arm_matrix_instance_f32 *pSrcB_converted = f32MatrixFromNumpy(pSrcB);
-    uint32_t row = pSrcA_converted->numRows ;
-    uint32_t column = pSrcB_converted->numCols ;
-    arm_matrix_instance_f32 *pDst_converted = createf32Matrix(row,column);
-
-    arm_status returnValue = arm_mat_mult_f32(pSrcA_converted,pSrcB_converted,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromf32Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mat_vec_mult_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  arm_matrix_instance_q15 *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  q15_t *pSrcB_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    arm_matrix_instance_q15 *pSrcA_converted = q15MatrixFromNumpy(pSrcA);
-    GETARGUMENT(pSrcB,NPY_INT16,int16_t,q15_t);
-    uint32_t row = pSrcA_converted->numRows ;
-    uint32_t column = pSrcA_converted->numCols ;
-    pDst=PyMem_Malloc(sizeof(q15_t)*row);
-
-    arm_mat_vec_mult_q15(pSrcA_converted,pSrcB_converted,pDst);
-    INT16ARRAY1(pDstOBJ,row,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mat_vec_mult_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  arm_matrix_instance_q7 *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  q7_t *pSrcB_converted=NULL; // input
-  q7_t *pDst=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    arm_matrix_instance_q7 *pSrcA_converted = q7MatrixFromNumpy(pSrcA);
-    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
-    uint32_t row = pSrcA_converted->numRows ;
-    uint32_t column = pSrcA_converted->numCols ;
-    pDst=PyMem_Malloc(sizeof(q7_t)*row);
-
-    arm_mat_vec_mult_q7(pSrcA_converted,pSrcB_converted,pDst);
-    INT8ARRAY1(pDstOBJ,row,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mat_mult_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  arm_matrix_instance_q7 *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  arm_matrix_instance_q7 *pSrcB_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q7_t *pState_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OOO",&pSrcA,&pSrcB,&pState))
-  {
-
-    arm_matrix_instance_q7 *pSrcA_converted = q7MatrixFromNumpy(pSrcA);
-    arm_matrix_instance_q7 *pSrcB_converted = q7MatrixFromNumpy(pSrcB);
-    GETARGUMENT(pState,NPY_BYTE,int8_t,q7_t);
-    uint32_t row = pSrcA_converted->numRows ;
-    uint32_t column = pSrcB_converted->numCols ;
-    arm_matrix_instance_q7 *pDst_converted = createq7Matrix(row,column);
-
-    arm_status returnValue = arm_mat_mult_q7(pSrcA_converted,pSrcB_converted,pDst_converted,pState_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromq7Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    FREEARGUMENT(pState_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mat_mult_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  arm_matrix_instance_q15 *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  arm_matrix_instance_q15 *pSrcB_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q15_t *pState_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OOO",&pSrcA,&pSrcB,&pState))
-  {
-
-    arm_matrix_instance_q15 *pSrcA_converted = q15MatrixFromNumpy(pSrcA);
-    arm_matrix_instance_q15 *pSrcB_converted = q15MatrixFromNumpy(pSrcB);
-    
-    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
-    uint32_t row = pSrcA_converted->numRows ;
-    uint32_t column = pSrcB_converted->numCols ;
-    arm_matrix_instance_q15 *pDst_converted = createq15Matrix(row,column);
-
-    arm_status returnValue = arm_mat_mult_q15(pSrcA_converted,pSrcB_converted,pDst_converted,pState_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromq15Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    FREEARGUMENT(pState_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mat_mult_fast_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  arm_matrix_instance_q15 *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  arm_matrix_instance_q15 *pSrcB_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q15_t *pState_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OOO",&pSrcA,&pSrcB,&pState))
-  {
-
-    arm_matrix_instance_q15 *pSrcA_converted = q15MatrixFromNumpy(pSrcA);
-    arm_matrix_instance_q15 *pSrcB_converted = q15MatrixFromNumpy(pSrcB);
-    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
-    uint32_t row = pSrcA_converted->numRows ;
-    uint32_t column = pSrcB_converted->numCols ;
-    arm_matrix_instance_q15 *pDst_converted = createq15Matrix(row,column);
-
-    arm_status returnValue = arm_mat_mult_fast_q15(pSrcA_converted,pSrcB_converted,pDst_converted,pState_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromq15Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    FREEARGUMENT(pState_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mat_vec_mult_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  arm_matrix_instance_q31 *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  q31_t *pSrcB_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    arm_matrix_instance_q31 *pSrcA_converted = q31MatrixFromNumpy(pSrcA);
-    GETARGUMENT(pSrcB,NPY_INT32,int32_t,q31_t);
-    uint32_t row = pSrcA_converted->numRows ;
-    uint32_t column = pSrcA_converted->numCols ;
-    pDst=PyMem_Malloc(sizeof(q31_t)*row);
-
-    arm_mat_vec_mult_q31(pSrcA_converted,pSrcB_converted,pDst);
-    INT32ARRAY1(pDstOBJ,row,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mat_mult_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  arm_matrix_instance_q31 *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  arm_matrix_instance_q31 *pSrcB_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    arm_matrix_instance_q31 *pSrcA_converted = q31MatrixFromNumpy(pSrcA);
-    arm_matrix_instance_q31 *pSrcB_converted = q31MatrixFromNumpy(pSrcB);
-    uint32_t row = pSrcA_converted->numRows ;
-    uint32_t column = pSrcB_converted->numCols ;
-    arm_matrix_instance_q31 *pDst_converted = createq31Matrix(row,column);
-
-    arm_status returnValue = arm_mat_mult_q31(pSrcA_converted,pSrcB_converted,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromq31Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mat_mult_opt_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  arm_matrix_instance_q31 *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  arm_matrix_instance_q31 *pSrcB_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q31_t *pState_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OOO",&pSrcA,&pSrcB,&pState))
-  {
-
-    arm_matrix_instance_q31 *pSrcA_converted = q31MatrixFromNumpy(pSrcA);
-    arm_matrix_instance_q31 *pSrcB_converted = q31MatrixFromNumpy(pSrcB);
-    
-    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
-    uint32_t row = pSrcA_converted->numRows ;
-    uint32_t column = pSrcB_converted->numCols ;
-    arm_matrix_instance_q31 *pDst_converted = createq31Matrix(row,column);
-
-    arm_status returnValue = arm_mat_mult_opt_q31(pSrcA_converted,pSrcB_converted,pDst_converted,pState_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromq31Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    FREEARGUMENT(pState_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mat_mult_fast_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  arm_matrix_instance_q31 *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  arm_matrix_instance_q31 *pSrcB_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    arm_matrix_instance_q31 *pSrcA_converted = q31MatrixFromNumpy(pSrcA);
-    arm_matrix_instance_q31 *pSrcB_converted = q31MatrixFromNumpy(pSrcB);
-    uint32_t row = pSrcA_converted->numRows ;
-    uint32_t column = pSrcB_converted->numCols ;
-    arm_matrix_instance_q31 *pDst_converted = createq31Matrix(row,column);
-
-    arm_status returnValue = arm_mat_mult_fast_q31(pSrcA_converted,pSrcB_converted,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromq31Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mat_sub_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  arm_matrix_instance_f32 *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  arm_matrix_instance_f32 *pSrcB_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    arm_matrix_instance_f32 *pSrcA_converted = f32MatrixFromNumpy(pSrcA);
-    arm_matrix_instance_f32 *pSrcB_converted = f32MatrixFromNumpy(pSrcB);
-    uint32_t row = pSrcA_converted->numRows ;
-    uint32_t column = pSrcB_converted->numCols ;
-    arm_matrix_instance_f32 *pDst_converted = createf32Matrix(row,column);
-
-    arm_status returnValue = arm_mat_sub_f32(pSrcA_converted,pSrcB_converted,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromf32Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mat_sub_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  arm_matrix_instance_q15 *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  arm_matrix_instance_q15 *pSrcB_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    arm_matrix_instance_q15 *pSrcA_converted = q15MatrixFromNumpy(pSrcA);
-    arm_matrix_instance_q15 *pSrcB_converted = q15MatrixFromNumpy(pSrcB);
-    uint32_t row = pSrcA_converted->numRows ;
-    uint32_t column = pSrcB_converted->numCols ;
-    arm_matrix_instance_q15 *pDst_converted = createq15Matrix(row,column);
-
-    arm_status returnValue = arm_mat_sub_q15(pSrcA_converted,pSrcB_converted,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromq15Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mat_sub_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  arm_matrix_instance_q31 *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  arm_matrix_instance_q31 *pSrcB_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    arm_matrix_instance_q31 *pSrcA_converted = q31MatrixFromNumpy(pSrcA);
-    arm_matrix_instance_q31 *pSrcB_converted = q31MatrixFromNumpy(pSrcB);
-    uint32_t row = pSrcA_converted->numRows ;
-    uint32_t column = pSrcB_converted->numCols ;
-    arm_matrix_instance_q31 *pDst_converted = createq31Matrix(row,column);
-
-    arm_status returnValue = arm_mat_sub_q31(pSrcA_converted,pSrcB_converted,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromq31Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mat_scale_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  arm_matrix_instance_f32 *pSrc_converted=NULL; // input
-  float32_t scale; // input
-
-  if (PyArg_ParseTuple(args,"Of",&pSrc,&scale))
-  {
-
-    arm_matrix_instance_f32 *pSrc_converted = f32MatrixFromNumpy(pSrc);
-    uint32_t row = pSrc_converted->numRows ;
-    uint32_t column = pSrc_converted->numCols ;
-    arm_matrix_instance_f32 *pDst_converted = createf32Matrix(row,column);
-
-    arm_status returnValue = arm_mat_scale_f32(pSrc_converted,scale,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromf32Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mat_scale_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  arm_matrix_instance_q15 *pSrc_converted=NULL; // input
-  q15_t scaleFract; // input
-  int32_t shift; // input
-
-  if (PyArg_ParseTuple(args,"Ohi",&pSrc,&scaleFract,&shift))
-  {
-
-    arm_matrix_instance_q15 *pSrc_converted = q15MatrixFromNumpy(pSrc);
-    uint32_t row = pSrc_converted->numRows ;
-    uint32_t column = pSrc_converted->numCols ;
-    arm_matrix_instance_q15 *pDst_converted = createq15Matrix(row,column);
-
-    arm_status returnValue = arm_mat_scale_q15(pSrc_converted,scaleFract,shift,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromq15Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mat_scale_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  arm_matrix_instance_q31 *pSrc_converted=NULL; // input
-  q31_t scaleFract; // input
-  int32_t shift; // input
-
-  if (PyArg_ParseTuple(args,"Oii",&pSrc,&scaleFract,&shift))
-  {
-
-    arm_matrix_instance_q31 *pSrc_converted = q31MatrixFromNumpy(pSrc);
-    uint32_t row = pSrc_converted->numRows ;
-    uint32_t column = pSrc_converted->numCols ;
-    arm_matrix_instance_q31 *pDst_converted = createq31Matrix(row,column);
-
-    arm_status returnValue = arm_mat_scale_q31(pSrc_converted,scaleFract,shift,pDst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pDstOBJ=NumpyArrayFromq31Matrix(pDst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_pid_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  int32_t resetStateFlag; // input
-
-  if (PyArg_ParseTuple(args,"Oi",&S,&resetStateFlag))
-  {
-
-    ml_arm_pid_instance_f32Object *selfS = (ml_arm_pid_instance_f32Object *)S;
-
-    arm_pid_init_f32(selfS->instance,resetStateFlag);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_pid_reset_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&S))
-  {
-
-    ml_arm_pid_instance_f32Object *selfS = (ml_arm_pid_instance_f32Object *)S;
-
-    arm_pid_reset_f32(selfS->instance);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_pid_init_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  int32_t resetStateFlag; // input
-
-  if (PyArg_ParseTuple(args,"Oi",&S,&resetStateFlag))
-  {
-
-    ml_arm_pid_instance_q31Object *selfS = (ml_arm_pid_instance_q31Object *)S;
-
-    arm_pid_init_q31(selfS->instance,resetStateFlag);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_pid_reset_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&S))
-  {
-
-    ml_arm_pid_instance_q31Object *selfS = (ml_arm_pid_instance_q31Object *)S;
-
-    arm_pid_reset_q31(selfS->instance);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_pid_init_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  int32_t resetStateFlag; // input
-
-  if (PyArg_ParseTuple(args,"Oi",&S,&resetStateFlag))
-  {
-
-    ml_arm_pid_instance_q15Object *selfS = (ml_arm_pid_instance_q15Object *)S;
-
-    arm_pid_init_q15(selfS->instance,resetStateFlag);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_pid_reset_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&S))
-  {
-
-    ml_arm_pid_instance_q15Object *selfS = (ml_arm_pid_instance_q15Object *)S;
-
-    arm_pid_reset_q15(selfS->instance);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mult_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q7_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  q7_t *pSrcB_converted=NULL; // input
-  q7_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
-    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrcA ;
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
-
-
-    arm_mult_q7(pSrcA_converted,pSrcB_converted,pDst,blockSize);
- INT8ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mult_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q15_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  q15_t *pSrcB_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrcA ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_mult_q15(pSrcA_converted,pSrcB_converted,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mult_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q31_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  q31_t *pSrcB_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrcA ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_mult_q31(pSrcA_converted,pSrcB_converted,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mult_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  float32_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  float32_t *pSrcB_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrcA ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_mult_f32(pSrcA_converted,pSrcB_converted,pDst,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cfft_radix2_init_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t fftLen; // input
-  uint32_t ifftFlag; // input
-  uint32_t bitReverseFlag; // input
-
-  if (PyArg_ParseTuple(args,"Ohii",&S,&fftLen,&ifftFlag,&bitReverseFlag))
-  {
-
-    ml_arm_cfft_radix2_instance_q15Object *selfS = (ml_arm_cfft_radix2_instance_q15Object *)S;
-
-    arm_status returnValue = arm_cfft_radix2_init_q15(selfS->instance,fftLen,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cfft_radix2_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_cfft_radix2_instance_q15Object *selfS = (ml_arm_cfft_radix2_instance_q15Object *)S;
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-
-    arm_cfft_radix2_q15(selfS->instance,pSrc_converted);
-    FREEARGUMENT(pSrc_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cfft_radix4_init_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t fftLen; // input
-  uint32_t ifftFlag; // input
-  uint32_t bitReverseFlag; // input
-
-  if (PyArg_ParseTuple(args,"Ohii",&S,&fftLen,&ifftFlag,&bitReverseFlag))
-  {
-
-    ml_arm_cfft_radix4_instance_q15Object *selfS = (ml_arm_cfft_radix4_instance_q15Object *)S;
-
-    arm_status returnValue = arm_cfft_radix4_init_q15(selfS->instance,fftLen,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cfft_radix4_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_cfft_radix4_instance_q15Object *selfS = (ml_arm_cfft_radix4_instance_q15Object *)S;
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-
-    arm_cfft_radix4_q15(selfS->instance,pSrc_converted);
-    FREEARGUMENT(pSrc_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cfft_radix2_init_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t fftLen; // input
-  uint32_t ifftFlag; // input
-  uint32_t bitReverseFlag; // input
-
-  if (PyArg_ParseTuple(args,"Ohii",&S,&fftLen,&ifftFlag,&bitReverseFlag))
-  {
-
-    ml_arm_cfft_radix2_instance_q31Object *selfS = (ml_arm_cfft_radix2_instance_q31Object *)S;
-
-    arm_status returnValue = arm_cfft_radix2_init_q31(selfS->instance,fftLen,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cfft_radix2_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_cfft_radix2_instance_q31Object *selfS = (ml_arm_cfft_radix2_instance_q31Object *)S;
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-
-    arm_cfft_radix2_q31(selfS->instance,pSrc_converted);
-    FREEARGUMENT(pSrc_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cfft_radix4_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_cfft_radix4_instance_q31Object *selfS = (ml_arm_cfft_radix4_instance_q31Object *)S;
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-
-    arm_cfft_radix4_q31(selfS->instance,pSrc_converted);
-    FREEARGUMENT(pSrc_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cfft_radix4_init_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t fftLen; // input
-  uint32_t ifftFlag; // input
-  uint32_t bitReverseFlag; // input
-
-  if (PyArg_ParseTuple(args,"Ohii",&S,&fftLen,&ifftFlag,&bitReverseFlag))
-  {
-
-    ml_arm_cfft_radix4_instance_q31Object *selfS = (ml_arm_cfft_radix4_instance_q31Object *)S;
-
-    arm_status returnValue = arm_cfft_radix4_init_q31(selfS->instance,fftLen,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cfft_radix2_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t fftLen; // input
-  uint32_t ifftFlag; // input
-  uint32_t bitReverseFlag; // input
-
-  if (PyArg_ParseTuple(args,"Ohii",&S,&fftLen,&ifftFlag,&bitReverseFlag))
-  {
-
-    ml_arm_cfft_radix2_instance_f32Object *selfS = (ml_arm_cfft_radix2_instance_f32Object *)S;
-
-    arm_status returnValue = arm_cfft_radix2_init_f32(selfS->instance,fftLen,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cfft_radix2_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_cfft_radix2_instance_f32Object *selfS = (ml_arm_cfft_radix2_instance_f32Object *)S;
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-
-    arm_cfft_radix2_f32(selfS->instance,pSrc_converted);
-    FREEARGUMENT(pSrc_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cfft_radix4_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t fftLen; // input
-  uint32_t ifftFlag; // input
-  uint32_t bitReverseFlag; // input
-
-  if (PyArg_ParseTuple(args,"Ohii",&S,&fftLen,&ifftFlag,&bitReverseFlag))
-  {
-
-    ml_arm_cfft_radix4_instance_f32Object *selfS = (ml_arm_cfft_radix4_instance_f32Object *)S;
-
-    arm_status returnValue = arm_cfft_radix4_init_f32(selfS->instance,fftLen,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cfft_radix4_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_cfft_radix4_instance_f32Object *selfS = (ml_arm_cfft_radix4_instance_f32Object *)S;
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-
-    arm_cfft_radix4_f32(selfS->instance,pSrc_converted);
-    FREEARGUMENT(pSrc_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cfft_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *p1=NULL; // input
-  q15_t *p1_converted=NULL; // input
-  uint32_t ifftFlag; // input
-  uint32_t bitReverseFlag; // input
-
-  if (PyArg_ParseTuple(args,"OOii",&S,&p1,&ifftFlag,&bitReverseFlag))
-  {
-
-    ml_arm_cfft_instance_q15Object *selfS = (ml_arm_cfft_instance_q15Object *)S;
-    GETARGUMENT(p1,NPY_INT16,int16_t,int16_t);
-
-    arm_cfft_q15(selfS->instance,p1_converted,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
- INT16ARRAY1(p1OBJ,2*selfS->instance->fftLen,p1_converted);
-
-    PyObject *pythonResult = Py_BuildValue("O",p1OBJ);
-
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cfft_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *p1=NULL; // input
-  q31_t *p1_converted=NULL; // input
-  uint32_t ifftFlag; // input
-  uint32_t bitReverseFlag; // input
-
-  if (PyArg_ParseTuple(args,"OOii",&S,&p1,&ifftFlag,&bitReverseFlag))
-  {
-
-    ml_arm_cfft_instance_q31Object *selfS = (ml_arm_cfft_instance_q31Object *)S;
-    GETARGUMENT(p1,NPY_INT32,int32_t,int32_t);
-
-    arm_cfft_q31(selfS->instance,p1_converted,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
- INT32ARRAY1(p1OBJ,2*selfS->instance->fftLen,p1_converted);
-
-    PyObject *pythonResult = Py_BuildValue("O",p1OBJ);
-
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-
-static PyObject *
-cmsis_arm_cfft_f64(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *p1=NULL; // input
-  float64_t *p1_converted=NULL; // input
-  uint32_t ifftFlag; // input
-  uint32_t bitReverseFlag; // input
-
-  if (PyArg_ParseTuple(args,"OOii",&S,&p1,&ifftFlag,&bitReverseFlag))
-  {
-
-    ml_arm_cfft_instance_f64Object *selfS = (ml_arm_cfft_instance_f64Object *)S;
-    GETARGUMENT(p1,NPY_DOUBLE,double,float64_t);
-
-    arm_cfft_f64(selfS->instance,p1_converted,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
-    FLOATARRAY1(p1OBJ,2*selfS->instance->fftLen,p1_converted);
-
-    PyObject *pythonResult = Py_BuildValue("O",p1OBJ);
-
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cfft_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *p1=NULL; // input
-  float32_t *p1_converted=NULL; // input
-  uint32_t ifftFlag; // input
-  uint32_t bitReverseFlag; // input
-
-  if (PyArg_ParseTuple(args,"OOii",&S,&p1,&ifftFlag,&bitReverseFlag))
-  {
-
-    ml_arm_cfft_instance_f32Object *selfS = (ml_arm_cfft_instance_f32Object *)S;
-    GETARGUMENT(p1,NPY_DOUBLE,double,float32_t);
-
-    arm_cfft_f32(selfS->instance,p1_converted,(uint8_t)ifftFlag,(uint8_t)bitReverseFlag);
- FLOATARRAY1(p1OBJ,2*selfS->instance->fftLen,p1_converted);
-
-    PyObject *pythonResult = Py_BuildValue("O",p1OBJ);
-
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rfft_init_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint32_t fftLenReal; // input
-  uint32_t ifftFlagR; // input
-  uint32_t bitReverseFlag; // input
-
-  if (PyArg_ParseTuple(args,"Oiii",&S,&fftLenReal,&ifftFlagR,&bitReverseFlag))
-  {
-
-    ml_arm_rfft_instance_q15Object *selfS = (ml_arm_rfft_instance_q15Object *)S;
-
-    arm_status returnValue = arm_rfft_init_q15(selfS->instance,fftLenReal,ifftFlagR,bitReverseFlag);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rfft_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_rfft_instance_q15Object *selfS = (ml_arm_rfft_instance_q15Object *)S;
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*2*selfS->instance->fftLenReal);
-
-
-    arm_rfft_q15(selfS->instance,pSrc_converted,pDst);
- INT16ARRAY1(pDstOBJ,2*selfS->instance->fftLenReal,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rfft_init_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint32_t fftLenReal; // input
-  uint32_t ifftFlagR; // input
-  uint32_t bitReverseFlag; // input
-
-  if (PyArg_ParseTuple(args,"Oiii",&S,&fftLenReal,&ifftFlagR,&bitReverseFlag))
-  {
-
-    ml_arm_rfft_instance_q31Object *selfS = (ml_arm_rfft_instance_q31Object *)S;
-
-    arm_status returnValue = arm_rfft_init_q31(selfS->instance,fftLenReal,ifftFlagR,bitReverseFlag);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rfft_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_rfft_instance_q31Object *selfS = (ml_arm_rfft_instance_q31Object *)S;
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*2*selfS->instance->fftLenReal);
-
-
-    arm_rfft_q31(selfS->instance,pSrc_converted,pDst);
- INT32ARRAY1(pDstOBJ,2*selfS->instance->fftLenReal,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rfft_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *S_CFFT=NULL; // input
-  uint32_t fftLenReal; // input
-  uint32_t ifftFlagR; // input
-  uint32_t bitReverseFlag; // input
-
-  if (PyArg_ParseTuple(args,"OOiii",&S,&S_CFFT,&fftLenReal,&ifftFlagR,&bitReverseFlag))
-  {
-
-    ml_arm_rfft_instance_f32Object *selfS = (ml_arm_rfft_instance_f32Object *)S;
-    ml_arm_cfft_radix4_instance_f32Object *selfS_CFFT = (ml_arm_cfft_radix4_instance_f32Object *)S_CFFT;
-
-    arm_status returnValue = arm_rfft_init_f32(selfS->instance,selfS_CFFT->instance,fftLenReal,ifftFlagR,bitReverseFlag);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rfft_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_rfft_instance_f32Object *selfS = (ml_arm_rfft_instance_f32Object *)S;
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*2*selfS->instance->fftLenReal);
-
-
-    arm_rfft_f32(selfS->instance,pSrc_converted,pDst);
- FLOATARRAY1(pDstOBJ,selfS->instance->fftLenReal+1,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_rfft_fast_init_f64(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t fftLen; // input
-
-  if (PyArg_ParseTuple(args,"Oh",&S,&fftLen))
-  {
-
-    ml_arm_rfft_fast_instance_f64Object *selfS = (ml_arm_rfft_fast_instance_f64Object *)S;
-
-    arm_status returnValue = arm_rfft_fast_init_f64(selfS->instance,fftLen);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-#if 0
-static PyObject *
-cmsis_arm_rfft_32_fast_init_f64(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&S))
-  {
-
-    ml_arm_rfft_fast_instance_f64Object *selfS = (ml_arm_rfft_fast_instance_f64Object *)S;
-
-    arm_status returnValue = arm_rfft_32_fast_init_f64(selfS->instance);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rfft_64_fast_init_f64(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&S))
-  {
-
-    ml_arm_rfft_fast_instance_f64Object *selfS = (ml_arm_rfft_fast_instance_f64Object *)S;
-
-    arm_status returnValue = arm_rfft_64_fast_init_f64(selfS->instance);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rfft_128_fast_init_f64(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&S))
-  {
-
-    ml_arm_rfft_fast_instance_f64Object *selfS = (ml_arm_rfft_fast_instance_f64Object *)S;
-
-    arm_status returnValue = arm_rfft_128_fast_init_f64(selfS->instance);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rfft_256_fast_init_f64(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&S))
-  {
-
-    ml_arm_rfft_fast_instance_f64Object *selfS = (ml_arm_rfft_fast_instance_f64Object *)S;
-
-    arm_status returnValue = arm_rfft_256_fast_init_f64(selfS->instance);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rfft_512_fast_init_f64(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&S))
-  {
-
-    ml_arm_rfft_fast_instance_f64Object *selfS = (ml_arm_rfft_fast_instance_f64Object *)S;
-
-    arm_status returnValue = arm_rfft_512_fast_init_f64(selfS->instance);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rfft_1024_fast_init_f64(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&S))
-  {
-
-    ml_arm_rfft_fast_instance_f64Object *selfS = (ml_arm_rfft_fast_instance_f64Object *)S;
-
-    arm_status returnValue = arm_rfft_1024_fast_init_f64(selfS->instance);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rfft_2048_fast_init_f64(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&S))
-  {
-
-    ml_arm_rfft_fast_instance_f64Object *selfS = (ml_arm_rfft_fast_instance_f64Object *)S;
-
-    arm_status returnValue = arm_rfft_2048_fast_init_f64(selfS->instance);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rfft_4096_fast_init_f64(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&S))
-  {
-
-    ml_arm_rfft_fast_instance_f64Object *selfS = (ml_arm_rfft_fast_instance_f64Object *)S;
-
-    arm_status returnValue = arm_rfft_4096_fast_init_f64(selfS->instance);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-#endif
-
-static PyObject *
-cmsis_arm_rfft_fast_f64(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *p=NULL; // input
-  float64_t *p_converted=NULL; // input
-  float64_t *pOut=NULL; // output
-  uint32_t ifftFlag; // input
-
-  if (PyArg_ParseTuple(args,"OOi",&S,&p,&ifftFlag))
-  {
-
-    ml_arm_rfft_fast_instance_f64Object *selfS = (ml_arm_rfft_fast_instance_f64Object *)S;
-    GETARGUMENT(p,NPY_DOUBLE,double,float64_t);
-
-    pOut=PyMem_Malloc(sizeof(float64_t)*2*selfS->instance->fftLenRFFT);
-
-
-    arm_rfft_fast_f64(selfS->instance,p_converted,pOut,(uint8_t)ifftFlag);
- FLOATARRAY1(pOutOBJ,2*selfS->instance->fftLenRFFT,pOut);
-
-    PyObject *pythonResult = Py_BuildValue("O",pOutOBJ);
-
-    FREEARGUMENT(p_converted);
-    Py_DECREF(pOutOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-
-static PyObject *
-cmsis_arm_rfft_fast_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t fftLen; // input
-
-  if (PyArg_ParseTuple(args,"Oh",&S,&fftLen))
-  {
-
-    ml_arm_rfft_fast_instance_f32Object *selfS = (ml_arm_rfft_fast_instance_f32Object *)S;
-
-    arm_status returnValue = arm_rfft_fast_init_f32(selfS->instance,fftLen);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-#if 0
-
-static PyObject *
-cmsis_arm_rfft_32_fast_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&S))
-  {
-
-    ml_arm_rfft_fast_instance_f32Object *selfS = (ml_arm_rfft_fast_instance_f32Object *)S;
-
-    arm_status returnValue = arm_rfft_32_fast_init_f32(selfS->instance);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rfft_64_fast_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&S))
-  {
-
-    ml_arm_rfft_fast_instance_f32Object *selfS = (ml_arm_rfft_fast_instance_f32Object *)S;
-
-    arm_status returnValue = arm_rfft_64_fast_init_f32(selfS->instance);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rfft_128_fast_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&S))
-  {
-
-    ml_arm_rfft_fast_instance_f32Object *selfS = (ml_arm_rfft_fast_instance_f32Object *)S;
-
-    arm_status returnValue = arm_rfft_128_fast_init_f32(selfS->instance);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rfft_256_fast_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&S))
-  {
-
-    ml_arm_rfft_fast_instance_f32Object *selfS = (ml_arm_rfft_fast_instance_f32Object *)S;
-
-    arm_status returnValue = arm_rfft_256_fast_init_f32(selfS->instance);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rfft_512_fast_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&S))
-  {
-
-    ml_arm_rfft_fast_instance_f32Object *selfS = (ml_arm_rfft_fast_instance_f32Object *)S;
-
-    arm_status returnValue = arm_rfft_512_fast_init_f32(selfS->instance);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rfft_1024_fast_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&S))
-  {
-
-    ml_arm_rfft_fast_instance_f32Object *selfS = (ml_arm_rfft_fast_instance_f32Object *)S;
-
-    arm_status returnValue = arm_rfft_1024_fast_init_f32(selfS->instance);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rfft_2048_fast_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&S))
-  {
-
-    ml_arm_rfft_fast_instance_f32Object *selfS = (ml_arm_rfft_fast_instance_f32Object *)S;
-
-    arm_status returnValue = arm_rfft_2048_fast_init_f32(selfS->instance);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rfft_4096_fast_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&S))
-  {
-
-    ml_arm_rfft_fast_instance_f32Object *selfS = (ml_arm_rfft_fast_instance_f32Object *)S;
-
-    arm_status returnValue = arm_rfft_4096_fast_init_f32(selfS->instance);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-#endif 
-
-static PyObject *
-cmsis_arm_rfft_fast_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *p=NULL; // input
-  float32_t *p_converted=NULL; // input
-  float32_t *pOut=NULL; // output
-  uint32_t ifftFlag; // input
-
-  if (PyArg_ParseTuple(args,"OOi",&S,&p,&ifftFlag))
-  {
-
-    ml_arm_rfft_fast_instance_f32Object *selfS = (ml_arm_rfft_fast_instance_f32Object *)S;
-    GETARGUMENT(p,NPY_DOUBLE,double,float32_t);
-
-    pOut=PyMem_Malloc(sizeof(float32_t)*(selfS->instance->fftLenRFFT));
-
-
-    arm_rfft_fast_f32(selfS->instance,p_converted,pOut,(uint8_t)ifftFlag);
- FLOATARRAY1(pOutOBJ,(selfS->instance->fftLenRFFT),pOut);
-
-    PyObject *pythonResult = Py_BuildValue("O",pOutOBJ);
-
-    FREEARGUMENT(p_converted);
-    Py_DECREF(pOutOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_dct4_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *S_RFFT=NULL; // input
-  PyObject *S_CFFT=NULL; // input
-  uint16_t N; // input
-  uint16_t Nby2; // input
-  float32_t normalize; // input
-
-  if (PyArg_ParseTuple(args,"OOOhhf",&S,&S_RFFT,&S_CFFT,&N,&Nby2,&normalize))
-  {
-
-    ml_arm_dct4_instance_f32Object *selfS = (ml_arm_dct4_instance_f32Object *)S;
-    ml_arm_rfft_instance_f32Object *selfS_RFFT = (ml_arm_rfft_instance_f32Object *)S_RFFT;
-    ml_arm_cfft_radix4_instance_f32Object *selfS_CFFT = (ml_arm_cfft_radix4_instance_f32Object *)S_CFFT;
-    uint32_t outputLength = selfS->instance->N ;
-
-    arm_status returnValue = arm_dct4_init_f32(selfS->instance,selfS_RFFT->instance,selfS_CFFT->instance,N,Nby2,normalize);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_dct4_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pState=NULL; // input
-  float32_t *pState_converted=NULL; // input
-  PyObject *pInlineBuffer=NULL; // input
-  float32_t *pInlineBuffer_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OOO",&S,&pState,&pInlineBuffer))
-  {
-
-    ml_arm_dct4_instance_f32Object *selfS = (ml_arm_dct4_instance_f32Object *)S;
-    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pInlineBuffer,NPY_DOUBLE,double,float32_t);
-    uint32_t outputLength = selfS->instance->N ;
-
-    arm_dct4_f32(selfS->instance,pState_converted,pInlineBuffer_converted);
- FLOATARRAY1(pInlineBufferOBJ,outputLength,pInlineBuffer_converted);
-
-    PyObject *pythonResult = Py_BuildValue("O",pInlineBufferOBJ);
-
-    FREEARGUMENT(pState_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_dct4_init_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *S_RFFT=NULL; // input
-  PyObject *S_CFFT=NULL; // input
-  uint16_t N; // input
-  uint16_t Nby2; // input
-  q31_t normalize; // input
-
-  if (PyArg_ParseTuple(args,"OOOhhi",&S,&S_RFFT,&S_CFFT,&N,&Nby2,&normalize))
-  {
-
-    ml_arm_dct4_instance_q31Object *selfS = (ml_arm_dct4_instance_q31Object *)S;
-    ml_arm_rfft_instance_q31Object *selfS_RFFT = (ml_arm_rfft_instance_q31Object *)S_RFFT;
-    ml_arm_cfft_radix4_instance_q31Object *selfS_CFFT = (ml_arm_cfft_radix4_instance_q31Object *)S_CFFT;
-    uint32_t outputLength = selfS->instance->N ;
-
-    arm_status returnValue = arm_dct4_init_q31(selfS->instance,selfS_RFFT->instance,selfS_CFFT->instance,N,Nby2,normalize);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_dct4_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pState=NULL; // input
-  q31_t *pState_converted=NULL; // input
-  PyObject *pInlineBuffer=NULL; // input
-  q31_t *pInlineBuffer_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OOO",&S,&pState,&pInlineBuffer))
-  {
-
-    ml_arm_dct4_instance_q31Object *selfS = (ml_arm_dct4_instance_q31Object *)S;
-    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pInlineBuffer,NPY_INT32,int32_t,int32_t);
-    uint32_t outputLength = selfS->instance->N ;
-
-    arm_dct4_q31(selfS->instance,pState_converted,pInlineBuffer_converted);
- INT32ARRAY1(pInlineBufferOBJ,outputLength,pInlineBuffer_converted);
-
-    PyObject *pythonResult = Py_BuildValue("O",pInlineBufferOBJ);
-
-    FREEARGUMENT(pState_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_dct4_init_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *S_RFFT=NULL; // input
-  PyObject *S_CFFT=NULL; // input
-  uint16_t N; // input
-  uint16_t Nby2; // input
-  q15_t normalize; // input
-
-  if (PyArg_ParseTuple(args,"OOOhhh",&S,&S_RFFT,&S_CFFT,&N,&Nby2,&normalize))
-  {
-
-    ml_arm_dct4_instance_q15Object *selfS = (ml_arm_dct4_instance_q15Object *)S;
-    ml_arm_rfft_instance_q15Object *selfS_RFFT = (ml_arm_rfft_instance_q15Object *)S_RFFT;
-    ml_arm_cfft_radix4_instance_q15Object *selfS_CFFT = (ml_arm_cfft_radix4_instance_q15Object *)S_CFFT;
-    uint32_t outputLength = selfS->instance->N ;
-
-    arm_status returnValue = arm_dct4_init_q15(selfS->instance,selfS_RFFT->instance,selfS_CFFT->instance,N,Nby2,normalize);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_dct4_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pState=NULL; // input
-  q15_t *pState_converted=NULL; // input
-  PyObject *pInlineBuffer=NULL; // input
-  q15_t *pInlineBuffer_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OOO",&S,&pState,&pInlineBuffer))
-  {
-
-    ml_arm_dct4_instance_q15Object *selfS = (ml_arm_dct4_instance_q15Object *)S;
-    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pInlineBuffer,NPY_INT16,int16_t,int16_t);
-    uint32_t outputLength = selfS->instance->N ;
-
-    arm_dct4_q15(selfS->instance,pState_converted,pInlineBuffer_converted);
- INT16ARRAY1(pInlineBufferOBJ,outputLength,pInlineBuffer_converted);
-
-    PyObject *pythonResult = Py_BuildValue("O",pInlineBufferOBJ);
-
-    FREEARGUMENT(pState_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_levinson_durbin_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pPhi=NULL; // input
-  q31_t *pPhi_converted=NULL; // input
-  q31_t *pA=NULL; // output
-  q31_t err; // output
-  uint32_t nbCoefs; // input
-
-  if (PyArg_ParseTuple(args,"Oi",&pPhi,&nbCoefs))
-  {
-
-    GETARGUMENT(pPhi,NPY_INT32,int32_t,q31_t);
-
-    pA=PyMem_Malloc(sizeof(q31_t)*nbCoefs);
-
-
-    arm_levinson_durbin_q31(pPhi_converted,pA,&err,nbCoefs);
-    
-    INT32ARRAY1(pAOBJ,nbCoefs,pA);
-
-    PyObject *pythonResult = Py_BuildValue("Oi",pAOBJ,err);
-
-    FREEARGUMENT(pPhi_converted);
-    Py_DECREF(pAOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_levinson_durbin_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pPhi=NULL; // input
-  float32_t *pPhi_converted=NULL; // input
-  float32_t *pA=NULL; // output
-  float32_t err; // output
-  uint32_t nbCoefs; // input
-
-  if (PyArg_ParseTuple(args,"Oi",&pPhi,&nbCoefs))
-  {
-
-    GETARGUMENT(pPhi,NPY_DOUBLE,double,float32_t);
-
-    pA=PyMem_Malloc(sizeof(float32_t)*nbCoefs);
-
-
-    arm_levinson_durbin_f32(pPhi_converted,pA,&err,nbCoefs);
-    
-    FLOATARRAY1(pAOBJ,nbCoefs,pA);
-
-    PyObject *pythonResult = Py_BuildValue("Of",pAOBJ,err);
-
-    FREEARGUMENT(pPhi_converted);
-    Py_DECREF(pAOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_quaternion_product_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  float32_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  float32_t *pSrcB_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t nbQuaternions; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
-    nbQuaternions = arraySizepSrcA / 4 ;
-
-    pDst=PyMem_Malloc(4*sizeof(float32_t)*nbQuaternions);
-
-
-    arm_quaternion_product_f32(pSrcA_converted,pSrcB_converted,pDst,nbQuaternions);
- FLOATARRAY1(pDstOBJ,4*nbQuaternions,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_quaternion_product_single_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  float32_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  float32_t *pSrcB_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
-
-    pDst=PyMem_Malloc(4*sizeof(float32_t));
-
-
-    arm_quaternion_product_single_f32(pSrcA_converted,pSrcB_converted,pDst);
- FLOATARRAY1(pDstOBJ,4,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_add_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  float32_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  float32_t *pSrcB_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrcA ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_add_f32(pSrcA_converted,pSrcB_converted,pDst,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-/*
-
-For the arm_(and|xor|or)_u(32|16|8)
-
-*/
-
-#define U_UN_OP(OP,TYP,EXT,NPYTYPE)                     \
-static PyObject *                                       \
-cmsis_arm_##OP##_##EXT(PyObject *obj, PyObject *args)   \
-{                                                       \
-                                                        \
-  PyObject *pSrcA=NULL;                                 \
-  TYP *pSrcA_converted=NULL;                            \
-  TYP *pDst=NULL;                                       \
-  uint32_t blockSize;                                   \
-                                                        \
-  if (PyArg_ParseTuple(args,"O",&pSrcA))                \
-  {                                                     \
-                                                        \
-    GETARGUMENT(pSrcA,NPYTYPE,TYP,TYP);                 \
-    blockSize = arraySizepSrcA ;                        \
-                                                        \
-    pDst=PyMem_Malloc(sizeof(TYP)*blockSize);           \
-                                                        \
-                                                        \
-    arm_##OP##_##EXT(pSrcA_converted,pDst,blockSize);   \
- TYP_ARRAY1(pDstOBJ,blockSize,pDst,NPYTYPE);            \
-                                                        \
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);\
-                                                        \
-    FREEARGUMENT(pSrcA_converted);                      \
-    Py_DECREF(pDstOBJ);                                 \
-    return(pythonResult);                               \
-                                                        \
-  }                                                     \
-  return(NULL);                                         \
-}
-
-#define U_BIN_OP(OP,TYP,EXT,NPYTYPE)                                 \
-static PyObject *                                                    \
-cmsis_arm_##OP##_##EXT(PyObject *obj, PyObject *args)                \
-{                                                                    \
-                                                                     \
-  PyObject *pSrcA=NULL;                                              \
-  TYP *pSrcA_converted=NULL;                                         \
-  PyObject *pSrcB=NULL;                                              \
-  TYP *pSrcB_converted=NULL;                                         \
-  TYP *pDst=NULL;                                                    \
-  uint32_t blockSize;                                                \
-                                                                     \
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))                     \
-  {                                                                  \
-                                                                     \
-    GETARGUMENT(pSrcA,NPYTYPE,TYP,TYP);                              \
-    GETARGUMENT(pSrcB,NPYTYPE,TYP,TYP);                              \
-    blockSize = arraySizepSrcA ;                                     \
-                                                                     \
-    pDst=PyMem_Malloc(sizeof(TYP)*blockSize);                        \
-                                                                     \
-                                                                     \
-    arm_##OP##_##EXT(pSrcA_converted,pSrcB_converted,pDst,blockSize);\
- TYP_ARRAY1(pDstOBJ,blockSize,pDst,NPYTYPE);                         \
-                                                                     \
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);             \
-                                                                     \
-    FREEARGUMENT(pSrcA_converted);                                   \
-    FREEARGUMENT(pSrcB_converted);                                   \
-    Py_DECREF(pDstOBJ);                                              \
-    return(pythonResult);                                            \
-                                                                     \
-  }                                                                  \
-  return(NULL);                                                      \
-}
-
-U_BIN_OP(and,uint32_t,u32,NPY_UINT32);
-U_BIN_OP(and,uint16_t,u16,NPY_UINT16);
-U_BIN_OP(and,uint8_t,u8,NPY_UINT8);
-
-U_BIN_OP(or,uint32_t,u32,NPY_UINT32);
-U_BIN_OP(or,uint16_t,u16,NPY_UINT16);
-U_BIN_OP(or,uint8_t,u8,NPY_UINT8);
-
-U_BIN_OP(xor,uint32_t,u32,NPY_UINT32);
-U_BIN_OP(xor,uint16_t,u16,NPY_UINT16);
-U_BIN_OP(xor,uint8_t,u8,NPY_UINT8);
-
-U_UN_OP(not,uint32_t,u32,NPY_UINT32);
-U_UN_OP(not,uint16_t,u16,NPY_UINT16);
-U_UN_OP(not,uint8_t,u8,NPY_UINT8);
-
-static PyObject *
-cmsis_arm_add_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q7_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  q7_t *pSrcB_converted=NULL; // input
-  q7_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
-    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrcA ;
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
-
-
-    arm_add_q7(pSrcA_converted,pSrcB_converted,pDst,blockSize);
- INT8ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_add_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q15_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  q15_t *pSrcB_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrcA ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_add_q15(pSrcA_converted,pSrcB_converted,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_add_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q31_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  q31_t *pSrcB_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrcA ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_add_q31(pSrcA_converted,pSrcB_converted,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_sub_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  float32_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  float32_t *pSrcB_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrcA ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_sub_f32(pSrcA_converted,pSrcB_converted,pDst,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_sub_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q7_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  q7_t *pSrcB_converted=NULL; // input
-  q7_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
-    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrcA ;
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
-
-
-    arm_sub_q7(pSrcA_converted,pSrcB_converted,pDst,blockSize);
- INT8ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_sub_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q15_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  q15_t *pSrcB_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrcA ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_sub_q15(pSrcA_converted,pSrcB_converted,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_sub_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q31_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  q31_t *pSrcB_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrcA ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_sub_q31(pSrcA_converted,pSrcB_converted,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_quaternion2rotation_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t nbQuaternions; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    nbQuaternions = arraySizepSrc / 4 ;
-
-    pDst=PyMem_Malloc(9*sizeof(float32_t)*nbQuaternions);
-
-
-    arm_quaternion2rotation_f32(pSrc_converted,pDst,nbQuaternions);
- FLOATARRAY1(pDstOBJ,9*nbQuaternions,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_rotation2quaternion_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t nbQuaternions; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    nbQuaternions = arraySizepSrc / 9 ;
-
-    pDst=PyMem_Malloc(4*sizeof(float32_t)*nbQuaternions);
-
-
-    arm_rotation2quaternion_f32(pSrc_converted,pDst,nbQuaternions);
- FLOATARRAY1(pDstOBJ,4*nbQuaternions,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_quaternion_normalize_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t nbQuaternions; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    nbQuaternions = arraySizepSrc / 4 ;
-
-    pDst=PyMem_Malloc(4*sizeof(float32_t)*nbQuaternions);
-
-
-    arm_quaternion_normalize_f32(pSrc_converted,pDst,nbQuaternions);
- FLOATARRAY1(pDstOBJ,4*nbQuaternions,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_quaternion_norm_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t nbQuaternions; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    nbQuaternions = arraySizepSrc / 4 ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*nbQuaternions);
-
-
-    arm_quaternion_norm_f32(pSrc_converted,pDst,nbQuaternions);
- FLOATARRAY1(pDstOBJ,nbQuaternions,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_quaternion_conjugate_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t nbQuaternions; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    nbQuaternions = arraySizepSrc / 4 ;
-
-    pDst=PyMem_Malloc(4*sizeof(float32_t)*nbQuaternions);
-
-
-    arm_quaternion_conjugate_f32(pSrc_converted,pDst,nbQuaternions);
- FLOATARRAY1(pDstOBJ,4*nbQuaternions,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_quaternion_inverse_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t nbQuaternions; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    nbQuaternions = arraySizepSrc / 4 ;
-
-    pDst=PyMem_Malloc(4*sizeof(float32_t)*nbQuaternions);
-
-
-    arm_quaternion_inverse_f32(pSrc_converted,pDst,nbQuaternions);
- FLOATARRAY1(pDstOBJ,4*nbQuaternions,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_scale_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t scale; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"Of",&pSrc,&scale))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_scale_f32(pSrc_converted,scale,pDst,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_scale_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  int32_t scaleFract; // input
-  int32_t shift; // input
-  q7_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"Oii",&pSrc,&scaleFract,&shift))
-  {
-
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
-
-
-    arm_scale_q7(pSrc_converted,(q7_t)scaleFract,(int8_t)shift,pDst,blockSize);
- INT8ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_scale_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t scaleFract; // input
-  int32_t shift; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"Ohi",&pSrc,&scaleFract,&shift))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_scale_q15(pSrc_converted,scaleFract,(int8_t)shift,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_scale_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t scaleFract; // input
-  int32_t shift; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"Oii",&pSrc,&scaleFract,&shift))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_scale_q31(pSrc_converted,scaleFract,(int8_t)shift,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_abs_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  q7_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
-
-
-    arm_abs_q7(pSrc_converted,pDst,blockSize);
- INT8ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_abs_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_abs_f32(pSrc_converted,pDst,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_abs_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_abs_q15(pSrc_converted,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_vlog_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_vlog_q15(pSrc_converted,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_abs_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_abs_q31(pSrc_converted,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_vlog_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_vlog_q31(pSrc_converted,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-#define FLOATDIST(NAME)                                                \
-static PyObject *                                                      \
-cmsis_arm_##NAME##_f32(PyObject *obj, PyObject *args)                  \
-{                                                                      \
-                                                                       \
-  PyObject *pSrcA=NULL;                                                \
-  float32_t *pSrcA_converted=NULL;                                     \
-  PyObject *pSrcB=NULL;                                                \
-  float32_t *pSrcB_converted=NULL;                                     \
-  uint32_t blockSize;                                                  \
-  float32_t *result=NULL;                                              \
-                                                                       \
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))                       \
-  {                                                                    \
-                                                                       \
-    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);                    \
-    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);                    \
-    blockSize = arraySizepSrcA ;                                       \
-                                                                       \
-    result=PyMem_Malloc(sizeof(float32_t)*1);                          \
-                                                                       \
-                                                                       \
-    arm_##NAME##_f32(pSrcA_converted,pSrcB_converted,blockSize,result);\
-    PyObject* resultOBJ=Py_BuildValue("f",*result);                    \
-                                                                       \
-    PyObject *pythonResult = Py_BuildValue("O",resultOBJ);             \
-                                                                       \
-    FREEARGUMENT(pSrcA_converted);                                     \
-    FREEARGUMENT(pSrcB_converted);                                     \
-    Py_DECREF(resultOBJ);                                              \
-    return(pythonResult);                                              \
-                                                                       \
-  }                                                                    \
-  return(NULL);                                                        \
-}
-
-#if 0
-FLOATDIST(braycurtis_distance);
-FLOATDIST(canberra_distance);
-FLOATDIST(chebyshev_distance);
-FLOATDIST(cityblock_distance);
-FLOATDIST(correlation_distance);
-FLOATDIST(cosine_distance);
-FLOATDIST(euclidean_distance);
-FLOATDIST(jensenshannon_distance);
-FLOATDIST(minkowski_distance);
-#endif
-
-static PyObject *
-cmsis_arm_dot_prod_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  float32_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  float32_t *pSrcB_converted=NULL; // input
-  uint32_t blockSize; // input
-  float32_t *result=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrcA ;
-
-    result=PyMem_Malloc(sizeof(float32_t)*1);
-
-
-    arm_dot_prod_f32(pSrcA_converted,pSrcB_converted,blockSize,result);
-    PyObject* resultOBJ=Py_BuildValue("f",*result);
-
-    PyObject *pythonResult = Py_BuildValue("O",resultOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(resultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_dot_prod_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q7_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  q7_t *pSrcB_converted=NULL; // input
-  uint32_t blockSize; // input
-  q31_t *result=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
-    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrcA ;
-
-    result=PyMem_Malloc(sizeof(q31_t)*1);
-
-
-    arm_dot_prod_q7(pSrcA_converted,pSrcB_converted,blockSize,result);
-    PyObject* resultOBJ=Py_BuildValue("i",*result);
-
-    PyObject *pythonResult = Py_BuildValue("O",resultOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(resultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_dot_prod_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q15_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  q15_t *pSrcB_converted=NULL; // input
-  uint32_t blockSize; // input
-  q63_t *result=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrcA ;
-
-    result=PyMem_Malloc(sizeof(q63_t)*1);
-
-
-    arm_dot_prod_q15(pSrcA_converted,pSrcB_converted,blockSize,result);
-    PyObject* resultOBJ=Py_BuildValue("L",*result);
-
-    PyObject *pythonResult = Py_BuildValue("O",resultOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(resultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_dot_prod_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q31_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  q31_t *pSrcB_converted=NULL; // input
-  uint32_t blockSize; // input
-  q63_t *result=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrcA ;
-
-    result=PyMem_Malloc(sizeof(q63_t)*1);
-
-
-    arm_dot_prod_q31(pSrcA_converted,pSrcB_converted,blockSize,result);
-    PyObject* resultOBJ=Py_BuildValue("L",*result);
-
-    PyObject *pythonResult = Py_BuildValue("O",resultOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(resultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_shift_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  int32_t shiftBits; // input
-  q7_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"Oi",&pSrc,&shiftBits))
-  {
-
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
-
-
-    arm_shift_q7(pSrc_converted,(int8_t)shiftBits,pDst,blockSize);
- INT8ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_shift_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  int32_t shiftBits; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"Oi",&pSrc,&shiftBits))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_shift_q15(pSrc_converted,(int8_t)shiftBits,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_shift_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  int32_t shiftBits; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"Oi",&pSrc,&shiftBits))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_shift_q31(pSrc_converted,(int8_t)shiftBits,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_clip_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t low,high; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"Off",&pSrc,&low,&high))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_clip_f32(pSrc_converted,pDst,low,high,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_clip_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t low,high; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"Oii",&pSrc,&low,&high))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_clip_q31(pSrc_converted,pDst,low,high,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_clip_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t low,high; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"Ohh",&pSrc,&low,&high))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_clip_q15(pSrc_converted,pDst,low,high,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_clip_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  int32_t low,high; // input
-  q7_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"Oii",&pSrc,&low,&high))
-  {
-
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
-
-
-    arm_clip_q7(pSrc_converted,pDst,(q7_t)low,(q7_t)high,blockSize);
- INT8ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_fill_f32(PyObject *obj, PyObject *args)
-{
-
-  float32_t value; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"fi",&value,&blockSize))
-  {
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_fill_f32(value,pDst,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_fill_q31(PyObject *obj, PyObject *args)
-{
-
-  q31_t value; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"ii",&value,&blockSize))
-  {
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_fill_q31(value,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_fill_q15(PyObject *obj, PyObject *args)
-{
-
-  q15_t value; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"hi",&value,&blockSize))
-  {
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_fill_q15(value,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_fill_q7(PyObject *obj, PyObject *args)
-{
-
-  q31_t value; // input
-  q7_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"ii",&value,&blockSize))
-  {
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
-
-
-    arm_fill_q7((q7_t)value,pDst,blockSize);
- INT8ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_offset_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t offset; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"Of",&pSrc,&offset))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_offset_f32(pSrc_converted,offset,pDst,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_offset_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  int32_t offset; // input
-  q7_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"Oi",&pSrc,&offset))
-  {
-
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
-
-
-    arm_offset_q7(pSrc_converted,(q7_t)offset,pDst,blockSize);
- INT8ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_offset_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t offset; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"Oh",&pSrc,&offset))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_offset_q15(pSrc_converted,offset,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_offset_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t offset; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"Oi",&pSrc,&offset))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_offset_q31(pSrc_converted,offset,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_negate_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_negate_f32(pSrc_converted,pDst,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_negate_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  q7_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
-
-
-    arm_negate_q7(pSrc_converted,pDst,blockSize);
- INT8ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_negate_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_negate_q15(pSrc_converted,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_negate_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_negate_q31(pSrc_converted,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_copy_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_copy_f32(pSrc_converted,pDst,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_copy_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  q7_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
-
-
-    arm_copy_q7(pSrc_converted,pDst,blockSize);
- INT8ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_copy_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_copy_q15(pSrc_converted,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_copy_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_copy_q31(pSrc_converted,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_conv_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  float32_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  float32_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  float32_t *pDst=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
-  {
-
-    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
-    uint32_t outputLength = srcALen + srcBLen - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*outputLength);
-
-
-    arm_conv_f32(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
- FLOATARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_conv_opt_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q15_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q15_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q15_t *pDst=NULL; // output
-  PyObject *pScratch1=NULL; // input
-  q15_t *pScratch1_converted=NULL; // input
-  PyObject *pScratch2=NULL; // input
-  q15_t *pScratch2_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OiOiOO",&pSrcA,&srcALen,&pSrcB,&srcBLen,&pScratch1,&pScratch2))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pScratch1,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pScratch2,NPY_INT16,int16_t,int16_t);
-    uint32_t outputLength = srcALen + srcBLen - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
-
-
-    arm_conv_opt_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,pScratch1_converted,pScratch2_converted);
- INT16ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    FREEARGUMENT(pScratch1_converted);
-    FREEARGUMENT(pScratch2_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_conv_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q15_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q15_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q15_t *pDst=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
-    uint32_t outputLength = srcALen + srcBLen - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
-
-
-    arm_conv_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
- INT16ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_conv_fast_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q15_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q15_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q15_t *pDst=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
-    uint32_t outputLength = srcALen + srcBLen - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
-
-
-    arm_conv_fast_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
- INT16ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_conv_fast_opt_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q15_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q15_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q15_t *pDst=NULL; // output
-  PyObject *pScratch1=NULL; // input
-  q15_t *pScratch1_converted=NULL; // input
-  PyObject *pScratch2=NULL; // input
-  q15_t *pScratch2_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OiOiOO",&pSrcA,&srcALen,&pSrcB,&srcBLen,&pScratch1,&pScratch2))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pScratch1,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pScratch2,NPY_INT16,int16_t,int16_t);
-    uint32_t outputLength = srcALen + srcBLen - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
-
-
-    arm_conv_fast_opt_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,pScratch1_converted,pScratch2_converted);
- INT16ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    FREEARGUMENT(pScratch1_converted);
-    FREEARGUMENT(pScratch2_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_conv_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q31_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q31_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q31_t *pDst=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
-    uint32_t outputLength = srcALen + srcBLen - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*outputLength);
-
-
-    arm_conv_q31(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
- INT32ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_conv_fast_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q31_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q31_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q31_t *pDst=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
-    uint32_t outputLength = srcALen + srcBLen - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*outputLength);
-
-
-    arm_conv_fast_q31(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
- INT32ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_conv_opt_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q7_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q7_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q7_t *pDst=NULL; // output
-  PyObject *pScratch1=NULL; // input
-  q15_t *pScratch1_converted=NULL; // input
-  PyObject *pScratch2=NULL; // input
-  q15_t *pScratch2_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OiOiOO",&pSrcA,&srcALen,&pSrcB,&srcBLen,&pScratch1,&pScratch2))
-  {
-
-    GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
-    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
-    GETARGUMENT(pScratch1,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pScratch2,NPY_INT16,int16_t,int16_t);
-    uint32_t outputLength = srcALen + srcBLen - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*outputLength);
-
-
-    arm_conv_opt_q7(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,pScratch1_converted,pScratch2_converted);
- INT8ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    FREEARGUMENT(pScratch1_converted);
-    FREEARGUMENT(pScratch2_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_conv_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q7_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q7_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q7_t *pDst=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
-  {
-
-    GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
-    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
-    uint32_t outputLength = srcALen + srcBLen - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*outputLength);
-
-
-    arm_conv_q7(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
- INT8ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_conv_partial_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  float32_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  float32_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  float32_t *pDst=NULL; // output
-  uint32_t firstIndex; // input
-  uint32_t numPoints; // input
-
-  if (PyArg_ParseTuple(args,"OiOiii",&pSrcA,&srcALen,&pSrcB,&srcBLen,&firstIndex,&numPoints))
-  {
-
-    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
-    uint32_t outputLength = srcALen + srcBLen - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*outputLength);
-
-
-    arm_status returnValue = arm_conv_partial_f32(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,firstIndex,numPoints);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
- FLOATARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_conv_partial_opt_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q15_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q15_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q15_t *pDst=NULL; // output
-  uint32_t firstIndex; // input
-  uint32_t numPoints; // input
-  PyObject *pScratch1=NULL; // input
-  q15_t *pScratch1_converted=NULL; // input
-  PyObject *pScratch2=NULL; // input
-  q15_t *pScratch2_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OiOiiiOO",&pSrcA,&srcALen,&pSrcB,&srcBLen,&firstIndex,&numPoints,&pScratch1,&pScratch2))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pScratch1,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pScratch2,NPY_INT16,int16_t,int16_t);
-    uint32_t outputLength = srcALen + srcBLen - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
-
-
-    arm_status returnValue = arm_conv_partial_opt_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,firstIndex,numPoints,pScratch1_converted,pScratch2_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
- INT16ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    FREEARGUMENT(pScratch1_converted);
-    FREEARGUMENT(pScratch2_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_conv_partial_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q15_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q15_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q15_t *pDst=NULL; // output
-  uint32_t firstIndex; // input
-  uint32_t numPoints; // input
-
-  if (PyArg_ParseTuple(args,"OiOiii",&pSrcA,&srcALen,&pSrcB,&srcBLen,&firstIndex,&numPoints))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
-    uint32_t outputLength = srcALen + srcBLen - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
-
-
-    arm_status returnValue = arm_conv_partial_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,firstIndex,numPoints);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
- INT16ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_conv_partial_fast_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q15_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q15_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q15_t *pDst=NULL; // output
-  uint32_t firstIndex; // input
-  uint32_t numPoints; // input
-
-  if (PyArg_ParseTuple(args,"OiOiii",&pSrcA,&srcALen,&pSrcB,&srcBLen,&firstIndex,&numPoints))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
-    uint32_t outputLength = srcALen + srcBLen - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
-
-
-    arm_status returnValue = arm_conv_partial_fast_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,firstIndex,numPoints);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
- INT16ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_conv_partial_fast_opt_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q15_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q15_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q15_t *pDst=NULL; // output
-  uint32_t firstIndex; // input
-  uint32_t numPoints; // input
-  PyObject *pScratch1=NULL; // input
-  q15_t *pScratch1_converted=NULL; // input
-  PyObject *pScratch2=NULL; // input
-  q15_t *pScratch2_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OiOiiiOO",&pSrcA,&srcALen,&pSrcB,&srcBLen,&firstIndex,&numPoints,&pScratch1,&pScratch2))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pScratch1,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pScratch2,NPY_INT16,int16_t,int16_t);
-    uint32_t outputLength = srcALen + srcBLen - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
-
-
-    arm_status returnValue = arm_conv_partial_fast_opt_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,firstIndex,numPoints,pScratch1_converted,pScratch2_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
- INT16ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    FREEARGUMENT(pScratch1_converted);
-    FREEARGUMENT(pScratch2_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_conv_partial_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q31_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q31_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q31_t *pDst=NULL; // output
-  uint32_t firstIndex; // input
-  uint32_t numPoints; // input
-
-  if (PyArg_ParseTuple(args,"OiOiii",&pSrcA,&srcALen,&pSrcB,&srcBLen,&firstIndex,&numPoints))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
-    uint32_t outputLength = srcALen + srcBLen - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*outputLength);
-
-
-    arm_status returnValue = arm_conv_partial_q31(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,firstIndex,numPoints);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
- INT32ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_conv_partial_fast_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q31_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q31_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q31_t *pDst=NULL; // output
-  uint32_t firstIndex; // input
-  uint32_t numPoints; // input
-
-  if (PyArg_ParseTuple(args,"OiOiii",&pSrcA,&srcALen,&pSrcB,&srcBLen,&firstIndex,&numPoints))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
-    uint32_t outputLength = srcALen + srcBLen - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*outputLength);
-
-
-    arm_status returnValue = arm_conv_partial_fast_q31(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,firstIndex,numPoints);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
- INT32ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_conv_partial_opt_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q7_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q7_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q7_t *pDst=NULL; // output
-  uint32_t firstIndex; // input
-  uint32_t numPoints; // input
-  PyObject *pScratch1=NULL; // input
-  q15_t *pScratch1_converted=NULL; // input
-  PyObject *pScratch2=NULL; // input
-  q15_t *pScratch2_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OiOiiiOO",&pSrcA,&srcALen,&pSrcB,&srcBLen,&firstIndex,&numPoints,&pScratch1,&pScratch2))
-  {
-
-    GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
-    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
-    GETARGUMENT(pScratch1,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pScratch2,NPY_INT16,int16_t,int16_t);
-    uint32_t outputLength = srcALen + srcBLen - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*outputLength);
-
-
-    arm_status returnValue = arm_conv_partial_opt_q7(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,firstIndex,numPoints,pScratch1_converted,pScratch2_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
- INT8ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    FREEARGUMENT(pScratch1_converted);
-    FREEARGUMENT(pScratch2_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_conv_partial_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q7_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q7_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q7_t *pDst=NULL; // output
-  uint32_t firstIndex; // input
-  uint32_t numPoints; // input
-
-  if (PyArg_ParseTuple(args,"OiOiii",&pSrcA,&srcALen,&pSrcB,&srcBLen,&firstIndex,&numPoints))
-  {
-
-    GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
-    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
-    uint32_t outputLength = srcALen + srcBLen - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*outputLength);
-
-
-    arm_status returnValue = arm_conv_partial_q7(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,firstIndex,numPoints);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
- INT8ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_decimate_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_fir_decimate_instance_f32Object *selfS = (ml_arm_fir_decimate_instance_f32Object *)S;
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_fir_decimate_f32(selfS->instance,pSrc_converted,pDst,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_decimate_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numTaps; // input
-  uint32_t M; // input
-  PyObject *pCoeffs=NULL; // input
-  float32_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  float32_t *pState_converted=NULL; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OhiOO",&S,&numTaps,&M,&pCoeffs,&pState))
-  {
-
-    ml_arm_fir_decimate_instance_f32Object *selfS = (ml_arm_fir_decimate_instance_f32Object *)S;
-    GETARGUMENT(pCoeffs,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepState - arraySizepCoeffs + 1;
-
-    arm_status returnValue = arm_fir_decimate_init_f32(selfS->instance,numTaps,(uint8_t)M,pCoeffs_converted,pState_converted,blockSize);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_decimate_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_fir_decimate_instance_q15Object *selfS = (ml_arm_fir_decimate_instance_q15Object *)S;
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_fir_decimate_q15(selfS->instance,pSrc_converted,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_decimate_fast_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_fir_decimate_instance_q15Object *selfS = (ml_arm_fir_decimate_instance_q15Object *)S;
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_fir_decimate_fast_q15(selfS->instance,pSrc_converted,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_decimate_init_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numTaps; // input
-  uint32_t M; // input
-  PyObject *pCoeffs=NULL; // input
-  q15_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q15_t *pState_converted=NULL; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OhiOO",&S,&numTaps,&M,&pCoeffs,&pState))
-  {
-
-    ml_arm_fir_decimate_instance_q15Object *selfS = (ml_arm_fir_decimate_instance_q15Object *)S;
-    GETARGUMENT(pCoeffs,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepState - arraySizepCoeffs + 1;
-
-    arm_status returnValue = arm_fir_decimate_init_q15(selfS->instance,numTaps,(uint8_t)M,pCoeffs_converted,pState_converted,blockSize);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_decimate_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_fir_decimate_instance_q31Object *selfS = (ml_arm_fir_decimate_instance_q31Object *)S;
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_fir_decimate_q31(selfS->instance,pSrc_converted,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_decimate_fast_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_fir_decimate_instance_q31Object *selfS = (ml_arm_fir_decimate_instance_q31Object *)S;
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_fir_decimate_fast_q31(selfS->instance,pSrc_converted,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_decimate_init_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numTaps; // input
-  uint32_t M; // input
-  PyObject *pCoeffs=NULL; // input
-  q31_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q31_t *pState_converted=NULL; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OhiOO",&S,&numTaps,&M,&pCoeffs,&pState))
-  {
-
-    ml_arm_fir_decimate_instance_q31Object *selfS = (ml_arm_fir_decimate_instance_q31Object *)S;
-    GETARGUMENT(pCoeffs,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepState - arraySizepCoeffs + 1;
-
-    arm_status returnValue = arm_fir_decimate_init_q31(selfS->instance,numTaps,(uint8_t)M,pCoeffs_converted,pState_converted,blockSize);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_interpolate_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_fir_interpolate_instance_q15Object *selfS = (ml_arm_fir_interpolate_instance_q15Object *)S;
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_fir_interpolate_q15(selfS->instance,pSrc_converted,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_interpolate_init_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint32_t L; // input
-  uint16_t numTaps; // input
-  PyObject *pCoeffs=NULL; // input
-  q15_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q15_t *pState_converted=NULL; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OihOO",&S,&L,&numTaps,&pCoeffs,&pState))
-  {
-
-    ml_arm_fir_interpolate_instance_q15Object *selfS = (ml_arm_fir_interpolate_instance_q15Object *)S;
-    GETARGUMENT(pCoeffs,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepState - arraySizepCoeffs + 1;
-
-    arm_status returnValue = arm_fir_interpolate_init_q15(selfS->instance,(uint8_t)L,numTaps,pCoeffs_converted,pState_converted,blockSize);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_interpolate_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_fir_interpolate_instance_q31Object *selfS = (ml_arm_fir_interpolate_instance_q31Object *)S;
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_fir_interpolate_q31(selfS->instance,pSrc_converted,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_interpolate_init_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint32_t L; // input
-  uint16_t numTaps; // input
-  PyObject *pCoeffs=NULL; // input
-  q31_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q31_t *pState_converted=NULL; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OihOO",&S,&L,&numTaps,&pCoeffs,&pState))
-  {
-
-    ml_arm_fir_interpolate_instance_q31Object *selfS = (ml_arm_fir_interpolate_instance_q31Object *)S;
-    GETARGUMENT(pCoeffs,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepState - arraySizepCoeffs + 1;
-
-    arm_status returnValue = arm_fir_interpolate_init_q31(selfS->instance,(uint8_t)L,numTaps,pCoeffs_converted,pState_converted,blockSize);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_interpolate_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_fir_interpolate_instance_f32Object *selfS = (ml_arm_fir_interpolate_instance_f32Object *)S;
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_fir_interpolate_f32(selfS->instance,pSrc_converted,pDst,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_interpolate_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint32_t L; // input
-  uint16_t numTaps; // input
-  PyObject *pCoeffs=NULL; // input
-  float32_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  float32_t *pState_converted=NULL; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OihOO",&S,&L,&numTaps,&pCoeffs,&pState))
-  {
-
-    ml_arm_fir_interpolate_instance_f32Object *selfS = (ml_arm_fir_interpolate_instance_f32Object *)S;
-    GETARGUMENT(pCoeffs,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepState - arraySizepCoeffs + 1;
-
-    arm_status returnValue = arm_fir_interpolate_init_f32(selfS->instance,(uint8_t)L,numTaps,pCoeffs_converted,pState_converted,blockSize);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_biquad_cas_df1_32x64_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  arm_biquad_cas_df1_32x64_ins_q31 *S_converted=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_biquad_cas_df1_32x64_q31(S_converted,pSrc_converted,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_biquad_cas_df1_32x64_init_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  arm_biquad_cas_df1_32x64_ins_q31 *S_converted=NULL; // input
-  uint32_t numStages; // input
-  PyObject *pCoeffs=NULL; // input
-  q31_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q63_t *pState_converted=NULL; // input
-  uint32_t postShift; // input
-
-  if (PyArg_ParseTuple(args,"OiOOi",&S,&numStages,&pCoeffs,&pState,&postShift))
-  {
-
-    GETARGUMENT(pCoeffs,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pState,NPY_INT64,q63_t,q63_t);
-
-    arm_biquad_cas_df1_32x64_init_q31(S_converted,(uint8_t)numStages,pCoeffs_converted,pState_converted,(uint8_t)postShift);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_biquad_cascade_df2T_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_biquad_cascade_df2T_instance_f32Object *selfS = (ml_arm_biquad_cascade_df2T_instance_f32Object *)S;
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_biquad_cascade_df2T_f32(selfS->instance,pSrc_converted,pDst,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_biquad_cascade_stereo_df2T_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_biquad_cascade_stereo_df2T_instance_f32Object *selfS = (ml_arm_biquad_cascade_stereo_df2T_instance_f32Object *)S;
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_biquad_cascade_stereo_df2T_f32(selfS->instance,pSrc_converted,pDst,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_biquad_cascade_df2T_f64(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  float64_t *pSrc_converted=NULL; // input
-  float64_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_biquad_cascade_df2T_instance_f64Object *selfS = (ml_arm_biquad_cascade_df2T_instance_f64Object *)S;
-    GETARGUMENT(pSrc,NPY_FLOAT64,float64_t,float64_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(float64_t)*blockSize);
-
-
-    arm_biquad_cascade_df2T_f64(selfS->instance,pSrc_converted,pDst,blockSize);
- FLOAT64ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_biquad_cascade_df2T_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint32_t numStages; // input
-  PyObject *pCoeffs=NULL; // input
-  float32_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  float32_t *pState_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OiOO",&S,&numStages,&pCoeffs,&pState))
-  {
-
-    ml_arm_biquad_cascade_df2T_instance_f32Object *selfS = (ml_arm_biquad_cascade_df2T_instance_f32Object *)S;
-    GETARGUMENT(pCoeffs,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
-
-    arm_biquad_cascade_df2T_init_f32(selfS->instance,(uint8_t)numStages,pCoeffs_converted,pState_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_biquad_cascade_stereo_df2T_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint32_t numStages; // input
-  PyObject *pCoeffs=NULL; // input
-  float32_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  float32_t *pState_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OiOO",&S,&numStages,&pCoeffs,&pState))
-  {
-
-    ml_arm_biquad_cascade_stereo_df2T_instance_f32Object *selfS = (ml_arm_biquad_cascade_stereo_df2T_instance_f32Object *)S;
-    GETARGUMENT(pCoeffs,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
-
-    arm_biquad_cascade_stereo_df2T_init_f32(selfS->instance,(uint8_t)numStages,pCoeffs_converted,pState_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_biquad_cascade_df2T_init_f64(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint32_t numStages; // input
-  PyObject *pCoeffs=NULL; // input
-  float64_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  float64_t *pState_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OiOO",&S,&numStages,&pCoeffs,&pState))
-  {
-
-    ml_arm_biquad_cascade_df2T_instance_f64Object *selfS = (ml_arm_biquad_cascade_df2T_instance_f64Object *)S;
-    GETARGUMENT(pCoeffs,NPY_FLOAT64,float64_t,float64_t);
-    GETARGUMENT(pState,NPY_FLOAT64,float64_t,float64_t);
-
-    arm_biquad_cascade_df2T_init_f64(selfS->instance,(uint8_t)numStages,pCoeffs_converted,pState_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_lattice_init_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numStages; // input
-  PyObject *pCoeffs=NULL; // input
-  q15_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q15_t *pState_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OhOO",&S,&numStages,&pCoeffs,&pState))
-  {
-
-    ml_arm_fir_lattice_instance_q15Object *selfS = (ml_arm_fir_lattice_instance_q15Object *)S;
-    GETARGUMENT(pCoeffs,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
-
-    arm_fir_lattice_init_q15(selfS->instance,numStages,pCoeffs_converted,pState_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_lattice_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_fir_lattice_instance_q15Object *selfS = (ml_arm_fir_lattice_instance_q15Object *)S;
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_fir_lattice_q15(selfS->instance,pSrc_converted,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_lattice_init_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numStages; // input
-  PyObject *pCoeffs=NULL; // input
-  q31_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q31_t *pState_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OhOO",&S,&numStages,&pCoeffs,&pState))
-  {
-
-    ml_arm_fir_lattice_instance_q31Object *selfS = (ml_arm_fir_lattice_instance_q31Object *)S;
-    GETARGUMENT(pCoeffs,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
-
-    arm_fir_lattice_init_q31(selfS->instance,numStages,pCoeffs_converted,pState_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_lattice_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_fir_lattice_instance_q31Object *selfS = (ml_arm_fir_lattice_instance_q31Object *)S;
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_fir_lattice_q31(selfS->instance,pSrc_converted,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_lattice_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numStages; // input
-  PyObject *pCoeffs=NULL; // input
-  float32_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  float32_t *pState_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OhOO",&S,&numStages,&pCoeffs,&pState))
-  {
-
-    ml_arm_fir_lattice_instance_f32Object *selfS = (ml_arm_fir_lattice_instance_f32Object *)S;
-    GETARGUMENT(pCoeffs,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
-
-    arm_fir_lattice_init_f32(selfS->instance,numStages,pCoeffs_converted,pState_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_lattice_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_fir_lattice_instance_f32Object *selfS = (ml_arm_fir_lattice_instance_f32Object *)S;
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_fir_lattice_f32(selfS->instance,pSrc_converted,pDst,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_iir_lattice_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_iir_lattice_instance_f32Object *selfS = (ml_arm_iir_lattice_instance_f32Object *)S;
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_iir_lattice_f32(selfS->instance,pSrc_converted,pDst,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_iir_lattice_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numStages; // input
-  PyObject *pkCoeffs=NULL; // input
-  float32_t *pkCoeffs_converted=NULL; // input
-  PyObject *pvCoeffs=NULL; // input
-  float32_t *pvCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  float32_t *pState_converted=NULL; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OhOOO",&S,&numStages,&pkCoeffs,&pvCoeffs,&pState))
-  {
-
-    ml_arm_iir_lattice_instance_f32Object *selfS = (ml_arm_iir_lattice_instance_f32Object *)S;
-    GETARGUMENT(pkCoeffs,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pvCoeffs,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepkCoeffs ;
-
-    arm_iir_lattice_init_f32(selfS->instance,numStages,pkCoeffs_converted,pvCoeffs_converted,pState_converted,blockSize);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_iir_lattice_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_iir_lattice_instance_q31Object *selfS = (ml_arm_iir_lattice_instance_q31Object *)S;
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_iir_lattice_q31(selfS->instance,pSrc_converted,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_iir_lattice_init_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numStages; // input
-  PyObject *pkCoeffs=NULL; // input
-  q31_t *pkCoeffs_converted=NULL; // input
-  PyObject *pvCoeffs=NULL; // input
-  q31_t *pvCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q31_t *pState_converted=NULL; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OhOOO",&S,&numStages,&pkCoeffs,&pvCoeffs,&pState))
-  {
-
-    ml_arm_iir_lattice_instance_q31Object *selfS = (ml_arm_iir_lattice_instance_q31Object *)S;
-    GETARGUMENT(pkCoeffs,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pvCoeffs,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepkCoeffs ;
-
-    arm_iir_lattice_init_q31(selfS->instance,numStages,pkCoeffs_converted,pvCoeffs_converted,pState_converted,blockSize);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_iir_lattice_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OO",&S,&pSrc))
-  {
-
-    ml_arm_iir_lattice_instance_q15Object *selfS = (ml_arm_iir_lattice_instance_q15Object *)S;
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_iir_lattice_q15(selfS->instance,pSrc_converted,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_iir_lattice_init_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numStages; // input
-  PyObject *pkCoeffs=NULL; // input
-  q15_t *pkCoeffs_converted=NULL; // input
-  PyObject *pvCoeffs=NULL; // input
-  q15_t *pvCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q15_t *pState_converted=NULL; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OhOOO",&S,&numStages,&pkCoeffs,&pvCoeffs,&pState))
-  {
-
-    ml_arm_iir_lattice_instance_q15Object *selfS = (ml_arm_iir_lattice_instance_q15Object *)S;
-    GETARGUMENT(pkCoeffs,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pvCoeffs,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepkCoeffs ;
-
-    arm_iir_lattice_init_q15(selfS->instance,numStages,pkCoeffs_converted,pvCoeffs_converted,pState_converted,blockSize);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cfft_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t fftLen; // input
-
-  if (PyArg_ParseTuple(args,"Oh",&S,&fftLen))
-  {
-
-    ml_arm_cfft_instance_f32Object *selfS = (ml_arm_cfft_instance_f32Object *)S;
-
-    arm_status returnValue = arm_cfft_init_f32(selfS->instance,fftLen);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_cfft_init_f64(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t fftLen; // input
-
-  if (PyArg_ParseTuple(args,"Oh",&S,&fftLen))
-  {
-
-    ml_arm_cfft_instance_f64Object *selfS = (ml_arm_cfft_instance_f64Object *)S;
-
-    arm_status returnValue = arm_cfft_init_f64(selfS->instance,fftLen);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_cfft_init_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t fftLen; // input
-
-  if (PyArg_ParseTuple(args,"Oh",&S,&fftLen))
-  {
-
-    ml_arm_cfft_instance_q31Object *selfS = (ml_arm_cfft_instance_q31Object *)S;
-
-    arm_status returnValue = arm_cfft_init_q31(selfS->instance,fftLen);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cfft_init_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t fftLen; // input
-
-  if (PyArg_ParseTuple(args,"Oh",&S,&fftLen))
-  {
-
-    ml_arm_cfft_instance_q15Object *selfS = (ml_arm_cfft_instance_q15Object *)S;
-
-    arm_status returnValue = arm_cfft_init_q15(selfS->instance,fftLen);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_lms_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  PyObject *pRef=NULL; // input
-  float32_t *pRef_converted=NULL; // input
-  float32_t *pOut=NULL; // output
-  PyObject *pErr=NULL; // input
-  float32_t *pErr_converted=NULL; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OOOO",&S,&pSrc,&pRef,&pErr))
-  {
-
-    ml_arm_lms_instance_f32Object *selfS = (ml_arm_lms_instance_f32Object *)S;
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pRef,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pErr,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pOut=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_lms_f32(selfS->instance,pSrc_converted,pRef_converted,pOut,pErr_converted,blockSize);
- FLOATARRAY1(pOutOBJ,blockSize,pOut);
-
-    PyObject *pythonResult = Py_BuildValue("O",pOutOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    FREEARGUMENT(pRef_converted);
-    Py_DECREF(pOutOBJ);
-    FREEARGUMENT(pErr_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_lms_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numTaps; // input
-  PyObject *pCoeffs=NULL; // input
-  float32_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  float32_t *pState_converted=NULL; // input
-  float32_t mu; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OhOOf",&S,&numTaps,&pCoeffs,&pState,&mu))
-  {
-
-    ml_arm_lms_instance_f32Object *selfS = (ml_arm_lms_instance_f32Object *)S;
-    GETARGUMENT(pCoeffs,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepState - arraySizepCoeffs + 1 ;
-
-    arm_lms_init_f32(selfS->instance,numTaps,pCoeffs_converted,pState_converted,mu,blockSize);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_lms_init_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numTaps; // input
-  PyObject *pCoeffs=NULL; // input
-  q15_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q15_t *pState_converted=NULL; // input
-  q15_t mu; // input
-  uint32_t blockSize; // input
-  uint32_t postShift; // input
-
-  if (PyArg_ParseTuple(args,"OhOOhi",&S,&numTaps,&pCoeffs,&pState,&mu,&postShift))
-  {
-
-    ml_arm_lms_instance_q15Object *selfS = (ml_arm_lms_instance_q15Object *)S;
-    GETARGUMENT(pCoeffs,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepState - arraySizepCoeffs + 1 ;
-
-    arm_lms_init_q15(selfS->instance,numTaps,pCoeffs_converted,pState_converted,mu,blockSize,postShift);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_lms_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  PyObject *pRef=NULL; // input
-  q15_t *pRef_converted=NULL; // input
-  q15_t *pOut=NULL; // output
-  PyObject *pErr=NULL; // input
-  q15_t *pErr_converted=NULL; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OOOO",&S,&pSrc,&pRef,&pErr))
-  {
-
-    ml_arm_lms_instance_q15Object *selfS = (ml_arm_lms_instance_q15Object *)S;
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pRef,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pErr,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pOut=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_lms_q15(selfS->instance,pSrc_converted,pRef_converted,pOut,pErr_converted,blockSize);
- INT16ARRAY1(pOutOBJ,blockSize,pOut);
-
-    PyObject *pythonResult = Py_BuildValue("O",pOutOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    FREEARGUMENT(pRef_converted);
-    Py_DECREF(pOutOBJ);
-    FREEARGUMENT(pErr_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_lms_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  PyObject *pRef=NULL; // input
-  q31_t *pRef_converted=NULL; // input
-  q31_t *pOut=NULL; // output
-  PyObject *pErr=NULL; // input
-  q31_t *pErr_converted=NULL; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OOOO",&S,&pSrc,&pRef,&pErr))
-  {
-
-    ml_arm_lms_instance_q31Object *selfS = (ml_arm_lms_instance_q31Object *)S;
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pRef,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pErr,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pOut=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_lms_q31(selfS->instance,pSrc_converted,pRef_converted,pOut,pErr_converted,blockSize);
- INT32ARRAY1(pOutOBJ,blockSize,pOut);
-
-    PyObject *pythonResult = Py_BuildValue("O",pOutOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    FREEARGUMENT(pRef_converted);
-    Py_DECREF(pOutOBJ);
-    FREEARGUMENT(pErr_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_lms_init_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numTaps; // input
-  PyObject *pCoeffs=NULL; // input
-  q31_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q31_t *pState_converted=NULL; // input
-  q31_t mu; // input
-  uint32_t blockSize; // input
-  uint32_t postShift; // input
-
-  if (PyArg_ParseTuple(args,"OhOOii",&S,&numTaps,&pCoeffs,&pState,&mu,&postShift))
-  {
-
-    ml_arm_lms_instance_q31Object *selfS = (ml_arm_lms_instance_q31Object *)S;
-    GETARGUMENT(pCoeffs,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepState - arraySizepCoeffs + 1 ;
-
-    arm_lms_init_q31(selfS->instance,numTaps,pCoeffs_converted,pState_converted,mu,blockSize,postShift);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_lms_norm_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  PyObject *pRef=NULL; // input
-  float32_t *pRef_converted=NULL; // input
-  float32_t *pOut=NULL; // output
-  PyObject *pErr=NULL; // input
-  float32_t *pErr_converted=NULL; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OOOO",&S,&pSrc,&pRef,&pErr))
-  {
-
-    ml_arm_lms_norm_instance_f32Object *selfS = (ml_arm_lms_norm_instance_f32Object *)S;
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pRef,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pErr,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pOut=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_lms_norm_f32(selfS->instance,pSrc_converted,pRef_converted,pOut,pErr_converted,blockSize);
- FLOATARRAY1(pOutOBJ,blockSize,pOut);
-
-    PyObject *pythonResult = Py_BuildValue("O",pOutOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    FREEARGUMENT(pRef_converted);
-    Py_DECREF(pOutOBJ);
-    FREEARGUMENT(pErr_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_lms_norm_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numTaps; // input
-  PyObject *pCoeffs=NULL; // input
-  float32_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  float32_t *pState_converted=NULL; // input
-  float32_t mu; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OhOOf",&S,&numTaps,&pCoeffs,&pState,&mu))
-  {
-
-    ml_arm_lms_norm_instance_f32Object *selfS = (ml_arm_lms_norm_instance_f32Object *)S;
-    GETARGUMENT(pCoeffs,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepState - arraySizepCoeffs + 1 ;
-
-    arm_lms_norm_init_f32(selfS->instance,numTaps,pCoeffs_converted,pState_converted,mu,blockSize);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_lms_norm_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  PyObject *pRef=NULL; // input
-  q31_t *pRef_converted=NULL; // input
-  q31_t *pOut=NULL; // output
-  PyObject *pErr=NULL; // input
-  q31_t *pErr_converted=NULL; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OOOO",&S,&pSrc,&pRef,&pErr))
-  {
-
-    ml_arm_lms_norm_instance_q31Object *selfS = (ml_arm_lms_norm_instance_q31Object *)S;
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pRef,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pErr,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pOut=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_lms_norm_q31(selfS->instance,pSrc_converted,pRef_converted,pOut,pErr_converted,blockSize);
- INT32ARRAY1(pOutOBJ,blockSize,pOut);
-
-    PyObject *pythonResult = Py_BuildValue("O",pOutOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    FREEARGUMENT(pRef_converted);
-    Py_DECREF(pOutOBJ);
-    FREEARGUMENT(pErr_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_lms_norm_init_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numTaps; // input
-  PyObject *pCoeffs=NULL; // input
-  q31_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q31_t *pState_converted=NULL; // input
-  q31_t mu; // input
-  uint32_t blockSize; // input
-  uint32_t postShift; // input
-
-  if (PyArg_ParseTuple(args,"OhOOii",&S,&numTaps,&pCoeffs,&pState,&mu,&postShift))
-  {
-
-    ml_arm_lms_norm_instance_q31Object *selfS = (ml_arm_lms_norm_instance_q31Object *)S;
-    GETARGUMENT(pCoeffs,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepState - arraySizepCoeffs + 1 ;
-
-    arm_lms_norm_init_q31(selfS->instance,numTaps,pCoeffs_converted,pState_converted,mu,blockSize,(uint8_t)postShift);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_lms_norm_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  PyObject *pRef=NULL; // input
-  q15_t *pRef_converted=NULL; // input
-  q15_t *pOut=NULL; // output
-  PyObject *pErr=NULL; // input
-  q15_t *pErr_converted=NULL; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OOOO",&S,&pSrc,&pRef,&pErr))
-  {
-
-    ml_arm_lms_norm_instance_q15Object *selfS = (ml_arm_lms_norm_instance_q15Object *)S;
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pRef,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pErr,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pOut=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_lms_norm_q15(selfS->instance,pSrc_converted,pRef_converted,pOut,pErr_converted,blockSize);
- INT16ARRAY1(pOutOBJ,blockSize,pOut);
-
-    PyObject *pythonResult = Py_BuildValue("O",pOutOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    FREEARGUMENT(pRef_converted);
-    Py_DECREF(pOutOBJ);
-    FREEARGUMENT(pErr_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_lms_norm_init_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numTaps; // input
-  PyObject *pCoeffs=NULL; // input
-  q15_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q15_t *pState_converted=NULL; // input
-  q15_t mu; // input
-  uint32_t blockSize; // input
-  uint32_t postShift; // input
-
-  if (PyArg_ParseTuple(args,"OhOOhi",&S,&numTaps,&pCoeffs,&pState,&mu,&postShift))
-  {
-
-    ml_arm_lms_norm_instance_q15Object *selfS = (ml_arm_lms_norm_instance_q15Object *)S;
-    GETARGUMENT(pCoeffs,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepState - arraySizepCoeffs + 1 ;
-
-    arm_lms_norm_init_q15(selfS->instance,numTaps,pCoeffs_converted,pState_converted,mu,blockSize,(uint8_t)postShift);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_correlate_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  float32_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  float32_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  float32_t *pDst=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
-  {
-
-    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
-    uint32_t outputLength = 2*MAX(srcALen,srcBLen) - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*outputLength);
-
-
-    arm_correlate_f32(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
- FLOATARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_correlate_opt_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q15_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q15_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q15_t *pDst=NULL; // output
-  PyObject *pScratch=NULL; // input
-  q15_t *pScratch_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OiOiO",&pSrcA,&srcALen,&pSrcB,&srcBLen,&pScratch))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pScratch,NPY_INT16,int16_t,int16_t);
-    uint32_t outputLength = 2*MAX(srcALen,srcBLen) - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
-
-
-    arm_correlate_opt_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,pScratch_converted);
- INT16ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    FREEARGUMENT(pScratch_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_correlate_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q15_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q15_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q15_t *pDst=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
-    uint32_t outputLength = 2*MAX(srcALen,srcBLen) - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
-
-
-    arm_correlate_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
- INT16ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_correlate_fast_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q15_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q15_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q15_t *pDst=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
-    uint32_t outputLength = 2*MAX(srcALen,srcBLen) - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
-
-
-    arm_correlate_fast_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
- INT16ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_correlate_fast_opt_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q15_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q15_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q15_t *pDst=NULL; // output
-  PyObject *pScratch=NULL; // input
-  q15_t *pScratch_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OiOiO",&pSrcA,&srcALen,&pSrcB,&srcBLen,&pScratch))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pScratch,NPY_INT16,int16_t,int16_t);
-    uint32_t outputLength = 2*MAX(srcALen,srcBLen) - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*outputLength);
-
-
-    arm_correlate_fast_opt_q15(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,pScratch_converted);
- INT16ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    FREEARGUMENT(pScratch_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_correlate_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q31_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q31_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q31_t *pDst=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
-    uint32_t outputLength = 2*MAX(srcALen,srcBLen) - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*outputLength);
-
-
-    arm_correlate_q31(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
- INT32ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_correlate_fast_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q31_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q31_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q31_t *pDst=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
-    uint32_t outputLength = 2*MAX(srcALen,srcBLen) - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*outputLength);
-
-
-    arm_correlate_fast_q31(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
- INT32ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_correlate_opt_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q7_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q7_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q7_t *pDst=NULL; // output
-  PyObject *pScratch1=NULL; // input
-  q15_t *pScratch1_converted=NULL; // input
-  PyObject *pScratch2=NULL; // input
-  q15_t *pScratch2_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OiOiOO",&pSrcA,&srcALen,&pSrcB,&srcBLen,&pScratch1,&pScratch2))
-  {
-
-    GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
-    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
-    GETARGUMENT(pScratch1,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pScratch2,NPY_INT16,int16_t,int16_t);
-    uint32_t outputLength = 2*MAX(srcALen,srcBLen) - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*outputLength);
-
-
-    arm_correlate_opt_q7(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst,pScratch1_converted,pScratch2_converted);
- INT8ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    FREEARGUMENT(pScratch1_converted);
-    FREEARGUMENT(pScratch2_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_correlate_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q7_t *pSrcA_converted=NULL; // input
-  uint32_t srcALen; // input
-  PyObject *pSrcB=NULL; // input
-  q7_t *pSrcB_converted=NULL; // input
-  uint32_t srcBLen; // input
-  q7_t *pDst=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OiOi",&pSrcA,&srcALen,&pSrcB,&srcBLen))
-  {
-
-    GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
-    GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
-    uint32_t outputLength = 2*MAX(srcALen,srcBLen) - 1 ;
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*outputLength);
-
-
-    arm_correlate_q7(pSrcA_converted,srcALen,pSrcB_converted,srcBLen,pDst);
- INT8ARRAY1(pDstOBJ,outputLength,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_sparse_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  PyObject *pScratchIn=NULL; // input
-  float32_t *pScratchIn_converted=NULL; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OOO",&S,&pSrc,&pScratchIn))
-  {
-
-    ml_arm_fir_sparse_instance_f32Object *selfS = (ml_arm_fir_sparse_instance_f32Object *)S;
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pScratchIn,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_fir_sparse_f32(selfS->instance,pSrc_converted,pDst,pScratchIn_converted,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    FREEARGUMENT(pScratchIn_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_sparse_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numTaps; // input
-  PyObject *pCoeffs=NULL; // input
-  float32_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  float32_t *pState_converted=NULL; // input
-  PyObject *pTapDelay=NULL; // input
-  int32_t *pTapDelay_converted=NULL; // input
-  uint16_t maxDelay; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OhOOOh",&S,&numTaps,&pCoeffs,&pState,&pTapDelay,&maxDelay))
-  {
-
-    ml_arm_fir_sparse_instance_f32Object *selfS = (ml_arm_fir_sparse_instance_f32Object *)S;
-    GETARGUMENT(pCoeffs,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pState,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pTapDelay,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepState - arraySizepCoeffs + 1;
-
-    arm_fir_sparse_init_f32(selfS->instance,numTaps,pCoeffs_converted,pState_converted,pTapDelay_converted,maxDelay,blockSize);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_sparse_init_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numTaps; // input
-  PyObject *pCoeffs=NULL; // input
-  q31_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q31_t *pState_converted=NULL; // input
-  PyObject *pTapDelay=NULL; // input
-  int32_t *pTapDelay_converted=NULL; // input
-  uint16_t maxDelay; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OhOOOh",&S,&numTaps,&pCoeffs,&pState,&pTapDelay,&maxDelay))
-  {
-
-    ml_arm_fir_sparse_instance_q31Object *selfS = (ml_arm_fir_sparse_instance_q31Object *)S;
-    GETARGUMENT(pCoeffs,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pTapDelay,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepState - arraySizepCoeffs + 1;
-
-    arm_fir_sparse_init_q31(selfS->instance,numTaps,pCoeffs_converted,pState_converted,pTapDelay_converted,maxDelay,blockSize);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_sparse_init_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numTaps; // input
-  PyObject *pCoeffs=NULL; // input
-  q15_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q15_t *pState_converted=NULL; // input
-  PyObject *pTapDelay=NULL; // input
-  int32_t *pTapDelay_converted=NULL; // input
-  uint16_t maxDelay; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OhOOOh",&S,&numTaps,&pCoeffs,&pState,&pTapDelay,&maxDelay))
-  {
-
-    ml_arm_fir_sparse_instance_q15Object *selfS = (ml_arm_fir_sparse_instance_q15Object *)S;
-    GETARGUMENT(pCoeffs,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pTapDelay,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepState - arraySizepCoeffs + 1;
-
-    arm_fir_sparse_init_q15(selfS->instance,numTaps,pCoeffs_converted,pState_converted,pTapDelay_converted,maxDelay,blockSize);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_fir_sparse_init_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint16_t numTaps; // input
-  PyObject *pCoeffs=NULL; // input
-  q7_t *pCoeffs_converted=NULL; // input
-  PyObject *pState=NULL; // input
-  q7_t *pState_converted=NULL; // input
-  PyObject *pTapDelay=NULL; // input
-  int32_t *pTapDelay_converted=NULL; // input
-  uint16_t maxDelay; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OhOOOh",&S,&numTaps,&pCoeffs,&pState,&pTapDelay,&maxDelay))
-  {
-
-    ml_arm_fir_sparse_instance_q7Object *selfS = (ml_arm_fir_sparse_instance_q7Object *)S;
-    GETARGUMENT(pCoeffs,NPY_BYTE,int8_t,q7_t);
-    GETARGUMENT(pState,NPY_BYTE,int8_t,q7_t);
-    GETARGUMENT(pTapDelay,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepState - arraySizepCoeffs + 1;
-
-    arm_fir_sparse_init_q7(selfS->instance,numTaps,pCoeffs_converted,pState_converted,pTapDelay_converted,maxDelay,blockSize);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_sin_cos_f32(PyObject *obj, PyObject *args)
-{
-
-  float32_t theta; // input
-  float32_t pS;
-  float32_t pC;
-
-  if (PyArg_ParseTuple(args,"f",&theta))
-  {
-
-
-    
-    arm_sin_cos_f32(theta,&pS,&pC);
-    
-    PyObject* retS=Py_BuildValue("f",pS);
-    PyObject* retC=Py_BuildValue("f",pC);
-
-    PyObject *pythonResult = Py_BuildValue("OO",retS,retC);
-
-    Py_DECREF(retS);
-    Py_DECREF(retC);
-
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_sin_cos_q31(PyObject *obj, PyObject *args)
-{
-
-  q31_t theta; // input
-  q31_t pS;
-  q31_t pC;
-
-  if (PyArg_ParseTuple(args,"i",&theta))
-  {
-
-    arm_sin_cos_q31(theta,&pS,&pC);
-    
-    PyObject* retS=Py_BuildValue("i",pS);
-    PyObject* retC=Py_BuildValue("i",pC);
-
-    PyObject *pythonResult = Py_BuildValue("OO",retS,retC);
-
-    Py_DECREF(retS);
-    Py_DECREF(retC);
-
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cmplx_conj_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t numSamples; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    numSamples = arraySizepSrc ;
-    numSamples = numSamples / 2;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*2*numSamples);
-
-
-    arm_cmplx_conj_f32(pSrc_converted,pDst,numSamples);
- FLOATARRAY1(pDstOBJ,2*numSamples,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cmplx_conj_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t numSamples; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    numSamples = arraySizepSrc ;
-    numSamples = numSamples / 2;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*2*numSamples);
-
-
-    arm_cmplx_conj_q31(pSrc_converted,pDst,numSamples);
- INT32ARRAY1(pDstOBJ,2*numSamples,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cmplx_conj_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t numSamples; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    numSamples = arraySizepSrc ;
-    numSamples = numSamples / 2;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*2*numSamples);
-
-
-    arm_cmplx_conj_q15(pSrc_converted,pDst,numSamples);
- INT16ARRAY1(pDstOBJ,2*numSamples,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cmplx_mag_squared_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t numSamples; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    numSamples = arraySizepSrc ;
-    numSamples = numSamples / 2;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*2*numSamples);
-
-
-    arm_cmplx_mag_squared_f32(pSrc_converted,pDst,numSamples);
- FLOATARRAY1(pDstOBJ,numSamples,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cmplx_mag_squared_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t numSamples; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    numSamples = arraySizepSrc ;
-    numSamples = numSamples / 2;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*2*numSamples);
-
-
-    arm_cmplx_mag_squared_q31(pSrc_converted,pDst,numSamples);
- INT32ARRAY1(pDstOBJ,numSamples,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cmplx_mag_squared_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t numSamples; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    numSamples = arraySizepSrc ;
-    numSamples = numSamples / 2;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*2*numSamples);
-
-
-    arm_cmplx_mag_squared_q15(pSrc_converted,pDst,numSamples);
- INT16ARRAY1(pDstOBJ,numSamples,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_pid_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  float32_t in; // input
-
-  if (PyArg_ParseTuple(args,"Of",&S,&in))
-  {
-
-    ml_arm_pid_instance_f32Object *selfS = (ml_arm_pid_instance_f32Object *)S;
-
-    float32_t returnValue = arm_pid_f32(selfS->instance,in);
-    PyObject* theReturnOBJ=Py_BuildValue("f",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_pid_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  q31_t in; // input
-
-  if (PyArg_ParseTuple(args,"Oi",&S,&in))
-  {
-
-    ml_arm_pid_instance_q31Object *selfS = (ml_arm_pid_instance_q31Object *)S;
-
-    q31_t returnValue = arm_pid_q31(selfS->instance,in);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_pid_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  q15_t in; // input
-
-  if (PyArg_ParseTuple(args,"Oh",&S,&in))
-  {
-
-    ml_arm_pid_instance_q15Object *selfS = (ml_arm_pid_instance_q15Object *)S;
-
-    q15_t returnValue = arm_pid_q15(selfS->instance,in);
-    PyObject* theReturnOBJ=Py_BuildValue("h",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mat_inverse_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *src=NULL; // input
-  arm_matrix_instance_f32 *src_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&src))
-  {
-
-    arm_matrix_instance_f32 *src_converted = f32MatrixFromNumpy(src);
-    uint32_t row = src_converted->numCols ;
-    uint32_t column = src_converted->numRows ;
-    arm_matrix_instance_f32 *dst_converted = createf32Matrix(row,column);
-
-    arm_status returnValue = arm_mat_inverse_f32(src_converted,dst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* dstOBJ=NumpyArrayFromf32Matrix(dst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,dstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(src_converted);
-    Py_DECREF(dstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mat_inverse_f64(PyObject *obj, PyObject *args)
-{
-
-  PyObject *src=NULL; // input
-  arm_matrix_instance_f64 *src_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"O",&src))
-  {
-
-    arm_matrix_instance_f64 *src_converted = f64MatrixFromNumpy(src);
-    uint32_t row = src_converted->numCols ;
-    uint32_t column = src_converted->numRows ;
-    arm_matrix_instance_f64 *dst_converted = createf64Matrix(row,column);
-
-    arm_status returnValue = arm_mat_inverse_f64(src_converted,dst_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* dstOBJ=NumpyArrayFromf64Matrix(dst_converted);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,dstOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(src_converted);
-    Py_DECREF(dstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_clarke_f32(PyObject *obj, PyObject *args)
-{
-
-  float32_t Ia; // input
-  float32_t Ib; // input
-  PyObject *pIalpha=NULL; // input
-  float32_t *pIalpha_converted=NULL; // input
-  PyObject *pIbeta=NULL; // input
-  float32_t *pIbeta_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"ffOO",&Ia,&Ib,&pIalpha,&pIbeta))
-  {
-
-    GETARGUMENT(pIalpha,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pIbeta,NPY_DOUBLE,double,float32_t);
-
-    arm_clarke_f32(Ia,Ib,pIalpha_converted,pIbeta_converted);
-    FREEARGUMENT(pIalpha_converted);
-    FREEARGUMENT(pIbeta_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_clarke_q31(PyObject *obj, PyObject *args)
-{
-
-  q31_t Ia; // input
-  q31_t Ib; // input
-  PyObject *pIalpha=NULL; // input
-  q31_t *pIalpha_converted=NULL; // input
-  PyObject *pIbeta=NULL; // input
-  q31_t *pIbeta_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"iiOO",&Ia,&Ib,&pIalpha,&pIbeta))
-  {
-
-    GETARGUMENT(pIalpha,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pIbeta,NPY_INT32,int32_t,int32_t);
-
-    arm_clarke_q31(Ia,Ib,pIalpha_converted,pIbeta_converted);
-    FREEARGUMENT(pIalpha_converted);
-    FREEARGUMENT(pIbeta_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_q7_to_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_q7_to_q31(pSrc_converted,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_inv_clarke_f32(PyObject *obj, PyObject *args)
-{
-
-  float32_t Ialpha; // input
-  float32_t Ibeta; // input
-  PyObject *pIa=NULL; // input
-  float32_t *pIa_converted=NULL; // input
-  PyObject *pIb=NULL; // input
-  float32_t *pIb_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"ffOO",&Ialpha,&Ibeta,&pIa,&pIb))
-  {
-
-    GETARGUMENT(pIa,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pIb,NPY_DOUBLE,double,float32_t);
-
-    arm_inv_clarke_f32(Ialpha,Ibeta,pIa_converted,pIb_converted);
-    FREEARGUMENT(pIa_converted);
-    FREEARGUMENT(pIb_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_inv_clarke_q31(PyObject *obj, PyObject *args)
-{
-
-  q31_t Ialpha; // input
-  q31_t Ibeta; // input
-  PyObject *pIa=NULL; // input
-  q31_t *pIa_converted=NULL; // input
-  PyObject *pIb=NULL; // input
-  q31_t *pIb_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"iiOO",&Ialpha,&Ibeta,&pIa,&pIb))
-  {
-
-    GETARGUMENT(pIa,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pIb,NPY_INT32,int32_t,int32_t);
-
-    arm_inv_clarke_q31(Ialpha,Ibeta,pIa_converted,pIb_converted);
-    FREEARGUMENT(pIa_converted);
-    FREEARGUMENT(pIb_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_q7_to_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_q7_to_q15(pSrc_converted,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_park_f32(PyObject *obj, PyObject *args)
-{
-
-  float32_t Ialpha; // input
-  float32_t Ibeta; // input
-  PyObject *pId=NULL; // input
-  float32_t *pId_converted=NULL; // input
-  PyObject *pIq=NULL; // input
-  float32_t *pIq_converted=NULL; // input
-  float32_t sinVal; // input
-  float32_t cosVal; // input
-
-  if (PyArg_ParseTuple(args,"ffOOff",&Ialpha,&Ibeta,&pId,&pIq,&sinVal,&cosVal))
-  {
-
-    GETARGUMENT(pId,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pIq,NPY_DOUBLE,double,float32_t);
-
-    arm_park_f32(Ialpha,Ibeta,pId_converted,pIq_converted,sinVal,cosVal);
-    FREEARGUMENT(pId_converted);
-    FREEARGUMENT(pIq_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_park_q31(PyObject *obj, PyObject *args)
-{
-
-  q31_t Ialpha; // input
-  q31_t Ibeta; // input
-  PyObject *pId=NULL; // input
-  q31_t *pId_converted=NULL; // input
-  PyObject *pIq=NULL; // input
-  q31_t *pIq_converted=NULL; // input
-  q31_t sinVal; // input
-  q31_t cosVal; // input
-
-  if (PyArg_ParseTuple(args,"iiOOii",&Ialpha,&Ibeta,&pId,&pIq,&sinVal,&cosVal))
-  {
-
-    GETARGUMENT(pId,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pIq,NPY_INT32,int32_t,int32_t);
-
-    arm_park_q31(Ialpha,Ibeta,pId_converted,pIq_converted,sinVal,cosVal);
-    FREEARGUMENT(pId_converted);
-    FREEARGUMENT(pIq_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_q7_to_float(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_q7_to_float(pSrc_converted,pDst,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_inv_park_f32(PyObject *obj, PyObject *args)
-{
-
-  float32_t Id; // input
-  float32_t Iq; // input
-  PyObject *pIalpha=NULL; // input
-  float32_t *pIalpha_converted=NULL; // input
-  PyObject *pIbeta=NULL; // input
-  float32_t *pIbeta_converted=NULL; // input
-  float32_t sinVal; // input
-  float32_t cosVal; // input
-
-  if (PyArg_ParseTuple(args,"ffOOff",&Id,&Iq,&pIalpha,&pIbeta,&sinVal,&cosVal))
-  {
-
-    GETARGUMENT(pIalpha,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pIbeta,NPY_DOUBLE,double,float32_t);
-
-    arm_inv_park_f32(Id,Iq,pIalpha_converted,pIbeta_converted,sinVal,cosVal);
-    FREEARGUMENT(pIalpha_converted);
-    FREEARGUMENT(pIbeta_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_inv_park_q31(PyObject *obj, PyObject *args)
-{
-
-  q31_t Id; // input
-  q31_t Iq; // input
-  PyObject *pIalpha=NULL; // input
-  q31_t *pIalpha_converted=NULL; // input
-  PyObject *pIbeta=NULL; // input
-  q31_t *pIbeta_converted=NULL; // input
-  q31_t sinVal; // input
-  q31_t cosVal; // input
-
-  if (PyArg_ParseTuple(args,"iiOOii",&Id,&Iq,&pIalpha,&pIbeta,&sinVal,&cosVal))
-  {
-
-    GETARGUMENT(pIalpha,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pIbeta,NPY_INT32,int32_t,int32_t);
-
-    arm_inv_park_q31(Id,Iq,pIalpha_converted,pIbeta_converted,sinVal,cosVal);
-    FREEARGUMENT(pIalpha_converted);
-    FREEARGUMENT(pIbeta_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_q31_to_float(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_q31_to_float(pSrc_converted,pDst,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_linear_interp_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  float32_t x; // input
-
-  if (PyArg_ParseTuple(args,"Of",&S,&x))
-  {
-
-    ml_arm_linear_interp_instance_f32Object *selfS = (ml_arm_linear_interp_instance_f32Object *)S;
-
-    float32_t returnValue = arm_linear_interp_f32(selfS->instance,x);
-    PyObject* theReturnOBJ=Py_BuildValue("f",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_linear_interp_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pYData=NULL; // input
-  q31_t *pYData_converted=NULL; // input
-  q31_t x; // input
-  uint32_t nValues; // input
-
-  if (PyArg_ParseTuple(args,"Oii",&pYData,&x,&nValues))
-  {
-
-    GETARGUMENT(pYData,NPY_INT32,int32_t,int32_t);
-
-    q31_t returnValue = arm_linear_interp_q31(pYData_converted,x,nValues);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pYData_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_linear_interp_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pYData=NULL; // input
-  q15_t *pYData_converted=NULL; // input
-  q31_t x; // input
-  uint32_t nValues; // input
-
-  if (PyArg_ParseTuple(args,"Oii",&pYData,&x,&nValues))
-  {
-
-    GETARGUMENT(pYData,NPY_INT16,int16_t,int16_t);
-
-    q15_t returnValue = arm_linear_interp_q15(pYData_converted,x,nValues);
-    PyObject* theReturnOBJ=Py_BuildValue("h",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pYData_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_linear_interp_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pYData=NULL; // input
-  q7_t *pYData_converted=NULL; // input
-  q31_t x; // input
-  uint32_t nValues; // input
-
-  if (PyArg_ParseTuple(args,"Oii",&pYData,&x,&nValues))
-  {
-
-    GETARGUMENT(pYData,NPY_BYTE,int8_t,q7_t);
-
-    q7_t returnValue = arm_linear_interp_q7(pYData_converted,x,nValues);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    FREEARGUMENT(pYData_converted);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_sin_f32(PyObject *obj, PyObject *args)
-{
-
-  float32_t x; // input
-
-  if (PyArg_ParseTuple(args,"f",&x))
-  {
-
-
-    float32_t returnValue = arm_sin_f32(x);
-    PyObject* theReturnOBJ=Py_BuildValue("f",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_sin_q31(PyObject *obj, PyObject *args)
-{
-
-  q31_t x; // input
-
-  if (PyArg_ParseTuple(args,"i",&x))
-  {
-
-
-    q31_t returnValue = arm_sin_q31(x);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_sin_q15(PyObject *obj, PyObject *args)
-{
-
-  q15_t x; // input
-
-  if (PyArg_ParseTuple(args,"h",&x))
-  {
-
-
-    q15_t returnValue = arm_sin_q15(x);
-    PyObject* theReturnOBJ=Py_BuildValue("h",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cos_f32(PyObject *obj, PyObject *args)
-{
-
-  float32_t x; // input
-
-  if (PyArg_ParseTuple(args,"f",&x))
-  {
-
-
-    float32_t returnValue = arm_cos_f32(x);
-    PyObject* theReturnOBJ=Py_BuildValue("f",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cos_q31(PyObject *obj, PyObject *args)
-{
-
-  q31_t x; // input
-
-  if (PyArg_ParseTuple(args,"i",&x))
-  {
-
-
-    q31_t returnValue = arm_cos_q31(x);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cos_q15(PyObject *obj, PyObject *args)
-{
-
-  q15_t x; // input
-
-  if (PyArg_ParseTuple(args,"h",&x))
-  {
-
-
-    q15_t returnValue = arm_cos_q15(x);
-    PyObject* theReturnOBJ=Py_BuildValue("h",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_sqrt_f32(PyObject *obj, PyObject *args)
-{
-
-  float32_t in; // input
-  float32_t pOut; // output
-
-  if (PyArg_ParseTuple(args,"f",&in))
-  {
-
-
-    arm_status returnValue = arm_sqrt_f32(in,&pOut);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pOutOBJ=Py_BuildValue("f",pOut);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pOutOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    Py_DECREF(pOutOBJ);
-
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_sqrt_q31(PyObject *obj, PyObject *args)
-{
-
-  q31_t in; // input
-  q31_t pOut; // output
-
-  if (PyArg_ParseTuple(args,"i",&in))
-  {
-
-
-
-
-    arm_status returnValue = arm_sqrt_q31(in,&pOut);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pOutOBJ=Py_BuildValue("i",pOut);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pOutOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    Py_DECREF(pOutOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_divide_q31(PyObject *obj, PyObject *args)
-{
-
-  q31_t num,den; // input
-  q31_t pOut;
-  int16_t shift; // output
-
-  if (PyArg_ParseTuple(args,"ii",&num,&den))
-  {
-
-
-
-    arm_status returnValue = arm_divide_q31(num,den,&pOut,&shift);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pOutOBJ=Py_BuildValue("i",pOut);
-    PyObject* pShiftOBJ=Py_BuildValue("h",shift);
-
-    PyObject *pythonResult = Py_BuildValue("OOO",theReturnOBJ,pOutOBJ,pShiftOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    Py_DECREF(pOutOBJ);
-    Py_DECREF(pShiftOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_divide_q15(PyObject *obj, PyObject *args)
-{
-
-  q15_t num,den; // input
-  q15_t pOut;
-  int16_t shift; // output
-
-  if (PyArg_ParseTuple(args,"hh",&num,&den))
-  {
-
-
-
-    arm_status returnValue = arm_divide_q15(num,den,&pOut,&shift);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pOutOBJ=Py_BuildValue("h",pOut);
-    PyObject* pShiftOBJ=Py_BuildValue("h",shift);
-
-    PyObject *pythonResult = Py_BuildValue("OOO",theReturnOBJ,pOutOBJ,pShiftOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    Py_DECREF(pOutOBJ);
-    Py_DECREF(pShiftOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_sqrt_q15(PyObject *obj, PyObject *args)
-{
-
-  q15_t in; // input
-  q15_t pOut; // output
-
-  if (PyArg_ParseTuple(args,"h",&in))
-  {
-
-
-
-    arm_status returnValue = arm_sqrt_q15(in,&pOut);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-    PyObject* pOutOBJ=Py_BuildValue("h",pOut);
-
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pOutOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    Py_DECREF(pOutOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_circularWrite_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *circBuffer=NULL; // input
-  int32_t *circBuffer_converted=NULL; // input
-  int32_t L; // input
-  PyObject *writeOffset=NULL; // input
-  uint16_t *writeOffset_converted=NULL; // input
-  int32_t bufferInc; // input
-  PyObject *src=NULL; // input
-  int32_t *src_converted=NULL; // input
-  int32_t srcInc; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OiOiOi",&circBuffer,&L,&writeOffset,&bufferInc,&src,&srcInc))
-  {
-
-    GETARGUMENT(circBuffer,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(writeOffset,NPY_UINT16,uint16_t,uint16_t);
-    GETARGUMENT(src,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizecircBuffer ;
-
-    arm_circularWrite_f32(circBuffer_converted,L,writeOffset_converted,bufferInc,src_converted,srcInc,blockSize);
-    FREEARGUMENT(circBuffer_converted);
-    FREEARGUMENT(writeOffset_converted);
-    FREEARGUMENT(src_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_circularWrite_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *circBuffer=NULL; // input
-  q15_t *circBuffer_converted=NULL; // input
-  int32_t L; // input
-  PyObject *writeOffset=NULL; // input
-  uint16_t *writeOffset_converted=NULL; // input
-  int32_t bufferInc; // input
-  PyObject *src=NULL; // input
-  q15_t *src_converted=NULL; // input
-  int32_t srcInc; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OiOiOi",&circBuffer,&L,&writeOffset,&bufferInc,&src,&srcInc))
-  {
-
-    GETARGUMENT(circBuffer,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(writeOffset,NPY_UINT16,uint16_t,uint16_t);
-    GETARGUMENT(src,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizecircBuffer ;
-
-    arm_circularWrite_q15(circBuffer_converted,L,writeOffset_converted,bufferInc,src_converted,srcInc,blockSize);
-    FREEARGUMENT(circBuffer_converted);
-    FREEARGUMENT(writeOffset_converted);
-    FREEARGUMENT(src_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_circularWrite_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *circBuffer=NULL; // input
-  q7_t *circBuffer_converted=NULL; // input
-  int32_t L; // input
-  PyObject *writeOffset=NULL; // input
-  uint16_t *writeOffset_converted=NULL; // input
-  int32_t bufferInc; // input
-  PyObject *src=NULL; // input
-  q7_t *src_converted=NULL; // input
-  int32_t srcInc; // input
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"OiOiOi",&circBuffer,&L,&writeOffset,&bufferInc,&src,&srcInc))
-  {
-
-    GETARGUMENT(circBuffer,NPY_BYTE,int8_t,q7_t);
-    GETARGUMENT(writeOffset,NPY_UINT16,uint16_t,uint16_t);
-    GETARGUMENT(src,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizecircBuffer ;
-
-    arm_circularWrite_q7(circBuffer_converted,L,writeOffset_converted,bufferInc,src_converted,srcInc,blockSize);
-    FREEARGUMENT(circBuffer_converted);
-    FREEARGUMENT(writeOffset_converted);
-    FREEARGUMENT(src_converted);
-    Py_RETURN_NONE;
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_power_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q63_t *pResult=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q63_t)*1);
-
-
-    arm_power_q31(pSrc_converted,blockSize,pResult);
-    PyObject* pResultOBJ=Py_BuildValue("L",*pResult);
-
-    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_power_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  float32_t *pResult=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(float32_t)*1);
-
-
-    arm_power_f32(pSrc_converted,blockSize,pResult);
-    PyObject* pResultOBJ=Py_BuildValue("f",*pResult);
-
-    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_power_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q63_t *pResult=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q63_t)*1);
-
-
-    arm_power_q15(pSrc_converted,blockSize,pResult);
-    PyObject* pResultOBJ=Py_BuildValue("L",*pResult);
-
-    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_power_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q31_t *pResult=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q31_t)*1);
-
-
-    arm_power_q7(pSrc_converted,blockSize,pResult);
-    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
-
-    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mean_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q7_t *pResult=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q7_t)*1);
-
-
-    arm_mean_q7(pSrc_converted,blockSize,pResult);
-    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
-
-    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mean_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q15_t *pResult=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q15_t)*1);
-
-
-    arm_mean_q15(pSrc_converted,blockSize,pResult);
-    PyObject* pResultOBJ=Py_BuildValue("h",*pResult);
-
-    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mean_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q31_t *pResult=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q31_t)*1);
-
-
-    arm_mean_q31(pSrc_converted,blockSize,pResult);
-    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
-
-    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_mean_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  float32_t *pResult=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(float32_t)*1);
-
-
-    arm_mean_f32(pSrc_converted,blockSize,pResult);
-    PyObject* pResultOBJ=Py_BuildValue("f",*pResult);
-
-    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_var_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  float32_t *pResult=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(float32_t)*1);
-
-
-    arm_var_f32(pSrc_converted,blockSize,pResult);
-    PyObject* pResultOBJ=Py_BuildValue("f",*pResult);
-
-    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_var_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q31_t *pResult=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q31_t)*1);
-
-
-    arm_var_q31(pSrc_converted,blockSize,pResult);
-    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
-
-    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_var_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q15_t *pResult=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q15_t)*1);
-
-
-    arm_var_q15(pSrc_converted,blockSize,pResult);
-    PyObject* pResultOBJ=Py_BuildValue("h",*pResult);
-
-    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rms_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  float32_t *pResult=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(float32_t)*1);
-
-
-    arm_rms_f32(pSrc_converted,blockSize,pResult);
-    PyObject* pResultOBJ=Py_BuildValue("f",*pResult);
-
-    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rms_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q31_t *pResult=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q31_t)*1);
-
-
-    arm_rms_q31(pSrc_converted,blockSize,pResult);
-    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
-
-    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_rms_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q15_t *pResult=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q15_t)*1);
-
-
-    arm_rms_q15(pSrc_converted,blockSize,pResult);
-    PyObject* pResultOBJ=Py_BuildValue("h",*pResult);
-
-    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_std_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  float32_t *pResult=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(float32_t)*1);
-
-
-    arm_std_f32(pSrc_converted,blockSize,pResult);
-    PyObject* pResultOBJ=Py_BuildValue("f",*pResult);
-
-    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_std_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q31_t *pResult=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q31_t)*1);
-
-
-    arm_std_q31(pSrc_converted,blockSize,pResult);
-    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
-
-    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_std_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q15_t *pResult=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q15_t)*1);
-
-
-    arm_std_q15(pSrc_converted,blockSize,pResult);
-    PyObject* pResultOBJ=Py_BuildValue("h",*pResult);
-
-    PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cmplx_mag_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t numSamples; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    numSamples = arraySizepSrc ;
-    numSamples = numSamples / 2;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*2*numSamples);
-
-
-    arm_cmplx_mag_f32(pSrc_converted,pDst,numSamples);
- FLOATARRAY1(pDstOBJ,numSamples,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cmplx_mag_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t numSamples; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    numSamples = arraySizepSrc ;
-    numSamples = numSamples / 2;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*2*numSamples);
-
-
-    arm_cmplx_mag_q31(pSrc_converted,pDst,numSamples);
- INT32ARRAY1(pDstOBJ,numSamples,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cmplx_mag_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t numSamples; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    numSamples = arraySizepSrc ;
-    numSamples = numSamples / 2;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*2*numSamples);
-
-
-    arm_cmplx_mag_q15(pSrc_converted,pDst,numSamples);
- INT16ARRAY1(pDstOBJ,numSamples,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_cmplx_mag_fast_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t numSamples; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    numSamples = arraySizepSrc ;
-    numSamples = numSamples / 2;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*2*numSamples);
-
-
-    arm_cmplx_mag_fast_q15(pSrc_converted,pDst,numSamples);
- INT16ARRAY1(pDstOBJ,numSamples,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_cmplx_dot_prod_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q15_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  q15_t *pSrcB_converted=NULL; // input
-  uint32_t numSamples; // input
-  q31_t *realResult=NULL; // output
-  q31_t *imagResult=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
-    numSamples = arraySizepSrcA ;
-    numSamples = numSamples / 2;
-
-    realResult=PyMem_Malloc(sizeof(q31_t)*1);
-
-
-    imagResult=PyMem_Malloc(sizeof(q31_t)*1);
-
-
-    arm_cmplx_dot_prod_q15(pSrcA_converted,pSrcB_converted,numSamples,realResult,imagResult);
-    PyObject* realResultOBJ=Py_BuildValue("i",*realResult);
-    PyObject* imagResultOBJ=Py_BuildValue("i",*imagResult);
-
-    PyObject *pythonResult = Py_BuildValue("OO",realResultOBJ,imagResultOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(realResultOBJ);
-    Py_DECREF(imagResultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cmplx_dot_prod_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q31_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  q31_t *pSrcB_converted=NULL; // input
-  uint32_t numSamples; // input
-  q63_t *realResult=NULL; // output
-  q63_t *imagResult=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
-    numSamples = arraySizepSrcA ;
-    numSamples = numSamples / 2;
-
-    realResult=PyMem_Malloc(sizeof(q63_t)*1);
-
-
-    imagResult=PyMem_Malloc(sizeof(q63_t)*1);
-
-
-    arm_cmplx_dot_prod_q31(pSrcA_converted,pSrcB_converted,numSamples,realResult,imagResult);
-    PyObject* realResultOBJ=Py_BuildValue("L",*realResult);
-    PyObject* imagResultOBJ=Py_BuildValue("L",*imagResult);
-
-    PyObject *pythonResult = Py_BuildValue("OO",realResultOBJ,imagResultOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(realResultOBJ);
-    Py_DECREF(imagResultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cmplx_dot_prod_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  float32_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  float32_t *pSrcB_converted=NULL; // input
-  uint32_t numSamples; // input
-  float32_t *realResult=NULL; // output
-  float32_t *imagResult=NULL; // output
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
-    numSamples = arraySizepSrcA ;
-    numSamples = numSamples / 2;
-
-    realResult=PyMem_Malloc(sizeof(float32_t)*1);
-
-
-    imagResult=PyMem_Malloc(sizeof(float32_t)*1);
-
-
-    arm_cmplx_dot_prod_f32(pSrcA_converted,pSrcB_converted,numSamples,realResult,imagResult);
-    PyObject* realResultOBJ=Py_BuildValue("f",*realResult);
-    PyObject* imagResultOBJ=Py_BuildValue("f",*imagResult);
-
-    PyObject *pythonResult = Py_BuildValue("OO",realResultOBJ,imagResultOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(realResultOBJ);
-    Py_DECREF(imagResultOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cmplx_mult_real_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcCmplx=NULL; // input
-  q15_t *pSrcCmplx_converted=NULL; // input
-  PyObject *pSrcReal=NULL; // input
-  q15_t *pSrcReal_converted=NULL; // input
-  q15_t *pCmplxDst=NULL; // output
-  uint32_t numSamples; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcCmplx,&pSrcReal))
-  {
-
-    GETARGUMENT(pSrcCmplx,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pSrcReal,NPY_INT16,int16_t,int16_t);
-    numSamples = arraySizepSrcCmplx ;
-    numSamples = numSamples / 2;
-
-    pCmplxDst=PyMem_Malloc(sizeof(q15_t)*2*numSamples);
-
-
-    arm_cmplx_mult_real_q15(pSrcCmplx_converted,pSrcReal_converted,pCmplxDst,numSamples);
- INT16ARRAY1(pCmplxDstOBJ,2*numSamples,pCmplxDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pCmplxDstOBJ);
-
-    FREEARGUMENT(pSrcCmplx_converted);
-    FREEARGUMENT(pSrcReal_converted);
-    Py_DECREF(pCmplxDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cmplx_mult_real_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcCmplx=NULL; // input
-  q31_t *pSrcCmplx_converted=NULL; // input
-  PyObject *pSrcReal=NULL; // input
-  q31_t *pSrcReal_converted=NULL; // input
-  q31_t *pCmplxDst=NULL; // output
-  uint32_t numSamples; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcCmplx,&pSrcReal))
-  {
-
-    GETARGUMENT(pSrcCmplx,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pSrcReal,NPY_INT32,int32_t,int32_t);
-    numSamples = arraySizepSrcCmplx ;
-    numSamples = numSamples / 2;
-
-    pCmplxDst=PyMem_Malloc(sizeof(q31_t)*2*numSamples);
-
-
-    arm_cmplx_mult_real_q31(pSrcCmplx_converted,pSrcReal_converted,pCmplxDst,numSamples);
- INT32ARRAY1(pCmplxDstOBJ,2*numSamples,pCmplxDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pCmplxDstOBJ);
-
-    FREEARGUMENT(pSrcCmplx_converted);
-    FREEARGUMENT(pSrcReal_converted);
-    Py_DECREF(pCmplxDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cmplx_mult_real_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcCmplx=NULL; // input
-  float32_t *pSrcCmplx_converted=NULL; // input
-  PyObject *pSrcReal=NULL; // input
-  float32_t *pSrcReal_converted=NULL; // input
-  float32_t *pCmplxDst=NULL; // output
-  uint32_t numSamples; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcCmplx,&pSrcReal))
-  {
-
-    GETARGUMENT(pSrcCmplx,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pSrcReal,NPY_DOUBLE,double,float32_t);
-    numSamples = arraySizepSrcCmplx ;
-    numSamples = numSamples / 2;
-
-    pCmplxDst=PyMem_Malloc(sizeof(float32_t)*2*numSamples);
-
-
-    arm_cmplx_mult_real_f32(pSrcCmplx_converted,pSrcReal_converted,pCmplxDst,numSamples);
- FLOATARRAY1(pCmplxDstOBJ,2*numSamples,pCmplxDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pCmplxDstOBJ);
-
-    FREEARGUMENT(pSrcCmplx_converted);
-    FREEARGUMENT(pSrcReal_converted);
-    Py_DECREF(pCmplxDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_min_q7(PyObject *obj, PyObject *args)
-{
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q7_t *pResult=NULL; // output
-  uint32_t *pIndex=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q7_t)*1);
-
-
-    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
-
-
-    arm_min_q7(pSrc_converted,blockSize,pResult,pIndex);
-    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
-    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
-
-    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    Py_DECREF(pIndexOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_min_no_idx_q7(PyObject *obj, PyObject *args)
-{
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q7_t pResult;
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-
-
-    arm_min_no_idx_q7(pSrc_converted,blockSize,&pResult);
-    PyObject* pResultOBJ=Py_BuildValue("i",pResult);
-
-
-    FREEARGUMENT(pSrc_converted);
-    return(pResultOBJ);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_absmin_q7(PyObject *obj, PyObject *args)
-{
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q7_t *pResult=NULL; // output
-  uint32_t *pIndex=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q7_t)*1);
-
-
-    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
-
-
-    arm_absmin_q7(pSrc_converted,blockSize,pResult,pIndex);
-    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
-    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
-
-    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    Py_DECREF(pIndexOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_absmin_no_idx_q7(PyObject *obj, PyObject *args)
-{
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q7_t pResult; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-
-
-
-
-    arm_absmin_no_idx_q7(pSrc_converted,blockSize,&pResult);
-    PyObject* pResultOBJ=Py_BuildValue("i",pResult);
-
-
-    FREEARGUMENT(pSrc_converted);
-    return(pResultOBJ);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_min_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q15_t *pResult=NULL; // output
-  uint32_t *pIndex=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q15_t)*1);
-
-
-    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
-
-
-    arm_min_q15(pSrc_converted,blockSize,pResult,pIndex);
-    PyObject* pResultOBJ=Py_BuildValue("h",*pResult);
-    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
-
-    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    Py_DECREF(pIndexOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_min_no_idx_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q15_t pResult; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-
-
-
-
-    arm_min_no_idx_q15(pSrc_converted,blockSize,&pResult);
-    PyObject* pResultOBJ=Py_BuildValue("h",pResult);
-
-
-    FREEARGUMENT(pSrc_converted);
-    return(pResultOBJ);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_absmin_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q15_t *pResult=NULL; // output
-  uint32_t *pIndex=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q15_t)*1);
-
-
-    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
-
-
-    arm_absmin_q15(pSrc_converted,blockSize,pResult,pIndex);
-    PyObject* pResultOBJ=Py_BuildValue("h",*pResult);
-    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
-
-    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    Py_DECREF(pIndexOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_absmin_no_idx_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q15_t pResult; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-
-
-
-
-    arm_absmin_no_idx_q15(pSrc_converted,blockSize,&pResult);
-    PyObject* pResultOBJ=Py_BuildValue("h",pResult);
-
-
-    FREEARGUMENT(pSrc_converted);
-    return(pResultOBJ);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_min_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q31_t *pResult=NULL; // output
-  uint32_t *pIndex=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q31_t)*1);
-
-
-    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
-
-
-    arm_min_q31(pSrc_converted,blockSize,pResult,pIndex);
-    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
-    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
-
-    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    Py_DECREF(pIndexOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_min_no_idx_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q31_t pResult; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-
-
-
-
-    arm_min_no_idx_q31(pSrc_converted,blockSize,&pResult);
-    PyObject* pResultOBJ=Py_BuildValue("i",pResult);
-
-
-    FREEARGUMENT(pSrc_converted);
-    return(pResultOBJ);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_absmin_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q31_t *pResult=NULL; // output
-  uint32_t *pIndex=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q31_t)*1);
-
-
-    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
-
-
-    arm_absmin_q31(pSrc_converted,blockSize,pResult,pIndex);
-    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
-    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
-
-    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    Py_DECREF(pIndexOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_absmin_no_idx_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q31_t pResult; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-
-
-
-    arm_absmin_no_idx_q31(pSrc_converted,blockSize,&pResult);
-    PyObject* pResultOBJ=Py_BuildValue("i",pResult);
-
-
-    FREEARGUMENT(pSrc_converted);
-    return(pResultOBJ);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_min_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  float32_t *pResult=NULL; // output
-  uint32_t *pIndex=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(float32_t)*1);
-
-
-    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
-
-
-    arm_min_f32(pSrc_converted,blockSize,pResult,pIndex);
-    PyObject* pResultOBJ=Py_BuildValue("f",*pResult);
-    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
-
-    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    Py_DECREF(pIndexOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_absmin_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  float32_t *pResult=NULL; // output
-  uint32_t *pIndex=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(float32_t)*1);
-
-
-    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
-
-
-    arm_absmin_f32(pSrc_converted,blockSize,pResult,pIndex);
-    PyObject* pResultOBJ=Py_BuildValue("f",*pResult);
-    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
-
-    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    Py_DECREF(pIndexOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_max_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q7_t *pResult=NULL; // output
-  uint32_t *pIndex=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q7_t)*1);
-
-
-    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
-
-
-    arm_max_q7(pSrc_converted,blockSize,pResult,pIndex);
-    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
-    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
-
-    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    Py_DECREF(pIndexOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_max_no_idx_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q7_t pResult; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-
-
-
-
-    arm_max_no_idx_q7(pSrc_converted,blockSize,&pResult);
-    PyObject* pResultOBJ=Py_BuildValue("i",pResult);
-
-
-    FREEARGUMENT(pSrc_converted);
-    return(pResultOBJ);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_absmax_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q7_t *pResult=NULL; // output
-  uint32_t *pIndex=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q7_t)*1);
-
-
-    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
-
-
-    arm_absmax_q7(pSrc_converted,blockSize,pResult,pIndex);
-    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
-    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
-
-    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    Py_DECREF(pIndexOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_absmax_no_idx_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q7_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q7_t pResult; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
-    blockSize = arraySizepSrc ;
-
-
-
-
-
-    arm_absmax_no_idx_q7(pSrc_converted,blockSize,&pResult);
-    PyObject* pResultOBJ=Py_BuildValue("i",pResult);
-
-
-    FREEARGUMENT(pSrc_converted);
-    return(pResultOBJ);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_max_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q15_t *pResult=NULL; // output
-  uint32_t *pIndex=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q15_t)*1);
-
-
-    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
-
-
-    arm_max_q15(pSrc_converted,blockSize,pResult,pIndex);
-    PyObject* pResultOBJ=Py_BuildValue("h",*pResult);
-    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
-
-    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    Py_DECREF(pIndexOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_max_no_idx_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q15_t pResult; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-
-
-
-
-    arm_max_no_idx_q15(pSrc_converted,blockSize,&pResult);
-    PyObject* pResultOBJ=Py_BuildValue("h",pResult);
-
-
-    FREEARGUMENT(pSrc_converted);
-    return(pResultOBJ);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_absmax_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q15_t *pResult=NULL; // output
-  uint32_t *pIndex=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q15_t)*1);
-
-
-    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
-
-
-    arm_absmax_q15(pSrc_converted,blockSize,pResult,pIndex);
-    PyObject* pResultOBJ=Py_BuildValue("h",*pResult);
-    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
-
-    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    Py_DECREF(pIndexOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_absmax_no_idx_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q15_t pResult; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-
-
-
-    arm_absmax_no_idx_q15(pSrc_converted,blockSize,&pResult);
-    PyObject* pResultOBJ=Py_BuildValue("h",pResult);
-
-
-    FREEARGUMENT(pSrc_converted);
-    return(pResultOBJ);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_max_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q31_t *pResult=NULL; // output
-  uint32_t *pIndex=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q31_t)*1);
-
-
-    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
-
-
-    arm_max_q31(pSrc_converted,blockSize,pResult,pIndex);
-    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
-    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
-
-    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    Py_DECREF(pIndexOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_max_no_idx_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q31_t pResult; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-
-
-
-
-    arm_max_no_idx_q31(pSrc_converted,blockSize,&pResult);
-    PyObject* pResultOBJ=Py_BuildValue("i",pResult);
-
-
-    FREEARGUMENT(pSrc_converted);
-    return(pResultOBJ);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_absmax_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q31_t *pResult=NULL; // output
-  uint32_t *pIndex=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(q31_t)*1);
-
-
-    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
-
-
-    arm_absmax_q31(pSrc_converted,blockSize,pResult,pIndex);
-    PyObject* pResultOBJ=Py_BuildValue("i",*pResult);
-    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
-
-    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    Py_DECREF(pIndexOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_absmax_no_idx_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  q31_t pResult; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-
-
-
-    arm_absmax_no_idx_q31(pSrc_converted,blockSize,&pResult);
-    PyObject* pResultOBJ=Py_BuildValue("i",pResult);
-
-
-    FREEARGUMENT(pSrc_converted);
-    return(pResultOBJ);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_max_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  float32_t *pResult=NULL; // output
-  uint32_t *pIndex=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(float32_t)*1);
-
-
-    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
-
-
-    arm_max_f32(pSrc_converted,blockSize,pResult,pIndex);
-    PyObject* pResultOBJ=Py_BuildValue("f",*pResult);
-    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
-
-    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    Py_DECREF(pIndexOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_absmax_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  uint32_t blockSize; // input
-  float32_t *pResult=NULL; // output
-  uint32_t *pIndex=NULL; // output
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pResult=PyMem_Malloc(sizeof(float32_t)*1);
-
-
-    pIndex=PyMem_Malloc(sizeof(uint32_t)*1);
-
-
-    arm_absmax_f32(pSrc_converted,blockSize,pResult,pIndex);
-    PyObject* pResultOBJ=Py_BuildValue("f",*pResult);
-    PyObject* pIndexOBJ=Py_BuildValue("i",*pIndex);
-
-    PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pResultOBJ);
-    Py_DECREF(pIndexOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cmplx_mult_cmplx_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q15_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  q15_t *pSrcB_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t numSamples; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
-    numSamples = arraySizepSrcA ;
-    numSamples = numSamples / 2;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*2*numSamples);
-
-
-    arm_cmplx_mult_cmplx_q15(pSrcA_converted,pSrcB_converted,pDst,numSamples);
- INT16ARRAY1(pDstOBJ,2*numSamples,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cmplx_mult_cmplx_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  q31_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  q31_t *pSrcB_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t numSamples; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
-    numSamples = arraySizepSrcA ;
-    numSamples = numSamples / 2;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*2*numSamples);
-
-
-    arm_cmplx_mult_cmplx_q31(pSrcA_converted,pSrcB_converted,pDst,numSamples);
- INT32ARRAY1(pDstOBJ,2*numSamples,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_cmplx_mult_cmplx_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrcA=NULL; // input
-  float32_t *pSrcA_converted=NULL; // input
-  PyObject *pSrcB=NULL; // input
-  float32_t *pSrcB_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t numSamples; // input
-
-  if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
-  {
-
-    GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
-    numSamples = arraySizepSrcA ;
-    numSamples = numSamples / 2;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*2*numSamples);
-
-
-    arm_cmplx_mult_cmplx_f32(pSrcA_converted,pSrcB_converted,pDst,numSamples);
- FLOATARRAY1(pDstOBJ,2*numSamples,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrcA_converted);
-    FREEARGUMENT(pSrcB_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_float_to_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_float_to_q31(pSrc_converted,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_float_to_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_float_to_q15(pSrc_converted,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_float_to_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  float32_t *pSrc_converted=NULL; // input
-  q7_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
-
-
-    arm_float_to_q7(pSrc_converted,pDst,blockSize);
- INT8ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_q31_to_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q15_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
-
-
-    arm_q31_to_q15(pSrc_converted,pDst,blockSize);
- INT16ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_q31_to_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q31_t *pSrc_converted=NULL; // input
-  q7_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
-
-
-    arm_q31_to_q7(pSrc_converted,pDst,blockSize);
- INT8ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_q15_to_float(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  float32_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
-
-
-    arm_q15_to_float(pSrc_converted,pDst,blockSize);
- FLOATARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_q15_to_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q31_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
-
-
-    arm_q15_to_q31(pSrc_converted,pDst,blockSize);
- INT32ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_q15_to_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *pSrc=NULL; // input
-  q15_t *pSrc_converted=NULL; // input
-  q7_t *pDst=NULL; // output
-  uint32_t blockSize; // input
-
-  if (PyArg_ParseTuple(args,"O",&pSrc))
-  {
-
-    GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
-    blockSize = arraySizepSrc ;
-
-    pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
-
-
-    arm_q15_to_q7(pSrc_converted,pDst,blockSize);
- INT8ARRAY1(pDstOBJ,blockSize,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-
-    FREEARGUMENT(pSrc_converted);
-    Py_DECREF(pDstOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_bilinear_interp_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  float32_t X; // input
-  float32_t Y; // input
-
-  if (PyArg_ParseTuple(args,"Off",&S,&X,&Y))
-  {
-
-    ml_arm_bilinear_interp_instance_f32Object *selfS = (ml_arm_bilinear_interp_instance_f32Object *)S;
-
-    float32_t returnValue = arm_bilinear_interp_f32(selfS->instance,X,Y);
-    PyObject* theReturnOBJ=Py_BuildValue("f",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_bilinear_interp_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  q31_t X; // input
-  q31_t Y; // input
-
-  if (PyArg_ParseTuple(args,"Oii",&S,&X,&Y))
-  {
-
-    ml_arm_bilinear_interp_instance_q31Object *selfS = (ml_arm_bilinear_interp_instance_q31Object *)S;
-
-    q31_t returnValue = arm_bilinear_interp_q31(selfS->instance,X,Y);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_bilinear_interp_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  q31_t X; // input
-  q31_t Y; // input
-
-  if (PyArg_ParseTuple(args,"Oii",&S,&X,&Y))
-  {
-
-    ml_arm_bilinear_interp_instance_q15Object *selfS = (ml_arm_bilinear_interp_instance_q15Object *)S;
-
-    q15_t returnValue = arm_bilinear_interp_q15(selfS->instance,X,Y);
-    PyObject* theReturnOBJ=Py_BuildValue("h",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-
-static PyObject *
-cmsis_arm_bilinear_interp_q7(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  q31_t X; // input
-  q31_t Y; // input
-
-  if (PyArg_ParseTuple(args,"Oii",&S,&X,&Y))
-  {
-
-    ml_arm_bilinear_interp_instance_q7Object *selfS = (ml_arm_bilinear_interp_instance_q7Object *)S;
-
-    q7_t returnValue = arm_bilinear_interp_q7(selfS->instance,X,Y);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-/*
-
-MFCC
-
-*/
-
-static PyObject *
-cmsis_arm_mfcc_init_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint32_t fftLen,nbMelFilters,nbDctOutputs; // input
-
-  PyObject *pdctCoefs=NULL; // input
-  float32_t *pdctCoefs_converted=NULL; // input
-
-  PyObject *pfilterCoefs=NULL; // input
-  float32_t *pfilterCoefs_converted=NULL; // input
-
-  PyObject *pwindowCoefs=NULL; // input
-  float32_t *pwindowCoefs_converted=NULL; // input
-
-  PyObject *pfilterPos=NULL; // input
-  uint32_t *pfilterPos_converted=NULL; // input
-
-  PyObject *pfilterLengths=NULL; // input
-  uint32_t *pfilterLengths_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OiiiOOOOO",&S,&fftLen,&nbMelFilters,&nbDctOutputs,
-    &pdctCoefs,&pfilterPos,&pfilterLengths,&pfilterCoefs,&pwindowCoefs))
-  {
-
-    ml_arm_mfcc_instance_f32Object *selfS = (ml_arm_mfcc_instance_f32Object *)S;
-
-    GETARGUMENT(pdctCoefs,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pfilterPos,NPY_UINT32,uint32_t,uint32_t);
-    GETARGUMENT(pfilterLengths,NPY_UINT32,uint32_t,uint32_t);
-    GETARGUMENT(pfilterCoefs,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(pwindowCoefs,NPY_DOUBLE,double,float32_t);
-
-
-    arm_status returnValue = arm_mfcc_init_f32(selfS->instance,
-        fftLen,nbMelFilters,nbDctOutputs,
-        pdctCoefs_converted,
-        pfilterPos_converted,pfilterLengths_converted,pfilterCoefs_converted,
-        pwindowCoefs_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mfcc_f32(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *p1=NULL; // input
-  float32_t *p1_converted=NULL; // input
-
-  PyObject *tmp=NULL; // input
-  float32_t *tmp_converted=NULL; // input
-
-  float32_t *pDst;
-  if (PyArg_ParseTuple(args,"OOO",&S,&p1,&tmp))
-  {
-
-    ml_arm_mfcc_instance_f32Object *selfS = (ml_arm_mfcc_instance_f32Object *)S;
-    GETARGUMENT(p1,NPY_DOUBLE,double,float32_t);
-    GETARGUMENT(tmp,NPY_DOUBLE,double,float32_t);
-
-    pDst=PyMem_Malloc(sizeof(float32_t)*selfS->instance->nbDctOutputs);
-
-    arm_mfcc_f32(selfS->instance,p1_converted,pDst,tmp_converted);
-
-    FLOATARRAY1(pDstOBJ,selfS->instance->nbDctOutputs,pDst);
-
-    PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
-    Py_DECREF(pDstOBJ);
-
-    FREEARGUMENT(p1_converted);
-    FREEARGUMENT(tmp_converted);
-
-    
-
-
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mfcc_init_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint32_t fftLen,nbMelFilters,nbDctOutputs; // input
-
-  PyObject *pdctCoefs=NULL; // input
-  q15_t *pdctCoefs_converted=NULL; // input
-
-  PyObject *pfilterCoefs=NULL; // input
-  q15_t *pfilterCoefs_converted=NULL; // input
-
-  PyObject *pwindowCoefs=NULL; // input
-  q15_t *pwindowCoefs_converted=NULL; // input
-
-  PyObject *pfilterPos=NULL; // input
-  uint32_t *pfilterPos_converted=NULL; // input
-
-  PyObject *pfilterLengths=NULL; // input
-  uint32_t *pfilterLengths_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OiiiOOOOO",&S,&fftLen,&nbMelFilters,&nbDctOutputs,
-    &pdctCoefs,&pfilterPos,&pfilterLengths,&pfilterCoefs,&pwindowCoefs))
-  {
-
-    ml_arm_mfcc_instance_q15Object *selfS = (ml_arm_mfcc_instance_q15Object *)S;
-
-    GETARGUMENT(pdctCoefs,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pfilterPos,NPY_UINT32,uint32_t,uint32_t);
-    GETARGUMENT(pfilterLengths,NPY_UINT32,uint32_t,uint32_t);
-    GETARGUMENT(pfilterCoefs,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(pwindowCoefs,NPY_INT16,int16_t,int16_t);
-
-
-    arm_status returnValue = arm_mfcc_init_q15(selfS->instance,
-        fftLen,nbMelFilters,nbDctOutputs,
-        pdctCoefs_converted,
-        pfilterPos_converted,pfilterLengths_converted,pfilterCoefs_converted,
-        pwindowCoefs_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mfcc_q15(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *p1=NULL; // input
-  q15_t *p1_converted=NULL; // input
-
-  PyObject *tmp=NULL; // input
-  q31_t *tmp_converted=NULL; // input
-
-  q15_t *pDst;
-  if (PyArg_ParseTuple(args,"OOO",&S,&p1,&tmp))
-  {
-
-    ml_arm_mfcc_instance_q15Object *selfS = (ml_arm_mfcc_instance_q15Object *)S;
-    GETARGUMENT(p1,NPY_INT16,int16_t,int16_t);
-    GETARGUMENT(tmp,NPY_INT32,int32_t,int32_t);
-
-    pDst=PyMem_Malloc(sizeof(q15_t)*selfS->instance->nbDctOutputs);
-
-    arm_status status = arm_mfcc_q15(selfS->instance,p1_converted,pDst,tmp_converted);
-
-    INT16ARRAY1(pDstOBJ,selfS->instance->nbDctOutputs,pDst);
-
-    PyObject* theReturnOBJ=Py_BuildValue("i",status);
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-    Py_DECREF(pDstOBJ);
-    Py_DECREF(theReturnOBJ);
-
-    FREEARGUMENT(p1_converted);
-    FREEARGUMENT(tmp_converted);
-
-
-
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mfcc_init_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  uint32_t fftLen,nbMelFilters,nbDctOutputs; // input
-
-  PyObject *pdctCoefs=NULL; // input
-  q31_t *pdctCoefs_converted=NULL; // input
-
-  PyObject *pfilterCoefs=NULL; // input
-  q31_t *pfilterCoefs_converted=NULL; // input
-
-  PyObject *pwindowCoefs=NULL; // input
-  q31_t *pwindowCoefs_converted=NULL; // input
-
-  PyObject *pfilterPos=NULL; // input
-  uint32_t *pfilterPos_converted=NULL; // input
-
-  PyObject *pfilterLengths=NULL; // input
-  uint32_t *pfilterLengths_converted=NULL; // input
-
-  if (PyArg_ParseTuple(args,"OiiiOOOOO",&S,&fftLen,&nbMelFilters,&nbDctOutputs,
-    &pdctCoefs,&pfilterPos,&pfilterLengths,&pfilterCoefs,&pwindowCoefs))
-  {
-
-    ml_arm_mfcc_instance_q31Object *selfS = (ml_arm_mfcc_instance_q31Object *)S;
-
-    GETARGUMENT(pdctCoefs,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pfilterPos,NPY_UINT32,uint32_t,uint32_t);
-    GETARGUMENT(pfilterLengths,NPY_UINT32,uint32_t,uint32_t);
-    GETARGUMENT(pfilterCoefs,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(pwindowCoefs,NPY_INT32,int32_t,int32_t);
-
-
-    arm_status returnValue = arm_mfcc_init_q31(selfS->instance,
-        fftLen,nbMelFilters,nbDctOutputs,
-        pdctCoefs_converted,
-        pfilterPos_converted,pfilterLengths_converted,pfilterCoefs_converted,
-        pwindowCoefs_converted);
-    PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
-
-    PyObject *pythonResult = Py_BuildValue("O",theReturnOBJ);
-
-    Py_DECREF(theReturnOBJ);
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_arm_mfcc_q31(PyObject *obj, PyObject *args)
-{
-
-  PyObject *S=NULL; // input
-  PyObject *p1=NULL; // input
-  q31_t *p1_converted=NULL; // input
-
-  PyObject *tmp=NULL; // input
-  q31_t *tmp_converted=NULL; // input
-
-  q31_t *pDst;
-  if (PyArg_ParseTuple(args,"OOO",&S,&p1,&tmp))
-  {
-
-    ml_arm_mfcc_instance_q31Object *selfS = (ml_arm_mfcc_instance_q31Object *)S;
-    GETARGUMENT(p1,NPY_INT32,int32_t,int32_t);
-    GETARGUMENT(tmp,NPY_INT32,int32_t,int32_t);
-
-    pDst=PyMem_Malloc(sizeof(q31_t)*selfS->instance->nbDctOutputs);
-
-    arm_status status = arm_mfcc_q31(selfS->instance,p1_converted,pDst,tmp_converted);
-
-    INT32ARRAY1(pDstOBJ,selfS->instance->nbDctOutputs,pDst);
-
-    PyObject* theReturnOBJ=Py_BuildValue("i",status);
-    PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
-    Py_DECREF(pDstOBJ);
-    Py_DECREF(theReturnOBJ);
-
-    FREEARGUMENT(p1_converted);
-    FREEARGUMENT(tmp_converted);
-
-
-
-    return(pythonResult);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_ssat(PyObject *obj, PyObject *args)
-{
-
-  int32_t val; // input
-  uint32_t sat;
-
-  if (PyArg_ParseTuple(args,"iI",&val,&sat))
-  {
-
-    int32_t result = __SSAT(val,sat);
-    PyObject* theReturnOBJ=Py_BuildValue("i",result);
-
-    return(theReturnOBJ);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_usat(PyObject *obj, PyObject *args)
-{
-
-  int32_t val; // input
-  uint32_t sat;
-  q15_t pOut,shift; // output
-
-  if (PyArg_ParseTuple(args,"iI",&val,&sat))
-  {
-
-    uint32_t result = __USAT(val,sat);
-    PyObject* theReturnOBJ=Py_BuildValue("I",result);
-
-    return(theReturnOBJ);
-
-  }
-  return(NULL);
-}
-
-static PyObject *
-cmsis_clz(PyObject *obj, PyObject *args)
-{
-
-  uint32_t val;
-
-  if (PyArg_ParseTuple(args,"I",&val))
-  {
-
-    uint8_t result = __CLZ(val);
-    PyObject* theReturnOBJ=Py_BuildValue("B",result);
-
-    return(theReturnOBJ);
-
-  }
-  return(NULL);
-}
-
-static PyMethodDef CMSISMLMethods[] = {
-
-{"arm_recip_q31",  cmsis_arm_recip_q31, METH_VARARGS,""},
-{"arm_recip_q15",  cmsis_arm_recip_q15, METH_VARARGS,""},
-{"arm_fir_q7",  cmsis_arm_fir_q7, METH_VARARGS,""},
-{"arm_fir_init_q7",  cmsis_arm_fir_init_q7, METH_VARARGS,""},
-{"arm_fir_q15",  cmsis_arm_fir_q15, METH_VARARGS,""},
-{"arm_fir_fast_q15",  cmsis_arm_fir_fast_q15, METH_VARARGS,""},
-{"arm_fir_init_q15",  cmsis_arm_fir_init_q15, METH_VARARGS,""},
-{"arm_fir_q31",  cmsis_arm_fir_q31, METH_VARARGS,""},
-{"arm_fir_fast_q31",  cmsis_arm_fir_fast_q31, METH_VARARGS,""},
-{"arm_fir_init_q31",  cmsis_arm_fir_init_q31, METH_VARARGS,""},
-{"arm_fir_f32",  cmsis_arm_fir_f32, METH_VARARGS,""},
-{"arm_fir_init_f32",  cmsis_arm_fir_init_f32, METH_VARARGS,""},
-{"arm_biquad_cascade_df1_q15",  cmsis_arm_biquad_cascade_df1_q15, METH_VARARGS,""},
-{"arm_biquad_cascade_df1_init_q15",  cmsis_arm_biquad_cascade_df1_init_q15, METH_VARARGS,""},
-{"arm_biquad_cascade_df1_fast_q15",  cmsis_arm_biquad_cascade_df1_fast_q15, METH_VARARGS,""},
-{"arm_biquad_cascade_df1_q31",  cmsis_arm_biquad_cascade_df1_q31, METH_VARARGS,""},
-{"arm_biquad_cascade_df1_fast_q31",  cmsis_arm_biquad_cascade_df1_fast_q31, METH_VARARGS,""},
-{"arm_biquad_cascade_df1_init_q31",  cmsis_arm_biquad_cascade_df1_init_q31, METH_VARARGS,""},
-{"arm_biquad_cascade_df1_f32",  cmsis_arm_biquad_cascade_df1_f32, METH_VARARGS,""},
-{"arm_biquad_cascade_df1_init_f32",  cmsis_arm_biquad_cascade_df1_init_f32, METH_VARARGS,""},
-{"arm_mat_add_f32",  cmsis_arm_mat_add_f32, METH_VARARGS,""},
-{"arm_mat_add_q15",  cmsis_arm_mat_add_q15, METH_VARARGS,""},
-{"arm_mat_add_q31",  cmsis_arm_mat_add_q31, METH_VARARGS,""},
-{"arm_mat_cmplx_mult_f32",  cmsis_arm_mat_cmplx_mult_f32, METH_VARARGS,""},
-{"arm_mat_cmplx_mult_q15",  cmsis_arm_mat_cmplx_mult_q15, METH_VARARGS,""},
-{"arm_mat_cmplx_mult_q31",  cmsis_arm_mat_cmplx_mult_q31, METH_VARARGS,""},
-{"arm_mat_trans_f32",  cmsis_arm_mat_trans_f32, METH_VARARGS,""},
-{"arm_mat_trans_q15",  cmsis_arm_mat_trans_q15, METH_VARARGS,""},
-{"arm_mat_trans_q31",  cmsis_arm_mat_trans_q31, METH_VARARGS,""},
-{"arm_mat_trans_q7",  cmsis_arm_mat_trans_q7, METH_VARARGS,""},
-
-
-{"arm_mat_vec_mult_f32",  cmsis_arm_mat_vec_mult_f32, METH_VARARGS,""},
-{"arm_mat_vec_mult_q31",  cmsis_arm_mat_vec_mult_q31, METH_VARARGS,""},
-{"arm_mat_vec_mult_q15",  cmsis_arm_mat_vec_mult_q15, METH_VARARGS,""},
-{"arm_mat_vec_mult_q7",  cmsis_arm_mat_vec_mult_q7, METH_VARARGS,""},
-
-{"arm_mat_mult_f32",  cmsis_arm_mat_mult_f32, METH_VARARGS,""},
-{"arm_mat_mult_q7",  cmsis_arm_mat_mult_q7, METH_VARARGS,""},
-{"arm_mat_mult_q15",  cmsis_arm_mat_mult_q15, METH_VARARGS,""},
-{"arm_mat_mult_fast_q15",  cmsis_arm_mat_mult_fast_q15, METH_VARARGS,""},
-{"arm_mat_mult_q31",  cmsis_arm_mat_mult_q31, METH_VARARGS,""},
-{"arm_mat_mult_opt_q31",  cmsis_arm_mat_mult_opt_q31, METH_VARARGS,""},
-{"arm_mat_mult_fast_q31",  cmsis_arm_mat_mult_fast_q31, METH_VARARGS,""},
-{"arm_mat_sub_f32",  cmsis_arm_mat_sub_f32, METH_VARARGS,""},
-{"arm_mat_sub_q15",  cmsis_arm_mat_sub_q15, METH_VARARGS,""},
-{"arm_mat_sub_q31",  cmsis_arm_mat_sub_q31, METH_VARARGS,""},
-{"arm_mat_scale_f32",  cmsis_arm_mat_scale_f32, METH_VARARGS,""},
-{"arm_mat_scale_q15",  cmsis_arm_mat_scale_q15, METH_VARARGS,""},
-{"arm_mat_scale_q31",  cmsis_arm_mat_scale_q31, METH_VARARGS,""},
-{"arm_pid_init_f32",  cmsis_arm_pid_init_f32, METH_VARARGS,""},
-{"arm_pid_reset_f32",  cmsis_arm_pid_reset_f32, METH_VARARGS,""},
-{"arm_pid_init_q31",  cmsis_arm_pid_init_q31, METH_VARARGS,""},
-{"arm_pid_reset_q31",  cmsis_arm_pid_reset_q31, METH_VARARGS,""},
-{"arm_pid_init_q15",  cmsis_arm_pid_init_q15, METH_VARARGS,""},
-{"arm_pid_reset_q15",  cmsis_arm_pid_reset_q15, METH_VARARGS,""},
-{"arm_mult_q7",  cmsis_arm_mult_q7, METH_VARARGS,""},
-{"arm_mult_q15",  cmsis_arm_mult_q15, METH_VARARGS,""},
-{"arm_mult_q31",  cmsis_arm_mult_q31, METH_VARARGS,""},
-{"arm_mult_f32",  cmsis_arm_mult_f32, METH_VARARGS,""},
-{"arm_cfft_radix2_init_q15",  cmsis_arm_cfft_radix2_init_q15, METH_VARARGS,""},
-{"arm_cfft_radix2_q15",  cmsis_arm_cfft_radix2_q15, METH_VARARGS,""},
-{"arm_cfft_radix4_init_q15",  cmsis_arm_cfft_radix4_init_q15, METH_VARARGS,""},
-{"arm_cfft_radix4_q15",  cmsis_arm_cfft_radix4_q15, METH_VARARGS,""},
-{"arm_cfft_radix2_init_q31",  cmsis_arm_cfft_radix2_init_q31, METH_VARARGS,""},
-{"arm_cfft_radix2_q31",  cmsis_arm_cfft_radix2_q31, METH_VARARGS,""},
-{"arm_cfft_radix4_q31",  cmsis_arm_cfft_radix4_q31, METH_VARARGS,""},
-{"arm_cfft_radix4_init_q31",  cmsis_arm_cfft_radix4_init_q31, METH_VARARGS,""},
-{"arm_cfft_radix2_init_f32",  cmsis_arm_cfft_radix2_init_f32, METH_VARARGS,""},
-{"arm_cfft_radix2_f32",  cmsis_arm_cfft_radix2_f32, METH_VARARGS,""},
-{"arm_cfft_radix4_init_f32",  cmsis_arm_cfft_radix4_init_f32, METH_VARARGS,""},
-{"arm_cfft_radix4_f32",  cmsis_arm_cfft_radix4_f32, METH_VARARGS,""},
-{"arm_cfft_q15",  cmsis_arm_cfft_q15, METH_VARARGS,""},
-{"arm_cfft_q31",  cmsis_arm_cfft_q31, METH_VARARGS,""},
-{"arm_cfft_f64",  cmsis_arm_cfft_f64, METH_VARARGS,""},
-{"arm_cfft_f32",  cmsis_arm_cfft_f32, METH_VARARGS,""},
-{"arm_rfft_init_q15",  cmsis_arm_rfft_init_q15, METH_VARARGS,""},
-{"arm_rfft_q15",  cmsis_arm_rfft_q15, METH_VARARGS,""},
-{"arm_rfft_init_q31",  cmsis_arm_rfft_init_q31, METH_VARARGS,""},
-{"arm_rfft_q31",  cmsis_arm_rfft_q31, METH_VARARGS,""},
-{"arm_rfft_init_f32",  cmsis_arm_rfft_init_f32, METH_VARARGS,""},
-{"arm_rfft_f32",  cmsis_arm_rfft_f32, METH_VARARGS,""},
-{"arm_rfft_fast_init_f64",  cmsis_arm_rfft_fast_init_f64, METH_VARARGS,""},
-{"arm_rfft_fast_f32",  cmsis_arm_rfft_fast_f32, METH_VARARGS,""},
-{"arm_rfft_fast_init_f32",  cmsis_arm_rfft_fast_init_f32, METH_VARARGS,""},
-{"arm_rfft_fast_f32",  cmsis_arm_rfft_fast_f32, METH_VARARGS,""},
-{"arm_dct4_init_f32",  cmsis_arm_dct4_init_f32, METH_VARARGS,""},
-{"arm_dct4_f32",  cmsis_arm_dct4_f32, METH_VARARGS,""},
-{"arm_dct4_init_q31",  cmsis_arm_dct4_init_q31, METH_VARARGS,""},
-{"arm_dct4_q31",  cmsis_arm_dct4_q31, METH_VARARGS,""},
-{"arm_dct4_init_q15",  cmsis_arm_dct4_init_q15, METH_VARARGS,""},
-{"arm_dct4_q15",  cmsis_arm_dct4_q15, METH_VARARGS,""},
-{"arm_add_f32",  cmsis_arm_add_f32, METH_VARARGS,""},
-{"arm_add_q7",  cmsis_arm_add_q7, METH_VARARGS,""},
-{"arm_add_q15",  cmsis_arm_add_q15, METH_VARARGS,""},
-{"arm_add_q31",  cmsis_arm_add_q31, METH_VARARGS,""},
-{"arm_sub_f32",  cmsis_arm_sub_f32, METH_VARARGS,""},
-{"arm_sub_q7",  cmsis_arm_sub_q7, METH_VARARGS,""},
-{"arm_sub_q15",  cmsis_arm_sub_q15, METH_VARARGS,""},
-{"arm_sub_q31",  cmsis_arm_sub_q31, METH_VARARGS,""},
-{"arm_scale_f32",  cmsis_arm_scale_f32, METH_VARARGS,""},
-{"arm_scale_q7",  cmsis_arm_scale_q7, METH_VARARGS,""},
-{"arm_scale_q15",  cmsis_arm_scale_q15, METH_VARARGS,""},
-{"arm_scale_q31",  cmsis_arm_scale_q31, METH_VARARGS,""},
-{"arm_abs_q7",  cmsis_arm_abs_q7, METH_VARARGS,""},
-{"arm_abs_f32",  cmsis_arm_abs_f32, METH_VARARGS,""},
-{"arm_abs_q15",  cmsis_arm_abs_q15, METH_VARARGS,""},
-{"arm_abs_q31",  cmsis_arm_abs_q31, METH_VARARGS,""},
-{"arm_vlog_q15",  cmsis_arm_vlog_q15, METH_VARARGS,""},
-{"arm_vlog_q31",  cmsis_arm_vlog_q31, METH_VARARGS,""},
-{"arm_dot_prod_f32",  cmsis_arm_dot_prod_f32, METH_VARARGS,""},
-{"arm_dot_prod_q7",  cmsis_arm_dot_prod_q7, METH_VARARGS,""},
-{"arm_dot_prod_q15",  cmsis_arm_dot_prod_q15, METH_VARARGS,""},
-{"arm_dot_prod_q31",  cmsis_arm_dot_prod_q31, METH_VARARGS,""},
-{"arm_shift_q7",  cmsis_arm_shift_q7, METH_VARARGS,""},
-{"arm_shift_q15",  cmsis_arm_shift_q15, METH_VARARGS,""},
-{"arm_shift_q31",  cmsis_arm_shift_q31, METH_VARARGS,""},
-{"arm_clip_f32",  cmsis_arm_clip_f32, METH_VARARGS,""},
-{"arm_clip_q31",  cmsis_arm_clip_q31, METH_VARARGS,""},
-{"arm_clip_q15",  cmsis_arm_clip_q15, METH_VARARGS,""},
-{"arm_clip_q7",  cmsis_arm_clip_q7, METH_VARARGS,""},
-{"arm_offset_f32",  cmsis_arm_offset_f32, METH_VARARGS,""},
-{"arm_offset_q7",  cmsis_arm_offset_q7, METH_VARARGS,""},
-{"arm_offset_q15",  cmsis_arm_offset_q15, METH_VARARGS,""},
-{"arm_offset_q31",  cmsis_arm_offset_q31, METH_VARARGS,""},
-{"arm_negate_f32",  cmsis_arm_negate_f32, METH_VARARGS,""},
-{"arm_negate_q7",  cmsis_arm_negate_q7, METH_VARARGS,""},
-{"arm_negate_q15",  cmsis_arm_negate_q15, METH_VARARGS,""},
-{"arm_negate_q31",  cmsis_arm_negate_q31, METH_VARARGS,""},
-{"arm_copy_f32",  cmsis_arm_copy_f32, METH_VARARGS,""},
-{"arm_copy_q7",  cmsis_arm_copy_q7, METH_VARARGS,""},
-{"arm_copy_q15",  cmsis_arm_copy_q15, METH_VARARGS,""},
-{"arm_copy_q31",  cmsis_arm_copy_q31, METH_VARARGS,""},
-{"arm_conv_f32",  cmsis_arm_conv_f32, METH_VARARGS,""},
-{"arm_conv_opt_q15",  cmsis_arm_conv_opt_q15, METH_VARARGS,""},
-{"arm_conv_q15",  cmsis_arm_conv_q15, METH_VARARGS,""},
-{"arm_conv_fast_q15",  cmsis_arm_conv_fast_q15, METH_VARARGS,""},
-{"arm_conv_fast_opt_q15",  cmsis_arm_conv_fast_opt_q15, METH_VARARGS,""},
-{"arm_conv_q31",  cmsis_arm_conv_q31, METH_VARARGS,""},
-{"arm_conv_fast_q31",  cmsis_arm_conv_fast_q31, METH_VARARGS,""},
-{"arm_conv_opt_q7",  cmsis_arm_conv_opt_q7, METH_VARARGS,""},
-{"arm_conv_q7",  cmsis_arm_conv_q7, METH_VARARGS,""},
-{"arm_conv_partial_f32",  cmsis_arm_conv_partial_f32, METH_VARARGS,""},
-{"arm_conv_partial_opt_q15",  cmsis_arm_conv_partial_opt_q15, METH_VARARGS,""},
-{"arm_conv_partial_q15",  cmsis_arm_conv_partial_q15, METH_VARARGS,""},
-{"arm_conv_partial_fast_q15",  cmsis_arm_conv_partial_fast_q15, METH_VARARGS,""},
-{"arm_conv_partial_fast_opt_q15",  cmsis_arm_conv_partial_fast_opt_q15, METH_VARARGS,""},
-{"arm_conv_partial_q31",  cmsis_arm_conv_partial_q31, METH_VARARGS,""},
-{"arm_conv_partial_fast_q31",  cmsis_arm_conv_partial_fast_q31, METH_VARARGS,""},
-{"arm_conv_partial_opt_q7",  cmsis_arm_conv_partial_opt_q7, METH_VARARGS,""},
-{"arm_conv_partial_q7",  cmsis_arm_conv_partial_q7, METH_VARARGS,""},
-{"arm_fir_decimate_f32",  cmsis_arm_fir_decimate_f32, METH_VARARGS,""},
-{"arm_fir_decimate_init_f32",  cmsis_arm_fir_decimate_init_f32, METH_VARARGS,""},
-{"arm_fir_decimate_q15",  cmsis_arm_fir_decimate_q15, METH_VARARGS,""},
-{"arm_fir_decimate_fast_q15",  cmsis_arm_fir_decimate_fast_q15, METH_VARARGS,""},
-{"arm_fir_decimate_init_q15",  cmsis_arm_fir_decimate_init_q15, METH_VARARGS,""},
-{"arm_fir_decimate_q31",  cmsis_arm_fir_decimate_q31, METH_VARARGS,""},
-{"arm_fir_decimate_fast_q31",  cmsis_arm_fir_decimate_fast_q31, METH_VARARGS,""},
-{"arm_fir_decimate_init_q31",  cmsis_arm_fir_decimate_init_q31, METH_VARARGS,""},
-{"arm_fir_interpolate_q15",  cmsis_arm_fir_interpolate_q15, METH_VARARGS,""},
-{"arm_fir_interpolate_init_q15",  cmsis_arm_fir_interpolate_init_q15, METH_VARARGS,""},
-{"arm_fir_interpolate_q31",  cmsis_arm_fir_interpolate_q31, METH_VARARGS,""},
-{"arm_fir_interpolate_init_q31",  cmsis_arm_fir_interpolate_init_q31, METH_VARARGS,""},
-{"arm_fir_interpolate_f32",  cmsis_arm_fir_interpolate_f32, METH_VARARGS,""},
-{"arm_fir_interpolate_init_f32",  cmsis_arm_fir_interpolate_init_f32, METH_VARARGS,""},
-{"arm_biquad_cas_df1_32x64_q31",  cmsis_arm_biquad_cas_df1_32x64_q31, METH_VARARGS,""},
-{"arm_biquad_cas_df1_32x64_init_q31",  cmsis_arm_biquad_cas_df1_32x64_init_q31, METH_VARARGS,""},
-{"arm_biquad_cascade_df2T_f32",  cmsis_arm_biquad_cascade_df2T_f32, METH_VARARGS,""},
-{"arm_biquad_cascade_stereo_df2T_f32",  cmsis_arm_biquad_cascade_stereo_df2T_f32, METH_VARARGS,""},
-{"arm_biquad_cascade_df2T_f64",  cmsis_arm_biquad_cascade_df2T_f64, METH_VARARGS,""},
-{"arm_biquad_cascade_df2T_init_f32",  cmsis_arm_biquad_cascade_df2T_init_f32, METH_VARARGS,""},
-{"arm_biquad_cascade_stereo_df2T_init_f32",  cmsis_arm_biquad_cascade_stereo_df2T_init_f32, METH_VARARGS,""},
-{"arm_biquad_cascade_df2T_init_f64",  cmsis_arm_biquad_cascade_df2T_init_f64, METH_VARARGS,""},
-{"arm_fir_lattice_init_q15",  cmsis_arm_fir_lattice_init_q15, METH_VARARGS,""},
-{"arm_fir_lattice_q15",  cmsis_arm_fir_lattice_q15, METH_VARARGS,""},
-{"arm_fir_lattice_init_q31",  cmsis_arm_fir_lattice_init_q31, METH_VARARGS,""},
-{"arm_fir_lattice_q31",  cmsis_arm_fir_lattice_q31, METH_VARARGS,""},
-{"arm_fir_lattice_init_f32",  cmsis_arm_fir_lattice_init_f32, METH_VARARGS,""},
-{"arm_fir_lattice_f32",  cmsis_arm_fir_lattice_f32, METH_VARARGS,""},
-{"arm_iir_lattice_f32",  cmsis_arm_iir_lattice_f32, METH_VARARGS,""},
-{"arm_iir_lattice_init_f32",  cmsis_arm_iir_lattice_init_f32, METH_VARARGS,""},
-{"arm_iir_lattice_q31",  cmsis_arm_iir_lattice_q31, METH_VARARGS,""},
-{"arm_iir_lattice_init_q31",  cmsis_arm_iir_lattice_init_q31, METH_VARARGS,""},
-{"arm_iir_lattice_q15",  cmsis_arm_iir_lattice_q15, METH_VARARGS,""},
-{"arm_iir_lattice_init_q15",  cmsis_arm_iir_lattice_init_q15, METH_VARARGS,""},
-{"arm_cfft_init_f32",  cmsis_arm_cfft_init_f32, METH_VARARGS,""},
-{"arm_cfft_init_f64",  cmsis_arm_cfft_init_f64, METH_VARARGS,""},
-{"arm_cfft_init_q31",  cmsis_arm_cfft_init_q31, METH_VARARGS,""},
-{"arm_cfft_init_q15",  cmsis_arm_cfft_init_q15, METH_VARARGS,""},
-{"arm_lms_f32",  cmsis_arm_lms_f32, METH_VARARGS,""},
-{"arm_lms_init_f32",  cmsis_arm_lms_init_f32, METH_VARARGS,""},
-{"arm_lms_init_q15",  cmsis_arm_lms_init_q15, METH_VARARGS,""},
-{"arm_lms_q15",  cmsis_arm_lms_q15, METH_VARARGS,""},
-{"arm_lms_q31",  cmsis_arm_lms_q31, METH_VARARGS,""},
-{"arm_lms_init_q31",  cmsis_arm_lms_init_q31, METH_VARARGS,""},
-{"arm_lms_norm_f32",  cmsis_arm_lms_norm_f32, METH_VARARGS,""},
-{"arm_lms_norm_init_f32",  cmsis_arm_lms_norm_init_f32, METH_VARARGS,""},
-{"arm_lms_norm_q31",  cmsis_arm_lms_norm_q31, METH_VARARGS,""},
-{"arm_lms_norm_init_q31",  cmsis_arm_lms_norm_init_q31, METH_VARARGS,""},
-{"arm_lms_norm_q15",  cmsis_arm_lms_norm_q15, METH_VARARGS,""},
-{"arm_lms_norm_init_q15",  cmsis_arm_lms_norm_init_q15, METH_VARARGS,""},
-{"arm_correlate_f32",  cmsis_arm_correlate_f32, METH_VARARGS,""},
-{"arm_correlate_opt_q15",  cmsis_arm_correlate_opt_q15, METH_VARARGS,""},
-{"arm_correlate_q15",  cmsis_arm_correlate_q15, METH_VARARGS,""},
-{"arm_correlate_fast_q15",  cmsis_arm_correlate_fast_q15, METH_VARARGS,""},
-{"arm_correlate_fast_opt_q15",  cmsis_arm_correlate_fast_opt_q15, METH_VARARGS,""},
-{"arm_correlate_q31",  cmsis_arm_correlate_q31, METH_VARARGS,""},
-{"arm_correlate_fast_q31",  cmsis_arm_correlate_fast_q31, METH_VARARGS,""},
-{"arm_correlate_opt_q7",  cmsis_arm_correlate_opt_q7, METH_VARARGS,""},
-{"arm_correlate_q7",  cmsis_arm_correlate_q7, METH_VARARGS,""},
-{"arm_fir_sparse_f32",  cmsis_arm_fir_sparse_f32, METH_VARARGS,""},
-{"arm_fir_sparse_init_f32",  cmsis_arm_fir_sparse_init_f32, METH_VARARGS,""},
-{"arm_fir_sparse_init_q31",  cmsis_arm_fir_sparse_init_q31, METH_VARARGS,""},
-{"arm_fir_sparse_init_q15",  cmsis_arm_fir_sparse_init_q15, METH_VARARGS,""},
-{"arm_fir_sparse_init_q7",  cmsis_arm_fir_sparse_init_q7, METH_VARARGS,""},
-{"arm_sin_cos_f32",  cmsis_arm_sin_cos_f32, METH_VARARGS,""},
-{"arm_sin_cos_q31",  cmsis_arm_sin_cos_q31, METH_VARARGS,""},
-{"arm_cmplx_conj_f32",  cmsis_arm_cmplx_conj_f32, METH_VARARGS,""},
-{"arm_cmplx_conj_q31",  cmsis_arm_cmplx_conj_q31, METH_VARARGS,""},
-{"arm_cmplx_conj_q15",  cmsis_arm_cmplx_conj_q15, METH_VARARGS,""},
-{"arm_cmplx_mag_squared_f32",  cmsis_arm_cmplx_mag_squared_f32, METH_VARARGS,""},
-{"arm_cmplx_mag_squared_q31",  cmsis_arm_cmplx_mag_squared_q31, METH_VARARGS,""},
-{"arm_cmplx_mag_squared_q15",  cmsis_arm_cmplx_mag_squared_q15, METH_VARARGS,""},
-{"arm_pid_f32",  cmsis_arm_pid_f32, METH_VARARGS,""},
-{"arm_pid_q31",  cmsis_arm_pid_q31, METH_VARARGS,""},
-{"arm_pid_q15",  cmsis_arm_pid_q15, METH_VARARGS,""},
-{"arm_mat_inverse_f32",  cmsis_arm_mat_inverse_f32, METH_VARARGS,""},
-{"arm_mat_inverse_f64",  cmsis_arm_mat_inverse_f64, METH_VARARGS,""},
-{"arm_clarke_f32",  cmsis_arm_clarke_f32, METH_VARARGS,""},
-{"arm_clarke_q31",  cmsis_arm_clarke_q31, METH_VARARGS,""},
-{"arm_q7_to_q31",  cmsis_arm_q7_to_q31, METH_VARARGS,""},
-{"arm_inv_clarke_f32",  cmsis_arm_inv_clarke_f32, METH_VARARGS,""},
-{"arm_inv_clarke_q31",  cmsis_arm_inv_clarke_q31, METH_VARARGS,""},
-{"arm_q7_to_q15",  cmsis_arm_q7_to_q15, METH_VARARGS,""},
-{"arm_park_f32",  cmsis_arm_park_f32, METH_VARARGS,""},
-{"arm_park_q31",  cmsis_arm_park_q31, METH_VARARGS,""},
-{"arm_q7_to_float",  cmsis_arm_q7_to_float, METH_VARARGS,""},
-{"arm_inv_park_f32",  cmsis_arm_inv_park_f32, METH_VARARGS,""},
-{"arm_inv_park_q31",  cmsis_arm_inv_park_q31, METH_VARARGS,""},
-{"arm_q31_to_float",  cmsis_arm_q31_to_float, METH_VARARGS,""},
-{"arm_linear_interp_f32",  cmsis_arm_linear_interp_f32, METH_VARARGS,""},
-{"arm_linear_interp_q31",  cmsis_arm_linear_interp_q31, METH_VARARGS,""},
-{"arm_linear_interp_q15",  cmsis_arm_linear_interp_q15, METH_VARARGS,""},
-{"arm_linear_interp_q7",  cmsis_arm_linear_interp_q7, METH_VARARGS,""},
-{"arm_sin_f32",  cmsis_arm_sin_f32, METH_VARARGS,""},
-{"arm_sin_q31",  cmsis_arm_sin_q31, METH_VARARGS,""},
-{"arm_sin_q15",  cmsis_arm_sin_q15, METH_VARARGS,""},
-{"arm_cos_f32",  cmsis_arm_cos_f32, METH_VARARGS,""},
-{"arm_cos_q31",  cmsis_arm_cos_q31, METH_VARARGS,""},
-{"arm_cos_q15",  cmsis_arm_cos_q15, METH_VARARGS,""},
-{"arm_sqrt_f32",  cmsis_arm_sqrt_f32, METH_VARARGS,""},
-{"arm_sqrt_q31",  cmsis_arm_sqrt_q31, METH_VARARGS,""},
-{"arm_sqrt_q15",  cmsis_arm_sqrt_q15, METH_VARARGS,""},
-{"arm_divide_q31",  cmsis_arm_divide_q31, METH_VARARGS,""},
-{"arm_divide_q15",  cmsis_arm_divide_q15, METH_VARARGS,""},
-{"arm_circularWrite_f32",  cmsis_arm_circularWrite_f32, METH_VARARGS,""},
-{"arm_circularWrite_q15",  cmsis_arm_circularWrite_q15, METH_VARARGS,""},
-{"arm_circularWrite_q7",  cmsis_arm_circularWrite_q7, METH_VARARGS,""},
-{"arm_power_q31",  cmsis_arm_power_q31, METH_VARARGS,""},
-{"arm_power_f32",  cmsis_arm_power_f32, METH_VARARGS,""},
-{"arm_power_q15",  cmsis_arm_power_q15, METH_VARARGS,""},
-{"arm_power_q7",  cmsis_arm_power_q7, METH_VARARGS,""},
-{"arm_mean_q7",  cmsis_arm_mean_q7, METH_VARARGS,""},
-{"arm_mean_q15",  cmsis_arm_mean_q15, METH_VARARGS,""},
-{"arm_mean_q31",  cmsis_arm_mean_q31, METH_VARARGS,""},
-{"arm_mean_f32",  cmsis_arm_mean_f32, METH_VARARGS,""},
-{"arm_var_f32",  cmsis_arm_var_f32, METH_VARARGS,""},
-{"arm_var_q31",  cmsis_arm_var_q31, METH_VARARGS,""},
-{"arm_var_q15",  cmsis_arm_var_q15, METH_VARARGS,""},
-{"arm_rms_f32",  cmsis_arm_rms_f32, METH_VARARGS,""},
-{"arm_rms_q31",  cmsis_arm_rms_q31, METH_VARARGS,""},
-{"arm_rms_q15",  cmsis_arm_rms_q15, METH_VARARGS,""},
-{"arm_std_f32",  cmsis_arm_std_f32, METH_VARARGS,""},
-{"arm_std_q31",  cmsis_arm_std_q31, METH_VARARGS,""},
-{"arm_std_q15",  cmsis_arm_std_q15, METH_VARARGS,""},
-{"arm_cmplx_mag_f32",  cmsis_arm_cmplx_mag_f32, METH_VARARGS,""},
-{"arm_cmplx_mag_q31",  cmsis_arm_cmplx_mag_q31, METH_VARARGS,""},
-{"arm_cmplx_mag_q15",  cmsis_arm_cmplx_mag_q15, METH_VARARGS,""},
-{"arm_cmplx_mag_fast_q15",  cmsis_arm_cmplx_mag_fast_q15, METH_VARARGS,""},
-{"arm_cmplx_dot_prod_q15",  cmsis_arm_cmplx_dot_prod_q15, METH_VARARGS,""},
-{"arm_cmplx_dot_prod_q31",  cmsis_arm_cmplx_dot_prod_q31, METH_VARARGS,""},
-{"arm_cmplx_dot_prod_f32",  cmsis_arm_cmplx_dot_prod_f32, METH_VARARGS,""},
-{"arm_cmplx_mult_real_q15",  cmsis_arm_cmplx_mult_real_q15, METH_VARARGS,""},
-{"arm_cmplx_mult_real_q31",  cmsis_arm_cmplx_mult_real_q31, METH_VARARGS,""},
-{"arm_cmplx_mult_real_f32",  cmsis_arm_cmplx_mult_real_f32, METH_VARARGS,""},
-{"arm_min_q7",  cmsis_arm_min_q7, METH_VARARGS,""},
-{"arm_min_no_idx_q7",  cmsis_arm_min_no_idx_q7, METH_VARARGS,""},
-{"arm_min_no_idx_q15",  cmsis_arm_min_no_idx_q15, METH_VARARGS,""},
-{"arm_min_no_idx_q31",  cmsis_arm_min_no_idx_q31, METH_VARARGS,""},
-{"arm_min_q15",  cmsis_arm_min_q15, METH_VARARGS,""},
-{"arm_min_q31",  cmsis_arm_min_q31, METH_VARARGS,""},
-{"arm_min_f32",  cmsis_arm_min_f32, METH_VARARGS,""},
-{"arm_absmin_q7",   cmsis_arm_absmin_q7, METH_VARARGS,""},
-{"arm_absmin_q15",  cmsis_arm_absmin_q15, METH_VARARGS,""},
-{"arm_absmin_q31",  cmsis_arm_absmin_q31, METH_VARARGS,""},
-{"arm_absmin_no_idx_q7",   cmsis_arm_absmin_no_idx_q7, METH_VARARGS,""},
-{"arm_absmin_no_idx_q15",  cmsis_arm_absmin_no_idx_q15, METH_VARARGS,""},
-{"arm_absmin_no_idx_q31",  cmsis_arm_absmin_no_idx_q31, METH_VARARGS,""},
-{"arm_absmin_f32",  cmsis_arm_absmin_f32, METH_VARARGS,""},
-{"arm_max_q7",  cmsis_arm_max_q7, METH_VARARGS,""},
-{"arm_max_q15",  cmsis_arm_max_q15, METH_VARARGS,""},
-{"arm_max_q31",  cmsis_arm_max_q31, METH_VARARGS,""},
-{"arm_absmax_q7",  cmsis_arm_absmax_q7, METH_VARARGS,""},
-{"arm_absmax_q15", cmsis_arm_absmax_q15, METH_VARARGS,""},
-{"arm_absmax_q31", cmsis_arm_absmax_q31, METH_VARARGS,""},
-{"arm_max_f32",  cmsis_arm_max_f32, METH_VARARGS,""},
-{"arm_absmax_f32",  cmsis_arm_absmax_f32, METH_VARARGS,""},
-{"arm_max_no_idx_q7",  cmsis_arm_max_no_idx_q7, METH_VARARGS,""},
-{"arm_max_no_idx_q15",  cmsis_arm_max_no_idx_q15, METH_VARARGS,""},
-{"arm_max_no_idx_q31",  cmsis_arm_max_no_idx_q31, METH_VARARGS,""},
-{"arm_absmax_no_idx_q7",  cmsis_arm_absmax_no_idx_q7, METH_VARARGS,""},
-{"arm_absmax_no_idx_q15", cmsis_arm_absmax_no_idx_q15, METH_VARARGS,""},
-{"arm_absmax_no_idx_q31", cmsis_arm_absmax_no_idx_q31, METH_VARARGS,""},
-{"arm_cmplx_mult_cmplx_q15",  cmsis_arm_cmplx_mult_cmplx_q15, METH_VARARGS,""},
-{"arm_cmplx_mult_cmplx_q31",  cmsis_arm_cmplx_mult_cmplx_q31, METH_VARARGS,""},
-{"arm_cmplx_mult_cmplx_f32",  cmsis_arm_cmplx_mult_cmplx_f32, METH_VARARGS,""},
-{"arm_float_to_q31",  cmsis_arm_float_to_q31, METH_VARARGS,""},
-{"arm_float_to_q15",  cmsis_arm_float_to_q15, METH_VARARGS,""},
-{"arm_float_to_q7",  cmsis_arm_float_to_q7, METH_VARARGS,""},
-{"arm_q31_to_q15",  cmsis_arm_q31_to_q15, METH_VARARGS,""},
-{"arm_q31_to_q7",  cmsis_arm_q31_to_q7, METH_VARARGS,""},
-{"arm_q15_to_float",  cmsis_arm_q15_to_float, METH_VARARGS,""},
-{"arm_q15_to_q31",  cmsis_arm_q15_to_q31, METH_VARARGS,""},
-{"arm_q15_to_q7",  cmsis_arm_q15_to_q7, METH_VARARGS,""},
-{"arm_bilinear_interp_f32",  cmsis_arm_bilinear_interp_f32, METH_VARARGS,""},
-{"arm_bilinear_interp_q31",  cmsis_arm_bilinear_interp_q31, METH_VARARGS,""},
-{"arm_bilinear_interp_q15",  cmsis_arm_bilinear_interp_q15, METH_VARARGS,""},
-{"arm_bilinear_interp_q7",  cmsis_arm_bilinear_interp_q7, METH_VARARGS,""},
-
-{"arm_fill_f32",  cmsis_arm_fill_f32, METH_VARARGS,""},
-{"arm_fill_q31",  cmsis_arm_fill_q31, METH_VARARGS,""},
-{"arm_fill_q15",  cmsis_arm_fill_q15, METH_VARARGS,""},
-{"arm_fill_q7",  cmsis_arm_fill_q7, METH_VARARGS,""},
-
-{"arm_mat_cmplx_trans_f32",  cmsis_arm_mat_cmplx_trans_f32, METH_VARARGS,""},
-{"arm_mat_cmplx_trans_q31",  cmsis_arm_mat_cmplx_trans_q31, METH_VARARGS,""},
-{"arm_mat_cmplx_trans_q15",  cmsis_arm_mat_cmplx_trans_q15, METH_VARARGS,""},
-{"arm_levinson_durbin_f32",  cmsis_arm_levinson_durbin_f32, METH_VARARGS,""},
-{"arm_levinson_durbin_q31",  cmsis_arm_levinson_durbin_q31, METH_VARARGS,""},
-
-{"arm_and_u32",  cmsis_arm_and_u32, METH_VARARGS,""},
-{"arm_and_u16",  cmsis_arm_and_u16, METH_VARARGS,""},
-{"arm_and_u8" ,  cmsis_arm_and_u8, METH_VARARGS,""},
-
-{"arm_or_u32",  cmsis_arm_or_u32, METH_VARARGS,""},
-{"arm_or_u16",  cmsis_arm_or_u16, METH_VARARGS,""},
-{"arm_or_u8" ,  cmsis_arm_or_u8, METH_VARARGS,""},
-
-{"arm_xor_u32",  cmsis_arm_xor_u32, METH_VARARGS,""},
-{"arm_xor_u16",  cmsis_arm_xor_u16, METH_VARARGS,""},
-{"arm_xor_u8" ,  cmsis_arm_xor_u8, METH_VARARGS,""},
-
-{"arm_not_u32",  cmsis_arm_not_u32, METH_VARARGS,""},
-{"arm_not_u16",  cmsis_arm_not_u16, METH_VARARGS,""},
-{"arm_not_u8" ,  cmsis_arm_not_u8, METH_VARARGS,""},
-
-{"arm_quaternion_normalize_f32" ,  cmsis_arm_quaternion_normalize_f32, METH_VARARGS,""},
-{"arm_quaternion_conjugate_f32" ,  cmsis_arm_quaternion_conjugate_f32, METH_VARARGS,""},
-{"arm_quaternion_inverse_f32" ,  cmsis_arm_quaternion_inverse_f32, METH_VARARGS,""},
-{"arm_quaternion_norm_f32" ,  cmsis_arm_quaternion_norm_f32, METH_VARARGS,""},
-{"arm_quaternion2rotation_f32" ,  cmsis_arm_quaternion2rotation_f32, METH_VARARGS,""},
-{"arm_rotation2quaternion_f32" ,  cmsis_arm_rotation2quaternion_f32, METH_VARARGS,""},
-{"arm_quaternion_product_f32" ,  cmsis_arm_quaternion_product_f32, METH_VARARGS,""},
-{"arm_quaternion_product_single_f32" ,  cmsis_arm_quaternion_product_single_f32, METH_VARARGS,""},
-
-#if 0
-{"arm_braycurtis_distance_f32", cmsis_arm_braycurtis_distance_f32, METH_VARARGS,""},
-{"arm_canberra_distance_f32",cmsis_arm_canberra_distance_f32, METH_VARARGS,""},
-{"arm_chebyshev_distance_f32",cmsis_arm_chebyshev_distance_f32, METH_VARARGS,""},
-{"arm_cityblock_distance_f32",cmsis_arm_cityblock_distance_f32, METH_VARARGS,""},
-{"arm_correlation_distance_f32",cmsis_arm_correlation_distance_f32, METH_VARARGS,""},
-{"arm_cosine_distance_f32",cmsis_arm_cosine_distance_f32, METH_VARARGS,""},
-{"arm_euclidean_distance_f32",cmsis_arm_euclidean_distance_f32, METH_VARARGS,""},
-{"arm_jensenshannon_distance_f32",cmsis_arm_jensenshannon_distance_f32, METH_VARARGS,""},
-{"arm_minkowski_distance_f32",cmsis_arm_minkowski_distance_f32, METH_VARARGS,""},
-#endif
-    {"arm_mfcc_init_f32",  cmsis_arm_mfcc_init_f32, METH_VARARGS,""},
-    {"arm_mfcc_f32",  cmsis_arm_mfcc_f32, METH_VARARGS,""},
-    {"arm_mfcc_init_q15",  cmsis_arm_mfcc_init_q15, METH_VARARGS,""},
-    {"arm_mfcc_q15",  cmsis_arm_mfcc_q15, METH_VARARGS,""},
-    {"arm_mfcc_init_q31",  cmsis_arm_mfcc_init_q31, METH_VARARGS,""},
-    {"arm_mfcc_q31",  cmsis_arm_mfcc_q31, METH_VARARGS,""},
-    {"ssat",  cmsis_ssat, METH_VARARGS,""},
-    {"usat",  cmsis_usat, METH_VARARGS,""},
-    {"clz",  cmsis_clz, METH_VARARGS,""},
-    {"error_out", (PyCFunction)error_out, METH_NOARGS, NULL},
-    {NULL, NULL, 0, NULL}        /* Sentinel */
-};
-

PythonWrapper/config.py

@@ -1,12 +0,0 @@
-CMSISDSP = 1
-
-ROOT=".."
-
-config = CMSISDSP
-
-if config == CMSISDSP:
-    extensionName = 'internal' 
-    setupName = 'CMSISDSP'
-    setupDescription = 'CMSIS-DSP Python API'
-    cflags="-DCMSISDSP"
-

PythonWrapper/docs/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

PythonWrapper/docs/make.bat

@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=source
+set BUILDDIR=build
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.https://www.sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd

PythonWrapper/docs/source/api.rst

@@ -0,0 +1,225 @@
+API
+===
+
+.. highlight:: python
+
+The idea is to follow as closely as possible the CMSIS-DSP API to ease the migration to the final implementation on a board.
+
+First you need to import the module::
+
+    import cmsisdsp as dsp
+
+If you use numpy::
+
+    import numpy as np
+
+If you use scipy signal processing functions::
+
+    from scipy import signal
+
+
+Standard APIs
+*************
+
+.. code-block:: C
+    
+     void arm_add_f32(
+            const float32_t * pSrcA,
+            const float32_t * pSrcB,
+            float32_t * pDst,
+            uint32_t blockSize);
+
+.. py:function:: dsp.arm_add_f32(pSrcA,pSrcB)
+
+   Return a list of random ingredients as strings.
+
+   :param pSrcA: array.
+   :type pSrcA: NumPy array
+   :param pSrcB: array.
+   :type pSrcB: NumPy array
+   :return: array.
+   :rtype: NumPy array
+
+Example::
+
+      import cmsisdsp as dsp
+
+      r = dsp.arm_add_f32([1.,2,3],[4.,5,7])
+
+You can use a CMSIS-DSP function with numpy arrays: ::
+
+   r = dsp.arm_add_f32(np.array([1.,2,3]),np.array([4.,5,7]))
+
+The result of a CMSIS-DSP function will always be a numpy array whatever the arguments were (numpy array or list).
+
+Functions with instance arguments 
+*********************************
+
+When the CMSIS-DSP function is requiring an instance data structure, it is just a bit more complex to use it:
+
+First you need to create this instance::
+
+      import cmsisdsp as dsp
+
+      firf32 = dsp.arm_fir_instance_f32()
+
+.. code-block:: C
+
+   void arm_fir_init_f32(
+               arm_fir_instance_f32 * S,
+               uint16_t numTaps,
+         const float32_t * pCoeffs,
+               float32_t * pState,
+               uint32_t blockSize);
+
+
+.. py:function:: dsp.arm_fir_init_f32(S,numTaps,pCoeffs,pState)
+
+   Return a list of random ingredients as strings.
+
+   :param S: f32 instance.
+   :type S: int
+   :param pCoeffs: array.
+   :type pCoeffs: NumPy array
+   :param pState: array.
+   :type pState: NumPy array
+   :return: array.
+   :rtype: NumPy array
+
+Example of use::
+
+   dsp.arm_fir_init_f32(firf32,3,[1.,2,3],[0,0,0,0,0,0,0])
+
+The third argument in this function is the state. Since all arguments (except the instance ones) are read-only in this Python API, this state will never be changed ! It is just used to communicate the length of the state array which must be allocated by the init function. This argument is required because it is present in the CMSIS-DSP API and in the final C implementation you'll need to allocate a state array with the right dimension.
+
+Since the goal is to be as close as possible to the C API, the API is forcing the use of this argument.
+
+The only change compared to the C API is that the size variables (like blockSize for filter) are computed automatically from the other arguments. This choice was made to make it a bit easier the use of numpy array with the API.
+
+Now, you can check that the instance was initialized correctly::
+
+.. code-block:: python
+
+   print(firf32.numTaps())
+
+The filter can then be called:
+
+.. code-block:: C
+
+   void arm_fir_f32(
+               const arm_fir_instance_f32 * S,
+               const float32_t * pSrc,
+                     float32_t * pDst,
+                     uint32_t blockSize);
+
+.. py:function:: dsp.arm_fir_f32(S,pSrc)
+
+   Return a list of random ingredients as strings.
+
+   :param S: f32 instance.
+   :type S: int
+   :param pSrc: array of input samples.
+   :type pSrc: NumPy array
+   :return: array.
+   :rtype: NumPy array
+
+Then, you can filter with CMSIS-DSP::
+
+   print(dsp.arm_fir_f32(firf32,[1,2,3,4,5]))
+
+The size of this signal should be blockSize. blockSize was inferred from the size of the state array : numTaps + blockSize - 1 according to CMSIS-DSP. So here the signal must have 5 samples.
+
+If you want to filter more than 5 samples, then you can just call the function again. The state variable inside firf32 will ensure that it works like in the CMSIS-DSP C code::
+
+    print(dsp.arm_fir_f32(firf32,[6,7,8,9,10]))
+
+If you want to compare with scipy it is easy but warning : coefficients for the filter are in opposite order in scipy ::
+
+    filtered_x = signal.lfilter([3,2,1.], 1.0, [1,2,3,4,5,6,7,8,9,10])
+    print(filtered_x)
+
+FFT
+***
+
+The CMSIS-DSP cfft is requiring complex signals with a specific layout in memory.
+
+To remain as close as possible to the C API, we are not using complex numbers in the wrapper. So a complex signal must be converted into a real one. A function like the bewlo one can be used::
+
+   def imToReal1D(a):
+       ar=np.zeros(np.array(a.shape) * 2)
+       ar[0::2]=a.real
+       ar[1::2]=a.imag
+       return(ar)
+
+In the same way, the return array from the CMSIS-DSP FFT will not be containing complex Python scalars. It must be converted back with a function like::
+
+   def realToIm1D(ar):
+       return(ar[0::2] + 1j * ar[1::2])
+
+Then, the utilisation of the API si very similar to what was done for the FIR example:
+
+Then, you create the FFT instance with::
+
+    cfftf32=dsp.arm_cfft_instance_f32()
+
+You initialize the instance with the init function ::
+
+    status=dsp.arm_cfft_init_f32(cfftf32, nb)
+    print(status)
+
+You convert the complex signal to the format expected by the wrapper::
+
+    signalR = imToReal1D(signal)
+
+You compute the FFT of the signal with::
+
+    resultR = dsp.arm_cfft_f32(cfftf32,signalR,0,1)
+
+You convert back to a complex format to compare with scipy::
+
+    resultI = realToIm1D(resultR)
+    print(resultI)
+
+Matrix
+******
+
+For matrix, the instance variables are masked by the Python API. We decided that for matrix only there was no use for having the CMSIS-DSP instance visibles since they contain the same information as the numpy array (samples and dimension).
+
+So to use a CMSIS-DSP matrix function, it is very simple::
+
+    a=np.array([[1.,2,3,4],[5,6,7,8],[9,10,11,12]])
+    b=np.array([[1.,2,3],[5.1,6,7],[9.1,10,11],[5,8,4]])
+
+Numpy result as reference::
+
+    print(np.dot(a , b))
+
+CMSIS-DSP result::
+
+    v=dsp.arm_mat_mult_f32(a,b)
+    print(v)
+
+In a real C code, a pointer to a data structure for the result v would have to be passed as argument of the function.
+
+The C API is:
+
+.. code-block:: C
+
+   arm_status arm_mat_mult_f32(
+                const arm_matrix_instance_f32 * pSrcA,
+                const arm_matrix_instance_f32 * pSrcB,
+                      arm_matrix_instance_f32 * pDst);
+
+The Python API is:
+
+
+.. py:function:: dsp.arm_mat_mult_f32(pSrcA,pSrcB)
+
+   Return the matrix product pSrcA * pSrcB
+
+   :param pSrcA: array of input samples.
+   :type pSrcA: NumPy array
+   :param pSrcB: array of input samples.
+   :type pSrcB: NumPy array
+   :return: the matrix product.
+   :rtype: NumPy array

PythonWrapper/docs/source/conf.py

@@ -0,0 +1,60 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+# import os
+# import sys
+# sys.path.insert(0, os.path.abspath('.'))
+
+import pathlib
+import sys
+sys.path.insert(0, pathlib.Path(__file__).parents[2].resolve().as_posix())
+import cmsisdsp
+
+# -- Project information -----------------------------------------------------
+
+project = 'cmsisdsp'
+copyright = 'Copyright (C) 2010-2022 ARM Limited or its affiliates. All rights reserved.'
+author = 'Christophe Favergeon'
+
+# The full version, including alpha/beta/rc tags
+release = '1.0.1'
+
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = ['sphinx.ext.autodoc'
+]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = []
+
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'alabaster'
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+

PythonWrapper/docs/source/datatype.rst

@@ -0,0 +1,12 @@
+Datatype
+========
+
+.. autodata:: cmsisdsp.datatype.F64
+.. autodata:: cmsisdsp.datatype.F32
+.. autodata:: cmsisdsp.datatype.F16
+.. autodata:: cmsisdsp.datatype.Q31
+.. autodata:: cmsisdsp.datatype.Q15
+.. autodata:: cmsisdsp.datatype.Q7
+
+
+.. autofunction:: cmsisdsp.datatype.convert

PythonWrapper/docs/source/fixedpoint.rst

@@ -0,0 +1,13 @@
+Fixed point
+===========
+
+Fixed point extensions
+
+.. autofunction:: cmsisdsp.fixedpoint.toQ31
+.. autofunction:: cmsisdsp.fixedpoint.toQ15
+.. autofunction:: cmsisdsp.fixedpoint.toQ7
+
+.. autofunction:: cmsisdsp.fixedpoint.Q31toF32
+.. autofunction:: cmsisdsp.fixedpoint.Q15toF32
+.. autofunction:: cmsisdsp.fixedpoint.Q7toF32
+

PythonWrapper/docs/source/index.rst

@@ -0,0 +1,31 @@
+.. cmsisdsp documentation master file, created by
+   sphinx-quickstart on Mon Feb 14 11:09:26 2022.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+Welcome to CMSIS-DSP PythonWrapper's documentation!
+===================================================
+
+**cmsisdsp** is a Python wrapper for the Arm `CMSIS-DSP API <https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP>`_. With **cmsisdsp** you can run the `CMSIS-DSP API <https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP>`_ functions in Python. The functions are compatible with NumPy.
+
+The APIs of the functions in package **cmsisdsp** are as close as possible to the C versions to make it easier to migrate the Python implementation of your code to an equivalent C one running on the embedded target.
+
+In addition to the Python interface to the C functions, there are additional submodules.
+
+* :doc:`fixedpoint.py <fixedpoint>` is providing some tools to help generating the fixedpoint values expected
+  by CMSIS-DSP.
+* :doc:`mfcc.py <mfcc>` is generating some tools to generate the MEL filters, DCT and window coefficients
+  expected by the CMSIS-DSP MFCC implementation.
+
+Table of contents
+*****************
+.. toctree::
+
+   Python API to C functions <api>
+   datatype.py <datatype>
+   fixedpoint.py <fixedpoint>
+   mfcc.py <mfcc>
+
+.. note::
+
+   This project is under development.

PythonWrapper/docs/source/mfcc.rst

@@ -0,0 +1,26 @@
+MFCC
+====
+
+.. highlight:: python
+
+.. autofunction:: cmsisdsp.mfcc.frequencyToMelSpace
+.. autofunction:: cmsisdsp.mfcc.melSpaceToFrequency
+
+MEL filters are represented as 3 arrays to encode a sparse matrix.
+
+.. autofunction:: cmsisdsp.mfcc.melFilterMatrix
+
+The API is returning a tuple::
+  
+  (filterLength,filterPos,PackedCoefficients)
+
+The first argument is the list of MEL filter lengths.
+
+The second argument is the position of the first coefficient of the filter in the list of coefficients,
+
+The last argument is the concatenated list of all filter coefficients.
+
+
+
+.. autofunction:: cmsisdsp.mfcc.dctMatrix
+

PythonWrapper/examples/debug.py

@@ -0,0 +1,20 @@
+import cmsisdsp as dsp
+import numpy as np
+from scipy import signal
+
+firf32 = dsp.arm_fir_instance_f32()
+dsp.arm_fir_init_f32(firf32,3,[1.,2,3],[0,0,0,0,0,0,0])
+print(firf32.numTaps())
+filtered_x = signal.lfilter([3,2,1.], 1.0, [1,2,3,4,5,1,2,3,4,5])
+print(filtered_x)
+print(dsp.arm_fir_f32(firf32,[1,2,3,4,5]))
+print(dsp.arm_fir_f32(firf32,[1,2,3,4,5]))
+
+a=np.array([[1.,2,3,4],[5,6,7,8],[9,10,11,12]])
+b=np.array([[1.,2,3,4],[5.1,6,7,8],[9.1,10,11,12]])
+#print(a+b)
+
+#print("OK")
+
+v=dsp.arm_mat_add_f32(a,b)
+print(v)

PythonWrapper/example.py → PythonWrapper/examples/example.py

@@ -56,6 +56,7 @@ plot(res[1:nb])
 
 
 biquadQ31 = dsp.arm_biquad_casd_df1_inst_q31()
+
 numStages=3
 state=np.zeros(numStages*4)
 # For use in CMSIS, denominator coefs must be negated

PythonWrapper/testdsp.py → PythonWrapper/examples/testdsp.py

@@ -80,6 +80,7 @@ print(filtered_x)
 print(dsp.arm_fir_f32(firf32,[1,2,3,4,5]))
 print(dsp.arm_fir_f32(firf32,[1,2,3,4,5]))
 
+
 def q31sat(x):
      if x > 0x7FFFFFFF:
           return(np.int32(0x7FFFFFFF))
@@ -139,12 +140,18 @@ resultQ31=dsp.arm_fir_q31(firq31,xQ31)
 result=Q31toF32(resultQ31)
 print(result)
 
+
 a=np.array([[1.,2,3,4],[5,6,7,8],[9,10,11,12]])
 b=np.array([[1.,2,3,4],[5.1,6,7,8],[9.1,10,11,12]])
 print(a+b)
+
+print("OK")
+
 v=dsp.arm_mat_add_f32(a,b)
 print(v)
 
+
+
 a=np.array([[1.,2,3,4],[5,6,7,8],[9,10,11,12]])
 b=np.array([[1.,2,3],[5.1,6,7],[9.1,10,11],[5,8,4]])
 print(np.dot(a , b))

PythonWrapper/setup.py

@@ -1,204 +0,0 @@
-from distutils.core import setup, Extension
-import glob
-import numpy
-import config
-import sys
-import os
-import os.path
-from config import ROOT
-import re
-
-includes = [os.path.join(ROOT,"Include"),os.path.join(ROOT,"PrivateInclude"),os.path.join("cmsisdsp_pkg","src")]
-
-if sys.platform == 'win32':
-  cflags = ["-DWIN",config.cflags,"-DUNALIGNED_SUPPORT_DISABLE"] 
-else:
-  cflags = ["-Wno-attributes","-Wno-unused-function","-Wno-unused-variable","-Wno-implicit-function-declaration",config.cflags,"-D__GNUC_PYTHON__"]
-
-transform = glob.glob(os.path.join(ROOT,"Source","TransformFunctions","*.c"))
-#transform.remove(os.path.join(ROOT,"Source","TransformFunctions","arm_dct4_init_q15.c"))
-#transform.remove(os.path.join(ROOT,"Source","TransformFunctions","arm_rfft_init_q15.c"))
-transform.remove(os.path.join(ROOT,"Source","TransformFunctions","TransformFunctions.c"))
-transform.remove(os.path.join(ROOT,"Source","TransformFunctions","TransformFunctionsF16.c"))
-
-support = glob.glob(os.path.join(ROOT,"Source","SupportFunctions","*.c"))
-support.remove(os.path.join(ROOT,"Source","SupportFunctions","SupportFunctions.c"))
-support.remove(os.path.join(ROOT,"Source","SupportFunctions","SupportFunctionsF16.c"))
-
-fastmath = glob.glob(os.path.join(ROOT,"Source","FastMathFunctions","*.c"))
-fastmath.remove(os.path.join(ROOT,"Source","FastMathFunctions","FastMathFunctions.c"))
-
-filtering = glob.glob(os.path.join(ROOT,"Source","FilteringFunctions","*.c"))
-filtering.remove(os.path.join(ROOT,"Source","FilteringFunctions","FilteringFunctions.c"))
-filtering.remove(os.path.join(ROOT,"Source","FilteringFunctions","FilteringFunctionsF16.c"))
-
-matrix = glob.glob(os.path.join(ROOT,"Source","MatrixFunctions","*.c"))
-matrix.remove(os.path.join(ROOT,"Source","MatrixFunctions","MatrixFunctions.c"))
-matrix.remove(os.path.join(ROOT,"Source","MatrixFunctions","MatrixFunctionsF16.c"))
-
-statistics = glob.glob(os.path.join(ROOT,"Source","StatisticsFunctions","*.c"))
-statistics.remove(os.path.join(ROOT,"Source","StatisticsFunctions","StatisticsFunctions.c"))
-statistics.remove(os.path.join(ROOT,"Source","StatisticsFunctions","StatisticsFunctionsF16.c"))
-
-complexf = glob.glob(os.path.join(ROOT,"Source","ComplexMathFunctions","*.c"))
-complexf.remove(os.path.join(ROOT,"Source","ComplexMathFunctions","ComplexMathFunctions.c"))
-complexf.remove(os.path.join(ROOT,"Source","ComplexMathFunctions","ComplexMathFunctionsF16.c"))
-
-basic = glob.glob(os.path.join(ROOT,"Source","BasicMathFunctions","*.c"))
-basic.remove(os.path.join(ROOT,"Source","BasicMathFunctions","BasicMathFunctions.c"))
-basic.remove(os.path.join(ROOT,"Source","BasicMathFunctions","BasicMathFunctionsF16.c"))
-
-controller = glob.glob(os.path.join(ROOT,"Source","ControllerFunctions","*.c"))
-controller.remove(os.path.join(ROOT,"Source","ControllerFunctions","ControllerFunctions.c"))
-
-common = glob.glob(os.path.join(ROOT,"Source","CommonTables","*.c"))
-common.remove(os.path.join(ROOT,"Source","CommonTables","CommonTables.c"))
-common.remove(os.path.join(ROOT,"Source","CommonTables","CommonTablesF16.c"))
-
-interpolation = glob.glob(os.path.join(ROOT,"Source","InterpolationFunctions","*.c"))
-interpolation.remove(os.path.join(ROOT,"Source","InterpolationFunctions","InterpolationFunctions.c"))
-interpolation.remove(os.path.join(ROOT,"Source","InterpolationFunctions","InterpolationFunctionsF16.c"))
-
-quaternion = glob.glob(os.path.join(ROOT,"Source","QuaternionMathFunctions","*.c"))
-quaternion.remove(os.path.join(ROOT,"Source","QuaternionMathFunctions","QuaternionMathFunctions.c"))
-
-#distance = glob.glob(os.path.join(ROOT,"Source","DistanceFunctions","*.c"))
-#distance.remove(os.path.join(ROOT,"Source","DistanceFunctions","DistanceFunctions.c"))
-
-
-#modulesrc = glob.glob(os.path.join("cmsisdsp_pkg","src","*.c"))
-modulesrc = []
-modulesrc.append(os.path.join("cmsisdsp_pkg","src","cmsismodule.c"))
-
-allsrcs = support + fastmath + filtering + matrix + statistics + complexf + basic
-allsrcs = allsrcs + controller + transform + modulesrc + common+ interpolation
-allsrcs = allsrcs + quaternion
-
-missing=set(["arm_abs_f64"
-,"arm_absmax_f64"
-,"arm_absmin_f64"
-,"arm_add_f64"
-,"arm_barycenter_f32"
-,"arm_braycurtis_distance_f32"
-,"arm_canberra_distance_f32"
-,"arm_chebyshev_distance_f32"
-,"arm_chebyshev_distance_f64"
-,"arm_circularRead_f32"
-,"arm_cityblock_distance_f32"
-,"arm_cityblock_distance_f64"
-,"arm_cmplx_mag_f64"
-,"arm_cmplx_mag_squared_f64"
-,"arm_cmplx_mult_cmplx_f64"
-,"arm_copy_f64"
-,"arm_correlate_f64"
-,"arm_correlation_distance_f32"
-,"arm_cosine_distance_f32"
-,"arm_cosine_distance_f64"
-,"arm_dot_prod_f64"
-,"arm_entropy_f32"
-,"arm_entropy_f64"
-,"arm_euclidean_distance_f32"
-,"arm_euclidean_distance_f64"
-,"arm_exponent_f32"
-,"arm_fill_f64"
-,"arm_fir_f64"
-,"arm_fir_init_f64"
-,"arm_gaussian_naive_bayes_predict_f32"
-,"arm_jensenshannon_distance_f32"
-,"arm_kullback_leibler_f32"
-,"arm_kullback_leibler_f64"
-,"arm_logsumexp_dot_prod_f32"
-,"arm_logsumexp_f32"
-,"arm_mat_cholesky_f32"
-,"arm_mat_cholesky_f64"
-,"arm_mat_init_f32"
-,"arm_mat_ldlt_f32"
-,"arm_mat_ldlt_f64"
-,"arm_mat_mult_f64"
-,"arm_mat_solve_lower_triangular_f32"
-,"arm_mat_solve_lower_triangular_f64"
-,"arm_mat_solve_upper_triangular_f32"
-,"arm_mat_solve_upper_triangular_f64"
-,"arm_mat_sub_f64"
-,"arm_mat_trans_f64"
-,"arm_max_f64"
-,"arm_max_no_idx_f32"
-,"arm_max_no_idx_f64"
-,"arm_mean_f64"
-,"arm_merge_sort_f32"
-,"arm_merge_sort_init_f32"
-,"arm_min_f64"
-,"arm_minkowski_distance_f32"
-,"arm_mult_f64"
-,"arm_negate_f64"
-,"arm_offset_f64"
-,"arm_power_f64"
-,"arm_scale_f64"
-,"arm_sort_f32"
-,"arm_sort_init_f32"
-,"arm_spline_f32"
-,"arm_spline_init_f32"
-,"arm_std_f64"
-,"arm_sub_f64"
-,"arm_svm_linear_init_f32"
-,"arm_svm_linear_predict_f32"
-,"arm_svm_polynomial_init_f32"
-,"arm_svm_polynomial_predict_f32"
-,"arm_svm_rbf_init_f32"
-,"arm_svm_rbf_predict_f32"
-,"arm_svm_sigmoid_init_f32"
-,"arm_svm_sigmoid_predict_f32"
-,"arm_var_f64"
-,"arm_vexp_f32"
-,"arm_vexp_f64"
-,"arm_vlog_f64"
-,"arm_vsqrt_f32"
-,"arm_weighted_sum_f32"
-,"arm_circularRead_q15"
-,"arm_circularRead_q7"
-,"arm_div_q63_to_q31"
-,"arm_fir_sparse_q15"
-,"arm_fir_sparse_q31"
-,"arm_fir_sparse_q7"
-,"arm_mat_init_q15"
-,"arm_mat_init_q31"])
-
-def notf16(number):
-  if re.search(r'f16',number):
-     return(False)
-  if re.search(r'F16',number):
-     return(False)
-  return(True)
-
-def isnotmissing(src):
-  name=os.path.splitext(os.path.basename(src))[0]
-  return(not (name in missing))
-
-# If there are too many files, the linker command is failing on Windows.
-# So f16 functions are removed since they are not currently available in the wrapper.
-# A next version will have to structure this wrapper more cleanly so that the
-# build can work even with more functions
-srcs = list(filter(isnotmissing,list(filter(notf16, allsrcs))))
-
-
-module1 = Extension(config.extensionName,
-                    sources = (srcs
-                              )
-                              ,
-                    include_dirs =  includes + [numpy.get_include()],
-                    #extra_compile_args = ["-Wno-unused-variable","-Wno-implicit-function-declaration",config.cflags]
-                    extra_compile_args = cflags
-                              )
-
-setup (name = config.setupName,
-       version = '1.0.1',
-       packages=['cmsisdsp'],
-       description = config.setupDescription,
-       ext_modules = [module1],
-       author = 'Copyright (C) 2010-2022 ARM Limited or its affiliates. All rights reserved.',
-       url="https://github.com/ARM-software/CMSIS_5",
-       classifiers=[
-        "Programming Language :: Python",
-        "License :: OSI Approved :: Apache Software License",
-        "Operating System :: OS Independent",
-    ])

PythonWrapper_README.md

@@ -0,0 +1,257 @@
+# README
+
+This is a Python wrapper for the Arm open source [CMSIS-DSP](https://arm-software.github.io/CMSIS_5/DSP/html/index.html) and it is compatible with `NumPy`.
+
+The CMSIS-DSP is available on our [GitHub](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP) or as a CMSIS Pack.
+
+The idea is to follow as closely as possible the C [CMSIS-DSP](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP) API to ease the migration to the final implementation on a board.
+
+The signal processing chain can thus be tested and developed in a Python environment and then easily converted to a C implementation running on a Cortex-M or Cortex-A board.
+
+It is an experimental wrapper with some limitations as described in the sections below.
+
+A tutorial is also available but with less details than this README:
+https://developer.arm.com/documentation/102463/latest/
+
+This wrapper is also containing the scripts for the new CMSIS-DSP [Synchronous Data Flow](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP/SDFTools) (SDF) framework.
+
+SDF is also including some nodes to communicate with Modelica using the VHT Modelica blocks developed as part of our [VHT-SystemModeling](https://github.com/ARM-software/VHT-SystemModeling) demos.
+
+
+
+# How to build and install
+
+## Tested configurations
+
+The building of this package has been tested on Windows with the Python install from python.org and Microsoft Visual 2017. 
+
+It has also been tested with `cygwin`. In that case, `python-devel` must be installed too. On Mac, it was tested with standard XCode installation.
+
+To run the examples, `scipy` and `matplotlib` must also be installed.
+
+Other configurations should work but the `setup.py` file would have to be improved. 
+
+Python 3 must be used.
+
+## Installing and Building
+
+### Installing
+
+It is advised to do it in a Python virtual environment. Then, in the virtual environment you can just do:
+
+    pip install cmsisdsp
+
+You must have a recent `pip` (to automatically install the dependencies like `NumPy`) and you should have a compiler which can be found by Python when building the package.
+
+DSP examples are available in the [CMSIS-DSP PythonWrapper examples](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP/PythonWrapper/examples) folder.
+
+Synchronous Data Flow examples are available in the [SDF](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP/SDFTools) folder of [CMSIS-DSP](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP) .
+
+### Building
+
+It it is not working (because it is not possible for us to test all configurations), you can then try to build and install the wrapper manually.
+
+It is advised to do this it into a virtualenv
+
+
+Since the [CMSIS-DSP](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP) wrapper is using `NumPy`, you must first install it in the virtual environment. 
+
+    > pip install numpy
+
+Once `NumPy` is installed, you can build the [CMSIS-DSP](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP) python wrapper. Go to folder `CMSIS/DSP`.
+(In a previous version you had to go to the `PythonWrapper` folder. Now the `setup.py` is inside the DSP folder).
+
+Now, you can install the cmsisdsp package in editable mode:
+
+    > pip install -e "Path To The Folder Containing setup.py"
+
+
+
+## Running the examples
+
+Install some packages to be able to run the examples
+
+    > pip install numpy
+    > pip install scipy
+    > pip install matplotlib
+
+Depending on the example, you may have to install more packages.
+
+The examples are in the  [CMSIS-DSP PythonWrapper examples](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP/PythonWrapper/examples) folder.
+
+You can test the scripts `testdsp.py` and `example.py` and try to run them from this virtual environment. `example.py` is requiring a data file to be downloaded from the web. See below in this document for the link.
+
+It is also possible to compile and install directly from a Jupyter notebook by doing something like:
+
+    !pip install git+https://github.com/ARM-software/
+    CMSIS_5.git@5.8.0#egg=CMSISDSP\&subdirectory=CMSIS/DSP/PythonWrapper
+
+This will download, compile and install the PythonWrapper from the version 5.8.0 of the [CMSIS-DSP](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP) (so not from the develop branch). It is an older version of the `PythonWrapper`.
+
+If you use this install method for a more recent version, don't forget `setup.py` have been moved to `DSP` folder and is no more in `PythonWrapper`.
+
+It will work only if the compiler can be found and run from Jupyter.
+
+Note that due to the great number of possible configurations (OS, Compiler, Python), we can't give any support if you have problems compiling the `PythonWrapper` on your specific configuration. But, generally people manage to do it and solve all the problems.
+
+# Usage
+
+The idea is to follow as closely as possible the [CMSIS-DSP](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP) API to ease the migration to the final implementation on a board.
+
+First you need to import the module
+
+    > import cmsisdsp as dsp
+
+If you use numpy:
+
+    > import numpy as np
+
+If you use scipy signal processing functions:
+
+    > from scipy import signal
+
+## Functions with no instance arguments
+
+You can use a [CMSIS-DSP](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP) function with numpy arrays:
+
+    > r = dsp.arm_add_f32(np.array([1.,2,3]),np.array([4.,5,7]))
+
+The function can also be called more simply with
+
+    > r = dsp.arm_add_f32([1.,2,3],[4.,5,7])
+
+The result of a [CMSIS-DSP](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP) function will always be a numpy array whatever the arguments were (numpy array or list).
+
+## Functions with instance arguments 
+
+When the [CMSIS-DSP](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP) function is requiring an instance data structure, it is just a bit more complex to use it:
+
+First you need to create this instance:
+
+    > firf32 = dsp.arm_fir_instance_f32()
+
+Then, you need to call an init function:
+
+    > dsp.arm_fir_init_f32(firf32,3,[1.,2,3],[0,0,0,0,0,0,0])
+
+The third argument in this function is the state. Since all arguments (except the instance ones) are read-only in this Python API, this state will never be changed ! It is just used to communicate the length of the state array which must be allocated by the init function. This argument is required because it is present in the [CMSIS-DSP](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP) API and in the final C implementation you'll need to allocate a state array with the right dimension.
+
+Since the goal is to be as close as possible to the C API, the API is forcing the use of this argument.
+
+The only change compared to the C API is that the size variables (like blockSize for filter) are computed automatically from the other arguments. This choice was made to make it a bit easier the use of numpy array with the API.
+
+Now, you can check that the instance was initialized correctly.
+
+    > print(firf32.numTaps())
+
+Then, you can filter with CMSIS-DSP:
+
+    > print(dsp.arm_fir_f32(firf32,[1,2,3,4,5]))
+
+The size of this signal should be `blockSize`. `blockSize` was inferred from the size of the state array : `numTaps + blockSize - 1` according to [CMSIS-DSP.](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP) So here the signal must have 5 samples.
+
+If you want to filter more than 5 samples, then you can just call the function again. The state variable inside firf32 will ensure that it works like in the [CMSIS-DSP](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP) C code. 
+
+    > print(dsp.arm_fir_f32(firf32,[6,7,8,9,10]))
+
+If you want to compare with scipy it is easy but warning : coefficients for the filter are in opposite order in scipy :
+
+    > filtered_x = signal.lfilter([3,2,1.], 1.0, [1,2,3,4,5,6,7,8,9,10])
+    > print(filtered_x)
+
+The principles are the same for all other APIs.
+
+## FFT 
+
+Here is an example for using FFT from the Python interface:
+
+Let's define a signal you will use for the FFT.
+
+    > nb = 16
+    > signal = np.cos(2 * np.pi * np.arange(nb) / nb)
+
+The [CMSIS-DSP](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP) cfft is requiring complex signals with a specific layout in memory.
+
+To remain as close as possible to the C API, we are not using complex numbers in the wrapper. So a complex signal must be converted into a real one. The function imToReal1D is defined in testdsp.py 
+
+    > signalR = imToReal1D(signal)
+
+Then, you create the FFT instance with:
+
+    > cfftf32=dsp.arm_cfft_instance_f32()
+
+You initialize the instance with the init function provided by the wrapper:
+
+    > status=dsp.arm_cfft_init_f32(cfftf32, nb)
+    > print(status)
+
+You compute the FFT of the signal with:
+
+    > resultR = dsp.arm_cfft_f32(cfftf32,signalR,0,1)
+
+You convert back to a complex format to compare with scipy:
+
+    > resultI = realToIm1D(resultR)
+    > print(resultI)
+
+## Matrix 
+
+For matrix, the instance variables are masked by the Python API. We decided that for matrix only there was no use for having the [CMSIS-DSP](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP) instance visibles since they contain the same information as the numpy array (samples and dimension).
+
+So to use a [CMSIS-DSP](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP) matrix function, it is very simple:
+
+    > a=np.array([[1.,2,3,4],[5,6,7,8],[9,10,11,12]])
+    > b=np.array([[1.,2,3],[5.1,6,7],[9.1,10,11],[5,8,4]])
+
+`NumPy` result as reference:
+
+    > print(np.dot(a , b))
+
+[CMSIS-DSP](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP) result:
+
+    > v=dsp.arm_mat_mult_f32(a,b)
+    > print(v)
+
+In a real C code, a pointer to a data structure for the result `v` would have to be passed as argument of the function.
+
+## example.py
+
+This example depends on a data file which can be downloaded here:
+
+https://archive.physionet.org/pn3/ecgiddb/Person_87/rec_2.dat
+
+This signal was created for a master thesis:
+
+Lugovaya T.S. Biometric human identification based on electrocardiogram. [Master's thesis] Faculty of Computing Technologies and Informatics, Electrotechnical University "LETI", Saint-Petersburg, Russian Federation; June 2005. 
+
+and it is part of the PhysioNet database
+
+Goldberger AL, Amaral LAN, Glass L, Hausdorff JM, Ivanov PCh, Mark RG, Mietus JE, Moody GB, Peng C-K, Stanley HE. PhysioBank, PhysioToolkit, and PhysioNet: Components of a New Research Resource for Complex Physiologic Signals. Circulation 101(23):e215-e220 [Circulation Electronic Pages; http://circ.ahajournals.org/cgi/content/full/101/23/e215]; 2000 (June 13). 
+
+## Submodules
+
+The Python wrapper is containing three submodules : `fixedpoint` , `mfcc` and `datatype`
+
+`fixedpoint` is proving some tools to help generating the fixedpoint values expected
+by [CMSIS-DSP](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP).
+
+`mfcc` is generating some tools to generate the MEL filters, DCT and window coefficients
+expected by the [CMSIS-DSP](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP) MFCC implementation.
+
+MEL filters are represented as 3 arrays to encode a sparse array.
+
+`datatype` is an API on top of `fixedpoint` to provide more reuse when converting between data formats.
+
+The wrapper is now containing the Synchronous Data Flow Python scripts and you should refer the the documentation in `DSP/SDFTools` folder to know how to use those tools.
+
+# LIMITATIONS
+
+Due to the high number of functions in the [CMSIS-DSP](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP), the first version of the wrapper was generated automatically from a custom script.
+
+Only a subset of the functions has been tested.
+
+It is likely that some problems are present. The API is quite regular in [CMSIS-DSP](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/DSP) but there are a few exceptions and the generation script is not managing all of them.
+
+So, the API may crash due to unallocated variables or wrong data conversions.
+
+The generated C code is a first version for bootstrapping the process. Now that this C file exists, the improvements will be done on the C code rather than on the generation script.

README.md

@@ -1,5 +1,58 @@
 # README
 
+## Folders and files
+
+### Folders
+
+* cmsisdsp
+  * Require to build the CMSIS-DSP PythonWrapper for the Python repository
+  * It contains all Python packages
+* ComputeLibrary:
+  * Some kernels required when building CMSIS-DSP with Neon acceleration
+* Examples:
+  * Examples of use of CMSIS-DSP
+* Include:
+  * Include files for CMSIS-DSP
+* Platforms:
+  * Used for running the CMSIS-DSP test framework on Arm IPSS
+* PrivateInclude:
+  * Some include needed to build CMSIS-DSP
+* PythonWrapper:
+  * C code for the CMSIS-DSP PythonWrapper
+  * Examples for the PythonWrapper
+* Scripts:
+  * Debugging scripts
+  * Script to generate some coefficient tables used by CMSIS-DSP
+* SDFTools:
+  * Examples for the Synchronous Data Flow
+  * C++ templates for the Synchronous Data Flow
+* Source:
+  * CMSIS-DSP source
+* Testing:
+  * CMSIS-DSP Test frameworks
+* Toolchain:
+  * cmake files for building with gcc or Arm clang
+
+### Files
+
+Some files are needed to generate the PythonWrapper:
+
+* PythonWrapper_README.md
+* LICENSE.txt
+* MANIFEST.in
+* pyproject.toml
+* setup.py
+
+cmake files are useful to build CMSIS-DSP and the Test framework.
+
+filterLinkScript.py is used by the cmake build.
+
+cmsisdspconfig.py:
+
+* Web browser UI to generate build configurations
+
+
+
 ## How to use
 
 This document is explaining how to use cmake with CMSIS-DSP.
@@ -24,7 +77,7 @@ The cmake command is requiring several arguments. For instance, to build for m7
     -DROOT="../../../../../.." \
     -DPLATFORM="FVP" \
     -G "Unix Makefiles" ..
-  
+
 DCMAKE_PREFIX_PATH is the path to the compiler toolchain. This folder should contain the bin folder where are the compiler executables.
 
 ROOT is pointing to the root CMSIS folder (the one containing CMSIS and Device).
@@ -45,7 +98,7 @@ To build for A5, you need to change DCMAKE_TOOLCHAIN_FILE and ARM_CPU:
     -DARM_CPU="cortex-a5"
 
 To build for A5 with Neon acceleration, you need to add:
-  
+
     -DNEON=ON
 
 ### Building 

SDFTools/README.md

@@ -89,7 +89,13 @@ At the end, both FIFOs are empty so the schedule can be run again : it is period
 
 ## How to build the examples
 
-In folder SDFTools/example/build, type the cmake command:
+First, you must install the `CMSIS-DSP` PythonWrapper:
+
+```
+pip install cmsisdsp
+```
+
+In folder `SDFTools/example/build`, type the `cmake` command:
 
 ```bash
 cmake -DHOST=YES -DDOT="path to dot tool" -DCMSIS="path to cmsis" -G "Unix Makefiles" ..
@@ -112,7 +118,13 @@ dot -Tpdf -o test.pdf test.dot
 
 It will generate the C++ files for the schedule and a pdf representation of the graph.
 
-Then, to build, you'll need to build CMSIS-DSP, the .cpp file contained in the example and add the include folder `sdf/src` 
+Note that the Python code is relying on the CMSIS-DSP PythonWrapper which is now also containing the Python scripts for the Synchronous Data Flow.
+
+To build the C examples:
+
+* CMSIS-DSP must be built, 
+* the .cpp file contained in the example must be built
+* the include folder `sdf/src` must be added
 
 For `example3` which is using an input file, cmake should have copied the input test pattern `input_example3.txt` inside the build folder. The output file will also be generated in the build folder.
 
@@ -125,6 +137,8 @@ python main.py
 
 The first line is generating the schedule in Python. The second line is executing the schedule.
 
+`example7` is communicating with `OpenModelica`. You need to install the VHTModelica blocks from the [VHT-SystemModeling](https://github.com/ARM-software/VHT-SystemModeling) project on our GitHub
+
 ## Limitations
 
 It is a first version and there are lots of limitations and probably bugs:
@@ -164,6 +178,7 @@ Here is a list of the nodes supported by default. More can be easily added:
 - StereoToMonoQ15 : Interleaved stereo converted to mono with scaling to avoid saturation of the addition
 - Python only nodes:
   - WavSink and WavSource to use wav files for testing
+  - VHTSDF : To communicate with OpenModelica using VHTModelica blocks
 
 
 ## Detailed examples 
@@ -175,21 +190,4 @@ Here is a list of the nodes supported by default. More can be easily added:
 
 Examples 5 and 6 are showing how to use the CMSIS-DSP MFCC with a synchronous data flow.
 
-## Building the examples
-
-The script `create.bat` or `create.sh` in folder `examples/build` must be changed to use the path to the root CMSIS-DSP folder.
-
-Then, those scripts can be used to create a make using cmake.
-
-After those steps, typing `make` will build the C examples.
-
-To run the first one for example you'll have to type (from `build` folder): `bin_example1\example1`
-
-For the python examples, you need to go to the example folder (for instance `example4`). In the folder, type `python main.py`.
-
-
-
-If the dataflow is changed for any Python example, from the corresponding example folder you'll have to type `python graph.py` to regenerate the schedule. And you'll have to type `dot -Tpdf -o test.pdf test.dot` in the Python examples to regenerate the graph picture.
-
-For the C++ examples, the make is taking care of regenerating the schedule and the dot graph when `graph.py` is edited.
-
+Example 7 is communicating with OpenModelica. The Modelica model (PythonTest) in the example is implementing a Larsen effect.

SDFTools/examples/CMakeLists.txt

@@ -1,8 +1,9 @@
 cmake_minimum_required (VERSION 3.14)
 include(CMakePrintHelpers)
 
-find_package(Python3 3.6 EXACT COMPONENTS Interpreter)
+set(Python_FIND_REGISTRY "LAST")
 
+find_package (Python COMPONENTS Interpreter)
 
 function(sdf TARGET)
     if (DOT)
@@ -17,7 +18,7 @@ function(sdf TARGET)
 
     add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/generated/scheduler.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/test.dot
-        COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/graph.py
+        COMMAND ${Python_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/graph.py
         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
         DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/graph.py
         VERBATIM

SDFTools/examples/example1/graph.py

@@ -1,8 +1,4 @@
-import sys
-
-sys.path.append("../..")
-
-from sdf import *
+from cmsisdsp.sdf.scheduler import *
 
 ### Define new types of Nodes 
 

SDFTools/examples/example2/graph.py

@@ -1,8 +1,5 @@
-import sys
+from cmsisdsp.sdf.scheduler import *
 
-sys.path.append("../..")
-
-from sdf import *
 
 AUDIO_INTERRUPT_LENGTH = 160
 MFCCFEATURESSIZE=10

SDFTools/examples/example3/graph.py

@@ -1,9 +1,6 @@
-import sys
 import numpy as np 
 
-sys.path.append("../..")
-
-from sdf import *
+from cmsisdsp.sdf.scheduler import *
 
 
 FS=16000

SDFTools/examples/example4/appnodes.py

@@ -25,20 +25,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 ############################################
-from sdf.schedule.simu import *
+from cmsisdsp.sdf.nodes.simu import *
 from custom import *
 
-from sdf.nodes.py.host.FileSink import *
-from sdf.nodes.py.host.FileSource import *
-from sdf.nodes.py.CFFT import *
-from sdf.nodes.py.ICFFT import *
-from sdf.nodes.py.ToComplex import *
-from sdf.nodes.py.ToReal import *
-
-
-
-
-
-
-
-
+from cmsisdsp.sdf.nodes.host.FileSink import *
+from cmsisdsp.sdf.nodes.host.FileSource import *
+from cmsisdsp.sdf.nodes.CFFT import *
+from cmsisdsp.sdf.nodes.ICFFT import *
+from cmsisdsp.sdf.nodes.ToComplex import *
+from cmsisdsp.sdf.nodes.ToReal import *

SDFTools/examples/example4/debug.py

@@ -1,10 +1,5 @@
-import sys
-
-# To find SDF module
-sys.path.append("../..")
-
 import numpy as np
-from sdf.schedule.simu import *
+from cmsisdsp.sdf.nodes.simu import *
 
 a=np.zeros(10)
 f=FIFO(10,a)

SDFTools/examples/example4/graph.py

@@ -1,16 +1,13 @@
-import sys
 import numpy as np 
 
-sys.path.append("../..")
-
-from sdf import *
-
+from cmsisdsp.sdf.scheduler import *
 
 
 FS=16000
 # You can try with 120
 AUDIO_INTERRUPT_LENGTH = 192
 WINSIZE=256
+OVERLAP=128
 floatType=CType(F32)
 
 
@@ -18,8 +15,8 @@ floatType=CType(F32)
 src=FileSource("src",AUDIO_INTERRUPT_LENGTH)
 src.addLiteralArg("input_example3.txt")
 
-sliding=SlidingBuffer("audioWin",floatType,256,128)
-overlap=OverlapAdd("audioOverlap",floatType,256,128)
+sliding=SlidingBuffer("audioWin",floatType,WINSIZE,OVERLAP)
+overlap=OverlapAdd("audioOverlap",floatType,WINSIZE,OVERLAP)
 window=Dsp("mult",floatType,WINSIZE)
 
 toCmplx=ToComplex("toCmplx",floatType,WINSIZE)

SDFTools/examples/example4/sched.py

@@ -7,12 +7,10 @@
 
 import sys
 
-# To find SDF module
-sys.path.append("../..")
 
 import numpy as np
 import cmsisdsp as dsp
-from sdf.schedule.simu import *
+from cmsisdsp.sdf.nodes.simu import *
 from appnodes import * 
 from custom import *
 

SDFTools/examples/example5/appnodes.py

@@ -25,16 +25,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 ############################################
-from sdf.schedule.simu import *
+from cmsisdsp.sdf.nodes.simu import *
 from custom import *
 
 # Host only nodes
-from sdf.nodes.py.host.NumpySink import *
-from sdf.nodes.py.host.WavSource import *
+from cmsisdsp.sdf.nodes.host.NumpySink import *
+from cmsisdsp.sdf.nodes.host.WavSource import *
 
 # Embedded nodes
-from sdf.nodes.py.StereoToMono import *
-from sdf.nodes.py.MFCC import *
+from cmsisdsp.sdf.nodes.StereoToMono import *
+from cmsisdsp.sdf.nodes.MFCC import *
 
 
 

SDFTools/examples/example5/graph.py

@@ -1,9 +1,7 @@
-import sys
 import numpy as np 
 
-sys.path.append("../..")
+from cmsisdsp.sdf.scheduler import *
 
-from sdf import *
 
 from sharedconfig import *
 

SDFTools/examples/example5/sched.py

@@ -7,12 +7,10 @@
 
 import sys
 
-# To find SDF module
-sys.path.append("../..")
 
 import numpy as np
 import cmsisdsp as dsp
-from sdf.schedule.simu import *
+from cmsisdsp.sdf.nodes.simu import *
 from appnodes import * 
 from custom import *
 

SDFTools/examples/example6/graph.py

@@ -1,9 +1,7 @@
-import sys
 import numpy as np 
 
-sys.path.append("../..")
+from cmsisdsp.sdf.scheduler import *
 
-from sdf import *
 
 from sharedconfig import *
 

SDFTools/examples/example7/PythonTest.mo

@@ -0,0 +1,36 @@
+model PythonTest
+  ARM.Models.VHT vht(launchVHT = false, samplingFrequency = 16)  annotation(
+    Placement(visible = true, transformation(origin = {-12, 0}, extent = {{-10, -10}, {10, 10}}, rotation = 0)));
+  Modelica.Blocks.Continuous.TransferFunction transferFunction(a = {1.0, 942.317, 3.94761e7}, b = {1, 1675.7, 3.94761e7})  annotation(
+    Placement(visible = true, transformation(origin = {32, 0}, extent = {{-10, -10}, {10, 10}}, rotation = 0)));
+  Modelica.Blocks.Nonlinear.FixedDelay fixedDelay(delayTime = 0.1)  annotation(
+    Placement(visible = true, transformation(origin = {68, 0}, extent = {{-10, -10}, {10, 10}}, rotation = 0)));
+  Modelica.Blocks.Math.Add add annotation(
+    Placement(visible = true, transformation(origin = {-36, -28}, extent = {{10, -10}, {-10, 10}}, rotation = -90)));
+  Modelica.Blocks.Math.Gain gain(k = 0.8)  annotation(
+    Placement(visible = true, transformation(origin = {102, 0}, extent = {{-10, -10}, {10, 10}}, rotation = 0)));
+  Modelica.Blocks.Noise.TruncatedNormalNoise noise(samplePeriod = 0.0000625, useAutomaticLocalSeed = true, useGlobalSeed = true, y_max = 0.1, y_min = -0.1) annotation(
+    Placement(visible = true, transformation(origin = {-82, 8}, extent = {{-10, -10}, {10, 10}}, rotation = 0)));
+  inner Modelica.Blocks.Noise.GlobalSeed globalSeed annotation(
+    Placement(visible = true, transformation(origin = {-86, -28}, extent = {{-10, -10}, {10, 10}}, rotation = 0)));
+  ARM.Sound.WaveOutput waveOutput(path = "C:\\benchresults\\PythonSDFModelica\\larsen.wav")  annotation(
+    Placement(visible = true, transformation(origin = {24, -32}, extent = {{-10, -10}, {10, 10}}, rotation = 0)));
+equation
+  connect(vht.y, transferFunction.u) annotation(
+    Line(points = {{0, 0}, {20, 0}}, color = {0, 0, 127}));
+  connect(transferFunction.y, fixedDelay.u) annotation(
+    Line(points = {{44, 0}, {56, 0}}, color = {0, 0, 127}));
+  connect(add.y, vht.x) annotation(
+    Line(points = {{-36, -16}, {-36, 0}, {-24, 0}}, color = {0, 0, 127}));
+  connect(fixedDelay.y, gain.u) annotation(
+    Line(points = {{80, 0}, {90, 0}}, color = {0, 0, 127}));
+  connect(gain.y, add.u1) annotation(
+    Line(points = {{114, 0}, {132, 0}, {132, -48}, {-30, -48}, {-30, -40}}, color = {0, 0, 127}));
+  connect(noise.y, add.u2) annotation(
+    Line(points = {{-70, 8}, {-54, 8}, {-54, -46}, {-42, -46}, {-42, -40}}, color = {0, 0, 127}));
+  connect(vht.y, waveOutput.x) annotation(
+    Line(points = {{0, 0}, {6, 0}, {6, -32}, {12, -32}}, color = {0, 0, 127}));
+  annotation(
+    Diagram(coordinateSystem(extent = {{-200, -200}, {200, 200}})),
+    uses(ARM(version = "0.1.0"), Modelica(version = "4.0.0")));
+end PythonTest;

SDFTools/examples/example7/appnodes.py

@@ -0,0 +1,45 @@
+###########################################
+# Project:      CMSIS DSP Library
+# Title:        appnodes.py
+# Description:  Application nodes for Example 4
+# 
+# $Date:        29 July 2021
+# $Revision:    V1.10.0
+# 
+# Target Processor: Cortex-M and Cortex-A cores
+# -------------------------------------------------------------------- */
+# 
+# Copyright (C) 2010-2022 ARM Limited or its affiliates. All rights reserved.
+# 
+# SPDX-License-Identifier: Apache-2.0
+# 
+# Licensed under the Apache License, Version 2.0 (the License); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+# www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an AS IS BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+############################################
+from cmsisdsp.sdf.nodes.simu import *
+from custom import *
+
+from cmsisdsp.sdf.nodes.host.FileSink import *
+from cmsisdsp.sdf.nodes.host.FileSource import *
+from cmsisdsp.sdf.nodes.CFFT import *
+from cmsisdsp.sdf.nodes.ICFFT import *
+from cmsisdsp.sdf.nodes.ToComplex import *
+from cmsisdsp.sdf.nodes.ToReal import *
+
+from cmsisdsp.sdf.nodes.host.VHTSDF import *
+
+
+
+
+
+
+

SDFTools/examples/example7/custom.py

@@ -0,0 +1,21 @@
+from cmsisdsp.sdf.nodes.simu import *
+
+import numpy as np 
+import cmsisdsp as dsp
+
+
+class Processing(GenericNode):
+    def __init__(self,inputSize,outputSize,fifoin,fifoout):
+        GenericNode.__init__(self,inputSize,outputSize,fifoin,fifoout)
+
+    def run(self):
+
+        i=self.getReadBuffer()
+        o=self.getWriteBuffer()
+
+        b=dsp.arm_scale_q15(i,0x6000,1)
+
+        o[:]=b[:]
+
+        
+        return(0)

SDFTools/examples/example7/graph.py

@@ -0,0 +1,51 @@
+import numpy as np 
+
+from cmsisdsp.sdf.scheduler import *
+
+
+class Processing(GenericNode):
+    def __init__(self,name,outLength):
+        GenericNode.__init__(self,name)
+        self.addInput("i",CType(Q15),outLength)
+        self.addOutput("o",CType(Q15),outLength)
+
+    @property
+    def typeName(self):
+        return "Processing"
+
+
+BUFSIZE=128
+### Define nodes
+src=VHTSource("src",BUFSIZE,0)
+processing=Processing("proc",BUFSIZE)
+sink=VHTSink("sink",BUFSIZE,0)
+
+
+g = Graph()
+
+g.connect(src.o, processing.i)
+g.connect(processing.o, sink.i)
+
+
+
+print("Generate graphviz and code")
+
+
+
+#print(g.nullVector())
+sched = g.computeSchedule()
+#print(sched.schedule)
+print("Schedule length = %d" % sched.scheduleLength)
+print("Memory usage %d bytes" % sched.memory)
+#
+conf=Configuration()
+# Pass the source and sink objects used to communicate with the VHT Modelica block
+#conf.pyOptionalArgs=""
+conf.pathToSDFModule="C:\\\\benchresults\\\\cmsis_docker\\\\CMSIS\\\\DSP\\\\SDFTools"
+#conf.dumpFIFO=True
+#conf.prefix="sched1"
+sched.pythoncode(".",config=conf)
+
+with open("test.dot","w") as f:
+    sched.graphviz(f)
+

SDFTools/examples/example7/main.py

@@ -0,0 +1,19 @@
+import sched as s 
+import signal, os
+
+
+if __name__ == '__main__':
+
+   nb=0 
+   error=0
+
+   try:
+      nb,error = s.scheduler()
+   except Exception as inst:
+      print(inst)
+
+
+
+
+
+

SDFTools/examples/example7/sched.py

@@ -0,0 +1,61 @@
+#
+# Generated with CMSIS-DSP SDF Scripts.
+# The generated code is not covered by CMSIS-DSP license.
+# 
+# The support classes and code is covered by CMSIS-DSP license.
+#
+
+import sys
+
+
+import numpy as np
+import cmsisdsp as dsp
+from cmsisdsp.sdf.nodes.simu import *
+from appnodes import * 
+from custom import *
+
+DEBUGSCHED=False
+
+# 
+# FIFO buffers
+# 
+
+
+FIFOSIZE0=128
+buf0=np.zeros(FIFOSIZE0,dtype=np.int16)
+
+FIFOSIZE1=128
+buf1=np.zeros(FIFOSIZE1,dtype=np.int16)
+
+
+def scheduler():
+    sdfError=0
+    nbSchedule=0
+
+    #
+    #  Create FIFOs objects
+    #
+    fifo0=FIFO(FIFOSIZE0,buf0)
+    fifo1=FIFO(FIFOSIZE1,buf1)
+
+    # 
+    #  Create node objects
+    #
+    proc = Processing(128,128,fifo0,fifo1)
+    sink = VHTSink(128,fifo1,0)
+    src = VHTSource(128,fifo0,0)
+
+    while(sdfError==0):
+       nbSchedule = nbSchedule + 1
+
+       sdfError = src.run()
+       if sdfError < 0:
+          break
+       sdfError = proc.run()
+       if sdfError < 0:
+          break
+       sdfError = sink.run()
+       if sdfError < 0:
+          break
+
+    return(nbSchedule,sdfError)

SDFTools/examples/example7/test.dot

@@ -0,0 +1,47 @@
+
+
+
+digraph structs {
+    node [shape=plaintext]
+    rankdir=LR
+    edge [arrowsize=0.5]
+    fontname="times"
+
+
+proc [label=<
+<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0" CELLPADDING="4">
+  <TR>
+    <TD ALIGN="CENTER" PORT="i">proc<BR/>(Processing)</TD>
+  </TR>
+</TABLE>>];
+
+sink [label=<
+<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0" CELLPADDING="4">
+  <TR>
+    <TD ALIGN="CENTER" PORT="i">sink<BR/>(VHTSink)</TD>
+  </TR>
+</TABLE>>];
+
+src [label=<
+<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0" CELLPADDING="4">
+  <TR>
+    <TD ALIGN="CENTER" PORT="i">src<BR/>(VHTSource)</TD>
+  </TR>
+</TABLE>>];
+
+
+
+src:i -> proc:i [headlabel=<
+<TABLE BORDER="0" CELLPADDING="2"><TR><TD><FONT COLOR="blue" POINT-SIZE="12.0" >128</FONT>
+</TD></TR></TABLE>>,taillabel=<
+<TABLE BORDER="0" CELLPADDING="2"><TR><TD><FONT COLOR="blue" POINT-SIZE="12.0" >128</FONT>
+</TD></TR></TABLE>>,label="q15(128)"]
+
+proc:i -> sink:i [headlabel=<
+<TABLE BORDER="0" CELLPADDING="2"><TR><TD><FONT COLOR="blue" POINT-SIZE="12.0" >128</FONT>
+</TD></TR></TABLE>>,taillabel=<
+<TABLE BORDER="0" CELLPADDING="2"><TR><TD><FONT COLOR="blue" POINT-SIZE="12.0" >128</FONT>
+</TD></TR></TABLE>>,label="q15(128)"]
+
+
+}

cmsisdsp/__init__.py

@@ -0,0 +1,27 @@
+import cmsisdsp.version
+
+from cmsisdsp_filtering import *
+from cmsisdsp_matrix import *
+from cmsisdsp_support import *
+from cmsisdsp_statistics import *
+from cmsisdsp_complexf import *
+from cmsisdsp_basic import *
+from cmsisdsp_controller import *
+from cmsisdsp_transform import *
+from cmsisdsp_interpolation import *
+from cmsisdsp_quaternion import *
+from cmsisdsp_fastmath import *
+
+__version__ = cmsisdsp.version.__version__
+
+# CMSIS-DSP Version used to build the wrapper
+cmsis_dsp_version="1.10.0"
+
+
+# Commit hash used to build the wrapper
+commit_hash="f2fb4f86cee3a17fbb394c315c99b833249db44d"
+
+# True if development version used
+developmentVersion=True
+
+__all__ = ["datatype", "fixedpoint", "mfcc"]

PythonWrapper/cmsisdsp/datatype.py → cmsisdsp/datatype.py

@@ -1,17 +1,36 @@
 import cmsisdsp.fixedpoint as f
 import numpy as np
 
+#: F64 format
 F64 = 64 
+#: F32 format
 F32 = 32
+#: F16 format
 F16 = 16
+#: Q31 fixed point format
 Q31 = 31 
+#: Q15 fixed point format
 Q15 = 15
+#: Q7 fixed point format
 Q7 = 7
 
 class UnknownCMSISDSPDataType(Exception):
     pass
 
 def convert(samples,format):
+    """
+     Return an array of scalars in a given format converted from an array of doubles.
+     It is typically used to convert a reference table in double to a table with a lower
+     accuracy used for a specific implementation of an algorithm.
+
+     :param samples: array of double.
+     :type samples: array
+     :param format: Format identification (F64,F32,F16,Q31,Q15,Q7).
+     :type format: int
+     :return: array of scalars in chosen format.
+     :rtype: array
+
+     """
     if format==Q31:
        return(f.toQ31(np.array(samples)))
     if format==Q15:

cmsisdsp/fixedpoint.py

@@ -0,0 +1,103 @@
+import numpy as np
+
+def q31sat(x):
+     if x > 0x7FFFFFFF:
+          return(np.int32(0x7FFFFFFF))
+     elif x < -0x80000000:
+          return(np.int32(0x80000000))
+     else:
+          return(np.int32(x))
+
+q31satV=np.vectorize(q31sat)
+
+def toQ31(x):
+     """
+     Return an array of Q31 scalars from an array of floats
+
+     :param x: array of float.
+     :type x: array
+     :return: array of Q31 scalars.
+     :rtype: array
+
+     """
+     return(q31satV(np.round(np.array(x) * (1<<31))))
+
+def q15sat(x):
+     if x > 0x7FFF:
+          return(np.int16(0x7FFF))
+     elif x < -0x8000:
+          return(np.int16(0x8000))
+     else:
+          return(np.int16(x))
+
+q15satV=np.vectorize(q15sat)
+
+def toQ15(x):
+     """
+     Return an array of Q15 scalars from an array of floats
+
+     :param x: array of float.
+     :type x: array
+     :return: array of Q15 scalars.
+     :rtype: array
+
+     """
+     return(q15satV(np.round(np.array(x) * (1<<15))))
+
+def q7sat(x):
+     if x > 0x7F:
+          return(np.int8(0x7F))
+     elif x < -0x80:
+          return(np.int8(0x80))
+     else:
+          return(np.int8(x))
+
+q7satV=np.vectorize(q7sat)
+
+def toQ7(x):
+     """
+     Return an array of Q7 scalars from an array of floats
+
+     :param x: array of float.
+     :type x: array
+     :return: array of Q7 scalars.
+     :rtype: array
+
+     """
+     return(q7satV(np.round(np.array(x) * (1<<7))))
+
+def Q31toF32(x):
+     """
+     Return an array of float values from an array of Q31 values
+
+     :param x: Array of Q31 values.
+     :type x: array
+     :return: Array of float values.
+     :rtype: array
+
+     """
+     return(1.0*np.array(x) / 2**31)
+
+def Q15toF32(x):
+     """
+     Return an array of float values from an array of Q15 values
+
+     :param x: Array of Q15 values.
+     :type x: array
+     :return: Array of float values.
+     :rtype: array
+
+     """
+     return(1.0*np.array(x) / 2**15)
+
+def Q7toF32(x):
+     """
+     Return an array of float values from an array of Q7 values
+
+     :param x: Array of Q7 values.
+     :type x: array
+     :return: Array of float values.
+     :rtype: array
+
+     """
+     return(1.0*np.array(x) / 2**7)

PythonWrapper/cmsisdsp/mfcc.py → cmsisdsp/mfcc.py

@@ -2,13 +2,49 @@ import numpy as np
 import cmsisdsp.datatype as dt
 
 def frequencyToMelSpace(freq):
+    """
+     Convert a frequency in Hz to Mel space value
+
+     :param freq: Frequency in Hz.
+     :type freq: float
+     :return: Mel value.
+     :rtype: float
+
+    """
     return 1127.0 * np.log(1.0 + freq / 700.0)
 
 def melSpaceToFrequency(mels):
+    """
+     Convert a Mel space value to a frequency in Hz
+
+     :param freq: Mel value.
+     :type freq: float
+     :return: Frequency in Hz.
+     :rtype: float
+
+    """
     return 700.0 * (np.exp(mels / 1127.0) - 1.0)
 
 def melFilterMatrix(dtype,fmin, fmax, numOfMelFilters,fs,FFTSize):
-
+    """
+     Sparse matrix in a specific format and encoding the filters in Mel space
+
+     :param dtype: The datatype to use for the matrix coefficients.
+     :type dtype: int
+     :param fmin: Minimum frequency in Hz.
+     :type fmin: float
+     :param fmax: Maximum frequency in Hz.
+     :type fmax: float
+     :param numOfMelFilters: Number of Mel filters.
+     :type numOfMelFilters: int
+     :param fs: Sampling frequency.
+     :type fs: int
+     :param FFTSize: FFT Length.
+     :type FFTSize: int
+     :return: A tuple encoding the sparse matrix.
+     :rtype: A tuple
+
+    """
     filters = np.zeros((numOfMelFilters,int(FFTSize/2+1)))
     zeros = np.zeros(int(FFTSize // 2 ))
 
@@ -54,7 +90,19 @@ def melFilterMatrix(dtype,fmin, fmax, numOfMelFilters,fs,FFTSize):
 
 
 def dctMatrix(dtype,numOfDctOutputs, numOfMelFilters):
-   
+    """
+     Dct matrix in a specific format
+
+     :param dtype: The datatype to use for the matrix coefficients.
+     :type dtype: int
+     :param numOfDctOutputs: Number of DCT bands.
+     :type numOfDctOutputs: int
+     :param numOfMelFilters: Number of Mel filters.
+     :type numOfMelFilters: int
+     :return: The dct matrix.
+     :rtype: array of dtype
+
+    """
     result = np.zeros((numOfDctOutputs,numOfMelFilters))
     s=(np.linspace(1,numOfMelFilters,numOfMelFilters) - 0.5)/numOfMelFilters
 

SDFTools/sdf/nodes/py/CFFT.py → cmsisdsp/sdf/nodes/CFFT.py

@@ -25,7 +25,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 ############################################
-from sdf.schedule.simu import *
+from .simu import *
 import cmsisdsp as dsp 
 
 

SDFTools/sdf/nodes/py/ICFFT.py → cmsisdsp/sdf/nodes/ICFFT.py

@@ -25,7 +25,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 ############################################
-from sdf.schedule.simu import *
+from .simu import *
 import cmsisdsp as dsp 
 
 # CMSIS-DSP ICFFT

SDFTools/sdf/nodes/py/MFCC.py → cmsisdsp/sdf/nodes/MFCC.py

@@ -25,7 +25,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 ############################################
-from sdf.schedule.simu import *
+from .simu import *
 import cmsisdsp as dsp 
 
 

SDFTools/sdf/nodes/py/NullSink.py → cmsisdsp/sdf/nodes/NullSink.py

@@ -25,7 +25,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 ############################################
-from sdf.schedule.simu import *
+from .simu import *
 
 # This node is doing nothing
 # and can be useful when debugging a graph

SDFTools/sdf/nodes/py/StereoToMono.py → cmsisdsp/sdf/nodes/StereoToMono.py

@@ -25,7 +25,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 ############################################
-from sdf.schedule.simu import *
+from .simu import *
 import numpy as np 
 import cmsisdsp as dsp
 

SDFTools/sdf/nodes/py/ToComplex.py → cmsisdsp/sdf/nodes/ToComplex.py

@@ -25,7 +25,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 ############################################
-from sdf.schedule.simu import *
+from .simu import *
 
 # Convert a stream of reals a b c ...
 # to complexes a 0 b 0 c 0 ...

SDFTools/sdf/nodes/py/ToReal.py → cmsisdsp/sdf/nodes/ToReal.py

@@ -25,7 +25,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 ############################################
-from sdf.schedule.simu import *
+from .simu import *
 
 # Convert a stream of complexes a 0 b 0 c 0 ...
 # to reals a b c ...

SDFTools/sdf/nodes/py/Unzip.py → cmsisdsp/sdf/nodes/Unzip.py

@@ -25,7 +25,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 ############################################
-from sdf.schedule.simu import *
+from .simu import *
 
 # Convert a stream of a1 b1 a2 b2 ...
 # to two streams

SDFTools/sdf/nodes/py/Zip.py → cmsisdsp/sdf/nodes/Zip.py

@@ -26,7 +26,7 @@
 # limitations under the License.
 ############################################
 
-from sdf.schedule.simu import *
+from .simu import *
 
 
 class Unzip(GenericNode): 

SDFTools/sdf/__init__.py → cmsisdsp/sdf/nodes/__init__.py

@@ -26,9 +26,5 @@
 # limitations under the License.
 ############################################    
 
-from sdf.schedule.node import *
-from sdf.schedule.types import *
-from sdf.schedule.description import *
-from sdf.schedule.config import *
-from sdf.schedule.standard import *
+
 

SDFTools/sdf/nodes/py/host/FileSink.py → cmsisdsp/sdf/nodes/host/FileSink.py

@@ -25,7 +25,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 ############################################
-from sdf.schedule.simu import *
+from ..simu import *
 import numpy as np 
 
 
@@ -43,7 +43,7 @@ class FileSink(GenericSink):
         if (nextPos <= self._buffer.size):
             # Save output to buffer defined in custom.py 
             # and used to display result with matplotlib
-            self._buffer[self._bufPos:self._inputSize ]=b[:]
+            self._buffer[self._bufPos:self._bufPos+self._inputSize ]=b[:]
             self._bufPos = nextPos
 
         for sample in b:

SDFTools/sdf/nodes/py/host/FileSource.py → cmsisdsp/sdf/nodes/host/FileSource.py

@@ -25,7 +25,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 ############################################
-from sdf.schedule.simu import *
+from ..simu import *
 
 # Read a list of float from a file
 # and pad with 0 indefinitely when  end of file is reached.

SDFTools/sdf/nodes/py/host/NumpySink.py → cmsisdsp/sdf/nodes/host/NumpySink.py

@@ -26,7 +26,7 @@
 # limitations under the License.
 ############################################
 
-from sdf.schedule.simu import *
+from ..simu import *
 
 # Add each new received buffer to a list of buffers
 class NumpySink(GenericSink):

cmsisdsp/sdf/nodes/host/VHT.py

@@ -0,0 +1,107 @@
+from multiprocessing import Process,Semaphore
+import multiprocessing as mp
+import socket
+import cmsisdsp.sdf.nodes.host.message as msg
+
+HOST = '127.0.0.1'    # The remote host
+PORT = 50007 
+
+class ModelicaConnectionLost(Exception):
+    pass
+
+def connectToServer(inputMode,theid):
+   s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+   s.connect((HOST, PORT))
+   # Identify as vht input
+   if inputMode:
+      print("Connecting as INPUT")
+      theBytes=msg.list_to_bytes(msg.clientID(msg.VSIINPUT,theid))
+   else:
+      print("Connecting as OUTPUT")
+      theBytes=msg.list_to_bytes(msg.clientID(msg.VSIOUTPUT,theid))
+   #print("vs0: %d %d" % (int(theBytes[0]),int(theBytes[1])))
+   msg.sendBytes(s,theBytes)
+   return(s)
+
+def source(theid,size,queue,started):
+   s=connectToServer(True,theid)
+   started.release()
+   try:
+      while True:
+         received=msg.receiveBytes(s,size)
+         queue.put(received)
+   except Exception as inst:
+      print(inst)
+   finally:
+      queue.close()
+
+
+def sink(theid,size,queue,started):
+   s=connectToServer(False,theid)
+   data= bytes(size)
+   msg.sendBytes(s,data)
+   started.release()
+   try:
+      while True:
+         tosend=queue.get(True,2)
+         msg.sendBytes(s,tosend)
+   except Exception as inst:
+      print(inst)
+   finally:
+      queue.close()
+
+class Source:
+   def __init__(self,theid,bufferSize):
+      self._bufferSize_ = bufferSize 
+      self._srcQueue_ = mp.Queue()
+      self._started_ = Semaphore()
+      # Q15 data is sent so a *2 factor for bufferSize since
+      # source function is working with bytes
+      self._src_ = Process(target=source, args=(theid,2*bufferSize,self._srcQueue_,self._started_))
+      self._src_.start()
+
+   @property
+   def queue(self):
+      return(self._srcQueue_)
+
+   def get(self):
+      if self._src_.exitcode is None:  
+         return(msg.bytes_to_list(self.queue.get(True,2)))
+      else:
+         raise ModelicaConnectionLost
+
+   def end(self):
+      self._src_.terminate()
+
+   def wait(self):
+      self._started_.acquire()
+
+
+
+class Sink:
+   def __init__(self,theid,bufferSize):
+      self._bufferSize_ = bufferSize 
+      self._sinkQueue_ = mp.Queue()
+      self._started_ = Semaphore()
+      # Q15 data is sent so a *2 factor for bufferSize since
+      # sink function is working with bytes
+      self._sink_ = Process(target=sink, args=(theid,2*bufferSize,self._sinkQueue_,self._started_))
+      self._sink_.start()
+
+   @property
+   def queue(self):
+      return(self._sinkQueue_)
+
+   def put(self,data):
+      if self._sink_.exitcode is None: 
+         q15list=[int(x) for x in data]
+         self.queue.put(msg.list_to_bytes(q15list),True,1)
+      else:
+         raise ModelicaConnectionLost
+
+   def end(self):
+      self._sink_.terminate()
+
+   def wait(self):
+      self._started_.acquire()
+

cmsisdsp/sdf/nodes/host/VHTSDF.py

@@ -0,0 +1,38 @@
+from ..simu import *
+import numpy as np 
+import cmsisdsp as dsp
+from .VHT import *
+
+
+class VHTSource(GenericSource):
+    def __init__(self,outputSize,fifoout,theid):
+        GenericSource.__init__(self,outputSize,fifoout)
+        self._src_=Source(theid,outputSize)
+        self._src_.wait()
+
+    def run(self):
+        o=self.getWriteBuffer()
+        
+        theInput = self._src_.get()
+        o[:]=theInput[:]
+
+        
+        return(0)
+
+    def __del__(self):
+        self._src_.end()
+
+class VHTSink(GenericSink):
+    def __init__(self,inputSize,fifoin,theid):
+        GenericSink.__init__(self,inputSize,fifoin)
+        self._sink_=Sink(theid,inputSize)
+        self._sink_.wait()
+
+    def run(self):
+        i=self.getReadBuffer()
+        self._sink_.put(i)
+
+        return(0)
+
+    def __del__(self):
+        self._sink_.end()

SDFTools/sdf/nodes/py/host/WavSink.py → cmsisdsp/sdf/nodes/host/WavSink.py

@@ -26,7 +26,7 @@
 # limitations under the License.
 ############################################
 
-from sdf.schedule.simu import *
+from ..simu import *
 import wave
 import struct 
 
@@ -47,7 +47,7 @@ class WavSink(GenericSink):
         if (nextPos <= self._buffer.size):
             # Save output to buffer defined in custom.py 
             # and used to display result with matplotlib
-            self._buffer[self._bufPos:self._inputSize]=b[:]
+            self._buffer[self._bufPos:self._bufPos+self._inputSize]=b[:]
             self._bufPos = nextPos
 
         for sample in b:

SDFTools/sdf/nodes/py/host/WavSource.py → cmsisdsp/sdf/nodes/host/WavSource.py

@@ -25,7 +25,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 ############################################
-from sdf.schedule.simu import *
+from ..simu import *
 import wave
 
 # It is assuming the input is a stereo file

cmsisdsp/sdf/nodes/host/message.py

@@ -0,0 +1,136 @@
+# --------------------------------------------------------------------------
+# Copyright (c) 2020-2022 Arm Limited (or its affiliates). All rights reserved.
+# 
+# SPDX-License-Identifier: Apache-2.0
+# 
+# Licensed under the Apache License, Version 2.0 (the License); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+# www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an AS IS BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# --------------------------------------------------------------------------
+import sys 
+
+# VSI KIND
+VSIOUTPUT = 0
+VSIINPUT = 1
+
+# MESSAGE IDs 
+CLIENTREADBUF=1 
+CLIENTWRITEBUF=2 
+CLIENTSTOP=3 
+
+# PACKETSIZE : default number of bytes read on a socket
+PACKETSIZE = 1024
+# Conersion between size expressed in bytes or in Q15
+INTSIZE = 2 
+
+# Error raised when trying to read / write to sockets
+class ErrorTooMuchDataReceived(Exception):
+    pass
+
+class CantReceiveData(Exception):
+    pass
+
+
+def clientID(inputMode,theID):
+       return([(theID << 1) | inputMode])
+       
+# Receive a given number of bytes
+# Socket is read by block of PACKETSIZE
+def receiveBytes(conn,nb):
+    data = b""
+    while nb > 0:
+       if nb < PACKETSIZE:
+         newData = conn.recv(nb)
+         if not newData: raise CantReceiveData
+       else:
+         newData= conn.recv(PACKETSIZE)
+         if not newData: raise CantReceiveData
+       nb = nb - len(newData)
+       if nb < 0:
+          raise ErrorTooMuchDataReceived
+
+       data += newData
+    return(data)
+
+# Send bytes
+def sendBytes(conn,data):
+    conn.sendall(data)
+
+# Convert a list of Q15 to a bytestream
+def list_to_bytes(l):
+    return(b"".join([x.to_bytes(INTSIZE,byteorder=sys.byteorder,signed=True) for x in l]))
+
+# Convert a bytestream to a list of Q15
+def bytes_to_list(l):
+    res=[] 
+    i = 0
+    while(i<len(l)):
+        res.append(int.from_bytes(l[i:i+INTSIZE],byteorder=sys.byteorder,signed=True))
+        i = i+INTSIZE
+    return(res)
+
+# Send a list of Q15
+def sendIntList(conn,l):
+    data = list_to_bytes(l)
+    sendBytes(conn,data)
+
+# Receive a list of Q15
+def getIntList(conn,length):
+    data = receiveBytes(conn,INTSIZE*length)
+    return(bytes_to_list(data))
+
+
+# Low level bytes management
+# Return the message ID and the number of bytes expected in the message
+def getMsgAndNbOfBytes(data):
+    msgID = int(data[0])
+    length= int.from_bytes(data[1:5],byteorder=sys.byteorder,signed=False)
+    return(msgID,length)
+
+# A client is requesting data from the server. It is the input of VHT
+# Client -> Server
+def getBufferMsg(conn,nbBytes):
+    # Ask buffer from server
+    a=(CLIENTREADBUF).to_bytes(1,byteorder=sys.byteorder)
+    b=(nbBytes).to_bytes(4,byteorder=sys.byteorder)
+    msg=a+b 
+    sendBytes(conn,msg)
+    # Receive buffer from server
+    data = receiveBytes(conn,nbBytes)
+    return(data)
+
+# Stop the server when the end of the SDF scheduling has been reached.
+# It is to make it easier to end the demo.
+# Only the VHT client has to be killed.
+# Client -> Server
+def stopMsg(conn):
+    # Send a stop message to server
+    a=(CLIENTSTOP).to_bytes(1,byteorder=sys.byteorder)
+    b=(0).to_bytes(4,byteorder=sys.byteorder)
+    msg=a+b 
+    sendBytes(conn,msg)
+
+# Data in bytes
+# A client is sending that some bytes be sent to the server
+# It is the output of VHT
+# Client -> Server
+def writeBufferMsg(conn,theBytes):
+    # Tell server a buffer is coming
+    a=(CLIENTWRITEBUF).to_bytes(1,byteorder=sys.byteorder)
+    nbBytes = len(theBytes)
+    b=(nbBytes).to_bytes(4,byteorder=sys.byteorder)
+    msg = a+b+theBytes
+    # Send message and buffer to server
+    sendBytes(conn,msg)
+
+
+
+

SDFTools/sdf/schedule/simu.py → cmsisdsp/sdf/nodes/simu.py

@@ -47,7 +47,7 @@ class FIFO(FIFOBase):
             self._writePos = self._writePos - self._readPos
             self._readPos = 0
         
-        ret = self._buffer[self._writePos:self._writePos+nb];
+        ret = self._buffer[self._writePos:self._writePos+nb]
         self._writePos = self._writePos + nb
         return(ret)
 
@@ -142,27 +142,45 @@ class SlidingBuffer(GenericNode):
         b=self.getWriteBuffer()
         b[:self._overlap] = self._memory 
         b[self._overlap:self._windowSize]=a[:self._windowSize-self._overlap] 
-        self._memory[:self._overlap] = a[self._windowSize-(self._overlap<<1):self._windowSize-self._overlap]
+        self._memory[:self._overlap] = b[self._windowSize-self._overlap:self._windowSize]
         
         return(0)
 
+
+class OverlapTooBig(Exception):
+    pass
+
 class OverlapAdd(GenericNode):
     def __init__(self,windowSize,overlap,fifoin,fifoout):
-        GenericNode.__init__(self,windowSize,overlap,fifoin,fifoout)
+        GenericNode.__init__(self,windowSize,windowSize-overlap,fifoin,fifoout)
+        if ((windowSize-overlap)<=0):
+           raise OverlapTooBig
 
         self._windowSize = windowSize
         self._overlap = overlap 
-        self._memory = np.zeros(windowSize)
+        self._memory = np.zeros(overlap)
 
     def run(self):
         a=self.getReadBuffer()
         b=self.getWriteBuffer()
 
-        self._memory[:self._windowSize-self._overlap] = self._memory[self._overlap:self._windowSize]
-        self._memory[:self._windowSize-self._overlap] += a[:self._windowSize-self._overlap]
-        self._memory[self._windowSize-self._overlap:self._windowSize]=a[self._windowSize-self._overlap:self._windowSize]
-        
+        self._memory[:self._overlap]= a[:self._overlap] + self._memory[:self._overlap] 
+
+        if (2*self._overlap - self._windowSize > 0):
+            b[:self._windowSize-self._overlap] = self._memory[:self._windowSize-self._overlap]
+
+            tmp=np.zeros(2*self._overlap - self._windowSize)
+            tmp[:] = self._memory[self._windowSize-self._overlap:self._overlap]
+            self._memory[:2*self._overlap - self._windowSize] = tmp
+
+            self._memory[2*self._overlap - self._windowSize:self._overlap] = a[self._overlap:self._windowSize]
 
-        b[:self._overlap] = self._memory[:self._overlap]
+        elif (2*self._overlap - self._windowSize < 0):
+            b[:self._overlap] = self._memory[:self._overlap]
+            b[self._overlap:self._windowSize-self._overlap] = a[self._overlap:self._windowSize-self._overlap]
+            self._memory[:self._overlap] = a[self._windowSize-self._overlap:self._windowSize]
+        else:
+            b[:self._overlap]=self._memory[:self._overlap]
+            self._memory[:self._overlap] = a[self._overlap:2*self._overlap]
 
         return(0)

cmsisdsp/sdf/scheduler/__init__.py

@@ -0,0 +1,5 @@
+from .node import *
+from ..types import *
+from .description import *
+from .config import *
+from .standard import *

SDFTools/sdf/schedule/ccode.py → cmsisdsp/sdf/scheduler/ccode.py

@@ -27,11 +27,14 @@
 ############################################
 from jinja2 import Environment, PackageLoader, select_autoescape
 import os.path
-from sdf.schedule.config import *
+import pathlib
+from .config import *
 
 def gencode(sched,directory,config):
+
+
     env = Environment(
-       loader=PackageLoader("sdf"),
+       loader=PackageLoader("cmsisdsp.sdf.scheduler"),
        autoescape=select_autoescape(),
        trim_blocks=True
     )

SDFTools/sdf/schedule/description.py → cmsisdsp/sdf/scheduler/description.py

@@ -32,13 +32,13 @@ import numpy as np
 from sympy import Matrix
 from sympy.core.numbers import ilcm,igcd
 
-import sdf.schedule.graphviz
-import sdf.schedule.ccode
-import sdf.schedule.pythoncode
+import cmsisdsp.sdf.scheduler.graphviz
+import cmsisdsp.sdf.scheduler.ccode
+import cmsisdsp.sdf.scheduler.pythoncode
 
-from sdf.schedule.node import *
-from sdf.schedule.config import *
-from sdf.schedule.types import *
+from .node import *
+from .config import *
+from ..types import *
 
 # To debug graph coloring for memory optimization
 #import matplotlib.pyplot as plt
@@ -661,15 +661,15 @@ class Schedule:
 
     def ccode(self,directory,config=Configuration()):
         """Write graphviz into file f""" 
-        sdf.schedule.ccode.gencode(self,directory,config)
+        cmsisdsp.sdf.scheduler.ccode.gencode(self,directory,config)
 
     def pythoncode(self,directory,config=Configuration()):
         """Write graphviz into file f""" 
-        sdf.schedule.pythoncode.gencode(self,directory,config)
+        cmsisdsp.sdf.scheduler.pythoncode.gencode(self,directory,config)
 
     def graphviz(self,f,config=Configuration()):
         """Write graphviz into file f""" 
-        sdf.schedule.graphviz.gengraph(self,f,config)
+        cmsisdsp.sdf.scheduler.graphviz.gengraph(self,f,config)
     
     
     

SDFTools/sdf/schedule/graphviz.py → cmsisdsp/sdf/scheduler/graphviz.py

@@ -26,10 +26,13 @@
 # limitations under the License.
 ############################################
 from jinja2 import Environment, PackageLoader, select_autoescape
+import pathlib
+import os.path
 
 def gengraph(sched,f,config):
+
     env = Environment(
-       loader=PackageLoader("sdf"),
+       loader=PackageLoader("cmsisdsp.sdf.scheduler"),
        autoescape=select_autoescape(),
        trim_blocks=True
     )

SDFTools/sdf/schedule/node.py → cmsisdsp/sdf/scheduler/node.py

@@ -26,7 +26,9 @@
 # limitations under the License.
 ############################################
 """Description of the basic types used to build a dataflow graph"""
-from jinja2 import Environment, PackageLoader, select_autoescape
+from jinja2 import Environment, FileSystemLoader, PackageLoader,select_autoescape
+import pathlib
+import os.path
 
 class NoFunctionArrayInPython(Exception):
     pass
@@ -483,7 +485,7 @@ class OverlapAdd(GenericNode):
         self._length = length 
         self._overlap = overlap 
         self.addInput("i",theType,length)
-        self.addOutput("o",theType,overlap)
+        self.addOutput("o",theType,length-overlap)
     
     def ioTemplate(self):
         """ioTemplate is different for window
@@ -524,8 +526,9 @@ class GenericFunction(GenericNode):
     NODEID={}
     PUREID=1
 
+
     ENV = Environment(
-       loader=PackageLoader("sdf"),
+       loader=PackageLoader("cmsisdsp.sdf.scheduler"),
        autoescape=select_autoescape(),
        lstrip_blocks=True,
        trim_blocks=True

SDFTools/sdf/schedule/pythoncode.py → cmsisdsp/sdf/scheduler/pythoncode.py

@@ -27,11 +27,13 @@
 ############################################
 from jinja2 import Environment, PackageLoader, select_autoescape
 import os.path
-from sdf.schedule.config import *
+import pathlib 
+from .config import *
 
 def gencode(sched,directory,config):
+
     env = Environment(
-       loader=PackageLoader("sdf"),
+       loader=PackageLoader("cmsisdsp.sdf.scheduler"),
        autoescape=select_autoescape(),
        trim_blocks=True
     )

SDFTools/sdf/schedule/standard.py → cmsisdsp/sdf/scheduler/standard.py

@@ -27,8 +27,8 @@
 ############################################
 """Standard nodes available to describe a network in addition to the generic nodes"""
 
-from sdf.schedule.node import *
-from sdf.schedule.types import *
+from ..types import *
+from .node import GenericNode,GenericSource,GenericSink
 
 floatType=CType(F32)
 
@@ -196,3 +196,33 @@ class NumpySink(GenericSink):
     def typeName(self):
         return "NumpySink"
 
+##################
+#
+# Node to communicates with a VHT block running in Modelica
+#
+# It is requiring the VHT Modelica extensions which can be found
+# in the VHTSystemModeling repository on ArmSoftware GitHub
+
+class VHTSource(GenericNode):
+    def __init__(self,name,inLength,theID):
+        GenericSource.__init__(self,name)
+
+        self.addOutput("o",CType(Q15),inLength)
+        self.addLiteralArg(theID)
+
+
+    @property
+    def typeName(self):
+        return "VHTSource"
+
+class VHTSink(GenericNode):
+    def __init__(self,name,inLength,theID):
+        GenericSource.__init__(self,name)
+
+        self.addInput("i",CType(Q15),inLength)
+        self.addLiteralArg(theID)
+
+    @property
+    def typeName(self):
+        return "VHTSink"
+