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_statistics"
30 #define MODINITNAME cmsisdsp_statistics
31
32 #include "cmsisdsp_module.h"
33
34
35 NUMPYVECTORFROMBUFFER(f32,float32_t,NPY_FLOAT);
36
37
38
typeRegistration(PyObject * module)39 void typeRegistration(PyObject *module) {
40
41
42 }
43
44
45
46
47 static PyObject *
cmsis_arm_power_q31(PyObject * obj,PyObject * args)48 cmsis_arm_power_q31(PyObject *obj, PyObject *args)
49 {
50
51 PyObject *pSrc=NULL; // input
52 q31_t *pSrc_converted=NULL; // input
53 uint32_t blockSize; // input
54 q63_t pResult; // output
55
56 if (PyArg_ParseTuple(args,"O",&pSrc))
57 {
58
59 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
60 blockSize = arraySizepSrc ;
61
62
63 arm_power_q31(pSrc_converted,blockSize,&pResult);
64 PyObject* pResultOBJ=Py_BuildValue("L",pResult);
65
66 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
67
68 FREEARGUMENT(pSrc_converted);
69 Py_DECREF(pResultOBJ);
70 return(pythonResult);
71
72 }
73 return(NULL);
74 }
75
76
77 static PyObject *
cmsis_arm_power_f32(PyObject * obj,PyObject * args)78 cmsis_arm_power_f32(PyObject *obj, PyObject *args)
79 {
80
81 PyObject *pSrc=NULL; // input
82 float32_t *pSrc_converted=NULL; // input
83 uint32_t blockSize; // input
84 float32_t pResult; // output
85
86 if (PyArg_ParseTuple(args,"O",&pSrc))
87 {
88
89 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
90 blockSize = arraySizepSrc ;
91
92
93 arm_power_f32(pSrc_converted,blockSize,&pResult);
94 PyObject* pResultOBJ=Py_BuildValue("f",pResult);
95
96 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
97
98 FREEARGUMENT(pSrc_converted);
99 Py_DECREF(pResultOBJ);
100 return(pythonResult);
101
102 }
103 return(NULL);
104 }
105
106 static PyObject *
cmsis_arm_power_f64(PyObject * obj,PyObject * args)107 cmsis_arm_power_f64(PyObject *obj, PyObject *args)
108 {
109
110 PyObject *pSrc=NULL; // input
111 float64_t *pSrc_converted=NULL; // input
112 uint32_t blockSize; // input
113 float64_t pResult; // output
114
115 if (PyArg_ParseTuple(args,"O",&pSrc))
116 {
117
118 GETARGUMENT(pSrc,NPY_DOUBLE,double,float64_t);
119 blockSize = arraySizepSrc ;
120
121
122 arm_power_f64(pSrc_converted,blockSize,&pResult);
123 PyObject* pResultOBJ=Py_BuildValue("d",pResult);
124
125 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
126
127 FREEARGUMENT(pSrc_converted);
128 Py_DECREF(pResultOBJ);
129 return(pythonResult);
130
131 }
132 return(NULL);
133 }
134
135
136 static PyObject *
cmsis_arm_power_q15(PyObject * obj,PyObject * args)137 cmsis_arm_power_q15(PyObject *obj, PyObject *args)
138 {
139
140 PyObject *pSrc=NULL; // input
141 q15_t *pSrc_converted=NULL; // input
142 uint32_t blockSize; // input
143 q63_t pResult; // output
144
145 if (PyArg_ParseTuple(args,"O",&pSrc))
146 {
147
148 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
149 blockSize = arraySizepSrc ;
150
151
152
153 arm_power_q15(pSrc_converted,blockSize,&pResult);
154 PyObject* pResultOBJ=Py_BuildValue("L",pResult);
155
156 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
157
158 FREEARGUMENT(pSrc_converted);
159 Py_DECREF(pResultOBJ);
160 return(pythonResult);
161
162 }
163 return(NULL);
164 }
165
166
167 static PyObject *
cmsis_arm_power_q7(PyObject * obj,PyObject * args)168 cmsis_arm_power_q7(PyObject *obj, PyObject *args)
169 {
170
171 PyObject *pSrc=NULL; // input
172 q7_t *pSrc_converted=NULL; // input
173 uint32_t blockSize; // input
174 q31_t pResult; // output
175
176 if (PyArg_ParseTuple(args,"O",&pSrc))
177 {
178
179 GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
180 blockSize = arraySizepSrc ;
181
182
183 arm_power_q7(pSrc_converted,blockSize,&pResult);
184 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
185
186 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
187
188 FREEARGUMENT(pSrc_converted);
189 Py_DECREF(pResultOBJ);
190 return(pythonResult);
191
192 }
193 return(NULL);
194 }
195
196
197 static PyObject *
cmsis_arm_mean_q7(PyObject * obj,PyObject * args)198 cmsis_arm_mean_q7(PyObject *obj, PyObject *args)
199 {
200
201 PyObject *pSrc=NULL; // input
202 q7_t *pSrc_converted=NULL; // input
203 uint32_t blockSize; // input
204 q7_t pResult; // output
205
206 if (PyArg_ParseTuple(args,"O",&pSrc))
207 {
208
209 GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
210 blockSize = arraySizepSrc ;
211
212
213
214 arm_mean_q7(pSrc_converted,blockSize,&pResult);
215 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
216
217 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
218
219 FREEARGUMENT(pSrc_converted);
220 Py_DECREF(pResultOBJ);
221 return(pythonResult);
222
223 }
224 return(NULL);
225 }
226
227
228 static PyObject *
cmsis_arm_mean_q15(PyObject * obj,PyObject * args)229 cmsis_arm_mean_q15(PyObject *obj, PyObject *args)
230 {
231
232 PyObject *pSrc=NULL; // input
233 q15_t *pSrc_converted=NULL; // input
234 uint32_t blockSize; // input
235 q15_t pResult; // output
236
237 if (PyArg_ParseTuple(args,"O",&pSrc))
238 {
239
240 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
241 blockSize = arraySizepSrc ;
242
243
244
245 arm_mean_q15(pSrc_converted,blockSize,&pResult);
246 PyObject* pResultOBJ=Py_BuildValue("h",pResult);
247
248 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
249
250 FREEARGUMENT(pSrc_converted);
251 Py_DECREF(pResultOBJ);
252 return(pythonResult);
253
254 }
255 return(NULL);
256 }
257
258
259 static PyObject *
cmsis_arm_mean_q31(PyObject * obj,PyObject * args)260 cmsis_arm_mean_q31(PyObject *obj, PyObject *args)
261 {
262
263 PyObject *pSrc=NULL; // input
264 q31_t *pSrc_converted=NULL; // input
265 uint32_t blockSize; // input
266 q31_t pResult; // output
267
268 if (PyArg_ParseTuple(args,"O",&pSrc))
269 {
270
271 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
272 blockSize = arraySizepSrc ;
273
274
275
276 arm_mean_q31(pSrc_converted,blockSize,&pResult);
277 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
278
279 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
280
281 FREEARGUMENT(pSrc_converted);
282 Py_DECREF(pResultOBJ);
283 return(pythonResult);
284
285 }
286 return(NULL);
287 }
288
289
290 static PyObject *
cmsis_arm_mean_f32(PyObject * obj,PyObject * args)291 cmsis_arm_mean_f32(PyObject *obj, PyObject *args)
292 {
293
294 PyObject *pSrc=NULL; // input
295 float32_t *pSrc_converted=NULL; // input
296 uint32_t blockSize; // input
297 float32_t pResult; // output
298
299 if (PyArg_ParseTuple(args,"O",&pSrc))
300 {
301
302 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
303 blockSize = arraySizepSrc ;
304
305
306 arm_mean_f32(pSrc_converted,blockSize,&pResult);
307 PyObject* pResultOBJ=Py_BuildValue("f",pResult);
308
309 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
310
311 FREEARGUMENT(pSrc_converted);
312 Py_DECREF(pResultOBJ);
313 return(pythonResult);
314
315 }
316 return(NULL);
317 }
318
319 static PyObject *
cmsis_arm_mean_f64(PyObject * obj,PyObject * args)320 cmsis_arm_mean_f64(PyObject *obj, PyObject *args)
321 {
322
323 PyObject *pSrc=NULL; // input
324 float64_t *pSrc_converted=NULL; // input
325 uint32_t blockSize; // input
326 float64_t pResult; // output
327
328 if (PyArg_ParseTuple(args,"O",&pSrc))
329 {
330
331 GETARGUMENT(pSrc,NPY_DOUBLE,double,float64_t);
332 blockSize = arraySizepSrc ;
333
334
335 arm_mean_f64(pSrc_converted,blockSize,&pResult);
336 PyObject* pResultOBJ=Py_BuildValue("d",pResult);
337
338 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
339
340 FREEARGUMENT(pSrc_converted);
341 Py_DECREF(pResultOBJ);
342 return(pythonResult);
343
344 }
345 return(NULL);
346 }
347
348 static PyObject *
cmsis_arm_var_f32(PyObject * obj,PyObject * args)349 cmsis_arm_var_f32(PyObject *obj, PyObject *args)
350 {
351
352 PyObject *pSrc=NULL; // input
353 float32_t *pSrc_converted=NULL; // input
354 uint32_t blockSize; // input
355 float32_t pResult; // output
356
357 if (PyArg_ParseTuple(args,"O",&pSrc))
358 {
359
360 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
361 blockSize = arraySizepSrc ;
362
363
364
365 arm_var_f32(pSrc_converted,blockSize,&pResult);
366 PyObject* pResultOBJ=Py_BuildValue("f",pResult);
367
368 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
369
370 FREEARGUMENT(pSrc_converted);
371 Py_DECREF(pResultOBJ);
372 return(pythonResult);
373
374 }
375 return(NULL);
376 }
377
378 static PyObject *
cmsis_arm_var_f64(PyObject * obj,PyObject * args)379 cmsis_arm_var_f64(PyObject *obj, PyObject *args)
380 {
381
382 PyObject *pSrc=NULL; // input
383 float64_t *pSrc_converted=NULL; // input
384 uint32_t blockSize; // input
385 float64_t pResult; // output
386
387 if (PyArg_ParseTuple(args,"O",&pSrc))
388 {
389
390 GETARGUMENT(pSrc,NPY_DOUBLE,double,float64_t);
391 blockSize = arraySizepSrc ;
392
393
394
395 arm_var_f64(pSrc_converted,blockSize,&pResult);
396 PyObject* pResultOBJ=Py_BuildValue("d",pResult);
397
398 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
399
400 FREEARGUMENT(pSrc_converted);
401 Py_DECREF(pResultOBJ);
402 return(pythonResult);
403
404 }
405 return(NULL);
406 }
407
408 static PyObject *
cmsis_arm_var_q31(PyObject * obj,PyObject * args)409 cmsis_arm_var_q31(PyObject *obj, PyObject *args)
410 {
411
412 PyObject *pSrc=NULL; // input
413 q31_t *pSrc_converted=NULL; // input
414 uint32_t blockSize; // input
415 q31_t pResult; // output
416
417 if (PyArg_ParseTuple(args,"O",&pSrc))
418 {
419
420 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
421 blockSize = arraySizepSrc ;
422
423
424 arm_var_q31(pSrc_converted,blockSize,&pResult);
425 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
426
427 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
428
429 FREEARGUMENT(pSrc_converted);
430 Py_DECREF(pResultOBJ);
431 return(pythonResult);
432
433 }
434 return(NULL);
435 }
436
437
438 static PyObject *
cmsis_arm_var_q15(PyObject * obj,PyObject * args)439 cmsis_arm_var_q15(PyObject *obj, PyObject *args)
440 {
441
442 PyObject *pSrc=NULL; // input
443 q15_t *pSrc_converted=NULL; // input
444 uint32_t blockSize; // input
445 q15_t pResult; // output
446
447 if (PyArg_ParseTuple(args,"O",&pSrc))
448 {
449
450 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
451 blockSize = arraySizepSrc ;
452
453 arm_var_q15(pSrc_converted,blockSize,&pResult);
454 PyObject* pResultOBJ=Py_BuildValue("h",pResult);
455
456 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
457
458 FREEARGUMENT(pSrc_converted);
459 Py_DECREF(pResultOBJ);
460 return(pythonResult);
461
462 }
463 return(NULL);
464 }
465
466
467 static PyObject *
cmsis_arm_rms_f32(PyObject * obj,PyObject * args)468 cmsis_arm_rms_f32(PyObject *obj, PyObject *args)
469 {
470
471 PyObject *pSrc=NULL; // input
472 float32_t *pSrc_converted=NULL; // input
473 uint32_t blockSize; // input
474 float32_t pResult; // output
475
476 if (PyArg_ParseTuple(args,"O",&pSrc))
477 {
478
479 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
480 blockSize = arraySizepSrc ;
481
482
483
484 arm_rms_f32(pSrc_converted,blockSize,&pResult);
485 PyObject* pResultOBJ=Py_BuildValue("f",pResult);
486
487 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
488
489 FREEARGUMENT(pSrc_converted);
490 Py_DECREF(pResultOBJ);
491 return(pythonResult);
492
493 }
494 return(NULL);
495 }
496
497
498 static PyObject *
cmsis_arm_rms_q31(PyObject * obj,PyObject * args)499 cmsis_arm_rms_q31(PyObject *obj, PyObject *args)
500 {
501
502 PyObject *pSrc=NULL; // input
503 q31_t *pSrc_converted=NULL; // input
504 uint32_t blockSize; // input
505 q31_t pResult; // output
506
507 if (PyArg_ParseTuple(args,"O",&pSrc))
508 {
509
510 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
511 blockSize = arraySizepSrc ;
512
513 arm_rms_q31(pSrc_converted,blockSize,&pResult);
514 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
515
516 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
517
518 FREEARGUMENT(pSrc_converted);
519 Py_DECREF(pResultOBJ);
520 return(pythonResult);
521
522 }
523 return(NULL);
524 }
525
526
527 static PyObject *
cmsis_arm_rms_q15(PyObject * obj,PyObject * args)528 cmsis_arm_rms_q15(PyObject *obj, PyObject *args)
529 {
530
531 PyObject *pSrc=NULL; // input
532 q15_t *pSrc_converted=NULL; // input
533 uint32_t blockSize; // input
534 q15_t pResult; // output
535
536 if (PyArg_ParseTuple(args,"O",&pSrc))
537 {
538
539 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
540 blockSize = arraySizepSrc ;
541
542
543 arm_rms_q15(pSrc_converted,blockSize,&pResult);
544 PyObject* pResultOBJ=Py_BuildValue("h",pResult);
545
546 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
547
548 FREEARGUMENT(pSrc_converted);
549 Py_DECREF(pResultOBJ);
550 return(pythonResult);
551
552 }
553 return(NULL);
554 }
555
556
557 static PyObject *
cmsis_arm_std_f32(PyObject * obj,PyObject * args)558 cmsis_arm_std_f32(PyObject *obj, PyObject *args)
559 {
560
561 PyObject *pSrc=NULL; // input
562 float32_t *pSrc_converted=NULL; // input
563 uint32_t blockSize; // input
564 float32_t pResult; // output
565
566 if (PyArg_ParseTuple(args,"O",&pSrc))
567 {
568
569 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
570 blockSize = arraySizepSrc ;
571
572
573
574 arm_std_f32(pSrc_converted,blockSize,&pResult);
575 PyObject* pResultOBJ=Py_BuildValue("f",pResult);
576
577 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
578
579 FREEARGUMENT(pSrc_converted);
580 Py_DECREF(pResultOBJ);
581 return(pythonResult);
582
583 }
584 return(NULL);
585 }
586
587 static PyObject *
cmsis_arm_std_f64(PyObject * obj,PyObject * args)588 cmsis_arm_std_f64(PyObject *obj, PyObject *args)
589 {
590
591 PyObject *pSrc=NULL; // input
592 float64_t *pSrc_converted=NULL; // input
593 uint32_t blockSize; // input
594 float64_t pResult; // output
595
596 if (PyArg_ParseTuple(args,"O",&pSrc))
597 {
598
599 GETARGUMENT(pSrc,NPY_DOUBLE,double,float64_t);
600 blockSize = arraySizepSrc ;
601
602
603
604 arm_std_f64(pSrc_converted,blockSize,&pResult);
605 PyObject* pResultOBJ=Py_BuildValue("d",pResult);
606
607 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
608
609 FREEARGUMENT(pSrc_converted);
610 Py_DECREF(pResultOBJ);
611 return(pythonResult);
612
613 }
614 return(NULL);
615 }
616
617
618 static PyObject *
cmsis_arm_std_q31(PyObject * obj,PyObject * args)619 cmsis_arm_std_q31(PyObject *obj, PyObject *args)
620 {
621
622 PyObject *pSrc=NULL; // input
623 q31_t *pSrc_converted=NULL; // input
624 uint32_t blockSize; // input
625 q31_t pResult; // output
626
627 if (PyArg_ParseTuple(args,"O",&pSrc))
628 {
629
630 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
631 blockSize = arraySizepSrc ;
632
633 arm_std_q31(pSrc_converted,blockSize,&pResult);
634 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
635
636 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
637
638 FREEARGUMENT(pSrc_converted);
639 Py_DECREF(pResultOBJ);
640 return(pythonResult);
641
642 }
643 return(NULL);
644 }
645
646
647 static PyObject *
cmsis_arm_std_q15(PyObject * obj,PyObject * args)648 cmsis_arm_std_q15(PyObject *obj, PyObject *args)
649 {
650
651 PyObject *pSrc=NULL; // input
652 q15_t *pSrc_converted=NULL; // input
653 uint32_t blockSize; // input
654 q15_t pResult; // output
655
656 if (PyArg_ParseTuple(args,"O",&pSrc))
657 {
658
659 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
660 blockSize = arraySizepSrc ;
661
662 arm_std_q15(pSrc_converted,blockSize,&pResult);
663 PyObject* pResultOBJ=Py_BuildValue("h",pResult);
664
665 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
666
667 FREEARGUMENT(pSrc_converted);
668 Py_DECREF(pResultOBJ);
669 return(pythonResult);
670
671 }
672 return(NULL);
673 }
674
675
676
677
678 static PyObject *
cmsis_arm_min_q7(PyObject * obj,PyObject * args)679 cmsis_arm_min_q7(PyObject *obj, PyObject *args)
680 {
681 PyObject *pSrc=NULL; // input
682 q7_t *pSrc_converted=NULL; // input
683 uint32_t blockSize; // input
684 q7_t pResult; // output
685 uint32_t pIndex; // output
686
687 if (PyArg_ParseTuple(args,"O",&pSrc))
688 {
689
690 GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
691 blockSize = arraySizepSrc ;
692
693
694 arm_min_q7(pSrc_converted,blockSize,&pResult,&pIndex);
695 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
696 PyObject* pIndexOBJ=Py_BuildValue("i",pIndex);
697
698 PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
699
700 FREEARGUMENT(pSrc_converted);
701 Py_DECREF(pResultOBJ);
702 Py_DECREF(pIndexOBJ);
703 return(pythonResult);
704
705 }
706 return(NULL);
707 }
708
709 static PyObject *
cmsis_arm_min_no_idx_q7(PyObject * obj,PyObject * args)710 cmsis_arm_min_no_idx_q7(PyObject *obj, PyObject *args)
711 {
712 PyObject *pSrc=NULL; // input
713 q7_t *pSrc_converted=NULL; // input
714 uint32_t blockSize; // input
715 q7_t pResult;
716
717 if (PyArg_ParseTuple(args,"O",&pSrc))
718 {
719
720 GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
721 blockSize = arraySizepSrc ;
722
723
724
725 arm_min_no_idx_q7(pSrc_converted,blockSize,&pResult);
726 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
727
728
729 FREEARGUMENT(pSrc_converted);
730 return(pResultOBJ);
731
732 }
733 return(NULL);
734 }
735
736 static PyObject *
cmsis_arm_absmin_q7(PyObject * obj,PyObject * args)737 cmsis_arm_absmin_q7(PyObject *obj, PyObject *args)
738 {
739 PyObject *pSrc=NULL; // input
740 q7_t *pSrc_converted=NULL; // input
741 uint32_t blockSize; // input
742 q7_t pResult; // output
743 uint32_t pIndex; // output
744
745 if (PyArg_ParseTuple(args,"O",&pSrc))
746 {
747
748 GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
749 blockSize = arraySizepSrc ;
750
751
752 arm_absmin_q7(pSrc_converted,blockSize,&pResult,&pIndex);
753 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
754 PyObject* pIndexOBJ=Py_BuildValue("i",pIndex);
755
756 PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
757
758 FREEARGUMENT(pSrc_converted);
759 Py_DECREF(pResultOBJ);
760 Py_DECREF(pIndexOBJ);
761 return(pythonResult);
762
763 }
764 return(NULL);
765 }
766
767 static PyObject *
cmsis_arm_absmin_no_idx_q7(PyObject * obj,PyObject * args)768 cmsis_arm_absmin_no_idx_q7(PyObject *obj, PyObject *args)
769 {
770 PyObject *pSrc=NULL; // input
771 q7_t *pSrc_converted=NULL; // input
772 uint32_t blockSize; // input
773 q7_t pResult; // output
774
775 if (PyArg_ParseTuple(args,"O",&pSrc))
776 {
777
778 GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
779 blockSize = arraySizepSrc ;
780
781
782
783
784
785 arm_absmin_no_idx_q7(pSrc_converted,blockSize,&pResult);
786 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
787
788
789 FREEARGUMENT(pSrc_converted);
790 return(pResultOBJ);
791
792 }
793 return(NULL);
794 }
795
796
797 static PyObject *
cmsis_arm_min_q15(PyObject * obj,PyObject * args)798 cmsis_arm_min_q15(PyObject *obj, PyObject *args)
799 {
800
801 PyObject *pSrc=NULL; // input
802 q15_t *pSrc_converted=NULL; // input
803 uint32_t blockSize; // input
804 q15_t pResult; // output
805 uint32_t pIndex; // output
806
807 if (PyArg_ParseTuple(args,"O",&pSrc))
808 {
809
810 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
811 blockSize = arraySizepSrc ;
812
813
814 arm_min_q15(pSrc_converted,blockSize,&pResult,&pIndex);
815 PyObject* pResultOBJ=Py_BuildValue("h",pResult);
816 PyObject* pIndexOBJ=Py_BuildValue("i",pIndex);
817
818 PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
819
820 FREEARGUMENT(pSrc_converted);
821 Py_DECREF(pResultOBJ);
822 Py_DECREF(pIndexOBJ);
823 return(pythonResult);
824
825 }
826 return(NULL);
827 }
828
829 static PyObject *
cmsis_arm_min_no_idx_q15(PyObject * obj,PyObject * args)830 cmsis_arm_min_no_idx_q15(PyObject *obj, PyObject *args)
831 {
832
833 PyObject *pSrc=NULL; // input
834 q15_t *pSrc_converted=NULL; // input
835 uint32_t blockSize; // input
836 q15_t pResult; // output
837
838 if (PyArg_ParseTuple(args,"O",&pSrc))
839 {
840
841 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
842 blockSize = arraySizepSrc ;
843
844
845
846
847
848 arm_min_no_idx_q15(pSrc_converted,blockSize,&pResult);
849 PyObject* pResultOBJ=Py_BuildValue("h",pResult);
850
851
852 FREEARGUMENT(pSrc_converted);
853 return(pResultOBJ);
854
855 }
856 return(NULL);
857 }
858
859 static PyObject *
cmsis_arm_absmin_q15(PyObject * obj,PyObject * args)860 cmsis_arm_absmin_q15(PyObject *obj, PyObject *args)
861 {
862
863 PyObject *pSrc=NULL; // input
864 q15_t *pSrc_converted=NULL; // input
865 uint32_t blockSize; // input
866 q15_t pResult; // output
867 uint32_t pIndex; // output
868
869 if (PyArg_ParseTuple(args,"O",&pSrc))
870 {
871
872 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
873 blockSize = arraySizepSrc ;
874
875 arm_absmin_q15(pSrc_converted,blockSize,&pResult,&pIndex);
876 PyObject* pResultOBJ=Py_BuildValue("h",pResult);
877 PyObject* pIndexOBJ=Py_BuildValue("i",pIndex);
878
879 PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
880
881 FREEARGUMENT(pSrc_converted);
882 Py_DECREF(pResultOBJ);
883 Py_DECREF(pIndexOBJ);
884 return(pythonResult);
885
886 }
887 return(NULL);
888 }
889
890 static PyObject *
cmsis_arm_absmin_no_idx_q15(PyObject * obj,PyObject * args)891 cmsis_arm_absmin_no_idx_q15(PyObject *obj, PyObject *args)
892 {
893
894 PyObject *pSrc=NULL; // input
895 q15_t *pSrc_converted=NULL; // input
896 uint32_t blockSize; // input
897 q15_t pResult; // output
898
899 if (PyArg_ParseTuple(args,"O",&pSrc))
900 {
901
902 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
903 blockSize = arraySizepSrc ;
904
905
906
907
908
909 arm_absmin_no_idx_q15(pSrc_converted,blockSize,&pResult);
910 PyObject* pResultOBJ=Py_BuildValue("h",pResult);
911
912
913 FREEARGUMENT(pSrc_converted);
914 return(pResultOBJ);
915
916 }
917 return(NULL);
918 }
919
920
921 static PyObject *
cmsis_arm_min_q31(PyObject * obj,PyObject * args)922 cmsis_arm_min_q31(PyObject *obj, PyObject *args)
923 {
924
925 PyObject *pSrc=NULL; // input
926 q31_t *pSrc_converted=NULL; // input
927 uint32_t blockSize; // input
928 q31_t pResult; // output
929 uint32_t pIndex; // output
930
931 if (PyArg_ParseTuple(args,"O",&pSrc))
932 {
933
934 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
935 blockSize = arraySizepSrc ;
936
937 arm_min_q31(pSrc_converted,blockSize,&pResult,&pIndex);
938 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
939 PyObject* pIndexOBJ=Py_BuildValue("i",pIndex);
940
941 PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
942
943 FREEARGUMENT(pSrc_converted);
944 Py_DECREF(pResultOBJ);
945 Py_DECREF(pIndexOBJ);
946 return(pythonResult);
947
948 }
949 return(NULL);
950 }
951
952 static PyObject *
cmsis_arm_min_no_idx_q31(PyObject * obj,PyObject * args)953 cmsis_arm_min_no_idx_q31(PyObject *obj, PyObject *args)
954 {
955
956 PyObject *pSrc=NULL; // input
957 q31_t *pSrc_converted=NULL; // input
958 uint32_t blockSize; // input
959 q31_t pResult; // output
960
961 if (PyArg_ParseTuple(args,"O",&pSrc))
962 {
963
964 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
965 blockSize = arraySizepSrc ;
966
967
968
969
970
971 arm_min_no_idx_q31(pSrc_converted,blockSize,&pResult);
972 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
973
974
975 FREEARGUMENT(pSrc_converted);
976 return(pResultOBJ);
977
978 }
979 return(NULL);
980 }
981
982 static PyObject *
cmsis_arm_absmin_q31(PyObject * obj,PyObject * args)983 cmsis_arm_absmin_q31(PyObject *obj, PyObject *args)
984 {
985
986 PyObject *pSrc=NULL; // input
987 q31_t *pSrc_converted=NULL; // input
988 uint32_t blockSize; // input
989 q31_t pResult; // output
990 uint32_t pIndex; // output
991
992 if (PyArg_ParseTuple(args,"O",&pSrc))
993 {
994
995 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
996 blockSize = arraySizepSrc ;
997
998
999 arm_absmin_q31(pSrc_converted,blockSize,&pResult,&pIndex);
1000 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
1001 PyObject* pIndexOBJ=Py_BuildValue("i",pIndex);
1002
1003 PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
1004
1005 FREEARGUMENT(pSrc_converted);
1006 Py_DECREF(pResultOBJ);
1007 Py_DECREF(pIndexOBJ);
1008 return(pythonResult);
1009
1010 }
1011 return(NULL);
1012 }
1013
1014 static PyObject *
cmsis_arm_absmin_no_idx_q31(PyObject * obj,PyObject * args)1015 cmsis_arm_absmin_no_idx_q31(PyObject *obj, PyObject *args)
1016 {
1017
1018 PyObject *pSrc=NULL; // input
1019 q31_t *pSrc_converted=NULL; // input
1020 uint32_t blockSize; // input
1021 q31_t pResult; // output
1022
1023 if (PyArg_ParseTuple(args,"O",&pSrc))
1024 {
1025
1026 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
1027 blockSize = arraySizepSrc ;
1028
1029
1030
1031
1032 arm_absmin_no_idx_q31(pSrc_converted,blockSize,&pResult);
1033 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
1034
1035
1036 FREEARGUMENT(pSrc_converted);
1037 return(pResultOBJ);
1038
1039 }
1040 return(NULL);
1041 }
1042
1043
1044 static PyObject *
cmsis_arm_min_f32(PyObject * obj,PyObject * args)1045 cmsis_arm_min_f32(PyObject *obj, PyObject *args)
1046 {
1047
1048 PyObject *pSrc=NULL; // input
1049 float32_t *pSrc_converted=NULL; // input
1050 uint32_t blockSize; // input
1051 float32_t pResult; // output
1052 uint32_t pIndex; // output
1053
1054 if (PyArg_ParseTuple(args,"O",&pSrc))
1055 {
1056
1057 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
1058 blockSize = arraySizepSrc ;
1059
1060
1061 arm_min_f32(pSrc_converted,blockSize,&pResult,&pIndex);
1062 PyObject* pResultOBJ=Py_BuildValue("f",pResult);
1063 PyObject* pIndexOBJ=Py_BuildValue("i",pIndex);
1064
1065 PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
1066
1067 FREEARGUMENT(pSrc_converted);
1068 Py_DECREF(pResultOBJ);
1069 Py_DECREF(pIndexOBJ);
1070 return(pythonResult);
1071
1072 }
1073 return(NULL);
1074 }
1075
1076 static PyObject *
cmsis_arm_min_f64(PyObject * obj,PyObject * args)1077 cmsis_arm_min_f64(PyObject *obj, PyObject *args)
1078 {
1079
1080 PyObject *pSrc=NULL; // input
1081 float64_t *pSrc_converted=NULL; // input
1082 uint32_t blockSize; // input
1083 float64_t pResult; // output
1084 uint32_t pIndex; // output
1085
1086 if (PyArg_ParseTuple(args,"O",&pSrc))
1087 {
1088
1089 GETARGUMENT(pSrc,NPY_DOUBLE,double,float64_t);
1090 blockSize = arraySizepSrc ;
1091
1092
1093 arm_min_f64(pSrc_converted,blockSize,&pResult,&pIndex);
1094 PyObject* pResultOBJ=Py_BuildValue("d",pResult);
1095 PyObject* pIndexOBJ=Py_BuildValue("i",pIndex);
1096
1097 PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
1098
1099 FREEARGUMENT(pSrc_converted);
1100 Py_DECREF(pResultOBJ);
1101 Py_DECREF(pIndexOBJ);
1102 return(pythonResult);
1103
1104 }
1105 return(NULL);
1106 }
1107
1108 static PyObject *
cmsis_arm_min_no_idx_f32(PyObject * obj,PyObject * args)1109 cmsis_arm_min_no_idx_f32(PyObject *obj, PyObject *args)
1110 {
1111
1112 PyObject *pSrc=NULL; // input
1113 float32_t *pSrc_converted=NULL; // input
1114 uint32_t blockSize; // input
1115 float32_t pResult; // output
1116
1117 if (PyArg_ParseTuple(args,"O",&pSrc))
1118 {
1119
1120 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
1121 blockSize = arraySizepSrc ;
1122
1123
1124 arm_min_no_idx_f32(pSrc_converted,blockSize,&pResult);
1125 PyObject* pResultOBJ=Py_BuildValue("f",pResult);
1126
1127 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
1128
1129 FREEARGUMENT(pSrc_converted);
1130 Py_DECREF(pResultOBJ);
1131 return(pythonResult);
1132
1133 }
1134 return(NULL);
1135 }
1136
1137 static PyObject *
cmsis_arm_min_no_idx_f64(PyObject * obj,PyObject * args)1138 cmsis_arm_min_no_idx_f64(PyObject *obj, PyObject *args)
1139 {
1140
1141 PyObject *pSrc=NULL; // input
1142 float64_t *pSrc_converted=NULL; // input
1143 uint32_t blockSize; // input
1144 float64_t pResult; // output
1145
1146 if (PyArg_ParseTuple(args,"O",&pSrc))
1147 {
1148
1149 GETARGUMENT(pSrc,NPY_DOUBLE,double,float64_t);
1150 blockSize = arraySizepSrc ;
1151
1152
1153 arm_min_no_idx_f64(pSrc_converted,blockSize,&pResult);
1154 PyObject* pResultOBJ=Py_BuildValue("d",pResult);
1155
1156 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
1157
1158 FREEARGUMENT(pSrc_converted);
1159 Py_DECREF(pResultOBJ);
1160 return(pythonResult);
1161
1162 }
1163 return(NULL);
1164 }
1165
1166 static PyObject *
cmsis_arm_absmin_f32(PyObject * obj,PyObject * args)1167 cmsis_arm_absmin_f32(PyObject *obj, PyObject *args)
1168 {
1169
1170 PyObject *pSrc=NULL; // input
1171 float32_t *pSrc_converted=NULL; // input
1172 uint32_t blockSize; // input
1173 float32_t pResult; // output
1174 uint32_t pIndex; // output
1175
1176 if (PyArg_ParseTuple(args,"O",&pSrc))
1177 {
1178
1179 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
1180 blockSize = arraySizepSrc ;
1181
1182
1183 arm_absmin_f32(pSrc_converted,blockSize,&pResult,&pIndex);
1184 PyObject* pResultOBJ=Py_BuildValue("f",pResult);
1185 PyObject* pIndexOBJ=Py_BuildValue("i",pIndex);
1186
1187 PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
1188
1189 FREEARGUMENT(pSrc_converted);
1190 Py_DECREF(pResultOBJ);
1191 Py_DECREF(pIndexOBJ);
1192 return(pythonResult);
1193
1194 }
1195 return(NULL);
1196 }
1197
1198 static PyObject *
cmsis_arm_absmin_f64(PyObject * obj,PyObject * args)1199 cmsis_arm_absmin_f64(PyObject *obj, PyObject *args)
1200 {
1201
1202 PyObject *pSrc=NULL; // input
1203 float64_t *pSrc_converted=NULL; // input
1204 uint32_t blockSize; // input
1205 float64_t pResult; // output
1206 uint32_t pIndex; // output
1207
1208 if (PyArg_ParseTuple(args,"O",&pSrc))
1209 {
1210
1211 GETARGUMENT(pSrc,NPY_DOUBLE,double,float64_t);
1212 blockSize = arraySizepSrc ;
1213
1214
1215 arm_absmin_f64(pSrc_converted,blockSize,&pResult,&pIndex);
1216 PyObject* pResultOBJ=Py_BuildValue("d",pResult);
1217 PyObject* pIndexOBJ=Py_BuildValue("i",pIndex);
1218
1219 PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
1220
1221 FREEARGUMENT(pSrc_converted);
1222 Py_DECREF(pResultOBJ);
1223 Py_DECREF(pIndexOBJ);
1224 return(pythonResult);
1225
1226 }
1227 return(NULL);
1228 }
1229
1230 static PyObject *
cmsis_arm_absmin_no_idx_f32(PyObject * obj,PyObject * args)1231 cmsis_arm_absmin_no_idx_f32(PyObject *obj, PyObject *args)
1232 {
1233
1234 PyObject *pSrc=NULL; // input
1235 float32_t *pSrc_converted=NULL; // input
1236 uint32_t blockSize; // input
1237 float32_t pResult; // output
1238
1239 if (PyArg_ParseTuple(args,"O",&pSrc))
1240 {
1241
1242 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
1243 blockSize = arraySizepSrc ;
1244
1245 arm_absmin_no_idx_f32(pSrc_converted,blockSize,&pResult);
1246 PyObject* pResultOBJ=Py_BuildValue("f",pResult);
1247
1248 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
1249
1250 FREEARGUMENT(pSrc_converted);
1251 Py_DECREF(pResultOBJ);
1252 return(pythonResult);
1253
1254 }
1255 return(NULL);
1256 }
1257
1258 static PyObject *
cmsis_arm_absmin_no_idx_f64(PyObject * obj,PyObject * args)1259 cmsis_arm_absmin_no_idx_f64(PyObject *obj, PyObject *args)
1260 {
1261
1262 PyObject *pSrc=NULL; // input
1263 float64_t *pSrc_converted=NULL; // input
1264 uint32_t blockSize; // input
1265 float64_t pResult; // output
1266
1267 if (PyArg_ParseTuple(args,"O",&pSrc))
1268 {
1269
1270 GETARGUMENT(pSrc,NPY_DOUBLE,double,float64_t);
1271 blockSize = arraySizepSrc ;
1272
1273 arm_absmin_no_idx_f64(pSrc_converted,blockSize,&pResult);
1274 PyObject* pResultOBJ=Py_BuildValue("d",pResult);
1275
1276 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
1277
1278 FREEARGUMENT(pSrc_converted);
1279 Py_DECREF(pResultOBJ);
1280 return(pythonResult);
1281
1282 }
1283 return(NULL);
1284 }
1285
1286
1287 static PyObject *
cmsis_arm_max_q7(PyObject * obj,PyObject * args)1288 cmsis_arm_max_q7(PyObject *obj, PyObject *args)
1289 {
1290
1291 PyObject *pSrc=NULL; // input
1292 q7_t *pSrc_converted=NULL; // input
1293 uint32_t blockSize; // input
1294 q7_t pResult; // output
1295 uint32_t pIndex; // output
1296
1297 if (PyArg_ParseTuple(args,"O",&pSrc))
1298 {
1299
1300 GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
1301 blockSize = arraySizepSrc ;
1302
1303
1304 arm_max_q7(pSrc_converted,blockSize,&pResult,&pIndex);
1305 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
1306 PyObject* pIndexOBJ=Py_BuildValue("i",pIndex);
1307
1308 PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
1309
1310 FREEARGUMENT(pSrc_converted);
1311 Py_DECREF(pResultOBJ);
1312 Py_DECREF(pIndexOBJ);
1313 return(pythonResult);
1314
1315 }
1316 return(NULL);
1317 }
1318
1319 static PyObject *
cmsis_arm_max_no_idx_q7(PyObject * obj,PyObject * args)1320 cmsis_arm_max_no_idx_q7(PyObject *obj, PyObject *args)
1321 {
1322
1323 PyObject *pSrc=NULL; // input
1324 q7_t *pSrc_converted=NULL; // input
1325 uint32_t blockSize; // input
1326 q7_t pResult; // output
1327
1328 if (PyArg_ParseTuple(args,"O",&pSrc))
1329 {
1330
1331 GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
1332 blockSize = arraySizepSrc ;
1333
1334
1335
1336
1337
1338 arm_max_no_idx_q7(pSrc_converted,blockSize,&pResult);
1339 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
1340
1341
1342 FREEARGUMENT(pSrc_converted);
1343 return(pResultOBJ);
1344
1345 }
1346 return(NULL);
1347 }
1348
1349 static PyObject *
cmsis_arm_absmax_q7(PyObject * obj,PyObject * args)1350 cmsis_arm_absmax_q7(PyObject *obj, PyObject *args)
1351 {
1352
1353 PyObject *pSrc=NULL; // input
1354 q7_t *pSrc_converted=NULL; // input
1355 uint32_t blockSize; // input
1356 q7_t pResult; // output
1357 uint32_t pIndex; // output
1358
1359 if (PyArg_ParseTuple(args,"O",&pSrc))
1360 {
1361
1362 GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
1363 blockSize = arraySizepSrc ;
1364
1365
1366 arm_absmax_q7(pSrc_converted,blockSize,&pResult,&pIndex);
1367 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
1368 PyObject* pIndexOBJ=Py_BuildValue("i",pIndex);
1369
1370 PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
1371
1372 FREEARGUMENT(pSrc_converted);
1373 Py_DECREF(pResultOBJ);
1374 Py_DECREF(pIndexOBJ);
1375 return(pythonResult);
1376
1377 }
1378 return(NULL);
1379 }
1380
1381 static PyObject *
cmsis_arm_absmax_no_idx_q7(PyObject * obj,PyObject * args)1382 cmsis_arm_absmax_no_idx_q7(PyObject *obj, PyObject *args)
1383 {
1384
1385 PyObject *pSrc=NULL; // input
1386 q7_t *pSrc_converted=NULL; // input
1387 uint32_t blockSize; // input
1388 q7_t pResult; // output
1389
1390 if (PyArg_ParseTuple(args,"O",&pSrc))
1391 {
1392
1393 GETARGUMENT(pSrc,NPY_BYTE,int8_t,q7_t);
1394 blockSize = arraySizepSrc ;
1395
1396
1397
1398
1399
1400 arm_absmax_no_idx_q7(pSrc_converted,blockSize,&pResult);
1401 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
1402
1403
1404 FREEARGUMENT(pSrc_converted);
1405 return(pResultOBJ);
1406
1407 }
1408 return(NULL);
1409 }
1410
1411
1412 static PyObject *
cmsis_arm_max_q15(PyObject * obj,PyObject * args)1413 cmsis_arm_max_q15(PyObject *obj, PyObject *args)
1414 {
1415
1416 PyObject *pSrc=NULL; // input
1417 q15_t *pSrc_converted=NULL; // input
1418 uint32_t blockSize; // input
1419 q15_t pResult; // output
1420 uint32_t pIndex; // output
1421
1422 if (PyArg_ParseTuple(args,"O",&pSrc))
1423 {
1424
1425 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
1426 blockSize = arraySizepSrc ;
1427
1428
1429 arm_max_q15(pSrc_converted,blockSize,&pResult,&pIndex);
1430 PyObject* pResultOBJ=Py_BuildValue("h",pResult);
1431 PyObject* pIndexOBJ=Py_BuildValue("i",pIndex);
1432
1433 PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
1434
1435 FREEARGUMENT(pSrc_converted);
1436 Py_DECREF(pResultOBJ);
1437 Py_DECREF(pIndexOBJ);
1438 return(pythonResult);
1439
1440 }
1441 return(NULL);
1442 }
1443
1444 static PyObject *
cmsis_arm_max_no_idx_q15(PyObject * obj,PyObject * args)1445 cmsis_arm_max_no_idx_q15(PyObject *obj, PyObject *args)
1446 {
1447
1448 PyObject *pSrc=NULL; // input
1449 q15_t *pSrc_converted=NULL; // input
1450 uint32_t blockSize; // input
1451 q15_t pResult; // output
1452
1453 if (PyArg_ParseTuple(args,"O",&pSrc))
1454 {
1455
1456 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
1457 blockSize = arraySizepSrc ;
1458
1459
1460
1461
1462
1463 arm_max_no_idx_q15(pSrc_converted,blockSize,&pResult);
1464 PyObject* pResultOBJ=Py_BuildValue("h",pResult);
1465
1466
1467 FREEARGUMENT(pSrc_converted);
1468 return(pResultOBJ);
1469
1470 }
1471 return(NULL);
1472 }
1473
1474 static PyObject *
cmsis_arm_absmax_q15(PyObject * obj,PyObject * args)1475 cmsis_arm_absmax_q15(PyObject *obj, PyObject *args)
1476 {
1477
1478 PyObject *pSrc=NULL; // input
1479 q15_t *pSrc_converted=NULL; // input
1480 uint32_t blockSize; // input
1481 q15_t pResult; // output
1482 uint32_t pIndex; // output
1483
1484 if (PyArg_ParseTuple(args,"O",&pSrc))
1485 {
1486
1487 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
1488 blockSize = arraySizepSrc ;
1489
1490 arm_absmax_q15(pSrc_converted,blockSize,&pResult,&pIndex);
1491 PyObject* pResultOBJ=Py_BuildValue("h",pResult);
1492 PyObject* pIndexOBJ=Py_BuildValue("i",pIndex);
1493
1494 PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
1495
1496 FREEARGUMENT(pSrc_converted);
1497 Py_DECREF(pResultOBJ);
1498 Py_DECREF(pIndexOBJ);
1499 return(pythonResult);
1500
1501 }
1502 return(NULL);
1503 }
1504
1505 static PyObject *
cmsis_arm_absmax_no_idx_q15(PyObject * obj,PyObject * args)1506 cmsis_arm_absmax_no_idx_q15(PyObject *obj, PyObject *args)
1507 {
1508
1509 PyObject *pSrc=NULL; // input
1510 q15_t *pSrc_converted=NULL; // input
1511 uint32_t blockSize; // input
1512 q15_t pResult; // output
1513
1514 if (PyArg_ParseTuple(args,"O",&pSrc))
1515 {
1516
1517 GETARGUMENT(pSrc,NPY_INT16,int16_t,int16_t);
1518 blockSize = arraySizepSrc ;
1519
1520
1521
1522
1523 arm_absmax_no_idx_q15(pSrc_converted,blockSize,&pResult);
1524 PyObject* pResultOBJ=Py_BuildValue("h",pResult);
1525
1526
1527 FREEARGUMENT(pSrc_converted);
1528 return(pResultOBJ);
1529
1530 }
1531 return(NULL);
1532 }
1533
1534
1535 static PyObject *
cmsis_arm_max_q31(PyObject * obj,PyObject * args)1536 cmsis_arm_max_q31(PyObject *obj, PyObject *args)
1537 {
1538
1539 PyObject *pSrc=NULL; // input
1540 q31_t *pSrc_converted=NULL; // input
1541 uint32_t blockSize; // input
1542 q31_t pResult; // output
1543 uint32_t pIndex; // output
1544
1545 if (PyArg_ParseTuple(args,"O",&pSrc))
1546 {
1547
1548 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
1549 blockSize = arraySizepSrc ;
1550
1551 arm_max_q31(pSrc_converted,blockSize,&pResult,&pIndex);
1552 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
1553 PyObject* pIndexOBJ=Py_BuildValue("i",pIndex);
1554
1555 PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
1556
1557 FREEARGUMENT(pSrc_converted);
1558 Py_DECREF(pResultOBJ);
1559 Py_DECREF(pIndexOBJ);
1560 return(pythonResult);
1561
1562 }
1563 return(NULL);
1564 }
1565
1566 static PyObject *
cmsis_arm_max_no_idx_q31(PyObject * obj,PyObject * args)1567 cmsis_arm_max_no_idx_q31(PyObject *obj, PyObject *args)
1568 {
1569
1570 PyObject *pSrc=NULL; // input
1571 q31_t *pSrc_converted=NULL; // input
1572 uint32_t blockSize; // input
1573 q31_t pResult; // output
1574
1575 if (PyArg_ParseTuple(args,"O",&pSrc))
1576 {
1577
1578 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
1579 blockSize = arraySizepSrc ;
1580
1581
1582
1583
1584
1585 arm_max_no_idx_q31(pSrc_converted,blockSize,&pResult);
1586 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
1587
1588
1589 FREEARGUMENT(pSrc_converted);
1590 return(pResultOBJ);
1591
1592 }
1593 return(NULL);
1594 }
1595
1596 static PyObject *
cmsis_arm_absmax_q31(PyObject * obj,PyObject * args)1597 cmsis_arm_absmax_q31(PyObject *obj, PyObject *args)
1598 {
1599
1600 PyObject *pSrc=NULL; // input
1601 q31_t *pSrc_converted=NULL; // input
1602 uint32_t blockSize; // input
1603 q31_t pResult; // output
1604 uint32_t pIndex; // output
1605
1606 if (PyArg_ParseTuple(args,"O",&pSrc))
1607 {
1608
1609 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
1610 blockSize = arraySizepSrc ;
1611
1612 arm_absmax_q31(pSrc_converted,blockSize,&pResult,&pIndex);
1613 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
1614 PyObject* pIndexOBJ=Py_BuildValue("i",pIndex);
1615
1616 PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
1617
1618 FREEARGUMENT(pSrc_converted);
1619 Py_DECREF(pResultOBJ);
1620 Py_DECREF(pIndexOBJ);
1621 return(pythonResult);
1622
1623 }
1624 return(NULL);
1625 }
1626
1627 static PyObject *
cmsis_arm_absmax_no_idx_q31(PyObject * obj,PyObject * args)1628 cmsis_arm_absmax_no_idx_q31(PyObject *obj, PyObject *args)
1629 {
1630
1631 PyObject *pSrc=NULL; // input
1632 q31_t *pSrc_converted=NULL; // input
1633 uint32_t blockSize; // input
1634 q31_t pResult; // output
1635
1636 if (PyArg_ParseTuple(args,"O",&pSrc))
1637 {
1638
1639 GETARGUMENT(pSrc,NPY_INT32,int32_t,int32_t);
1640 blockSize = arraySizepSrc ;
1641
1642
1643
1644
1645 arm_absmax_no_idx_q31(pSrc_converted,blockSize,&pResult);
1646 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
1647
1648
1649 FREEARGUMENT(pSrc_converted);
1650 return(pResultOBJ);
1651
1652 }
1653 return(NULL);
1654 }
1655
1656
1657 static PyObject *
cmsis_arm_max_f32(PyObject * obj,PyObject * args)1658 cmsis_arm_max_f32(PyObject *obj, PyObject *args)
1659 {
1660
1661 PyObject *pSrc=NULL; // input
1662 float32_t *pSrc_converted=NULL; // input
1663 uint32_t blockSize; // input
1664 float32_t pResult; // output
1665 uint32_t pIndex; // output
1666
1667 if (PyArg_ParseTuple(args,"O",&pSrc))
1668 {
1669
1670 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
1671 blockSize = arraySizepSrc ;
1672
1673
1674 arm_max_f32(pSrc_converted,blockSize,&pResult,&pIndex);
1675 PyObject* pResultOBJ=Py_BuildValue("f",pResult);
1676 PyObject* pIndexOBJ=Py_BuildValue("i",pIndex);
1677
1678 PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
1679
1680 FREEARGUMENT(pSrc_converted);
1681 Py_DECREF(pResultOBJ);
1682 Py_DECREF(pIndexOBJ);
1683 return(pythonResult);
1684
1685 }
1686 return(NULL);
1687 }
1688
1689 static PyObject *
cmsis_arm_max_f64(PyObject * obj,PyObject * args)1690 cmsis_arm_max_f64(PyObject *obj, PyObject *args)
1691 {
1692
1693 PyObject *pSrc=NULL; // input
1694 float64_t *pSrc_converted=NULL; // input
1695 uint32_t blockSize; // input
1696 float64_t pResult; // output
1697 uint32_t pIndex; // output
1698
1699 if (PyArg_ParseTuple(args,"O",&pSrc))
1700 {
1701
1702 GETARGUMENT(pSrc,NPY_DOUBLE,double,float64_t);
1703 blockSize = arraySizepSrc ;
1704
1705
1706 arm_max_f64(pSrc_converted,blockSize,&pResult,&pIndex);
1707 PyObject* pResultOBJ=Py_BuildValue("d",pResult);
1708 PyObject* pIndexOBJ=Py_BuildValue("i",pIndex);
1709
1710 PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
1711
1712 FREEARGUMENT(pSrc_converted);
1713 Py_DECREF(pResultOBJ);
1714 Py_DECREF(pIndexOBJ);
1715 return(pythonResult);
1716
1717 }
1718 return(NULL);
1719 }
1720
1721 static PyObject *
cmsis_arm_max_no_idx_f32(PyObject * obj,PyObject * args)1722 cmsis_arm_max_no_idx_f32(PyObject *obj, PyObject *args)
1723 {
1724
1725 PyObject *pSrc=NULL; // input
1726 float32_t *pSrc_converted=NULL; // input
1727 uint32_t blockSize; // input
1728 float32_t pResult; // output
1729
1730 if (PyArg_ParseTuple(args,"O",&pSrc))
1731 {
1732
1733 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
1734 blockSize = arraySizepSrc ;
1735
1736
1737 arm_max_no_idx_f32(pSrc_converted,blockSize,&pResult);
1738 PyObject* pResultOBJ=Py_BuildValue("f",pResult);
1739
1740 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
1741
1742 FREEARGUMENT(pSrc_converted);
1743 Py_DECREF(pResultOBJ);
1744 return(pythonResult);
1745
1746 }
1747 return(NULL);
1748 }
1749
1750 static PyObject *
cmsis_arm_max_no_idx_f64(PyObject * obj,PyObject * args)1751 cmsis_arm_max_no_idx_f64(PyObject *obj, PyObject *args)
1752 {
1753
1754 PyObject *pSrc=NULL; // input
1755 float64_t *pSrc_converted=NULL; // input
1756 uint32_t blockSize; // input
1757 float64_t pResult; // output
1758
1759 if (PyArg_ParseTuple(args,"O",&pSrc))
1760 {
1761
1762 GETARGUMENT(pSrc,NPY_DOUBLE,double,float64_t);
1763 blockSize = arraySizepSrc ;
1764
1765
1766 arm_max_no_idx_f64(pSrc_converted,blockSize,&pResult);
1767 PyObject* pResultOBJ=Py_BuildValue("d",pResult);
1768
1769 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
1770
1771 FREEARGUMENT(pSrc_converted);
1772 Py_DECREF(pResultOBJ);
1773 return(pythonResult);
1774
1775 }
1776 return(NULL);
1777 }
1778
1779 static PyObject *
cmsis_arm_absmax_f32(PyObject * obj,PyObject * args)1780 cmsis_arm_absmax_f32(PyObject *obj, PyObject *args)
1781 {
1782
1783 PyObject *pSrc=NULL; // input
1784 float32_t *pSrc_converted=NULL; // input
1785 uint32_t blockSize; // input
1786 float32_t pResult; // output
1787 uint32_t pIndex; // output
1788
1789 if (PyArg_ParseTuple(args,"O",&pSrc))
1790 {
1791
1792 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
1793 blockSize = arraySizepSrc ;
1794
1795 arm_absmax_f32(pSrc_converted,blockSize,&pResult,&pIndex);
1796 PyObject* pResultOBJ=Py_BuildValue("f",pResult);
1797 PyObject* pIndexOBJ=Py_BuildValue("i",pIndex);
1798
1799 PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
1800
1801 FREEARGUMENT(pSrc_converted);
1802 Py_DECREF(pResultOBJ);
1803 Py_DECREF(pIndexOBJ);
1804 return(pythonResult);
1805
1806 }
1807 return(NULL);
1808 }
1809
1810 static PyObject *
cmsis_arm_absmax_f64(PyObject * obj,PyObject * args)1811 cmsis_arm_absmax_f64(PyObject *obj, PyObject *args)
1812 {
1813
1814 PyObject *pSrc=NULL; // input
1815 float64_t *pSrc_converted=NULL; // input
1816 uint32_t blockSize; // input
1817 float64_t pResult; // output
1818 uint32_t pIndex; // output
1819
1820 if (PyArg_ParseTuple(args,"O",&pSrc))
1821 {
1822
1823 GETARGUMENT(pSrc,NPY_DOUBLE,double,float64_t);
1824 blockSize = arraySizepSrc ;
1825
1826 arm_absmax_f64(pSrc_converted,blockSize,&pResult,&pIndex);
1827 PyObject* pResultOBJ=Py_BuildValue("d",pResult);
1828 PyObject* pIndexOBJ=Py_BuildValue("i",pIndex);
1829
1830 PyObject *pythonResult = Py_BuildValue("OO",pResultOBJ,pIndexOBJ);
1831
1832 FREEARGUMENT(pSrc_converted);
1833 Py_DECREF(pResultOBJ);
1834 Py_DECREF(pIndexOBJ);
1835 return(pythonResult);
1836
1837 }
1838 return(NULL);
1839 }
1840
1841 static PyObject *
cmsis_arm_absmax_no_idx_f32(PyObject * obj,PyObject * args)1842 cmsis_arm_absmax_no_idx_f32(PyObject *obj, PyObject *args)
1843 {
1844
1845 PyObject *pSrc=NULL; // input
1846 float32_t *pSrc_converted=NULL; // input
1847 uint32_t blockSize; // input
1848 float32_t pResult; // output
1849
1850 if (PyArg_ParseTuple(args,"O",&pSrc))
1851 {
1852
1853 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
1854 blockSize = arraySizepSrc ;
1855
1856 arm_absmax_no_idx_f32(pSrc_converted,blockSize,&pResult);
1857 PyObject* pResultOBJ=Py_BuildValue("f",pResult);
1858
1859 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
1860
1861 FREEARGUMENT(pSrc_converted);
1862 Py_DECREF(pResultOBJ);
1863 return(pythonResult);
1864
1865 }
1866 return(NULL);
1867 }
1868
1869 static PyObject *
cmsis_arm_absmax_no_idx_f64(PyObject * obj,PyObject * args)1870 cmsis_arm_absmax_no_idx_f64(PyObject *obj, PyObject *args)
1871 {
1872
1873 PyObject *pSrc=NULL; // input
1874 float64_t *pSrc_converted=NULL; // input
1875 uint32_t blockSize; // input
1876 float64_t pResult; // output
1877
1878 if (PyArg_ParseTuple(args,"O",&pSrc))
1879 {
1880
1881 GETARGUMENT(pSrc,NPY_DOUBLE,double,float64_t);
1882 blockSize = arraySizepSrc ;
1883
1884 arm_absmax_no_idx_f64(pSrc_converted,blockSize,&pResult);
1885 PyObject* pResultOBJ=Py_BuildValue("d",pResult);
1886
1887 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
1888
1889 FREEARGUMENT(pSrc_converted);
1890 Py_DECREF(pResultOBJ);
1891 return(pythonResult);
1892
1893 }
1894 return(NULL);
1895 }
1896
1897 static PyObject *
cmsis_arm_entropy_f32(PyObject * obj,PyObject * args)1898 cmsis_arm_entropy_f32(PyObject *obj, PyObject *args)
1899 {
1900
1901 PyObject *pSrc=NULL; // input
1902 float32_t *pSrc_converted=NULL; // input
1903 uint32_t blockSize; // input
1904 float32_t pResult; // output
1905
1906 if (PyArg_ParseTuple(args,"O",&pSrc))
1907 {
1908
1909 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
1910 blockSize = arraySizepSrc ;
1911
1912 pResult=arm_entropy_f32(pSrc_converted,blockSize);
1913 PyObject* pResultOBJ=Py_BuildValue("f",pResult);
1914
1915 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
1916
1917 FREEARGUMENT(pSrc_converted);
1918 Py_DECREF(pResultOBJ);
1919 return(pythonResult);
1920
1921 }
1922 return(NULL);
1923 }
1924
1925 static PyObject *
cmsis_arm_accumulate_f32(PyObject * obj,PyObject * args)1926 cmsis_arm_accumulate_f32(PyObject *obj, PyObject *args)
1927 {
1928
1929 PyObject *pSrc=NULL; // input
1930 float32_t *pSrc_converted=NULL; // input
1931 uint32_t blockSize; // input
1932 float32_t pResult; // output
1933
1934 if (PyArg_ParseTuple(args,"O",&pSrc))
1935 {
1936
1937 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
1938 blockSize = arraySizepSrc ;
1939
1940 arm_accumulate_f32(pSrc_converted,blockSize,&pResult);
1941 PyObject* pResultOBJ=Py_BuildValue("f",pResult);
1942
1943 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
1944
1945 FREEARGUMENT(pSrc_converted);
1946 Py_DECREF(pResultOBJ);
1947 return(pythonResult);
1948
1949 }
1950 return(NULL);
1951 }
1952
1953 static PyObject *
cmsis_arm_entropy_f64(PyObject * obj,PyObject * args)1954 cmsis_arm_entropy_f64(PyObject *obj, PyObject *args)
1955 {
1956
1957 PyObject *pSrc=NULL; // input
1958 float64_t *pSrc_converted=NULL; // input
1959 uint32_t blockSize; // input
1960 float64_t pResult; // output
1961
1962 if (PyArg_ParseTuple(args,"O",&pSrc))
1963 {
1964
1965 GETARGUMENT(pSrc,NPY_DOUBLE,double,float64_t);
1966 blockSize = arraySizepSrc ;
1967
1968 pResult=arm_entropy_f64(pSrc_converted,blockSize);
1969 PyObject* pResultOBJ=Py_BuildValue("d",pResult);
1970
1971 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
1972
1973 FREEARGUMENT(pSrc_converted);
1974 Py_DECREF(pResultOBJ);
1975 return(pythonResult);
1976
1977 }
1978 return(NULL);
1979 }
1980
1981 static PyObject *
cmsis_arm_accumulate_f64(PyObject * obj,PyObject * args)1982 cmsis_arm_accumulate_f64(PyObject *obj, PyObject *args)
1983 {
1984
1985 PyObject *pSrc=NULL; // input
1986 float64_t *pSrc_converted=NULL; // input
1987 uint32_t blockSize; // input
1988 float64_t pResult; // output
1989
1990 if (PyArg_ParseTuple(args,"O",&pSrc))
1991 {
1992
1993 GETARGUMENT(pSrc,NPY_DOUBLE,double,float64_t);
1994 blockSize = arraySizepSrc ;
1995
1996 arm_accumulate_f64(pSrc_converted,blockSize,&pResult);
1997 PyObject* pResultOBJ=Py_BuildValue("d",pResult);
1998
1999 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
2000
2001 FREEARGUMENT(pSrc_converted);
2002 Py_DECREF(pResultOBJ);
2003 return(pythonResult);
2004
2005 }
2006 return(NULL);
2007 }
2008
2009 static PyObject *
cmsis_arm_kullback_leibler_f32(PyObject * obj,PyObject * args)2010 cmsis_arm_kullback_leibler_f32(PyObject *obj, PyObject *args)
2011 {
2012
2013 PyObject *pSrcA=NULL; // input
2014 float32_t *pSrcA_converted=NULL; // input
2015 PyObject *pSrcB=NULL; // input
2016 float32_t *pSrcB_converted=NULL; // input
2017 uint32_t blockSize; // input
2018 float32_t result; // output
2019
2020 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
2021 {
2022
2023 GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
2024 GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
2025 blockSize = arraySizepSrcA ;
2026
2027
2028
2029 result=arm_kullback_leibler_f32(pSrcA_converted,pSrcB_converted,blockSize);
2030 PyObject* resultOBJ=Py_BuildValue("f",result);
2031
2032 PyObject *pythonResult = Py_BuildValue("O",resultOBJ);
2033
2034 FREEARGUMENT(pSrcA_converted);
2035 FREEARGUMENT(pSrcB_converted);
2036 Py_DECREF(resultOBJ);
2037 return(pythonResult);
2038
2039 }
2040 return(NULL);
2041 }
2042
2043 static PyObject *
cmsis_arm_kullback_leibler_f64(PyObject * obj,PyObject * args)2044 cmsis_arm_kullback_leibler_f64(PyObject *obj, PyObject *args)
2045 {
2046
2047 PyObject *pSrcA=NULL; // input
2048 float64_t *pSrcA_converted=NULL; // input
2049 PyObject *pSrcB=NULL; // input
2050 float64_t *pSrcB_converted=NULL; // input
2051 uint32_t blockSize; // input
2052 float64_t result; // output
2053
2054 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
2055 {
2056
2057 GETARGUMENT(pSrcA,NPY_DOUBLE,double,float64_t);
2058 GETARGUMENT(pSrcB,NPY_DOUBLE,double,float64_t);
2059 blockSize = arraySizepSrcA ;
2060
2061
2062
2063 result=arm_kullback_leibler_f64(pSrcA_converted,pSrcB_converted,blockSize);
2064 PyObject* resultOBJ=Py_BuildValue("d",result);
2065
2066 PyObject *pythonResult = Py_BuildValue("O",resultOBJ);
2067
2068 FREEARGUMENT(pSrcA_converted);
2069 FREEARGUMENT(pSrcB_converted);
2070 Py_DECREF(resultOBJ);
2071 return(pythonResult);
2072
2073 }
2074 return(NULL);
2075 }
2076
2077 static PyObject *
cmsis_arm_logsumexp_f32(PyObject * obj,PyObject * args)2078 cmsis_arm_logsumexp_f32(PyObject *obj, PyObject *args)
2079 {
2080
2081 PyObject *pSrc=NULL; // input
2082 float32_t *pSrc_converted=NULL; // input
2083 uint32_t blockSize; // input
2084 float32_t pResult; // output
2085
2086 if (PyArg_ParseTuple(args,"O",&pSrc))
2087 {
2088
2089 GETARGUMENT(pSrc,NPY_DOUBLE,double,float32_t);
2090 blockSize = arraySizepSrc ;
2091
2092 pResult=arm_logsumexp_f32(pSrc_converted,blockSize);
2093 PyObject* pResultOBJ=Py_BuildValue("f",pResult);
2094
2095 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
2096
2097 FREEARGUMENT(pSrc_converted);
2098 Py_DECREF(pResultOBJ);
2099 return(pythonResult);
2100
2101 }
2102 return(NULL);
2103 }
2104
2105 static PyObject *
cmsis_arm_logsumexp_dot_prod_f32(PyObject * obj,PyObject * args)2106 cmsis_arm_logsumexp_dot_prod_f32(PyObject *obj, PyObject *args)
2107 {
2108
2109 PyObject *pSrcA=NULL; // input
2110 float32_t *pSrcA_converted=NULL; // input
2111 PyObject *pSrcB=NULL; // input
2112 float32_t *pSrcB_converted=NULL; // input
2113 uint32_t blockSize; // input
2114 float32_t result; // output
2115
2116 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
2117 {
2118
2119 GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
2120 GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
2121 blockSize = arraySizepSrcA ;
2122
2123 float32_t *tmp=PyMem_Malloc(sizeof(float32_t)*blockSize);
2124
2125 result=arm_logsumexp_dot_prod_f32(pSrcA_converted,pSrcB_converted,blockSize,tmp);
2126 PyMem_Free(tmp);
2127
2128 PyObject* resultOBJ=Py_BuildValue("f",result);
2129
2130 PyObject *pythonResult = Py_BuildValue("O",resultOBJ);
2131
2132 FREEARGUMENT(pSrcA_converted);
2133 FREEARGUMENT(pSrcB_converted);
2134 Py_DECREF(resultOBJ);
2135 return(pythonResult);
2136
2137 }
2138 return(NULL);
2139 }
2140
2141 static PyObject *
cmsis_arm_mse_q7(PyObject * obj,PyObject * args)2142 cmsis_arm_mse_q7(PyObject *obj, PyObject *args)
2143 {
2144
2145 PyObject *pSrcA=NULL; // input
2146 q7_t *pSrcA_converted=NULL; // input
2147 PyObject *pSrcB=NULL; // input
2148 q7_t *pSrcB_converted=NULL; // input
2149
2150 uint32_t blockSize; // input
2151 q7_t pResult; // output
2152
2153 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
2154 {
2155
2156 GETARGUMENT(pSrcA,NPY_BYTE,int8_t,q7_t);
2157 GETARGUMENT(pSrcB,NPY_BYTE,int8_t,q7_t);
2158
2159 blockSize = arraySizepSrcA ;
2160
2161
2162 arm_mse_q7(pSrcA_converted,pSrcB_converted, blockSize,&pResult);
2163 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
2164
2165 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
2166
2167 FREEARGUMENT(pSrcA_converted);
2168 FREEARGUMENT(pSrcB_converted);
2169
2170 Py_DECREF(pResultOBJ);
2171 return(pythonResult);
2172
2173 }
2174 return(NULL);
2175 }
2176
2177 static PyObject *
cmsis_arm_mse_q15(PyObject * obj,PyObject * args)2178 cmsis_arm_mse_q15(PyObject *obj, PyObject *args)
2179 {
2180
2181 PyObject *pSrcA=NULL; // input
2182 q15_t *pSrcA_converted=NULL; // input
2183 PyObject *pSrcB=NULL; // input
2184 q15_t *pSrcB_converted=NULL; // input
2185
2186 uint32_t blockSize; // input
2187 q15_t pResult; // output
2188
2189 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
2190 {
2191
2192 GETARGUMENT(pSrcA,NPY_INT16,int16_t,q15_t);
2193 GETARGUMENT(pSrcB,NPY_INT16,int16_t,q15_t);
2194
2195 blockSize = arraySizepSrcA ;
2196
2197
2198 arm_mse_q15(pSrcA_converted,pSrcB_converted,blockSize,&pResult);
2199 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
2200
2201 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
2202
2203 FREEARGUMENT(pSrcA_converted);
2204 FREEARGUMENT(pSrcB_converted);
2205
2206 Py_DECREF(pResultOBJ);
2207 return(pythonResult);
2208
2209 }
2210 return(NULL);
2211 }
2212
2213 static PyObject *
cmsis_arm_mse_q31(PyObject * obj,PyObject * args)2214 cmsis_arm_mse_q31(PyObject *obj, PyObject *args)
2215 {
2216
2217 PyObject *pSrcA=NULL; // input
2218 q31_t *pSrcA_converted=NULL; // input
2219 PyObject *pSrcB=NULL; // input
2220 q31_t *pSrcB_converted=NULL; // input
2221
2222 uint32_t blockSize; // input
2223 q31_t pResult; // output
2224
2225 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
2226 {
2227
2228 GETARGUMENT(pSrcA,NPY_INT32,int32_t,q31_t);
2229 GETARGUMENT(pSrcB,NPY_INT32,int32_t,q31_t);
2230
2231 blockSize = arraySizepSrcA ;
2232
2233
2234 arm_mse_q31(pSrcA_converted,pSrcB_converted,blockSize,&pResult);
2235 PyObject* pResultOBJ=Py_BuildValue("i",pResult);
2236
2237 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
2238
2239 FREEARGUMENT(pSrcA_converted);
2240 FREEARGUMENT(pSrcB_converted);
2241
2242 Py_DECREF(pResultOBJ);
2243 return(pythonResult);
2244
2245 }
2246 return(NULL);
2247 }
2248
2249 static PyObject *
cmsis_arm_mse_f32(PyObject * obj,PyObject * args)2250 cmsis_arm_mse_f32(PyObject *obj, PyObject *args)
2251 {
2252
2253 PyObject *pSrcA=NULL; // input
2254 float32_t *pSrcA_converted=NULL; // input
2255 PyObject *pSrcB=NULL; // input
2256 float32_t *pSrcB_converted=NULL; // input
2257
2258 uint32_t blockSize; // input
2259 float32_t pResult; // output
2260
2261 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
2262 {
2263
2264 GETARGUMENT(pSrcA,NPY_DOUBLE,double,float32_t);
2265 GETARGUMENT(pSrcB,NPY_DOUBLE,double,float32_t);
2266
2267 blockSize = arraySizepSrcA ;
2268
2269
2270 arm_mse_f32(pSrcA_converted,pSrcB_converted,blockSize,&pResult);
2271 PyObject* pResultOBJ=Py_BuildValue("f",pResult);
2272
2273 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
2274
2275 FREEARGUMENT(pSrcA_converted);
2276 FREEARGUMENT(pSrcB_converted);
2277
2278 Py_DECREF(pResultOBJ);
2279 return(pythonResult);
2280
2281 }
2282 return(NULL);
2283 }
2284
2285 static PyObject *
cmsis_arm_mse_f64(PyObject * obj,PyObject * args)2286 cmsis_arm_mse_f64(PyObject *obj, PyObject *args)
2287 {
2288
2289 PyObject *pSrcA=NULL; // input
2290 float64_t *pSrcA_converted=NULL; // input
2291 PyObject *pSrcB=NULL; // input
2292 float64_t *pSrcB_converted=NULL; // input
2293
2294 uint32_t blockSize; // input
2295 float64_t pResult; // output
2296
2297 if (PyArg_ParseTuple(args,"OO",&pSrcA,&pSrcB))
2298 {
2299
2300 GETARGUMENT(pSrcA,NPY_DOUBLE,double,float64_t);
2301 GETARGUMENT(pSrcB,NPY_DOUBLE,double,float64_t);
2302
2303 blockSize = arraySizepSrcA ;
2304
2305
2306 arm_mse_f64(pSrcA_converted,pSrcB_converted,blockSize,&pResult);
2307 PyObject* pResultOBJ=Py_BuildValue("d",pResult);
2308
2309 PyObject *pythonResult = Py_BuildValue("O",pResultOBJ);
2310
2311 FREEARGUMENT(pSrcA_converted);
2312 FREEARGUMENT(pSrcB_converted);
2313
2314 Py_DECREF(pResultOBJ);
2315 return(pythonResult);
2316
2317 }
2318 return(NULL);
2319 }
2320
2321 static PyMethodDef CMSISDSPMethods[] = {
2322
2323
2324 {"arm_power_q31", cmsis_arm_power_q31, METH_VARARGS,""},
2325 {"arm_power_f32", cmsis_arm_power_f32, METH_VARARGS,""},
2326 {"arm_power_f64", cmsis_arm_power_f64, METH_VARARGS,""},
2327 {"arm_power_q15", cmsis_arm_power_q15, METH_VARARGS,""},
2328 {"arm_power_q7", cmsis_arm_power_q7, METH_VARARGS,""},
2329 {"arm_mean_q7", cmsis_arm_mean_q7, METH_VARARGS,""},
2330 {"arm_mean_q15", cmsis_arm_mean_q15, METH_VARARGS,""},
2331 {"arm_mean_q31", cmsis_arm_mean_q31, METH_VARARGS,""},
2332 {"arm_mean_f32", cmsis_arm_mean_f32, METH_VARARGS,""},
2333 {"arm_mean_f64", cmsis_arm_mean_f64, METH_VARARGS,""},
2334 {"arm_var_f32", cmsis_arm_var_f32, METH_VARARGS,""},
2335 {"arm_var_f64", cmsis_arm_var_f64, METH_VARARGS,""},
2336 {"arm_var_q31", cmsis_arm_var_q31, METH_VARARGS,""},
2337 {"arm_var_q15", cmsis_arm_var_q15, METH_VARARGS,""},
2338 {"arm_rms_f32", cmsis_arm_rms_f32, METH_VARARGS,""},
2339 {"arm_rms_q31", cmsis_arm_rms_q31, METH_VARARGS,""},
2340 {"arm_rms_q15", cmsis_arm_rms_q15, METH_VARARGS,""},
2341 {"arm_std_f32", cmsis_arm_std_f32, METH_VARARGS,""},
2342 {"arm_std_f64", cmsis_arm_std_f64, METH_VARARGS,""},
2343
2344 {"arm_std_q31", cmsis_arm_std_q31, METH_VARARGS,""},
2345 {"arm_std_q15", cmsis_arm_std_q15, METH_VARARGS,""},
2346
2347 {"arm_min_q7", cmsis_arm_min_q7, METH_VARARGS,""},
2348 {"arm_min_no_idx_q7", cmsis_arm_min_no_idx_q7, METH_VARARGS,""},
2349 {"arm_min_no_idx_q15", cmsis_arm_min_no_idx_q15, METH_VARARGS,""},
2350 {"arm_min_no_idx_q31", cmsis_arm_min_no_idx_q31, METH_VARARGS,""},
2351 {"arm_min_q15", cmsis_arm_min_q15, METH_VARARGS,""},
2352 {"arm_min_q31", cmsis_arm_min_q31, METH_VARARGS,""},
2353 {"arm_min_f32", cmsis_arm_min_f32, METH_VARARGS,""},
2354 {"arm_min_f64", cmsis_arm_min_f64, METH_VARARGS,""},
2355 {"arm_min_no_idx_f32", cmsis_arm_min_no_idx_f32, METH_VARARGS,""},
2356 {"arm_min_no_idx_f64", cmsis_arm_min_no_idx_f64, METH_VARARGS,""},
2357
2358 {"arm_absmin_q7", cmsis_arm_absmin_q7, METH_VARARGS,""},
2359 {"arm_absmin_q15", cmsis_arm_absmin_q15, METH_VARARGS,""},
2360 {"arm_absmin_q31", cmsis_arm_absmin_q31, METH_VARARGS,""},
2361 {"arm_absmin_no_idx_q7", cmsis_arm_absmin_no_idx_q7, METH_VARARGS,""},
2362 {"arm_absmin_no_idx_q15", cmsis_arm_absmin_no_idx_q15, METH_VARARGS,""},
2363 {"arm_absmin_no_idx_q31", cmsis_arm_absmin_no_idx_q31, METH_VARARGS,""},
2364 {"arm_absmin_f32", cmsis_arm_absmin_f32, METH_VARARGS,""},
2365 {"arm_absmin_f64", cmsis_arm_absmin_f64, METH_VARARGS,""},
2366 {"arm_absmin_no_idx_f64", cmsis_arm_absmin_no_idx_f64, METH_VARARGS,""},
2367 {"arm_absmin_no_idx_f32", cmsis_arm_absmin_no_idx_f32, METH_VARARGS,""},
2368 {"arm_max_q7", cmsis_arm_max_q7, METH_VARARGS,""},
2369 {"arm_max_q15", cmsis_arm_max_q15, METH_VARARGS,""},
2370 {"arm_max_q31", cmsis_arm_max_q31, METH_VARARGS,""},
2371 {"arm_absmax_q7", cmsis_arm_absmax_q7, METH_VARARGS,""},
2372 {"arm_absmax_q15", cmsis_arm_absmax_q15, METH_VARARGS,""},
2373 {"arm_absmax_q31", cmsis_arm_absmax_q31, METH_VARARGS,""},
2374 {"arm_max_f32", cmsis_arm_max_f32, METH_VARARGS,""},
2375 {"arm_max_f64", cmsis_arm_max_f64, METH_VARARGS,""},
2376
2377 {"arm_max_no_idx_f32", cmsis_arm_max_no_idx_f32, METH_VARARGS,""},
2378 {"arm_max_no_idx_f64", cmsis_arm_max_no_idx_f64, METH_VARARGS,""},
2379
2380 {"arm_absmax_f32", cmsis_arm_absmax_f32, METH_VARARGS,""},
2381 {"arm_absmax_f64", cmsis_arm_absmax_f64, METH_VARARGS,""},
2382
2383 {"arm_absmax_no_idx_f32", cmsis_arm_absmax_no_idx_f32, METH_VARARGS,""},
2384 {"arm_absmax_no_idx_f64", cmsis_arm_absmax_no_idx_f64, METH_VARARGS,""},
2385
2386 {"arm_max_no_idx_q7", cmsis_arm_max_no_idx_q7, METH_VARARGS,""},
2387 {"arm_max_no_idx_q15", cmsis_arm_max_no_idx_q15, METH_VARARGS,""},
2388 {"arm_max_no_idx_q31", cmsis_arm_max_no_idx_q31, METH_VARARGS,""},
2389 {"arm_absmax_no_idx_q7", cmsis_arm_absmax_no_idx_q7, METH_VARARGS,""},
2390 {"arm_absmax_no_idx_q15", cmsis_arm_absmax_no_idx_q15, METH_VARARGS,""},
2391 {"arm_absmax_no_idx_q31", cmsis_arm_absmax_no_idx_q31, METH_VARARGS,""},
2392 {"arm_entropy_f32", cmsis_arm_entropy_f32, METH_VARARGS,""},
2393 {"arm_entropy_f64", cmsis_arm_entropy_f64, METH_VARARGS,""},
2394 {"arm_kullback_leibler_f32", cmsis_arm_kullback_leibler_f32, METH_VARARGS,""},
2395 {"arm_kullback_leibler_f64", cmsis_arm_kullback_leibler_f64, METH_VARARGS,""},
2396
2397 {"arm_logsumexp_f32", cmsis_arm_logsumexp_f32, METH_VARARGS,""},
2398 {"arm_logsumexp_dot_prod_f32", cmsis_arm_logsumexp_dot_prod_f32, METH_VARARGS,""},
2399 {"arm_mse_q7", cmsis_arm_mse_q7, METH_VARARGS,""},
2400 {"arm_mse_q15", cmsis_arm_mse_q15, METH_VARARGS,""},
2401 {"arm_mse_q31", cmsis_arm_mse_q31, METH_VARARGS,""},
2402 {"arm_mse_f32", cmsis_arm_mse_f32, METH_VARARGS,""},
2403 {"arm_mse_f64", cmsis_arm_mse_f64, METH_VARARGS,""},
2404 {"arm_accumulate_f32", cmsis_arm_accumulate_f32, METH_VARARGS,""},
2405 {"arm_accumulate_f64", cmsis_arm_accumulate_f64, METH_VARARGS,""},
2406
2407
2408 {"error_out", (PyCFunction)error_out, METH_NOARGS, NULL},
2409 {NULL, NULL, 0, NULL} /* Sentinel */
2410 };
2411
2412 #ifdef IS_PY3K
cmsisdsp_traverse(PyObject * m,visitproc visit,void * arg)2413 static int cmsisdsp_traverse(PyObject *m, visitproc visit, void *arg) {
2414 Py_VISIT(GETSTATE(m)->error);
2415 return 0;
2416 }
2417
cmsisdsp_clear(PyObject * m)2418 static int cmsisdsp_clear(PyObject *m) {
2419 Py_CLEAR(GETSTATE(m)->error);
2420 return 0;
2421 }
2422
2423
2424 static struct PyModuleDef moduledef = {
2425 PyModuleDef_HEAD_INIT,
2426 MODNAME,
2427 NULL,
2428 sizeof(struct module_state),
2429 CMSISDSPMethods,
2430 NULL,
2431 cmsisdsp_traverse,
2432 cmsisdsp_clear,
2433 NULL
2434 };
2435
2436 #define INITERROR return NULL
2437
2438 PyMODINIT_FUNC
CAT(PyInit_,MODINITNAME)2439 CAT(PyInit_,MODINITNAME)(void)
2440
2441
2442 #else
2443 #define INITERROR return
2444
2445 void CAT(init,MODINITNAME)(void)
2446 #endif
2447 {
2448 import_array();
2449
2450 #ifdef IS_PY3K
2451 PyObject *module = PyModule_Create(&moduledef);
2452 #else
2453 PyObject *module = Py_InitModule(MODNAME, CMSISDSPMethods);
2454 #endif
2455
2456 if (module == NULL)
2457 INITERROR;
2458 struct module_state *st = GETSTATE(module);
2459
2460 st->error = PyErr_NewException(MODNAME".Error", NULL, NULL);
2461 if (st->error == NULL) {
2462 Py_DECREF(module);
2463 INITERROR;
2464 }
2465
2466
2467 typeRegistration(module);
2468
2469 #ifdef IS_PY3K
2470 return module;
2471 #endif
2472 }
