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!");
}
