coxdev 0.2.0__tar.gz → 0.3.0__tar.gz

coxdev-0.3.0/.github/workflows/R.yml

@@ -0,0 +1,71 @@
+# Check the R package, and test it against the Python package
+
+name: R package
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  R-CMD-check:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: Check the C++ copies in the R package are current
+      run: |
+        diff cpp/include/coxdev.h R/coxdev/inst/include/coxdev.h
+        diff cpp/src/coxdev.cpp R/coxdev/src/coxdev.cpp
+
+    - uses: r-lib/actions/setup-pandoc@v2
+
+    - uses: r-lib/actions/setup-r@v2
+      with:
+        use-public-rspm: true
+
+    # the Suggests include survival and glmnet, which the Python tests that
+    # compare with R (through rpy2) need as well
+    - uses: r-lib/actions/setup-r-dependencies@v2
+      with:
+        working-directory: R/coxdev
+        extra-packages: any::rcmdcheck
+        needs: check
+
+    - uses: r-lib/actions/check-r-package@v2
+      with:
+        working-directory: R/coxdev
+        args: 'c("--no-manual", "--as-cran")'
+        error-on: '"warning"'
+
+    - name: Install the R package
+      run: R CMD INSTALL R/coxdev
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.12"
+
+    - name: Install the Python package and rpy2
+      run: |
+        pip install --upgrade pip
+        pip install . pytest pandas rpy2
+
+    # every Python test that compares with R through rpy2: survival, glmnet
+    # and the R package. COXDEV_REQUIRE_R makes a missing R setup fail them
+    # instead of skipping them.
+    - name: Test the Python package against R
+      env:
+        COXDEV_REQUIRE_R: 1
+      run: |
+        mkdir empty_dir
+        cd empty_dir
+        python -m pytest ../tests/test_R_package.py ../tests/test_residuals_hazard.py \
+          ../tests/test_compareR.py ../tests/test_bad.py --test-size=200 -rs

coxdev-0.3.0/.github/workflows/docs.yml

@@ -0,0 +1,107 @@
+# Build the Jupyter Book in doc/ and deploy it to GitHub Pages.
+# Requires Settings -> Pages -> Source: "GitHub Actions".
+
+name: Docs
+on:
+  workflow_dispatch:
+    inputs:
+      tag_name:
+        description: 'The tag or commit to build docs from'
+        required: true
+        default: 'main'
+        type: string
+
+env:
+  # `BASE_URL` determines where the website is served from, including CSS & JS assets
+  BASE_URL: /${{ github.event.repository.name }}
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
+# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
+concurrency:
+  group: 'pages'
+  cancel-in-progress: false
+jobs:
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.inputs.tag_name }}
+          fetch-depth: 0 # setuptools_scm needs the tags
+          submodules: recursive
+
+      - name: Setup Pages
+        uses: actions/configure-pages@v5
+
+      # Jupyter Book 2 runs on Node
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20.x
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      # glmstar first: it pulls coxdev from PyPI, which `pip install .` then replaces
+      - name: Install package and Jupyter Book
+        run: |
+          pip install --upgrade pip
+          pip install meson-python ninja meson pybind11 setuptools_scm
+          pip install "glmstar>=0.2.0" pandas matplotlib
+          pip install .
+          pip install "jupyter-book>=2" ipykernel sphinx sphinx-book-theme
+
+      # The R pages run on the R kernel for Jupyter (IRkernel), with the
+      # R package from R/coxdev: no rpy2
+      - uses: r-lib/actions/setup-r@v2
+        with:
+          use-public-rspm: true
+
+      - name: Install the R package and the R kernel
+        run: |
+          Rscript -e 'install.packages(c("R6", "Rcpp", "RcppEigen", "survival", "Matrix", "glmnet", "IRkernel"))'
+          Rscript -e 'IRkernel::installspec()'
+          R CMD INSTALL R/coxdev
+          jupyter kernelspec list
+
+      # The R pages run on the R kernel for Jupyter (IRkernel), with the
+      # R package from R/coxdev: no rpy2
+      - uses: r-lib/actions/setup-r@v2
+        with:
+          use-public-rspm: true
+
+      - name: Install the R package and the R kernel
+        run: |
+          Rscript -e 'install.packages(c("R6", "Rcpp", "RcppEigen", "survival", "Matrix", "glmnet", "IRkernel"))'
+          Rscript -e 'IRkernel::installspec()'
+          R CMD INSTALL R/coxdev
+          jupyter kernelspec list
+
+      - name: Build HTML
+        run: |
+          cd doc
+          jupyter-book build --html --execute
+
+      # The API reference: Sphinx autodoc, into api/ next to the book
+      - name: Build API reference
+        run: |
+          sphinx-build -b html doc/api doc/_build/html/api
+          test -f doc/_build/html/api/index.html
+
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: 'doc/_build/html'
+
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

