arviz 0.23.3__py3-none-any.whl → 1.0.0rc0__py3-none-any.whl

arviz/tests/base_tests/test_stats_ecdf_utils.py

@@ -1,166 +0,0 @@
-import pytest
-
-import numpy as np
-import scipy.stats
-from ...stats.ecdf_utils import (
-    compute_ecdf,
-    ecdf_confidence_band,
-    _get_ecdf_points,
-    _simulate_ecdf,
-    _get_pointwise_confidence_band,
-)
-
-try:
-    import numba  # pylint: disable=unused-import
-
-    numba_options = [True, False]  # pylint: disable=invalid-name
-except ImportError:
-    numba_options = [False]  # pylint: disable=invalid-name
-
-
-def test_compute_ecdf():
-    """Test compute_ecdf function."""
-    sample = np.array([1, 2, 3, 3, 4, 5])
-    eval_points = np.arange(0, 7, 0.1)
-    ecdf_expected = (sample[:, None] <= eval_points).mean(axis=0)
-    assert np.allclose(compute_ecdf(sample, eval_points), ecdf_expected)
-    assert np.allclose(compute_ecdf(sample / 2 + 10, eval_points / 2 + 10), ecdf_expected)
-
-
-@pytest.mark.parametrize("difference", [True, False])
-def test_get_ecdf_points(difference):
-    """Test _get_ecdf_points."""
-    # if first point already outside support, no need to insert it
-    sample = np.array([1, 2, 3, 3, 4, 5, 5])
-    eval_points = np.arange(-1, 7, 0.1)
-    x, y = _get_ecdf_points(sample, eval_points, difference)
-    assert np.array_equal(x, eval_points)
-    assert np.array_equal(y, compute_ecdf(sample, eval_points))
-
-    # if first point is inside support, insert it if not in difference mode
-    eval_points = np.arange(1, 6, 0.1)
-    x, y = _get_ecdf_points(sample, eval_points, difference)
-    assert len(x) == len(eval_points) + 1 - difference
-    assert len(y) == len(eval_points) + 1 - difference
-
-    # if not in difference mode, first point should be (eval_points[0], 0)
-    if not difference:
-        assert x[0] == eval_points[0]
-        assert y[0] == 0
-        assert np.allclose(x[1:], eval_points)
-        assert np.allclose(y[1:], compute_ecdf(sample, eval_points))
-        assert x[-1] == eval_points[-1]
-        assert y[-1] == 1
-
-
-@pytest.mark.parametrize(
-    "dist", [scipy.stats.norm(3, 10), scipy.stats.binom(10, 0.5)], ids=["continuous", "discrete"]
-)
-@pytest.mark.parametrize("seed", [32, 87])
-def test_simulate_ecdf(dist, seed):
-    """Test _simulate_ecdf."""
-    ndraws = 1000
-    eval_points = np.arange(0, 1, 0.1)
-
-    rvs = dist.rvs
-
-    random_state = np.random.default_rng(seed)
-    ecdf = _simulate_ecdf(ndraws, eval_points, rvs, random_state=random_state)
-    random_state = np.random.default_rng(seed)
-    ecdf_expected = compute_ecdf(np.sort(rvs(ndraws, random_state=random_state)), eval_points)
-
-    assert np.allclose(ecdf, ecdf_expected)
-
-
-@pytest.mark.parametrize("prob", [0.8, 0.9])
-@pytest.mark.parametrize(
-    "dist", [scipy.stats.norm(3, 10), scipy.stats.poisson(100)], ids=["continuous", "discrete"]
-)
-@pytest.mark.parametrize("ndraws", [10_000])
-def test_get_pointwise_confidence_band(dist, prob, ndraws, num_trials=1_000, seed=57):
-    """Test _get_pointwise_confidence_band."""
-    eval_points = np.linspace(*dist.interval(0.99), 10)
-    cdf_at_eval_points = dist.cdf(eval_points)
-
-    ecdf_lower, ecdf_upper = _get_pointwise_confidence_band(prob, ndraws, cdf_at_eval_points)
-
-    # check basic properties
-    assert np.all(ecdf_lower >= 0)
-    assert np.all(ecdf_upper <= 1)
-    assert np.all(ecdf_lower <= ecdf_upper)
-
-    # use simulation to estimate lower and upper bounds on pointwise probability
-    in_interval = []
-    random_state = np.random.default_rng(seed)
-    for _ in range(num_trials):
-        ecdf = _simulate_ecdf(ndraws, eval_points, dist.rvs, random_state=random_state)
-        in_interval.append((ecdf_lower <= ecdf) & (ecdf < ecdf_upper))
-    asymptotic_dist = scipy.stats.norm(
-        np.mean(in_interval, axis=0), scipy.stats.sem(in_interval, axis=0)
-    )
-    prob_lower, prob_upper = asymptotic_dist.interval(0.999)
-
-    # check target probability within all bounds
-    assert np.all(prob_lower <= prob)
-    assert np.all(prob <= prob_upper)
-
-
-@pytest.mark.parametrize("prob", [0.8, 0.9])
-@pytest.mark.parametrize(
-    "dist, rvs",
-    [
-        (scipy.stats.norm(3, 10), scipy.stats.norm(3, 10).rvs),
-        (scipy.stats.norm(3, 10), None),
-        (scipy.stats.poisson(100), scipy.stats.poisson(100).rvs),
-    ],
-    ids=["continuous", "continuous default rvs", "discrete"],
-)
-@pytest.mark.parametrize("ndraws", [10_000])
-@pytest.mark.parametrize("method", ["pointwise", "optimized", "simulated"])
-@pytest.mark.parametrize("use_numba", numba_options)
-def test_ecdf_confidence_band(
-    dist, rvs, prob, ndraws, method, use_numba, num_trials=1_000, seed=57
-):
-    """Test test_ecdf_confidence_band."""
-    if use_numba and method != "optimized":
-        pytest.skip("Numba only used in optimized method")
-
-    eval_points = np.linspace(*dist.interval(0.99), 10)
-    cdf_at_eval_points = dist.cdf(eval_points)
-    random_state = np.random.default_rng(seed)
-
-    ecdf_lower, ecdf_upper = ecdf_confidence_band(
-        ndraws,
-        eval_points,
-        cdf_at_eval_points,
-        prob=prob,
-        rvs=rvs,
-        random_state=random_state,
-        method=method,
-    )
-
-    if method == "pointwise":
-        # these values tested elsewhere, we just make sure they're the same
-        ecdf_lower_pointwise, ecdf_upper_pointwise = _get_pointwise_confidence_band(
-            prob, ndraws, cdf_at_eval_points
-        )
-        assert np.array_equal(ecdf_lower, ecdf_lower_pointwise)
-        assert np.array_equal(ecdf_upper, ecdf_upper_pointwise)
-        return
-
-    # check basic properties
-    assert np.all(ecdf_lower >= 0)
-    assert np.all(ecdf_upper <= 1)
-    assert np.all(ecdf_lower <= ecdf_upper)
-
-    # use simulation to estimate lower and upper bounds on simultaneous probability
-    in_envelope = []
-    random_state = np.random.default_rng(seed)
-    for _ in range(num_trials):
-        ecdf = _simulate_ecdf(ndraws, eval_points, dist.rvs, random_state=random_state)
-        in_envelope.append(np.all(ecdf_lower <= ecdf) & np.all(ecdf < ecdf_upper))
-    asymptotic_dist = scipy.stats.norm(np.mean(in_envelope), scipy.stats.sem(in_envelope))
-    prob_lower, prob_upper = asymptotic_dist.interval(0.999)
-
-    # check target probability within bounds
-    assert prob_lower <= prob <= prob_upper

