pyR0compute 0.1.0__tar.gz

pyr0compute-0.1.0/.gitignore

@@ -0,0 +1,2 @@
+.ipynb_checkpoints/
+.DS_Store

pyr0compute-0.1.0/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+## 0.1.0 (unreleased)
+
+First packaged release. The code of the original notebook was turned into an installable library.
+
+### Added
+- `R0Model`: models can be entered as text (`dS/dt = ...`), as a dict or as SymPy symbols.
+- Automatic detection of parameters: every symbol that is not a state variable.
+- Equations in any order; infected compartments given by name, symbol or index.
+- Safe parsing of names that are special in SymPy (`I`, `S`, `E`, `N`, `beta`, `gamma`, `lambda`) and `^` for powers.
+- Auxiliary definitions in text models (`N = S + I + R`).
+- Partial user-given disease-free equilibrium (`dfe={"S": "N"}`), list of all non-negative DFEs (`dfe_candidates`).
+- `report_latex()`: step-by-step report in LaTeX (document or Markdown for notebooks).
+- `R0_numeric`, `sensitivity_indices`, `report`, `latex`, `eigenvalues`, `next_generation_matrix_small`.
+- Informative exceptions (`ModelSpecificationError`, `DiseaseFreeEquilibriumError`, `NextGenerationError`).
+- Test suite (SIR, SEIR, vector-borne, literature models) and continuous integration.
+
+### Fixed
+- Terms with a division (e.g. `beta*S*I/N`) were never recognised as new infections, so R0 was silently returned as 0. The sign test `term.has(-1)` matched the exponent of `1/N`.
+- Coefficients such as `(1 - p)*beta*S*I` were split into a new-infection part and a spurious transition part, giving a wrong R0.
+- For vector-borne models the negative eigenvalue `-sqrt(...)` could be returned as R0; the Perron root is now used.
+- When the dominant eigenvalue depends on the parameters (competing strains), R0 is returned as `Max(...)` instead of an arbitrary branch.
+- Undetermined DFE values were replaced by unexplained symbols such as `S_eq`; an error now says which value must be given.
+- Several DFEs: the first solution returned by SymPy was taken silently.
+
+### Changed
+- `GeneralEpidemiologicalModel` keeps the original interface; `parameters` is now optional and the infected equations no longer need to come first.
+- Output is silent by default (`verbose=True` or `report()` for the step-by-step description).

pyr0compute-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yvan Baldera-Moreno
+
+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.

