externals/zexy/src z_tabread4.c,1.2,1.3 - Pd-cvs

3 Feb 2005


      Update of /cvsroot/pure-data/externals/zexy/src
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv13982
Modified Files:
    z_tabread4.c 
Log Message:
added range for [tabdump]
added [tabminmax] (works also with ranges)
Index: z_tabread4.c
===================================================================
RCS file: /cvsroot/pure-data/externals/zexy/src/z_tabread4.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** z_tabread4.c	21 Jul 2004 13:20:52 -0000	1.2
--- z_tabread4.c	3 Feb 2005 17:20:09 -0000	1.3
***************
*** 14,20 ****
    t_object x_obj;
    t_symbol *x_arrayname;
  } t_tabdump;
! static void tabdump_bang(t_tabdump *x, t_float findex)
  {
    t_garray *A;
--- 14,21 ----
    t_object x_obj;
    t_symbol *x_arrayname;
+   t_int startindex, stopindex;
  } t_tabdump;
! static void tabdump_bang(t_tabdump *x)
  {
    t_garray *A;
***************
*** 29,34 ****
      {
        int n;
!       t_atom *atombuf = (t_atom *)getbytes(sizeof(t_atom)*npoints);
!       for (n = 0; n < npoints; n++) SETFLOAT(&atombuf[n], vec[n]);
        outlet_list(x->x_obj.ob_outlet, &s_list, npoints, atombuf);
        freebytes(atombuf,sizeof(t_atom)*npoints);
--- 30,43 ----
      {
        int n;
!       t_atom *atombuf;
! 
!       int start=x->startindex;
!       int stop =x->stopindex;
!       if(start<0||start>stop)start=0;
!       if(stop<start||stop>npoints)stop=npoints;
!       npoints=stop-start;
! 
!       atombuf = (t_atom *)getbytes(sizeof(t_atom)*npoints);
!       for (n = 0; n < npoints; n++) SETFLOAT(&atombuf[n], vec[start+n]);
        outlet_list(x->x_obj.ob_outlet, &s_list, npoints, atombuf);
        freebytes(atombuf,sizeof(t_atom)*npoints);
***************
*** 36,39 ****
--- 45,63 ----
  }
+ static void tabdump_list(t_tabdump *x, t_symbol*s,int argc, t_atom*argv)
+ {
+   int a,b;
+   switch(argc){
+   case 2:
+     a=atom_getint(argv);
+     b=atom_getint(argv+1);
+     x->startindex=(a<b)?a:b;
+     x->stopindex =(a>b)?a:b;
+     tabdump_bang(x);
+     break;
+   default:
+     error("tabdump: list must be 2 floats (is %d atoms)", argc);
+   }
+ }
static void tabdump_set(t_tabdump *x, t_symbol *s)
***************
*** 46,49 ****
--- 70,75 ----
    t_tabdump *x = (t_tabdump *)pd_new(tabdump_class);
    x->x_arrayname = s;
+   x->startindex=0;
+   x->stopindex=-1;
    outlet_new(&x->x_obj, &s_list);
***************
*** 66,69 ****
--- 92,97 ----
    		     0, sizeof(t_tabdump), 0, A_DEFSYM, 0);
    class_addbang(tabdump_class, (t_method)tabdump_bang);
+   class_addlist(tabdump_class, (t_method)tabdump_list);
+ 
    class_addmethod(tabdump_class, (t_method)tabdump_set, gensym("set"),
    	  A_SYMBOL, 0);
***************
*** 73,76 ****
--- 101,224 ----
  }
