"""Small DSP helpers (numpy only).""" import numpy as np # ------------------------------------------------------------------ resampling # Kaiser-windowed sinc interpolator. The kernel is tabulated at PHASES # fractional offsets per input sample (with linear interpolation between # rows), so evaluating it costs one gather and a multiply-add per tap instead # of a Bessel function and a sinc. Table error is ~1e-6, well under the # kernel's own ~3e-5 interpolation error. PHASES = 1024 _TABLES = {} def _kernel_table(cutoff, half_taps, beta): key = (float(cutoff), half_taps, float(beta)) if key not in _TABLES: hw = int(np.ceil(half_taps / cutoff)) # half-width in input samples offs = np.arange(-hw + 1, hw + 1) f = np.arange(PHASES + 1) / PHASES d = f[:, None] - offs[None, :] w = np.i0(beta * np.sqrt(np.clip(1.0 - (d / hw) ** 2, 0.0, None))) / np.i0(beta) T = cutoff * np.sinc(cutoff * d) * w _TABLES[key] = (hw, offs, T, np.diff(T, axis=0)) return _TABLES[key] def resample_at(x, pos, cutoff=1.0, half_taps=6, beta=8.0, chunk=1 << 16): """Evaluate complex sequence ``x`` at fractional sample positions ``pos``. ``cutoff`` is the low-pass cutoff relative to the Nyquist rate of ``x`` (1.0 = pure interpolation, 1/osr = anti-alias filter for decimating by ``osr``). Samples outside ``x`` are treated as zero. """ x = np.asarray(x, dtype=np.complex128) pos = np.asarray(pos, dtype=np.float64) hw, offs, T, D = _kernel_table(cutoff, half_taps, beta) L = len(x) # zero padding of 2*hw each side; clipping base to [-hw-1, L+hw-1] keeps every # tap index in the padded array, and a clipped base only ever sees zeros xp = np.concatenate([np.zeros(2 * hw, complex), x, np.zeros(2 * hw, complex)]) base = np.floor(pos) frac = pos - base base = np.clip(base.astype(np.int64), -hw - 1, L + hw - 1) if len(pos) > 1 and not np.any(frac): step = base[1] - base[0] if step > 0 and np.all(np.diff(base) == step): # uniform integer positions (decimation): one FIR, then pick outputs v = np.convolve(xp, T[0][::-1], mode="valid") # v[j] = sum_t xp[j+t] T0[t] return v[base + hw + 1] out = np.empty(len(pos), dtype=np.complex128) ph = frac * PHASES j = np.minimum(ph.astype(np.int64), PHASES - 1) w = (ph - j)[:, None] for a in range(0, len(pos), chunk): s = slice(a, a + chunk) taps = T[j[s]] + w[s] * D[j[s]] idx = base[s, None] + (2 * hw) + offs[None, :] out[s] = np.einsum("ij,ij->i", xp[idx], taps) return out def resample_at_reference(x, pos, cutoff=1.0, half_taps=6, beta=8.0, chunk=16384): """Direct evaluation of the same kernel, kept as the test reference.""" x = np.asarray(x) pos = np.asarray(pos, dtype=np.float64) hw = int(np.ceil(half_taps / cutoff)) offs = np.arange(-hw + 1, hw + 1) i0 = np.i0(beta) out = np.empty(len(pos), dtype=np.complex128) for a in range(0, len(pos), chunk): p = pos[a:a + chunk] base = np.floor(p).astype(np.int64) idx = base[:, None] + offs[None, :] d = p[:, None] - idx w = np.i0(beta * np.sqrt(np.clip(1.0 - (d / hw) ** 2, 0.0, None))) / i0 h = cutoff * np.sinc(cutoff * d) * w ok = (idx >= 0) & (idx < len(x)) out[a:a + chunk] = np.sum(x[np.clip(idx, 0, len(x) - 1)] * h * ok, axis=1) return out # ------------------------------------------------------------------ misc def wrap(x, period): """Wrap to [-period/2, period/2).""" return (np.asarray(x) + period / 2.0) % period - period / 2.0 def jacobsen(X, k): """Sub-bin peak offset from complex DFT bins around index ``k`` (rectangular window). Returns delta in bins, |delta| < ~0.5.""" M = len(X) xm, x0, xp = X[(k - 1) % M], X[k], X[(k + 1) % M] den = 2 * x0 - xm - xp if den == 0: return 0.0 return float(np.real((xm - xp) / den))