pyr0compute-0.1.0/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.5
+Name: pyR0compute
+Version: 0.1.0
+Summary: Symbolic computation of the basic reproduction number R0 via the next-generation matrix method
+Project-URL: Homepage, https://github.com/Yvan-BM-Git/pyR0compute
+Project-URL: Issues, https://github.com/Yvan-BM-Git/pyR0compute/issues
+Author: Yvan Baldera-Moreno
+License-Expression: MIT
+License-File: LICENSE
+Keywords: R0,basic reproduction number,compartmental models,epidemiology,mathematical immunology,next-generation matrix,symbolic computation,sympy
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.9
+Requires-Dist: numpy>=1.22
+Requires-Dist: sympy>=1.12
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == 'test'
+Description-Content-Type: text/markdown
+
+# pyR0compute
+
+Symbolic computation of the basic reproduction number $R_0$ of compartmental ODE models by the next-generation matrix method (van den Driessche & Watmough, 2002).
+
+Write the model, say which compartments are infected, and pyR0compute does the rest: every symbol that is not a state variable is treated as a parameter, the new-infection terms $\mathcal{F}$ and transitions $\mathcal{V}$ are identified, the disease-free equilibrium (DFE) is solved, and $R_0 = \rho(FV^{-1})$ is returned as a SymPy expression.
+
+[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Yvan-BM-Git/pyR0compute/blob/main/examples/pyR0compute_examples.ipynb)
+
+## Installation
+
+```bash
+pip install pyR0compute
+```
+
+Until the first release is on PyPI, install it from GitHub:
+
+```bash
+pip install git+https://github.com/Yvan-BM-Git/pyR0compute
+```
+
+Requires Python ≥ 3.9, SymPy and NumPy.
+
+## Quick start
+
+```python
+from pyr0compute import R0Model
+
+model = R0Model("""
+    dS/dt = Lambda - beta*S*I - mu*S
+    dE/dt = beta*S*I - (sigma + mu)*E
+    dI/dt = sigma*E - (gamma + mu)*I
+    dR/dt = gamma*I - mu*R
+""", infected=["E", "I"])
+
+model.parameters   # (Lambda, beta, gamma, mu, sigma)  <- detected automatically
+model.dfe          # {S: Lambda/mu, E: 0, I: 0, R: 0}
+model.R0           # Lambda*beta*sigma/(mu*(gamma + mu)*(mu + sigma))
+```
+
+The equations can be written in any order; there is no need to list the infected compartments first.
+
+### Three ways to enter a model
+
+```python
+# 1. Text: one "dX/dt = ..." (or "X' = ...") line per variable.
+#    Auxiliary lines such as "N = S + I + R" are substituted.
+R0Model("""
+    N = S + I + R
+    dS/dt = Lambda - beta*S*I/N - mu*S
+    dI/dt = beta*S*I/N - (gamma + mu)*I
+    dR/dt = gamma*I - mu*R
+""", infected=["I"])
+
+# 2. A dict {variable: right-hand side} (strings or SymPy expressions)
+R0Model({"S": "Lambda - beta*S*I - mu*S",
+         "I": "beta*S*I - (gamma + mu)*I"}, infected=["I"])
+
+# 3. SymPy symbols
+import sympy as sp
+S, I = sp.symbols("S I")
+beta, gamma, mu, Lam = sp.symbols("beta gamma mu Lambda")
+R0Model({S: Lam - beta*S*I - mu*S, I: beta*S*I - (gamma + mu)*I}, infected=[I])
+```
+
+Use subscripts in names for clean LaTeX: `mu_h`, `alpha_hv`, `Delta_h` are written $\mu_h$, $\alpha_{hv}$, $\Delta_h$. Names that are special in SymPy (`I`, `S`, `E`, `N`, `beta`, `gamma`, `Lambda`, even `lambda`) are plain symbols inside text models, and `^` means a power.
+
+### What you get
+
+| Attribute / method | Content |
+|---|---|
+| `R0` | Basic reproduction number (spectral radius of $FV^{-1}$) |
+| `parameters` | Parameters detected automatically |
+| `new_infections`, `transitions` | Terms $\mathcal{F}_i$ and $\mathcal{V}_i$ of each infected compartment |
+| `dfe`, `dfe_candidates` | Disease-free equilibrium used, and all non-negative ones found |
+| `F`, `V`, `K` | Jacobians at the DFE and next-generation matrix $K = FV^{-1}$ |
+| `next_generation_matrix_small` | $K$ restricted to compartments receiving new infections |
+| `eigenvalues` | Eigenvalues of $K$ |
+| `R0_numeric(values)` | Numerical spectral radius (for large models without a closed form) |
+| `sensitivity_indices(values=None)` | Normalized forward sensitivity indices $\Upsilon_p = \frac{\partial R_0}{\partial p}\frac{p}{R_0}$ |
+| `report()` | Step-by-step description of the whole computation |
+| `report_latex(style, standalone, mat_str)` | The same report in LaTeX (`"document"`, compilable with `standalone=True`) or Markdown for notebooks (`"markdown"`) |
+| `latex()` | LaTeX code of $R_0$ |
+
+### When the automatic choices need help
+
+* **Closed populations** (no births), e.g. the classic SIR: the DFE is not unique, so give it, `dfe={"S": "N"}`. The error message says which value is missing.
+* **Several DFEs** (e.g. logistic vector populations): the one with the most non-zero compartments is used and a warning is shown. Choose another with `dfe={...}`; all are in `model.dfe_candidates`.
+* **Custom decompositions**: the split $\mathcal{F}$/$\mathcal{V}$ is not unique. Override the automatic one with `new_infections={"E": "beta*S*I/N"}`.
+
+### How new infections are detected
+
+In the equation of an infected compartment, a positive term is a new infection when it involves an infected compartment and either (i) it is lost from an uninfected compartment (a transfer such as $S \to E$), or (ii) it involves an uninfected compartment and is not a transfer between infected compartments. Progression ($E \to I$), treatment failure, superinfection between strains, deaths and recoveries go to $\mathcal{V}$. `model.report()` shows the classification of every term and the reason.
+
+## Validation
+
+The test suite (`pytest`) reproduces known results: SIR (with and without vital dynamics, mass-action and frequency-dependent), SEIR, a vaccination model, Ross-Macdonald, a host-vector SEIR/SEI model with human-to-human transmission and logistic vectors, the treatment model of van den Driessche & Watmough (2002, §4.1), within-host target cell-infected cell-virus models and a two-strain model with superinfection. Symbolic results are also checked against the numerical spectral radius.
+
+## Previous interface
+
+Code written for the original notebook keeps working:
+
+```python
+from pyr0compute import GeneralEpidemiologicalModel
+model = GeneralEpidemiologicalModel(variables, parameters, equations, infected_indices)
+model.calculate_R0()
+```
+
+## Citation
+
+If you use pyR0compute in your research, please cite it (see `CITATION.cff`) together with:
+
+* van den Driessche, P., & Watmough, J. (2002). Reproduction numbers and sub-threshold endemic equilibria for compartmental models of disease transmission. *Mathematical Biosciences*, 180(1-2), 29-48.
+* Diekmann, O., Heesterbeek, J. A. P., & Roberts, M. G. (2010). The construction of next-generation matrices for compartmental epidemic models. *Journal of the Royal Society Interface*, 7(47), 873-885.
+
+## Resumen en español
+
+pyR0compute calcula simbólicamente el número básico de reproducción $R_0$ mediante el método de la matriz de próxima generación. Basta escribir el sistema de EDO e indicar los compartimentos infectados: todos los demás símbolos se reconocen automáticamente como parámetros, se identifican los términos de nuevas infecciones, se calcula el equilibrio libre de enfermedad y se obtiene $R_0$. El notebook `examples/pyR0compute_examples.ipynb` contiene ejemplos listos para Google Colab.
+
+## License
+
+MIT, see `LICENSE`.

