_id
stringlengths 64
64
| repository
stringlengths 7
61
| name
stringlengths 5
45
| content
stringlengths 0
943k
| download_url
stringlengths 94
213
| language
stringclasses 1
value | comments
stringlengths 0
20.9k
| code
stringlengths 0
943k
|
|---|---|---|---|---|---|---|---|
1be650a915f49da4f5796efb4be030f4aa8e14a12d76e3e7cad728fab8ba4f24 | luuuucaaa/faustGranulator | multichannel_noisegenerator_v1.dsp | // multi-channel noise generator
N = 8;
polyrandom(N) = scramble(N) ~ _
with {scramble(1) = * (1103515245) : + (12345);
scramble(n) = scramble(1) <: scramble(n - 1),
_;
};
polynoise(N) = polyrandom(N) : par(i, N, / (2147483647.0)); | https://raw.githubusercontent.com/luuuucaaa/faustGranulator/161bed38e164ba69726a91575597468ba2a5f1a0/multichannel_noisegenerator_v1.dsp | faust | multi-channel noise generator | N = 8;
polyrandom(N) = scramble(N) ~ _
with {scramble(1) = * (1103515245) : + (12345);
scramble(n) = scramble(1) <: scramble(n - 1),
_;
};
polynoise(N) = polyrandom(N) : par(i, N, / (2147483647.0)); |
fd56e19a07c7c8b3f527c410a217ecf2d93cf1802a2d47a816f4dcaba49d9d4e | luuuucaaa/faustGranulator | granulator_v2_7.dsp | declare name "Multichannel Data Granulator";
declare version "2.7";
declare author "Lukas Hartmann & Luca Hilbrich";
declare options "[osc:on]";
declare options "[midi:on]";
import("stdfaust.lib");
// USER INTERFACE //
volumeSlider = vslider("h:/h:[0]Granulator/ [0]Volume [midi:ctrl 0]", 0.5, 0, 1, 0.01); // volume slider
pitchSlider = vslider("h:/h:[0]Granulator/ [1] Pitch [midi:ctrl 1]", 1, -2, 2, 0.01); // pitch control (downsampling)
windowSlider = vslider("h:/h:[0]Granulator/ [2]Window[style:radio{'Sine Window':window1;'Hamming Window':window2;'Flat Top Window':window3}] [midi:ctrl 2]",1,1,3,1);
grainAmountSlider = vslider("h:/h:[1]Grain/ [1] Density [midi:ctrl 3]", 1, 1, MAXN, 1); // number of grains
grainbufferSizeSlider = vslider("h:/h:[1]Grain/ [2] Size [midi:ctrl 4]", 0.1, 0.01, 0.5, 0.01); // grain size in samples
delayLengthSlider = vslider("h:/h:[1]Grain/ [3] Delay [midi:ctrl 5]", 2, 0.5, 2, 0.1); // delay length in samples
positionspreadSlider = vslider("h:/h:[1]Grain/ [4] Spread [midi:ctrl 6]", 1, 0.1, 2, 0.1); // position spread of grains
reverb_spread_slider = vslider("h:/v:[2]Effects/ [0]Reverb Spread[unit:%][style:knob][midi:ctrl 16]", 0, 0, 100, 1);
dry_wet = vslider("h:/v:[2]Effects/ [1]Dry Wet[style:knob] [midi:ctrl 17]", 0.4, 0, 1, 0.001);
filter_cuttoff = vslider("h:/v:[2]Effects/ [2]HPF[unit:Hz][style:knob] [midi:ctrl 18]", 100, 100, 10000, 1);
// CODE //
SR = 44100; // samplerate in samples per second
MAXN = 10; // maximum numbers of grains
Volume = volumeSlider; // volume slider
bufferSize = 2 * SR; // size of input buffer in samples
bufferCounter = + (1) % delayLength ~ _; // counter to cycle through the input buffer from 0 to bufferSize
delayLength = SR * delayLengthSlider; // set delay length with delay length slider
grainbufferSize = SR * grainbufferSizeSlider; // size of grainbuffer in samples
grainbufferCounter = + (pitchSlider) % grainbufferSize ~ _; // counter to cycle through the grains from 0 to grainSize
SH(trigger, signal) = ( * (1 - trigger) + signal * trigger) ~ _; // sample and hold function definiton for grain offset
grainOffset(i) = int(SH(1 - 1', int(delayLength * noise(i)))); // delay length between grainbuffer refresh
grainCounter(i) = (grainbufferCounter + grainOffset(i)) % grainbufferSize; // grain-specific grain counter
grainRandomStartPos(i) = int(SH(int(grainCounter(i) / (grainbufferSize - 1)), int(delayLength * noise(i))));
grainPosition(i) = grainCounter(i) + grainRandomStartPos(i);
buffer(writeIndex, readIndex, signal) = rwtable(bufferSize, 0.0, int(writeIndex % delayLength), signal, int(readIndex % delayLength)); // function definition of cycling buffer
window1(i) = sin(2 * 3.14159 * grainCounter(i) / (grainbufferSize - 1)); // window function
window2(i) = 0.54 - 0.64 * cos(2 * 3.14159 * grainCounter(i) / grainbufferSize - 1); // hamming window
window3(i) = 1 - 1.93 * cos(2 * 3.14159 * grainCounter(i) / grainbufferSize - 1) + 1.29 * cos(4 * 3.14159 * grainCounter(i) / grainbufferSize - 1) - 0.388 * cos(6 * 3.14159 * grainCounter(i) / grainbufferSize - 1) + 0.028 * cos(8 * 3.14159 * grainCounter(i) / grainbufferSize - 1); // flat top window
// NOISE GENERATOR //
RANDMAX = (2147483647.0) * 2 ; // max number of random number generatorn
polyRandom(n) = scramble(n) ~ _
with {
scramble (1) = * (1103515245) : + (12345); // pseudo random number generator
scramble (n) = scramble(1) <: scramble(n - 1), _;
};
polyNoise(n) = polyRandom(n) : par(i, n, /(RANDMAX));
noiseChan(n, 0) = polyNoise(MAXN + 1) :> _, par(j, n - 1, !);
noiseChan(n, i) = polyNoise(MAXN + 1) :> par(j, i, !), _, par(j, n - i - 1, !);
noise(i) = (noiseChan(MAXN + 1, i) + 1) / 2 * positionspreadSlider; //to get nth channel of multi-channel noiser (not quite sure how)
// EFFECTS //
reverb = _, _ <: ( * (dry_wet) * fixedgain, * (dry_wet) * fixedgain :
re.stereo_freeverb(0.5, 0.5, 0.5, reverb_spread_slider)),
* (1 - dry_wet), * (1 - dry_wet) :> _, _
with {
fixedgain = 0.1;
}; // stereo reverb with dry/wet implementation
hpf_filter = _, _: (fi.highpass(filter_order, filter_cuttoff)), (fi.highpass(filter_order, filter_cuttoff)): _, _
with {
filter_order = 1;
}; //stereo hpf
// PROCESS //
process = _ <: par(i, MAXN, buffer(int(bufferCounter), int(grainPosition(i)), _) * windowSlider * Volume * (i < grainAmountSlider) / grainAmountSlider) :> reverb :> hpf_filter :> _, _; | https://raw.githubusercontent.com/luuuucaaa/faustGranulator/161bed38e164ba69726a91575597468ba2a5f1a0/granulator_v2_7.dsp | faust | USER INTERFACE //
volume slider
pitch control (downsampling)
number of grains
grain size in samples
delay length in samples
position spread of grains
CODE //
samplerate in samples per second
maximum numbers of grains
volume slider
size of input buffer in samples
counter to cycle through the input buffer from 0 to bufferSize
set delay length with delay length slider
size of grainbuffer in samples
counter to cycle through the grains from 0 to grainSize
sample and hold function definiton for grain offset
delay length between grainbuffer refresh
grain-specific grain counter
function definition of cycling buffer
window function
hamming window
flat top window
NOISE GENERATOR //
max number of random number generatorn
pseudo random number generator
to get nth channel of multi-channel noiser (not quite sure how)
EFFECTS //
stereo reverb with dry/wet implementation
stereo hpf
PROCESS // | declare name "Multichannel Data Granulator";
declare version "2.7";
declare author "Lukas Hartmann & Luca Hilbrich";
declare options "[osc:on]";
declare options "[midi:on]";
import("stdfaust.lib");
windowSlider = vslider("h:/h:[0]Granulator/ [2]Window[style:radio{'Sine Window':window1;'Hamming Window':window2;'Flat Top Window':window3}] [midi:ctrl 2]",1,1,3,1);
reverb_spread_slider = vslider("h:/v:[2]Effects/ [0]Reverb Spread[unit:%][style:knob][midi:ctrl 16]", 0, 0, 100, 1);
dry_wet = vslider("h:/v:[2]Effects/ [1]Dry Wet[style:knob] [midi:ctrl 17]", 0.4, 0, 1, 0.001);
filter_cuttoff = vslider("h:/v:[2]Effects/ [2]HPF[unit:Hz][style:knob] [midi:ctrl 18]", 100, 100, 10000, 1);
grainRandomStartPos(i) = int(SH(int(grainCounter(i) / (grainbufferSize - 1)), int(delayLength * noise(i))));
grainPosition(i) = grainCounter(i) + grainRandomStartPos(i);
polyRandom(n) = scramble(n) ~ _
with {
scramble (n) = scramble(1) <: scramble(n - 1), _;
};
polyNoise(n) = polyRandom(n) : par(i, n, /(RANDMAX));
noiseChan(n, 0) = polyNoise(MAXN + 1) :> _, par(j, n - 1, !);
noiseChan(n, i) = polyNoise(MAXN + 1) :> par(j, i, !), _, par(j, n - i - 1, !);
reverb = _, _ <: ( * (dry_wet) * fixedgain, * (dry_wet) * fixedgain :
re.stereo_freeverb(0.5, 0.5, 0.5, reverb_spread_slider)),
* (1 - dry_wet), * (1 - dry_wet) :> _, _
with {
fixedgain = 0.1;
hpf_filter = _, _: (fi.highpass(filter_order, filter_cuttoff)), (fi.highpass(filter_order, filter_cuttoff)): _, _
with {
filter_order = 1;
process = _ <: par(i, MAXN, buffer(int(bufferCounter), int(grainPosition(i)), _) * windowSlider * Volume * (i < grainAmountSlider) / grainAmountSlider) :> reverb :> hpf_filter :> _, _; |
3804b031268aa8b8ddcd040a419aa4d720540bec8fd5e12e1e964a6765890273 | luuuucaaa/faustGranulator | granulator_v2_2.dsp | // USER INTERFACE //
volumeSlider = hslider("Volume", 0.5, 0, 1, 0.01); // volume slider
grainbufferSizeSlider = hslider("Grain Size", 1000, 1000, 10000, 1); // grain size in samples
delayLengthSlider = hslider("Delay Length", 1000, 1000, 10000, 1); // delay length in samples
pitchSlider = hslider("Pitch", 1, 0.1, 2, 0.1); // pitch control/ downsampling
// CODE //
SR = 44100; // samplerate in samples per second
N = 1; // numbers of grains
Volume = volumeSlider;
bufferSize = SR; // size of input buffer in samples
bufferCounter = + (1) % delayLength ~ _; // counter to cycle through the input buffer from 0 to bufferSize
delayLength = delayLengthSlider; // set delay length with delay length slider
grainbufferSize = grainbufferSizeSlider; // size of grainbuffer in samples
grainbufferCounter = + (pitchSlider) % grainbufferSize ~ _; // counter to cycle through the grains from 0 to grainSize
SH(trigger, signal) = ( * (1 - trigger) + signal * trigger) ~ _; // sample and hold function definiton for grain offset
grainOffset(i) = int(SH(1 - 1', int(delayLength))); // delay length between grainbuffer refresh
grainCounter(i) = (grainbufferCounter + grainOffset(i)) % grainbufferSize; // grain-specific grain counter
// grainPosition(i) = grainCounter(i) + random(i);
buffer(writeIndex, readIndex, signal) = rwtable(bufferSize, 0.0, int(writeIndex % delayLength), signal, int(readIndex % delayLength)); // function definition of cycling buffer
window(i) = sin(2 * 3.14159 * grainCounter(i) / (grainbufferSize - 1)); // window function
// PROCESS //
process = _ <: par(i, N, buffer(int(bufferCounter), int(grainCounter(i)), _) * window(i) * Volume * (i < N) / N) :> _ <: _, _;
| https://raw.githubusercontent.com/luuuucaaa/faustGranulator/161bed38e164ba69726a91575597468ba2a5f1a0/granulator_v2_2.dsp | faust | USER INTERFACE //
volume slider
grain size in samples
delay length in samples
pitch control/ downsampling
CODE //
samplerate in samples per second
numbers of grains
size of input buffer in samples
counter to cycle through the input buffer from 0 to bufferSize
set delay length with delay length slider
size of grainbuffer in samples
counter to cycle through the grains from 0 to grainSize
sample and hold function definiton for grain offset
delay length between grainbuffer refresh
grain-specific grain counter
grainPosition(i) = grainCounter(i) + random(i);
function definition of cycling buffer
window function
PROCESS // |
Volume = volumeSlider;
process = _ <: par(i, N, buffer(int(bufferCounter), int(grainCounter(i)), _) * window(i) * Volume * (i < N) / N) :> _ <: _, _;
|
0a8d2daf264fadbb19a137aaf31f1e92cd60e3b91a82d5cc51e66e479abc93cd | luuuucaaa/faustGranulator | granulator_v2_6.dsp | import("stdfaust.lib");
// USER INTERFACE //
volumeSlider = vslider("h:/h:[0]Granulator/ [0]Volume", 0.5, 0, 1, 0.01); // volume slider
grainbufferSizeSlider = vslider("h:/h:[1]Grain/ [2] Size", 0.1, 0.01, 0.5, 0.01); // grain size in samples
delayLengthSlider = vslider("h:/h:[1]Grain/ [3] Delay", 2, 0.5, 2, 0.1); // delay length in samples
pitchSlider = vslider("h:/h:[0]Granulator/ [1] Pitch", 1, -2, 2, 0.01); // pitch control (downsampling)
grainAmountSlider = vslider("h:/h:[1]Grain/ [1] Density", 1, 1, MAXN, 1); // number of grains
positionspreadSlider = vslider("h:/h:[1]Grain/ [4] Spread", 1, 0.1, 2, 0.1); // position spread of grains
reverb_spread_slider = vslider("h:/v:[2]Effects/ [0]Reverb Spread[unit:%][style:knob]", 0, 0, 100, 1);
dry_wet = vslider("h:/v:[2]Effects/ [1]Dry Wet[style:knob]", 0.4, 0, 1, 0.001);
filter_cuttoff = vslider("h:/v:[2]Effects/ [2]HPF[unit:Hz][style:knob]", 100, 100, 10000, 1);
windowSlider = vslider("h:/h:[0]Granulator/ [2]Window[style:radio{'Sine Window':window1;'Hamming Window':window2;'Flat Top Window':window3}]",1,1,3,1);
// CODE //
SR = 44100; // samplerate in samples per second
MAXN = 10; // maximum numbers of grains
Volume = volumeSlider; // volume slider
bufferSize = 2 * SR; // size of input buffer in samples
bufferCounter = + (1) % delayLength ~ _; // counter to cycle through the input buffer from 0 to bufferSize
delayLength = SR * delayLengthSlider; // set delay length with delay length slider
grainbufferSize = SR * grainbufferSizeSlider; // size of grainbuffer in samples
grainbufferCounter = + (pitchSlider) % grainbufferSize ~ _; // counter to cycle through the grains from 0 to grainSize
SH(trigger, signal) = ( * (1 - trigger) + signal * trigger) ~ _; // sample and hold function definiton for grain offset
grainOffset(i) = int(SH(1 - 1', int(delayLength * noise(i)))); // delay length between grainbuffer refresh
grainCounter(i) = (grainbufferCounter + grainOffset(i)) % grainbufferSize; // grain-specific grain counter
grainRandomStartPos(i) = int(SH(int(grainCounter(i) / (grainbufferSize - 1)), int(delayLength * noise(i))));
grainPosition(i) = grainCounter(i) + grainRandomStartPos(i);
buffer(writeIndex, readIndex, signal) = rwtable(bufferSize, 0.0, int(writeIndex % delayLength), signal, int(readIndex % delayLength)); // function definition of cycling buffer
window1(i) = sin(2 * 3.14159 * grainCounter(i) / (grainbufferSize - 1)); // window function
window2(i) = 0.54 - 0.64 * cos(2 * 3.14159 * grainCounter(i) / grainbufferSize - 1); // hamming window
window3(i) = 1 - 1.93 * cos(2 * 3.14159 * grainCounter(i) / grainbufferSize - 1) + 1.29 * cos(4 * 3.14159 * grainCounter(i) / grainbufferSize - 1) - 0.388 * cos(6 * 3.14159 * grainCounter(i) / grainbufferSize - 1) + 0.028 * cos(8 * 3.14159 * grainCounter(i) / grainbufferSize - 1); // flat top window
// NOISE GENERATOR //
RANDMAX = (2147483647.0) * 2 ; // max number of random number generatorn
polyRandom(n) = scramble(n) ~ _
with {
scramble (1) = * (1103515245) : + (12345); // pseudo random number generator
scramble (n) = scramble(1) <: scramble(n - 1), _;
};
polyNoise(n) = polyRandom(n) : par(i, n, /(RANDMAX));
noiseChan(n, 0) = polyNoise(MAXN + 1) :> _, par(j, n - 1, !);
noiseChan(n, i) = polyNoise(MAXN + 1) :> par(j, i, !), _, par(j, n - i - 1, !);
noise(i) = (noiseChan(MAXN + 1, i) + 1) / 2 * positionspreadSlider; //to get nth channel of multi-channel noiser (not quite sure how)
// EFFECTS //
reverb = _, _ <: ( * (dry_wet) * fixedgain, * (dry_wet) * fixedgain :
re.stereo_freeverb(0.5, 0.5, 0.5, reverb_spread_slider)),
* (1 - dry_wet), * (1 - dry_wet) :> _, _
with {
fixedgain = 0.1;
}; // stereo reverb with dry/wet implementation
hpf_filter = _, _: (fi.highpass(filter_order, filter_cuttoff)), (fi.highpass(filter_order, filter_cuttoff)): _, _
with {
filter_order = 1;
}; //stereo hpf
// PROCESS //
process = _ <: par(i, MAXN, buffer(int(bufferCounter), int(grainPosition(i)), _) * windowSlider * Volume * (i < grainAmountSlider) / grainAmountSlider) :> reverb :> hpf_filter :> _, _; | https://raw.githubusercontent.com/luuuucaaa/faustGranulator/161bed38e164ba69726a91575597468ba2a5f1a0/granulator_v2_6.dsp | faust | USER INTERFACE //
volume slider
grain size in samples
delay length in samples
pitch control (downsampling)
number of grains
position spread of grains
CODE //
samplerate in samples per second
maximum numbers of grains
volume slider
size of input buffer in samples
counter to cycle through the input buffer from 0 to bufferSize
set delay length with delay length slider
size of grainbuffer in samples
counter to cycle through the grains from 0 to grainSize
sample and hold function definiton for grain offset
delay length between grainbuffer refresh
grain-specific grain counter
function definition of cycling buffer
window function
hamming window
flat top window
NOISE GENERATOR //
max number of random number generatorn
pseudo random number generator
to get nth channel of multi-channel noiser (not quite sure how)
EFFECTS //
stereo reverb with dry/wet implementation
stereo hpf
PROCESS // | import("stdfaust.lib");
reverb_spread_slider = vslider("h:/v:[2]Effects/ [0]Reverb Spread[unit:%][style:knob]", 0, 0, 100, 1);
dry_wet = vslider("h:/v:[2]Effects/ [1]Dry Wet[style:knob]", 0.4, 0, 1, 0.001);
filter_cuttoff = vslider("h:/v:[2]Effects/ [2]HPF[unit:Hz][style:knob]", 100, 100, 10000, 1);
windowSlider = vslider("h:/h:[0]Granulator/ [2]Window[style:radio{'Sine Window':window1;'Hamming Window':window2;'Flat Top Window':window3}]",1,1,3,1);
grainRandomStartPos(i) = int(SH(int(grainCounter(i) / (grainbufferSize - 1)), int(delayLength * noise(i))));
grainPosition(i) = grainCounter(i) + grainRandomStartPos(i);
polyRandom(n) = scramble(n) ~ _
with {
scramble (n) = scramble(1) <: scramble(n - 1), _;
};
polyNoise(n) = polyRandom(n) : par(i, n, /(RANDMAX));
noiseChan(n, 0) = polyNoise(MAXN + 1) :> _, par(j, n - 1, !);
noiseChan(n, i) = polyNoise(MAXN + 1) :> par(j, i, !), _, par(j, n - i - 1, !);
reverb = _, _ <: ( * (dry_wet) * fixedgain, * (dry_wet) * fixedgain :
re.stereo_freeverb(0.5, 0.5, 0.5, reverb_spread_slider)),
* (1 - dry_wet), * (1 - dry_wet) :> _, _
with {
fixedgain = 0.1;
hpf_filter = _, _: (fi.highpass(filter_order, filter_cuttoff)), (fi.highpass(filter_order, filter_cuttoff)): _, _
with {
filter_order = 1;
process = _ <: par(i, MAXN, buffer(int(bufferCounter), int(grainPosition(i)), _) * windowSlider * Volume * (i < grainAmountSlider) / grainAmountSlider) :> reverb :> hpf_filter :> _, _; |
57946f7c0358731af99a5870fb18d9a6935ead63f1b94be3ee9d8da7cd029884 | luuuucaaa/faustGranulator | granulator_v2_1.dsp | // USER INTERFACE //
grainOffsetSlider = hslider("Grain Offset", 100, 100, 10000, 1); // grain offset in samples
grainSizeSlider = hslider("Grain Size", 1000, 1000, 100000, 1); // grain size in samples
// CODE //
SR = 44100; // samplerate in samples per second
N = 1; // numbers of grains
bufferSize = 3*SR; // size of input buffer in samples
bufferCounter = + (1) % bufferSize ~ _; // counter to cycle through the input buffer from 0 to bufferSize
grainSize = grainSizeSlider; // size of grains in samples
grainCounter = + (1) % grainSize ~ _; // counter to cycle through the grains from 0 to grainSize
grainOffset(i) = grainOffsetSlider * i; // offset from first grain in samples
grainPosition(i) = (grainCounter + grainOffset(i));
buffer(writeIndex, readIndex, signal) = rwtable(bufferSize, 0.0, writeIndex, signal, readIndex); // function definition of cycling buffer
window(i) = sin(2 * 3.14159 * grainPosition(i) / (grainSize - 1));
// window(i) = 0.5 - 0.46 * cos((2 * 3.141592 * grainPosition(i)) / grainSize - 1); // hamming window (clipping?)
// PROCESS //
process = _ <: par(i, N, buffer(int(bufferCounter), int(grainCounter), _) * window(i)) :> _ <: _, _; // N cycling buffers in parallel; bufferCounter as writeIndex, grainCounter + (i // * grainOffset) as readIndex with i as index of one single cycling buffer | https://raw.githubusercontent.com/luuuucaaa/faustGranulator/161bed38e164ba69726a91575597468ba2a5f1a0/granulator_v2_1.dsp | faust | USER INTERFACE //
grain offset in samples
grain size in samples
CODE //
samplerate in samples per second
numbers of grains
size of input buffer in samples
counter to cycle through the input buffer from 0 to bufferSize
size of grains in samples
counter to cycle through the grains from 0 to grainSize
offset from first grain in samples
function definition of cycling buffer
window(i) = 0.5 - 0.46 * cos((2 * 3.141592 * grainPosition(i)) / grainSize - 1); // hamming window (clipping?)
PROCESS //
N cycling buffers in parallel; bufferCounter as writeIndex, grainCounter + (i // * grainOffset) as readIndex with i as index of one single cycling buffer |
grainPosition(i) = (grainCounter + grainOffset(i));
window(i) = sin(2 * 3.14159 * grainPosition(i) / (grainSize - 1));
|
ded6569c362f33b51d30e636664f4f3e8652f328d6f7b68f6c82ab2640810f93 | luuuucaaa/faustGranulator | granulator_v2_3.dsp | // USER INTERFACE //
volumeSlider = hslider("Volume", 0.5, 0, 1, 0.01); // volume slider
grainbufferSizeSlider = hslider("Grain Size", 1000, 1000, 10000, 1); // grain size in samples
delayLengthSlider = hslider("Delay Length", 1000, 1000, 10000, 1); // delay length in samples
pitchSlider = hslider("Pitch", 1, 0.1, 2, 0.1); // pitch control/ downsampling
// CODE //
SR = 44100; // samplerate in samples per second
N = 4; // numbers of grains
Volume = volumeSlider;
bufferSize = SR; // size of input buffer in samples
bufferCounter = + (1) % delayLength ~ _; // counter to cycle through the input buffer from 0 to bufferSize
delayLength = delayLengthSlider; // set delay length with delay length slider
grainbufferSize = grainbufferSizeSlider; // size of grainbuffer in samples
grainbufferCounter = + (pitchSlider) % grainbufferSize ~ _; // counter to cycle through the grains from 0 to grainSize
SH(trigger, signal) = ( * (1 - trigger) + signal * trigger) ~ _; // sample and hold function definiton for grain offset
grainOffset(i) = int(SH(1 - 1', int(delayLength))); // delay length between grainbuffer refresh
grainCounter(i) = (grainbufferCounter + grainOffset(i)) % grainbufferSize; // grain-specific grain counter
grainRandomStartPos(i) = int(SH(int(grainCounter(i)/(grainbufferSize-1)),int(delayLength*noise(i))));
buffer(writeIndex, readIndex, signal) = rwtable(bufferSize, 0.0, int(writeIndex % delayLength), signal, int(readIndex % delayLength)); // function definition of cycling buffer
window(i) = sin(2 * 3.14159 * grainCounter(i) / (grainbufferSize - 1)); // window function
// NOISE GENERATOR //
RANDMAX = (2147483647.0) * 2 ; // max number of random number generatorn
polyRandom(n) = scramble(n) ~ _
with {
scramble (1) = * (1103515245) : + (12345); // pseudo random number generator
scramble (n) = scramble(1) <: scramble(n - 1), _;
};
polyNoise(n) = polyRandom(n) : par(i, n, /(RANDMAX));
noiseChan(n,0) = polyNoise(N+1):>_,par( j, n-1 , !);
noiseChan(n,i) = polyNoise(N+1):>par( j, i , !) , _, par( j, n-i-1,!);
noise(i) = (noiseChan(N+1,i) + 1) / 2; //to get nth channel of multi-channel noiser (not quite sure how)
// PROCESS //
process = _ <: par(i, N, buffer(int(bufferCounter), int(grainCounter(i)+ grainRandomStartPos(i)), _) * window(i) * Volume * (i < N) / N) :> _ <: _, _;
| https://raw.githubusercontent.com/luuuucaaa/faustGranulator/161bed38e164ba69726a91575597468ba2a5f1a0/granulator_v2_3.dsp | faust | USER INTERFACE //
volume slider
grain size in samples
delay length in samples
pitch control/ downsampling
CODE //
samplerate in samples per second
numbers of grains
size of input buffer in samples
counter to cycle through the input buffer from 0 to bufferSize
set delay length with delay length slider
size of grainbuffer in samples
counter to cycle through the grains from 0 to grainSize
sample and hold function definiton for grain offset
delay length between grainbuffer refresh
grain-specific grain counter
function definition of cycling buffer
window function
NOISE GENERATOR //
max number of random number generatorn
pseudo random number generator
to get nth channel of multi-channel noiser (not quite sure how)
PROCESS // |
Volume = volumeSlider;
grainRandomStartPos(i) = int(SH(int(grainCounter(i)/(grainbufferSize-1)),int(delayLength*noise(i))));
polyRandom(n) = scramble(n) ~ _
with {
scramble (n) = scramble(1) <: scramble(n - 1), _;
};
polyNoise(n) = polyRandom(n) : par(i, n, /(RANDMAX));
noiseChan(n,0) = polyNoise(N+1):>_,par( j, n-1 , !);
noiseChan(n,i) = polyNoise(N+1):>par( j, i , !) , _, par( j, n-i-1,!);
process = _ <: par(i, N, buffer(int(bufferCounter), int(grainCounter(i)+ grainRandomStartPos(i)), _) * window(i) * Volume * (i < N) / N) :> _ <: _, _;
|
407552ed33e5396952ede91fc3a27790eb2f4927a4f379ea9275e92f8ee8669f | HexHive/datAFLow | bug-221107.dsp | import("music.lib");
//--------------------------------
// bug du 22-nov-2007 (Christophe)
//--------------------------------
T1(index) = rdtable(10000, sin(time/100), int(index*100)); //Low cpu cost sine calculation
T2(index) = rdtable(1000, pow(2,(time/100)), int(index*100));
s1 = hslider("slider1",0, 0, 100, 1);
s2 = hslider("slider2",0, 0, 100, 1);
process = T1(s1), T2(s2);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/bug-221107.dsp | faust | --------------------------------
bug du 22-nov-2007 (Christophe)
--------------------------------
Low cpu cost sine calculation | import("music.lib");
T2(index) = rdtable(1000, pow(2,(time/100)), int(index*100));
s1 = hslider("slider1",0, 0, 100, 1);
s2 = hslider("slider2",0, 0, 100, 1);
process = T1(s1), T2(s2);
|
e52c7640ce957156534e18e95ec00a41df0053db041e5632c5e5ea50d2f1dfb7 | HexHive/datAFLow | clipped_samplerate.dsp | import("math.lib");
process = _,(SR:float):@;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/clipped_samplerate.dsp | faust | import("math.lib");
process = _,(SR:float):@;
|
|
441494c277ed8b55bf7a4f3aa3666627fc2089cac09064bbf6f49a8b4a25f0d2 | HexHive/datAFLow | vumeter.dsp | declare name "vumeter";
declare version "1.0";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2006";
//-------------------------------------------------
// Simple vumeter
//-------------------------------------------------
import("math.lib");
import("music.lib");
vmeter(x) = attach(x, envelop(x) : vbargraph("[2][unit:dB]", -70, +5));
hmeter(x) = attach(x, envelop(x) : hbargraph("[2][unit:dB]", -70, +5));
envelop = abs : max ~ -(1.0/SR) : max(db2linear(-70)) : linear2db;
process = hmeter, hmeter;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/vumeter.dsp | faust | -------------------------------------------------
Simple vumeter
------------------------------------------------- | declare name "vumeter";
declare version "1.0";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2006";
import("math.lib");
import("music.lib");
vmeter(x) = attach(x, envelop(x) : vbargraph("[2][unit:dB]", -70, +5));
hmeter(x) = attach(x, envelop(x) : hbargraph("[2][unit:dB]", -70, +5));
envelop = abs : max ~ -(1.0/SR) : max(db2linear(-70)) : linear2db;
process = hmeter, hmeter;
|
b4937080d138842538a6188a794760c89251aa1721e12c2a25af2aa86120e485 | HexHive/datAFLow | sharedelays.dsp | import("music.lib");
process = _ <: delay1s(200), delay1s(300) : +;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/sharedelays.dsp | faust | import("music.lib");
process = _ <: delay1s(200), delay1s(300) : +;
|
|
da34e539d00b44a46f0572e6cbe4dcecfea18385231fa2de165059521133b99a | HexHive/datAFLow | osci.dsp | declare name "osci";
declare version "1.0";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2009";
//-----------------------------------------------
// Sinusoidal Oscillator
// (with linear interpolation)
//-----------------------------------------------
import("music.lib");
smooth(c) = *(1-c) : +~*(c);
vol = hslider("volume [unit:dB]", 0, -96, 0, 0.1) : db2linear : smooth(0.999) ;
freq = hslider("freq [unit:Hz]", 564, 20, 24000, 1);
process = vgroup("Oscillator", osci(freq) * vol);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/osci.dsp | faust | -----------------------------------------------
Sinusoidal Oscillator
(with linear interpolation)
----------------------------------------------- | declare name "osci";
declare version "1.0";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2009";
import("music.lib");
smooth(c) = *(1-c) : +~*(c);
vol = hslider("volume [unit:dB]", 0, -96, 0, 0.1) : db2linear : smooth(0.999) ;
freq = hslider("freq [unit:Hz]", 564, 20, 24000, 1);
process = vgroup("Oscillator", osci(freq) * vol);
|
c6181eb84f38b003ae3abc8e061df671edf64ff1ea0344d144249833552aa9dd | HexHive/datAFLow | test14.dsp |
process = (+ <: _, cos)~ sin : _,!; | https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/test14.dsp | faust |
process = (+ <: _, cos)~ sin : _,!; |
|
24e81bddbaf2d9f8945f89a0990a319480ae8bd5f51ddfe12e0a248498b55ac5 | HexHive/datAFLow | tp2.dsp | // error detection
process = nentry("part",0, -10, 10, 1), +(1)~_ : soundfile("tango.wav",4);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/tp2.dsp | faust | error detection |
process = nentry("part",0, -10, 10, 1), +(1)~_ : soundfile("tango.wav",4);
|
4c1f30ea2c13e5e00258382c265ddfca919cfc97c372349b6b2b405ee9a7896f | HexHive/datAFLow | fst.granulator.dsp | //---------------------------- Granulator ------------------------------
import("music.lib");
//------------------------------------------------------------------
smooth(c) = *(1-c) : +~*(c);
square(x) = x*x;
noise2 = (+(12342) ~ *(1123915245))/RANDMAX;
noise3 = (+(12345) ~ *(1094789245))/RANDMAX;
noise4 = (+(12312) ~ *(1103195245))/RANDMAX;
//------------------------ User interface -----------------------
size = nentry("1 grainsize",200,0.001,10000,1)*(44.1): smooth(0.99);
sizevariation = fmin(nentry("2 sizevariation",20,0,5000,1)*(44.1),size-2): smooth(0.99);
separation = nentry("3 grainseparation",200,0,10000,1)*(44.1) : smooth(0.99);
separationvariation = fmin(nentry("4 ratevariation",20,0,5000,1)*(44.1),separation-2): smooth(0.99);
pitch = nentry("5 pitch (semitones)", 0,-30,30,0.01): smooth(0.99);
pitchvariation = nentry("6 pitchvariation",0,0,30,0.01): smooth(0.99);
spread = nentry("7 stereospread",0.5,0,1,0.01): smooth(0.99);
fixdelay = nentry("8 fixdelay",0,0,1000,1)*(44.1) : smooth(0.99);
delayrange = nentry("9 delay range", 0,0,1000,1)*(44.1) : smooth(0.99);
//------------------ Random variations calculation --------------
Sample(sig,selector,y) = select2(int(selector), y, sig); //SnH Gives a random value when selector=1 and keeps it while selector=0
SnH(sig) = Sample(sig,select)~_ : smooth(0.9995) ; //Usefull to calculate random grain and silence durations
calc(y) = ((+(1)*(y<size+sizevariation+separation+separationvariation))~_ );
calculate = calc~_;
select = calculate==0; //Selector for SnH, to give a new value at each grain
//------------------- Grain and silence durations --------------
grainsize(sig1) = size + SnH(sig1)*(sizevariation);
grainseparation(sig2) = separation + SnH(sig2)*(separationvariation);
//------------------- Counters,Window and Grain ----------------
//Loop counts form 0 to grainsize+grainseparation
counter(sig1,sig2) = count(sig1,sig2)~_
with {
count(sig1,sig2,y) = ((+(1)*(y<grainsize(sig1)+grainseparation(sig2)))~_ );
};
playgrain(sig1,sig2) = (counter(sig1,sig2) < grainsize(sig1));
windowcount(sig1,sig2) = (counter(sig1,sig2))*(playgrain(sig1,sig2));
TABLESIN(index) = rdtable(10000, sin(time/100), int(index*100)); //Low cpu cost sine calculation
window(sig1,sig2) = square(TABLESIN(PI*(windowcount(sig1,sig2)/grainsize(sig1))));
//---------------------- pitch-shifter -------------------------
positivepow(index) = rdtable(1000, pow(2,(time/100)), int(index*100));
POWER2(index) = select2(index<0,positivepow(index),1/positivepow(fabs(index)));
transpose (w, x, s, sig) = fdelay1s(d,sig)*fmin(d/x,1) + fdelay1s(d+w,sig)*(1-fmin(d/x,1))
with { i = 1 - POWER2(s/12);
d = i : (+ : +(w) : fmod(_,w)) ~ _; };
grain(sig1,sig2,sig3,x) = x : *(window(sig1,sig2)) : transpose(4000,1000,pitch+SnH(sig3)*(pitchvariation));
//-------------------------- Stereo spread -------------------
stereospread(sig1,sig2) = _ <: *(1-fabs(SnH(sig1*(spread)))),*(1-fabs(SnH(sig2*(spread)))); //random panoramic
delayedpart = fdelay1s(fixdelay+SnH((noise+1.1)/(2))*delayrange:smooth(0.999)) : stereospread(noise3,noise4);
realtimepart = stereospread(noise,noise2);
granulation(x) = x : grain(noise3,noise2,noise) <: realtimepart,delayedpart :> _,_ ;
process = hgroup("Granulator",granulation);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/fst.granulator.dsp | faust | ---------------------------- Granulator ------------------------------
------------------------------------------------------------------
------------------------ User interface -----------------------
------------------ Random variations calculation --------------
SnH Gives a random value when selector=1 and keeps it while selector=0
Usefull to calculate random grain and silence durations
Selector for SnH, to give a new value at each grain
------------------- Grain and silence durations --------------
------------------- Counters,Window and Grain ----------------
Loop counts form 0 to grainsize+grainseparation
Low cpu cost sine calculation
---------------------- pitch-shifter -------------------------
-------------------------- Stereo spread -------------------
random panoramic |
import("music.lib");
smooth(c) = *(1-c) : +~*(c);
square(x) = x*x;
noise2 = (+(12342) ~ *(1123915245))/RANDMAX;
noise3 = (+(12345) ~ *(1094789245))/RANDMAX;
noise4 = (+(12312) ~ *(1103195245))/RANDMAX;
size = nentry("1 grainsize",200,0.001,10000,1)*(44.1): smooth(0.99);
sizevariation = fmin(nentry("2 sizevariation",20,0,5000,1)*(44.1),size-2): smooth(0.99);
separation = nentry("3 grainseparation",200,0,10000,1)*(44.1) : smooth(0.99);
separationvariation = fmin(nentry("4 ratevariation",20,0,5000,1)*(44.1),separation-2): smooth(0.99);
pitch = nentry("5 pitch (semitones)", 0,-30,30,0.01): smooth(0.99);
pitchvariation = nentry("6 pitchvariation",0,0,30,0.01): smooth(0.99);
spread = nentry("7 stereospread",0.5,0,1,0.01): smooth(0.99);
fixdelay = nentry("8 fixdelay",0,0,1000,1)*(44.1) : smooth(0.99);
delayrange = nentry("9 delay range", 0,0,1000,1)*(44.1) : smooth(0.99);
calc(y) = ((+(1)*(y<size+sizevariation+separation+separationvariation))~_ );
calculate = calc~_;
grainsize(sig1) = size + SnH(sig1)*(sizevariation);
grainseparation(sig2) = separation + SnH(sig2)*(separationvariation);
counter(sig1,sig2) = count(sig1,sig2)~_
with {
count(sig1,sig2,y) = ((+(1)*(y<grainsize(sig1)+grainseparation(sig2)))~_ );
};
playgrain(sig1,sig2) = (counter(sig1,sig2) < grainsize(sig1));
windowcount(sig1,sig2) = (counter(sig1,sig2))*(playgrain(sig1,sig2));
window(sig1,sig2) = square(TABLESIN(PI*(windowcount(sig1,sig2)/grainsize(sig1))));
positivepow(index) = rdtable(1000, pow(2,(time/100)), int(index*100));
POWER2(index) = select2(index<0,positivepow(index),1/positivepow(fabs(index)));
transpose (w, x, s, sig) = fdelay1s(d,sig)*fmin(d/x,1) + fdelay1s(d+w,sig)*(1-fmin(d/x,1))
with { i = 1 - POWER2(s/12);
d = i : (+ : +(w) : fmod(_,w)) ~ _; };
grain(sig1,sig2,sig3,x) = x : *(window(sig1,sig2)) : transpose(4000,1000,pitch+SnH(sig3)*(pitchvariation));
delayedpart = fdelay1s(fixdelay+SnH((noise+1.1)/(2))*delayrange:smooth(0.999)) : stereospread(noise3,noise4);
realtimepart = stereospread(noise,noise2);
granulation(x) = x : grain(noise3,noise2,noise) <: realtimepart,delayedpart :> _,_ ;
process = hgroup("Granulator",granulation);
|
89ae147972d2d53f0fce7139e5b880fd3a4a5edfb6c0f62e6e47ff028529300c | HexHive/datAFLow | phaser_flanger.dsp | ol = library("oscillator.lib");
fl = library("filter.lib");
el = library("effect.lib");
//process = ol.sawtooth_demo <:
// el.flanger_demo : el.phaser2_demo :> fl.spectral_level_demo <: _,_;
fx_stack =
vgroup("[1]", ol.sawtooth_demo) <:
vgroup("[2]", el.flanger_demo) :
vgroup("[3]", el.phaser2_demo);
level_viewer(x,y) = attach(x,vgroup("[4]", fl.spectral_level_demo(x+y))),y;
process = fx_stack : level_viewer;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/phaser_flanger.dsp | faust | process = ol.sawtooth_demo <:
el.flanger_demo : el.phaser2_demo :> fl.spectral_level_demo <: _,_; | ol = library("oscillator.lib");
fl = library("filter.lib");
el = library("effect.lib");
fx_stack =
vgroup("[1]", ol.sawtooth_demo) <:
vgroup("[2]", el.flanger_demo) :
vgroup("[3]", el.phaser2_demo);
level_viewer(x,y) = attach(x,vgroup("[4]", fl.spectral_level_demo(x+y))),y;
process = fx_stack : level_viewer;
|
26b65b3c1565d5388d4dca6a015de700d4aba6b9b8022d932cf25358ae589883 | HexHive/datAFLow | good.dsp | process = 0.01 : (+,1.0:fmod)~_;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/good.dsp | faust | process = 0.01 : (+,1.0:fmod)~_;
|
|
681e6f5c51effd57e8ced7a5f78e79e37108e504135617da763d1068d26a60c3 | HexHive/datAFLow | lowboost.dsp | declare name "lowboost";
declare version "1.0";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2006";
//------------------------------------------------------------------
// DAFX, Digital Audio Effects (Wiley ed.)
// chapter 2 : filters
// section 2.3 : Equalizers
// page 53 : second order shelving filter design
//------------------------------------------------------------------
import("music.lib");
//------------------- low-frequency shelving boost (table 2.3) --------------------
V0(g) = pow(10,g/20.0);
K(fc) = tan(PI*fc/SR);
square(x) = x*x;
denom(fc) = 1 + sqrt(2)*K(fc) + square(K(fc));
lfboost(fc, g) = TF2( (1 + sqrt(2*V0(g))*K(fc) + V0(g)*square(K(fc))) / denom(fc),
2 * (V0(g)*square(K(fc)) - 1) / denom(fc),
(1 - sqrt(2*V0(g))*K(fc) + V0(g)*square(K(fc))) / denom(fc),
2 * (square(K(fc)) - 1) / denom(fc),
(1 - sqrt(2)*K(fc) + square(K(fc))) / denom(fc)
);
//------------------------------ User Interface -----------------------------------
freq = hslider("[1]freq [unit:Hz][style:knob]", 1000, 20, 20000, 0.1);
gain = hslider("[2]gain [unit:dB][style:knob]", 0, -20, 20, 0.1);
//----------------------------------- Process -------------------------------------
process = vgroup("low-freq shelving boost", lfboost(freq,gain));
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/lowboost.dsp | faust | ------------------------------------------------------------------
DAFX, Digital Audio Effects (Wiley ed.)
chapter 2 : filters
section 2.3 : Equalizers
page 53 : second order shelving filter design
------------------------------------------------------------------
------------------- low-frequency shelving boost (table 2.3) --------------------
------------------------------ User Interface -----------------------------------
----------------------------------- Process ------------------------------------- | declare name "lowboost";
declare version "1.0";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2006";
import("music.lib");
V0(g) = pow(10,g/20.0);
K(fc) = tan(PI*fc/SR);
square(x) = x*x;
denom(fc) = 1 + sqrt(2)*K(fc) + square(K(fc));
lfboost(fc, g) = TF2( (1 + sqrt(2*V0(g))*K(fc) + V0(g)*square(K(fc))) / denom(fc),
2 * (V0(g)*square(K(fc)) - 1) / denom(fc),
(1 - sqrt(2*V0(g))*K(fc) + V0(g)*square(K(fc))) / denom(fc),
2 * (square(K(fc)) - 1) / denom(fc),
(1 - sqrt(2)*K(fc) + square(K(fc))) / denom(fc)
);
freq = hslider("[1]freq [unit:Hz][style:knob]", 1000, 20, 20000, 0.1);
gain = hslider("[2]gain [unit:dB][style:knob]", 0, -20, 20, 0.1);
process = vgroup("low-freq shelving boost", lfboost(freq,gain));
|
102b47bcc55201de33376bc7a0227c55f75702d2d4cfbab5c962fe773b97ea5f | HexHive/datAFLow | waveform5.dsp | w1(x) = waveform {10,20,30,40,50},int(x):rdtable;
process = *(sin(w1(4*hslider("value",0,0,1,0.01)))), w1(4*hslider("value",0,0,1,0.01));
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/waveform5.dsp | faust | w1(x) = waveform {10,20,30,40,50},int(x):rdtable;
process = *(sin(w1(4*hslider("value",0,0,1,0.01)))), w1(4*hslider("value",0,0,1,0.01));
|
|
d0f11a47fc67a2a8f63a7bbf489382fc407d4c61f4a72ad5f7b637ff626141f7 | HexHive/datAFLow | test7.dsp | fii(x) = (x+x')/2;
foo = +~sin;
faa = +~sin;
process = +~fii : mem : mem;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/test7.dsp | faust | fii(x) = (x+x')/2;
foo = +~sin;
faa = +~sin;
process = +~fii : mem : mem;
|
|
4129841a59afaf693078837a0c33fe4f5575f34cae487c870806f2764c481a2d | HexHive/datAFLow | error07.dsp | // WARNING : shadowed pattern-matching rule: (x) => x,3:*; previous rule was: (x) => x,2:*;
foo(x) = x*2;
foo(x) = x*3;
process = foo(10);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/error07.dsp | faust | WARNING : shadowed pattern-matching rule: (x) => x,3:*; previous rule was: (x) => x,2:*; |
foo(x) = x*2;
foo(x) = x*3;
process = foo(10);
|
df7a6c10ced54fccf1e9ff6bcb35ed16d5e8043b25257c5fb9ffd5a986fea523 | HexHive/datAFLow | dimensioncheck_1.dsp | process = vectorize(4):serialize;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/dimensioncheck_1.dsp | faust | process = vectorize(4):serialize;
|
|
55157ceeee9095a2d24429bd87b8c0186e592bb1034b28a3822e8def83f5d939 | HexHive/datAFLow | error27-tblsize-nonconst.dsp | import("music.lib");
foo(i) = rdtable(SR, time%6, i);
process = foo(time%128); | https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/error27-tblsize-nonconst.dsp | faust | import("music.lib");
foo(i) = rdtable(SR, time%6, i);
process = foo(time%128); |
|
3c3dce2d8fc240c64477eb6bd68010836a246e2acfd10a38554ad2aad9c8d7f2 | HexHive/datAFLow | badcpp.dsp | process = ffunction(float foof|foo|fool (float), <math.h>,"");
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/badcpp.dsp | faust | process = ffunction(float foof|foo|fool (float), <math.h>,"");
|
|
a07e5c4c6b4c5cdf5a217b175e28b87106aae2fc1c0a8e866a8ba91bfb285cfb | HexHive/datAFLow | mr_delay.dsp | process = vectorize(4):serialize:@(3);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/mr_delay.dsp | faust | process = vectorize(4):serialize:@(3);
|
|
6ac70644aaf28575ad3b3b033c2ae0965130fb6a9641fd3d347b2d1485496426 | HexHive/datAFLow | noise.dsp | declare name "Noise";
declare version "1.1";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2009";
//-----------------------------------------------------------------
// Noise generator and demo file for the Faust math documentation
//-----------------------------------------------------------------
<mdoc>
\section{Presentation of the "noise.dsp" Faust program}
This program describes a white noise generator with an interactive volume, using a random function.
\subsection{The random function}
The \texttt{random} function describes a generator of random numbers, which equation follows. You should notice hereby the use of an integer arithmetic on 32 bits, relying on integer wrapping for big numbers.
<equation>random</equation>
\subsection{The noise function}
The white noise then corresponds to:
<equation>noise</equation>
</mdoc>
random = +(12345)~*(1103515245);
noise = random/2147483647.0;
<mdoc>
\subsection{Just add a user interface element to play volume!}
Endly, the sound level of this program is controlled by a user slider, which gives the following equation:
<equation>process</equation>
</mdoc>
<mdoc>
\section{Block-diagram schema of process}
This process is illustrated on figure 1.
<diagram>process</diagram>
</mdoc>
process = noise * vslider("Volume[style:knob][acc: 0 0 -10 0 10]", 0.5, 0, 1, 0.1);
<mdoc>
\section{Notice of this documentation}
You might be careful of certain information and naming conventions used in this documentation:
<notice/>
\section{Listing of the input code}
The following listing shows the input Faust code, parsed to compile this mathematical documentation.
<listing/>
</mdoc>
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/noise.dsp | faust | -----------------------------------------------------------------
Noise generator and demo file for the Faust math documentation
----------------------------------------------------------------- | declare name "Noise";
declare version "1.1";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2009";
<mdoc>
\section{Presentation of the "noise.dsp" Faust program}
This program describes a white noise generator with an interactive volume, using a random function.
\subsection{The random function}
The \texttt{random} function describes a generator of random numbers, which equation follows. You should notice hereby the use of an integer arithmetic on 32 bits, relying on integer wrapping for big numbers.
<equation>random</equation>
\subsection{The noise function}
The white noise then corresponds to:
<equation>noise</equation>
</mdoc>
random = +(12345)~*(1103515245);
noise = random/2147483647.0;
<mdoc>
\subsection{Just add a user interface element to play volume!}
Endly, the sound level of this program is controlled by a user slider, which gives the following equation:
<equation>process</equation>
</mdoc>
<mdoc>
\section{Block-diagram schema of process}
This process is illustrated on figure 1.
<diagram>process</diagram>
</mdoc>
process = noise * vslider("Volume[style:knob][acc: 0 0 -10 0 10]", 0.5, 0, 1, 0.1);
<mdoc>
\section{Notice of this documentation}
You might be careful of certain information and naming conventions used in this documentation:
<notice/>
\section{Listing of the input code}
The following listing shows the input Faust code, parsed to compile this mathematical documentation.
<listing/>
</mdoc>
|
ca9c07de38272ab298babf05c6d1aeb7ba51c349bd8262a27da1b8f4ca335313 | HexHive/datAFLow | parabolic-env6.dsp | //-----------------------------------------------
//
// Parabolic Grain Envelop : from Ross Bencina
//
//-----------------------------------------------
import("music.lib");
//----------------------------------------------------------------------
// RINTEGRATE : Resetable integrator
// It integrates the values of x : 0, x(0), x(0)+x(1), x(0)+x(1)+x(2),...
// The integration is controled by a boolean <onoff> signal. When
// <onoff> is 1, values are integrated. When <onoff> is 0, the integration
// is stopped and the output value is reset to 0
//----------------------------------------------------------------------
rintegrate(onoff) = (+:*(onoff))~_ : mem;
//----------------------------------------------------------------------
// INTEGRATE : signal integrator
// It integrates the values of x : 0, x(0), x(0)+x(1), x(0)+x(1)+x(2),...
// The implementation is based on rintegrate with an onoff signal always
// on (i.e. 1).
//----------------------------------------------------------------------
integrate = rintegrate(1);
//----------------------------------------------------------------------
// Trigable Parabolic Grain Envelop :
// Multiply the incoming signal <sig> with a parabolic envelop of duration
// <sdur> samples and of amplitude <gamp>. The envelop is controled by a
// trigger boolean signal <trig>. An envelop is trigged when the <trig>
// become 1. Once trigged the envelop will continue until the end before
// being retriggable
//----------------------------------------------------------------------
grainenv(sdur, gamp, trig, sig) = (_|trig|trig' : amplitude : max(0)) ~ >(0) : *(sig)
with {
rdur = 1.0/sdur;
rdur2 = rdur*rdur;
curve = -8.0 * gamp * rdur2;
slope(on) = 4 * gamp * (rdur - rdur2) + rintegrate(on,curve);
amplitude(on) = rintegrate(on, slope(on));
};
//----------------------------------------------------------------------
// A grain
// <id> is the value that must be used by sel to trig the grain
// <po> is the delay (in samples) on the input signal
// <sdur> is the duration of the grain (in samples)
// <gamp> is the amplitude of the grain
// <sel> is the selection signal used to trig the grain. The grain is
// trigged when <sel> == <id>
// <sig> is the audio signal to process
//----------------------------------------------------------------------
grain(id, pos, sdur, gamp, sel, sig)
= sig : delay10s(pos) : grainenv(sdur, gamp, (sel==id));
trig = (integrate(1) % 7 == 3);
selector_ = integrate(1) % 7;
//process = integrate(1), slope(trig), max(0.0,bidule(trig));
//process = integrate(1), trig, grainenv(10, 2.8, trig, 1);
process = integrate(1), trig, grain(3, 2, 10, 1, selector_, integrate(1));
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/parabolic-env6.dsp | faust | -----------------------------------------------
Parabolic Grain Envelop : from Ross Bencina
-----------------------------------------------
----------------------------------------------------------------------
RINTEGRATE : Resetable integrator
It integrates the values of x : 0, x(0), x(0)+x(1), x(0)+x(1)+x(2),...
The integration is controled by a boolean <onoff> signal. When
<onoff> is 1, values are integrated. When <onoff> is 0, the integration
is stopped and the output value is reset to 0
----------------------------------------------------------------------
----------------------------------------------------------------------
INTEGRATE : signal integrator
It integrates the values of x : 0, x(0), x(0)+x(1), x(0)+x(1)+x(2),...
The implementation is based on rintegrate with an onoff signal always
on (i.e. 1).
----------------------------------------------------------------------
----------------------------------------------------------------------
Trigable Parabolic Grain Envelop :
Multiply the incoming signal <sig> with a parabolic envelop of duration
<sdur> samples and of amplitude <gamp>. The envelop is controled by a
trigger boolean signal <trig>. An envelop is trigged when the <trig>
become 1. Once trigged the envelop will continue until the end before
being retriggable
----------------------------------------------------------------------
----------------------------------------------------------------------
A grain
<id> is the value that must be used by sel to trig the grain
<po> is the delay (in samples) on the input signal
<sdur> is the duration of the grain (in samples)
<gamp> is the amplitude of the grain
<sel> is the selection signal used to trig the grain. The grain is
trigged when <sel> == <id>
<sig> is the audio signal to process
----------------------------------------------------------------------
process = integrate(1), slope(trig), max(0.0,bidule(trig));
process = integrate(1), trig, grainenv(10, 2.8, trig, 1); |
import("music.lib");
rintegrate(onoff) = (+:*(onoff))~_ : mem;
integrate = rintegrate(1);
grainenv(sdur, gamp, trig, sig) = (_|trig|trig' : amplitude : max(0)) ~ >(0) : *(sig)
with {
rdur = 1.0/sdur;
rdur2 = rdur*rdur;
curve = -8.0 * gamp * rdur2;
slope(on) = 4 * gamp * (rdur - rdur2) + rintegrate(on,curve);
amplitude(on) = rintegrate(on, slope(on));
};
grain(id, pos, sdur, gamp, sel, sig)
= sig : delay10s(pos) : grainenv(sdur, gamp, (sel==id));
trig = (integrate(1) % 7 == 3);
selector_ = integrate(1) % 7;
process = integrate(1), trig, grain(3, 2, 10, 1, selector_, integrate(1));
|
fc54b08e69077804554f9991dba78988f7ab70578c8e4bf1f9f556ffe78e2b2c | HexHive/datAFLow | sound.dsp |
process = 0,_~+(1):soundfile("son[url:{'sound1';'sound2'}]",4):!,!,_,_,_,_;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/sound.dsp | faust |
process = 0,_~+(1):soundfile("son[url:{'sound1';'sound2'}]",4):!,!,_,_,_,_;
|
|
ac35c8322f08f19d622c59e2b5d9ec2cc9fcbc400803b4a16add0fc400155779 | HexHive/datAFLow | castsimplify.dsp | // check that redondant cast are removed from the code
process = (int : int), float, float(hslider("foo", 0, 0, 10, 1));
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/castsimplify.dsp | faust | check that redondant cast are removed from the code | process = (int : int), float, float(hslider("foo", 0, 0, 10, 1));
|
548646eefe32b9e0d0e687444736a7ae1adab3d5578b7cd4c1333ed4e272b1df | HexHive/datAFLow | rateconflict_2.dsp | up2 = vectorize(1) <: # : serialize;
dw2 = vectorize(2) : [0];
up4 = up2:up2;
dw4 = vectorize(4) : [0];
process = up2 ~ ( (up4~dw2) : dw2); | https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/rateconflict_2.dsp | faust | up2 = vectorize(1) <: # : serialize;
dw2 = vectorize(2) : [0];
up4 = up2:up2;
dw4 = vectorize(4) : [0];
process = up2 ~ ( (up4~dw2) : dw2); |
|
c839f17490d3cb55cdbb587b2aa55b402360ef7661b06d7564dbd84f001ef433 | HexHive/datAFLow | PM-bug20.dsp | // replace
replace (x,y,(u:v)) = replace(x,y,u) : replace(x,y,v);
replace (x,y,(u,v)) = replace(x,y,u) , replace(x,y,v);
replace (x,y,(u<:v)) = replace(x,y,u) <: replace(x,y,v);
replace (x,y,(u:>v)) = replace(x,y,u) :> replace(x,y,v);
replace (x,y,(u~v)) = replace(x,y,u) ~ replace(x,y,v);
replace (x,y,x) = y;
replace (x,y,u) = u;
process = replace(1,2,(0,0,1,0,1));
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/PM-bug20.dsp | faust | replace |
replace (x,y,(u:v)) = replace(x,y,u) : replace(x,y,v);
replace (x,y,(u,v)) = replace(x,y,u) , replace(x,y,v);
replace (x,y,(u<:v)) = replace(x,y,u) <: replace(x,y,v);
replace (x,y,(u:>v)) = replace(x,y,u) :> replace(x,y,v);
replace (x,y,(u~v)) = replace(x,y,u) ~ replace(x,y,v);
replace (x,y,x) = y;
replace (x,y,u) = u;
process = replace(1,2,(0,0,1,0,1));
|
c5e706574bc2fb545e06e336f0c7ea45b1dcbee21fe8e75d1b5dff0a3642b13b | HexHive/datAFLow | testif1.dsp | // Test real if
if(c,t,e) = select2(c,e,t);
process(x) = if(x<0, 0, x) : abs;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/testif1.dsp | faust | Test real if | if(c,t,e) = select2(c,e,t);
process(x) = if(x<0, 0, x) : abs;
|
599bdb2cd571e8ad525b0bc29034f8e1fab744b1567aae7871b8b88ce53a3d79 | HexHive/datAFLow | numsimplerr6.dsp | process = 0,0 : sin;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/numsimplerr6.dsp | faust | process = 0,0 : sin;
|
|
1b3c6165c67638f4d632a1074fbb563bf12e482d03362c35c603ec150970c751 | HexHive/datAFLow | karplus32.dsp | declare name "karplus32";
declare version "1.0";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2006";
//-----------------------------------------------
// karplus-strong
// with 32 resonators in parallel
//-----------------------------------------------
import("music.lib");
// Excitator
//--------
upfront(x) = (x-x') > 0.0;
decay(n,x) = x - (x>0)/n;
release(n) = + ~ decay(n);
trigger(n) = upfront : release(n) : >(0.0) : +(leak);
leak = 1.0/65536.0;
size = hslider("excitation (samples)", 128, 2, 512, 1);
// Resonator
//-----------------
dur = hslider("duration (samples)", 128, 2, 512, 1);
att = hslider("attenuation", 0, 0, 1, 0.01);
average(x) = (x+x')/2;
resonator(d, a) = (+ : delay(4096, d-1.5)) ~ (average : *(1.0-a)) ;
// Polyphony
//-----------------
detune = hslider("detune", 37.9904, 0, 512, 1);
polyphony = hslider("polyphony", 14, 0, 32, 1);
output = hslider("output volume", 0.4866, 0, 1, 0.1);
process = vgroup("karplus32",
vgroup("noise generator", noise * hslider("level", 0.5, 0, 1, 0.1))
: vgroup("excitator", *(button("play"): trigger(size)))
<: vgroup("resonator x32", par(i,32, resonator(dur+i*detune, att) * (polyphony > i)))
:> *(output),*(output)
); | https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/karplus32.dsp | faust | -----------------------------------------------
karplus-strong
with 32 resonators in parallel
-----------------------------------------------
Excitator
--------
Resonator
-----------------
Polyphony
----------------- | declare name "karplus32";
declare version "1.0";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2006";
import("music.lib");
upfront(x) = (x-x') > 0.0;
decay(n,x) = x - (x>0)/n;
release(n) = + ~ decay(n);
trigger(n) = upfront : release(n) : >(0.0) : +(leak);
leak = 1.0/65536.0;
size = hslider("excitation (samples)", 128, 2, 512, 1);
dur = hslider("duration (samples)", 128, 2, 512, 1);
att = hslider("attenuation", 0, 0, 1, 0.01);
average(x) = (x+x')/2;
resonator(d, a) = (+ : delay(4096, d-1.5)) ~ (average : *(1.0-a)) ;
detune = hslider("detune", 37.9904, 0, 512, 1);
polyphony = hslider("polyphony", 14, 0, 32, 1);
output = hslider("output volume", 0.4866, 0, 1, 0.1);
process = vgroup("karplus32",
vgroup("noise generator", noise * hslider("level", 0.5, 0, 1, 0.1))
: vgroup("excitator", *(button("play"): trigger(size)))
<: vgroup("resonator x32", par(i,32, resonator(dur+i*detune, att) * (polyphony > i)))
:> *(output),*(output)
); |
6bb3020e57612bbf5fedfbff986c7f0ad56514ecb07b4777234b3ccc974f9396 | HexHive/datAFLow | test2.dsp | import("music.lib");
process = TF2(1.25,1.73,1,1.73,1);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/test2.dsp | faust | import("music.lib");
process = TF2(1.25,1.73,1,1.73,1);
|
|
01da2bbb8ebf99d9da409543a084bd528c98fbab6ca696c58be11afde8c4baea | HexHive/datAFLow | midi_tester.dsp | declare name "Faust Midi Tester";
declare version "1.0";
declare author "Vincent Rateau, GRAME";
declare license "GPL v3";
declare reference "www.sonejo.net";
// FAUST MIDI TESTER
process = _*0, (vgroup("FAUST MIDI TESTER", hgroup("[1]", controltester, noteontester, noteofftester, midiclocktester), hgroup("[2]", kattester, pctester, chattester, pitchwheeltester) :> _)) : attach;
///////////////////////////
//Ctrl tester (ctrl ): tester(midi in, midi out)
controltester = vgroup("CTRL IN/OUT", valuetest(50,51), booltest(100,101))
with{
valuetest(i,o) = hslider("Ctrl Value IN (Ctrl %i) [midi:ctrl %i]", 60, 0, 127, 1) : hbargraph("Ctrl Value OUT (Ctrl %o) [midi:ctrl %o]", 0, 127);
booltest(i,o) = checkbox("Ctrl Bool IN (Ctrl %i) [midi:ctrl %i]") : hbargraph("Ctrl Bool OUT (Ctrl %o) [midi:ctrl %o]", 0, 1);
};
//Note tester (keyon) : tester(midi in, midi out)
noteontester = vgroup("NOTE ON IN/OUT", valuetest(50,51), booltest(100,101))
with{
valuetest(i,o) = hslider("NoteOn Value IN (Note %i) [midi:keyon %i]", 60, 0, 127, 1) : hbargraph("NoteOn Value OUT (Note %o) [midi:keyon %o]", 0, 127);
booltest(i,o) = checkbox("NoteOn Bool IN (Note %i) [midi:keyon %i]") : hbargraph("NoteOn Bool OUT (Note %o) [midi:keyon %o]", 0, 1);
};
//Note tester (keyoff) : tester(midi in, midi out)
noteofftester = vgroup("NOTE OFF IN/OUT", valuetest(50,51), booltest(100,101))
with{
valuetest(i,o) = hslider("NoteOff Value IN (Note %i) [midi:keyoff %i]", 60, 0, 127, 1) : hbargraph("NoteOff Value OUT (Note %o) [midi:keyoff %o]", 0, 127);
booltest(i,o) = checkbox("NoteOff Bool IN (Note %i) [midi:keyoff %i]") : hbargraph("NoteOff Bool OUT (Note %o) [midi:keyoff %o]", 0, 1);
};
//Midisync tester
midiclocktester = vgroup("MIDI SYNC (IN)", clock, startstop)
with{
clock = checkbox("MIDI clock signal [midi:clock]");
startstop = checkbox("MIDI START/STOP [midi:start] [midi:stop]");
};
//Key Aftertouch tester (keypress) : tester(midi in, midi out)
kattester = vgroup("KEY AFTERTOUCH (KAT) IN/OUT",valuetest(50,51), booltest(100,101))
with{
valuetest(i,o) = hslider("Note KAT Value IN (Note %i) [midi:keypress %i]", 60, 0, 127, 1) : hbargraph("Note KAT Value OUT (Note %o) [midi:keypress %o]", 0, 127);
booltest(i,o) = checkbox("Note KAT Bool IN (Note %i) [midi:keypress %i]") : hbargraph("Note KAT Bool OUT (Note %o) [midi:keypress %o]", 0, 1);
};
//ProgramChange tester (pgm) : tester(midi in, midi out)
pctester = vgroup("PROGRAM CHANGE (PC) IN/OUT",valuetest(50,51), booltest(100,101))
with{
valuetest(i,o) = hslider("ProgramChange Value IN (PC %i) [midi:pgm %i]", 60, 0, 127, 1) : hbargraph("ProgramChange Value OUT (PC %o) [midi:pgm %o]", 0, 127);
booltest(i,o) = checkbox("ProgramChange Bool IN (PC %i) [midi:pgm %i]") : hbargraph("ProgramChange Bool OUT (PC %o) [midi:pgm %o]", 0, 1);
};
//Channel Aftertourch tester (chanpress) : tester(midi in, midi out)
chattester = vgroup("CHANNEL AFTERTOUCH (CHAT) IN/OUT",valuetest(50,51), booltest(100,101))
with{
valuetest(i,o) = hslider("Note CHAT Value IN (Note %i) [midi:chanpress %i]", 60, 0, 127, 1) : hbargraph("Note CHAT Value OUT (Note %o) [midi:chanpress %o]", 0, 127);
booltest(i,o) = checkbox("Note CHAT Bool IN (Note %i) [midi:chanpress %i]") : hbargraph("Note CHAT Bool OUT (Note %o) [midi:chanpress %o]", 0, 1);
};
//Pitchwheel tester (pitchwheel) : tester(midi in, midi out)
pitchwheeltester = vgroup("PITCHWHEEL IN/OUT",valuetest, booltest)
with{
valuetest = hslider("Pitchwheel Value IN [midi:pitchwheel]", 0, -8192, 8191, 1) : hbargraph("Pitchwheel Value OUT[midi:pitchwheel]", -8192, 8191);
booltest = checkbox("Pitchwheel Bool IN [midi:pitchwheel]") : hbargraph("Pitchwheel Bool OUT [midi:pitchwheel]", 0, 1);
};
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/midi_tester.dsp | faust | FAUST MIDI TESTER
/////////////////////////
Ctrl tester (ctrl ): tester(midi in, midi out)
Note tester (keyon) : tester(midi in, midi out)
Note tester (keyoff) : tester(midi in, midi out)
Midisync tester
Key Aftertouch tester (keypress) : tester(midi in, midi out)
ProgramChange tester (pgm) : tester(midi in, midi out)
Channel Aftertourch tester (chanpress) : tester(midi in, midi out)
Pitchwheel tester (pitchwheel) : tester(midi in, midi out) | declare name "Faust Midi Tester";
declare version "1.0";
declare author "Vincent Rateau, GRAME";
declare license "GPL v3";
declare reference "www.sonejo.net";
process = _*0, (vgroup("FAUST MIDI TESTER", hgroup("[1]", controltester, noteontester, noteofftester, midiclocktester), hgroup("[2]", kattester, pctester, chattester, pitchwheeltester) :> _)) : attach;
controltester = vgroup("CTRL IN/OUT", valuetest(50,51), booltest(100,101))
with{
valuetest(i,o) = hslider("Ctrl Value IN (Ctrl %i) [midi:ctrl %i]", 60, 0, 127, 1) : hbargraph("Ctrl Value OUT (Ctrl %o) [midi:ctrl %o]", 0, 127);
booltest(i,o) = checkbox("Ctrl Bool IN (Ctrl %i) [midi:ctrl %i]") : hbargraph("Ctrl Bool OUT (Ctrl %o) [midi:ctrl %o]", 0, 1);
};
noteontester = vgroup("NOTE ON IN/OUT", valuetest(50,51), booltest(100,101))
with{
valuetest(i,o) = hslider("NoteOn Value IN (Note %i) [midi:keyon %i]", 60, 0, 127, 1) : hbargraph("NoteOn Value OUT (Note %o) [midi:keyon %o]", 0, 127);
booltest(i,o) = checkbox("NoteOn Bool IN (Note %i) [midi:keyon %i]") : hbargraph("NoteOn Bool OUT (Note %o) [midi:keyon %o]", 0, 1);
};
noteofftester = vgroup("NOTE OFF IN/OUT", valuetest(50,51), booltest(100,101))
with{
valuetest(i,o) = hslider("NoteOff Value IN (Note %i) [midi:keyoff %i]", 60, 0, 127, 1) : hbargraph("NoteOff Value OUT (Note %o) [midi:keyoff %o]", 0, 127);
booltest(i,o) = checkbox("NoteOff Bool IN (Note %i) [midi:keyoff %i]") : hbargraph("NoteOff Bool OUT (Note %o) [midi:keyoff %o]", 0, 1);
};
midiclocktester = vgroup("MIDI SYNC (IN)", clock, startstop)
with{
clock = checkbox("MIDI clock signal [midi:clock]");
startstop = checkbox("MIDI START/STOP [midi:start] [midi:stop]");
};
kattester = vgroup("KEY AFTERTOUCH (KAT) IN/OUT",valuetest(50,51), booltest(100,101))
with{
valuetest(i,o) = hslider("Note KAT Value IN (Note %i) [midi:keypress %i]", 60, 0, 127, 1) : hbargraph("Note KAT Value OUT (Note %o) [midi:keypress %o]", 0, 127);
booltest(i,o) = checkbox("Note KAT Bool IN (Note %i) [midi:keypress %i]") : hbargraph("Note KAT Bool OUT (Note %o) [midi:keypress %o]", 0, 1);
};
pctester = vgroup("PROGRAM CHANGE (PC) IN/OUT",valuetest(50,51), booltest(100,101))
with{
valuetest(i,o) = hslider("ProgramChange Value IN (PC %i) [midi:pgm %i]", 60, 0, 127, 1) : hbargraph("ProgramChange Value OUT (PC %o) [midi:pgm %o]", 0, 127);
booltest(i,o) = checkbox("ProgramChange Bool IN (PC %i) [midi:pgm %i]") : hbargraph("ProgramChange Bool OUT (PC %o) [midi:pgm %o]", 0, 1);
};
chattester = vgroup("CHANNEL AFTERTOUCH (CHAT) IN/OUT",valuetest(50,51), booltest(100,101))
with{
valuetest(i,o) = hslider("Note CHAT Value IN (Note %i) [midi:chanpress %i]", 60, 0, 127, 1) : hbargraph("Note CHAT Value OUT (Note %o) [midi:chanpress %o]", 0, 127);
booltest(i,o) = checkbox("Note CHAT Bool IN (Note %i) [midi:chanpress %i]") : hbargraph("Note CHAT Bool OUT (Note %o) [midi:chanpress %o]", 0, 1);
};
pitchwheeltester = vgroup("PITCHWHEEL IN/OUT",valuetest, booltest)
with{
valuetest = hslider("Pitchwheel Value IN [midi:pitchwheel]", 0, -8192, 8191, 1) : hbargraph("Pitchwheel Value OUT[midi:pitchwheel]", -8192, 8191);
booltest = checkbox("Pitchwheel Bool IN [midi:pitchwheel]") : hbargraph("Pitchwheel Bool OUT [midi:pitchwheel]", 0, 1);
};
|
044cc99b88111b14be0d324082810fad955731593cc298f42660b78894c6a0d0 | HexHive/datAFLow | mr_cast.dsp | process = int:vectorize(4):serialize:float;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/mr_cast.dsp | faust | process = int:vectorize(4):serialize:float;
|
|
a92246f942a86d00850f2c1207e1e722feeb25eab2e676ab1be6c63a69550e27 | HexHive/datAFLow | uselessrec.dsp | process = *(3)~!;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/uselessrec.dsp | faust | process = *(3)~!;
|
|
8fdd1c261c270d2c80a721929783b949d23f5438dccd77745183922dba28c521 | HexHive/datAFLow | PM-bug17.dsp | // example of not very explicit error message
foo(x,y,y) = y*2;
foo(x,y,z) = y*3;
//process = 2:foo(1,2);
//process = foo(1,1,1), ((1,1) : (foo(1,1), foo(1,2)));
process = foo(1,1), foo(1,2);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/PM-bug17.dsp | faust | example of not very explicit error message
process = 2:foo(1,2);
process = foo(1,1,1), ((1,1) : (foo(1,1), foo(1,2))); |
foo(x,y,y) = y*2;
foo(x,y,z) = y*3;
process = foo(1,1), foo(1,2);
|
84295ea03ced1773f9bb9206779f98bcf8872f5717b00eed4801baa52ba19df0 | HexHive/datAFLow | shortdelays.dsp | // check short delay are correctly compiled
process = _ <: sum(i,4, @(i+4)/(i+1));
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/shortdelays.dsp | faust | check short delay are correctly compiled |
process = _ <: sum(i,4, @(i+4)/(i+1));
|
5f5f729494864445e9379dc0b325e9b1d60bbd076c2006df81ce473946a99753 | HexHive/datAFLow | delay01.dsp | // now @ accepts float delays converted to int automatically
process = @(7.3);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/delay01.dsp | faust | now @ accepts float delays converted to int automatically | process = @(7.3);
|
44dfac20dd191c37847c312fa3e09c45940545547c9af92440dffebdbc8e8237 | HexHive/datAFLow | testpow2.dsp | // Test real if
process(x) = 2*x^2 : /(x);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/testpow2.dsp | faust | Test real if |
process(x) = 2*x^2 : /(x);
|
be7243a6cbb6101cf7e35c31f5ac174f86063f04f82cf66a10caa71365eb3fcd | HexHive/datAFLow | karplus.dsp | declare name "karplus";
declare version "1.0";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2006";
//-----------------------------------------------
// karplus-strong
//-----------------------------------------------
import("music.lib");
// Excitator
//--------
upfront(x) = (x-x') > 0.0;
decay(n,x) = x - (x>0.0)/n;
release(n) = + ~ decay(n);
trigger(n) = upfront : release(n) : >(0.0);
size = hslider("excitation [unit:f]", 327.023, 2, 512, 1);
// resonator
//-----------------
dur = hslider("duration [unit:f]", 271.994, 2, 512, 1);
att = hslider("attenuation", 0, 0, 1, 0.01);
average(x) = (x+x')/2;
resonator(d, a) = (+ : delay(4096, d-1.5)) ~ (average : *(1.0-a));
process = noise * hslider("level", 0.5, 0, 1, 0.01)
: vgroup("excitator", *(button("play"): trigger(size)))
: vgroup("resonator", resonator(dur, att));
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/karplus.dsp | faust | -----------------------------------------------
karplus-strong
-----------------------------------------------
Excitator
--------
resonator
----------------- | declare name "karplus";
declare version "1.0";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2006";
import("music.lib");
upfront(x) = (x-x') > 0.0;
decay(n,x) = x - (x>0.0)/n;
release(n) = + ~ decay(n);
trigger(n) = upfront : release(n) : >(0.0);
size = hslider("excitation [unit:f]", 327.023, 2, 512, 1);
dur = hslider("duration [unit:f]", 271.994, 2, 512, 1);
att = hslider("attenuation", 0, 0, 1, 0.01);
average(x) = (x+x')/2;
resonator(d, a) = (+ : delay(4096, d-1.5)) ~ (average : *(1.0-a));
process = noise * hslider("level", 0.5, 0, 1, 0.01)
: vgroup("excitator", *(button("play"): trigger(size)))
: vgroup("resonator", resonator(dur, att));
|
b1e47556dda2e9d22cd11cdfdea4cd74117b4f3264a8a85ec1c00c72948542ac | HexHive/datAFLow | math.dsp | // Test of all math functions
import("math.lib");
singleprecision my_INFINITY = 3.402823466e+38;
doubleprecision my_INFINITY = 1.7976931348623158e+308;
quadprecision my_INFINITY = 1.7976931348623158e+308;
my_isnan = ffunction(int isnanf|isnan|isnanl (float),<math.h>,"");
my_isinf = ffunction(int isinff|isinf|isinfl (float),<math.h>,"");
process = ((2.0', 2', 2.0, 2) : par( i, 4, ^(31))),
_ >> _,
_ << _,
int(_*10.5) % 3,
_*10.5 % 3.0,
int(_*3.5) & int(_*2.4),
_*3.5 & _*2.4,
int(_*3.5) | int(_*2.4),
_*3.5 | _*2.4,
xor(int(_*3.5), int(_*2.4)),
xor(_*3.5, _*2.4),
int(_*3.5) ^ int(_*2.4),
_*3.5 ^ _*2.4,
int(_*3.5) > int(_*2.4),
_*3.5 > _*2.4,
int(_*3.5) >= int(_*2.4),
_*3.5 >= _*2.4,
int(_*3.5) < int(_*2.4),
_*3.5 < _*2.4,
int(_*3.5) <= int(_*2.4),
_*3.5 <= _*2.4,
int(_*3.5) == int(_*2.4),
_*3.5 == _*2.4,
int(_*3.5) != int(_*2.4),
_*3.5 != _*2.4,
abs(int(_*4.4)),
abs(int(_*-4.4)),
abs(_*4.4),
abs(_*-4.4),
acos(_*0.5),
asin(_*0.5),
atan(_*0.5),
atan2(_*0.5, 4.0),
ceil(_*1.3),
cos(_*0.3),
exp(_*0.5),
floor(_*6.5),
fmod(_*9.2, 2.0),
log((_+1)*0.5),
log10((_+1)*0.5),
max(_*0.5, _*0.4),
min(_*0.5, _*0.4),
max(int(_*3.5), int(_*2.4)),
min(int(_*3.5), int(_*2.4)),
pow(_*0.5, 0.3),
pow(_*0.5, 3),
pow(10, _*3),
remainder(_*9.2, 2.0),
rint(_*1.5),
sin(_*0.3),
sqrt(_*0.3),
tan(_*0.3),
acosh(10+_*0.3),
asinh(10+_*0.3),
atanh(0.5+_*0.3),
cosh(10+_*0.3),
sinh(10+_*0.3),
tanh(10+_*0.3);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/math.dsp | faust | Test of all math functions |
import("math.lib");
singleprecision my_INFINITY = 3.402823466e+38;
doubleprecision my_INFINITY = 1.7976931348623158e+308;
quadprecision my_INFINITY = 1.7976931348623158e+308;
my_isnan = ffunction(int isnanf|isnan|isnanl (float),<math.h>,"");
my_isinf = ffunction(int isinff|isinf|isinfl (float),<math.h>,"");
process = ((2.0', 2', 2.0, 2) : par( i, 4, ^(31))),
_ >> _,
_ << _,
int(_*10.5) % 3,
_*10.5 % 3.0,
int(_*3.5) & int(_*2.4),
_*3.5 & _*2.4,
int(_*3.5) | int(_*2.4),
_*3.5 | _*2.4,
xor(int(_*3.5), int(_*2.4)),
xor(_*3.5, _*2.4),
int(_*3.5) ^ int(_*2.4),
_*3.5 ^ _*2.4,
int(_*3.5) > int(_*2.4),
_*3.5 > _*2.4,
int(_*3.5) >= int(_*2.4),
_*3.5 >= _*2.4,
int(_*3.5) < int(_*2.4),
_*3.5 < _*2.4,
int(_*3.5) <= int(_*2.4),
_*3.5 <= _*2.4,
int(_*3.5) == int(_*2.4),
_*3.5 == _*2.4,
int(_*3.5) != int(_*2.4),
_*3.5 != _*2.4,
abs(int(_*4.4)),
abs(int(_*-4.4)),
abs(_*4.4),
abs(_*-4.4),
acos(_*0.5),
asin(_*0.5),
atan(_*0.5),
atan2(_*0.5, 4.0),
ceil(_*1.3),
cos(_*0.3),
exp(_*0.5),
floor(_*6.5),
fmod(_*9.2, 2.0),
log((_+1)*0.5),
log10((_+1)*0.5),
max(_*0.5, _*0.4),
min(_*0.5, _*0.4),
max(int(_*3.5), int(_*2.4)),
min(int(_*3.5), int(_*2.4)),
pow(_*0.5, 0.3),
pow(_*0.5, 3),
pow(10, _*3),
remainder(_*9.2, 2.0),
rint(_*1.5),
sin(_*0.3),
sqrt(_*0.3),
tan(_*0.3),
acosh(10+_*0.3),
asinh(10+_*0.3),
atanh(0.5+_*0.3),
cosh(10+_*0.3),
sinh(10+_*0.3),
tanh(10+_*0.3);
|
75b70a6aad67a8b1030333cfae80bbe49a783c33f1972b26dc1b4cab666e1842 | HexHive/datAFLow | bug-0994jpar.dsp | //-------------------------------------------------
// bug découvert le 24 juillet 2008 en voulant
// compiler sonik-cube
// faust: generator/compile_scal.cpp:1095:
// virtual std::string ScalarCompiler::generateFixDelay(CTree*, CTree*, CTree*):
// Assertion `getVectorNameProperty(exp, vecname)' failed.
//-------------------------------------------------
process = vbargraph("dB", -96, 1) : @(10);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/bug-0994jpar.dsp | faust | -------------------------------------------------
bug découvert le 24 juillet 2008 en voulant
compiler sonik-cube
faust: generator/compile_scal.cpp:1095:
virtual std::string ScalarCompiler::generateFixDelay(CTree*, CTree*, CTree*):
Assertion `getVectorNameProperty(exp, vecname)' failed.
------------------------------------------------- |
process = vbargraph("dB", -96, 1) : @(10);
|
6e388968634a4ac8218b9fe99fc19adefa61edbabd5c3b18af8b12057800d916 | HexHive/datAFLow | schema4.dsp | // exemple de schema illisible
import("music.lib");
freq = hslider("freq", 440, 20, 20000, 0.1);
partial(i) = osc(i*freq);
partial0 = osc(0*freq);
partial1 = osc(1*freq);
partial2 = osc(2*freq);
process = partial(0), partial1, partial(2);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/schema4.dsp | faust | exemple de schema illisible |
import("music.lib");
freq = hslider("freq", 440, 20, 20000, 0.1);
partial(i) = osc(i*freq);
partial0 = osc(0*freq);
partial1 = osc(1*freq);
partial2 = osc(2*freq);
process = partial(0), partial1, partial(2);
|
040c478340c7f3f6be2cd3d633e14ac30a5f109540bd3a9158c00573840ee066 | HexHive/datAFLow | PM-bug12.dsp | // example of partially applied rules
// transformed into a symbolic box
foo(x,x,z) = z*2;
foo(x,y,z) = z*3;
process = foo(1,1), foo(2,1);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/PM-bug12.dsp | faust | example of partially applied rules
transformed into a symbolic box |
foo(x,x,z) = z*2;
foo(x,y,z) = z*3;
process = foo(1,1), foo(2,1);
|
791ec0d28a8d9f59066524f1f49b03bcd68ec99eeb6d3ec29447f02bfd2257e9 | HexHive/datAFLow | error22.dsp | // can't compute interval of recursive signal
filter = *(0.01) : +~*(0.99);
d = hslider("delay", 0, 0, 1000, 1) : filter : int;
process = @(d);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/error22.dsp | faust | can't compute interval of recursive signal | filter = *(0.01) : +~*(0.99);
d = hslider("delay", 0, 0, 1000, 1) : filter : int;
process = @(d);
|
c679181020dcf4b2daca43834973a4878c65dff4cb59f51ef95ae27c7d343f30 | HexHive/datAFLow | intcast02.dsp | // variable (but bounded) delays using the @ operator
process = @(hslider("delay (samples)", 0, 0, 10, 1)); | https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/intcast02.dsp | faust | variable (but bounded) delays using the @ operator | process = @(hslider("delay (samples)", 0, 0, 10, 1)); |
90859bb48b57b57420867196124453689c988387c71da2d01dcd1a77770f4743 | HexHive/datAFLow | t2.dsp | // test that -pn option doesn't pass inside components
main = component("foo.lib"); | https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/t2.dsp | faust | test that -pn option doesn't pass inside components | main = component("foo.lib"); |
f0bc3d2a1e04edb0f1897dbe80384e8e3a8d42ded618092d122d8b1ace90d9ba | HexHive/datAFLow | parametric_eq.dsp | ol = library("oscillator.lib");
fl = library("filter.lib");
//process = ol.sawtooth_demo : fl.parametric_eq_demo :
// fl.mth_octave_spectral_level_demo(2) <: _,_;
process =
vgroup("[1]", ol.sawtooth_demo) :
vgroup("[2]", fl.parametric_eq_demo) :
vgroup("[3]", fl.mth_octave_spectral_level_demo(2))
<: _,_;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/parametric_eq.dsp | faust | process = ol.sawtooth_demo : fl.parametric_eq_demo :
fl.mth_octave_spectral_level_demo(2) <: _,_; | ol = library("oscillator.lib");
fl = library("filter.lib");
process =
vgroup("[1]", ol.sawtooth_demo) :
vgroup("[2]", fl.parametric_eq_demo) :
vgroup("[3]", fl.mth_octave_spectral_level_demo(2))
<: _,_;
|
3f063d219b9f6a5cdbab12d15df937ae4e9b1e8fc1cdb75fae87472512c913d9 | HexHive/datAFLow | multirate_3.dsp | process = <:#; | https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/multirate_3.dsp | faust | process = <:#; |
|
e78f366a391f2a99b99412089de8a0657bc22cf97868ecb87b9d3933a0e2b425 | HexHive/datAFLow | test26.dsp | //mise en cache des expressions recursives
x = 1:+~_;
y = 2:*~_;
foo(x,y,u,v) = x+y+u, y-x+v;
process = foo~(_,_);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/test26.dsp | faust | mise en cache des expressions recursives | x = 1:+~_;
y = 2:*~_;
foo(x,y,u,v) = x+y+u, y-x+v;
process = foo~(_,_);
|
1f5d4fbdfe6fe018c464d85806c6a0f40bfd00bd1d1024c481a40523658a020b | HexHive/datAFLow | test21.dsp |
d = hslider("delay", 0, 0, 1000, 1) : int;
process = @(d);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/test21.dsp | faust |
d = hslider("delay", 0, 0, 1000, 1) : int;
process = @(d);
|
|
9162df61bf68d3a40dcb7e7cb0f26261e78c2b6804573e38ce97784c854a43e6 | HexHive/datAFLow | felix1.dsp | import("math.lib");
import("music.lib");
process = delay(512, hypot(2,4));
zprocess = 512 + hypot(2,4);
xprocess = 512 + hypot(2,button("foo"));
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/felix1.dsp | faust | import("math.lib");
import("music.lib");
process = delay(512, hypot(2,4));
zprocess = 512 + hypot(2,4);
xprocess = 512 + hypot(2,button("foo"));
|
|
e5729e930eb45d75bc46e9fd80a635e272cbb89c82b5f4217a1043f276e5c15b | HexHive/datAFLow | path3.dsp | foo(n,x,y) = vgroup( "foo %n", *(x*y));
process = tgroup("toto", par(i, 4, foo(i, hslider("slid1", 0,0,1,0.1), hslider("/t:toto/slid2", 0,0,1,0.1))));
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/path3.dsp | faust | foo(n,x,y) = vgroup( "foo %n", *(x*y));
process = tgroup("toto", par(i, 4, foo(i, hslider("slid1", 0,0,1,0.1), hslider("/t:toto/slid2", 0,0,1,0.1))));
|
|
382bd9c1c8134eac9a089a2e2b90ca264b47de84e895bcf3c5ae4da7430768c3 | HexHive/datAFLow | 20091211-hbg-bug.dsp | // Faust Template
process = hbargraph("toto", -1, 1);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/20091211-hbg-bug.dsp | faust | Faust Template | process = hbargraph("toto", -1, 1);
|
dd724f8204faeeaf474a1a43b55fb80c707c41b79a692fe4701012c9a2f315ef | HexHive/datAFLow | error04.dsp | //ERROR : inconsistent number of parameters in pattern-matching rule: (x,y) => -; previous rule was: (5) => +;
// Faust should complain about inconsistent number of patterns
// between the foo rules
foo (5) = +;
foo (x,y) = -;
process = foo(3,2);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/error04.dsp | faust | ERROR : inconsistent number of parameters in pattern-matching rule: (x,y) => -; previous rule was: (5) => +;
Faust should complain about inconsistent number of patterns
between the foo rules |
foo (5) = +;
foo (x,y) = -;
process = foo(3,2);
|
8876d76aac54399c8a526febc8d942b174443a35de271adaa52e9da234b3528f | HexHive/datAFLow | intcast01.dsp | process = int(int(hslider("toto", 0, -10, 10, 0.1))) : int; | https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/intcast01.dsp | faust | process = int(int(hslider("toto", 0, -10, 10, 0.1))) : int; |
|
0b50daf04b35e03bf62dba94d64d7c7f81b1fca92bd3d2e9ee5e3af6520aec78 | HexHive/datAFLow | bug090728.dsp | // This code (provided by Felix [email protected]) takes exponential time to compile
// The problem has been corrected in faust 0996b7
import("math.lib");
import("music.lib");
ndots = 40; // integer ! minimal possible value is 4
/// exponential compile time, change this value
diffy = hslider("DiffY", 1, 0, 1, 0.001);
dots = hslider("Dots", 4, 4, ndots, 1);
freqrange = hslider("Freqrange", 0, 0, 1000, 0.001);
freqcenter = hslider("Freqcenter", 100, 20, 5000, 0.001);
SH(trig,x) = (*(1 - trig) + x * trig) ~ _;
switchN(n, s) = par(i, n , _*(i==s)):>_;
mirror(x) = x*((x<=1)&(x>= -1)) + (1-frac(x))*(x>1) + (-frac(x)-1)*(x< -1);
dynElem(ramp, noise, num) = rampElem(ramp,noise,num), noise, (num+1),
rampElem(ramp,noise,num), ampElem(ramp,noise);
ampElem(ramp, noise) =
(_<:(_*(1-(ramp<ramp'))+mirror(_+noise'*diffy)*(ramp<ramp')))~_;
rampElem(ramp, noise, num)= rampCond(ramp, noise)*(num<=dots)+ramp*(num>dots);
rampCond(ramp, noise) =
(_<:(rampGen(timeC(ramp,noise))*((ramp<ramp')|((_'<_)&(_<=1))) ))~_;
rampGen(time, x) = x+time;
timeC(ramp, noise) = (SH((ramp<ramp'), noise)*0.5+0.5)*fRange+mFreq;
fRange = 1/SR*freqrange;
mFreq = 1/SR*freqcenter*dots;
imp(x) = 1*(x'==0)+1;
impuls = (imp~_)-1;
rampno1(x) = x+impuls;
///### these are the lines, that cause the exponentially increasing compile time ###
pSeries(1,Func) = Func;
pSeries(i,Func) = Func : pSeries(i-1,Func), _, _;
pchain(n) = pSeries(n,dynElem) ~ rampno1;
rawgen = (noise,1):pchain(ndots);
process = rawgen;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/bug090728.dsp | faust | This code (provided by Felix [email protected]) takes exponential time to compile
The problem has been corrected in faust 0996b7
integer ! minimal possible value is 4
/ exponential compile time, change this value
/### these are the lines, that cause the exponentially increasing compile time ### |
import("math.lib");
import("music.lib");
diffy = hslider("DiffY", 1, 0, 1, 0.001);
dots = hslider("Dots", 4, 4, ndots, 1);
freqrange = hslider("Freqrange", 0, 0, 1000, 0.001);
freqcenter = hslider("Freqcenter", 100, 20, 5000, 0.001);
SH(trig,x) = (*(1 - trig) + x * trig) ~ _;
switchN(n, s) = par(i, n , _*(i==s)):>_;
mirror(x) = x*((x<=1)&(x>= -1)) + (1-frac(x))*(x>1) + (-frac(x)-1)*(x< -1);
dynElem(ramp, noise, num) = rampElem(ramp,noise,num), noise, (num+1),
rampElem(ramp,noise,num), ampElem(ramp,noise);
ampElem(ramp, noise) =
(_<:(_*(1-(ramp<ramp'))+mirror(_+noise'*diffy)*(ramp<ramp')))~_;
rampElem(ramp, noise, num)= rampCond(ramp, noise)*(num<=dots)+ramp*(num>dots);
rampCond(ramp, noise) =
(_<:(rampGen(timeC(ramp,noise))*((ramp<ramp')|((_'<_)&(_<=1))) ))~_;
rampGen(time, x) = x+time;
timeC(ramp, noise) = (SH((ramp<ramp'), noise)*0.5+0.5)*fRange+mFreq;
fRange = 1/SR*freqrange;
mFreq = 1/SR*freqcenter*dots;
imp(x) = 1*(x'==0)+1;
impuls = (imp~_)-1;
rampno1(x) = x+impuls;
pSeries(1,Func) = Func;
pSeries(i,Func) = Func : pSeries(i-1,Func), _, _;
pchain(n) = pSeries(n,dynElem) ~ rampno1;
rawgen = (noise,1):pchain(ndots);
process = rawgen;
|
189f34ac8da4febc96826b3fa446503db6b474e555ed44a2a054c9b3ff7a89cc | HexHive/datAFLow | cubic_distortion.dsp | declare name "cubic_distortion";
ol = library("oscillator.lib");
fl = library("filter.lib");
el = library("effect.lib");
process =
// ol.oscr_demo : el.cubicnl_demo : fl.spectral_level_demo <: _,_;
vgroup("[1]",ol.oscr_demo) :
vgroup("[2]",el.cubicnl_demo) :
vgroup("[3]",fl.spectral_level_demo) <: _,_;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/cubic_distortion.dsp | faust | ol.oscr_demo : el.cubicnl_demo : fl.spectral_level_demo <: _,_; | declare name "cubic_distortion";
ol = library("oscillator.lib");
fl = library("filter.lib");
el = library("effect.lib");
process =
vgroup("[1]",ol.oscr_demo) :
vgroup("[2]",el.cubicnl_demo) :
vgroup("[3]",fl.spectral_level_demo) <: _,_;
|
3dc6f31ace6542d9cafd6bb79a203844d6a87bf31fa0bff0e27c8a700aee5b68 | HexHive/datAFLow | ratepass_7.dsp | up2 = vectorize(1) <: # : serialize;
dw3 = vectorize(3) : [0];
process = up2 : dw3; | https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/ratepass_7.dsp | faust | up2 = vectorize(1) <: # : serialize;
dw3 = vectorize(3) : [0];
process = up2 : dw3; |
|
cc4cfc02c3c34adae83a4a4289b4dfed7b43e3bcfcd46d43d909ee5ef288ff96 | HexHive/datAFLow | precision.dsp | // teste la précision des valeurs
process = waveform {-1.83767764006829192879877155064605e+00,-1.83767764006829192879877155064606e+00,2,3,4,5,6,7,8,9,
1.2,
1.02,
1.002,
1.0002,
1.00002,
1.000002,
1.0000002,
1.00000002,
1.000000002,
1.0000000002,
1.00000000002,
1.000000000002,
1.0000000000002,
1.00000000000002,
1.000000000000002,
1.0000000000000002,
1.00000000000000025,
1.00000000000000030,
1.00000000000000035,
1.00000000000000040,
9999
};
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/precision.dsp | faust | teste la précision des valeurs | process = waveform {-1.83767764006829192879877155064605e+00,-1.83767764006829192879877155064606e+00,2,3,4,5,6,7,8,9,
1.2,
1.02,
1.002,
1.0002,
1.00002,
1.000002,
1.0000002,
1.00000002,
1.000000002,
1.0000000002,
1.00000000002,
1.000000000002,
1.0000000000002,
1.00000000000002,
1.000000000000002,
1.0000000000000002,
1.00000000000000025,
1.00000000000000030,
1.00000000000000035,
1.00000000000000040,
9999
};
|
39c158f86395d7fb928c35fbbfd8c0376e8142ef5f6139bbc86249f860b9c4b9 | HexHive/datAFLow | highShelf.dsp | import("maxmsp.lib");
G = hslider("Gain [unit:dB]", 0, -10, 10, 0.1);
F = hslider("Freq", 1000, 100, 10000, 1);
Q = hslider("Q", 1, 0.01, 100, 0.01);
process(x) = highShelf(x,F,G,Q);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/highShelf.dsp | faust | import("maxmsp.lib");
G = hslider("Gain [unit:dB]", 0, -10, 10, 0.1);
F = hslider("Freq", 1000, 100, 10000, 1);
Q = hslider("Q", 1, 0.01, 100, 0.01);
process(x) = highShelf(x,F,G,Q);
|
|
824d0fbc27c01444cde663e09d903d017580a012901ef8dc285e045016042c57 | HexHive/datAFLow | test8.dsp | // partage des expressions interieur exterieur
foo = +~sin;
process = foo : mem : sin;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/test8.dsp | faust | partage des expressions interieur exterieur |
foo = +~sin;
process = foo : mem : sin;
|
3648e98cb4c9c5c7ce537b42c3b4945d9dca79fe0c0c81eb0313d06c65b95f02 | HexHive/datAFLow | schema3.dsp | // exemple de schema illisible
import("music.lib");
fold = case {
(1,f,x) => x(0);
(n,f,x) => f(fold(n-1,f,x),x(n-1));
};
fpar(n) = fold(n,\(x,y).(x,y));
freq = hslider("freq", 440, 20, 20000, 0.1);
partial(i) = osc(i*freq);
process = fpar(5, partial);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/schema3.dsp | faust | exemple de schema illisible |
import("music.lib");
fold = case {
(1,f,x) => x(0);
(n,f,x) => f(fold(n-1,f,x),x(n-1));
};
fpar(n) = fold(n,\(x,y).(x,y));
freq = hslider("freq", 440, 20, 20000, 0.1);
partial(i) = osc(i*freq);
process = fpar(5, partial);
|
c91b26ce496c4e5cca04835f0648a90bc11bd0bafdbedfd1574a9905c9fc031b | HexHive/datAFLow | BPF.dsp | import("maxmsp.lib");
G = hslider("Gain [unit:dB]", 0, -10, 10, 0.1);
F = hslider("Freq", 1000, 100, 10000, 1);
Q = hslider("Q", 1, 0.01, 100, 0.01);
process(x) = BPF(x,F,G,Q);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/BPF.dsp | faust | import("maxmsp.lib");
G = hslider("Gain [unit:dB]", 0, -10, 10, 0.1);
F = hslider("Freq", 1000, 100, 10000, 1);
Q = hslider("Q", 1, 0.01, 100, 0.01);
process(x) = BPF(x,F,G,Q);
|
|
4b0a80be1f4508187f1961e883b118f1f049941c617d89c102c70ab906b2be2d | HexHive/datAFLow | PM-bug3-4.dsp | toto (n) = fact(n)
with {
fact (0) = 1;
fact (n) = n*fact(n-1);
};
foo (x:y) = (y:x);
process = foo(sin:sqrt);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/PM-bug3-4.dsp | faust | toto (n) = fact(n)
with {
fact (0) = 1;
fact (n) = n*fact(n-1);
};
foo (x:y) = (y:x);
process = foo(sin:sqrt);
|
|
38c92937afa735a99aa7748cf4c33d9593df734566836249bc77968babe141f7 | HexHive/datAFLow | tapiir.dsp | declare name "tapiir";
declare version "1.0";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2006";
//======================================================
//
// TAPIIR
// (from Maarten de Boer's Tapiir)
//
//======================================================
import("music.lib");
dsize = 524288;
// user interface
//---------------
tap(n) = vslider("tap %n", 0,0,1,0.1);
in(n) = vslider("input %n", 1,0,1,0.1);
gain = vslider("gain", 1,0,1,0.1);
del = vslider("delay (sec)", 0, 0, 5, 0.01) * SR;
// mixer and matrix
//-----------------------------------------------------------
mixer(taps,lines) = par(i,taps,*(tap(i))),
par(i,lines,*(in(i)))
:> *(gain);
matrix(taps,lines) = (bus(lines+taps)
<: tgroup("",
par(i, taps,
hgroup("Tap %i",
mixer(taps,lines) : delay(dsize,del))))
) ~ bus(taps);
// tapiir
//--------
tapiir(taps,lines) = vgroup("Tapiir",
bus(lines)
<: (matrix(taps,lines), bus(lines))
<: vgroup( "outputs", par( i, lines, hgroup("output %i", mixer(taps,lines)) ) )
);
process = tapiir(6,2);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/tapiir.dsp | faust | ======================================================
TAPIIR
(from Maarten de Boer's Tapiir)
======================================================
user interface
---------------
mixer and matrix
-----------------------------------------------------------
tapiir
-------- | declare name "tapiir";
declare version "1.0";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2006";
import("music.lib");
dsize = 524288;
tap(n) = vslider("tap %n", 0,0,1,0.1);
in(n) = vslider("input %n", 1,0,1,0.1);
gain = vslider("gain", 1,0,1,0.1);
del = vslider("delay (sec)", 0, 0, 5, 0.01) * SR;
mixer(taps,lines) = par(i,taps,*(tap(i))),
par(i,lines,*(in(i)))
:> *(gain);
matrix(taps,lines) = (bus(lines+taps)
<: tgroup("",
par(i, taps,
hgroup("Tap %i",
mixer(taps,lines) : delay(dsize,del))))
) ~ bus(taps);
tapiir(taps,lines) = vgroup("Tapiir",
bus(lines)
<: (matrix(taps,lines), bus(lines))
<: vgroup( "outputs", par( i, lines, hgroup("output %i", mixer(taps,lines)) ) )
);
process = tapiir(6,2);
|
88162b82470ffc93100c810bb3229b8c8fb61de877d76bc739d35cc1ba9c4c27 | HexHive/datAFLow | error05.dsp | //ERROR : inconsistent number of parameters in pattern-matching rule: (x,z) => z; previous rule was: (x,x,z) => x;
// test for unconsistent pattern matching rules
fuu (x,x,z) = x;
fuu (x,z) = z;
process = fuu(1,1), fuu(1,2);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/error05.dsp | faust | ERROR : inconsistent number of parameters in pattern-matching rule: (x,z) => z; previous rule was: (x,x,z) => x;
test for unconsistent pattern matching rules | fuu (x,x,z) = x;
fuu (x,z) = z;
process = fuu(1,1), fuu(1,2);
|
7015fc7d84bd634a577db5418eb7de8e1b2d7d98819fea1390b0c191d29c71b0 | HexHive/datAFLow | SHbug.dsp | // Bug discovered June 30, 2009
// partial application of primitives should work
//
myselect2(t,a,b)=select2(t,a,b);
sampleAndHold(t) = select2(t,_) ~ _;
process = sampleAndHold(int(button("sample")));
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/SHbug.dsp | faust | Bug discovered June 30, 2009
partial application of primitives should work
|
myselect2(t,a,b)=select2(t,a,b);
sampleAndHold(t) = select2(t,_) ~ _;
process = sampleAndHold(int(button("sample")));
|
b40500694c213006cf540bd86058e5fa82baa37496b9660e53e12c6d534f816d | HexHive/datAFLow | test9.dsp | // partage des expressions lentes
vol = hslider("vol", 0, 0, 1, 0.1);
process = +~*(sin(vol));
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/test9.dsp | faust | partage des expressions lentes |
vol = hslider("vol", 0, 0, 1, 0.1);
process = +~*(sin(vol));
|
546559deca2a31621175b937cd240560e01d95c2469958c05c3ee4ee9865dcb2 | HexHive/datAFLow | peakingEQ.dsp | import("maxmsp.lib");
G = hslider("Gain [unit:dB]", 0, -10, 10, 0.1);
F = hslider("Freq", 1000, 100, 10000, 1);
Q = hslider("Q", 1, 0.01, 100, 0.01);
process(x) = peakingEQ(x,F,G,Q);
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/peakingEQ.dsp | faust | import("maxmsp.lib");
G = hslider("Gain [unit:dB]", 0, -10, 10, 0.1);
F = hslider("Freq", 1000, 100, 10000, 1);
Q = hslider("Q", 1, 0.01, 100, 0.01);
process(x) = peakingEQ(x,F,G,Q);
|
|
cc457749cf9db52a7df6527b56235197443a383ea5e1e6362da012fd24838f52 | HexHive/datAFLow | numsimplerr5.dsp | process = 0,0,0 : +; | https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/numsimplerr5.dsp | faust | process = 0,0,0 : +; |
|
dc13818a321be2d5cfeb34fc29aff5e7bb0a7e2f45dfce8bd968ff92d39aa3fb | HexHive/datAFLow | comb_delay1.dsp | import("music.lib");
// 10 samples delay modulation
modulator = @(osc(1000) : +(1) : *(5) : min(10) : max(0));
fix = @(100);
source = osc(440);
process = source : modulator : fix;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/comb_delay1.dsp | faust | 10 samples delay modulation | import("music.lib");
modulator = @(osc(1000) : +(1) : *(5) : min(10) : max(0));
fix = @(100);
source = osc(440);
process = source : modulator : fix;
|
fd274de5722f92b325eaedfbd7428ecb3e8e7d4b860127e524c9dc07ee2372a0 | HexHive/datAFLow | test13.dsp |
process = (+ <: _, cos)~ sin; | https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/test13.dsp | faust |
process = (+ <: _, cos)~ sin; |
|
3a268fa15450a8c54377cbb465081094f4eb3c8c3bf647993bb7aeada4e7dcc3 | HexHive/datAFLow | spectral_tilt.dsp | // example exercising filter.lib's spectral_tilt_demo
N = 10; // Number of pole-zero pairs to use
process = sig(ol.sawtooth_demo)
: stg(el.bypass1(bp,fl.spectral_tilt_demo(N)))
<: sag(fl.spectral_level_demo)
with {
fl = library("filter.lib");
ol = library("oscillator.lib");
el = library("effect.lib");
bp = stg(checkbox("[0] Bypass Spectral Tilt"));
stg(x) = vgroup(
"[1] Spectral Tilt Filter [tooltip: See Faust's filter.lib for spectral_tilt_demo]",x);
sig(x) = vgroup(
"[2] Test Signal [tooltip: See Faust's oscillator.lib for sawtooth_demo]",x);
sag(x) = vgroup(
"[4] Spectrum Analyzer [tooltip: See Faust's filter.lib for spectral_level_demo]",x);
};
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/spectral_tilt.dsp | faust | example exercising filter.lib's spectral_tilt_demo
Number of pole-zero pairs to use |
process = sig(ol.sawtooth_demo)
: stg(el.bypass1(bp,fl.spectral_tilt_demo(N)))
<: sag(fl.spectral_level_demo)
with {
fl = library("filter.lib");
ol = library("oscillator.lib");
el = library("effect.lib");
bp = stg(checkbox("[0] Bypass Spectral Tilt"));
stg(x) = vgroup(
"[1] Spectral Tilt Filter [tooltip: See Faust's filter.lib for spectral_tilt_demo]",x);
sig(x) = vgroup(
"[2] Test Signal [tooltip: See Faust's oscillator.lib for sawtooth_demo]",x);
sag(x) = vgroup(
"[4] Spectrum Analyzer [tooltip: See Faust's filter.lib for spectral_level_demo]",x);
};
|
50a2ffb87579442fb18dc3b6212491fb232e99b0eb7fad0044724aaa9d89a93b | HexHive/datAFLow | carre_volterra.dsp | /************************************************************
* Travaux dirigés sur les séries de Volterra
* Programmation d'un filtre Moog simplifié en FAUST
*
* M2R ATIAM, UE TSM
* Thomas Hélie et Yann Orlarey
**************************************************************/
// Version utilisant la syntaxe étendue
import("math.lib"); // pour avoir PI et SR la frequence d'échantillonnage
import("oscillator.lib");
import("effect.lib");
// Chaine de traitement Volterra composée de trois modules M
// et d'un module de sortie S. A noter que la deuxième entrée du
// premier module M est à 0
process = C, 0 : M : M : M : M : S;
C = square(freq) + square(freq+delta) : *(level)
with {
freq = hslider("freq carre", 440, 20, 8000, 1);
delta = hslider("delta", 2, 0, 6, 0.1);
level = hslider("level",0.5, 0, 1, 0.01);
};
// Module de traitement M.
// L'expression F1(x) ne sera calculée qu'une
// seule fois car Faust va optimiser le code.
M(x,y) = F1(x), F1(x^3 - F1(x)^3 + y);
// Module de sortie S.
// c'est un module M dont l'entrée du deuxième
// F1 est divisée par 3 et les sorties additionnées
S(x,y) = x + T3*y with { T3 = -1.0/3.0 * checkbox("NL"); };
// Fonction F1 avec définition locale du paramètre v controlé
// par la fréquence de coupure
F1 = *(v/(1.+v)) : + ~ /(1.+v)
with {
v = (2*PI/SR)*hslider("freq[unit:Hz]", 700, 1, 20000, 1);
};
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/carre_volterra.dsp | faust | ***********************************************************
* Travaux dirigés sur les séries de Volterra
* Programmation d'un filtre Moog simplifié en FAUST
*
* M2R ATIAM, UE TSM
* Thomas Hélie et Yann Orlarey
*************************************************************
Version utilisant la syntaxe étendue
pour avoir PI et SR la frequence d'échantillonnage
Chaine de traitement Volterra composée de trois modules M
et d'un module de sortie S. A noter que la deuxième entrée du
premier module M est à 0
Module de traitement M.
L'expression F1(x) ne sera calculée qu'une
seule fois car Faust va optimiser le code.
Module de sortie S.
c'est un module M dont l'entrée du deuxième
F1 est divisée par 3 et les sorties additionnées
Fonction F1 avec définition locale du paramètre v controlé
par la fréquence de coupure |
import("oscillator.lib");
import("effect.lib");
process = C, 0 : M : M : M : M : S;
C = square(freq) + square(freq+delta) : *(level)
with {
freq = hslider("freq carre", 440, 20, 8000, 1);
delta = hslider("delta", 2, 0, 6, 0.1);
level = hslider("level",0.5, 0, 1, 0.01);
};
M(x,y) = F1(x), F1(x^3 - F1(x)^3 + y);
S(x,y) = x + T3*y with { T3 = -1.0/3.0 * checkbox("NL"); };
F1 = *(v/(1.+v)) : + ~ /(1.+v)
with {
v = (2*PI/SR)*hslider("freq[unit:Hz]", 700, 1, 20000, 1);
};
|
ca35ca2c42fac2ccd0c91b6e8d0ddc90d2c0499d514cdf2e1e9a9c4a969c7742 | HexHive/datAFLow | mr_undersample.dsp | up2 = vectorize(1) <: # : serialize;
dw2 = vectorize(2) : [0];
filter = _<:_,@(1):+:*(0.5);
process = *(2):dw2:exp:filter:up2;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/mr_undersample.dsp | faust | up2 = vectorize(1) <: # : serialize;
dw2 = vectorize(2) : [0];
filter = _<:_,@(1):+:*(0.5);
process = *(2):dw2:exp:filter:up2;
|
|
a1dff1067d0cc9245c7c926a77e541eb2767da3db794ae8e59a6908d94908023 | HexHive/datAFLow | test11.dsp | import("music.lib");
//foo (d) = (+:delay1s(d)) ~ _;
foo (d) = (+:@(d)) ~ _;
process = _ <: foo(30), foo(20); | https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/test11.dsp | faust | foo (d) = (+:delay1s(d)) ~ _; | import("music.lib");
foo (d) = (+:@(d)) ~ _;
process = _ <: foo(30), foo(20); |
2a5deec7f912ed791382365fe46e6fc7cd388aab27d2da89ff8195fd96f0c18d | HexHive/datAFLow | dimensioncheck_3.dsp | process = vectorize(2)<:#:serialize; | https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/dimensioncheck_3.dsp | faust | process = vectorize(2)<:#:serialize; |
|
01ce994d6fd1a51be905c2457ab371a0d0addce978874c95c9e112916994eddc | HexHive/datAFLow | PM-bug1.dsp | // ------------------------------------------------------------------
// In this example the two choice0 should give the same operation (/)
// But this is not the case as "3,6:foo:/" is not correctly
// simplified to 2.
//-------------------------------------------------------------------
foo(x,y) = (y,x);
choice0 = case {
(1) => *;
(2) => /;
(x) => +;
};
process = choice0((6,3:/)), choice0((3,6:foo:/));
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/PM-bug1.dsp | faust | ------------------------------------------------------------------
In this example the two choice0 should give the same operation (/)
But this is not the case as "3,6:foo:/" is not correctly
simplified to 2.
------------------------------------------------------------------- |
foo(x,y) = (y,x);
choice0 = case {
(1) => *;
(2) => /;
(x) => +;
};
process = choice0((6,3:/)), choice0((3,6:foo:/));
|
95d06e4ec48a353160db50e892f074309c2fd7623e6fc2ec14a9b20f1c9ecd65 | HexHive/datAFLow | parabolic-env.dsp | durationSamples = 100;
grainAmplitude = 2.8;
rdur = 1.0/durationSamples;
rdur2 = rdur*rdur;
curve = -8.0 * grainAmplitude * rdur2;
slope = 4* grainAmplitude * (rdur - rdur2) + (curve : +~_:mem);
amplitude = slope : + ~_:mem;
process = slope, amplitude; | https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/parabolic-env.dsp | faust | durationSamples = 100;
grainAmplitude = 2.8;
rdur = 1.0/durationSamples;
rdur2 = rdur*rdur;
curve = -8.0 * grainAmplitude * rdur2;
slope = 4* grainAmplitude * (rdur - rdur2) + (curve : +~_:mem);
amplitude = slope : + ~_:mem;
process = slope, amplitude; |
|
d5a596c7241c3f597b637c07100ac356c51406231f13ac88badaeac64591d7ed | HexHive/datAFLow | test14bis.dsp | // bug dans version 0.9.9.3-bis
// (ne se produit pas avec les version 0.9.9.2 et 0.9.9.3)
// le compilateur se plaint de ne pas avoir de type associé
// à la deuxième sortie qui est pourtant inutilisée
process = (+ <: _, _)~ _ : _,!; | https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/test14bis.dsp | faust | bug dans version 0.9.9.3-bis
(ne se produit pas avec les version 0.9.9.2 et 0.9.9.3)
le compilateur se plaint de ne pas avoir de type associé
à la deuxième sortie qui est pourtant inutilisée | process = (+ <: _, _)~ _ : _,!; |
340030ebd0af7d92e0ba17e59322813abf4fbbb171e5fa587dd8110c78de9420 | HexHive/datAFLow | granulator1.dsp | //-----------------------------------------------
//
// Parabolic Grain Envelop : from Ross Bencina
//
//-----------------------------------------------
import("music.lib");
//----------------------------------------------------------------------
// RINTEGRATE : Resetable integrator
// It integrates the values of x : 0, x(0), x(0)+x(1), x(0)+x(1)+x(2),...
// The integration is controled by a boolean <onoff> signal. When
// <onoff> is 1, values are integrated. When <onoff> is 0, the integration
// is stopped and the output value is reset to 0
//----------------------------------------------------------------------
rintegrate(onoff) = (+:*(onoff))~_ : mem;
//----------------------------------------------------------------------
// INTEGRATE : signal integrator
// It integrates the values of x : 0, x(0), x(0)+x(1), x(0)+x(1)+x(2),...
// The implementation is based on rintegrate with an onoff signal always
// on (i.e. 1).
//----------------------------------------------------------------------
integrate = rintegrate(1);
//----------------------------------------------------------------------
// Trigable Parabolic Grain Envelop :
// Multiply the incoming signal <sig> with a parabolic envelop of duration
// <sdur> samples and of amplitude <gamp>. The envelop is controled by a
// trigger boolean signal <trig>. An envelop is trigged when the <trig>
// become 1. Once trigged the envelop will continue until the end before
// being retriggable
//----------------------------------------------------------------------
grainenv(sdur, gamp, trig, sig) = (_|trig|trig' : amplitude : max(0)) ~ >(0) : *(sig)
with {
rdur = 1.0/sdur;
rdur2 = rdur*rdur;
curve = -8.0 * gamp * rdur2;
slope(on) = 4 * gamp * (rdur - rdur2) + rintegrate(on,curve);
amplitude(on) = rintegrate(on, slope(on));
};
//----------------------------------------------------------------------
// A grain
// <id> is the value that must be used by sel to trig the grain
// <po> is the delay (in samples) on the input signal
// <gdur> is the duration of the grain (in samples)
// <gamp> is the amplitude of the grain
// <sel> is the selection signal used to trig the grain. The grain is
// trigged when <sel> == <id>
// <sig> is the audio signal to process
//----------------------------------------------------------------------
grain(id, pos, gdur, gamp, sel, sig)
= sig : delay10s(pos) : grainenv(gdur, gamp, (sel==id));
//----------------------------------------------------------------------
// A multi grain with a stereo output
// <num> the number of grains
// <tdur> the total duration over which the grains are distributed
// <gdur> is the duration of the grain (in samples)
// <gamp> is the amplitude of the grain
// <sel> is the selection signal used to trig the grains.
// <sig> is the audio signal to process
//----------------------------------------------------------------------
multigrain2(num, tdur, gdur, gamp, sel, sig)
= sel, sig <: par(i,num, grain(i, tdur*i/num, gdur, gamp)) :> _,_;
//----------------------------------------------------------------------
//integer random numbers
// Generates integer random numbers between two values <lo> and <hi>
//----------------------------------------------------------------------
irnd(lo,hi) = int( (lo+hi)/2 + noise*(hi-lo)/2 );
//----------------------------------------------------------------------
// Sample and hold : the value is sampled when <t> is 1
// and hold when <t> is 0
//----------------------------------------------------------------------
SH(t) = *(t): +~*(1-t);
trig = (integrate(1) % 7 == 3);
selector_ = irnd(0, 20);
//process = integrate(1), slope(trig), max(0.0,bidule(trig));
//process = integrate(1), trig, grainenv(10, 2.8, trig, 1);
//process = integrate(1), selector, multigrain2(4, 100, 10, 1, selector, integrate(1));
//process = integrate(1), pulse(10), irnd(0,100), (irnd(0,100) : SH(pulse(10)));
vol = hslider("vol", 0, 0, 1, 0.01);
lim1 = hslider("lim1", 0, 0, 10000, 1);
lim2 = hslider("lim2", 0, 0, 10000, 1);
process = *(vol) : multigrain2( 32, 5*SR, SR/20, 1, (irnd(lim1,lim2) : SH(pulse(SR/137))) );
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/granulator1.dsp | faust | -----------------------------------------------
Parabolic Grain Envelop : from Ross Bencina
-----------------------------------------------
----------------------------------------------------------------------
RINTEGRATE : Resetable integrator
It integrates the values of x : 0, x(0), x(0)+x(1), x(0)+x(1)+x(2),...
The integration is controled by a boolean <onoff> signal. When
<onoff> is 1, values are integrated. When <onoff> is 0, the integration
is stopped and the output value is reset to 0
----------------------------------------------------------------------
----------------------------------------------------------------------
INTEGRATE : signal integrator
It integrates the values of x : 0, x(0), x(0)+x(1), x(0)+x(1)+x(2),...
The implementation is based on rintegrate with an onoff signal always
on (i.e. 1).
----------------------------------------------------------------------
----------------------------------------------------------------------
Trigable Parabolic Grain Envelop :
Multiply the incoming signal <sig> with a parabolic envelop of duration
<sdur> samples and of amplitude <gamp>. The envelop is controled by a
trigger boolean signal <trig>. An envelop is trigged when the <trig>
become 1. Once trigged the envelop will continue until the end before
being retriggable
----------------------------------------------------------------------
----------------------------------------------------------------------
A grain
<id> is the value that must be used by sel to trig the grain
<po> is the delay (in samples) on the input signal
<gdur> is the duration of the grain (in samples)
<gamp> is the amplitude of the grain
<sel> is the selection signal used to trig the grain. The grain is
trigged when <sel> == <id>
<sig> is the audio signal to process
----------------------------------------------------------------------
----------------------------------------------------------------------
A multi grain with a stereo output
<num> the number of grains
<tdur> the total duration over which the grains are distributed
<gdur> is the duration of the grain (in samples)
<gamp> is the amplitude of the grain
<sel> is the selection signal used to trig the grains.
<sig> is the audio signal to process
----------------------------------------------------------------------
----------------------------------------------------------------------
integer random numbers
Generates integer random numbers between two values <lo> and <hi>
----------------------------------------------------------------------
----------------------------------------------------------------------
Sample and hold : the value is sampled when <t> is 1
and hold when <t> is 0
----------------------------------------------------------------------
process = integrate(1), slope(trig), max(0.0,bidule(trig));
process = integrate(1), trig, grainenv(10, 2.8, trig, 1);
process = integrate(1), selector, multigrain2(4, 100, 10, 1, selector, integrate(1));
process = integrate(1), pulse(10), irnd(0,100), (irnd(0,100) : SH(pulse(10))); |
import("music.lib");
rintegrate(onoff) = (+:*(onoff))~_ : mem;
integrate = rintegrate(1);
grainenv(sdur, gamp, trig, sig) = (_|trig|trig' : amplitude : max(0)) ~ >(0) : *(sig)
with {
rdur = 1.0/sdur;
rdur2 = rdur*rdur;
curve = -8.0 * gamp * rdur2;
slope(on) = 4 * gamp * (rdur - rdur2) + rintegrate(on,curve);
amplitude(on) = rintegrate(on, slope(on));
};
grain(id, pos, gdur, gamp, sel, sig)
= sig : delay10s(pos) : grainenv(gdur, gamp, (sel==id));
multigrain2(num, tdur, gdur, gamp, sel, sig)
= sel, sig <: par(i,num, grain(i, tdur*i/num, gdur, gamp)) :> _,_;
irnd(lo,hi) = int( (lo+hi)/2 + noise*(hi-lo)/2 );
SH(t) = *(t): +~*(1-t);
trig = (integrate(1) % 7 == 3);
selector_ = irnd(0, 20);
vol = hslider("vol", 0, 0, 1, 0.01);
lim1 = hslider("lim1", 0, 0, 10000, 1);
lim2 = hslider("lim2", 0, 0, 10000, 1);
process = *(vol) : multigrain2( 32, 5*SR, SR/20, 1, (irnd(lim1,lim2) : SH(pulse(SR/137))) );
|
1e45103935f66b34d0c381abc1bd8c02d4bd560e056315914d0eb58c2c05e0a9 | HexHive/datAFLow | reverb_tester.dsp | import("effect.lib");
process(x,y) = stereo_reverb_tester(gui_group,x,y)
with {
gui_group(x) = hgroup("Stereo Reverb Tester",x);
stereo_reverb_tester(revin_group,x,y) = inx,iny with {
ck_group(x) = revin_group(vgroup("[1] Input Config",x));
mutegain = 0;
pinkin = ck_group(checkbox("[2] Pink Noise
[tooltip: Pink Noise (or 1/f noise) is Constant-Q Noise (useful for adjusting the EQ sections)]"));
impulsify = _ <: _,mem : - : >(0);
imp_group(x) = revin_group(hgroup("[2] Impulse Selection",x));
pulseL = imp_group(button("[1] Left
[tooltip: Send impulse into LEFT channel]")) : impulsify;
pulseC = imp_group(button("[2] Center
[tooltip: Send impulse into LEFT and RIGHT channels]")) : impulsify;
pulseR = imp_group(button("[3] Right
[tooltip: Send impulse into RIGHT channel]")) : impulsify;
inx = x*mutegain + (pulseL+pulseC) + pn;
iny = y*mutegain + (pulseR+pulseC) + pn;
pn = 0.1*pinkin*component("oscillator.lib").pink_noise;
};
};
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/reverb_tester.dsp | faust | import("effect.lib");
process(x,y) = stereo_reverb_tester(gui_group,x,y)
with {
gui_group(x) = hgroup("Stereo Reverb Tester",x);
stereo_reverb_tester(revin_group,x,y) = inx,iny with {
ck_group(x) = revin_group(vgroup("[1] Input Config",x));
mutegain = 0;
pinkin = ck_group(checkbox("[2] Pink Noise
[tooltip: Pink Noise (or 1/f noise) is Constant-Q Noise (useful for adjusting the EQ sections)]"));
impulsify = _ <: _,mem : - : >(0);
imp_group(x) = revin_group(hgroup("[2] Impulse Selection",x));
pulseL = imp_group(button("[1] Left
[tooltip: Send impulse into LEFT channel]")) : impulsify;
pulseC = imp_group(button("[2] Center
[tooltip: Send impulse into LEFT and RIGHT channels]")) : impulsify;
pulseR = imp_group(button("[3] Right
[tooltip: Send impulse into RIGHT channel]")) : impulsify;
inx = x*mutegain + (pulseL+pulseC) + pn;
iny = y*mutegain + (pulseR+pulseC) + pn;
pn = 0.1*pinkin*component("oscillator.lib").pink_noise;
};
};
|
|
3395a6afb6a53cf3080b58d4b9b893eb8b8551e53a61bf4ae9cdcabe116780a0 | HexHive/datAFLow | surface.dsp | // Modeling a 2D surface with a von neumann
surface(X,Y) = route(X*Y, X*Y, par(x, X, par(y, Y, neighborhood(X,Y).vonNeumann(x,y) ) ) );
// von Neumann neighborhood (or 4-neighborhood)
neighborhood(X,Y) = environment {
vonNeumann(x,y) =
(coord(x,y), coord(x+1,y)),
(coord(x,y), coord(x-1,y)),
(coord(x,y), coord(x,y+1)),
(coord(x,y), coord(x,y-1));
Moore(x,y) =
(coord(x,y), coord(x+1,y)),
(coord(x,y), coord(x-1,y)),
(coord(x,y), coord(x,y+1)),
(coord(x,y), coord(x,y-1)),
(coord(x,y), coord(x+1,y+1)),
(coord(x,y), coord(x-1,y-1)),
(coord(x,y), coord(x-1,y+1)),
(coord(x,y), coord(x+1,y-1));
coord(x,y) = (1+x+y*X) * (x>=0) * (x<X) * (y>=0) * (y<Y);
};
process = surface(2,2);
/*
0 1 2
3 4 5
6 7 8
0 1
2 3
*/ | https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/surface.dsp | faust | Modeling a 2D surface with a von neumann
von Neumann neighborhood (or 4-neighborhood)
0 1 2
3 4 5
6 7 8
0 1
2 3
|
surface(X,Y) = route(X*Y, X*Y, par(x, X, par(y, Y, neighborhood(X,Y).vonNeumann(x,y) ) ) );
neighborhood(X,Y) = environment {
vonNeumann(x,y) =
(coord(x,y), coord(x+1,y)),
(coord(x,y), coord(x-1,y)),
(coord(x,y), coord(x,y+1)),
(coord(x,y), coord(x,y-1));
Moore(x,y) =
(coord(x,y), coord(x+1,y)),
(coord(x,y), coord(x-1,y)),
(coord(x,y), coord(x,y+1)),
(coord(x,y), coord(x,y-1)),
(coord(x,y), coord(x+1,y+1)),
(coord(x,y), coord(x-1,y-1)),
(coord(x,y), coord(x-1,y+1)),
(coord(x,y), coord(x+1,y-1));
coord(x,y) = (1+x+y*X) * (x>=0) * (x<X) * (y>=0) * (y<Y);
};
process = surface(2,2);
|
e5637d9fa84ae350a821552f2f43f87eea74548ce2e055b9c94ec2a5bf231faf | HexHive/datAFLow | 20100313-ffdelay-bug.dsp | //-------------------------------------------------------------------------------
// bug corrected in version 0.9.14
//-------------------------------------------------------------------------------
// No vector name for : f()
// faust: generator/compile_scal.cpp:1067:
// virtual std::string ScalarCompiler::generateFixDelay(CTree*, CTree*, CTree*):
// Assertion `0' failed.
//-------------------------------------------------------------------------------
//
f = ffunction(float f(), <math.h>, "");
process = f : mem;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/20100313-ffdelay-bug.dsp | faust | -------------------------------------------------------------------------------
bug corrected in version 0.9.14
-------------------------------------------------------------------------------
No vector name for : f()
faust: generator/compile_scal.cpp:1067:
virtual std::string ScalarCompiler::generateFixDelay(CTree*, CTree*, CTree*):
Assertion `0' failed.
-------------------------------------------------------------------------------
| f = ffunction(float f(), <math.h>, "");
process = f : mem;
|
279fbd45734d67432f976c9c75d9a260de2edf3528991cf995692c0e208c59d6 | HexHive/datAFLow | dimensioncheck_5.dsp | process = vectorize(2)<:+:abs:serialize;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/dimensioncheck_5.dsp | faust | process = vectorize(2)<:+:abs:serialize;
|
|
6a80955c73b5595aeaaebd6a41c6c2f5c96621e2c7e881ad18fdd1c5c8e353b1 | HexHive/datAFLow | harpe.dsp | //-----------------------------------------------
// Basic harpe simulation with OSC control
// (based on Karplus-Strong)
//
//-----------------------------------------------
declare name "Harpe";
declare author "Grame";
process = harpe(11); // an 11 strings harpe
//-----------------------------------------------
// whoite noise generator
//-----------------------------------------------
noise = random / RANDMAX
with {
random = +(12345) ~ *(1103515245);
RANDMAX = 2147483647.0;
};
//-----------------------------------------------
// String simulation
//-----------------------------------------------
string(freq, att, level, trig) = noise*level
: *(trig : trigger(freq2samples(freq)))
: resonator(freq2samples(freq), att)
with {
resonator(d, a) = (+ : @(d-1)) ~ (average : *(1.0-a));
average(x) = (x+x')/2;
trigger(n) = upfront : + ~ decay(n) : >(0.0);
upfront(x) = (x-x') > 0.0;
decay(n,x) = x - (x>0.0)/n;
freq2samples(f) = 44100.0/f;
};
//-----------------------------------------------
// Build a N strings harpe
// Each string is triggered by a specific
// position [0..1] of the "hand"
//-----------------------------------------------
harpe(N) = hand <: par(i, N, position((i+0.5)/N)
: string(440 * 2.0^(i/5.0), att, lvl)
: pan((i+0.5)/N))
:> _,_
with {
lvl = hslider("level [unit:f][osc:/accxyz/0 -10 10]", 0.5, 0, 1, 0.01)^2;
att = hslider("attenuation [osc:/1/fader3]", 0, 0, 0.01, 0.001);
hand = hslider("hand[osc:/accxyz/1 -10 10]", 0.43, 0, 1, 0.01):smooth(0.9);
pan(p) = _ <: *(sqrt(1-p)), *(sqrt(p));
position(a,x) = (min(x, x') < a) & (a < max(x, x'));
smooth(c) = *(1.0-c) : + ~ *(c);
};
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/harpe.dsp | faust | -----------------------------------------------
Basic harpe simulation with OSC control
(based on Karplus-Strong)
-----------------------------------------------
an 11 strings harpe
-----------------------------------------------
whoite noise generator
-----------------------------------------------
-----------------------------------------------
String simulation
-----------------------------------------------
-----------------------------------------------
Build a N strings harpe
Each string is triggered by a specific
position [0..1] of the "hand"
----------------------------------------------- |
declare name "Harpe";
declare author "Grame";
noise = random / RANDMAX
with {
random = +(12345) ~ *(1103515245);
RANDMAX = 2147483647.0;
};
string(freq, att, level, trig) = noise*level
: *(trig : trigger(freq2samples(freq)))
: resonator(freq2samples(freq), att)
with {
resonator(d, a) = (+ : @(d-1)) ~ (average : *(1.0-a));
average(x) = (x+x')/2;
trigger(n) = upfront : + ~ decay(n) : >(0.0);
upfront(x) = (x-x') > 0.0;
decay(n,x) = x - (x>0.0)/n;
freq2samples(f) = 44100.0/f;
};
harpe(N) = hand <: par(i, N, position((i+0.5)/N)
: string(440 * 2.0^(i/5.0), att, lvl)
: pan((i+0.5)/N))
:> _,_
with {
lvl = hslider("level [unit:f][osc:/accxyz/0 -10 10]", 0.5, 0, 1, 0.01)^2;
att = hslider("attenuation [osc:/1/fader3]", 0, 0, 0.01, 0.001);
hand = hslider("hand[osc:/accxyz/1 -10 10]", 0.43, 0, 1, 0.01):smooth(0.9);
pan(p) = _ <: *(sqrt(1-p)), *(sqrt(p));
position(a,x) = (min(x, x') < a) & (a < max(x, x'));
smooth(c) = *(1.0-c) : + ~ *(c);
};
|
072f83b0cccfa64313d7a425939a5a5b0820846957dbadb58c6c92bc88b8ca07 | HexHive/datAFLow | switcher.dsp | declare name "switcher";
declare version "1.0";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2007";
//-----------------------------------------------
// Switch between two stereo sources.
// Useful to compare these two sources
// The parameter c\in{0,1} indicates the
// channels to select
//-----------------------------------------------
switch(c,x0,x1,y0,y1) = sel(c,x0,y0), sel(c,x1,y1)
with {
sel(c,x,y) = (1-c)*x + c*y;
};
process = switch(hslider("source 0 <-> source 1",0,0,1,1));
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/switcher.dsp | faust | -----------------------------------------------
Switch between two stereo sources.
Useful to compare these two sources
The parameter c\in{0,1} indicates the
channels to select
----------------------------------------------- | declare name "switcher";
declare version "1.0";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2007";
switch(c,x0,x1,y0,y1) = sel(c,x0,y0), sel(c,x1,y1)
with {
sel(c,x,y) = (1-c)*x + c*y;
};
process = switch(hslider("source 0 <-> source 1",0,0,1,1));
|
112041d27e81e92f06399457f55d14ce468398c540ac327964c8ec2cc19d0cab | HexHive/datAFLow | ratepass_6.dsp | up2 = vectorize(1) <: # : serialize;
dw2 = vectorize(2) : [0];
process = ((up2) ~ dw2, dw2):+; | https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/ratepass_6.dsp | faust | up2 = vectorize(1) <: # : serialize;
dw2 = vectorize(2) : [0];
process = ((up2) ~ dw2, dw2):+; |
|
443b9b40c37aa9f95d918022ac2f29a67e14ec59615013e91cade1e50b0983a3 | HexHive/datAFLow | stereoecho.dsp | declare name "stereoecho";
declare version "1.0";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2007";
//-----------------------------------------------
// A 1 second Stereo Echo
//-----------------------------------------------
import("music.lib");
process = vgroup("stereo echo", (echo1s, echo1s))
with {
echo1s = vgroup("echo 1000", +~(delay(65536, int(hslider("millisecond", 16.3, 0, 1000, 0.10)*millisec)-1) * (hslider("feedback", 90.9, 0, 100, 0.1)/100.0)));
};
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/stereoecho.dsp | faust | -----------------------------------------------
A 1 second Stereo Echo
----------------------------------------------- | declare name "stereoecho";
declare version "1.0";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2007";
import("music.lib");
process = vgroup("stereo echo", (echo1s, echo1s))
with {
echo1s = vgroup("echo 1000", +~(delay(65536, int(hslider("millisecond", 16.3, 0, 1000, 0.10)*millisec)-1) * (hslider("feedback", 90.9, 0, 100, 0.1)/100.0)));
};
|
4e21b0f3dde0b236954d8922f1dd26c1f59f17f7fc811fb9b24659e3de439ff1 | HexHive/datAFLow | tf_exp.dsp |
process = 1,(1 : mem) : - : _,(0 : \(x1).(10,(x1,20.0f : /) : pow)) : * : _<:(_<:(_,((0,(1,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),(1,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : *),(mem : _,((0,(1,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),(1,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : *):>+~(_,(0,((1,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : -),(1,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : -) : *) : \(x2).(\(x3).(x3,x2 : -))~(_<:(_,((2,(1,((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -) : *),((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,1 : @ : _,(((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *):>_) : _<:(_,(((0,(0,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),(1,((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : +),((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,1 : @ : _,((2,(0,(1,((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : -) : *),((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,2 : @ : _,(((0,(0,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),(1,((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : +),((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *):>_),(_<:(_,((1,(0,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),(1,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : *),(mem : _,((1,(0,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),(1,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : *):>+~(_,(0,((1,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : -),(1,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : -) : *) : \(x2).(\(x3).(x3,x2 : -))~(_<:(_,((2,(1,((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -) : *),((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,1 : @ : _,(((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *):>_) : _<:(_,(((1,(0,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),(0,((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : +),((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,1 : @ : _,((2,(1,(0,((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : -) : *),((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,2 : @ : _,(((1,(0,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),(0,((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : +),((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *):>_<:(_<:(_,((0,(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : *),(mem : _,((0,(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : *):>+~(_,(0,((1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : -),(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : -) : *) : \(x2).(\(x3).(x3,x2 : -))~(_<:(_,((2,(1,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -) : *),((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,1 : @ : _,(((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *):>_) : _<:(_,(((0,(0,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),(1,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : +),((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,1 : @ : _,((2,(0,(1,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : -) : *),((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,2 : @ : _,(((0,(0,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),(1,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : +),((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *):>_),(_<:(_,((1,(0,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : *),(mem : _,((1,(0,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : *):>+~(_,(0,((1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : -),(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : -) : *) : \(x2).(\(x3).(x3,x2 : -))~(_<:(_,((2,(1,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -) : *),((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,1 : @ : _,(((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *):>_) : _<:(_,(((1,(0,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),(0,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : +),((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,1 : @ : _,((2,(1,(0,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : -) : *),((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,2 : @ : _,(((1,(0,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),(0,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : +),((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *):>_<:_)) : (\(x4).(\(x5).(x5,x4 : -))~(_<:(_,((2,(1,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -) : *),((1,(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,1 : @ : _,(((1,(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *):>_) : _<:(_,(((1,(-1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),(1,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : +),((1,(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,1 : @ : _,((2,(1,(1,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : -) : *),((1,(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,2 : @ : _,1 : *):>_),_,_ : (_,(10,0.0f : pow) : *),(_,(10,0.0f : pow) : *),(_,(10,0.0f : pow) : *):>_;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/tf_exp.dsp | faust |
process = 1,(1 : mem) : - : _,(0 : \(x1).(10,(x1,20.0f : /) : pow)) : * : _<:(_<:(_,((0,(1,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),(1,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : *),(mem : _,((0,(1,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),(1,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : *):>+~(_,(0,((1,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : -),(1,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : -) : *) : \(x2).(\(x3).(x3,x2 : -))~(_<:(_,((2,(1,((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -) : *),((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,1 : @ : _,(((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *):>_) : _<:(_,(((0,(0,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),(1,((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : +),((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,1 : @ : _,((2,(0,(1,((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : -) : *),((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,2 : @ : _,(((0,(0,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),(1,((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : +),((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *):>_),(_<:(_,((1,(0,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),(1,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : *),(mem : _,((1,(0,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),(1,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : *):>+~(_,(0,((1,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : -),(1,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : -) : *) : \(x2).(\(x3).(x3,x2 : -))~(_<:(_,((2,(1,((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -) : *),((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,1 : @ : _,(((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *):>_) : _<:(_,(((1,(0,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),(0,((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : +),((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,1 : @ : _,((2,(1,(0,((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : -) : *),((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,2 : @ : _,(((1,(0,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),(0,((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : +),((1,(1.0000000000000002f,(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(3553.1412912100559f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *):>_<:(_<:(_,((0,(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : *),(mem : _,((0,(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : *):>+~(_,(0,((1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : -),(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : -) : *) : \(x2).(\(x3).(x3,x2 : -))~(_<:(_,((2,(1,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -) : *),((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,1 : @ : _,(((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *):>_) : _<:(_,(((0,(0,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),(1,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : +),((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,1 : @ : _,((2,(0,(1,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : -) : *),((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,2 : @ : _,(((0,(0,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),(1,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : +),((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *):>_),(_<:(_,((1,(0,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : *),(mem : _,((1,(0,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : *):>+~(_,(0,((1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : -),(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : +) : /) : -) : *) : \(x2).(\(x3).(x3,x2 : -))~(_<:(_,((2,(1,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -) : *),((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,1 : @ : _,(((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *):>_) : _<:(_,(((1,(0,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),(0,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : +),((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,1 : @ : _,((2,(1,(0,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : -) : *),((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,2 : @ : _,(((1,(0,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),(0,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : +),((1,(1.0000000000000002f,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *):>_<:_)) : (\(x4).(\(x5).(x5,x4 : -))~(_<:(_,((2,(1,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -) : *),((1,(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,1 : @ : _,(((1,(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : -),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *):>_) : _<:(_,(((1,(-1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),(1,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : +),((1,(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,1 : @ : _,((2,(1,(1,((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : *) : -) : *),((1,(1,(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +),((1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /),(1,(1776.5706456050279f,(192000.0f,(1.0f,fconstant(int fSamplingFreq, <math.h>) : max) : min) : / : tan) : /) : *) : +) : /) : *),(_,2 : @ : _,1 : *):>_),_,_ : (_,(10,0.0f : pow) : *),(_,(10,0.0f : pow) : *),(_,(10,0.0f : pow) : *):>_;
|
|
cd1795b43b7d48bbb091b8e89d1611d19da4eedbb8f1d1a1fc880c35a13e8a53 | HexHive/datAFLow | multirate_1.dsp | process = vectorize(4); | https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/multirate_1.dsp | faust | process = vectorize(4); |
|
3f115d30c0c591a14453e5754f6c955c264f4e97579a771683ff093e834ec3a5 | HexHive/datAFLow | 20aout08.dsp | // exemple de code pas tres optimisé et pas bien
// normalisé (avec 0994jpar)
neg(x) = -x;
half(x) = x/2;
// process = half : neg;
process = neg : half;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/20aout08.dsp | faust | exemple de code pas tres optimisé et pas bien
normalisé (avec 0994jpar)
process = half : neg; |
neg(x) = -x;
half(x) = x/2;
process = neg : half;
|
e391beffdee2b1b77254d12e1fb93c13e707f496f3bb56930a5af6ff644bbfb5 | HexHive/datAFLow | k-min.dsp |
vol = hslider("volume", 0.2, 0, 1, 0.1);
process = 1 * vol;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/k-min.dsp | faust |
vol = hslider("volume", 0.2, 0, 1, 0.1);
process = 1 * vol;
|
|
005d316843e9330fdc22a3e20a297784654440db2422025aafddaccdfd188cc5 | HexHive/datAFLow | capture.dsp | declare name "capture";
declare version "1.0";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2006";
//-------------------------------------------------
// Capture : record up to 8s of sound and
// playback the recorded sound in loop
//-------------------------------------------------
import("music.lib");
B = button("Capture"); // Capture sound while pressed
I = int(B); // convert button signal from float to integer
R = (I-I') <= 0; // Reset capture when button is pressed
D = (+(I):*(R))~_; // Compute capture duration while button is pressed: 0..NNNN0..MMM
capture = *(B) : (+ : delay(8*65536, D-1)) ~ *(1.0-B) ;
smooth(c) = *(1-c) : +~*(c);
level = hslider("level (db)", 0, -96, 4, 0.1) : db2linear : smooth(0.999);
process = vgroup( "Audio Capture", capture : *(level) ) ;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/capture.dsp | faust | -------------------------------------------------
Capture : record up to 8s of sound and
playback the recorded sound in loop
-------------------------------------------------
Capture sound while pressed
convert button signal from float to integer
Reset capture when button is pressed
Compute capture duration while button is pressed: 0..NNNN0..MMM | declare name "capture";
declare version "1.0";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2006";
import("music.lib");
capture = *(B) : (+ : delay(8*65536, D-1)) ~ *(1.0-B) ;
smooth(c) = *(1-c) : +~*(c);
level = hslider("level (db)", 0, -96, 4, 0.1) : db2linear : smooth(0.999);
process = vgroup( "Audio Capture", capture : *(level) ) ;
|
1b34e20551390d8fcdfcdaadb85bb7251857b701e552f0dab0dee8a9d9c0c80a | HexHive/datAFLow | test27.dsp | // bug conan : this program should compile but it doesn't on faust-0.9.9.1
process = ffunction(int random (), <stdlib.h>, "");
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/test27.dsp | faust | bug conan : this program should compile but it doesn't on faust-0.9.9.1 |
process = ffunction(int random (), <stdlib.h>, "");
|
6edd630006ef634862d8ada8c1c272e30fa4bce85dcd4c262a505b5dd75b5cc8 | HexHive/datAFLow | dimensioncheck_6.dsp | process = vectorize(2)<:/:serialize;
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/dimensioncheck_6.dsp | faust | process = vectorize(2)<:/:serialize;
|
|
425bb6604ddb67bbd676e0777a2c14659d2f7a16b1f7b83538df6aff9df1b6e0 | HexHive/datAFLow | bandfilter.dsp | declare name "bandfilter";
declare version "1.0";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2006";
import("math.lib");
import("music.lib");
//---------------------second order filter--------------------------
// filter(Q,F,G)
// Q : quality factor [1..100]
// F : frequency (Hz)
// G : gain [0..1]
//------------------------------------------------------------------
filter(Q,F,G) = TF2((1 + K/Q + K*K) / D,
2 * (K*K - 1) / D,
(1 - K/Q + K*K) / D,
2 * (K*K - 1) / D,
(1 - V*K/Q + K*K) / D
)
with {
V = db2linear(G);
K = tan(PI*F/SR);
D = 1 + V*K/Q + K*K;
};
//--------------- Band Filter with user interface ------------------
// bandfilter(F)
// F : default frequency (Hz)
//
//------------------------------------------------------------------
bandfilter(F) = filter(nentry("Q factor [style:knob]",50,0.1,100,0.1),
nentry("freq [unit:Hz][style:knob]", F, 20, 20000, 1),
0 - vslider("gain [unit:dB]", 0, -50, 50, 0.1)
);
//------------------------- Process --------------------------------
process = vgroup("Bandfilter", bandfilter(1000));
| https://raw.githubusercontent.com/HexHive/datAFLow/b9f3cbc42b1970f8655817c9fb67b1eaba3ae4c0/evaluation/ddfuzz/seeds/faust/bandfilter.dsp | faust | ---------------------second order filter--------------------------
filter(Q,F,G)
Q : quality factor [1..100]
F : frequency (Hz)
G : gain [0..1]
------------------------------------------------------------------
--------------- Band Filter with user interface ------------------
bandfilter(F)
F : default frequency (Hz)
------------------------------------------------------------------
------------------------- Process -------------------------------- | declare name "bandfilter";
declare version "1.0";
declare author "Grame";
declare license "BSD";
declare copyright "(c)GRAME 2006";
import("math.lib");
import("music.lib");
filter(Q,F,G) = TF2((1 + K/Q + K*K) / D,
2 * (K*K - 1) / D,
(1 - K/Q + K*K) / D,
2 * (K*K - 1) / D,
(1 - V*K/Q + K*K) / D
)
with {
V = db2linear(G);
K = tan(PI*F/SR);
D = 1 + V*K/Q + K*K;
};
bandfilter(F) = filter(nentry("Q factor [style:knob]",50,0.1,100,0.1),
nentry("freq [unit:Hz][style:knob]", F, 20, 20000, 1),
0 - vslider("gain [unit:dB]", 0, -50, 50, 0.1)
);
process = vgroup("Bandfilter", bandfilter(1000));
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.