From 59a57d6fd293f9ff9bfe86cf2da90a890495c16b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?IOhannes=20m=20zm=C3=B6lnig?= Date: Tue, 20 Sep 2005 08:12:38 +0000 Subject: added more objects by fz svn path=/trunk/externals/iem/iemmatrix/; revision=3600 --- src/mtx_decay.c | 251 +++++++++++++++++++++++++++++++++++++++++++++++++++++ src/mtx_rowrfft.c | 205 +++++++++++++++++++++++++++++++++++++++++++ src/mtx_rowrifft.c | 238 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/mtx_slice.c | 215 +++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 909 insertions(+) create mode 100644 src/mtx_decay.c create mode 100644 src/mtx_rowrfft.c create mode 100644 src/mtx_rowrifft.c create mode 100644 src/mtx_slice.c (limited to 'src') diff --git a/src/mtx_decay.c b/src/mtx_decay.c new file mode 100644 index 0000000..9170d43 --- /dev/null +++ b/src/mtx_decay.c @@ -0,0 +1,251 @@ +/* + * iemmatrix + * + * objects for manipulating simple matrices + * mostly refering to matlab/octave matrix functions + * + * Copyright (c) 2005, Franz Zotter + * IEM, Graz, Austria + * + * For information on usage and redistribution, and for a DISCLAIMER OF ALL + * WARRANTIES, see the file, "LICENSE.txt," in this distribution. + * + */ + +#include "iemmatrix.h" + +static t_class *mtx_decay_class; + +typedef struct _MTXDecay_ MTXDecay; +struct _MTXDecay_ +{ + t_object x_obj; + int rows; + int columns; + int size; + int decay_dimension; + int decay_direction; + t_float decay_parameter; + + t_outlet *list_outlet; + + t_atom *list_out; + t_atom *list_in; + t_float *x; + t_float *y; +}; + +static void deleteMTXDecay (MTXDecay *mtx_decay_obj) +{ + if (mtx_decay_obj->list_out) + freebytes (mtx_decay_obj->list_out, sizeof(t_atom)*(mtx_decay_obj->size+2)); + if (mtx_decay_obj->x) + freebytes (mtx_decay_obj->x, sizeof(t_float)*(mtx_decay_obj->size)); + if (mtx_decay_obj->y) + freebytes (mtx_decay_obj->y, sizeof(t_float)*(mtx_decay_obj->size)); +} + +static void mTXSetDecayParameter (MTXDecay *mtx_decay_obj, t_float d_param) +{ + d_param = (d_param > 0.0f)?d_param:0.0f; + d_param = (d_param < 1.0f)?d_param:1.0f; + mtx_decay_obj->decay_parameter = d_param; +} +static void mTXSetDecayDirection (MTXDecay *mtx_decay_obj, t_float c_dir) +{ + int direction = (int) c_dir; + mtx_decay_obj->decay_direction = (direction==-1)?direction:1; +} +static void mTXSetDecayDimension (MTXDecay *mtx_decay_obj, t_float c_dim) +{ + int dimension = (int) c_dim; + mtx_decay_obj->decay_dimension = (dimension==2)?dimension:1; +} + +static void *newMTXDecay (t_symbol *s, int argc, t_atom *argv) +{ + MTXDecay *mtx_decay_obj = (MTXDecay *) pd_new (mtx_decay_class); + int c_dir = 1; + int c_dim = 1; + t_float c_par = 0.9f; + + mtx_decay_obj->decay_dimension = c_dim; + switch ((argc>3)?3:argc) { + case 3: + c_dir = atom_getint(argv+2); + case 2: + c_dim = atom_getint(argv+1); + case 1: + c_par = atom_getfloat(argv); + } + mTXSetDecayParameter (mtx_decay_obj, c_par); + mTXSetDecayDirection (mtx_decay_obj, (t_float) c_dir); + mTXSetDecayDimension (mtx_decay_obj, (t_float) c_dim); + + mtx_decay_obj->list_outlet = outlet_new (&mtx_decay_obj->x_obj, gensym("matrix")); + return ((void *) mtx_decay_obj); +} + +static void mTXDecayBang (MTXDecay *mtx_decay_obj) +{ + if (mtx_decay_obj->list_out) + outlet_anything(mtx_decay_obj->list_outlet, gensym("matrix"), + mtx_decay_obj->size+2, mtx_decay_obj->list_out); +} + +static void writeFloatIntoList (int n, t_atom *l, t_float *f) +{ + for (;n--;f++, l++) + SETFLOAT (l, *f); +} +static void readFloatFromList (int n, t_atom *l, t_float *f) +{ + while (n--) + *f++ = atom_getfloat (l++); +} +static void readFloatFromListModulo (int n, int m, t_atom *l, t_float *f) +{ + t_atom *ptr = l; + int count1, count2; + n /= m; + count1 = m; + while (count1--) + for (count2 = n, ptr = l++; count2--; ptr += m, f++) + *f = atom_getfloat (ptr); +} +static void writeFloatIntoListModulo (int n, int m, t_atom *l, t_float *f) +{ + t_atom *ptr = l; + int count1, count2; + n /= m; + count1 = m; + while (count1--) + for (count2 = n, ptr = l++; count2--; ptr += m, f++) + SETFLOAT(ptr,*f); +} + +static void deCay (int n, t_float *x, t_float *y, t_float alpha) +{ + t_float decay = *x; + t_float oneminusalpha = 1.0f-alpha; + for (;n--; x++, y++) { + decay = alpha * decay + oneminusalpha * *x; + *y = decay = (decay < *x)? *x : decay; + } +} +static void deCayReverse (int n, t_float *x, t_float *y, t_float alpha) +{ + t_float decay = *x; + t_float oneminusalpha = 1.0f-alpha; + for (;n--; x--, y--) { + decay = alpha * decay + oneminusalpha * *x; + *y = decay = (decay < *x)? *x : decay; + } +} + +static void mTXDecayMatrix (MTXDecay *mtx_decay_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_decay_obj->list_out; + t_float *x = mtx_decay_obj->x; + t_float *y = mtx_decay_obj->y; + int count; + + // size check + if (!size) { + post("mtx_decay: invalid dimensions"); + return; + } + else if (list_sizesize) { + x = (t_float *) resizebytes (x, + sizeof (t_float) * (mtx_decay_obj->size), + sizeof (t_float) * (size)); + y = (t_float *) resizebytes (y, + sizeof (t_float) * (mtx_decay_obj->size), + sizeof (t_float) * (size)); + list_out = (t_atom *) resizebytes (list_out, + sizeof (t_atom) * (mtx_decay_obj->size+2), + sizeof (t_atom) * (size + 2)); + } + mtx_decay_obj->size = size; + mtx_decay_obj->rows = rows; + mtx_decay_obj->columns = columns; + mtx_decay_obj->list_out = list_out; + mtx_decay_obj->x = x; + mtx_decay_obj->y = y; + + // main part + // reading matrix from inlet + if (mtx_decay_obj->decay_dimension == 2) { + readFloatFromListModulo (size, columns, list_ptr, x); + columns = mtx_decay_obj->rows; + rows = mtx_decay_obj->columns; + } + else + readFloatFromList (size, list_ptr, x); + + // calculating decay + if (mtx_decay_obj->decay_direction == -1) { + x += columns-1; + y += columns-1; + for (count = rows; count--; x += columns, y += columns) + deCayReverse (columns,x,y,mtx_decay_obj->decay_parameter); + } + else + for (count = rows; count--; x += columns, y += columns) + deCay (columns,x,y,mtx_decay_obj->decay_parameter); + x = mtx_decay_obj->x; + y = mtx_decay_obj->y; + + // writing matrix to outlet + if (mtx_decay_obj->decay_dimension == 2) { + columns = mtx_decay_obj->columns; + rows = mtx_decay_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_decay_obj->list_outlet, gensym("matrix"), + mtx_decay_obj->size+2, list_out); +} + +void mtx_decay_setup (void) +{ + mtx_decay_class = class_new + (gensym("mtx_decay"), + (t_newmethod) newMTXDecay, + (t_method) deleteMTXDecay, + sizeof (MTXDecay), + CLASS_DEFAULT, A_GIMME, 0); + class_addbang (mtx_decay_class, (t_method) mTXDecayBang); + class_addmethod (mtx_decay_class, (t_method) mTXDecayMatrix, gensym("matrix"), A_GIMME,0); + class_addmethod (mtx_decay_class, (t_method) mTXSetDecayParameter, gensym("alpha"), A_DEFFLOAT,0); + class_addmethod (mtx_decay_class, (t_method) mTXSetDecayDimension, gensym("dimension"), A_DEFFLOAT,0); + class_addmethod (mtx_decay_class, (t_method) mTXSetDecayDirection, gensym("direction"), A_DEFFLOAT,0); + class_sethelpsymbol (mtx_decay_class, gensym("iemmatrix/mtx_decay")); +} + +void iemtx_decay_setup(void){ + mtx_decay_setup(); +} diff --git a/src/mtx_rowrfft.c b/src/mtx_rowrfft.c new file mode 100644 index 0000000..e7f0551 --- /dev/null +++ b/src/mtx_rowrfft.c @@ -0,0 +1,205 @@ +/* + * iemmatrix + * + * objects for manipulating simple matrices + * mostly refering to matlab/octave matrix functions + * + * Copyright (c) 2005, Franz Zotter + * IEM, Graz, Austria + * + * For information on usage and redistribution, and for a DISCLAIMER OF ALL + * WARRANTIES, see the file, "LICENSE.txt," in this distribution. + * + */ + +#include "iemmatrix.h" + +static t_class *mtx_rowrfft_class; + +typedef struct _MTXRowrfft_ MTXRowrfft; +struct _MTXRowrfft_ +{ + t_object x_obj; + int rows; + int columns; + int columns_re; + int size; + int size2; + t_float renorm_fac; + + t_float *f_re; + t_float *f_im; + + t_outlet *list_re_out; + t_outlet *list_im_out; + + t_atom *list_re; + t_atom *list_im; +}; + +static void deleteMTXRowrfft (MTXRowrfft *mtx_rowrfft_obj) +{ + if (mtx_rowrfft_obj->f_re) + freebytes (mtx_rowrfft_obj->f_re, sizeof(t_float)*mtx_rowrfft_obj->size); + if (mtx_rowrfft_obj->f_im) + freebytes (mtx_rowrfft_obj->f_im, sizeof(t_float)*mtx_rowrfft_obj->size); + if (mtx_rowrfft_obj->list_re) + freebytes (mtx_rowrfft_obj->list_re, sizeof(t_atom)*(mtx_rowrfft_obj->size2+2)); + if (mtx_rowrfft_obj->list_im) + freebytes (mtx_rowrfft_obj->list_im, sizeof(t_atom)*(mtx_rowrfft_obj->size2+2)); +} + +static void *newMTXRowrfft (t_symbol *s, int argc, t_atom *argv) +{ + MTXRowrfft *mtx_rowrfft_obj = (MTXRowrfft *) pd_new (mtx_rowrfft_class); + mtx_rowrfft_obj->list_re_out = outlet_new (&mtx_rowrfft_obj->x_obj, gensym("matrix")); + mtx_rowrfft_obj->list_im_out = outlet_new (&mtx_rowrfft_obj->x_obj, gensym("matrix")); + return ((void *) mtx_rowrfft_obj); +} + +static void mTXrowrfftBang (MTXRowrfft *mtx_rowrfft_obj) +{ + if (mtx_rowrfft_obj->list_im) { + outlet_anything(mtx_rowrfft_obj->list_im_out, gensym("matrix"), mtx_rowrfft_obj->size2+2, mtx_rowrfft_obj->list_im); + outlet_anything(mtx_rowrfft_obj->list_re_out, gensym("matrix"), mtx_rowrfft_obj->size2+2, mtx_rowrfft_obj->list_re); + } +} + +static void fftRestoreImag (int n, t_float *re, t_float *im) +{ + t_float *im2; + n >>= 1; + *im=0; + re += n; + im += n; + im2 = im; + *im=0; + while (--n) { + *--im = -*++re; + *++im2 = 0; + *re = 0; + } +} + +static void zeroFloatArray (int n, t_float *f) +{ + while (n--) + *f++ = 0.0f; +} + +static void writeFloatIntoList (int n, t_atom *l, t_float *f) +{ + for (;n--;f++, l++) + SETFLOAT (l, *f); +} +static void readFloatFromList (int n, t_atom *l, t_float *f) +{ + while (n--) + *f++ = atom_getfloat (l++); +} + +static void mTXrowrfftMatrix (MTXRowrfft *mtx_rowrfft_obj, t_symbol *s, + int argc, t_atom *argv) +{ + //mTXrowrfftList (mtx_rowrfft_obj, s, argc-2, argv+2); + int rows = atom_getint (argv++); + int columns = atom_getint (argv++); + int columns_re = (columns>>1)+1; + int size = rows * columns; + int in_size = argc-2; + int size2 = columns_re * rows; + int fft_count; + t_atom *ptr_re = mtx_rowrfft_obj->list_re; + t_atom *ptr_im = mtx_rowrfft_obj->list_im; + t_float *f_re = mtx_rowrfft_obj->f_re; + t_float *f_im = mtx_rowrfft_obj->f_im; + + // fftsize check + if (!size) + post("mtx_rowrfft: invalid dimensions"); + else if (in_sizesize) { + f_re = (t_float *) resizebytes (f_re, + sizeof (t_float) * mtx_rowrfft_obj->size, + sizeof (t_float) * size); + f_im = (t_float *) resizebytes (f_im, + sizeof (t_float) * mtx_rowrfft_obj->size, + sizeof (t_float) * size); + ptr_re = (t_atom *) resizebytes (ptr_re, + sizeof (t_atom) * (mtx_rowrfft_obj->size2+2), + sizeof (t_atom) * (size2 + 2)); + ptr_im = (t_atom *) resizebytes (ptr_im, + sizeof (t_atom) * (mtx_rowrfft_obj->size2+2), + sizeof (t_atom) * (size2 + 2)); + } + } + else { + f_re = (t_float *) getbytes (sizeof (t_float) * size); + f_im = (t_float *) getbytes (sizeof (t_float) * size); + ptr_re = (t_atom *) getbytes (sizeof (t_atom) * (size2+2)); + ptr_im = (t_atom *) getbytes (sizeof (t_atom) * (size2+2)); + } + mtx_rowrfft_obj->size = size; + mtx_rowrfft_obj->size2 = size2; + mtx_rowrfft_obj->rows = rows; + mtx_rowrfft_obj->columns = columns; + mtx_rowrfft_obj->columns_re = columns_re; + mtx_rowrfft_obj->list_im = ptr_im; + mtx_rowrfft_obj->list_re = ptr_re; + mtx_rowrfft_obj->f_re = f_re; + mtx_rowrfft_obj->f_im = f_im; + + // main part + readFloatFromList (size, argv, f_re); + + fft_count = rows; + ptr_re += 2; + ptr_im += 2; + while (fft_count--){ + mayer_realfft (columns, f_re); + fftRestoreImag (columns, f_re, f_im); + writeFloatIntoList (columns_re, ptr_re, f_re); + writeFloatIntoList (columns_re, ptr_im, f_im); + f_im += columns; + f_re += columns; + ptr_re += columns_re; + ptr_im += columns_re; + } + ptr_re = mtx_rowrfft_obj->list_re; + ptr_im = mtx_rowrfft_obj->list_im; + + SETSYMBOL(ptr_re, gensym("matrix")); + SETSYMBOL(ptr_im, gensym("matrix")); + SETFLOAT(ptr_re, rows); + SETFLOAT(ptr_im, rows); + SETFLOAT(&ptr_re[1], columns_re); + SETFLOAT(&ptr_im[1], columns_re); + outlet_anything(mtx_rowrfft_obj->list_im_out, gensym("matrix"), + mtx_rowrfft_obj->size2+2, ptr_im); + outlet_anything(mtx_rowrfft_obj->list_re_out, gensym("matrix"), + mtx_rowrfft_obj->size2+2, ptr_re); + } + else + post("mtx_rowfft: rowvector size no power of 2!"); +} + +void mtx_rowrfft_setup (void) +{ + mtx_rowrfft_class = class_new + (gensym("mtx_rowrfft"), + (t_newmethod) newMTXRowrfft, + (t_method) deleteMTXRowrfft, + sizeof (MTXRowrfft), + CLASS_DEFAULT, A_GIMME, 0); + class_addbang (mtx_rowrfft_class, (t_method) mTXrowrfftBang); + class_addmethod (mtx_rowrfft_class, (t_method) mTXrowrfftMatrix, gensym("matrix"), A_GIMME,0); + class_sethelpsymbol (mtx_rowrfft_class, gensym("iemmatrix/mtx_rowrfft")); +} + +void iemtx_rowrfft_setup(void){ + mtx_rowrfft_setup(); +} diff --git a/src/mtx_rowrifft.c b/src/mtx_rowrifft.c new file mode 100644 index 0000000..9eaba9c --- /dev/null +++ b/src/mtx_rowrifft.c @@ -0,0 +1,238 @@ +/* + * iemmatrix + * + * objects for manipulating simple matrices + * mostly refering to matlab/octave matrix functions + * + * Copyright (c) 2005, Franz Zotter + * IEM, Graz, Austria + * + * For information on usage and redistribution, and for a DISCLAIMER OF ALL + * WARRANTIES, see the file, "LICENSE.txt," in this distribution. + * + */ + +#include "iemmatrix.h" + +static t_class *mtx_rowrifft_class; + +typedef struct _MTXRowrifft_ +{ + t_object x_obj; + int rows; + int columns; + int columns_re; + int size; + int size2; + t_float renorm_fac; + + t_float *f_re; + t_float *f_im; + + t_outlet *list_re_out; + t_outlet *list_im_out; + + t_atom *list_re; + t_atom *list_im; +} MTXRowrifft; + + +// helper functions: these should really go into a separate file! + + +static void zeroFloatArray (int n, t_float *f) +{ + while (n--) + *f++ = 0.0f; +} + +static void writeFloatIntoList (int n, t_atom *l, t_float *f) +{ + for (;n--;f++, l++) + SETFLOAT (l, *f); +} +static void readFloatFromList (int n, t_atom *l, t_float *f) +{ + while (n--) + *f++ = atom_getfloat (l++); +} + +//--------------inverse real fft + +static void multiplyVector (int n, t_float *f, t_float fac) +{ + while (n--) + *f++ *= fac; +} + + +static void ifftPrepareReal (int n, t_float *re, t_float *im) +{ + n >>= 1; + re += n; + im += n; + + while (--n) + *++re = -*--im; +} + + +static void *newMTXRowrifft (t_symbol *s, int argc, t_atom *argv) +{ + MTXRowrifft *mtx_rowrifft_obj = (MTXRowrifft *) pd_new (mtx_rowrifft_class); + inlet_new(&mtx_rowrifft_obj->x_obj, &mtx_rowrifft_obj->x_obj.ob_pd, gensym("matrix"),gensym("")); + mtx_rowrifft_obj->list_re_out = outlet_new (&mtx_rowrifft_obj->x_obj, gensym("matrix")); + return ((void *) mtx_rowrifft_obj); +} + + +static void mTXrowrifftMatrixCold (MTXRowrifft *mtx_rowrifft_obj, t_symbol *s, + int argc, t_atom *argv) +{ + //mTXrowrifftList (mtx_rowrifft_obj, s, argc-2, argv+2); + int rows = atom_getint (argv++); + int columns_re = atom_getint (argv++); + int in_size = argc-2; + int columns = (columns_re-1)<<1; + int size2 = columns_re * rows; + int size = rows * columns; + int ifft_count; + t_atom *ptr_re = mtx_rowrifft_obj->list_re; + t_float *f_re = mtx_rowrifft_obj->f_re; + t_float *f_im = mtx_rowrifft_obj->f_im; + + // ifftsize check + if (!size) + post("mtx_rowrifft: invalid dimensions"); + else if (in_size < size2) + post("mtx_rowrifft: sparse matrix not yet supported: use \"mtx_check\""); + else if (columns == (1 << ilog2(columns))) { + // memory things + if (f_re) { + if (size != mtx_rowrifft_obj->size) { + f_re = (t_float *) resizebytes (f_re, + sizeof (t_float) * mtx_rowrifft_obj->size, + sizeof (t_float) * size); + f_im = (t_float *) resizebytes (f_im, + sizeof (t_float) * mtx_rowrifft_obj->size, + sizeof (t_float) * size); + ptr_re = (t_atom *) resizebytes (ptr_re, + sizeof (t_atom) * (mtx_rowrifft_obj->size + 2), + sizeof (t_atom) * (size + 2)); + } + } + else { + f_re = (t_float *) getbytes (sizeof (t_float) * size); + f_im = (t_float *) getbytes (sizeof (t_float) * size); + ptr_re = (t_atom *) getbytes (sizeof (t_atom) * (size + 2)); + } + mtx_rowrifft_obj->size = size; + mtx_rowrifft_obj->size2 = size2; + mtx_rowrifft_obj->rows = rows; + mtx_rowrifft_obj->columns = columns; + mtx_rowrifft_obj->columns_re = columns_re; + mtx_rowrifft_obj->list_re = ptr_re; + mtx_rowrifft_obj->f_re = f_re; + mtx_rowrifft_obj->f_im = f_im; + + // main part: reading imaginary part + ifft_count = rows; + mtx_rowrifft_obj->renorm_fac = 1.0f / columns; + while (ifft_count--) { + readFloatFromList (columns_re, argv, f_im); + argv += columns_re; + f_im += columns; + } + // do nothing else! + } + else + post("mtx_rowrifft: rowvector size no power of 2!"); +} + +static void mTXrowrifftMatrixHot (MTXRowrifft *mtx_rowrifft_obj, t_symbol *s, + int argc, t_atom *argv) +{ + //mTXrowrifftList (mtx_rowrifft_obj, s, argc-2, argv+2); + int rows = atom_getint (argv++); + int columns_re = atom_getint (argv++); + int columns = mtx_rowrifft_obj->columns; + int size = mtx_rowrifft_obj->size; + int in_size = argc-2; + int size2 = mtx_rowrifft_obj->size2; + int ifft_count; + t_atom *ptr_re = mtx_rowrifft_obj->list_re; + t_float *f_re = mtx_rowrifft_obj->f_re; + t_float *f_im = mtx_rowrifft_obj->f_im; + t_float renorm_fac; + + // ifftsize check + if ((rows != mtx_rowrifft_obj->rows) || + (columns_re != mtx_rowrifft_obj->columns_re)) + post("mtx_rowrifft: matrix dimensions do not match"); + else if (in_sizesize2) + post("mtx_rowrifft: invalid right side matrix"); + else { // main part + ifft_count = rows; + ptr_re += 2; + renorm_fac = mtx_rowrifft_obj->renorm_fac; + while (ifft_count--){ + readFloatFromList (columns_re, argv, f_re); + ifftPrepareReal (columns, f_re, f_im); + mayer_realifft (columns, f_re); + multiplyVector (columns, f_re, renorm_fac); + f_im += columns; + f_re += columns; + ptr_re += columns; + argv += columns_re; + } + ptr_re = mtx_rowrifft_obj->list_re; + f_re = mtx_rowrifft_obj->f_re; + size2 = mtx_rowrifft_obj->size2; + + SETSYMBOL(ptr_re, gensym("matrix")); + SETFLOAT(ptr_re, rows); + SETFLOAT(&ptr_re[1], mtx_rowrifft_obj->columns); + writeFloatIntoList (size, ptr_re+2, f_re); + outlet_anything(mtx_rowrifft_obj->list_re_out, gensym("matrix"), size+2, ptr_re); + } +} + +static void mTXrowrifftBang (MTXRowrifft *mtx_rowrifft_obj) +{ + if (mtx_rowrifft_obj->list_re) + outlet_anything(mtx_rowrifft_obj->list_re_out, gensym("matrix"), + mtx_rowrifft_obj->size+2, mtx_rowrifft_obj->list_re); +} + + +static void deleteMTXRowrifft (MTXRowrifft *mtx_rowrfft_obj) +{ + if (mtx_rowrfft_obj->f_re) + freebytes (mtx_rowrfft_obj->f_re, sizeof(t_float)*mtx_rowrfft_obj->size); + if (mtx_rowrfft_obj->f_im) + freebytes (mtx_rowrfft_obj->f_im, sizeof(t_float)*mtx_rowrfft_obj->size); + if (mtx_rowrfft_obj->list_re) + freebytes (mtx_rowrfft_obj->list_re, sizeof(t_atom)*(mtx_rowrfft_obj->size2+2)); + if (mtx_rowrfft_obj->list_im) + freebytes (mtx_rowrfft_obj->list_im, sizeof(t_atom)*(mtx_rowrfft_obj->size2+2)); +} + +static void mtx_rowrifft_setup (void) +{ + mtx_rowrifft_class = class_new + (gensym("mtx_rowrifft"), + (t_newmethod) newMTXRowrifft, + (t_method) deleteMTXRowrifft, + sizeof (MTXRowrifft), + CLASS_DEFAULT, A_GIMME, 0); + class_addbang (mtx_rowrifft_class, (t_method) mTXrowrifftBang); + class_addmethod (mtx_rowrifft_class, (t_method) mTXrowrifftMatrixHot, gensym("matrix"), A_GIMME,0); + class_addmethod (mtx_rowrifft_class, (t_method) mTXrowrifftMatrixCold, gensym(""), A_GIMME,0); + class_sethelpsymbol (mtx_rowrifft_class, gensym("iemmatrix/mtx_rowrfft")); +} + +void iemtx_rowrifft_setup(void){ + mtx_rowrifft_setup(); +} diff --git a/src/mtx_slice.c b/src/mtx_slice.c new file mode 100644 index 0000000..7dc1042 --- /dev/null +++ b/src/mtx_slice.c @@ -0,0 +1,215 @@ +/* + * iemmatrix + * + * objects for manipulating simple matrices + * mostly refering to matlab/octave matrix functions + * + * Copyright (c) 2005, Franz Zotter + * IEM, Graz, Austria + * + * For information on usage and redistribution, and for a DISCLAIMER OF ALL + * WARRANTIES, see the file, "LICENSE.txt," in this distribution. + * + */ + +#include "iemmatrix.h" + +static t_class *mtx_slice_class; + +typedef struct _MTXslice_ MTXslice; +struct _MTXslice_ +{ + t_object x_obj; + int slice_size; + int slice_startcol; + int slice_startrow; + int slice_stopcol; + int slice_stoprow; + + t_outlet *list_outlet; + + t_atom *list_out; +}; + +static void deleteMTXSlice (MTXslice *mtx_slice_obj) +{ + if (mtx_slice_obj->list_out) + freebytes (mtx_slice_obj->list_out, sizeof(t_atom)*(mtx_slice_obj->slice_size+2)); +} + +static void mTXSliceIndexList (MTXslice *mtx_slice_obj, t_symbol *s, + int argc, t_atom *argv) +{ + int startcol; + int startrow; + int stopcol; + int stoprow; + t_symbol *endsym = gensym("end"); + t_atom *list_out = mtx_slice_obj->list_out; + + if (argc<4) { + post("mtx_slice: invalid index vector: "); + return; + } + startrow = atom_getint(&argv[0]); + startcol = atom_getint(&argv[1]); + stoprow = atom_getint(&argv[2]); + stopcol = atom_getint(&argv[3]); + if (atom_getsymbol(&argv[0])==endsym) { + startrow = -1; + } + if (atom_getsymbol(&argv[1])==endsym) { + startcol = -1; + } + if (atom_getsymbol(&argv[2])==endsym) { + stoprow = -1; + } + if (atom_getsymbol(&argv[3])==endsym) { + stopcol = -1; + } + + if (((startrow<1) && (atom_getsymbol(&argv[0])!=endsym)) || + ((startcol<1) && (atom_getsymbol(&argv[1])!=endsym))) { + post("mtx_slice: row and column indices must be >0, or misused \"end\" keyword"); + return; + } + + if (((startrow>stoprow) && (atom_getsymbol(&argv[2])!=endsym)) || + ((startcol>stopcol) && (atom_getsymbol (&argv[3])!=endsym))) { + post("mtx_slice: start_indexslice_startrow = startrow; + mtx_slice_obj->slice_startcol = startcol; + mtx_slice_obj->slice_stoprow = stoprow; + mtx_slice_obj->slice_stopcol = stopcol; +} + +static void *newMTXSlice (t_symbol *s, int argc, t_atom *argv) +{ + MTXslice *mtx_slice_obj = (MTXslice *) pd_new (mtx_slice_class); + if (argc==4) + mTXSliceIndexList (mtx_slice_obj, gensym("list"),argc,argv); + else { + mtx_slice_obj->slice_startrow = 1; + mtx_slice_obj->slice_startcol = 1; + mtx_slice_obj->slice_stopcol = -1; + mtx_slice_obj->slice_stoprow = -1; + } + mtx_slice_obj->list_outlet = outlet_new (&mtx_slice_obj->x_obj, gensym("matrix")); + inlet_new(&mtx_slice_obj->x_obj, &mtx_slice_obj->x_obj.ob_pd, gensym("list"),gensym("")); + return ((void *) mtx_slice_obj); +} + +static void mTXSliceBang (MTXslice *mtx_slice_obj) +{ + if (mtx_slice_obj->list_out) + outlet_anything(mtx_slice_obj->list_outlet, gensym("matrix"), + mtx_slice_obj->slice_size+2, mtx_slice_obj->list_out); +} +/* + static void copyList (int size, t_atom *x, t_atom *y) + { + while(size--) + *y++=*x++; + } +*/ + +static void writeVectorIntoList (int n, t_atom *x, t_atom *y) +{ + for (;n--;x++,y++) + *y = *x; +} + +static void writeSliceIntoList (int slicerows, const int slicecols, int columns, t_atom *x, t_atom *y) +{ + for (;slicerows--;x+=columns,y+=slicecols) + writeVectorIntoList(slicecols, x, y); +} + +static void mTXSliceMatrix (MTXslice *mtx_slice_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_in = argv; + t_atom *list_out = mtx_slice_obj->list_out; + int stopcol = mtx_slice_obj->slice_stopcol; + int stoprow = mtx_slice_obj->slice_stoprow; + int startrow = mtx_slice_obj->slice_startrow; + int startcol = mtx_slice_obj->slice_startcol; + int slicecols, slicerows, slicesize; + + // size check + if (!size) { + post("mtx_slice: invalid dimensions"); + return; + } + else if (list_size0"); + return; + } + if ((stopcol > columns) || + (stoprow > rows)) { + post("mtx_slice: slice index exceeds matrix dimensions"); + return; + } + if ((stoprowslice_size) { + if (!list_out) + list_out = (t_atom *) getbytes (sizeof (t_atom) * (slicesize + 2)); + else + list_out = (t_atom *) resizebytes (list_out, + sizeof (t_atom) * (mtx_slice_obj->slice_size+2), + sizeof (t_atom) * (slicesize + 2)); + mtx_slice_obj->slice_size = slicesize; + mtx_slice_obj->list_out = list_out; + } + list_out += 2; + list_in += columns * (startrow-1) + startcol-1; + writeSliceIntoList (slicerows, slicecols, + columns, list_in,list_out); + list_out = mtx_slice_obj->list_out; + SETSYMBOL(list_out, gensym("matrix")); + SETFLOAT(list_out, slicerows); + SETFLOAT(&list_out[1], slicecols); + outlet_anything(mtx_slice_obj->list_outlet, gensym("matrix"), + slicesize+2, list_out); +} + +void mtx_slice_setup (void) +{ + mtx_slice_class = class_new + (gensym("mtx_slice"), + (t_newmethod) newMTXSlice, + (t_method) deleteMTXSlice, + sizeof (MTXslice), + CLASS_DEFAULT, A_GIMME, 0); + class_addbang (mtx_slice_class, (t_method) mTXSliceBang); + class_addmethod (mtx_slice_class, (t_method) mTXSliceMatrix, gensym("matrix"), A_GIMME,0); + class_addmethod (mtx_slice_class, (t_method) mTXSliceIndexList, gensym(""), A_GIMME,0); + class_sethelpsymbol (mtx_slice_class, gensym("iemmatrix/mtx_slice")); +} + +void iemtx_slice_setup(void){ + mtx_slice_setup(); +} -- cgit v1.2.1