ExoIris 0.23.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

exoiris/bin1d.py

@@ -0,0 +1,97 @@
+#  ExoIris: fast, flexible, and easy exoplanet transmission spectroscopy in Python.
+#  Copyright (C) 2026 Hannu Parviainen
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from numba import njit
+from numpy import zeros, isfinite, where, nan, sqrt, ndarray, sum
+
+@njit
+def bin1d(v, e, el, er, bins, estimate_errors: bool = False) -> tuple[ndarray, ndarray]:
+    """Bin 2D spectrophotometry data with its uncertainties into predefined bins along the first axis.
+
+        Parameters
+        ----------
+        v : ndarray
+            A 2D spectrophotometry array.
+        e : ndarray
+            A 2D array of uncertainties associated with the spectrophotometry in `v`, matching the shape of `v`.
+        el : ndarray
+            A 1D array containing the left edges of the integration ranges for each spectral data point.
+        er : ndarray
+            A 1D array containing the right edges of the integration ranges for each spectral data point.
+        bins : ndarray
+            A 2D array containing the edges of the bins. These should be sorted in ascending order.
+        estimate_errors: bool, optional.
+            Should the uncertainties be estimated from the data? Default value is False.
+
+        Returns
+        -------
+        tuple of ndarrays
+            A tuple containing two 2D arrays:
+            - The first array (`bv`) contains the binned values of the transmission spectrum.
+            - The second array (`be`) contains the binned uncertainties.
+    """
+    nbins = len(bins)
+    ndata = v.shape[0]
+    bv = zeros((nbins, v.shape[1]))
+    be = zeros((nbins, v.shape[1]))
+    nonfin_weights = isfinite(v).astype('d')
+    v = where(nonfin_weights, v, 0.0)
+    e2 = where(nonfin_weights, e**2, 0.0)
+    weights = zeros(v.shape)
+    npt = zeros(v.shape[1])
+
+    i = 0
+    for ibin in range(nbins):
+        npt[:] = 0
+        bel, ber = bins[ibin]
+        for i in range(i, ndata - 1):
+            if el[i + 1] > bel:
+                break
+        il = i
+        if er[i] > ber:
+            weights[i, :] = ber - bel
+            npt += 1
+        else:
+            weights[i, :] = er[i] - max(el[i], bel)
+            npt += 1
+            for i in range(i + 1, ndata):
+                if er[i] < ber:
+                    weights[i, :] = er[i] - el[i]
+                    npt += 1
+
+                else:
+                    weights[i, :] = ber - el[i]
+                    npt += 1
+                    break
+        ir = i
+
+        weights[il:ir+1, :] *= nonfin_weights[il:ir+1, :]
+        weights[il:ir+1, :] /= weights[il:ir+1, :].sum(0)
+        npt += (nonfin_weights[il:ir+1, :]-1.0).sum(0)
+        ws = sum(weights[il:ir+1, :], 0)
+        ws2 = sum(weights[il:ir+1, :]**2, 0)
+        ws = where(ws > 0, ws, nan)
+        bv[ibin] = vmean = sum(weights[il:ir+1, :] * v[il:ir+1,:], 0) / ws
+
+        if estimate_errors:
+            var_sum = sum(weights[il:ir+1, :] * (v[il:ir+1, :] - vmean)**2, 0)
+            denominator = ws - ws2 / ws
+            sample_variance = var_sum / denominator
+            be[ibin, :] = where((npt > 1) & (ws**2 > ws2),
+                                sqrt(sample_variance * ws2 / (ws * ws)), nan)
+        else:
+            be[ibin] = sqrt(sum(weights[il:ir+1, :]**2 * e2[il:ir+1,:], 0)) / ws
+    return bv, be

exoiris/bin2d.py

