Add keyword arguments to spectrogram

code/numpy/fft/fft.c

@@ -5,7 +5,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2019-2021 Zoltán Vörös
+ * Copyright (c) 2019-2024 Zoltán Vörös
  *               2020 Scott Shawcroft for Adafruit Industries
  *               2020 Taku Fukada
 */
@@ -43,16 +43,16 @@
 //|
 #if ULAB_SUPPORTS_COMPLEX & ULAB_FFT_IS_NUMPY_COMPATIBLE
 static mp_obj_t fft_fft(mp_obj_t arg) {
-    return fft_fft_ifft_spectrogram(arg, FFT_FFT);
+    return fft_fft_ifft(arg, FFT_FFT);
 }
 
 MP_DEFINE_CONST_FUN_OBJ_1(fft_fft_obj, fft_fft);
 #else
 static mp_obj_t fft_fft(size_t n_args, const mp_obj_t *args) {
     if(n_args == 2) {
-        return fft_fft_ifft_spectrogram(n_args, args[0], args[1], FFT_FFT);
+        return fft_fft_ifft(n_args, args[0], args[1], FFT_FFT);
     } else {
-        return fft_fft_ifft_spectrogram(n_args, args[0], mp_const_none, FFT_FFT);
+        return fft_fft_ifft(n_args, args[0], mp_const_none, FFT_FFT);
     }
 }
 
@@ -71,17 +71,17 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(fft_fft_obj, 1, 2, fft_fft);
 
 #if ULAB_SUPPORTS_COMPLEX & ULAB_FFT_IS_NUMPY_COMPATIBLE
 static mp_obj_t fft_ifft(mp_obj_t arg) {
-    return fft_fft_ifft_spectrogram(arg, FFT_IFFT);
+    return fft_fft_ifft(arg, FFT_IFFT);
 }
 
 MP_DEFINE_CONST_FUN_OBJ_1(fft_ifft_obj, fft_ifft);
 #else
 static mp_obj_t fft_ifft(size_t n_args, const mp_obj_t *args) {
     NOT_IMPLEMENTED_FOR_COMPLEX()
     if(n_args == 2) {
-        return fft_fft_ifft_spectrogram(n_args, args[0], args[1], FFT_IFFT);
+        return fft_fft_ifft(n_args, args[0], args[1], FFT_IFFT);
     } else {
-        return fft_fft_ifft_spectrogram(n_args, args[0], mp_const_none, FFT_IFFT);
+        return fft_fft_ifft(n_args, args[0], mp_const_none, FFT_IFFT);
     }
 }
 

code/numpy/fft/fft_tools.c

@@ -5,7 +5,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2019-2021 Zoltán Vörös
+ * Copyright (c) 2019-2024 Zoltán Vörös
 */
 
 #include <math.h>
@@ -45,7 +45,7 @@
     imag[i] = data[2i+1]
 
 */
