I thought that
op = _,_;
should be equivalent to
op(x1,x2) = x1,x2;
and since inputs(op) == 2 all these definitions
process = op;
process = op(_);
process = op(_,_);
process = op(_)(_);
should be equivalent and result in
output0[i] = FAUSTFLOAT(float(input0[i]));
output1[i] = FAUSTFLOAT(float(input1[i]));
This is almost true, but there is one exception:
op(x1,x2) = x1,x2;
process = op(_);
acts as cross2 and compiles to
output0[i] = FAUSTFLOAT(float(input1[i]));
output1[i] = FAUSTFLOAT(float(input0[i]));
-------------------------------------------------------------------------------
Perhaps I can even understand this... so if we have
op(x1,x2) = x1,x2;
process = op(_);
then op(_) "returns" \(x2).(_,x2) after transformation and then
process = \(x2).(_,x2);
"binds" the 1st input to x2. Right?
OK, but why this doesn't happen with builtin primitives? Say,
process = /(_);
compiles to "input0[i] / input1[i]" as expected... OK, this is probably
because
/(2)(3)
/(2, 3)
are NOT the same thing as I'd expect. It seems there are some special rules
for builtin operators?
-------------------------------------------------------------------------------
Is there any documentation which explains these subtlenesses?
Thanks,
Oleg.
------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most
engaging tech sites, Slashdot.org! http://sdm.link/slashdot
_______________________________________________
Faudiostream-users mailing list
Faudiostream-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/faudiostream-users
