Add Sallen-Key LPF to the benchmark suite

Standalone Lyte, Lua, and C implementations of a Sallen-Key low-pass
filter processing 2M samples with per-sample coefficient recomputation
(exp + tan per sample). fc is modulated slightly by the input signal
to prevent the C optimizer from hoisting the coefficient computation
out of the loop.

Wired into benchmark/run.sh as the fourth benchmark row (SK LPF).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: wtholliday

.gitignore

@@ -30,6 +30,8 @@ benchmark/fft_c_o2
 benchmark/fft_c_o3
 benchmark/sort_c_o2
 benchmark/sort_c_o3
+benchmark/sk_lpf_c_o2
+benchmark/sk_lpf_c_o3
 benchmark/freeverb_bench
 
 vscode-lyte/node_modules/

benchmark/run.sh

@@ -35,6 +35,8 @@ cc -O2 -o benchmark/sort_c_o2 benchmark/sort.c -lm
 cc -O3 -o benchmark/sort_c_o3 benchmark/sort.c -lm
 cc -O2 -o benchmark/fft_c_o2 benchmark/fft.c -lm
 cc -O3 -o benchmark/fft_c_o3 benchmark/fft.c -lm
+cc -O2 -o benchmark/sk_lpf_c_o2 benchmark/sk_lpf.c -lm
+cc -O3 -o benchmark/sk_lpf_c_o3 benchmark/sk_lpf.c -lm
 
 if ! command -v lua &>/dev/null; then
     echo "Error: lua not found. Install with: brew install lua" >&2
@@ -160,6 +162,13 @@ run_benchmark "FFT" \
     "benchmark/fft.lua" \
     "1024-point FFT x 2000 iterations"
 
+run_benchmark "SK LPF" \
+    "benchmark/sk_lpf.lyte" \
+    "benchmark/sk_lpf_c_o2" \
+    "benchmark/sk_lpf_c_o3" \
+    "benchmark/sk_lpf.lua" \
+    "Sallen-Key LPF, 2M samples with per-sample coefficients"
+
 if [ "$FAIL" = "1" ]; then
     echo ""
     echo "!! One or more benchmarks failed — see errors above" >&2

benchmark/sk_lpf.c

@@ -0,0 +1,67 @@
+// Sallen-Key low-pass filter benchmark
+// Process 2 million samples with per-sample coefficient recomputation
+// Based on Andrew Simper's nodal filter equations (SkfLinearTrapOptimised2.pdf)
+
+#include <math.h>
+#include <stdio.h>
+#include <time.h>
+
+int main(void) {
+    int n = 2000000;
+    double inv_sr = 1.0 / 44100.0;
+    double f_min = log(50.0);
+    double f_max = log(16000.0);
+    double f_range = f_max - f_min;
+
+    double ic1eq = 0.0;
+    double ic2eq = 0.0;
+    double last_y = 0.0;
+
+    double phase = 0.0;
+    double freq = 440.0 / 44100.0;
+    double two_pi = 2.0 * M_PI;
+
+    double fc_val = 0.5;
+    double res_val = 0.3;
+
+    struct timespec t0, t1;
+    clock_gettime(CLOCK_MONOTONIC, &t0);
+
+    for (int i = 0; i < n; i++) {
+        double x = sin(phase * two_pi);
+        phase += freq;
+        if (phase > 1.0) phase -= 1.0;
+
+        double fc_norm = fc_val + 0.001 * x;
+        if (fc_norm < 0.0) fc_norm = 0.0;
+        if (fc_norm > 1.0) fc_norm = 1.0;
+        double res_c = res_val;
+        if (res_c < 0.0) res_c = 0.0;
+        if (res_c > 1.0) res_c = 1.0;
+
+        double cutoff = exp(fc_norm * f_range + f_min);
+        double g  = tan(M_PI * cutoff * inv_sr);
+        double k  = 2.0 * res_c;
+        double g1 = 1.0 + g;
+        double a0 = 1.0 / (g1 * g1 - g * k);
+        double a1 = k * a0;
+        double a2 = g1 * a0;
+        double a3 = g * a2;
+        double a4 = 1.0 / g1;
+        double a5 = g * a4;
+
+        double v1 = a1 * ic2eq + a2 * ic1eq + a3 * x;
+        double v2 = a4 * ic2eq + a5 * v1;
+
+        ic1eq = 2.0 * (v1 - k * v2) - ic1eq;
+        ic2eq = 2.0 * v2 - ic2eq;
+
+        last_y = v2;
+    }
+
+    clock_gettime(CLOCK_MONOTONIC, &t1);
+    double elapsed = (t1.tv_sec - t0.tv_sec) + (t1.tv_nsec - t0.tv_nsec) * 1e-9;
+    fprintf(stderr, "exec: %.3fs\n", elapsed);
+    printf("%d samples, last_y=%f\n", n, last_y);
+    return 0;
+}

benchmark/sk_lpf.lua

