diff-diff 1.3.1__py3-none-any.whl → 1.4.0__py3-none-any.whl

diff_diff/__init__.py

@@ -103,7 +103,7 @@ from diff_diff.visualization import (
     plot_sensitivity,
 )
 
-__version__ = "1.3.1"
+__version__ = "1.4.0"
 __all__ = [
     # Estimators
     "DifferenceInDifferences",

diff_diff/estimators.py

@@ -17,12 +17,12 @@ from typing import Any, Dict, List, Optional, Tuple
 import numpy as np
 import pandas as pd
 
+from diff_diff.linalg import compute_r_squared, compute_robust_vcov, solve_ols
 from diff_diff.results import DiDResults, MultiPeriodDiDResults, PeriodEffect
 from diff_diff.utils import (
     WildBootstrapResults,
     compute_confidence_interval,
     compute_p_value,
-    compute_robust_se,
     validate_binary,
     wild_bootstrap_se,
 )
@@ -261,8 +261,11 @@ class DifferenceInDifferences:
                     X = np.column_stack([X, dummies[col].values.astype(float)])
                     var_names.append(col)
 
-        # Fit OLS
-        coefficients, residuals, fitted, r_squared = self._fit_ols(X, y)
+        # Fit OLS using unified backend
+        coefficients, residuals, fitted, vcov = solve_ols(
+            X, y, return_fitted=True, return_vcov=False
+        )
+        r_squared = compute_r_squared(y, residuals)
 
         # Extract ATT (coefficient on interaction term)
         att_idx = 3  # Index of interaction term
@@ -285,13 +288,13 @@ class DifferenceInDifferences:
             )
         elif self.cluster is not None:
             cluster_ids = data[self.cluster].values
-            vcov = compute_robust_se(X, residuals, cluster_ids)
+            vcov = compute_robust_vcov(X, residuals, cluster_ids)
             se = np.sqrt(vcov[att_idx, att_idx])
             t_stat = att / se
             p_value = compute_p_value(t_stat, df=df)
             conf_int = compute_confidence_interval(att, se, self.alpha, df=df)
         elif self.robust:
-            vcov = compute_robust_se(X, residuals)
+            vcov = compute_robust_vcov(X, residuals)
             se = np.sqrt(vcov[att_idx, att_idx])
             t_stat = att / se
             p_value = compute_p_value(t_stat, df=df)
@@ -300,7 +303,7 @@ class DifferenceInDifferences:
             # Classical OLS standard errors
             n = len(y)
             k = X.shape[1]
-            mse = np.sum(residuals ** 2) / (n - k)
+            mse = np.sum(residuals**2) / (n - k)
             # Use solve() instead of inv() for numerical stability
             # solve(A, B) computes X where AX=B, so this yields (X'X)^{-1} * mse
             vcov = np.linalg.solve(X.T @ X, mse * np.eye(k))
@@ -352,10 +355,15 @@ class DifferenceInDifferences:
 
         return self.results_
 
-    def _fit_ols(self, X: np.ndarray, y: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray, float]:
+    def _fit_ols(
+        self, X: np.ndarray, y: np.ndarray
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, float]:
         """
         Fit OLS regression.
 
+        This method is kept for backwards compatibility. Internally uses the
+        unified solve_ols from diff_diff.linalg for optimized computation.
+
         Parameters
         ----------
         X : np.ndarray
@@ -367,32 +375,12 @@ class DifferenceInDifferences:
         -------
         tuple
             (coefficients, residuals, fitted_values, r_squared)
-
-        Raises
-        ------
-        ValueError
-            If design matrix is rank-deficient (perfect multicollinearity).
         """
-        # Check for rank deficiency (perfect multicollinearity)
-        rank = np.linalg.matrix_rank(X)
-        if rank < X.shape[1]:
-            raise ValueError(
-                f"Design matrix is rank-deficient (rank {rank} < {X.shape[1]} columns). "
-                "This indicates perfect multicollinearity. Check your fixed effects "
-                "and covariates for linear dependencies."
-            )
-
-        # Solve normal equations: β = (X'X)^(-1) X'y
-        coefficients = np.linalg.lstsq(X, y, rcond=None)[0]
-
-        # Compute fitted values and residuals
-        fitted = X @ coefficients
-        residuals = y - fitted
-
-        # Compute R-squared
-        ss_res = np.sum(residuals ** 2)
-        ss_tot = np.sum((y - np.mean(y)) ** 2)
-        r_squared = 1 - (ss_res / ss_tot) if ss_tot > 0 else 0.0
+        # Use unified OLS backend
+        coefficients, residuals, fitted, _ = solve_ols(
+            X, y, return_fitted=True, return_vcov=False
+        )
+        r_squared = compute_r_squared(y, residuals)
 
         return coefficients, residuals, fitted, r_squared
 
@@ -442,7 +430,7 @@ class DifferenceInDifferences:
         t_stat = bootstrap_results.t_stat_original
 
         # Also compute vcov for storage (using cluster-robust for consistency)
-        vcov = compute_robust_se(X, residuals, cluster_ids)
+        vcov = compute_robust_vcov(X, residuals, cluster_ids)
 
         return se, p_value, conf_int, t_stat, vcov, bootstrap_results
 
@@ -889,8 +877,11 @@ class MultiPeriodDiD(DifferenceInDifferences):
                     X = np.column_stack([X, dummies[col].values.astype(float)])
                     var_names.append(col)
 
-        # Fit OLS
-        coefficients, residuals, fitted, r_squared = self._fit_ols(X, y)
+        # Fit OLS using unified backend
+        coefficients, residuals, fitted, _ = solve_ols(
+            X, y, return_fitted=True, return_vcov=False
+        )
+        r_squared = compute_r_squared(y, residuals)
 
         # Degrees of freedom
         df = len(y) - X.shape[1] - n_absorbed_effects
@@ -900,13 +891,13 @@ class MultiPeriodDiD(DifferenceInDifferences):
         # For now, we use analytical inference even if inference="wild_bootstrap"
         if self.cluster is not None:
             cluster_ids = data[self.cluster].values
-            vcov = compute_robust_se(X, residuals, cluster_ids)
+            vcov = compute_robust_vcov(X, residuals, cluster_ids)
         elif self.robust:
-            vcov = compute_robust_se(X, residuals)
+            vcov = compute_robust_vcov(X, residuals)
         else:
             n = len(y)
             k = X.shape[1]
-            mse = np.sum(residuals ** 2) / (n - k)
+            mse = np.sum(residuals**2) / (n - k)
             # Use solve() instead of inv() for numerical stability
             # solve(A, B) computes X where AX=B, so this yields (X'X)^{-1} * mse
             vcov = np.linalg.solve(X.T @ X, mse * np.eye(k))

diff_diff/linalg.py