pyr0compute-0.1.0/README.md

@@ -0,0 +1,121 @@
+# pyR0compute
+
+Symbolic computation of the basic reproduction number $R_0$ of compartmental ODE models by the next-generation matrix method (van den Driessche & Watmough, 2002).
+
+Write the model, say which compartments are infected, and pyR0compute does the rest: every symbol that is not a state variable is treated as a parameter, the new-infection terms $\mathcal{F}$ and transitions $\mathcal{V}$ are identified, the disease-free equilibrium (DFE) is solved, and $R_0 = \rho(FV^{-1})$ is returned as a SymPy expression.
+
+[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Yvan-BM-Git/pyR0compute/blob/main/examples/pyR0compute_examples.ipynb)
+
+## Installation
+
+```bash
+pip install pyR0compute
+```
+
+Until the first release is on PyPI, install it from GitHub:
+
+```bash
+pip install git+https://github.com/Yvan-BM-Git/pyR0compute
+```
+
+Requires Python ≥ 3.9, SymPy and NumPy.
+
+## Quick start
+
+```python
+from pyr0compute import R0Model
+
+model = R0Model("""
+    dS/dt = Lambda - beta*S*I - mu*S
+    dE/dt = beta*S*I - (sigma + mu)*E
+    dI/dt = sigma*E - (gamma + mu)*I
+    dR/dt = gamma*I - mu*R
+""", infected=["E", "I"])
+
+model.parameters   # (Lambda, beta, gamma, mu, sigma)  <- detected automatically
+model.dfe          # {S: Lambda/mu, E: 0, I: 0, R: 0}
+model.R0           # Lambda*beta*sigma/(mu*(gamma + mu)*(mu + sigma))
+```
+
+The equations can be written in any order; there is no need to list the infected compartments first.
+
+### Three ways to enter a model
+
+```python
+# 1. Text: one "dX/dt = ..." (or "X' = ...") line per variable.
+#    Auxiliary lines such as "N = S + I + R" are substituted.
+R0Model("""
+    N = S + I + R
+    dS/dt = Lambda - beta*S*I/N - mu*S
+    dI/dt = beta*S*I/N - (gamma + mu)*I
+    dR/dt = gamma*I - mu*R
+""", infected=["I"])
+
+# 2. A dict {variable: right-hand side} (strings or SymPy expressions)
+R0Model({"S": "Lambda - beta*S*I - mu*S",
+         "I": "beta*S*I - (gamma + mu)*I"}, infected=["I"])
+
+# 3. SymPy symbols
+import sympy as sp
+S, I = sp.symbols("S I")
+beta, gamma, mu, Lam = sp.symbols("beta gamma mu Lambda")
+R0Model({S: Lam - beta*S*I - mu*S, I: beta*S*I - (gamma + mu)*I}, infected=[I])
+```
+
+Use subscripts in names for clean LaTeX: `mu_h`, `alpha_hv`, `Delta_h` are written $\mu_h$, $\alpha_{hv}$, $\Delta_h$. Names that are special in SymPy (`I`, `S`, `E`, `N`, `beta`, `gamma`, `Lambda`, even `lambda`) are plain symbols inside text models, and `^` means a power.
+
+### What you get
+
+| Attribute / method | Content |
+|---|---|
+| `R0` | Basic reproduction number (spectral radius of $FV^{-1}$) |
+| `parameters` | Parameters detected automatically |
+| `new_infections`, `transitions` | Terms $\mathcal{F}_i$ and $\mathcal{V}_i$ of each infected compartment |
+| `dfe`, `dfe_candidates` | Disease-free equilibrium used, and all non-negative ones found |
+| `F`, `V`, `K` | Jacobians at the DFE and next-generation matrix $K = FV^{-1}$ |
+| `next_generation_matrix_small` | $K$ restricted to compartments receiving new infections |
+| `eigenvalues` | Eigenvalues of $K$ |
+| `R0_numeric(values)` | Numerical spectral radius (for large models without a closed form) |
+| `sensitivity_indices(values=None)` | Normalized forward sensitivity indices $\Upsilon_p = \frac{\partial R_0}{\partial p}\frac{p}{R_0}$ |
+| `report()` | Step-by-step description of the whole computation |
+| `report_latex(style, standalone, mat_str)` | The same report in LaTeX (`"document"`, compilable with `standalone=True`) or Markdown for notebooks (`"markdown"`) |
+| `latex()` | LaTeX code of $R_0$ |
+
+### When the automatic choices need help
+
+* **Closed populations** (no births), e.g. the classic SIR: the DFE is not unique, so give it, `dfe={"S": "N"}`. The error message says which value is missing.
+* **Several DFEs** (e.g. logistic vector populations): the one with the most non-zero compartments is used and a warning is shown. Choose another with `dfe={...}`; all are in `model.dfe_candidates`.
+* **Custom decompositions**: the split $\mathcal{F}$/$\mathcal{V}$ is not unique. Override the automatic one with `new_infections={"E": "beta*S*I/N"}`.
+
+### How new infections are detected
+
+In the equation of an infected compartment, a positive term is a new infection when it involves an infected compartment and either (i) it is lost from an uninfected compartment (a transfer such as $S \to E$), or (ii) it involves an uninfected compartment and is not a transfer between infected compartments. Progression ($E \to I$), treatment failure, superinfection between strains, deaths and recoveries go to $\mathcal{V}$. `model.report()` shows the classification of every term and the reason.
+
+## Validation
+
+The test suite (`pytest`) reproduces known results: SIR (with and without vital dynamics, mass-action and frequency-dependent), SEIR, a vaccination model, Ross-Macdonald, a host-vector SEIR/SEI model with human-to-human transmission and logistic vectors, the treatment model of van den Driessche & Watmough (2002, §4.1), within-host target cell-infected cell-virus models and a two-strain model with superinfection. Symbolic results are also checked against the numerical spectral radius.
+
+## Previous interface
+
+Code written for the original notebook keeps working:
+
+```python
+from pyr0compute import GeneralEpidemiologicalModel
+model = GeneralEpidemiologicalModel(variables, parameters, equations, infected_indices)
+model.calculate_R0()
+```
+
+## Citation
+
+If you use pyR0compute in your research, please cite it (see `CITATION.cff`) together with:
+
+* van den Driessche, P., & Watmough, J. (2002). Reproduction numbers and sub-threshold endemic equilibria for compartmental models of disease transmission. *Mathematical Biosciences*, 180(1-2), 29-48.
+* Diekmann, O., Heesterbeek, J. A. P., & Roberts, M. G. (2010). The construction of next-generation matrices for compartmental epidemic models. *Journal of the Royal Society Interface*, 7(47), 873-885.
+
+## Resumen en español
+
+pyR0compute calcula simbólicamente el número básico de reproducción $R_0$ mediante el método de la matriz de próxima generación. Basta escribir el sistema de EDO e indicar los compartimentos infectados: todos los demás símbolos se reconocen automáticamente como parámetros, se identifican los términos de nuevas infecciones, se calcula el equilibrio libre de enfermedad y se obtiene $R_0$. El notebook `examples/pyR0compute_examples.ipynb` contiene ejemplos listos para Google Colab.
+
+## License
+
+MIT, see `LICENSE`.

