From 24960daf3e326591047eb099af840da6e95d0910 Mon Sep 17 00:00:00 2001 From: Eric Wieser Date: Sun, 19 Feb 2017 13:12:30 +0000 Subject: BUG: Preserve types of empty arrays when known Fixes regression in #5805 --- numpy/lib/tests/test_index_tricks.py | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) (limited to 'numpy/lib/tests') diff --git a/numpy/lib/tests/test_index_tricks.py b/numpy/lib/tests/test_index_tricks.py index d9fa1f43e..e645114ab 100644 --- a/numpy/lib/tests/test_index_tricks.py +++ b/numpy/lib/tests/test_index_tricks.py @@ -198,11 +198,16 @@ class TestIndexExpression(TestCase): class TestIx_(TestCase): def test_regression_1(self): - # Test empty inputs create ouputs of indexing type, gh-5804 - # Test both lists and arrays - for func in (range, np.arange): - a, = np.ix_(func(0)) - assert_equal(a.dtype, np.intp) + # Test empty untyped inputs create ouputs of indexing type, gh-5804 + a, = np.ix_(range(0)) + assert_equal(a.dtype, np.intp) + + a, = np.ix_([]) + assert_equal(a.dtype, np.intp) + + # but if the type is specified, don't change it + a, = np.ix_(np.array([], dtype=np.float32)) + assert_equal(a.dtype, np.float32) def test_shape_and_dtype(self): sizes = (4, 5, 3, 2) -- cgit v1.2.1 From b5895be146cdc3063ffa9ca8ae27b5bcf7992719 Mon Sep 17 00:00:00 2001 From: Eric Wieser Date: Sun, 14 Apr 2019 19:26:53 -0700 Subject: BUG: Fix structured_to_unstructured on single-field types Previously a single-field type would decay, which is undesirable. The included test previously did not pass --- numpy/lib/tests/test_recfunctions.py | 2 ++ 1 file changed, 2 insertions(+) (limited to 'numpy/lib/tests') diff --git a/numpy/lib/tests/test_recfunctions.py b/numpy/lib/tests/test_recfunctions.py index 11f8a5afa..d1fcf2153 100644 --- a/numpy/lib/tests/test_recfunctions.py +++ b/numpy/lib/tests/test_recfunctions.py @@ -214,6 +214,8 @@ class TestRecFunctions(object): dtype=[('x', 'i4'), ('y', 'f4'), ('z', 'f8')]) out = np.mean(structured_to_unstructured(b[['x', 'z']]), axis=-1) assert_equal(out, np.array([ 3. , 5.5, 9. , 11. ])) + out = np.mean(structured_to_unstructured(b[['x']]), axis=-1) + assert_equal(out, np.array([ 1. , 4. , 7. , 10. ])) c = np.arange(20).reshape((4,5)) out = unstructured_to_structured(c, a.dtype) -- cgit v1.2.1 From 9a23f16b67958205468f7f5c4e0966f393558d9a Mon Sep 17 00:00:00 2001 From: Eric Wieser Date: Tue, 23 Apr 2019 01:55:21 -0700 Subject: ENH: Add support for Fraction to percentile and quantile With true division available, using `.0` to convert integers to floats offers no value, and harms compatibility with precise rational types. --- numpy/lib/tests/test_function_base.py | 36 +++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) (limited to 'numpy/lib/tests') diff --git a/numpy/lib/tests/test_function_base.py b/numpy/lib/tests/test_function_base.py index e2c24a123..6d32c365a 100644 --- a/numpy/lib/tests/test_function_base.py +++ b/numpy/lib/tests/test_function_base.py @@ -5,6 +5,7 @@ import warnings import sys import decimal import types +from fractions import Fraction import pytest import numpy as np @@ -2508,6 +2509,21 @@ class TestPercentile(object): assert_equal(np.percentile(x, 0), np.nan) assert_equal(np.percentile(x, 0, interpolation='nearest'), np.nan) + def test_fraction(self): + x = [Fraction(i, 2) for i in np.arange(8)] + + p = np.percentile(x, Fraction(0)) + assert_equal(p, Fraction(0)) + assert_equal(type(p), Fraction) + + p = np.percentile(x, Fraction(100)) + assert_equal(p, Fraction(7, 2)) + assert_equal(type(p), Fraction) + + p = np.percentile(x, Fraction(50)) + assert_equal(p, Fraction(7, 4)) + assert_equal(type(p), Fraction) + def test_api(self): d = np.ones(5) np.percentile(d, 5, None, None, False) @@ -2912,6 +2928,26 @@ class TestQuantile(object): assert_equal(np.quantile(x, 1), 3.5) assert_equal(np.quantile(x, 0.5), 1.75) + def test_fraction(self): + # fractional input, integral quantile + x = [Fraction(i, 2) for i in np.arange(8)] + + q = np.quantile(x, 0) + assert_equal(q, 0) + assert_equal(type(q), Fraction) + + q = np.quantile(x, 1) + assert_equal(q, Fraction(7, 2)) + assert_equal(type(q), Fraction) + + q = np.quantile(x, Fraction(1, 2)) + assert_equal(q, Fraction(7, 4)) + assert_equal(type(q), Fraction) + + # repeat with integral input but fractional quantile + x = np.arange(8) + assert_equal(np.quantile(x, Fraction(1, 2)), Fraction(7, 2)) + 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]) -- cgit v1.2.1 From d7de4ad70d6794b36e4789e4f6146a884113bd66 Mon Sep 17 00:00:00 2001 From: ayir Date: Wed, 10 Apr 2019 17:00:25 +0200 Subject: ENH: add clearer error message for diff(0-d) --- numpy/lib/tests/test_function_base.py | 3 +++ 1 file changed, 3 insertions(+) (limited to 'numpy/lib/tests') diff --git a/numpy/lib/tests/test_function_base.py b/numpy/lib/tests/test_function_base.py index 1e04bfaec..8f1b56e3f 100644 --- a/numpy/lib/tests/test_function_base.py +++ b/numpy/lib/tests/test_function_base.py @@ -695,6 +695,9 @@ class TestDiff(object): assert_raises(np.AxisError, diff, x, axis=3) assert_raises(np.AxisError, diff, x, axis=-4) + x = np.array(1.11111111111, np.float64) + assert_raises(ValueError, diff, x) + def test_nd(self): x = 20 * rand(10, 20, 30) out1 = x[:, :, 1:] - x[:, :, :-1] -- cgit v1.2.1 From 59a521ee07693cc5c58d68987691df4bcc9e48ff Mon Sep 17 00:00:00 2001 From: Sebastian Berg Date: Fri, 26 Apr 2019 09:21:32 -0700 Subject: BUG: (py2 only) fix unicode support for savetxt fmt string By now, all that is needed is to also allow unicode strings to pass through. Adds a test for the support which already succeeds on python3. Closes gh-4053 (replaces the old PR) --- numpy/lib/tests/test_io.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) (limited to 'numpy/lib/tests') diff --git a/numpy/lib/tests/test_io.py b/numpy/lib/tests/test_io.py index 835344429..f26f89f40 100644 --- a/numpy/lib/tests/test_io.py +++ b/numpy/lib/tests/test_io.py @@ -561,6 +561,19 @@ class TestSaveTxt(object): s.seek(0) assert_equal(s.read(), utf8 + '\n') + @pytest.mark.parametrize("fmt", [u"%f", b"%f"]) + @pytest.mark.parametrize("iotype", [StringIO, BytesIO]) + def test_unicode_and_bytes_fmt(self, fmt, iotype): + # string type of fmt should not matter, see also gh-4053 + a = np.array([1.]) + s = iotype() + np.savetxt(s, a, fmt=fmt) + s.seek(0) + if iotype is StringIO: + assert_equal(s.read(), u"%f\n" % 1.) + else: + assert_equal(s.read(), b"%f\n" % 1.) + class LoadTxtBase(object): def check_compressed(self, fopen, suffixes): -- cgit v1.2.1 From 666d92ac85a6adf0fec7361c3340fc6ab12c8330 Mon Sep 17 00:00:00 2001 From: mattip Date: Tue, 30 Apr 2019 06:47:29 -0400 Subject: BUG: handle subarrays in descr_to_dtype --- numpy/lib/tests/test_format.py | 1 + 1 file changed, 1 insertion(+) (limited to 'numpy/lib/tests') diff --git a/numpy/lib/tests/test_format.py b/numpy/lib/tests/test_format.py index 2ebd483d5..9d12fafc0 100644 --- a/numpy/lib/tests/test_format.py +++ b/numpy/lib/tests/test_format.py @@ -411,6 +411,7 @@ record_arrays = [ np.array(NbufferT, dtype=np.dtype(Ndescr).newbyteorder('<')), np.array(PbufferT, dtype=np.dtype(Pdescr).newbyteorder('>')), np.array(NbufferT, dtype=np.dtype(Ndescr).newbyteorder('>')), + np.zeros(1, dtype=[('c', (' Date: Sun, 14 Apr 2019 15:49:15 -0700 Subject: BUG: Always return views from structured_to_unstructured when possible Also applies to unstructured_to_structured While producing correct resutls, the test added in this commit would previously make an unecessary copy, causing the assertion to fail. The cause was `astype` was being asked to convert from a subarray of shape `(x, y)` to one of `(x*y,)`, which it cannot do without making a copy. This changes the approach used to skip the step of flattening subarrays to 1d --- numpy/lib/tests/test_recfunctions.py | 9 +++++++++ 1 file changed, 9 insertions(+) (limited to 'numpy/lib/tests') diff --git a/numpy/lib/tests/test_recfunctions.py b/numpy/lib/tests/test_recfunctions.py index d1fcf2153..d4d317d30 100644 --- a/numpy/lib/tests/test_recfunctions.py +++ b/numpy/lib/tests/test_recfunctions.py @@ -243,6 +243,15 @@ class TestRecFunctions(object): assert_(dd.base is d) assert_(ddd.base is d) + # including uniform fields with subarrays unpacked + d = np.array([(1, [2, 3], [[ 4, 5], [ 6, 7]]), + (8, [9, 10], [[11, 12], [13, 14]])], + dtype=[('x0', 'i4'), ('x1', ('i4', 2)), ('x2', ('i4', (2, 2)))]) + dd = structured_to_unstructured(d) + ddd = unstructured_to_structured(dd, d.dtype) + assert_(dd.base is d) + assert_(ddd.base is d) + # test that nested fields with identical names don't break anything point = np.dtype([('x', int), ('y', int)]) triangle = np.dtype([('a', point), ('b', point), ('c', point)]) -- cgit v1.2.1 From f16c558fc3c3b57c4f2a93a80a778746ddd2f8ef Mon Sep 17 00:00:00 2001 From: psschand Date: Thu, 2 May 2019 06:06:30 +0530 Subject: BUG: fix unravel_index when dimension is greater than 'intp' The PR is: gh13439 Closes gh-9538 --- numpy/lib/tests/test_index_tricks.py | 3 +++ 1 file changed, 3 insertions(+) (limited to 'numpy/lib/tests') diff --git a/numpy/lib/tests/test_index_tricks.py b/numpy/lib/tests/test_index_tricks.py index e687e2f54..2f7e97831 100644 --- a/numpy/lib/tests/test_index_tricks.py +++ b/numpy/lib/tests/test_index_tricks.py @@ -106,6 +106,9 @@ class TestRavelUnravelIndex(object): np.ravel_multi_index(arr, (41, 7, 120, 36, 2706, 8, 6)), [5627771580, 117259570957]) + # test unravel_index for big indices (issue #9538) + assert_raises(ValueError, np.unravel_index, 1, (2**32-1, 2**31+1)) + # test overflow checking for too big array (issue #7546) dummy_arr = ([0],[0]) half_max = np.iinfo(np.intp).max // 2 -- cgit v1.2.1 From b90addd13f17d967d81dc1d7515887d4fcd6ef59 Mon Sep 17 00:00:00 2001 From: mattip Date: Thu, 2 May 2019 11:29:10 -0400 Subject: BUG: parse more subarrays in descr_to_dtype --- numpy/lib/tests/test_format.py | 44 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) (limited to 'numpy/lib/tests') diff --git a/numpy/lib/tests/test_format.py b/numpy/lib/tests/test_format.py index 9d12fafc0..a3ac89cdd 100644 --- a/numpy/lib/tests/test_format.py +++ b/numpy/lib/tests/test_format.py @@ -629,6 +629,50 @@ def test_pickle_disallow(): assert_raises(ValueError, np.save, path, np.array([None], dtype=object), allow_pickle=False) +@pytest.mark.parametrize('dt', [ + np.dtype(np.dtype([('a', np.int8), + ('b', np.int16), + ('c', np.int32), + ], align=True), + (3,)), + np.dtype([('x', ([('a', '|i1'), + ('', '|V3'), + ('b', '|i1'), + ('', '|V3'), + ], + (3,)), + (4,), + )]), + np.dtype([('x', np.dtype({'names':['a','b'], + 'formats':['i1','i1'], + 'offsets':[0,4], + 'itemsize':8, + }, + (3,)), + (4,), + )]), + np.dtype([('x', + (' Date: Mon, 6 May 2019 08:55:27 -0400 Subject: TEST: tweak two slow tests to speed them up --- numpy/lib/tests/test_histograms.py | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) (limited to 'numpy/lib/tests') diff --git a/numpy/lib/tests/test_histograms.py b/numpy/lib/tests/test_histograms.py index c96b01d42..afaa526af 100644 --- a/numpy/lib/tests/test_histograms.py +++ b/numpy/lib/tests/test_histograms.py @@ -554,15 +554,11 @@ class TestHistogramOptimBinNums(object): return a / (a + b) ll = [[nbins_ratio(seed, size) for size in np.geomspace(start=10, stop=100, num=4).round().astype(int)] - for seed in range(256)] + for seed in range(10)] # the average difference between the two methods decreases as the dataset size increases. - assert_almost_equal(abs(np.mean(ll, axis=0) - 0.5), - [0.1065248, - 0.0968844, - 0.0331818, - 0.0178057], - decimal=3) + avg = abs(np.mean(ll, axis=0) - 0.5) + assert_almost_equal(avg, [0.15, 0.09, 0.08, 0.03], decimal=2) def test_simple_range(self): """ -- cgit v1.2.1 From c2de04da9b0feb2853b9814c7953aa51a29a058e Mon Sep 17 00:00:00 2001 From: mattip Date: Wed, 13 Feb 2019 18:14:05 +0200 Subject: ENH: add 'order' keyword to packbits, unpackbits --- numpy/lib/tests/test_packbits.py | 27 +++++++++++++++++++++------ 1 file changed, 21 insertions(+), 6 deletions(-) (limited to 'numpy/lib/tests') diff --git a/numpy/lib/tests/test_packbits.py b/numpy/lib/tests/test_packbits.py index 00d5ca827..5f650996f 100644 --- a/numpy/lib/tests/test_packbits.py +++ b/numpy/lib/tests/test_packbits.py @@ -2,7 +2,7 @@ from __future__ import division, absolute_import, print_function import numpy as np from numpy.testing import assert_array_equal, assert_equal, assert_raises - +import pytest def test_packbits(): # Copied from the docstring. @@ -50,8 +50,8 @@ def test_packbits_empty_with_axis(): assert_equal(b.dtype, np.uint8) assert_equal(b.shape, out_shape) - -def test_packbits_large(): +@pytest.mark.parametrize('order', ('l', 'b')) +def test_packbits_large(order): # test data large enough for 16 byte vectorization a = np.array([1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, @@ -71,7 +71,7 @@ def test_packbits_large(): a = a.repeat(3) for dtype in '?bBhHiIlLqQ': arr = np.array(a, dtype=dtype) - b = np.packbits(arr, axis=None) + b = np.packbits(arr, axis=None, order=order) assert_equal(b.dtype, np.uint8) r = [252, 127, 192, 3, 254, 7, 252, 0, 7, 31, 240, 0, 28, 1, 255, 252, 113, 248, 3, 255, 192, 28, 15, 192, 28, 126, 0, 224, 127, 255, @@ -81,9 +81,10 @@ def test_packbits_large(): 255, 224, 1, 255, 252, 126, 63, 0, 1, 192, 252, 14, 63, 0, 15, 199, 252, 113, 255, 3, 128, 56, 252, 14, 7, 0, 113, 255, 255, 142, 56, 227, 129, 248, 227, 129, 199, 31, 128] - assert_array_equal(b, r) + if order == 'big': + assert_array_equal(b, r) # equal for size being multiple of 8 - assert_array_equal(np.unpackbits(b)[:-4], a) + assert_array_equal(np.unpackbits(b, order=order)[:-4], a) # check last byte of different remainders (16 byte vectorization) b = [np.packbits(arr[:-i], axis=None)[-1] for i in range(1, 16)] @@ -229,6 +230,20 @@ def test_unpackbits(): [0, 0, 0, 0, 0, 1, 1, 1], [0, 0, 0, 1, 0, 1, 1, 1]])) +def test_pack_unpack_order(): + a = np.array([[2], [7], [23]], dtype=np.uint8) + b = np.unpackbits(a, axis=1) + assert_equal(b.dtype, np.uint8) + b_little = np.unpackbits(a, axis=1, order='little') + b_big = np.unpackbits(a, axis=1, order='big') + assert_array_equal(b, b_big) + assert_array_equal(a, np.packbits(b_little, axis=1, order='little')) + assert_array_equal(b[:,::-1], b_little) + assert_array_equal(a, np.packbits(b_big, axis=1, order='big')) + assert_raises(ValueError, np.unpackbits, a, order='r') + assert_raises(TypeError, np.unpackbits, a, order=10) + + def test_unpackbits_empty(): a = np.empty((0,), dtype=np.uint8) -- cgit v1.2.1 From fa709605401b5acde6fa515239ba29a548c53755 Mon Sep 17 00:00:00 2001 From: mattip Date: Wed, 27 Feb 2019 17:28:35 +0200 Subject: BUG: parametrize tests, fix for interaction of count, order --- numpy/lib/tests/test_packbits.py | 110 ++++++++++++++++++++++++--------------- 1 file changed, 69 insertions(+), 41 deletions(-) (limited to 'numpy/lib/tests') diff --git a/numpy/lib/tests/test_packbits.py b/numpy/lib/tests/test_packbits.py index 5f650996f..d6e96f3ea 100644 --- a/numpy/lib/tests/test_packbits.py +++ b/numpy/lib/tests/test_packbits.py @@ -3,6 +3,7 @@ from __future__ import division, absolute_import, print_function import numpy as np from numpy.testing import assert_array_equal, assert_equal, assert_raises import pytest +from itertools import chain def test_packbits(): # Copied from the docstring. @@ -242,7 +243,7 @@ def test_pack_unpack_order(): assert_array_equal(a, np.packbits(b_big, axis=1, order='big')) assert_raises(ValueError, np.unpackbits, a, order='r') assert_raises(TypeError, np.unpackbits, a, order=10) - + def test_unpackbits_empty(): @@ -283,8 +284,7 @@ def test_unpackbits_large(): assert_array_equal(np.packbits(np.unpackbits(d, axis=0), axis=0), d) -def test_unpackbits_count(): - # test complete invertibility of packbits and unpackbits with count +class TestCount(): x = np.array([ [1, 0, 1, 0, 0, 1, 0], [0, 1, 1, 1, 0, 0, 0], @@ -294,53 +294,81 @@ def test_unpackbits_count(): [0, 0, 1, 1, 1, 0, 0], [0, 1, 0, 1, 0, 1, 0], ], dtype=np.uint8) - padded1 = np.zeros(57, dtype=np.uint8) padded1[:49] = x.ravel() + padded1b = np.zeros(57, dtype=np.uint8) + padded1b[:49] = x[::-1].copy().ravel() + padded2 = np.zeros((9, 9), dtype=np.uint8) + padded2[:7, :7] = x - packed = np.packbits(x) - for count in range(58): - unpacked = np.unpackbits(packed, count=count) + @pytest.mark.parametrize('order', ('l', 'b')) + @pytest.mark.parametrize('count', chain(range(58), range(-1, -57, -1))) + def test_roundtrip(self, order, count): + if count < 0: + # one extra zero of padding + cutoff = count - 1 + else: + cutoff = count + # test complete invertibility of packbits and unpackbits with count + packed = np.packbits(self.x, order=order) + unpacked = np.unpackbits(packed, count=count, order=order) assert_equal(unpacked.dtype, np.uint8) - assert_array_equal(unpacked, padded1[:count]) - for count in range(-1, -57, -1): - unpacked = np.unpackbits(packed, count=count) - assert_equal(unpacked.dtype, np.uint8) - # count -1 because padded1 has 57 instead of 56 elements - assert_array_equal(unpacked, padded1[:count-1]) - for kwargs in [{}, {'count': None}]: + assert_array_equal(unpacked, self.padded1[:cutoff]) + + @pytest.mark.parametrize('kwargs', [ + {}, {'count': None}, + ]) + def test_count(self, kwargs): + packed = np.packbits(self.x) unpacked = np.unpackbits(packed, **kwargs) assert_equal(unpacked.dtype, np.uint8) - assert_array_equal(unpacked, padded1[:-1]) - assert_raises(ValueError, np.unpackbits, packed, count=-57) - - padded2 = np.zeros((9, 9), dtype=np.uint8) - padded2[:7, :7] = x - - packed0 = np.packbits(x, axis=0) - packed1 = np.packbits(x, axis=1) - for count in range(10): - unpacked0 = np.unpackbits(packed0, axis=0, count=count) - assert_equal(unpacked0.dtype, np.uint8) - assert_array_equal(unpacked0, padded2[:count, :x.shape[1]]) - unpacked1 = np.unpackbits(packed1, axis=1, count=count) - assert_equal(unpacked1.dtype, np.uint8) - assert_array_equal(unpacked1, padded2[:x.shape[1], :count]) - for count in range(-1, -9, -1): - unpacked0 = np.unpackbits(packed0, axis=0, count=count) + assert_array_equal(unpacked, self.padded1[:-1]) + + @pytest.mark.parametrize('order', ('l', 'b')) + # delta==-1 when count<0 because one extra zero of padding + @pytest.mark.parametrize('count', chain(range(8), range(-1, -9, -1))) + def test_roundtrip_axis(self, order, count): + if count < 0: + # one extra zero of padding + cutoff = count - 1 + else: + cutoff = count + packed0 = np.packbits(self.x, axis=0, order=order) + unpacked0 = np.unpackbits(packed0, axis=0, count=count, order=order) assert_equal(unpacked0.dtype, np.uint8) - # count -1 because one extra zero of padding - assert_array_equal(unpacked0, padded2[:count-1, :x.shape[1]]) - unpacked1 = np.unpackbits(packed1, axis=1, count=count) + assert_array_equal(unpacked0, self.padded2[:cutoff, :self.x.shape[1]]) + + packed1 = np.packbits(self.x, axis=1, order=order) + unpacked1 = np.unpackbits(packed1, axis=1, count=count, order=order) assert_equal(unpacked1.dtype, np.uint8) - assert_array_equal(unpacked1, padded2[:x.shape[0], :count-1]) - for kwargs in [{}, {'count': None}]: + assert_array_equal(unpacked1, self.padded2[:self.x.shape[0], :cutoff]) + + @pytest.mark.parametrize('kwargs', [ + {}, {'count': None}, + {'order' : 'l'}, {'order': 'l', 'count': None}, + {'order' : 'b'}, {'order': 'b', 'count': None}, + ]) + def test_axis_count(self, kwargs): + packed0 = np.packbits(self.x, axis=0) unpacked0 = np.unpackbits(packed0, axis=0, **kwargs) assert_equal(unpacked0.dtype, np.uint8) - assert_array_equal(unpacked0, padded2[:-1, :x.shape[1]]) + if kwargs.get('order', 'b') == 'b': + assert_array_equal(unpacked0, self.padded2[:-1, :self.x.shape[1]]) + else: + assert_array_equal(unpacked0[::-1, :], self.padded2[:-1, :self.x.shape[1]]) + + packed1 = np.packbits(self.x, axis=1) unpacked1 = np.unpackbits(packed1, axis=1, **kwargs) assert_equal(unpacked1.dtype, np.uint8) - assert_array_equal(unpacked1, padded2[:x.shape[0], :-1]) - assert_raises(ValueError, np.unpackbits, packed0, axis=0, count=-9) - assert_raises(ValueError, np.unpackbits, packed1, axis=1, count=-9) - + if kwargs.get('order', 'b') == 'b': + assert_array_equal(unpacked1, self.padded2[:self.x.shape[0], :-1]) + else: + assert_array_equal(unpacked1[:, ::-1], self.padded2[:self.x.shape[0], :-1]) + + def test_bad_count(self): + packed0 = np.packbits(self.x, axis=0) + assert_raises(ValueError, np.unpackbits, packed0, axis=0, count=-9) + packed1 = np.packbits(self.x, axis=1) + assert_raises(ValueError, np.unpackbits, packed1, axis=1, count=-9) + packed = np.packbits(self.x) + assert_raises(ValueError, np.unpackbits, packed, count=-57) -- cgit v1.2.1 From 599dbade766ad3fecc82afa308803a2e0082c149 Mon Sep 17 00:00:00 2001 From: Eric Wieser Date: Thu, 28 Dec 2017 11:17:52 +0000 Subject: API: Make MaskedArray.mask return a view, rather than the underlying mask This prevents consumers from reshaping the mask in place, which breaks things As a result, `x.mask is x.mask` returns `False`, but this was already true of `x.data is x.data`. May also be related to gh-10270 --- numpy/lib/tests/test_function_base.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'numpy/lib/tests') diff --git a/numpy/lib/tests/test_function_base.py b/numpy/lib/tests/test_function_base.py index 6d32c365a..0702c3856 100644 --- a/numpy/lib/tests/test_function_base.py +++ b/numpy/lib/tests/test_function_base.py @@ -945,7 +945,7 @@ class TestGradient(object): assert_equal(type(out), type(x)) # And make sure that the output and input don't have aliased mask # arrays - assert_(x.mask is not out.mask) + assert_(x._mask is not out._mask) # Also check that edge_order=2 doesn't alter the original mask x2 = np.ma.arange(5) x2[2] = np.ma.masked -- cgit v1.2.1 From b415ffad5327c5ff656b94c6aaf683209c9c8104 Mon Sep 17 00:00:00 2001 From: mattip Date: Wed, 13 Mar 2019 10:05:40 +0200 Subject: ENH: changes from review --- numpy/lib/tests/test_packbits.py | 54 +++++++++++++++++++++------------------- 1 file changed, 29 insertions(+), 25 deletions(-) (limited to 'numpy/lib/tests') diff --git a/numpy/lib/tests/test_packbits.py b/numpy/lib/tests/test_packbits.py index d6e96f3ea..95a465c36 100644 --- a/numpy/lib/tests/test_packbits.py +++ b/numpy/lib/tests/test_packbits.py @@ -51,8 +51,8 @@ def test_packbits_empty_with_axis(): assert_equal(b.dtype, np.uint8) assert_equal(b.shape, out_shape) -@pytest.mark.parametrize('order', ('l', 'b')) -def test_packbits_large(order): +@pytest.mark.parametrize('bitorder', ('little', 'big')) +def test_packbits_large(bitorder): # test data large enough for 16 byte vectorization a = np.array([1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, @@ -72,7 +72,7 @@ def test_packbits_large(order): a = a.repeat(3) for dtype in '?bBhHiIlLqQ': arr = np.array(a, dtype=dtype) - b = np.packbits(arr, axis=None, order=order) + b = np.packbits(arr, axis=None, bitorder=bitorder) assert_equal(b.dtype, np.uint8) r = [252, 127, 192, 3, 254, 7, 252, 0, 7, 31, 240, 0, 28, 1, 255, 252, 113, 248, 3, 255, 192, 28, 15, 192, 28, 126, 0, 224, 127, 255, @@ -82,10 +82,10 @@ def test_packbits_large(order): 255, 224, 1, 255, 252, 126, 63, 0, 1, 192, 252, 14, 63, 0, 15, 199, 252, 113, 255, 3, 128, 56, 252, 14, 7, 0, 113, 255, 255, 142, 56, 227, 129, 248, 227, 129, 199, 31, 128] - if order == 'big': + if bitorder == 'big': assert_array_equal(b, r) # equal for size being multiple of 8 - assert_array_equal(np.unpackbits(b, order=order)[:-4], a) + assert_array_equal(np.unpackbits(b, bitorder=bitorder)[:-4], a) # check last byte of different remainders (16 byte vectorization) b = [np.packbits(arr[:-i], axis=None)[-1] for i in range(1, 16)] @@ -235,14 +235,14 @@ def test_pack_unpack_order(): a = np.array([[2], [7], [23]], dtype=np.uint8) b = np.unpackbits(a, axis=1) assert_equal(b.dtype, np.uint8) - b_little = np.unpackbits(a, axis=1, order='little') - b_big = np.unpackbits(a, axis=1, order='big') + b_little = np.unpackbits(a, axis=1, bitorder='little') + b_big = np.unpackbits(a, axis=1, bitorder='big') assert_array_equal(b, b_big) - assert_array_equal(a, np.packbits(b_little, axis=1, order='little')) + assert_array_equal(a, np.packbits(b_little, axis=1, bitorder='little')) assert_array_equal(b[:,::-1], b_little) - assert_array_equal(a, np.packbits(b_big, axis=1, order='big')) - assert_raises(ValueError, np.unpackbits, a, order='r') - assert_raises(TypeError, np.unpackbits, a, order=10) + assert_array_equal(a, np.packbits(b_big, axis=1, bitorder='big')) + assert_raises(ValueError, np.unpackbits, a, bitorder='r') + assert_raises(TypeError, np.unpackbits, a, bitorder=10) @@ -301,17 +301,17 @@ class TestCount(): padded2 = np.zeros((9, 9), dtype=np.uint8) padded2[:7, :7] = x - @pytest.mark.parametrize('order', ('l', 'b')) + @pytest.mark.parametrize('bitorder', ('little', 'big')) @pytest.mark.parametrize('count', chain(range(58), range(-1, -57, -1))) - def test_roundtrip(self, order, count): + def test_roundtrip(self, bitorder, count): if count < 0: # one extra zero of padding cutoff = count - 1 else: cutoff = count # test complete invertibility of packbits and unpackbits with count - packed = np.packbits(self.x, order=order) - unpacked = np.unpackbits(packed, count=count, order=order) + packed = np.packbits(self.x, bitorder=bitorder) + unpacked = np.unpackbits(packed, count=count, bitorder=bitorder) assert_equal(unpacked.dtype, np.uint8) assert_array_equal(unpacked, self.padded1[:cutoff]) @@ -324,35 +324,39 @@ class TestCount(): assert_equal(unpacked.dtype, np.uint8) assert_array_equal(unpacked, self.padded1[:-1]) - @pytest.mark.parametrize('order', ('l', 'b')) + @pytest.mark.parametrize('bitorder', ('little', 'big')) # delta==-1 when count<0 because one extra zero of padding @pytest.mark.parametrize('count', chain(range(8), range(-1, -9, -1))) - def test_roundtrip_axis(self, order, count): + def test_roundtrip_axis(self, bitorder, count): if count < 0: # one extra zero of padding cutoff = count - 1 else: cutoff = count - packed0 = np.packbits(self.x, axis=0, order=order) - unpacked0 = np.unpackbits(packed0, axis=0, count=count, order=order) + packed0 = np.packbits(self.x, axis=0, bitorder=bitorder) + unpacked0 = np.unpackbits(packed0, axis=0, count=count, + bitorder=bitorder) assert_equal(unpacked0.dtype, np.uint8) assert_array_equal(unpacked0, self.padded2[:cutoff, :self.x.shape[1]]) - packed1 = np.packbits(self.x, axis=1, order=order) - unpacked1 = np.unpackbits(packed1, axis=1, count=count, order=order) + packed1 = np.packbits(self.x, axis=1, bitorder=bitorder) + unpacked1 = np.unpackbits(packed1, axis=1, count=count, + bitorder=bitorder) assert_equal(unpacked1.dtype, np.uint8) assert_array_equal(unpacked1, self.padded2[:self.x.shape[0], :cutoff]) @pytest.mark.parametrize('kwargs', [ {}, {'count': None}, - {'order' : 'l'}, {'order': 'l', 'count': None}, - {'order' : 'b'}, {'order': 'b', 'count': None}, + {'bitorder' : 'little'}, + {'bitorder': 'little', 'count': None}, + {'bitorder' : 'big'}, + {'bitorder': 'big', 'count': None}, ]) def test_axis_count(self, kwargs): packed0 = np.packbits(self.x, axis=0) unpacked0 = np.unpackbits(packed0, axis=0, **kwargs) assert_equal(unpacked0.dtype, np.uint8) - if kwargs.get('order', 'b') == 'b': + if kwargs.get('bitorder', 'big') == 'big': assert_array_equal(unpacked0, self.padded2[:-1, :self.x.shape[1]]) else: assert_array_equal(unpacked0[::-1, :], self.padded2[:-1, :self.x.shape[1]]) @@ -360,7 +364,7 @@ class TestCount(): packed1 = np.packbits(self.x, axis=1) unpacked1 = np.unpackbits(packed1, axis=1, **kwargs) assert_equal(unpacked1.dtype, np.uint8) - if kwargs.get('order', 'b') == 'b': + if kwargs.get('bitorder', 'big') == 'big': assert_array_equal(unpacked1, self.padded2[:self.x.shape[0], :-1]) else: assert_array_equal(unpacked1[:, ::-1], self.padded2[:self.x.shape[0], :-1]) -- cgit v1.2.1 From bd73a15363295658e150754edf6d1073cbdb3975 Mon Sep 17 00:00:00 2001 From: mattip Date: Sun, 5 May 2019 19:50:06 -0400 Subject: MAINT: remove uneeded code --- numpy/lib/tests/test_format.py | 29 ++++++++++++++++++++--------- 1 file changed, 20 insertions(+), 9 deletions(-) (limited to 'numpy/lib/tests') diff --git a/numpy/lib/tests/test_format.py b/numpy/lib/tests/test_format.py index a3ac89cdd..4a3fbdf57 100644 --- a/numpy/lib/tests/test_format.py +++ b/numpy/lib/tests/test_format.py @@ -635,14 +635,6 @@ def test_pickle_disallow(): ('c', np.int32), ], align=True), (3,)), - np.dtype([('x', ([('a', '|i1'), - ('', '|V3'), - ('b', '|i1'), - ('', '|V3'), - ], - (3,)), - (4,), - )]), np.dtype([('x', np.dtype({'names':['a','b'], 'formats':['i1','i1'], 'offsets':[0,4], @@ -665,8 +657,27 @@ def test_pickle_disallow(): )), (4,) ))) - ]) + ]), + np.dtype([ + ('a', np.dtype(( + np.dtype(( + np.dtype(( + np.dtype([ + ('a', int), + ('b', np.dtype({'names':['a','b'], + 'formats':['i1','i1'], + 'offsets':[0,4], + 'itemsize':8})), + ]), + (3,), + )), + (4,), + )), + (5,), + ))) + ]), ]) + def test_descr_to_dtype(dt): dt1 = format.descr_to_dtype(dt.descr) assert_equal_(dt1, dt) -- cgit v1.2.1