@@ -0,0 +1,271 @@
+"""
+Unified linear algebra backend for diff-diff.
+
+This module provides optimized OLS and variance estimation that can be
+swapped to a compiled backend (Rust/C++) for maximum performance.
+
+The key optimizations are:
+1. scipy.linalg.lstsq with 'gelsy' driver (QR-based, faster than SVD)
+2. Vectorized cluster-robust SE via groupby (eliminates O(n*clusters) loop)
+3. Single interface for all estimators (reduces code duplication)
+
+Future: This module can be extended with a Rust backend for additional speedup.
+"""
+
+from typing import Optional, Tuple, Union
+
+import numpy as np
+import pandas as pd
+from scipy.linalg import lstsq as scipy_lstsq
+
+
+def solve_ols(
+    X: np.ndarray,
+    y: np.ndarray,
+    *,
+    cluster_ids: Optional[np.ndarray] = None,
+    return_vcov: bool = True,
+    return_fitted: bool = False,
+    check_finite: bool = True,
+) -> Union[
+    Tuple[np.ndarray, np.ndarray, Optional[np.ndarray]],
+    Tuple[np.ndarray, np.ndarray, np.ndarray, Optional[np.ndarray]],
+]:
+    """
+    Solve OLS regression with optional clustered standard errors.
+
+    This is the unified OLS solver for all diff-diff estimators. It uses
+    scipy's optimized LAPACK routines and vectorized variance estimation.
+
+    Parameters
+    ----------
+    X : ndarray of shape (n, k)
+        Design matrix (should include intercept if desired).
+    y : ndarray of shape (n,)
+        Response vector.
+    cluster_ids : ndarray of shape (n,), optional
+        Cluster identifiers for cluster-robust standard errors.
+        If None, HC1 (heteroskedasticity-robust) SEs are computed.
+    return_vcov : bool, default True
+        Whether to compute and return the variance-covariance matrix.
+        Set to False for faster computation when SEs are not needed.
+    return_fitted : bool, default False
+        Whether to return fitted values in addition to residuals.
+    check_finite : bool, default True
+        Whether to check that X and y contain only finite values (no NaN/Inf).
+        Set to False for faster computation if you are certain your data is clean.
+
+    Returns
+    -------
+    coefficients : ndarray of shape (k,)
+        OLS coefficient estimates.
+    residuals : ndarray of shape (n,)
+        Residuals (y - X @ coefficients).
+    fitted : ndarray of shape (n,), optional
+        Fitted values (X @ coefficients). Only returned if return_fitted=True.
+    vcov : ndarray of shape (k, k) or None
+        Variance-covariance matrix (HC1 or cluster-robust).
+        None if return_vcov=False.
+
+    Notes
+    -----
+    This function uses scipy.linalg.lstsq with the 'gelsy' driver, which is
+    QR-based and typically faster than NumPy's default SVD-based solver for
+    well-conditioned matrices.
+
+    The cluster-robust standard errors use the sandwich estimator with the
+    standard small-sample adjustment: (G/(G-1)) * ((n-1)/(n-k)).
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from diff_diff.linalg import solve_ols
+    >>> X = np.column_stack([np.ones(100), np.random.randn(100)])
+    >>> y = 2 + 3 * X[:, 1] + np.random.randn(100)
+    >>> coef, resid, vcov = solve_ols(X, y)
+    >>> print(f"Intercept: {coef[0]:.2f}, Slope: {coef[1]:.2f}")
+    """
+    # Validate inputs
+    X = np.asarray(X, dtype=np.float64)
+    y = np.asarray(y, dtype=np.float64)
+
+    if X.ndim != 2:
+        raise ValueError(f"X must be 2-dimensional, got shape {X.shape}")
+    if y.ndim != 1:
+        raise ValueError(f"y must be 1-dimensional, got shape {y.shape}")
+    if X.shape[0] != y.shape[0]:
+        raise ValueError(
+            f"X and y must have same number of observations: "
+            f"{X.shape[0]} vs {y.shape[0]}"
+        )
+
+    n, k = X.shape
+    if n < k:
+        raise ValueError(
+            f"Fewer observations ({n}) than parameters ({k}). "
+            "Cannot solve underdetermined system."
+        )
+
+    # Check for NaN/Inf values if requested
+    if check_finite:
+        if not np.isfinite(X).all():
+            raise ValueError(
+                "X contains NaN or Inf values. "
+                "Clean your data or set check_finite=False to skip this check."
+            )
+        if not np.isfinite(y).all():
+            raise ValueError(
+                "y contains NaN or Inf values. "
+                "Clean your data or set check_finite=False to skip this check."
+            )
+
+    # Solve OLS using scipy's optimized solver
+    # 'gelsy' uses QR with column pivoting, faster than default 'gelsd' (SVD)
+    # Note: gelsy doesn't reliably report rank, so we don't check for deficiency
+    coefficients = scipy_lstsq(X, y, lapack_driver="gelsy", check_finite=False)[0]
+
+    # Compute residuals and fitted values
+    fitted = X @ coefficients
+    residuals = y - fitted
+
+    # Compute variance-covariance matrix if requested
+    vcov = None
+    if return_vcov:
+        vcov = compute_robust_vcov(X, residuals, cluster_ids)
+
+    if return_fitted:
+        return coefficients, residuals, fitted, vcov
+    else:
+        return coefficients, residuals, vcov
+
+
+def compute_robust_vcov(
+    X: np.ndarray,
+    residuals: np.ndarray,
+    cluster_ids: Optional[np.ndarray] = None,
+) -> np.ndarray:
+    """
+    Compute heteroskedasticity-robust or cluster-robust variance-covariance matrix.
+
+    Uses the sandwich estimator: (X'X)^{-1} * meat * (X'X)^{-1}
+
+    Parameters
+    ----------
+    X : ndarray of shape (n, k)
+        Design matrix.
+    residuals : ndarray of shape (n,)
+        OLS residuals.
+    cluster_ids : ndarray of shape (n,), optional
+        Cluster identifiers. If None, computes HC1 robust SEs.
+
+    Returns
+    -------
+    vcov : ndarray of shape (k, k)
+        Variance-covariance matrix.
+
+    Notes
+    -----
+    For HC1 (no clustering):
+        meat = X' * diag(u^2) * X
+        adjustment = n / (n - k)
+
+    For cluster-robust:
+        meat = sum_g (X_g' u_g)(X_g' u_g)'
+        adjustment = (G / (G-1)) * ((n-1) / (n-k))
+
+    The cluster-robust computation is vectorized using pandas groupby,
+    which is much faster than a Python loop over clusters.
+    """
+    n, k = X.shape
+    XtX = X.T @ X
+
+    if cluster_ids is None:
+        # HC1 (heteroskedasticity-robust) standard errors
+        adjustment = n / (n - k)
+        u_squared = residuals**2
+        # Vectorized meat computation: X' diag(u^2) X = (X * u^2)' X
+        meat = X.T @ (X * u_squared[:, np.newaxis])
+    else:
+        # Cluster-robust standard errors (vectorized via groupby)
+        cluster_ids = np.asarray(cluster_ids)
+        unique_clusters = np.unique(cluster_ids)
+        n_clusters = len(unique_clusters)
+
+        if n_clusters < 2:
+            raise ValueError(
+                f"Need at least 2 clusters for cluster-robust SEs, got {n_clusters}"
+            )
+
+        # Small-sample adjustment
+        adjustment = (n_clusters / (n_clusters - 1)) * ((n - 1) / (n - k))
+
+        # Compute cluster-level scores: sum of X_i * u_i within each cluster
+        # scores[i] = X[i] * residuals[i] for each observation
+        scores = X * residuals[:, np.newaxis]  # (n, k)
+
+        # Sum scores within each cluster using pandas groupby (vectorized)
+        # This is much faster than looping over clusters
+        cluster_scores = pd.DataFrame(scores).groupby(cluster_ids).sum().values  # (G, k)
+
+        # Meat is the outer product sum: sum_g (score_g)(score_g)'
+        # Equivalent to cluster_scores.T @ cluster_scores
+        meat = cluster_scores.T @ cluster_scores  # (k, k)
+
+    # Sandwich estimator: (X'X)^{-1} meat (X'X)^{-1}
+    # Solve (X'X) temp = meat, then solve (X'X) vcov' = temp'
+    # More stable than explicit inverse
+    try:
+        temp = np.linalg.solve(XtX, meat)
+        vcov = adjustment * np.linalg.solve(XtX, temp.T).T
+    except np.linalg.LinAlgError as e:
+        if "Singular" in str(e):
+            raise ValueError(
+                "Design matrix is rank-deficient (singular X'X matrix). "
+                "This indicates perfect multicollinearity. Check your fixed effects "
+                "and covariates for linear dependencies."
+            ) from e
+        raise
+
+    return vcov
+
+
+def compute_r_squared(
+    y: np.ndarray,
+    residuals: np.ndarray,
+    adjusted: bool = False,
+    n_params: int = 0,
+) -> float:
+    """
+    Compute R-squared or adjusted R-squared.
+
+    Parameters
+    ----------
+    y : ndarray of shape (n,)
+        Response vector.
+    residuals : ndarray of shape (n,)
+        OLS residuals.
+    adjusted : bool, default False
+        If True, compute adjusted R-squared.
+    n_params : int, default 0
+        Number of parameters (including intercept). Required if adjusted=True.
+
+    Returns
+    -------
+    r_squared : float
+        R-squared or adjusted R-squared.
+    """
+    ss_res = np.sum(residuals**2)
+    ss_tot = np.sum((y - np.mean(y)) ** 2)
+
+    if ss_tot == 0:
+        return 0.0
+
+    r_squared = 1 - (ss_res / ss_tot)
+
+    if adjusted:
+        n = len(y)
+        if n <= n_params:
+            return r_squared
+        r_squared = 1 - (1 - r_squared) * (n - 1) / (n - n_params)
+
+    return r_squared