arviz/tests/base_tests/test_stats_numba.py

@@ -1,45 +0,0 @@
-# pylint: disable=redefined-outer-name, no-member
-import numpy as np
-import pytest
-
-from ...rcparams import rcParams
-from ...stats import r2_score, summary
-from ...utils import Numba
-from ..helpers import (  # pylint: disable=unused-import
-    check_multiple_attrs,
-    importorskip,
-    multidim_models,
-)
-from .test_stats import centered_eight, non_centered_eight  # pylint: disable=unused-import
-
-numba = importorskip("numba")
-
-rcParams["data.load"] = "eager"
-
-
-@pytest.mark.parametrize("circ_var_names", [["mu"], None])
-def test_summary_circ_vars(centered_eight, circ_var_names):
-    assert summary(centered_eight, circ_var_names=circ_var_names) is not None
-    state = Numba.numba_flag
-    Numba.disable_numba()
-    assert summary(centered_eight, circ_var_names=circ_var_names) is not NotImplementedError
-    Numba.enable_numba()
-    assert state == Numba.numba_flag
-
-
-def test_numba_stats():
-    """Numba test for r2_score"""
-    state = Numba.numba_flag  # Store the current state of Numba
-    set_1 = np.random.randn(100, 100)
-    set_2 = np.random.randn(100, 100)
-    set_3 = np.random.rand(100)
-    set_4 = np.random.rand(100)
-    Numba.disable_numba()
-    non_numba = r2_score(set_1, set_2)
-    non_numba_one_dimensional = r2_score(set_3, set_4)
-    Numba.enable_numba()
-    with_numba = r2_score(set_1, set_2)
-    with_numba_one_dimensional = r2_score(set_3, set_4)
-    assert state == Numba.numba_flag  # Ensure that initial state = final state
-    assert np.allclose(non_numba, with_numba)
-    assert np.allclose(non_numba_one_dimensional, with_numba_one_dimensional)

