pypando 0.1.0__tar.gz

pypando-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2021 QuaDBio Lab (Pando, the R package this is ported from)
+Copyright (c) 2026 omicverse contributors (py-Pando Python port)
+
+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.

pypando-0.1.0/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: pypando
+Version: 0.1.0
+Summary: Pure-Python Pando — gene regulatory network inference from paired single-cell RNA + ATAC (regions, motifs, per-gene TF x binding-site models, modules), AnnData-native, parity-tested against R.
+License: MIT License
+        
+        Copyright (c) 2021 QuaDBio Lab (Pando, the R package this is ported from)
+        Copyright (c) 2026 omicverse contributors (py-Pando Python port)
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/omicverse/py-Pando
+Project-URL: Repository, https://github.com/omicverse/py-Pando
+Project-URL: Issues, https://github.com/omicverse/py-Pando/issues
+Project-URL: Upstream R package, https://github.com/quadbio/Pando
+Keywords: single-cell,multiome,scATAC-seq,gene-regulatory-network,pando,transcription-factor,motif,anndata
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.23
+Requires-Dist: scipy>=1.10
+Requires-Dist: pandas>=1.5
+Requires-Dist: anndata>=0.9
+Requires-Dist: scikit-learn>=1.4
+Requires-Dist: pyfaidx>=0.7
+Requires-Dist: MOODS-python>=1.9.4
+Requires-Dist: pooch>=1.6
+Provides-Extra: xgb
+Requires-Dist: xgboost>=1.7; extra == "xgb"
+Provides-Extra: umap
+Requires-Dist: umap-learn; extra == "umap"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: xgboost>=1.7; extra == "dev"
+Dynamic: license-file
+
+# py-Pando
+
+**Pure-Python Pando**: gene regulatory network inference from paired single-cell RNA + ATAC data, AnnData-native, parity-tested against the R package.
+
+[Pando](https://github.com/quadbio/Pando) (Fleck *et al.*, *Nature* 2023, [doi:10.1038/s41586-022-05459-w](https://doi.org/10.1038/s41586-022-05459-w)) fits, for every target gene, a regression of its expression on TF expression x accessibility of TF-binding peaks near the gene, and reads significant TF–peak terms as regulatory links. py-Pando ports it following the [omicverse-rebuildr](https://github.com/omicverse/omicverse-rebuildr) protocol: the R source is the specification, and pre-registered parity gates (`data/manifest.yaml`) were committed before any algorithmic code.
+
+## Install
+
+```bash
+pip install pypando            # core
+pip install "pypando[xgb]"     # + xgboost models
+pip install "pypando[umap]"    # + UMAP layout of the module graph
+```
+
+## Quick start
+
+```python
+import pypando as pp
+
+# rna:  AnnData, cells x genes, log-normalised (Seurat LogNormalize)
+# atac: AnnData, cells x peaks, TF-IDF (Signac RunTFIDF), var_names "chr-start-end"
+annotation = pp.annotation_from_gtf("gencode.v41.basic.annotation.gff3.gz")
+
+grn = pp.initiate_grn(rna, atac, annotation)                # peaks minus exons
+grn = pp.find_motifs(grn, genome="hg38.fa")                 # Pando's 1,590 motifs, MOODS
+grn = pp.infer_grn(grn, genes=targets, method="glm")        # one model per target gene
+grn = pp.find_modules(grn)                                  # TF modules
+
+pp.coef(grn)            # TF / target / region / estimate / std_err / pval / padj / corr
+pp.gof(grn)             # R^2 and number of variables per target gene
+pp.NetworkModules(grn)  # module table + genes_pos / genes_neg / regions / peaks
+```
+
+Within Epione: `epione.grn.pando(rna, atac, genome="hg38", genes=targets)`.
+
+## Function map
+
+| R (Pando 1.1.1) | Python | Parity on the fixture |
+|---|---|---|
+| `initiate_grn` | `pp.initiate_grn` | identical regions (with and without `regions=` phastCons) |
+| `find_motifs` | `pp.find_motifs` | identical region x motif matrix (1,240,962 hits) |
+| `find_peaks_near_genes` (Signac, GREAT) | `pp.find_peaks_near_genes` | identical |
+| `infer_grn(method = "glm")` | `pp.infer_grn` | identical rows; estimates / SE / t / rsq to ~1e-14; -log10 p to 4e-13 |
+| `infer_grn(method = "glmnet")` | | lambda identical; coefficients Pearson 0.9999 (see notes) |
+| `infer_grn(method = "cv.glmnet")` | | R's folds reproduced; coefficients within 5e-14 |
+| `infer_grn(method = "xgb")` | | **gate fails vs installed R** (xgboost >= 3 drops Pando's parameters); identical (2e-16) with them honoured |
+| `infer_grn(method = "bagging_ridge" / "bayesian_ridge")` | | ~1e-14 (NumPy seeded as in R) |
+| `find_modules` | `pp.find_modules` | identical modules |
+| `fit_model`, `fit_glm`, `fit_glmnet`, `fit_cvglmnet`, `fit_xgb`, `fit_bagging_ridge`, `fit_bayesian_ridge` | same names | per-function, to ~1e-14 (notebook 3) |
+| `format_coefs`, `sparse_cor`, `aggregate_matrix`, `aggregate_assay`, `GetAssaySummary` | same names | exact |
+| `get_network_graph` | `pp.get_network_graph` | graph + PageRank; UMAP layout via umap-learn (not R's uwot stream) |
+| `coef`, `gof`, `GetNetwork`, `NetworkModules`, `NetworkTFs`, `NetworkRegions`, `NetworkFeatures`, `NetworkParams`, `NetworkGraph`, `DefaultNetwork`, `GetGRN`, `Params`, `create_GRNData` | same names | accessors |
+| `plot_gof`, `plot_module_metrics`, `plot_network_graph` | same names (matplotlib) | — |
+| `fit_brms` | — | not ported (Stan) |
+| `get_tf_network`, `plot_tf_network` | — | not ported (see report) |
+
+Full numbers: [RECONSTRUCTION_REPORT.md](RECONSTRUCTION_REPORT.md) and `examples/compare_R_vs_Python.ipynb`.
+
+## What makes the glm network identical
+
+R's `glm` uses LINPACK's `dqrdc2` QR with limited pivoting: a column whose remaining norm falls below `1e-11` of its original norm is moved to the end and its coefficient becomes `NA`. Pando's per-gene designs (hundreds to thousands of `peak x TF` products, often nearly collinear) sit right at that threshold, so the pivot decisions depend on the last bits of BLAS level-1 results. py-Pando's QR (`pypando._blas`, numba) calls the same BLAS routines (`dnrm2`, `ddot`, `daxpy`, `dscal`) in the same order as R's Fortran, multiplies with `dgemv` like R's `%*%`, sums in long double like R's `sum()`, and inverts with LAPACK `dpotri` like `chol2inv`. With the same BLAS build (here OpenBLAS 0.3.34) and one BLAS thread (`infer_grn(blas_threads=1)`, the default), the glm network is bit-identical to R's, including genes where R's IRLS does not converge.
+
+## Notes
+
+* **cv.glmnet** folds come from an emulation of R's `set.seed()` + `sample()` (`pypando.rrng`), so `infer_grn(method="cv.glmnet", seed=42)` uses R's folds after `set.seed(42)`. Fold fits follow glmnet 5.0: each fold on its own lambda path, predictions interpolated onto the full path (glmnet 4.x refitted folds on the full path; `cv_glmnet_gaussian(fold_lambda="full")`).
+* **glmnet**: py-Pando's coordinate descent follows glmnet's path rules (standardisation, lambda sequence, `fdev` / `devmax` stopping) but not its strong-rule screening, so for genes with hundreds of variables both stop within glmnet's 1e-7 tolerance at slightly different coefficients. `fit_glmnet` ports `family = "gaussian"` given as a string, which is how `infer_grn` calls it; R's `fit_glmnet` called directly with its default `family = gaussian` (a function) goes to glmnet's generic `glmnet.path` solver, which is not ported.
+* **xgb**: Pando calls `xgboost::xgboost(data, label, params = list(max_depth = 3, eta = 0.01), ...)`. xgboost >= 3 changed that function's interface and silently ignores `params`, training with depth 6 and learning rate 0.3. py-Pando uses Pando's parameters; with them honoured in R (`xgb.train`), importances match to 1e-15.
+* **bagging_ridge** draws from NumPy's global RNG, as Pando's scikit-learn call does from R; `infer_grn(seed=...)` seeds it.
+* **New in Python** (not in R): `region_background`, `regions_near_genes` and `subset_regions` scan only the regions a target gene can reach, against the background of all regions — the network is identical to a full scan.
+
+## Reproducing the R comparison
+
+```bash
+python tests/make_fixture.py pbmc_granulocyte_sorted_10k_filtered_feature_bc_matrix.h5 data/fixture
+Rscript tests/r_reference_driver.R data/fixture ref                     # R 4.4.3, Pando 1.1.1
+python tests/_run_candidate.py ref cand hg38.fa
+python tests/parity_check.py ref cand results.json
+PYPANDO_REF_DIR=ref PYPANDO_FASTA=hg38.fa PYPANDO_CAND_DIR=cand pytest tests/test_exact_match.py
+```
+
+## Citation
+
+Fleck, J.S., Jansen, S.M.J., Wollny, D. *et al.* Inferring and perturbing cell fate regulomes in human brain organoids. *Nature* 621, 365–372 (2023).
+
+## License
+
+MIT, as the upstream R package (see `LICENSE`).

pypando-0.1.0/README.md

@@ -0,0 +1,87 @@
+# py-Pando
+
+**Pure-Python Pando**: gene regulatory network inference from paired single-cell RNA + ATAC data, AnnData-native, parity-tested against the R package.
+
+[Pando](https://github.com/quadbio/Pando) (Fleck *et al.*, *Nature* 2023, [doi:10.1038/s41586-022-05459-w](https://doi.org/10.1038/s41586-022-05459-w)) fits, for every target gene, a regression of its expression on TF expression x accessibility of TF-binding peaks near the gene, and reads significant TF–peak terms as regulatory links. py-Pando ports it following the [omicverse-rebuildr](https://github.com/omicverse/omicverse-rebuildr) protocol: the R source is the specification, and pre-registered parity gates (`data/manifest.yaml`) were committed before any algorithmic code.
+
+## Install
+
+```bash
+pip install pypando            # core
+pip install "pypando[xgb]"     # + xgboost models
+pip install "pypando[umap]"    # + UMAP layout of the module graph
+```
+
+## Quick start
+
+```python
+import pypando as pp
+
+# rna:  AnnData, cells x genes, log-normalised (Seurat LogNormalize)
+# atac: AnnData, cells x peaks, TF-IDF (Signac RunTFIDF), var_names "chr-start-end"
+annotation = pp.annotation_from_gtf("gencode.v41.basic.annotation.gff3.gz")
+
+grn = pp.initiate_grn(rna, atac, annotation)                # peaks minus exons
+grn = pp.find_motifs(grn, genome="hg38.fa")                 # Pando's 1,590 motifs, MOODS
+grn = pp.infer_grn(grn, genes=targets, method="glm")        # one model per target gene
+grn = pp.find_modules(grn)                                  # TF modules
+
+pp.coef(grn)            # TF / target / region / estimate / std_err / pval / padj / corr
+pp.gof(grn)             # R^2 and number of variables per target gene
+pp.NetworkModules(grn)  # module table + genes_pos / genes_neg / regions / peaks
+```
+
+Within Epione: `epione.grn.pando(rna, atac, genome="hg38", genes=targets)`.
+
+## Function map
+
+| R (Pando 1.1.1) | Python | Parity on the fixture |
+|---|---|---|
+| `initiate_grn` | `pp.initiate_grn` | identical regions (with and without `regions=` phastCons) |
+| `find_motifs` | `pp.find_motifs` | identical region x motif matrix (1,240,962 hits) |
+| `find_peaks_near_genes` (Signac, GREAT) | `pp.find_peaks_near_genes` | identical |
+| `infer_grn(method = "glm")` | `pp.infer_grn` | identical rows; estimates / SE / t / rsq to ~1e-14; -log10 p to 4e-13 |
+| `infer_grn(method = "glmnet")` | | lambda identical; coefficients Pearson 0.9999 (see notes) |
+| `infer_grn(method = "cv.glmnet")` | | R's folds reproduced; coefficients within 5e-14 |
+| `infer_grn(method = "xgb")` | | **gate fails vs installed R** (xgboost >= 3 drops Pando's parameters); identical (2e-16) with them honoured |
+| `infer_grn(method = "bagging_ridge" / "bayesian_ridge")` | | ~1e-14 (NumPy seeded as in R) |
+| `find_modules` | `pp.find_modules` | identical modules |
+| `fit_model`, `fit_glm`, `fit_glmnet`, `fit_cvglmnet`, `fit_xgb`, `fit_bagging_ridge`, `fit_bayesian_ridge` | same names | per-function, to ~1e-14 (notebook 3) |
+| `format_coefs`, `sparse_cor`, `aggregate_matrix`, `aggregate_assay`, `GetAssaySummary` | same names | exact |
+| `get_network_graph` | `pp.get_network_graph` | graph + PageRank; UMAP layout via umap-learn (not R's uwot stream) |
+| `coef`, `gof`, `GetNetwork`, `NetworkModules`, `NetworkTFs`, `NetworkRegions`, `NetworkFeatures`, `NetworkParams`, `NetworkGraph`, `DefaultNetwork`, `GetGRN`, `Params`, `create_GRNData` | same names | accessors |
+| `plot_gof`, `plot_module_metrics`, `plot_network_graph` | same names (matplotlib) | — |
+| `fit_brms` | — | not ported (Stan) |
+| `get_tf_network`, `plot_tf_network` | — | not ported (see report) |
+
+Full numbers: [RECONSTRUCTION_REPORT.md](RECONSTRUCTION_REPORT.md) and `examples/compare_R_vs_Python.ipynb`.
+
+## What makes the glm network identical
+
+R's `glm` uses LINPACK's `dqrdc2` QR with limited pivoting: a column whose remaining norm falls below `1e-11` of its original norm is moved to the end and its coefficient becomes `NA`. Pando's per-gene designs (hundreds to thousands of `peak x TF` products, often nearly collinear) sit right at that threshold, so the pivot decisions depend on the last bits of BLAS level-1 results. py-Pando's QR (`pypando._blas`, numba) calls the same BLAS routines (`dnrm2`, `ddot`, `daxpy`, `dscal`) in the same order as R's Fortran, multiplies with `dgemv` like R's `%*%`, sums in long double like R's `sum()`, and inverts with LAPACK `dpotri` like `chol2inv`. With the same BLAS build (here OpenBLAS 0.3.34) and one BLAS thread (`infer_grn(blas_threads=1)`, the default), the glm network is bit-identical to R's, including genes where R's IRLS does not converge.
+
+## Notes
+
+* **cv.glmnet** folds come from an emulation of R's `set.seed()` + `sample()` (`pypando.rrng`), so `infer_grn(method="cv.glmnet", seed=42)` uses R's folds after `set.seed(42)`. Fold fits follow glmnet 5.0: each fold on its own lambda path, predictions interpolated onto the full path (glmnet 4.x refitted folds on the full path; `cv_glmnet_gaussian(fold_lambda="full")`).
+* **glmnet**: py-Pando's coordinate descent follows glmnet's path rules (standardisation, lambda sequence, `fdev` / `devmax` stopping) but not its strong-rule screening, so for genes with hundreds of variables both stop within glmnet's 1e-7 tolerance at slightly different coefficients. `fit_glmnet` ports `family = "gaussian"` given as a string, which is how `infer_grn` calls it; R's `fit_glmnet` called directly with its default `family = gaussian` (a function) goes to glmnet's generic `glmnet.path` solver, which is not ported.
+* **xgb**: Pando calls `xgboost::xgboost(data, label, params = list(max_depth = 3, eta = 0.01), ...)`. xgboost >= 3 changed that function's interface and silently ignores `params`, training with depth 6 and learning rate 0.3. py-Pando uses Pando's parameters; with them honoured in R (`xgb.train`), importances match to 1e-15.
+* **bagging_ridge** draws from NumPy's global RNG, as Pando's scikit-learn call does from R; `infer_grn(seed=...)` seeds it.
+* **New in Python** (not in R): `region_background`, `regions_near_genes` and `subset_regions` scan only the regions a target gene can reach, against the background of all regions — the network is identical to a full scan.
+
+## Reproducing the R comparison
+
+```bash
+python tests/make_fixture.py pbmc_granulocyte_sorted_10k_filtered_feature_bc_matrix.h5 data/fixture
+Rscript tests/r_reference_driver.R data/fixture ref                     # R 4.4.3, Pando 1.1.1
+python tests/_run_candidate.py ref cand hg38.fa
+python tests/parity_check.py ref cand results.json
+PYPANDO_REF_DIR=ref PYPANDO_FASTA=hg38.fa PYPANDO_CAND_DIR=cand pytest tests/test_exact_match.py
+```
+
+## Citation
+
+Fleck, J.S., Jansen, S.M.J., Wollny, D. *et al.* Inferring and perturbing cell fate regulomes in human brain organoids. *Nature* 621, 365–372 (2023).
+
+## License
+
+MIT, as the upstream R package (see `LICENSE`).

pypando-0.1.0/pypando/__init__.py

@@ -0,0 +1,117 @@
+"""py-Pando — pure-Python port of Pando (Fleck et al., Nature 2023).
+
+Pando infers gene regulatory networks from paired single-cell RNA and ATAC
+data: for every target gene it regresses expression on TF expression x
+accessibility of TF-binding peaks near the gene.
+
+Functional API (mirrors the R package)::
+
+    import pypando as pp
+    grn = pp.initiate_grn(rna, atac, annotation)
+    grn = pp.find_motifs(grn, genome="hg38.fa")
+    grn = pp.infer_grn(grn, genes=targets)
+    grn = pp.find_modules(grn)
+    pp.coef(grn); pp.gof(grn); pp.NetworkModules(grn)
+"""
+from . import data
+from .annotation import annotation_from_gtf
+from .core import Pando
+from .grn import (
+    find_modules,
+    find_motifs,
+    find_peaks_near_genes,
+    fit_grn_models,
+    format_coefs,
+    infer_grn,
+    initiate_grn,
+    region_background,
+    regions_near_genes,
+    subset_regions,
+)
+from .graph import get_network_graph
+from .models import (
+    fit_bagging_ridge,
+    fit_bayesian_ridge,
+    fit_brms,
+    fit_cvglmnet,
+    fit_glm,
+    fit_glmnet,
+    fit_model,
+    fit_xgb,
+)
+from .motifs import PFM, load_motif2tf, load_pando_motifs
+from .objects import (
+    GRNData,
+    Modules,
+    Network,
+    Regions,
+    RegulatoryNetwork,
+    DefaultNetwork,
+    GetGRN,
+    GetNetwork,
+    NetworkFeatures,
+    NetworkGraph,
+    NetworkModules,
+    NetworkParams,
+    NetworkRegions,
+    NetworkTFs,
+    Params,
+    coef,
+    gof,
+)
+from .objects import GetAssaySummary, aggregate_assay, create_GRNData
+from .plots import plot_gof, plot_module_metrics, plot_network_graph
+from .utils import aggregate_matrix, sparse_cor
+
+__all__ = [
+    "Pando",
+    "annotation_from_gtf",
+    "initiate_grn",
+    "find_motifs",
+    "find_peaks_near_genes",
+    "infer_grn",
+    "fit_grn_models",
+    "format_coefs",
+    "find_modules",
+    "region_background",
+    "regions_near_genes",
+    "subset_regions",
+    "get_network_graph",
+    "fit_model",
+    "fit_glm",
+    "fit_glmnet",
+    "fit_cvglmnet",
+    "fit_xgb",
+    "fit_bagging_ridge",
+    "fit_bayesian_ridge",
+    "fit_brms",
+    "PFM",
+    "load_pando_motifs",
+    "load_motif2tf",
+    "GRNData",
+    "RegulatoryNetwork",
+    "Regions",
+    "Network",
+    "Modules",
+    "GetGRN",
+    "GetNetwork",
+    "DefaultNetwork",
+    "NetworkFeatures",
+    "NetworkTFs",
+    "NetworkRegions",
+    "NetworkModules",
+    "NetworkParams",
+    "NetworkGraph",
+    "Params",
+    "coef",
+    "gof",
+    "aggregate_matrix",
+    "aggregate_assay",
+    "GetAssaySummary",
+    "create_GRNData",
+    "plot_gof",
+    "plot_module_metrics",
+    "plot_network_graph",
+    "sparse_cor",
+]
+__version__ = "0.1.0"

pypando-0.1.0/pypando/_blas.py

@@ -0,0 +1,177 @@
+"""R's QR (``dqrdc2`` / ``dqrls``) compiled with numba, calling the BLAS.
+
+R's Fortran routines call the BLAS level-1 kernels ``dnrm2``, ``ddot``,
+``daxpy`` and ``dscal``. Floating-point results of those kernels depend on
+their summation order, so for decisions that sit on a knife edge (a column
+is "negligible" if its residual norm falls below ``1e-11`` times its
+original norm) the only way to reproduce R is to make the same calls in the
+same order. This module does that through SciPy's BLAS (the library NumPy
+and SciPy are linked to); with the same BLAS build as R's, the QR is
+bit-identical to R's.
+"""
+from __future__ import annotations
+
+import ctypes
+
+import numpy as np
+
+__all__ = ["dqrdc2_blas", "dqrls_blas", "available"]
+
+try:
+    import numba
+    from numba import njit
+    import scipy.linalg.cython_blas as _cb
+
+    def _fn(name, restype, *argtypes):
+        cap = _cb.__pyx_capi__[name]
+        ctypes.pythonapi.PyCapsule_GetName.restype = ctypes.c_char_p
+        ctypes.pythonapi.PyCapsule_GetName.argtypes = [ctypes.py_object]
+        ctypes.pythonapi.PyCapsule_GetPointer.restype = ctypes.c_void_p
+        ctypes.pythonapi.PyCapsule_GetPointer.argtypes = [ctypes.py_object, ctypes.c_char_p]
+        ptr = ctypes.pythonapi.PyCapsule_GetPointer(cap, ctypes.pythonapi.PyCapsule_GetName(cap))
+        return ctypes.CFUNCTYPE(restype, *argtypes)(ptr)
+
+    _P = ctypes.c_void_p
+    _dnrm2 = _fn("dnrm2", ctypes.c_double, _P, _P, _P)
+    _ddot = _fn("ddot", ctypes.c_double, _P, _P, _P, _P, _P)
+    _daxpy = _fn("daxpy", None, _P, _P, _P, _P, _P, _P)
+    _dscal = _fn("dscal", None, _P, _P, _P, _P)
+    available = True
+except Exception:  # pragma: no cover - numba or the capsules missing
+    available = False
+
+
+if available:
+
+    @njit(cache=False)
+    def _dqrdc2(x, tol, jpvt, qraux, work, ib, db):
+        # x: Fortran-ordered (n, p). ib: int32 scratch[4], db: float64 scratch[2]
+        n, p = x.shape
+        xp = x.ctypes.data
+        ld = n
+        step = 8  # sizeof(double)
+        one = ib.ctypes.data  # ib[0] = 1 (incx)
+        nn = ib.ctypes.data + 4  # ib[1] = length
+        ib[0] = 1
+        if n > 0:
+            for j in range(p):
+                ib[1] = n
+                v = _dnrm2(nn, xp + (j * ld) * step, one)
+                qraux[j] = v
+                work[j, 0] = v
+                work[j, 1] = v if v != 0.0 else 1.0
+        lup = min(n, p)
+        k = p + 1
+        for l in range(lup):
+            while not ((l + 1) >= k or qraux[l] >= work[l, 1] * tol):
+                for i in range(n):
+                    t = x[i, l]
+                    for j in range(l + 1, p):
+                        x[i, j - 1] = x[i, j]
+                    x[i, p - 1] = t
+                i0 = jpvt[l]
+                t = qraux[l]
+                tt = work[l, 0]
+                ttt = work[l, 1]
+                for j in range(l + 1, p):
+                    jpvt[j - 1] = jpvt[j]
+                    qraux[j - 1] = qraux[j]
+                    work[j - 1, 0] = work[j, 0]
+                    work[j - 1, 1] = work[j, 1]
+                jpvt[p - 1] = i0
+                qraux[p - 1] = t
+                work[p - 1, 0] = tt
+                work[p - 1, 1] = ttt
+                k -= 1
+            if (l + 1) != n:
+                m = n - l
+                ib[1] = m
+                col_l = xp + (l * ld + l) * step
+                nrmxl = _dnrm2(nn, col_l, one)
+                if nrmxl != 0.0:
+                    if x[l, l] != 0.0:
+                        nrmxl = abs(nrmxl) if x[l, l] >= 0 else -abs(nrmxl)
+                    db[0] = 1.0 / nrmxl
+                    _dscal(nn, db.ctypes.data, col_l, one)
+                    x[l, l] = 1.0 + x[l, l]
+                    for j in range(l + 1, p):
+                        col_j = xp + (j * ld + l) * step
+                        t = -_ddot(nn, col_l, one, col_j, one) / x[l, l]
+                        db[1] = t
+                        _daxpy(nn, db.ctypes.data + 8, col_l, one, col_j, one)
+                        if qraux[j] != 0.0:
+                            r = abs(x[l, j]) / qraux[j]
+                            tt = 1.0 - r * r
+                            if tt < 0.0:
+                                tt = 0.0
+                            t = tt
+                            if abs(t) >= 1e-6:
+                                qraux[j] = qraux[j] * np.sqrt(t)
+                            else:
+                                ib[2] = n - l - 1
+                                qraux[j] = _dnrm2(ib.ctypes.data + 8, xp + (j * ld + l + 1) * step, one)
+                                work[j, 0] = qraux[j]
+                    qraux[l] = x[l, l]
+                    x[l, l] = -nrmxl
+        return min(k - 1, n)
+
+    @njit(cache=False)
+    def _dqrsl_b(x, k, qraux, y, b, ib, db):
+        # qty (job digit b) then b (job digit c), as dqrsl with job 1110
+        n = x.shape[0]
+        xp = x.ctypes.data
+        step = 8
+        ib[0] = 1
+        one = ib.ctypes.data
+        nn = ib.ctypes.data + 4
+        qty = y.copy()
+        qp = qty.ctypes.data
+        ju = min(k, n - 1)
+        for j in range(ju):
+            if qraux[j] != 0.0:
+                temp = x[j, j]
+                x[j, j] = qraux[j]
+                ib[1] = n - j
+                col = xp + (j * n + j) * step
+                t = -_ddot(nn, col, one, qp + j * step, one) / x[j, j]
+                db[1] = t
+                _daxpy(nn, db.ctypes.data + 8, col, one, qp + j * step, one)
+                x[j, j] = temp
+        for i in range(k):
+            b[i] = qty[i]
+        bp = b.ctypes.data
+        for jj in range(k):
+            j = k - jj - 1
+            if x[j, j] == 0.0:
+                return j + 1  # info
+            b[j] = b[j] / x[j, j]
+            if j > 0:
+                db[1] = -b[j]
+                ib[1] = j
+                _daxpy(nn, db.ctypes.data + 8, xp + (j * n) * step, one, bp, one)
+        return 0
+
+
+def dqrdc2_blas(x: np.ndarray, tol: float):
+    """Same contract as :func:`pypando.rstats.dqrdc2`, BLAS-exact."""
+    X = np.array(x, dtype=np.float64, order="F", copy=True)
+    p = X.shape[1]
+    jpvt = np.arange(p, dtype=np.int64)
+    qraux = np.zeros(p)
+    work = np.zeros((p, 2))
+    ib = np.zeros(4, dtype=np.int32)
+    db = np.zeros(2)
+    k = _dqrdc2(X, float(tol), jpvt, qraux, work, ib, db)
+    return X, int(k), qraux, jpvt
+
+
+def dqrls_blas(x: np.ndarray, y: np.ndarray, tol: float):
+    """Same contract as :func:`pypando.rstats.dqrls`, BLAS-exact."""
+    qr, k, qraux, pivot = dqrdc2_blas(x, tol)
+    p = qr.shape[1]
+    b = np.zeros(p)
+    if k > 0:
+        ib = np.zeros(4, dtype=np.int32)
+        db = np.zeros(2)
+        _dqrsl_b(qr, k, qraux, np.ascontiguousarray(y, dtype=np.float64), b, ib, db)
+    return {"coefficients": b, "rank": k, "pivot": pivot, "qr": qr, "qraux": qraux}

pypando-0.1.0/pypando/_wilcox.py

@@ -0,0 +1,77 @@
+"""One-sample Wilcoxon signed rank test as in R 4.4 (``stats::wilcox.test``).
+
+R 4.4.x (the reference environment, R 4.4.3) drops zeros, ranks
+``abs(x)`` without rounding (``digits.rank = Inf``) and uses the exact
+null distribution when ``n < 50`` with no ties and no zeros; otherwise the
+normal approximation with tie correction and continuity correction.
+R >= 4.6 changed the zero handling; this follows 4.4.
+"""
+from __future__ import annotations
+
+import math
+
+import numpy as np
+from scipy import stats
+
+__all__ = ["wilcox_signed_rank_pvalue", "psignrank"]
+
+
+def _csignrank_counts(n: int) -> np.ndarray:
+    """Number of subsets of {1..n} with each sum 0..n(n+1)/2."""
+    u = n * (n + 1) // 2
+    c = np.zeros(u + 1, dtype=object)
+    c[0] = 1
+    for k in range(1, n + 1):
+        c[k:] = c[k:] + c[:-k] if k <= u else c[k:]
+    return c
+
+
+def psignrank(q: float, n: int, lower_tail: bool = True) -> float:
+    """``stats::psignrank`` (exact)."""
+    q = math.floor(q + 1e-7)
+    u = n * (n + 1) // 2
+    if q < 0:
+        return 0.0 if lower_tail else 1.0
+    if q >= u:
+        return 1.0 if lower_tail else 0.0
+    c = _csignrank_counts(n)
+    total = 2**n
+    low = sum(c[: q + 1])
+    p = low / total
+    return float(p) if lower_tail else float((total - low) / total)
+
+
+def wilcox_signed_rank_pvalue(x, mu: float = 0.0, correct: bool = True, exact=None) -> float:
+    """``wilcox.test(x, mu = mu)$p.value``, two-sided, R 4.4 semantics."""
+    x = np.asarray(x, dtype=np.float64)
+    x = x[~np.isnan(x)]
+    if len(x) < 1:
+        raise ValueError("not enough (non-missing) 'x' observations")
+    x = x - mu
+    zeroes = bool(np.any(x == 0))
+    if zeroes:
+        x = x[x != 0]
+    n = float(len(x))
+    if exact is None:
+        exact = n < 50
+    r = stats.rankdata(np.abs(x), method="average")
+    statistic = float(r[x > 0].sum())
+    ties = len(r) != len(np.unique(r))
+    if exact and not ties and not zeroes:
+        ni = int(n)
+        if statistic > n * (n + 1) / 4:
+            p = psignrank(statistic - 1, ni, lower_tail=False)
+        else:
+            p = psignrank(statistic, ni)
+        return min(2 * p, 1.0)
+    _, nties = np.unique(r, return_counts=True)
+    z = statistic - n * (n + 1) / 4
+    sigma = math.sqrt(max(0.0, n * (n + 1) * (2 * n + 1) / 24 - float(np.sum(nties.astype(float) ** 3 - nties)) / 48))
+    correction = math.copysign(0.5, z) if (correct and z != 0) else 0.0
+    # IEEE arithmetic as in R: sigma = 0 (e.g. all values were zeros and were
+    # dropped) gives z = NaN (0/0) or +-Inf, and the p-value NaN or 0.
+    with np.errstate(divide="ignore", invalid="ignore"):
+        z = np.float64(z - correction) / np.float64(sigma)
+    if np.isnan(z):
+        return float("nan")
+    return float(2 * min(stats.norm.cdf(z), stats.norm.sf(z)))