@@ -0,0 +1,69 @@
+-- Sallen-Key low-pass filter benchmark
+-- Process 2 million samples with per-sample coefficient recomputation
+-- Based on Andrew Simper's nodal filter equations (SkfLinearTrapOptimised2.pdf)
+
+local sin = math.sin
+local exp = math.exp
+local tan = math.tan
+local log = math.log
+local pi  = math.pi
+
+local function run()
+    local n = 2000000
+    local inv_sr = 1.0 / 44100.0
+    local f_min = log(50.0)
+    local f_max = log(16000.0)
+    local f_range = f_max - f_min
+
+    local ic1eq = 0.0
+    local ic2eq = 0.0
+    local last_y = 0.0
+
+    local phase = 0.0
+    local freq = 440.0 / 44100.0
+    local two_pi = 2.0 * pi
+
+    local fc_val = 0.5
+    local res_val = 0.3
+
+    for i = 1, n do
+        -- generate input sample
+        local x = sin(phase * two_pi)
+        phase = phase + freq
+        if phase > 1.0 then phase = phase - 1.0 end
+
+        -- clamp controls (modulate fc slightly so coefficients vary per sample)
+        local fc_norm = fc_val + 0.001 * x
+        if fc_norm < 0.0 then fc_norm = 0.0 end
+        if fc_norm > 1.0 then fc_norm = 1.0 end
+        local res_c = res_val
+        if res_c < 0.0 then res_c = 0.0 end
+        if res_c > 1.0 then res_c = 1.0 end
+
+        -- map normalised fc to log frequency and compute coefficients
+        local cutoff = exp(fc_norm * f_range + f_min)
+        local g  = tan(pi * cutoff * inv_sr)
+        local k  = 2.0 * res_c
+        local g1 = 1.0 + g
+        local a0 = 1.0 / (g1 * g1 - g * k)
+        local a1 = k * a0
+        local a2 = g1 * a0
+        local a3 = g * a2
+        local a4 = 1.0 / g1
+        local a5 = g * a4
+
+        -- trapezoidal integrators
+        local v1 = a1 * ic2eq + a2 * ic1eq + a3 * x
+        local v2 = a4 * ic2eq + a5 * v1
+
+        ic1eq = 2.0 * (v1 - k * v2) - ic1eq
+        ic2eq = 2.0 * v2 - ic2eq
+
+        last_y = v2
+    end
+end
+
+local t0 = os.clock()
+run()
+local elapsed = os.clock() - t0
+io.stderr:write(string.format("exec: %.3fs\n", elapsed))

benchmark/sk_lpf.lyte

@@ -0,0 +1,62 @@
+// Sallen-Key low-pass filter benchmark
+// Process 2 million samples with per-sample coefficient recomputation
+// Based on Andrew Simper's nodal filter equations (SkfLinearTrapOptimised2.pdf)
+
+main {
+    var n = 2000000
+    var inv_sr = 1.0 / 44100.0
+    var f_min = ln(50.0)
+    var f_max = ln(16000.0)
+    var f_range = f_max - f_min
+
+    var ic1eq = 0.0
+    var ic2eq = 0.0
+    var last_y = 0.0
+
+    var phase = 0.0
+    var freq = 440.0 / 44100.0
+    var two_pi = 2.0 * 3.14159265
+
+    var fc_val = 0.5
+    var res_val = 0.3
+
+    for i in 0 .. n {
+        // generate input sample
+        var x = sin(phase * two_pi)
+        phase = phase + freq
+        if phase > 1.0 { phase = phase - 1.0 }
+
+        // clamp controls (modulate fc slightly so coefficients vary per sample)
+        var fc_norm = fc_val + 0.001 * x
+        if fc_norm < 0.0 { fc_norm = 0.0 }
+        if fc_norm > 1.0 { fc_norm = 1.0 }
+        var res_c = res_val
+        if res_c < 0.0 { res_c = 0.0 }
+        if res_c > 1.0 { res_c = 1.0 }
+
+        // map normalised fc to log frequency and compute coefficients
+        var cutoff = exp(fc_norm * f_range + f_min)
+        var g  = tan(3.14159265 * cutoff * inv_sr)
+        var k  = 2.0 * res_c
+        var g1 = 1.0 + g
+        var a0 = 1.0 / (g1 * g1 - g * k)
+        var a1 = k * a0
+        var a2 = g1 * a0
+        var a3 = g * a2
+        var a4 = 1.0 / g1
+        var a5 = g * a4
+
+        // trapezoidal integrators
+        var v1 = a1 * ic2eq + a2 * ic1eq + a3 * x
+        var v2 = a4 * ic2eq + a5 * v1
+
+        ic1eq = 2.0 * (v1 - k * v2) - ic1eq
+        ic2eq = 2.0 * v2 - ic2eq
+
+        last_y = v2
+    }
+
+    print(last_y as i32)
+    print(n)
+    println(" samples processed")
+}