static void mtx_mulelement_matrix(t_mtx_binmtx *x, t_symbol *s, int argc, t_atom *argv)
{
int row=atom_getfloat(argv++);
int col=atom_getfloat(argv++);
t_atom *m;
t_atom *m2 = x->m2.atombuffer+2;
int n = argc-2;
if (argc<2){ pd_error(x, "crippled matrix"); return; }
if ((col<1)||(row<1)) { pd_error(x, "invalid dimensions"); return; }
if (col*row>argc-2){ pd_error(x, "sparse matrix not yet supported : use \"mtx_check\""); return; }
if (!(x->m2.col*x->m2.row)) {
adjustsize(&x->m, row, col);
matrix_set(&x->m, 0);
outlet_anything(x->x_obj.ob_outlet, gensym("matrix"), argc, x->m.atombuffer);
return;
}
if ((col!=x->m2.col)||(row!=x->m2.row)){ pd_error(x, "matrix dimension do not match"); /* LATER SOLVE THIS */ return; }
adjustsize(&x->m, row, col);
m = x->m.atombuffer+2;
while(n--){
t_float f = atom_getfloat(argv++)*atom_getfloat(m2++);
SETFLOAT(m, f);
m++;
}
outlet_anything(x->x_obj.ob_outlet, gensym("matrix"), argc, x->m.atombuffer);
}
static void *mtx_row_new(t_symbol *s, int argc, t_atom *argv)
{
t_matrix *x = (t_matrix *)pd_new(mtx_row_class);
int i, j, q;
outlet_new(&x->x_obj, 0);
inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym(""));
x->current_row=0;
x->col=x->row=0;
x->atombuffer=0;
switch (argc) {
case 0:break;
case 1:
i = atom_getfloat(argv);
if (i<0)i=0;
if(i)adjustsize(x, i, i);
matrix_set(x, 0);
break;
case 2:
i = atom_getfloat(argv++);if(i<0)i=0;
j = atom_getfloat(argv++);if(j<0)j=0;
if(i*j)adjustsize(x, i, j);
matrix_set(x, 0);
break;
default:
i = atom_getfloat(argv++);if(i<0)i=0;
j = atom_getfloat(argv++);if(j<0)j=0;
q = atom_getfloat(argv++);if(q<0)q=0;
if(i*j)adjustsize(x, i, j);
matrix_set(x, 0);
x->current_row=q;
}
return (x);
}
static void *matrix_new(t_symbol *s, int argc, t_atom *argv)
{
t_matrix *x = (t_matrix *)pd_new(matrix_class);
int row, col;
inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("matrix"), gensym(""));
outlet_new(&x->x_obj, 0);
x->atombuffer = 0;
x->x_canvas = canvas_getcurrent();
switch (argc) {
case 0:
row = col = 0;
break;
case 1:
if (argv->a_type == A_SYMBOL) {
matrix_read(x, argv->a_w.w_symbol);
return(x);
}
row = col = atom_getfloat(argv);
break;
default:
row = atom_getfloat(argv++);
col = atom_getfloat(argv++);
}
if(row*col) {
adjustsize(x, row, col);
matrix_set(x, 0);
}
return (x);
}
static void mTXConcatDoColConcatenation (MTXconcat *mtx_concat_obj,
t_matrix *mtx1, t_matrix *mtx2, t_matrix *mtx_out)
{
int mrows = mtx1->row + mtx2->row;
int cnt;
t_atom *ptr_in1 = mtx1->atombuffer+2;
t_atom *ptr_in2 = mtx2->atombuffer+2;
t_atom *ptr_out;
if (mtx1->col != mtx2->col) {
pd_error(mtx_concat_obj, "[mtx_concat]: col-mode: matrices must have same number of columns!");
return;
}
adjustsize (mtx_out, mrows, mtx1->col);
ptr_out = mtx_out->atombuffer+2;
for (cnt=mtx1->row; cnt--; ptr_in1 += mtx1->col,
ptr_out += mtx_out->col) {
memcpy (ptr_out, ptr_in1, mtx1->col * sizeof(t_atom));
}
for (cnt=mtx2->row; cnt--; ptr_in2 += mtx2->col,
ptr_out += mtx_out->col) {
memcpy (ptr_out, ptr_in2, mtx2->col * sizeof(t_atom));
}
mTXConcatBang(mtx_concat_obj);
}
static void mtx_roll_matrix(t_matrix *x, t_symbol *s, int argc,
t_atom *argv)
{
int row, col, colroll;
t_atom *ap;
int c;
if(iemmatrix_check(x, argc, argv, 0))return;
row=atom_getint(argv++);
col=atom_getint(argv++);
colroll = ((int)x->f%col+col)%col;
adjustsize(x, row, col);
ap = x->atombuffer+2;
c=col;
while(c--) {
t_atom *in = argv+col-c-1;
t_atom *out = ap +(col-c-1+colroll)%col;
int r = row;
while (r--) {
SETFLOAT(out, atom_getfloat(in));
out+=col;
in+=col;
}
}
matrix_bang(x);
}
static void mtx_atan2_float(t_mtx_binmtx *x, t_float f)
{
t_matrix *m=&x->m, *m2=&x->m2;
t_atom *ap, *ap2=m2->atombuffer+2;
int row2, col2, n;
if (!m2->atombuffer) {
pd_error(x, "[mtx_atan2]: right-hand matrix is missing");
return;
}
row2=atom_getfloat(m2->atombuffer);
col2=atom_getfloat(m2->atombuffer+1);
adjustsize(m, row2, col2);
ap=m->atombuffer+2;
n=row2*col2;
while(n--) {
SETFLOAT(ap, atan2f(f,atom_getfloat(ap2++)));
ap++;
}
outlet_anything(x->x_obj.ob_outlet, gensym("matrix"), m->row*m->col+2,
m->atombuffer);
}
static void mtx_mul_matrix(t_mtx_binmtx *x, t_symbol *s, int argc, t_atom *argv)
{
t_matrix *m=&x->m, *m2=&x->m2;
t_atom *ap, *ap1=argv+2, *ap2=m2->atombuffer+2;
int row=atom_getfloat(argv), col=atom_getfloat(argv+1);
int row2, col2, n, r, c;
if (!m2->atombuffer){ pd_error(x, "right-hand matrix is missing"); return; }
if (argc<2){ pd_error(x, "crippled matrix"); return; }
if ((col<1)||(row<1)){pd_error(x, "invalid dimensions"); return; }
if (col*row>argc-2){ pd_error(x, "sparse matrix not yet supported : use \"mtx_check\""); return; }
row2=atom_getfloat(m2->atombuffer);
col2=atom_getfloat(m2->atombuffer+1);
if (col!=row2) { pd_error(x, "matrix dimensions do not match !"); return; }
adjustsize(m, row, col2);
ap=m->atombuffer+2;
for(r=0;r<row;r++)
for(c=0;c<col2;c++) {
t_matrixfloat sum = 0.f;
for(n=0;n<col;n++)sum+=(t_matrixfloat)atom_getfloat(ap1+col*r+n)*atom_getfloat(ap2+col2*n+c);
SETFLOAT(ap+col2*r+c,sum);
}
outlet_anything(x->x_obj.ob_outlet, gensym("matrix"), m->row*m->col+2, m->atombuffer);
}
static void mtx_dbtorms_matrix(t_mtx_binmtx *x, t_symbol *s, int argc, t_atom *argv)
{
int row=atom_getfloat(argv++);
int col=atom_getfloat(argv++);
t_atom *m;
int n = argc-2;
if (argc<2){ post("mtx_dbtorms: crippled matrix"); return; }
if ((col<1)||(row<1)) { post("mtx_dbtorms: invalid dimensions"); return; }
if (col*row>argc-2){ post("sparse matrix not yet supported : use \"mtx_check\""); return; }
adjustsize(&x->m, row, col);
m = x->m.atombuffer+2;
while(n--){
t_float f=atom_getfloat(argv++);
t_float v=0;
f=(f>485)?485:f;
v=(f<=0)?0:exp((LOGTEN*0.05) * (f-100.));
SETFLOAT(m, (v<0)?0:v);
m++;
}
outlet_anything(x->x_obj.ob_outlet, gensym("matrix"), argc, x->m.atombuffer);
}
static void mtx_atan2_matrix(t_mtx_binmtx *x, t_symbol *s, int argc,
t_atom *argv)
{
int row=atom_getfloat(argv);
int col=atom_getfloat(argv+1);
t_atom *m;
t_atom *m1 = argv+2;
t_atom *m2 = x->m2.atombuffer+2;
int n = argc-2;
if(iemmatrix_check(x, argc, argv, 0))return;
if (!(x->m2.col*x->m2.row)) {
outlet_anything(x->x_obj.ob_outlet, gensym("matrix"), argc, argv);
return;
}
if ((col!=x->m2.col)||(row!=x->m2.row)) {
pd_error(x, "[mtx_atan2]: matrix dimensions do not match");
/* LATER SOLVE THIS */
return;
}
adjustsize(&x->m, row, col);
m = x->m.atombuffer+2;
while(n--) {
t_float f1=atom_getfloat(m1++);
t_float f2=atom_getfloat(m2++);
t_float f = atan2f(f1,f2);
SETFLOAT(m, f);
m++;
}
outlet_anything(x->x_obj.ob_outlet, gensym("matrix"), argc,
x->m.atombuffer);
}
static void matrix_size(t_matrix *x, t_symbol *s, int argc, t_atom *argv)
{
int col, row;
switch(argc) {
case 0: /* size */
if (x->row*x->col)
outlet_list(x->x_obj.ob_outlet, gensym("size"), 2, x->atombuffer);
break;
case 1:
row=atom_getfloat(argv);
adjustsize(x, row, row);
matrix_set(x, 0);
break;
default:
row=atom_getfloat(argv++);
col=atom_getfloat(argv);
adjustsize(x, row, col);
matrix_set(x, 0);
}
}
static void mtx_mulscalar_list(t_mtx_binscalar *x, t_symbol *s, int argc, t_atom *argv)
{
int n=argc;
t_atom *m;
t_float factor = x->f;
adjustsize(&x->m, 1, argc);
m = x->m.atombuffer;
while(n--){
m->a_type = A_FLOAT;
(m++)->a_w.w_float = atom_getfloat(argv++)*factor;
}
outlet_list(x->x_obj.ob_outlet, gensym("list"), argc, x->m.atombuffer);
}
void *
domalloc(size_t len)
{
void *ret;
size_t blocklen;
blocklen = adjustsize(len);
ret = malloc(blocklen);
if (ret == NULL) {
complain(NULL, "Out of memory");
die();
}
return placeheaders(ret, len);
}
static void mtx_rmstodb_list(t_mtx_binscalar *x, t_symbol *s, int argc, t_atom *argv)
{
int n=argc;
t_atom *m;
adjustsize(&x->m, 1, argc);
m = x->m.atombuffer;
while(n--){
t_float f=atom_getfloat(argv++);
t_float v=(f<0)?0.:(100+20./LOGTEN * log(f));
SETFLOAT(m, (v<0)?0:v);
m++;
}
outlet_list(x->x_obj.ob_outlet, gensym("list"), argc, x->m.atombuffer);
}
void *
dorealloc(void *ptr, size_t oldlen, size_t newlen)
{
void *ret;
void *blockptr;
size_t newblocklen;
blockptr = checkheaders(ptr, oldlen);
newblocklen = adjustsize(newlen);
ret = realloc(blockptr, newblocklen);
if (ret == NULL) {
complain(NULL, "Out of memory");
die();
}
return placeheaders(ret, newlen);
}
static void mtx_scroll_matrix(t_matrix *x, t_symbol *s, int argc,
t_atom *argv)
{
int row, col, rowscroll;
if(iemmatrix_check(x, argc, argv, 0))return;
row=atom_getfloat(argv++);
col=atom_getfloat(argv++);
rowscroll = ((int)x->f%row+row)%row;
adjustsize(x, row, col);
memcpy(x->atombuffer+2, argv+(row-rowscroll)*col,
rowscroll*col*sizeof(t_atom));
memcpy(x->atombuffer+2+rowscroll*col, argv,
(row-rowscroll)*col*sizeof(t_atom));
matrix_bang(x);
}
static void mtx_dbtorms_list(t_mtx_binscalar *x, t_symbol *s, int argc, t_atom *argv)
{
int n=argc;
t_atom *m;
adjustsize(&x->m, 1, argc);
m = x->m.atombuffer;
while(n--){
t_float f=atom_getfloat(argv++);
t_float v=0;
f=(f>485)?485:f;
v=(f<=0)?0:exp((LOGTEN*0.05) * (f-100.));
SETFLOAT(m, (v<0)?0:v);
m++;
}
outlet_list(x->x_obj.ob_outlet, gensym("list"), argc, x->m.atombuffer);
}
static void mtx_mean_matrix(t_matrix *x, t_symbol *s, int argc, t_atom *argv)
{
int row=atom_getfloat(argv++);
int col=atom_getfloat(argv++);
t_atom *ip, *op;
int c=col, r;
t_float sum;
t_float factor=1./row;
adjustsize(x, 1, col);
op=x->atombuffer;
while(c--){
sum=0;
ip=argv+col-c-1;
r=row;
while(r--)sum+=atom_getfloat(ip+col*r);
SETFLOAT(op, sum*factor);
op++;
}
outlet_list(x->x_obj.ob_outlet, gensym("row"), col, x->atombuffer);
}
static void mtx_abs_matrix(t_mtx_binmtx *x, t_symbol *s, int argc, t_atom *argv)
{
int row=atom_getint(argv++);
int col=atom_getint(argv++);
t_atom *m;
int n = row*col;
if (argc<2){ post("mtx_abs: crippled matrix"); return; }
if ((col<1)||(row<1)) { post("mtx_abs: invalid dimensions"); return; }
if (col*row>argc-2){ post("sparse matrix not yet supported : use \"mtx_check\""); return; }
adjustsize(&x->m, row, col);
m = x->m.atombuffer+2;
while(n--){
t_float f = atom_getfloat(argv++);
SETFLOAT(m, (t_float)fabs(f));
m++;
}
outlet_anything(x->x_obj.ob_outlet, gensym("matrix"), argc, x->m.atombuffer);
}
static void mtx_divscalar_matrix(t_mtx_binscalar *x, t_symbol *s, int argc, t_atom *argv)
{
int n=argc-2;
t_atom *m;
t_float factor = 1.0/x->f;
int row=atom_getfloat(argv++);
int col=atom_getfloat(argv++);
if (argc<2){
pd_error(x, "crippled matrix");
return;
}
adjustsize(&x->m, row, col);
m = x->m.atombuffer+2;
while(n--){
m->a_type = A_FLOAT;
(m++)->a_w.w_float = atom_getfloat(argv++)*factor;
}
outlet_anything(x->x_obj.ob_outlet, gensym("matrix"), argc, x->m.atombuffer);
}
static void mtx_atan2scalar_matrix(t_mtx_binscalar *x, t_symbol *s,
int argc, t_atom *argv)
{
int n=argc-2;
int row=atom_getfloat(argv), col=atom_getfloat(argv+1);
t_float offset=x->f;
t_atom *buf;
t_atom *ap=argv+2;
if(iemmatrix_check(x, argc, argv, IEMMATRIX_CHECK_CRIPPLED))return;
adjustsize(&x->m, row, col);
buf=x->m.atombuffer+2;
while(n--) {
buf->a_type = A_FLOAT;
buf++->a_w.w_float = atan2f(atom_getfloat(ap),offset);
ap++;
}
outlet_anything(x->x_obj.ob_outlet, gensym("matrix"), argc,
x->m.atombuffer);
}