arviz/tests/base_tests/test_stats_utils.py

@@ -1,384 +0,0 @@
-"""Tests for stats_utils."""
-
-#  pylint: disable=no-member
-import numpy as np
-import pytest
-from numpy.testing import assert_array_almost_equal
-from scipy.special import logsumexp
-from scipy.stats import circstd
-
-from ...data import from_dict, load_arviz_data
-from ...stats.density_utils import histogram
-from ...stats.stats_utils import (
-    ELPDData,
-    _angle,
-    _circfunc,
-    _circular_standard_deviation,
-    _sqrt,
-    get_log_likelihood,
-)
-from ...stats.stats_utils import logsumexp as _logsumexp
-from ...stats.stats_utils import make_ufunc, not_valid, stats_variance_2d, wrap_xarray_ufunc
-
-
-@pytest.mark.parametrize("ary_dtype", [np.float64, np.float32, np.int32, np.int64])
-@pytest.mark.parametrize("axis", [None, 0, 1, (-2, -1)])
-@pytest.mark.parametrize("b", [None, 0, 1 / 100, 1 / 101])
-@pytest.mark.parametrize("keepdims", [True, False])
-def test_logsumexp_b(ary_dtype, axis, b, keepdims):
-    """Test ArviZ implementation of logsumexp.
-
-    Test also compares against Scipy implementation.
-    Case where b=None, they are equal. (N=len(ary))
-    Second case where b=x, and x is 1/(number of elements), they are almost equal.
-
-    Test tests against b parameter.
-    """
-    ary = np.random.randn(100, 101).astype(ary_dtype)  # pylint: disable=no-member
-    assert _logsumexp(ary=ary, axis=axis, b=b, keepdims=keepdims, copy=True) is not None
-    ary = ary.copy()
-    assert _logsumexp(ary=ary, axis=axis, b=b, keepdims=keepdims, copy=False) is not None
-    out = np.empty(5)
-    assert _logsumexp(ary=np.random.randn(10, 5), axis=0, out=out) is not None
-
-    # Scipy implementation
-    scipy_results = logsumexp(ary, b=b, axis=axis, keepdims=keepdims)
-    arviz_results = _logsumexp(ary, b=b, axis=axis, keepdims=keepdims)
-
-    assert_array_almost_equal(scipy_results, arviz_results)
-
-
-@pytest.mark.parametrize("ary_dtype", [np.float64, np.float32, np.int32, np.int64])
-@pytest.mark.parametrize("axis", [None, 0, 1, (-2, -1)])
-@pytest.mark.parametrize("b_inv", [None, 0, 100, 101])
-@pytest.mark.parametrize("keepdims", [True, False])
-def test_logsumexp_b_inv(ary_dtype, axis, b_inv, keepdims):
-    """Test ArviZ implementation of logsumexp.
-
-    Test also compares against Scipy implementation.
-    Case where b=None, they are equal. (N=len(ary))
-    Second case where b=x, and x is 1/(number of elements), they are almost equal.
-
-    Test tests against b_inv parameter.
-    """
-    ary = np.random.randn(100, 101).astype(ary_dtype)  # pylint: disable=no-member
-    assert _logsumexp(ary=ary, axis=axis, b_inv=b_inv, keepdims=keepdims, copy=True) is not None
-    ary = ary.copy()
-    assert _logsumexp(ary=ary, axis=axis, b_inv=b_inv, keepdims=keepdims, copy=False) is not None
-    out = np.empty(5)
-    assert _logsumexp(ary=np.random.randn(10, 5), axis=0, out=out) is not None
-
-    if b_inv != 0:
-        # Scipy implementation when b_inv != 0
-        b_scipy = 1 / b_inv if b_inv is not None else None
-        scipy_results = logsumexp(ary, b=b_scipy, axis=axis, keepdims=keepdims)
-        arviz_results = _logsumexp(ary, b_inv=b_inv, axis=axis, keepdims=keepdims)
-
-        assert_array_almost_equal(scipy_results, arviz_results)
-
-
-@pytest.mark.parametrize("quantile", ((0.5,), (0.5, 0.1)))
-@pytest.mark.parametrize("arg", (True, False))
-def test_wrap_ufunc_output(quantile, arg):
-    ary = np.random.randn(4, 100)
-    n_output = len(quantile)
-    if arg:
-        res = wrap_xarray_ufunc(
-            np.quantile, ary, ufunc_kwargs={"n_output": n_output}, func_args=(quantile,)
-        )
-    elif n_output == 1:
-        res = wrap_xarray_ufunc(np.quantile, ary, func_kwargs={"q": quantile})
-    else:
-        res = wrap_xarray_ufunc(
-            np.quantile, ary, ufunc_kwargs={"n_output": n_output}, func_kwargs={"q": quantile}
-        )
-    if n_output == 1:
-        assert not isinstance(res, tuple)
-    else:
-        assert isinstance(res, tuple)
-        assert len(res) == n_output
-
-
-@pytest.mark.parametrize("out_shape", ((1, 2), (1, 2, 3), (2, 3, 4, 5)))
-@pytest.mark.parametrize("input_dim", ((4, 100), (4, 100, 3), (4, 100, 4, 5)))
-def test_wrap_ufunc_out_shape(out_shape, input_dim):
-    func = lambda x: np.random.rand(*out_shape)
-    ary = np.ones(input_dim)
-    res = wrap_xarray_ufunc(
-        func, ary, func_kwargs={"out_shape": out_shape}, ufunc_kwargs={"n_dims": 1}
-    )
-    assert res.shape == (*ary.shape[:-1], *out_shape)
-
-
-def test_wrap_ufunc_out_shape_multi_input():
-    out_shape = (2, 4)
-    func = lambda x, y: np.random.rand(*out_shape)
-    ary1 = np.ones((4, 100))
-    ary2 = np.ones((4, 5))
-    res = wrap_xarray_ufunc(
-        func, ary1, ary2, func_kwargs={"out_shape": out_shape}, ufunc_kwargs={"n_dims": 1}
-    )
-    assert res.shape == (*ary1.shape[:-1], *out_shape)
-
-
-def test_wrap_ufunc_out_shape_multi_output_same():
-    func = lambda x: (np.random.rand(1, 2), np.random.rand(1, 2))
-    ary = np.ones((4, 100))
-    res1, res2 = wrap_xarray_ufunc(
-        func,
-        ary,
-        func_kwargs={"out_shape": ((1, 2), (1, 2))},
-        ufunc_kwargs={"n_dims": 1, "n_output": 2},
-    )
-    assert res1.shape == (*ary.shape[:-1], 1, 2)
-    assert res2.shape == (*ary.shape[:-1], 1, 2)
-
-
-def test_wrap_ufunc_out_shape_multi_output_diff():
-    func = lambda x: (np.random.rand(5, 3), np.random.rand(10, 4))
-    ary = np.ones((4, 100))
-    res1, res2 = wrap_xarray_ufunc(
-        func,
-        ary,
-        func_kwargs={"out_shape": ((5, 3), (10, 4))},
-        ufunc_kwargs={"n_dims": 1, "n_output": 2},
-    )
-    assert res1.shape == (*ary.shape[:-1], 5, 3)
-    assert res2.shape == (*ary.shape[:-1], 10, 4)
-
-
-@pytest.mark.parametrize("n_output", (1, 2, 3))
-def test_make_ufunc(n_output):
-    if n_output == 3:
-        func = lambda x: (np.mean(x), np.mean(x), np.mean(x))
-    elif n_output == 2:
-        func = lambda x: (np.mean(x), np.mean(x))
-    else:
-        func = np.mean
-    ufunc = make_ufunc(func, n_dims=1, n_output=n_output)
-    ary = np.ones((4, 100))
-    res = ufunc(ary)
-    if n_output > 1:
-        assert all(len(res_i) == 4 for res_i in res)
-        assert all((res_i == 1).all() for res_i in res)
-    else:
-        assert len(res) == 4
-        assert (res == 1).all()
-
-
-@pytest.mark.parametrize("n_output", (1, 2, 3))
-def test_make_ufunc_out(n_output):
-    if n_output == 3:
-        func = lambda x: (np.mean(x), np.mean(x), np.mean(x))
-        res = (np.empty((4,)), np.empty((4,)), np.empty((4,)))
-    elif n_output == 2:
-        func = lambda x: (np.mean(x), np.mean(x))
-        res = (np.empty((4,)), np.empty((4,)))
-    else:
-        func = np.mean
-        res = np.empty((4,))
-    ufunc = make_ufunc(func, n_dims=1, n_output=n_output)
-    ary = np.ones((4, 100))
-    ufunc(ary, out=res)
-    if n_output > 1:
-        assert all(len(res_i) == 4 for res_i in res)
-        assert all((res_i == 1).all() for res_i in res)
-    else:
-        assert len(res) == 4
-        assert (res == 1).all()
-
-
-def test_make_ufunc_bad_ndim():
-    with pytest.raises(TypeError):
-        make_ufunc(np.mean, n_dims=0)
-
-
-@pytest.mark.parametrize("n_output", (1, 2, 3))
-def test_make_ufunc_out_bad(n_output):
-    if n_output == 3:
-        func = lambda x: (np.mean(x), np.mean(x), np.mean(x))
-        res = (np.empty((100,)), np.empty((100,)))
-    elif n_output == 2:
-        func = lambda x: (np.mean(x), np.mean(x))
-        res = np.empty((100,))
-    else:
-        func = np.mean
-        res = np.empty((100,))
-    ufunc = make_ufunc(func, n_dims=1, n_output=n_output)
-    ary = np.ones((4, 100))
-    with pytest.raises(TypeError):
-        ufunc(ary, out=res)
-
-
-@pytest.mark.parametrize("how", ("all", "any"))
-def test_nan(how):
-    assert not not_valid(np.ones(10), check_shape=False, nan_kwargs=dict(how=how))
-    if how == "any":
-        assert not_valid(
-            np.concatenate((np.random.randn(100), np.full(2, np.nan))),
-            check_shape=False,
-            nan_kwargs=dict(how=how),
-        )
-    else:
-        assert not not_valid(
-            np.concatenate((np.random.randn(100), np.full(2, np.nan))),
-            check_shape=False,
-            nan_kwargs=dict(how=how),
-        )
-        assert not_valid(np.full(10, np.nan), check_shape=False, nan_kwargs=dict(how=how))
-
-
-@pytest.mark.parametrize("axis", (-1, 0, 1))
-def test_nan_axis(axis):
-    data = np.random.randn(4, 100)
-    data[0, 0] = np.nan  #  pylint: disable=unsupported-assignment-operation
-    axis_ = (len(data.shape) + axis) if axis < 0 else axis
-    assert not_valid(data, check_shape=False, nan_kwargs=dict(how="any"))
-    assert not_valid(data, check_shape=False, nan_kwargs=dict(how="any", axis=axis)).any()
-    assert not not_valid(data, check_shape=False, nan_kwargs=dict(how="any", axis=axis)).all()
-    assert not_valid(data, check_shape=False, nan_kwargs=dict(how="any", axis=axis)).shape == tuple(
-        dim for ax, dim in enumerate(data.shape) if ax != axis_
-    )
-
-
-def test_valid_shape():
-    assert not not_valid(
-        np.ones((2, 200)), check_nan=False, shape_kwargs=dict(min_chains=2, min_draws=100)
-    )
-    assert not not_valid(
-        np.ones((200, 2)), check_nan=False, shape_kwargs=dict(min_chains=100, min_draws=2)
-    )
-    assert not_valid(
-        np.ones((10, 10)), check_nan=False, shape_kwargs=dict(min_chains=2, min_draws=100)
-    )
-    assert not_valid(
-        np.ones((10, 10)), check_nan=False, shape_kwargs=dict(min_chains=100, min_draws=2)
-    )
-
-
-def test_get_log_likelihood():
-    idata = from_dict(
-        log_likelihood={
-            "y1": np.random.normal(size=(4, 100, 6)),
-            "y2": np.random.normal(size=(4, 100, 8)),
-        }
-    )
-    lik1 = get_log_likelihood(idata, "y1")
-    lik2 = get_log_likelihood(idata, "y2")
-    assert lik1.shape == (4, 100, 6)
-    assert lik2.shape == (4, 100, 8)
-
-
-def test_get_log_likelihood_warning():
-    idata = from_dict(
-        sample_stats={
-            "log_likelihood": np.random.normal(size=(4, 100, 6)),
-        }
-    )
-    with pytest.warns(DeprecationWarning):
-        get_log_likelihood(idata)
-
-
-def test_get_log_likelihood_no_var_name():
-    idata = from_dict(
-        log_likelihood={
-            "y1": np.random.normal(size=(4, 100, 6)),
-            "y2": np.random.normal(size=(4, 100, 8)),
-        }
-    )
-    with pytest.raises(TypeError, match="Found several"):
-        get_log_likelihood(idata)
-
-
-def test_get_log_likelihood_no_group():
-    idata = from_dict(
-        posterior={
-            "a": np.random.normal(size=(4, 100)),
-            "b": np.random.normal(size=(4, 100)),
-        }
-    )
-    with pytest.raises(TypeError, match="log likelihood not found"):
-        get_log_likelihood(idata)
-
-
-def test_elpd_data_error():
-    with pytest.raises(IndexError):
-        repr(ELPDData(data=[0, 1, 2], index=["not IC", "se", "p"]))
-
-
-def test_stats_variance_1d():
-    """Test for stats_variance_1d."""
-    data = np.random.rand(1000000)
-    assert np.allclose(np.var(data), stats_variance_2d(data))
-    assert np.allclose(np.var(data, ddof=1), stats_variance_2d(data, ddof=1))
-
-
-def test_stats_variance_2d():
-    """Test for stats_variance_2d."""
-    data_1 = np.random.randn(1000, 1000)
-    data_2 = np.random.randn(1000000)
-    school = load_arviz_data("centered_eight").posterior["mu"].values
-    n_school = load_arviz_data("non_centered_eight").posterior["mu"].values
-    assert np.allclose(np.var(school, ddof=1, axis=1), stats_variance_2d(school, ddof=1, axis=1))
-    assert np.allclose(np.var(school, ddof=1, axis=0), stats_variance_2d(school, ddof=1, axis=0))
-    assert np.allclose(
-        np.var(n_school, ddof=1, axis=1), stats_variance_2d(n_school, ddof=1, axis=1)
-    )
-    assert np.allclose(
-        np.var(n_school, ddof=1, axis=0), stats_variance_2d(n_school, ddof=1, axis=0)
-    )
-    assert np.allclose(np.var(data_2), stats_variance_2d(data_2))
-    assert np.allclose(np.var(data_2, ddof=1), stats_variance_2d(data_2, ddof=1))
-    assert np.allclose(np.var(data_1, axis=0), stats_variance_2d(data_1, axis=0))
-    assert np.allclose(np.var(data_1, axis=1), stats_variance_2d(data_1, axis=1))
-    assert np.allclose(np.var(data_1, axis=0, ddof=1), stats_variance_2d(data_1, axis=0, ddof=1))
-    assert np.allclose(np.var(data_1, axis=1, ddof=1), stats_variance_2d(data_1, axis=1, ddof=1))
-
-
-def test_variance_bad_data():
-    """Test for variance when the data range is extremely wide."""
-    data = np.array([1e20, 200e-10, 1e-17, 432e9, 2500432, 23e5, 16e-7])
-    assert np.allclose(stats_variance_2d(data), np.var(data))
-    assert np.allclose(stats_variance_2d(data, ddof=1), np.var(data, ddof=1))
-    assert not np.allclose(stats_variance_2d(data), np.var(data, ddof=1))
-
-
-def test_histogram():
-    school = load_arviz_data("non_centered_eight").posterior["mu"].values
-    k_count_az, k_dens_az, _ = histogram(school, bins=np.asarray([-np.inf, 0.5, 0.7, 1, np.inf]))
-    k_dens_np, *_ = np.histogram(school, bins=[-np.inf, 0.5, 0.7, 1, np.inf], density=True)
-    k_count_np, *_ = np.histogram(school, bins=[-np.inf, 0.5, 0.7, 1, np.inf], density=False)
-    assert np.allclose(k_count_az, k_count_np)
-    assert np.allclose(k_dens_az, k_dens_np)
-
-
-def test_sqrt():
-    x = np.random.rand(100)
-    y = np.random.rand(100)
-    assert np.allclose(_sqrt(x, y), np.sqrt(x + y))
-
-
-def test_angle():
-    x = np.random.randn(100)
-    high = 8
-    low = 4
-    res = (x - low) * 2 * np.pi / (high - low)
-    assert np.allclose(_angle(x, low, high, np.pi), res)
-
-
-def test_circfunc():
-    school = load_arviz_data("centered_eight").posterior["mu"].values
-    a_a = _circfunc(school, 8, 4, skipna=False)
-    assert np.allclose(a_a, _angle(school, 4, 8, np.pi))
-
-
-@pytest.mark.parametrize(
-    "data", (np.random.randn(100), np.random.randn(100, 100), np.random.randn(100, 100, 100))
-)
-def test_circular_standard_deviation_1d(data):
-    high = 8
-    low = 4
-    assert np.allclose(
-        _circular_standard_deviation(data, high=high, low=low),
-        circstd(data, high=high, low=low),
-    )