scipy 1.15.3__cp313-cp313-macosx_14_0_arm64.whl → 1.16.0__cp313-cp313-macosx_14_0_arm64.whl

scipy/stats/tests/test_kdeoth.py

@@ -9,9 +9,9 @@ from pytest import raises as assert_raises
 
 def test_kde_1d():
     #some basic tests comparing to normal distribution
-    np.random.seed(8765678)
+    rng = np.random.default_rng(8765678)
     n_basesample = 500
-    xn = np.random.randn(n_basesample)
+    xn = rng.normal(0, 1, n_basesample)
     xnmean = xn.mean()
     xnstd = xn.std(ddof=1)
 
@@ -19,7 +19,15 @@ def test_kde_1d():
     gkde = stats.gaussian_kde(xn)
 
     # evaluate the density function for the kde for some points
-    xs = np.linspace(-7,7,501)
+    xx = np.asarray([0.1, 0.5, 0.9])
+    loc, scale = gkde.dataset, np.sqrt(gkde.covariance)
+    assert_allclose(
+        gkde(xx), 
+        stats.norm.pdf(xx[:, None], loc=loc, scale=scale).sum(axis=-1) / gkde.n,
+        rtol=5e-14
+    )
+
+    xs = np.linspace(-7, 7, 501)
     kdepdf = gkde.evaluate(xs)
     normpdf = stats.norm.pdf(xs, loc=xnmean, scale=xnstd)
     intervall = xs[1] - xs[0]
@@ -40,10 +48,10 @@ def test_kde_1d():
 
 def test_kde_1d_weighted():
     #some basic tests comparing to normal distribution
-    np.random.seed(8765678)
+    rng = np.random.default_rng(8765678)
     n_basesample = 500
-    xn = np.random.randn(n_basesample)
-    wn = np.random.rand(n_basesample)
+    xn = rng.normal(0, 1, n_basesample)
+    wn = rng.random(n_basesample)
     xnmean = np.average(xn, weights=wn)
     xnstd = np.sqrt(np.average((xn-xnmean)**2, weights=wn))
 
@@ -51,7 +59,18 @@ def test_kde_1d_weighted():
     gkde = stats.gaussian_kde(xn, weights=wn)
 
     # evaluate the density function for the kde for some points
-    xs = np.linspace(-7,7,501)
+    # evaluate the density function for the kde for some points
+    xx = np.asarray([0.1, 0.5, 0.9])
+    loc, scale = gkde.dataset, np.sqrt(gkde.covariance)
+
+    pdf = stats.norm.pdf
+    assert_allclose(
+        gkde(xx), 
+        np.sum(pdf(xx[:, None], loc=loc, scale=scale) * gkde.weights, axis=-1),
+        rtol=5e-14
+    )
+
+    xs = np.linspace(-7, 7, 501)
     kdepdf = gkde.evaluate(xs)
     normpdf = stats.norm.pdf(xs, loc=xnmean, scale=xnstd)
     intervall = xs[1] - xs[0]
@@ -70,21 +89,45 @@ def test_kde_1d_weighted():
                         (kdepdf*normpdf).sum()*intervall, decimal=2)
 
 
-@pytest.mark.xslow
-def test_kde_2d():
+@pytest.mark.parametrize("n_basesample",
+                         [
+                            20,
+                            pytest.param(500, marks=[pytest.mark.xslow])
+                         ]
+)
+def test_kde_2d(n_basesample):
     #some basic tests comparing to normal distribution
-    np.random.seed(8765678)
-    n_basesample = 500
+    rng = np.random.default_rng(8765678)
 
     mean = np.array([1.0, 3.0])
     covariance = np.array([[1.0, 2.0], [2.0, 6.0]])
 
     # Need transpose (shape (2, 500)) for kde
-    xn = np.random.multivariate_normal(mean, covariance, size=n_basesample).T
+    xn = rng.multivariate_normal(mean, covariance, size=n_basesample).T
 
     # get kde for original sample
     gkde = stats.gaussian_kde(xn)
 
