1 /* ----------------------------------------------------------------------
2 * Project: CMSIS DSP Python Wrapper
3 * Title: cmsismodule.h
4 * Description: C code for the CMSIS-DSP Python wrapper
5 *
6 * $Date: 27 April 2021
7 * $Revision: V1.0
8 *
9 * Target Processor: Cortex-M cores
10 * -------------------------------------------------------------------- */
11 /*
12 * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
13 *
14 * SPDX-License-Identifier: Apache-2.0
15 *
16 * Licensed under the Apache License, Version 2.0 (the License); you may
17 * not use this file except in compliance with the License.
18 * You may obtain a copy of the License at
19 *
20 * www.apache.org/licenses/LICENSE-2.0
21 *
22 * Unless required by applicable law or agreed to in writing, software
23 * distributed under the License is distributed on an AS IS BASIS, WITHOUT
24 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
25 * See the License for the specific language governing permissions and
26 * limitations under the License.
27 */
28
29 #define MODNAME "cmsisdsp_matrix"
30 #define MODINITNAME cmsisdsp_matrix
31
32 #include "cmsisdsp_module.h"
33
34 MATRIXFROMNUMPY(f32,float32_t,double,NPY_DOUBLE);
35 MATRIXFROMNUMPY(f64,float64_t,double,NPY_DOUBLE);
36 MATRIXFROMNUMPY(q31,q31_t,int32_t,NPY_INT32);
37 MATRIXFROMNUMPY(q15,q15_t,int16_t,NPY_INT16);
38 MATRIXFROMNUMPY(q7,q7_t,int8_t,NPY_BYTE);
39
40 CREATEMATRIX(f32,float32_t);
41 CREATEMATRIX(f64,float64_t);
42 CREATEMATRIX(q31,q31_t);
43 CREATEMATRIX(q15,q15_t);
44 CREATEMATRIX(q7,q7_t);
45
46 NUMPYVECTORFROMBUFFER(f32,float32_t,NPY_FLOAT);
47
48 NUMPYARRAYFROMMATRIX(f32,NPY_FLOAT);
49 NUMPYARRAYFROMMATRIX(f64,NPY_DOUBLE);
50 NUMPYARRAYFROMMATRIX(q31,NPY_INT32);
51 NUMPYARRAYFROMMATRIX(q15,NPY_INT16);
52 NUMPYARRAYFROMMATRIX(q7,NPY_BYTE);
53
54
55
56
57
58
59
60
61
62 typedef struct {
63 PyObject_HEAD
64 arm_matrix_instance_f32 *instance;
65 } dsp_arm_matrix_instance_f32Object;
66
67
68 static void
arm_matrix_instance_f32_dealloc(dsp_arm_matrix_instance_f32Object * self)69 arm_matrix_instance_f32_dealloc(dsp_arm_matrix_instance_f32Object* self)
70 {
71 //printf("Dealloc called\n");
72 if (self->instance)
73 {
74
75
76 if (self->instance->pData)
77 {
78 PyMem_Free(self->instance->pData);
79 }
80
81
82 PyMem_Free(self->instance);
83 }
84
85 Py_TYPE(self)->tp_free((PyObject*)self);
86 }
87
88
89 static PyObject *
arm_matrix_instance_f32_new(PyTypeObject * type,PyObject * args,PyObject * kwds)90 arm_matrix_instance_f32_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
91 {
92 dsp_arm_matrix_instance_f32Object *self;
93 //printf("New called\n");
94
95 self = (dsp_arm_matrix_instance_f32Object *)type->tp_alloc(type, 0);
96 //printf("alloc called\n");
97
98 if (self != NULL) {
99
100 self->instance = PyMem_Malloc(sizeof(arm_matrix_instance_f32));
101
102 self->instance->pData = NULL;
103
104 }
105
106
107 return (PyObject *)self;
108 }
109
110 static int
arm_matrix_instance_f32_init(dsp_arm_matrix_instance_f32Object * self,PyObject * args,PyObject * kwds)111 arm_matrix_instance_f32_init(dsp_arm_matrix_instance_f32Object *self, PyObject *args, PyObject *kwds)
112 {
113
114 PyObject *pData=NULL;
115 char *kwlist[] = {
116 "numRows","numCols","pData",NULL
117 };
118
119 if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhO", kwlist,&self->instance->numRows
120 ,&self->instance->numCols
121 ,&pData
122 ))
123 {
124
125 INITARRAYFIELD(pData,NPY_DOUBLE,double,float32_t);
126
127 }
128 return 0;
129 }
130
131 GETFIELD(arm_matrix_instance_f32,numRows,"h");
132 GETFIELD(arm_matrix_instance_f32,numCols,"h");
133
134
135 static PyMethodDef arm_matrix_instance_f32_methods[] = {
136
137 {"numRows", (PyCFunction) Method_arm_matrix_instance_f32_numRows,METH_NOARGS,"numRows"},
138 {"numCols", (PyCFunction) Method_arm_matrix_instance_f32_numCols,METH_NOARGS,"numCols"},
139
140 {NULL} /* Sentinel */
141 };
142
143
144 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);
145
146
147 typedef struct {
148 PyObject_HEAD
149 arm_matrix_instance_f64 *instance;
150 } dsp_arm_matrix_instance_f64Object;
151
152
153 static void
arm_matrix_instance_f64_dealloc(dsp_arm_matrix_instance_f64Object * self)154 arm_matrix_instance_f64_dealloc(dsp_arm_matrix_instance_f64Object* self)
155 {
156 //printf("Dealloc called\n");
157 if (self->instance)
158 {
159
160
161 if (self->instance->pData)
162 {
163 PyMem_Free(self->instance->pData);
164 }
165
166
167 PyMem_Free(self->instance);
168 }
169
170 Py_TYPE(self)->tp_free((PyObject*)self);
171 }
172
173
174 static PyObject *
arm_matrix_instance_f64_new(PyTypeObject * type,PyObject * args,PyObject * kwds)175 arm_matrix_instance_f64_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
176 {
177 dsp_arm_matrix_instance_f64Object *self;
178 //printf("New called\n");
179
180 self = (dsp_arm_matrix_instance_f64Object *)type->tp_alloc(type, 0);
181 //printf("alloc called\n");
182
183 if (self != NULL) {
184
185 self->instance = PyMem_Malloc(sizeof(arm_matrix_instance_f64));
186
187 self->instance->pData = NULL;
188
189 }
190
191
192 return (PyObject *)self;
193 }
194
195 static int
arm_matrix_instance_f64_init(dsp_arm_matrix_instance_f64Object * self,PyObject * args,PyObject * kwds)196 arm_matrix_instance_f64_init(dsp_arm_matrix_instance_f64Object *self, PyObject *args, PyObject *kwds)
197 {
198
199 PyObject *pData=NULL;
200 char *kwlist[] = {
201 "numRows","numCols","pData",NULL
202 };
203
204 if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhO", kwlist,&self->instance->numRows
205 ,&self->instance->numCols
206 ,&pData
207 ))
208 {
209
210 INITARRAYFIELD(pData,NPY_FLOAT64,float64_t,float64_t);
211
212 }
213 return 0;
214 }
215
216 GETFIELD(arm_matrix_instance_f64,numRows,"h");
217 GETFIELD(arm_matrix_instance_f64,numCols,"h");
218
219
220 static PyMethodDef arm_matrix_instance_f64_methods[] = {
221
222 {"numRows", (PyCFunction) Method_arm_matrix_instance_f64_numRows,METH_NOARGS,"numRows"},
223 {"numCols", (PyCFunction) Method_arm_matrix_instance_f64_numCols,METH_NOARGS,"numCols"},
224
225 {NULL} /* Sentinel */
226 };
227
228
229 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);
230
231
232 typedef struct {
233 PyObject_HEAD
234 arm_matrix_instance_q15 *instance;
235 } dsp_arm_matrix_instance_q15Object;
236
237
238 static void
arm_matrix_instance_q15_dealloc(dsp_arm_matrix_instance_q15Object * self)239 arm_matrix_instance_q15_dealloc(dsp_arm_matrix_instance_q15Object* self)
240 {
241 //printf("Dealloc called\n");
242 if (self->instance)
243 {
244
245
246 if (self->instance->pData)
247 {
248 PyMem_Free(self->instance->pData);
249 }
250
251
252 PyMem_Free(self->instance);
253 }
254
255 Py_TYPE(self)->tp_free((PyObject*)self);
256 }
257
258
259 static PyObject *
arm_matrix_instance_q15_new(PyTypeObject * type,PyObject * args,PyObject * kwds)260 arm_matrix_instance_q15_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
261 {
262 dsp_arm_matrix_instance_q15Object *self;
263 //printf("New called\n");
264
265 self = (dsp_arm_matrix_instance_q15Object *)type->tp_alloc(type, 0);
266 //printf("alloc called\n");
267
268 if (self != NULL) {
269
270 self->instance = PyMem_Malloc(sizeof(arm_matrix_instance_q15));
271
272 self->instance->pData = NULL;
273
274 }
275
276
277 return (PyObject *)self;
278 }
279
280 static int
arm_matrix_instance_q15_init(dsp_arm_matrix_instance_q15Object * self,PyObject * args,PyObject * kwds)281 arm_matrix_instance_q15_init(dsp_arm_matrix_instance_q15Object *self, PyObject *args, PyObject *kwds)
282 {
283
284 PyObject *pData=NULL;
285 char *kwlist[] = {
286 "numRows","numCols","pData",NULL
287 };
288
289 if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhO", kwlist,&self->instance->numRows
290 ,&self->instance->numCols
291 ,&pData
292 ))
293 {
294
295 INITARRAYFIELD(pData,NPY_INT16,int16_t,int16_t);
296
297 }
298 return 0;
299 }
300
301 GETFIELD(arm_matrix_instance_q15,numRows,"h");
302 GETFIELD(arm_matrix_instance_q15,numCols,"h");
303
304
305 static PyMethodDef arm_matrix_instance_q15_methods[] = {
306
307 {"numRows", (PyCFunction) Method_arm_matrix_instance_q15_numRows,METH_NOARGS,"numRows"},
308 {"numCols", (PyCFunction) Method_arm_matrix_instance_q15_numCols,METH_NOARGS,"numCols"},
309
310 {NULL} /* Sentinel */
311 };
312
313
314 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);
315
316
317 typedef struct {
318 PyObject_HEAD
319 arm_matrix_instance_q31 *instance;
320 } dsp_arm_matrix_instance_q31Object;
321
322
323 static void
arm_matrix_instance_q31_dealloc(dsp_arm_matrix_instance_q31Object * self)324 arm_matrix_instance_q31_dealloc(dsp_arm_matrix_instance_q31Object* self)
325 {
326 //printf("Dealloc called\n");
327 if (self->instance)
328 {
329
330
331 if (self->instance->pData)
332 {
333 PyMem_Free(self->instance->pData);
334 }
335
336
337 PyMem_Free(self->instance);
338 }
339
340 Py_TYPE(self)->tp_free((PyObject*)self);
341 }
342
343
344 static PyObject *
arm_matrix_instance_q31_new(PyTypeObject * type,PyObject * args,PyObject * kwds)345 arm_matrix_instance_q31_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
346 {
347 dsp_arm_matrix_instance_q31Object *self;
348 //printf("New called\n");
349
350 self = (dsp_arm_matrix_instance_q31Object *)type->tp_alloc(type, 0);
351 //printf("alloc called\n");
352
353 if (self != NULL) {
354
355 self->instance = PyMem_Malloc(sizeof(arm_matrix_instance_q31));
356
357 self->instance->pData = NULL;
358
359 }
360
361
362 return (PyObject *)self;
363 }
364
365 static int
arm_matrix_instance_q31_init(dsp_arm_matrix_instance_q31Object * self,PyObject * args,PyObject * kwds)366 arm_matrix_instance_q31_init(dsp_arm_matrix_instance_q31Object *self, PyObject *args, PyObject *kwds)
367 {
368
369 PyObject *pData=NULL;
370 char *kwlist[] = {
371 "numRows","numCols","pData",NULL
372 };
373
374 if (PyArg_ParseTupleAndKeywords(args, kwds, "|hhO", kwlist,&self->instance->numRows
375 ,&self->instance->numCols
376 ,&pData
377 ))
378 {
379
380 INITARRAYFIELD(pData,NPY_INT32,int32_t,int32_t);
381
382 }
383 return 0;
384 }
385
386 GETFIELD(arm_matrix_instance_q31,numRows,"h");
387 GETFIELD(arm_matrix_instance_q31,numCols,"h");
388
389
390 static PyMethodDef arm_matrix_instance_q31_methods[] = {
391
392 {"numRows", (PyCFunction) Method_arm_matrix_instance_q31_numRows,METH_NOARGS,"numRows"},
393 {"numCols", (PyCFunction) Method_arm_matrix_instance_q31_numCols,METH_NOARGS,"numCols"},
394
395 {NULL} /* Sentinel */
396 };
397
398
399 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);
400
401
402
403
typeRegistration(PyObject * module)404 void typeRegistration(PyObject *module) {
405
406
407 ADDTYPE(arm_matrix_instance_f32);
408 ADDTYPE(arm_matrix_instance_f64);
409 ADDTYPE(arm_matrix_instance_q15);
410 ADDTYPE(arm_matrix_instance_q31);
411
412
413 }
414
415
416
417
418
419
420 static PyObject *
cmsis_arm_mat_add_f32(PyObject * obj,PyObject * args)421 cmsis_arm_mat_add_f32(PyObject *obj, PyObject *args)
422 {
423
424 PyObject *pSrcA=NULL; // input
425 arm_matrix_instance_f32 pSrcA_converted; // input
426 PyObject *pSrcB=NULL; // input
427 arm_matrix_instance_f32 pSrcB_converted; // input
428
429 arm_matrix_instance_f32 pDst_converted;
430
431 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
432 {
433
434 f32MatrixFromNumpy(&pSrcA_converted,pSrcA);
435 f32MatrixFromNumpy(&pSrcB_converted,pSrcB);
436 uint32_t row = pSrcA_converted.numRows ;
437 uint32_t column = pSrcB_converted.numCols ;
438 createf32Matrix(&pDst_converted,row,column);
439
440 arm_status returnValue = arm_mat_add_f32(&pSrcA_converted,&pSrcB_converted,&pDst_converted);
441 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
442 PyObject* pDstOBJ=NumpyArrayFromf32Matrix(&pDst_converted);
443
444 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
445
446 Py_DECREF(theReturnOBJ);
447 FREEMATRIX(&pSrcA_converted);
448 FREEMATRIX(&pSrcB_converted);
449 Py_DECREF(pDstOBJ);
450 return(pythonResult);
451
452 }
453 Py_RETURN_NONE;
454 }
455
456
457 static PyObject *
cmsis_arm_mat_add_q15(PyObject * obj,PyObject * args)458 cmsis_arm_mat_add_q15(PyObject *obj, PyObject *args)
459 {
460
461 PyObject *pSrcA=NULL; // input
462 arm_matrix_instance_q15 pSrcA_converted; // input
463 PyObject *pSrcB=NULL; // input
464 arm_matrix_instance_q15 pSrcB_converted; // input
465
466 arm_matrix_instance_q15 pDst_converted;
467
468 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
469 {
470
471 q15MatrixFromNumpy(&pSrcA_converted,pSrcA);
472 q15MatrixFromNumpy(&pSrcB_converted,pSrcB);
473 uint32_t row = pSrcA_converted.numRows ;
474 uint32_t column = pSrcB_converted.numCols ;
475 createq15Matrix(&pDst_converted,row,column);
476
477 arm_status returnValue = arm_mat_add_q15(&pSrcA_converted,
478 &pSrcB_converted,
479 &pDst_converted);
480 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
481 PyObject* pDstOBJ=NumpyArrayFromq15Matrix(&pDst_converted);
482
483 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
484
485 Py_DECREF(theReturnOBJ);
486 FREEMATRIX(&pSrcA_converted);
487 FREEMATRIX(&pSrcB_converted);
488 Py_DECREF(pDstOBJ);
489 return(pythonResult);
490
491 }
492 Py_RETURN_NONE;
493 }
494
495
496 static PyObject *
cmsis_arm_mat_add_q31(PyObject * obj,PyObject * args)497 cmsis_arm_mat_add_q31(PyObject *obj, PyObject *args)
498 {
499
500 PyObject *pSrcA=NULL; // input
501 arm_matrix_instance_q31 pSrcA_converted; // input
502 PyObject *pSrcB=NULL; // input
503 arm_matrix_instance_q31 pSrcB_converted; // input
504
505 arm_matrix_instance_q31 pDst_converted;
506
507 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
508 {
509
510 q31MatrixFromNumpy(&pSrcA_converted,pSrcA);
511 q31MatrixFromNumpy(&pSrcB_converted,pSrcB);
512 uint32_t row = pSrcA_converted.numRows ;
513 uint32_t column = pSrcB_converted.numCols ;
514 createq31Matrix(&pDst_converted,row,column);
515
516 arm_status returnValue = arm_mat_add_q31(&pSrcA_converted,
517 &pSrcB_converted,
518 &pDst_converted);
519 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
520 PyObject* pDstOBJ=NumpyArrayFromq31Matrix(&pDst_converted);
521
522 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
523
524 Py_DECREF(theReturnOBJ);
525 FREEMATRIX(&pSrcA_converted);
526 FREEMATRIX(&pSrcB_converted);
527 Py_DECREF(pDstOBJ);
528 return(pythonResult);
529
530 }
531 Py_RETURN_NONE;
532 }
533
534 static PyObject *
cmsis_arm_mat_cmplx_trans_f32(PyObject * obj,PyObject * args)535 cmsis_arm_mat_cmplx_trans_f32(PyObject *obj, PyObject *args)
536 {
537
538 PyObject *pSrc=NULL; // input
539 arm_matrix_instance_f32 pSrc_converted; // input
540 arm_matrix_instance_f32 pDst_converted;
541
542 if (PyArg_ParseTuple(args,"O",&pSrc))
543 {
544
545 f32MatrixFromNumpy(&pSrc_converted,pSrc);
546 pSrc_converted.numCols = pSrc_converted.numCols / 2;
547
548 uint32_t row = pSrc_converted.numCols ;
549 uint32_t column = pSrc_converted.numRows*2 ;
550 createf32Matrix(&pDst_converted,row,column);
551 /*
552 Dimensions in matrix instance are not correct but they are not used
553 by CMSIS-DSP since the library is not compiled with ARM_MATRIX_CHECK.
554 So only source dimensions are used for the computation.
555
556 The dimensions are correct for createf32Matrix since we need to create
557 a bigger buffer and createf32Matrix only knows real.
558
559 */
560
561 arm_status returnValue = arm_mat_cmplx_trans_f32(&pSrc_converted,&pDst_converted);
562 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
563 PyObject* pDstOBJ=NumpyArrayFromf32Matrix(&pDst_converted);
564
565 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
566
567 Py_DECREF(theReturnOBJ);
568 FREEMATRIX(&pSrc_converted);
569 Py_DECREF(pDstOBJ);
570 return(pythonResult);
571
572 }
573 Py_RETURN_NONE;
574 }
575
576 static PyObject *
cmsis_arm_mat_cmplx_trans_q31(PyObject * obj,PyObject * args)577 cmsis_arm_mat_cmplx_trans_q31(PyObject *obj, PyObject *args)
578 {
579
580 PyObject *pSrc=NULL; // input
581 arm_matrix_instance_q31 pSrc_converted; // input
582 arm_matrix_instance_q31 pDst_converted;
583
584 if (PyArg_ParseTuple(args,"O",&pSrc))
585 {
586
587 q31MatrixFromNumpy(&pSrc_converted,pSrc);
588 pSrc_converted.numCols = pSrc_converted.numCols / 2;
589
590 uint32_t row = pSrc_converted.numCols ;
591 uint32_t column = pSrc_converted.numRows*2 ;
592 createq31Matrix(&pDst_converted,row,column);
593 /*
594 Dimensions in matrix instance are not correct but they are not used
595 by CMSIS-DSP since the library is not compiled with ARM_MATRIX_CHECK.
596 So only source dimensions are used for the computation.
597
598 The dimensions are correct for createf32Matrix since we need to create
599 a bigger buffer and createf32Matrix only knows real.
600
601 */
602
603 arm_status returnValue = arm_mat_cmplx_trans_q31(&pSrc_converted,&pDst_converted);
604 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
605 PyObject* pDstOBJ=NumpyArrayFromq31Matrix(&pDst_converted);
606
607 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
608
609 Py_DECREF(theReturnOBJ);
610 FREEMATRIX(&pSrc_converted);
611 Py_DECREF(pDstOBJ);
612 return(pythonResult);
613
614 }
615 Py_RETURN_NONE;
616 }
617
618 static PyObject *
cmsis_arm_mat_cmplx_trans_q15(PyObject * obj,PyObject * args)619 cmsis_arm_mat_cmplx_trans_q15(PyObject *obj, PyObject *args)
620 {
621
622 PyObject *pSrc=NULL; // input
623 arm_matrix_instance_q15 pSrc_converted; // input
624 arm_matrix_instance_q15 pDst_converted;
625
626 if (PyArg_ParseTuple(args,"O",&pSrc))
627 {
628
629 q15MatrixFromNumpy(&pSrc_converted,pSrc);
630 pSrc_converted.numCols = pSrc_converted.numCols / 2;
631
632 uint32_t row = pSrc_converted.numCols ;
633 uint32_t column = pSrc_converted.numRows*2 ;
634 createq15Matrix(&pDst_converted,row,column);
635 /*
636 Dimensions in matrix instance are not correct but they are not used
637 by CMSIS-DSP since the library is not compiled with ARM_MATRIX_CHECK.
638 So only source dimensions are used for the computation.
639
640 The dimensions are correct for createf32Matrix since we need to create
641 a bigger buffer and createf32Matrix only knows real.
642
643 */
644
645 arm_status returnValue = arm_mat_cmplx_trans_q15(&pSrc_converted,&pDst_converted);
646 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
647 PyObject* pDstOBJ=NumpyArrayFromq15Matrix(&pDst_converted);
648
649 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
650
651 Py_DECREF(theReturnOBJ);
652 FREEMATRIX(&pSrc_converted);
653 Py_DECREF(pDstOBJ);
654 return(pythonResult);
655
656 }
657 Py_RETURN_NONE;
658 }
659
660 static PyObject *
cmsis_arm_mat_cmplx_mult_f32(PyObject * obj,PyObject * args)661 cmsis_arm_mat_cmplx_mult_f32(PyObject *obj, PyObject *args)
662 {
663
664 PyObject *pSrcA=NULL; // input
665 arm_matrix_instance_f32 pSrcA_converted; // input
666 PyObject *pSrcB=NULL; // input
667 arm_matrix_instance_f32 pSrcB_converted; // input
668 arm_matrix_instance_f32 pDst_converted;
669
670 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
671 {
672
673 f32MatrixFromNumpy(&pSrcA_converted,pSrcA);
674 f32MatrixFromNumpy(&pSrcB_converted,pSrcB);
675 pSrcA_converted.numCols = pSrcA_converted.numCols / 2;
676 pSrcB_converted.numCols = pSrcB_converted.numCols / 2;
677 uint32_t row = pSrcA_converted.numRows ;
678 uint32_t column = pSrcB_converted.numCols * 2;
679 createf32Matrix(&pDst_converted,row,column);
680
681 arm_status returnValue = arm_mat_cmplx_mult_f32(&pSrcA_converted,
682 &pSrcB_converted,&pDst_converted);
683 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
684 PyObject* pDstOBJ=NumpyArrayFromf32Matrix(&pDst_converted);
685
686 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
687
688 Py_DECREF(theReturnOBJ);
689 FREEMATRIX(&pSrcA_converted);
690 FREEMATRIX(&pSrcB_converted);
691 Py_DECREF(pDstOBJ);
692 return(pythonResult);
693
694 }
695 Py_RETURN_NONE;
696 }
697
698
699 static PyObject *
cmsis_arm_mat_cmplx_mult_q15(PyObject * obj,PyObject * args)700 cmsis_arm_mat_cmplx_mult_q15(PyObject *obj, PyObject *args)
701 {
702
703 PyObject *pSrcA=NULL; // input
704 arm_matrix_instance_q15 pSrcA_converted; // input
705 PyObject *pSrcB=NULL; // input
706 arm_matrix_instance_q15 pSrcB_converted; // input
707 PyObject *pScratch=NULL; // input
708 q15_t *pScratch_converted=NULL; // input
709 arm_matrix_instance_q15 pDst_converted;
710
711 if (PyArg_ParseTuple(args,"OOO",&pSrcA,&pSrcB,&pScratch))
712 {
713
714 q15MatrixFromNumpy(&pSrcA_converted,pSrcA);
715 q15MatrixFromNumpy(&pSrcB_converted,pSrcB);
716 GETARGUMENT(pScratch,NPY_INT16,int16_t,int16_t);
717 pSrcA_converted.numCols = pSrcA_converted.numCols / 2;
718 pSrcB_converted.numCols = pSrcB_converted.numCols / 2;
719 uint32_t row = pSrcA_converted.numRows ;
720 uint32_t column = pSrcB_converted.numCols * 2;
721 createq15Matrix(&pDst_converted,row,column);
722
723 arm_status returnValue = arm_mat_cmplx_mult_q15(&pSrcA_converted,
724 &pSrcB_converted,&pDst_converted,pScratch_converted);
725 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
726 PyObject* pDstOBJ=NumpyArrayFromq15Matrix(&pDst_converted);
727
728 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
729
730 Py_DECREF(theReturnOBJ);
731 FREEMATRIX(&pSrcA_converted);
732 FREEMATRIX(&pSrcB_converted);
733 Py_DECREF(pDstOBJ);
734 FREEARGUMENT(pScratch_converted);
735 return(pythonResult);
736
737 }
738 Py_RETURN_NONE;
739 }
740
741
742 static PyObject *
cmsis_arm_mat_cmplx_mult_q31(PyObject * obj,PyObject * args)743 cmsis_arm_mat_cmplx_mult_q31(PyObject *obj, PyObject *args)
744 {
745
746 PyObject *pSrcA=NULL; // input
747 arm_matrix_instance_q31 pSrcA_converted; // input
748 PyObject *pSrcB=NULL; // input
749 arm_matrix_instance_q31 pSrcB_converted; // input
750 arm_matrix_instance_q31 pDst_converted;
751
752 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
753 {
754
755 q31MatrixFromNumpy(&pSrcA_converted,pSrcA);
756 q31MatrixFromNumpy(&pSrcB_converted,pSrcB);
757 pSrcA_converted.numCols = pSrcA_converted.numCols / 2;
758 pSrcB_converted.numCols = pSrcB_converted.numCols / 2;
759 uint32_t row = pSrcA_converted.numRows ;
760 uint32_t column = pSrcB_converted.numCols * 2;
761 createq31Matrix(&pDst_converted,row,column);
762
763 arm_status returnValue = arm_mat_cmplx_mult_q31(&pSrcA_converted,
764 &pSrcB_converted,&pDst_converted);
765 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
766 PyObject* pDstOBJ=NumpyArrayFromq31Matrix(&pDst_converted);
767
768 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
769
770 Py_DECREF(theReturnOBJ);
771 FREEMATRIX(&pSrcA_converted);
772 FREEMATRIX(&pSrcB_converted);
773 Py_DECREF(pDstOBJ);
774 return(pythonResult);
775
776 }
777 Py_RETURN_NONE;
778 }
779
780
781 static PyObject *
cmsis_arm_mat_trans_f32(PyObject * obj,PyObject * args)782 cmsis_arm_mat_trans_f32(PyObject *obj, PyObject *args)
783 {
784
785 PyObject *pSrc=NULL; // input
786 arm_matrix_instance_f32 pSrc_converted; // input
787 arm_matrix_instance_f32 pDst_converted;
788
789 if (PyArg_ParseTuple(args,"O",&pSrc))
790 {
791
792 f32MatrixFromNumpy(&pSrc_converted,pSrc);
793 uint32_t row = pSrc_converted.numCols ;
794 uint32_t column = pSrc_converted.numRows ;
795 createf32Matrix(&pDst_converted,row,column);
796
797 arm_status returnValue = arm_mat_trans_f32(&pSrc_converted,&pDst_converted);
798 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
799 PyObject* pDstOBJ=NumpyArrayFromf32Matrix(&pDst_converted);
800
801 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
802
803 Py_DECREF(theReturnOBJ);
804 FREEMATRIX(&pSrc_converted);
805 Py_DECREF(pDstOBJ);
806 return(pythonResult);
807
808 }
809 Py_RETURN_NONE;
810 }
811
812 static PyObject *
cmsis_arm_mat_trans_f64(PyObject * obj,PyObject * args)813 cmsis_arm_mat_trans_f64(PyObject *obj, PyObject *args)
814 {
815
816 PyObject *pSrc=NULL; // input
817 arm_matrix_instance_f64 pSrc_converted; // input
818 arm_matrix_instance_f64 pDst_converted;
819
820 if (PyArg_ParseTuple(args,"O",&pSrc))
821 {
822
823 f64MatrixFromNumpy(&pSrc_converted,pSrc);
824 uint32_t row = pSrc_converted.numCols ;
825 uint32_t column = pSrc_converted.numRows ;
826 createf64Matrix(&pDst_converted,row,column);
827
828 arm_status returnValue = arm_mat_trans_f64(&pSrc_converted,&pDst_converted);
829 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
830 PyObject* pDstOBJ=NumpyArrayFromf64Matrix(&pDst_converted);
831
832 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
833
834 Py_DECREF(theReturnOBJ);
835 FREEMATRIX(&pSrc_converted);
836 Py_DECREF(pDstOBJ);
837 return(pythonResult);
838
839 }
840 Py_RETURN_NONE;
841 }
842
843 static PyObject *
cmsis_arm_mat_trans_q7(PyObject * obj,PyObject * args)844 cmsis_arm_mat_trans_q7(PyObject *obj, PyObject *args)
845 {
846
847 PyObject *pSrc=NULL; // input
848 arm_matrix_instance_q7 pSrc_converted; // input
849 arm_matrix_instance_q7 pDst_converted;
850
851 if (PyArg_ParseTuple(args,"O",&pSrc))
852 {
853
854 q7MatrixFromNumpy(&pSrc_converted,pSrc);
855 uint32_t row = pSrc_converted.numCols ;
856 uint32_t column = pSrc_converted.numRows ;
857 createq7Matrix(&pDst_converted,row,column);
858
859 arm_status returnValue = arm_mat_trans_q7(&pSrc_converted,&pDst_converted);
860 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
861 PyObject* pDstOBJ=NumpyArrayFromq7Matrix(&pDst_converted);
862
863 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
864
865 Py_DECREF(theReturnOBJ);
866 FREEMATRIX(&pSrc_converted);
867 Py_DECREF(pDstOBJ);
868 return(pythonResult);
869
870 }
871 Py_RETURN_NONE;
872 }
873
874 static PyObject *
cmsis_arm_mat_trans_q15(PyObject * obj,PyObject * args)875 cmsis_arm_mat_trans_q15(PyObject *obj, PyObject *args)
876 {
877
878 PyObject *pSrc=NULL; // input
879 arm_matrix_instance_q15 pSrc_converted; // input
880 arm_matrix_instance_q15 pDst_converted;
881
882 if (PyArg_ParseTuple(args,"O",&pSrc))
883 {
884
885 q15MatrixFromNumpy(&pSrc_converted,pSrc);
886 uint32_t row = pSrc_converted.numCols ;
887 uint32_t column = pSrc_converted.numRows ;
888 createq15Matrix(&pDst_converted,row,column);
889
890 arm_status returnValue = arm_mat_trans_q15(&pSrc_converted,&pDst_converted);
891 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
892 PyObject* pDstOBJ=NumpyArrayFromq15Matrix(&pDst_converted);
893
894 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
895
896 Py_DECREF(theReturnOBJ);
897 FREEMATRIX(&pSrc_converted);
898 Py_DECREF(pDstOBJ);
899 return(pythonResult);
900
901 }
902 Py_RETURN_NONE;
903 }
904
905
906 static PyObject *
cmsis_arm_mat_trans_q31(PyObject * obj,PyObject * args)907 cmsis_arm_mat_trans_q31(PyObject *obj, PyObject *args)
908 {
909
910 PyObject *pSrc=NULL; // input
911 arm_matrix_instance_q31 pSrc_converted; // input
912 arm_matrix_instance_q31 pDst_converted;
913
914 if (PyArg_ParseTuple(args,"O",&pSrc))
915 {
916
917 q31MatrixFromNumpy(&pSrc_converted,pSrc);
918 uint32_t row = pSrc_converted.numCols ;
919 uint32_t column = pSrc_converted.numRows ;
920 createq31Matrix(&pDst_converted,row,column);
921
922 arm_status returnValue = arm_mat_trans_q31(&pSrc_converted,&pDst_converted);
923 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
924 PyObject* pDstOBJ=NumpyArrayFromq31Matrix(&pDst_converted);
925
926 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
927
928 Py_DECREF(theReturnOBJ);
929 FREEMATRIX(&pSrc_converted);
930 Py_DECREF(pDstOBJ);
931 return(pythonResult);
932
933 }
934 Py_RETURN_NONE;
935 }
936
937 static PyObject *
cmsis_arm_mat_vec_mult_f32(PyObject * obj,PyObject * args)938 cmsis_arm_mat_vec_mult_f32(PyObject *obj, PyObject *args)
939 {
940
941 PyObject *pSrcA=NULL; // input
942 arm_matrix_instance_f32 pSrcA_converted; // input
943 PyObject *pSrcB=NULL; // input
944 float32_t *pSrcB_converted=NULL; // input
945 float32_t *pDst=NULL; // output
946
947 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
948 {
949
950 f32MatrixFromNumpy(&pSrcA_converted,pSrcA);
951 GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
952 uint32_t row = pSrcA_converted.numRows ;
953 uint32_t column = pSrcA_converted.numCols ;
954 pDst=PyMem_Malloc(sizeof(float32_t)*row);
955
956 arm_mat_vec_mult_f32(&pSrcA_converted,pSrcB_converted,pDst);
957 FLOATARRAY1(pDstOBJ,row,pDst);
958
959 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
960
961 FREEMATRIX(&pSrcA_converted);
962 FREEARGUMENT(pSrcB_converted);
963 Py_DECREF(pDstOBJ);
964 return(pythonResult);
965
966 }
967 Py_RETURN_NONE;
968 }
969
970 static PyObject *
cmsis_arm_mat_mult_f32(PyObject * obj,PyObject * args)971 cmsis_arm_mat_mult_f32(PyObject *obj, PyObject *args)
972 {
973
974 PyObject *pSrcA=NULL; // input
975 arm_matrix_instance_f32 pSrcA_converted; // input
976 PyObject *pSrcB=NULL; // input
977 arm_matrix_instance_f32 pSrcB_converted; // input
978 arm_matrix_instance_f32 pDst_converted;
979
980 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
981 {
982
983 f32MatrixFromNumpy(&pSrcA_converted,pSrcA);
984 f32MatrixFromNumpy(&pSrcB_converted,pSrcB);
985 uint32_t row = pSrcA_converted.numRows ;
986 uint32_t column = pSrcB_converted.numCols ;
987 createf32Matrix(&pDst_converted,row,column);
988
989 arm_status returnValue = arm_mat_mult_f32(&pSrcA_converted,
990 &pSrcB_converted,
991 &pDst_converted);
992 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
993 PyObject* pDstOBJ=NumpyArrayFromf32Matrix(&pDst_converted);
994
995 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
996
997 Py_DECREF(theReturnOBJ);
998 FREEMATRIX(&pSrcA_converted);
999 FREEMATRIX(&pSrcB_converted);
1000 Py_DECREF(pDstOBJ);
1001 return(pythonResult);
1002
1003 }
1004 Py_RETURN_NONE;
1005 }
1006
1007 static PyObject *
cmsis_arm_mat_mult_f64(PyObject * obj,PyObject * args)1008 cmsis_arm_mat_mult_f64(PyObject *obj, PyObject *args)
1009 {
1010
1011 PyObject *pSrcA=NULL; // input
1012 arm_matrix_instance_f64 pSrcA_converted; // input
1013 PyObject *pSrcB=NULL; // input
1014 arm_matrix_instance_f64 pSrcB_converted; // input
1015 arm_matrix_instance_f64 pDst_converted ;
1016
1017 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
1018 {
1019
1020 f64MatrixFromNumpy(&pSrcA_converted,pSrcA);
1021 f64MatrixFromNumpy(&pSrcB_converted,pSrcB);
1022 uint32_t row = pSrcA_converted.numRows ;
1023 uint32_t column = pSrcB_converted.numCols ;
1024 createf64Matrix(&pDst_converted,row,column);
1025
1026 arm_status returnValue = arm_mat_mult_f64(&pSrcA_converted,
1027 &pSrcB_converted,&pDst_converted);
1028 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1029 PyObject* pDstOBJ=NumpyArrayFromf64Matrix(&pDst_converted);
1030
1031 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
1032
1033 Py_DECREF(theReturnOBJ);
1034 FREEMATRIX(&pSrcA_converted);
1035 FREEMATRIX(&pSrcB_converted);
1036 Py_DECREF(pDstOBJ);
1037 return(pythonResult);
1038
1039 }
1040 Py_RETURN_NONE;
1041 }
1042
1043 static PyObject *
cmsis_arm_mat_vec_mult_q15(PyObject * obj,PyObject * args)1044 cmsis_arm_mat_vec_mult_q15(PyObject *obj, PyObject *args)
1045 {
1046
1047 PyObject *pSrcA=NULL; // input
1048 arm_matrix_instance_q15 pSrcA_converted; // input
1049 PyObject *pSrcB=NULL; // input
1050 q15_t *pSrcB_converted=NULL; // input
1051 q15_t *pDst=NULL; // output
1052
1053 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
1054 {
1055
1056 q15MatrixFromNumpy(&pSrcA_converted,pSrcA);
1057 GETARGUMENT(pSrcB,NPY_INT16,int16_t,q15_t);
1058 uint32_t row = pSrcA_converted.numRows ;
1059 uint32_t column = pSrcA_converted.numCols ;
1060 pDst=PyMem_Malloc(sizeof(q15_t)*row);
1061
1062 arm_mat_vec_mult_q15(&pSrcA_converted,pSrcB_converted,pDst);
1063 INT16ARRAY1(pDstOBJ,row,pDst);
1064
1065 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1066
1067 FREEMATRIX(&pSrcA_converted);
1068 FREEARGUMENT(pSrcB_converted);
1069 Py_DECREF(pDstOBJ);
1070 return(pythonResult);
1071
1072 }
1073 Py_RETURN_NONE;
1074 }
1075
1076 static PyObject *
cmsis_arm_mat_vec_mult_q7(PyObject * obj,PyObject * args)1077 cmsis_arm_mat_vec_mult_q7(PyObject *obj, PyObject *args)
1078 {
1079
1080 PyObject *pSrcA=NULL; // input
1081 arm_matrix_instance_q7 pSrcA_converted; // input
1082 PyObject *pSrcB=NULL; // input
1083 q7_t *pSrcB_converted=NULL; // input
1084 q7_t *pDst=NULL; // output
1085
1086 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
1087 {
1088
1089 q7MatrixFromNumpy(&pSrcA_converted,pSrcA);
1090 GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
1091 uint32_t row = pSrcA_converted.numRows ;
1092 uint32_t column = pSrcA_converted.numCols ;
1093 pDst=PyMem_Malloc(sizeof(q7_t)*row);
1094
1095 arm_mat_vec_mult_q7(&pSrcA_converted,pSrcB_converted,pDst);
1096 INT8ARRAY1(pDstOBJ,row,pDst);
1097
1098 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1099
1100 FREEMATRIX(&pSrcA_converted);
1101 FREEARGUMENT(pSrcB_converted);
1102 Py_DECREF(pDstOBJ);
1103 return(pythonResult);
1104
1105 }
1106 Py_RETURN_NONE;
1107 }
1108
1109 static PyObject *
cmsis_arm_mat_mult_q7(PyObject * obj,PyObject * args)1110 cmsis_arm_mat_mult_q7(PyObject *obj, PyObject *args)
1111 {
1112
1113 PyObject *pSrcA=NULL; // input
1114 arm_matrix_instance_q7 pSrcA_converted; // input
1115 PyObject *pSrcB=NULL; // input
1116 arm_matrix_instance_q7 pSrcB_converted; // input
1117 PyObject *pState=NULL; // input
1118 q7_t *pState_converted=NULL; // input
1119 arm_matrix_instance_q7 pDst_converted;
1120
1121 if (PyArg_ParseTuple(args,"OOO",&pSrcA,&pSrcB,&pState))
1122 {
1123
1124 q7MatrixFromNumpy(&pSrcA_converted,pSrcA);
1125 q7MatrixFromNumpy(&pSrcB_converted,pSrcB);
1126 GETARGUMENT(pState,NPY_BYTE,int8_t,q7_t);
1127 uint32_t row = pSrcA_converted.numRows ;
1128 uint32_t column = pSrcB_converted.numCols ;
1129 createq7Matrix(&pDst_converted,row,column);
1130
1131 arm_status returnValue = arm_mat_mult_q7(&pSrcA_converted,
1132 &pSrcB_converted,
1133 &pDst_converted,pState_converted);
1134 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1135 PyObject* pDstOBJ=NumpyArrayFromq7Matrix(&pDst_converted);
1136
1137 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
1138
1139 Py_DECREF(theReturnOBJ);
1140 FREEMATRIX(&pSrcA_converted);
1141 FREEMATRIX(&pSrcB_converted);
1142 Py_DECREF(pDstOBJ);
1143 FREEARGUMENT(pState_converted);
1144 return(pythonResult);
1145
1146 }
1147 Py_RETURN_NONE;
1148 }
1149
1150 static PyObject *
cmsis_arm_mat_mult_q15(PyObject * obj,PyObject * args)1151 cmsis_arm_mat_mult_q15(PyObject *obj, PyObject *args)
1152 {
1153
1154 PyObject *pSrcA=NULL; // input
1155 arm_matrix_instance_q15 pSrcA_converted; // input
1156 PyObject *pSrcB=NULL; // input
1157 arm_matrix_instance_q15 pSrcB_converted; // input
1158 PyObject *pState=NULL; // input
1159 q15_t *pState_converted=NULL; // input
1160 arm_matrix_instance_q15 pDst_converted;
1161
1162 if (PyArg_ParseTuple(args,"OOO",&pSrcA,&pSrcB,&pState))
1163 {
1164
1165 q15MatrixFromNumpy(&pSrcA_converted,pSrcA);
1166 q15MatrixFromNumpy(&pSrcB_converted,pSrcB);
1167
1168 GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
1169 uint32_t row = pSrcA_converted.numRows ;
1170 uint32_t column = pSrcB_converted.numCols ;
1171 createq15Matrix(&pDst_converted,row,column);
1172
1173 arm_status returnValue = arm_mat_mult_q15(&pSrcA_converted,
1174 &pSrcB_converted,&pDst_converted,pState_converted);
1175 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1176 PyObject* pDstOBJ=NumpyArrayFromq15Matrix(&pDst_converted);
1177
1178 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
1179
1180 Py_DECREF(theReturnOBJ);
1181 FREEMATRIX(&pSrcA_converted);
1182 FREEMATRIX(&pSrcB_converted);
1183 Py_DECREF(pDstOBJ);
1184 FREEARGUMENT(pState_converted);
1185 return(pythonResult);
1186
1187 }
1188 Py_RETURN_NONE;
1189 }
1190
1191
1192 static PyObject *
cmsis_arm_mat_mult_fast_q15(PyObject * obj,PyObject * args)1193 cmsis_arm_mat_mult_fast_q15(PyObject *obj, PyObject *args)
1194 {
1195
1196 PyObject *pSrcA=NULL; // input
1197 arm_matrix_instance_q15 pSrcA_converted; // input
1198 PyObject *pSrcB=NULL; // input
1199 arm_matrix_instance_q15 pSrcB_converted; // input
1200 PyObject *pState=NULL; // input
1201 q15_t *pState_converted=NULL; // input
1202 arm_matrix_instance_q15 pDst_converted;
1203
1204 if (PyArg_ParseTuple(args,"OOO",&pSrcA,&pSrcB,&pState))
1205 {
1206
1207 q15MatrixFromNumpy(&pSrcA_converted,pSrcA);
1208 q15MatrixFromNumpy(&pSrcB_converted,pSrcB);
1209 GETARGUMENT(pState,NPY_INT16,int16_t,int16_t);
1210 uint32_t row = pSrcA_converted.numRows ;
1211 uint32_t column = pSrcB_converted.numCols ;
1212 createq15Matrix(&pDst_converted,row,column);
1213
1214 arm_status returnValue = arm_mat_mult_fast_q15(&pSrcA_converted,
1215 &pSrcB_converted,&pDst_converted,pState_converted);
1216 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1217 PyObject* pDstOBJ=NumpyArrayFromq15Matrix(&pDst_converted);
1218
1219 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
1220
1221 Py_DECREF(theReturnOBJ);
1222 FREEMATRIX(&pSrcA_converted);
1223 FREEMATRIX(&pSrcB_converted);
1224 Py_DECREF(pDstOBJ);
1225 FREEARGUMENT(pState_converted);
1226 return(pythonResult);
1227
1228 }
1229 Py_RETURN_NONE;
1230 }
1231
1232 static PyObject *
cmsis_arm_mat_vec_mult_q31(PyObject * obj,PyObject * args)1233 cmsis_arm_mat_vec_mult_q31(PyObject *obj, PyObject *args)
1234 {
1235
1236 PyObject *pSrcA=NULL; // input
1237 arm_matrix_instance_q31 pSrcA_converted; // input
1238 PyObject *pSrcB=NULL; // input
1239 q31_t *pSrcB_converted=NULL; // input
1240 q31_t *pDst=NULL; // output
1241
1242 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
1243 {
1244
1245 q31MatrixFromNumpy(&pSrcA_converted,pSrcA);
1246 GETARGUMENT(pSrcB,NPY_INT32,int32_t,q31_t);
1247 uint32_t row = pSrcA_converted.numRows ;
1248 uint32_t column = pSrcA_converted.numCols ;
1249 pDst=PyMem_Malloc(sizeof(q31_t)*row);
1250
1251 arm_mat_vec_mult_q31(&pSrcA_converted,pSrcB_converted,pDst);
1252 INT32ARRAY1(pDstOBJ,row,pDst);
1253
1254 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1255
1256 FREEMATRIX(&pSrcA_converted);
1257 FREEARGUMENT(pSrcB_converted);
1258 Py_DECREF(pDstOBJ);
1259 return(pythonResult);
1260
1261 }
1262 Py_RETURN_NONE;
1263 }
1264
1265 static PyObject *
cmsis_arm_mat_mult_q31(PyObject * obj,PyObject * args)1266 cmsis_arm_mat_mult_q31(PyObject *obj, PyObject *args)
1267 {
1268
1269 PyObject *pSrcA=NULL; // input
1270 arm_matrix_instance_q31 pSrcA_converted; // input
1271 PyObject *pSrcB=NULL; // input
1272 arm_matrix_instance_q31 pSrcB_converted; // input
1273 arm_matrix_instance_q31 pDst_converted;
1274
1275 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
1276 {
1277
1278 q31MatrixFromNumpy(&pSrcA_converted,pSrcA);
1279 q31MatrixFromNumpy(&pSrcB_converted,pSrcB);
1280 uint32_t row = pSrcA_converted.numRows ;
1281 uint32_t column = pSrcB_converted.numCols ;
1282 createq31Matrix(&pDst_converted,row,column);
1283
1284 arm_status returnValue = arm_mat_mult_q31(&pSrcA_converted,&pSrcB_converted,
1285 &pDst_converted);
1286 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1287 PyObject* pDstOBJ=NumpyArrayFromq31Matrix(&pDst_converted);
1288
1289 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
1290
1291 Py_DECREF(theReturnOBJ);
1292 FREEMATRIX(&pSrcA_converted);
1293 FREEMATRIX(&pSrcB_converted);
1294 Py_DECREF(pDstOBJ);
1295 return(pythonResult);
1296
1297 }
1298 Py_RETURN_NONE;
1299 }
1300
1301 static PyObject *
cmsis_arm_mat_mult_opt_q31(PyObject * obj,PyObject * args)1302 cmsis_arm_mat_mult_opt_q31(PyObject *obj, PyObject *args)
1303 {
1304
1305 PyObject *pSrcA=NULL; // input
1306 arm_matrix_instance_q31 pSrcA_converted; // input
1307 PyObject *pSrcB=NULL; // input
1308 arm_matrix_instance_q31 pSrcB_converted; // input
1309 PyObject *pState=NULL; // input
1310 q31_t *pState_converted=NULL; // input
1311 arm_matrix_instance_q31 pDst_converted;
1312
1313 if (PyArg_ParseTuple(args,"OOO",&pSrcA,&pSrcB,&pState))
1314 {
1315
1316 q31MatrixFromNumpy(&pSrcA_converted,pSrcA);
1317 q31MatrixFromNumpy(&pSrcB_converted,pSrcB);
1318
1319 GETARGUMENT(pState,NPY_INT32,int32_t,int32_t);
1320 uint32_t row = pSrcA_converted.numRows ;
1321 uint32_t column = pSrcB_converted.numCols ;
1322 createq31Matrix(&pDst_converted,row,column);
1323
1324 arm_status returnValue = arm_mat_mult_opt_q31(&pSrcA_converted,
1325 &pSrcB_converted,&pDst_converted,pState_converted);
1326 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1327 PyObject* pDstOBJ=NumpyArrayFromq31Matrix(&pDst_converted);
1328
1329 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
1330
1331 Py_DECREF(theReturnOBJ);
1332 FREEMATRIX(&pSrcA_converted);
1333 FREEMATRIX(&pSrcB_converted);
1334 Py_DECREF(pDstOBJ);
1335 FREEARGUMENT(pState_converted);
1336 return(pythonResult);
1337
1338 }
1339 Py_RETURN_NONE;
1340 }
1341
1342 static PyObject *
cmsis_arm_mat_mult_fast_q31(PyObject * obj,PyObject * args)1343 cmsis_arm_mat_mult_fast_q31(PyObject *obj, PyObject *args)
1344 {
1345
1346 PyObject *pSrcA=NULL; // input
1347 arm_matrix_instance_q31 pSrcA_converted; // input
1348 PyObject *pSrcB=NULL; // input
1349 arm_matrix_instance_q31 pSrcB_converted; // input
1350 arm_matrix_instance_q31 pDst_converted;
1351
1352 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
1353 {
1354
1355 q31MatrixFromNumpy(&pSrcA_converted,pSrcA);
1356 q31MatrixFromNumpy(&pSrcB_converted,pSrcB);
1357 uint32_t row = pSrcA_converted.numRows ;
1358 uint32_t column = pSrcB_converted.numCols ;
1359 createq31Matrix(&pDst_converted,row,column);
1360
1361 arm_status returnValue = arm_mat_mult_fast_q31(&pSrcA_converted,
1362 &pSrcB_converted,&pDst_converted);
1363 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1364 PyObject* pDstOBJ=NumpyArrayFromq31Matrix(&pDst_converted);
1365
1366 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
1367
1368 Py_DECREF(theReturnOBJ);
1369 FREEMATRIX(&pSrcA_converted);
1370 FREEMATRIX(&pSrcB_converted);
1371 Py_DECREF(pDstOBJ);
1372 return(pythonResult);
1373
1374 }
1375 Py_RETURN_NONE;
1376 }
1377
1378
1379 static PyObject *
cmsis_arm_mat_sub_f32(PyObject * obj,PyObject * args)1380 cmsis_arm_mat_sub_f32(PyObject *obj, PyObject *args)
1381 {
1382
1383 PyObject *pSrcA=NULL; // input
1384 arm_matrix_instance_f32 pSrcA_converted; // input
1385 PyObject *pSrcB=NULL; // input
1386 arm_matrix_instance_f32 pSrcB_converted; // input
1387 arm_matrix_instance_f32 pDst_converted;
1388
1389 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
1390 {
1391
1392 f32MatrixFromNumpy(&pSrcA_converted,pSrcA);
1393 f32MatrixFromNumpy(&pSrcB_converted,pSrcB);
1394 uint32_t row = pSrcA_converted.numRows ;
1395 uint32_t column = pSrcB_converted.numCols ;
1396 createf32Matrix(&pDst_converted,row,column);
1397
1398 arm_status returnValue = arm_mat_sub_f32(&pSrcA_converted,
1399 &pSrcB_converted,&pDst_converted);
1400 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1401 PyObject* pDstOBJ=NumpyArrayFromf32Matrix(&pDst_converted);
1402
1403 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
1404
1405 Py_DECREF(theReturnOBJ);
1406 FREEMATRIX(&pSrcA_converted);
1407 FREEMATRIX(&pSrcB_converted);
1408 Py_DECREF(pDstOBJ);
1409 return(pythonResult);
1410
1411 }
1412 Py_RETURN_NONE;
1413 }
1414
1415 static PyObject *
cmsis_arm_mat_sub_f64(PyObject * obj,PyObject * args)1416 cmsis_arm_mat_sub_f64(PyObject *obj, PyObject *args)
1417 {
1418
1419 PyObject *pSrcA=NULL; // input
1420 arm_matrix_instance_f64 pSrcA_converted; // input
1421 PyObject *pSrcB=NULL; // input
1422 arm_matrix_instance_f64 pSrcB_converted; // input
1423 arm_matrix_instance_f64 pDst_converted;
1424
1425 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
1426 {
1427
1428 f64MatrixFromNumpy(&pSrcA_converted,pSrcA);
1429 f64MatrixFromNumpy(&pSrcB_converted,pSrcB);
1430 uint32_t row = pSrcA_converted.numRows ;
1431 uint32_t column = pSrcB_converted.numCols ;
1432 createf64Matrix(&pDst_converted,row,column);
1433
1434 arm_status returnValue = arm_mat_sub_f64(&pSrcA_converted,
1435 &pSrcB_converted,&pDst_converted);
1436 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1437 PyObject* pDstOBJ=NumpyArrayFromf64Matrix(&pDst_converted);
1438
1439 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
1440
1441 Py_DECREF(theReturnOBJ);
1442 FREEMATRIX(&pSrcA_converted);
1443 FREEMATRIX(&pSrcB_converted);
1444 Py_DECREF(pDstOBJ);
1445 return(pythonResult);
1446
1447 }
1448 Py_RETURN_NONE;
1449 }
1450
1451
1452 static PyObject *
cmsis_arm_mat_sub_q15(PyObject * obj,PyObject * args)1453 cmsis_arm_mat_sub_q15(PyObject *obj, PyObject *args)
1454 {
1455
1456 PyObject *pSrcA=NULL; // input
1457 arm_matrix_instance_q15 pSrcA_converted; // input
1458 PyObject *pSrcB=NULL; // input
1459 arm_matrix_instance_q15 pSrcB_converted; // input
1460 arm_matrix_instance_q15 pDst_converted;
1461
1462 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
1463 {
1464
1465 q15MatrixFromNumpy(&pSrcA_converted,pSrcA);
1466 q15MatrixFromNumpy(&pSrcB_converted,pSrcB);
1467 uint32_t row = pSrcA_converted.numRows ;
1468 uint32_t column = pSrcB_converted.numCols ;
1469 createq15Matrix(&pDst_converted,row,column);
1470
1471 arm_status returnValue = arm_mat_sub_q15(&pSrcA_converted,&pSrcB_converted,
1472 &pDst_converted);
1473 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1474 PyObject* pDstOBJ=NumpyArrayFromq15Matrix(&pDst_converted);
1475
1476 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
1477
1478 Py_DECREF(theReturnOBJ);
1479 FREEMATRIX(&pSrcA_converted);
1480 FREEMATRIX(&pSrcB_converted);
1481 Py_DECREF(pDstOBJ);
1482 return(pythonResult);
1483
1484 }
1485 Py_RETURN_NONE;
1486 }
1487
1488
1489 static PyObject *
cmsis_arm_mat_sub_q31(PyObject * obj,PyObject * args)1490 cmsis_arm_mat_sub_q31(PyObject *obj, PyObject *args)
1491 {
1492
1493 PyObject *pSrcA=NULL; // input
1494 arm_matrix_instance_q31 pSrcA_converted; // input
1495 PyObject *pSrcB=NULL; // input
1496 arm_matrix_instance_q31 pSrcB_converted; // input
1497 arm_matrix_instance_q31 pDst_converted;
1498
1499 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
1500 {
1501
1502 q31MatrixFromNumpy(&pSrcA_converted,pSrcA);
1503 q31MatrixFromNumpy(&pSrcB_converted,pSrcB);
1504 uint32_t row = pSrcA_converted.numRows ;
1505 uint32_t column = pSrcB_converted.numCols ;
1506 createq31Matrix(&pDst_converted,row,column);
1507
1508 arm_status returnValue = arm_mat_sub_q31(&pSrcA_converted,
1509 &pSrcB_converted,&pDst_converted);
1510 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1511 PyObject* pDstOBJ=NumpyArrayFromq31Matrix(&pDst_converted);
1512
1513 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
1514
1515 Py_DECREF(theReturnOBJ);
1516 FREEMATRIX(&pSrcA_converted);
1517 FREEMATRIX(&pSrcB_converted);
1518 Py_DECREF(pDstOBJ);
1519 return(pythonResult);
1520
1521 }
1522 Py_RETURN_NONE;
1523 }
1524
1525
1526 static PyObject *
cmsis_arm_mat_scale_f32(PyObject * obj,PyObject * args)1527 cmsis_arm_mat_scale_f32(PyObject *obj, PyObject *args)
1528 {
1529
1530 PyObject *pSrc=NULL; // input
1531 arm_matrix_instance_f32 pSrc_converted; // input
1532 float32_t scale; // input
1533 arm_matrix_instance_f32 pDst_converted;
1534
1535 if (PyArg_ParseTuple(args,"Of",&pSrc,&scale))
1536 {
1537
1538 f32MatrixFromNumpy(&pSrc_converted,pSrc);
1539 uint32_t row = pSrc_converted.numRows ;
1540 uint32_t column = pSrc_converted.numCols ;
1541 createf32Matrix(&pDst_converted,row,column);
1542
1543 arm_status returnValue = arm_mat_scale_f32(&pSrc_converted,scale,&pDst_converted);
1544 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1545 PyObject* pDstOBJ=NumpyArrayFromf32Matrix(&pDst_converted);
1546
1547 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
1548
1549 Py_DECREF(theReturnOBJ);
1550 FREEMATRIX(&pSrc_converted);
1551 Py_DECREF(pDstOBJ);
1552 return(pythonResult);
1553
1554 }
1555 Py_RETURN_NONE;
1556 }
1557
1558
1559 static PyObject *
cmsis_arm_mat_scale_q15(PyObject * obj,PyObject * args)1560 cmsis_arm_mat_scale_q15(PyObject *obj, PyObject *args)
1561 {
1562
1563 PyObject *pSrc=NULL; // input
1564 arm_matrix_instance_q15 pSrc_converted; // input
1565 q15_t scaleFract; // input
1566 int32_t shift; // input
1567 arm_matrix_instance_q15 pDst_converted;
1568
1569 if (PyArg_ParseTuple(args,"Ohi",&pSrc,&scaleFract,&shift))
1570 {
1571
1572 q15MatrixFromNumpy(&pSrc_converted,pSrc);
1573 uint32_t row = pSrc_converted.numRows ;
1574 uint32_t column = pSrc_converted.numCols ;
1575 createq15Matrix(&pDst_converted,row,column);
1576
1577 arm_status returnValue = arm_mat_scale_q15(&pSrc_converted,scaleFract,shift,&pDst_converted);
1578 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1579 PyObject* pDstOBJ=NumpyArrayFromq15Matrix(&pDst_converted);
1580
1581 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
1582
1583 Py_DECREF(theReturnOBJ);
1584 FREEMATRIX(&pSrc_converted);
1585 Py_DECREF(pDstOBJ);
1586 return(pythonResult);
1587
1588 }
1589 Py_RETURN_NONE;
1590 }
1591
1592
1593 static PyObject *
cmsis_arm_mat_scale_q31(PyObject * obj,PyObject * args)1594 cmsis_arm_mat_scale_q31(PyObject *obj, PyObject *args)
1595 {
1596
1597 PyObject *pSrc=NULL; // input
1598 arm_matrix_instance_q31 pSrc_converted; // input
1599 q31_t scaleFract; // input
1600 int32_t shift; // input
1601 arm_matrix_instance_q31 pDst_converted;
1602
1603 if (PyArg_ParseTuple(args,"Oii",&pSrc,&scaleFract,&shift))
1604 {
1605
1606 q31MatrixFromNumpy(&pSrc_converted,pSrc);
1607 uint32_t row = pSrc_converted.numRows ;
1608 uint32_t column = pSrc_converted.numCols ;
1609 createq31Matrix(&pDst_converted,row,column);
1610
1611 arm_status returnValue = arm_mat_scale_q31(&pSrc_converted,scaleFract,shift,&pDst_converted);
1612 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1613 PyObject* pDstOBJ=NumpyArrayFromq31Matrix(&pDst_converted);
1614
1615 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
1616
1617 Py_DECREF(theReturnOBJ);
1618 FREEMATRIX(&pSrc_converted);
1619 Py_DECREF(pDstOBJ);
1620 return(pythonResult);
1621
1622 }
1623 Py_RETURN_NONE;
1624 }
1625
1626 static PyObject *
cmsis_arm_mat_qr_f64(PyObject * obj,PyObject * args)1627 cmsis_arm_mat_qr_f64(PyObject *obj, PyObject *args)
1628 {
1629
1630 PyObject *src=NULL;
1631 arm_matrix_instance_f64 src_converted;
1632
1633 PyObject *pTmpaIn=NULL;
1634 float64_t *pTmpaIn_converted=NULL;
1635
1636 PyObject *pTmpbIn=NULL;
1637 float64_t *pTmpbIn_converted=NULL;
1638
1639 float64_t threshold;
1640
1641 arm_matrix_instance_f64 Q_converted;
1642 arm_matrix_instance_f64 R_converted;
1643
1644 if (PyArg_ParseTuple(args,"OdOO",&src,&threshold,&pTmpaIn,&pTmpbIn))
1645 {
1646
1647 f64MatrixFromNumpy(&src_converted,src);
1648 uint64_t column = src_converted.numCols ;
1649 uint64_t row = src_converted.numRows ;
1650
1651 GETARGUMENT(pTmpaIn,NPY_DOUBLE,double,float64_t);
1652 GETARGUMENT(pTmpbIn,NPY_DOUBLE,double,float64_t);
1653 int tmpALength=arraySizepTmpaIn ;
1654 int tmpBLength=arraySizepTmpbIn ;
1655
1656
1657 createf64Matrix(&Q_converted,row,row);
1658 createf64Matrix(&R_converted,row,column);
1659 float64_t *pTau=PyMem_Malloc(sizeof(float64_t)*column);
1660 float64_t *pTmpa=PyMem_Malloc(sizeof(float64_t)*tmpALength);
1661 float64_t *pTmpb=PyMem_Malloc(sizeof(float64_t)*tmpBLength);
1662
1663 arm_status returnValue = arm_mat_qr_f64(&src_converted,threshold,
1664 &R_converted,&Q_converted,pTau,pTmpa,pTmpb);
1665
1666 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1667 PyObject* ROBJ=NumpyArrayFromf64Matrix(&R_converted);
1668 PyObject* QOBJ=NumpyArrayFromf64Matrix(&Q_converted);
1669 FLOAT64ARRAY1(pTauOBJ,column,pTau);
1670
1671 PyObject *pythonResult = Py_BuildValue("OOOO",theReturnOBJ,ROBJ,QOBJ,pTauOBJ);
1672
1673 Py_DECREF(theReturnOBJ);
1674 Py_DECREF(ROBJ);
1675 Py_DECREF(QOBJ);
1676 Py_DECREF(pTauOBJ);
1677 FREEMATRIX(&src_converted);
1678 FREEARGUMENT(pTmpaIn_converted);
1679 FREEARGUMENT(pTmpbIn_converted);
1680
1681 PyMem_Free(pTmpa);
1682 PyMem_Free(pTmpb);
1683
1684 return(pythonResult);
1685
1686 }
1687 Py_RETURN_NONE;
1688 }
1689
1690 static PyObject *
cmsis_arm_mat_qr_f32(PyObject * obj,PyObject * args)1691 cmsis_arm_mat_qr_f32(PyObject *obj, PyObject *args)
1692 {
1693
1694 PyObject *src=NULL;
1695 arm_matrix_instance_f32 src_converted;
1696
1697 PyObject *pTmpaIn=NULL;
1698 float32_t *pTmpaIn_converted=NULL;
1699
1700 PyObject *pTmpbIn=NULL;
1701 float32_t *pTmpbIn_converted=NULL;
1702
1703 float32_t threshold;
1704
1705 arm_matrix_instance_f32 Q_converted;
1706 arm_matrix_instance_f32 R_converted;
1707
1708 if (PyArg_ParseTuple(args,"OfOO",&src,&threshold,&pTmpaIn,&pTmpbIn))
1709 {
1710
1711 f32MatrixFromNumpy(&src_converted,src);
1712 uint32_t column = src_converted.numCols ;
1713 uint32_t row = src_converted.numRows ;
1714
1715 GETARGUMENT(pTmpaIn,NPY_DOUBLE,double,float32_t);
1716 GETARGUMENT(pTmpbIn,NPY_DOUBLE,double,float32_t);
1717 int tmpALength=arraySizepTmpaIn ;
1718 int tmpBLength=arraySizepTmpbIn ;
1719
1720
1721 createf32Matrix(&Q_converted,row,row);
1722 createf32Matrix(&R_converted,row,column);
1723 float32_t *pTau=PyMem_Malloc(sizeof(float32_t)*column);
1724 float32_t *pTmpa=PyMem_Malloc(sizeof(float32_t)*tmpALength);
1725 float32_t *pTmpb=PyMem_Malloc(sizeof(float32_t)*tmpBLength);
1726
1727 arm_status returnValue = arm_mat_qr_f32(&src_converted,threshold,
1728 &R_converted,&Q_converted,pTau,pTmpa,pTmpb);
1729
1730 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1731 PyObject* ROBJ=NumpyArrayFromf32Matrix(&R_converted);
1732 PyObject* QOBJ=NumpyArrayFromf32Matrix(&Q_converted);
1733 FLOATARRAY1(pTauOBJ,column,pTau);
1734
1735 PyObject *pythonResult = Py_BuildValue("OOOO",theReturnOBJ,ROBJ,QOBJ,pTauOBJ);
1736
1737 Py_DECREF(theReturnOBJ);
1738 Py_DECREF(ROBJ);
1739 Py_DECREF(QOBJ);
1740 Py_DECREF(pTauOBJ);
1741 FREEMATRIX(&src_converted);
1742 FREEARGUMENT(pTmpaIn_converted);
1743 FREEARGUMENT(pTmpbIn_converted);
1744
1745 PyMem_Free(pTmpa);
1746 PyMem_Free(pTmpb);
1747
1748
1749 return(pythonResult);
1750
1751 }
1752 Py_RETURN_NONE;
1753 }
1754
1755 static PyObject *
cmsis_arm_householder_f64(PyObject * obj,PyObject * args)1756 cmsis_arm_householder_f64(PyObject *obj, PyObject *args)
1757 {
1758
1759 PyObject *pSrc=NULL; // input
1760 float64_t *pSrc_converted=NULL; // input
1761 uint32_t blockSize; // input
1762 float64_t pResult; // output
1763 float64_t *pDst=NULL; // output
1764 float64_t threshold;
1765
1766 if (PyArg_ParseTuple(args,"Od",&pSrc,&threshold))
1767 {
1768
1769 GETARGUMENT(pSrc,NPY_DOUBLE,double,float64_t);
1770 blockSize = arraySizepSrc ;
1771
1772 pDst=PyMem_Malloc(sizeof(float64_t)*blockSize);
1773
1774
1775 pResult=arm_householder_f64(pSrc_converted,threshold,blockSize,pDst);
1776 PyObject* pResultOBJ=Py_BuildValue("d",pResult);
1777 FLOAT64ARRAY1(pDstOBJ,blockSize,pDst);
1778
1779 PyObject *betaResult = Py_BuildValue("O",pResultOBJ);
1780 PyObject *vecResult = Py_BuildValue("O",pDstOBJ);
1781
1782 PyObject *pythonResult = Py_BuildValue("OO",betaResult,vecResult);
1783
1784 FREEARGUMENT(pSrc_converted);
1785 Py_DECREF(pResultOBJ);
1786 Py_DECREF(pDstOBJ);
1787 return(pythonResult);
1788
1789 }
1790 Py_RETURN_NONE;
1791 }
1792
1793 static PyObject *
cmsis_arm_householder_f32(PyObject * obj,PyObject * args)1794 cmsis_arm_householder_f32(PyObject *obj, PyObject *args)
1795 {
1796
1797 PyObject *pSrc=NULL; // input
1798 float32_t *pSrc_converted=NULL; // input
1799 uint32_t blockSize; // input
1800 float32_t pResult; // output
1801 float32_t *pDst=NULL; // output
1802 float32_t threshold;
1803
1804 if (PyArg_ParseTuple(args,"Of",&pSrc,&threshold))
1805 {
1806
1807 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
1808 blockSize = arraySizepSrc ;
1809
1810 pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
1811
1812
1813 pResult=arm_householder_f32(pSrc_converted,threshold,blockSize,pDst);
1814 PyObject* pResultOBJ=Py_BuildValue("f",pResult);
1815 FLOATARRAY1(pDstOBJ,blockSize,pDst);
1816
1817 PyObject *betaResult = Py_BuildValue("O",pResultOBJ);
1818 PyObject *vecResult = Py_BuildValue("O",pDstOBJ);
1819
1820 PyObject *pythonResult = Py_BuildValue("OO",betaResult,vecResult);
1821
1822 FREEARGUMENT(pSrc_converted);
1823 Py_DECREF(pResultOBJ);
1824 Py_DECREF(pDstOBJ);
1825 return(pythonResult);
1826
1827 }
1828 Py_RETURN_NONE;
1829 }
1830
1831 static PyObject *
cmsis_arm_mat_inverse_f32(PyObject * obj,PyObject * args)1832 cmsis_arm_mat_inverse_f32(PyObject *obj, PyObject *args)
1833 {
1834
1835 PyObject *src=NULL; // input
1836 arm_matrix_instance_f32 src_converted; // input
1837 arm_matrix_instance_f32 dst_converted;
1838
1839 if (PyArg_ParseTuple(args,"O",&src))
1840 {
1841
1842 f32MatrixFromNumpy(&src_converted,src);
1843 uint32_t row = src_converted.numCols ;
1844 uint32_t column = src_converted.numRows ;
1845 createf32Matrix(&dst_converted,row,column);
1846
1847 arm_status returnValue = arm_mat_inverse_f32(&src_converted,&dst_converted);
1848 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1849 PyObject* dstOBJ=NumpyArrayFromf32Matrix(&dst_converted);
1850
1851 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,dstOBJ);
1852
1853 Py_DECREF(theReturnOBJ);
1854 FREEMATRIX(&src_converted);
1855 Py_DECREF(dstOBJ);
1856 return(pythonResult);
1857
1858 }
1859 Py_RETURN_NONE;
1860 }
1861
1862
1863 static PyObject *
cmsis_arm_mat_inverse_f64(PyObject * obj,PyObject * args)1864 cmsis_arm_mat_inverse_f64(PyObject *obj, PyObject *args)
1865 {
1866
1867 PyObject *src=NULL; // input
1868 arm_matrix_instance_f64 src_converted; // input
1869 arm_matrix_instance_f64 dst_converted;
1870
1871 if (PyArg_ParseTuple(args,"O",&src))
1872 {
1873
1874 f64MatrixFromNumpy(&src_converted,src);
1875 uint32_t row = src_converted.numCols ;
1876 uint32_t column = src_converted.numRows ;
1877 createf64Matrix(&dst_converted,row,column);
1878
1879 arm_status returnValue = arm_mat_inverse_f64(&src_converted,&dst_converted);
1880 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1881 PyObject* dstOBJ=NumpyArrayFromf64Matrix(&dst_converted);
1882
1883 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,dstOBJ);
1884
1885 Py_DECREF(theReturnOBJ);
1886 FREEMATRIX(&src_converted);
1887 Py_DECREF(dstOBJ);
1888 return(pythonResult);
1889
1890 }
1891 Py_RETURN_NONE;
1892 }
1893
1894
1895 static PyObject *
cmsis_arm_mat_cholesky_f32(PyObject * obj,PyObject * args)1896 cmsis_arm_mat_cholesky_f32(PyObject *obj, PyObject *args)
1897 {
1898
1899 PyObject *src=NULL; // input
1900 arm_matrix_instance_f32 src_converted; // input
1901 arm_matrix_instance_f32 dst_converted;
1902
1903 if (PyArg_ParseTuple(args,"O",&src))
1904 {
1905
1906 f32MatrixFromNumpy(&src_converted,src);
1907 uint32_t column = src_converted.numCols ;
1908 uint32_t row = src_converted.numRows ;
1909 createf32Matrix(&dst_converted,row,column);
1910
1911 float32_t *p=dst_converted.pData;
1912 for(int r=0;r<row;r++)
1913 {
1914 for(int c =0; c < column;c++)
1915 {
1916 *p++=0.0f;
1917 }
1918 }
1919
1920 arm_status returnValue = arm_mat_cholesky_f32(&src_converted,&dst_converted);
1921 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1922 PyObject* dstOBJ=NumpyArrayFromf32Matrix(&dst_converted);
1923
1924 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,dstOBJ);
1925
1926 Py_DECREF(theReturnOBJ);
1927 FREEMATRIX(&src_converted);
1928 Py_DECREF(dstOBJ);
1929 return(pythonResult);
1930
1931 }
1932 Py_RETURN_NONE;
1933 }
1934
1935 static PyObject *
cmsis_arm_mat_cholesky_f64(PyObject * obj,PyObject * args)1936 cmsis_arm_mat_cholesky_f64(PyObject *obj, PyObject *args)
1937 {
1938
1939 PyObject *src=NULL; // input
1940 arm_matrix_instance_f64 src_converted; // input
1941 arm_matrix_instance_f64 dst_converted;
1942
1943 if (PyArg_ParseTuple(args,"O",&src))
1944 {
1945
1946 f64MatrixFromNumpy(&src_converted,src);
1947 uint32_t column = src_converted.numCols ;
1948 uint32_t row = src_converted.numRows ;
1949 createf64Matrix(&dst_converted,row,column);
1950
1951 float64_t *p=dst_converted.pData;
1952 for(int r=0;r<row;r++)
1953 {
1954 for(int c =0; c < column;c++)
1955 {
1956 *p++=0.0f;
1957 }
1958 }
1959
1960
1961 arm_status returnValue = arm_mat_cholesky_f64(&src_converted,&dst_converted);
1962 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
1963 PyObject* dstOBJ=NumpyArrayFromf64Matrix(&dst_converted);
1964
1965 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,dstOBJ);
1966
1967 Py_DECREF(theReturnOBJ);
1968 FREEMATRIX(&src_converted);
1969 Py_DECREF(dstOBJ);
1970 return(pythonResult);
1971
1972 }
1973 Py_RETURN_NONE;
1974 }
1975
1976 static PyObject *
cmsis_arm_mat_ldlt_f32(PyObject * obj,PyObject * args)1977 cmsis_arm_mat_ldlt_f32(PyObject *obj, PyObject *args)
1978 {
1979
1980 PyObject *src=NULL; // input
1981 arm_matrix_instance_f32 src_converted; // input
1982 arm_matrix_instance_f32 l_converted;
1983 arm_matrix_instance_f32 d_converted;
1984
1985 if (PyArg_ParseTuple(args,"O",&src))
1986 {
1987
1988 f32MatrixFromNumpy(&src_converted,src);
1989 uint32_t column = src_converted.numCols ;
1990 uint32_t row = src_converted.numRows ;
1991
1992 createf32Matrix(&l_converted,row,column);
1993 createf32Matrix(&d_converted,row,column);
1994
1995 uint16_t *pPerm=(uint16_t *)PyMem_Malloc(sizeof(uint16_t)*row);
1996 INT16ARRAY1(pPermOBJ,row,pPerm);
1997
1998 arm_status returnValue = arm_mat_ldlt_f32(&src_converted,&l_converted,&d_converted,pPerm);
1999 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2000
2001 PyObject* lOBJ=NumpyArrayFromf32Matrix(&l_converted);
2002 PyObject* dOBJ=NumpyArrayFromf32Matrix(&d_converted);
2003
2004
2005 PyObject *pythonResult = Py_BuildValue("OOOO",theReturnOBJ,lOBJ,dOBJ,pPermOBJ);
2006
2007 Py_DECREF(theReturnOBJ);
2008 FREEMATRIX(&src_converted);
2009 Py_DECREF(lOBJ);
2010 Py_DECREF(dOBJ);
2011 Py_DECREF(pPermOBJ);
2012
2013 return(pythonResult);
2014
2015 }
2016 Py_RETURN_NONE;
2017 }
2018
2019 static PyObject *
cmsis_arm_mat_ldlt_f64(PyObject * obj,PyObject * args)2020 cmsis_arm_mat_ldlt_f64(PyObject *obj, PyObject *args)
2021 {
2022
2023 PyObject *src=NULL; // input
2024 arm_matrix_instance_f64 src_converted; // input
2025 arm_matrix_instance_f64 l_converted;
2026 arm_matrix_instance_f64 d_converted;
2027
2028 if (PyArg_ParseTuple(args,"O",&src))
2029 {
2030
2031 f64MatrixFromNumpy(&src_converted,src);
2032 uint32_t column = src_converted.numCols ;
2033 uint32_t row = src_converted.numRows ;
2034
2035 createf64Matrix(&l_converted,row,column);
2036 createf64Matrix(&d_converted,row,column);
2037
2038 uint16_t *pPerm=(uint16_t *)PyMem_Malloc(sizeof(uint16_t)*row);
2039 INT16ARRAY1(pPermOBJ,row,pPerm);
2040
2041 arm_status returnValue = arm_mat_ldlt_f64(&src_converted,&l_converted,&d_converted,pPerm);
2042 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2043
2044 PyObject* lOBJ=NumpyArrayFromf64Matrix(&l_converted);
2045 PyObject* dOBJ=NumpyArrayFromf64Matrix(&d_converted);
2046
2047
2048 PyObject *pythonResult = Py_BuildValue("OOOO",theReturnOBJ,lOBJ,dOBJ,pPermOBJ);
2049
2050 Py_DECREF(theReturnOBJ);
2051 FREEMATRIX(&src_converted);
2052 Py_DECREF(lOBJ);
2053 Py_DECREF(dOBJ);
2054 Py_DECREF(pPermOBJ);
2055
2056 return(pythonResult);
2057
2058 }
2059 Py_RETURN_NONE;
2060 }
2061
2062 static PyObject *
cmsis_arm_mat_solve_lower_triangular_f32(PyObject * obj,PyObject * args)2063 cmsis_arm_mat_solve_lower_triangular_f32(PyObject *obj, PyObject *args)
2064 {
2065
2066 PyObject *pSrcA=NULL; // input
2067 arm_matrix_instance_f32 pSrcA_converted; // input
2068 PyObject *pSrcB=NULL; // input
2069 arm_matrix_instance_f32 pSrcB_converted; // input
2070 arm_matrix_instance_f32 pDst_converted;
2071
2072 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
2073 {
2074
2075 f32MatrixFromNumpy(&pSrcA_converted,pSrcA);
2076 f32MatrixFromNumpy(&pSrcB_converted,pSrcB);
2077 uint32_t column = pSrcB_converted.numCols ;
2078 uint32_t row = pSrcA_converted.numRows ;
2079
2080 createf32Matrix(&pDst_converted,row,column);
2081
2082 arm_status returnValue = arm_mat_solve_lower_triangular_f32(&pSrcA_converted,
2083 &pSrcB_converted,&pDst_converted);
2084 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2085 PyObject* pDstOBJ=NumpyArrayFromf32Matrix(&pDst_converted);
2086
2087 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
2088
2089 Py_DECREF(theReturnOBJ);
2090 FREEMATRIX(&pSrcA_converted);
2091 FREEMATRIX(&pSrcB_converted);
2092 Py_DECREF(pDstOBJ);
2093 return(pythonResult);
2094
2095 }
2096 Py_RETURN_NONE;
2097 }
2098
2099 static PyObject *
cmsis_arm_mat_solve_lower_triangular_f64(PyObject * obj,PyObject * args)2100 cmsis_arm_mat_solve_lower_triangular_f64(PyObject *obj, PyObject *args)
2101 {
2102
2103 PyObject *pSrcA=NULL; // input
2104 arm_matrix_instance_f64 pSrcA_converted; // input
2105 PyObject *pSrcB=NULL; // input
2106 arm_matrix_instance_f64 pSrcB_converted; // input
2107 arm_matrix_instance_f64 pDst_converted;
2108
2109 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
2110 {
2111
2112 f64MatrixFromNumpy(&pSrcA_converted,pSrcA);
2113 f64MatrixFromNumpy(&pSrcB_converted,pSrcB);
2114 uint32_t column = pSrcB_converted.numCols ;
2115 uint32_t row = pSrcA_converted.numRows ;
2116
2117 createf64Matrix(&pDst_converted,row,column);
2118
2119 arm_status returnValue = arm_mat_solve_lower_triangular_f64(&pSrcA_converted,
2120 &pSrcB_converted,&pDst_converted);
2121 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2122 PyObject* pDstOBJ=NumpyArrayFromf64Matrix(&pDst_converted);
2123
2124 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
2125
2126 Py_DECREF(theReturnOBJ);
2127 FREEMATRIX(&pSrcA_converted);
2128 FREEMATRIX(&pSrcB_converted);
2129 Py_DECREF(pDstOBJ);
2130 return(pythonResult);
2131
2132 }
2133 Py_RETURN_NONE;
2134 }
2135
2136 static PyObject *
cmsis_arm_mat_solve_upper_triangular_f32(PyObject * obj,PyObject * args)2137 cmsis_arm_mat_solve_upper_triangular_f32(PyObject *obj, PyObject *args)
2138 {
2139
2140 PyObject *pSrcA=NULL; // input
2141 arm_matrix_instance_f32 pSrcA_converted; // input
2142 PyObject *pSrcB=NULL; // input
2143 arm_matrix_instance_f32 pSrcB_converted; // input
2144 arm_matrix_instance_f32 pDst_converted;
2145
2146 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
2147 {
2148
2149 f32MatrixFromNumpy(&pSrcA_converted,pSrcA);
2150 f32MatrixFromNumpy(&pSrcB_converted,pSrcB);
2151 uint32_t column = pSrcB_converted.numCols ;
2152 uint32_t row = pSrcA_converted.numRows ;
2153 createf32Matrix(&pDst_converted,row,column);
2154
2155 arm_status returnValue = arm_mat_solve_upper_triangular_f32(&pSrcA_converted,
2156 &pSrcB_converted,&pDst_converted);
2157 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2158 PyObject* pDstOBJ=NumpyArrayFromf32Matrix(&pDst_converted);
2159
2160 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
2161
2162 Py_DECREF(theReturnOBJ);
2163 FREEMATRIX(&pSrcA_converted);
2164 FREEMATRIX(&pSrcB_converted);
2165 Py_DECREF(pDstOBJ);
2166 return(pythonResult);
2167
2168 }
2169 Py_RETURN_NONE;
2170 }
2171
2172 static PyObject *
cmsis_arm_mat_solve_upper_triangular_f64(PyObject * obj,PyObject * args)2173 cmsis_arm_mat_solve_upper_triangular_f64(PyObject *obj, PyObject *args)
2174 {
2175
2176 PyObject *pSrcA=NULL; // input
2177 arm_matrix_instance_f64 pSrcA_converted; // input
2178 PyObject *pSrcB=NULL; // input
2179 arm_matrix_instance_f64 pSrcB_converted; // input
2180 arm_matrix_instance_f64 pDst_converted;
2181
2182 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
2183 {
2184
2185 f64MatrixFromNumpy(&pSrcA_converted,pSrcA);
2186 f64MatrixFromNumpy(&pSrcB_converted,pSrcB);
2187 uint32_t column = pSrcB_converted.numCols ;
2188 uint32_t row = pSrcA_converted.numRows ;
2189 createf64Matrix(&pDst_converted,row,column);
2190
2191 arm_status returnValue = arm_mat_solve_upper_triangular_f64(&pSrcA_converted,
2192 &pSrcB_converted,&pDst_converted);
2193 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
2194 PyObject* pDstOBJ=NumpyArrayFromf64Matrix(&pDst_converted);
2195
2196 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,pDstOBJ);
2197
2198 Py_DECREF(theReturnOBJ);
2199 FREEMATRIX(&pSrcA_converted);
2200 FREEMATRIX(&pSrcB_converted);
2201 Py_DECREF(pDstOBJ);
2202 return(pythonResult);
2203
2204 }
2205 Py_RETURN_NONE;
2206 }
2207
2208
2209 static PyMethodDef CMSISDSPMethods[] = {
2210
2211 {"arm_mat_add_f32", cmsis_arm_mat_add_f32, METH_VARARGS,""},
2212 {"arm_mat_add_q15", cmsis_arm_mat_add_q15, METH_VARARGS,""},
2213 {"arm_mat_add_q31", cmsis_arm_mat_add_q31, METH_VARARGS,""},
2214 {"arm_mat_cmplx_mult_f32", cmsis_arm_mat_cmplx_mult_f32, METH_VARARGS,""},
2215 {"arm_mat_cmplx_mult_q15", cmsis_arm_mat_cmplx_mult_q15, METH_VARARGS,""},
2216 {"arm_mat_cmplx_mult_q31", cmsis_arm_mat_cmplx_mult_q31, METH_VARARGS,""},
2217 {"arm_mat_trans_f32", cmsis_arm_mat_trans_f32, METH_VARARGS,""},
2218 {"arm_mat_trans_f64", cmsis_arm_mat_trans_f64, METH_VARARGS,""},
2219 {"arm_mat_trans_q15", cmsis_arm_mat_trans_q15, METH_VARARGS,""},
2220 {"arm_mat_trans_q31", cmsis_arm_mat_trans_q31, METH_VARARGS,""},
2221 {"arm_mat_trans_q7", cmsis_arm_mat_trans_q7, METH_VARARGS,""},
2222
2223
2224 {"arm_mat_vec_mult_f32", cmsis_arm_mat_vec_mult_f32, METH_VARARGS,""},
2225 {"arm_mat_vec_mult_q31", cmsis_arm_mat_vec_mult_q31, METH_VARARGS,""},
2226 {"arm_mat_vec_mult_q15", cmsis_arm_mat_vec_mult_q15, METH_VARARGS,""},
2227 {"arm_mat_vec_mult_q7", cmsis_arm_mat_vec_mult_q7, METH_VARARGS,""},
2228
2229 {"arm_mat_mult_f32", cmsis_arm_mat_mult_f32, METH_VARARGS,""},
2230 {"arm_mat_mult_f64", cmsis_arm_mat_mult_f32, METH_VARARGS,""},
2231 {"arm_mat_mult_q7", cmsis_arm_mat_mult_q7, METH_VARARGS,""},
2232 {"arm_mat_mult_q15", cmsis_arm_mat_mult_q15, METH_VARARGS,""},
2233 {"arm_mat_mult_fast_q15", cmsis_arm_mat_mult_fast_q15, METH_VARARGS,""},
2234 {"arm_mat_mult_q31", cmsis_arm_mat_mult_q31, METH_VARARGS,""},
2235 {"arm_mat_mult_opt_q31", cmsis_arm_mat_mult_opt_q31, METH_VARARGS,""},
2236 {"arm_mat_mult_fast_q31", cmsis_arm_mat_mult_fast_q31, METH_VARARGS,""},
2237 {"arm_mat_sub_f32", cmsis_arm_mat_sub_f32, METH_VARARGS,""},
2238 {"arm_mat_sub_f64", cmsis_arm_mat_sub_f64, METH_VARARGS,""},
2239 {"arm_mat_sub_q15", cmsis_arm_mat_sub_q15, METH_VARARGS,""},
2240 {"arm_mat_sub_q31", cmsis_arm_mat_sub_q31, METH_VARARGS,""},
2241 {"arm_mat_scale_f32", cmsis_arm_mat_scale_f32, METH_VARARGS,""},
2242 {"arm_mat_scale_q15", cmsis_arm_mat_scale_q15, METH_VARARGS,""},
2243 {"arm_mat_scale_q31", cmsis_arm_mat_scale_q31, METH_VARARGS,""},
2244 {"arm_mat_inverse_f32", cmsis_arm_mat_inverse_f32, METH_VARARGS,""},
2245 {"arm_mat_inverse_f64", cmsis_arm_mat_inverse_f64, METH_VARARGS,""},
2246 {"arm_mat_cmplx_trans_f32", cmsis_arm_mat_cmplx_trans_f32, METH_VARARGS,""},
2247 {"arm_mat_cmplx_trans_q31", cmsis_arm_mat_cmplx_trans_q31, METH_VARARGS,""},
2248 {"arm_mat_cmplx_trans_q15", cmsis_arm_mat_cmplx_trans_q15, METH_VARARGS,""},
2249 {"arm_mat_cholesky_f32", cmsis_arm_mat_cholesky_f32, METH_VARARGS,""},
2250 {"arm_mat_cholesky_f64", cmsis_arm_mat_cholesky_f64, METH_VARARGS,""},
2251 {"arm_mat_ldlt_f32", cmsis_arm_mat_ldlt_f32, METH_VARARGS,""},
2252 {"arm_mat_ldlt_f64", cmsis_arm_mat_ldlt_f64, METH_VARARGS,""},
2253 {"arm_mat_solve_lower_triangular_f32", cmsis_arm_mat_solve_lower_triangular_f32, METH_VARARGS,""},
2254 {"arm_mat_solve_lower_triangular_f64", cmsis_arm_mat_solve_lower_triangular_f64, METH_VARARGS,""},
2255 {"arm_mat_solve_upper_triangular_f32", cmsis_arm_mat_solve_upper_triangular_f32, METH_VARARGS,""},
2256 {"arm_mat_solve_upper_triangular_f64", cmsis_arm_mat_solve_upper_triangular_f64, METH_VARARGS,""},
2257 {"arm_householder_f32", cmsis_arm_householder_f32, METH_VARARGS,""},
2258 {"arm_householder_f64", cmsis_arm_householder_f64, METH_VARARGS,""},
2259 {"arm_mat_qr_f32", cmsis_arm_mat_qr_f32, METH_VARARGS,""},
2260 {"arm_mat_qr_f64", cmsis_arm_mat_qr_f64, METH_VARARGS,""},
2261
2262 {"error_out", (PyCFunction)error_out, METH_NOARGS, NULL},
2263
2264 {NULL, NULL, 0, NULL} /* Sentinel */
2265 };
2266
2267 #ifdef IS_PY3K
cmsisdsp_traverse(PyObject * m,visitproc visit,void * arg)2268 static int cmsisdsp_traverse(PyObject *m, visitproc visit, void *arg) {
2269 Py_VISIT(GETSTATE(m)->error);
2270 return 0;
2271 }
2272
cmsisdsp_clear(PyObject * m)2273 static int cmsisdsp_clear(PyObject *m) {
2274 Py_CLEAR(GETSTATE(m)->error);
2275 return 0;
2276 }
2277
2278
2279 static struct PyModuleDef moduledef = {
2280 PyModuleDef_HEAD_INIT,
2281 MODNAME,
2282 NULL,
2283 sizeof(struct module_state),
2284 CMSISDSPMethods,
2285 NULL,
2286 cmsisdsp_traverse,
2287 cmsisdsp_clear,
2288 NULL
2289 };
2290
2291 #define INITERROR return NULL
2292
2293 PyMODINIT_FUNC
CAT(PyInit_,MODINITNAME)2294 CAT(PyInit_,MODINITNAME)(void)
2295
2296
2297 #else
2298 #define INITERROR return
2299
2300 void CAT(init,MODINITNAME)(void)
2301 #endif
2302 {
2303 import_array();
2304
2305 #ifdef IS_PY3K
2306 PyObject *module = PyModule_Create(&moduledef);
2307 #else
2308 PyObject *module = Py_InitModule(MODNAME, CMSISDSPMethods);
2309 #endif
2310
2311 if (module == NULL)
2312 INITERROR;
2313 struct module_state *st = GETSTATE(module);
2314
2315 st->error = PyErr_NewException(MODNAME".Error", NULL, NULL);
2316 if (st->error == NULL) {
2317 Py_DECREF(module);
2318 INITERROR;
2319 }
2320
2321
2322 typeRegistration(module);
2323
2324 #ifdef IS_PY3K
2325 return module;
2326 #endif
2327 }
