coxdev 0.1.5__tar.gz → 0.1.7__tar.gz

coxdev-0.1.7/.github/workflows/test.yml

@@ -0,0 +1,51 @@
+# Run all tests
+
+name: Run tests (Linux)
+
+# Controls when the workflow will run
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        python-version: ["3.12"]
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+        fetch-depth: 0
+
+    - name: Set up Python  ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install coxdev
+      run: |
+        pip install --upgrade pip
+        pip install meson-python ninja meson pybind11 setuptools_scm pytest pandas joblib
+        pip install .
+
+    - name: Verify installed source
+      run: |
+        cd /tmp
+        python -c "import coxdev.base; import inspect; print(inspect.getsourcefile(coxdev.base)); print(''.join(open(inspect.getsourcefile(coxdev.base)).readlines()[:20]))"
+
+    - name: Debug Installation
+      run: |
+        cd /tmp
+        python -c "import coxdev; print(f'Location: {coxdev.__file__}'); import os; print(f'Contents: {os.listdir(os.path.dirname(coxdev.__file__))}')"
+
+    - name: Test coxdev
+      run: |
+        mkdir empty_dir
+        cd empty_dir
+        python -m pytest ../tests --test-size=100

{coxdev-0.1.5 → coxdev-0.1.7}/.gitignore

@@ -53,8 +53,3 @@ modules.order
 Module.symvers
 Mkfile.old
 dkms.conf
-
-# Documentation files (generated/private)
-doc/saturated_likelihood_calc.tex
-CLAUDE.md
-2026-02-02-implement-the-following-plan.txt

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: coxdev
-Version: 0.1.5
+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>
@@ -19,7 +19,6 @@ Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pandas; extra == "test"
 Requires-Dist: joblib; extra == "test"
-Requires-Dist: rpy2; extra == "test"
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: scipy; extra == "dev"
@@ -38,7 +37,7 @@ Description-Content-Type: text/markdown
 
 # coxdev
 
-A high-performance Python library for computing Cox proportional hazards model deviance, gradients, and Hessian information matrices. Built with C++ and Eigen for optimal performance, this library provides efficient survival analysis computations with support for different tie-breaking methods.
+A high-performance C++ for computing Cox proportional hazards model deviance, gradients, and Hessian information matrices. Built with Eigen for ease of use in R and Python, this library provides efficient survival analysis computations with support for different tie-breaking methods.
 
 ## Features
 
@@ -60,10 +59,6 @@ This package requires the Eigen C++ library headers. The Eigen library is includ
    git submodule update --init --recursive
    ```
 
-2. **Check Eigen availability**: Run the check script to verify Eigen headers are available:
-   ```bash
-   python check_eigen.py
-   ```
 
 ### Standard Installation
 
@@ -81,7 +76,7 @@ env EIGEN_LIBRARY_PATH=/path/to/eigen pip install .
 ### Development Installation
 
 ```bash
-pip install pybind11 meson-python ninja setuptools_scm
+pip install .[dev]
 pip install -e . --no-build-isolation
 ```
 
@@ -197,44 +192,16 @@ The library is optimized for performance:
 
 ### Prerequisites
 
-- Python 3.9+
 - C++ compiler with C++17 support
 - Eigen library headers
-- pybind11
-
-### Build Steps
-
-1. Clone the repository with submodules:
-   ```bash
-   git clone --recursive https://github.com/jonathan-taylor/coxdev.git
-   cd coxdev
-   ```
-
-2. Install build dependencies:
-   ```bash
-   pip install build wheel setuptools pybind11 numpy
-   ```
-
-3. Build the package:
-   ```bash
-   python -m build
-   ```
+- For Python library: Python >= 3.9 + pybind11
 
-### Building Wheels
-
-For wheel building:
-```bash
-# Standard wheel build
-python -m build
-
-# With custom Eigen path
-env EIGEN_LIBRARY_PATH=/path/to/eigen python -m build
-```
 
 ## Testing
 
 Run the test suite:
 ```bash