+    # evaluate vs multivariate normal, using the KDE definition
+    xx = np.asarray([[1, 2], [3, 4], [5, 6]])
+    arg = xx[:, None, :] - gkde.dataset.T
+    pdf = stats.multivariate_normal.pdf
+    assert_allclose(
+        gkde(xx.T),
+        pdf(arg, cov=gkde.covariance).sum(axis=-1) / gkde.n,
+        rtol=5e-14
+    )
+
+    # ... and cdf
+    cdf = stats.multivariate_normal.cdf
+    lo, hi = [-1, -2], [0, 0]
+    lo_, hi_ = lo - gkde.dataset.T, hi - gkde.dataset.T
+    assert_allclose(
+        gkde.integrate_box(lo, hi, rng=rng),
+        cdf(hi_, lower_limit=lo_, cov=gkde.covariance, rng=rng).sum(axis=-1) / gkde.n,
+        rtol=5e-7
+    )
+
     # evaluate the density function for the kde for some points
     x, y = np.mgrid[-7:7:500j, -7:7:500j]
     grid_coords = np.vstack([x.ravel(), y.ravel()])
@@ -99,8 +142,8 @@ def test_kde_2d():
 
     small = -1e100
     large = 1e100
-    prob1 = gkde.integrate_box([small, mean[1]], [large, large])
-    prob2 = gkde.integrate_box([small, small], [large, mean[1]])
+    prob1 = gkde.integrate_box([small, mean[1]], [large, large], rng=rng)
+    prob2 = gkde.integrate_box([small, small], [large, mean[1]], rng=rng)
 
     assert_almost_equal(prob1, 0.5, decimal=1)
     assert_almost_equal(prob2, 0.5, decimal=1)
@@ -110,22 +153,48 @@ def test_kde_2d():
                         (kdepdf*normpdf).sum()*(intervall**2), decimal=2)
 
 
-@pytest.mark.xslow
-def test_kde_2d_weighted():
+@pytest.mark.parametrize("n_basesample",
+                         [
+                            20,
+                            pytest.param(500, marks=[pytest.mark.xslow])
+                         ]
+)
+def test_kde_2d_weighted(n_basesample):
     #some basic tests comparing to normal distribution
-    np.random.seed(8765678)
-    n_basesample = 500
+    rng = np.random.RandomState(8765678)
 
     mean = np.array([1.0, 3.0])
     covariance = np.array([[1.0, 2.0], [2.0, 6.0]])
 
     # Need transpose (shape (2, 500)) for kde
-    xn = np.random.multivariate_normal(mean, covariance, size=n_basesample).T
-    wn = np.random.rand(n_basesample)
+    xn = rng.multivariate_normal(mean, covariance, size=n_basesample).T
+    wn = rng.rand(n_basesample)
 
     # get kde for original sample
     gkde = stats.gaussian_kde(xn, weights=wn)
 
+
+    # evaluate vs multivariate normal, using the kde definition
+    xx = np.asarray([[1, 2], [3, 4], [5, 6]])
+    arg = xx[:, None, :] - gkde.dataset.T
+    pdf = stats.multivariate_normal.pdf
+    assert_allclose(
+        gkde(xx.T),
+        np.sum(pdf(arg, cov=gkde.covariance) * gkde.weights, axis=-1),
+        rtol=5e-14
+    )
+
+    # ... and cdf
+    cdf = stats.multivariate_normal.cdf
+    lo, hi = [-1, -2], [0, 0]
+    lo_, hi_ = lo - gkde.dataset.T, hi - gkde.dataset.T
+    assert_allclose(
+        gkde.integrate_box(lo, hi, rng=rng),
+        np.sum(cdf(hi_, lower_limit=lo_, cov=gkde.covariance, rng=rng) *
+               gkde.weights, axis=-1),
+        rtol=5e-6
+    )
+
     # evaluate the density function for the kde for some points
     x, y = np.mgrid[-7:7:500j, -7:7:500j]
     grid_coords = np.vstack([x.ravel(), y.ravel()])
@@ -140,8 +209,8 @@ def test_kde_2d_weighted():
 
     small = -1e100
     large = 1e100