+ /* =================== tabminmax ====================== */
+ 
+ static t_class *tabminmax_class;
+ 
+ typedef struct _tabminmax
+ {
+   t_object x_obj;
+   t_outlet*min_out, *max_out;
+   t_symbol *x_arrayname;
+   t_int startindex, stopindex;
+ } t_tabminmax;
+ 
+ static void tabminmax_bang(t_tabminmax *x)
+ {
+   t_garray *A;
+   int npoints;
+   t_float *vec;
+ 
+   if (!(A = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class)))
+     error("%s: no such array", x->x_arrayname->s_name);
+   else if (!garray_getfloatarray(A, &npoints, &vec))
+     error("%s: bad template for tabminmax", x->x_arrayname->s_name);
+   else
+     {
+       int n;
+       t_atom atombuf[2];
+       t_float min, max;
+       int mindex, maxdex;
+ 
+       int start=x->startindex;
+       int stop =x->stopindex;
+       if(start<0||start>stop)start=0;
+       if(stop<start||stop>npoints)stop=npoints;
+       npoints=stop-start;
+ 
+       min=vec[start];
+       max=vec[start];
+ 
+       mindex=start;
+       maxdex=start;
+       
+       for (n = 1; n < npoints; n++){
+ 	t_float val=vec[start+n];
+ 	if(val<min){
+ 	  mindex=start+n;
+ 	  min=val;
+ 	}
+ 	if(val>max){
+ 	  maxdex=start+n;
+ 	  max=val;
+ 	}
+       }
+ 
+       SETFLOAT(atombuf, max);
+       SETFLOAT(atombuf+1, maxdex);
+       outlet_list(x->max_out, &s_list, 2, atombuf);
+ 
+       SETFLOAT(atombuf, min);
+       SETFLOAT(atombuf+1, mindex);
+       outlet_list(x->min_out, &s_list, 2, atombuf);
+     }
+ }
+ 
+ static void tabminmax_list(t_tabminmax *x, t_symbol*s,int argc, t_atom*argv)
+ {
+   int a,b;
+   switch(argc){
+   case 2:
+     a=atom_getint(argv);
+     b=atom_getint(argv+1);
+     x->startindex=(a<b)?a:b;
+     x->stopindex =(a>b)?a:b;
+     tabminmax_bang(x);
+     break;
+   default:
+     error("tabminmax: list must be 2 floats (is %d atoms)", argc);
+   }
+ }
+ 
+ static void tabminmax_set(t_tabminmax *x, t_symbol *s)
+ {
+   x->x_arrayname = s;
+ }
+ 
+ static void *tabminmax_new(t_symbol *s)
+ {
+   t_tabminmax *x = (t_tabminmax *)pd_new(tabminmax_class);
+   x->x_arrayname = s;
+   x->startindex=0;
+   x->stopindex=-1;
+   x->min_out=outlet_new(&x->x_obj, &s_list);
+   x->max_out=outlet_new(&x->x_obj, &s_list);
+ 
+   return (x);
+ }
+ 
+ static void tabminmax_helper(void)
+ {
+   post("\n%c tabminmax - object : dumps a table as a package of floats", HEARTSYMBOL);
+   post("'set <table>'\t: read out another table\n"
+        "'bang'\t\t: get min and max of the table\n"
+        "outlet\t\t: table-data as package of floats");
+   post("creation\t: "tabminmax <table>"");
+ 
+ }
+ 
+ static void tabminmax_setup(void)
+ {
+   tabminmax_class = class_new(gensym("tabminmax"), (t_newmethod)tabminmax_new,
+ 			     0, sizeof(t_tabminmax), 0, A_DEFSYM, 0);
+   class_addbang(tabminmax_class, (t_method)tabminmax_bang);
+   class_addlist(tabminmax_class, (t_method)tabminmax_list);
+ 
+   class_addmethod(tabminmax_class, (t_method)tabminmax_set, gensym("set"),
+ 		  A_SYMBOL, 0);
+ 
+   class_addmethod(tabminmax_class, (t_method)tabminmax_helper, gensym("help"), 0);
+   class_sethelpsymbol(tabminmax_class, gensym("zexy/tabminmax"));
+ }
+
/* =================== tabset ====================== */
***************
*** 160,163 ****
--- 308,312 ----
  {
    tabdump_setup();
+   tabminmax_setup();
    tabset_setup();
  }