123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980 |
- import warnings
- import pytest
- import numpy as np
- from numpy.lib.nanfunctions import _nan_mask, _replace_nan
- from numpy.testing import (
- assert_, assert_equal, assert_almost_equal, assert_no_warnings,
- assert_raises, assert_array_equal, suppress_warnings
- )
- # Test data
- _ndat = np.array([[0.6244, np.nan, 0.2692, 0.0116, np.nan, 0.1170],
- [0.5351, -0.9403, np.nan, 0.2100, 0.4759, 0.2833],
- [np.nan, np.nan, np.nan, 0.1042, np.nan, -0.5954],
- [0.1610, np.nan, np.nan, 0.1859, 0.3146, np.nan]])
- # Rows of _ndat with nans removed
- _rdat = [np.array([0.6244, 0.2692, 0.0116, 0.1170]),
- np.array([0.5351, -0.9403, 0.2100, 0.4759, 0.2833]),
- np.array([0.1042, -0.5954]),
- np.array([0.1610, 0.1859, 0.3146])]
- # Rows of _ndat with nans converted to ones
- _ndat_ones = np.array([[0.6244, 1.0, 0.2692, 0.0116, 1.0, 0.1170],
- [0.5351, -0.9403, 1.0, 0.2100, 0.4759, 0.2833],
- [1.0, 1.0, 1.0, 0.1042, 1.0, -0.5954],
- [0.1610, 1.0, 1.0, 0.1859, 0.3146, 1.0]])
- # Rows of _ndat with nans converted to zeros
- _ndat_zeros = np.array([[0.6244, 0.0, 0.2692, 0.0116, 0.0, 0.1170],
- [0.5351, -0.9403, 0.0, 0.2100, 0.4759, 0.2833],
- [0.0, 0.0, 0.0, 0.1042, 0.0, -0.5954],
- [0.1610, 0.0, 0.0, 0.1859, 0.3146, 0.0]])
- class TestNanFunctions_MinMax:
- nanfuncs = [np.nanmin, np.nanmax]
- stdfuncs = [np.min, np.max]
- def test_mutation(self):
- # Check that passed array is not modified.
- ndat = _ndat.copy()
- for f in self.nanfuncs:
- f(ndat)
- assert_equal(ndat, _ndat)
- def test_keepdims(self):
- mat = np.eye(3)
- for nf, rf in zip(self.nanfuncs, self.stdfuncs):
- for axis in [None, 0, 1]:
- tgt = rf(mat, axis=axis, keepdims=True)
- res = nf(mat, axis=axis, keepdims=True)
- assert_(res.ndim == tgt.ndim)
- def test_out(self):
- mat = np.eye(3)
- for nf, rf in zip(self.nanfuncs, self.stdfuncs):
- resout = np.zeros(3)
- tgt = rf(mat, axis=1)
- res = nf(mat, axis=1, out=resout)
- assert_almost_equal(res, resout)
- assert_almost_equal(res, tgt)
- def test_dtype_from_input(self):
- codes = 'efdgFDG'
- for nf, rf in zip(self.nanfuncs, self.stdfuncs):
- for c in codes:
- mat = np.eye(3, dtype=c)
- tgt = rf(mat, axis=1).dtype.type
- res = nf(mat, axis=1).dtype.type
- assert_(res is tgt)
- # scalar case
- tgt = rf(mat, axis=None).dtype.type
- res = nf(mat, axis=None).dtype.type
- assert_(res is tgt)
- def test_result_values(self):
- for nf, rf in zip(self.nanfuncs, self.stdfuncs):
- tgt = [rf(d) for d in _rdat]
- res = nf(_ndat, axis=1)
- assert_almost_equal(res, tgt)
- def test_allnans(self):
- mat = np.array([np.nan]*9).reshape(3, 3)
- for f in self.nanfuncs:
- for axis in [None, 0, 1]:
- with warnings.catch_warnings(record=True) as w:
- warnings.simplefilter('always')
- assert_(np.isnan(f(mat, axis=axis)).all())
- assert_(len(w) == 1, 'no warning raised')
- assert_(issubclass(w[0].category, RuntimeWarning))
- # Check scalars
- with warnings.catch_warnings(record=True) as w:
- warnings.simplefilter('always')
- assert_(np.isnan(f(np.nan)))
- assert_(len(w) == 1, 'no warning raised')
- assert_(issubclass(w[0].category, RuntimeWarning))
- def test_masked(self):
- mat = np.ma.fix_invalid(_ndat)
- msk = mat._mask.copy()
- for f in [np.nanmin]:
- res = f(mat, axis=1)
- tgt = f(_ndat, axis=1)
- assert_equal(res, tgt)
- assert_equal(mat._mask, msk)
- assert_(not np.isinf(mat).any())
- def test_scalar(self):
- for f in self.nanfuncs:
- assert_(f(0.) == 0.)
- def test_subclass(self):
- class MyNDArray(np.ndarray):
- pass
- # Check that it works and that type and
- # shape are preserved
- mine = np.eye(3).view(MyNDArray)
- for f in self.nanfuncs:
- res = f(mine, axis=0)
- assert_(isinstance(res, MyNDArray))
- assert_(res.shape == (3,))
- res = f(mine, axis=1)
- assert_(isinstance(res, MyNDArray))
- assert_(res.shape == (3,))
- res = f(mine)
- assert_(res.shape == ())
- # check that rows of nan are dealt with for subclasses (#4628)
- mine[1] = np.nan
- for f in self.nanfuncs:
- with warnings.catch_warnings(record=True) as w:
- warnings.simplefilter('always')
- res = f(mine, axis=0)
- assert_(isinstance(res, MyNDArray))
- assert_(not np.any(np.isnan(res)))
- assert_(len(w) == 0)
- with warnings.catch_warnings(record=True) as w:
- warnings.simplefilter('always')
- res = f(mine, axis=1)
- assert_(isinstance(res, MyNDArray))
- assert_(np.isnan(res[1]) and not np.isnan(res[0])
- and not np.isnan(res[2]))
- assert_(len(w) == 1, 'no warning raised')
- assert_(issubclass(w[0].category, RuntimeWarning))
- with warnings.catch_warnings(record=True) as w:
- warnings.simplefilter('always')
- res = f(mine)
- assert_(res.shape == ())
- assert_(res != np.nan)
- assert_(len(w) == 0)
- def test_object_array(self):
- arr = np.array([[1.0, 2.0], [np.nan, 4.0], [np.nan, np.nan]], dtype=object)
- assert_equal(np.nanmin(arr), 1.0)
- assert_equal(np.nanmin(arr, axis=0), [1.0, 2.0])
- with warnings.catch_warnings(record=True) as w:
- warnings.simplefilter('always')
- # assert_equal does not work on object arrays of nan
- assert_equal(list(np.nanmin(arr, axis=1)), [1.0, 4.0, np.nan])
- assert_(len(w) == 1, 'no warning raised')
- assert_(issubclass(w[0].category, RuntimeWarning))
- class TestNanFunctions_ArgminArgmax:
- nanfuncs = [np.nanargmin, np.nanargmax]
- def test_mutation(self):
- # Check that passed array is not modified.
- ndat = _ndat.copy()
- for f in self.nanfuncs:
- f(ndat)
- assert_equal(ndat, _ndat)
- def test_result_values(self):
- for f, fcmp in zip(self.nanfuncs, [np.greater, np.less]):
- for row in _ndat:
- with suppress_warnings() as sup:
- sup.filter(RuntimeWarning, "invalid value encountered in")
- ind = f(row)
- val = row[ind]
- # comparing with NaN is tricky as the result
- # is always false except for NaN != NaN
- assert_(not np.isnan(val))
- assert_(not fcmp(val, row).any())
- assert_(not np.equal(val, row[:ind]).any())
- def test_allnans(self):
- mat = np.array([np.nan]*9).reshape(3, 3)
- for f in self.nanfuncs:
- for axis in [None, 0, 1]:
- assert_raises(ValueError, f, mat, axis=axis)
- assert_raises(ValueError, f, np.nan)
- def test_empty(self):
- mat = np.zeros((0, 3))
- for f in self.nanfuncs:
- for axis in [0, None]:
- assert_raises(ValueError, f, mat, axis=axis)
- for axis in [1]:
- res = f(mat, axis=axis)
- assert_equal(res, np.zeros(0))
- def test_scalar(self):
- for f in self.nanfuncs:
- assert_(f(0.) == 0.)
- def test_subclass(self):
- class MyNDArray(np.ndarray):
- pass
- # Check that it works and that type and
- # shape are preserved
- mine = np.eye(3).view(MyNDArray)
- for f in self.nanfuncs:
- res = f(mine, axis=0)
- assert_(isinstance(res, MyNDArray))
- assert_(res.shape == (3,))
- res = f(mine, axis=1)
- assert_(isinstance(res, MyNDArray))
- assert_(res.shape == (3,))
- res = f(mine)
- assert_(res.shape == ())
- class TestNanFunctions_IntTypes:
- int_types = (np.int8, np.int16, np.int32, np.int64, np.uint8,
- np.uint16, np.uint32, np.uint64)
- mat = np.array([127, 39, 93, 87, 46])
- def integer_arrays(self):
- for dtype in self.int_types:
- yield self.mat.astype(dtype)
- def test_nanmin(self):
- tgt = np.min(self.mat)
- for mat in self.integer_arrays():
- assert_equal(np.nanmin(mat), tgt)
- def test_nanmax(self):
- tgt = np.max(self.mat)
- for mat in self.integer_arrays():
- assert_equal(np.nanmax(mat), tgt)
- def test_nanargmin(self):
- tgt = np.argmin(self.mat)
- for mat in self.integer_arrays():
- assert_equal(np.nanargmin(mat), tgt)
- def test_nanargmax(self):
- tgt = np.argmax(self.mat)
- for mat in self.integer_arrays():
- assert_equal(np.nanargmax(mat), tgt)
- def test_nansum(self):
- tgt = np.sum(self.mat)
- for mat in self.integer_arrays():
- assert_equal(np.nansum(mat), tgt)
- def test_nanprod(self):
- tgt = np.prod(self.mat)
- for mat in self.integer_arrays():
- assert_equal(np.nanprod(mat), tgt)
- def test_nancumsum(self):
- tgt = np.cumsum(self.mat)
- for mat in self.integer_arrays():
- assert_equal(np.nancumsum(mat), tgt)
- def test_nancumprod(self):
- tgt = np.cumprod(self.mat)
- for mat in self.integer_arrays():
- assert_equal(np.nancumprod(mat), tgt)
- def test_nanmean(self):
- tgt = np.mean(self.mat)
- for mat in self.integer_arrays():
- assert_equal(np.nanmean(mat), tgt)
- def test_nanvar(self):
- tgt = np.var(self.mat)
- for mat in self.integer_arrays():
- assert_equal(np.nanvar(mat), tgt)
- tgt = np.var(mat, ddof=1)
- for mat in self.integer_arrays():
- assert_equal(np.nanvar(mat, ddof=1), tgt)
- def test_nanstd(self):
- tgt = np.std(self.mat)
- for mat in self.integer_arrays():
- assert_equal(np.nanstd(mat), tgt)
- tgt = np.std(self.mat, ddof=1)
- for mat in self.integer_arrays():
- assert_equal(np.nanstd(mat, ddof=1), tgt)
- class SharedNanFunctionsTestsMixin:
- def test_mutation(self):
- # Check that passed array is not modified.
- ndat = _ndat.copy()
- for f in self.nanfuncs:
- f(ndat)
- assert_equal(ndat, _ndat)
- def test_keepdims(self):
- mat = np.eye(3)
- for nf, rf in zip(self.nanfuncs, self.stdfuncs):
- for axis in [None, 0, 1]:
- tgt = rf(mat, axis=axis, keepdims=True)
- res = nf(mat, axis=axis, keepdims=True)
- assert_(res.ndim == tgt.ndim)
- def test_out(self):
- mat = np.eye(3)
- for nf, rf in zip(self.nanfuncs, self.stdfuncs):
- resout = np.zeros(3)
- tgt = rf(mat, axis=1)
- res = nf(mat, axis=1, out=resout)
- assert_almost_equal(res, resout)
- assert_almost_equal(res, tgt)
- def test_dtype_from_dtype(self):
- mat = np.eye(3)
- codes = 'efdgFDG'
- for nf, rf in zip(self.nanfuncs, self.stdfuncs):
- for c in codes:
- with suppress_warnings() as sup:
- if nf in {np.nanstd, np.nanvar} and c in 'FDG':
- # Giving the warning is a small bug, see gh-8000
- sup.filter(np.ComplexWarning)
- tgt = rf(mat, dtype=np.dtype(c), axis=1).dtype.type
- res = nf(mat, dtype=np.dtype(c), axis=1).dtype.type
- assert_(res is tgt)
- # scalar case
- tgt = rf(mat, dtype=np.dtype(c), axis=None).dtype.type
- res = nf(mat, dtype=np.dtype(c), axis=None).dtype.type
- assert_(res is tgt)
- def test_dtype_from_char(self):
- mat = np.eye(3)
- codes = 'efdgFDG'
- for nf, rf in zip(self.nanfuncs, self.stdfuncs):
- for c in codes:
- with suppress_warnings() as sup:
- if nf in {np.nanstd, np.nanvar} and c in 'FDG':
- # Giving the warning is a small bug, see gh-8000
- sup.filter(np.ComplexWarning)
- tgt = rf(mat, dtype=c, axis=1).dtype.type
- res = nf(mat, dtype=c, axis=1).dtype.type
- assert_(res is tgt)
- # scalar case
- tgt = rf(mat, dtype=c, axis=None).dtype.type
- res = nf(mat, dtype=c, axis=None).dtype.type
- assert_(res is tgt)
- def test_dtype_from_input(self):
- codes = 'efdgFDG'
- for nf, rf in zip(self.nanfuncs, self.stdfuncs):
- for c in codes:
- mat = np.eye(3, dtype=c)
- tgt = rf(mat, axis=1).dtype.type
- res = nf(mat, axis=1).dtype.type
- assert_(res is tgt, "res %s, tgt %s" % (res, tgt))
- # scalar case
- tgt = rf(mat, axis=None).dtype.type
- res = nf(mat, axis=None).dtype.type
- assert_(res is tgt)
- def test_result_values(self):
- for nf, rf in zip(self.nanfuncs, self.stdfuncs):
- tgt = [rf(d) for d in _rdat]
- res = nf(_ndat, axis=1)
- assert_almost_equal(res, tgt)
- def test_scalar(self):
- for f in self.nanfuncs:
- assert_(f(0.) == 0.)
- def test_subclass(self):
- class MyNDArray(np.ndarray):
- pass
- # Check that it works and that type and
- # shape are preserved
- array = np.eye(3)
- mine = array.view(MyNDArray)
- for f in self.nanfuncs:
- expected_shape = f(array, axis=0).shape
- res = f(mine, axis=0)
- assert_(isinstance(res, MyNDArray))
- assert_(res.shape == expected_shape)
- expected_shape = f(array, axis=1).shape
- res = f(mine, axis=1)
- assert_(isinstance(res, MyNDArray))
- assert_(res.shape == expected_shape)
- expected_shape = f(array).shape
- res = f(mine)
- assert_(isinstance(res, MyNDArray))
- assert_(res.shape == expected_shape)
- class TestNanFunctions_SumProd(SharedNanFunctionsTestsMixin):
- nanfuncs = [np.nansum, np.nanprod]
- stdfuncs = [np.sum, np.prod]
- def test_allnans(self):
- # Check for FutureWarning
- with warnings.catch_warnings(record=True) as w:
- warnings.simplefilter('always')
- res = np.nansum([np.nan]*3, axis=None)
- assert_(res == 0, 'result is not 0')
- assert_(len(w) == 0, 'warning raised')
- # Check scalar
- res = np.nansum(np.nan)
- assert_(res == 0, 'result is not 0')
- assert_(len(w) == 0, 'warning raised')
- # Check there is no warning for not all-nan
- np.nansum([0]*3, axis=None)
- assert_(len(w) == 0, 'unwanted warning raised')
- def test_empty(self):
- for f, tgt_value in zip([np.nansum, np.nanprod], [0, 1]):
- mat = np.zeros((0, 3))
- tgt = [tgt_value]*3
- res = f(mat, axis=0)
- assert_equal(res, tgt)
- tgt = []
- res = f(mat, axis=1)
- assert_equal(res, tgt)
- tgt = tgt_value
- res = f(mat, axis=None)
- assert_equal(res, tgt)
- class TestNanFunctions_CumSumProd(SharedNanFunctionsTestsMixin):
- nanfuncs = [np.nancumsum, np.nancumprod]
- stdfuncs = [np.cumsum, np.cumprod]
- def test_allnans(self):
- for f, tgt_value in zip(self.nanfuncs, [0, 1]):
- # Unlike other nan-functions, sum/prod/cumsum/cumprod don't warn on all nan input
- with assert_no_warnings():
- res = f([np.nan]*3, axis=None)
- tgt = tgt_value*np.ones((3))
- assert_(np.array_equal(res, tgt), 'result is not %s * np.ones((3))' % (tgt_value))
- # Check scalar
- res = f(np.nan)
- tgt = tgt_value*np.ones((1))
- assert_(np.array_equal(res, tgt), 'result is not %s * np.ones((1))' % (tgt_value))
- # Check there is no warning for not all-nan
- f([0]*3, axis=None)
- def test_empty(self):
- for f, tgt_value in zip(self.nanfuncs, [0, 1]):
- mat = np.zeros((0, 3))
- tgt = tgt_value*np.ones((0, 3))
- res = f(mat, axis=0)
- assert_equal(res, tgt)
- tgt = mat
- res = f(mat, axis=1)
- assert_equal(res, tgt)
- tgt = np.zeros((0))
- res = f(mat, axis=None)
- assert_equal(res, tgt)
- def test_keepdims(self):
- for f, g in zip(self.nanfuncs, self.stdfuncs):
- mat = np.eye(3)
- for axis in [None, 0, 1]:
- tgt = f(mat, axis=axis, out=None)
- res = g(mat, axis=axis, out=None)
- assert_(res.ndim == tgt.ndim)
- for f in self.nanfuncs:
- d = np.ones((3, 5, 7, 11))
- # Randomly set some elements to NaN:
- rs = np.random.RandomState(0)
- d[rs.rand(*d.shape) < 0.5] = np.nan
- res = f(d, axis=None)
- assert_equal(res.shape, (1155,))
- for axis in np.arange(4):
- res = f(d, axis=axis)
- assert_equal(res.shape, (3, 5, 7, 11))
- def test_result_values(self):
- for axis in (-2, -1, 0, 1, None):
- tgt = np.cumprod(_ndat_ones, axis=axis)
- res = np.nancumprod(_ndat, axis=axis)
- assert_almost_equal(res, tgt)
- tgt = np.cumsum(_ndat_zeros,axis=axis)
- res = np.nancumsum(_ndat, axis=axis)
- assert_almost_equal(res, tgt)
- def test_out(self):
- mat = np.eye(3)
- for nf, rf in zip(self.nanfuncs, self.stdfuncs):
- resout = np.eye(3)
- for axis in (-2, -1, 0, 1):
- tgt = rf(mat, axis=axis)
- res = nf(mat, axis=axis, out=resout)
- assert_almost_equal(res, resout)
- assert_almost_equal(res, tgt)
- class TestNanFunctions_MeanVarStd(SharedNanFunctionsTestsMixin):
- nanfuncs = [np.nanmean, np.nanvar, np.nanstd]
- stdfuncs = [np.mean, np.var, np.std]
- def test_dtype_error(self):
- for f in self.nanfuncs:
- for dtype in [np.bool_, np.int_, np.object_]:
- assert_raises(TypeError, f, _ndat, axis=1, dtype=dtype)
- def test_out_dtype_error(self):
- for f in self.nanfuncs:
- for dtype in [np.bool_, np.int_, np.object_]:
- out = np.empty(_ndat.shape[0], dtype=dtype)
- assert_raises(TypeError, f, _ndat, axis=1, out=out)
- def test_ddof(self):
- nanfuncs = [np.nanvar, np.nanstd]
- stdfuncs = [np.var, np.std]
- for nf, rf in zip(nanfuncs, stdfuncs):
- for ddof in [0, 1]:
- tgt = [rf(d, ddof=ddof) for d in _rdat]
- res = nf(_ndat, axis=1, ddof=ddof)
- assert_almost_equal(res, tgt)
- def test_ddof_too_big(self):
- nanfuncs = [np.nanvar, np.nanstd]
- stdfuncs = [np.var, np.std]
- dsize = [len(d) for d in _rdat]
- for nf, rf in zip(nanfuncs, stdfuncs):
- for ddof in range(5):
- with suppress_warnings() as sup:
- sup.record(RuntimeWarning)
- sup.filter(np.ComplexWarning)
- tgt = [ddof >= d for d in dsize]
- res = nf(_ndat, axis=1, ddof=ddof)
- assert_equal(np.isnan(res), tgt)
- if any(tgt):
- assert_(len(sup.log) == 1)
- else:
- assert_(len(sup.log) == 0)
- def test_allnans(self):
- mat = np.array([np.nan]*9).reshape(3, 3)
- for f in self.nanfuncs:
- for axis in [None, 0, 1]:
- with warnings.catch_warnings(record=True) as w:
- warnings.simplefilter('always')
- assert_(np.isnan(f(mat, axis=axis)).all())
- assert_(len(w) == 1)
- assert_(issubclass(w[0].category, RuntimeWarning))
- # Check scalar
- assert_(np.isnan(f(np.nan)))
- assert_(len(w) == 2)
- assert_(issubclass(w[0].category, RuntimeWarning))
- def test_empty(self):
- mat = np.zeros((0, 3))
- for f in self.nanfuncs:
- for axis in [0, None]:
- with warnings.catch_warnings(record=True) as w:
- warnings.simplefilter('always')
- assert_(np.isnan(f(mat, axis=axis)).all())
- assert_(len(w) == 1)
- assert_(issubclass(w[0].category, RuntimeWarning))
- for axis in [1]:
- with warnings.catch_warnings(record=True) as w:
- warnings.simplefilter('always')
- assert_equal(f(mat, axis=axis), np.zeros([]))
- assert_(len(w) == 0)
- class TestNanFunctions_Median:
- def test_mutation(self):
- # Check that passed array is not modified.
- ndat = _ndat.copy()
- np.nanmedian(ndat)
- assert_equal(ndat, _ndat)
- def test_keepdims(self):
- mat = np.eye(3)
- for axis in [None, 0, 1]:
- tgt = np.median(mat, axis=axis, out=None, overwrite_input=False)
- res = np.nanmedian(mat, axis=axis, out=None, overwrite_input=False)
- assert_(res.ndim == tgt.ndim)
- d = np.ones((3, 5, 7, 11))
- # Randomly set some elements to NaN:
- w = np.random.random((4, 200)) * np.array(d.shape)[:, None]
- w = w.astype(np.intp)
- d[tuple(w)] = np.nan
- with suppress_warnings() as sup:
- sup.filter(RuntimeWarning)
- res = np.nanmedian(d, axis=None, keepdims=True)
- assert_equal(res.shape, (1, 1, 1, 1))
- res = np.nanmedian(d, axis=(0, 1), keepdims=True)
- assert_equal(res.shape, (1, 1, 7, 11))
- res = np.nanmedian(d, axis=(0, 3), keepdims=True)
- assert_equal(res.shape, (1, 5, 7, 1))
- res = np.nanmedian(d, axis=(1,), keepdims=True)
- assert_equal(res.shape, (3, 1, 7, 11))
- res = np.nanmedian(d, axis=(0, 1, 2, 3), keepdims=True)
- assert_equal(res.shape, (1, 1, 1, 1))
- res = np.nanmedian(d, axis=(0, 1, 3), keepdims=True)
- assert_equal(res.shape, (1, 1, 7, 1))
- def test_out(self):
- mat = np.random.rand(3, 3)
- nan_mat = np.insert(mat, [0, 2], np.nan, axis=1)
- resout = np.zeros(3)
- tgt = np.median(mat, axis=1)
- res = np.nanmedian(nan_mat, axis=1, out=resout)
- assert_almost_equal(res, resout)
- assert_almost_equal(res, tgt)
- # 0-d output:
- resout = np.zeros(())
- tgt = np.median(mat, axis=None)
- res = np.nanmedian(nan_mat, axis=None, out=resout)
- assert_almost_equal(res, resout)
- assert_almost_equal(res, tgt)
- res = np.nanmedian(nan_mat, axis=(0, 1), out=resout)
- assert_almost_equal(res, resout)
- assert_almost_equal(res, tgt)
- def test_small_large(self):
- # test the small and large code paths, current cutoff 400 elements
- for s in [5, 20, 51, 200, 1000]:
- d = np.random.randn(4, s)
- # Randomly set some elements to NaN:
- w = np.random.randint(0, d.size, size=d.size // 5)
- d.ravel()[w] = np.nan
- d[:,0] = 1. # ensure at least one good value
- # use normal median without nans to compare
- tgt = []
- for x in d:
- nonan = np.compress(~np.isnan(x), x)
- tgt.append(np.median(nonan, overwrite_input=True))
- assert_array_equal(np.nanmedian(d, axis=-1), tgt)
- def test_result_values(self):
- tgt = [np.median(d) for d in _rdat]
- res = np.nanmedian(_ndat, axis=1)
- assert_almost_equal(res, tgt)
- def test_allnans(self):
- mat = np.array([np.nan]*9).reshape(3, 3)
- for axis in [None, 0, 1]:
- with suppress_warnings() as sup:
- sup.record(RuntimeWarning)
- assert_(np.isnan(np.nanmedian(mat, axis=axis)).all())
- if axis is None:
- assert_(len(sup.log) == 1)
- else:
- assert_(len(sup.log) == 3)
- # Check scalar
- assert_(np.isnan(np.nanmedian(np.nan)))
- if axis is None:
- assert_(len(sup.log) == 2)
- else:
- assert_(len(sup.log) == 4)
- def test_empty(self):
- mat = np.zeros((0, 3))
- for axis in [0, None]:
- with warnings.catch_warnings(record=True) as w:
- warnings.simplefilter('always')
- assert_(np.isnan(np.nanmedian(mat, axis=axis)).all())
- assert_(len(w) == 1)
- assert_(issubclass(w[0].category, RuntimeWarning))
- for axis in [1]:
- with warnings.catch_warnings(record=True) as w:
- warnings.simplefilter('always')
- assert_equal(np.nanmedian(mat, axis=axis), np.zeros([]))
- assert_(len(w) == 0)
- def test_scalar(self):
- assert_(np.nanmedian(0.) == 0.)
- def test_extended_axis_invalid(self):
- d = np.ones((3, 5, 7, 11))
- assert_raises(np.AxisError, np.nanmedian, d, axis=-5)
- assert_raises(np.AxisError, np.nanmedian, d, axis=(0, -5))
- assert_raises(np.AxisError, np.nanmedian, d, axis=4)
- assert_raises(np.AxisError, np.nanmedian, d, axis=(0, 4))
- assert_raises(ValueError, np.nanmedian, d, axis=(1, 1))
- def test_float_special(self):
- with suppress_warnings() as sup:
- sup.filter(RuntimeWarning)
- for inf in [np.inf, -np.inf]:
- a = np.array([[inf, np.nan], [np.nan, np.nan]])
- assert_equal(np.nanmedian(a, axis=0), [inf, np.nan])
- assert_equal(np.nanmedian(a, axis=1), [inf, np.nan])
- assert_equal(np.nanmedian(a), inf)
- # minimum fill value check
- a = np.array([[np.nan, np.nan, inf],
- [np.nan, np.nan, inf]])
- assert_equal(np.nanmedian(a), inf)
- assert_equal(np.nanmedian(a, axis=0), [np.nan, np.nan, inf])
- assert_equal(np.nanmedian(a, axis=1), inf)
- # no mask path
- a = np.array([[inf, inf], [inf, inf]])
- assert_equal(np.nanmedian(a, axis=1), inf)
- a = np.array([[inf, 7, -inf, -9],
- [-10, np.nan, np.nan, 5],
- [4, np.nan, np.nan, inf]],
- dtype=np.float32)
- if inf > 0:
- assert_equal(np.nanmedian(a, axis=0), [4., 7., -inf, 5.])
- assert_equal(np.nanmedian(a), 4.5)
- else:
- assert_equal(np.nanmedian(a, axis=0), [-10., 7., -inf, -9.])
- assert_equal(np.nanmedian(a), -2.5)
- assert_equal(np.nanmedian(a, axis=-1), [-1., -2.5, inf])
- for i in range(0, 10):
- for j in range(1, 10):
- a = np.array([([np.nan] * i) + ([inf] * j)] * 2)
- assert_equal(np.nanmedian(a), inf)
- assert_equal(np.nanmedian(a, axis=1), inf)
- assert_equal(np.nanmedian(a, axis=0),
- ([np.nan] * i) + [inf] * j)
- a = np.array([([np.nan] * i) + ([-inf] * j)] * 2)
- assert_equal(np.nanmedian(a), -inf)
- assert_equal(np.nanmedian(a, axis=1), -inf)
- assert_equal(np.nanmedian(a, axis=0),
- ([np.nan] * i) + [-inf] * j)
- class TestNanFunctions_Percentile:
- def test_mutation(self):
- # Check that passed array is not modified.
- ndat = _ndat.copy()
- np.nanpercentile(ndat, 30)
- assert_equal(ndat, _ndat)
- def test_keepdims(self):
- mat = np.eye(3)
- for axis in [None, 0, 1]:
- tgt = np.percentile(mat, 70, axis=axis, out=None,
- overwrite_input=False)
- res = np.nanpercentile(mat, 70, axis=axis, out=None,
- overwrite_input=False)
- assert_(res.ndim == tgt.ndim)
- d = np.ones((3, 5, 7, 11))
- # Randomly set some elements to NaN:
- w = np.random.random((4, 200)) * np.array(d.shape)[:, None]
- w = w.astype(np.intp)
- d[tuple(w)] = np.nan
- with suppress_warnings() as sup:
- sup.filter(RuntimeWarning)
- res = np.nanpercentile(d, 90, axis=None, keepdims=True)
- assert_equal(res.shape, (1, 1, 1, 1))
- res = np.nanpercentile(d, 90, axis=(0, 1), keepdims=True)
- assert_equal(res.shape, (1, 1, 7, 11))
- res = np.nanpercentile(d, 90, axis=(0, 3), keepdims=True)
- assert_equal(res.shape, (1, 5, 7, 1))
- res = np.nanpercentile(d, 90, axis=(1,), keepdims=True)
- assert_equal(res.shape, (3, 1, 7, 11))
- res = np.nanpercentile(d, 90, axis=(0, 1, 2, 3), keepdims=True)
- assert_equal(res.shape, (1, 1, 1, 1))
- res = np.nanpercentile(d, 90, axis=(0, 1, 3), keepdims=True)
- assert_equal(res.shape, (1, 1, 7, 1))
- def test_out(self):
- mat = np.random.rand(3, 3)
- nan_mat = np.insert(mat, [0, 2], np.nan, axis=1)
- resout = np.zeros(3)
- tgt = np.percentile(mat, 42, axis=1)
- res = np.nanpercentile(nan_mat, 42, axis=1, out=resout)
- assert_almost_equal(res, resout)
- assert_almost_equal(res, tgt)
- # 0-d output:
- resout = np.zeros(())
- tgt = np.percentile(mat, 42, axis=None)
- res = np.nanpercentile(nan_mat, 42, axis=None, out=resout)
- assert_almost_equal(res, resout)
- assert_almost_equal(res, tgt)
- res = np.nanpercentile(nan_mat, 42, axis=(0, 1), out=resout)
- assert_almost_equal(res, resout)
- assert_almost_equal(res, tgt)
- def test_result_values(self):
- tgt = [np.percentile(d, 28) for d in _rdat]
- res = np.nanpercentile(_ndat, 28, axis=1)
- assert_almost_equal(res, tgt)
- # Transpose the array to fit the output convention of numpy.percentile
- tgt = np.transpose([np.percentile(d, (28, 98)) for d in _rdat])
- res = np.nanpercentile(_ndat, (28, 98), axis=1)
- assert_almost_equal(res, tgt)
- def test_allnans(self):
- mat = np.array([np.nan]*9).reshape(3, 3)
- for axis in [None, 0, 1]:
- with warnings.catch_warnings(record=True) as w:
- warnings.simplefilter('always')
- assert_(np.isnan(np.nanpercentile(mat, 60, axis=axis)).all())
- if axis is None:
- assert_(len(w) == 1)
- else:
- assert_(len(w) == 3)
- assert_(issubclass(w[0].category, RuntimeWarning))
- # Check scalar
- assert_(np.isnan(np.nanpercentile(np.nan, 60)))
- if axis is None:
- assert_(len(w) == 2)
- else:
- assert_(len(w) == 4)
- assert_(issubclass(w[0].category, RuntimeWarning))
- def test_empty(self):
- mat = np.zeros((0, 3))
- for axis in [0, None]:
- with warnings.catch_warnings(record=True) as w:
- warnings.simplefilter('always')
- assert_(np.isnan(np.nanpercentile(mat, 40, axis=axis)).all())
- assert_(len(w) == 1)
- assert_(issubclass(w[0].category, RuntimeWarning))
- for axis in [1]:
- with warnings.catch_warnings(record=True) as w:
- warnings.simplefilter('always')
- assert_equal(np.nanpercentile(mat, 40, axis=axis), np.zeros([]))
- assert_(len(w) == 0)
- def test_scalar(self):
- assert_equal(np.nanpercentile(0., 100), 0.)
- a = np.arange(6)
- r = np.nanpercentile(a, 50, axis=0)
- assert_equal(r, 2.5)
- assert_(np.isscalar(r))
- def test_extended_axis_invalid(self):
- d = np.ones((3, 5, 7, 11))
- assert_raises(np.AxisError, np.nanpercentile, d, q=5, axis=-5)
- assert_raises(np.AxisError, np.nanpercentile, d, q=5, axis=(0, -5))
- assert_raises(np.AxisError, np.nanpercentile, d, q=5, axis=4)
- assert_raises(np.AxisError, np.nanpercentile, d, q=5, axis=(0, 4))
- assert_raises(ValueError, np.nanpercentile, d, q=5, axis=(1, 1))
- def test_multiple_percentiles(self):
- perc = [50, 100]
- mat = np.ones((4, 3))
- nan_mat = np.nan * mat
- # For checking consistency in higher dimensional case
- large_mat = np.ones((3, 4, 5))
- large_mat[:, 0:2:4, :] = 0
- large_mat[:, :, 3:] *= 2
- for axis in [None, 0, 1]:
- for keepdim in [False, True]:
- with suppress_warnings() as sup:
- sup.filter(RuntimeWarning, "All-NaN slice encountered")
- val = np.percentile(mat, perc, axis=axis, keepdims=keepdim)
- nan_val = np.nanpercentile(nan_mat, perc, axis=axis,
- keepdims=keepdim)
- assert_equal(nan_val.shape, val.shape)
- val = np.percentile(large_mat, perc, axis=axis,
- keepdims=keepdim)
- nan_val = np.nanpercentile(large_mat, perc, axis=axis,
- keepdims=keepdim)
- assert_equal(nan_val, val)
- megamat = np.ones((3, 4, 5, 6))
- assert_equal(np.nanpercentile(megamat, perc, axis=(1, 2)).shape, (2, 3, 6))
- class TestNanFunctions_Quantile:
- # most of this is already tested by TestPercentile
- def test_regression(self):
- ar = np.arange(24).reshape(2, 3, 4).astype(float)
- ar[0][1] = np.nan
- assert_equal(np.nanquantile(ar, q=0.5), np.nanpercentile(ar, q=50))
- assert_equal(np.nanquantile(ar, q=0.5, axis=0),
- np.nanpercentile(ar, q=50, axis=0))
- assert_equal(np.nanquantile(ar, q=0.5, axis=1),
- np.nanpercentile(ar, q=50, axis=1))
- assert_equal(np.nanquantile(ar, q=[0.5], axis=1),
- np.nanpercentile(ar, q=[50], axis=1))
- assert_equal(np.nanquantile(ar, q=[0.25, 0.5, 0.75], axis=1),
- np.nanpercentile(ar, q=[25, 50, 75], axis=1))
- def test_basic(self):
- x = np.arange(8) * 0.5
- assert_equal(np.nanquantile(x, 0), 0.)
- assert_equal(np.nanquantile(x, 1), 3.5)
- assert_equal(np.nanquantile(x, 0.5), 1.75)
- def test_no_p_overwrite(self):
- # this is worth retesting, because quantile does not make a copy
- p0 = np.array([0, 0.75, 0.25, 0.5, 1.0])
- p = p0.copy()
- np.nanquantile(np.arange(100.), p, interpolation="midpoint")
- assert_array_equal(p, p0)
- p0 = p0.tolist()
- p = p.tolist()
- np.nanquantile(np.arange(100.), p, interpolation="midpoint")
- assert_array_equal(p, p0)
- @pytest.mark.parametrize("arr, expected", [
- # array of floats with some nans
- (np.array([np.nan, 5.0, np.nan, np.inf]),
- np.array([False, True, False, True])),
- # int64 array that can't possibly have nans
- (np.array([1, 5, 7, 9], dtype=np.int64),
- True),
- # bool array that can't possibly have nans
- (np.array([False, True, False, True]),
- True),
- # 2-D complex array with nans
- (np.array([[np.nan, 5.0],
- [np.nan, np.inf]], dtype=np.complex64),
- np.array([[False, True],
- [False, True]])),
- ])
- def test__nan_mask(arr, expected):
- for out in [None, np.empty(arr.shape, dtype=np.bool_)]:
- actual = _nan_mask(arr, out=out)
- assert_equal(actual, expected)
- # the above won't distinguish between True proper
- # and an array of True values; we want True proper
- # for types that can't possibly contain NaN
- if type(expected) is not np.ndarray:
- assert actual is True
- def test__replace_nan():
- """ Test that _replace_nan returns the original array if there are no
- NaNs, not a copy.
- """
- for dtype in [np.bool_, np.int32, np.int64]:
- arr = np.array([0, 1], dtype=dtype)
- result, mask = _replace_nan(arr, 0)
- assert mask is None
- # do not make a copy if there are no nans
- assert result is arr
- for dtype in [np.float32, np.float64]:
- arr = np.array([0, 1], dtype=dtype)
- result, mask = _replace_nan(arr, 2)
- assert (mask == False).all()
- # mask is not None, so we make a copy
- assert result is not arr
- assert_equal(result, arr)
- arr_nan = np.array([0, 1, np.nan], dtype=dtype)
- result_nan, mask_nan = _replace_nan(arr_nan, 2)
- assert_equal(mask_nan, np.array([False, False, True]))
- assert result_nan is not arr_nan
- assert_equal(result_nan, np.array([0, 1, 2]))
- assert np.isnan(arr_nan[-1])
|