-    prob1 = gkde.integrate_box([small, mean[1]], [large, large])
-    prob2 = gkde.integrate_box([small, small], [large, mean[1]])
+    prob1 = gkde.integrate_box([small, mean[1]], [large, large], rng=rng)
+    prob2 = gkde.integrate_box([small, small], [large, mean[1]], rng=rng)
 
     assert_almost_equal(prob1, 0.5, decimal=1)
     assert_almost_equal(prob2, 0.5, decimal=1)
@@ -156,9 +225,9 @@ def test_kde_bandwidth_method():
         """Same as default, just check that it works."""
         return np.power(kde_obj.n, -1./(kde_obj.d+4))
 
-    np.random.seed(8765678)
+    rng = np.random.default_rng(8765678)
     n_basesample = 50
-    xn = np.random.randn(n_basesample)
+    xn = rng.normal(0, 1, n_basesample)
 
     # Default
     gkde = stats.gaussian_kde(xn)
@@ -182,9 +251,9 @@ def test_kde_bandwidth_method_weighted():
         """Same as default, just check that it works."""
         return np.power(kde_obj.neff, -1./(kde_obj.d+4))
 
-    np.random.seed(8765678)
+    rng = np.random.default_rng(8765678)
     n_basesample = 50
-    xn = np.random.randn(n_basesample)
+    xn = rng.normal(0, 1, n_basesample)
 
     # Default
     gkde = stats.gaussian_kde(xn)
@@ -347,9 +416,9 @@ def test_pdf_logpdf_validation():
 
 
 def test_pdf_logpdf():
-    np.random.seed(1)
+    rng = np.random.default_rng(1)
     n_basesample = 50
-    xn = np.random.randn(n_basesample)
+    xn = rng.normal(0, 1, n_basesample)
 
     # Default
     gkde = stats.gaussian_kde(xn)
@@ -371,10 +440,10 @@ def test_pdf_logpdf():
 
 
 def test_pdf_logpdf_weighted():
-    np.random.seed(1)
+    rng = np.random.default_rng(1)
     n_basesample = 50
-    xn = np.random.randn(n_basesample)
-    wn = np.random.rand(n_basesample)
+    xn = rng.normal(0, 1, n_basesample)
+    wn = rng.random(n_basesample)
 
     # Default
     gkde = stats.gaussian_kde(xn, weights=wn)
@@ -492,10 +561,10 @@ def test_marginal_iv():
 def test_logpdf_overflow():
     # regression test for gh-12988; testing against linalg instability for
     # very high dimensionality kde
-    np.random.seed(1)
+    rng = np.random.default_rng(1)
     n_dimensions = 2500
     n_samples = 5000