@@ -0,0 +1,218 @@
+#  ExoIris: fast, flexible, and easy exoplanet transmission spectroscopy in Python.
+#  Copyright (C) 2026 Hannu Parviainen
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from numba import njit
+from numpy import zeros, isfinite, where, nan, sqrt, ndarray, int32, float64
+
+@njit
+def bin2d(v: ndarray, e: ndarray,
+             wl_l: ndarray, wl_r: ndarray,
+             tm_l: ndarray, tm_r: ndarray,
+             wl_bins: ndarray, tm_bins: ndarray,
+             estimate_errors: bool = False) -> tuple[ndarray, ndarray, ndarray]:
+    """Bin 2D spectrophotometry data in both wavelength and time dimensions.
+
+    Parameters
+    ----------
+    v : ndarray
+        A 2D spectrophotometry array with shape (n_wavelength, n_exposure).
+    e : ndarray
+        A 2D array of uncertainties matching the shape of `v`.
+    wl_l : ndarray
+        A 1D array of left wavelength edges for each spectral data point.
+    wl_r : ndarray
+        A 1D array of right wavelength edges for each spectral data point.
+    tm_l : ndarray
+        A 1D array of left time edges for each exposure.
+    tm_r : ndarray
+        A 1D array of right time edges for each exposure.
+    wl_bins : ndarray
+        A 2D array (n_wl_bins, 2) of wavelength bin edges [left, right].
+    tm_bins : ndarray
+        A 2D array (n_tm_bins, 2) of time bin edges [left, right].
+    estimate_errors : bool, optional
+        If True, estimate uncertainties from data scatter. Default is False.
+
+    Returns
+    -------
+    tuple of ndarrays
+        - bv: Binned values with shape (n_wl_bins, n_tm_bins).
+        - be: Binned uncertainties with shape (n_wl_bins, n_tm_bins).
+        - bn: Number of original finite pixels in each bin with shape (n_wl_bins, n_tm_bins).
+    """
+    n_wl_bins = len(wl_bins)
+    n_tm_bins = len(tm_bins)
+    n_wl = v.shape[0]
+    n_tm = v.shape[1]
+
+    bv = zeros((n_wl_bins, n_tm_bins))
+    be = zeros((n_wl_bins, n_tm_bins))
+    bn = zeros((n_wl_bins, n_tm_bins), dtype=int32)
+
+    # Pre-compute masks and cleaned data
+    nonfin_mask = isfinite(v)
+    v_clean = where(nonfin_mask, v, 0.0)
+    e2_clean = where(nonfin_mask, e**2, 0.0)
+    nonfin_weights = nonfin_mask.astype(float64)
+
+    # Pre-compute time bin indices and weights
+    tm_il_arr = zeros(n_tm_bins, dtype=int32)
+    tm_ir_arr = zeros(n_tm_bins, dtype=int32)
+    tm_weights_all = zeros((n_tm_bins, n_tm))
+
+    for itm_bin in range(n_tm_bins):
+        tm_bel, tm_ber = tm_bins[itm_bin]
+
+        # Find first time index
+        tm_il = 0
+        for j in range(n_tm - 1):
+            if tm_l[j + 1] > tm_bel:
+                tm_il = j
+                break
+        else:
+            tm_il = n_tm - 1
+
+        tm_il_arr[itm_bin] = tm_il
+
+        # Calculate time weights with ROBUST overlap logic
+        # Overlap = max(0, min(pixel_right, bin_right) - max(pixel_left, bin_left))
+        # We perform the loop starting from the found index until pixels no longer overlap
+
+        tm_idx = tm_il
+        # Iterate until pixel starts after bin ends or we run out of pixels
+        while tm_idx < n_tm:
+            # Optimization: If pixel starts after bin ends, stop.
+            if tm_l[tm_idx] >= tm_ber:
+                # But careful: tm_il search might land us on a pixel that starts after bin
+                # if the bin is in a gap. If so, we just want to record the index and break.
+                break
+
+            # Calculate overlap
+            # min(pixel_r, bin_r)
+            r_bound = tm_r[tm_idx] if tm_r[tm_idx] < tm_ber else tm_ber
+            # max(pixel_l, bin_l)
+            l_bound = tm_l[tm_idx] if tm_l[tm_idx] > tm_bel else tm_bel
+
+            if r_bound > l_bound:
+                tm_weights_all[itm_bin, tm_idx] = r_bound - l_bound
+
+            # If this pixel goes past the bin, we are done with this bin
+            if tm_r[tm_idx] >= tm_ber:
+                break
+
+            tm_idx += 1
+
+        tm_ir_arr[itm_bin] = min(tm_idx, n_tm - 1)
+
+    # Allocation moved outside loop
+    wl_weights = zeros(n_wl)
+
+    # Process wavelength bins
+    wl_start = 0
+    for iwl_bin in range(n_wl_bins):
+        wl_bel, wl_ber = wl_bins[iwl_bin]
+
+        # Reset weights for this iteration (faster than re-allocating)
+        # We only need to zero out the range we are about to use or used previously?
+        # Actually, since we calculate specific indices [wl_il, wl_ir],
+        # we can just zero them out at the end of the loop, or re-zero the whole array.
+        # Given n_wl is usually small (spectroscopy), zeroing whole array is fine.
+        wl_weights[:] = 0.0
+
+        # Find first wavelength index
+        wl_il = wl_start
+        for wl_il in range(wl_start, n_wl - 1):
+            if wl_l[wl_il + 1] > wl_bel:
+                break
+
+        # Calculate wavelength weights (Same robust logic as time)
+        wl_idx = wl_il
+        while wl_idx < n_wl:
+            if wl_l[wl_idx] >= wl_ber:
+                break
+
+            r_bound = wl_r[wl_idx] if wl_r[wl_idx] < wl_ber else wl_ber
+            l_bound = wl_l[wl_idx] if wl_l[wl_idx] > wl_bel else wl_bel
+
+            if r_bound > l_bound:
+                wl_weights[wl_idx] = r_bound - l_bound
+
+            if wl_r[wl_idx] >= wl_ber:
+                break
+            wl_idx += 1
+
+        wl_ir = min(wl_idx, n_wl - 1)
+
+        # Optimization for next bin search
+        wl_start = wl_il
+
+        # Process all time bins for this wavelength bin
+        for itm_bin in range(n_tm_bins):
+            tm_il = tm_il_arr[itm_bin]
+            tm_ir = tm_ir_arr[itm_bin]
+
+            total_weight = 0.0
+            sum_w2 = 0.0
+            weighted_sum = 0.0
+            weighted_e2_sum = 0.0
+            npt = 0
+
+            for i in range(wl_il, wl_ir + 1):
+                w_wl = wl_weights[i]
+                if w_wl <= 0: continue # Skip if no overlap
+
+                for j in range(tm_il, tm_ir + 1):
+                    # Combine weights
+                    w = w_wl * tm_weights_all[itm_bin, j] * nonfin_weights[i, j]
+
+                    if w > 0:
+                        total_weight += w
+                        sum_w2 += w * w
+                        weighted_sum += w * v_clean[i, j]
+                        weighted_e2_sum += w * w * e2_clean[i, j]
+                        npt += 1
+
+            bn[iwl_bin, itm_bin] = npt
+
+            if total_weight > 0:
+                bv[iwl_bin, itm_bin] = vmean = weighted_sum / total_weight
+
+                if estimate_errors:
+                    # Need at least 2 points (or effective degrees of freedom) to estimate variance
+                    if npt > 1 and total_weight**2 > sum_w2:
+                        var_sum = 0.0
+                        for i in range(wl_il, wl_ir + 1):
+                            w_wl = wl_weights[i]
+                            if w_wl <= 0: continue
+
+                            for j in range(tm_il, tm_ir + 1):
+                                w = w_wl * tm_weights_all[itm_bin, j] * nonfin_weights[i, j]
+                                if w > 0:
+                                    var_sum += w * (v_clean[i, j] - vmean) ** 2
+
+                        denominator = total_weight - (sum_w2 / total_weight)
+                        sample_variance = var_sum / denominator
+                        be[iwl_bin, itm_bin] = sqrt(sample_variance * (sum_w2 / (total_weight * total_weight)))
+                    else:
+                        be[iwl_bin, itm_bin] = nan
+                else:
+                    # Propagate input errors: SE = sqrt(sum(w² * σ²)) / sum(w)
+                    be[iwl_bin, itm_bin] = sqrt(weighted_e2_sum) / total_weight
+            else:
+                bv[iwl_bin, itm_bin] = nan
+                be[iwl_bin, itm_bin] = nan
+
+    return bv, be, bn

