Conventions

• All examples use fs = 44100 Hz, so Nyquist = 22050 Hz.
• Faust notation: x' is x delayed by 1 sample, x'' by 2 samples. In f ~ g the signal fed back through g arrives with a 1-sample delay.
• “Phase delay” is measured in degrees and is positive when the output is late.
• Click on any figure to open it at full size.

1. Delay + sum: cancellation or reinforcement

1.1 Phase as a wheel

Before adding anything, it helps to picture a sinusoid as a point going round a wheel: one full cycle of the sinusoid is one full turn, 360°. At every sample the wheel turns by a fixed angle, which depends on the frequency:

angle per sample = 360° × f / fs

So delaying by one sample means turning the wheel back by that angle. The same 1-sample delay is a tiny angle at low frequencies and a big one at high frequencies. Keep this in mind: it is the seed of everything in section 4.

1.2 Adding the delayed copy

Take a sinusoid as input and imagine sweeping its frequency. What happens if we delay it by one sample and add it to the original?

• At 22050 Hz the delayed copy is half a cycle (180°) late, i.e. upside down: perfect cancellation. Why? At 44100 samples per second a 22050 Hz sinusoid takes 2 samples to complete a cycle: one positive, one negative. Delayed by one sample, wherever the original is +1 the copy is −1. They are exactly in opposite phase.
• Going down in frequency the cancellation decreases gradually, but not in a straight line. It follows a cosine: amplitude = 2·|cos(π·f/fs)|
  • at 11025 Hz a cycle lasts 4 samples, so 1 sample is a quarter cycle (90°): amplitude 1.41 (√2);
  • at 5512 Hz a cycle lasts 8 samples, 1 sample = 45°: amplitude 1.85;
  • at 2756 Hz a cycle lasts 16 samples, 1 sample = 22.5°: amplitude 1.96.
• At 0 Hz the two signals are perfectly in phase: reinforcement, amplitude 2.

Where does the cosine come from? On the wheel, x and x’ are two arrows of the same length, separated by the angle of one sample. Their sum is an arrow whose length depends on that angle: 2 when they point the same way (0°), 0 when they point in opposite directions (180°), √2 when they are at right angles (90°). In general it is 2·cos(angle/2). (Adding arrows on a wheel will come back in section 6.)

Sample by sample (the sum is in green, with its continuous curve):

In the middle panel the green diamonds land at ±1, not ±1.41: the samples simply do not fall on the peak of the sum. The thin green curve shows the true amplitude.

And as a gain curve over the whole spectrum:

This is a FIR (Finite Impulse Response) lowpass filter. If instead of adding we subtract the copy (x − x'), we turn it upside down ourselves before adding it, and everything flips: a notch at 0 Hz, i.e. a highpass (dashed curve).

import("stdfaust.lib");

// 1-sample delay + sum (lowpass) or subtraction (highpass)
lowpass = _ <: _, mem :> _;           // x + x'
highpass = _ <: _, (mem : *(-1)) :> _; // x - x'

process = lowpass;

1.3 FIR and feedback: zeros and poles

There are two ways of using the delayed copy:

• FIR: the copy is added once. Where the copy arrives upside down, it cancels the original → a zero, i.e. a notch in the spectrum.
• Feedback: the output goes back to the input, so the copy comes back again and again, one lap after the other. Where it comes back in phase, each lap adds to the previous ones and the signal builds up → a pole, i.e. a peak. It does the opposite of a zero.

The sign decides where the effect happens:

Why does the one-pole with − peak at 22050 Hz? The 22050 Hz signal (+1, −1, +1…) arrives inverted after one sample, and the minus sign inverts it again: it comes back in phase and builds up.

FIR and feedback are not symmetric:

• FIR: one copy can cancel another exactly (silence), but as a reinforcement it reaches at most 2 (the original plus one copy).
• Feedback: the signal comes back forever, so the reinforcement accumulates lap after lap. With a feedback coefficient a = 0.9, at 0 Hz it reaches 10 times the input, i.e. +20 dB. But a total cancellation is never possible.

1.4 Why the feedback needs a coefficient

In the feedback, the coefficient keeps the filter from blowing up. Example with a one-pole (y = x + a·y') and a constant input equal to 1 (a “step”):

• without a coefficient (a = 1): each output is “input + previous output”, so 1, 2, 3, 4… it grows forever. With a > 1 it is even worse: it grows exponentially, and keeps growing after the input stops;
• with a = 0.9: only 90% comes back each lap: 1, 1.9, 2.71, 3.44… The steps get smaller and smaller and the output settles at 1 / (1 − a) = 10;
• with a = 0.5: it settles at 2, and much faster.

The rule: feedback is stable only if |a| < 1. The closer a is to 1, the higher the peak, and the longer the filter takes to settle (roughly 1/(1 − a) samples: about 10 samples for a = 0.9, 100 for a = 0.99). Remember this “slowness”: it will explain, in section 4, why an allpass delays some frequencies more than others.

With a negative a (dashed curve) the peak moves to 22050 Hz, as in the table above.

import("stdfaust.lib");

// one-pole: y = x + a * y'   (~ feeds the output back with a 1-sample delay)
onepole(a) = + ~ *(a);

process = onepole(0.9);

So the coefficient decides how deep the notch is (g, in the FIR) or how high the peak is (a, in the feedback), depending on the kind of filter.

Recap of section 1. A delayed copy is an angle that grows with frequency. Added once (FIR) it can cancel exactly: a zero, a notch. Fed back (feedback) it can build up: a pole, a peak. The coefficient sets how strong, and in feedback it must stay below 1.

2. Longer delays: the comb

2.1 The phase grows D times faster

With a delay of D samples, the angle of the copy grows D times faster with frequency:

phase shift = 360° × f × D / fs

The horizontal lines say what the copy looks like: at 180°, 540°, 900°… it is inverted; at 360°, 720°, 1080°… it is the same again (inverted twice, four times…). 360° is a full turn of the wheel, so the copy lines up with the original again.

• D = 1 only reaches 180°: a single cancellation, at 22050 Hz;
• D = 2 reaches 360°: inverted at 11025 Hz, the same again at 22050 Hz;
• D = 4 reaches 720°: inverted at 5512 and 16537 Hz, the same at 11025 and 22050 Hz.

It helps to check D = 2 sample by sample:

22050 Hz (period 2 samples):  +1 −1 +1 −1 +1 −1
  delayed by 2:                ·  · +1 −1 +1 −1    → identical: reinforcement
11025 Hz (period 4 samples):  +1  0 −1  0 +1  0 −1
  delayed by 2:                ·  · +1  0 −1  0 +1 → inverted: cancellation

The rule: a frequency is reinforced when, during the delay, it completes a whole number of cycles (0, 1, 2…), because the delayed copy lines up with the original. It is cancelled when it completes a whole number of cycles plus a half. So the peaks of a comb are every fs/D Hz. The longer the delay, the more frequencies fit a whole number of cycles inside it, and the more peaks there are: the “teeth” of the comb.

A common misconception: “if I lengthen the delay by one sample, the peak moves down to half the frequency, then half again.” The peaks do not move down: they multiply, and they are spaced fs/D apart. With feedback +, D = 1 has a peak at 0 Hz; D = 2 at 0 and 22050 Hz; D = 3 at 0 and 14700 Hz. With feedback − the peaks sit halfway between: D = 1 at 22050 Hz; D = 2 at 11025 Hz; D = 3 at 7350 and 22050 Hz.

2.2 Peaks and notches

With feedback (y = x + g·y[n−D]) the frequencies where the copy comes back the same become peaks (poles). With the FIR (x + x[n−D]) the frequencies where it comes back inverted become notches (zeros). On the right of each row is the “circle” of poles (x) and zeros (o), explained in the next section:

import("stdfaust.lib");

// comb with delay D: feedback (peaks) and FIR (notches)
// ~ already adds 1 sample, so the delay inside the feedback is D - 1
combFB(D, g) = + ~ (@(D - 1) : *(g));   // y = x + g * y[n-D]
combFIR(D) = _ <: _, @(D) :> _;         // y = x + x[n-D]

process = combFB(4, 0.8);

2.3 The circle of poles and zeros

Now that we have FIR, feedback, coefficients and delays, we can read the “circle” (the z-plane). It is a map on which poles and zeros are drawn, and from which the response of a filter can be read:

• The angle on the circle is the frequency. On the right (0°) is 0 Hz, at the top (90°) is 11025 Hz, on the left (180°) is 22050 Hz. It is the same wheel as in 1.1: one sample of delay at 11025 Hz is a quarter turn.
• A pole (x) makes a peak at the frequency of its angle. The closer it is to the edge, the higher and narrower the peak. Towards the centre the peak becomes low and wide. On the edge or outside, the filter becomes unstable: it is the a ≥ 1 case of 1.4.
• A zero (o) makes a notch at the frequency of its angle. If it sits exactly on the edge, the notch is total (silence). The further it moves away from the edge, the shallower the notch.

From left to right:

1. one-pole a = 0.5: the pole is halfway towards 0 Hz, so the peak is low and wide;
2. a = 0.9: the pole is close to the edge, so the peak is high (+20 dB) and narrow;
3. a = −0.9: the same pole, but on the left, so the peak moves to 22050 Hz;
4. FIR x + x’: a zero on the edge at 22050 Hz, total notch;
5. FIR x + 0.5·x’: a zero inside the circle, partial notch.

In the D = 4 comb above there are 4 poles spread around the circle (0, 11025, 22050 Hz, plus the mirror of 11025 Hz below) and 4 zeros halfway between them. The delay D decides how many poles and zeros there are and where they sit (every 360°/D). The coefficient decides how close they are to the edge.

The lower half of the circle mirrors the upper half: for a real signal it holds the same information. It is the same mirror as in the next section.

2.4 Above 22050 Hz: the mirror (aliasing)

The phase count could go on above 22050 Hz: with D = 2 there would be a cancellation at 33075 Hz and the phase would line up again at 44100 Hz. But in the digital world those frequencies do not exist as different frequencies: two sinusoids at f and at fs − f produce exactly the same samples.

On the left: at 44100 Hz, a 5000 Hz sinusoid and a 39100 Hz one (= 44100 − 5000) go through the same points. The digital system only sees the samples, so it cannot tell them apart. That is why everything above fs/2 folds back as in a mirror: 33075 Hz behaves like 11025 Hz. Looking from 0 to fs/2 is enough.

What about 96 kHz or 192 kHz? It works the same way, but the mirror moves: it always sits at half the sampling rate. On the right of the plot: at 44.1 kHz the folding happens at 22.05 kHz, at 96 kHz at 48 kHz (at 192 kHz it would be at 96 kHz). So:

• every rule in these notes holds, as long as frequencies are measured as a fraction of fs (0 Hz, fs/4, fs/2…);
• one sample lasts less time: at 96 kHz about 10 µs instead of 23 µs. The lowpass x + x' has its notch at fs/2 = 48 kHz, outside the audible range, and is almost flat in the audio band. To get the same filter in Hz, the delays must be doubled (or the coefficients recalculated);
• the advantage of a high fs is more room above the audible range before the mirror.

3. The allpass

An allpass is a filter with the same amplitude at every frequency that still changes the signal: it changes its phase. To see how that is possible, look at its topology. It contains:

• a FIR part (direct signal + delayed signal, with a certain sign) that creates notches;
• a part that feeds back and fills exactly those notches with poles.

The result is a flat filter: the same amplitude at every frequency.

Reading the diagram from the left:

1. FIR part (blue): the signal splits in two: one part is multiplied by −g, the other is delayed by D samples. They are added once: −g·x + x[n−D]. It is a FIR comb, so it makes notches every fs/D Hz.
2. Feedback part (red): the output comes back delayed by D samples, multiplied by g, and is added to the input: + g·y[n−D]. It is a feedback comb, so it makes peaks every fs/D Hz, in the same places as the notches.

The two parts on their own, and the result:

At 0 Hz the FIR has a notch (0.5) and the feedback a peak (2): 0.5 × 2 = 1. At 2205 Hz the FIR has a peak (1.5) and the feedback a notch (0.667): 1.5 × 0.667 = 1. And so on at every frequency, so the black line is flat.

Two important points:

• FIR and feedback are in series, not in parallel. The signal goes through the FIR first and then through the feedback. In series the gains multiply (notch 0.5 × peak 2 = 1). In parallel they would add up, and nothing would compensate. In the classic diagram the two parts share the same delay line to save memory, so they look like a single block, but they are two pieces in series.

  A common misconception: “two separate branches leave x: one is a FIR with delay D and gain g that makes the zeros, the other is a feedback with the same D and g that makes the poles, and they cancel each other.” The idea of poles and zeros compensating is right, but the two parts are one after the other (series), not side by side. And, as the next point shows, they do not cancel completely.

• The FIR coefficients are swapped. The allpass FIR is “first −g, then 1”, while the feedback is “1, then −g”. It is the same FIR, reversed in time. A signal reversed in time has:

  • the same amplitude at every frequency, so the same notches;
  • a different phase.

  If the FIR were identical to the feedback (1, …, −g), it would remove the signal before it enters the loop, and the loop would have nothing left to build up: everything would cancel, amplitude and phase. What remains is a wire, which is useless. With the reversed FIR the notches are the same, but the phase is not:

The amplitude compensates, the phase does not. The allpass only changes the phase. This is the most important idea in these notes.

The compensation happens over time: the impulse response is a tail (−0.5, 0.75, 0.375, 0.188… every D samples), not a single impulse. On transients you can hear it; on steady sinusoids the volume is flat.

import("stdfaust.lib");

// Schroeder allpass: FIR and feedback in series, same delay D and same g
D = 10;
g = 0.5;
fir = _ <: *(-g), @(D) :> _;          // -g * x + x[n-D]     (the zeros)
iir = + ~ (@(D - 1) : *(g));          // y = in + g * y[n-D] (the poles)
allpass = fir : iir;

// with the FIR equal to the feedback (1, ..., -g) poles and zeros cancel: a wire
firSame = _ <: _, (@(D) : *(-g)) :> _;
wire = firSame : iir;

process = allpass;

A question that comes up: “So an allpass is just a neutral delay?” Not quite. If you mix it with the dry signal you do get notches, as with a comb. But an allpass is not a delay of a fixed time: it is a delay that is different at every frequency. That is what the next section is about.

4. Time delay and phase in degrees are two different things

When a frequency comes out “late”, two different things can be measured:

• the time delay: how long after the input it arrives (in samples or ms);
• the phase delay: how many degrees behind the input it is.

They are linked by:

phase delay (degrees) = 360° × f × time delay (samples) / fs

The same time delay gives different angles at different frequencies: 1 sample is a lot for a fast frequency and very little for a slow one (the wheel of 1.1).

• Pure delay: every frequency arrives after the same time, so the angle grows in a straight line (the lines of section 2). Mixed with x it gives the comb: fixed, evenly spaced notches.
• Allpass: every frequency arrives after a different time.

4.1 Why different times: two roads

First-order allpass with c = −0.9 (the 1-sample allpass used in phasers):

y[n] = −0.9·x[n] + x[n−1]  +  0.9·y[n−1]
       └──── fast road ────┘   └─ slow road ─┘

• The slow road is a one-pole lowpass (the loop with +0.9 from 1.4). The lows go round the loop and build up, but building up takes time (about 10 samples for a = 0.9), so they come out late.
• The fast road is the direct FIR. In the loop, the highs flip sign at each lap and die out, so they come out almost only through the direct road: at once.
• “Flat” says how much comes out, not when. Part of the signal travels fast, part slowly.

You can see it with the step response (input jumping from 0 to 1):

The edge of the step (highs) comes out at once, at −0.9. The level (lows) arrives after 20–40 samples, as slowly as the one-pole.

The same can be measured frequency by frequency: how long each frequency takes to come out (this is called group delay):

• with c = −0.9 the lows come out after 19 samples, the highs almost at once;
• with c = 0 every frequency comes out after 1 sample: it is a delay;
• with c = 0.5 it is the other way round: the highs come out late (the pole is towards 22050 Hz).

Where the loop resonates, the signal stays in it for a long time, so it comes out late. The FIR can compensate the height of the peak, but it cannot make the loop release earlier what it holds: to do that it would need to know the future.

import("stdfaust.lib");

// first-order allpass: H(z) = (c + z^-1) / (1 + c z^-1)
// y = c * x + x' - c * y'   (c = 0: a 1-sample delay)
ap1(c) = _ <: *(c), mem :> (+ ~ *(-c));

process = ap1(-0.9);

A question that comes up: “If the filter is flat and the poles fill the notches, why should different frequencies have different delays?” Because flat amplitude only means that, in the end, the same amount of each frequency comes out. The frequencies near the pole get there by going round the loop many times; the others take the direct road. Same amount, different travel time.

4.2 A sinusoid through the allpass

Send a sinusoid x through the allpass and compare the output with the direct x:

• at 0 Hz they are in phase;
• going up in frequency, the output is more and more delayed, in degrees;
• at 22050 Hz it is half a cycle (180°) behind;
• the amplitude is always the same.

The first-order allpass has the same start and end points as the 1-sample delay (0° and 180°). What changes is the road in between:

On the left with a linear frequency axis, on the right in octaves (like the display of an EQ). With c = 0 the allpass is exactly the 1-sample delay (the grey line).

Watch out, time versus degrees. With c = −0.9 the lows have a lot of time delay (19 samples) but few degrees: a cycle at 100 Hz lasts 441 samples, so 19 samples are only 15°. The highs have almost no time delay but many degrees. “The lows are the most delayed” is true in time and false in degrees.

On the octave axis (right) each curve looks like a stretched S: flat in the lows, steep around one frequency, flat again near 180°. The steep part is where the pole acts, and c moves it left or right.

A comb made allpass (D = 10) has different phase delays in different parts of the spectrum, in correspondence with the poles of the comb (0, 4410, 8820… Hz):

The allpass goes through the same points as the delay (0°, 180°, 360°…), but near the poles the angle climbs steeply and between poles it almost stops.

Rule: where there is a pole, the angle climbs steeply with frequency, because there the signal has a lot of time delay. The coefficient moves the pole, and with it the climbing zone.

4.3 The phaser

Allpass + dry signal → a notch where the angle of the allpass is 180° (the two are in opposite phase). Since c moves the curve, c moves the notch:

With c = 0 the two allpass are two samples of delay, and the notch at 11025 Hz is exactly the one of the D = 2 FIR comb of section 2.

• comb = the same time for every frequency → fixed notches;
• phaser = a different time for each frequency → notches that move.

import("stdfaust.lib");

ap1(c) = _ <: *(c), mem :> (+ ~ *(-c));

// minimal phaser: 2 allpass + dry, c moves the notch
phaser(c) = _ <: _, (ap1(c) : ap1(c)) :> *(0.5);

process = phaser(-0.5);

Try it. Listen to the difference on noise: on the left a comb (dry + 8-sample delay), on the right a phaser (dry + 4 allpass). Move c and only the right channel changes.

import("stdfaust.lib");

ap1(c) = _ <: *(c), mem :> (+ ~ *(-c));

// left: dry + pure delay = comb (same time for every frequency: fixed, evenly spaced notches)
// right: dry + 4 allpass = phaser (different time per frequency: notches move with c)
comb(D) = _ <: _, @(D) :> *(0.5);
phaser4(c) = _ <: _, seq(i, 4, ap1(c)) :> *(0.5);

c = hslider("c", -0.7, -0.99, 0.99, 0.01) : si.smoo;
process = no.noise * 0.5 <: comb(8), phaser4(c);

5. The goal: the same angle at every frequency

A phase shifter wants to move every frequency by the same angle. For 90°, a quarter of a cycle, the delay would have to equal a quarter of the period of each frequency:

110 samples at 100 Hz, 11 at 1000 Hz, 1.1 at 10000 Hz: the lows delayed a lot, the highs almost not at all. A delay cannot do it, because it gives every frequency the same time.

One allpass cannot do it either. It does hold the lows longer than the highs, so it goes in the right direction, but its curve crosses 90° at a single frequency:

With an allpass tuned to give 90° at 1 kHz, the output is only 11° behind x at 100 Hz and 158° behind at 5000 Hz.

The solution splits into two separate problems, which the next two sections solve one at a time:

1. Section 6: if we already had the signal at 0° and the same signal at 90° (at every frequency), how would we get any other angle? Answer: a crossfade.
2. Section 7: how do we get the signal at 90°? Answer: with two allpass chains, not one.

6. The crossfade

Step 1: two ingredients

Suppose we have two signals:

• I = the signal at 0° (I for in-phase);
• Q = the same signal at 90°, i.e. delayed by a quarter cycle, at every frequency (Q for quadrature, which means “at 90°”).

How to build Q is the topic of section 7. For now, imagine we have it.

Step 2: mix them with two weights

y = I·cos(θ) + Q·sin(θ)

It is a crossfade between I and Q in which the two volumes come from the circle:

With the negative weights (I upside down is “180°”, Q upside down is “270°”) the crossfade covers the whole turn, not only 0° to 90°.

Step 3: why the phase lands “in between”

Two sinusoids of the same frequency, added together, give another sinusoid of that frequency, with a phase in between. The more weight we give to Q, the closer we get to “90° of delay”:

It is the arrow sum of 1.2 again: I and Q are two arrows at right angles on the wheel, and weighting them with cos θ and sin θ gives an arrow at angle θ. In trigonometry this is cos(a − θ) = cos(a)·cos(θ) + sin(a)·sin(θ): to shift a cosine by θ, all you need is the cosine itself (I) and its 90° version (Q), mixed with cos θ and sin θ.

Step 4: why cos and sin

cos and sin keep the volume constant, because cos² θ + sin² θ = 1 (Pythagoras on the circle). It is the same law as an equal-power pan. With a linear crossfade, halfway (45°) the volume would drop.

Step 5: why it works at every frequency

The weights cos θ and sin θ do not depend on frequency: they are just two volumes. So every frequency is shifted by the same θ. And the time adapts by itself:

45° is 55 samples at 100 Hz and 5.5 samples at 1000 Hz. That is exactly the “lows delayed a lot, highs a little” of section 5. The hard work, the frequency-dependent part, is done once, when building Q. After that, changing θ means turning two volume knobs.

Step 6: the sign

• y = I·cos θ + Q·sin θ delays by θ. This is the version used in the code: the “Phase Shift” slider at 90 means 90° of delay.
• y = I·cos θ − Q·sin θ (with a minus) turns the wheel the other way: it advances by θ. Musically it is the same (advancing by 90° = delaying by 270°), but if the slider must be a delay, the sign must be +.

import("stdfaust.lib");

// crossfade: from I (0 degrees) and Q (90 degrees) to any angle
// y = I * cos(theta) + Q * sin(theta): delays by theta degrees
rotate(degrees) = *(cos(theta)), *(sin(theta)) :> _
with {
    theta = degrees * ma.PI / 180.0;
};

process = rotate(hslider("Phase Shift [unit:°]", 45.0, 0.0, 360.0, 1.0) : si.smoo);

Analogy: the Hilbert transform builds two loudspeakers, one at 0° and one at 90°. The crossfade is the pan that places the sound anywhere around the circle. Without the crossfade we would only have 0° or 90°.

Building Q is called the Hilbert transform. So the second problem is: build Q.

Questions that come up

“If the allpass chains already make the 90°, what does the crossfade control?” The angle of the output. The allpass chains give two fixed references (0° and 90°); the crossfade, i.e. the slider, chooses where to be between and around them.

“With a single stage, can I control at most 90°?” No. 90° is the fixed distance between I and Q, not the range of the slider. Thanks to the negative weights, a single stage covers the whole turn, 0–360°.

“If I set 1080°, is the output three cycles behind?” On a steady sinusoid, three whole cycles behind is identical to the original: phase lives on a circle, and 1080° = 3 turns = 0°. A phase shifter cannot delay the attack of a sound by three cycles, because three cycles last 30 ms at 100 Hz but 3 ms at 1 kHz. That would be a delay of a different time at every frequency, a different device. What a range larger than 360° does give, in a feedback loop, is a longer sweep: while θ moves through 1080°, every phase relation is crossed three times.

7. Building I and Q

Step 1: a perfect Q does not exist

A constant (0 Hz) has no cycles, so it cannot be “a quarter cycle late”. And near 0 Hz the delays would become huge (plot of section 5): 90° is about 11000 samples at 1 Hz, 110000 at 0.1 Hz… a filter that holds the signal forever. So we accept that below ~20 Hz it does not work (and, by the mirror of 2.4, near 22050 Hz).

Step 2: the trick, do not compare with x

The crossfade only uses I and Q, never x. So we do not need Q to be 90° behind x: we need Q to be 90° behind I. And I does not have to be x.

So x goes through two different chains of allpass. With respect to x, both shift the phase in a frequency-dependent way. Between them, though, they always stay 90° apart, like the two rails of a railway: they bend, but the distance between them stays the same.

For example: at 100 Hz I is 392° behind x and Q 482°; at 1000 Hz 863° and 953°; at 5000 Hz 1223° and 1313°. Always 90° apart.

The consequence: the output is shifted by θ with respect to I, not with respect to x. With θ = 0 we do not get x back, but x after the allpass chain. When comparing or measuring, the right reference is I.

Step 3: how the two curves are kept “parallel”

• Allpass filters in series add their angles. If the first delays a frequency by 30° and the second by 50°, together they make 80°.
• Each allpass makes a climb of 180° around its pole (section 4).
• The climbs alternate between the two branches: Q makes each climb half a step before I. Half a climb = 90°.

Start with a single pair: Q’s pole low (~400 Hz), I’s pole high (~2400 Hz):

• in the lows neither has climbed yet, so they are close;
• in the middle Q has already climbed and I has not yet: distance ~90°;
• in the highs both have climbed, so they are close again.

The distance draws a small hill topping at ~90°. Between 700 and 1400 Hz this is already a phase shifter (maximum error 1.7°), but over a single octave.

More alternating pairs widen the good zone:

Top: with 4 allpass per branch the climbs (▲) alternate, Q, I, Q, I… from lows to highs, and Q always stays half a step ahead. Bottom, the distance between I and Q:

• 1 + 1: ~90° (± 1.7°) only between 700 and 1400 Hz;
• 2 + 2: ± 8° between 100 and 8000 Hz;
• 4 + 4: ± 4.8° between 20 and 20000 Hz.

(examples with 1-sample allpass, coefficients optimised by computer)

Step 4: the two blocks of the phase shifter

x ──► [many allpass, fixed coefficients c] ──► I ──► ×cos θ ──┐
  └─► [many allpass, other fixed c]        ──► Q ──► ×sin θ ──┴─(+)──► output
          └── Hilbert: builds the 90° ──┘           └── crossfade: chooses θ ──┘

• Hilbert is fixed. Its calibration is the set of coefficients c, which decide where the poles are, i.e. where the climbs happen. They are not computed by hand: an optimisation finds them (Niemitalo used a genetic algorithm, Vicanek a numerical optimisation, Laurent de Soras’ hiir library a design formula).
• Crossfade: cos and sin only choose θ. It is the “Phase Shift” slider.

A common confusion: “so the phase shifter is many allpass filters calibrated with sine and cosine?” No: the two parts are separate. The calibration of the 90° is done by the coefficients of the allpass filters. Sine and cosine appear only in the crossfade, as the two volumes that choose θ.

Step 5: the brick of the code, a 2-sample allpass

In the code the “brick” is not the 1-sample allpass of the examples, but a 2-sample one:

tf(c, y, x) = c * (x + y') - x'';   // used as tf(c) ~ _

~ _ feeds the output back with a 1-sample delay, so inside tf y' is the output from 2 samples ago and x'' the input from 2 samples ago:

y[n] = c·x[n] − x[n−2]  +  c·y[n−2]
       └─ FIR (fast) ─┘    └ loop (slow) ┘

It is the Schroeder allpass of section 3 with D = 2: FIR and loop with the same coefficient, the FIR reversed (with the sign flipped: at 0 Hz each section turns the signal upside down, but with an even number of sections the inversions cancel out). And from section 2 we know that a loop with D = 2 resonates at 0 Hz and at 22050 Hz at the same time. So each section makes the same climb as the 1-sample allpass in the lows, plus a second, mirrored climb towards 22050 Hz:

This is why the Hilbert of the code works poorly both near 0 Hz and near 22050 Hz: the mirror.

The Q branch has an extra 1-sample delay (x'). At 11025 Hz two samples are half a cycle, so every section is transparent there: the only difference between I and Q is x', and at 11025 Hz one sample is exactly 90° (the wheel of 1.1). In the lows the sections make almost all of the 90°; going up, more and more of it comes from x':

8. Vicanek’s improvement

The structure is the same (same brick, two branches, crossfade). Only the number of allpass and the coefficients change, computed for a higher order. As Oleg Nesterov points out in the mailing-list thread, Niemitalo’s and Vicanek’s filters belong to the same family (polyphase half-band IIR, like the hiir library). Vicanek computed and published one set of coefficients for 8 + 8 allpass: one among many possible.

Why “many possible”? A designer like hiir asks for two things: how many allpass to use, and how far the filter must work, i.e. how close to 0 Hz and to Nyquist. With a fixed number of climbs one can either concentrate them in the middle of the band (the distance stays extremely close to 90°, but the filter gives up earlier in the deep lows) or spread them towards the lows (it works lower, but the distance wobbles more around 90°). Each choice gives a different set of coefficients.

More climbs, closer together, make the distance smoother and closer to 90°:

• Niemitalo wobbles by ±0.7° over the whole band;
• Vicanek stays below 0.0015° from ~35 Hz up;
• below ~20 Hz both give up in the same way. Vicanek used the extra sections to be more precise, not to reach lower.

When does it matter?

• Slider still: almost inaudible. 0.7° of error changes the volume by about ±0.05 dB as θ varies.
• θ moving (the phase shifter becomes a frequency shifter, see “Try it” below): the error creates a “ghost copy” shifted in the wrong direction. In the worst case it is at −44 dB with Niemitalo and −98 dB with Vicanek (measured with a 1 kHz sine shifted by +100 Hz: −55 dB versus −99 dB).
• Many stages in cascade: the errors add up.

The price: roughly twice the CPU, and the lows come out a little later (more allpass, more “slow road”). At 30 Hz the I branch delays by about 318 samples with Niemitalo and 558 with Vicanek; at 1 kHz about 13 versus 27.

The code: Hilbert_Vicanek_Phase_Shifter.dsp

Hilbert transform with Vicanek’s coefficients. It has a single stage (slider 0–360°) and a version with N stages in cascade (slider 0–1080°, divided among the stages). It outputs both the reference (real branch, 0°) and the rotated signal; in an acoustic feedback loop (one microphone, one loudspeaker) only the rotated signal is used.

import("stdfaust.lib");

// Phase shifter using the Hilbert transform
// Martin Vicanek coefficients (8 + 8 allpass)
// Phase Shifter Using a Hilbert Transformer
hilbertPHshift(degrees, x) = realPH, output
with {
    analytic(x) = real, imaginary
    with {
        re_c = (0.0406273391966415, 
                0.2984386654059753,
                0.5938455547890998, 
                0.7953345677003365,
                0.9040699927853059, 
                0.9568366727621767,
                0.9815966237057977, 
                0.9938718801312583);
        im_c = (0.1500685240941415, 
                0.4538477444783975,
                0.7081016258869689, 
                0.8589957406397113,
                0.9353623391637175, 
                0.9715130669899118,
                0.9886689766148302, 
                0.9980623781456869);
        tf(c, y, x) = c * (x + y') - x'';
        real =      x  : seq(i, 8, tf(ba.take(i + 1, re_c)) ~ _);
        imaginary = x' : seq(i, 8, tf(ba.take(i + 1, im_c)) ~ _);
    };
    realPH = x : analytic : _, !;
    quadraturePH = x : analytic : !, _;
    output = realPH * cos((degrees * ma.PI / 180.0)) + quadraturePH * sin((degrees * ma.PI / 180.0));
};
HilbertPhaseShifter = hilbertPHshift(hslider("Phase Shift °", 0.0, 0.0, 360.0, 1.0) : si.smoo);

// N stages in cascade: each stage rotates by (slider / N), total N * (slider / N) = slider
// reference: x passed N times through the real branch (0° rotation)
N = 6;
HilbertPhaseShifterN = _ <: seq(i, N, hilbertPHshift(0.0) : _, !),
                            seq(i, N, hilbertPHshift(degreesN) : !, _)
with {
    degreesN = hslider("Phase Shift N°", 0.0, 0.0, 1080.0, 1.0) / N : si.smoo;
};

//process = co.compressor_mono(6, -18, 0.001, 0.05) : HilbertPhaseShifter;
// feedback (1 mic = 1 speaker): rotated output only, the reference is just for testing
process = co.compressor_mono(6, -18, 0.001, 0.05) : HilbertPhaseShifterN : !, _;
//process = os.osc(800) : HilbertPhaseShifter;
//process = os.osc(800) : HilbertPhaseShifterN;

Measured on this code: Q − I = 90.00° from 50 Hz to 20 kHz, and the slider at 90 gives 90° of delay with respect to the reference.

Try it: check that I and Q are 90° apart. If they are, then for a sine of amplitude 1 the outputs at θ and θ + 90° are themselves a 0°/90° pair, and out(θ)² + out(θ + 90)² must be 1 (Pythagoras again). Add this to the file:

// add to Hilbert_Vicanek_Phase_Shifter.dsp
// I and Q are 90 degrees apart if out(theta)^2 + out(theta + 90)^2 = 1 for a unit sine
check(f, theta) = os.osc(f) <: (hilbertPHshift(theta) : !, _),
                               (hilbertPHshift(theta + 90.0) : !, _) : ^(2) + ^(2);

process = check(1000.0, 37.0), check(20.0, 37.0);

At 1 kHz the result stays at 1 within 0.0002 (the limit there is the precision of os.osc in float, not the filter). At 20 Hz it wobbles by about ±0.014: that is the ~0.8° error of the lowest octave.

Try it: from phase shifter to frequency shifter. If θ keeps moving at a constant speed, the wheel is pushed round continuously and every frequency moves by the same number of Hz (a Bode frequency shifter). A growing delay lowers the frequency, so θ must decrease to shift up:

// add to Hilbert_Vicanek_Phase_Shifter.dsp
// theta moving all the time: the phase shifter becomes a frequency shifter
// a growing delay lowers the frequency, so theta decreases to shift up by df Hz
fshift(df) = hilbertPHshift(-360.0 * os.phasor(1, df)) : !, _;

process = os.osc(1000.0) : fshift(hslider("Shift [unit:Hz]", 100.0, 0.0, 500.0, 1.0));

With a 1 kHz sine and a 100 Hz shift, the output is at 1100 Hz and the ghost copy at 900 Hz is at −98.6 dB. This is also why moving the slider of the phase shifter briefly shifts the pitch while it moves.

9. Pitfalls checklist

These all came up while building and testing the code, and all of them produce a patch that runs but does not do what it should.

1. Comparing with x instead of I. The output is rotated with respect to the real branch I, which is x after the allpass chain. A patch that outputs x and the rotated signal side by side shows a frequency-dependent difference even at θ = 0. The reference must be I (or, with N stages, x through N real branches).
2. The sign of the crossfade. I·cos θ − Q·sin θ advances; I·cos θ + Q·sin θ delays. If the slider is meant as a delay, use +.
3. Swapped coefficient lists. The list starting with 0.0406… goes on the branch without x', the one starting with 0.1500… on the branch with x'. Swapped, the difference is no longer 90°: about −74° at 1 kHz and −8° at 5 kHz.
4. The same slider value given to every stage of a cascade. seq(i, 6, hilbertPHshift(slider)) rotates by 6 × slider: with the slider at 1080, that is 6480° = 18 turns, i.e. no rotation at all. To get a total of slider degrees, divide by N inside, as in HilbertPhaseShifterN.
5. Expecting 1080° to be different from 0° on a still slider. It is not (section 6). A cascade only lengthens the sweep, at the cost of N times the CPU and N times the delay of the lows. A single stage with a 0–1080 slider gives the same rotation, because cos and sin repeat every 360°.

10. Summary

1. A delay is an angle that grows with frequency: one sample is 360° × f / fs.
2. A copy added once (FIR) makes notches (zeros); a copy fed back makes peaks (poles). Feedback needs a coefficient below 1.
3. A delay of D samples puts peaks or notches every fs/D Hz: the comb. On the circle, the angle is the frequency and the distance from the edge is the strength.
4. An allpass puts a FIR (notches) and a feedback (peaks) in series, with the FIR reversed in time: the amplitude is flat, the phase is not.
5. In an allpass, frequencies near the pole go round the loop longer and come out later: a different time for each frequency. In degrees this is a climb of 180° around the pole.
6. A phase shifter needs the same angle at every frequency, which no delay and no single allpass can give.
7. If we had I (0°) and Q (90°), a crossfade with cos θ and sin θ would give any angle θ at every frequency.
8. Q cannot be built against x, but it can be built against I: two allpass chains whose climbs alternate stay 90° apart (the Hilbert transform).
9. More allpass per branch, better 90°. Vicanek’s 8 + 8 coefficients bring the error from ~0.7° (Niemitalo’s 4 + 4) to ~0.001°, which matters mostly when θ moves.

References

• Neil Robertson, Phase or Frequency Shifter Using a Hilbert Transformer, DSPRelated: https://www.dsprelated.com/showarticle/1147.php
• Martin Vicanek, Reverse IIR (the 8 + 8 coefficients): https://vicanek.de/articles/ReverseIIR.pdf
• Laurent de Soras, hiir library (designs of any order and transition band): https://ldesoras.fr/prod.html
• Olli Niemitalo, 4 + 4 Hilbert IIR (coefficients found with a genetic algorithm)
• faudiostream-users mailing-list thread, “Claude helped cleanup/improvements on the Faust libraries”, August–September 2026
• Faust libraries: fi.hilbert, fi.pospass, pf.phaser2_mono

Here we examines three distinct approximation strategies—Taylor series expansion, polynomial waveshaping, and rational approximation—with focus on their computational cost and practical implementation trade-offs.

The Fundamental Challenge

A phasor generates a linear ramp from 0 to 1. Converting this to a sinusoid requires either:

1. Wavetable lookup (~5-6 operations: multiplication, cast, memory reads, interpolation)
2. Mathematical approximation (variable cost depending on method)

Commercial synthesizers universally employ wavetables because memory (64KB for a high-quality table) is negligible compared to the performance gain. However, algorithmic approaches offer instructive alternatives.

Triangle Wave Conversion

The first processing step is converting the phasor to a triangle wave that oscillates between -1 and +1. This normalization simplifies the subsequent sine approximation.

tri(x) = (x < 0.5) * (4 * x - 1) + (x >= 0.5) * (3 - 4 * x);

profile:

• 1 comparison (x < 0.5)
• 1 comparison (x >= 0.5)
• 4 multiplications
• 3 additions/subtractions

Total: ~6-8 operations (comparisons compile to conditional moves or masked operations in SIMD contexts)

This triangle function is computationally lean and avoids expensive operations like floor() or modulo that higher-level abstractions (ma.frac) might introduce.

Method 1: Taylor Series Expansion

The Taylor series for sine around zero is:

sin(x) = x - x³/6 + x⁵/120 - x⁷/5040 + ...

Naive implementation would recompute powers repeatedly. The optimized version uses Horner’s method to minimize operations:

sintaylor(x) = x * (1 - x * x * (1.0/6 - x * x * (1.0/120 - x * x / 5040)));

profile:

• 1 multiplication to compute x²
• 5 additional multiplications (reusing x²)
• 3 subtractions
• Divisions by constants are precomputed by the compiler

Total: ~6 multiplications + 3 additions

Precision: With 4 terms (up to x⁷), THD (Total Harmonic Distortion) is approximately 0.01%. Adding one more term (x⁹/362880) reduces this to ~0.0001%.

Scaling factor: The triangle output is multiplied by 0.90 instead of π/2 ≈ 1.5708 to keep the argument within the convergence range where the series is most accurate. This is a practical compromise that slightly reduces amplitude but significantly improves precision.

Method 2: Polynomial Waveshaping (Minimax Approximation)

Unlike Taylor series (which converges around a single point), minimax polynomials are optimized to minimize the maximum error across an entire interval using Chebyshev or Remez exchange algorithms.

sinpoly(x) = x * (1.5708 - 0.645964 * x * x);

Assembly profile:

• 1 multiplication (x²)
• 2 multiplications
• 1 subtraction

Total: ~3 multiplications + 1 addition

This is half the computational cost of the Taylor series implementation while maintaining comparable accuracy for audio applications. The coefficients (1.5708, 0.645964) are empirically derived to minimize error in the [-π/2, π/2] range.

Trade-off: Fewer terms mean this approximation degrades faster outside the optimal range, but for normalized triangle input, the error remains below perceptual thresholds.

Method 3: Bhaskara’s Rational Approximation

Bhaskara I (7th century Indian mathematician) derived a rational approximation:

sin(x) ≈ 4x(π - x) / (π² - x(π - x))    for x ∈ [0, π]

Implementation requires careful input conditioning for positive and negative polarities:

sinbhaskara(x) = (4 * x * (PI - x)) / (PI * PI - x * (PI - x));

sineoscbhaskara(x) = ((x - 0.5) * 2.0) <: 
    sinbhaskara(abs(_) * PI) * (((_ < 0.0) * -1.0) + (_ > 0.0)) * 0.7;

profile:

• Input normalization: 2 multiplications, 1 subtraction
• Absolute value: 1 comparison + conditional
• Bhaskara formula: 6 multiplications, 3 additions, 1 division
• Sign restoration: 2 comparisons, 2 multiplications

Total: ~9 multiplications + 1 division + 4 comparisons

Characteristics:

• Division operation is expensive (~10-20 cycles on modern CPUs vs ~3-5 for multiplication)
• Maximum error is ~0.0016 over [0, π] (historically remarkable for its simplicity)
• The 0.7 scaling factor compensates for the approximation’s slight amplitude excess

Practical Considerations

When to use each method:

• Polynomial waveshaping: Best balance for real-time DSP. Minimal CPU cost with acceptable precision.
• Taylor series: Preferred when precision is critical and extra terms can be added as needed.
• Bhaskara: Historical interest and educational value. The division operation makes it less suitable for high-polyphony contexts.

The performance difference becomes critical in resource-constrained environments (embedded systems, mobile devices, or when CPU headroom is needed for filters, effects, and modulation).

Code Implementation

import("stdfaust.lib");

// High-precision π constant
PI = 3.141592653589793238462643383279502884197169399375105820974944592307816;

// Triangle wave converter (phasor [0,1] to triangle [-1,1])
tri(x) = (x < 0.5) * (4 * x - 1) + (x >= 0.5) * (3 - 4 * x);

// Method 1: Taylor series (Horner's method, 4 terms)
sintaylor(x) = x * (1 - x * x * (1.0/6 - x * x * (1.0/120 - x * x / 5040)));
// Or more
sintaylor2(x) = x - (x * x * x) / 6 + (x * x * x * x * x) / 120 - 
    (x * x * x * x * x * x * x) / 5040;
sineosctaylor(x) = sintaylor(tri(x) * 0.5 * PI);
// out
process = os.phasor(1, si.smoo(hslider("F", 440, 20, 1000, 0.001))) : 
    sineosctaylor * si.smoo(hslider("G", 0.8, 0, 1, 0.001));

// Method 2: Minimax polynomial approximation  
sinpoly(x) = x * (1.5708 - 0.645964 * x * x);
sineoscpoly(x) = sinpoly(tri(x) * 0.90);
// out
/*
process = os.phasor(1, si.smoo(hslider("F", 440, 20, 1000, 0.001))) : 
    sineoscpoly * si.smoo(hslider("G", 0.8, 0, 1, 0.001));
*/

// Method 3: Bhaskara's rational approximation
sinbhaskara(x) = (4 * x * (PI - x)) / (PI * PI - x * (PI - x));
sineoscbhaskara(x) = ((x - 0.5) * 2.0) <: 
    sinbhaskara(abs(_) * PI) * (((_ < 0.0) * -1.0) + (_ > 0.0)) * 0.7;
// out
/*
process = os.phasor(1, si.smoo(hslider("F", 440, 20, 1000, 0.001))) : 
    sineoscbhaskara * si.smoo(hslider("G", 0.8, 0, 1, 0.001));
*/

Conclusion

While wavetable oscillators remain the industry standard for production environments, understanding these approximation methods provides insight into the computational mechanics of DSP. The polynomial waveshaping approach offers an excellent compromise between efficiency and precision, requiring only ~3× the operations of a wavetable while eliminating memory requirements entirely.

For educational purposes, experimenting with these methods in FAUST reveals how mathematical abstractions translate to actual CPU cycles—a critical skill for optimizing real-time audio processing systems.

Constructing a delay line

In FAUST the _ represent a signal input. A function with one input that goes directly to the output is written as follows:

import("stdfaust.lib");

// signal input - output
//process = _;

where process is the main function in Faust (the compiler’s output function). And import("stdfaust.lib"); is the function for import the Standard Faust Libraries.

Faust provides us with three different syntaxes to express a delay line:

• ' - is used to express a one sample delay. Time expressions can be chained, so the output signal of this program

// signal in delay (' = mem), (mem = Z^(-1))
 //process = _'';

will produce a delayed signal of two samples.

• mem - indicates a 1 sample delay. You can use the “mem” successively add delay samples, so the output signal of this program

// signal in delay (' = mem), (mem = Z^(-1))
//process = _ : mem : mem : _;

will produce a delayed signal of two samples. These last two programs produce the same result.

@ - indicates a number of variable delay samples, so for example a signal with 192000 samples of delay is written like:

 // signal in delay (@192000 = 192000 samples of delay)
 //process = _ @ 192000;

Dirac impulse

Now, another element that we can introduce through the filter syntax is the Dirac impulse, which represents our minimum DSP unit, namely the single sample by putting a number 1 and subtracting the same value from it but doing it at a delayed sample.

Example:

// Dirac Impulse with delay lines - Impulse at Compile Time  
 dirac0 = 1 - 1';  
 //process = dirac0;

or something like that using functional syntax:

// Dirac Impulse with delay lines - Impulse at Compile Time  
 dirac1(x) = x - x';  
 //process = dirac1(1);

Methods for Implementing Recursive Circuits in the Faust Language

Now we will illustrate three main methods for Implementing Recursive Circuits in FAUST Language:

• Writing the code line with internal recursion: in this way tilde ~ operator sends the signal output to itself, to the first available input creating a feedback circuit.

One way to force the operator to point to a certain point in the code, is to put parentheses (), in this way ~ will point to the input before the parenthesis. In this program, the input is summed with itself delayed by one sample and multiplied by 0.5:

  // dirac in feedback in sin
  //process = (1 - 1') * 1000 : (_ + _) ~ _ * (0.9999) : sin;

• Using the with construction with{};: It can be used to create a local enviroment. You can define a function in which are passed the various arguments of the function that control the parameters of the code, and say that that function is equal to exit from the with, with ~ _. You can find an exhaustive explanation of with construction here

Example:

   // with environment example (dirac in feedback in sin)
   //where out ~ _ returns to itself.
   function_with(input1, input2) = out ~ _ : sin
       	with{   
        		section1 = (1 - 1') * input1;
        		section2(argument1) = (argument1 * input2) + section1;
        		out = section2;
        	};
   //process = function_with(1000, 0.9999);

Moreover, with in Faust allows declaring variables that are not pointed to from outside the code but only from the belonging function; in this case

the function to which with belongs is “function_with”.

• A third method is to use the letrec environment. with this method we can write a signal recursively, similar to how recurrence equations are written.

  // letrec function  
   function_letrec = sin(y)
   // letrec definition  
   	letrec {  
    		'y = dirac * damp + amp * y;  
    	}  
    	// inside the letrec function  
       with {  
           dirac = (1 - 1');
           damp = 1000;
           amp = 0.9999;
       };  
  //process = function_letrec <: si.bus(2);
  

Concluding this chapter on filter syntax in FAUST, we need to introduce a fundamental concept that will help us gain a more comprehensive understanding of digital filters: the relationship between milliseconds and samples -> sampling frequency.

Milliseconds - Samples and the importance of the sampling frequency

Digital filters differ from analog filters for one particular reason: the Analog-to-Digital (AD) conversion system involves discretizing a continuous physical phenomenon into a sampled numerical one. Understanding the relationship between time and samples helps us in reasoning and practical applications of digital filters. These filters indeed entail spectral changes (when observed in the frequency domain) and involve temporal integration changes (when observed in the time domain). This brief preamble will be explained further in the chapter on the bilinear transform. For now, let’s focus on small examples of converting between milliseconds and samples.

Conversion from Milliseconds to Samples

This program takes input time expressed in milliseconds and returns the value in samples.

// milliseconds to samples conversion
milliseconds = 10;
msec2samps(msec) = msec * (ma.SR/1000);
//process = msec2samps(milliseconds);

Through ma.SR, we use the current sampling frequency of the machine we are using. For example, if we have a sampling frequency of 96000 samples per second, it means that 1000ms (1 second) is represented by 96000 parts, and therefore a single unit of time like 1ms corresponds digitally to 96 samples. For this reason, we divide the sampling frequency by 1000ms, resulting in a total number of samples that corresponds to 1ms in the digital world at a certain sampling frequency. And then we multiply the result of this operation by the total number of milliseconds we want to obtain as a representation in samples. If we multiply by 100 we will have 9600 samples every 100ms at a sampling frequency of 96000 samples per second.

Conversion from Samples to Milliseconds

Function for Conversion from Samples to Milliseconds: we input a total number of samples, of which we need to know the overall duration in milliseconds based on our sampling frequency.

We know that a sampling frequency corresponds to a set of values that express together the duration of 1 second (1000 ms).

It means, for example, that at a sampling frequency of 48,000 samples per second, 1000 milliseconds are represented by 48,000 parts. So if we divide our 1000ms. / into the 48,000 parts which are the samples of our system, we would get the duration in milliseconds of a single sample at that sampling frequency, in this case therefore: 1000 / 48,000 = 0.02ms. And so the duration in milliseconds of a single sample at 48,000 samples per second, is 0.02 milliseconds. If we multiply the obtained number * a total number of samples, we will get the time in milliseconds of those samples for that sampling frequency used.

Obviously, as can be deduced from the considerations, as the sampling frequency increases, the temporal duration of a single sample decreases, and thus a greater definition.

Phase Alignment of Feedback

We need to spend a few words about the implementation of a delay line in feedback in the digital world. In the following program, we have a Dirac impulse that is summed by itselfs delayed by 2 samples.

// dirac delayed
//process = (_ + (1 - 1')) ~ _ @2;

We expect these values to appear in the first 10 samples:

However, the results of the data plot are as follows:

There’s something wrong. With each feedback cycle, it’s being delayed by one extra sample! That’s because in the digital domain, the feedback of a delay line, when applied, costs by default one sample delay. ‘Feedback = 1 Sample’

So one must consider that the number of delay samples equals the number of samples minus 1:

// dirac delayed + phase alignment
delSampsDirac0 = 2;
//process = (_ + (1 - 1')) ~ _@(delSampsDirac0 - 1);

In some application scenarios later on, we’ll need a one-sample delay even at the input signal. In this case, simply concatenating a delay line in series will suffice.

// dirac delayed + phase alignment (final)
delSampsDirac1 = 2;
//process = (_ + (1 - 1')) ~ _@(delSampsDirac1 - 1) : mem;

Digital Filters

ONEZERO FILTER (1st Order FIR)

_ represents the input signal, (_ denotes the signal) it is then split into two parallel paths <: one delayed by one sample _' (' denotes one sample delay) and one without delay, _ (, denotes transition to the second path) they are then summed into a single signal :> _ ; the delayed signal has a feedforward amplitude control * feedforward there is a general amplitude control * outgain on the output function onezeroout

// onezero, g = give amplitude 0 to +/- 1 (open - close) to the delayed signal  
oz(b1) = _ <: (_ : mem * b1), _ :> +;  
//process = oz;

ONEPOLE FILTER (1st Order IIR)

+ ~ is the summation, and the feedback of the arguments inside parentheses ()_ represents the input signal, (_ denotes the signal) delayed by one sample _ (automatically in the feedback) which enters : into the gain control of the feedback * 1-feedback the same feedback controls the input amplification of the signal not injected into the feedback there is a general amplitude control * outgain on the output function onezeroout

// onepole, g = give amplitude 0 to +/- 1 (open - close) to the delayed signal  
op(b1) = _ * (1 - abs(b1)) : + ~ * (b1);
//process = op;

and OPF with Frequency Cut transfer functions:

• (1)

// onepole with frequency cut formula (chamberlin), fc = Hz
lp1p(fc) = _ * g : + ~ * (1 - g)
    with{
        k(x) = x / (1.0 + x);
        g = tan(fc * ma.PI / SR) : k;
    };
//process = lp1p;

• (2)

  lp1p2(fc) = _ * (1 - b1) : + ~ * (b1)
      with {
           b1 = exp((fc * ma.PI / ma.SR) * -1);
      };
  //process = lp1p2;
  

same OPF with Formulae expressed in Seconds (1 / FC)

• (3)

// onepole in seconds or smooth function
opsec(sec) = _ * g : + ~ * (1 - g)
    with{
        k(x) = x / (1.0 + x);
        g = tan((1 / sec) * ma.PI / ma.SR) : k;
    };
//process = opsec;

FEEDFORWARD COMB FILTER (Nth Order FIR)

_ represents the input signal, (_ denotes the signal) it is then split into two parallel paths <: one delayed by @(delaysamples) samples (thus value to be passed externally) and one without delay, _ (, denotes transition to the second path) they are then summed into a single signal :> _ ;

the delayed signal has a feedforward amplitude control * feedforward

there is a general amplitude control * outgain on the output function onezeroout

// feedforward comb filter, (t, g) = delay time in samples, filter gain 0-1  
ffcf(t, g) = _ <: ((_ @ (t)) * g), _ :> +;  
//process = (1000, 0.9, _) : ffcf;

FEEDBACK COMB FILTER (Nth Order IIR)

+ ~ is the summation, and the feedback of the arguments inside parentheses () _ represents the input signal, (_ denotes the signal) delayed by @(delaysamples) samples (thus value to be passed externally) which enters : into the gain control of the feedback, * feedback

In the feedback, one sample of delay is already present by default, hence delaysamples-1.

there is a general amplitude control * outgain on the output function combfeedbout

// feedback comb filter, (t, g) = give: delay time in samples, feedback gain 0-1
fbcf(t, g) = _ : (+  @(t - 1) ~ *(g)) : mem;
//process = (1000, 0.9, _) : fbcf;

Lowpass FEEDBACK COMB FILTER (Nth Order IIR)

similar to the comb filter, but within the feedback, following the feedback enters the signal : into the onepole. The onepole is a lowpass where the cutoff frequency can be controlled between 0. and 1. In the feedback, one sample of delay is already present by default, hence delaysamples-1.

// lowpass feedback comb filter, (t, g) = give: delay time in samples, g gain 0-1, Freq cut (HZ)
lbcf(t, g, fc) = _ : (+  @(t - 1) ~ (lp1p(fc) * (g))) : mem;
//process = (1000, 0.9, 10000, _) : lbcf;

ALLPASS FILTER

from the sum of a comb IIR and a comb FIR in opposition of phase, emerge a recursive delay unit that preserve the phase of the input signal. (+ transitions : to a cable _ and a split <: then @delay and gain, in feedback ~ to the initial sum. filtergain controls the amplitude of the two gain states, which in the filter are the same value but positive and negative, one side * -filtergain and one side * +filtergain. In the feedback, one sample of delay is already present by default, hence delaysamples-1. To maintain the delay threshold of the value delaysamples, a mem delay (of the subtracted sample) is added at the end.

// allpass filter, (t, g) = give: delay in samples, feedback gain 0-1
apf(t, g) = _ : (+ : _ <: @(t  - 1), *(g))~ *(-g) : mem, _ : + : _;
//process = (1000, 0.9, _) : apf;

MODULATED ALLPASS FILTER

Allpass Filter with Time-Variant delay

// Modulated Allpass filter
modapf(delsamples, samplesmod, freqmod, apcoeff) = ( + : _ <:  
    delayMod(delsamples, samplesmod, freqmod),
    * (apcoeff))~ * (-apcoeff) : mem, _ : + : _
    with{
        delayMod(samples, samplesMod, freqMod, x) = delay
        with{
            unipolarMod(f, samples) = ((os.osc(f) + 1) / 2) * samples;
            delay = x : de.fdelay(samples, samples - unipolarMod(freqMod, samplesMod));
        };
    };
//process = _ <: modapf(1100, 800, .12, .99), modapf(1000, 900, .12, .99);

STATE VARIABLE FILTER (SVF)

State variable filters are second-order RC active filters consisting of two identical op-amp integrators with each one acting as a first-order, single-pole low pass filter, a summing amplifier around which we can set the filters gain and its damping feedback network. The output signals from all three op-amp stages are fed back to the input allowing us to define the state of the circuit. The state variable filter is a type of multiple-feedback filter circuit that can produce all three filter responses, Low Pass, High Pass and Band Pass simultaneously from the same single active filter design, and derivation like Notch, Peak, Allpass…

Robert Bristow Johnson’s SVF Biquad

This filter transfer functions were derived from analog prototypes (that are shown below for each EQ filter type) and had been digitized using the Bilinear Transform by Robert Bristow-Johnson: https://webaudio.github.io/Audio-EQ-Cookbook/audio-eq-cookbook.html

// Robert Bristow-Johnson's Biquad Filter - Direct Form 1
// https://webaudio.github.io/Audio-EQ-Cookbook/audio-eq-cookbook.html
biquad(i, cf, q) = _ : coefficients(i) : biquadFilter
     with{
         biquadFilter(a0, a1, a2, b1, b2) = biquadFilter
             with{
                 biquadFilter =  _ <: _, (mem  <: (_, mem)) : (_ * a0, _ * a1, _ * a2) :> _ :  
                                 ((_, _) :> _) ~ (_ <: (_, mem) : (_ * -b1, _ * -b2) :> _);
             };

         // Angular Frequency formula
         omega(x) = (2 * ma.PI * x) / ma.SR;
         // Angular Frequency in the sine domain
         sn(x) = sin(omega(x));
         // Angular Frequency in the cosine domain
         cs(x) = cos(omega(x));  
         // Alpha
         alpha(cf0, q0) = sin(omega(cf0)) / (2 * q0);

         // Robert Bristow-Johnson's Biquad Filter - Coefficents
         // Lowpass Filter
         coefficients(0) = a0, a1, a2, b1, b2, _
         with{
             b0 = (1 + alpha(cf, q));
             a0 = ((1 - cs(cf)) / 2) / b0;
             a1 = (1 - cs(cf)) / b0;
             a2 = ((1 - cs(cf)) / 2) / b0;
             b1 = (-2 * cs(cf)) / b0;
             b2 = (1 - alpha(cf, q)) / b0;
         };
         // Highpass filter
         coefficients(1) = a0, a1, a2, b1, b2, _
         with{
             b0 = (1 + alpha(cf, q));
             a0 = ((1 + cs(cf)) / 2) / b0;
             a1 = (-1 * (1 + cs(cf))) / b0;
             a2 = ((1 + cs(cf)) / 2) / b0;
             b1 = (-2 * cs(cf)) / b0;
             b2 = (1 - alpha(cf, q)) / b0;
         };
         // Bandpass Filter
         coefficients(2) = a0, a1, a2, b1, b2, _
         with{
             b0 = 1 + alpha(cf, q);
             a0 = alpha(cf, q) / b0;
             a1 = 0;
             a2 = - alpha(cf, q) / b0;
             b1 = (-2 * cs(cf)) / b0;
             b2 = (1 - alpha(cf, q)) / b0;
         };
         // Notch filter
         coefficients(3) = a0, a1, a2, b1, b2, _
         with{
             b0 = 1 + alpha(cf, q);
             a0 = 1 / b0;
             a1 = (-2 * cs(cf)) / b0;
             a2 = 1 / b0;
             b1 = (-2 * cs(cf)) / b0;
             b2 = (1 - alpha(cf, q)) / b0;
         };
         // Peaking EQ filter
         coefficients(4) = a0, a1, a2, b1, b2, _
         with{
             A = 10;
             b0 = 1 + (alpha(cf, q) / A);
             a0 = (1 + (alpha(cf, q) * A)) / b0;
             a1 = (-2 * cs(cf)) / b0;
             a2 = (1 - (alpha(cf, q) * A)) / b0;
             b1 = (-2 * cs(cf)) / b0;
             b2 = (1 - (alpha(cf, q) / A)) / b0;
         };
         // Low Shelf Filter
         coefficients(5) = a0, a1, a2, b1, b2, _
         with{
             //dbGain 20;
             A  = pow(10, -20 /40);
             beta = sqrt(A + A);
             b0 = (A + 1) + (A - 1) * cs(cf) + beta * alpha(cf, q);
             a0 = (A * ((A + 1) - (A - 1) * cs(cf) + beta * alpha(cf, q))) /b0;
             a1 = (2 * A * ((A - 1) - (A + 1) * cs(cf))) / b0;
             a2 = (A * ((A + 1) - (A - 1) * cs(cf) - beta * alpha(cf, q))) /b0;
             b1 = (-2 * ((A - 1) + (A + 1) * cs(cf))) / b0;
             b2 = ((A + 1) + (A - 1) * cs(cf) - beta * alpha(cf, q)) / b0;
         };
         // High Shelf Filter
         coefficients(6) = a0, a1, a2, b1, b2, _
         with{
             //dbGain 20;
             A  = pow(10, -20 /40);
             beta = sqrt(A + A);
             b0 = (A + 1) - (A - 1) * cs(cf) + beta * alpha(cf, q);
             a0 = (A * ((A + 1) + (A - 1) * cs(cf) + beta * alpha(cf, q))) /b0;
             a1 = (2 * A * ((A - 1) + (A + 1) * cs(cf))) / b0;
             a2 = (A * ((A + 1) + (A - 1) * cs(cf) - beta * alpha(cf, q))) /b0;
             b1 = (2 * ((A - 1) - (A + 1) * cs(cf))) / b0;
             b2 = ((A + 1) - (A - 1) * cs(cf) - beta * alpha(cf, q)) / b0;
         };
};
//process = (1000, 1, _) : biquad(0);

ONEPOLE Topology Preserving Transforms (TPT)

TPT version of the One-Pole Filter by Vadim Zavalishin reference: https://www.native-instruments.de/fileadmin/redaktion_upload/pdf/KeepTopology.pdf the topology-preserving transform approach, can be considered as a generalization of bilinear transform, zero-delay feedback and trapezoidal integration methods. This results in digital filters having nice amplitude and phase responses, nice time-varying behavior and plenty of options for nonlinearities

// Vadim Zavalishin's Onepole TPT Filter (Topology Preserving Transform)  
onePoleTPT(cf, x) = loop ~ _ : ! , si.bus(3)
     with {
         g = tan(cf * PI * ma.T);
         G = g / (1.0 + g);
         loop(s) = u , lp , hp , ap
             with {
             v = (x - s) * G; u = v + lp; lp = v + s; hp = x - lp; ap = lp - hp;
             };
     };
//process = onePoleTPT;

// Lowpass and Highpass TPT
LPTPT(cf, x) = onePoleTPT(cf, x) : (_ , ! , !);
HPTPT(cf, x) = onePoleTPT(cf, x) : (! , _ , !);

// Allpass TPT
APTPT(cf, x) = onePoleTPT(cf, x) : (!, !, _);

Vadim Zavalishin’s SVF Topology Preserving Transform

// Vadim Zavalishin's SVF TPT filter (Topology Preserving Transform)
SVFTPT(Q, cf, x) = loop ~ si.bus(2) : (! , ! , _ , _ , _ , _ , _)
     with {
         g = tan(cf * ma.PI * ma.T);
         R = 1.0 / (2.0 * Q);
         G1 = 1.0 / (1.0 + 2.0 * R * g + g * g);
         G2 = 2.0 * R + g;
         loop(s1, s2) = u1 , u2 , lp , hp , bp * 2.0 * R , x - bp * 4.0 * R , bp
             with {
                 hp = (x - s1 * G2 - s2) * G1;
                 v1 = hp * g;
                 bp = s1 + v1;
                 v2 = bp * g;
                 lp = s2 + v2;
                 u1 = v1 + bp;
                 u2 = v2 + lp;
             };
     };

// HP - LP SVF  
LPSVFTPT(Q, cf, x) = SVFTPT(Q, cf, x) : (_ , ! , ! , ! , !);
HPSVFTPT(Q, cf, x) = SVFTPT(Q, cf, x) : (! , _ , ! , ! , !);

// Normalized Bandpass SVF  
BPSVFTPT(Q, cf, x) = SVFTPT(Q, cf, x) : (! , ! , _ , ! , !);

NotchSVFTPT(Q, cf, x) = x - BPSVF(Q, cf, x);
APSVFTPT(Q, cf, x) = SVFTPT(Q, cf, x) : (! , ! , ! , _ , !);
PeakingSVFTPT(Q, cf, x) = LPSVF(Q, cf, x) - HPSVF(Q, cf, x);
BP2SVFTPT(Q, cf, x) = SVFTPT(Q, cf, x) : (! , ! , ! , ! , _);

// Bandpass Bandwidth SVF
BPBWSVFTPT(BW, CF, x) = BPSVF(clip(20000, EPS, (CF / BW)), CF, x);

Reverberation

Reverberation is the persistence of sound after it has been produced. It is an acoustic phenomenon related to the reflection of sound waves by an obstacle placed in front of the sound source. Assumptions that determine the perception of a reverberation phenomenon:

1. The human ear cannot distinguish two sounds if they are perceived less than 100 milliseconds apart.
2. The speed of sound in the air at 20°C is approximately 340 m/s.
3. The sound source and the listener are in the same location facing the obstacle.

Given these assumptions, in an open space, reverberation can be discussed when the obstacle is less than 17 meters from the sound source. Indeed, up to this distance, the path of the sound wave from the source to the obstacle and back is less than 34 meters, and therefore the sound takes less than 100 milliseconds to return to the starting point, blending into the listener’s ear with the original sound. If the obstacle is more than 17 meters away from the source, then the delay of the reflected sound compared to the direct sound is more than 100 milliseconds, and the two sounds are therefore distinct. In this case, it is called an echo.

Duration of Reverberation

The factors that influence the duration of reverberation are multiple. The most influential ones are:

1. Room size

   • Larger rooms produce longer reverberations.
   • Small rooms produce shorter reverberations.

2. Materials

   • Hard materials like ceramics and plastics reflect sound more.
   • Soft materials like wood absorb much more sound.

   For these reasons related to materials, a small room like a bathroom has longer reverberation times than a large wooden room.

The best way to listen to the reverberation of a reverberant space is to produce an impulsive sound; like a clap of hands or a snap of fingers.

Reverberation in Music

Music has made extensive use of reverberation for thousands of years. Archaeologists believe that reverberation produced by caves was used in ancient ceremonies. Many cathedrals in Europe have reverberations lasting more than 10 seconds, and the choral music of certain eras worked particularly well by exploiting the reverberation inside these cathedrals. In fact, the reverberation of individual notes overlaps on subsequent notes, transforming a monophonic melody into a polyphonic sound.

Reflections

A standard room has 6 surfaces:

• Right wall
• Left wall
• Front wall
• Back wall
• Ceiling
• Floor

A sound, when produced, bounces off the surfaces and is subsequently heard, producing what are called:

1. First-order reflections

Each of these will produce another 6 echoes: 6 echoes, each bouncing off the 6 surfaces, will produce 36 echoes; these are called:

1. Second-order reflections

producing a total of 42 echoes in a very short period of time, and so on… Of all these echoes, none is perceived individually, but rather their ensemble and dispersion over time are perceived. Reverberation is thus composed of thousands of echoes of the original sound that persist and decay over time.

Artificial Reverberation Models

Reverberation is artificial when it is not present in the room where the recording is taking place but is instead added later.

1. Tape echo A particular magnetic tape recorder/player is used, which constantly moves a tape loop inside a mechanism with a fixed recording head and a mobile playback head. The signal recorded by the first head is read by the second and mixed with the original, generating the effect. These devices are bulky and heavy. Like in any tape recording, there is background noise similar to hiss, significantly higher than that produced with digital technologies.

2. Spring reverb The signal is passed, through a transducer, through a metal spiral (the spring). At the other end of the spring, a transducer equivalent to the first one reintroduces the signal into the amplification circuit, mixing it with the original. The signal taken from the second transducer is slightly delayed compared to the one applied to the first, creating the reverberation effect in the listener’s ear.

3. Chamber reverb Following the spring reverb model, in a box acoustically isolated from the outside, a curved tube is inserted to create the longest possible path. At one end of the tube is placed a small loudspeaker, while at the other end there is a microphone. The sound emitted by the loudspeaker will take some time to travel the entire tube and reach the microphone, thus generating the necessary delay. The signal taken from the microphone will be fed back into the mixing console, mixed with the original.

4. Plate reverb Similar to spring reverb, but with a large metal plate instead of the spring. It has two transducers attached to its surface and works in a similar way, although its quality is significantly higher.

Digital Reverbs

They are produced by a computer or dedicated DSP integrated circuits. There are integrated circuits on the market that include A/D and D/A converters, memories, and timing circuits. An acoustic signal is transduced and converted into numbers that enter memories. In fact, the bytes are “scrolled” from one bank to the next until the last one is reached. The digital signal taken from the last memory is then reconverted into analog and mixed with the original signal, obtaining the reverberation effect; the farther the read point from the write point, the longer the echo time will be. The size of these read and write memories is called delay line, and it is expressed in samples. The large capacity of RAM memories allows achieving delays of several seconds and therefore smoothly transition from reverb to echo. The strategy used afterwards is to feed back the output of the delay line by adding it to the input, thus creating a feedback circuit. All this process is done because modern computers are very powerful, but they are not yet powerful enough to generate all the reflections heard in a large room, one by one. Rather, the goal of creating digital reverbs is to implement models and strategies to replicate the impression of the reverberation of a room. The replication process has generated in the history of digital reverbs true and proper typical sounds different from each other which can be implemented and preferred by musicians for aesthetic reasons.

Digital Reverb in FAUST

Experiments and algorithms of digital reverb models in the FAUST language (GRAME)

Delay Lines in Faust

Delay lines in Faust are divided into the following categories: mem - indicates a single sample delay @ - indicates a number (e.g., 44100) of variable delay samples x’- x indicates any input and: ‘ a sample delay, ‘‘(2), etc. rdtable - indicates a read-only table rwtable - indicates a read and write table.

Through delay lines, we can create a Dirac impulse, which represents our minimum unit, namely the single sample by putting a number 1 and subtracting the same value from it but doing it at a delayed sample.

Example:

// import Standard Faust library
// https://github.com/grame-cncm/faustlibraries/
import("stdfaust.lib");

// Dirac Impulse with delay lines - Impulse at Compile Time
dirac = 1 - 1';
process = dirac, dirac;

Some Methods for Implementing Recursive Circuits in the Faust Language

We will illustrate 3 main methods:

• Writing the code line with internal recursion:

  in this way the tilde ~ operator sends the signal output to itself, to the first available input creating a feedback circuit. One way to force the operator to point to a certain point in the code, is to put parentheses (), in this way ~ will point to the input before the parenthesis.

• A second method consists of using with{} .

  You can define a function in which are passed the various arguments of the function that control the parameters of the code, and say that that function is equal to exit from the with with ~ _

  Example:

      function_with(argument1, argument2) = out_with ~ _
       with{  
        section1 = _ * argument1;
        section2 = argument1 * argument2;
        out_with = section2;
        };
  
        where out_with ~ _ returns to itself.
  

Moreover, with in Faust allows declaring variables that are not pointed to from outside the code but only from the belonging function; in this case the function to which with belongs is “function_with”.

• A third method is to use the letrec environment.

  with this method we can write a signal recursively, similar to how recurrence equations are written.

Example:

// import Standard Faust library  
// https://github.com/grame-cncm/faustlibraries/  
import("stdfaust.lib");

// letrec function
lowpass(cf, x) = y
// letrec definition
     letrec {
         'y = b0 * x - a1 * y;
     }
     // inside the letrec function
     with {
         b0 = 1 + a1;
         a1 = exp(-w(cf)) * -1;
         w(f) = 2 * ma.PI * f / ma.SR;
     };

 // Output of the letrec function
 process = lowpass(100, no.noise) <: si.bus(2);

Conversion of Milliseconds to Samples and Vice Versa

Conversion from Milliseconds to Samples

Function for Conversion from Milliseconds to Samples: we input the time in milliseconds, and the function gives us the value in samples.

For example, if we have a sampling frequency of 48,000 samples per second, it means that 1000ms (1 second) is represented by 48,000 parts, and therefore a single unit of time like 1 ms. Corresponds digitally to 48 samples.

For this reason, we divide the sampling frequency by 1000ms, resulting in a total number of samples that corresponds to 1 ms. in the digital world at a certain sampling frequency.

And then we multiply the result of this operation by the total number of milliseconds we want to obtain as a representation in samples. If we multiply *10. For example, we will get 480 samples at a sampling frequency of 48,000 samples per second.

Conversion from Samples to Milliseconds

Function for Conversion from Samples to Milliseconds: we input a total number of samples, of which we need to know the overall duration in milliseconds based on our sampling frequency.

We know that a sampling frequency corresponds to a set of values that express together the duration of 1 second (1000 ms).

It means, for example, that at a sampling frequency of 48,000 samples per second, 1000 milliseconds are represented by 48,000 parts. So if we divide our 1000ms. / into the 48,000 parts which are the samples of our system, we would get the duration in milliseconds of a single sample at that sampling frequency, in this case therefore: 1000 / 48,000 = 0.02ms. And so the duration in milliseconds of a single sample at 48,000 samples per second, is 0.02 milliseconds. If we multiply the obtained number * a total number of samples, we will get the time in milliseconds of those samples for that sampling frequency used.

Obviously, as can be deduced from the considerations, as the sampling frequency increases, the temporal duration of a single sample decreases, and thus a greater definition.

Phase Alignment of Feedback

In the digital domain, the feedback of a delay line, when applied, costs by default one sample delay. Feedback = 1 Sample

At the moment I decide therefore to put inside the feedback a number of delay samples, we can take for example 10 samples in our delay line, it means that, The direct signal will come out for delay samples at:

input in the delay signal –> output from the delay 10samp

1st Feedback: output from the delay at 10samp + 1 feedback = input in the delay 11samp –> output from the delay 21samp

2nd Feedback: output from the delay at 21samp + 1 feedback = input in the delay 22samp –> output from the delay 32samp

3rd Feedback: output from the delay at 32samp + 1 feedback = input in the delay 33samp –> output from the delay 43samp

and so on…

we can therefore notice immediately that we will not have the correct delay value required inside the same, because of the sample delay that occurs at the moment when I decide to create a feedback circuit. if we use the method of subtracting one sample from the delay line, we will have this result:

input in the delay signal –> -1, output from the delay 9samp

1st Feedback: output from the delay at 9samp + 1 feedback = input in the delay 10samp –> -1, output from the delay 19samp

2nd Feedback: output from the delay at 19samp + 1 feedback = input in the delay 20samp –> -1, output from the delay 29samp

3rd Feedback: output from the delay at 29samp + 1 feedback = input in the delay 30samp –> -1, output from the delay 39samp

and so on…

we can therefore notice that with this method, compared to the previous one we will have as input to the delay line always the number of delay samples required. But we notice that from the first output of the delayed signal subtracting -1 we have one sample delay less than we would like. To realign everything, we just need to add one sample delay to the overall output of the circuit, thus having from the first output:

input in the delay signal –> -1, output from the delay 9samp +1 = 10out

1st Feedback: output from the delay at 9samp + 1 feedback = input in the delay 10samp –> -1, output from the delay 19samp +1 = 20out

and so on…

Let’s proceed with an implementation:

// import Standard Faust library  
// https://github.com/grame-cncm/faustlibraries/  
import("stdfaust.lib");

sampdel = ma.SR;  
// sample rate - ma.SR

process =   _ :  
             // input signal goes in
             +~ @(sampdel -1) *(0.8)  
             // delay line with feedback: +~
             : mem
             // output goes to a single sample delay
             <: si.bus(2);

T60 Decay Calculation

The term “T60” in the context of digital reverberation refers to the reverberation time. The reverberation time is a measure of the duration for which sound persists in a space after the sound source has stopped. It indicates how quickly the sound energy decreases over time.

The T60 value represents the time it takes for the sound level to decrease by 60 decibels (dB) compared to its initial value. In other words, it is the time taken for the sound energy to decay by 60 dB. A long T60 indicates prolonged reverberation, while a short T60 indicates shorter reverberation.

The formula below uses the relationship between the T60 decay time and the number of filter samples to calculate the amplification gain necessary. The result of the calculation is a linear value ranging from 0 to 1, representing the amplification to be applied to the filter feedback.

Insert the following arguments into the function:

• The value in samples of the filter you are using for the delay.

• The decay value in T60 (decay time of 60 dB in seconds)

• = GET as output from the function, the value to be passed as amplification to the filter feedback to achieve the desired T60 decay time

// T60 DECAY TIME from Milliseconds
// (ms, T60) = ms delay of the filter, seconds we want for t60 decay
t60_ms(ms, t60) = pow(0.001, (ms / 1000) / t60);

// formula 2
// (samps,seconds) = give: samples of the filter, seconds we want for t60 decay
dect60(samps,seconds) = 1/(10^((3*(((1000 / ma.SR)*samps)/1000))/seconds));

Digital Filters

ONEZERO FILTER (1st Order FIR)

_ represents the input signal, (_ denotes the signal) it is then split into two parallel paths <: one delayed by one sample _’ (‘ denotes one sample delay) and one without delay , _ (, denotes transition to the second path) they are then summed into a single signal :> _ ; the delayed signal has a feedforward amplitude control * feedforward there is a general amplitude control * outgain on the output function onezeroout

 // import Standard Faust library
 // https://github.com/grame-cncm/faustlibraries/
 import("stdfaust.lib");


 // (G) = G=give amplitude 0-1(open-close) to the delayed signal
 ozf(G) = _ <: ((_ : mem * G), _) :> +;

 // out
 process = ozf(0.1);

ONEPOLE FILTER (1st Order IIR)

+~ is the summation, and the feedback of the arguments inside parentheses () _ represents the input signal, (_ denotes the signal) delayed by one sample _ (automatically in the feedback) which enters : into the gain control of the feedback * 1-feedback the same feedback controls the input amplification of the signal not injected into the feedback there is a general amplitude control * outgain on the output function onezeroout

 // import Standard Faust library
 // https://github.com/grame-cncm/faustlibraries/
 import("stdfaust.lib");

 // (G)  = give amplitude 1-0 (open-close) for the lowpass cut
 // (CF) = Frequency Cut in HZ
 OPF(CF,x) = OPFFBcircuit ~ _  
     with{
         g(x) = x / (1.0 + x);
         G = tan(CF * ma.PI / ma.SR):g;
         OPFFBcircuit(y) = x*G+(y*(1-G));
         };

 process = OPF(20000) <: si.bus(2);

ONEPOLE Topology Preserving Transforms (TPT)

TPT version of the One-Pole Filter by Vadim Zavalishin reference: (by Will Pirkle) http://www.willpirkle.com/Downloads/AN-4VirtualAnalogFilters.2.0.pdf

 // import Standard Faust library
 // https://github.com/grame-cncm/faustlibraries/
 import("stdfaust.lib");

 OnepoleTPT(CF,x) = circuit ~ _ : ! , _
     with {
         g = tan(CF * ma.PI / ma.SR);
         G = g / (1.0 + g);
         circuit(sig) = u , lp
             with {
                 v = (x - sig) * G;
                 u = v + lp;
                 lp = v + sig;
             };
     };

 // out
 process = OnepoleTPT(100);

FEEDFORWARD COMB FILTER (Nth Order FIR)

_ represents the input signal, (_ denotes the signal) it is then split into two parallel paths <: one delayed by @(delaysamples) samples (thus value to be passed externally) and one without delay , _ (, denotes transition to the second path) they are then summed into a single signal :> _ ;

In the feedback, one sample of delay is already present by default, hence delaysamples-1.

the delayed signal has a feedforward amplitude control * feedforward

there is a general amplitude control * outgain on the output function onezeroout

 // import Standard Faust library
 // https://github.com/grame-cncm/faustlibraries/
 import("stdfaust.lib");

 // (t,g) = delay time in samples, filter gain 0-1
 ffcf(t, g, x) = (x@(t) * g), x :> +;
 process = _ * .1 : ffcf(100, 1);

FEEDBACK COMB FILTER (Nth Order IIR)

+~ is the summation, and the feedback of the arguments inside parentheses () _ represents the input signal, (_ denotes the signal) delayed by @(delaysamples) samples (thus value to be passed externally) which enters : into the gain control of the feedback * feedback

In the feedback, one sample of delay is already present by default, hence delaysamples-1.

there is a general amplitude control * outgain on the output function combfeedbout

 // import Standard Faust library
 // https://github.com/grame-cncm/faustlibraries/
 import("stdfaust.lib");

 // Feedback Comb Filter. FBComb(Del,G,signal)  
 // (Del, G) = DEL=delay time in samples. G=feedback gain 0-1
 fbcf(del, g, x) = loop ~ _  
     with {
         loop(y) = x + y@(del - 1) * g;
     };

 process = _ * .1 : fbcf(4480, .9);

Lowpass FEEDBACK COMB FILTER (Nth Order IIR)

similar to the comb filter, but within the feedback, following the feedback enters the signal : into the onepole. The onepole is a lowpass where the cutoff frequency can be controlled between 0. and 1. In the feedback, one sample of delay is already present by default, hence delaysamples-1.

 // import Standard Faust library
 // https://github.com/grame-cncm/faustlibraries/
 import("stdfaust.lib");

 // LPFBC(Del, FCut) = give: delay samps, -feedback gain 0-1-, lowpass Freq.Cut HZ
 lpfbcf(del, cf, x) = loop ~ _ : !, _
     with {
         onepole(CF, x) = loop ~ _  
             with{
                 g(x) = x / (1.0 + x);
                 G = tan(CF * ma.PI / ma.SR):g;
                 loop(y) = x * G + (y * (1 - G));
             };
         loop(y) = x + y@(del - 1) <: onepole(cf), _;
     };
 process = _ * .1 : lpfbcf(2000, 10000);

ALLPASS FILTER

from the sum (+ transitions : to a cable _ and a split <: then @delay and gain, in feedback ~ to the initial sum. filtergain controls the amplitude of the two gain states, which in the filter are the same value but positive and negative, one side *-filtergain and one side *+filtergain. In the feedback, one sample of delay is already present by default, hence delaysamples-1. To maintain the delay threshold of the value delaysamples, a mem delay (of the subtracted sample) is added at the end

 // Allpass
 // (t,g) = give: delay in samples, feedback gain 0-1
 apf(t, g) =    _ : (+ : _ <: @ (t  - 1), * (- g)) ~ * (g) : mem, _ : + : _;
 process = _ * .1 <: apf(100, .5);

Modulated ALLPASS FILTER

// delay modulated : mod = mod source +/- 1, t = del in samps, tMod = mod in samps
delaymod(mod, t, tMod) = de.fdelay(tMax, modIndx)
with{
    tMax = t + tMod;
    modIndx = t + mod * tMod;
};

// modulated Allpass filter
apfMod(mod, t, tMod, g) = _ : (+ : _ <: delaymod(mod, t - 1, tMod), * (- g)) ~ * (g) : mem, _ : + : _;

process = apfMod(os.osc(0.10), 19200, 100, 0.7)

Topologies and Design of Digital Reverbs

Chamberlin Reverb

The Chamberlin Reverb is named after Hal Chamberlin, a pioneer in digital sound processing. This reverberation model was first introduced in his seminal book, Musical Applications of Microprocessors (1979). At its core, the Chamberlin Reverb uses a network of all-pass filters (APF) to create a dense and natural-sounding reverberation effect. The model is particularly effective at simulating small acoustic spaces, such as rooms or chambers, and is designed with simplicity in mind, making it computationally efficient. This efficiency made it suitable for the early digital processors with limited resources.

// Chamberlin Reverb
chamberlinReverb = ap3ch <: apout1ch, apout2ch
with {
    ap3ch = apf(msasamps(49.6), 0.75) : apf(msasamps(34.75), 0.72) : apf(msasamps(24.18), 0.691);
    apout1ch = apf(msasamps(17.85), 0.649) : apf(msasamps(10.98), 0.662);
    apout2ch = apf(msasamps(18.01), 0.646) : apf(msasamps(10.82), 0.666);
};
process = chamberlinReverb;

Chamberlin Reverb with Decay T60

This version includes a decay time T60 control in the comb-allpass filters, representing the time required for the signal to decay by 60 dB.

// Chamberlin Reverb with T60 Decay
chamberlinDecay(seconds) = ap3ch <: apout1ch, apout2ch
with {
    ap3ch = apf(msasamps(49.6), t60_ms(49.6, seconds)) :
            apf(msasamps(34.75), t60_ms(34.75, seconds)) :
            apf(msasamps(24.18), t60_ms(24.18, seconds));
    apout1ch = apf(msasamps(17.85), t60_ms(17.85, seconds)) :
               apf(msasamps(10.98), t60_ms(10.98, seconds));
    apout2ch = apf(msasamps(18.01), t60_ms(18.01, seconds)) :
               apf(msasamps(10.82), t60_ms(10.82, seconds));
};
process = chamberlinDecay(10);

Schroeder-Chowning SATREV Reverberator

The Schroeder-Chowning SATREV Reverberator is a landmark in the history of algorithmic reverb design, based on the design proposed by Manfred Schroeder and refined by John Chowning, this model combines 4 parallel comb filters with 3 serial all-pass filters (drawn from a 1971 MUS10 software listing).

// Schroeder-Chowning SATREV Reverberator
satreverb = _ * 0.2 <: fbcfSchroeder(901, 0.805),
    fbcfSchroeder(778, 0.827), fbcfSchroeder(1011, 0.783),
    fbcfSchroeder(1123, 0.764) :> apf(125, 0.7) :
    apf(42, 0.7) : apf(12, 0.7) <: _ , _ * -1;
process = satreverb;

Schroeder Samson Box Reverberator

In October 1977, CCRMA took delivery of the Systems Concepts Digital Synthesizer, affectionately known as the ``Samson Box,’’ named after its designer Peter Samson. This reverberator developed for this system, which remains known as JCREV, builds upon the earlier reverberation models by Schroeder but expanding on them with improvements that catered to more complex, real-time audio processing requirements. This model includes 3 serial all-pass filters and 4 parallel comb filters.

// Schroeder Samson Box Reverberator
jcreverb = _ * 0.06 : apf(347, 0.7) : apf(113, 0.7) :
    apf(37, 0.7) <: fbcfSchroeder(1601, 0.802), fbcfSchroeder(1867, 0.733),
    fbcfSchroeder(2053, 0.753), fbcfSchroeder(2251, 0.733) :
    mix_mtx
with {
    mix_mtx = _,_,_,_ <: psum, - psum, asum, - asum : _,_,_,_;
    psum = _,_,_,_ :> _;
    asum = *(-1), _, *(-1), _ :> _;
};
process = jcreverb;

Moorer Reverb

James A. Moorer’s 1979 design for digital reverberation was one of the earliest to build upon the work of Manfred R. Schroeder, refining and expanding on his ideas in significant ways. Moorer’s design, as outlined in his seminal paper “About This Reverberation Business”, introduced crucial improvements to digital reverb algorithms that continue to influence modern reverberation models. A key innovation in Moorer’s approach was the use of a tapped delay line to simulate early reflections—an important feature in the perception of acoustic space. The early reflections, rather than the later reverberant tail, play a more prominent role in how we perceive the size and shape of an environment. The tapped delay line in Moorer’s model could be adjusted with specific delay times and gain structures to approximate the reflections of an actual acoustic space, such as a concert hall. In his article, Moorer provides a 19-tap delay line based on a geometric simulation of the Boston Symphony Hall. He omits the first tap, which has a delay time of 0 and a gain of 1, as it represents the original dry signal. Additionally, Moorer enhanced his reverb model by incorporating a first-order low-pass filter in the feedback loop of the six comb filters. This filter simulates the absorption effects of air, which are influenced by factors such as humidity, temperature, the frequency of sound, and the distance from the sound source. Moorer discusses how atmospheric conditions affect the intensity of sound as it travels, and this low-pass filter helped account for the natural damping of higher frequencies over distance. This combination of early reflections through a tapped delay line and the low-pass feedback filters for air absorption marked a significant step forward in creating more realistic digital reverberation, and Moorer’s work laid the foundation for many of the reverberation algorithms in use today.

// Moorer Reverb
moorerReverb = _ * 0.1 : earlyReflections <: combSection + _
with {
    earlyReflections =  _ <:
        (_ @ sasamps(0.0043)) * 0.841,
        (_ @ sasamps(0.0215)) * 0.504,
        (_ @ sasamps(0.0225)) * 0.491,
        (_ @ sasamps(0.0268)) * 0.379,
        (_ @ sasamps(0.0270)) * 0.380,
        (_ @ sasamps(0.0298)) * 0.346,
        (_ @ sasamps(0.0458)) * 0.289,
        (_ @ sasamps(0.0485)) * 0.272,
        (_ @ sasamps(0.0572)) * 0.192,
        (_ @ sasamps(0.0587)) * 0.193,
        (_ @ sasamps(0.0595)) * 0.217,
        (_ @ sasamps(0.0612)) * 0.181,
        (_ @ sasamps(0.0707)) * 0.180,
        (_ @ sasamps(0.0708)) * 0.181,
        (_ @ sasamps(0.0726)) * 0.176,
        (_ @ sasamps(0.0741)) * 0.142,
        (_ @ sasamps(0.0753)) * 0.167,
        (_ @ sasamps(0.0797)) * 0.134 :> _;

    combSection = _ <:
        lbcf(sasamps(0.040), 0.95, 0.5),
        lbcf(sasamps(0.041), 0.95, 0.5),
        lbcf(sasamps(0.043), 0.95, 0.5),
        lbcf(sasamps(0.055), 0.95, 0.5),
        lbcf(sasamps(0.059), 0.95, 0.5),
        lbcf(sasamps(0.061), 0.95, 0.5) :> _ :
        apf(sasamps(0.007), -0.09683) @ sasamps(0.0017);
};
process = moorerReverb;

Freeverb

A more recently developed Schroeder/Moorer Reverberation Simulation is Freeverb – a public domain C++ program by Jezar at Dreampoint used extensively in the free-software world. It uses four Schroeder allpasses in series and eight parallel Schroeder-Moorer filtered-feedback comb-filters for each audio channel, and is said to be especially well tuned.

freeverb = _ * 0.1 : combSection : allpassSection
with {
    combSection = _ <:
    // 1557 samples at 44100 = ms 35.3061218
    lbcf(msasamps(35.3061218), 0.84, 0.2),
    // 1617 samples at 44100 = ms 36.6666679
    lbcf(msasamps(36.6666679), 0.84, 0.2),
    // 1491 samples at 44100 = ms 33.8095245
    lbcf(msasamps(33.8095245), 0.84, 0.2),
    // 1422 samples at 44100 = ms 32.2448997
    lbcf(msasamps(32.2448997), 0.84, 0.2),
    // 1277 samples at 44100 = ms 28.9569168
    lbcf(msasamps(28.9569168), 0.84, 0.2),
    // 1356 samples at 44100 = ms 30.7482986
    lbcf(msasamps(30.7482986), 0.84, 0.2),
    // 1188 samples at 44100 = ms 26.9387760
    lbcf(msasamps(26.9387760), 0.84, 0.2),
    // 1116 samples at 44100 = ms 25.3061218
    lbcf(msasamps(25.3061218), 0.84, 0.2) :> _;

    allpassSection =
    // 225 samples at 44100 = ms 5.1020408
    apf(msasamps(5.10204080), -0.5) :
    // 556 samples at 44100 = ms 12.6077099
    apf(msasamps(12.6077099), -0.5) :
    // 441 samples at 44100 = ms 10.0000000
    apf(msasamps(10.0000000), -0.5) :
    // 341 samples at 44100 = ms 7.7324262
    apf(msasamps(7.73242620), -0.5);
};
process = freeverb;

Feedback Delay Network (FDN)

The first ideas originate from Michael Gerzon’s Studio Sound reverb articles from 1971 and 1972. Later, in 1982, Stautner and Puckette introduced a multichannel reverberation algorithm in their paper “Designing Multichannel Reverberators.” The algorithm, called the Feedback Delay Network (FDN), aims to simulate the behavior of reflections within a room by using only a series of parallel comb filters with interconnected feedback paths. Below is a 4x4 example of the general design they proposed.

fdnLossless = (inputPath : delaysPath : hadamardPath : normHadamard) ~
si.bus(4) : delCompensation
with{
    t60(msDel, t60) = pow(0.001, msDel / t60);
    inputPath = ro.interleave(4, 2) : par(i, 4, (_, _) :> _);
    delay(ms) = _ @ (msasamps(ms) - 1);
    delaysPath = delay(68), delay(77), delay(90), delay(99);
    hadamardPath = hadamard(4);
    normHadamard = par(i, 4, _ * (1.0 / sqrt(4)));
    delCompensation = par(i, 4, mem);
};
//process = fdnLossless :> par(i, 2, _ / 2);

fdn = (inputPath : opPath : delaysPath : hadamardPath : normHadamard : decay) ~
si.bus(4) : delCompensation
with{
    t60(msDel, t60) = pow(0.001, msDel / t60);
    inputPath = ro.interleave(4, 2) : par(i, 4, (_, _) :> _);
    opPath = par(i, 4, op(0.4));
    delay(ms) = _ @ (msasamps(ms) - 1);
    delaysPath = delay(68), delay(77), delay(90), delay(99);
    hadamardPath = hadamard(4);
    normHadamard = par(i, 4, _ * (1.0 / sqrt(4)));
    decay = _ * t60_ms(68, 1), _ * t60_ms(77, 1),
            _ * t60_ms(90, 1), _ * t60_ms(99, 1);
    delCompensation = par(i, 4, mem);
};
process = fdn :> par(i, 2, _ / 2);

Keith Barr Allpass Loop

Keith Barr was one of the co-founders of MXR, back in 1973. After MXR, he founded Alesis. Most recently, he designed the FV-1 chip for Spin Semiconductor. His Allpass Loop Reverb is a simplified yet effective model, utilizing a single allpass filter within a feedback loop. When multiple delays and all pass filters are placed into a loop, sound injected into the loop will recirculate, and the density of any impulse will increase as the signal passes successively through the allpass filters. The result, after a short period of time, will be a wash of sound, completely diffused as a natural reverb tail. The reverb can usually have a mono input (as from a single source), but benefits from a stereo output which gives the listener a more full, surrounding reverberant image.

Here a Faust porting of: Reverb 1 program from the Spin Semiconductor FV-1 internal ROM

kb_rom_rev1(rt, damp, L, R) = aploop
with{
// input allpass sections
apSec(0) = apf(adaptSR(32768, 156), 0.5) : apf(adaptSR(32768, 223), 0.5) : apf(adaptSR(32768, 332), 0.5) : apf(adaptSR(32768, 548), 0.5);
apSec(1) = apf(adaptSR(32768, 186), 0.5) : apf(adaptSR(32768, 253), 0.5) : apf(adaptSR(32768, 302), 0.5) : apf(adaptSR(32768, 498), 0.5);

// allpass loop sections
loopSec(0) = _ @ (adaptSR(32768, 4568) - 1) : _ * rt : _ + (L : apSec(0)) : apfMod(os.osc(0.5), adaptSR(32768, 1251), adaptSR(32768, 20), 0.6) : apf(adaptSR(32768, 1751), 0.6) : op(damp) : op(- 0.05);
loopSec(1) = _ @ adaptSR(32768, 5859) : _ * rt : apf(adaptSR(32768, 1443), 0.6) : apf(adaptSR(32768, 1343), 0.6) : op(damp) : op(- 0.05);
loopSec(2) = _ @ adaptSR(32768, 4145) : _ * rt : _ + (R : apSec(1)) : apfMod(os.osc(0.5), adaptSR(32768, 1582), adaptSR(32768, 20), 0.6) : apf(adaptSR(32768, 1981), 0.6) : op(damp) : op(- 0.05);
loopSec(3) = _ @ adaptSR(32768, 3476) : _ * rt : apf(adaptSR(32768, 1274), 0.6) : apf(adaptSR(32768, 1382), 0.6) : op(damp) : op(- 0.05);

// output delay taps
outTaps = ((_ * 1.5 @ adaptSR(32768, 2630), _ * 1.2 @ adaptSR(32768, 1943), _ * 1.0 @ adaptSR(32768, 3200), _ * 0.8 @ adaptSR(32768, 4016)) :> +),
((_ * 1.0 @ adaptSR(32768, 2420), _ * 0.8 @ adaptSR(32768, 2631), _ * 1.5 @ adaptSR(32768, 1163), _ * 1.2 @ adaptSR(32768, 3330)) :> +);

// complete allpass loop
aploop = (_ : loopSec(0) <: ((loopSec(1) <: ((_ : loopSec(2) <: loopSec(3), _), _)), _)) ~ _ : ro.cross(4) <: outTaps;
};
process = kb_rom_rev1(0.95, 0.5);

Here another Reverb Model based on the Keith Barr Allpass Loop Reverb. A Corey Kereliuk’s implementation of the Reverb.

ck_kbVerb(apfG, krt) = si.bus(2) : mix(ma.PI/2) : * (0.5), * (0.5) : procLeft, procRight : si.bus(2)
with{	 
    // stereo input mix
    mix(theta) = si.bus(2) <: (*(c), *(-s), *(s), *(c)) : (+, +) : si.bus(2)
	with {
		c = cos(theta);
		s = sin(theta);
	};

    // import prime numbers
    primes = component("prime_numbers.dsp").primes;
    // calculation of left and right indexes
    ind_left(i)  = 100 + 10 * pow(2, i) : int;
    ind_right(i) = 100 + 11 * pow(2, i) : int;

    // allpass single section
    section((n1, n2)) = apf(n1, - apfG) : apf(n2, - apfG) : _ @ int(0.75 * (n1 + n2));

    // chain and ring functions
    allpass_chain(((n1, n2), ns), x) = _ : section((n1, n2)) <: R(x, ns), _
    with {
    	R(x, ((n1, n2), ns)) = _,x : + : section((n1, n2)) <: R(x, ns), _;
    	R(x, (n1, n2)) = _,x : + : section((n1, n2));
    };
    procMono(feedfwd_delays, feedback_delays, feedback_gain, x) = x :
    (+ : allpass_chain(feedfwd_delays, x)) ~ (_,x : + : section(feedback_delays) :
    *(feedback_gain)) :> _;
    // left reverb
	feedfwd_delays_left = par(i, 5, (ba.take((ind_left(i)), primes), ba.take((ind_left(i+1)), primes)));
	feedback_delays_left = (ba.take(100, primes), ba.take(101, primes));
	procLeft = procMono(feedfwd_delays_left, feedback_delays_left, krt);
	// right reverb
	feedfwd_delays_right = par(i, 4, (ba.take((ind_right(i)), primes), ba.take((ind_right(i+1)), primes)));
	feedback_delays_right = (ba.take(97, primes), ba.take(99, primes));
	procRight = procMono(feedfwd_delays_right, feedback_delays_right, krt);
};
process = ck_kbVerb(0.7, 0.5);

James Dattorro and the Lexicon 480L Topology: A Landmark in Reverb Design

In his groundbreaking paper published in the Journal of the Audio Engineering Society, Vol. 45, No. 9, September 1997, James Dattorro opened up the design secrets behind the allpass loop reverbs, offering detailed insights into a reverb architecture that would shape the future of digital reverb technology. Whereas earlier papers, such as Gardner’s, hinted at concepts that had been circulating privately within the music technology industry, Dattorro’s paper fully exposed the inner workings of allpass loop reverbs. He introduced a specific allpass loop reverb in great detail, including all the delay lengths and coefficients, which he described as being “in the style of [Lexicon’s] Griesinger.” This paper effectively served as a Rosetta Stone for reverb design, offering a clear and practical understanding of the mechanisms that drive reverb effects. Many modern reverb plugins and built-in synth reverbs have directly recreated the “Dattorro” reverb, underscoring the paper’s enduring influence in the field. One of the paper’s key contributions was Dattorro’s exploration of the single loop feedback system, which was central to the Lexicon 480L’s reverb design. This architecture, which Dattorro helped reveal, is simpler yet more effective in simulating natural reverbs, providing dense and realistic sound with minimal complexity. The Lexicon 480L’s feedback structure, initially shrouded in secrecy, was described in Dattorro’s work with full transparency, as the company had granted him permission to detail their proprietary system. This was a crucial moment in the advancement of reverb design, as it opened up new possibilities for digital reverberation.

greisingerReverb(decay, damp) = (si.bus(2) :> _ * (1 / 2) : predelay : op(damp) : apfsec) <: si.bus(2) : (ro.interleave(2, 2) : (par(i, 2, (_, _) :> + : loopsec(i)) : ro.crossNM(4, 1), si.bus(3))) ~ si.bus(2) : (si.block(2), si.bus(6)) : routing
with{
    predelay = _ @ msasamps(30);

    apfsec = apf(msasamps(4.771), 0.75) : apf(msasamps(3.595), 0.75) :
        apf(msasamps(12.73), 0.625) : apf(msasamps(9.307), 0.625);

    loopsec(0) = apfMod(os.osc(0.10), msasamps(30.51), msasamps(4), 0.7) :
        _ @ msasamps(141.69) : (_ <: _, _) : (op(damp), _) :
        (apf(msasamps(89.24), 0.5) <: _, _), _ :
        (_ @ (msasamps(106.28) - 1) <: _, mem), _, _ :  
        (_ * decay, _, _, _) : (_, ro.cross(3));

    loopsec(1) = apfMod(os.osc(0.07), msasamps(22.58), msasamps(4), 0.7) :
        _ @ msasamps(149.62) : (_ <: _, _) : (op(damp), _) :
        (apf(msasamps(60.48), 0.5) <: _, _), _ :
        (_ @ (msasamps(125.00) - 1) <: _, mem), _, _ :  
        (_ * decay, _, _, _) : (_, ro.cross(3));

    routing(dA0, ap0, dB0, dA1, ap1, dB1) =
        ((dA0 @ msasamps(8.90), dA0 @ msasamps(99.8), ap0 @ msasamps(64.2), dB0 @ msasamps(67),
          dA1 @ msasamps(66.8), ap1 @ msasamps(6.3), dB1 @ msasamps(35.8),  0) :> +),
        ((dA0 @ msasamps(70.8), ap0 @ msasamps(11.2), dB0 @ msasamps(4.1), dA1 @ msasamps(11.8),
          dA1 @ msasamps(121.7), ap1 @ msasamps(41.2), dB1 @ msasamps(89.7), 0) :> +);
};
process = greisingerReverb(0.8, 0.4);

References

• Manfred Schroeder, “Natural Sounding Artificial Reverb,” 1962.
• Michael Gerzon, “Synthetic Stereo Reverberation,” 1971.
• James (Andy) Moorer, “About This Reverberation Business,” 1979
• Christopher Moore, “Time-Modulated Delay System and Improved Reverberation Using Same,” 1979.
• John Stautner and Miller Puckette, “Designing Multichannel Reverberators,” 1982.
• Jon Dattorro, “Effect Design - Part 1: Reverberator and Other Filters,” 1997.
• Jean-Marc Jot, “Efficient models for reverberation and distance rendering in computer music and virtual audio reality,” 1997.
• D. Rochesso, “Reverberation,” DAFX - Digital Audio Effects, Udo Zölzer, 2002.

Topologies

• Manfred Schroeder propone l’applicazione di una rete di allpass e comb filters.
• James Moorer implementa un filtro lowpass all’interno della retroazione dei comb.
• Christopher Moore propone linee di ritardo modulate nel tempo e uscite Multi-tap da modelli delle early relfection.
• William Martens e Gary Kendall propongono delle early reflection spazializzate.
• Michael Gerzon, John Stautner & Miller Puckette propongono le Feedback Delay Network (mixer a matrice per i feedback).
• David Griesinger propone un singolo Loop di Feedback utilizzando ritardi e filtri allpass.

Main References

Introduction to Digital Filters: With Audio Applications. books by Julius O. Smith III. Links to the series by Smith:

• Mathematics of the Discrete Fourier Transform (DFT)
• Introduction to Digital Filters
• Physical Audio Signal Processing
• Spectral Audio Signal Processing CCRMA by J.Smith https://ccrma.stanford.edu/~jos/fp/ su DSP Related Free DSP Books

TOM ERBE - UC SAN DIEGO - REVERB TOPOLOGIES AND DESIGN http://tre.ucsd.edu/wordpress/wp-content/uploads/2018/10/reverbtopo.pdf

Corey Kereliuk - Building a Reverb Plugin in Faust Keith Barr’s reverb architecture Building a Reverb Plugin in Faust

Spin Semiconductor DSP Basics Spin Semiconductor - DSP Basics Spin Semiconductor Audio Effects Spin Semiconductor - Effects

freeverb3vst - Reverb Algorithms Tips http://freeverb3vst.osdn.jp/tips/reverb.shtml

History of allpass loop / “ring” reverbs History of allpass loop / "ring" reverbs? - Spin Semiconductor

Musical Applications of Microprocessors (The Hayden microcomputer series) http://sites.music.columbia.edu/cmc/courses/g6610/fall2016/week8/Musical_Applications_of_Microprocessors-Charmberlin.pdf

Acustica_Riverbero - Alfredo Ardia Appunti: acustica_Riverbero

Dattorro Convex Optimization of a Reverberator Dattorro Convex Optimization of a Reverberator - Wikimization

primes under 10.000 https://www.matematika.it/public/allegati/34/Numeri_primi_minori_di_10000_1_3.pdf

In computers, time-varying details that occur unpredictably in the physics of sound must be carefully sequenced, often to the point of exhausting the resources of the computer (and the programmer).

This problem has existed since the early days of computer music. Indeed, we can think of the first examples of research in this field, such as those conducted by Max Mathews and his colleagues at Bell Labs, who studied the possibilities of sound control using nonlinear signals and algorithms in the early MUSIC-N family synthesis languages. Some examples include low-frequency noise generators such as RAN and RAH, which generate pseudo-random signals for controlling sound parameters like frequency, amplitude, etc.

Using nonlinear signals in sound synthesis and control can thus be an effective way to generate sounds that are closer to natural ones compared to those generated through more standard digital synthesis techniques, using more computationally efficient methods. Here, I will implement circuits in the Faust programming language (GRAME) to discretely represent some pseudo-random and stochastic models useful for generating control signals.

White Noise Generator

The first fundamental building block for working with random numbers is the pseudo-random number generator, also known in the Digital Signal Processing (DSP) domain as digital white noise. When a random stream of numbers is generated and reproduced at the sample level, the resulting sound is typical of white noise. White noise generators have been used in the field of computer music since its beginning. We can trace their utilization back to even Max Mathew’s 1963 article The Digital Computer as a Musical Instrument, the first known paper on computer music.

In general, a random number generator provides an N-bit binary number every time it is called. If these conditions are truly met, each bit or any subset of the bits in the numbers should also be random. However, no algorithmic random number generator completely meets all of these criteria. In fact, most random number generation algorithms are numerical functions that accept their previous output as input and generate a new output.

The initial input used when the generator is started is called the seed, and it can usually be any number except zero. If the same seed number is used on two different occasions, the series of numbers generated will also be the same.

Since the output numbers are integers with a finite number of bits, it is obvious that at some point in the sequence the seed will appear again. From this point forward, the sequence repeats itself.

An efficient random number generator will generate all or nearly all of the 2N different numbers that can be represented by an N-bit word before repeating.

Linear Congruential Generator

One of the most popular random number algorithms is the linear congruential method. The first model is attributed to the Lehmer random number generator (named after D. H. Lehmer), sometimes also referred to as the Park-Miller random number generator (after Stephen K. Park and Keith W. Miller). This is a type of linear congruential generator (LCG) that operates in the multiplicative group of integers modulo N.

The basic function is: \(R_{\text{new}} = (A \times R_{\text{old}} + C) \mod M\) where A and C are carefully chosen constants, and M is the largest possible number plus one for the chosen word length. The generator is completely specified by giving values for A, C, and the word length. For any given word length, there are values for A and C (besides the trivial ones, A = 1 and C = 1) that will give M values before repeating.

In Faust, a typical linear congruential generator following this method can be written as follows:

import("stdfaust.lib");

// Pseudo-random noise with linear congruential generator (LCG)
noise(initSeed) = lcg ~ _ : (_ / m)
with{
 a = 18446744073709551557; c = 12345; m = 2 ^ 31;
lcg(seed) = ((a * seed + c) + (initSeed - initSeed') % m);
};
process = noise(1212);

This algorithm will generate a new random value on every sample, corresponding to the sample rate of the system.

How the LCG Works:

Initialization:

   - The generator starts with an initial seed (initSeed) that serves as the starting value for the sequence. The quality of randomness depends heavily on this seed.

Recurrence Relation:

   - The generator calculates each new random value in seed

   - Here:

     - A: Is the multiplier.

     - C: Is the increment.

     - M: Is the modulus, which determines the range of possible output values.

Feedback:

   - The output of the lcg function is fed back into itself through the feedback operator (~ in FAUST), allowing it to generate a sequence of pseudo-random numbers.

Scaling:

   - The result is divided by M (_ / m) to normalize the output to the range [0, 1].

Constants in the Code:

   - a: A large, carefully chosen multiplier to ensure good randomness.

   - c: A small constant increment, often chosen to avoid patterns in the generated numbers.

   - m: The modulus, chosen as a power of two (here, \(2^{31}\)), which is common for computational efficiency.

Multiple Outputs

It is also possible to generate multiple outputs from the same linear congruential generator by adding an internal sequential operation seqN that repeats the LCG process in series and takes multiple taps. Here’s an example of how you can create multiple outputs:

import("stdfaust.lib");

// Noise - Linear Congruential Generator - Multiple Outputs
multinoise(N, initSeed) = ((_ + (initSeed - initSeed') :
    seqN(N, (_ * a + c) % m )) ~ _ : par(i, N, _ / m))
with{
    // LCG constants
    a = 18446744073709551557; c = 12345; m = 2 ^ 31;
    // Sequential operations
    seqN(N, OP) = _ <: seq(i, N, (OP <: _, _),
        si.bus(i + 1)) : (_, !, si.bus(N - 1), !);
};
process = multinoise(4, 1212);

Low frequency Noise Generator

Since in Faust every function runs at the single sample level, our linear congruential generator will generate a new number at every sample. For this reason, if we want to use a noise generator as a low-frequency oscillator for control signals, we need to hold the values at slower rate intervals.

For this purpose, the first thing we need to do is build a sample-and-hold module that can hold a signal when triggered.

In Faust, we can write a sample-and-hold function as follows:

import("stdfaust.lib");

// a classic sample and hold
sah(x, t) = selector(t, _, x) ~ _
with{
    // binary selector
    selector(sel, x, y) = x * (1 - sel) + y * (sel);
};

How sah Works:

Initial State:

• The feedback loop (~ _) initializes the memory (_) to zero (or undefined, depending on implementation).

Sampling:

• When t (the trigger signal) becomes 1, the selector picks the value of x (the input signal) and stores it in the feedback loop (_).

Holding:

• When t is 0, the selector picks the previously stored value from _, effectively holding the last sampled value.

The feedback (~) allows the output to retain and “remember” the last sampled value. Without it, the function would only output the input directly without holding any value.

Now that we have our SAH module, we need a clock function that can generate triggers at regular intervals. For this purpose, we need triggers that last only one sample. In fact, if we use this sample and hold function with a bandwidth larger than a single sample, the gate of the input signal will remain open depending on the duration of the band before the output is stored in our feedback circuit.

We can write a single-sample trigger as follows:

import("stdfaust.lib");

// Synchronous pulse train in HZ
metro(ms) = phasor0(1000 / max(1, ms)) : derivate + dirac
with{
    // phasor that start from 0
    phasor0(f) = (_ <: _ + f, _) ~ _ % ma.SR : (!, _ / ma.SR);
    // Dirac Impulse at Compile Time
    dirac = 1 - (1 : mem);
    // first derivate
    derivate(x) = x < x';
};
process = metro(100);

How the Synchronous Pulse Train (metro) Works:

The metro function generates a pulse train with a specified frequency (given in milliseconds).

Main Function:

• metro(ms) takes an input in milliseconds (ms) to define the pulse interval.
• It converts the interval in milliseconds to a frequency in Hz using: 1000 / max(1, ms) This ensures the frequency is always positive and at least 1 ms, avoiding divisions by 0.

Phasor Generation:

phasor0(f) = (_ <: _ + f, _) ~ _ % ma.SR : (!, _ / ma.SR);

Creates a repeating ramp signal (phasor) that oscillates between 0 and 1.

• _ <: _ + f Increments the current phase value by f (frequency).

• ~ _ Uses feedback to store the current phase value across iterations.

• % ma.SR Resets the phase to 0 when it reaches the Sample Rate, creating a looping behavior.

• _ / ma.SR Normalizes the ramp signal to a range of [0, 1] dividing the output by Sample Rate.

Derivative Detection:

derivate(x) = x < x'; Detects when the phasor value resets to 0 by comparing the current value (x) with its previous value at 1 sample delay \(Z^{-1}\) = '.

Dirac Impulse:

dirac = 1 - (1 : mem); (mem and ' are the same) Generates a single impulse at compile time, ensuring an initial pulse is present.

The pulse train is generated by combining the output of the derivative (derivate) with the Dirac impulse: metro(ms) = phasor0(1000 / max(1, ms)) : derivate + dirac;

where:

• phasor0 creates the ramp signal.

• derivate detects when the ramp resets.

• dirac ensures an initial pulse is present.

• The combination produces a series of synchronized 1 sample pulses.

Now that our modules are complete, we can connect them together to sample the noise input at a low sampling rate, building the low-frequency noise generator as follows:

process = noise(1212), metro(100) : sah;

Or by putting everything together in a single function:

import("stdfaust.lib");

// noise sampled with a classic sample and hold
sahNoise(seed, f) = selector(pulseTrain, _, noise(seed)) ~ _
with{
    // Pseudo-random noise with linear congruential generator (LCG)
    noise(initSeed) = lcg ~ _ : (_ / m)
    with{
        a = 18446744073709551557; c = 12345; m = 2 ^ 31;
        lcg(seed) = ((a * seed + c) + (initSeed - initSeed') % m);
    };
    // binary selector
    selector(sel, x, y) = x * (1 - sel) + y * (sel);
    // Dirac Impulse at Compile Time
    dirac = 1 - (1 : mem);
    derivate(x) = x < x';
    phasor0 = (_ <: _ + f, _) ~  _ % ma.SR : (!, _ / ma.SR);
    pulseTrain = phasor0 : derivate + dirac;
};
process = sahNoise(1212, 100);

This will sample random values every 100 milliseconds.

If we decide to use the same code and trigger the SAH manually, we obtain a random number generator.

A new random number is generated each time the user clicks the GUI button.

import("stdfaust.lib");

// random number generator
random(range, seed, trigger) = ((noise(seed) : abs), dirac(trigger)) :
    sah * range
with{
    // transform a constant to 1 sample trigger
    dirac(x) = (x - x') > 0;
    // Pseudo-random noise with linear congruential generator (LCG)
    noise(initSeed) = lcg ~ _ : (_ / m)
    with{
        a = 18446744073709551557; c = 12345; m = 2 ^ 31;
        lcg(seed) = ((a * seed + c) + (initSeed - initSeed') % m);
    };  
    // a classic sample and hold
    sah(x, t) = selector(t, _, x) ~ _
    with{
        // binary selector
        selector(sel, x, y) = x * (1 - sel) + y * (sel);
    };
};
process = random(100, 1212, button("trigger"));

where abs ensures only positive values by applying the absolute value, range is a multiplication factor that determines the output range, extending it beyond [0, 1] to [0, range], and dirac(x) = (x - x') > 0; transforms a signal with a bandwidth larger than a single sample into a single-sample impulse.

Asynchronous Low frequency Noise Generator

We now have a low frequency noise generator, but the values are output at a synchronous clock rate. This means that while the sequence of values is unpredictable, the timing of updates remains consistent.

If we want to make our noise generator more complex, we can apply the principles we’ve learned so far to create an asynchronous clock for our low-frequency noise by mixing these elements together.

What we aim to achieve now is the generation of a clock with asynchronous timing, so that the output values from the sample and hold can change at unpredictable moments.

The following Faust code implements a random impulse generator, where the impulses occur at irregular intervals based on a pseudo-random number generator. The intervals are constrained to a range between ms1 and ms2, specified in milliseconds.

// random impulse generator / ms1 & ms2 = range
randometro(seed, ms1, ms2) = randomtrigger
with{
    // Pseudo-random noise with linear congruential generator (LCG)
    noise(initSeed) = lcg ~ _ : (_ / m)
    with{
        a = 18446744073709551557; c = 12345; m = 2 ^ 31;
        lcg(seed) = ((a * seed + c) + (initSeed - initSeed') % m);
    };
    // Dirac Impulse at Compile Time
    dirac = 1 - (1 : mem);
    derivate(x) = x < x';
    phasor0(f) = (_ <: _ + f, _) ~  _ % ma.SR : (!, _ / ma.SR);
    pulseTrain(f) = phasor0(f) : derivate;
    // a classic sample and hold
    sah(t, x) = selector(t, _, x) ~ _
    with{
        // binary selector
        selector(sel, x, y) = x * (1 - sel) + y * (sel);
    };
    msMin = min((1000 / max(1, ms1)), (1000 / max(1, ms2)));
    msMax = max((1000 / max(1, ms1)), (1000 / max(1, ms2)));
    randomtrigger = ((_ + dirac), abs(noise(seed)) * (msMax - msMin) + msMin :
        sah : pulseTrain) ~ _;
};
//process = randometro(1212, 100, 4000), randometro(1234, 100, 4000);

The function randometro(seed, ms1, ms2) takes as its input a seed value for the LCG and ms1, ms2 as the bounds of the random interval range, given in milliseconds.

msMin = min((1000 / max(1, ms1)), (1000 / max(1, ms2)));
msMax = max((1000 / max(1, ms1)), (1000 / max(1, ms2)));

This converts the input intervals ms1 and ms2 (in milliseconds) into corresponding frequencies in Hz.

The variables msMin andmsMax represent the lower and upper bounds, ensuring consistent interval limits derived from ms1 and ms2.

Beyond the functions we have already discussed, the core of the random impulse train is defined as:

randomtrigger = ((_ + dirac), abs(noise(seed)) * (msMax - msMin) + msMin :
    sah : pulseTrain) ~ _;

The function generates a random interval using noise(seed), scaled to the range [msMin, msMax].

Here, msMin serves as the base frequency offset, while msMax scales the seed to adjust the range of the output values. The term (msMax - msMin) ensures the maximum range does not exceed the intended limit, as msMin is added as a base offset.

Next, the sah function is used to sample and hold the random value, ensuring it remains constant during the specified interval.

Finally, the pulseTrain function takes the random value as its frequency, varying it over time based on the newly generated random number. This output is fed back into the sah function, which triggers the next random value and consequently alters the frequency, creating a dynamic and unpredictable sequence.

We now have a random impulse generator that we can use as a clock source for the low-frequency noise generator, making it operate at asynchronous time intervals. This can be used as a non-linear control signal.

Below is the complete code that brings it all together:

import("stdfaust.lib");

// SAH noise at random intervals / ms1 & ms2 = range
sahNoiserandom(seed, ms1, ms2) = selector(randometro, _, noise(seed)) ~ _
with{
    // Pseudo-random noise with linear congruential generator (LCG)
    noise(initSeed) = lcg ~ _ : (_ / m)
    with{
        a = 18446744073709551557; c = 12345; m = 2 ^ 31;
        lcg(seed) = ((a * seed + c) + (initSeed - initSeed') % m);
    };
    // binary selector
    selector(sel, x, y) = x * (1 - sel) + y * (sel);
    // random impulse generator / ms1 & ms2 = range
    randometro = randomtrigger
    with{
        // Dirac Impulse at Compile Time
        dirac = 1 - (1 : mem);
        derivate(x) = x < x';
        phasor0(f) = (_ <: _ + f, _) ~  _ % ma.SR : (!, _ / ma.SR);
        pulseTrain(f) = phasor0(f) : derivate;
        // a classic sample and hold
        sah(t, x) = selector(t, _, x) ~ _
        with{
            // binary selector
            selector(sel, x, y) = x * (1 - sel) + y * (sel);
        };
        msMin = min((1000 / max(1, ms1)), (1000 / max(1, ms2)));
        msMax = max((1000 / max(1, ms1)), (1000 / max(1, ms2)));
        randomtrigger = ((_ + dirac), abs(noise(seed * 2)) * (msMax - msMin) +
            msMin : sah : pulseTrain) ~ _;
    };
};
process = sahNoiserandom(1212, 100, 4000);

Stochastic Signals

In Digital Signal Processing (DSP), the concept of stochastic processes is often used to describe signals that evolve unpredictably over time. While random signals (such as noise) can be unpredictable, stochastic processes are defined by probabilistic models that describe the likelihood of different outcomes, making their behavior dynamic but not entirely predetermined.

For example, random walks and Brownian motion are both types of stochastic processes commonly used to model natural, physical randomness, and they lead to outputs that feel more connected to real-world phenomena.

Stochastic processes are useful in applications where randomness and gradual changes are required, such as in Brownian motion, fractal-based noise, and Markov chains. These processes introduce correlations between successive values, which is particularly useful for modeling behaviors that evolve smoothly rather than in abrupt, discontinuous jumps.

A stochastic process in fact refers to a system that is nondeterministic or unpredictable. It evolves in a way that can’t be precisely predicted, though it is governed by probabilistic rules. These processes are defined by their probabilistic models, which describe the likelihood of various outcomes over time, making them dynamic with behavior that is not predetermined.

On the other hand, random typically refers to something that is unrecognizable or not following any identifiable pattern. Random signals evolve in time in an unpredictable manner, and their individual values cannot be predicted with certainty. However as we observe with pseudo-random generators, the average properties of random signals are deterministic. Since total unpredictability cannot be computed, the terms “stochastic” and “random” can sometimes be used interchangeably.

A case of study of the Random Walk : the Drunk object from Max Msp

One of the simplest stochastic processes is the random walk, a term first introduced by Karl Pearson in 1905. The random walk is the formalization of the idea of taking successive steps in random directions, and it is the simplest Markov process, whose most well-known mathematical representation is the Norbert Wiener process. A Wiener process, also known as Brownian motion, is a Gaussian stochastic process in continuous time with independent increments. It is used to model Brownian motion itself as well as various random phenomena observed in applied mathematics, finance, and physics.

The term “Brownian motion” specifically refers to the erratic motion of particles small enough (with diameters on the order of a micrometer) to be unaffected by gravity, present in fluids or gaseous suspensions (such as smoke), and observable under a microscope. The phenomenon was discovered in the early 19th century by the Scottish botanist Robert Brown and was later modeled in 1905 by the German theoretical physicist Albert Einstein.

In the Max MSP programming environment, an example of Brownian motion for control signals can be found in the object drunk.

The drunk walk model is a stochastic process that nominally follows the path of a drunk person who has just left a bar. At each step, he randomly chooses to move either to the left or to the right, without knowing where he came from or where he is going. After the first step, his next move is chosen randomly, either left or right, and this pattern continues. In the mathematical model, the drunk never sobers up, and an interesting feature of this process is that the drunk tends to return to his starting point over time.

I attempted and succeeded in porting this model to Faust. Below is the Faust code that implements the random walk process.

import("stdfaust.lib");

// random walk generator : variable steps and max value
drunk(seed, maxvalue, stepsize, trigger) = noise(seed), (trigger : dirac) :
    sah * (abs(stepsize) + 1) : int * (trigger : dirac) : + ~ _ :
        foldInt(abs(maxvalue))
with{
    // transform a constant to 1 sample trigger
    dirac(x) = (x - x') > 0;
    // pseudo-random noise with linear congruential generator (LCG)
    noise(initSeed) = lcg ~ _ : (_ / m)
    with{
        a = 18446744073709551557; c = 12345; m = 2 ^ 31;
        lcg(seed) = ((a * seed + c) + (initSeed - initSeed') % m);
    };
    // a classic sample and hold
    sah(x, t) = selector(t, _, x) ~ _
    with{
        // binary selector
        selector(sel, x, y) = x * (1 - sel) + y * (sel);
    };
    // fold at max Int value and 0
    foldInt(maxv, x) = maxv - abs((abs(x) % (2 * maxv)) - maxv);
};
process = (os.phasor(1, 10) - 0.1 < 0.0) : drunk(1212, 100, 10);

In this code, at every trigger input, the sample and hold noise provides an integer value between a base of 1 and a maximum value, similar to how we implement the random impulse generator. However, the key difference is that at each step, the value is held inside the integrator (+ ~ _), and at successive steps, a sum or difference is performed between the value stored in the integrator and the new value generated.

To achieve this, we need to ensure that when a new number is generated by the sah, it lasts only one sample (int * (trigger : dirac)). If we don’t implement this, another operation will be automatically performed on the next sample, causing unintended results.

Finally, the foldInt object: foldInt(maxv, x) = maxv - abs((abs(x) % (2 * maxv)) - maxv); ensures that only values within the range of maxvalue are output. If the range is exceeded, a foldover operation is performed on the signal, wrapping the value back into the defined range.

An important aspect of creating time-varying control signals is to obtain a smooth transition between every sample. In fact, a random walk signal like the one generated by the drunk object, at the sample level in Faust, creates discontinuities in the signal. These discontinuities can lead to issues such as aliasing, or worse, an overall lack of definition in the behaviors used to control a carrier signal due to the poor temporal consistency of the signal.

An alternative way to program a random walk in Faust in response to these problems could be simpler than this last one. By changing the direction of the signal at every sample, we can impose a condition on the noise generator to produce only binary values in the range of [-1, 1]. To avoid discontinuities, we can use integration techniques such as linear interpolation or filters to smooth the signal.

randomWalk(seed, speed, smooth, trigger) = binaryNoise(seed) / ma.SR : + ~ _ : _ * speed : wavefolding : fi.lowpass(1, 1 / smooth)
with{
    // transform a constant to 1 sample trigger
    dirac(x) = (x - x') > 0;
    // a classic sample and hold
    sah(x, t) = selector(t, _, x) ~ _
    with{
        // binary selector
        selector(sel, x, y) = x * (1 - sel) + y * (sel);
    };
    // pseudo-random binary noise with linear congruential generator (LCG)
    binaryNoise(initSeed) = lcg ~ _ : (_ / m) : condition
    with{
        a = 18446744073709551557; c = 12345; m = 2 ^ 31;
        lcg(seed) = ((a * seed + c) + (initSeed - initSeed') % m);
        condition = _ <: (_ > 0.0) + (_ <= 0.0) * - 1;
    };
    // WAVEFOLDING
    wavefolding = intreset <: trifunctionpos,trifunctionneg :> + : _ * 2
    with{
        intreset(x)= x-int(x);
        triconditionpos(x) = (x <  0.5) * (x) + ((x >  0.5) * ((x * -1) +1));
        trifunctionpos(x) = (x > 0) * (x) : triconditionpos;
        triconditionneg(x) = (x > -0.5) * (x) + ((x < -0.5) * ((x * -1) -1));
        trifunctionneg(x) = (x < 0) * (x) : triconditionneg;
    };
};
process = (os.phasor(1, 100) - 0.1 < 0.0) : randomWalk(1212, 10, 2);

This last code is an example of how one can generate a non-linear, fully functioning control signal from a stochastic model like the random walk, or from other generators to obtain complex behaviors. We can address the resolution of this kind of problem by focusing on continuity, since from the RAN object in Music V. In his book on computer music (Mathews, The Technology of Computer Music), Max Mathews explains how, in the random number generator, he achieved a continuous function using linear interpolation methods.

The calibration of non-linear signal processing is an art in itself, involving a range of functional models beyond the one described here. It requires studying and refining the response of control signals and is closely tied to the type of analysis and behavior a composer or programmer seeks to achieve in their algorithm. Given the importance of this topic, it will require further focus, which I will explore in more depth in future posts.