diff_diff/staggered.py

@@ -13,12 +13,16 @@ import numpy as np
 import pandas as pd
 from scipy import optimize
 
+from diff_diff.linalg import solve_ols
 from diff_diff.results import _get_significance_stars
 from diff_diff.utils import (
     compute_confidence_interval,
     compute_p_value,
 )
 
+# Type alias for pre-computed structures
+PrecomputedData = Dict[str, Any]
+
 # =============================================================================
 # Bootstrap Weight Generators
 # =============================================================================
@@ -75,6 +79,59 @@ def _generate_bootstrap_weights(
         )
 
 
+def _generate_bootstrap_weights_batch(
+    n_bootstrap: int,
+    n_units: int,
+    weight_type: str,
+    rng: np.random.Generator,
+) -> np.ndarray:
+    """
+    Generate all bootstrap weights at once (vectorized).
+
+    Parameters
+    ----------
+    n_bootstrap : int
+        Number of bootstrap iterations.
+    n_units : int
+        Number of units (clusters) to generate weights for.
+    weight_type : str
+        Type of weights: "rademacher", "mammen", or "webb".
+    rng : np.random.Generator
+        Random number generator.
+
+    Returns
+    -------
+    np.ndarray
+        Array of bootstrap weights with shape (n_bootstrap, n_units).
+    """
+    if weight_type == "rademacher":
+        # Rademacher: +1 or -1 with equal probability
+        return rng.choice([-1.0, 1.0], size=(n_bootstrap, n_units))
+
+    elif weight_type == "mammen":
+        # Mammen's two-point distribution
+        sqrt5 = np.sqrt(5)
+        val1 = -(sqrt5 - 1) / 2
+        val2 = (sqrt5 + 1) / 2
+        p1 = (sqrt5 + 1) / (2 * sqrt5)
+        return rng.choice([val1, val2], size=(n_bootstrap, n_units), p=[p1, 1 - p1])
+
+    elif weight_type == "webb":
+        # Webb's 6-point distribution
+        values = np.array([
+            -np.sqrt(3 / 2), -np.sqrt(2 / 2), -np.sqrt(1 / 2),
+            np.sqrt(1 / 2), np.sqrt(2 / 2), np.sqrt(3 / 2)
+        ])
+        probs = np.array([1, 2, 3, 3, 2, 1]) / 12
+        return rng.choice(values, size=(n_bootstrap, n_units), p=probs)
+
+    else:
+        raise ValueError(
+            f"weight_type must be 'rademacher', 'mammen', or 'webb', "
+            f"got '{weight_type}'"
+        )
+
+
 # =============================================================================
 # Bootstrap Results Container
 # =============================================================================
