From bc0046fefb787c90bc2a7ae4eaf0bbc23ec654c1 Mon Sep 17 00:00:00 2001 From: Anton Soloviev Date: Wed, 21 Oct 2026 18:30:27 -0700 Subject: [PATCH] Keep real convolution variance for short exposures --- python/celerite2/terms.py | 25 +++++++++--- python/test/test_real_convolution.py | 59 ++++++++++++++++++++++++++++ 2 files changed, 79 insertions(+), 5 deletions(-) create mode 100644 python/test/test_real_convolution.py diff --git a/python/celerite2/terms.py b/python/celerite2/terms.py index cb9d2cc..b5190cd 100644 --- a/python/celerite2/terms.py +++ b/python/celerite2/terms.py @@ -22,6 +22,20 @@ import celerite2.driver as driver +def _cosh_minus_one(x): + """Evaluate cosh(x) - 1 without cancellation near zero.""" + return np.where( + np.abs(x) < 0.01, 2 * np.sinh(0.5 * x) ** 2, np.cosh(x) - 1 + ) + + +def _sinh_minus_x(x): + """Use the series through x**9 where subtraction loses precision.""" + x2 = x * x + series = x * x2 * (1 / 6 + x2 * (1 / 120 + x2 * (1 / 5040 + x2 / 362880))) + return np.where(np.abs(x) < 0.01, series, np.sinh(x) - x) + + class Term: """The abstract base "term" that is the superclass of all other terms @@ -355,7 +369,7 @@ def get_celerite_matrices( # Real part cd = cr * dt - delta_diag = 2 * np.sum(ar * (cd - np.sinh(cd)) / cd**2) + delta_diag = -2 * np.sum(ar * _sinh_minus_x(cd) / cd**2) # Complex part cd = cc * dt @@ -386,7 +400,7 @@ def get_coefficients(self): # Real componenets crd = cr * self.delta - coeffs = [2 * ar * (np.cosh(crd) - 1) / crd**2, cr] + coeffs = [2 * ar * _cosh_minus_one(crd) / crd**2, cr] # Imaginary coefficients cd = c * self.delta @@ -433,13 +447,14 @@ def get_value(self, tau0): # Real parts: # tau > Delta crd = cr * dt - cosh = np.cosh(crd) norm = 2 * ar / crd**2 - K_large = np.sum(norm * (cosh - 1) * np.exp(-cr * tau), axis=-1) + K_large = np.sum( + norm * _cosh_minus_one(crd) * np.exp(-cr * tau), axis=-1 + ) # tau < Delta crdmt = cr * dmt - K_small = K_large + np.sum(norm * (crdmt - np.sinh(crdmt)), axis=-1) + K_small = K_large - np.sum(norm * _sinh_minus_x(crdmt), axis=-1) # Complex part cd = c * dt diff --git a/python/test/test_real_convolution.py b/python/test/test_real_convolution.py new file mode 100644 index 0000000..d8c7f84 --- /dev/null +++ b/python/test/test_real_convolution.py @@ -0,0 +1,59 @@ +import numpy as np +import pytest +from scipy.integrate import quad +from scipy.linalg import cho_factor, cho_solve + +from celerite2 import GaussianProcess, terms + + +def _averaged_kernel(lag, delta, components): + def integrand(u): + value = sum( + a * np.exp(-c * abs(lag + delta * u)) for a, c in components + ) + return (1 - abs(u)) * value + + points = [0.0] + if abs(lag) < delta: + points.append(-lag / delta) + return quad(integrand, -1, 1, points=points, epsabs=1e-13)[0] + + +@pytest.mark.parametrize("delta", [0.1, 1e-3, 1e-5, 1e-7, 1e-9]) +@pytest.mark.parametrize( + "components", [[(1.2, 0.08)], [(1.2, 0.08), (0.5, 0.2)]] +) +def test_short_exposure_real_kernel(delta, components): + kernel = terms.RealTerm(a=components[0][0], c=components[0][1]) + for a, c in components[1:]: + kernel += terms.RealTerm(a=a, c=c) + kernel = terms.TermConvolution(kernel, delta=delta) + lags = np.array([0.0, 0.25 * delta, 0.5 * delta, delta, 1.0]) + expected = [_averaged_kernel(lag, delta, components) for lag in lags] + np.testing.assert_allclose( + kernel.get_value(lags), expected, rtol=2e-12, atol=2e-12 + ) + + +@pytest.mark.parametrize("delta", [0.1, 1e-3, 1e-5, 1e-7, 1e-9]) +def test_short_exposure_real_factorization(delta): + components = [(1.2, 0.08)] + kernel = terms.TermConvolution(terms.RealTerm(a=1.2, c=0.08), delta=delta) + t = np.arange(8.0) + y = np.sin(t) + values = np.array([_averaged_kernel(lag, delta, components) for lag in t]) + expected_cov = values[ + np.abs(t[:, None] - t[None, :]).astype(int) + ] + 0.04 * np.eye(8) + expected_inverse = cho_solve(cho_factor(expected_cov), y) + gp = GaussianProcess(kernel) + gp.compute(t, diag=0.04) + np.testing.assert_allclose( + kernel.to_dense(t, np.full(8, 0.04)), + expected_cov, + rtol=2e-12, + atol=2e-12, + ) + np.testing.assert_allclose( + gp.apply_inverse(y), expected_inverse, rtol=2e-11, atol=2e-11 + )