-void fft_kernel_complex(mp_float_t *data, size_t n, int isign) {
+void fft_kernel(mp_float_t *data, size_t n, int isign) {
     size_t j, m, mmax, istep;
     mp_float_t tempr, tempi;
     mp_float_t wtemp, wr, wpr, wpi, wi, theta;
@@ -94,9 +94,9 @@ void fft_kernel_complex(mp_float_t *data, size_t n, int isign) {
 /*
  * The following function is a helper interface to the python side.
  * It has been factored out from fft.c, so that the same argument parsing
- * routine can be called from scipy.signal.spectrogram.
+ * routine can be called from utils.spectrogram.
  */
-mp_obj_t fft_fft_ifft_spectrogram(mp_obj_t data_in, uint8_t type) {
+mp_obj_t fft_fft_ifft(mp_obj_t data_in, uint8_t type) {
     if(!mp_obj_is_type(data_in, &ulab_ndarray_type)) {
         mp_raise_NotImplementedError(MP_ERROR_TEXT("FFT is defined for ndarrays only"));
     }
@@ -134,20 +134,10 @@ mp_obj_t fft_fft_ifft_spectrogram(mp_obj_t data_in, uint8_t type) {
     }
     data -= 2 * len;
 
-    if((type == FFT_FFT) || (type == FFT_SPECTROGRAM)) {
-        fft_kernel_complex(data, len, 1);
-        if(type == FFT_SPECTROGRAM) {
-            ndarray_obj_t *spectrum = ndarray_new_linear_array(len, NDARRAY_FLOAT);
-            mp_float_t *sarray = (mp_float_t *)spectrum->array;
-            for(size_t i = 0; i < len; i++) {
-                *sarray++ = MICROPY_FLOAT_C_FUN(sqrt)(data[0] * data[0] + data[1] * data[1]);
-                data += 2;
-            }
-            m_del(mp_float_t, data, 2 * len);
-            return MP_OBJ_FROM_PTR(spectrum);
-        }
+    if(type == FFT_FFT) {
+        fft_kernel(data, len, 1);
     } else { // inverse transform
-        fft_kernel_complex(data, len, -1);
+        fft_kernel(data, len, -1);
         // TODO: numpy accepts the norm keyword argument
         for(size_t i = 0; i < 2 * len; i++) {
             *data++ /= len;
@@ -202,7 +192,7 @@ void fft_kernel(mp_float_t *real, mp_float_t *imag, size_t n, int isign) {
     }
 }
 
-mp_obj_t fft_fft_ifft_spectrogram(size_t n_args, mp_obj_t arg_re, mp_obj_t arg_im, uint8_t type) {
+mp_obj_t fft_fft_ifft(size_t n_args, mp_obj_t arg_re, mp_obj_t arg_im, uint8_t type) {
     if(!mp_obj_is_type(arg_re, &ulab_ndarray_type)) {
         mp_raise_NotImplementedError(MP_ERROR_TEXT("FFT is defined for ndarrays only"));
     }
@@ -258,15 +248,8 @@ mp_obj_t fft_fft_ifft_spectrogram(size_t n_args, mp_obj_t arg_re, mp_obj_t arg_i
         data_im -= len;
     }
 
-    if((type == FFT_FFT) || (type == FFT_SPECTROGRAM)) {
+    if(type == FFT_FFT) {
         fft_kernel(data_re, data_im, len, 1);
-        if(type == FFT_SPECTROGRAM) {
-            for(size_t i=0; i < len; i++) {
-                *data_re = MICROPY_FLOAT_C_FUN(sqrt)(*data_re * *data_re + *data_im * *data_im);
-                data_re++;
-                data_im++;
-            }
-        }
     } else { // inverse transform
         fft_kernel(data_re, data_im, len, -1);
         // TODO: numpy accepts the norm keyword argument
@@ -275,13 +258,9 @@ mp_obj_t fft_fft_ifft_spectrogram(size_t n_args, mp_obj_t arg_re, mp_obj_t arg_i
             *data_im++ /= len;
         }
     }
-    if(type == FFT_SPECTROGRAM) {
-        return MP_OBJ_FROM_PTR(out_re);
-    } else {
-        mp_obj_t tuple[2];
-        tuple[0] = MP_OBJ_FROM_PTR(out_re);
-        tuple[1] = MP_OBJ_FROM_PTR(out_im);
-        return mp_obj_new_tuple(2, tuple);
-    }
+    mp_obj_t tuple[2];
+    tuple[0] = MP_OBJ_FROM_PTR(out_re);
+    tuple[1] = MP_OBJ_FROM_PTR(out_im);
+    return mp_obj_new_tuple(2, tuple);
 }
 #endif  /* ULAB_SUPPORTS_COMPLEX & ULAB_FFT_IS_NUMPY_COMPATIBLE */

code/numpy/fft/fft_tools.h

@@ -14,15 +14,14 @@
 enum FFT_TYPE {
     FFT_FFT,
     FFT_IFFT,
-    FFT_SPECTROGRAM,
 };
 
 #if ULAB_SUPPORTS_COMPLEX & ULAB_FFT_IS_NUMPY_COMPATIBLE
 void fft_kernel(mp_float_t *, size_t , int );
-mp_obj_t fft_fft_ifft_spectrogram(mp_obj_t , uint8_t );
+mp_obj_t fft_fft_ifft(mp_obj_t , uint8_t );
 #else
 void fft_kernel(mp_float_t *, mp_float_t *, size_t , int );
-mp_obj_t fft_fft_ifft_spectrogram(size_t , mp_obj_t , mp_obj_t , uint8_t );
+mp_obj_t fft_fft_ifft(size_t , mp_obj_t , mp_obj_t , uint8_t );
 #endif /* ULAB_SUPPORTS_COMPLEX & ULAB_FFT_IS_NUMPY_COMPATIBLE */
 
 #endif /* _FFT_TOOLS_ */

code/numpy/poly.c

@@ -121,7 +121,7 @@ mp_obj_t poly_polyfit(size_t n_args, const mp_obj_t *args) {
     ndarray_obj_t *beta = ndarray_new_linear_array(deg+1, NDARRAY_FLOAT);
     mp_float_t *betav = (mp_float_t *)beta->array;
     // x[0..(deg+1)] contains now the product X^T * y; we can get rid of y
-    m_del(float, y, leny);
+    m_del(mp_float_t, y, leny);
 
     // now, we calculate beta, i.e., we apply prod = (X^T * X)^(-1) on x = X^T * y; x is a column vector now
     for(uint8_t i=0; i < deg+1; i++) {

code/ulab.c

@@ -33,7 +33,7 @@
 #include "user/user.h"
 #include "utils/utils.h"
 
-#define ULAB_VERSION 6.5.4
+#define ULAB_VERSION 6.5.5
 #define xstr(s) str(s)
 #define str(s) #s
 

code/ulab.h

@@ -440,7 +440,7 @@
 // Note that in this case, the input also must be numpythonic,
 // i.e., the real an imaginary parts cannot be passed as two arguments
 #ifndef ULAB_FFT_IS_NUMPY_COMPATIBLE
-#define ULAB_FFT_IS_NUMPY_COMPATIBLE    (0)
+#define ULAB_FFT_IS_NUMPY_COMPATIBLE    (1)
 #endif
 
 #ifndef ULAB_FFT_HAS_FFT