sequential-importance-sampling 0.1.0__tar.gz

sequential_importance_sampling-0.1.0/LICENSE

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

sequential_importance_sampling-0.1.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: sequential-importance-sampling
+Version: 0.1.0
+Summary: Sequential importance sampling for contingency tables with fixed margins
+Author: gfrt0
+License-Expression: MIT
+Project-URL: Repository, https://github.com/gfrt0/sequential-importance-sampling
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: numba
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# Sequential Importance Sampling for Contingency Tables
+
+Numba-accelerated sequential importance sampling (SIS) for uniformly sampling **two-way** contingency tables with fixed row and column margins, following **Chen, Diaconis, Holmes, and Liu (2005, JASA)**.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```python
+import numpy as np
+from sequential_importance_sampling import sample_tables
+
+# Row and column margins from Chen et al. (2005)
+row_sums = np.array([10, 62, 13, 11, 39])
+col_sums = np.array([65, 25, 45])
+
+# Draw 150,000 importance-weighted tables
+tables, logq = sample_tables(row_sums, col_sums, num_samples=150_000, rng_seed=44042)
+
+# Estimate the number of tables with these margins
+# True value: 239,382,173 (Diaconis and Gangolli, 1995)
+print("Estimate:", np.exp(-logq).mean())
+```
+
+**Batch dimensions** are supported for sampling many independent two-way tables in parallel. If `row_sums` has shape `(R, d1, d2, ...)` and `col_sums` has shape `(C, d1, d2, ...)`, each combination of batch indices defines an independent R×C table problem. The output `tables` will have shape `(num_samples, d1, d2, ..., R, C)` with batch dims before table dims for C-contiguous access. Note that this does **not** extend to multi-way (3+) contingency tables with additional margin constraints — each batch element is a separate two-way table.
+
+## API
+
+| Function | Description |
+|---|---|
+| `sample_tables` | Main entry point — sample batches of tables with arbitrary batch dimensions |
+| `sample_table_sis` | Sample a single contingency table via column-wise SIS |
+
+`sample_tables` returns `(tables, logq)` where `logq` contains the log importance weights. Pass `parallel=False` to disable numba parallelism.
+
+## Tests
+
+Run the Diaconis-Gangolli counting verification:
+
+```bash
+python tests/test_diaconis_gangolli.py
+```
+
+```
+True count:               239,382,173
+SIS estimate (n=150k):    239,413,201
+Coefficient of variation: 0.9512
+Effective sample size:    78,750
+```
+
+Run the Holmes-Jones example from the Chen et al. paper:
+
+```bash
+python tests/test_holmes_jones.py
+```
+
+```
+Reference (Chen et al.):  3.383e16
+SIS estimate (n=1M):     3.382e+16
+log10 estimate:           16.5291
+log10 reference:          16.5293
+Coefficient of variation: 1.0537
+Effective sample size:    473,875
+```
+
+
+## References
+
+- Chen, Y., Diaconis, P., Holmes, S. P., & Liu, J. S. (2005). Sequential Monte Carlo methods for statistical analysis of tables. *Journal of the American Statistical Association*, 100(469), 109-120.
+- Diaconis, P., & Gangolli, A. (1995). Rectangular arrays with fixed margins. In *Discrete Probability and Algorithms* (pp. 15-41). Springer.

sequential_importance_sampling-0.1.0/README.md