pyr0compute-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["hatchling>=1.21"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pyR0compute"
+dynamic = ["version"]
+description = "Symbolic computation of the basic reproduction number R0 via the next-generation matrix method"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Yvan Baldera-Moreno" }]
+requires-python = ">=3.9"
+dependencies = ["sympy>=1.12", "numpy>=1.22"]
+keywords = [
+  "basic reproduction number", "R0", "next-generation matrix", "epidemiology",
+  "mathematical immunology", "compartmental models", "symbolic computation", "sympy",
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Science/Research",
+  "Intended Audience :: Education",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Topic :: Scientific/Engineering :: Mathematics",
+  "Topic :: Scientific/Engineering :: Medical Science Apps.",
+]
+
+[project.optional-dependencies]
+test = ["pytest>=7"]
+
+[project.urls]
+Homepage = "https://github.com/Yvan-BM-Git/pyR0compute"
+Issues = "https://github.com/Yvan-BM-Git/pyR0compute/issues"
+
+[tool.hatch.version]
+path = "src/pyr0compute/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pyr0compute"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/pyr0compute", "tests", "README.md", "LICENSE", "CHANGELOG.md"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"

pyr0compute-0.1.0/src/pyr0compute/__init__.py

@@ -0,0 +1,39 @@
+"""pyR0compute: symbolic computation of the basic reproduction number R0.
+
+Implements the next-generation matrix method of van den Driessche & Watmough
+(2002) for compartmental ODE models. Write the model, say which compartments
+are infected, and every other symbol is treated as a parameter::
+
+    from pyr0compute import R0Model
+
+    model = R0Model('''
+        dS/dt = Lambda - beta*S*I - mu*S
+        dI/dt = beta*S*I - (gamma + mu)*I
+        dR/dt = gamma*I - mu*R
+    ''', infected=["I"])
+
+    model.R0          # Lambda*beta/(mu*(gamma + mu))
+"""
+
+from .compat import GeneralEpidemiologicalModel
+from .exceptions import (
+    DiseaseFreeEquilibriumError,
+    ModelSpecificationError,
+    NextGenerationError,
+    R0ComputeError,
+)
+from .model import R0Model
+from .parsing import parse_expression
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "R0Model",
+    "GeneralEpidemiologicalModel",
+    "parse_expression",
+    "R0ComputeError",
+    "ModelSpecificationError",
+    "DiseaseFreeEquilibriumError",
+    "NextGenerationError",
+    "__version__",
+]

