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_basic"
30 #define MODINITNAME cmsisdsp_basic
31
32 #include "cmsisdsp_module.h"
33
34
35 NUMPYVECTORFROMBUFFER(f32,float32_t,NPY_FLOAT);
36
37
typeRegistration(PyObject * module)38 void typeRegistration(PyObject *module) {
39
40
41 }
42
43
44 static PyObject *
cmsis_arm_recip_q31(PyObject * obj,PyObject * args)45 cmsis_arm_recip_q31(PyObject *obj, PyObject *args)
46 {
47
48 q31_t in; // input
49 q31_t dst; // output
50 PyObject *pRecipTable=NULL; // input
51 q31_t *pRecipTable_converted=NULL; // input
52
53 if (PyArg_ParseTuple(args,"iO",&in,&pRecipTable))
54 {
55
56 GETARGUMENT(pRecipTable,NPY_INT32,int32_t,int32_t);
57
58
59 uint32_t returnValue = arm_recip_q31(in,&dst,pRecipTable_converted);
60 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
61 PyObject* dstOBJ=Py_BuildValue("i",dst);
62
63 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,dstOBJ);
64
65 Py_DECREF(theReturnOBJ);
66 Py_DECREF(dstOBJ);
67 FREEARGUMENT(pRecipTable_converted);
68 return(pythonResult);
69
70 }
71 return(NULL);
72 }
73
74
75 static PyObject *
cmsis_arm_recip_q15(PyObject * obj,PyObject * args)76 cmsis_arm_recip_q15(PyObject *obj, PyObject *args)
77 {
78
79 q15_t in; // input
80 q15_t dst; // output
81 PyObject *pRecipTable=NULL; // input
82 q15_t *pRecipTable_converted=NULL; // input
83
84 if (PyArg_ParseTuple(args,"hO",&in,&pRecipTable))
85 {
86
87 GETARGUMENT(pRecipTable,NPY_INT16,int16_t,int16_t);
88
89
90 uint32_t returnValue = arm_recip_q15(in,&dst,pRecipTable_converted);
91 PyObject* theReturnOBJ=Py_BuildValue("i",returnValue);
92 PyObject* dstOBJ=Py_BuildValue("h",dst);
93
94 PyObject *pythonResult = Py_BuildValue("OO",theReturnOBJ,dstOBJ);
95
96 Py_DECREF(theReturnOBJ);
97 Py_DECREF(dstOBJ);
98 FREEARGUMENT(pRecipTable_converted);
99 return(pythonResult);
100
101 }
102 return(NULL);
103 }
104
105
106 static PyObject *
cmsis_arm_mult_q7(PyObject * obj,PyObject * args)107 cmsis_arm_mult_q7(PyObject *obj, PyObject *args)
108 {
109
110 PyObject *pSrcA=NULL; // input
111 q7_t *pSrcA_converted=NULL; // input
112 PyObject *pSrcB=NULL; // input
113 q7_t *pSrcB_converted=NULL; // input
114 q7_t *pDst=NULL; // output
115 uint32_t blockSize; // input
116
117 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
118 {
119
120 GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
121 GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
122 blockSize = arraySizepSrcA ;
123
124 pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
125
126
127 arm_mult_q7(pSrcA_converted,pSrcB_converted,pDst,blockSize);
128 INT8ARRAY1(pDstOBJ,blockSize,pDst);
129
130 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
131
132 FREEARGUMENT(pSrcA_converted);
133 FREEARGUMENT(pSrcB_converted);
134 Py_DECREF(pDstOBJ);
135 return(pythonResult);
136
137 }
138 return(NULL);
139 }
140
141
142 static PyObject *
cmsis_arm_mult_q15(PyObject * obj,PyObject * args)143 cmsis_arm_mult_q15(PyObject *obj, PyObject *args)
144 {
145
146 PyObject *pSrcA=NULL; // input
147 q15_t *pSrcA_converted=NULL; // input
148 PyObject *pSrcB=NULL; // input
149 q15_t *pSrcB_converted=NULL; // input
150 q15_t *pDst=NULL; // output
151 uint32_t blockSize; // input
152
153 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
154 {
155
156 GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
157 GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
158 blockSize = arraySizepSrcA ;
159
160 pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
161
162
163 arm_mult_q15(pSrcA_converted,pSrcB_converted,pDst,blockSize);
164 INT16ARRAY1(pDstOBJ,blockSize,pDst);
165
166 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
167
168 FREEARGUMENT(pSrcA_converted);
169 FREEARGUMENT(pSrcB_converted);
170 Py_DECREF(pDstOBJ);
171 return(pythonResult);
172
173 }
174 return(NULL);
175 }
176
177
178 static PyObject *
cmsis_arm_mult_q31(PyObject * obj,PyObject * args)179 cmsis_arm_mult_q31(PyObject *obj, PyObject *args)
180 {
181
182 PyObject *pSrcA=NULL; // input
183 q31_t *pSrcA_converted=NULL; // input
184 PyObject *pSrcB=NULL; // input
185 q31_t *pSrcB_converted=NULL; // input
186 q31_t *pDst=NULL; // output
187 uint32_t blockSize; // input
188
189 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
190 {
191
192 GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
193 GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
194 blockSize = arraySizepSrcA ;
195
196 pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
197
198
199 arm_mult_q31(pSrcA_converted,pSrcB_converted,pDst,blockSize);
200 INT32ARRAY1(pDstOBJ,blockSize,pDst);
201
202 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
203
204 FREEARGUMENT(pSrcA_converted);
205 FREEARGUMENT(pSrcB_converted);
206 Py_DECREF(pDstOBJ);
207 return(pythonResult);
208
209 }
210 return(NULL);
211 }
212
213
214 static PyObject *
cmsis_arm_mult_f32(PyObject * obj,PyObject * args)215 cmsis_arm_mult_f32(PyObject *obj, PyObject *args)
216 {
217
218 PyObject *pSrcA=NULL; // input
219 float32_t *pSrcA_converted=NULL; // input
220 PyObject *pSrcB=NULL; // input
221 float32_t *pSrcB_converted=NULL; // input
222 float32_t *pDst=NULL; // output
223 uint32_t blockSize; // input
224
225 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
226 {
227
228 GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
229 GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
230 blockSize = arraySizepSrcA ;
231
232 pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
233
234
235 arm_mult_f32(pSrcA_converted,pSrcB_converted,pDst,blockSize);
236 FLOATARRAY1(pDstOBJ,blockSize,pDst);
237
238 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
239
240 FREEARGUMENT(pSrcA_converted);
241 FREEARGUMENT(pSrcB_converted);
242 Py_DECREF(pDstOBJ);
243 return(pythonResult);
244
245 }
246 return(NULL);
247 }
248
249 static PyObject *
cmsis_arm_mult_f64(PyObject * obj,PyObject * args)250 cmsis_arm_mult_f64(PyObject *obj, PyObject *args)
251 {
252
253 PyObject *pSrcA=NULL; // input
254 float64_t *pSrcA_converted=NULL; // input
255 PyObject *pSrcB=NULL; // input
256 float64_t *pSrcB_converted=NULL; // input
257 float64_t *pDst=NULL; // output
258 uint32_t blockSize; // input
259
260 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
261 {
262
263 GETARGUMENT(pSrcA,NPY_DOUBLE,double,float64_t);
264 GETARGUMENT(pSrcB,NPY_DOUBLE,double,float64_t);
265 blockSize = arraySizepSrcA ;
266
267 pDst=PyMem_Malloc(sizeof(float64_t)*blockSize);
268
269
270 arm_mult_f64(pSrcA_converted,pSrcB_converted,pDst,blockSize);
271 FLOAT64ARRAY1(pDstOBJ,blockSize,pDst);
272
273 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
274
275 FREEARGUMENT(pSrcA_converted);
276 FREEARGUMENT(pSrcB_converted);
277 Py_DECREF(pDstOBJ);
278 return(pythonResult);
279
280 }
281 return(NULL);
282 }
283
284
285
286 static PyObject *
cmsis_arm_add_f32(PyObject * obj,PyObject * args)287 cmsis_arm_add_f32(PyObject *obj, PyObject *args)
288 {
289
290 PyObject *pSrcA=NULL; // input
291 float32_t *pSrcA_converted=NULL; // input
292 PyObject *pSrcB=NULL; // input
293 float32_t *pSrcB_converted=NULL; // input
294 float32_t *pDst=NULL; // output
295 uint32_t blockSize; // input
296
297 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
298 {
299
300 GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
301 GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
302 blockSize = arraySizepSrcA ;
303
304 pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
305
306
307 arm_add_f32(pSrcA_converted,pSrcB_converted,pDst,blockSize);
308 FLOATARRAY1(pDstOBJ,blockSize,pDst);
309
310 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
311
312 FREEARGUMENT(pSrcA_converted);
313 FREEARGUMENT(pSrcB_converted);
314 Py_DECREF(pDstOBJ);
315 return(pythonResult);
316
317 }
318 return(NULL);
319 }
320
321 static PyObject *
cmsis_arm_add_f64(PyObject * obj,PyObject * args)322 cmsis_arm_add_f64(PyObject *obj, PyObject *args)
323 {
324
325 PyObject *pSrcA=NULL; // input
326 float64_t *pSrcA_converted=NULL; // input
327 PyObject *pSrcB=NULL; // input
328 float64_t *pSrcB_converted=NULL; // input
329 float64_t *pDst=NULL; // output
330 uint32_t blockSize; // input
331
332 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
333 {
334
335 GETARGUMENT(pSrcA,NPY_DOUBLE,double,float64_t);
336 GETARGUMENT(pSrcB,NPY_DOUBLE,double,float64_t);
337 blockSize = arraySizepSrcA ;
338
339 pDst=PyMem_Malloc(sizeof(float64_t)*blockSize);
340
341
342 arm_add_f64(pSrcA_converted,pSrcB_converted,pDst,blockSize);
343 FLOAT64ARRAY1(pDstOBJ,blockSize,pDst);
344
345 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
346
347 FREEARGUMENT(pSrcA_converted);
348 FREEARGUMENT(pSrcB_converted);
349 Py_DECREF(pDstOBJ);
350 return(pythonResult);
351
352 }
353 return(NULL);
354 }
355
356 /*
357
358 For the arm_(and|xor|or)_u(32|16|8)
359
360 */
361
362 #define U_UN_OP(OP,TYP,EXT,NPYTYPE) \
363 static PyObject * \
364 cmsis_arm_##OP##_##EXT(PyObject *obj, PyObject *args) \
365 { \
366 \
367 PyObject *pSrcA=NULL; \
368 TYP *pSrcA_converted=NULL; \
369 TYP *pDst=NULL; \
370 uint32_t blockSize; \
371 \
372 if (PyArg_ParseTuple(args,"O",&pSrcA)) \
373 { \
374 \
375 GETARGUMENT(pSrcA,NPYTYPE,TYP,TYP); \
376 blockSize = arraySizepSrcA ; \
377 \
378 pDst=PyMem_Malloc(sizeof(TYP)*blockSize); \
379 \
380 \
381 arm_##OP##_##EXT(pSrcA_converted,pDst,blockSize); \
382 TYP_ARRAY1(pDstOBJ,blockSize,pDst,NPYTYPE); \
383 \
384 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);\
385 \
386 FREEARGUMENT(pSrcA_converted); \
387 Py_DECREF(pDstOBJ); \
388 return(pythonResult); \
389 \
390 } \
391 return(NULL); \
392 }
393
394 #define U_BIN_OP(OP,TYP,EXT,NPYTYPE) \
395 static PyObject * \
396 cmsis_arm_##OP##_##EXT(PyObject *obj, PyObject *args) \
397 { \
398 \
399 PyObject *pSrcA=NULL; \
400 TYP *pSrcA_converted=NULL; \
401 PyObject *pSrcB=NULL; \
402 TYP *pSrcB_converted=NULL; \
403 TYP *pDst=NULL; \
404 uint32_t blockSize; \
405 \
406 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB)) \
407 { \
408 \
409 GETARGUMENT(pSrcA,NPYTYPE,TYP,TYP); \
410 GETARGUMENT(pSrcB,NPYTYPE,TYP,TYP); \
411 blockSize = arraySizepSrcA ; \
412 \
413 pDst=PyMem_Malloc(sizeof(TYP)*blockSize); \
414 \
415 \
416 arm_##OP##_##EXT(pSrcA_converted,pSrcB_converted,pDst,blockSize);\
417 TYP_ARRAY1(pDstOBJ,blockSize,pDst,NPYTYPE); \
418 \
419 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ); \
420 \
421 FREEARGUMENT(pSrcA_converted); \
422 FREEARGUMENT(pSrcB_converted); \
423 Py_DECREF(pDstOBJ); \
424 return(pythonResult); \
425 \
426 } \
427 return(NULL); \
428 }
429
430 U_BIN_OP(and,uint32_t,u32,NPY_UINT32);
431 U_BIN_OP(and,uint16_t,u16,NPY_UINT16);
432 U_BIN_OP(and,uint8_t,u8,NPY_UINT8);
433
434 U_BIN_OP(or,uint32_t,u32,NPY_UINT32);
435 U_BIN_OP(or,uint16_t,u16,NPY_UINT16);
436 U_BIN_OP(or,uint8_t,u8,NPY_UINT8);
437
438 U_BIN_OP(xor,uint32_t,u32,NPY_UINT32);
439 U_BIN_OP(xor,uint16_t,u16,NPY_UINT16);
440 U_BIN_OP(xor,uint8_t,u8,NPY_UINT8);
441
442 U_UN_OP(not,uint32_t,u32,NPY_UINT32);
443 U_UN_OP(not,uint16_t,u16,NPY_UINT16);
444 U_UN_OP(not,uint8_t,u8,NPY_UINT8);
445
446 static PyObject *
cmsis_arm_add_q7(PyObject * obj,PyObject * args)447 cmsis_arm_add_q7(PyObject *obj, PyObject *args)
448 {
449
450 PyObject *pSrcA=NULL; // input
451 q7_t *pSrcA_converted=NULL; // input
452 PyObject *pSrcB=NULL; // input
453 q7_t *pSrcB_converted=NULL; // input
454 q7_t *pDst=NULL; // output
455 uint32_t blockSize; // input
456
457 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
458 {
459
460 GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
461 GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
462 blockSize = arraySizepSrcA ;
463
464 pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
465
466
467 arm_add_q7(pSrcA_converted,pSrcB_converted,pDst,blockSize);
468 INT8ARRAY1(pDstOBJ,blockSize,pDst);
469
470 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
471
472 FREEARGUMENT(pSrcA_converted);
473 FREEARGUMENT(pSrcB_converted);
474 Py_DECREF(pDstOBJ);
475 return(pythonResult);
476
477 }
478 return(NULL);
479 }
480
481
482 static PyObject *
cmsis_arm_add_q15(PyObject * obj,PyObject * args)483 cmsis_arm_add_q15(PyObject *obj, PyObject *args)
484 {
485
486 PyObject *pSrcA=NULL; // input
487 q15_t *pSrcA_converted=NULL; // input
488 PyObject *pSrcB=NULL; // input
489 q15_t *pSrcB_converted=NULL; // input
490 q15_t *pDst=NULL; // output
491 uint32_t blockSize; // input
492
493 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
494 {
495
496 GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
497 GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
498 blockSize = arraySizepSrcA ;
499
500 pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
501
502
503 arm_add_q15(pSrcA_converted,pSrcB_converted,pDst,blockSize);
504 INT16ARRAY1(pDstOBJ,blockSize,pDst);
505
506 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
507
508 FREEARGUMENT(pSrcA_converted);
509 FREEARGUMENT(pSrcB_converted);
510 Py_DECREF(pDstOBJ);
511 return(pythonResult);
512
513 }
514 return(NULL);
515 }
516
517
518 static PyObject *
cmsis_arm_add_q31(PyObject * obj,PyObject * args)519 cmsis_arm_add_q31(PyObject *obj, PyObject *args)
520 {
521
522 PyObject *pSrcA=NULL; // input
523 q31_t *pSrcA_converted=NULL; // input
524 PyObject *pSrcB=NULL; // input
525 q31_t *pSrcB_converted=NULL; // input
526 q31_t *pDst=NULL; // output
527 uint32_t blockSize; // input
528
529 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
530 {
531
532 GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
533 GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
534 blockSize = arraySizepSrcA ;
535
536 pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
537
538
539 arm_add_q31(pSrcA_converted,pSrcB_converted,pDst,blockSize);
540 INT32ARRAY1(pDstOBJ,blockSize,pDst);
541
542 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
543
544 FREEARGUMENT(pSrcA_converted);
545 FREEARGUMENT(pSrcB_converted);
546 Py_DECREF(pDstOBJ);
547 return(pythonResult);
548
549 }
550 return(NULL);
551 }
552
553
554 static PyObject *
cmsis_arm_sub_f32(PyObject * obj,PyObject * args)555 cmsis_arm_sub_f32(PyObject *obj, PyObject *args)
556 {
557
558 PyObject *pSrcA=NULL; // input
559 float32_t *pSrcA_converted=NULL; // input
560 PyObject *pSrcB=NULL; // input
561 float32_t *pSrcB_converted=NULL; // input
562 float32_t *pDst=NULL; // output
563 uint32_t blockSize; // input
564
565 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
566 {
567
568 GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
569 GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
570 blockSize = arraySizepSrcA ;
571
572 pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
573
574
575 arm_sub_f32(pSrcA_converted,pSrcB_converted,pDst,blockSize);
576 FLOATARRAY1(pDstOBJ,blockSize,pDst);
577
578 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
579
580 FREEARGUMENT(pSrcA_converted);
581 FREEARGUMENT(pSrcB_converted);
582 Py_DECREF(pDstOBJ);
583 return(pythonResult);
584
585 }
586 return(NULL);
587 }
588
589 static PyObject *
cmsis_arm_sub_f64(PyObject * obj,PyObject * args)590 cmsis_arm_sub_f64(PyObject *obj, PyObject *args)
591 {
592
593 PyObject *pSrcA=NULL; // input
594 float64_t *pSrcA_converted=NULL; // input
595 PyObject *pSrcB=NULL; // input
596 float64_t *pSrcB_converted=NULL; // input
597 float64_t *pDst=NULL; // output
598 uint32_t blockSize; // input
599
600 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
601 {
602
603 GETARGUMENT(pSrcA,NPY_DOUBLE,double,float64_t);
604 GETARGUMENT(pSrcB,NPY_DOUBLE,double,float64_t);
605 blockSize = arraySizepSrcA ;
606
607 pDst=PyMem_Malloc(sizeof(float64_t)*blockSize);
608
609
610 arm_sub_f64(pSrcA_converted,pSrcB_converted,pDst,blockSize);
611 FLOAT64ARRAY1(pDstOBJ,blockSize,pDst);
612
613 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
614
615 FREEARGUMENT(pSrcA_converted);
616 FREEARGUMENT(pSrcB_converted);
617 Py_DECREF(pDstOBJ);
618 return(pythonResult);
619
620 }
621 return(NULL);
622 }
623
624
625 static PyObject *
cmsis_arm_sub_q7(PyObject * obj,PyObject * args)626 cmsis_arm_sub_q7(PyObject *obj, PyObject *args)
627 {
628
629 PyObject *pSrcA=NULL; // input
630 q7_t *pSrcA_converted=NULL; // input
631 PyObject *pSrcB=NULL; // input
632 q7_t *pSrcB_converted=NULL; // input
633 q7_t *pDst=NULL; // output
634 uint32_t blockSize; // input
635
636 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
637 {
638
639 GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
640 GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
641 blockSize = arraySizepSrcA ;
642
643 pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
644
645
646 arm_sub_q7(pSrcA_converted,pSrcB_converted,pDst,blockSize);
647 INT8ARRAY1(pDstOBJ,blockSize,pDst);
648
649 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
650
651 FREEARGUMENT(pSrcA_converted);
652 FREEARGUMENT(pSrcB_converted);
653 Py_DECREF(pDstOBJ);
654 return(pythonResult);
655
656 }
657 return(NULL);
658 }
659
660
661 static PyObject *
cmsis_arm_sub_q15(PyObject * obj,PyObject * args)662 cmsis_arm_sub_q15(PyObject *obj, PyObject *args)
663 {
664
665 PyObject *pSrcA=NULL; // input
666 q15_t *pSrcA_converted=NULL; // input
667 PyObject *pSrcB=NULL; // input
668 q15_t *pSrcB_converted=NULL; // input
669 q15_t *pDst=NULL; // output
670 uint32_t blockSize; // input
671
672 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
673 {
674
675 GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
676 GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
677 blockSize = arraySizepSrcA ;
678
679 pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
680
681
682 arm_sub_q15(pSrcA_converted,pSrcB_converted,pDst,blockSize);
683 INT16ARRAY1(pDstOBJ,blockSize,pDst);
684
685 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
686
687 FREEARGUMENT(pSrcA_converted);
688 FREEARGUMENT(pSrcB_converted);
689 Py_DECREF(pDstOBJ);
690 return(pythonResult);
691
692 }
693 return(NULL);
694 }
695
696
697 static PyObject *
cmsis_arm_sub_q31(PyObject * obj,PyObject * args)698 cmsis_arm_sub_q31(PyObject *obj, PyObject *args)
699 {
700
701 PyObject *pSrcA=NULL; // input
702 q31_t *pSrcA_converted=NULL; // input
703 PyObject *pSrcB=NULL; // input
704 q31_t *pSrcB_converted=NULL; // input
705 q31_t *pDst=NULL; // output
706 uint32_t blockSize; // input
707
708 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
709 {
710
711 GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
712 GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
713 blockSize = arraySizepSrcA ;
714
715 pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
716
717
718 arm_sub_q31(pSrcA_converted,pSrcB_converted,pDst,blockSize);
719 INT32ARRAY1(pDstOBJ,blockSize,pDst);
720
721 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
722
723 FREEARGUMENT(pSrcA_converted);
724 FREEARGUMENT(pSrcB_converted);
725 Py_DECREF(pDstOBJ);
726 return(pythonResult);
727
728 }
729 return(NULL);
730 }
731
732
733 static PyObject *
cmsis_arm_scale_f32(PyObject * obj,PyObject * args)734 cmsis_arm_scale_f32(PyObject *obj, PyObject *args)
735 {
736
737 PyObject *pSrc=NULL; // input
738 float32_t *pSrc_converted=NULL; // input
739 float32_t scale; // input
740 float32_t *pDst=NULL; // output
741 uint32_t blockSize; // input
742
743 if (PyArg_ParseTuple(args,"Of",&pSrc,&scale))
744 {
745
746 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
747 blockSize = arraySizepSrc ;
748
749 pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
750
751
752 arm_scale_f32(pSrc_converted,scale,pDst,blockSize);
753 FLOATARRAY1(pDstOBJ,blockSize,pDst);
754
755 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
756
757 FREEARGUMENT(pSrc_converted);
758 Py_DECREF(pDstOBJ);
759 return(pythonResult);
760
761 }
762 return(NULL);
763 }
764
765 static PyObject *
cmsis_arm_scale_f64(PyObject * obj,PyObject * args)766 cmsis_arm_scale_f64(PyObject *obj, PyObject *args)
767 {
768
769 PyObject *pSrc=NULL; // input
770 float64_t *pSrc_converted=NULL; // input
771 float64_t scale; // input
772 float64_t *pDst=NULL; // output
773 uint32_t blockSize; // input
774
775 if (PyArg_ParseTuple(args,"Od",&pSrc,&scale))
776 {
777
778 GETARGUMENT(pSrc,NPY_DOUBLE,double,float64_t);
779 blockSize = arraySizepSrc ;
780
781 pDst=PyMem_Malloc(sizeof(float64_t)*blockSize);
782
783
784 arm_scale_f64(pSrc_converted,scale,pDst,blockSize);
785 FLOAT64ARRAY1(pDstOBJ,blockSize,pDst);
786
787 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
788
789 FREEARGUMENT(pSrc_converted);
790 Py_DECREF(pDstOBJ);
791 return(pythonResult);
792
793 }
794 return(NULL);
795 }
796
797
798 static PyObject *
cmsis_arm_scale_q7(PyObject * obj,PyObject * args)799 cmsis_arm_scale_q7(PyObject *obj, PyObject *args)
800 {
801
802 PyObject *pSrc=NULL; // input
803 q7_t *pSrc_converted=NULL; // input
804 int32_t scaleFract; // input
805 int32_t shift; // input
806 q7_t *pDst=NULL; // output
807 uint32_t blockSize; // input
808
809 if (PyArg_ParseTuple(args,"Oii",&pSrc,&scaleFract,&shift))
810 {
811
812 GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
813 blockSize = arraySizepSrc ;
814
815 pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
816
817
818 arm_scale_q7(pSrc_converted,(q7_t)scaleFract,(int8_t)shift,pDst,blockSize);
819 INT8ARRAY1(pDstOBJ,blockSize,pDst);
820
821 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
822
823 FREEARGUMENT(pSrc_converted);
824 Py_DECREF(pDstOBJ);
825 return(pythonResult);
826
827 }
828 return(NULL);
829 }
830
831
832 static PyObject *
cmsis_arm_scale_q15(PyObject * obj,PyObject * args)833 cmsis_arm_scale_q15(PyObject *obj, PyObject *args)
834 {
835
836 PyObject *pSrc=NULL; // input
837 q15_t *pSrc_converted=NULL; // input
838 q15_t scaleFract; // input
839 int32_t shift; // input
840 q15_t *pDst=NULL; // output
841 uint32_t blockSize; // input
842
843 if (PyArg_ParseTuple(args,"Ohi",&pSrc,&scaleFract,&shift))
844 {
845
846 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
847 blockSize = arraySizepSrc ;
848
849 pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
850
851
852 arm_scale_q15(pSrc_converted,scaleFract,(int8_t)shift,pDst,blockSize);
853 INT16ARRAY1(pDstOBJ,blockSize,pDst);
854
855 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
856
857 FREEARGUMENT(pSrc_converted);
858 Py_DECREF(pDstOBJ);
859 return(pythonResult);
860
861 }
862 return(NULL);
863 }
864
865
866 static PyObject *
cmsis_arm_scale_q31(PyObject * obj,PyObject * args)867 cmsis_arm_scale_q31(PyObject *obj, PyObject *args)
868 {
869
870 PyObject *pSrc=NULL; // input
871 q31_t *pSrc_converted=NULL; // input
872 q31_t scaleFract; // input
873 int32_t shift; // input
874 q31_t *pDst=NULL; // output
875 uint32_t blockSize; // input
876
877 if (PyArg_ParseTuple(args,"Oii",&pSrc,&scaleFract,&shift))
878 {
879
880 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
881 blockSize = arraySizepSrc ;
882
883 pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
884
885
886 arm_scale_q31(pSrc_converted,scaleFract,(int8_t)shift,pDst,blockSize);
887 INT32ARRAY1(pDstOBJ,blockSize,pDst);
888
889 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
890
891 FREEARGUMENT(pSrc_converted);
892 Py_DECREF(pDstOBJ);
893 return(pythonResult);
894
895 }
896 return(NULL);
897 }
898
899
900 static PyObject *
cmsis_arm_abs_q7(PyObject * obj,PyObject * args)901 cmsis_arm_abs_q7(PyObject *obj, PyObject *args)
902 {
903
904 PyObject *pSrc=NULL; // input
905 q7_t *pSrc_converted=NULL; // input
906 q7_t *pDst=NULL; // output
907 uint32_t blockSize; // input
908
909 if (PyArg_ParseTuple(args,"O",&pSrc))
910 {
911
912 GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
913 blockSize = arraySizepSrc ;
914
915 pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
916
917
918 arm_abs_q7(pSrc_converted,pDst,blockSize);
919 INT8ARRAY1(pDstOBJ,blockSize,pDst);
920
921 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
922
923 FREEARGUMENT(pSrc_converted);
924 Py_DECREF(pDstOBJ);
925 return(pythonResult);
926
927 }
928 return(NULL);
929 }
930
931
932 static PyObject *
cmsis_arm_abs_f32(PyObject * obj,PyObject * args)933 cmsis_arm_abs_f32(PyObject *obj, PyObject *args)
934 {
935
936 PyObject *pSrc=NULL; // input
937 float32_t *pSrc_converted=NULL; // input
938 float32_t *pDst=NULL; // output
939 uint32_t blockSize; // input
940
941 if (PyArg_ParseTuple(args,"O",&pSrc))
942 {
943
944 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
945 blockSize = arraySizepSrc ;
946
947 pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
948
949
950 arm_abs_f32(pSrc_converted,pDst,blockSize);
951 FLOATARRAY1(pDstOBJ,blockSize,pDst);
952
953 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
954
955 FREEARGUMENT(pSrc_converted);
956 Py_DECREF(pDstOBJ);
957 return(pythonResult);
958
959 }
960 return(NULL);
961 }
962
963 static PyObject *
cmsis_arm_abs_f64(PyObject * obj,PyObject * args)964 cmsis_arm_abs_f64(PyObject *obj, PyObject *args)
965 {
966
967 PyObject *pSrc=NULL; // input
968 float64_t *pSrc_converted=NULL; // input
969 float64_t *pDst=NULL; // output
970 uint32_t blockSize; // input
971
972 if (PyArg_ParseTuple(args,"O",&pSrc))
973 {
974
975 GETARGUMENT(pSrc,NPY_DOUBLE,double,float64_t);
976 blockSize = arraySizepSrc ;
977
978 pDst=PyMem_Malloc(sizeof(float64_t)*blockSize);
979
980
981 arm_abs_f64(pSrc_converted,pDst,blockSize);
982 FLOAT64ARRAY1(pDstOBJ,blockSize,pDst);
983
984 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
985
986 FREEARGUMENT(pSrc_converted);
987 Py_DECREF(pDstOBJ);
988 return(pythonResult);
989
990 }
991 return(NULL);
992 }
993
994
995 static PyObject *
cmsis_arm_abs_q15(PyObject * obj,PyObject * args)996 cmsis_arm_abs_q15(PyObject *obj, PyObject *args)
997 {
998
999 PyObject *pSrc=NULL; // input
1000 q15_t *pSrc_converted=NULL; // input
1001 q15_t *pDst=NULL; // output
1002 uint32_t blockSize; // input
1003
1004 if (PyArg_ParseTuple(args,"O",&pSrc))
1005 {
1006
1007 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
1008 blockSize = arraySizepSrc ;
1009
1010 pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
1011
1012
1013 arm_abs_q15(pSrc_converted,pDst,blockSize);
1014 INT16ARRAY1(pDstOBJ,blockSize,pDst);
1015
1016 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1017
1018 FREEARGUMENT(pSrc_converted);
1019 Py_DECREF(pDstOBJ);
1020 return(pythonResult);
1021
1022 }
1023 return(NULL);
1024 }
1025
1026
1027 static PyObject *
cmsis_arm_abs_q31(PyObject * obj,PyObject * args)1028 cmsis_arm_abs_q31(PyObject *obj, PyObject *args)
1029 {
1030
1031 PyObject *pSrc=NULL; // input
1032 q31_t *pSrc_converted=NULL; // input
1033 q31_t *pDst=NULL; // output
1034 uint32_t blockSize; // input
1035
1036 if (PyArg_ParseTuple(args,"O",&pSrc))
1037 {
1038
1039 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
1040 blockSize = arraySizepSrc ;
1041
1042 pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
1043
1044
1045 arm_abs_q31(pSrc_converted,pDst,blockSize);
1046 INT32ARRAY1(pDstOBJ,blockSize,pDst);
1047
1048 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1049
1050 FREEARGUMENT(pSrc_converted);
1051 Py_DECREF(pDstOBJ);
1052 return(pythonResult);
1053
1054 }
1055 return(NULL);
1056 }
1057
1058
1059
1060
1061
1062 static PyObject *
cmsis_arm_dot_prod_f32(PyObject * obj,PyObject * args)1063 cmsis_arm_dot_prod_f32(PyObject *obj, PyObject *args)
1064 {
1065
1066 PyObject *pSrcA=NULL; // input
1067 float32_t *pSrcA_converted=NULL; // input
1068 PyObject *pSrcB=NULL; // input
1069 float32_t *pSrcB_converted=NULL; // input
1070 uint32_t blockSize; // input
1071 float32_t result; // output
1072
1073 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
1074 {
1075
1076 GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
1077 GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
1078 blockSize = arraySizepSrcA ;
1079
1080
1081
1082 arm_dot_prod_f32(pSrcA_converted,pSrcB_converted,blockSize,&result);
1083 PyObject* resultOBJ=Py_BuildValue("f",result);
1084
1085 PyObject *pythonResult = Py_BuildValue("O",resultOBJ);
1086
1087 FREEARGUMENT(pSrcA_converted);
1088 FREEARGUMENT(pSrcB_converted);
1089 Py_DECREF(resultOBJ);
1090 return(pythonResult);
1091
1092 }
1093 return(NULL);
1094 }
1095
1096 static PyObject *
cmsis_arm_dot_prod_f64(PyObject * obj,PyObject * args)1097 cmsis_arm_dot_prod_f64(PyObject *obj, PyObject *args)
1098 {
1099
1100 PyObject *pSrcA=NULL; // input
1101 float64_t *pSrcA_converted=NULL; // input
1102 PyObject *pSrcB=NULL; // input
1103 float64_t *pSrcB_converted=NULL; // input
1104 uint32_t blockSize; // input
1105 float64_t result; // output
1106
1107 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
1108 {
1109
1110 GETARGUMENT(pSrcA,NPY_DOUBLE,double,float64_t);
1111 GETARGUMENT(pSrcB,NPY_DOUBLE,double,float64_t);
1112 blockSize = arraySizepSrcA ;
1113
1114
1115
1116 arm_dot_prod_f64(pSrcA_converted,pSrcB_converted,blockSize,&result);
1117 PyObject* resultOBJ=Py_BuildValue("d",result);
1118
1119 PyObject *pythonResult = Py_BuildValue("O",resultOBJ);
1120
1121 FREEARGUMENT(pSrcA_converted);
1122 FREEARGUMENT(pSrcB_converted);
1123 Py_DECREF(resultOBJ);
1124 return(pythonResult);
1125
1126 }
1127 return(NULL);
1128 }
1129
1130
1131 static PyObject *
cmsis_arm_dot_prod_q7(PyObject * obj,PyObject * args)1132 cmsis_arm_dot_prod_q7(PyObject *obj, PyObject *args)
1133 {
1134
1135 PyObject *pSrcA=NULL; // input
1136 q7_t *pSrcA_converted=NULL; // input
1137 PyObject *pSrcB=NULL; // input
1138 q7_t *pSrcB_converted=NULL; // input
1139 uint32_t blockSize; // input
1140 q31_t result; // output
1141
1142 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
1143 {
1144
1145 GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
1146 GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
1147 blockSize = arraySizepSrcA ;
1148
1149
1150
1151 arm_dot_prod_q7(pSrcA_converted,pSrcB_converted,blockSize,&result);
1152 PyObject* resultOBJ=Py_BuildValue("i",result);
1153
1154 PyObject *pythonResult = Py_BuildValue("O",resultOBJ);
1155
1156 FREEARGUMENT(pSrcA_converted);
1157 FREEARGUMENT(pSrcB_converted);
1158 Py_DECREF(resultOBJ);
1159 return(pythonResult);
1160
1161 }
1162 return(NULL);
1163 }
1164
1165
1166 static PyObject *
cmsis_arm_dot_prod_q15(PyObject * obj,PyObject * args)1167 cmsis_arm_dot_prod_q15(PyObject *obj, PyObject *args)
1168 {
1169
1170 PyObject *pSrcA=NULL; // input
1171 q15_t *pSrcA_converted=NULL; // input
1172 PyObject *pSrcB=NULL; // input
1173 q15_t *pSrcB_converted=NULL; // input
1174 uint32_t blockSize; // input
1175 q63_t result; // output
1176
1177 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
1178 {
1179
1180 GETARGUMENT(pSrcA,NPY_INT16,int16_t,int16_t);
1181 GETARGUMENT(pSrcB,NPY_INT16,int16_t,int16_t);
1182 blockSize = arraySizepSrcA ;
1183
1184
1185
1186 arm_dot_prod_q15(pSrcA_converted,pSrcB_converted,blockSize,&result);
1187 PyObject* resultOBJ=Py_BuildValue("L",result);
1188
1189 PyObject *pythonResult = Py_BuildValue("O",resultOBJ);
1190
1191 FREEARGUMENT(pSrcA_converted);
1192 FREEARGUMENT(pSrcB_converted);
1193 Py_DECREF(resultOBJ);
1194 return(pythonResult);
1195
1196 }
1197 return(NULL);
1198 }
1199
1200
1201 static PyObject *
cmsis_arm_dot_prod_q31(PyObject * obj,PyObject * args)1202 cmsis_arm_dot_prod_q31(PyObject *obj, PyObject *args)
1203 {
1204
1205 PyObject *pSrcA=NULL; // input
1206 q31_t *pSrcA_converted=NULL; // input
1207 PyObject *pSrcB=NULL; // input
1208 q31_t *pSrcB_converted=NULL; // input
1209 uint32_t blockSize; // input
1210 q63_t result; // output
1211
1212 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
1213 {
1214
1215 GETARGUMENT(pSrcA,NPY_INT32,int32_t,int32_t);
1216 GETARGUMENT(pSrcB,NPY_INT32,int32_t,int32_t);
1217 blockSize = arraySizepSrcA ;
1218
1219
1220
1221 arm_dot_prod_q31(pSrcA_converted,pSrcB_converted,blockSize,&result);
1222 PyObject* resultOBJ=Py_BuildValue("L",result);
1223
1224 PyObject *pythonResult = Py_BuildValue("O",resultOBJ);
1225
1226 FREEARGUMENT(pSrcA_converted);
1227 FREEARGUMENT(pSrcB_converted);
1228 Py_DECREF(resultOBJ);
1229 return(pythonResult);
1230
1231 }
1232 return(NULL);
1233 }
1234
1235
1236 static PyObject *
cmsis_arm_shift_q7(PyObject * obj,PyObject * args)1237 cmsis_arm_shift_q7(PyObject *obj, PyObject *args)
1238 {
1239
1240 PyObject *pSrc=NULL; // input
1241 q7_t *pSrc_converted=NULL; // input
1242 int32_t shiftBits; // input
1243 q7_t *pDst=NULL; // output
1244 uint32_t blockSize; // input
1245
1246 if (PyArg_ParseTuple(args,"Oi",&pSrc,&shiftBits))
1247 {
1248
1249 GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
1250 blockSize = arraySizepSrc ;
1251
1252 pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
1253
1254
1255 arm_shift_q7(pSrc_converted,(int8_t)shiftBits,pDst,blockSize);
1256 INT8ARRAY1(pDstOBJ,blockSize,pDst);
1257
1258 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1259
1260 FREEARGUMENT(pSrc_converted);
1261 Py_DECREF(pDstOBJ);
1262 return(pythonResult);
1263
1264 }
1265 return(NULL);
1266 }
1267
1268
1269 static PyObject *
cmsis_arm_shift_q15(PyObject * obj,PyObject * args)1270 cmsis_arm_shift_q15(PyObject *obj, PyObject *args)
1271 {
1272
1273 PyObject *pSrc=NULL; // input
1274 q15_t *pSrc_converted=NULL; // input
1275 int32_t shiftBits; // input
1276 q15_t *pDst=NULL; // output
1277 uint32_t blockSize; // input
1278
1279 if (PyArg_ParseTuple(args,"Oi",&pSrc,&shiftBits))
1280 {
1281
1282 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
1283 blockSize = arraySizepSrc ;
1284
1285 pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
1286
1287
1288 arm_shift_q15(pSrc_converted,(int8_t)shiftBits,pDst,blockSize);
1289 INT16ARRAY1(pDstOBJ,blockSize,pDst);
1290
1291 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1292
1293 FREEARGUMENT(pSrc_converted);
1294 Py_DECREF(pDstOBJ);
1295 return(pythonResult);
1296
1297 }
1298 return(NULL);
1299 }
1300
1301
1302 static PyObject *
cmsis_arm_shift_q31(PyObject * obj,PyObject * args)1303 cmsis_arm_shift_q31(PyObject *obj, PyObject *args)
1304 {
1305
1306 PyObject *pSrc=NULL; // input
1307 q31_t *pSrc_converted=NULL; // input
1308 int32_t shiftBits; // input
1309 q31_t *pDst=NULL; // output
1310 uint32_t blockSize; // input
1311
1312 if (PyArg_ParseTuple(args,"Oi",&pSrc,&shiftBits))
1313 {
1314
1315 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
1316 blockSize = arraySizepSrc ;
1317
1318 pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
1319
1320
1321 arm_shift_q31(pSrc_converted,(int8_t)shiftBits,pDst,blockSize);
1322 INT32ARRAY1(pDstOBJ,blockSize,pDst);
1323
1324 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1325
1326 FREEARGUMENT(pSrc_converted);
1327 Py_DECREF(pDstOBJ);
1328 return(pythonResult);
1329
1330 }
1331 return(NULL);
1332 }
1333
1334 static PyObject *
cmsis_arm_clip_f32(PyObject * obj,PyObject * args)1335 cmsis_arm_clip_f32(PyObject *obj, PyObject *args)
1336 {
1337
1338 PyObject *pSrc=NULL; // input
1339 float32_t *pSrc_converted=NULL; // input
1340 float32_t low,high; // input
1341 float32_t *pDst=NULL; // output
1342 uint32_t blockSize; // input
1343
1344 if (PyArg_ParseTuple(args,"Off",&pSrc,&low,&high))
1345 {
1346
1347 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
1348 blockSize = arraySizepSrc ;
1349
1350 pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
1351
1352
1353 arm_clip_f32(pSrc_converted,pDst,low,high,blockSize);
1354 FLOATARRAY1(pDstOBJ,blockSize,pDst);
1355
1356 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1357
1358 FREEARGUMENT(pSrc_converted);
1359 Py_DECREF(pDstOBJ);
1360 return(pythonResult);
1361
1362 }
1363 return(NULL);
1364 }
1365
1366 static PyObject *
cmsis_arm_clip_q31(PyObject * obj,PyObject * args)1367 cmsis_arm_clip_q31(PyObject *obj, PyObject *args)
1368 {
1369
1370 PyObject *pSrc=NULL; // input
1371 q31_t *pSrc_converted=NULL; // input
1372 q31_t low,high; // input
1373 q31_t *pDst=NULL; // output
1374 uint32_t blockSize; // input
1375
1376 if (PyArg_ParseTuple(args,"Oii",&pSrc,&low,&high))
1377 {
1378
1379 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
1380 blockSize = arraySizepSrc ;
1381
1382 pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
1383
1384
1385 arm_clip_q31(pSrc_converted,pDst,low,high,blockSize);
1386 INT32ARRAY1(pDstOBJ,blockSize,pDst);
1387
1388 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1389
1390 FREEARGUMENT(pSrc_converted);
1391 Py_DECREF(pDstOBJ);
1392 return(pythonResult);
1393
1394 }
1395 return(NULL);
1396 }
1397
1398
1399 static PyObject *
cmsis_arm_clip_q15(PyObject * obj,PyObject * args)1400 cmsis_arm_clip_q15(PyObject *obj, PyObject *args)
1401 {
1402
1403 PyObject *pSrc=NULL; // input
1404 q15_t *pSrc_converted=NULL; // input
1405 q15_t low,high; // input
1406 q15_t *pDst=NULL; // output
1407 uint32_t blockSize; // input
1408
1409 if (PyArg_ParseTuple(args,"Ohh",&pSrc,&low,&high))
1410 {
1411
1412 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
1413 blockSize = arraySizepSrc ;
1414
1415 pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
1416
1417
1418 arm_clip_q15(pSrc_converted,pDst,low,high,blockSize);
1419 INT16ARRAY1(pDstOBJ,blockSize,pDst);
1420
1421 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1422
1423 FREEARGUMENT(pSrc_converted);
1424 Py_DECREF(pDstOBJ);
1425 return(pythonResult);
1426
1427 }
1428 return(NULL);
1429 }
1430
1431 static PyObject *
cmsis_arm_clip_q7(PyObject * obj,PyObject * args)1432 cmsis_arm_clip_q7(PyObject *obj, PyObject *args)
1433 {
1434
1435 PyObject *pSrc=NULL; // input
1436 q7_t *pSrc_converted=NULL; // input
1437 int32_t low,high; // input
1438 q7_t *pDst=NULL; // output
1439 uint32_t blockSize; // input
1440
1441 if (PyArg_ParseTuple(args,"Oii",&pSrc,&low,&high))
1442 {
1443
1444 GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
1445 blockSize = arraySizepSrc ;
1446
1447 pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
1448
1449
1450 arm_clip_q7(pSrc_converted,pDst,(q7_t)low,(q7_t)high,blockSize);
1451 INT8ARRAY1(pDstOBJ,blockSize,pDst);
1452
1453 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1454
1455 FREEARGUMENT(pSrc_converted);
1456 Py_DECREF(pDstOBJ);
1457 return(pythonResult);
1458
1459 }
1460 return(NULL);
1461 }
1462
1463
1464 static PyObject *
cmsis_arm_offset_f32(PyObject * obj,PyObject * args)1465 cmsis_arm_offset_f32(PyObject *obj, PyObject *args)
1466 {
1467
1468 PyObject *pSrc=NULL; // input
1469 float32_t *pSrc_converted=NULL; // input
1470 float32_t offset; // input
1471 float32_t *pDst=NULL; // output
1472 uint32_t blockSize; // input
1473
1474 if (PyArg_ParseTuple(args,"Of",&pSrc,&offset))
1475 {
1476
1477 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
1478 blockSize = arraySizepSrc ;
1479
1480 pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
1481
1482
1483 arm_offset_f32(pSrc_converted,offset,pDst,blockSize);
1484 FLOATARRAY1(pDstOBJ,blockSize,pDst);
1485
1486 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1487
1488 FREEARGUMENT(pSrc_converted);
1489 Py_DECREF(pDstOBJ);
1490 return(pythonResult);
1491
1492 }
1493 return(NULL);
1494 }
1495
1496 static PyObject *
cmsis_arm_offset_f64(PyObject * obj,PyObject * args)1497 cmsis_arm_offset_f64(PyObject *obj, PyObject *args)
1498 {
1499
1500 PyObject *pSrc=NULL; // input
1501 float64_t *pSrc_converted=NULL; // input
1502 float64_t offset; // input
1503 float64_t *pDst=NULL; // output
1504 uint32_t blockSize; // input
1505
1506 if (PyArg_ParseTuple(args,"Od",&pSrc,&offset))
1507 {
1508
1509 GETARGUMENT(pSrc,NPY_DOUBLE,double,float64_t);
1510 blockSize = arraySizepSrc ;
1511
1512 pDst=PyMem_Malloc(sizeof(float64_t)*blockSize);
1513
1514
1515 arm_offset_f64(pSrc_converted,offset,pDst,blockSize);
1516 FLOAT64ARRAY1(pDstOBJ,blockSize,pDst);
1517
1518 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1519
1520 FREEARGUMENT(pSrc_converted);
1521 Py_DECREF(pDstOBJ);
1522 return(pythonResult);
1523
1524 }
1525 return(NULL);
1526 }
1527
1528
1529 static PyObject *
cmsis_arm_offset_q7(PyObject * obj,PyObject * args)1530 cmsis_arm_offset_q7(PyObject *obj, PyObject *args)
1531 {
1532
1533 PyObject *pSrc=NULL; // input
1534 q7_t *pSrc_converted=NULL; // input
1535 int32_t offset; // input
1536 q7_t *pDst=NULL; // output
1537 uint32_t blockSize; // input
1538
1539 if (PyArg_ParseTuple(args,"Oi",&pSrc,&offset))
1540 {
1541
1542 GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
1543 blockSize = arraySizepSrc ;
1544
1545 pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
1546
1547
1548 arm_offset_q7(pSrc_converted,(q7_t)offset,pDst,blockSize);
1549 INT8ARRAY1(pDstOBJ,blockSize,pDst);
1550
1551 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1552
1553 FREEARGUMENT(pSrc_converted);
1554 Py_DECREF(pDstOBJ);
1555 return(pythonResult);
1556
1557 }
1558 return(NULL);
1559 }
1560
1561
1562 static PyObject *
cmsis_arm_offset_q15(PyObject * obj,PyObject * args)1563 cmsis_arm_offset_q15(PyObject *obj, PyObject *args)
1564 {
1565
1566 PyObject *pSrc=NULL; // input
1567 q15_t *pSrc_converted=NULL; // input
1568 q15_t offset; // input
1569 q15_t *pDst=NULL; // output
1570 uint32_t blockSize; // input
1571
1572 if (PyArg_ParseTuple(args,"Oh",&pSrc,&offset))
1573 {
1574
1575 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
1576 blockSize = arraySizepSrc ;
1577
1578 pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
1579
1580
1581 arm_offset_q15(pSrc_converted,offset,pDst,blockSize);
1582 INT16ARRAY1(pDstOBJ,blockSize,pDst);
1583
1584 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1585
1586 FREEARGUMENT(pSrc_converted);
1587 Py_DECREF(pDstOBJ);
1588 return(pythonResult);
1589
1590 }
1591 return(NULL);
1592 }
1593
1594
1595 static PyObject *
cmsis_arm_offset_q31(PyObject * obj,PyObject * args)1596 cmsis_arm_offset_q31(PyObject *obj, PyObject *args)
1597 {
1598
1599 PyObject *pSrc=NULL; // input
1600 q31_t *pSrc_converted=NULL; // input
1601 q31_t offset; // input
1602 q31_t *pDst=NULL; // output
1603 uint32_t blockSize; // input
1604
1605 if (PyArg_ParseTuple(args,"Oi",&pSrc,&offset))
1606 {
1607
1608 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
1609 blockSize = arraySizepSrc ;
1610
1611 pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
1612
1613
1614 arm_offset_q31(pSrc_converted,offset,pDst,blockSize);
1615 INT32ARRAY1(pDstOBJ,blockSize,pDst);
1616
1617 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1618
1619 FREEARGUMENT(pSrc_converted);
1620 Py_DECREF(pDstOBJ);
1621 return(pythonResult);
1622
1623 }
1624 return(NULL);
1625 }
1626
1627
1628 static PyObject *
cmsis_arm_negate_f32(PyObject * obj,PyObject * args)1629 cmsis_arm_negate_f32(PyObject *obj, PyObject *args)
1630 {
1631
1632 PyObject *pSrc=NULL; // input
1633 float32_t *pSrc_converted=NULL; // input
1634 float32_t *pDst=NULL; // output
1635 uint32_t blockSize; // input
1636
1637 if (PyArg_ParseTuple(args,"O",&pSrc))
1638 {
1639
1640 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
1641 blockSize = arraySizepSrc ;
1642
1643 pDst=PyMem_Malloc(sizeof(float32_t)*blockSize);
1644
1645
1646 arm_negate_f32(pSrc_converted,pDst,blockSize);
1647 FLOATARRAY1(pDstOBJ,blockSize,pDst);
1648
1649 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1650
1651 FREEARGUMENT(pSrc_converted);
1652 Py_DECREF(pDstOBJ);
1653 return(pythonResult);
1654
1655 }
1656 return(NULL);
1657 }
1658
1659 static PyObject *
cmsis_arm_negate_f64(PyObject * obj,PyObject * args)1660 cmsis_arm_negate_f64(PyObject *obj, PyObject *args)
1661 {
1662
1663 PyObject *pSrc=NULL; // input
1664 float64_t *pSrc_converted=NULL; // input
1665 float64_t *pDst=NULL; // output
1666 uint32_t blockSize; // input
1667
1668 if (PyArg_ParseTuple(args,"O",&pSrc))
1669 {
1670
1671 GETARGUMENT(pSrc,NPY_DOUBLE,double,float64_t);
1672 blockSize = arraySizepSrc ;
1673
1674 pDst=PyMem_Malloc(sizeof(float64_t)*blockSize);
1675
1676
1677 arm_negate_f64(pSrc_converted,pDst,blockSize);
1678 FLOAT64ARRAY1(pDstOBJ,blockSize,pDst);
1679
1680 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1681
1682 FREEARGUMENT(pSrc_converted);
1683 Py_DECREF(pDstOBJ);
1684 return(pythonResult);
1685
1686 }
1687 return(NULL);
1688 }
1689
1690 static PyObject *
cmsis_arm_negate_q7(PyObject * obj,PyObject * args)1691 cmsis_arm_negate_q7(PyObject *obj, PyObject *args)
1692 {
1693
1694 PyObject *pSrc=NULL; // input
1695 q7_t *pSrc_converted=NULL; // input
1696 q7_t *pDst=NULL; // output
1697 uint32_t blockSize; // input
1698
1699 if (PyArg_ParseTuple(args,"O",&pSrc))
1700 {
1701
1702 GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
1703 blockSize = arraySizepSrc ;
1704
1705 pDst=PyMem_Malloc(sizeof(q7_t)*blockSize);
1706
1707
1708 arm_negate_q7(pSrc_converted,pDst,blockSize);
1709 INT8ARRAY1(pDstOBJ,blockSize,pDst);
1710
1711 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1712
1713 FREEARGUMENT(pSrc_converted);
1714 Py_DECREF(pDstOBJ);
1715 return(pythonResult);
1716
1717 }
1718 return(NULL);
1719 }
1720
1721
1722 static PyObject *
cmsis_arm_negate_q15(PyObject * obj,PyObject * args)1723 cmsis_arm_negate_q15(PyObject *obj, PyObject *args)
1724 {
1725
1726 PyObject *pSrc=NULL; // input
1727 q15_t *pSrc_converted=NULL; // input
1728 q15_t *pDst=NULL; // output
1729 uint32_t blockSize; // input
1730
1731 if (PyArg_ParseTuple(args,"O",&pSrc))
1732 {
1733
1734 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
1735 blockSize = arraySizepSrc ;
1736
1737 pDst=PyMem_Malloc(sizeof(q15_t)*blockSize);
1738
1739
1740 arm_negate_q15(pSrc_converted,pDst,blockSize);
1741 INT16ARRAY1(pDstOBJ,blockSize,pDst);
1742
1743 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1744
1745 FREEARGUMENT(pSrc_converted);
1746 Py_DECREF(pDstOBJ);
1747 return(pythonResult);
1748
1749 }
1750 return(NULL);
1751 }
1752
1753
1754 static PyObject *
cmsis_arm_negate_q31(PyObject * obj,PyObject * args)1755 cmsis_arm_negate_q31(PyObject *obj, PyObject *args)
1756 {
1757
1758 PyObject *pSrc=NULL; // input
1759 q31_t *pSrc_converted=NULL; // input
1760 q31_t *pDst=NULL; // output
1761 uint32_t blockSize; // input
1762
1763 if (PyArg_ParseTuple(args,"O",&pSrc))
1764 {
1765
1766 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
1767 blockSize = arraySizepSrc ;
1768
1769 pDst=PyMem_Malloc(sizeof(q31_t)*blockSize);
1770
1771
1772 arm_negate_q31(pSrc_converted,pDst,blockSize);
1773 INT32ARRAY1(pDstOBJ,blockSize,pDst);
1774
1775 PyObject *pythonResult = Py_BuildValue("O",pDstOBJ);
1776
1777 FREEARGUMENT(pSrc_converted);
1778 Py_DECREF(pDstOBJ);
1779 return(pythonResult);
1780
1781 }
1782 return(NULL);
1783 }
1784
1785
1786
1787 static PyObject *
cmsis_ssat(PyObject * obj,PyObject * args)1788 cmsis_ssat(PyObject *obj, PyObject *args)
1789 {
1790
1791 int32_t val; // input
1792 uint32_t sat;
1793
1794 if (PyArg_ParseTuple(args,"iI",&val,&sat))
1795 {
1796
1797 int32_t result = __SSAT(val,sat);
1798 PyObject* theReturnOBJ=Py_BuildValue("i",result);
1799
1800 return(theReturnOBJ);
1801
1802 }
1803 return(NULL);
1804 }
1805
1806 static PyObject *
cmsis_usat(PyObject * obj,PyObject * args)1807 cmsis_usat(PyObject *obj, PyObject *args)
1808 {
1809
1810 int32_t val; // input
1811 uint32_t sat;
1812 q15_t pOut,shift; // output
1813
1814 if (PyArg_ParseTuple(args,"iI",&val,&sat))
1815 {
1816
1817 uint32_t result = __USAT(val,sat);
1818 PyObject* theReturnOBJ=Py_BuildValue("I",result);
1819
1820 return(theReturnOBJ);
1821
1822 }
1823 return(NULL);
1824 }
1825
1826 static PyObject *
cmsis_clz(PyObject * obj,PyObject * args)1827 cmsis_clz(PyObject *obj, PyObject *args)
1828 {
1829
1830 uint32_t val;
1831
1832 if (PyArg_ParseTuple(args,"I",&val))
1833 {
1834
1835 uint8_t result = __CLZ(val);
1836 PyObject* theReturnOBJ=Py_BuildValue("B",result);
1837
1838 return(theReturnOBJ);
1839
1840 }
1841 return(NULL);
1842 }
1843
1844 static PyMethodDef CMSISDSPMethods[] = {
1845
1846 {"arm_recip_q31", cmsis_arm_recip_q31, METH_VARARGS,""},
1847 {"arm_recip_q15", cmsis_arm_recip_q15, METH_VARARGS,""},
1848
1849
1850
1851
1852 {"arm_mult_q7", cmsis_arm_mult_q7, METH_VARARGS,""},
1853 {"arm_mult_q15", cmsis_arm_mult_q15, METH_VARARGS,""},
1854 {"arm_mult_q31", cmsis_arm_mult_q31, METH_VARARGS,""},
1855 {"arm_mult_f32", cmsis_arm_mult_f32, METH_VARARGS,""},
1856 {"arm_mult_f64", cmsis_arm_mult_f64, METH_VARARGS,""},
1857
1858
1859 {"arm_add_f32", cmsis_arm_add_f32, METH_VARARGS,""},
1860 {"arm_add_f64", cmsis_arm_add_f64, METH_VARARGS,""},
1861 {"arm_add_q7", cmsis_arm_add_q7, METH_VARARGS,""},
1862 {"arm_add_q15", cmsis_arm_add_q15, METH_VARARGS,""},
1863 {"arm_add_q31", cmsis_arm_add_q31, METH_VARARGS,""},
1864 {"arm_sub_f32", cmsis_arm_sub_f32, METH_VARARGS,""},
1865 {"arm_sub_f64", cmsis_arm_sub_f64, METH_VARARGS,""},
1866
1867 {"arm_sub_q7", cmsis_arm_sub_q7, METH_VARARGS,""},
1868 {"arm_sub_q15", cmsis_arm_sub_q15, METH_VARARGS,""},
1869 {"arm_sub_q31", cmsis_arm_sub_q31, METH_VARARGS,""},
1870 {"arm_scale_f32", cmsis_arm_scale_f32, METH_VARARGS,""},
1871 {"arm_scale_f64", cmsis_arm_scale_f64, METH_VARARGS,""},
1872 {"arm_scale_q7", cmsis_arm_scale_q7, METH_VARARGS,""},
1873 {"arm_scale_q15", cmsis_arm_scale_q15, METH_VARARGS,""},
1874 {"arm_scale_q31", cmsis_arm_scale_q31, METH_VARARGS,""},
1875 {"arm_abs_q7", cmsis_arm_abs_q7, METH_VARARGS,""},
1876 {"arm_abs_f32", cmsis_arm_abs_f32, METH_VARARGS,""},
1877 {"arm_abs_f64", cmsis_arm_abs_f64, METH_VARARGS,""},
1878 {"arm_abs_q15", cmsis_arm_abs_q15, METH_VARARGS,""},
1879 {"arm_abs_q31", cmsis_arm_abs_q31, METH_VARARGS,""},
1880 {"arm_dot_prod_f32", cmsis_arm_dot_prod_f32, METH_VARARGS,""},
1881 {"arm_dot_prod_f64", cmsis_arm_dot_prod_f64, METH_VARARGS,""},
1882
1883 {"arm_dot_prod_q7", cmsis_arm_dot_prod_q7, METH_VARARGS,""},
1884 {"arm_dot_prod_q15", cmsis_arm_dot_prod_q15, METH_VARARGS,""},
1885 {"arm_dot_prod_q31", cmsis_arm_dot_prod_q31, METH_VARARGS,""},
1886 {"arm_shift_q7", cmsis_arm_shift_q7, METH_VARARGS,""},
1887 {"arm_shift_q15", cmsis_arm_shift_q15, METH_VARARGS,""},
1888 {"arm_shift_q31", cmsis_arm_shift_q31, METH_VARARGS,""},
1889 {"arm_clip_f32", cmsis_arm_clip_f32, METH_VARARGS,""},
1890 {"arm_clip_q31", cmsis_arm_clip_q31, METH_VARARGS,""},
1891 {"arm_clip_q15", cmsis_arm_clip_q15, METH_VARARGS,""},
1892 {"arm_clip_q7", cmsis_arm_clip_q7, METH_VARARGS,""},
1893 {"arm_offset_f32", cmsis_arm_offset_f32, METH_VARARGS,""},
1894 {"arm_offset_f64", cmsis_arm_offset_f64, METH_VARARGS,""},
1895
1896 {"arm_offset_q7", cmsis_arm_offset_q7, METH_VARARGS,""},
1897 {"arm_offset_q15", cmsis_arm_offset_q15, METH_VARARGS,""},
1898 {"arm_offset_q31", cmsis_arm_offset_q31, METH_VARARGS,""},
1899 {"arm_negate_f32", cmsis_arm_negate_f32, METH_VARARGS,""},
1900 {"arm_negate_f64", cmsis_arm_negate_f64, METH_VARARGS,""},
1901 {"arm_negate_q7", cmsis_arm_negate_q7, METH_VARARGS,""},
1902 {"arm_negate_q15", cmsis_arm_negate_q15, METH_VARARGS,""},
1903 {"arm_negate_q31", cmsis_arm_negate_q31, METH_VARARGS,""},
1904
1905
1906
1907
1908
1909
1910 {"arm_and_u32", cmsis_arm_and_u32, METH_VARARGS,""},
1911 {"arm_and_u16", cmsis_arm_and_u16, METH_VARARGS,""},
1912 {"arm_and_u8" , cmsis_arm_and_u8, METH_VARARGS,""},
1913
1914 {"arm_or_u32", cmsis_arm_or_u32, METH_VARARGS,""},
1915 {"arm_or_u16", cmsis_arm_or_u16, METH_VARARGS,""},
1916 {"arm_or_u8" , cmsis_arm_or_u8, METH_VARARGS,""},
1917
1918 {"arm_xor_u32", cmsis_arm_xor_u32, METH_VARARGS,""},
1919 {"arm_xor_u16", cmsis_arm_xor_u16, METH_VARARGS,""},
1920 {"arm_xor_u8" , cmsis_arm_xor_u8, METH_VARARGS,""},
1921
1922 {"arm_not_u32", cmsis_arm_not_u32, METH_VARARGS,""},
1923 {"arm_not_u16", cmsis_arm_not_u16, METH_VARARGS,""},
1924 {"arm_not_u8" , cmsis_arm_not_u8, METH_VARARGS,""},
1925
1926
1927 {"ssat", cmsis_ssat, METH_VARARGS,""},
1928 {"usat", cmsis_usat, METH_VARARGS,""},
1929 {"clz", cmsis_clz, METH_VARARGS,""},
1930 {"error_out", (PyCFunction)error_out, METH_NOARGS, NULL},
1931 {NULL, NULL, 0, NULL} /* Sentinel */
1932 };
1933
1934 #ifdef IS_PY3K
cmsisdsp_traverse(PyObject * m,visitproc visit,void * arg)1935 static int cmsisdsp_traverse(PyObject *m, visitproc visit, void *arg) {
1936 Py_VISIT(GETSTATE(m)->error);
1937 return 0;
1938 }
1939
cmsisdsp_clear(PyObject * m)1940 static int cmsisdsp_clear(PyObject *m) {
1941 Py_CLEAR(GETSTATE(m)->error);
1942 return 0;
1943 }
1944
1945
1946 static struct PyModuleDef moduledef = {
1947 PyModuleDef_HEAD_INIT,
1948 MODNAME,
1949 NULL,
1950 sizeof(struct module_state),
1951 CMSISDSPMethods,
1952 NULL,
1953 cmsisdsp_traverse,
1954 cmsisdsp_clear,
1955 NULL
1956 };
1957
1958 #define INITERROR return NULL
1959
1960 PyMODINIT_FUNC
CAT(PyInit_,MODINITNAME)1961 CAT(PyInit_,MODINITNAME)(void)
1962
1963
1964 #else
1965 #define INITERROR return
1966
1967 void CAT(init,MODINITNAME)(void)
1968 #endif
1969 {
1970 import_array();
1971
1972 #ifdef IS_PY3K
1973 PyObject *module = PyModule_Create(&moduledef);
1974 #else
1975 PyObject *module = Py_InitModule(MODNAME, CMSISDSPMethods);
1976 #endif
1977
1978 if (module == NULL)
1979 INITERROR;
1980 struct module_state *st = GETSTATE(module);
1981
1982 st->error = PyErr_NewException(MODNAME".Error", NULL, NULL);
1983 if (st->error == NULL) {
1984 Py_DECREF(module);
1985 INITERROR;
1986 }
1987
1988
1989 typeRegistration(module);
1990
1991 #ifdef IS_PY3K
1992 return module;
1993 #endif
1994 }