-    xn = np.array([np.random.randn(n_samples) + (n) for n in range(
+    xn = np.array([rng.normal(0, 1, n_samples) + (n) for n in range(
         0, n_dimensions)])
 
     # Default
@@ -508,9 +577,9 @@ def test_logpdf_overflow():
 
 def test_weights_intact():
     # regression test for gh-9709: weights are not modified
-    np.random.seed(12345)
-    vals = np.random.lognormal(size=100)
-    weights = np.random.choice([1.0, 10.0, 100], size=vals.size)
+    rng = np.random.default_rng(12345)
+    vals = rng.lognormal(size=100)
+    weights = rng.choice([1.0, 10.0, 100], size=vals.size)
     orig_weights = weights.copy()
 
     stats.gaussian_kde(np.log10(vals), weights=weights)
@@ -519,7 +588,6 @@ def test_weights_intact():
 
 def test_weights_integer():
     # integer weights are OK, cf gh-9709 (comment)
-    np.random.seed(12345)
     values = [0.2, 13.5, 21.0, 75.0, 99.0]
     weights = [1, 2, 4, 8, 16]  # a list of integers
     pdf_i = stats.gaussian_kde(values, weights=weights)
@@ -558,11 +626,11 @@ def test_seed():
             rng = np.random.default_rng(1234)
             gkde_trail.resample(n_sample, seed=rng)
 
-    np.random.seed(8765678)
+    rng = np.random.default_rng(8765678)
     n_basesample = 500
-    wn = np.random.rand(n_basesample)
+    wn = rng.random(n_basesample)
     # Test 1D case
-    xn_1d = np.random.randn(n_basesample)
+    xn_1d = rng.normal(0, 1, n_basesample)
 
     gkde_1d = stats.gaussian_kde(xn_1d)
     test_seed_sub(gkde_1d)
@@ -572,7 +640,7 @@ def test_seed():
     # Test 2D case
     mean = np.array([1.0, 3.0])
     covariance = np.array([[1.0, 2.0], [2.0, 6.0]])
-    xn_2d = np.random.multivariate_normal(mean, covariance, size=n_basesample).T
+    xn_2d = rng.multivariate_normal(mean, covariance, size=n_basesample).T
 
     gkde_2d = stats.gaussian_kde(xn_2d)
     test_seed_sub(gkde_2d)

scipy/stats/tests/test_marray.py

@@ -0,0 +1,289 @@
+import pytest
+import numpy as np
+from scipy import stats
+
+from scipy._lib._array_api import xp_assert_close, xp_assert_equal
+from scipy.stats._stats_py import _xp_mean, _xp_var, _length_nonmasked
+from scipy.stats._axis_nan_policy import _axis_nan_policy_factory
+
+
+marray = pytest.importorskip('marray')
+skip_backend = pytest.mark.skip_xp_backends
+
+
+def get_arrays(n_arrays, *, dtype='float64', xp=np, shape=(7, 8), seed=84912165484321):
+    mxp = marray._get_namespace(xp)
+    rng = np.random.default_rng(seed)
+
+    datas, masks = [], []
+    for i in range(n_arrays):
+        data = rng.random(size=shape)
+        if dtype.startswith('complex'):
+            data = 10*data * 10j*rng.standard_normal(size=shape)
+        data = data.astype(dtype)
+        datas.append(data)
+        mask = rng.random(size=shape) > 0.75
+        masks.append(mask)
+
+    marrays = []
+    nan_arrays = []
+    for array, mask in zip(datas, masks):
+        marrays.append(mxp.asarray(array, mask=mask))
+        nan_array = array.copy()
+        nan_array[mask] = xp.nan
+        nan_arrays.append(nan_array)
+
+    return mxp, marrays, nan_arrays
+
+
+@skip_backend('dask.array', reason='Arrays need `device` attribute: dask/dask#11711')
+@skip_backend('jax.numpy', reason="JAX doesn't allow item assignment.")
+@skip_backend('torch', reason="marray#99")
+@pytest.mark.parametrize('fun, kwargs', [(stats.gmean, {}),
+                                         (stats.hmean, {}),
+                                         (stats.pmean, {'p': 2})])
+@pytest.mark.parametrize('axis', [0, 1])
+def test_xmean(fun, kwargs, axis, xp):
+    mxp, marrays, narrays = get_arrays(2, xp=xp)
+    res = fun(marrays[0], weights=marrays[1], axis=axis, **kwargs)
+    ref = fun(narrays[0], weights=narrays[1], nan_policy='omit', axis=axis, **kwargs)
+    xp_assert_close(res.data, xp.asarray(ref))
+
+
+@skip_backend('dask.array', reason='Arrays need `device` attribute: dask/dask#11711')
+@skip_backend('jax.numpy', reason="JAX doesn't allow item assignment.")
+@skip_backend('torch', reason="marray#99")
+@pytest.mark.parametrize('axis', [0, 1, None])
+@pytest.mark.parametrize('keepdims', [False, True])
+def test_xp_mean(axis, keepdims, xp):
+    mxp, marrays, narrays = get_arrays(2, xp=xp)
+    kwargs = dict(axis=axis, keepdims=keepdims)
+    res = _xp_mean(marrays[0], weights=marrays[1], **kwargs)
+    ref = _xp_mean(narrays[0], weights=narrays[1], nan_policy='omit', **kwargs)
+    xp_assert_close(res.data, xp.asarray(ref))
+
+
+@skip_backend('dask.array', reason='Arrays need `device` attribute: dask/dask#11711')
+@skip_backend('jax.numpy', reason="JAX doesn't allow item assignment.")
+@skip_backend('torch', reason="array-api-compat#242")
+@pytest.mark.parametrize('fun, kwargs',
+    [(stats.moment, {'order': 2}),
+     (stats.skew, {}),
+     (stats.skew, {'bias': False}),
+     (stats.kurtosis, {}),
+     (stats.kurtosis, {'bias': False}),
+     (stats.sem, {}),
+     (stats.kstat, {'n': 1}),
+     (stats.kstat, {'n': 2}),
+     (stats.kstat, {'n': 3}),
+     (stats.kstat, {'n': 4}),
+     (stats.kstatvar, {'n': 1}),
+     (stats.kstatvar, {'n': 2}),
+     (stats.circmean, {}),
+     (stats.circvar, {}),
+     (stats.circstd, {}),
+     (_xp_var, {}),
+     (stats.tmean, {'limits': (0.1, 0.9)}),
+     (stats.tvar, {'limits': (0.1, 0.9)}),
+     (stats.tmin, {'lowerlimit': 0.5}),
+     (stats.tmax, {'upperlimit': 0.5}),
+     (stats.tstd, {'limits': (0.1, 0.9)}),
+     (stats.tsem, {'limits': (0.1, 0.9)}),
+     ])
+@pytest.mark.parametrize('axis', [0, 1, None])
+def test_several(fun, kwargs, axis, xp):
+    mxp, marrays, narrays = get_arrays(1, xp=xp)
+    kwargs = dict(axis=axis) | kwargs
+    res = fun(marrays[0], **kwargs)
+    ref = fun(narrays[0], nan_policy='omit', **kwargs)
+    xp_assert_close(res.data, xp.asarray(ref))
+
+
+@skip_backend('dask.array', reason='Arrays need `device` attribute: dask/dask#11711')
+@skip_backend('jax.numpy', reason="JAX doesn't allow item assignment.")
+@skip_backend('torch', reason="array-api-compat#242")
+@pytest.mark.parametrize('axis', [0, 1])
+@pytest.mark.parametrize('kwargs', [{}])
+def test_describe(axis, kwargs, xp):
+    mxp, marrays, narrays = get_arrays(1, xp=xp)
+    kwargs = dict(axis=axis) | kwargs
+    res = stats.describe(marrays[0], **kwargs)
+    ref = stats.describe(narrays[0], nan_policy='omit', **kwargs)
+    xp_assert_close(res.nobs.data, xp.asarray(ref.nobs))
+    xp_assert_close(res.minmax[0].data, xp.asarray(ref.minmax[0].data))
+    xp_assert_close(res.minmax[1].data, xp.asarray(ref.minmax[1].data))
+    xp_assert_close(res.variance.data, xp.asarray(ref.variance.data))
+    xp_assert_close(res.skewness.data, xp.asarray(ref.skewness.data))
+    xp_assert_close(res.kurtosis.data, xp.asarray(ref.kurtosis.data))
+
+
+@skip_backend('dask.array', reason='Arrays need `device` attribute: dask/dask#11711')
+@skip_backend('jax.numpy', reason="JAX doesn't allow item assignment.")
+@skip_backend('torch', reason="array-api-compat#242")
+@pytest.mark.parametrize('fun', [stats.zscore, stats.gzscore, stats.zmap])
+@pytest.mark.parametrize('axis', [0, 1, None])
+def test_zscore(fun, axis, xp):
+    mxp, marrays, narrays = (get_arrays(2, xp=xp) if fun == stats.zmap
+                             else get_arrays(1, xp=xp))
+    res = fun(*marrays, axis=axis)
+    ref = xp.asarray(fun(*narrays, nan_policy='omit', axis=axis))
+    xp_assert_close(res.data[~res.mask], ref[~xp.isnan(ref)])
+    xp_assert_equal(res.mask, marrays[0].mask)
+
+
+@skip_backend('dask.array', reason='Arrays need `device` attribute: dask/dask#11711')
+@skip_backend('jax.numpy', reason="JAX doesn't allow item assignment.")
+@skip_backend('torch', reason="array-api-compat#242")
+@skip_backend('cupy', reason="special functions won't work")
+@pytest.mark.parametrize('f_name', ['ttest_1samp', 'ttest_rel', 'ttest_ind'])
+@pytest.mark.parametrize('axis', [0, 1, None])
+def test_ttest(f_name, axis, xp):
+    f = getattr(stats, f_name)
+    mxp, marrays, narrays = get_arrays(2, xp=xp)
+    if f_name == 'ttest_1samp':
+        marrays[1] = mxp.mean(marrays[1], axis=axis, keepdims=axis is not None)
+        narrays[1] = np.nanmean(narrays[1], axis=axis, keepdims=axis is not None)
+    res = f(*marrays, axis=axis)
+    ref = f(*narrays, nan_policy='omit', axis=axis)
+    xp_assert_close(res.statistic.data, xp.asarray(ref.statistic))
+    xp_assert_close(res.pvalue.data, xp.asarray(ref.pvalue))
+    res_ci = res.confidence_interval()
+    ref_ci = ref.confidence_interval()
+    xp_assert_close(res_ci.low.data, xp.asarray(ref_ci.low))
+    xp_assert_close(res_ci.high.data, xp.asarray(ref_ci.high))
+
+
+@skip_backend('dask.array', reason='Arrays need `device` attribute: dask/dask#11711')
+@skip_backend('jax.numpy', reason="JAX doesn't allow item assignment.")
+@skip_backend('torch', reason="array-api-compat#242")
+@skip_backend('cupy', reason="special functions won't work")
+@pytest.mark.filterwarnings("ignore::scipy.stats._axis_nan_policy.SmallSampleWarning")
+@pytest.mark.parametrize('f_name', ['skewtest', 'kurtosistest',
+                                    'normaltest', 'jarque_bera'])
+@pytest.mark.parametrize('axis', [0, 1, None])
+def test_normality_tests(f_name, axis, xp):
+    f = getattr(stats, f_name)
+    mxp, marrays, narrays = get_arrays(1, xp=xp, shape=(10, 11))
+
+    res = f(*marrays, axis=axis)
+    ref = f(*narrays, nan_policy='omit', axis=axis)
+
+    xp_assert_close(res.statistic.data, xp.asarray(ref.statistic))
+    xp_assert_close(res.pvalue.data, xp.asarray(ref.pvalue))
+
+
+def pd_nsamples(kwargs):
+    return 2 if kwargs.get('f_exp', None) is not None else 1
+
+
+@_axis_nan_policy_factory(lambda *args: tuple(args), paired=True, n_samples=pd_nsamples)
+def power_divergence_ref(f_obs, f_exp=None, *,  ddof, lambda_, axis=0):
+    return stats.power_divergence(f_obs, f_exp, axis=axis, ddof=ddof, lambda_=lambda_)
+
+
+@skip_backend('dask.array', reason='Arrays need `device` attribute: dask/dask#11711')
+@skip_backend('jax.numpy', reason="JAX doesn't allow item assignment.")
+@skip_backend('torch', reason="array-api-compat#242")
+@skip_backend('cupy', reason="special functions won't work")
+@pytest.mark.parametrize('lambda_', ['pearson', 'log-likelihood', 'freeman-tukey',
+                                     'mod-log-likelihood', 'neyman', 'cressie-read',
+                                     'chisquare'])
+@pytest.mark.parametrize('ddof', [0, 1])
+@pytest.mark.parametrize('axis', [0, 1, None])
+def test_power_divergence_chisquare(lambda_, ddof, axis, xp):
+    mxp, marrays, narrays = get_arrays(2, xp=xp, shape=(5, 6))
+
+    kwargs = dict(axis=axis, ddof=ddof)
+    if lambda_ == 'chisquare':
+        lambda_ = "pearson"
+        def f(*args, **kwargs):
+            return stats.chisquare(*args, **kwargs)
+    else:
+        def f(*args, **kwargs):
+            return stats.power_divergence(*args, lambda_=lambda_, **kwargs)
+
+    # test 1-arg
+    res = f(marrays[0], **kwargs)
+    ref = power_divergence_ref(narrays[0], nan_policy='omit', lambda_=lambda_, **kwargs)
+
+    xp_assert_close(res.statistic.data, xp.asarray(ref[0]))
+    xp_assert_close(res.pvalue.data, xp.asarray(ref[1]))
+
+    # test 2-arg
+    common_mask = np.isnan(narrays[0]) | np.isnan(narrays[1])
+    normalize = (np.nansum(narrays[1] * ~common_mask, axis=axis, keepdims=True)
+                 / np.nansum(narrays[0] * ~common_mask, axis=axis, keepdims=True))
+    marrays[0] *= xp.asarray(normalize)
+    narrays[0] *= normalize
+
+    res = f(*marrays, **kwargs)
+    ref = power_divergence_ref(*narrays, nan_policy='omit', lambda_=lambda_, **kwargs)
+
+    xp_assert_close(res.statistic.data, xp.asarray(ref[0]))
+    xp_assert_close(res.pvalue.data, xp.asarray(ref[1]))
+
+
+@skip_backend('dask.array', reason='Arrays need `device` attribute: dask/dask#11711')
+@skip_backend('jax.numpy', reason="JAX doesn't allow item assignment.")
+@skip_backend('torch', reason="array-api-compat#242")
+@skip_backend('cupy', reason="special functions won't work")
+@pytest.mark.parametrize('method', ['fisher', 'pearson', 'mudholkar_george',
+                                    'tippett', 'stouffer'])
+@pytest.mark.parametrize('axis', [0, 1, None])
+def test_combine_pvalues(method, axis, xp):
+    mxp, marrays, narrays = get_arrays(2, xp=xp, shape=(10, 11))
+
+    kwargs = dict(method=method, axis=axis)
+    res = stats.combine_pvalues(marrays[0], **kwargs)
+    ref = stats.combine_pvalues(narrays[0], nan_policy='omit', **kwargs)
+
+    xp_assert_close(res.statistic.data, xp.asarray(ref.statistic))
+    xp_assert_close(res.pvalue.data, xp.asarray(ref.pvalue))
+
+    if method != 'stouffer':
+        return
+
+    res = stats.combine_pvalues(marrays[0], weights=marrays[1], **kwargs)
+    ref = stats.combine_pvalues(narrays[0], weights=narrays[1],
+                                nan_policy='omit', **kwargs)
+
+    xp_assert_close(res.statistic.data, xp.asarray(ref.statistic))
+    xp_assert_close(res.pvalue.data, xp.asarray(ref.pvalue))
+
+
+@skip_backend('dask.array', reason='Arrays need `device` attribute: dask/dask#11711')
+@skip_backend('jax.numpy', reason="JAX doesn't allow item assignment.")
+@skip_backend('torch', reason="array-api-compat#242")
+@skip_backend('cupy', reason="special functions won't work")
+def test_ttest_ind_from_stats(xp):
+    shape = (10, 11)
+    mxp, marrays, narrays = get_arrays(6, xp=xp, shape=shape)
+    mask = np.astype(np.sum(np.stack([np.isnan(arg) for arg in narrays]), axis=0), bool)
+    narrays = [arg[~mask] for arg in narrays]
+    marrays[2], marrays[5] = marrays[2] * 100, marrays[5] * 100
+    narrays[2], narrays[5] = narrays[2] * 100, narrays[5] * 100
+
+    res = stats.ttest_ind_from_stats(*marrays)
+    ref = stats.ttest_ind_from_stats(*narrays)
+
+    mask = xp.asarray(mask)
+    assert xp.any(mask) and xp.any(~mask)
+    xp_assert_close(res.statistic.data[~mask], xp.asarray(ref.statistic))
+    xp_assert_close(res.pvalue.data[~mask], xp.asarray(ref.pvalue))
+    xp_assert_close(res.statistic.mask, mask)
+    xp_assert_close(res.pvalue.mask, mask)
+    assert res.statistic.shape == shape
+    assert res.pvalue.shape == shape
+
+def test_length_nonmasked_marray_iterable_axis_raises():
+    xp = marray._get_namespace(np)
+
+    data = [[1.0, 2.0], [3.0, 4.0]]
+    mask = [[False, False], [True, False]]
+    marr = xp.asarray(data, mask=mask)
+
+    # Axis tuples are not currently supported for MArray input.
+    # This test can be removed after support is added.
+    with pytest.raises(NotImplementedError,
+        match="`axis` must be an integer or None for use with `MArray`"):
+        _length_nonmasked(marr, axis=(0, 1), xp=xp)