Filters and delay lines: two useful DSP building blocks

class DelayLine:
    def __init__(self, max_len):
        self.buf = np.zeros(max_len)
        self.i = 0
    def process(self, x, delay, feedback=0.0):
        # read the past
        r = int(self.i - delay) % len(self.buf)
        y = self.buf[r]
        # write the present, optionally mixed with what came back
        self.buf[self.i] = x + y * feedback
        self.i = (self.i + 1) % len(self.buf)
        return y

# delay = time        + feedback = 0     -> echo
# delay modulated     + feedback = 0     -> chorus / flanger building blocks
# many delays         + feedback > 0     -> reverb (a first approximation)
# This toy truncates delay to integer samples; practical modulation interpolates
# fractional-sample reads and carefully handles the feedback path.

# One-pole low-pass — the smallest useful filter there is
class OnePole:
    def __init__(self, sr, cutoff_hz):
        self.z = 0.0
        self.a = np.exp(-2 * np.pi * cutoff_hz / sr)   # matched-pole coefficient from cutoff and sample rate
    def process(self, x):
        # y[n] = (1-a)*x[n] + a*y[n-1]   -- a weighted mix of new and old
        self.z = (1 - self.a) * x + self.a * self.z
        return self.z

# a close to 1  -> heavy smoothing -> low cutoff
# a close to 0  -> almost transparent -> high cutoff