{coxdev-0.2.0 → coxdev-0.3.0}/.github/workflows/test.yml

@@ -28,10 +28,17 @@ jobs:
       with:
         python-version: ${{ matrix.python-version }}
 
+    - name: Test the C++ code
+      run: |
+        c++ -std=c++17 -O2 -Wall -Ieigen -Icpp/include cpp/src/coxdev.cpp cpp/tests/test_residuals_hazard.cpp -o test_residuals_hazard
+        ./test_residuals_hazard
+        c++ -std=c++17 -O2 -Wall -Ieigen -Icpp/include cpp/src/coxdev.cpp cpp/tests/test_concordance.cpp -o test_concordance
+        ./test_concordance
+
     - name: Install coxdev
       run: |
         pip install --upgrade pip
-        pip install meson-python ninja meson pybind11 setuptools_scm pytest pandas joblib
+        pip install meson-python ninja meson pybind11 setuptools_scm pytest pandas glmstar
         pip install .
 
     - name: Verify installed source
@@ -44,6 +51,13 @@ jobs:
         cd /tmp
         python -c "import coxdev; print(f'Location: {coxdev.__file__}'); import os; print(f'Contents: {os.listdir(os.path.dirname(coxdev.__file__))}')"
 
+    - name: Run the notebooks in doc
+      run: |
+        pip install jupytext nbconvert ipykernel matplotlib pandas
+        for nb in using_coxdev sampling; do
+          jupytext --to ipynb --execute doc/$nb.md --output "$RUNNER_TEMP/$nb.ipynb"
+        done
+
     - name: Test coxdev
       run: |
         mkdir empty_dir

