static void mtxFFTMatrixHot (MtxFFT *x, t_symbol *s, int argc, t_atom *argv) { int rows, columns, size; int fft_count; t_atom *list_re = x->list_re; t_atom *list_im = x->list_im; t_float *f_re = x->f_re; t_float *f_im = x->f_im; /* fftsize check */ if(iemmatrix_check(x, argc, argv, 0))return; rows = atom_getint (argv++); columns = atom_getint (argv++); size = rows * columns; if (size != x->size) { pd_error(x, "[mtx_fft]: left matrix has other dimensions than right matrix"); } else if (columns < 4) { pd_error(x, "[mtx_fft]: matrix must have at least 4 columns"); } else if (columns == (1 << ilog2(columns))) { /* ok, do the FFT! */ /* main part */ readFloatFromList (size, argv, f_re); fft_count = rows; list_re += 2; list_im += 2; while (fft_count--) { mayer_fft (columns, f_re, f_im); writeFloatIntoList (columns, list_re, f_re); writeFloatIntoList (columns, list_im, f_im); f_im += columns; f_re += columns; list_re += columns; list_im += columns; } list_re = x->list_re; list_im = x->list_im; SETSYMBOL(list_re, gensym("matrix")); SETSYMBOL(list_im, gensym("matrix")); SETFLOAT(list_re, rows); SETFLOAT(list_im, rows); SETFLOAT(list_re+1, columns); SETFLOAT(list_im+1, columns); outlet_anything(x->list_im_out, gensym("matrix"), x->size+2, list_im); outlet_anything(x->list_re_out, gensym("matrix"), x->size+2, list_re); } else { pd_error(x, "[mtx_fft]: rowvector size no power of 2!"); } }
static void mTXCumsumMatrix (MTXCumsum *mtx_cumsum_obj, t_symbol *s, int argc, t_atom *argv) { int rows, columns, size; t_atom *list_ptr = argv+2; t_atom *list_out = mtx_cumsum_obj->list_out; t_float *x = mtx_cumsum_obj->x; t_float *y = mtx_cumsum_obj->y; int count; /* size check */ if(iemmatrix_check(mtx_cumsum_obj, argc, argv, 0))return; rows = atom_getint (argv+0); columns = atom_getint (argv+1); size = rows * columns; if ((!x)||(!list_out)||(!y)) { if (!x) { x = (t_float *) getbytes (sizeof (t_float) * (size)); } if (!y) { y = (t_float *) getbytes (sizeof (t_float) * (size)); } if (!list_out) { list_out = (t_atom *) getbytes (sizeof (t_atom) * (size+2)); } } else if (size != mtx_cumsum_obj->size) { x = (t_float *) resizebytes (x, sizeof (t_float) * (mtx_cumsum_obj->size), sizeof (t_float) * (size)); y = (t_float *) resizebytes (y, sizeof (t_float) * (mtx_cumsum_obj->size), sizeof (t_float) * (size)); list_out = (t_atom *) resizebytes (list_out, sizeof (t_atom) * (mtx_cumsum_obj->size+2), sizeof (t_atom) * (size + 2)); } mtx_cumsum_obj->size = size; mtx_cumsum_obj->rows = rows; mtx_cumsum_obj->columns = columns; mtx_cumsum_obj->list_out = list_out; mtx_cumsum_obj->x = x; mtx_cumsum_obj->y = y; /* main part */ /* reading matrix from inlet */ if ((mtx_cumsum_obj->cumsum_mode == col_sym) || (mtx_cumsum_obj->cumsum_mode == col_sym2)) { readFloatFromListModulo (size, columns, list_ptr, x); columns = mtx_cumsum_obj->rows; rows = mtx_cumsum_obj->columns; } else { readFloatFromList (size, list_ptr, x); } /* calculating cumsum */ if (mtx_cumsum_obj->cumsum_direction == -1) { if ((mtx_cumsum_obj->cumsum_mode == row_sym) || (mtx_cumsum_obj->cumsum_mode == col_sym) || (mtx_cumsum_obj->cumsum_mode == col_sym2)) { x += columns-1; y += columns-1; for (count = rows; count--; x += columns, y += columns) { cumSumReverse (columns,x,y); } } else { x += size-1; y += size-1; cumSumReverse (size, x, y); } } else if ((mtx_cumsum_obj->cumsum_mode == row_sym) || (mtx_cumsum_obj->cumsum_mode == col_sym) || (mtx_cumsum_obj->cumsum_mode == col_sym2)) for (count = rows; count--; x += columns, y += columns) { cumSum (columns,x,y); } else { cumSum (size, x, y); } x = mtx_cumsum_obj->x; y = mtx_cumsum_obj->y; /* writing matrix to outlet */ if ((mtx_cumsum_obj->cumsum_mode == col_sym) || (mtx_cumsum_obj->cumsum_mode == col_sym2)) { columns = mtx_cumsum_obj->columns; rows = mtx_cumsum_obj->rows; writeFloatIntoListModulo (size, columns, list_out+2, y); } else { writeFloatIntoList (size, list_out+2, y); } SETSYMBOL(list_out, gensym("matrix")); SETFLOAT(list_out, rows); SETFLOAT(&list_out[1], columns); outlet_anything(mtx_cumsum_obj->list_outlet, gensym("matrix"), mtx_cumsum_obj->size+2, list_out); }
static void mtxIFFTMatrixHot (MtxIFFT *x, t_symbol *s, int argc, t_atom *argv) { int rows = atom_getint (argv++); int columns = atom_getint (argv++); int size = rows * columns; int in_size = argc-2; int fft_count; t_atom *list_re = x->list_re; t_atom *list_im = x->list_im; t_float *f_re = x->f_re; t_float *f_im = x->f_im; /* fftsize check */ if (!size) { pd_error(x, "[mtx_ifft]: invalid dimensions"); } else if (in_size<size) { pd_error(x, "[mtx_ifft]: sparse matrix not yet supported: use \"mtx_check\""); } else if (size != x->size) { pd_error(x, "[mtx_ifft]: left matrix has other dimensions than right matrix"); } else if (columns < 4) { pd_error(x, "[mtx_ifft]: matrix must have at least 4 columns"); } else if (columns == (1 << ilog2(columns))) { /* ok, do the FFT! */ /* main part */ readFloatFromList (size, argv, f_re); fft_count = rows; list_re += 2; list_im += 2; while (fft_count--) { mayer_ifft (columns, f_re, f_im); multiplyVector (columns, f_re, x->renorm_fac); multiplyVector (columns, f_im, x->renorm_fac); writeFloatIntoList (columns, list_re, f_re); writeFloatIntoList (columns, list_im, f_im); f_im += columns; f_re += columns; list_re += columns; list_im += columns; } list_re = x->list_re; list_im = x->list_im; SETSYMBOL(list_re, gensym("matrix")); SETSYMBOL(list_im, gensym("matrix")); SETFLOAT(list_re, rows); SETFLOAT(list_im, rows); SETFLOAT(list_re+1, columns); SETFLOAT(list_im+1, columns); outlet_anything(x->list_im_out, gensym("matrix"), x->size+2, list_im); outlet_anything(x->list_re_out, gensym("matrix"), x->size+2, list_re); } else { pd_error(x, "[mtx_ifft]: rowvector size no power of 2!"); } }
static void mTXCumsumMatrix (MTXCumsum *mtx_cumsum_obj, t_symbol *s, int argc, t_atom *argv) { int rows = atom_getint (argv++); int columns = atom_getint (argv++); int size = rows * columns; int list_size = argc - 2; t_atom *list_ptr = argv; t_atom *list_out = mtx_cumsum_obj->list_out; t_float *x = mtx_cumsum_obj->x; t_float *y = mtx_cumsum_obj->y; int count; /* size check */ if (!size) { post("mtx_cumsum: invalid dimensions"); return; } else if (list_size<size) { post("mtx_cumsum: sparse matrix not yet supported: use \"mtx_check\""); return; } else if ((!x)||(!list_out)||(!y)) { if (!x) x = (t_float *) getbytes (sizeof (t_float) * (size)); if (!y) y = (t_float *) getbytes (sizeof (t_float) * (size)); if (!list_out) list_out = (t_atom *) getbytes (sizeof (t_atom) * (size+2)); } else if (size != mtx_cumsum_obj->size) { x = (t_float *) resizebytes (x, sizeof (t_float) * (mtx_cumsum_obj->size), sizeof (t_float) * (size)); y = (t_float *) resizebytes (y, sizeof (t_float) * (mtx_cumsum_obj->size), sizeof (t_float) * (size)); list_out = (t_atom *) resizebytes (list_out, sizeof (t_atom) * (mtx_cumsum_obj->size+2), sizeof (t_atom) * (size + 2)); } mtx_cumsum_obj->size = size; mtx_cumsum_obj->rows = rows; mtx_cumsum_obj->columns = columns; mtx_cumsum_obj->list_out = list_out; mtx_cumsum_obj->x = x; mtx_cumsum_obj->y = y; /* main part */ /* reading matrix from inlet */ if ((mtx_cumsum_obj->cumsum_mode == col_sym) || (mtx_cumsum_obj->cumsum_mode == col_sym2)) { readFloatFromListModulo (size, columns, list_ptr, x); columns = mtx_cumsum_obj->rows; rows = mtx_cumsum_obj->columns; } else readFloatFromList (size, list_ptr, x); /* calculating cumsum */ if (mtx_cumsum_obj->cumsum_direction == -1) { if ((mtx_cumsum_obj->cumsum_mode == row_sym) || (mtx_cumsum_obj->cumsum_mode == col_sym) || (mtx_cumsum_obj->cumsum_mode == col_sym2)) { x += columns-1; y += columns-1; for (count = rows; count--; x += columns, y += columns) cumSumReverse (columns,x,y); } else { x += size-1; y += size-1; cumSumReverse (size, x, y); } } else if ((mtx_cumsum_obj->cumsum_mode == row_sym) || (mtx_cumsum_obj->cumsum_mode == col_sym) || (mtx_cumsum_obj->cumsum_mode == col_sym2)) for (count = rows; count--; x += columns, y += columns) cumSum (columns,x,y); else cumSum (size, x, y); x = mtx_cumsum_obj->x; y = mtx_cumsum_obj->y; /* writing matrix to outlet */ if ((mtx_cumsum_obj->cumsum_mode == col_sym) || (mtx_cumsum_obj->cumsum_mode == col_sym2)) { columns = mtx_cumsum_obj->columns; rows = mtx_cumsum_obj->rows; writeFloatIntoListModulo (size, columns, list_out+2, y); } else writeFloatIntoList (size, list_out+2, y); SETSYMBOL(list_out, gensym("matrix")); SETFLOAT(list_out, rows); SETFLOAT(&list_out[1], columns); outlet_anything(mtx_cumsum_obj->list_outlet, gensym("matrix"), mtx_cumsum_obj->size+2, list_out); }
static void mTXRfftMatrix (MTXRfft *x, t_symbol *s, int argc, t_atom *argv) { int rows = atom_getint (argv++); int columns = atom_getint (argv++); int columns_re = (columns>>1)+1; /* N/2+1 samples needed for real part of realfft */ int size = rows * columns; int in_size = argc-2; int size2 = columns_re * rows + 2; /* +2 since the list also contains matrix row+col */ int fft_count; t_atom *list_re = x->list_re; t_atom *list_im = x->list_im; #ifdef HAVE_FFTW3_H fftw_complex *f_out = x->f_out; double *f_in = x->f_in; #else t_float *f_re = x->f_re; t_float *f_im = x->f_im; #endif /* fftsize check */ if (!size) post("mtx_rfft: invalid dimensions"); else if (in_size<size) post("mtx_rfft: sparse matrix not yet supported: use \"mtx_check\""); else if (columns < 4){ post("mtx_rfft: matrix must have at least 4 columns"); } else if (columns == (1 << ilog2(columns))) { /* ok, do the FFT! */ /* memory things */ #ifdef HAVE_FFTW3_H if ((x->rows!=rows)||(columns!=x->fftn)){ f_out=(fftw_complex*)realloc(f_out, sizeof(fftw_complex)*(size2-2)); f_in=(double*)realloc(f_in, sizeof(double)*size); x->f_in = f_in; x->f_out = f_out; for (fft_count=0; fft_count<x->rows; fft_count++) { fftw_destroy_plan(x->fftplan[fft_count]); } x->fftplan = (fftw_plan*)realloc(x->fftplan, sizeof(fftw_plan)*rows); for (fft_count=0; fft_count<rows; fft_count++, f_in+=columns, f_out+=columns_re) { x->fftplan[fft_count] = fftw_plan_dft_r2c_1d (columns,f_in,f_out,FFTW_ESTIMATE); } x->fftn=columns; x->rows=rows; f_in=x->f_in; f_out=x->f_out; } #else f_re=(t_float*)realloc(f_re, sizeof(t_float)*size); f_im=(t_float*)realloc(f_im, sizeof(t_float)*size); x->f_re = f_re; x->f_im = f_im; #endif list_re=(t_atom*)realloc(list_re, sizeof(t_atom)*size2); list_im=(t_atom*)realloc(list_im, sizeof(t_atom)*size2); x->size = size; x->size2 = size2; x->list_im = list_im; x->list_re = list_re; /* main part */ #ifdef HAVE_FFTW3_H readDoubleFromList (size, argv, f_in); #else readFloatFromList (size, argv, f_re); #endif list_re += 2; list_im += 2; for (fft_count=0;fft_count<rows;fft_count++){ #ifdef HAVE_FFTW3_H fftw_execute(x->fftplan[fft_count]); writeFFTWComplexPartIntoList(columns_re,list_re,f_out,REALPART); writeFFTWComplexPartIntoList(columns_re,list_im,f_out,IMAGPART); f_out+=columns_re; #else mayer_realfft (columns, f_re); fftRestoreImag (columns, f_re, f_im); writeFloatIntoList (columns_re, list_re, f_re); writeFloatIntoList (columns_re, list_im, f_im); f_im += columns; f_re += columns; #endif list_re += columns_re; list_im += columns_re; } list_re = x->list_re; list_im = x->list_im; SETSYMBOL(list_re, gensym("matrix")); SETSYMBOL(list_im, gensym("matrix")); SETFLOAT(list_re, rows); SETFLOAT(list_im, rows); SETFLOAT(list_re+1, columns_re); SETFLOAT(list_im+1, columns_re); outlet_anything(x->list_im_out, gensym("matrix"), x->size2, list_im); outlet_anything(x->list_re_out, gensym("matrix"), x->size2, list_re); } else post("mtx_rowfft: rowvector size no power of 2!"); }