coxdev 0.1.6__tar.gz → 0.1.7__tar.gz

{coxdev-0.1.6 → coxdev-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: coxdev
-Version: 0.1.6
+Version: 0.1.7
 Summary: Library for computing Cox deviance
 Keywords: Cox model
 Author-Email: Jonathan Taylor <jonathan.taylor@stanford.edu>, Trevor Hastie <hastie@stanford.edu>, Balasubramanian Narasimhan <naras@stanford.edu>

{coxdev-0.1.6 → coxdev-0.1.7}/doc/main.tex

@@ -47,10 +47,12 @@
 
 % ------------------------------------------------------------------------------
 
+\title{Some notes on the score and Hessian of weighted Cox's proportional hazards with ties}
+\author{Trevor Hastie, Balasubrmianian Narasimhan, Jonathan Taylor} % Replace with the actual author's name
+\date{April 13, 2026}
+
 \begin{document}
 
-\title{Some notes on the score and Hessian of  weighted
-Cox's proportional hazards with ties}
 
 \maketitle
 
@@ -83,8 +85,10 @@ the distinction between a start time equalling $t_i$ or not irrelevant.
 
 {\bf We'll assume that we've sorted things
 by event time. That is, $j > i \implies t_j > t_i$. As
-we have no ties in this section, we can recover "disk order"
-by reversing the sort. }
+we have no ties in this section, we can recover ``disk order''
+by reversing the sort. More generally, with ties we'll assume that
+$j > i \implies t_j \geq t_i$ and that tied event and start times
+will be sorted in an arbitrary but fixed order. Therefore, we can unambiguously map between this fixed order and ``disk order''.}
 
 \subsection{Right censored}
 % ------------------------------------------------------------------------------
@@ -93,7 +97,7 @@ Ignoring the linear term, and sign,  we need to differentiate (by $\eta_k$)
 \begin{equation}
    \sum_{i = 1}^n d_i w_i \log \left(\sum_{j \geq i} w_j e^{\eta_j}\right)
 \end{equation}
-Below, $d_i=\text{status}_i$ so it is always binary. Ties will be dealt with shortly.
+Below, $d_i=\text{status}_i$ so it will always be binary even in the presence of ties. Ties will be dealt with shortly.
 
 % ------------------------------------------------------------------------------
 % Reference and Cited Works
@@ -263,9 +267,11 @@ $$
 \pi_{i,\eta}[r] \pi_{i,\eta}[c] \right).
 $$
 
-\section{Ties}
+{\bf This also tells us about saturated log-likelihood by considering multinomials of successive risk sets.}
+
+\section{Ties and zero weights}
 
-{\bf We'll assume that we've picked an arbitrary
+{\bf As mentioned previously, we'll assume that we've picked an arbitrary
 sort of event times
 by event time. That is, $j \geq i \implies t_j \geq t_i$. We can recover ``disk order''
 by inverting this particular sort. So series indexed by $i$
@@ -278,7 +284,7 @@ hypothetical ordering of the events were given, then the
 risk sums for each failure at some time be computed.
 
 This is usually not done exactly. The Breslow and Efron methods
-"approximate" this computation of risk sums in a certain sense. 
+``approximate'' this computation of risk sums in a certain sense. 
 The two methods proceed essentially as above, i.e.
 computing a risk sum for each individual and then
 compute the log of the risk sum.
@@ -291,7 +297,7 @@ failures at a given obsered failure time.
 The linear term clearly has no issue,
 it is the sum of log risk sums that needs to be addressed. For this, we rewrite the log-likelihood as
 $$
-\sum_{i=1}^n d_i \left[w_i  \eta_i - \bar{w}_i \log \left( \bar{R}_i(we^{\eta}) \right) \right].
+\sum_{i=1, w_i > 0}^n d_i \left[w_i  \eta_i - \bar{w}_i \log \left( \bar{R}_i(we^{\eta}) \right) \right].
 $$
 
 As above, we recall that we restricted $d_i \in \{0,1\}$. Again,
@@ -564,6 +570,60 @@ $$
 \sum_{i=1}^n d_i \bar{w}_i  (\xi_r - E_{i,\eta}[\xi]) \pi_{i,\eta}[r] 
 $$
 
+\appendix
+\section{Proofs of Lemmas}
+
+\subsection*{Proof of Lemma \ref{lem:forward}}
+\begin{proof}
+Consider the evaluation of the risk sum for an individual $i$ that experiences an event ($d_i = 1$). The sum can be decomposed into two parts based on the definition of the risk set at time $t_i$, which includes all individuals $j$ such that $s_j < t_i \leq t_j$:
+$$
+\sum_{j: s_j < t_i \leq t_j} Z_j = \sum_{j: t_j \geq t_i} Z_j - \sum_{m: s_m \geq t_i, t_m \geq t_i} Z_m.
+$$
+Because the start time $s_m$ is always strictly less than the event time $t_m$ ($s_m < t_m$), the condition $s_m \geq t_i$ naturally implies $t_m \geq t_i$. Thus, the second sum simplifies:
+$$
+\sum_{j: s_j < t_i \leq t_j} Z_j = \sum_{j: t_j \geq t_i} Z_j - \sum_{m: s_m \geq t_i} Z_m.
+$$
+
+Let us assume 0-based indexing for the sequences. The sequence $Z$ is sorted in ascending order of event times $t$. The index ${\tt first}(i)$ represents the first occurrence of the event time $t_i$ in this sorted sequence. Therefore, summing $Z_j$ for all $j$ where $t_j \geq t_i$ is equivalent to summing the sequence from index ${\tt first}(i)$ to the end ($n-1$). By definition, the reversed cumsum $E(Z)_{{\tt first}(i)}$ computes exactly this quantity.
+
+Similarly, let $S(Z)$ be the reversed cumsum of $Z$ sorted by start times $s$. The quantity ${\tt eventmap}(i) = \#\{j : s_j < t_i\}$ gives the exact number of start times strictly less than $t_i$. In a 0-based indexed array sorted by start times, the indices $0, 1, \dots, {\tt eventmap}(i)-1$ correspond to $s_m < t_i$, and the indices from ${\tt eventmap}(i)$ onwards correspond to $s_m \geq t_i$. Thus, the reversed cumsum $S(Z)_{{\tt eventmap}(i)}$ computes the sum of $Z_m$ for $s_m \geq t_i$. 
+
+Multiplying by $d_i$ (which trivially yields $0$ on both sides if $d_i=0$) establishes the first equality:
+$$
+d_i \cdot \left( \sum_{j: t_j \geq t_i} Z_j - \sum_{m: s_m \geq t_i} Z_m \right) = d_i  \cdot \left( E(Z)_{{\tt first}(i)} - S(Z)_{{\tt eventmap}(i)} \right).
+$$
+
+For the second part of the Lemma, recall the definition of $\bar{R}_i(\xi)$ from Equation \ref{eq:risk:sum}:
+$$
+\bar{R}_i(Z) = \sum_{j: t_j \geq t_i} Z_j - \sum_{m: s_m \geq t_i} Z_m - \delta \cdot \sigma_i \cdot \Delta_i(Z)
+$$
+where $\Delta_i(Z) = \sum_{j: C_j=C_i} Z_j$ is the sum over the cluster of tied event times at $t_i$. The cluster spans indices from ${\tt first}(i)$ to ${\tt last}(i)$. In terms of the reversed cumsum $E(Z)$, the sum over this finite slice is simply $E(Z)_{{\tt first}(i)} - E(Z)_{{\tt last}(i)+1}$. Substituting this difference into the expression for $\bar{R}_i(Z)$ yields:
+$$
+\bar{r}_i'Z = E(Z)_{{\tt first}(i)} - S(Z)_{{\tt eventmap}(i)} - \delta \cdot \sigma_i  \cdot \left( E(Z)_{{\tt first}(i)} - E(Z)_{{\tt last}(i)+1} \right),
+$$
+which concludes the proof.
+\end{proof}
+
+\subsection*{Proof of Lemma \ref{lem:adjoint}}
+\begin{proof}
+We want to evaluate the sum $\sum_{i=1}^n d_i Z_i (1_{\{t_k \geq t_i\}} - 1_{\{s_k \geq t_i\}})$. The indicator $(1_{\{t_k \geq t_i\}} - 1_{\{s_k \geq t_i\}})$ equals $1$ if and only if $s_k < t_i \leq t_k$, and is $0$ otherwise. Thus, the sum effectively accumulates $d_i Z_i$ over the interval $(s_k, t_k]$.
+
+Assuming 0-based indexing for the arrays sorted by event time $t$, let us identify the bounds of this interval in terms of the sequence indices. 
+The upper bound is defined by $t_i \leq t_k$. In the sorted array, the elements satisfying this condition occupy indices $0$ through ${\tt last}(k)$. The total number of such elements is ${\tt last}(k) + 1$.
+The lower bound is defined by $s_k < t_i$, which means we exclude elements where $t_i \leq s_k$. The number of elements with $t_i \leq s_k$ is precisely given by ${\tt startmap}(k) = \#\{j : t_j \leq s_k\}$. Thus, the excluded indices are $0$ through ${\tt startmap}(k) - 1$.
+
+Consequently, the interval $s_k < t_i \leq t_k$ corresponds exactly to the index range $i \in \{{\tt startmap}(k), \dots, {\tt last}(k)\}$.
+
+Let $\bar{E}(d \cdot Z)$ denote the forward cumsum sequence of $d \cdot Z$, padded with a $0$ at the 0-th index. That is, $\bar{E}(d \cdot Z)_m = \sum_{i=0}^{m-1} d_i Z_i$.
+Using this forward cumsum, the sum over our target index range can be computed as the difference between the sum up to ${\tt last}(k)$ and the sum up to ${\tt startmap}(k)-1$:
+$$
+\sum_{i={\tt startmap}(k)}^{{\tt last}(k)} d_i Z_i = \bar{E}(d \cdot Z)_{{\tt last}(k)+1} - \bar{E}(d \cdot Z)_{{\tt startmap}(k)}.
+$$
+This establishes the first equality. 
+
+The second equality, ${\tt startmap}(k) = {\tt first}({\tt startmap}(k))$, holds because all individuals $j$ that share the exact same event time $t_j = s_k$ must either entirely fall within or outside the threshold boundary. Hence, the index count maps cleanly to the ${\tt first}$ function of that start boundary, ensuring numerical stability in implementations with ties.
+\end{proof}
+
 \end{document}
 
 \section{Blah}
@@ -682,4 +742,58 @@ $$
 m(k)=
 \max(\text{start}(k),{\tt first}(k)-1).$$
 
- \end{document}
+ \appendix
+\section{Proofs of Lemmas}
+
+\subsection*{Proof of Lemma \ref{lem:forward}}
+\begin{proof}
+Consider the evaluation of the risk sum for an individual $i$ that experiences an event ($d_i = 1$). The sum can be decomposed into two parts based on the definition of the risk set at time $t_i$, which includes all individuals $j$ such that $s_j < t_i \leq t_j$:
+$$
+\sum_{j: s_j < t_i \leq t_j} Z_j = \sum_{j: t_j \geq t_i} Z_j - \sum_{m: s_m \geq t_i, t_m \geq t_i} Z_m.
+$$
+Because the start time $s_m$ is always strictly less than the event time $t_m$ ($s_m < t_m$), the condition $s_m \geq t_i$ naturally implies $t_m \geq t_i$. Thus, the second sum simplifies:
+$$
+\sum_{j: s_j < t_i \leq t_j} Z_j = \sum_{j: t_j \geq t_i} Z_j - \sum_{m: s_m \geq t_i} Z_m.
+$$
+
+Let us assume 0-based indexing for the sequences. The sequence $Z$ is sorted in ascending order of event times $t$. The index ${\tt first}(i)$ represents the first occurrence of the event time $t_i$ in this sorted sequence. Therefore, summing $Z_j$ for all $j$ where $t_j \geq t_i$ is equivalent to summing the sequence from index ${\tt first}(i)$ to the end ($n-1$). By definition, the reversed cumsum $E(Z)_{{\tt first}(i)}$ computes exactly this quantity.
+
+Similarly, let $S(Z)$ be the reversed cumsum of $Z$ sorted by start times $s$. The quantity ${\tt eventmap}(i) = \#\{j : s_j < t_i\}$ gives the exact number of start times strictly less than $t_i$. In a 0-based indexed array sorted by start times, the indices $0, 1, \dots, {\tt eventmap}(i)-1$ correspond to $s_m < t_i$, and the indices from ${\tt eventmap}(i)$ onwards correspond to $s_m \geq t_i$. Thus, the reversed cumsum $S(Z)_{{\tt eventmap}(i)}$ computes the sum of $Z_m$ for $s_m \geq t_i$. 
+
+Multiplying by $d_i$ (which trivially yields $0$ on both sides if $d_i=0$) establishes the first equality:
+$$
+d_i \cdot \left( \sum_{j: t_j \geq t_i} Z_j - \sum_{m: s_m \geq t_i} Z_m \right) = d_i  \cdot \left( E(Z)_{{\tt first}(i)} - S(Z)_{{\tt eventmap}(i)} \right).
+$$
+
+For the second part of the Lemma, recall the definition of $\bar{R}_i(\xi)$ from Equation \ref{eq:risk:sum}:
+$$
+\bar{R}_i(Z) = \sum_{j: t_j \geq t_i} Z_j - \sum_{m: s_m \geq t_i} Z_m - \delta \cdot \sigma_i \cdot \Delta_i(Z)
+$$
+where $\Delta_i(Z) = \sum_{j: C_j=C_i} Z_j$ is the sum over the cluster of tied event times at $t_i$. The cluster spans indices from ${\tt first}(i)$ to ${\tt last}(i)$. In terms of the reversed cumsum $E(Z)$, the sum over this finite slice is simply $E(Z)_{{\tt first}(i)} - E(Z)_{{\tt last}(i)+1}$. Substituting this difference into the expression for $\bar{R}_i(Z)$ yields:
+$$
+\bar{r}_i'Z = E(Z)_{{\tt first}(i)} - S(Z)_{{\tt eventmap}(i)} - \delta \cdot \sigma_i  \cdot \left( E(Z)_{{\tt first}(i)} - E(Z)_{{\tt last}(i)+1} \right),
+$$
+which concludes the proof.
+\end{proof}
+
+\subsection*{Proof of Lemma \ref{lem:adjoint}}
+\begin{proof}
+We want to evaluate the sum $\sum_{i=1}^n d_i Z_i (1_{\{t_k \geq t_i\}} - 1_{\{s_k \geq t_i\}})$. The indicator $(1_{\{t_k \geq t_i\}} - 1_{\{s_k \geq t_i\}})$ equals $1$ if and only if $s_k < t_i \leq t_k$, and is $0$ otherwise. Thus, the sum effectively accumulates $d_i Z_i$ over the interval $(s_k, t_k]$.
+
+Assuming 0-based indexing for the arrays sorted by event time $t$, let us identify the bounds of this interval in terms of the sequence indices. 
+The upper bound is defined by $t_i \leq t_k$. In the sorted array, the elements satisfying this condition occupy indices $0$ through ${\tt last}(k)$. The total number of such elements is ${\tt last}(k) + 1$.
+The lower bound is defined by $s_k < t_i$, which means we exclude elements where $t_i \leq s_k$. The number of elements with $t_i \leq s_k$ is precisely given by ${\tt startmap}(k) = \#\{j : t_j \leq s_k\}$. Thus, the excluded indices are $0$ through ${\tt startmap}(k) - 1$.
+
+Consequently, the interval $s_k < t_i \leq t_k$ corresponds exactly to the index range $i \in \{{\tt startmap}(k), \dots, {\tt last}(k)\}$.
+
+Let $\bar{E}(d \cdot Z)$ denote the forward cumsum sequence of $d \cdot Z$, padded with a $0$ at the 0-th index. That is, $\bar{E}(d \cdot Z)_m = \sum_{i=0}^{m-1} d_i Z_i$.
+Using this forward cumsum, the sum over our target index range can be computed as the difference between the sum up to ${\tt last}(k)$ and the sum up to ${\tt startmap}(k)-1$:
+$$
+\sum_{i={\tt startmap}(k)}^{{\tt last}(k)} d_i Z_i = \bar{E}(d \cdot Z)_{{\tt last}(k)+1} - \bar{E}(d \cdot Z)_{{\tt startmap}(k)}.
+$$
+This establishes the first equality. 
+
+The second equality, ${\tt startmap}(k) = {\tt first}({\tt startmap}(k))$, holds because all individuals $j$ that share the exact same event time $t_j = s_k$ must either entirely fall within or outside the threshold boundary. Hence, the index count maps cleanly to the ${\tt first}$ function of that start boundary, ensuring numerical stability in implementations with ties.
+\end{proof}
+
+\end{document}

{coxdev-0.1.6 → coxdev-0.1.7}/python/coxdev/base.py

@@ -278,8 +278,8 @@ class CoxInformation(LinearOperator):
     def __post_init__(self):
         """Initialize the linear operator dimensions."""
         n = self.result.linear_predictor.shape[0]
-        self.shape = (n, n)
-        self.dtype = float
+        # sets shape and dtype (and, in SciPy >= 1.18, the array namespace used by @)
+        LinearOperator.__init__(self, dtype=float, shape=(n, n))
         
     def _matvec(self, arg):
         """

{coxdev-0.1.6 → coxdev-0.1.7}/tests/conftest.py

@@ -9,6 +9,45 @@ def pytest_addoption(parser):
         help="test size: how many of cumsum and compareR tests to run (-1 indicates all)",
     )
 
+
+@pytest.fixture(scope='session')
+def Rinfo():
+    val = {}
+    try:
+        import rpy2.robjects as rpy
+        val['rpy'] = rpy
+        val['has_rpy2'] = True
+    except ImportError:
+        pytest.skip('rpy2 is not importable')
+        val['has_rpy2'] = False
+        return val
+    
+    from rpy2.robjects.packages import importr
+    from rpy2.robjects import numpy2ri, pandas2ri
+    from rpy2.robjects import default_converter
+    from rpy2.robjects.vectors import FloatVector, IntVector
+    from rpy2.robjects import Formula
+    from rpy2.robjects import DataFrame
+
+    val['rpy'] = rpy
+    val['importr'] = importr
+    val['numpy2ri'] = numpy2ri
+    val['default_converter'] = default_converter
+    val['FloatVector'] = FloatVector
+    val['IntVector'] = IntVector
+    val['Formula'] = Formula
+    val['DataFrame'] = DataFrame
+
+    val['np_cv_rules'] = default_converter + numpy2ri.converter + pandas2ri.converter
+    np_cv_rules = val['np_cv_rules']
+    
+    val['glmnetR'] = importr('glmnet')
+    val['baseR'] = importr('base')
+    val['statR'] = importr('stats')
+    val['survivalR'] = importr('survival')
+
+    return val
+
 def pytest_collection_modifyitems(config, items):
     test_size = config.getoption("--test-size")
     if test_size >= 0:

{coxdev-0.1.6 → coxdev-0.1.7}/tests/simulate.py

@@ -4,7 +4,7 @@ import numpy as np
 import pandas as pd
 
 # basic model for times
-rng = np.random.default_rng(0)
+rng = np.random.default_rng(10)
 def sample_weights(size=1):
     W = rng.poisson(2, size=size) + rng.uniform(size=size)
     W[size//3] += 2.

{coxdev-0.1.6 → coxdev-0.1.7}/tests/stratified.py

@@ -265,8 +265,8 @@ class StratifiedCoxInformationTest(LinearOperator):
     def __post_init__(self):
         """Initialize the linear operator dimensions."""
         n = len(self.result.linear_predictor)
-        self.shape = (n, n)
-        self.dtype = float
+        # sets shape and dtype (and, in SciPy >= 1.18, the array namespace used by @)
+        LinearOperator.__init__(self, dtype=float, shape=(n, n))
         
     def _matvec(self, arg):
         """

{coxdev-0.1.6 → coxdev-0.1.7}/tests/test_compareR.py

@@ -2,32 +2,6 @@ import numpy as np
 import pandas as pd
 from coxdev import CoxDeviance, CoxDeviance
 
-try:
-    import rpy2.robjects as rpy
-    has_rpy2 = True
-except: # which exception a bit hard to predict
-    has_rpy2 = False
-    has_glmnet = False
-    
-if has_rpy2:
-    from rpy2.robjects.packages import importr
-    from rpy2.robjects import numpy2ri
-    from rpy2.robjects import default_converter
-
-    np_cv_rules = default_converter + numpy2ri.converter
-
-    rpy.r('''if (!require("glmnet", character.only = TRUE)) {
-  install.packages("glmnet")
-    }''')
-
-    try:
-        glmnetR = importr('glmnet')
-        has_glmnet = True
-    except: 
-        has_glmnet = False
-    baseR = importr('base')
-    survivalR = importr('survival')
-
 import pytest
 from .simulate import (simulate_df,
                        all_combos,
@@ -35,11 +9,32 @@ from .simulate import (simulate_df,
                        sample_weights,
                        sample_weights_zeros)
 
+def numpy_to_r_matrix(Rinfo, X):
+    """
+    Convert a 2D numpy array to an R matrix.
+    
+    Ensures proper row/column major ordering during the conversion.
+    
+    Parameters
+    ----------
+    X : np.ndarray
+        The 2D numpy array to convert.
+        
+    Returns
+    -------
+    rpy.r.matrix
+        The corresponding R matrix object.
+    """
+    rpy = Rinfo["rpy"]
+    FloatVector = Rinfo["FloatVector"]
+    return rpy.r.matrix(FloatVector(X.T.flatten()), nrow=X.shape[0], ncol=X.shape[1])
+
 def get_glmnet_result(event,
                       status,
                       start,
                       eta,
                       weight,
+                      Rinfo,
                       time=False):
 
     event = np.asarray(event)
@@ -47,7 +42,12 @@ def get_glmnet_result(event,
     weight = np.asarray(weight)
     eta = np.asarray(eta)
 
-    with np_cv_rules.context():
+    if not Rinfo.get('has_rpy2'):
+        pytest.skip('requires rpy2')
+    rpy = Rinfo['rpy']
+
+
+    with Rinfo['np_cv_rules'].context():
 
         rpy.r.assign('status', status)
         rpy.r.assign('event', event)
@@ -83,6 +83,7 @@ def get_coxph(event,
               X,
               beta,
               sample_weight,
+              Rinfo,
               start=None,
               ties='efron'):
 
@@ -91,7 +92,9 @@ def get_coxph(event,
     status = np.asarray(status)
     event = np.asarray(event)
 
-    with np_cv_rules.context():
+    rpy = Rinfo['rpy']
+
+    with Rinfo['np_cv_rules'].context():
         rpy.r.assign('status', status)
         rpy.r.assign('event', event)
         rpy.r.assign('X', X)
@@ -104,7 +107,7 @@ def get_coxph(event,
             rpy.r('y = Surv(start, event, status)')
         else:
             rpy.r('y = Surv(event, status)')
-        rpy.r('F = coxph(y ~ X, init=beta, weights=sample_weight, control=coxph.control(iter.max=0), ties=ties, robust=FALSE)')
+        rpy.r('F = coxph(y ~ X, init=beta, weights=sample_weight, control=coxph.control(iter.max=0), ties=ties, robust=FALSE, timefix=FALSE)')
         rpy.r('score = colSums(coxph.detail(F)$scor)')
         G = rpy.r('score')
         D = rpy.r('F$loglik')
@@ -118,6 +121,7 @@ def get_stratified_coxph(event,
                          X,
                          beta,
                          sample_weight,
+                         Rinfo,
                          start=None,
                          ties='efron'):
     """Get stratified Cox model results from R's survival package."""
@@ -128,7 +132,9 @@ def get_stratified_coxph(event,
     event = np.asarray(event)
     strata = np.asarray(strata).astype(np.int32)
 
-    with np_cv_rules.context():
+    rpy = Rinfo['rpy']
+
+    with Rinfo['np_cv_rules'].context():
         rpy.r.assign('status', status)
         rpy.r.assign('event', event)
         rpy.r.assign('strata', strata)
@@ -145,7 +151,7 @@ def get_stratified_coxph(event,
         else:
             rpy.r('y = Surv(event, status)')
             
-        rpy.r('F = coxph(y ~ X + strata(strata), init=beta, weights=sample_weight, control=coxph.control(iter.max=0), ties=ties, robust=FALSE)')
+        rpy.r('F = coxph(y ~ X + strata(strata), init=beta, weights=sample_weight, control=coxph.control(iter.max=0), ties=ties, robust=FALSE, timefix=FALSE)')
         rpy.r('score = colSums(coxph.detail(F)$scor)')
         G = rpy.r('score')
         D = rpy.r('F$loglik')
@@ -186,7 +192,6 @@ def create_stratified_data(n_samples=100, n_strata=3):
     }
 
 
-@pytest.mark.skipif(not has_rpy2, reason='rpy2 not available')
 @pytest.mark.parametrize('tie_types', all_combos)
 @pytest.mark.parametrize('tie_breaking', ['efron', 'breslow'])
 @pytest.mark.parametrize('sample_weight', [np.ones, sample_weights, sample_weights_zeros])
@@ -195,6 +200,7 @@ def test_coxph(tie_types,
                tie_breaking,
                sample_weight,
                have_start_times,
+               Rinfo,
                nrep=5,
                size=5,
                tol=1e-10):
@@ -241,6 +247,7 @@ def test_coxph(tie_types,
                             sample_weight=weight[keep],
                             start=start_keep,
                             ties=tie_breaking,
+                            Rinfo=Rinfo,
                             X=X[keep])
 
     assert np.allclose(D_coxph[0], C.deviance - 2 * C.loglik_sat)
@@ -248,7 +255,8 @@ def test_coxph(tie_types,
     assert delta_ph < tol
     assert np.linalg.norm(cov_ - cov_coxph) / np.linalg.norm(cov_) < tol
 
-def test_simple(nrep=5,
+def test_simple(Rinfo,
+                nrep=5,
                 size=5,
                 tol=1e-10):
     test_coxph(all_combos[-1],
@@ -257,16 +265,17 @@ def test_simple(nrep=5,
                True,
                nrep=5,
                size=5,
+               Rinfo=Rinfo,
                tol=1e-10)
     
 
-@pytest.mark.skipif(not has_glmnet, reason='glmnet not available')
 @pytest.mark.parametrize('tie_types', all_combos)
 @pytest.mark.parametrize('sample_weight', [np.ones, sample_weights])
 @pytest.mark.parametrize('have_start_times', [True, False])
 def test_glmnet(tie_types,
                 sample_weight,
                 have_start_times,
+                Rinfo,
                 nrep=5,
                 size=5,
                 tol=1e-10):
@@ -287,7 +296,8 @@ def test_glmnet(tie_types,
                                       data['status'],
                                       start,
                                       eta,
-                                      weight)
+                                      weight,
+                                      Rinfo=Rinfo)
 
     coxdev = CoxDeviance(event=data['event'],
                          start=start,
@@ -308,10 +318,14 @@ def test_glmnet(tie_types,
 @pytest.mark.parametrize('tie_breaking', ['efron', 'breslow'])
 @pytest.mark.parametrize('have_start_times', [True, False])
 @pytest.mark.parametrize('n_strata', [2, 3, 5])
-def test_stratified_coxph(tie_breaking, have_start_times, n_strata, tol=1e-10):
+def test_stratified_coxph(tie_breaking,
+                          have_start_times,
+                          n_strata,
+                          Rinfo,
+                          tol=1e-10):
     """Test CoxDeviance against R's stratified coxph."""
     
-    if not has_rpy2:
+    if not Rinfo['has_rpy2']:
         pytest.skip("rpy2 not available")
     
     # Create stratified data
@@ -350,7 +364,8 @@ def test_stratified_coxph(tie_breaking, have_start_times, n_strata, tol=1e-10):
         beta=data['beta'],
         sample_weight=data['weight'],
         start=start,
-        ties=tie_breaking
+        ties=tie_breaking,
+        Rinfo=Rinfo
     )
     
     # Compare deviance (adjust for saturated log-likelihood)
@@ -365,57 +380,11 @@ def test_stratified_coxph(tie_breaking, have_start_times, n_strata, tol=1e-10):
     assert np.linalg.norm(cov_ - cov_coxph) / np.linalg.norm(cov_) < tol
 
 
-@pytest.mark.parametrize('tie_breaking', ['efron', 'breslow'])
-@pytest.mark.parametrize('have_start_times', [True, False])
-def test_stratified_single_stratum(tie_breaking, have_start_times, tol=1e-10):
-    """Test that CoxDeviance with single stratum matches CoxDeviance."""
-    
-    if not has_rpy2:
-        pytest.skip("rpy2 not available")
-    
-    # Create data with single stratum
-    data = create_stratified_data(n_samples=100, n_strata=1)
-    
-    if have_start_times:
-        start = data['start']
-    else:
-        start = None
-    
-    # Create both models
-    coxdev = CoxDeviance(
-        event=data['event'],
-        start=start,
-        status=data['status'],
-        tie_breaking=tie_breaking
-    )
-    
-    stratdev = CoxDeviance(
-        event=data['event'],
-        start=start,
-        status=data['status'],
-        strata=data['strata'],
-        tie_breaking=tie_breaking
-    )
-    
-    # Compute results
-    eta = data['X'] @ data['beta']
-    C1 = coxdev(eta, data['weight'])
-    C2 = stratdev(eta, data['weight'])
-    
-    # Results should be identical
-    assert np.allclose(C1.deviance, C2.deviance, rtol=tol)
-    assert np.allclose(C1.gradient, C2.gradient, rtol=tol)
-    assert np.allclose(C1.diag_hessian, C2.diag_hessian, rtol=tol)
-    assert np.allclose(C1.loglik_sat, C2.loglik_sat, rtol=tol)
-
 
 @pytest.mark.parametrize('tie_breaking', ['efron', 'breslow'])
-def test_stratified_multiple_strata_sizes(tie_breaking, tol=1e-10):
+def test_stratified_multiple_strata_sizes(tie_breaking, Rinfo, tol=1e-10):
     """Test CoxDeviance with varying stratum sizes."""
     
-    if not has_rpy2:
-        pytest.skip("rpy2 not available")
-    
     # Create data with uneven stratum sizes using create_stratified_data
     n_samples = 200
     n_features = 2
@@ -460,6 +429,7 @@ def test_stratified_multiple_strata_sizes(tie_breaking, tol=1e-10):
         beta=beta,
         sample_weight=weight,
         start=start,
+        Rinfo=Rinfo,
         ties=tie_breaking
     )
     
@@ -467,3 +437,48 @@ def test_stratified_multiple_strata_sizes(tie_breaking, tol=1e-10):
     assert np.allclose(D_coxph[0], C.deviance - 2 * C.loglik_sat, rtol=tol)
     delta_ph = np.linalg.norm(G_coxph - X.T @ C.gradient) / np.linalg.norm(X.T @ C.gradient)
     assert delta_ph < tol
+
+@pytest.mark.parametrize('tie_breaking', ['efron', 'breslow'])
+@pytest.mark.parametrize('have_start_times', [True, False])
+def test_stratified_single_stratum(tie_breaking,
+                                   have_start_times,
+                                   tol=1e-10):
+    """Test that CoxDeviance with single stratum matches CoxDeviance."""
+    
+    # Create data with single stratum
+    data = create_stratified_data(n_samples=100, n_strata=1)
+    
+    if have_start_times:
+        start = data['start']
+    else:
+        start = None
+    
+    # Create both models
+    coxdev = CoxDeviance(
+        event=data['event'],
+        start=start,
+        status=data['status'],
+        tie_breaking=tie_breaking
+    )
+    
+    stratdev = CoxDeviance(
+        event=data['event'],
+        start=start,
+        status=data['status'],
+        strata=data['strata'],
+        tie_breaking=tie_breaking
+    )
+    
+    # Compute results
+    eta = data['X'] @ data['beta']
+    C1 = coxdev(eta, data['weight'])
+    C2 = stratdev(eta, data['weight'])
+    
+    # Results should be identical
+    assert np.allclose(C1.deviance, C2.deviance, rtol=tol)
+    assert np.allclose(C1.gradient, C2.gradient, rtol=tol)
+    assert np.allclose(C1.diag_hessian, C2.diag_hessian, rtol=tol)
+    assert np.allclose(C1.loglik_sat, C2.loglik_sat, rtol=tol)
+
+        
+    

{coxdev-0.1.6 → coxdev-0.1.7}/tests/test_stratified.py

@@ -629,3 +629,4 @@ def test_coxdeviance2_matches_stratified_and_coxdeviance(tie_breaking, use_weigh
         v = rng.standard_normal(n)
         assert np.allclose(info_cox @ v, info_strat @ v)
         assert np.allclose(info_cox @ v, info2 @ v)
+