Increase test coverage & drop python versions (#84)

* some more testing

* new environment

* make use of the toml defaults

* update python versions in CI/CD

Author: williambdean

.github/workflows/docs.yml

@@ -15,6 +15,6 @@ jobs:
           fetch-depth: 0
       - uses: actions/setup-python@v4
         with:
-          python-version: 3.9
+          python-version: 3.10
       - run: pip install mkdocs mkdocs-material mkdocs-markdownextradata-plugin mkdocs-git-revision-date-localized-plugin "mkdocstrings[python]"
       - run: mkdocs gh-deploy --force

.github/workflows/tests.yml

@@ -9,7 +9,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest]
-        python-version: ['3.8', '3.9', '3.10', '3.11', '3.12']
+        python-version: ['3.10', '3.11', '3.12']
 
     steps:
     - uses: actions/checkout@v2

Makefile

@@ -4,18 +4,11 @@ test-generate-baseline:
 	poetry run pytest --mpl-generate-path=tests/example-plots tests/test_example_plots.py
 
 test: 
-	poetry run pytest \
-		--mpl --mpl-baseline-path=tests/example-plots \
-		--cov=conjugate \
-		--cov-report=xml --cov-report=term-missing \
-		tests
+	poetry run pytest tests
 
 cov: 
-	poetry run pytest \
-		--mpl --mpl-baseline-path=tests/example-plots \
-		--cov=conjugate \
-		--cov-report=html --cov-report=term-missing \
-		tests
+	poetry run pytest tests
+	coverage html
 	open htmlcov/index.html
 
 format: 

conjugate/_compound_gamma.py

@@ -9,7 +9,7 @@ def compound_gamma_pdf(x, a, b, q):
 
 
 class compound_gamma:
-    """ "Implementation to work like scipy distribution classes.
+    """Implementation to work like scipy distribution classes.
 
     Reference:
     https://en.wikipedia.org/wiki/Beta_prime_distribution#Generalization

conjugate/distributions.py

@@ -1,15 +1,15 @@
 """These are the supported distributions based on the conjugate models.
 
-Many have the `dist` attribute which is a <a href=https://docs.scipy.org/doc/scipy/reference/stats.html>scipy.stats distribution</a> object. From there, 
+Many have the `dist` attribute which is a <a href=https://docs.scipy.org/doc/scipy/reference/stats.html>scipy.stats distribution</a> object. From there,
 you can use the methods from scipy.stats to get the pdf, cdf, etc.
 
 Distributions can be plotted using the `plot_pmf` or `plot_pdf` methods of the distribution.
 
-```python 
-from conjugate.distribution import Beta 
+```python
+from conjugate.distribution import Beta
 
 beta = Beta(1, 1)
-scipy_dist = beta.dist 
+scipy_dist = beta.dist
 
 print(scipy_dist.mean())
 # 0.5
@@ -21,9 +21,9 @@
 beta.plot_pmf(label="beta distribution")
 ```
 
-Distributions like Poisson can be added with other Poissons or multiplied by numerical values in order to scale rate. For instance, 
+Distributions like Poisson can be added with other Poissons or multiplied by numerical values in order to scale rate. For instance,
 
-```python 
+```python
 daily_rate = 0.25
 daily_pois = Poisson(lam=daily_rate)
 
@@ -34,6 +34,7 @@
 Below are the currently supported distributions
 
 """
+
 from dataclasses import dataclass
 from typing import Any, Tuple, Union
 
@@ -1004,6 +1005,27 @@ def sample_variance(self, size: int, random_state=None) -> NUMERIC:
 
         return 1 / precision
 
+    def sample_mean(
+        self,
+        size: int,
+        return_variance: bool = False,
+        random_state=None,
+    ) -> Union[NUMERIC, Tuple[NUMERIC, NUMERIC]]:
+        """Sample mean from the normal distribution.
+
+        Args:
+            size: number of samples
+            return_variance: whether to return variance as well
+            random_state: random state
+
+        Returns:
+            samples from the normal distribution
+
+        """
+        return self.sample_beta(
+            size=size, return_variance=return_variance, random_state=random_state
+        )
+
     def sample_beta(
         self, size: int, return_variance: bool = False, random_state=None
     ) -> Union[NUMERIC, Tuple[NUMERIC, NUMERIC]]:

conjugate/models.py

@@ -6,14 +6,14 @@
 
 - Bernoulli / Binomial
 - Negative Binomial