{coxdev-0.2.0 → coxdev-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: coxdev
-Version: 0.2.0
+Version: 0.3.0
 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>
@@ -13,13 +13,11 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.9
-Requires-Dist: joblib
 Requires-Dist: numpy
 Requires-Dist: scipy
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pandas; extra == "test"
-Requires-Dist: joblib; extra == "test"
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: scipy; extra == "dev"
@@ -34,6 +32,9 @@ Requires-Dist: jupyter-book; extra == "doc"
 Requires-Dist: pandas; extra == "doc"
 Requires-Dist: matplotlib; extra == "doc"
 Requires-Dist: rpy2; extra == "doc"
+Requires-Dist: glmstar>=0.2.0; extra == "doc"
+Requires-Dist: sphinx; extra == "doc"
+Requires-Dist: sphinx-book-theme; extra == "doc"
 Description-Content-Type: text/markdown
 
 # coxdev
@@ -105,6 +106,75 @@ print(f"Saturated log-likelihood: {result.loglik_sat:.4f}")
 print(f"Gradient norm: {np.linalg.norm(result.gradient):.4f}")
 ```
 
+## R Package
+
+The R package in `R/coxdev` runs the same C++ code, with the interface of
+the Python package. Install it from a clone of the repository:
+
+```bash
+R CMD INSTALL R/coxdev
+```
+
+or with `remotes::install_github("jonathan-taylor/coxdev", subdir = "R/coxdev")`.
+
+```r
+library(coxdev)
+set.seed(1)
+n <- 1000
+X <- matrix(rnorm(n * 3), n, 3)
+eta <- drop(X %*% c(0.5, -0.5, 0.25))
+event <- rexp(n, exp(eta))
+status <- rbinom(n, 1, 0.7)
+
+cox <- CoxDeviance$new(event = event, status = status, tie_breaking = "efron")
+# or with a Surv response: Surv(time, status) or Surv(start, stop, status),
+# with strata from glmnet::stratifySurv() if set
+cox <- CoxDeviance$new(survival::Surv(event, status), tie_breaking = "efron")
+
+res <- cox$compute(eta)          # Python: coxdev(eta)
+res$deviance                     # the objective
+res$gradient                     # its gradient in eta
+res$diag_hessian                 # the diagonal of its Hessian
+
+I <- cox$information(eta)        # a matrix-free operator, never n x n
+I %*% X                          # or I$multiply(X); t(X) %*% I also works
+info_beta <- crossprod(X, I %*% X)
+
+draws <- cox$sample_score(eta, method = "fisher", n_draws = 2000, seed = 1)
+G <- rnorm(n)
+w <- cox$wild_score(eta, G)
+```
+
+| Python | R |
+|---|---|
+| `CoxDeviance(event=, status=, start=, strata=, sample_weight=, tie_breaking=)` | `CoxDeviance$new(event =, status =, start =, strata =, sample_weight =, tie_breaking =)` |
+| | `CoxDeviance$new(Surv(...), strata =, sample_weight =, tie_breaking =)` |
+| `coxdev(eta, sample_weight)` | `cox$compute(eta, sample_weight)` |
+| `coxdev.information(eta, sample_weight)` (a `LinearOperator`) | `cox$information(eta, sample_weight)` (a `CoxInformation`, with `%*%`, `$multiply()`, `$diagonal()`, `$to_dense()`, `dim()`) |
+| `coxdev.sample_score(eta, sample_weight, method, n_draws, seed)` | `cox$sample_score(eta, sample_weight, method, n_draws, seed)` |
+| `coxdev.wild_score(eta, multipliers, sample_weight)` | `cox$wild_score(eta, multipliers, sample_weight)` |
+| `coxdev.score_residuals(eta, X, sample_weight)` | `cox$score_residuals(eta, X, sample_weight)` |
+| `coxdev.baseline_hazard(eta, sample_weight)` (a `BaselineHazard`) | `cox$baseline_hazard(eta, sample_weight)` (a data frame, with stratum labels as given) |
+
+The same `seed` gives the same draws from R and Python. In R, a seed is a
+whole number up to `2^53`, or a string of digits for any seed below
+`2^64`; with `seed = NULL` it is drawn from R's generator, so `set.seed()`
+makes the draws reproducible. Strata may be integers, a factor or
+character. `%*%` with the operator needs R 4.4.0 or later; `$multiply()`
+works on any version.
+
+The C++ sources in `R/coxdev/src` and `R/coxdev/inst/include` are copies of
+those in `cpp/`, so that the R package is self-contained: after editing
+`cpp/`, run `R/coxdev/tools/sync_cpp.sh` (CI checks that the copies agree).
+## Notebooks
+
+`doc/using_coxdev.md` (fitting by Newton's method with the information
+operator, robust standard errors, the baseline hazard and survival curves,
+and what keeping state saves) and `doc/sampling.md` (the methods of
+`sample_score` compared) are [jupytext](https://jupytext.readthedocs.io)
+notebooks, with executed copies in `doc/*.ipynb`. The R package has the
+same two as vignettes.
+
 ## Advanced Usage
 
 ### Left-Truncated Data
@@ -231,6 +301,122 @@ The random numbers come from the C++ code, from the bits of
 `std::mt19937_64`, so the same `seed` gives the same draws on every
 platform. With `seed=None`, a fresh seed is drawn.
 
+### Score Residuals and the Baseline Hazard
+
+```python
+# the score residuals of a design: row i is observation i's contribution
+# to the score of the coefficients
+U = coxdev.score_residuals(eta, X)
+I = X.T @ (coxdev.information(eta) @ X)
+robust_cov = np.linalg.solve(I, np.linalg.solve(I, U.T @ U).T)   # the sandwich
+
+# Breslow's (or, with Efron's ties, Efron's) baseline hazard, for eta as given
+H = coxdev.baseline_hazard(eta)
+H.time, H.hazard, H.cumulative_hazard, H.stratum
+```
+
+The cumulative hazard of observation `i` at time `t` is the
+`cumulative_hazard` at the last failure time `<= t` (in its stratum) times
+`exp(eta[i])`. Both agree with R's `survival` (`residuals(fit, type =
+"score")`, which is per unit weight, and `basehaz(fit, centered = FALSE)`).
+
+### Schoenfeld Residuals and Expected Survival at Exit
+
+```python
+# Schoenfeld residuals: for each failure, x_i less the mean of x over its
+# risk set; zero rows for the observations that do not fail
+R = coxdev.schoenfeld_residuals(eta, X)
+
+# the expected number of events of each observation over (start, event],
+# and the probability of surviving to event, given survival to start
+E = coxdev.expected_events(eta)
+S = coxdev.survival_at_exit(eta)          # exp(-E)
+martingale = status - E
+```
+
+The Schoenfeld residual of a failure is its covariates less their mean over
+its risk set, with weights `sample_weight * exp(eta)` (Schoenfeld, 1982).
+With Efron's ties the mean is the average over the tied failures of their
+Efron means, as in R's `survival`. Weighted by `sample_weight`, they sum to
+the score. Plotted against time, or against a function of time, they check
+the proportional hazards assumption (Grambsch and Therneau, 1994; Therneau
+and Grambsch, 2000, Chapter 6). As for the score residuals, the C++ takes
+one covariate, an n-vector, at a time, and `schoenfeld_residuals` loops
+over the columns of `X`, dense or sparse.
+
+`risk_set_variance(eta, Z)` gives, for each failure, the variance of each
+column of `Z` over its risk set, the `V_z` by which Grambsch and Therneau
+(1994) scale the Schoenfeld residuals: for one covariate, `beta + r / V_z`
+has mean about `beta(t)` at the failure time `t`. Weighted by
+`sample_weight`, the variances sum to the diagonal of the information. The
+covariance of two columns follows by polarization,
+`(V(y + z) - V(y - z)) / 4`.
+
+The expected number of events of observation `i` is `exp(eta[i])` times
+the increase of the baseline cumulative hazard (Breslow, 1972) over
+`(start[i], event[i]]`, with Efron's share at a tied failure time for the
+failures there. `status - E` is the martingale residual (Barlow and
+Prentice, 1988; Therneau, Grambsch and Fleming, 1990), and `exp(-E)` the
+expected survival probability at exit (Therneau and Grambsch, 2000,
+Chapter 4). These agree with R's `survival`: `residuals(fit, type =
+"schoenfeld")` (which has the rows of the failures only, in order of
+failure time), `predict(fit, type = "expected")`, `residuals(fit, type =
+"martingale")` and `predict(fit, type = "survival")`.
+
+#### References
+
+- Barlow, W. E. and Prentice, R. L. (1988). Residuals for relative risk
+  regression. *Biometrika*, 75(1), 65–74.
+- Breslow, N. E. (1972). Discussion of Professor Cox's paper. *Journal of
+  the Royal Statistical Society, Series B*, 34(2), 216–217.
+- Grambsch, P. M. and Therneau, T. M. (1994). Proportional hazards tests
+  and diagnostics based on weighted residuals. *Biometrika*, 81(3),
+  515–526.
+- Schoenfeld, D. (1982). Partial residuals for the proportional hazards
+  regression model. *Biometrika*, 69(1), 239–241.
+- Therneau, T. M. and Grambsch, P. M. (2000). *Modeling Survival Data:
+  Extending the Cox Model*. Springer, New York.
+- Therneau, T. M., Grambsch, P. M. and Fleming, T. R. (1990).
+  Martingale-based residuals for survival models. *Biometrika*, 77(1),
+  147–160.
+
+### The C-index
+
+```python
+C = coxdev.c_index(eta)          # Harrell's concordance index
+```
+
+Harrell's concordance index (Harrell et al., 1982; Harrell, Lee and Mark,
+1996): for each failure `i` at time `t`, every `j` at risk at `t` is
+compared with it, except the other failures at `t`; the pair has weight
+`w_i * w_j`, is concordant if `eta[i] > eta[j]`, and counts half if they
+are tied. With strata, only pairs within a stratum are compared. It is R's
+`survival::concordance(y ~ -eta, weights = w)` and, without strata,
+`glmnet::Cindex`. A two-dimensional `eta` gives one C-index per column.
+
+It takes `O(n log n)`, by the algorithm of the `survival` package's
+concordance vignette (Therneau and Atkinson): the subjects in decreasing
+time, with the weights of the risk set in a Fenwick tree (Fenwick, 1994)
+over the ranks of the predictor, counting the ordered pairs as Knight
+(1966) does for Kendall's tau.
+
+#### References
+
+- Fenwick, P. M. (1994). A new data structure for cumulative frequency
+  tables. *Software: Practice and Experience*, 24(3), 327–336.
+- Harrell, F. E., Califf, R. M., Pryor, D. B., Lee, K. L. and Rosati, R. A.
+  (1982). Evaluating the yield of medical tests. *JAMA*, 247(18),
+  2543–2546.
+- Harrell, F. E., Lee, K. L. and Mark, D. B. (1996). Multivariable
+  prognostic models: issues in developing models, evaluating assumptions
+  and adequacy, and measuring and reducing errors. *Statistics in
+  Medicine*, 15(4), 361–387.
+- Knight, W. R. (1966). A computer method for calculating Kendall's tau
+  with ungrouped data. *Journal of the American Statistical Association*,
+  61(314), 436–439.
+- Therneau, T. M. and Atkinson, E. J. *The concordance statistic*.
+  Vignette of the R package `survival`.
+
 ### Different Tie-Breaking Methods
 
 ```python
@@ -252,6 +438,7 @@ The main class for computing Cox model quantities.
 - **event**: Event times (failure times) for each observation
 - **status**: Event indicators (1 for event occurred, 0 for censored)
 - **start**: Start times for left-truncated data (optional)
+- **strata**: Stratum labels (optional): integers, strings or any sortable values; `baseline_hazard` reports each stratum by its label
 - **tie_breaking**: Method for handling tied event times ('efron' or 'breslow')
 
 #### Methods
@@ -260,6 +447,13 @@ The main class for computing Cox model quantities.
 - **`information(linear_predictor, sample_weight=None)`**: Get information matrix as linear operator
 - **`sample_score(linear_predictor, sample_weight=None, method='multinomial', n_draws=None, seed=None)`**: Draws of the score, one entry per observation: a vector if `n_draws` is None, else an `(n, n_draws)` array. See [Sampling the Score](#sampling-the-score)
 - **`wild_score(linear_predictor, multipliers, sample_weight=None)`**: The wild draw of the score for given multipliers
+- **`score_residuals(linear_predictor, X, sample_weight=None)`**: The `(n, p)` score residuals of a design `X`
+- **`baseline_hazard(linear_predictor, sample_weight=None)`**: The baseline hazard, a `BaselineHazard` with `time`, `hazard`, `cumulative_hazard` and `stratum`
+- **`schoenfeld_residuals(linear_predictor, X, sample_weight=None)`**: The `(n, p)` Schoenfeld residuals of a design `X`, zero for the observations that do not fail
+- **`risk_set_variance(linear_predictor, Z, sample_weight=None)`**: The `(n, p)` risk-set variances of the columns of `Z` at each failure, zero for the observations that do not fail
+- **`c_index(linear_predictor, sample_weight=None)`**: Harrell's concordance index (C-index) of a linear predictor, or one per column
+- **`expected_events(linear_predictor, sample_weight=None)`**: The expected number of events of each observation over `(start, event]`
+- **`survival_at_exit(linear_predictor, sample_weight=None)`**: The expected survival probability of each observation at its exit, `exp(-expected_events)`
 
 ### CoxDevianceResult
 
@@ -292,6 +486,34 @@ The library is optimized for performance:
 - For Python library: Python >= 3.9 + pybind11
 
 
+## C++ API
+
+The Python package (and the R package in `R/coxdev`) wrap the C++ classes
+`CoxDeviance` and `StratifiedCoxDeviance` in `cpp/include/coxdev.h`. After
+`compute_deviance(eta, weights)`, besides the gradient, the diagonal of the
+Hessian, products with the information and draws of the score, they give:
+
+- `score_residuals(x)`: for one covariate `x` (an n-vector), the n-vector
+  of score residuals, each observation's contribution to the score
+  `x^T (-gradient / 2)`, centered within each risk set (with Efron's
+  weights for ties if `efron`). They are linear in `x`, with `wild_score`
+  the adjoint: `G^T score_residuals(x)` is `x^T wild_score(G)`. The C++
+  never sees a design: applied to each column of `X` they give the `n x p`
+  matrix `U`, whose crossproduct `U^T U` is the middle of the robust
+  (sandwich) variance (Lin and Wei, 1989).
+- `baseline_hazard()`: the estimate of the baseline hazard, Breslow's
+  (1972) or, with Efron's ties, Efron's (1977), at each distinct failure
+  time (within each stratum): its increments and cumulative sum, for the
+  linear predictor as given, so that the cumulative hazard of observation
+  `i` at time `t` is `cumulative_hazard(t) * exp(eta_i)`.
+
+`cpp/tests` has tests of these against direct computations:
+
+```bash
+c++ -std=c++17 -O2 -Ieigen -Icpp/include cpp/src/coxdev.cpp cpp/tests/test_residuals_hazard.cpp -o test_residuals_hazard
+./test_residuals_hazard
+```
+
 ## Testing
 
 Most of the tests compare `coxdev` with R's `survival` and `glmnet`
@@ -359,6 +581,19 @@ For a quick check, `--test-size N` runs a random sample of `N` of the
 python -m pytest tests -rs --test-size 50
 ```
 
+### Testing the R package
+
+The R package has its own tests, against `survival` and `glmnet`, and
+`tests/test_R_package.py` checks that the R and Python packages agree
+(results, information and draws for the same seed). With the R package
+installed (`R CMD INSTALL R/coxdev`, which needs `Rcpp`, `RcppEigen` and
+`R6`, plus `testthat` for its tests):
+
+```bash
+Rscript -e 'testthat::test_local("R/coxdev")'
+python -m pytest tests/test_R_package.py -rs
+```
+
 ## Contributing
 
 1. Fork the repository

coxdev-0.3.0/R/coxdev/.Rbuildignore

@@ -0,0 +1,8 @@
+^LICENSE\.md$
+^tools$
+^GEMINI\.md$
+^src/\.venv$
+\.bak$
+^.*\.o$
+^src/.*\.so$
+^src/.*\.dll$

coxdev-0.3.0/R/coxdev/DESCRIPTION

@@ -0,0 +1,38 @@
+Package: coxdev
+Title: Cox Model Deviance, Gradient, Information and Score Sampling
+Version: 0.2.0.9000
+Authors@R: c(person("Jonathan", "Taylor", role = c("aut"), email = "jtaylo@stanford.edu"),
+             person("Trevor", "Hastie", role = c("aut")),
+             person("Balasubramanian", "Narasimhan", role = c("aut", "cre"),
+                    email = "naras@stanford.edu"))
+Description: Fast computation of the deviance of the Cox proportional
+    hazards model, its gradient and the diagonal of its Hessian with respect
+    to the linear predictor, the information as a matrix-free linear
+    operator, and draws of the score (multinomial, Bernoulli, Fisher
+    noncentral hypergeometric or wild), with Efron's or Breslow's ties,
+    start times (left truncation), strata and sample weights. The 'C++' code
+    is shared with the Python package 'coxdev', and the same seed gives the
+    same draws from either.
+License: GPL (>= 3)
+URL: https://github.com/jonathan-taylor/coxdev
+BugReports: https://github.com/jonathan-taylor/coxdev/issues
+Encoding: UTF-8
+Depends: R (>= 4.1.0)
+Imports:
+    R6,
+    Rcpp,
+    stats
+LinkingTo:
+    Rcpp,
+    RcppEigen
+Suggests:
+    glmnet (>= 5.0),
+    knitr,
+    Matrix,
+    rmarkdown,
+    survival,
+    testthat (>= 3.0.0)
+VignetteBuilder: knitr
+Roxygen: list(markdown = TRUE, r6 = TRUE)
+Config/testthat/edition: 3
+Config/roxygen2/version: 8.1.0

coxdev-0.3.0/R/coxdev/NAMESPACE

@@ -0,0 +1,13 @@
+# Generated by roxygen2: do not edit by hand
+
+S3method(as.matrix,CoxInformation)
+S3method(dim,CoxInformation)
+S3method(print,CoxDevianceResult)
+S3method(t,CoxInformation)
+export(CoxDeviance)
+export(CoxInformation)
+export(make_cox_deviance)
+if (getRversion() >= "4.4.0") S3method(matrixOps, CoxInformation, .matrixOps_CoxInformation)
+importFrom(R6,R6Class)
+importFrom(Rcpp,evalCpp)
+useDynLib(coxdev, .registration = TRUE)

coxdev-0.3.0/R/coxdev/R/RcppExports.R

@@ -0,0 +1,51 @@
+# Generated by using Rcpp::compileAttributes() -> do not edit by hand
+# Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393
+
+.cox_new <- function(start, event, status, strata, weight, efron) {
+    .Call(`_coxdev_cox_new`, start, event, status, strata, weight, efron)
+}
+
+.cox_valid <- function(ptr) {
+    .Call(`_coxdev_cox_valid`, ptr)
+}
+
+.cox_compute <- function(ptr, eta, sample_weight) {
+    .Call(`_coxdev_cox_compute`, ptr, eta, sample_weight)
+}
+
+.cox_information_matmat <- function(ptr, arg) {
+    .Call(`_coxdev_cox_information_matmat`, ptr, arg)
+}
+
+.cox_sample_score <- function(ptr, method, n_draws, seed) {
+    .Call(`_coxdev_cox_sample_score`, ptr, method, n_draws, seed)
+}
+
+.cox_wild_score <- function(ptr, multipliers) {
+    .Call(`_coxdev_cox_wild_score`, ptr, multipliers)
+}
+
+.cox_score_residuals <- function(ptr, x) {
+    .Call(`_coxdev_cox_score_residuals`, ptr, x)
+}
+
+.cox_schoenfeld_residuals <- function(ptr, x) {
+    .Call(`_coxdev_cox_schoenfeld_residuals`, ptr, x)
+}
+
+.cox_risk_set_variance <- function(ptr, z) {
+    .Call(`_coxdev_cox_risk_set_variance`, ptr, z)
+}
+
+.cox_expected_events <- function(ptr) {
+    .Call(`_coxdev_cox_expected_events`, ptr)
+}
+
+.cox_concordance <- function(ptr, pred, weight) {
+    .Call(`_coxdev_cox_concordance`, ptr, pred, weight)
+}
+
+.cox_baseline_hazard <- function(ptr) {
+    .Call(`_coxdev_cox_baseline_hazard`, ptr)
+}
+