pyr0compute-0.1.0/src/pyr0compute/compat.py

@@ -0,0 +1,79 @@
+"""Backward-compatible interface of the original notebook."""
+
+from __future__ import annotations
+
+from typing import Optional, Sequence
+
+import sympy as sp
+
+from .model import R0Model
+
+__all__ = ["GeneralEpidemiologicalModel"]
+
+
+class GeneralEpidemiologicalModel(R0Model):
+    """Interface of the original ``pyR0compute_examples.ipynb`` notebook.
+
+    Existing code keeps working, with two differences: the equations no longer
+    need to list the infected compartments first, and ``parameters`` is
+    optional (it is detected automatically). New code should use
+    :class:`R0Model`.
+
+    Parameters
+    ----------
+    variables, parameters, equations, infected_indices
+        As in the original notebook; ``infected_indices`` are positions in
+        ``variables``.
+    new_infection_terms
+        Optional list aligned with ``variables`` (zeros for uninfected).
+    equilibrium_point
+        Optional disease-free equilibrium aligned with ``variables``.
+    total_population
+        Accepted for compatibility; not needed.
+    verbose
+        Print the step-by-step report when :meth:`calculate_R0` is called
+        (default ``True``, like the original).
+    """
+
+    def __init__(
+        self,
+        variables: Sequence[sp.Symbol],
+        parameters: Optional[Sequence[sp.Symbol]],
+        equations: Sequence[sp.Expr],
+        infected_indices: Sequence[int],
+        new_infection_terms: Optional[Sequence[sp.Expr]] = None,
+        equilibrium_point: Optional[Sequence[sp.Expr]] = None,
+        total_population=None,
+        verbose: bool = True,
+        **kwargs,
+    ) -> None:
+        dfe = None
+        if equilibrium_point is not None:
+            dfe = dict(zip(variables, list(equilibrium_point)))
+        self._legacy_verbose = verbose
+        super().__init__(
+            equations=list(equations),
+            infected=list(infected_indices),
+            variables=list(variables),
+            parameters=list(parameters) if parameters else None,
+            new_infections=list(new_infection_terms) if new_infection_terms is not None else None,
+            dfe=dfe,
+            **kwargs,
+        )
+
+    def identify_F_V_terms(self):
+        """Return the vectors of new-infection and transition terms."""
+        F = sp.Matrix([self.new_infections[v] for v in self.infected])
+        V = sp.Matrix([self.transitions[v] for v in self.infected])
+        return F, V
+
+    def calculate_next_generation_matrices(self):
+        """Return ``(F, V)`` evaluated at the disease-free equilibrium."""
+        return self.F, self.V
+
+    def calculate_R0(self):
+        """Return R0 (printing the report if ``verbose``)."""
+        R0 = self.R0
+        if self._legacy_verbose:
+            print(self.report())
+        return R0

pyr0compute-0.1.0/src/pyr0compute/exceptions.py

@@ -0,0 +1,17 @@
+"""Exceptions raised by pyR0compute."""
+
+
+class R0ComputeError(ValueError):
+    """Base class for all pyR0compute errors."""
+
+
+class ModelSpecificationError(R0ComputeError):
+    """The model (equations, variables, infected compartments...) is ill-defined."""
+
+
+class DiseaseFreeEquilibriumError(R0ComputeError):
+    """The disease-free equilibrium could not be determined unambiguously."""
+
+
+class NextGenerationError(R0ComputeError):
+    """The next-generation matrix or its spectral radius could not be computed."""