-- Geometric 
+- Geometric
 - Hypergeometric
 - Poisson
 - Categorical / Multinomial
 
 ## Continuous
 
-- Normal 
+- Normal
 - Multivariate Normal
 - Linear Regression (Normal)
 - Log Normal
@@ -29,6 +29,7 @@
 Below are the supported models
 
 """
+
 from typing import Tuple
 
 import numpy as np
@@ -250,7 +251,7 @@ def negative_binomial_beta_posterior_predictive(
         BetaNegativeBinomial posterior predictive distribution
 
     """
-    return BetaNegativeBinomial(r=r, alpha=beta.alpha, beta=beta.beta)
+    return BetaNegativeBinomial(n=r, alpha=beta.alpha, beta=beta.beta)
 
 
 def hypergeometric_beta_binomial(

poetry.lock

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "conjugate-models"
-version = "0.7.1"
+version = "0.8.0"
 description = "Bayesian Conjugate Models in Python"
 authors = ["Will Dean <wd60622@gmail.com>"]
 license = "MIT"
@@ -22,10 +22,15 @@ classifiers = [
     "Operating System :: POSIX",
     "Operating System :: Unix",
     "Operating System :: MacOS",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
 ]
 
 [tool.poetry.dependencies]
-python = ">=3.8,<4.0"
+python = ">=3.10,<4.0"
 matplotlib = "*"
 numpy = "*"
 scipy = "*"
@@ -50,7 +55,7 @@ mkdocs-material = "^9.1.17"
 mkdocstrings = {extras = ["python"], version = "^0.22.0"}
 
 [tool.pytest.ini_options]
-addopts = "--mpl --mpl-baseline-path=tests/example-plots --cov=conjugate --cov-report=xml --cov-report=term-missing tests"
+addopts = "--mpl --mpl-baseline-path=tests/example-plots --cov=conjugate --cov-report=xml --cov-report=term-missing"
 
 [tool.tox]
 legacy_tox_ini = """
@@ -61,16 +66,14 @@ legacy_tox_ini = """
         py312
         py311
         py310
-        py39
-        py38
 
     [testenv]
     deps = 
         pytest 
         pytest-cov
         pytest-mpl
         pypika
-    commands = pytest
+    commands = pytest tests
 """
 
 [build-system]

pyproject.toml

@@ -9,23 +9,35 @@
 from scipy import __version__ as scipy_version
 
 from conjugate.distributions import (
-    get_beta_param_from_mean_and_alpha,
     Beta,
+    BetaBinomial,
     BetaNegativeBinomial,
+    Geometric,
+    Binomial,
+    CompoundGamma,
     Dirichlet,
-    Gamma,
     Exponential,
-    NegativeBinomial,
-    Poisson,
-    Normal,
+    Gamma,
+    NormalGamma,
+    InverseGamma,
+    InverseWishart,
+    Hypergeometric,
+    LogNormal,
+    Lomax,
     MultivariateNormal,
-    StudentT,
     MultivariateStudentT,
-    InverseWishart,
-    NormalInverseWishart,
-    InverseGamma,
+    NegativeBinomial,
+    Normal,
     NormalInverseGamma,
-    CompoundGamma,
+    NormalInverseWishart,
+    Pareto,
+    Poisson,
+    ScaledInverseChiSquared,
+    StudentT,
+    Uniform,
+    VectorizedDist,
+    VonMises,
+    get_beta_param_from_mean_and_alpha,
 )
 
 
@@ -47,6 +59,18 @@ def test_beta(alpha, beta) -> None:
     assert isinstance(ax, plt.Axes)
 
 
+def test_beta_uninformative() -> None:
+    beta = Beta.uninformative()
+    assert beta.alpha == 1.0
+    assert beta.beta == 1.0
+
+
+def test_beta_from_success_and_failures() -> None:
+    beta = Beta.from_successes_and_failures(successes=0, failures=0)
+    assert beta.alpha == 1.0
+    assert beta.beta == 1.0
+
+
 @pytest.mark.parametrize("mean", [0.025, 0.5, 0.75])
 @pytest.mark.parametrize("alpha", [1, 10, 100])
 def test_beta_mean_constructor(mean: float, alpha: float) -> None:
@@ -251,6 +275,9 @@ def test_normal_inverse_wishart() -> None:
     mean = distribution.sample_mean(size=1)
     assert mean.shape == (1, 2)
 
+    _, variance = distribution.sample_mean(size=1, return_variance=True)
+    assert variance.shape == (1, 2, 2)
+
 
 @pytest.mark.parametrize("n_features", [1, 2, 3])
 @pytest.mark.parametrize("n_samples", [1, 2, 10])
@@ -296,3 +323,110 @@ def test_normal_inverse_gamma(n_features, n_samples) -> None:
 def test_compound_gamma(a, b, q, size) -> None:
     dist = CompoundGamma(alpha=1, beta=1, lam=1)
     assert dist.dist.rvs(size=size).shape == size
+
+
+def test_binomial_max_value() -> None:
+    n = np.array([10, 20, 15])
+    p = 0.5
+    binomial = Binomial(n=n, p=p)
+
+    assert binomial.max_value == 20
+
+
+def test_dirichlet_rvs() -> None:
+    dirichlet = Dirichlet(alpha=np.array([[1, 2, 3], [1, 1, 1]]))
+
+    dist = dirichlet.dist
+    assert isinstance(dist, VectorizedDist)
+    samples = dist.rvs(size=10)
+    assert isinstance(samples, np.ndarray)
+
+
+@pytest.mark.parametrize(
+    "dist",
+    [
+        Binomial(n=10, p=0.5),
+        Geometric(p=0.5),
+        BetaBinomial(n=10, alpha=1, beta=1),
+        Poisson(lam=1),
+        BetaNegativeBinomial(n=10, alpha=1, beta=1),
+        NegativeBinomial(n=10, p=0.5),
+        Hypergeometric(N=100, k=5, n=10),
+    ],
+)
+def test_plot_pmf(dist) -> None:
+    dist.max_value = 10
+    ax = dist.plot_pmf()
+    assert isinstance(ax, plt.Axes)
+
+
+@pytest.mark.parametrize(
+    "dist",
+    [
+        Beta(alpha=1, beta=1),
+        Gamma(alpha=1, beta=1),
+        CompoundGamma(alpha=1, beta=1, lam=1),
+        LogNormal(mu=1, sigma=1),
+        ScaledInverseChiSquared(nu=1, sigma2=1),
+        VonMises(mu=0, kappa=1),
+        Lomax(alpha=1, lam=1),
+        StudentT(mu=0, sigma=1, nu=10),
+        InverseGamma(alpha=1, beta=1),
+        Pareto(x_m=10, alpha=1),
+        Uniform(low=10, high=20),
+        Normal(mu=0, sigma=1),
+        Exponential(lam=1),
+    ],
+)
+def test_plot_pdf(dist) -> None:
+    dist.max_value = 10
+    dist.min_value = 0
+    ax = dist.plot_pdf()
+    assert isinstance(ax, plt.Axes)
+
+
+def test_normal_gamma() -> None:
+    normal_gamma = NormalGamma(
+        mu=0,
+        lam=1,
+        alpha=1,
+        beta=1,
+    )
+
+    assert normal_gamma.gamma == Gamma(alpha=1, beta=1)
+
+    mean = normal_gamma.sample_mean(size=10)
+    assert mean.shape == (10,)
+
+    _, variance = normal_gamma.sample_mean(size=1, return_variance=True)
+    assert variance.shape == (1,)
+
+
+def test_scaled_inverse_chi_squared_round_trip() -> None:
+    inverse_gamma = InverseGamma(alpha=1, beta=1)
+    scaled_inverse_gamma = ScaledInverseChiSquared.from_inverse_gamma(inverse_gamma)
+    back_again = scaled_inverse_gamma.to_inverse_gamma()
+
+    assert inverse_gamma == back_again
+
+
+def test_combining_poisson() -> None:
+    poisson_1 = Poisson(lam=1)
+    poisson_2 = Poisson(lam=2)
+    poisson_3 = poisson_1 + poisson_2
+    assert poisson_3 == Poisson(lam=3)
+
+
+def test_scaling_of_normal() -> None:
+    normal = Normal(mu=0, sigma=1)
+
+    scaled_normal = 4 * normal
+    assert scaled_normal == Normal(mu=0, sigma=2)
+
+
+def test_normal_alternative_constructors() -> None:
+    assert Normal.uninformative() == Normal(mu=0, sigma=1)
+    assert Normal.from_mean_and_variance(mean=0, variance=4) == Normal(mu=0, sigma=2)
+    assert Normal.from_mean_and_precision(mean=0, precision=1 / 4) == Normal(
+        mu=0, sigma=2
+    )