@@ -0,0 +1,74 @@
+# Sequential Importance Sampling for Contingency Tables
+
+Numba-accelerated sequential importance sampling (SIS) for uniformly sampling **two-way** contingency tables with fixed row and column margins, following **Chen, Diaconis, Holmes, and Liu (2005, JASA)**.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```python
+import numpy as np
+from sequential_importance_sampling import sample_tables
+
+# Row and column margins from Chen et al. (2005)
+row_sums = np.array([10, 62, 13, 11, 39])
+col_sums = np.array([65, 25, 45])
+
+# Draw 150,000 importance-weighted tables
+tables, logq = sample_tables(row_sums, col_sums, num_samples=150_000, rng_seed=44042)
+
+# Estimate the number of tables with these margins
+# True value: 239,382,173 (Diaconis and Gangolli, 1995)
+print("Estimate:", np.exp(-logq).mean())
+```
+
+**Batch dimensions** are supported for sampling many independent two-way tables in parallel. If `row_sums` has shape `(R, d1, d2, ...)` and `col_sums` has shape `(C, d1, d2, ...)`, each combination of batch indices defines an independent R×C table problem. The output `tables` will have shape `(num_samples, d1, d2, ..., R, C)` with batch dims before table dims for C-contiguous access. Note that this does **not** extend to multi-way (3+) contingency tables with additional margin constraints — each batch element is a separate two-way table.
+
+## API
+
+| Function | Description |
+|---|---|
+| `sample_tables` | Main entry point — sample batches of tables with arbitrary batch dimensions |
+| `sample_table_sis` | Sample a single contingency table via column-wise SIS |
+
+`sample_tables` returns `(tables, logq)` where `logq` contains the log importance weights. Pass `parallel=False` to disable numba parallelism.
+
+## Tests
+
+Run the Diaconis-Gangolli counting verification:
+
+```bash
+python tests/test_diaconis_gangolli.py
+```
+
+```
+True count:               239,382,173
+SIS estimate (n=150k):    239,413,201
+Coefficient of variation: 0.9512
+Effective sample size:    78,750
+```
+
+Run the Holmes-Jones example from the Chen et al. paper:
+
+```bash
+python tests/test_holmes_jones.py
+```
+
+```
+Reference (Chen et al.):  3.383e16
+SIS estimate (n=1M):     3.382e+16
+log10 estimate:           16.5291
+log10 reference:          16.5293
+Coefficient of variation: 1.0537
+Effective sample size:    473,875
+```
+
+
+## References
+
+- Chen, Y., Diaconis, P., Holmes, S. P., & Liu, J. S. (2005). Sequential Monte Carlo methods for statistical analysis of tables. *Journal of the American Statistical Association*, 100(469), 109-120.
+- Diaconis, P., & Gangolli, A. (1995). Rectangular arrays with fixed margins. In *Discrete Probability and Algorithms* (pp. 15-41). Springer.