+pip install .[test]
 python -m pytest tests/
 ```
 

{coxdev-0.1.5/R_pkg → coxdev-0.1.7/R}/coxdev/DESCRIPTION

@@ -1,6 +1,6 @@
 Package: coxdev
 Title: Package for testing Cox calculations
-Version: 0.5
+Version: 0.2
 Authors@R: c(person("Jonathan", "Taylor", role = c("aut")),
 	     person("Trevor", "Hastie", role = c("aut")),
 	     person("Balasubramanian", "Narasimhan", role = c("aut", "cre"), email = "naras@stanford.edu"))
@@ -8,7 +8,7 @@ Description: Does Cox calculations.
 License: GPL (>= 3)
 Encoding: UTF-8
 Roxygen: list(markdown = TRUE)
-RoxygenNote: 7.3.3
+RoxygenNote: 7.2.3
 Suggests: 
     glmnet,
     knitr,

{coxdev-0.1.5/R_pkg → coxdev-0.1.7/R}/coxdev/NAMESPACE

@@ -1,8 +1,6 @@
 # Generated by roxygen2: do not edit by hand
 
 export(make_cox_deviance)
-export(make_cox_irls_state)
-export(make_stratified_cox_deviance)
 import(RcppEigen)
 importFrom(Rcpp,sourceCpp)
 useDynLib(coxdev, .registration = TRUE)

coxdev-0.1.7/R/coxdev/R/RcppExports.R

@@ -0,0 +1,47 @@
+# Generated by using Rcpp::compileAttributes() -> do not edit by hand
+# Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393
+
+.forward_cumsum <- function(sequence, output) {
+    invisible(.Call(`_coxdev_forward_cumsum`, sequence, output))
+}
+
+.reverse_cumsums <- function(sequence, event_buffer, start_buffer, event_order, start_order, do_event = FALSE, do_start = FALSE) {
+    invisible(.Call(`_coxdev_reverse_cumsums`, sequence, event_buffer, start_buffer, event_order, start_order, do_event, do_start))
+}
+
+.to_native_from_event <- function(arg, event_order, reorder_buffer) {
+    invisible(.Call(`_coxdev_to_native_from_event`, arg, event_order, reorder_buffer))
+}
+
+.to_event_from_native <- function(arg, event_order, reorder_buffer) {
+    invisible(.Call(`_coxdev_to_event_from_native`, arg, event_order, reorder_buffer))
+}
+
+.forward_prework <- function(status, w_avg, scaling, risk_sums, i, j, moment_buffer, arg, use_w_avg = TRUE) {
+    invisible(.Call(`_coxdev_forward_prework`, status, w_avg, scaling, risk_sums, i, j, moment_buffer, arg, use_w_avg))
+}
+
+.compute_sat_loglik <- function(first, last, weight, event_order, status, W_status) {
+    .Call(`_coxdev_compute_sat_loglik`, first, last, weight, event_order, status, W_status)
+}
+
+.sum_over_events <- function(event_order, start_order, first, last, start_map, scaling, status, efron, forward_cumsum_buffers, forward_scratch_buffer, value_buffer) {
+    invisible(.Call(`_coxdev_sum_over_events`, event_order, start_order, first, last, start_map, scaling, status, efron, forward_cumsum_buffers, forward_scratch_buffer, value_buffer))
+}
+
+.sum_over_risk_set <- function(arg, event_order, start_order, first, last, event_map, scaling, efron, risk_sum_buffers, risk_sum_buffers_offset, reverse_cumsum_buffers, reverse_cumsum_buffers_offset) {
+    invisible(.Call(`_coxdev_sum_over_risk_set`, arg, event_order, start_order, first, last, event_map, scaling, efron, risk_sum_buffers, risk_sum_buffers_offset, reverse_cumsum_buffers, reverse_cumsum_buffers_offset))
+}
+
+.cox_dev <- function(eta, sample_weight, exp_w, event_order, start_order, status, first, last, scaling, event_map, start_map, loglik_sat, T_1_term, T_2_term, grad_buffer, diag_hessian_buffer, diag_part_buffer, w_avg_buffer, event_reorder_buffers, risk_sum_buffers, forward_cumsum_buffers, forward_scratch_buffer, reverse_cumsum_buffers, have_start_times = TRUE, efron = FALSE) {
+    .Call(`_coxdev_cox_dev`, eta, sample_weight, exp_w, event_order, start_order, status, first, last, scaling, event_map, start_map, loglik_sat, T_1_term, T_2_term, grad_buffer, diag_hessian_buffer, diag_part_buffer, w_avg_buffer, event_reorder_buffers, risk_sum_buffers, forward_cumsum_buffers, forward_scratch_buffer, reverse_cumsum_buffers, have_start_times, efron)
+}
+
+.hessian_matvec <- function(arg, eta, sample_weight, risk_sums, diag_part, w_avg, exp_w, event_cumsum, start_cumsum, event_order, start_order, status, first, last, scaling, event_map, start_map, risk_sum_buffers, forward_cumsum_buffers, forward_scratch_buffer, reverse_cumsum_buffers, hess_matvec_buffer, have_start_times = TRUE, efron = FALSE) {
+    .Call(`_coxdev_hessian_matvec`, arg, eta, sample_weight, risk_sums, diag_part, w_avg, exp_w, event_cumsum, start_cumsum, event_order, start_order, status, first, last, scaling, event_map, start_map, risk_sum_buffers, forward_cumsum_buffers, forward_scratch_buffer, reverse_cumsum_buffers, hess_matvec_buffer, have_start_times, efron)
+}
+
+.preprocess <- function(start, event, status) {
+    .Call(`_coxdev_preprocess`, start, event, status)
+}
+

coxdev-0.1.7/R/coxdev/R/coxdev.R

@@ -0,0 +1,295 @@
+## #' @export
+## preprocess <- function(start, event, status) {
+##   # Convert inputs to vectors
+##   start <- as.numeric(start)
+##   event <- as.numeric(event)
+##   status <- as.numeric(status)
+##   nevent <- length(status)
+
+##   # Perform stacking of arrays
+##   stacked_time <- c(start, event)
+##   stacked_status_c <- c(rep(1, nevent), 1 - status) # complement of status
+##   stacked_is_start <- c(rep(1, nevent), rep(0, nevent))
+##   stacked_index <- c(seq_len(nevent), seq_len(nevent))
+
+##   # Perform the joint sort
+##   order_indices <- order(stacked_time, stacked_status_c, stacked_is_start)
+##   sorted_time <- stacked_time[order_indices]
+##   sorted_status <- 1 - stacked_status_c[order_indices]
+##   sorted_is_start <- stacked_is_start[order_indices]
+##   sorted_index <- stacked_index[order_indices]
+
+##   # Initialize variables for loop
+##   event_count <- 0
+##   start_count <- 0
+##   event_order <- numeric(0)
+##   start_order <- numeric(0)
+##   start_map <- numeric(0)
+##   event_map <- numeric(0)
+##   first <- numeric(0)
+##   which_event <- -1
+##   first_event <- -1
+##   num_successive_event <- 1
+##   last_row <- NULL
+
+##   # Loop through sorted data
+##   for (i in seq_along(sorted_time)) {
+##     s_time <- sorted_time[i]
+##     s_status <- sorted_status[i]
+##     s_is_start <- sorted_is_start[i]
+##     s_index <- sorted_index[i]
+
+##     if (s_is_start == 1) {
+##       start_order <- c(start_order, s_index)
+##       start_map <- c(start_map, event_count)
+##       start_count <- start_count + 1
+##     } else {
+##       if (s_status == 1) {
+##         if (!is.null(last_row) && s_time != last_row[1]) {
+##           first_event <- first_event + num_successive_event
+##           num_successive_event <- 1
+##           which_event <- which_event + 1
+##         } else {
+##           num_successive_event <- num_successive_event + 1
+##         }
+##         first <- c(first, first_event)
+##       } else {
+##         first_event <- first_event + num_successive_event
+##         num_successive_event <- 1
+##         first <- c(first, first_event)
+##       }
+
+##       event_map <- c(event_map, start_count)
+##       event_order <- c(event_order, s_index)
+##       event_count <- event_count + 1
+##     }
+##     last_row <- c(s_time, s_status, s_is_start, s_index)
+##   }
+
+##   # Reset start_map to original order and set to event order
+##   start_map_cp <- start_map
+##   start_map[start_order] <- start_map_cp
+
+##   s_status <- status[event_order]
+##   s_first <- first
+##   s_start_map <- start_map[event_order]
+##   s_event_map <- event_map
+
+##   s_event <- event[event_order]
+##   s_start <- event[start_order]
+
+##   # Compute `last`
+##   last <- numeric(0)
+##   last_event <- nevent - 1
+##   s_first_len <- length(s_first)
+##   for (i in seq_along(s_first)) {
+##     f <- s_first[s_first_len - i + 1]
+##     last <- c(last, last_event)
+##     if (f - (nevent - i) == 0) {
+##       last_event <- f - 1
+##     }
+##   }
+##   s_last <- rev(last)
+
+##   den <- s_last + 1 - s_first
+##   s_scaling <- (seq_len(nevent) - 1 - s_first) / den
+
+##   # Prepare the output list
+##   preproc <- list(
+##     start = s_start,
+##     event = s_event,
+##     first = s_first,
+##     last = s_last,
+##     scaling = s_scaling,
+##     start_map = s_start_map,
+##     event_map = s_event_map,
+##     status = s_status
+##   )
+
+##   return(list(preproc, event_order, start_order))
+## }
+
+#' Make cox deviance object
+#' @param event the event vector of times
+#' @param start the start vector, if start/stop. Use `NA` for just
+#'   right censored data
+#' @param status the status vector indicating event or censoring
+#' @param tie_breaking default 'efron'
+#' @param weight the sample weight the vector of sample weights,
+#'   default all ones
+#' @return a list of two functions named `coxdev` and `information`
+#'   each of which takes a linear predictor as argument, along with
+#'   weights
+#' @examples
+#' set.seed(10101)
+#' nobs <- 100; nvars <- 10
+#' nzc <- nvars %/% 3
+#' x <- matrix(rnorm(nobs * nvars), nobs, nvars)
+#' beta <- rnorm(nzc)
+#' fx <- x[, seq(nzc)] %*% beta / 3
+#' hx <- exp(fx)
+#' ty <- rexp(nobs,hx)
+#' tcens <- rbinom(n = nobs, prob = 0.3, size = 1)
+#' cox_deviance <- make_cox_deviance(event = ty,
+#'                                   status = tcens,
+#'                                   weight = rep(1.0, length(ty)),
+#'                                   tie_breaking = 'efron')
+#' result  <- cox_deviance$coxdev(linear_predictor = fx)
+#' str(result)
+#' tx  <- t(x)
+#' h <- cox_deviance$information(fx)
+#' I <- tx %*% h(x)  ## I should be symmetric
+#' cov  <- solve(I)
+#' @export
+make_cox_deviance <- function(event,
+                              start = NA, # if NA, indicates just right censored data
+                              status,
+                              tie_breaking = c('efron', 'breslow'),
+                              weight = rep(1.0, length(event))) {
+
+  tie_breaking  <- match.arg(tie_breaking)
+
+  event <- as.numeric(event)
+  nevent <- length(event)
+  status <- as.integer(status)
+  if (length(start) != length(status)) {
+    start <- rep(-Inf, nevent)
+    have_start_times <- FALSE
+  } else {
+    start  <- as.numeric(start)
+    have_start_times <- TRUE
+  }
+
+  ## prep_result  <- preprocess(start, event, status) # R version of preprocess
+  ## event_order  <- as.integer(prep_result[[2L]])  - 1L  ## for R 1-based indexing!
+  ## start_order  <- as.integer(prep_result[[3L]])  - 1L  ## for R 1-based indexing!
+  prep_result  <- .preprocess(start, event, status)  # C version of preprocess
+  event_order  <- as.integer(prep_result[[2L]])
+  start_order  <- as.integer(prep_result[[3L]])
+  preproc  <- prep_result[[1L]]
+  efron  <- (tie_breaking == 'efron') && (norm(matrix(preproc$scaling), "2") > 0)
+  status <- preproc[['status']]
+  event <- preproc[['event']]
+  start <- preproc[['start']]
+  first <- preproc[['first']]
+  last <- preproc[['last']]
+  scaling <- preproc[['scaling']]
+  event_map <- preproc[['event_map']]
+  start_map <- preproc[['start_map']]
+
+  ## This check is now moved in to C++ code.
+  ## first_start <- first[start_map + 1]  ## Only used for next check!
+  ## if (!all(first_start == start_map)) {
+  ##   stop('first_start disagrees with start_map')
+  ## }
+
+  n <- length(status)
+
+  # allocate necessary memory
+
+  T_1_term <- numeric(n)
+  T_2_term <- numeric(n)
+  # event_reorder_buffers = np.zeros((3, n))
+  event_reorder_buffers <- lapply(seq_len(3), function(x) numeric(n))
+  # forward_cumsum_buffers = np.zeros((5, n+1))
+  forward_cumsum_buffers <- lapply(seq_len(5), function(x) numeric(n + 1))
+  forward_scratch_buffer <- numeric(n)
+  # reverse_cumsum_buffers = np.zeros((4, n+1))
+  reverse_cumsum_buffers <- lapply(seq_len(4), function(x) numeric(n + 1))
+  # risk_sum_buffers = np.zeros((2, n))
+  risk_sum_buffers <- list(numeric(n), numeric(n))
+  hess_matvec_buffer <- numeric(n)
+  grad_buffer <- numeric(n)
+  diag_hessian_buffer <- numeric(n)
+  diag_part_buffer <- numeric(n)
+  w_avg_buffer <- numeric(n)
+  exp_w_buffer <- numeric(n)
+
+  coxdev <- function (linear_predictor, sample_weight = NULL) {
+    if (is.null(sample_weight)) {
+      sample_weight  <- rep(1.0, length(linear_predictor))
+    } else {
+      sample_weight  <- as.numeric(sample_weight)
+    }
+    loglik_sat  <- .compute_sat_loglik(first,
+                                       last,
+                                       sample_weight,
+                                       event_order,
+                                       status,
+                                       forward_cumsum_buffers[[1]])
+    eta <- linear_predictor - mean(linear_predictor)
+    exp_w_buffer <<- sample_weight * exp(eta) ## Note the double arrow
+
+    ## The C++ code has to be modified for R lists!
+    deviance  <- .cox_dev(eta,
+                          sample_weight,
+                          exp_w_buffer,
+                          event_order,
+                          start_order,
+                          status,
+                          first,
+                          last,
+                          scaling,
+                          event_map,
+                          start_map,
+                          loglik_sat,
+                          T_1_term,
+                          T_2_term,
+                          grad_buffer,
+                          diag_hessian_buffer,
+                          diag_part_buffer,
+                          w_avg_buffer,
+                          event_reorder_buffers,
+                          risk_sum_buffers, #[[1]] is for coxdev, [[2]] is for hessian...
+                          forward_cumsum_buffers,
+                          forward_scratch_buffer,
+                          reverse_cumsum_buffers, #[1:3] are for risk sums, [4:5] used for hessian risk*arg sums
+                          have_start_times,
+                          efron)
+    list(linear_predictor = linear_predictor,
+         sample_weight = sample_weight,
+         loglik_sat = loglik_sat,
+         deviance = deviance,
+         gradient = grad_buffer,
+         diag_hessian = diag_hessian_buffer)
+  }
+  information  <- function(eta, sample_weight = NULL) {
+
+    coxdev_result <- coxdev(eta, sample_weight)
+
+    event_cumsum <- reverse_cumsum_buffers[[1L]]
+    start_cumsum <- reverse_cumsum_buffers[[2L]]
+    risk_sums  <- risk_sum_buffers[[1L]]
+
+    matvec <- function(arg) {
+      # Have to handle both a vector or a matrix
+      arg <- as.matrix(-arg)
+      apply(arg, 2, .hessian_matvec,
+            eta = eta,
+            sample_weight = coxdev_result$sample_weight,
+            risk_sums = risk_sums,
+            diag_part = diag_part_buffer,
+            w_avg = w_avg_buffer,
+            exp_w = exp_w_buffer,
+            event_cumsum = event_cumsum,
+            start_cumsum = start_cumsum,
+            event_order = event_order,
+            start_order = start_order,
+            status = status,
+            first = first,
+            last = last,
+            scaling = scaling,
+            event_map = event_map,
+            start_map = start_map,
+            risk_sum_buffers = risk_sum_buffers,
+            forward_cumsum_buffers = forward_cumsum_buffers,
+            forward_scratch_buffer = forward_scratch_buffer,
+            reverse_cumsum_buffers = reverse_cumsum_buffers,
+            hess_matvec_buffer = hess_matvec_buffer,
+            have_start_times = have_start_times,
+            efron = efron)
+    }
+    matvec
+  }
+  list(coxdev = coxdev, information = information)
+}

{coxdev-0.1.5/R_pkg → coxdev-0.1.7/R}/coxdev/man/coxdev-package.Rd

@@ -2,7 +2,6 @@
 % Please edit documentation in R/coxdev-package.R
 \docType{package}
 \name{coxdev-package}
-\alias{coxdev}
 \alias{coxdev-package}
 \title{R Interface to coxdev C++ routines}
 \description{

coxdev-0.1.7/R/coxdev/src/Makevars

@@ -0,0 +1 @@
+PKG_CPPFLAGS=-DR_INTERFACE=1