exoiris/exoiris.py

@@ -43,7 +43,7 @@ from uncertainties import UFloat
 
 from .ldtkld import LDTkLD
 from .tsdata import TSData, TSDataGroup
-from .tslpf import TSLPF
+from .tslpf import TSLPF, interpolators
 from .wlpf import WhiteLPF
 from .loglikelihood import LogLikelihood
 
@@ -88,7 +88,14 @@ def load_model(fname: Path | str, name: str | None = None):
         try:
             ip = hdr['INTERP']
         except KeyError:
-            ip = 'bspline'
+            ip = 'linear'
+
+        # Read the interpolation model.
+        # =============================
+        try:
+            ip_ld = hdr['INTERP_LD']
+        except KeyError:
+            ip_ld = 'bspline-quadratic'
 
         # Read the noise model.
         # =====================
@@ -100,6 +107,7 @@ def load_model(fname: Path | str, name: str | None = None):
         # Setup the analysis.
         # ===================
         a = ExoIris(name or hdr['NAME'], ldmodel=ldm, data=data, noise_model=noise_model, interpolation=ip)
+        a.set_limb_darkening_interpolator(ip_ld)
         a.set_radius_ratio_knots(hdul['K_KNOTS'].data.astype('d'))
         a.set_limb_darkening_knots(hdul['LD_KNOTS'].data.astype('d'))
 