sequential_importance_sampling-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sequential-importance-sampling"
+version = "0.1.0"
+description = "Sequential importance sampling for contingency tables with fixed margins"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [
+    { name = "gfrt0" },
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+dependencies = [
+    "numpy",
+    "numba",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+]
+
+[project.urls]
+Repository = "https://github.com/gfrt0/sequential-importance-sampling"
+
+[tool.setuptools]
+py-modules = ["sequential_importance_sampling"]
+
+[tool.setuptools.package-dir]
+"" = "src"

sequential_importance_sampling-0.1.0/setup.cfg

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

sequential_importance_sampling-0.1.0/src/sequential_importance_sampling.egg-info/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: sequential-importance-sampling
+Version: 0.1.0
+Summary: Sequential importance sampling for contingency tables with fixed margins
+Author: gfrt0
+License-Expression: MIT
+Project-URL: Repository, https://github.com/gfrt0/sequential-importance-sampling
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: numba
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# Sequential Importance Sampling for Contingency Tables
+
+Numba-accelerated sequential importance sampling (SIS) for uniformly sampling **two-way** contingency tables with fixed row and column margins, following **Chen, Diaconis, Holmes, and Liu (2005, JASA)**.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```python
+import numpy as np
+from sequential_importance_sampling import sample_tables
+
+# Row and column margins from Chen et al. (2005)
+row_sums = np.array([10, 62, 13, 11, 39])
+col_sums = np.array([65, 25, 45])
+
+# Draw 150,000 importance-weighted tables
+tables, logq = sample_tables(row_sums, col_sums, num_samples=150_000, rng_seed=44042)
+
+# Estimate the number of tables with these margins
+# True value: 239,382,173 (Diaconis and Gangolli, 1995)
+print("Estimate:", np.exp(-logq).mean())
+```
+
+**Batch dimensions** are supported for sampling many independent two-way tables in parallel. If `row_sums` has shape `(R, d1, d2, ...)` and `col_sums` has shape `(C, d1, d2, ...)`, each combination of batch indices defines an independent R×C table problem. The output `tables` will have shape `(num_samples, d1, d2, ..., R, C)` with batch dims before table dims for C-contiguous access. Note that this does **not** extend to multi-way (3+) contingency tables with additional margin constraints — each batch element is a separate two-way table.
+
+## API
+
+| Function | Description |
+|---|---|
+| `sample_tables` | Main entry point — sample batches of tables with arbitrary batch dimensions |
+| `sample_table_sis` | Sample a single contingency table via column-wise SIS |
+
+`sample_tables` returns `(tables, logq)` where `logq` contains the log importance weights. Pass `parallel=False` to disable numba parallelism.
+
+## Tests
+
+Run the Diaconis-Gangolli counting verification:
+
+```bash
+python tests/test_diaconis_gangolli.py
+```
+
+```
+True count:               239,382,173
+SIS estimate (n=150k):    239,413,201
+Coefficient of variation: 0.9512
+Effective sample size:    78,750
+```
+
+Run the Holmes-Jones example from the Chen et al. paper:
+
+```bash
+python tests/test_holmes_jones.py
+```
+
+```
+Reference (Chen et al.):  3.383e16
+SIS estimate (n=1M):     3.382e+16
+log10 estimate:           16.5291
+log10 reference:          16.5293
+Coefficient of variation: 1.0537
+Effective sample size:    473,875
+```
+
+
+## References
+
+- Chen, Y., Diaconis, P., Holmes, S. P., & Liu, J. S. (2005). Sequential Monte Carlo methods for statistical analysis of tables. *Journal of the American Statistical Association*, 100(469), 109-120.
+- Diaconis, P., & Gangolli, A. (1995). Rectangular arrays with fixed margins. In *Discrete Probability and Algorithms* (pp. 15-41). Springer.

sequential_importance_sampling-0.1.0/src/sequential_importance_sampling.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/sequential_importance_sampling.py
+src/sequential_importance_sampling.egg-info/PKG-INFO
+src/sequential_importance_sampling.egg-info/SOURCES.txt
+src/sequential_importance_sampling.egg-info/dependency_links.txt
+src/sequential_importance_sampling.egg-info/requires.txt
+src/sequential_importance_sampling.egg-info/top_level.txt
+tests/test_diaconis_gangolli.py
+tests/test_holmes_jones.py

sequential_importance_sampling-0.1.0/src/sequential_importance_sampling.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sequential_importance_sampling-0.1.0/src/sequential_importance_sampling.egg-info/requires.txt

@@ -0,0 +1,5 @@
+numpy
+numba
+
+[dev]
+pytest

sequential_importance_sampling-0.1.0/src/sequential_importance_sampling.egg-info/top_level.txt

@@ -0,0 +1 @@
+sequential_importance_sampling

sequential_importance_sampling-0.1.0/src/sequential_importance_sampling.py

@@ -0,0 +1,204 @@
+import numba
+import numpy as np
+import math
+
+@numba.njit
+def count_bounded_compositions( s, bounds, K ):
+    """
+    Counts the number of integer vectors x with sum s and x[k] <= bounds[k].
+    Uses a 2-loop DP approach with complexity O(K*s).
+    """
+    dp = np.zeros((K + 1, s + 1), dtype=np.int64)
+    dp[0, 0] = 1
+
+    for k in range(1, K + 1):
+        bound_k = bounds[k - 1]
+        cumsum_prev_row = np.cumsum(dp[k - 1, :])
+        for j in range(s + 1):
+            upper_sum = cumsum_prev_row[j]
+            lower_sum_idx = j - bound_k - 1
+            lower_sum = cumsum_prev_row[lower_sum_idx] if lower_sum_idx >= 0 else 0
+            dp[k, j] = upper_sum - lower_sum
+    return dp[K, s]
+
+
+@numba.njit
+def _precompute_suffix_counts( column_sum, row_sums, K ):
+    """
+    Precompute suffix_counts[k, s] = number of compositions of s into
+    (x[k], ..., x[K-1]) with x[i] <= row_sums[i].
+
+    Built bottom-up from k = K-1 down to k = 0.  O(K * column_sum).
+    """
+    S = column_sum
+    suffix = np.zeros((K + 1, S + 1), dtype=np.int64)
+    suffix[K, 0] = 1
+
+    for k in range(K - 1, -1, -1):
+        bound_k = row_sums[k]
+        cumsum_next = np.cumsum(suffix[k + 1, :])
+        for s in range(S + 1):
+            upper = cumsum_next[s]
+            lower_idx = s - bound_k - 1
+            lower = cumsum_next[lower_idx] if lower_idx >= 0 else 0
+            suffix[k, s] = upper - lower
+
+    return suffix
+
+
+@numba.njit
+def sample_uniform_column( column_sum, row_sums, K ):
+    """
+    Uniformly sample integer vector x with sum column_sum and x[i] <= row_sums[i],
+    using suffix DP precomputation for O(K * column_sum) total work.
+
+    Returns (x, total_count) where total_count = number of valid compositions.
+    """
+    suffix = _precompute_suffix_counts(column_sum, row_sums, K)
+    total_count = suffix[0, column_sum]
+
+    output = np.zeros( K, dtype = np.int64 )
+    remaining = column_sum
+
+    for k in range(K - 1):
+        max_val = min( row_sums[k], remaining )
+
+        # Sample from unnormalized weights via linear scan.
+        # weight(val) = suffix[k+1, remaining - val]; sum = suffix[k, remaining].
+        target = np.random.random() * float(suffix[k, remaining])
+        cumulative = 0.0
+        chosen = max_val
+        for val in range(max_val + 1):
+            cumulative += float(suffix[k + 1, remaining - val])
+            if cumulative > target:
+                chosen = val
+                break
+
+        output[k] = chosen
+        remaining -= chosen
+
+    output[K - 1] = remaining
+    return output, total_count
+
+
+@numba.njit
+def sample_table_sis( row_sums, col_sums, K, C ):
+    """
+    Uniformly sample a single contingency table with fixed margins as in Chen Diaconis Holmes Liu (2005, JASA)
+    """
+    remaining = row_sums.copy()
+    output = np.zeros( (K, C), dtype = np.int64 )
+    log_q = 0.0
+
+    for c in range(C - 1):
+        col, total_count = sample_uniform_column( col_sums[c], remaining, K )
+        output[:, c] = col
+        log_q += math.log( total_count )
+        remaining -= col
+
+    output[:, C - 1] = remaining
+    return output, -log_q
+
+
+@numba.njit
+def _sample_tables_core(row_sums, col_sums, num_samples, rng_seed):
+    """
+    Sequential inner loop over (num_samples, n_batch).
+
+    row_sums: (n_batch, R) — each row is one batch element's row margins
+    col_sums: (n_batch, C) — each row is one batch element's column margins
+    """
+    n_batch = row_sums.shape[0]
+    R = row_sums.shape[1]
+    C = col_sums.shape[1]
+
+    tables = np.zeros((num_samples, n_batch, R, C), dtype=np.int64)
+    logq = np.zeros((num_samples, n_batch))
+
+    for s in range(num_samples):
+        for b in range(n_batch):
+            if rng_seed is not None:
+                np.random.seed(rng_seed + s * 104729 + b * 131)
+            table, lnq = sample_table_sis(row_sums[b].copy(), col_sums[b].copy(), R, C)
+            tables[s, b] = table
+            logq[s, b] = lnq
+
+    return tables, logq
+
+
+@numba.njit(parallel=True)
+def _sample_tables_core_parallel(row_sums, col_sums, num_samples, rng_seed):
+    """
+    Parallel inner loop: prange over num_samples, sequential over n_batch.
+
+    row_sums: (n_batch, R) — each row is one batch element's row margins
+    col_sums: (n_batch, C) — each row is one batch element's column margins
+    """
+    n_batch = row_sums.shape[0]
+    R = row_sums.shape[1]
+    C = col_sums.shape[1]
+
+    tables = np.zeros((num_samples, n_batch, R, C), dtype=np.int64)
+    logq = np.zeros((num_samples, n_batch))
+
+    for s in numba.prange(num_samples):
+        for b in range(n_batch):
+            if rng_seed is not None:
+                np.random.seed(rng_seed + s * 104729 + b * 131)
+            table, lnq = sample_table_sis(row_sums[b].copy(), col_sums[b].copy(), R, C)
+            tables[s, b] = table
+            logq[s, b] = lnq
+
+    return tables, logq
+
+
+def sample_tables(row_sums, col_sums, num_samples, rng_seed=None, parallel=True):
+    """
+    Sample contingency tables with fixed margins via sequential importance
+    sampling, following Chen, Diaconis, Holmes, and Liu (2005, JASA).
+
+    Inputs:
+        row_sums : array of shape (R, *batch) — row margins
+        col_sums : array of shape (C, *batch) — column margins
+            Batch dimensions (if any) must match between row_sums and col_sums.
+        num_samples : int — number of tables to draw
+        rng_seed    : optional int — seed for reproducibility
+        parallel    : bool — use numba parallel sampling (default True)
+
+    Outputs:
+        tables : int64 array of shape (num_samples, *batch, R, C)
+        logq   : float64 array of shape (num_samples, *batch)
+            Log importance weights. To estimate the number of tables with
+            the given margins, compute np.exp(-logq).mean().
+    """
+    row_sums = np.asarray(row_sums, dtype=np.int64)
+    col_sums = np.asarray(col_sums, dtype=np.int64)
+
+    R = row_sums.shape[0]
+    C = col_sums.shape[0]
+    batch_shape = row_sums.shape[1:]
+
+    assert col_sums.shape[1:] == batch_shape, (
+        f"Batch shapes must match: row_sums {row_sums.shape[1:]} vs col_sums {col_sums.shape[1:]}"
+    )
+
+    n_batch = int(np.prod(batch_shape)) if len(batch_shape) > 0 else 1
+
+    # Flatten batch dims and transpose so each batch element's margins are a
+    # contiguous row: (R, n_batch) -> (n_batch, R), same for col_sums.
+    row_flat = np.ascontiguousarray(row_sums.reshape(R, n_batch).T)
+    col_flat = np.ascontiguousarray(col_sums.reshape(C, n_batch).T)
+
+    if parallel:
+        tables_flat, logq_flat = _sample_tables_core_parallel(
+            row_flat, col_flat, num_samples, rng_seed
+        )
+    else:
+        tables_flat, logq_flat = _sample_tables_core(
+            row_flat, col_flat, num_samples, rng_seed
+        )
+
+    tables = tables_flat.reshape((num_samples,) + batch_shape + (R, C))
+    logq = logq_flat.reshape((num_samples,) + batch_shape)
+
+    return tables, logq

sequential_importance_sampling-0.1.0/tests/test_diaconis_gangolli.py

@@ -0,0 +1,45 @@
+"""
+Reproduce the counting result from Diaconis and Gangolli (1995):
+
+The number of 5x3 contingency tables of non-negative integers with
+row sums [10, 62, 13, 11, 39] and column sums [65, 25, 45] is
+exactly 239,382,173.
+
+We estimate this via sequential importance sampling following
+Chen, Diaconis, Holmes, and Liu (2005, JASA).
+"""
+
+import numpy as np
+from sequential_importance_sampling import sample_tables
+
+
+def test_diaconis_gangolli():
+    true_count = 239_382_173
+
+    row_sums = np.array([10, 62, 13, 11, 39])
+    col_sums = np.array([65, 25, 45])
+
+    _, logq = sample_tables(
+        row_sums, col_sums,
+        num_samples=150_000,
+        rng_seed=44042,
+    )
+
+    inv_w = np.exp(-logq)
+    estimate = inv_w.mean()
+    cv = inv_w.std() / inv_w.mean()
+    ess = 150_000 / (1 + cv ** 2)
+
+    print(f"True count:              {true_count:,}")
+    print(f"SIS estimate (n=150k):   {estimate:,.0f}")
+    print(f"Coefficient of variation: {cv:.4f}")
+    print(f"Effective sample size:   {ess:,.0f}")
+
+    # Allow 1% relative error
+    assert abs(estimate - true_count) / true_count < 0.01, (
+        f"Estimate {estimate:,.0f} too far from true count {true_count:,}"
+    )
+
+
+if __name__ == "__main__":
+    test_diaconis_gangolli()

sequential_importance_sampling-0.1.0/tests/test_holmes_jones.py

@@ -0,0 +1,50 @@
+"""
+Reproduce the counting result from Holmes and Jones (1996):
+
+A 5x4 contingency table with row sums [9, 49, 182, 478, 551]
+and column sums [9, 309, 355, 596].
+
+Chen et al. (2005, JASA) estimate the total number of tables
+as approximately 3.383 x 10^16 via SIS (Section 6.4).
+"""
+
+import numpy as np
+from sequential_importance_sampling import sample_tables
+
+
+def test_holmes_jones():
+    # Chen et al. (2005) SIS estimate: ~3.383 x 10^16
+    log10_reference = 16 + np.log10(3.383)
+
+    num_samples = 1_000_000
+
+    row_sums = np.array([9, 49, 182, 478, 551])
+    col_sums = np.array([9, 309, 355, 596])
+
+    _, logq = sample_tables(
+        row_sums, col_sums,
+        num_samples=num_samples,
+        rng_seed=44042,
+    )
+
+    inv_w = np.exp(-logq)
+    estimate = inv_w.mean()
+    log10_estimate = np.log10(estimate)
+    cv = inv_w.std() / inv_w.mean()
+    ess = num_samples / (1 + cv ** 2)
+
+    print(f"Reference (Chen et al.):  3.383e16")
+    print(f"SIS estimate (n=1M):     {estimate:.3e}")
+    print(f"log10 estimate:          {log10_estimate:.4f}")
+    print(f"log10 reference:         {log10_reference:.4f}")
+    print(f"Coefficient of variation: {cv:.4f}")
+    print(f"Effective sample size:   {ess:,.0f}")
+
+    # Allow 1% relative error on log10 scale
+    assert abs(log10_estimate - log10_reference) / log10_reference < 0.01, (
+        f"log10 estimate {log10_estimate:.4f} too far from reference {log10_reference:.4f}"
+    )
+
+
+if __name__ == "__main__":
+    test_holmes_jones()