apps/plugins/pdbox/PDa/src/d_arithmetic.c

   1 /* Copyright (c) 1997-1999 Miller Puckette.
   2 * For information on usage and redistribution, and for a DISCLAIMER OF ALL
   3 * WARRANTIES, see the file, "LICENSE.txt," in this distribution.  */
   4
   5 /*  arithmetic binops (+, -, *, /).
   6 If no creation argument is given, there are two signal inlets for vector/vector
   7 operation; otherwise it's vector/scalar and the second inlet takes a float
   8 to reset the value.
   9 */
  10
  11 #include "m_pd.h"
  12
  13 /* ----------------------------- plus ----------------------------- */
  14 static t_class *plus_class, *scalarplus_class;
  15
  16 typedef struct _plus
  17 {
  18     t_object x_obj;
  19     float x_f;
  20 } t_plus;
  21
  22 typedef struct _scalarplus
  23 {
  24     t_object x_obj;
  25     float x_f;
  26     t_float x_g;            /* inlet value */
  27 } t_scalarplus;
  28
  29 static void *plus_new(t_symbol *s, int argc, t_atom *argv)
  30 {
  31     if (argc > 1) post("+~: extra arguments ignored");
  32     if (argc)
  33     {
  34         t_scalarplus *x = (t_scalarplus *)pd_new(scalarplus_class);
  35         floatinlet_new(&x->x_obj, &x->x_g);
  36         x->x_g = atom_getfloatarg(0, argc, argv);
  37         outlet_new(&x->x_obj, &s_signal);
  38         x->x_f = 0;
  39         return (x);
  40     }
  41     else
  42     {
  43         t_plus *x = (t_plus *)pd_new(plus_class);
  44         inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
  45         outlet_new(&x->x_obj, &s_signal);
  46         x->x_f = 0;
  47         return (x);
  48     }
  49 }
  50
  51 t_int *plus_perform(t_int *w)
  52 {
  53     t_sample *in1 = (t_sample *)(w[1]);
  54     t_sample *in2 = (t_sample *)(w[2]);
  55     t_sample *out = (t_sample *)(w[3]);
  56     int n = (int)(w[4]);
  57     while (n--) *out++ = *in1++ + *in2++;
  58     return (w+5);
  59 }
  60
  61 t_int *plus_perf8(t_int *w)
  62 {
  63     t_sample *in1 = (t_sample *)(w[1]);
  64     t_sample *in2 = (t_sample *)(w[2]);
  65     t_sample *out = (t_sample *)(w[3]);
  66     int n = (int)(w[4]);
  67     for (; n; n -= 8, in1 += 8, in2 += 8, out += 8)
  68     {
  69         t_sample f0 = in1[0], f1 = in1[1], f2 = in1[2], f3 = in1[3];
  70         t_sample f4 = in1[4], f5 = in1[5], f6 = in1[6], f7 = in1[7];
  71
  72         t_sample g0 = in2[0], g1 = in2[1], g2 = in2[2], g3 = in2[3];
  73         t_sample g4 = in2[4], g5 = in2[5], g6 = in2[6], g7 = in2[7];
  74
  75         out[0] = f0 + g0; out[1] = f1 + g1; out[2] = f2 + g2; out[3] = f3 + g3;
  76         out[4] = f4 + g4; out[5] = f5 + g5; out[6] = f6 + g6; out[7] = f7 + g7;
  77     }
  78     return (w+5);
  79 }
  80
  81 t_int *scalarplus_perform(t_int *w)
  82 {
  83     t_sample *in = (t_sample *)(w[1]);
  84     t_sample f = ftofix(*(t_float *)(w[2]));
  85     t_sample *out = (t_sample *)(w[3]);
  86     int n = (int)(w[4]);
  87     while (n--) *out++ = *in++ + f;
  88     return (w+5);
  89 }
  90
  91 t_int *scalarplus_perf8(t_int *w)
  92 {
  93     t_sample *in = (t_sample *)(w[1]);
  94     t_sample g = ftofix(*(t_float *)(w[2]));
  95     t_sample *out = (t_sample *)(w[3]);
  96     int n = (int)(w[4]);
  97     for (; n; n -= 8, in += 8, out += 8)
  98     {
  99         t_sample f0 = in[0], f1 = in[1], f2 = in[2], f3 = in[3];
 100         t_sample f4 = in[4], f5 = in[5], f6 = in[6], f7 = in[7];
 101
 102         out[0] = f0 + g; out[1] = f1 + g; out[2] = f2 + g; out[3] = f3 + g;
 103         out[4] = f4 + g; out[5] = f5 + g; out[6] = f6 + g; out[7] = f7 + g;
 104     }
 105     return (w+5);
 106 }
 107
 108 void dsp_add_plus(t_sample *in1, t_sample *in2, t_sample *out, int n)
 109 {
 110     if (n&7)
 111         dsp_add(plus_perform, 4, in1, in2, out, n);
 112     else
 113         dsp_add(plus_perf8, 4, in1, in2, out, n);
 114 }
 115
 116 static void plus_dsp(t_plus *x, t_signal **sp)
 117 {
 118     dsp_add_plus(sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
 119 }
 120
 121 static void scalarplus_dsp(t_scalarplus *x, t_signal **sp)
 122 {
 123     if (sp[0]->s_n&7)
 124         dsp_add(scalarplus_perform, 4, sp[0]->s_vec, &x->x_g,
 125             sp[1]->s_vec, sp[0]->s_n);
 126     else
 127         dsp_add(scalarplus_perf8, 4, sp[0]->s_vec, &x->x_g,
 128             sp[1]->s_vec, sp[0]->s_n);
 129 }
 130
 131 static void plus_setup(void)
 132 {
 133     plus_class = class_new(gensym("+~"), (t_newmethod)plus_new, 0,
 134         sizeof(t_plus), 0, A_GIMME, 0);
 135     class_addmethod(plus_class, (t_method)plus_dsp, gensym("dsp"), 0);
 136     CLASS_MAINSIGNALIN(plus_class, t_plus, x_f);
 137     class_sethelpsymbol(plus_class, gensym("sigbinops"));
 138     scalarplus_class = class_new(gensym("+~"), 0, 0,
 139         sizeof(t_scalarplus), 0, 0);
 140     CLASS_MAINSIGNALIN(scalarplus_class, t_scalarplus, x_f);
 141     class_addmethod(scalarplus_class, (t_method)scalarplus_dsp, gensym("dsp"),
 142         0);
 143     class_sethelpsymbol(scalarplus_class, gensym("sigbinops"));
 144 }
 145
 146 /* ----------------------------- minus ----------------------------- */
 147 static t_class *minus_class, *scalarminus_class;
 148
 149 typedef struct _minus
 150 {
 151     t_object x_obj;
 152     float x_f;
 153 } t_minus;
 154
 155 typedef struct _scalarminus
 156 {
 157     t_object x_obj;
 158     float x_f;
 159     t_float x_g;
 160 } t_scalarminus;
 161
 162 static void *minus_new(t_symbol *s, int argc, t_atom *argv)
 163 {
 164     if (argc > 1) post("-~: extra arguments ignored");
 165     if (argc)
 166     {
 167         t_scalarminus *x = (t_scalarminus *)pd_new(scalarminus_class);
 168         floatinlet_new(&x->x_obj, &x->x_g);
 169         x->x_g = atom_getfloatarg(0, argc, argv);
 170         outlet_new(&x->x_obj, &s_signal);
 171         x->x_f = 0;
 172         return (x);
 173     }
 174     else
 175     {
 176         t_minus *x = (t_minus *)pd_new(minus_class);
 177         inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
 178         outlet_new(&x->x_obj, &s_signal);
 179         x->x_f = 0;
 180         return (x);
 181     }
 182 }
 183
 184 t_int *minus_perform(t_int *w)
 185 {
 186     t_sample *in1 = (t_sample *)(w[1]);
 187     t_sample *in2 = (t_sample *)(w[2]);
 188     t_sample *out = (t_sample *)(w[3]);
 189     int n = (int)(w[4]);
 190     while (n--) *out++ = *in1++ - *in2++;
 191     return (w+5);
 192 }
 193
 194 t_int *minus_perf8(t_int *w)
 195 {
 196     t_sample *in1 = (t_sample *)(w[1]);
 197     t_sample *in2 = (t_sample *)(w[2]);
 198     t_sample *out = (t_sample *)(w[3]);
 199     int n = (int)(w[4]);
 200     for (; n; n -= 8, in1 += 8, in2 += 8, out += 8)
 201     {
 202         t_sample f0 = in1[0], f1 = in1[1], f2 = in1[2], f3 = in1[3];
 203         t_sample f4 = in1[4], f5 = in1[5], f6 = in1[6], f7 = in1[7];
 204
 205         t_sample g0 = in2[0], g1 = in2[1], g2 = in2[2], g3 = in2[3];
 206         t_sample g4 = in2[4], g5 = in2[5], g6 = in2[6], g7 = in2[7];
 207
 208         out[0] = f0 - g0; out[1] = f1 - g1; out[2] = f2 - g2; out[3] = f3 - g3;
 209         out[4] = f4 - g4; out[5] = f5 - g5; out[6] = f6 - g6; out[7] = f7 - g7;
 210     }
 211     return (w+5);
 212 }
 213
 214 t_int *scalarminus_perform(t_int *w)
 215 {
 216     t_sample *in = (t_sample *)(w[1]);
 217     t_sample f = ftofix(*(t_float *)(w[2]));
 218     t_sample *out = (t_sample *)(w[3]);
 219     int n = (int)(w[4]);
 220     while (n--) *out++ = *in++ - f;
 221     return (w+5);
 222 }
 223
 224 t_int *scalarminus_perf8(t_int *w)
 225 {
 226     t_sample *in = (t_sample *)(w[1]);
 227     t_sample g = ftofix(*(t_float *)(w[2]));
 228     t_sample *out = (t_sample *)(w[3]);
 229     int n = (int)(w[4]);
 230     for (; n; n -= 8, in += 8, out += 8)
 231     {
 232         t_sample f0 = in[0], f1 = in[1], f2 = in[2], f3 = in[3];
 233         t_sample f4 = in[4], f5 = in[5], f6 = in[6], f7 = in[7];
 234
 235         out[0] = f0 - g; out[1] = f1 - g; out[2] = f2 - g; out[3] = f3 - g;
 236         out[4] = f4 - g; out[5] = f5 - g; out[6] = f6 - g; out[7] = f7 - g;
 237     }
 238     return (w+5);
 239 }
 240
 241 static void minus_dsp(t_minus *x, t_signal **sp)
 242 {
 243     if (sp[0]->s_n&7)
 244         dsp_add(minus_perform, 4,
 245             sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
 246     else
 247         dsp_add(minus_perf8, 4,
 248             sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
 249 }
 250
 251 static void scalarminus_dsp(t_scalarminus *x, t_signal **sp)
 252 {
 253     if (sp[0]->s_n&7)
 254         dsp_add(scalarminus_perform, 4, sp[0]->s_vec, &x->x_g,
 255             sp[1]->s_vec, sp[0]->s_n);
 256     else
 257         dsp_add(scalarminus_perf8, 4, sp[0]->s_vec, &x->x_g,
 258             sp[1]->s_vec, sp[0]->s_n);
 259 }
 260
 261 static void minus_setup(void)
 262 {
 263     minus_class = class_new(gensym("-~"), (t_newmethod)minus_new, 0,
 264         sizeof(t_minus), 0, A_GIMME, 0);
 265     CLASS_MAINSIGNALIN(minus_class, t_minus, x_f);
 266     class_addmethod(minus_class, (t_method)minus_dsp, gensym("dsp"), 0);
 267     class_sethelpsymbol(minus_class, gensym("sigbinops"));
 268     scalarminus_class = class_new(gensym("-~"), 0, 0,
 269         sizeof(t_scalarminus), 0, 0);
 270     CLASS_MAINSIGNALIN(scalarminus_class, t_scalarminus, x_f);
 271     class_addmethod(scalarminus_class, (t_method)scalarminus_dsp, gensym("dsp"),
 272         0);
 273     class_sethelpsymbol(scalarminus_class, gensym("sigbinops"));
 274 }
 275
 276 /* ----------------------------- times ----------------------------- */
 277
 278 static t_class *times_class, *scalartimes_class;
 279
 280 typedef struct _times
 281 {
 282     t_object x_obj;
 283     float x_f;
 284 } t_times;
 285
 286 typedef struct _scalartimes
 287 {
 288     t_object x_obj;
 289     float x_f;
 290     t_float x_g;
 291 } t_scalartimes;
 292
 293 static void *times_new(t_symbol *s, int argc, t_atom *argv)
 294 {
 295     if (argc > 1) post("*~: extra arguments ignored");
 296     if (argc)
 297     {
 298         t_scalartimes *x = (t_scalartimes *)pd_new(scalartimes_class);
 299         floatinlet_new(&x->x_obj, &x->x_g);
 300         x->x_g = atom_getfloatarg(0, argc, argv);
 301         outlet_new(&x->x_obj, &s_signal);
 302         x->x_f = 0;
 303         return (x);
 304     }
 305     else
 306     {
 307         t_times *x = (t_times *)pd_new(times_class);
 308         inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
 309         outlet_new(&x->x_obj, &s_signal);
 310         x->x_f = 0;
 311         return (x);
 312     }
 313 }
 314
 315 t_int *times_perform(t_int *w)
 316 {
 317     t_sample *in1 = (t_sample *)(w[1]);
 318     t_sample *in2 = (t_sample *)(w[2]);
 319     t_sample *out = (t_sample *)(w[3]);
 320     int n = (int)(w[4]);
 321     while (n--) *out++ = mult(*in1++,*in2++);
 322     return (w+5);
 323 }
 324
 325 t_int *times_perf8(t_int *w)
 326 {
 327     t_sample *in1 = (t_sample *)(w[1]);
 328     t_sample *in2 = (t_sample *)(w[2]);
 329     t_sample *out = (t_sample *)(w[3]);
 330     int n = (int)(w[4]);
 331     for (; n; n -= 8, in1 += 8, in2 += 8, out += 8)
 332     {
 333         t_sample f0 = in1[0], f1 = in1[1], f2 = in1[2], f3 = in1[3];
 334         t_sample f4 = in1[4], f5 = in1[5], f6 = in1[6], f7 = in1[7];
 335
 336         t_sample g0 = in2[0], g1 = in2[1], g2 = in2[2], g3 = in2[3];
 337         t_sample g4 = in2[4], g5 = in2[5], g6 = in2[6], g7 = in2[7];
 338
 339         out[0] = mult(f0,g0); out[1] = mult(f1,g1); out[2] = mult(f2,g2); out[3] = mult(f3,g3);
 340         out[4] = mult(f4,g4); out[5] = mult(f5,g5); out[6] = mult(f6,g6); out[7] = mult(f7,g7);
 341     }
 342     return (w+5);
 343 }
 344
 345 t_int *scalartimes_perform(t_int *w)
 346 {
 347     t_sample *in = (t_sample *)(w[1]);
 348     t_sample f = ftofix(*(t_float *)(w[2]));
 349     t_sample *out = (t_sample *)(w[3]);
 350     int n = (int)(w[4]);
 351     while (n--) *out++ = mult(*in++,f);
 352     return (w+5);
 353 }
 354
 355 t_int *scalartimes_perf8(t_int *w)
 356 {
 357     t_sample *in = (t_sample *)(w[1]);
 358     t_sample g = ftofix(*(t_float *)(w[2]));
 359     t_sample *out = (t_sample *)(w[3]);
 360     int n = (int)(w[4]);
 361     for (; n; n -= 8, in += 8, out += 8)
 362     {
 363         t_sample f0 = in[0], f1 = in[1], f2 = in[2], f3 = in[3];
 364         t_sample f4 = in[4], f5 = in[5], f6 = in[6], f7 = in[7];
 365
 366         out[0] = mult(f0,g); out[1] = mult(f1,g); out[2] = mult(f2,g); out[3] = mult(f3,g);
 367         out[4] = mult(f4,g); out[5] = mult(f5,g); out[6] = mult(f6,g); out[7] = mult(f7,g);
 368     }
 369     return (w+5);
 370 }
 371
 372 static void times_dsp(t_times *x, t_signal **sp)
 373 {
 374     if (sp[0]->s_n&7)
 375         dsp_add(times_perform, 4,
 376             sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
 377     else
 378         dsp_add(times_perf8, 4,
 379             sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
 380 }
 381
 382 static void scalartimes_dsp(t_scalartimes *x, t_signal **sp)
 383 {
 384     if (sp[0]->s_n&7)
 385         dsp_add(scalartimes_perform, 4, sp[0]->s_vec, &x->x_g,
 386             sp[1]->s_vec, sp[0]->s_n);
 387     else
 388         dsp_add(scalartimes_perf8, 4, sp[0]->s_vec, &x->x_g,
 389             sp[1]->s_vec, sp[0]->s_n);
 390 }
 391
 392 static void times_setup(void)
 393 {
 394     times_class = class_new(gensym("*~"), (t_newmethod)times_new, 0,
 395         sizeof(t_times), 0, A_GIMME, 0);
 396     CLASS_MAINSIGNALIN(times_class, t_times, x_f);
 397     class_addmethod(times_class, (t_method)times_dsp, gensym("dsp"), 0);
 398     class_sethelpsymbol(times_class, gensym("sigbinops"));
 399     scalartimes_class = class_new(gensym("*~"), 0, 0,
 400         sizeof(t_scalartimes), 0, 0);
 401     CLASS_MAINSIGNALIN(scalartimes_class, t_scalartimes, x_f);
 402     class_addmethod(scalartimes_class, (t_method)scalartimes_dsp, gensym("dsp"),
 403         0);
 404     class_sethelpsymbol(scalartimes_class, gensym("sigbinops"));
 405 }
 406
 407 /* ----------------------------- over ----------------------------- */
 408 static t_class *over_class, *scalarover_class;
 409
 410 typedef struct _over
 411 {
 412     t_object x_obj;
 413     float x_f;
 414 } t_over;
 415
 416 typedef struct _scalarover
 417 {
 418     t_object x_obj;
 419     float x_f;
 420     t_float x_g;
 421 } t_scalarover;
 422
 423 static void *over_new(t_symbol *s, int argc, t_atom *argv)
 424 {
 425     if (argc > 1) post("/~: extra arguments ignored");
 426     if (argc)
 427     {
 428         t_scalarover *x = (t_scalarover *)pd_new(scalarover_class);
 429         floatinlet_new(&x->x_obj, &x->x_g);
 430         x->x_g = atom_getfloatarg(0, argc, argv);
 431         outlet_new(&x->x_obj, &s_signal);
 432         x->x_f = 0;
 433         return (x);
 434     }
 435     else
 436     {
 437         t_over *x = (t_over *)pd_new(over_class);
 438         inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
 439         outlet_new(&x->x_obj, &s_signal);
 440         x->x_f = 0;
 441         return (x);
 442     }
 443 }
 444
 445 t_int *over_perform(t_int *w)
 446 {
 447     t_sample *in1 = (t_sample *)(w[1]);
 448     t_sample *in2 = (t_sample *)(w[2]);
 449     t_sample *out = (t_sample *)(w[3]);
 450     int n = (int)(w[4]);
 451     while (n--)
 452     {
 453         float g = *in2++;
 454         *out++ = (g ? *in1++ / g : 0);
 455     }
 456     return (w+5);
 457 }
 458
 459 t_int *over_perf8(t_int *w)
 460 {
 461     t_sample *in1 = (t_sample *)(w[1]);
 462     t_sample *in2 = (t_sample *)(w[2]);
 463     t_sample *out = (t_sample *)(w[3]);
 464     int n = (int)(w[4]);
 465     for (; n; n -= 8, in1 += 8, in2 += 8, out += 8)
 466     {
 467         t_sample f0 = in1[0], f1 = in1[1], f2 = in1[2], f3 = in1[3];
 468         t_sample f4 = in1[4], f5 = in1[5], f6 = in1[6], f7 = in1[7];
 469
 470         t_sample g0 = in2[0], g1 = in2[1], g2 = in2[2], g3 = in2[3];
 471         t_sample g4 = in2[4], g5 = in2[5], g6 = in2[6], g7 = in2[7];
 472
 473         out[0] = (g0? idiv(f0,g0) : 0);
 474         out[1] = (g1? idiv(f1,g1) : 0);
 475         out[2] = (g2? idiv(f2,g2) : 0);
 476         out[3] = (g3? idiv(f3,g3) : 0);
 477         out[4] = (g4? idiv(f4,g4) : 0);
 478         out[5] = (g5? idiv(f5,g5) : 0);
 479         out[6] = (g6? idiv(f6,g6) : 0);
 480         out[7] = (g7? idiv(f7,g7) : 0);
 481     }
 482     return (w+5);
 483 }
 484
 485 t_int *scalarover_perform(t_int *w)
 486 {
 487     t_sample *in = (t_sample *)(w[1]);
 488     t_sample f = idiv(ftofix(1.),ftofix(*(t_float *)(w[2])));
 489     t_sample *out = (t_sample *)(w[3]);
 490     int n = (int)(w[4]);
 491     while (n--) *out++ = mult(*in++,f);
 492     return (w+5);
 493 }
 494
 495 t_int *scalarover_perf8(t_int *w)
 496 {
 497     t_sample *in = (t_sample *)(w[1]);
 498     t_sample g = ftofix(*(t_float *)(w[2]));
 499     t_sample *out = (t_sample *)(w[3]);
 500     int n = (int)(w[4]);
 501     if (g) g = idiv(ftofix(1.f),g);
 502     for (; n; n -= 8, in += 8, out += 8)
 503     {
 504         t_sample f0 = in[0], f1 = in[1], f2 = in[2], f3 = in[3];
 505         t_sample f4 = in[4], f5 = in[5], f6 = in[6], f7 = in[7];
 506
 507         out[0] = mult(f0,g); out[1] = mult(f1,g); out[2] = mult(f2,g); out[3] = mult(f3,g);
 508         out[4] = mult(f4,g); out[5] = mult(f5,g); out[6] = mult(f6,g); out[7] = mult(f7,g);
 509     }
 510     return (w+5);
 511 }
 512
 513 static void over_dsp(t_over *x, t_signal **sp)
 514 {
 515     if (sp[0]->s_n&7)
 516         dsp_add(over_perform, 4,
 517             sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
 518     else
 519         dsp_add(over_perf8, 4,
 520             sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
 521 }
 522
 523 static void scalarover_dsp(t_scalarover *x, t_signal **sp)
 524 {
 525     if (sp[0]->s_n&7)
 526         dsp_add(scalarover_perform, 4, sp[0]->s_vec, &x->x_g,
 527             sp[1]->s_vec, sp[0]->s_n);
 528     else
 529         dsp_add(scalarover_perf8, 4, sp[0]->s_vec, &x->x_g,
 530             sp[1]->s_vec, sp[0]->s_n);
 531 }
 532
 533 static void over_setup(void)
 534 {
 535     over_class = class_new(gensym("/~"), (t_newmethod)over_new, 0,
 536         sizeof(t_over), 0, A_GIMME, 0);
 537     CLASS_MAINSIGNALIN(over_class, t_over, x_f);
 538     class_addmethod(over_class, (t_method)over_dsp, gensym("dsp"), 0);
 539     class_sethelpsymbol(over_class, gensym("sigbinops"));
 540     scalarover_class = class_new(gensym("/~"), 0, 0,
 541         sizeof(t_scalarover), 0, 0);
 542     CLASS_MAINSIGNALIN(scalarover_class, t_scalarover, x_f);
 543     class_addmethod(scalarover_class, (t_method)scalarover_dsp, gensym("dsp"),
 544         0);
 545     class_sethelpsymbol(scalarover_class, gensym("sigbinops"));
 546 }
 547
 548 /* ----------------------------- max ----------------------------- */
 549 static t_class *max_class, *scalarmax_class;
 550
 551 typedef struct _max
 552 {
 553     t_object x_obj;
 554     float x_f;
 555 } t_max;
 556
 557 typedef struct _scalarmax
 558 {
 559     t_object x_obj;
 560     float x_f;
 561     t_float x_g;
 562 } t_scalarmax;
 563
 564 static void *max_new(t_symbol *s, int argc, t_atom *argv)
 565 {
 566     if (argc > 1) post("max~: extra arguments ignored");
 567     if (argc)
 568     {
 569         t_scalarmax *x = (t_scalarmax *)pd_new(scalarmax_class);
 570         floatinlet_new(&x->x_obj, &x->x_g);
 571         x->x_g = atom_getfloatarg(0, argc, argv);
 572         outlet_new(&x->x_obj, &s_signal);
 573         x->x_f = 0;
 574         return (x);
 575     }
 576     else
 577     {
 578         t_max *x = (t_max *)pd_new(max_class);
 579         inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
 580         outlet_new(&x->x_obj, &s_signal);
 581         x->x_f = 0;
 582         return (x);
 583     }
 584 }
 585
 586 t_int *max_perform(t_int *w)
 587 {
 588     t_sample *in1 = (t_sample *)(w[1]);
 589     t_sample *in2 = (t_sample *)(w[2]);
 590     t_sample *out = (t_sample *)(w[3]);
 591     int n = (int)(w[4]);
 592     while (n--)
 593     {
 594         t_sample f = *in1++, g = *in2++;
 595         *out++ = (f > g ? f : g);
 596     }
 597     return (w+5);
 598 }
 599
 600 t_int *max_perf8(t_int *w)
 601 {
 602     t_sample *in1 = (t_sample *)(w[1]);
 603     t_sample *in2 = (t_sample *)(w[2]);
 604     t_sample *out = (t_sample *)(w[3]);
 605     int n = (int)(w[4]);
 606     for (; n; n -= 8, in1 += 8, in2 += 8, out += 8)
 607     {
 608         t_sample f0 = in1[0], f1 = in1[1], f2 = in1[2], f3 = in1[3];
 609         t_sample f4 = in1[4], f5 = in1[5], f6 = in1[6], f7 = in1[7];
 610
 611         t_sample g0 = in2[0], g1 = in2[1], g2 = in2[2], g3 = in2[3];
 612         t_sample g4 = in2[4], g5 = in2[5], g6 = in2[6], g7 = in2[7];
 613
 614         out[0] = (f0 > g0 ? f0 : g0); out[1] = (f1 > g1 ? f1 : g1);
 615         out[2] = (f2 > g2 ? f2 : g2); out[3] = (f3 > g3 ? f3 : g3);
 616         out[4] = (f4 > g4 ? f4 : g4); out[5] = (f5 > g5 ? f5 : g5);
 617         out[6] = (f6 > g6 ? f6 : g6); out[7] = (f7 > g7 ? f7 : g7);
 618     }
 619     return (w+5);
 620 }
 621
 622 t_int *scalarmax_perform(t_int *w)
 623 {
 624     t_sample *in = (t_sample *)(w[1]);
 625     t_sample f = ftofix(*(t_float *)(w[2]));
 626     t_sample *out = (t_sample *)(w[3]);
 627     int n = (int)(w[4]);
 628     while (n--)
 629     {
 630         t_sample g = *in++;
 631         *out++ = (f > g ? f : g);
 632     }
 633     return (w+5);
 634 }
 635
 636 t_int *scalarmax_perf8(t_int *w)
 637 {
 638     t_sample *in = (t_sample *)(w[1]);
 639     t_sample g = ftofix(*(t_float *)(w[2]));
 640     t_sample *out = (t_sample *)(w[3]);
 641     int n = (int)(w[4]);
 642     for (; n; n -= 8, in += 8, out += 8)
 643     {
 644         t_sample f0 = in[0], f1 = in[1], f2 = in[2], f3 = in[3];
 645         t_sample f4 = in[4], f5 = in[5], f6 = in[6], f7 = in[7];
 646
 647         out[0] = (f0 > g ? f0 : g); out[1] = (f1 > g ? f1 : g);
 648         out[2] = (f2 > g ? f2 : g); out[3] = (f3 > g ? f3 : g);
 649         out[4] = (f4 > g ? f4 : g); out[5] = (f5 > g ? f5 : g);
 650         out[6] = (f6 > g ? f6 : g); out[7] = (f7 > g ? f7 : g);
 651     }
 652     return (w+5);
 653 }
 654
 655 static void max_dsp(t_max *x, t_signal **sp)
 656 {
 657     if (sp[0]->s_n&7)
 658         dsp_add(max_perform, 4,
 659             sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
 660     else
 661         dsp_add(max_perf8, 4,
 662             sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
 663 }
 664
 665 static void scalarmax_dsp(t_scalarmax *x, t_signal **sp)
 666 {
 667     if (sp[0]->s_n&7)
 668         dsp_add(scalarmax_perform, 4, sp[0]->s_vec, &x->x_g,
 669             sp[1]->s_vec, sp[0]->s_n);
 670     else
 671         dsp_add(scalarmax_perf8, 4, sp[0]->s_vec, &x->x_g,
 672             sp[1]->s_vec, sp[0]->s_n);
 673 }
 674
 675 static void max_setup(void)
 676 {
 677     max_class = class_new(gensym("max~"), (t_newmethod)max_new, 0,
 678         sizeof(t_max), 0, A_GIMME, 0);
 679     CLASS_MAINSIGNALIN(max_class, t_max, x_f);
 680     class_addmethod(max_class, (t_method)max_dsp, gensym("dsp"), 0);
 681     class_sethelpsymbol(max_class, gensym("sigbinops"));
 682     scalarmax_class = class_new(gensym("max~"), 0, 0,
 683         sizeof(t_scalarmax), 0, 0);
 684     CLASS_MAINSIGNALIN(scalarmax_class, t_scalarmax, x_f);
 685     class_addmethod(scalarmax_class, (t_method)scalarmax_dsp, gensym("dsp"),
 686         0);
 687     class_sethelpsymbol(scalarmax_class, gensym("sigbinops"));
 688 }
 689
 690 /* ----------------------------- min ----------------------------- */
 691 static t_class *min_class, *scalarmin_class;
 692
 693 typedef struct _min
 694 {
 695     t_object x_obj;
 696     float x_f;
 697 } t_min;
 698
 699 typedef struct _scalarmin
 700 {
 701     t_object x_obj;
 702     t_float x_g;
 703     float x_f;
 704 } t_scalarmin;
 705
 706 static void *min_new(t_symbol *s, int argc, t_atom *argv)
 707 {
 708     if (argc > 1) post("min~: extra arguments ignored");
 709     if (argc)
 710     {
 711         t_scalarmin *x = (t_scalarmin *)pd_new(scalarmin_class);
 712         floatinlet_new(&x->x_obj, &x->x_g);
 713         x->x_g = atom_getfloatarg(0, argc, argv);
 714         outlet_new(&x->x_obj, &s_signal);
 715         x->x_f = 0;
 716         return (x);
 717     }
 718     else
 719     {
 720         t_min *x = (t_min *)pd_new(min_class);
 721         inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
 722         outlet_new(&x->x_obj, &s_signal);
 723         x->x_f = 0;
 724         return (x);
 725     }
 726 }
 727
 728 t_int *min_perform(t_int *w)
 729 {
 730     t_sample *in1 = (t_sample *)(w[1]);
 731     t_sample *in2 = (t_sample *)(w[2]);
 732     t_sample *out = (t_sample *)(w[3]);
 733     int n = (int)(w[4]);
 734     while (n--)
 735     {
 736         t_sample f = *in1++, g = *in2++;
 737         *out++ = (f < g ? f : g);
 738     }
 739     return (w+5);
 740 }
 741
 742 t_int *min_perf8(t_int *w)
 743 {
 744     t_sample *in1 = (t_sample *)(w[1]);
 745     t_sample *in2 = (t_sample *)(w[2]);
 746     t_sample *out = (t_sample *)(w[3]);
 747     int n = (int)(w[4]);
 748     for (; n; n -= 8, in1 += 8, in2 += 8, out += 8)
 749     {
 750         t_sample f0 = in1[0], f1 = in1[1], f2 = in1[2], f3 = in1[3];
 751         t_sample f4 = in1[4], f5 = in1[5], f6 = in1[6], f7 = in1[7];
 752
 753         t_sample g0 = in2[0], g1 = in2[1], g2 = in2[2], g3 = in2[3];
 754         t_sample g4 = in2[4], g5 = in2[5], g6 = in2[6], g7 = in2[7];
 755
 756         out[0] = (f0 < g0 ? f0 : g0); out[1] = (f1 < g1 ? f1 : g1);
 757         out[2] = (f2 < g2 ? f2 : g2); out[3] = (f3 < g3 ? f3 : g3);
 758         out[4] = (f4 < g4 ? f4 : g4); out[5] = (f5 < g5 ? f5 : g5);
 759         out[6] = (f6 < g6 ? f6 : g6); out[7] = (f7 < g7 ? f7 : g7);
 760     }
 761     return (w+5);
 762 }
 763
 764 t_int *scalarmin_perform(t_int *w)
 765 {
 766     t_sample *in = (t_sample *)(w[1]);
 767     t_sample f = ftofix(*(t_float *)(w[2]));
 768     t_sample *out = (t_sample *)(w[3]);
 769     int n = (int)(w[4]);
 770     while (n--)
 771     {
 772         t_sample g = *in++;
 773         *out++ = (f < g ? f : g);
 774     }
 775     return (w+5);
 776 }
 777
 778 t_int *scalarmin_perf8(t_int *w)
 779 {
 780     t_sample *in = (t_sample *)(w[1]);
 781     t_sample g = ftofix(*(t_float *)(w[2]));
 782     t_sample *out = (t_sample *)(w[3]);
 783     int n = (int)(w[4]);
 784     for (; n; n -= 8, in += 8, out += 8)
 785     {
 786         t_sample f0 = in[0], f1 = in[1], f2 = in[2], f3 = in[3];
 787         t_sample f4 = in[4], f5 = in[5], f6 = in[6], f7 = in[7];
 788
 789         out[0] = (f0 < g ? f0 : g); out[1] = (f1 < g ? f1 : g);
 790         out[2] = (f2 < g ? f2 : g); out[3] = (f3 < g ? f3 : g);
 791         out[4] = (f4 < g ? f4 : g); out[5] = (f5 < g ? f5 : g);
 792         out[6] = (f6 < g ? f6 : g); out[7] = (f7 < g ? f7 : g);
 793     }
 794     return (w+5);
 795 }
 796
 797 static void min_dsp(t_min *x, t_signal **sp)
 798 {
 799     if (sp[0]->s_n&7)
 800         dsp_add(min_perform, 4,
 801             sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
 802     else
 803         dsp_add(min_perf8, 4,
 804             sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
 805 }
 806
 807 static void scalarmin_dsp(t_scalarmin *x, t_signal **sp)
 808 {
 809     if (sp[0]->s_n&7)
 810         dsp_add(scalarmin_perform, 4, sp[0]->s_vec, &x->x_g,
 811             sp[1]->s_vec, sp[0]->s_n);
 812     else
 813         dsp_add(scalarmin_perf8, 4, sp[0]->s_vec, &x->x_g,
 814             sp[1]->s_vec, sp[0]->s_n);
 815 }
 816
 817 static void min_setup(void)
 818 {
 819     min_class = class_new(gensym("min~"), (t_newmethod)min_new, 0,
 820         sizeof(t_min), 0, A_GIMME, 0);
 821     CLASS_MAINSIGNALIN(min_class, t_min, x_f);
 822     class_addmethod(min_class, (t_method)min_dsp, gensym("dsp"), 0);
 823     class_sethelpsymbol(min_class, gensym("sigbinops"));
 824     scalarmin_class = class_new(gensym("min~"), 0, 0,
 825         sizeof(t_scalarmin), 0, 0);
 826     CLASS_MAINSIGNALIN(scalarmin_class, t_scalarmin, x_f);
 827     class_addmethod(scalarmin_class, (t_method)scalarmin_dsp, gensym("dsp"),
 828         0);
 829     class_sethelpsymbol(scalarmin_class, gensym("sigbinops"));
 830 }
 831
 832 /* ----------------------- global setup routine ---------------- */
 833 void d_arithmetic_setup(void)
 834 {
 835     plus_setup();
 836     minus_setup();
 837     times_setup();
 838     over_setup();
 839     max_setup();
 840     min_setup();
 841 }
 842
 843 /* Copyright (c) 1997-1999 Miller Puckette.
 844 * For information on usage and redistribution, and for a DISCLAIMER OF ALL
 845 * WARRANTIES, see the file, "LICENSE.txt," in this distribution.  */
 846
 847 /*  arithmetic binops (+, -, *, /).
 848 If no creation argument is given, there are two signal inlets for vector/vector
 849 operation; otherwise it's vector/scalar and the second inlet takes a float
 850 to reset the value.
 851 */
 852
 853 #include "m_pd.h"
 854
 855 /* ----------------------------- plus ----------------------------- */
 856 static t_class *plus_class, *scalarplus_class;
 857
 858 typedef struct _plus
 859 {
 860     t_object x_obj;
 861     float x_f;
 862 } t_plus;
 863
 864 typedef struct _scalarplus
 865 {
 866     t_object x_obj;
 867     float x_f;
 868     t_float x_g;            /* inlet value */
 869 } t_scalarplus;
 870
 871 static void *plus_new(t_symbol *s, int argc, t_atom *argv)
 872 {
 873     if (argc > 1) post("+~: extra arguments ignored");
 874     if (argc)
 875     {
 876         t_scalarplus *x = (t_scalarplus *)pd_new(scalarplus_class);
 877         floatinlet_new(&x->x_obj, &x->x_g);
 878         x->x_g = atom_getfloatarg(0, argc, argv);
 879         outlet_new(&x->x_obj, &s_signal);
 880         x->x_f = 0;
 881         return (x);
 882     }
 883     else
 884     {
 885         t_plus *x = (t_plus *)pd_new(plus_class);
 886         inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
 887         outlet_new(&x->x_obj, &s_signal);
 888         x->x_f = 0;
 889         return (x);
 890     }
 891 }
 892
 893 t_int *plus_perform(t_int *w)
 894 {
 895     t_sample *in1 = (t_sample *)(w[1]);
 896     t_sample *in2 = (t_sample *)(w[2]);
 897     t_sample *out = (t_sample *)(w[3]);
 898     int n = (int)(w[4]);
 899     while (n--) *out++ = *in1++ + *in2++;
 900     return (w+5);
 901 }
 902
 903 t_int *plus_perf8(t_int *w)
 904 {
 905     t_sample *in1 = (t_sample *)(w[1]);
 906     t_sample *in2 = (t_sample *)(w[2]);
 907     t_sample *out = (t_sample *)(w[3]);
 908     int n = (int)(w[4]);
 909     for (; n; n -= 8, in1 += 8, in2 += 8, out += 8)
 910     {
 911         t_sample f0 = in1[0], f1 = in1[1], f2 = in1[2], f3 = in1[3];
 912         t_sample f4 = in1[4], f5 = in1[5], f6 = in1[6], f7 = in1[7];
 913
 914         t_sample g0 = in2[0], g1 = in2[1], g2 = in2[2], g3 = in2[3];
 915         t_sample g4 = in2[4], g5 = in2[5], g6 = in2[6], g7 = in2[7];
 916
 917         out[0] = f0 + g0; out[1] = f1 + g1; out[2] = f2 + g2; out[3] = f3 + g3;
 918         out[4] = f4 + g4; out[5] = f5 + g5; out[6] = f6 + g6; out[7] = f7 + g7;
 919     }
 920     return (w+5);
 921 }
 922
 923 t_int *scalarplus_perform(t_int *w)
 924 {
 925     t_sample *in = (t_sample *)(w[1]);
 926     t_sample f = ftofix(*(t_float *)(w[2]));
 927     t_sample *out = (t_sample *)(w[3]);
 928     int n = (int)(w[4]);
 929     while (n--) *out++ = *in++ + f;
 930     return (w+5);
 931 }
 932
 933 t_int *scalarplus_perf8(t_int *w)
 934 {
 935     t_sample *in = (t_sample *)(w[1]);
 936     t_sample g = ftofix(*(t_float *)(w[2]));
 937     t_sample *out = (t_sample *)(w[3]);
 938     int n = (int)(w[4]);
 939     for (; n; n -= 8, in += 8, out += 8)
 940     {
 941         t_sample f0 = in[0], f1 = in[1], f2 = in[2], f3 = in[3];
 942         t_sample f4 = in[4], f5 = in[5], f6 = in[6], f7 = in[7];
 943
 944         out[0] = f0 + g; out[1] = f1 + g; out[2] = f2 + g; out[3] = f3 + g;
 945         out[4] = f4 + g; out[5] = f5 + g; out[6] = f6 + g; out[7] = f7 + g;
 946     }
 947     return (w+5);
 948 }
 949
 950 void dsp_add_plus(t_sample *in1, t_sample *in2, t_sample *out, int n)
 951 {
 952     if (n&7)
 953         dsp_add(plus_perform, 4, in1, in2, out, n);
 954     else
 955         dsp_add(plus_perf8, 4, in1, in2, out, n);
 956 }
 957
 958 static void plus_dsp(t_plus *x, t_signal **sp)
 959 {
 960     dsp_add_plus(sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
 961 }
 962
 963 static void scalarplus_dsp(t_scalarplus *x, t_signal **sp)
 964 {
 965     if (sp[0]->s_n&7)
 966         dsp_add(scalarplus_perform, 4, sp[0]->s_vec, &x->x_g,
 967             sp[1]->s_vec, sp[0]->s_n);
 968     else
 969         dsp_add(scalarplus_perf8, 4, sp[0]->s_vec, &x->x_g,
 970             sp[1]->s_vec, sp[0]->s_n);
 971 }
 972
 973 static void plus_setup(void)
 974 {
 975     plus_class = class_new(gensym("+~"), (t_newmethod)plus_new, 0,
 976         sizeof(t_plus), 0, A_GIMME, 0);
 977     class_addmethod(plus_class, (t_method)plus_dsp, gensym("dsp"), 0);
 978     CLASS_MAINSIGNALIN(plus_class, t_plus, x_f);
 979     class_sethelpsymbol(plus_class, gensym("sigbinops"));
 980     scalarplus_class = class_new(gensym("+~"), 0, 0,
 981         sizeof(t_scalarplus), 0, 0);
 982     CLASS_MAINSIGNALIN(scalarplus_class, t_scalarplus, x_f);
 983     class_addmethod(scalarplus_class, (t_method)scalarplus_dsp, gensym("dsp"),
 984         0);
 985     class_sethelpsymbol(scalarplus_class, gensym("sigbinops"));
 986 }
 987
 988 /* ----------------------------- minus ----------------------------- */
 989 static t_class *minus_class, *scalarminus_class;
 990
 991 typedef struct _minus
 992 {
 993     t_object x_obj;
 994     float x_f;
 995 } t_minus;
 996
 997 typedef struct _scalarminus
 998 {
 999     t_object x_obj;
1000     float x_f;
1001     t_float x_g;
1002 } t_scalarminus;
1003
1004 static void *minus_new(t_symbol *s, int argc, t_atom *argv)
1005 {
1006     if (argc > 1) post("-~: extra arguments ignored");
1007     if (argc)
1008     {
1009         t_scalarminus *x = (t_scalarminus *)pd_new(scalarminus_class);
1010         floatinlet_new(&x->x_obj, &x->x_g);
1011         x->x_g = atom_getfloatarg(0, argc, argv);
1012         outlet_new(&x->x_obj, &s_signal);
1013         x->x_f = 0;
1014         return (x);
1015     }
1016     else
1017     {
1018         t_minus *x = (t_minus *)pd_new(minus_class);
1019         inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
1020         outlet_new(&x->x_obj, &s_signal);
1021         x->x_f = 0;
1022         return (x);
1023     }
1024 }
1025
1026 t_int *minus_perform(t_int *w)
1027 {
1028     t_sample *in1 = (t_sample *)(w[1]);
1029     t_sample *in2 = (t_sample *)(w[2]);
1030     t_sample *out = (t_sample *)(w[3]);
1031     int n = (int)(w[4]);
1032     while (n--) *out++ = *in1++ - *in2++;
1033     return (w+5);
1034 }
1035
1036 t_int *minus_perf8(t_int *w)
1037 {
1038     t_sample *in1 = (t_sample *)(w[1]);
1039     t_sample *in2 = (t_sample *)(w[2]);
1040     t_sample *out = (t_sample *)(w[3]);
1041     int n = (int)(w[4]);
1042     for (; n; n -= 8, in1 += 8, in2 += 8, out += 8)
1043     {
1044         t_sample f0 = in1[0], f1 = in1[1], f2 = in1[2], f3 = in1[3];
1045         t_sample f4 = in1[4], f5 = in1[5], f6 = in1[6], f7 = in1[7];
1046
1047         t_sample g0 = in2[0], g1 = in2[1], g2 = in2[2], g3 = in2[3];
1048         t_sample g4 = in2[4], g5 = in2[5], g6 = in2[6], g7 = in2[7];
1049
1050         out[0] = f0 - g0; out[1] = f1 - g1; out[2] = f2 - g2; out[3] = f3 - g3;
1051         out[4] = f4 - g4; out[5] = f5 - g5; out[6] = f6 - g6; out[7] = f7 - g7;
1052     }
1053     return (w+5);
1054 }
1055
1056 t_int *scalarminus_perform(t_int *w)
1057 {
1058     t_sample *in = (t_sample *)(w[1]);
1059     t_sample f = ftofix(*(t_float *)(w[2]));
1060     t_sample *out = (t_sample *)(w[3]);
1061     int n = (int)(w[4]);
1062     while (n--) *out++ = *in++ - f;
1063     return (w+5);
1064 }
1065
1066 t_int *scalarminus_perf8(t_int *w)
1067 {
1068     t_sample *in = (t_sample *)(w[1]);
1069     t_sample g = ftofix(*(t_float *)(w[2]));
1070     t_sample *out = (t_sample *)(w[3]);
1071     int n = (int)(w[4]);
1072     for (; n; n -= 8, in += 8, out += 8)
1073     {
1074         t_sample f0 = in[0], f1 = in[1], f2 = in[2], f3 = in[3];
1075         t_sample f4 = in[4], f5 = in[5], f6 = in[6], f7 = in[7];
1076
1077         out[0] = f0 - g; out[1] = f1 - g; out[2] = f2 - g; out[3] = f3 - g;
1078         out[4] = f4 - g; out[5] = f5 - g; out[6] = f6 - g; out[7] = f7 - g;
1079     }
1080     return (w+5);
1081 }
1082
1083 static void minus_dsp(t_minus *x, t_signal **sp)
1084 {
1085     if (sp[0]->s_n&7)
1086         dsp_add(minus_perform, 4,
1087             sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
1088     else
1089         dsp_add(minus_perf8, 4,
1090             sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
1091 }
1092
1093 static void scalarminus_dsp(t_scalarminus *x, t_signal **sp)
1094 {
1095     if (sp[0]->s_n&7)
1096         dsp_add(scalarminus_perform, 4, sp[0]->s_vec, &x->x_g,
1097             sp[1]->s_vec, sp[0]->s_n);
1098     else
1099         dsp_add(scalarminus_perf8, 4, sp[0]->s_vec, &x->x_g,
1100             sp[1]->s_vec, sp[0]->s_n);
1101 }
1102
1103 static void minus_setup(void)
1104 {
1105     minus_class = class_new(gensym("-~"), (t_newmethod)minus_new, 0,
1106         sizeof(t_minus), 0, A_GIMME, 0);
1107     CLASS_MAINSIGNALIN(minus_class, t_minus, x_f);
1108     class_addmethod(minus_class, (t_method)minus_dsp, gensym("dsp"), 0);
1109     class_sethelpsymbol(minus_class, gensym("sigbinops"));
1110     scalarminus_class = class_new(gensym("-~"), 0, 0,
1111         sizeof(t_scalarminus), 0, 0);
1112     CLASS_MAINSIGNALIN(scalarminus_class, t_scalarminus, x_f);
1113     class_addmethod(scalarminus_class, (t_method)scalarminus_dsp, gensym("dsp"),
1114         0);
1115     class_sethelpsymbol(scalarminus_class, gensym("sigbinops"));
1116 }
1117
1118 /* ----------------------------- times ----------------------------- */
1119
1120 static t_class *times_class, *scalartimes_class;
1121
1122 typedef struct _times
1123 {
1124     t_object x_obj;
1125     float x_f;
1126 } t_times;
1127
1128 typedef struct _scalartimes
1129 {
1130     t_object x_obj;
1131     float x_f;
1132     t_float x_g;
1133 } t_scalartimes;
1134
1135 static void *times_new(t_symbol *s, int argc, t_atom *argv)
1136 {
1137     if (argc > 1) post("*~: extra arguments ignored");
1138     if (argc)
1139     {
1140         t_scalartimes *x = (t_scalartimes *)pd_new(scalartimes_class);
1141         floatinlet_new(&x->x_obj, &x->x_g);
1142         x->x_g = atom_getfloatarg(0, argc, argv);
1143         outlet_new(&x->x_obj, &s_signal);
1144         x->x_f = 0;
1145         return (x);
1146     }
1147     else
1148     {
1149         t_times *x = (t_times *)pd_new(times_class);
1150         inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
1151         outlet_new(&x->x_obj, &s_signal);
1152         x->x_f = 0;
1153         return (x);
1154     }
1155 }
1156
1157 t_int *times_perform(t_int *w)
1158 {
1159     t_sample *in1 = (t_sample *)(w[1]);
1160     t_sample *in2 = (t_sample *)(w[2]);
1161     t_sample *out = (t_sample *)(w[3]);
1162     int n = (int)(w[4]);
1163     while (n--) *out++ = mult(*in1++,*in2++);
1164     return (w+5);
1165 }
1166
1167 t_int *times_perf8(t_int *w)
1168 {
1169     t_sample *in1 = (t_sample *)(w[1]);
1170     t_sample *in2 = (t_sample *)(w[2]);
1171     t_sample *out = (t_sample *)(w[3]);
1172     int n = (int)(w[4]);
1173     for (; n; n -= 8, in1 += 8, in2 += 8, out += 8)
1174     {
1175         t_sample f0 = in1[0], f1 = in1[1], f2 = in1[2], f3 = in1[3];
1176         t_sample f4 = in1[4], f5 = in1[5], f6 = in1[6], f7 = in1[7];
1177
1178         t_sample g0 = in2[0], g1 = in2[1], g2 = in2[2], g3 = in2[3];
1179         t_sample g4 = in2[4], g5 = in2[5], g6 = in2[6], g7 = in2[7];
1180
1181         out[0] = mult(f0,g0); out[1] = mult(f1,g1); out[2] = mult(f2,g2); out[3] = mult(f3,g3);
1182         out[4] = mult(f4,g4); out[5] = mult(f5,g5); out[6] = mult(f6,g6); out[7] = mult(f7,g7);
1183     }
1184     return (w+5);
1185 }
1186
1187 t_int *scalartimes_perform(t_int *w)
1188 {
1189     t_sample *in = (t_sample *)(w[1]);
1190     t_sample f = ftofix(*(t_float *)(w[2]));
1191     t_sample *out = (t_sample *)(w[3]);
1192     int n = (int)(w[4]);
1193     while (n--) *out++ = mult(*in++,f);
1194     return (w+5);
1195 }
1196
1197 t_int *scalartimes_perf8(t_int *w)
1198 {
1199     t_sample *in = (t_sample *)(w[1]);
1200     t_sample g = ftofix(*(t_float *)(w[2]));
1201     t_sample *out = (t_sample *)(w[3]);
1202     int n = (int)(w[4]);
1203     for (; n; n -= 8, in += 8, out += 8)
1204     {
1205         t_sample f0 = in[0], f1 = in[1], f2 = in[2], f3 = in[3];
1206         t_sample f4 = in[4], f5 = in[5], f6 = in[6], f7 = in[7];
1207
1208         out[0] = mult(f0,g); out[1] = mult(f1,g); out[2] = mult(f2,g); out[3] = mult(f3,g);
1209         out[4] = mult(f4,g); out[5] = mult(f5,g); out[6] = mult(f6,g); out[7] = mult(f7,g);
1210     }
1211     return (w+5);
1212 }
1213
1214 static void times_dsp(t_times *x, t_signal **sp)
1215 {
1216     if (sp[0]->s_n&7)
1217         dsp_add(times_perform, 4,
1218             sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
1219     else
1220         dsp_add(times_perf8, 4,
1221             sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
1222 }
1223
1224 static void scalartimes_dsp(t_scalartimes *x, t_signal **sp)
1225 {
1226     if (sp[0]->s_n&7)
1227         dsp_add(scalartimes_perform, 4, sp[0]->s_vec, &x->x_g,
1228             sp[1]->s_vec, sp[0]->s_n);
1229     else
1230         dsp_add(scalartimes_perf8, 4, sp[0]->s_vec, &x->x_g,
1231             sp[1]->s_vec, sp[0]->s_n);
1232 }
1233
1234 static void times_setup(void)
1235 {
1236     times_class = class_new(gensym("*~"), (t_newmethod)times_new, 0,
1237         sizeof(t_times), 0, A_GIMME, 0);
1238     CLASS_MAINSIGNALIN(times_class, t_times, x_f);
1239     class_addmethod(times_class, (t_method)times_dsp, gensym("dsp"), 0);
1240     class_sethelpsymbol(times_class, gensym("sigbinops"));
1241     scalartimes_class = class_new(gensym("*~"), 0, 0,
1242         sizeof(t_scalartimes), 0, 0);
1243     CLASS_MAINSIGNALIN(scalartimes_class, t_scalartimes, x_f);
1244     class_addmethod(scalartimes_class, (t_method)scalartimes_dsp, gensym("dsp"),
1245         0);
1246     class_sethelpsymbol(scalartimes_class, gensym("sigbinops"));
1247 }
1248
1249 /* ----------------------------- over ----------------------------- */
1250 static t_class *over_class, *scalarover_class;
1251
1252 typedef struct _over
1253 {
1254     t_object x_obj;
1255     float x_f;
1256 } t_over;
1257
1258 typedef struct _scalarover
1259 {
1260     t_object x_obj;
1261     float x_f;
1262     t_float x_g;
1263 } t_scalarover;
1264
1265 static void *over_new(t_symbol *s, int argc, t_atom *argv)
1266 {
1267     if (argc > 1) post("/~: extra arguments ignored");
1268     if (argc)
1269     {
1270         t_scalarover *x = (t_scalarover *)pd_new(scalarover_class);
1271         floatinlet_new(&x->x_obj, &x->x_g);
1272         x->x_g = atom_getfloatarg(0, argc, argv);
1273         outlet_new(&x->x_obj, &s_signal);
1274         x->x_f = 0;
1275         return (x);
1276     }
1277     else
1278     {
1279         t_over *x = (t_over *)pd_new(over_class);
1280         inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
1281         outlet_new(&x->x_obj, &s_signal);
1282         x->x_f = 0;
1283         return (x);
1284     }
1285 }
1286
1287 t_int *over_perform(t_int *w)
1288 {
1289     t_sample *in1 = (t_sample *)(w[1]);
1290     t_sample *in2 = (t_sample *)(w[2]);
1291     t_sample *out = (t_sample *)(w[3]);
1292     int n = (int)(w[4]);
1293     while (n--)
1294     {
1295         float g = *in2++;
1296         *out++ = (g ? *in1++ / g : 0);
1297     }
1298     return (w+5);
1299 }
1300
1301 t_int *over_perf8(t_int *w)
1302 {
1303     t_sample *in1 = (t_sample *)(w[1]);
1304     t_sample *in2 = (t_sample *)(w[2]);
1305     t_sample *out = (t_sample *)(w[3]);
1306     int n = (int)(w[4]);
1307     for (; n; n -= 8, in1 += 8, in2 += 8, out += 8)
1308     {
1309         t_sample f0 = in1[0], f1 = in1[1], f2 = in1[2], f3 = in1[3];
1310         t_sample f4 = in1[4], f5 = in1[5], f6 = in1[6], f7 = in1[7];
1311
1312         t_sample g0 = in2[0], g1 = in2[1], g2 = in2[2], g3 = in2[3];
1313         t_sample g4 = in2[4], g5 = in2[5], g6 = in2[6], g7 = in2[7];
1314
1315         out[0] = (g0? idiv(f0,g0) : 0);
1316         out[1] = (g1? idiv(f1,g1) : 0);
1317         out[2] = (g2? idiv(f2,g2) : 0);
1318         out[3] = (g3? idiv(f3,g3) : 0);
1319         out[4] = (g4? idiv(f4,g4) : 0);
1320         out[5] = (g5? idiv(f5,g5) : 0);
1321         out[6] = (g6? idiv(f6,g6) : 0);
1322         out[7] = (g7? idiv(f7,g7) : 0);
1323     }
1324     return (w+5);
1325 }
1326
1327 t_int *scalarover_perform(t_int *w)
1328 {
1329     t_sample *in = (t_sample *)(w[1]);
1330     t_sample f = idiv(ftofix(1.),ftofix(*(t_float *)(w[2])));
1331     t_sample *out = (t_sample *)(w[3]);
1332     int n = (int)(w[4]);
1333     while (n--) *out++ = mult(*in++,f);
1334     return (w+5);
1335 }
1336
1337 t_int *scalarover_perf8(t_int *w)
1338 {
1339     t_sample *in = (t_sample *)(w[1]);
1340     t_sample g = ftofix(*(t_float *)(w[2]));
1341     t_sample *out = (t_sample *)(w[3]);
1342     int n = (int)(w[4]);
1343     if (g) g = idiv(ftofix(1.f),g);
1344     for (; n; n -= 8, in += 8, out += 8)
1345     {
1346         t_sample f0 = in[0], f1 = in[1], f2 = in[2], f3 = in[3];
1347         t_sample f4 = in[4], f5 = in[5], f6 = in[6], f7 = in[7];
1348
1349         out[0] = mult(f0,g); out[1] = mult(f1,g); out[2] = mult(f2,g); out[3] = mult(f3,g);
1350         out[4] = mult(f4,g); out[5] = mult(f5,g); out[6] = mult(f6,g); out[7] = mult(f7,g);
1351     }
1352     return (w+5);
1353 }
1354
1355 static void over_dsp(t_over *x, t_signal **sp)
1356 {
1357     if (sp[0]->s_n&7)
1358         dsp_add(over_perform, 4,
1359             sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
1360     else
1361         dsp_add(over_perf8, 4,
1362             sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
1363 }
1364
1365 static void scalarover_dsp(t_scalarover *x, t_signal **sp)
1366 {
1367     if (sp[0]->s_n&7)
1368         dsp_add(scalarover_perform, 4, sp[0]->s_vec, &x->x_g,
1369             sp[1]->s_vec, sp[0]->s_n);
1370     else
1371         dsp_add(scalarover_perf8, 4, sp[0]->s_vec, &x->x_g,
1372             sp[1]->s_vec, sp[0]->s_n);
1373 }
1374
1375 static void over_setup(void)
1376 {
1377     over_class = class_new(gensym("/~"), (t_newmethod)over_new, 0,
1378         sizeof(t_over), 0, A_GIMME, 0);
1379     CLASS_MAINSIGNALIN(over_class, t_over, x_f);
1380     class_addmethod(over_class, (t_method)over_dsp, gensym("dsp"), 0);
1381     class_sethelpsymbol(over_class, gensym("sigbinops"));
1382     scalarover_class = class_new(gensym("/~"), 0, 0,
1383         sizeof(t_scalarover), 0, 0);
1384     CLASS_MAINSIGNALIN(scalarover_class, t_scalarover, x_f);
1385     class_addmethod(scalarover_class, (t_method)scalarover_dsp, gensym("dsp"),
1386         0);
1387     class_sethelpsymbol(scalarover_class, gensym("sigbinops"));
1388 }
1389
1390 /* ----------------------------- max ----------------------------- */
1391 static t_class *max_class, *scalarmax_class;
1392
1393 typedef struct _max
1394 {
1395     t_object x_obj;
1396     float x_f;
1397 } t_max;
1398
1399 typedef struct _scalarmax
1400 {
1401     t_object x_obj;
1402     float x_f;
1403     t_float x_g;
1404 } t_scalarmax;
1405
1406 static void *max_new(t_symbol *s, int argc, t_atom *argv)
1407 {
1408     if (argc > 1) post("max~: extra arguments ignored");
1409     if (argc)
1410     {
1411         t_scalarmax *x = (t_scalarmax *)pd_new(scalarmax_class);
1412         floatinlet_new(&x->x_obj, &x->x_g);
1413         x->x_g = atom_getfloatarg(0, argc, argv);
1414         outlet_new(&x->x_obj, &s_signal);
1415         x->x_f = 0;
1416         return (x);
1417     }
1418     else
1419     {
1420         t_max *x = (t_max *)pd_new(max_class);
1421         inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
1422         outlet_new(&x->x_obj, &s_signal);
1423         x->x_f = 0;
1424         return (x);
1425     }
1426 }
1427
1428 t_int *max_perform(t_int *w)
1429 {
1430     t_sample *in1 = (t_sample *)(w[1]);
1431     t_sample *in2 = (t_sample *)(w[2]);
1432     t_sample *out = (t_sample *)(w[3]);
1433     int n = (int)(w[4]);
1434     while (n--)
1435     {
1436         t_sample f = *in1++, g = *in2++;
1437         *out++ = (f > g ? f : g);
1438     }
1439     return (w+5);
1440 }
1441
1442 t_int *max_perf8(t_int *w)
1443 {
1444     t_sample *in1 = (t_sample *)(w[1]);
1445     t_sample *in2 = (t_sample *)(w[2]);
1446     t_sample *out = (t_sample *)(w[3]);
1447     int n = (int)(w[4]);
1448     for (; n; n -= 8, in1 += 8, in2 += 8, out += 8)
1449     {
1450         t_sample f0 = in1[0], f1 = in1[1], f2 = in1[2], f3 = in1[3];
1451         t_sample f4 = in1[4], f5 = in1[5], f6 = in1[6], f7 = in1[7];
1452
1453         t_sample g0 = in2[0], g1 = in2[1], g2 = in2[2], g3 = in2[3];
1454         t_sample g4 = in2[4], g5 = in2[5], g6 = in2[6], g7 = in2[7];
1455
1456         out[0] = (f0 > g0 ? f0 : g0); out[1] = (f1 > g1 ? f1 : g1);
1457         out[2] = (f2 > g2 ? f2 : g2); out[3] = (f3 > g3 ? f3 : g3);
1458         out[4] = (f4 > g4 ? f4 : g4); out[5] = (f5 > g5 ? f5 : g5);
1459         out[6] = (f6 > g6 ? f6 : g6); out[7] = (f7 > g7 ? f7 : g7);
1460     }
1461     return (w+5);
1462 }
1463
1464 t_int *scalarmax_perform(t_int *w)
1465 {
1466     t_sample *in = (t_sample *)(w[1]);
1467     t_sample f = ftofix(*(t_float *)(w[2]));
1468     t_sample *out = (t_sample *)(w[3]);
1469     int n = (int)(w[4]);
1470     while (n--)
1471     {
1472         t_sample g = *in++;
1473         *out++ = (f > g ? f : g);
1474     }
1475     return (w+5);
1476 }
1477
1478 t_int *scalarmax_perf8(t_int *w)
1479 {
1480     t_sample *in = (t_sample *)(w[1]);
1481     t_sample g = ftofix(*(t_float *)(w[2]));
1482     t_sample *out = (t_sample *)(w[3]);
1483     int n = (int)(w[4]);
1484     for (; n; n -= 8, in += 8, out += 8)
1485     {
1486         t_sample f0 = in[0], f1 = in[1], f2 = in[2], f3 = in[3];
1487         t_sample f4 = in[4], f5 = in[5], f6 = in[6], f7 = in[7];
1488
1489         out[0] = (f0 > g ? f0 : g); out[1] = (f1 > g ? f1 : g);
1490         out[2] = (f2 > g ? f2 : g); out[3] = (f3 > g ? f3 : g);
1491         out[4] = (f4 > g ? f4 : g); out[5] = (f5 > g ? f5 : g);
1492         out[6] = (f6 > g ? f6 : g); out[7] = (f7 > g ? f7 : g);
1493     }
1494     return (w+5);
1495 }
1496
1497 static void max_dsp(t_max *x, t_signal **sp)
1498 {
1499     if (sp[0]->s_n&7)
1500         dsp_add(max_perform, 4,
1501             sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
1502     else
1503         dsp_add(max_perf8, 4,
1504             sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
1505 }
1506
1507 static void scalarmax_dsp(t_scalarmax *x, t_signal **sp)
1508 {
1509     if (sp[0]->s_n&7)
1510         dsp_add(scalarmax_perform, 4, sp[0]->s_vec, &x->x_g,
1511             sp[1]->s_vec, sp[0]->s_n);
1512     else
1513         dsp_add(scalarmax_perf8, 4, sp[0]->s_vec, &x->x_g,
1514             sp[1]->s_vec, sp[0]->s_n);
1515 }
1516
1517 static void max_setup(void)
1518 {
1519     max_class = class_new(gensym("max~"), (t_newmethod)max_new, 0,
1520         sizeof(t_max), 0, A_GIMME, 0);
1521     CLASS_MAINSIGNALIN(max_class, t_max, x_f);
1522     class_addmethod(max_class, (t_method)max_dsp, gensym("dsp"), 0);
1523     class_sethelpsymbol(max_class, gensym("sigbinops"));
1524     scalarmax_class = class_new(gensym("max~"), 0, 0,
1525         sizeof(t_scalarmax), 0, 0);
1526     CLASS_MAINSIGNALIN(scalarmax_class, t_scalarmax, x_f);
1527     class_addmethod(scalarmax_class, (t_method)scalarmax_dsp, gensym("dsp"),
1528         0);
1529     class_sethelpsymbol(scalarmax_class, gensym("sigbinops"));
1530 }
1531
1532 /* ----------------------------- min ----------------------------- */
1533 static t_class *min_class, *scalarmin_class;
1534
1535 typedef struct _min
1536 {
1537     t_object x_obj;
1538     float x_f;
1539 } t_min;
1540
1541 typedef struct _scalarmin
1542 {
1543     t_object x_obj;
1544     t_float x_g;
1545     float x_f;
1546 } t_scalarmin;
1547
1548 static void *min_new(t_symbol *s, int argc, t_atom *argv)
1549 {
1550     if (argc > 1) post("min~: extra arguments ignored");
1551     if (argc)
1552     {
1553         t_scalarmin *x = (t_scalarmin *)pd_new(scalarmin_class);
1554         floatinlet_new(&x->x_obj, &x->x_g);
1555         x->x_g = atom_getfloatarg(0, argc, argv);
1556         outlet_new(&x->x_obj, &s_signal);
1557         x->x_f = 0;
1558         return (x);
1559     }
1560     else
1561     {
1562         t_min *x = (t_min *)pd_new(min_class);
1563         inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
1564         outlet_new(&x->x_obj, &s_signal);
1565         x->x_f = 0;
1566         return (x);
1567     }
1568 }
1569
1570 t_int *min_perform(t_int *w)
1571 {
1572     t_sample *in1 = (t_sample *)(w[1]);
1573     t_sample *in2 = (t_sample *)(w[2]);
1574     t_sample *out = (t_sample *)(w[3]);
1575     int n = (int)(w[4]);
1576     while (n--)
1577     {
1578         t_sample f = *in1++, g = *in2++;
1579         *out++ = (f < g ? f : g);
1580     }
1581     return (w+5);
1582 }
1583
1584 t_int *min_perf8(t_int *w)
1585 {
1586     t_sample *in1 = (t_sample *)(w[1]);
1587     t_sample *in2 = (t_sample *)(w[2]);
1588     t_sample *out = (t_sample *)(w[3]);
1589     int n = (int)(w[4]);
1590     for (; n; n -= 8, in1 += 8, in2 += 8, out += 8)
1591     {
1592         t_sample f0 = in1[0], f1 = in1[1], f2 = in1[2], f3 = in1[3];
1593         t_sample f4 = in1[4], f5 = in1[5], f6 = in1[6], f7 = in1[7];
1594
1595         t_sample g0 = in2[0], g1 = in2[1], g2 = in2[2], g3 = in2[3];
1596         t_sample g4 = in2[4], g5 = in2[5], g6 = in2[6], g7 = in2[7];
1597
1598         out[0] = (f0 < g0 ? f0 : g0); out[1] = (f1 < g1 ? f1 : g1);
1599         out[2] = (f2 < g2 ? f2 : g2); out[3] = (f3 < g3 ? f3 : g3);
1600         out[4] = (f4 < g4 ? f4 : g4); out[5] = (f5 < g5 ? f5 : g5);
1601         out[6] = (f6 < g6 ? f6 : g6); out[7] = (f7 < g7 ? f7 : g7);
1602     }
1603     return (w+5);
1604 }
1605
1606 t_int *scalarmin_perform(t_int *w)
1607 {
1608     t_sample *in = (t_sample *)(w[1]);
1609     t_sample f = ftofix(*(t_float *)(w[2]));
1610     t_sample *out = (t_sample *)(w[3]);
1611     int n = (int)(w[4]);
1612     while (n--)
1613     {
1614         t_sample g = *in++;
1615         *out++ = (f < g ? f : g);
1616     }
1617     return (w+5);
1618 }
1619
1620 t_int *scalarmin_perf8(t_int *w)
1621 {
1622     t_sample *in = (t_sample *)(w[1]);
1623     t_sample g = ftofix(*(t_float *)(w[2]));
1624     t_sample *out = (t_sample *)(w[3]);
1625     int n = (int)(w[4]);
1626     for (; n; n -= 8, in += 8, out += 8)
1627     {
1628         t_sample f0 = in[0], f1 = in[1], f2 = in[2], f3 = in[3];
1629         t_sample f4 = in[4], f5 = in[5], f6 = in[6], f7 = in[7];
1630
1631         out[0] = (f0 < g ? f0 : g); out[1] = (f1 < g ? f1 : g);
1632         out[2] = (f2 < g ? f2 : g); out[3] = (f3 < g ? f3 : g);
1633         out[4] = (f4 < g ? f4 : g); out[5] = (f5 < g ? f5 : g);
1634         out[6] = (f6 < g ? f6 : g); out[7] = (f7 < g ? f7 : g);
1635     }
1636     return (w+5);
1637 }
1638
1639 static void min_dsp(t_min *x, t_signal **sp)
1640 {
1641     if (sp[0]->s_n&7)
1642         dsp_add(min_perform, 4,
1643             sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
1644     else
1645         dsp_add(min_perf8, 4,
1646             sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
1647 }
1648
1649 static void scalarmin_dsp(t_scalarmin *x, t_signal **sp)
1650 {
1651     if (sp[0]->s_n&7)
1652         dsp_add(scalarmin_perform, 4, sp[0]->s_vec, &x->x_g,
1653             sp[1]->s_vec, sp[0]->s_n);
1654     else
1655         dsp_add(scalarmin_perf8, 4, sp[0]->s_vec, &x->x_g,
1656             sp[1]->s_vec, sp[0]->s_n);
1657 }
1658
1659 static void min_setup(void)
1660 {
1661     min_class = class_new(gensym("min~"), (t_newmethod)min_new, 0,
1662         sizeof(t_min), 0, A_GIMME, 0);
1663     CLASS_MAINSIGNALIN(min_class, t_min, x_f);
1664     class_addmethod(min_class, (t_method)min_dsp, gensym("dsp"), 0);
1665     class_sethelpsymbol(min_class, gensym("sigbinops"));
1666     scalarmin_class = class_new(gensym("min~"), 0, 0,
1667         sizeof(t_scalarmin), 0, 0);
1668     CLASS_MAINSIGNALIN(scalarmin_class, t_scalarmin, x_f);
1669     class_addmethod(scalarmin_class, (t_method)scalarmin_dsp, gensym("dsp"),
1670         0);
1671     class_sethelpsymbol(scalarmin_class, gensym("sigbinops"));
1672 }
1673
1674 /* ----------------------- global setup routine ---------------- */
1675 void d_arithmetic_setup(void)
1676 {
1677     plus_setup();
1678     minus_setup();
1679     times_setup();
1680     over_setup();
1681     max_setup();
1682     min_setup();
1683 }
1684