splitpopsurv 0.1.0__tar.gz

splitpopsurv-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nobutaka Fukuda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

splitpopsurv-0.1.0/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: splitpopsurv
+Version: 0.1.0
+Summary: Split-population (cure / mover-stayer) survival models
+Author-email: Nobutaka Fukuda <nobutaka.fukuda@tohoku.ac.jp>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/nobifukuda/splitpopsurv-py
+Project-URL: Bug Tracker, https://github.com/nobifukuda/splitpopsurv-py/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Requires-Dist: scipy>=1.7
+Requires-Dist: pandas>=1.3
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Dynamic: license-file
+
+# splitpopsurv (Python)
+
+Split-population (cure / mover–stayer) survival models in Python: an
+accelerated failure-time regression for event timing among "movers",
+combined with a logistic regression on the probability of belonging to
+the immune "stayer" population.
+
+Five baseline timing distributions are provided — **log-logistic**,
+**Weibull**, **log-normal**, **gamma**, and the **generalized gamma** that
+nests the other four — following Schmidt & Witte (1989) and Yamaguchi
+(1992, 1998). This package is a Python translation of a set of Stata `ml`
+programs, with the log-likelihood corrected to match the published model
+and verified by simulation against known parameters.
+
+📖 **Full manual** (theory, formulas, the likelihood correction, and a
+complete function reference): [`docs/manual.html`](https://htmlpreview.github.io/?https://github.com/nobifukuda/splitpopsurv-py/blob/main/docs/manual.html)
+
+Companion packages implementing the same corrected models are available
+for [R](https://github.com/nobifukuda/splitpopsurv) and
+[Stata](https://github.com/nobifukuda/splitpopsurv-stata).
+
+## Author
+
+**Nobutaka Fukuda**, Tohoku University — <nobutaka.fukuda@tohoku.ac.jp>
+
+## Installation
+
+```bash
+pip install git+https://github.com/nobifukuda/splitpopsurv-py.git
+```
+
+## Usage
+
+```python
+import pandas as pd
+from splitpopsurv import fit_splitpop_weibull
+
+# mydata needs: time, event (0/1), and your covariates
+fit = fit_splitpop_weibull(
+    data=mydata,
+    time="time",
+    event="event",
+    h_vars=["x1"],       # H_regression: covariates for timing
+    p_vars=["x2"],       # P_regression: covariates for cure probability
+)
+
+print(fit.summary())     # coefficients, SEs, z-values, log-likelihood
+fit.params               # named parameter vector (numpy array)
+fit.as_dataframe()        # coefficients table as a pandas DataFrame
+```
+
+The other four distributions use the same signature:
+`fit_splitpop_loglogistic()`, `fit_splitpop_lognormal()`,
+`fit_splitpop_gamma()`, `fit_splitpop_ggamma()`.
+
+## A note on the original Stata code
+
+All five Stata programs this package translates compute a log-likelihood
+term that turns out to be the marginal *density* where the formula requires
+the marginal *hazard* (density divided by survival) — a discrepancy from
+Yamaguchi's own published model. This was confirmed by fitting simulated
+data with known parameters: the as-translated formula gives visibly biased
+estimates, or fails to converge outright, while the corrected formula
+implemented here recovers the true parameters accurately. See
+[`docs/manual.html`](https://htmlpreview.github.io/?https://github.com/nobifukuda/splitpopsurv-py/blob/main/docs/manual.html#correction)
+for the full derivation and the simulation results. This is the same
+correction independently verified for the R and Stata ports of this model.
+
+## Development
+
+```bash
+pip install -e ".[test]"
+pytest
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+## References
+
+Prentice, R. L. (1974). A log gamma model and its maximum likelihood
+estimation. *Biometrika*, 61(3), 539–544.
+
+Schmidt, P., & Witte, A. D. (1989). Predicting criminal recidivism using
+"split population" survival time models. *Journal of Econometrics*, 40(1),
+141–159.
+
+Yamaguchi, K. (1992). Accelerated failure-time regression models with a
+regression model of surviving fraction: An application to the analysis of
+"permanent employment" in Japan. *Journal of the American Statistical
+Association*, 87(418), 284–292.
+
+Yamaguchi, K., & Ferguson, L. R. (1995). The stopping and spacing of
+childbirths and their birth-history predictors: Rational-choice theory and
+event-history analysis. *American Sociological Review*, 60(2), 272–298.
+
+Yamaguchi, K. (1998). Mover-stayer models for analyzing event nonoccurrence
+and event timing with time-dependent covariates: An application to an
+analysis of remarriage. *Sociological Methodology*, 28(1), 327–361.

splitpopsurv-0.1.0/README.md

@@ -0,0 +1,100 @@
+# splitpopsurv (Python)
+
+Split-population (cure / mover–stayer) survival models in Python: an
+accelerated failure-time regression for event timing among "movers",
+combined with a logistic regression on the probability of belonging to
+the immune "stayer" population.
+
+Five baseline timing distributions are provided — **log-logistic**,
+**Weibull**, **log-normal**, **gamma**, and the **generalized gamma** that
+nests the other four — following Schmidt & Witte (1989) and Yamaguchi
+(1992, 1998). This package is a Python translation of a set of Stata `ml`
+programs, with the log-likelihood corrected to match the published model
+and verified by simulation against known parameters.
+
+📖 **Full manual** (theory, formulas, the likelihood correction, and a
+complete function reference): [`docs/manual.html`](https://htmlpreview.github.io/?https://github.com/nobifukuda/splitpopsurv-py/blob/main/docs/manual.html)
+
+Companion packages implementing the same corrected models are available
+for [R](https://github.com/nobifukuda/splitpopsurv) and
+[Stata](https://github.com/nobifukuda/splitpopsurv-stata).
+
+## Author
+
+**Nobutaka Fukuda**, Tohoku University — <nobutaka.fukuda@tohoku.ac.jp>
+
+## Installation
+
+```bash
+pip install git+https://github.com/nobifukuda/splitpopsurv-py.git
+```
+
+## Usage
+
+```python
+import pandas as pd
+from splitpopsurv import fit_splitpop_weibull
+
+# mydata needs: time, event (0/1), and your covariates
+fit = fit_splitpop_weibull(
+    data=mydata,
+    time="time",
+    event="event",
+    h_vars=["x1"],       # H_regression: covariates for timing
+    p_vars=["x2"],       # P_regression: covariates for cure probability
+)
+
+print(fit.summary())     # coefficients, SEs, z-values, log-likelihood
+fit.params               # named parameter vector (numpy array)
+fit.as_dataframe()        # coefficients table as a pandas DataFrame
+```
+
+The other four distributions use the same signature:
+`fit_splitpop_loglogistic()`, `fit_splitpop_lognormal()`,
+`fit_splitpop_gamma()`, `fit_splitpop_ggamma()`.
+
+## A note on the original Stata code
+
+All five Stata programs this package translates compute a log-likelihood
+term that turns out to be the marginal *density* where the formula requires
+the marginal *hazard* (density divided by survival) — a discrepancy from
+Yamaguchi's own published model. This was confirmed by fitting simulated
+data with known parameters: the as-translated formula gives visibly biased
+estimates, or fails to converge outright, while the corrected formula
+implemented here recovers the true parameters accurately. See
+[`docs/manual.html`](https://htmlpreview.github.io/?https://github.com/nobifukuda/splitpopsurv-py/blob/main/docs/manual.html#correction)
+for the full derivation and the simulation results. This is the same
+correction independently verified for the R and Stata ports of this model.
+
+## Development
+
+```bash
+pip install -e ".[test]"
+pytest
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+## References
+
+Prentice, R. L. (1974). A log gamma model and its maximum likelihood
+estimation. *Biometrika*, 61(3), 539–544.
+
+Schmidt, P., & Witte, A. D. (1989). Predicting criminal recidivism using
+"split population" survival time models. *Journal of Econometrics*, 40(1),
+141–159.
+
+Yamaguchi, K. (1992). Accelerated failure-time regression models with a
+regression model of surviving fraction: An application to the analysis of
+"permanent employment" in Japan. *Journal of the American Statistical
+Association*, 87(418), 284–292.
+
+Yamaguchi, K., & Ferguson, L. R. (1995). The stopping and spacing of
+childbirths and their birth-history predictors: Rational-choice theory and
+event-history analysis. *American Sociological Review*, 60(2), 272–298.
+
+Yamaguchi, K. (1998). Mover-stayer models for analyzing event nonoccurrence
+and event timing with time-dependent covariates: An application to an
+analysis of remarriage. *Sociological Methodology*, 28(1), 327–361.

splitpopsurv-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "splitpopsurv"
+version = "0.1.0"
+description = "Split-population (cure / mover-stayer) survival models"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Nobutaka Fukuda", email = "nobutaka.fukuda@tohoku.ac.jp" },
+]
+requires-python = ">=3.9"
+dependencies = [
+    "numpy>=1.20",
+    "scipy>=1.7",
+    "pandas>=1.3",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+
+[project.optional-dependencies]
+test = ["pytest>=7.0"]
+
+[project.urls]
+Homepage = "https://github.com/nobifukuda/splitpopsurv-py"
+"Bug Tracker" = "https://github.com/nobifukuda/splitpopsurv-py/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

splitpopsurv-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

splitpopsurv-0.1.0/src/splitpopsurv/__init__.py

@@ -0,0 +1,52 @@
+"""
+splitpopsurv: Split-Population (Cure / Mover-Stayer) Survival Models
+======================================================================
+
+Maximum-likelihood estimation of split-population survival models, which
+combine an accelerated failure-time regression for event timing among
+"movers" with a logistic regression on the probability of belonging to
+the immune "stayer" population. See Schmidt & Witte (1989) and Yamaguchi
+(1992, 1998) for the underlying theory, and the package README / manual
+for a full derivation including a likelihood correction relative to the
+Stata `ml` programs this package translates.
+
+Author:  Nobutaka Fukuda <nobutaka.fukuda@tohoku.ac.jp>
+License: MIT
+
+Main functions
+--------------
+fit_splitpop_loglogistic, fit_splitpop_weibull, fit_splitpop_lognormal,
+fit_splitpop_gamma, fit_splitpop_ggamma
+"""
+
+from .models import (
+    SplitPopResult,
+    fit_splitpop_loglogistic,
+    fit_splitpop_weibull,
+    fit_splitpop_lognormal,
+    fit_splitpop_gamma,
+    fit_splitpop_ggamma,
+    loglik_splitpop_loglogistic,
+    loglik_splitpop_weibull,
+    loglik_splitpop_lognormal,
+    loglik_splitpop_gamma,
+    loglik_splitpop_ggamma,
+)
+
+__version__ = "0.1.0"
+__author__ = "Nobutaka Fukuda"
+__email__ = "nobutaka.fukuda@tohoku.ac.jp"
+
+__all__ = [
+    "SplitPopResult",
+    "fit_splitpop_loglogistic",
+    "fit_splitpop_weibull",
+    "fit_splitpop_lognormal",
+    "fit_splitpop_gamma",
+    "fit_splitpop_ggamma",
+    "loglik_splitpop_loglogistic",
+    "loglik_splitpop_weibull",
+    "loglik_splitpop_lognormal",
+    "loglik_splitpop_gamma",
+    "loglik_splitpop_ggamma",
+]

splitpopsurv-0.1.0/src/splitpopsurv/models.py

@@ -0,0 +1,566 @@
+"""
+splitpopsurv.models
+====================
+
+Split-population (cure / mover-stayer) survival models.
+
+Author:  Nobutaka Fukuda <nobutaka.fukuda@tohoku.ac.jp>
+License: MIT
+
+A Python translation of five Stata `ml` programs (SphLog, SphWieb, SphNom,
+SphGam, SphGGam) for Log-logistic, Weibull, Log-normal, Gamma and
+Generalized Gamma split-population survival models.
+
+Statistical background: Schmidt & Witte (1989) "split population" survival
+models and Yamaguchi (1992, 1998) mover-stayer / accelerated-failure-time
+models with a logit regression on the surviving ("stayer"/"cured") fraction.
+See Yamaguchi & Ferguson (1995, American Sociological Review 60(2)) eqs.
+(3)-(6) and Yamaguchi (1998, Sociological Methodology 28) eq. (1)-(2) for
+the underlying model. Full references: the package README / docs/manual.html.
+
+Stata -> Python correspondence used throughout:
+    $ML_y1              -> time    (duration/survival time)
+    $ML_y2              -> event   (1 = failure observed, 0 = censored)
+    $ML_y3              -> group   (0/1 indicator that flips the cure-prob
+                                     equation, exactly as in the original
+                                     Stata code)
+    invlogit(x)          -> scipy.special.expit(x)
+    norm(x)              -> scipy.stats.norm.cdf(x)
+    gammap(a, x)          -> scipy.special.gammainc(a, x)   (regularized
+                              lower incomplete gamma)
+    lngamma(x)            -> scipy.special.gammaln(x)
+    _pi                   -> numpy.pi
+    ml model lf/d0 ...     -> scipy.optimize.minimize(..., method="L-BFGS-B")
+
+Each `fit_splitpop_*()` function mirrors one Stata `ml model` block: it
+takes the H_regression covariates (location/scale of the mover timing
+distribution) and P_regression covariates (the cure-probability logit),
+builds design matrices with an intercept, and maximizes the log-likelihood.
+
+Ancillary shape parameters (Stata's unnamed "()" or "ln_sigma:"/"kappa:"
+equations, i.e. intercept-only equations) are represented as single free
+scalars in the parameter vector, exactly as in the original.
+
+------------------------------------------------------------------------
+CORRECTION relative to the original Stata code (see docs/manual.html for
+the full derivation and a simulation-based verification -- this is the
+same correction independently verified for the R and Stata ports of this
+model):
+
+For a split-population model with mover survival S_m(t)/density f_m(t)
+and cure probability p, the marginal survival and density are
+
+    S(t) = (1-p) S_m(t) + p            f(t) = (1-p) f_m(t)
+
+and the standard hazard-based log-likelihood contribution for person i is
+
+    delta_i * log(f(t_i))  +  (1 - delta_i) * log(S(t_i))
+
+equivalently  delta_i * log(h(t_i)) + log(S(t_i))  where h(t) = f(t)/S(t)
+is the TRUE marginal hazard (Yamaguchi 1998, eq. 2).
+
+The original Stata code computes hz2/mhz = (1-p)*hz_m(t)*S_m(t), which
+equals the marginal DENSITY f(t), not the marginal hazard h(t) = f(t)/S(t)
+(it never divides by S(t)), then evaluates lnf = $ML_y2*ln(hz2) + ln(sv2)
+for every observation -- double-counting log(S(t_i)) for every observed
+event. This was confirmed by simulation with known true parameters (for
+this Python port too, see tests/): the as-written formula gives visibly
+biased estimates (especially for the cure-probability coefficients) or
+fails to converge, while the corrected formula below recovers the true
+parameters accurately.
+
+This package implements the CORRECTED formula:
+    loglik_i = delta_i * log(f(t_i))  +  (1 - delta_i) * log(S(t_i))
+written as np.where(event == 1, log(marginal density), log(marginal
+survival)), which is both statistically correct and numerically robust
+(it avoids ever forming hazard = density / survival, so there is no 0/0
+or inf*0 risk when survival underflows to exactly 0 in floating point at
+extreme durations).
+------------------------------------------------------------------------
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+from scipy import optimize
+from scipy.special import expit, gammaln, gammainc
+from scipy.stats import norm
+
+__all__ = [
+    "SplitPopResult",
+    "fit_splitpop_loglogistic",
+    "fit_splitpop_weibull",
+    "fit_splitpop_lognormal",
+    "fit_splitpop_gamma",
+    "fit_splitpop_ggamma",
+]
+
+
+# ---------------------------------------------------------------------
+# Helpers (internal)
+# ---------------------------------------------------------------------
+
+def _design_matrix(data: pd.DataFrame, varlist):
+    """Build an intercept + covariates design matrix from column names."""
+    n = len(data)
+    cols = ["Intercept"] + list(varlist)
+    X = np.column_stack(
+        [np.ones(n)] + [np.asarray(data[v], dtype=float) for v in varlist]
+    )
+    return X, cols
+
+
+def _cure_prob(theta_p, group):
+    """p = expit(theta_p) if group==1, 1-expit(theta_p) if group==0.
+
+    Kept exactly as in the Stata source: $ML_y3 flips which side of the
+    logistic curve is used for the cure probability.
+    """
+    p = expit(theta_p)
+    return np.where(group == 1, p, 1.0 - p)
+
+
+def _split_loglik(event, mdens, msurv):
+    """delta*log(marginal density) + (1-delta)*log(marginal survival).
+
+    Written with np.where (not delta*log(f)+log(S)) so that the density
+    term is never evaluated where it doesn't matter -- avoids inf*0 -> nan
+    when survival underflows to 0 at extreme durations.
+    """
+    with np.errstate(divide="ignore", invalid="ignore"):
+        return np.where(event == 1, np.log(mdens), np.log(msurv))
+
+
+def _safe_start_h(k_h, intercept_value=1.0):
+    """Positive-intercept, zero-slope start for Gamma's H_regression, where
+    theta1 = Xh @ b_h is used directly as a rate (no exp() transform) and
+    must stay positive regardless of covariate values."""
+    b0 = np.zeros(k_h)
+    b0[0] = intercept_value
+    return b0
+
+
+_BAD_PENALTY = 1e10
+
+
+def _neg_loglik_sum(loglik_fn):
+    # Wandering outside the valid parameter domain during a line-search
+    # trial step (e.g. a negative rate in the gamma model) produces NaN
+    # log-likelihood contributions. Most gradient-based optimizers cannot
+    # recover once the objective itself is NaN, so trial points like that
+    # are given a large but FINITE penalty instead -- the optimizer then
+    # treats them as simply "much worse" and backs away, rather than
+    # getting stuck. This never affects the optimum itself: at any point
+    # actually near a maximum the likelihood is finite by construction.
+    def obj(par, *args):
+        with np.errstate(all="ignore"):
+            ll = loglik_fn(par, *args)
+        total = np.sum(ll)
+        if not np.isfinite(total):
+            return _BAD_PENALTY
+        return -total
+    return obj
+
+
+def _optimize(loglik_fn, start, args, method):
+    obj = _neg_loglik_sum(loglik_fn)
+    res = optimize.minimize(obj, start, args=args, method=method,
+                             options={"maxiter": 2000})
+    return res
+
+
+# ---------------------------------------------------------------------
+# Result object
+# ---------------------------------------------------------------------
+
+class SplitPopResult:
+    """Result of a split-population survival model fit.
+
+    Attributes
+    ----------
+    params : numpy.ndarray
+        Point estimates, in the order given by ``param_names``.
+    param_names : list of str
+        Names, e.g. ``"H_regression:Intercept"``, ``"ln_sigma"``,
+        ``"P_regression:x2"``.
+    loglik : float
+        Maximized log-likelihood.
+    converged : bool
+        Whether the optimizer reported convergence.
+    nobs : int
+        Number of observations used.
+    distribution : str
+        Which baseline distribution was fit.
+    """
+
+    def __init__(self, params, param_names, loglik, hessian_inv, converged,
+                 message, nobs, distribution, nit):
+        self.params = np.asarray(params)
+        self.param_names = list(param_names)
+        self.loglik = float(loglik)
+        self._hessian_inv = hessian_inv
+        self.converged = bool(converged)
+        self.message = message
+        self.nobs = int(nobs)
+        self.distribution = distribution
+        self.nit = nit
+
+    @property
+    def bse(self):
+        """Standard errors (sqrt of the diagonal of the inverse Hessian
+        of the negative log-likelihood, i.e. the observed-information
+        covariance estimate -- the same convention as R's maxLik and
+        Stata's ml)."""
+        diag = np.diag(self._hessian_inv)
+        with np.errstate(invalid="ignore"):
+            return np.sqrt(np.where(diag >= 0, diag, np.nan))
+
+    @property
+    def zvalues(self):
+        with np.errstate(divide="ignore", invalid="ignore"):
+            return self.params / self.bse
+
+    @property
+    def pvalues(self):
+        with np.errstate(invalid="ignore"):
+            return 2.0 * (1.0 - norm.cdf(np.abs(self.zvalues)))
+
+    def conf_int(self, alpha=0.05):
+        z = norm.ppf(1 - alpha / 2)
+        lo = self.params - z * self.bse
+        hi = self.params + z * self.bse
+        return pd.DataFrame({"lower": lo, "upper": hi}, index=self.param_names)
+
+    def as_dataframe(self):
+        return pd.DataFrame(
+            {
+                "coef": self.params,
+                "std err": self.bse,
+                "z": self.zvalues,
+                "P>|z|": self.pvalues,
+            },
+            index=self.param_names,
+        )
+
+    def summary(self):
+        df = self.as_dataframe()
+        lines = []
+        lines.append(f"Split-population survival model ({self.distribution})")
+        lines.append(f"No. observations: {self.nobs}    Log-likelihood: {self.loglik:.4f}")
+        lines.append(f"Converged: {self.converged}    Iterations: {self.nit}")
+        lines.append("-" * 70)
+        lines.append(df.to_string(float_format=lambda x: f"{x:0.4f}"))
+        return "\n".join(lines)
+
+    def __repr__(self):
+        return f"<SplitPopResult distribution={self.distribution!r} loglik={self.loglik:.3f} converged={self.converged}>"
+
+
+def _make_result(res, param_names, nobs, distribution):
+    hess_inv = res.hess_inv
+    if not isinstance(hess_inv, np.ndarray):
+        hess_inv = hess_inv.todense() if hasattr(hess_inv, "todense") else np.asarray(hess_inv)
+    return SplitPopResult(
+        params=res.x,
+        param_names=param_names,
+        loglik=-res.fun,
+        hessian_inv=hess_inv,
+        converged=bool(res.success),
+        message=res.message,
+        nobs=nobs,
+        distribution=distribution,
+        nit=res.nit if hasattr(res, "nit") else None,
+    )
+
+
+# =======================================================================
+# 1. Log-logistic distribution  (Stata: SphLog)
+# =======================================================================
+
+def loglik_splitpop_loglogistic(par, time, event, group, Xh, Xp):
+    k_h = Xh.shape[1]
+    b_h = par[:k_h]
+    theta2 = par[k_h]
+    b_p = par[k_h + 1:]
+
+    theta1 = Xh @ b_h
+    theta3 = Xp @ b_p
+
+    p = _cure_prob(theta3, group)
+    lam = np.exp(-theta1)
+    sigma = 1.0 / theta2
+    sv = 1.0 / (1.0 + (lam * time) ** sigma)                 # S_m(t)
+    hz = (lam * sigma * (lam * time) ** (sigma - 1.0)) / (1.0 + (lam * time) ** sigma)  # h_m(t)
+    msv = (1 - p) * sv + p                                    # S(t)
+    mdens = (1 - p) * hz * sv                                 # f(t)
+
+    return _split_loglik(event, mdens, msv)
+
+
+def fit_splitpop_loglogistic(data: pd.DataFrame, time: str, event: str,
+                              h_vars, p_vars, group: str | None = None,
+                              start=None, method="L-BFGS-B"):
+    """Fit a split-population log-logistic survival model.
+
+    Parameters
+    ----------
+    data : pandas.DataFrame
+    time, event : str
+        Column names for duration ($ML_y1) and 0/1 event indicator
+        ($ML_y2; 1 = failure observed, 0 = censored).
+    h_vars : list of str
+        H_regression covariates (timing distribution).
+    p_vars : list of str
+        P_regression covariates (cure/stayer probability).
+    group : str or None
+        Column name of a 0/1 indicator that flips the cure-probability
+        logit ($ML_y3 in the Stata source). If None, a constant of 1 is
+        used for every observation (the ordinary case).
+    start : numpy.ndarray or None
+        Starting values; a sensible default is used if None.
+    method : str
+        Passed to ``scipy.optimize.minimize``. Default "BFGS"; try
+        "Nelder-Mead" if that fails to converge.
+
+    Returns
+    -------
+    SplitPopResult
+    """
+    Xh, hcols = _design_matrix(data, h_vars)
+    Xp, pcols = _design_matrix(data, p_vars)
+    t = np.asarray(data[time], dtype=float)
+    y = np.asarray(data[event], dtype=float)
+    g = np.ones(len(data)) if group is None else np.asarray(data[group], dtype=float)
+
+    if start is None:
+        start = np.concatenate([np.zeros(Xh.shape[1]), [1.0], np.zeros(Xp.shape[1])])
+
+    res = _optimize(loglik_splitpop_loglogistic, start, (t, y, g, Xh, Xp), method)
+    names = [f"H_regression:{c}" for c in hcols] + ["theta2"] + [f"P_regression:{c}" for c in pcols]
+    return _make_result(res, names, len(data), "loglogistic")
+
+
+# =======================================================================
+# 2. Weibull distribution  (Stata: SphWieb)
+# =======================================================================
+
+def loglik_splitpop_weibull(par, time, event, group, Xh, Xp):
+    k_h = Xh.shape[1]
+    b_h = par[:k_h]
+    theta2 = par[k_h]
+    b_p = par[k_h + 1:]
+
+    theta1 = Xh @ b_h
+    theta3 = Xp @ b_p
+
+    p = _cure_prob(theta3, group)
+    lam = np.exp(theta2)
+    sv = np.exp(-np.exp(theta1) * (time ** lam))              # S_m(t)
+    hz = lam * (time ** (lam - 1.0)) * np.exp(theta1)         # h_m(t)
+    msv = (1 - p) * sv + p                                    # S(t)
+    mdens = (1 - p) * hz * sv                                 # f(t)
+
+    return _split_loglik(event, mdens, msv)
+
+
+def fit_splitpop_weibull(data: pd.DataFrame, time: str, event: str,
+                          h_vars, p_vars, group: str | None = None,
+                          start=None, method="L-BFGS-B"):
+    """Fit a split-population Weibull survival model. See
+    :func:`fit_splitpop_loglogistic` for the argument reference."""
+    Xh, hcols = _design_matrix(data, h_vars)
+    Xp, pcols = _design_matrix(data, p_vars)
+    t = np.asarray(data[time], dtype=float)
+    y = np.asarray(data[event], dtype=float)
+    g = np.ones(len(data)) if group is None else np.asarray(data[group], dtype=float)
+
+    if start is None:
+        start = np.concatenate([np.zeros(Xh.shape[1]), [0.0], np.zeros(Xp.shape[1])])
+
+    res = _optimize(loglik_splitpop_weibull, start, (t, y, g, Xh, Xp), method)
+    names = [f"H_regression:{c}" for c in hcols] + ["ln_sigma"] + [f"P_regression:{c}" for c in pcols]
+    return _make_result(res, names, len(data), "weibull")
+
+
+# =======================================================================
+# 3. Log-normal distribution  (Stata: SphNom)
+# =======================================================================
+
+def loglik_splitpop_lognormal(par, time, event, group, Xh, Xp):
+    k_h = Xh.shape[1]
+    b_h = par[:k_h]
+    theta2 = par[k_h]
+    b_p = par[k_h + 1:]
+
+    theta1 = Xh @ b_h
+    theta3 = Xp @ b_p
+
+    p = _cure_prob(theta3, group)
+    sigma = np.exp(theta2)
+    lam = np.log(time) - theta1
+    sv = 1.0 - norm.cdf(lam / sigma)                                       # S_m(t)
+    pdf_m = np.exp(-(lam ** 2) / (2 * sigma ** 2)) / (np.sqrt(2 * np.pi) * sigma * time)  # f_m(t), direct (no /sv)
+    msv = (1 - p) * sv + p                                                 # S(t)
+    mdens = (1 - p) * pdf_m                                                # f(t)
+
+    return _split_loglik(event, mdens, msv)
+
+
+def fit_splitpop_lognormal(data: pd.DataFrame, time: str, event: str,
+                            h_vars, p_vars, group: str | None = None,
+                            start=None, method="L-BFGS-B"):
+    """Fit a split-population log-normal survival model. See
+    :func:`fit_splitpop_loglogistic` for the argument reference."""
+    Xh, hcols = _design_matrix(data, h_vars)
+    Xp, pcols = _design_matrix(data, p_vars)
+    t = np.asarray(data[time], dtype=float)
+    y = np.asarray(data[event], dtype=float)
+    g = np.ones(len(data)) if group is None else np.asarray(data[group], dtype=float)
+
+    if start is None:
+        start = np.concatenate([np.zeros(Xh.shape[1]), [0.0], np.zeros(Xp.shape[1])])
+
+    res = _optimize(loglik_splitpop_lognormal, start, (t, y, g, Xh, Xp), method)
+    names = [f"H_regression:{c}" for c in hcols] + ["ln_sigma"] + [f"P_regression:{c}" for c in pcols]
+    return _make_result(res, names, len(data), "lognormal")
+
+
+# =======================================================================
+# 4. Gamma distribution  (Stata: SphGam)
+# =======================================================================
+
+def loglik_splitpop_gamma(par, time, event, group, Xh, Xp):
+    k_h = Xh.shape[1]
+    b_h = par[:k_h]
+    theta2 = par[k_h]
+    b_p = par[k_h + 1:]
+
+    theta1 = Xh @ b_h
+    theta3 = Xp @ b_p
+
+    p = _cure_prob(theta3, group)
+    l = theta1 * time
+    k = theta2
+    cdf = gammainc(k, l)                                       # gammap(k, l)
+    gam = np.exp(gammaln(k))
+    pdf_m = (theta1 * (l ** (k - 1.0)) * np.exp(-l)) / gam     # f_m(t), direct (no /sv)
+    sv = 1.0 - cdf                                              # S_m(t)
+    msv = (1 - p) * sv + p                                      # S(t)
+    mdens = (1 - p) * pdf_m                                     # f(t)
+
+    return _split_loglik(event, mdens, msv)
+
+
+def fit_splitpop_gamma(data: pd.DataFrame, time: str, event: str,
+                        h_vars, p_vars, group: str | None = None,
+                        start=None, method="L-BFGS-B"):
+    """Fit a split-population gamma survival model.
+
+    Note: unlike the other four models, the H_regression linear index is
+    used directly as a rate (no ``exp()`` transform), so it must stay
+    positive. The default start sets a positive intercept and zero slopes
+    to keep it safe regardless of covariate values.
+
+    See :func:`fit_splitpop_loglogistic` for the argument reference.
+    """
+    Xh, hcols = _design_matrix(data, h_vars)
+    Xp, pcols = _design_matrix(data, p_vars)
+    t = np.asarray(data[time], dtype=float)
+    y = np.asarray(data[event], dtype=float)
+    g = np.ones(len(data)) if group is None else np.asarray(data[group], dtype=float)
+
+    if start is None:
+        start = np.concatenate([_safe_start_h(Xh.shape[1]), [1.0], np.zeros(Xp.shape[1])])
+
+    res = _optimize(loglik_splitpop_gamma, start, (t, y, g, Xh, Xp), method)
+    names = [f"H_regression:{c}" for c in hcols] + ["kappa"] + [f"P_regression:{c}" for c in pcols]
+    return _make_result(res, names, len(data), "gamma")
+
+
+# =======================================================================
+# 5. Generalized Gamma distribution  (Stata: SphGGam / KYmodel5, d0 method)
+# =======================================================================
+
+def loglik_splitpop_ggamma(par, time, event, group, Xh, Xp):
+    k_h = Xh.shape[1]
+    b_h = par[:k_h]
+    theta2 = par[k_h]
+    theta3s = par[k_h + 1]
+    b_p = par[k_h + 2:]
+
+    theta1 = Xh @ b_h
+    theta4 = Xp @ b_p
+
+    p = _cure_prob(theta4, group)
+
+    k = np.where(np.abs(theta3s) < 0.01, np.sign(theta3s) * 0.01, theta3s)
+    if k == 0:  # sign(0) == 0 in both Stata and numpy; break the tie like the
+        k = np.array(0.01)  # Stata guard would if it ever landed exactly on 0
+
+    s = np.exp(theta2)
+    l = np.abs(k) ** (-2.0)
+    z = np.sign(k) * (np.log(time) - theta1) / s
+    u = l * np.exp(np.abs(k) * z)
+
+    small_k = np.abs(k) < 0.01
+    if small_k:
+        cdf = norm.cdf(z)
+    elif k >= 0.01:
+        cdf = gammainc(l, u)                                   # gammap(l, u)
+    else:
+        cdf = 1.0 - gammainc(l, u)
+
+    gam = np.exp(gammaln(l))
+    if small_k:
+        pdf_m = np.exp(-(z ** 2) / 2.0) / (s * time * np.sqrt(2 * np.pi))
+    else:
+        pdf_m = (l ** l * np.exp(z * np.sqrt(l) - u)) / (s * time * np.sqrt(l) * gam)  # f_m(t), direct
+
+    sv = 1.0 - cdf                                              # S_m(t)
+    msv = (1 - p) * sv + p                                      # S(t)
+    mdens = (1 - p) * pdf_m                                     # f(t)
+
+    return _split_loglik(event, mdens, msv)
+
+
+def fit_splitpop_ggamma(data: pd.DataFrame, time: str, event: str,
+                         h_vars, p_vars, group: str | None = None,
+                         start=None, method="L-BFGS-B"):
+    """Fit a split-population generalized gamma survival model (Prentice
+    1974 / Yamaguchi & Ferguson 1995, note 10) -- the family that nests
+    Weibull (kappa=1), log-normal (kappa=0), and gamma (sigma=1).
+
+    Note: ``|kappa| < 0.01`` switches to a log-normal-equivalent branch, a
+    genuine kink in the likelihood surface (preserved from the Stata
+    guard). If standard errors come back non-finite, the optimizer likely
+    landed near that threshold -- try a different starting kappa.
+
+    See :func:`fit_splitpop_loglogistic` for the argument reference.
+    """
+    Xh, hcols = _design_matrix(data, h_vars)
+    Xp, pcols = _design_matrix(data, p_vars)
+    t = np.asarray(data[time], dtype=float)
+    y = np.asarray(data[event], dtype=float)
+    g = np.ones(len(data)) if group is None else np.asarray(data[group], dtype=float)
+
+    if start is None:
+        start = np.concatenate([np.zeros(Xh.shape[1]), [0.0, 1.0], np.zeros(Xp.shape[1])])
+
+    res = _optimize(loglik_splitpop_ggamma, start, (t, y, g, Xh, Xp), method)
+    names = ([f"H_regression:{c}" for c in hcols] + ["ln_sigma", "kappa"]
+              + [f"P_regression:{c}" for c in pcols])
+    return _make_result(res, names, len(data), "ggamma")
+
+
+# ---------------------------------------------------------------------
+# Notes on the pieces that don't carry over from Stata:
+#
+#  - `ml check` / `ml search`: call the relevant loglik_splitpop_*()
+#    function once by hand at candidate starting values, and/or try
+#    several starts or `method` values if convergence fails.
+#  - `ml graph`: plot fitted survival/hazard curves yourself (e.g. with
+#    matplotlib) from `result.params` plugged back into the survival/
+#    density formulas above.
+#  - `summary(fit)`'s closest analogue here is `result.summary()`.
+# ---------------------------------------------------------------------

splitpopsurv-0.1.0/src/splitpopsurv.egg-info/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: splitpopsurv
+Version: 0.1.0
+Summary: Split-population (cure / mover-stayer) survival models
+Author-email: Nobutaka Fukuda <nobutaka.fukuda@tohoku.ac.jp>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/nobifukuda/splitpopsurv-py
+Project-URL: Bug Tracker, https://github.com/nobifukuda/splitpopsurv-py/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Requires-Dist: scipy>=1.7
+Requires-Dist: pandas>=1.3
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Dynamic: license-file
+
+# splitpopsurv (Python)
+
+Split-population (cure / mover–stayer) survival models in Python: an
+accelerated failure-time regression for event timing among "movers",
+combined with a logistic regression on the probability of belonging to
+the immune "stayer" population.
+
+Five baseline timing distributions are provided — **log-logistic**,
+**Weibull**, **log-normal**, **gamma**, and the **generalized gamma** that
+nests the other four — following Schmidt & Witte (1989) and Yamaguchi
+(1992, 1998). This package is a Python translation of a set of Stata `ml`
+programs, with the log-likelihood corrected to match the published model
+and verified by simulation against known parameters.
+
+📖 **Full manual** (theory, formulas, the likelihood correction, and a
+complete function reference): [`docs/manual.html`](https://htmlpreview.github.io/?https://github.com/nobifukuda/splitpopsurv-py/blob/main/docs/manual.html)
+
+Companion packages implementing the same corrected models are available
+for [R](https://github.com/nobifukuda/splitpopsurv) and
+[Stata](https://github.com/nobifukuda/splitpopsurv-stata).
+
+## Author
+
+**Nobutaka Fukuda**, Tohoku University — <nobutaka.fukuda@tohoku.ac.jp>
+
+## Installation
+
+```bash
+pip install git+https://github.com/nobifukuda/splitpopsurv-py.git
+```
+
+## Usage
+
+```python
+import pandas as pd
+from splitpopsurv import fit_splitpop_weibull
+
+# mydata needs: time, event (0/1), and your covariates
+fit = fit_splitpop_weibull(
+    data=mydata,
+    time="time",
+    event="event",
+    h_vars=["x1"],       # H_regression: covariates for timing
+    p_vars=["x2"],       # P_regression: covariates for cure probability
+)
+
+print(fit.summary())     # coefficients, SEs, z-values, log-likelihood
+fit.params               # named parameter vector (numpy array)
+fit.as_dataframe()        # coefficients table as a pandas DataFrame
+```
+
+The other four distributions use the same signature:
+`fit_splitpop_loglogistic()`, `fit_splitpop_lognormal()`,
+`fit_splitpop_gamma()`, `fit_splitpop_ggamma()`.
+
+## A note on the original Stata code
+
+All five Stata programs this package translates compute a log-likelihood
+term that turns out to be the marginal *density* where the formula requires
+the marginal *hazard* (density divided by survival) — a discrepancy from
+Yamaguchi's own published model. This was confirmed by fitting simulated
+data with known parameters: the as-translated formula gives visibly biased
+estimates, or fails to converge outright, while the corrected formula
+implemented here recovers the true parameters accurately. See
+[`docs/manual.html`](https://htmlpreview.github.io/?https://github.com/nobifukuda/splitpopsurv-py/blob/main/docs/manual.html#correction)
+for the full derivation and the simulation results. This is the same
+correction independently verified for the R and Stata ports of this model.
+
+## Development
+
+```bash
+pip install -e ".[test]"
+pytest
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+## References
+
+Prentice, R. L. (1974). A log gamma model and its maximum likelihood
+estimation. *Biometrika*, 61(3), 539–544.
+
+Schmidt, P., & Witte, A. D. (1989). Predicting criminal recidivism using
+"split population" survival time models. *Journal of Econometrics*, 40(1),
+141–159.
+
+Yamaguchi, K. (1992). Accelerated failure-time regression models with a
+regression model of surviving fraction: An application to the analysis of
+"permanent employment" in Japan. *Journal of the American Statistical
+Association*, 87(418), 284–292.
+
+Yamaguchi, K., & Ferguson, L. R. (1995). The stopping and spacing of
+childbirths and their birth-history predictors: Rational-choice theory and
+event-history analysis. *American Sociological Review*, 60(2), 272–298.
+
+Yamaguchi, K. (1998). Mover-stayer models for analyzing event nonoccurrence
+and event timing with time-dependent covariates: An application to an
+analysis of remarriage. *Sociological Methodology*, 28(1), 327–361.

splitpopsurv-0.1.0/src/splitpopsurv.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/splitpopsurv/__init__.py
+src/splitpopsurv/models.py
+src/splitpopsurv.egg-info/PKG-INFO
+src/splitpopsurv.egg-info/SOURCES.txt
+src/splitpopsurv.egg-info/dependency_links.txt
+src/splitpopsurv.egg-info/requires.txt
+src/splitpopsurv.egg-info/top_level.txt
+tests/test_models.py

splitpopsurv-0.1.0/src/splitpopsurv.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

splitpopsurv-0.1.0/src/splitpopsurv.egg-info/requires.txt

@@ -0,0 +1,6 @@
+numpy>=1.20
+scipy>=1.7
+pandas>=1.3
+
+[test]
+pytest>=7.0

splitpopsurv-0.1.0/src/splitpopsurv.egg-info/top_level.txt

@@ -0,0 +1 @@
+splitpopsurv

splitpopsurv-0.1.0/tests/test_models.py

@@ -0,0 +1,141 @@
+import numpy as np
+import pandas as pd
+import pytest
+
+from splitpopsurv import (
+    fit_splitpop_loglogistic,
+    fit_splitpop_weibull,
+    fit_splitpop_lognormal,
+    fit_splitpop_gamma,
+    fit_splitpop_ggamma,
+    loglik_splitpop_loglogistic,
+    loglik_splitpop_weibull,
+    loglik_splitpop_lognormal,
+    loglik_splitpop_gamma,
+    loglik_splitpop_ggamma,
+)
+
+
+def make_weibull_data(n=150, seed=1):
+    rng = np.random.default_rng(seed)
+    x1 = rng.normal(size=n)
+    x2 = rng.binomial(1, 0.5, size=n).astype(float)
+    cured = rng.binomial(1, 1 / (1 + np.exp(-(0.2 + 0.5 * x2))), size=n)
+    u = rng.uniform(size=n)
+    t_latent = (-np.log(u) / np.exp(0.5 - 0.4 * x1)) ** (1 / 1.3)
+    censor = rng.exponential(1 / 0.2, size=n)
+    time = np.where(cured == 1, censor, np.minimum(t_latent, censor))
+    event = np.where(cured == 1, 0, (t_latent <= censor).astype(int))
+    time = np.maximum(time, 1e-3)
+    return pd.DataFrame({"time": time, "event": event, "x1": x1, "x2": x2})
+
+
+@pytest.fixture
+def data():
+    return make_weibull_data()
+
+
+@pytest.mark.parametrize(
+    "fit_fn,kwargs",
+    [
+        (fit_splitpop_loglogistic, {}),
+        (fit_splitpop_weibull, {}),
+        (fit_splitpop_lognormal, {}),
+        (fit_splitpop_gamma, {"h_vars": []}),
+        (fit_splitpop_ggamma, {}),
+    ],
+)
+def test_all_distributions_converge(data, fit_fn, kwargs):
+    h_vars = kwargs.pop("h_vars", ["x1"])
+    res = fit_fn(data, "time", "event", h_vars, ["x2"], **kwargs)
+    assert res.converged
+    assert np.isfinite(res.loglik)
+    assert not np.any(np.isnan(res.params))
+
+
+def test_parameter_naming_convention(data):
+    res = fit_splitpop_weibull(data, "time", "event", ["x1"], ["x2"])
+    assert any(n.startswith("H_regression:") for n in res.param_names)
+    assert any(n.startswith("P_regression:") for n in res.param_names)
+    assert "ln_sigma" in res.param_names
+
+
+def test_group_default_matches_explicit_all_ones(data):
+    data2 = data.copy()
+    data2["grp"] = 1
+    res_default = fit_splitpop_weibull(data, "time", "event", ["x1"], ["x2"])
+    res_explicit = fit_splitpop_weibull(data2, "time", "event", ["x1"], ["x2"], group="grp")
+    np.testing.assert_allclose(res_default.params, res_explicit.params, rtol=1e-4)
+
+
+def test_corrected_likelihood_recovers_known_weibull_parameters():
+    """Regression guard for the likelihood correction (larger n for a
+    tight tolerance -- mirrors the same check done for the R and Stata
+    ports of this exact model)."""
+    rng = np.random.default_rng(42)
+    n = 20000
+    x1 = rng.normal(size=n)
+    x2 = rng.binomial(1, 0.5, size=n).astype(float)
+    beta0, beta1, shape = 0.5, -0.4, 1.3
+    alpha0, alpha1 = 0.2, 0.8
+    theta1 = beta0 + beta1 * x1
+    cured = rng.binomial(1, 1 / (1 + np.exp(-(alpha0 + alpha1 * x2))), size=n)
+    u = rng.uniform(size=n)
+    t_latent = (-np.log(u) / np.exp(theta1)) ** (1 / shape)
+    censor = rng.exponential(1 / 0.05, size=n)
+    time = np.where(cured == 1, censor, np.minimum(t_latent, censor))
+    event = np.where(cured == 1, 0, (t_latent <= censor).astype(int))
+    time = np.maximum(time, 1e-4)
+    df = pd.DataFrame({"time": time, "event": event, "x1": x1, "x2": x2})
+
+    res = fit_splitpop_weibull(df, "time", "event", ["x1"], ["x2"])
+    est = dict(zip(res.param_names, res.params))
+
+    assert abs(est["H_regression:Intercept"] - beta0) < 0.1
+    assert abs(est["H_regression:x1"] - beta1) < 0.1
+    assert abs(est["P_regression:Intercept"] - alpha0) < 0.1
+    assert abs(est["P_regression:x2"] - alpha1) < 0.15
+
+
+def test_loglik_functions_return_finite_correctly_sized_vectors():
+    rng = np.random.default_rng(2)
+    n = 30
+    Xh = np.column_stack([np.ones(n), rng.normal(size=n)])
+    Xp = np.column_stack([np.ones(n), rng.binomial(1, 0.5, size=n).astype(float)])
+    time = rng.uniform(0.1, 5, size=n)
+    event = rng.binomial(1, 0.7, size=n).astype(float)
+    group = np.ones(n)
+
+    ll1 = loglik_splitpop_loglogistic(np.array([0, 0, 1, 0, 0], dtype=float), time, event, group, Xh, Xp)
+    ll2 = loglik_splitpop_weibull(np.array([0, 0, 0, 0, 0], dtype=float), time, event, group, Xh, Xp)
+    ll3 = loglik_splitpop_lognormal(np.array([0, 0, 0, 0, 0], dtype=float), time, event, group, Xh, Xp)
+    ll4 = loglik_splitpop_gamma(np.array([1, 0, 1, 0, 0], dtype=float), time, event, group, Xh, Xp)
+    ll5 = loglik_splitpop_ggamma(np.array([0, 0, 0, 1, 0, 0], dtype=float), time, event, group, Xh, Xp)
+
+    for ll in (ll1, ll2, ll3, ll4, ll5):
+        assert len(ll) == n
+        assert np.all(np.isfinite(ll))
+
+
+def test_censored_observation_never_depends_on_mover_density_term():
+    """Regression guard for the likelihood correction: for a censored
+    observation (event=0), the contribution must equal log(marginal
+    survival) exactly, regardless of how extreme the mover hazard/density
+    is at that duration."""
+    Xh = np.array([[1.0, 0.0]])
+    Xp = np.array([[1.0, 0.0]])
+    ll = loglik_splitpop_weibull(
+        np.array([0, 0, 0, 0, 0], dtype=float),
+        time=np.array([1e6]), event=np.array([0.0]),
+        group=np.array([1.0]), Xh=Xh, Xp=Xp,
+    )
+    assert np.isfinite(ll[0])
+
+
+def test_summary_and_dataframe_accessors(data):
+    res = fit_splitpop_weibull(data, "time", "event", ["x1"], ["x2"])
+    text = res.summary()
+    assert "weibull" in text
+    df = res.as_dataframe()
+    assert list(df.columns) == ["coef", "std err", "z", "P>|z|"]
+    assert len(df) == len(res.param_names)