@@ -162,7 +170,7 @@ class ExoIris:
     """
 
     def __init__(self, name: str, ldmodel, data: TSDataGroup | TSData, nk: int = 50, nldc: int = 10, nthreads: int = 1,
-                 tmpars: dict | None = None, noise_model: Literal["white", "fixed_gp", "free_gp"] = 'white',
+                 tmpars: dict | None = None, noise_model: Literal["white_profiled", "white_marginalized", "fixed_gp", "free_gp"] = 'white_profiled',
                  interpolation: Literal['nearest', 'linear', 'pchip', 'makima', 'bspline', 'bspline-quadratic', 'bspline-cubic'] = 'linear'):
         """
         Parameters
@@ -263,15 +271,15 @@ class ExoIris:
         data = TSDataGroup([data]) if isinstance(data, TSData) else data
         self._tsa.set_data(data)
 
-    def set_prior(self, parameter: Literal['radius ratios', 'baselines', 'wn multipliers'] | str,
+    def set_prior(self, parameter: Literal['radius ratios', 'offsets', 'wn multipliers'] | str,
                   prior: str | Any, *nargs) -> None:
         """Set a prior on a model parameter.
 
         Parameters
         ----------
         parameter
-            The name of the parameter to set a prior for. Can also be 'radius ratios', 'baselines', or 'wn multipliers'
-            to set identical priors on all the radius ratios, baselines, or white noise multipliers.
+            The name of the parameter to set a prior for. Can also be 'radius ratios', 'offsets', or 'wn multipliers'
+            to set identical priors on all the radius ratios, offsets, or white noise multipliers.
 
         prior
             The prior distribution for the parameter. This can be "NP" for a normal prior, "UP" for a
@@ -287,6 +295,9 @@ class ExoIris:
         elif parameter == 'wn multipliers':
             for par in self.ps[self._tsa._sl_wnm]:
                 self.set_prior(par.name, prior, *nargs)
+        elif parameter == 'offsets':
+            for par in self.ps[self._tsa._sl_bias]:
+                self.set_prior(par.name, prior, *nargs)
         else:
             self._tsa.set_prior(parameter, prior, *nargs)
 
@@ -509,6 +520,12 @@ class ExoIris:
         else:
             return self._wa.std_errors
 
+    def set_radius_ratio_interpolator(self, interpolator: str) -> None:
+        """Set the interpolator for the radius ratio (k) model."""
+        if interpolator not in interpolators.keys():
+            raise ValueError(f"Interpolator {interpolator} not recognized.")
+        self._tsa.set_k_interpolator(interpolator)
+
     def add_radius_ratio_knots(self, knot_wavelengths: Sequence) -> None:
         """Add radius ratio (k) knots.
 
@@ -558,6 +575,12 @@ class ExoIris:
         nk = nk[(nk >= wlmin) & (nk <= wlmax)]
         self.set_radius_ratio_knots(r_[ck[ck < nk[0]], nk, ck[ck > nk[-1]]])
 
+    def set_limb_darkening_interpolator(self, interpolator: str) -> None:
+        """Set the interpolator for the limb darkening model."""
+        if interpolator not in interpolators.keys():
+            raise ValueError(f"Interpolator {interpolator} not recognized.")
+        self._tsa.set_ld_interpolator(interpolator)
+
     def add_limb_darkening_knots(self, knot_wavelengths: Sequence) -> None:
         """Add limb darkening knots.
 
@@ -1283,6 +1306,7 @@ class ExoIris:
         pri.header['t14'] = self.transit_duration
         pri.header['ndgroups'] = self.data.size
         pri.header['interp'] = self._tsa.interpolation
+        pri.header['interp_ld'] = self._tsa.ld_interpolation
         pri.header['noise'] = self._tsa.noise_model
 
         if self._tsa.free_k_knot_ids is None:
@@ -1426,42 +1450,6 @@ class ExoIris:
         """
         return self._tsa.create_initial_population(n, source, add_noise)
 
-    def add_noise_to_solution(self, result: str = 'fit') -> None:
-        """Add noise to the global optimization result or MCMC parameter posteriors.
-
-        Add noise to the global optimization result or MCMC parameter posteriors. You may want to do this if you
-        create a new analysis from another one, for example, by adding radius ratio knots or changing the intrinsic
-        data resolution.
-
-        Parameters
-        ----------
-        result
-            Determines which result to add noise to. Default is 'fit'.
-
-        Raises
-        ------
-        ValueError
-            If the 'result' argument is not 'fit' or 'mcmc'.
-        """
-        if result == 'fit':
-            pvp = self._tsa._de_population[:, :].copy()
-        elif result == 'mcmc':
-            pvp = self._tsa._mc_chains[:, -1, :].copy()
-        else:
-            raise ValueError("The 'result' argument must be either 'fit' or 'mcmc'")
-
-        npv = pvp.shape[0]
-        pvp[:, 0] += normal(0, 0.005, size=npv)
-        pvp[:, 1] += normal(0, 0.001, size=npv)
-        pvp[:, 3] += normal(0, 0.005, size=npv)
-        pvp[:, self._tsa._sl_rratios] += normal(0, 1, pvp[:, self._tsa._sl_rratios].shape) * 0.002 * pvp[:, self._tsa._sl_rratios]
-        pvp[:, self._tsa._sl_ld] += normal(0, 1, pvp[:, self._tsa._sl_ld].shape) * 0.002 * pvp[:, self._tsa._sl_ld]
-
-        if result == 'fit':
-            self._tsa._de_population[:, :] = pvp
-        else:
-            pvp = self._tsa._mc_chains[:, -1, :] = pvp
-
     def optimize_gp_hyperparameters(self,
                                     log10_sigma_bounds: float | tuple[float, float] | None = None,
                                     log10_rho_bounds: float | tuple[float, float] = (-5, 0),

exoiris/lmlikelihood.py

@@ -0,0 +1,172 @@
+#  ExoIris: fast, flexible, and easy exoplanet transmission spectroscopy in Python.
+#  Copyright (C) 2026 Hannu Parviainen
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import numpy as np
+from numba import njit
+
+@njit
+def _chol_solve(l: np.ndarray, b: np.ndarray) -> np.ndarray:
+    """Solve L L^T x = b given lower-triangular L."""
+    y = np.linalg.solve(l, b)
+    return np.linalg.solve(l.T, y)
+
+
+@njit
+def marginalized_loglike_mbl1d(
+        obs: np.ndarray,
+        mod: np.ndarray,
+        covs: np.ndarray,
+        sigma: np.ndarray,
+        tau: float = 1e6,
+        drop_constant: bool = False,
+) -> float:
+    """Compute the analytically marginalized log-likelihood for a multiplicative baseline model.
+
+    JIT-compiled implementation of the collapsed (marginalized) log-likelihood for a
+    model where systematic trends multiply the physical signal:
+
+        obs = mod(θ) · covs·a + ε
+
+    where ε ~ N(0, diag(σ²)) and a ~ N(0, Λ). The baseline coefficients a are
+    integrated out analytically, yielding a likelihood that depends only on the
+    physical model mod(θ).
+
+    This formulation is appropriate when the out-of-transit baseline level must be
+    estimated from the data. The design matrix `covs` should include a constant
+    column (ones) to capture the baseline flux level, with additional columns for
+    systematic trends.
+
+    The computation avoids explicit matrix inversion by exploiting the Woodbury
+    identity and matrix determinant lemma, working with k×k matrices rather than
+    n×n matrices. This makes the function efficient when k ≪ n.
+
+    Parameters
+    ----------
+    obs : ndarray of shape (n,), dtype float64
+        Observed flux values. Must be contiguous float64 array.
+    mod : ndarray of shape (n,), dtype float64
+        Physical transit model evaluated at the current parameters θ, normalized
+        such that the out-of-transit level is unity. Must be contiguous float64.
+    covs : ndarray of shape (n, k), dtype float64
+        Design matrix for the multiplicative baseline. Should include a constant
+        column (ones) as the first column to capture the baseline flux level.
+        Additional columns represent systematic trends (e.g., airmass, detector
+        position, PSF width). Trend columns should typically be mean-centered.
+        Must be contiguous float64 with C ordering.
+    sigma : ndarray of shape (n,), dtype float64
+        Per-observation measurement uncertainties (standard deviations). All
+        values must be strictly positive. Must be contiguous float64.
+    tau : float, default 1e6
+        Prior standard deviation for all baseline coefficients (Λ = τ²I).
+    drop_constant : bool, default False
+        If True, omit terms constant in θ (log|Σ| and n·log(2π)). Use this for
+        MCMC sampling over θ when σ is fixed, as these terms only shift the
+        log-posterior by a constant without affecting sampling.
+
+    Returns
+    -------
+    float
+        The marginalized log-likelihood value. If drop_constant is True, this
+        omits θ-independent normalization terms.
+
+    Raises
+    ------
+    numpy.linalg.LinAlgError
+        If Lambda or the internal matrix K is not positive definite (Cholesky
+        decomposition fails). No other validation is performed.
+
+    Notes
+    -----
+    The marginalized likelihood is obtained by integrating over the baseline
+    coefficients:
+
+        L(θ) = ∫ p(obs | θ, a) p(a) da
+
+    Defining Φ = diag(mod)·covs, the marginal distribution of obs is:
+
+        obs ~ N(0, C)  where  C = Σ + τ²ΦΦᵀ
+
+    Rather than inverting the n×n matrix C directly, the implementation uses:
+
+        C⁻¹ = W − τ²W·Φ·K⁻¹·Φᵀ·W     (Woodbury identity)
+        |C| = |Σ|·|K|                 (matrix determinant lemma)
+
+    where W = Σ⁻¹ = diag(1/σ²) and K = I + τ²ΦᵀWΦ is a k×k matrix.
+
+    The log-likelihood is:
+
+        log L = −½ [obsᵀC⁻¹obs + log|C| + n·log(2π)]
+              = −½ [(obsᵀWobs − τ²cᵀK⁻¹c) + log|Σ| + log|K| + n·log(2π)]
+
+    where c = ΦᵀW·obs.
+
+    With the isotropic prior Λ = τ²I, the Cholesky factorization of Λ is trivially
+    L_Λ = τI, eliminating one matrix decomposition compared to the general case.
+    All operations involve only k×k matrices, giving O(nk² + k³) complexity
+    rather than O(n³).
+
+    In the limit τ → ∞, the marginalized likelihood approaches the profile
+    likelihood with a at its maximum likelihood estimate (ordinary least squares).
+    Numerical stability requires finite τ; values around 10⁶ are effectively
+    uninformative for normalized flux data while maintaining well-conditioned K.
+    """
+    n = obs.shape[0]
+    ncov = covs.shape[1]
+    tau2 = tau * tau
+    phi = mod[:, None] * covs
+    w = 1.0 / (sigma * sigma)
+    wphi = w[:, None] * phi
+    k = np.eye(ncov) + tau2 * (phi.T @ wphi)
+    c = phi.T @ (w * obs)
+    lk = np.linalg.cholesky(k)
+    obswobs = np.dot(w * obs, obs)
+    kinvc = _chol_solve(lk, c)
+    quad = obswobs - tau2 * np.dot(c, kinvc)
+    logdetk = 2.0 * np.sum(np.log(np.diag(lk)))
+    if drop_constant:
+        return -0.5 * (quad + logdetk)
+    logdetsigma = np.sum(np.log(sigma * sigma))
+    return -0.5 * (quad + logdetsigma + logdetk + n * np.log(2.0 * np.pi))
+
+@njit
+def marginalized_loglike_mbl2d(
+        obs: np.ndarray,
+        mod: np.ndarray,
+        err: np.ndarray,
+        covs: np.ndarray,
+        mask: np.ndarray,
+        tau: float = 1e6,
+) -> float:
+    nwl = obs.shape[0]
+    ncov = covs.shape[1]
+    tau2 = tau * tau
+    w = 1.0 / (err * err)
+
+    lnlike = 0.0
+    for i in range(nwl):
+        m = mask[i]
+        phi = mod[i, m, None] * covs[m]
+        wphi = w[i, m, None] * phi
+        k = np.eye(ncov) + tau2 * (phi.T @ wphi)
+        c = phi.T @ (w[i, m] * obs[i, m])
+        lk = np.linalg.cholesky(k)
+        obswobs = np.dot(w[i, m] * obs[i, m], obs[i, m])
+        kinvc = _chol_solve(lk, c)
+        quad = obswobs - tau2 * np.dot(c, kinvc)
+        logdetk = 2.0 * np.sum(np.log(np.diag(lk)))
+        logdetsigma = np.sum(np.log(err[i, m] * err[i, m]))
+        lnlike += -0.5 * (quad + logdetsigma + logdetk + mask[i].sum() * np.log(2.0 * np.pi))
+    return lnlike