@@ -226,15 +283,8 @@ def _linear_regression(
     # Add intercept
     X_with_intercept = np.column_stack([np.ones(n), X])
 
-    # OLS: beta = (X'X)^{-1} X'y
-    try:
-        beta = np.linalg.lstsq(X_with_intercept, y, rcond=None)[0]
-    except np.linalg.LinAlgError:
-        # Fallback: use pseudo-inverse
-        beta = np.linalg.pinv(X_with_intercept) @ y
-
-    fitted = X_with_intercept @ beta
-    residuals = y - fitted
+    # Use unified OLS backend (no vcov needed)
+    beta, residuals, _ = solve_ols(X_with_intercept, y, return_vcov=False)
 
     return beta, residuals
 
@@ -553,6 +603,14 @@ class CallawaySantAnna:
         Number of bootstrap iterations for inference.
         If 0, uses analytical standard errors.
         Recommended: 999 or more for reliable inference.
+
+        .. note:: Memory Usage
+            The bootstrap stores all weights in memory as a (n_bootstrap, n_units)
+            float64 array. For large datasets, this can be significant:
+            - 1K bootstrap × 10K units = ~80 MB
+            - 10K bootstrap × 100K units = ~8 GB
+            Consider reducing n_bootstrap if memory is constrained.
+
     bootstrap_weights : str, default="rademacher"
         Type of weights for multiplier bootstrap:
         - "rademacher": +1/-1 with equal probability (standard choice)
@@ -694,6 +752,199 @@ class CallawaySantAnna:
         self.is_fitted_ = False
         self.results_ = None
 
+    def _precompute_structures(
+        self,
+        df: pd.DataFrame,
+        outcome: str,
+        unit: str,
+        time: str,
+        first_treat: str,
+        covariates: Optional[List[str]],
+        time_periods: List[Any],
+        treatment_groups: List[Any],
+    ) -> PrecomputedData:
+        """
+        Pre-compute data structures for efficient ATT(g,t) computation.
+
+        This pivots data to wide format and pre-computes:
+        - Outcome matrix (units x time periods)
+        - Covariate matrix (units x covariates) from base period
+        - Unit cohort membership masks
+        - Control unit masks
+
+        Returns
+        -------
+        PrecomputedData
+            Dictionary with pre-computed structures.
+        """
+        # Get unique units and their cohort assignments
+        unit_info = df.groupby(unit)[first_treat].first()
+        all_units = unit_info.index.values
+        unit_cohorts = unit_info.values
+        n_units = len(all_units)
+
+        # Create unit index mapping for fast lookups
+        unit_to_idx = {u: i for i, u in enumerate(all_units)}
+
+        # Pivot outcome to wide format: rows = units, columns = time periods
+        outcome_wide = df.pivot(index=unit, columns=time, values=outcome)
+        # Reindex to ensure all units are present (handles unbalanced panels)
+        outcome_wide = outcome_wide.reindex(all_units)
+        outcome_matrix = outcome_wide.values  # Shape: (n_units, n_periods)
+        period_to_col = {t: i for i, t in enumerate(outcome_wide.columns)}
+
+        # Pre-compute cohort masks (boolean arrays)
+        cohort_masks = {}
+        for g in treatment_groups:
+            cohort_masks[g] = (unit_cohorts == g)
+
+        # Never-treated mask
+        never_treated_mask = (unit_cohorts == 0) | (unit_cohorts == np.inf)
+
+        # Pre-compute covariate matrices by time period if needed
+        # (covariates are retrieved from the base period of each comparison)
+        covariate_by_period = None
+        if covariates:
+            covariate_by_period = {}
+            for t in time_periods:
+                period_data = df[df[time] == t].set_index(unit)
+                period_cov = period_data.reindex(all_units)[covariates]
+                covariate_by_period[t] = period_cov.values  # Shape: (n_units, n_covariates)
+
+        return {
+            'all_units': all_units,
+            'unit_to_idx': unit_to_idx,
+            'unit_cohorts': unit_cohorts,
+            'outcome_matrix': outcome_matrix,
+            'period_to_col': period_to_col,
+            'cohort_masks': cohort_masks,
+            'never_treated_mask': never_treated_mask,
+            'covariate_by_period': covariate_by_period,
+            'time_periods': time_periods,
+        }
+
+    def _compute_att_gt_fast(
+        self,
+        precomputed: PrecomputedData,
+        g: Any,
+        t: Any,
+        covariates: Optional[List[str]],
+    ) -> Tuple[Optional[float], float, int, int, Optional[Dict[str, Any]]]:
+        """
+        Compute ATT(g,t) using pre-computed data structures (fast version).
+
+        Uses vectorized numpy operations on pre-pivoted outcome matrix
+        instead of repeated pandas filtering.
+        """
+        time_periods = precomputed['time_periods']
+        period_to_col = precomputed['period_to_col']
+        outcome_matrix = precomputed['outcome_matrix']
+        cohort_masks = precomputed['cohort_masks']
+        never_treated_mask = precomputed['never_treated_mask']
+        unit_cohorts = precomputed['unit_cohorts']
+        all_units = precomputed['all_units']
+        covariate_by_period = precomputed['covariate_by_period']
+
+        # Base period for comparison
+        base_period = g - 1 - self.anticipation
+        if base_period not in period_to_col:
+            # Find closest earlier period
+            earlier = [p for p in time_periods if p < g - self.anticipation]
+            if not earlier:
+                return None, 0.0, 0, 0, None
+            base_period = max(earlier)
+
+        # Check if periods exist in the data
+        if base_period not in period_to_col or t not in period_to_col:
+            return None, 0.0, 0, 0, None
+
+        base_col = period_to_col[base_period]
+        post_col = period_to_col[t]
+
+        # Get treated units mask (cohort g)
+        treated_mask = cohort_masks[g]
+
+        # Get control units mask
+        if self.control_group == "never_treated":
+            control_mask = never_treated_mask
+        else:  # not_yet_treated
+            # Not yet treated at time t: never-treated OR first_treat > t
+            control_mask = never_treated_mask | (unit_cohorts > t)
+
+        # Extract outcomes for base and post periods
+        y_base = outcome_matrix[:, base_col]
+        y_post = outcome_matrix[:, post_col]
+
+        # Compute outcome changes (vectorized)
+        outcome_change = y_post - y_base
+
+        # Filter to units with valid data (no NaN in either period)
+        valid_mask = ~(np.isnan(y_base) | np.isnan(y_post))
+
+        # Get treated and control with valid data
+        treated_valid = treated_mask & valid_mask
+        control_valid = control_mask & valid_mask
+
+        n_treated = np.sum(treated_valid)
+        n_control = np.sum(control_valid)
+
+        if n_treated == 0 or n_control == 0:
+            return None, 0.0, 0, 0, None
+
+        # Extract outcome changes for treated and control
+        treated_change = outcome_change[treated_valid]
+        control_change = outcome_change[control_valid]
+
+        # Get unit IDs for influence function
+        treated_units = all_units[treated_valid]
+        control_units = all_units[control_valid]
+
+        # Get covariates if specified (from the base period)
+        X_treated = None
+        X_control = None
+        if covariates and covariate_by_period is not None:
+            cov_matrix = covariate_by_period[base_period]
+            X_treated = cov_matrix[treated_valid]
+            X_control = cov_matrix[control_valid]
+
+            # Check for missing values
+            if np.any(np.isnan(X_treated)) or np.any(np.isnan(X_control)):
+                warnings.warn(
+                    f"Missing values in covariates for group {g}, time {t}. "
+                    "Falling back to unconditional estimation.",
+                    UserWarning,
+                    stacklevel=3,
+                )
+                X_treated = None
+                X_control = None
+
+        # Estimation method
+        if self.estimation_method == "reg":
+            att_gt, se_gt, inf_func = self._outcome_regression(
+                treated_change, control_change, X_treated, X_control
+            )
+        elif self.estimation_method == "ipw":
+            att_gt, se_gt, inf_func = self._ipw_estimation(
+                treated_change, control_change,
+                int(n_treated), int(n_control),
+                X_treated, X_control
+            )
+        else:  # doubly robust
+            att_gt, se_gt, inf_func = self._doubly_robust(
+                treated_change, control_change, X_treated, X_control
+            )
+
+        # Package influence function info with unit IDs for bootstrap
+        n_t = int(n_treated)
+        inf_func_info = {
+            'treated_units': list(treated_units),
+            'control_units': list(control_units),
+            'treated_inf': inf_func[:n_t],
+            'control_inf': inf_func[n_t:],
+        }
+
+        return att_gt, se_gt, int(n_treated), int(n_control), inf_func_info
+
     def fit(
         self,
         data: pd.DataFrame,
@@ -779,6 +1030,12 @@ class CallawaySantAnna:
         if n_control_units == 0:
             raise ValueError("No never-treated units found. Check 'first_treat' column.")
 
+        # Pre-compute data structures for efficient ATT(g,t) computation
+        precomputed = self._precompute_structures(
+            df, outcome, unit, time, first_treat,
+            covariates, time_periods, treatment_groups
+        )
+
         # Compute ATT(g,t) for each group-time combination
         group_time_effects = {}
         influence_func_info = {}  # Store influence functions for bootstrap
@@ -788,9 +1045,8 @@ class CallawaySantAnna:
             valid_periods = [t for t in time_periods if t >= g - self.anticipation]
 
             for t in valid_periods:
-                att_gt, se_gt, n_treat, n_ctrl, inf_info = self._compute_att_gt(
-                    df, outcome, unit, time, first_treat, g, t,
-                    covariates, time_periods
+                att_gt, se_gt, n_treat, n_ctrl, inf_info = self._compute_att_gt_fast(
+                    precomputed, g, t, covariates
                 )
 
                 if att_gt is not None:
@@ -917,135 +1173,6 @@ class CallawaySantAnna:
         self.is_fitted_ = True
         return self.results_
 
-    def _compute_att_gt(
-        self,
-        df: pd.DataFrame,
-        outcome: str,
-        unit: str,
-        time: str,
-        first_treat: str,
-        g: Any,
-        t: Any,
-        covariates: Optional[List[str]],
-        all_periods: List[Any],
-    ) -> Tuple[Optional[float], float, int, int, Optional[Dict[str, Any]]]:
-        """
-        Compute ATT(g,t) for a specific group-time combination.
-
-        Uses 2x2 DiD comparing:
-        - Treated: Units in cohort g
-        - Control: Never-treated units (or not-yet-treated if specified)
-        - Pre-period: g - 1 (or earlier if anticipation > 0)
-        - Post-period: t
-        """
-        # Base period for comparison
-        base_period = g - 1 - self.anticipation
-        if base_period not in all_periods:
-            # Find closest earlier period
-            earlier = [p for p in all_periods if p < g - self.anticipation]
-            if not earlier:
-                return None, 0.0, 0, 0, None
-            base_period = max(earlier)
-
-        # Treated group: units first treated in period g
-        treated_units = df[df[first_treat] == g][unit].unique()
-
-        # Control group
-        if self.control_group == "never_treated":
-            control_mask = df['_never_treated']
-        else:  # not_yet_treated
-            # Not yet treated at time t
-            control_mask = (df['_never_treated']) | (df[first_treat] > t)
-
-        control_units = df[control_mask][unit].unique()
-
-        if len(treated_units) == 0 or len(control_units) == 0:
-            return None, 0.0, 0, 0, None
-
-        # Get data for the two periods
-        df_base = df[df[time] == base_period].set_index(unit)
-        df_post = df[df[time] == t].set_index(unit)
-
-        # Compute outcome changes for treated
-        treated_base = df_base.loc[df_base.index.isin(treated_units), outcome]
-        treated_post = df_post.loc[df_post.index.isin(treated_units), outcome]
-        treated_common = treated_base.index.intersection(treated_post.index)
-
-        if len(treated_common) == 0:
-            return None, 0.0, 0, 0, None
-
-        treated_change = (
-            treated_post.loc[treated_common].values -
-            treated_base.loc[treated_common].values
-        )
-
-        # Compute outcome changes for control
-        control_base = df_base.loc[df_base.index.isin(control_units), outcome]
-        control_post = df_post.loc[df_post.index.isin(control_units), outcome]
-        control_common = control_base.index.intersection(control_post.index)
-
-        if len(control_common) == 0:
-            return None, 0.0, 0, 0, None
-
-        control_change = (
-            control_post.loc[control_common].values -
-            control_base.loc[control_common].values
-        )
-
-        # Get covariates if specified (use base period values for conditioning)
-        X_treated = None
-        X_control = None
-        if covariates:
-            try:
-                X_treated = df_base.loc[treated_common, covariates].values
-                X_control = df_base.loc[control_common, covariates].values
-                # Check for missing values and handle them
-                if np.any(np.isnan(X_treated)) or np.any(np.isnan(X_control)):
-                    warnings.warn(
-                        f"Missing values in covariates for group {g}, time {t}. "
-                        "Falling back to unconditional estimation.",
-                        UserWarning,
-                        stacklevel=3,
-                    )
-                    X_treated = None
-                    X_control = None
-            except KeyError:
-                warnings.warn(
-                    f"Could not extract covariates for group {g}, time {t}. "
-                    "Falling back to unconditional estimation.",
-                    UserWarning,
-                    stacklevel=3,
-                )
-                X_treated = None
-                X_control = None
-
-        # Estimation method
-        if self.estimation_method == "reg":
-            att_gt, se_gt, inf_func = self._outcome_regression(
-                treated_change, control_change, X_treated, X_control
-            )
-        elif self.estimation_method == "ipw":
-            att_gt, se_gt, inf_func = self._ipw_estimation(
-                treated_change, control_change,
-                len(treated_common), len(control_common),
-                X_treated, X_control
-            )
-        else:  # doubly robust
-            att_gt, se_gt, inf_func = self._doubly_robust(
-                treated_change, control_change, X_treated, X_control
-            )
-
-        # Package influence function info with unit IDs for bootstrap
-        n_t = len(treated_common)
-        inf_func_info = {
-            'treated_units': list(treated_common),
-            'control_units': list(control_common),
-            'treated_inf': inf_func[:n_t],
-            'control_inf': inf_func[n_t:],
-        }
-
-        return att_gt, se_gt, len(treated_common), len(control_common), inf_func_info
-
     def _outcome_regression(
         self,
         treated_change: np.ndarray,
@@ -1539,70 +1666,80 @@ class CallawaySantAnna:
                 gt_pairs, group_time_effects, treatment_groups
             )
 
-        # Bootstrap arrays to store results
+        # Pre-compute unit index arrays for each (g,t) pair (done once, not per iteration)
+        gt_treated_indices = []
+        gt_control_indices = []
+        gt_treated_inf = []
+        gt_control_inf = []
+
+        for j, gt in enumerate(gt_pairs):
+            info = influence_func_info[gt]
+            treated_idx = np.array([unit_to_idx[u] for u in info['treated_units']])
+            control_idx = np.array([unit_to_idx[u] for u in info['control_units']])
+            gt_treated_indices.append(treated_idx)
+            gt_control_indices.append(control_idx)
+            gt_treated_inf.append(np.asarray(info['treated_inf']))
+            gt_control_inf.append(np.asarray(info['control_inf']))
+
+        # Generate ALL bootstrap weights upfront: shape (n_bootstrap, n_units)
+        # This is much faster than generating one at a time
+        all_bootstrap_weights = _generate_bootstrap_weights_batch(
+            self.n_bootstrap, n_units, self.bootstrap_weight_type, rng
+        )
+
+        # Vectorized bootstrap ATT(g,t) computation
+        # Compute all bootstrap ATTs for all (g,t) pairs using matrix operations
         bootstrap_atts_gt = np.zeros((self.n_bootstrap, n_gt))
-        bootstrap_overall = np.zeros(self.n_bootstrap)
 
+        for j in range(n_gt):
+            treated_idx = gt_treated_indices[j]
+            control_idx = gt_control_indices[j]
+            treated_inf = gt_treated_inf[j]
+            control_inf = gt_control_inf[j]
+
+            # Extract weights for this (g,t)'s units across all bootstrap iterations
+            # Shape: (n_bootstrap, n_treated) and (n_bootstrap, n_control)
+            treated_weights = all_bootstrap_weights[:, treated_idx]
+            control_weights = all_bootstrap_weights[:, control_idx]
+
+            # Vectorized perturbation: matrix-vector multiply
+            # Shape: (n_bootstrap,)
+            perturbations = (
+                treated_weights @ treated_inf +
+                control_weights @ control_inf
+            )
+
+            bootstrap_atts_gt[:, j] = original_atts[j] + perturbations
+
+        # Vectorized overall ATT: matrix-vector multiply
+        # Shape: (n_bootstrap,)
+        bootstrap_overall = bootstrap_atts_gt @ overall_weights
+
+        # Vectorized event study aggregation
         if event_study_info is not None:
             rel_periods = sorted(event_study_info.keys())
-            bootstrap_event_study = {e: np.zeros(self.n_bootstrap) for e in rel_periods}
+            bootstrap_event_study = {}
+            for e in rel_periods:
+                agg_info = event_study_info[e]
+                gt_indices = agg_info['gt_indices']
+                weights = agg_info['weights']
+                # Vectorized: select columns and multiply by weights
+                bootstrap_event_study[e] = bootstrap_atts_gt[:, gt_indices] @ weights
         else:
             bootstrap_event_study = None
 
+        # Vectorized group aggregation
         if group_agg_info is not None:
             groups = sorted(group_agg_info.keys())
-            bootstrap_group = {g: np.zeros(self.n_bootstrap) for g in groups}
+            bootstrap_group = {}
+            for g in groups:
+                agg_info = group_agg_info[g]
+                gt_indices = agg_info['gt_indices']
+                weights = agg_info['weights']
+                bootstrap_group[g] = bootstrap_atts_gt[:, gt_indices] @ weights
         else:
             bootstrap_group = None
 
-        # Run bootstrap iterations
-        for b in range(self.n_bootstrap):
-            # Generate unit-level weights
-            unit_weights = _generate_bootstrap_weights(
-                n_units, self.bootstrap_weight_type, rng
-            )
-
-            # Compute bootstrap ATT(g,t) for each group-time pair
-            for j, gt in enumerate(gt_pairs):
-                info = influence_func_info[gt]
-
-                # Get weights for treated and control units
-                treated_indices = [unit_to_idx[u] for u in info['treated_units']]
-                control_indices = [unit_to_idx[u] for u in info['control_units']]
-
-                treated_weights = unit_weights[treated_indices]
-                control_weights = unit_weights[control_indices]
-
-                # Influence function perturbation
-                # Bootstrap ATT* = ATT + sum(weights * influence)
-                perturbation = (
-                    np.sum(treated_weights * info['treated_inf']) +
-                    np.sum(control_weights * info['control_inf'])
-                )
-
-                bootstrap_atts_gt[b, j] = original_atts[j] + perturbation
-
-            # Compute bootstrap overall ATT
-            bootstrap_overall[b] = np.sum(overall_weights * bootstrap_atts_gt[b, :])
-
-            # Compute bootstrap event study effects
-            if bootstrap_event_study is not None and event_study_info is not None:
-                for e, agg_info in event_study_info.items():
-                    gt_indices = agg_info['gt_indices']
-                    weights = agg_info['weights']
-                    bootstrap_event_study[e][b] = np.sum(
-                        weights * bootstrap_atts_gt[b, gt_indices]
-                    )
-
-            # Compute bootstrap group effects
-            if bootstrap_group is not None and group_agg_info is not None:
-                for g, agg_info in group_agg_info.items():
-                    gt_indices = agg_info['gt_indices']
-                    weights = agg_info['weights']
-                    bootstrap_group[g][b] = np.sum(
-                        weights * bootstrap_atts_gt[b, gt_indices]
-                    )
-
         # Compute bootstrap statistics for ATT(g,t)
         gt_ses = {}
         gt_cis = {}

diff_diff/sun_abraham.py

@@ -16,11 +16,11 @@ from typing import Any, Dict, List, Optional, Tuple
 import numpy as np
 import pandas as pd
 
+from diff_diff.linalg import compute_robust_vcov
 from diff_diff.results import _get_significance_stars
 from diff_diff.utils import (
     compute_confidence_interval,
     compute_p_value,
-    compute_robust_se,
 )
 
 
@@ -761,7 +761,7 @@ class SunAbraham:
 
         # Compute cluster-robust standard errors
         cluster_ids = df_demeaned[cluster_var].values
-        vcov = compute_robust_se(X, residuals, cluster_ids)
+        vcov = compute_robust_vcov(X, residuals, cluster_ids)
 
         # Extract cohort effects and standard errors
         cohort_effects: Dict[Tuple[Any, int], float] = {}

diff_diff/synthetic_did.py

@@ -10,6 +10,7 @@ import pandas as pd
 from numpy.linalg import LinAlgError
 
 from diff_diff.estimators import DifferenceInDifferences
+from diff_diff.linalg import solve_ols
 from diff_diff.results import SyntheticDiDResults
 from diff_diff.utils import (
     compute_confidence_interval,
@@ -444,9 +445,8 @@ class SyntheticDiD(DifferenceInDifferences):
 
         y = data[outcome].values.astype(float)
 
-        # Fit and get residuals
-        coeffs = np.linalg.lstsq(X_full, y, rcond=None)[0]
-        residuals = y - X_full @ coeffs
+        # Fit and get residuals using unified backend
+        coeffs, residuals, _ = solve_ols(X_full, y, return_vcov=False)
 
         # Add back the mean for interpretability
         data[outcome] = residuals + np.mean(y)

diff_diff/triple_diff.py

@@ -37,11 +37,11 @@ import numpy as np
 import pandas as pd
 from scipy import optimize
 
+from diff_diff.linalg import compute_robust_vcov, solve_ols
 from diff_diff.results import _get_significance_stars
 from diff_diff.utils import (
     compute_confidence_interval,
     compute_p_value,
-    compute_robust_se,
 )
 
 # =============================================================================
@@ -353,15 +353,13 @@ def _linear_regression(
     n = X.shape[0]
     X_with_intercept = np.column_stack([np.ones(n), X])
 
-    try:
-        beta = np.linalg.lstsq(X_with_intercept, y, rcond=None)[0]
-    except np.linalg.LinAlgError:
-        beta = np.linalg.pinv(X_with_intercept) @ y
-
-    fitted = X_with_intercept @ beta
-    residuals = y - fitted
+    # Use unified OLS backend
+    beta, residuals, fitted, _ = solve_ols(
+        X_with_intercept, y, return_fitted=True, return_vcov=False
+    )
 
-    ss_res = np.sum(residuals ** 2)
+    # Compute R-squared
+    ss_res = np.sum(residuals**2)
     ss_tot = np.sum((y - np.mean(y)) ** 2)
     r_squared = 1 - (ss_res / ss_tot) if ss_tot > 0 else 0.0
 
@@ -741,17 +739,13 @@ class TripleDifference:
 
         design_matrix = np.column_stack(design_cols)
 
-        # Fit OLS
-        try:
-            coefficients = np.linalg.lstsq(design_matrix, y, rcond=None)[0]
-        except np.linalg.LinAlgError:
-            coefficients = np.linalg.pinv(design_matrix) @ y
-
-        fitted = design_matrix @ coefficients
-        residuals = y - fitted
+        # Fit OLS using unified backend
+        coefficients, residuals, fitted, _ = solve_ols(
+            design_matrix, y, return_fitted=True, return_vcov=False
+        )
 
         # R-squared
-        ss_res = np.sum(residuals ** 2)
+        ss_res = np.sum(residuals**2)
         ss_tot = np.sum((y - np.mean(y)) ** 2)
         r_squared = 1 - (ss_res / ss_tot) if ss_tot > 0 else 0.0
 
@@ -1100,10 +1094,10 @@ class TripleDifference:
 
         if self.robust:
             # HC1 robust standard errors
-            vcov = compute_robust_se(X, residuals, cluster_ids=None)
+            vcov = compute_robust_vcov(X, residuals, cluster_ids=None)
         else:
             # Classical OLS standard errors
-            mse = np.sum(residuals ** 2) / (n - k)
+            mse = np.sum(residuals**2) / (n - k)
             try:
                 vcov = np.linalg.solve(X.T @ X, mse * np.eye(k))
             except np.linalg.LinAlgError:

diff_diff/twfe.py

@@ -12,11 +12,11 @@ if TYPE_CHECKING:
     from diff_diff.bacon import BaconDecompositionResults
 
 from diff_diff.estimators import DifferenceInDifferences
+from diff_diff.linalg import compute_robust_vcov
 from diff_diff.results import DiDResults
 from diff_diff.utils import (
     compute_confidence_interval,
     compute_p_value,
-    compute_robust_se,
 )
 
 
@@ -136,7 +136,7 @@ class TwoWayFixedEffects(DifferenceInDifferences):
             )
         else:
             # Standard cluster-robust SE
-            vcov = compute_robust_se(X, residuals, cluster_ids)
+            vcov = compute_robust_vcov(X, residuals, cluster_ids)
             se = np.sqrt(vcov[att_idx, att_idx])
             t_stat = att / se
             p_value = compute_p_value(t_stat, df=df)
@@ -214,11 +214,15 @@ class TwoWayFixedEffects(DifferenceInDifferences):
         data = data.copy()
         variables = [outcome] + (covariates or [])
 
+        # Cache groupby objects for efficiency (avoids re-computing group indexes)
+        unit_grouper = data.groupby(unit, sort=False)
+        time_grouper = data.groupby(time, sort=False)
+
         for var in variables:
-            # Unit means
-            unit_means = data.groupby(unit)[var].transform("mean")
-            # Time means
-            time_means = data.groupby(time)[var].transform("mean")
+            # Unit means (using cached grouper)
+            unit_means = unit_grouper[var].transform("mean")
+            # Time means (using cached grouper)
+            time_means = time_grouper[var].transform("mean")
             # Grand mean
             grand_mean = data[var].mean()
 

diff_diff/utils.py

@@ -10,6 +10,9 @@ import numpy as np
 import pandas as pd
 from scipy import stats
 
+from diff_diff.linalg import compute_robust_vcov as _compute_robust_vcov_linalg
+from diff_diff.linalg import solve_ols as _solve_ols_linalg
+
 # Numerical constants for optimization algorithms
 _OPTIMIZATION_MAX_ITER = 1000  # Maximum iterations for weight optimization
 _OPTIMIZATION_TOL = 1e-8  # Convergence tolerance for optimization
@@ -48,6 +51,9 @@ def compute_robust_se(
     """
     Compute heteroskedasticity-robust (HC1) or cluster-robust standard errors.
 
+    This function is a thin wrapper around the optimized implementation in
+    diff_diff.linalg for backwards compatibility.
+
     Parameters
     ----------
     X : np.ndarray
@@ -62,47 +68,7 @@ def compute_robust_se(
     np.ndarray
         Variance-covariance matrix of shape (k, k).
     """
-    n, k = X.shape
-    XtX = X.T @ X
-
-    if cluster_ids is None:
-        # HC1 robust standard errors
-        # HC1 adjustment factor: n / (n - k)
-        adjustment = n / (n - k)
-
-        # Create diagonal matrix with squared residuals
-        u_squared = residuals ** 2
-
-        # Meat of the sandwich: X' * diag(u^2) * X
-        meat = X.T @ (X * u_squared[:, np.newaxis])
-
-        # Compute XtX^{-1} @ meat @ XtX^{-1} using solve() for numerical stability
-        # First solve XtX @ temp = meat to get temp = XtX^{-1} @ meat
-        temp = np.linalg.solve(XtX, meat)
-        # Then solve XtX @ vcov = temp.T and transpose to get XtX^{-1} @ meat @ XtX^{-1}
-        vcov = adjustment * np.linalg.solve(XtX, temp.T).T
-    else:
-        # Cluster-robust standard errors
-        unique_clusters = np.unique(cluster_ids)
-        n_clusters = len(unique_clusters)
-
-        # Adjustment factor for cluster-robust SEs
-        adjustment = (n_clusters / (n_clusters - 1)) * ((n - 1) / (n - k))
-
-        # Compute the meat of the sandwich
-        meat = np.zeros((k, k))
-        for cluster in unique_clusters:
-            mask = cluster_ids == cluster
-            X_c = X[mask]
-            u_c = residuals[mask]
-            score_c = X_c.T @ u_c
-            meat += np.outer(score_c, score_c)
-
-        # Compute XtX^{-1} @ meat @ XtX^{-1} using solve() for numerical stability
-        temp = np.linalg.solve(XtX, meat)
-        vcov = adjustment * np.linalg.solve(XtX, temp.T).T
-
-    return np.asarray(vcov)
+    return _compute_robust_vcov_linalg(X, residuals, cluster_ids)
 
 
 def compute_confidence_interval(
@@ -461,11 +427,10 @@ def wild_bootstrap_se(
     n = X.shape[0]
 
     # Step 1: Compute original coefficient and cluster-robust SE
-    beta_hat = np.linalg.lstsq(X, y, rcond=None)[0]
+    beta_hat, _, vcov_original = _solve_ols_linalg(
+        X, y, cluster_ids=cluster_ids, return_vcov=True
+    )
     original_coef = beta_hat[coefficient_index]
-
-    # Compute cluster-robust SE for original t-statistic
-    vcov_original = compute_robust_se(X, residuals, cluster_ids)
     se_original = np.sqrt(vcov_original[coefficient_index, coefficient_index])
     t_stat_original = (original_coef - null_hypothesis) / se_original
 
@@ -477,8 +442,9 @@ def wild_bootstrap_se(
     # Fit restricted model (but we need to drop the column for the restricted coef)
     # Actually, for WCR bootstrap we keep all columns but impose the null via residuals
     # Re-estimate with the restricted dependent variable
-    beta_restricted = np.linalg.lstsq(X, y_restricted, rcond=None)[0]
-    residuals_restricted = y_restricted - X @ beta_restricted
+    beta_restricted, residuals_restricted, _ = _solve_ols_linalg(
+        X, y_restricted, return_vcov=False
+    )
 
     # Create cluster-to-observation mapping for efficiency
     cluster_map = {c: np.where(cluster_ids == c)[0] for c in unique_clusters}
@@ -500,13 +466,11 @@ def wild_bootstrap_se(
         # Construct bootstrap sample: y* = X @ beta_restricted + e_restricted * weights
         y_star = X @ beta_restricted + residuals_restricted * obs_weights
 
-        # Estimate bootstrap coefficients
-        beta_star = np.linalg.lstsq(X, y_star, rcond=None)[0]
+        # Estimate bootstrap coefficients with cluster-robust SE
+        beta_star, residuals_star, vcov_star = _solve_ols_linalg(
+            X, y_star, cluster_ids=cluster_ids, return_vcov=True
+        )
         bootstrap_coefs[b] = beta_star[coefficient_index]
-
-        # Compute bootstrap residuals and cluster-robust SE
-        residuals_star = y_star - X @ beta_star
-        vcov_star = compute_robust_se(X, residuals_star, cluster_ids)
         se_star = np.sqrt(vcov_star[coefficient_index, coefficient_index])
 
         # Compute bootstrap t-statistic (under null hypothesis)

{diff_diff-1.3.1.dist-info → diff_diff-1.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diff-diff
-Version: 1.3.1
+Version: 1.4.0
 Summary: A library for Difference-in-Differences causal inference analysis
 Author: diff-diff contributors
 License-Expression: MIT

diff_diff-1.4.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+diff_diff/__init__.py,sha256=cnvJNAfRou91h1XguGc2n3PAUmsgcDZibzE2mncrzoA,4361
+diff_diff/bacon.py,sha256=AgQOtGUN-gtMh8q6KsGmOiVF4uCCFG2IexbeKS0mBlQ,36819
+diff_diff/diagnostics.py,sha256=1yOKfauW9RP7alXYlaR8oq5tmol5T24idsfqzyAxBPQ,29572
+diff_diff/estimators.py,sha256=4-em3NWsXGsPiC_FZ22Erzwknc5SDuHyAQ3mNZkL9uI,35547
+diff_diff/honest_did.py,sha256=J4l-JyHHhhBiUT-F9Wls_8kjhxWhEj-N3BOe02pv0AA,46925
+diff_diff/linalg.py,sha256=cn5rG9okPRR759YsSr3HxoFYgwLhrO6YPSX00Cjenos,8998
+diff_diff/power.py,sha256=cpdbWG-lxqAKjeAoM_8Un8gYaDwADIeYdWUIkEBfXZg,42800
+diff_diff/prep.py,sha256=bTPXTWajBzdNVPcLQ_IBYjww63DhgS3Z37V9h5tsIgc,46985
+diff_diff/pretrends.py,sha256=NeYjTxC9s_iIj-3beYupiDAZROYaLjFIzbm-76XhqKk,36538
+diff_diff/results.py,sha256=ymN7_WVd-XTzJGmuULO8Ryda929uBOJX0FQZ341iJek,22746
+diff_diff/staggered.py,sha256=6eNSSvSS1otHvHu-CPj4_hUwI_u5xjpbXLK-xJ2qRRY,74423
+diff_diff/sun_abraham.py,sha256=kUlGkenlSnWWqC0X01AaR5eR1BWrF6GLBBfpChy9pq4,41713
+diff_diff/synthetic_did.py,sha256=bHGvVPjcTCyEdBd9JCksl-qBHkfsBhV5VcVvBZiPf_g,26798
+diff_diff/triple_diff.py,sha256=KOF4J5hPN7SryiyMaPCsS6ZeQa9ju9o7zwgoCwchQL8,44546
+diff_diff/twfe.py,sha256=VhizxT6HkuVCDmKJQXJ-9nu0AwFHMIqVxqe2Dq-5ON8,12185
+diff_diff/utils.py,sha256=r_wGGy3bKzppiiFeBKkE4o3RIorssctp7NgXza1SYcM,42886
+diff_diff/visualization.py,sha256=1X074fUk_fZleAlHdSGYc-ihdShY9FJ6WoKmBFCV6oI,51537
+diff_diff-1.4.0.dist-info/METADATA,sha256=utVY-c8vOsM16wTdsPqcAHwsxC6oFUDEe7q-QdIurCE,77719
+diff_diff-1.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+diff_diff-1.4.0.dist-info/top_level.txt,sha256=-7mAFgjEQIA2okDLHlh5pDwBQXnsO1Z85qvtHjZILoQ,10
+diff_diff-1.4.0.dist-info/RECORD,,

diff_diff-1.3.1.dist-info/RECORD

@@ -1,20 +0,0 @@
-diff_diff/__init__.py,sha256=1Izex7iZprjS_UGqIJj6iw9fO17US6ZI1HRINYW_tsA,4361
-diff_diff/bacon.py,sha256=AgQOtGUN-gtMh8q6KsGmOiVF4uCCFG2IexbeKS0mBlQ,36819
-diff_diff/diagnostics.py,sha256=1yOKfauW9RP7alXYlaR8oq5tmol5T24idsfqzyAxBPQ,29572
-diff_diff/estimators.py,sha256=4Jj9xAnF39EWElweFoYUa91YnyELelT8mRDzZKZWj4E,35807
-diff_diff/honest_did.py,sha256=J4l-JyHHhhBiUT-F9Wls_8kjhxWhEj-N3BOe02pv0AA,46925
-diff_diff/power.py,sha256=cpdbWG-lxqAKjeAoM_8Un8gYaDwADIeYdWUIkEBfXZg,42800
-diff_diff/prep.py,sha256=bTPXTWajBzdNVPcLQ_IBYjww63DhgS3Z37V9h5tsIgc,46985
-diff_diff/pretrends.py,sha256=NeYjTxC9s_iIj-3beYupiDAZROYaLjFIzbm-76XhqKk,36538
-diff_diff/results.py,sha256=ymN7_WVd-XTzJGmuULO8Ryda929uBOJX0FQZ341iJek,22746
-diff_diff/staggered.py,sha256=DPx6VRlF67IryT8cXYq_gfdclQZEDHIYzQakR3OSvWA,69465
-diff_diff/sun_abraham.py,sha256=ux6igLILW7Y1bh3TK33P781ATUWJS4fkwrjnpTARPlU,41685
-diff_diff/synthetic_did.py,sha256=PjVFvCWQeE0X_4YZhw8iKSkyoyS2LEy7-yiwIQQd4bE,26765
-diff_diff/triple_diff.py,sha256=Jb8ld5ME6E7uQNvS2pgNmi0kHY3WikrLWm4TjTe__xI,44679
-diff_diff/twfe.py,sha256=iB-hvmOQd97B5_3hWvoaYGCSfcwJbXfg6towhRYD_Bw,11931
-diff_diff/utils.py,sha256=F0vRZ32k065VsP4YcAcUdaF_dom834QOgYj3ZaGS2pI,44211
-diff_diff/visualization.py,sha256=1X074fUk_fZleAlHdSGYc-ihdShY9FJ6WoKmBFCV6oI,51537
-diff_diff-1.3.1.dist-info/METADATA,sha256=nML3_aj-pgfeQiWsz7mOI0HRAczQc1nPPOSJkqqqpNw,77719
-diff_diff-1.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-diff_diff-1.3.1.dist-info/top_level.txt,sha256=-7mAFgjEQIA2okDLHlh5pDwBQXnsO1Z85qvtHjZILoQ,10
-diff_diff-1.3.1.dist-info/RECORD,,