forestpd 0.1.0__tar.gz

forestpd-0.1.0/LICENSE

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

forestpd-0.1.0/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: forestpd
+Version: 0.1.0
+Summary: a package for maximizing phylogenetic diversity under phylogenetic and extinction uncertainty
+Author-email: Niels Holtgrefe <n.a.l.holtgrefe@tudelft.nl>
+License-Expression: MIT
+Project-URL: Documentation, https://nholtgrefe.github.io/forestpd/
+Project-URL: Repository, https://github.com/nholtgrefe/forestpd
+Keywords: phylogenetics,phylogenetic diversity,phylogenetic trees,bioinformatics,computational-biology
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: numba>=0.56.0
+Provides-Extra: phylozoo
+Requires-Dist: phylozoo>=0.4.1; extra == "phylozoo"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0.0; extra == "test"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: phylozoo>=0.4.1; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=7.0.0; extra == "docs"
+Requires-Dist: pydata-sphinx-theme>=0.15.0; extra == "docs"
+Requires-Dist: sphinx-copybutton>=0.5.0; extra == "docs"
+Requires-Dist: matplotlib>=3.5.0; extra == "docs"
+Dynamic: license-file
+
+[![PyPI](https://img.shields.io/pypi/v/forestpd)](https://pypi.org/project/forestpd/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue)](https://github.com/nholtgrefe/forestpd/blob/main/LICENSE)
+[![Docs](https://img.shields.io/badge/docs-stable-blue)](https://nholtgrefe.github.io/forestpd/)
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nholtgrefe/forestpd/main/docs/source/_static/forestpd-logo-dark.svg">
+  <img src="https://raw.githubusercontent.com/nholtgrefe/forestpd/main/docs/source/_static/forestpd-logo.svg" alt="ForestPD logo" width="360" align="right">
+</picture>
+
+**ForestPD** (Python package `forestpd`) chooses which taxa to protect so that as much
+phylogenetic diversity (PD) as possible is preserved across many phylogenetic trees at once. It uses [numba](https://numba.pydata.org/) for JIT-accelerated computation, and
+connects to [phylozoo](https://github.com/nholtgrefe/phylozoo) for plotting and further analysis.
+
+<br clear="right">
+
+## Key Features
+
+- **Many trees at once**: maximize PD summed over a whole collection of trees, such as posterior samples, bootstrap replicates or gene trees, optionally weighted per tree, with no summary tree or network in between.
+- **Budgets and extinction risks**: assign integer costs to taxa and maximize PD under a budget; optional survival probabilities make the objective the expected PD of the surviving taxa.
+- **Whole budget curves**: a single run gives the optimum, and optionally an optimal taxon set, for every budget up to the one asked for.
+- **Exact, and fast when the trees mostly agree**: the running time is exponential only in the size of agreement forests of the clusters shared by all trees, so ForestPD scales to tens of thousands of taxa and thousands of trees.
+- **Agreement forests**: a fast built-in heuristic, or minimum agreement forests through the optional [maffe](https://github.com/roehrt/maffe) solver.
+- **Rooted and unrooted PD**: unrooted by default, rooted with `rooted=True`.
+- **Interoperability**: read and write Newick, export the trees as one weighted split system (NEXUS) for split-diversity tools such as PDA, and convert to and from PhyloZoo trees.
+
+## Installation
+
+```bash
+pip install forestpd
+```
+
+Runtime dependencies (`numpy`, `numba`) are installed automatically. For conversion to and from
+PhyloZoo (e.g. for plotting), or for development:
+
+```bash
+pip install "forestpd[phylozoo]"   # PhyloZoo conversion
+pip install "forestpd[dev]"        # testing
+```
+
+Minimum agreement forests need [maffe](https://github.com/roehrt/maffe), which is built from
+source; see the [installation guide](https://nholtgrefe.github.io/forestpd/installation.html).
+
+## Quickstart
+
+Choose the taxa to protect on two trees, then add costs and survival probabilities and solve for
+several budgets in one run:
+
+```python
+import forestpd as fpd
+
+trees = ["(A:1,B:1,(C:1,D:1):2);", "(A:1,C:1,(B:1,D:1):2);"]  # or a file, one Newick tree per line
+
+result = fpd.optimize_maxmpd(trees, budget=2, return_taxa=True)
+print(result.value)         # 8.0
+print(sorted(result.taxa))  # ['B', 'C']  (['A', 'D'] is optimal too)
+
+# Costs (default 1) and survival probabilities of unprotected taxa (default 0)
+instance = fpd.MaxMPDInstance(trees, costs={"A": 2, "C": 3}, survival={"B": 0.5, "D": 0.2})
+budgets = [1, 2, 3, 4]
+for budget, r in zip(budgets, instance.optimize_many(budgets, return_taxa=True)):
+    print(budget, round(r.value, 2), sorted(r.taxa))
+# 1 3.0 ['D']
+# 2 6.0 ['B', 'D']
+# 3 9.0 ['A', 'D']
+# 4 10.0 ['A', 'B', 'D']
+```
+
+See the [user guide](https://nholtgrefe.github.io/forestpd/manual.html) for everything else,
+including rooted PD, per-tree weights, pruning trees to a taxon set, and the choice of agreement
+forest.
+
+## Documentation
+
+For the full manual, API reference, worked examples, and installation guide, visit the
+**[ForestPD docs](https://nholtgrefe.github.io/forestpd/)**.
+
+## Citation
+
+If you use ForestPD, please cite:
+
+> Niels Holtgrefe, Jannik Schestag, and Norbert Zeh.
+> **ForestPD: Maximizing Phylogenetic Diversity under Phylogenetic and Extinction Uncertainty.**
+> 2026.

forestpd-0.1.0/README.md

@@ -0,0 +1,83 @@
+[![PyPI](https://img.shields.io/pypi/v/forestpd)](https://pypi.org/project/forestpd/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue)](https://github.com/nholtgrefe/forestpd/blob/main/LICENSE)
+[![Docs](https://img.shields.io/badge/docs-stable-blue)](https://nholtgrefe.github.io/forestpd/)
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/nholtgrefe/forestpd/main/docs/source/_static/forestpd-logo-dark.svg">
+  <img src="https://raw.githubusercontent.com/nholtgrefe/forestpd/main/docs/source/_static/forestpd-logo.svg" alt="ForestPD logo" width="360" align="right">
+</picture>
+
+**ForestPD** (Python package `forestpd`) chooses which taxa to protect so that as much
+phylogenetic diversity (PD) as possible is preserved across many phylogenetic trees at once. It uses [numba](https://numba.pydata.org/) for JIT-accelerated computation, and
+connects to [phylozoo](https://github.com/nholtgrefe/phylozoo) for plotting and further analysis.
+
+<br clear="right">
+
+## Key Features
+
+- **Many trees at once**: maximize PD summed over a whole collection of trees, such as posterior samples, bootstrap replicates or gene trees, optionally weighted per tree, with no summary tree or network in between.
+- **Budgets and extinction risks**: assign integer costs to taxa and maximize PD under a budget; optional survival probabilities make the objective the expected PD of the surviving taxa.
+- **Whole budget curves**: a single run gives the optimum, and optionally an optimal taxon set, for every budget up to the one asked for.
+- **Exact, and fast when the trees mostly agree**: the running time is exponential only in the size of agreement forests of the clusters shared by all trees, so ForestPD scales to tens of thousands of taxa and thousands of trees.
+- **Agreement forests**: a fast built-in heuristic, or minimum agreement forests through the optional [maffe](https://github.com/roehrt/maffe) solver.
+- **Rooted and unrooted PD**: unrooted by default, rooted with `rooted=True`.
+- **Interoperability**: read and write Newick, export the trees as one weighted split system (NEXUS) for split-diversity tools such as PDA, and convert to and from PhyloZoo trees.
+
+## Installation
+
+```bash
+pip install forestpd
+```
+
+Runtime dependencies (`numpy`, `numba`) are installed automatically. For conversion to and from
+PhyloZoo (e.g. for plotting), or for development:
+
+```bash
+pip install "forestpd[phylozoo]"   # PhyloZoo conversion
+pip install "forestpd[dev]"        # testing
+```
+
+Minimum agreement forests need [maffe](https://github.com/roehrt/maffe), which is built from
+source; see the [installation guide](https://nholtgrefe.github.io/forestpd/installation.html).
+
+## Quickstart
+
+Choose the taxa to protect on two trees, then add costs and survival probabilities and solve for
+several budgets in one run:
+
+```python
+import forestpd as fpd
+
+trees = ["(A:1,B:1,(C:1,D:1):2);", "(A:1,C:1,(B:1,D:1):2);"]  # or a file, one Newick tree per line
+
+result = fpd.optimize_maxmpd(trees, budget=2, return_taxa=True)
+print(result.value)         # 8.0
+print(sorted(result.taxa))  # ['B', 'C']  (['A', 'D'] is optimal too)
+
+# Costs (default 1) and survival probabilities of unprotected taxa (default 0)
+instance = fpd.MaxMPDInstance(trees, costs={"A": 2, "C": 3}, survival={"B": 0.5, "D": 0.2})
+budgets = [1, 2, 3, 4]
+for budget, r in zip(budgets, instance.optimize_many(budgets, return_taxa=True)):
+    print(budget, round(r.value, 2), sorted(r.taxa))
+# 1 3.0 ['D']
+# 2 6.0 ['B', 'D']
+# 3 9.0 ['A', 'D']
+# 4 10.0 ['A', 'B', 'D']
+```
+
+See the [user guide](https://nholtgrefe.github.io/forestpd/manual.html) for everything else,
+including rooted PD, per-tree weights, pruning trees to a taxon set, and the choice of agreement
+forest.
+
+## Documentation
+
+For the full manual, API reference, worked examples, and installation guide, visit the
+**[ForestPD docs](https://nholtgrefe.github.io/forestpd/)**.
+
+## Citation
+
+If you use ForestPD, please cite:
+
+> Niels Holtgrefe, Jannik Schestag, and Norbert Zeh.
+> **ForestPD: Maximizing Phylogenetic Diversity under Phylogenetic and Extinction Uncertainty.**
+> 2026.

forestpd-0.1.0/pyproject.toml

@@ -0,0 +1,129 @@
+[build-system]
+requires = ["setuptools>=77.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "forestpd"
+dynamic = ["version"]
+authors = [
+    {name = "Niels Holtgrefe", email = "n.a.l.holtgrefe@tudelft.nl"},
+]
+description = "a package for maximizing phylogenetic diversity under phylogenetic and extinction uncertainty"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering :: Bio-Informatics",
+]
+keywords = [
+    "phylogenetics",
+    "phylogenetic diversity",
+    "phylogenetic trees",
+    "bioinformatics",
+    "computational-biology",
+]
+dependencies = [
+    "numpy>=1.20.0",
+    # Compiles the hot loops (Newick parsing, cluster reduction, profiles, the signature DP,
+    # split systems). Every kernel keeps a NumPy/Python fallback that is used if Numba cannot be
+    # imported, but that path is far slower.
+    "numba>=0.56.0",
+]
+
+[project.optional-dependencies]
+# Optional: conversion to and from PhyloZoo networks (forestpd.io.pz), which opens up plotting
+# and the rest of the PhyloZoo ecosystem. The core parses Newick itself and does not need it.
+phylozoo = [
+    "phylozoo>=0.4.1",
+]
+test = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+    "mypy>=1.0.0",
+    "black>=23.0.0",
+    "ruff>=0.1.0",
+    "phylozoo>=0.4.1",
+]
+# The documentation site (docs/): Sphinx with the PyData theme; matplotlib draws the examples' figure.
+docs = [
+    "sphinx>=7.0.0",
+    "pydata-sphinx-theme>=0.15.0",
+    "sphinx-copybutton>=0.5.0",
+    "matplotlib>=3.5.0",
+]
+
+[project.urls]
+Documentation = "https://nholtgrefe.github.io/forestpd/"
+Repository = "https://github.com/nholtgrefe/forestpd"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.dynamic]
+version = {attr = "forestpd.__version__"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+forestpd = ["py.typed"]
+
+[tool.pytest.ini_options]
+# Collect the test suite plus the doctests embedded in the source (the docstring Examples double as
+# executable tests, per the project conventions) and in the documentation pages.
+testpaths = ["tests", "src", "docs/source"]
+python_files = ["test_*.py", "*_test.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = [
+    "--strict-markers",
+    "--tb=short",
+    "--import-mode=importlib",
+    "--doctest-modules",
+    "--doctest-glob=*.rst",
+    # io/pz.py imports PhyloZoo, an optional extra; tests/test_pz.py covers it instead
+    "--ignore=src/forestpd/io/pz.py",
+]
+markers = [
+    "slow: marks tests as slow (deselect with '-m \"not slow\"')",
+]
+
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = false
+disallow_incomplete_defs = false
+check_untyped_defs = true
+no_implicit_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_no_return = true
+
+# PhyloZoo does not ship a py.typed marker yet, so it has no inline type information.
+[[tool.mypy.overrides]]
+module = ["phylozoo", "phylozoo.*"]
+ignore_missing_imports = true
+
+[tool.black]
+line-length = 100
+target-version = ['py310', 'py311']
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+# Ruff's classic default set, made explicit so the check does not change when a new
+# ruff release extends its defaults (0.16 enabled I/UP/SIM/RUF rules by default).
+select = ["E4", "E7", "E9", "F"]

forestpd-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

forestpd-0.1.0/src/forestpd/__init__.py

@@ -0,0 +1,65 @@
+"""
+forestpd — maximizing phylogenetic diversity under phylogenetic and extinction uncertainty.
+
+Solves MaxMPD: given unrooted weighted trees on a shared taxon set, per-tree weights ``w_j``,
+integer taxon costs and a budget ``B``, choose ``S`` with ``c(S) <= B`` maximizing
+``sum_j w_j PD_{T_j}(S)`` — or, with per-taxon survival probabilities, its expected value over the
+taxa that survive. Given a maximum agreement forest (MAF) of size ``k``, it solves MaxMPD in
+``O(2^k * n * B^2)`` time, where ``n`` is the total size of the trees. ``k`` is taken per common
+cluster, so it measures how much the trees disagree locally.
+
+The public entry points are :class:`MaxMPDInstance` (build it once, then call
+:meth:`~MaxMPDInstance.optimize`, :meth:`~MaxMPDInstance.optimize_many` and
+:meth:`~MaxMPDInstance.evaluate_pd`) and the one-call functions :func:`optimize_maxmpd`,
+:func:`optimize_many_maxmpd` and :func:`evaluate_maxmpd`. The pipeline has three stages —
+:mod:`forestpd.cluster`, :mod:`forestpd.maf`, :mod:`forestpd.algo` — described in ``README.md``.
+"""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+from .api import evaluate_maxmpd, optimize_many_maxmpd, optimize_maxmpd
+from .core import PhyloTree, TaxonRegistry
+from .exceptions import (
+    ForestPDError,
+    ForestPDImportError,
+    ForestPDInputError,
+    ForestPDValueError,
+    ForestPDWarning,
+)
+from .instance import MaxMPDInstance, MaxMPDResult, MaxMPDStructure
+from . import io, utils
+from .algo.convolve import HAVE_NUMBA as _HAVE_NUMBA
+
+if not _HAVE_NUMBA:  # pragma: no cover - depends on the environment
+    import warnings as _warnings
+
+    _warnings.warn(
+        "Numba could not be imported, so forestpd runs its NumPy/Python fallbacks: the same "
+        "results, but several times slower. Install numba (a dependency of forestpd) for full speed.",
+        ForestPDWarning,
+        stacklevel=2,
+    )
+
+__all__ = [
+    "__version__",
+    # Public API
+    "MaxMPDInstance",
+    "optimize_maxmpd",
+    "optimize_many_maxmpd",
+    "evaluate_maxmpd",
+    "MaxMPDResult",
+    "MaxMPDStructure",
+    "io",
+    "utils",
+    # Core types
+    "PhyloTree",
+    "TaxonRegistry",
+    # Exceptions
+    "ForestPDError",
+    "ForestPDValueError",
+    "ForestPDInputError",
+    "ForestPDImportError",
+    "ForestPDWarning",
+]

forestpd-0.1.0/src/forestpd/_evaluate.py

@@ -0,0 +1,113 @@
+"""
+Fast evaluation of the objective of a taxon set: the trees as one weighted split table.
+
+The objective of a protected set ``S`` is a sum over all edges of all trees of
+``w_j * len_j(e) * P(one side keeps a survivor) * P(the other side does)``, where a side holding a
+taxon of ``S`` keeps one surely and otherwise with probability ``1 - prod (1 - a(x))`` over its
+taxa. Both probabilities depend on the edge only through its split, so the edges are grouped by
+split once (:func:`forestpd.io.splits.split_system`, compiled) and each distinct split carries its
+summed weight ``W_s``. Each split is stored by its smaller side, as a sparse row of taxon ids.
+
+Scoring a set is then two sparse sums per split, independent of the number of trees: the protected
+taxa on the stored side (the other side has the rest), and the summed ``log(1 - a(x))`` of its
+unprotected taxa (the other side has the rest of the total). This regroups the per-edge sum of
+the per-edge definition exactly; without survival probabilities it is the split
+diversity of ``S``, i.e. its weighted PD.
+"""
+
+from __future__ import annotations
+
+from typing import Sequence
+
+import numpy as np
+
+from .core.tree import PhyloTree
+from .io import _splits_kernel
+from .io import splits as _splits
+
+
+class SplitTable:
+    """
+    The weighted splits of a set of trees, ready to score taxon sets.
+
+    Parameters
+    ----------
+    trees : Sequence[PhyloTree]
+        The trees, all on leaves ``0..n_taxa-1``.
+    weights : numpy.ndarray
+        ``float64[t]``; the per-tree weights.
+    log_loss : numpy.ndarray
+        ``float64[n_taxa]``; ``log(1 - a(x))`` per taxon.
+
+    Examples
+    --------
+    >>> from forestpd.core.tree import PhyloTree
+    >>> t = PhyloTree.from_edges(6, [(0, 4), (1, 4), (4, 5), (2, 5), (3, 5)], [1.0] * 5,
+    ...                          {i: i for i in range(4)})
+    >>> table = SplitTable([t, t], np.array([1.0, 0.5]), np.zeros(4))
+    >>> table.value([0, 2])          # the path 0 - 4 - 5 - 2, in both trees: 3 + 1.5
+    4.5
+    """
+
+    def __init__(self, trees: Sequence[PhyloTree], weights: np.ndarray, log_loss: np.ndarray):
+        n_taxa = trees[0].n_leaves
+        members, offsets, split_weights = _splits._flat_split_system(trees, weights)
+        if _splits.USE_COMPILED and _splits_kernel.HAVE_NUMBA:
+            members, offsets = _splits_kernel.smaller_sides(members, offsets, n_taxa)
+        else:
+            members, offsets = _smaller_sides(members, offsets, n_taxa)
+        self.n_taxa = n_taxa
+        self.members = members
+        self.weights = split_weights
+        self.log_loss = np.asarray(log_loss, dtype=np.float64)
+        # Rows are nonempty (every side holds a taxon), so reduceat over these starts is exact.
+        self.starts = offsets[:-1]
+
+    def value(self, protected: Sequence[int]) -> float:
+        """
+        The objective of protecting the taxa ``protected`` (taxon ids).
+
+        Parameters
+        ----------
+        protected : Sequence[int]
+            Distinct taxon ids.
+
+        Returns
+        -------
+        float
+            ``sum_s W_s P(side A keeps a survivor) P(side B does)``.
+        """
+        if self.weights.size == 0:
+            return 0.0
+        is_protected = np.zeros(self.n_taxa, dtype=bool)
+        is_protected[np.asarray(list(protected), dtype=np.int64)] = True
+        n_protected = int(is_protected.sum())
+        unprotected_loss = np.where(is_protected, 0.0, self.log_loss)
+        total_loss = float(unprotected_loss.sum())
+
+        on_side = is_protected[self.members]
+        protected_a = np.add.reduceat(on_side.astype(np.int64), self.starts)
+        loss_a = np.add.reduceat(unprotected_loss[self.members], self.starts)
+        protected_b = n_protected - protected_a
+        loss_b = total_loss - loss_a
+        keeps_a = np.where(protected_a > 0, 1.0, 0.0 - np.expm1(loss_a))
+        keeps_b = np.where(protected_b > 0, 1.0, 0.0 - np.expm1(loss_b))
+        return float(np.dot(self.weights, keeps_a * keeps_b))
+
+
+def _smaller_sides(
+    members: np.ndarray, offsets: np.ndarray, n_taxa: int
+) -> tuple[np.ndarray, np.ndarray]:
+    """The NumPy version of :func:`forestpd.io._splits_kernel.smaller_sides`."""
+    sides = []
+    everyone = np.arange(n_taxa)
+    for r in range(offsets.size - 1):
+        side = members[offsets[r] : offsets[r + 1]]
+        sides.append(side if 2 * side.size <= n_taxa else np.setdiff1d(everyone, side))
+    out_offsets = np.zeros(len(sides) + 1, dtype=np.int64)
+    np.cumsum([side.size for side in sides], out=out_offsets[1:])
+    flat = np.concatenate(sides) if sides else np.empty(0, dtype=np.int64)
+    return flat.astype(np.int64), out_offsets
+
+
+__all__ = ["SplitTable"]