mirror of https://github.com/exaloop/codon.git
817 lines
36 KiB
Python
817 lines
36 KiB
Python
import numpy as np
|
|
|
|
@test
|
|
def test_average(a,
|
|
expected,
|
|
axis=None,
|
|
weights=None,
|
|
returned: Static[int] = False,
|
|
keepdims: Static[int] = False):
|
|
if isinstance(expected, int) or isinstance(expected, float):
|
|
assert np.average(a,
|
|
axis=axis,
|
|
weights=weights,
|
|
returned=returned,
|
|
keepdims=keepdims) == expected
|
|
else:
|
|
assert (np.average(a,
|
|
axis=axis,
|
|
weights=weights,
|
|
returned=returned,
|
|
keepdims=keepdims) == expected).all()
|
|
|
|
test_average([5], 5)
|
|
test_average([2, 2, 2, 2, 2], 2)
|
|
test_average(np.arange(-5, 0), -3)
|
|
test_average(np.arange(1, 5), 2.5)
|
|
test_average([-1, 2, -3, 4, -5], -0.6)
|
|
test_average(np.arange(1, 11), 4.0, weights=np.arange(10, 0, -1))
|
|
test_average(np.arange(6).reshape((3, 2)),
|
|
np.array([0.75, 2.75, 4.75]),
|
|
axis=1,
|
|
weights=[1. / 4, 3. / 4])
|
|
test_average(np.arange(6).reshape((3, 2)),
|
|
np.array([[0.5], [2.5], [4.5]]),
|
|
axis=1,
|
|
keepdims=True)
|
|
w1 = [0, 1, 1, 1, 1, 0]
|
|
w2 = [[0, 1, 1, 1, 1, 0], [1, 0, 0, 0, 0, 1]]
|
|
y = np.array([[0., 1., 2., 3., 4., 5.], [0., 2., 4., 6., 8., 10.]])
|
|
test_average(np.arange(6), 2.5, axis=0, weights=w1)
|
|
test_average(y, np.array([0., 1.5, 3., 4.5, 6., 7.5]), axis=0)
|
|
test_average(y, np.array([2.5, 5.]), axis=1)
|
|
test_average(y, 3.3333333333333335, weights=w2)
|
|
test_average(y, [0., 1., 2., 3., 4., 10.], axis=0, weights=w2)
|
|
y = np.arange(12).reshape(2, 2, 3)
|
|
w = np.array([0., 0., 1., .5, .5, 0., 0., .5, .5, 1., 0., 0.]).reshape(2, 2, 3)
|
|
test_average(y, np.array([7., 5.5, 4.]), axis=(0, 1), weights=w)
|
|
|
|
def test_average2():
|
|
assert np.isnan(np.average(np.empty(0, float)))
|
|
assert np.isnan(np.average([1, 2, np.nan, 4, 5]))
|
|
assert np.isinf(np.average([1, 2, np.inf, 4, 5]))
|
|
assert np.isnan(np.average([1, 2, np.nan, np.inf, 4, 5]))
|
|
assert np.average(np.arange(1, 11),
|
|
weights=np.arange(10, 0, -1),
|
|
returned=True) == (4.0, 55.0)
|
|
assert (np.average(np.array([[1, 2, 3], [4, 5, 6]]), axis=1,
|
|
returned=True)[0] == np.array([2., 5.])).all()
|
|
assert (np.average(np.array([[1, 2, 3], [4, 5, 6]]), axis=1,
|
|
returned=True)[1] == np.array([3., 3.])).all()
|
|
a = np.arange(6)
|
|
b = np.arange(6) * 3
|
|
assert (np.average([[a, b], [b, a]], axis=1, returned=True)[0] == np.array(
|
|
[[0., 2., 4., 6., 8., 10.], [0., 2., 4., 6., 8., 10.]])).all()
|
|
assert (np.average([[a, b], [b, a]], axis=1,
|
|
returned=True)[1] == np.array([[2., 2., 2., 2., 2., 2.],
|
|
[2., 2., 2., 2., 2.,
|
|
2.]])).all()
|
|
assert (np.average([[a, b], [b, a]], axis=1, keepdims=True,
|
|
returned=True)[0] == np.array(
|
|
[[[0., 2., 4., 6., 8., 10.]],
|
|
[[0., 2., 4., 6., 8., 10.]]])).all()
|
|
x = np.arange(6).reshape(2, 3)
|
|
w2 = [[0, 0, 1], [1, 2, 3]]
|
|
assert (np.round(
|
|
np.average(x, axis=1, keepdims=True, returned=True, weights=w2)[0],
|
|
8) == np.round(np.array([[2.], [4.33333333]]), 8)).all()
|
|
assert (np.average(x, axis=1, keepdims=True, returned=True,
|
|
weights=w2)[1] == np.array([[1.], [6.]])).all()
|
|
|
|
test_average2()
|
|
|
|
@test
|
|
def test_cov(m,
|
|
expected,
|
|
y=None,
|
|
rowvar=True,
|
|
bias=False,
|
|
ddof: Optional[int] = None,
|
|
fweights=None,
|
|
aweights=None,
|
|
dtype: type = NoneType):
|
|
assert np.isnan(np.cov(np.empty(0, float)))
|
|
assert np.isnan(np.cov(np.array([2])))
|
|
assert np.asarray(
|
|
np.round(
|
|
np.cov(m,
|
|
y=y,
|
|
rowvar=rowvar,
|
|
bias=bias,
|
|
ddof=ddof,
|
|
fweights=fweights,
|
|
aweights=aweights,
|
|
dtype=dtype), 8) == expected).all()
|
|
|
|
test_cov(
|
|
np.array([[0, 2], [1, 1], [2, 0]]).T, np.array([[1., -1.], [-1., 1.]]))
|
|
test_cov(np.array([1, 2, 3, 4, 5]), np.array(2.5))
|
|
test_cov(np.array([1, 2, 3, 4, 5]), np.array(2.5), rowvar=False)
|
|
test_cov(np.array([1, 2, 3, 4, 5]), np.array(10.), ddof=4)
|
|
test_cov(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
|
|
np.array([[1., 1., 1.], [1., 1., 1.], [1., 1., 1.]]))
|
|
test_cov(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
|
|
np.array([[9., 9., 9.], [9., 9., 9.], [9., 9., 9.]]),
|
|
rowvar=False)
|
|
test_cov(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
|
|
np.array([[0.66666667, 0.66666667, 0.66666667],
|
|
[0.66666667, 0.66666667, 0.66666667],
|
|
[0.66666667, 0.66666667, 0.66666667]]),
|
|
rowvar=True,
|
|
bias=True)
|
|
test_cov(np.array([1, 2, 3, 4, 5]), np.array(2.), bias=True)
|
|
test_cov(np.array([1, 2, 3]),
|
|
np.array([[1., 0.5], [0.5, 0.25]]),
|
|
y=np.array([0.5, 1.0, 1.5]))
|
|
test_cov(np.array([1, 2, 3]),
|
|
np.array(0.98095238),
|
|
fweights=np.array([6, 1, 8]))
|
|
test_cov(np.array([1, 2, 3]),
|
|
np.array(1.66129032),
|
|
aweights=np.array([6, 1, 8]))
|
|
test_cov(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
|
|
np.array([[0.475, 0.475, 0.475], [0.475, 0.475, 0.475],
|
|
[0.475, 0.475, 0.475]]),
|
|
fweights=np.array([1, 2, 3]),
|
|
aweights=np.array([0.5, 1.0, 1.5]))
|
|
test_cov(np.array([1, 2, 3, 4, 5]),
|
|
np.array(1.74193548 + 0.j),
|
|
aweights=np.array([0.1, 0.2, 0.3, 0.2, 0.1]),
|
|
dtype=complex)
|
|
test_cov(np.array([[1 + 0j, 2 + 0j, 3 + 0j], [1j, 2j, 3j]]),
|
|
np.array([[1. + 0.j, 0. - 1.j], [0. + 1.j, 1. + 0.j]]))
|
|
test_cov(np.array([[1, 2, 3]]),
|
|
np.array([[1. + 0j, -1.j], [1.j, 1. + 0j]]),
|
|
y=np.array([[1j, 2j, 3j]]))
|
|
test_cov(np.array([0.3942, 0.5969, 0.7730, 0.9918, 0.7964]),
|
|
np.array(0.05084135))
|
|
|
|
@test
|
|
def test_corrcoef(x, expected, y=None, rowvar=True, dtype: type = NoneType):
|
|
assert np.isnan(np.corrcoef(np.empty(0, float)))
|
|
assert np.isnan(np.corrcoef(np.array([2])))
|
|
if isinstance(expected, int) or isinstance(expected, float):
|
|
assert np.corrcoef(x, y=y, rowvar=rowvar, dtype=dtype) == expected
|
|
else:
|
|
assert (np.round(np.corrcoef(x, y=y, rowvar=rowvar, dtype=dtype),
|
|
6) == np.round(expected, 6)).all()
|
|
|
|
test_corrcoef(
|
|
np.array([[0.77395605, 0.43887844, 0.85859792],
|
|
[0.69736803, 0.09417735, 0.97562235],
|
|
[0.7611397, 0.78606431, 0.12811363]]),
|
|
np.array([[1., 0.99256089, -0.68080986], [0.99256089, 1., -0.76492172],
|
|
[-0.68080986, -0.76492172, 1.]]))
|
|
test_corrcoef(
|
|
np.array([[0.77395605, 0.43887844, 0.85859792],
|
|
[0.69736803, 0.09417735, 0.97562235],
|
|
[0.7611397, 0.78606431, 0.12811363]]),
|
|
np.array(
|
|
[[1., 0.99256089, -0.68080986, 0.75008178, -0.934284, -0.99004057],
|
|
[0.99256089, 1., -0.76492172, 0.82502011, -0.97074098, -0.99981569],
|
|
[-0.68080986, -0.76492172, 1., -0.99507202, 0.89721355, 0.77714685],
|
|
[0.75008178, 0.82502011, -0.99507202, 1., -0.93657855, -0.83571711],
|
|
[-0.934284, -0.97074098, 0.89721355, -0.93657855, 1., 0.97517215],
|
|
[-0.99004057, -0.99981569, 0.77714685, -0.83571711, 0.97517215, 1.]]),
|
|
y=np.array([[0.45038594, 0.37079802, 0.92676499],
|
|
[0.64386512, 0.82276161, 0.4434142],
|
|
[0.22723872, 0.55458479, 0.06381726]]))
|
|
test_corrcoef(
|
|
np.array([[0.77395605, 0.43887844, 0.85859792],
|
|
[0.69736803, 0.09417735, 0.97562235],
|
|
[0.7611397, 0.78606431, 0.12811363]]),
|
|
np.array(
|
|
[[1., 0.77598074, -0.47458546, -0.75078643, -0.9665554, 0.22423734],
|
|
[0.77598074, 1., -0.92346708, -0.99923895, -0.58826587, -0.44069024],
|
|
[-0.47458546, -0.92346708, 1., 0.93773029, 0.23297648, 0.75137473],
|
|
[-0.75078643, -0.99923895, 0.93773029, 1., 0.55627469, 0.47536961],
|
|
[-0.9665554, -0.58826587, 0.23297648, 0.55627469, 1., -0.46666491],
|
|
[0.22423734, -0.44069024, 0.75137473, 0.47536961, -0.46666491, 1.]]),
|
|
y=np.array([[0.45038594, 0.37079802, 0.92676499],
|
|
[0.64386512, 0.82276161, 0.4434142],
|
|
[0.22723872, 0.55458479, 0.06381726]]),
|
|
rowvar=False)
|
|
test_corrcoef(np.array([[1 + 0j, 2 + 0j, 3 + 0j], [1j, 2j, 3j]]),
|
|
np.array([[1. + 0.j, 0. - 1.j], [0. + 1.j, 1. + 0.j]]))
|
|
test_corrcoef(np.array([[1, 2, 3]]),
|
|
np.array([[1. + 0j, -1.j], [1.j, 1. + 0j]]),
|
|
y=np.array([[1j, 2j, 3j]]))
|
|
test_corrcoef([[1e-100, 1e100], [1e100, 1e-100]],
|
|
np.array([[1., -1.], [-1., 1.]]))
|
|
|
|
@test
|
|
def test_correlate(a, b, expected, mode: Static[str] = 'valid'):
|
|
assert (np.round(np.correlate(a, b, mode=mode),
|
|
8) == np.round(expected, 8)).all()
|
|
|
|
test_correlate([1, 2, 3], [0., 1., 0.5], np.array(3.5))
|
|
test_correlate([0 + 0j, 4.5 + 2.1 - 9j, 1 + 0j, 0 + 0.5j],
|
|
[1 + 1j, 2 + 0j, 3 - 1j], np.array([16.2 - 17.j, -0.9 - 14.1j]))
|
|
test_correlate([0.8, 4.6, 3.4], [19j, -8 + 5j, 2 + 5j, 13 - 1j, 9 - 10j],
|
|
np.array([92. + 34.6j, 47. - 23.6j, -30. - 55.2j]))
|
|
test_correlate([1, 2, 3], [0., 1., 0.5], np.array([2., 3.5, 3.]), mode="same")
|
|
test_correlate([0 + 0j, 4.5 + 2.1 - 9j, 1 + 0j, 0 + 0.5j],
|
|
[1 + 1j, 2 + 0j, 3 - 1j],
|
|
np.array([28.8 - 20.4j, 16.2 - 17.j, -0.9 - 14.1j, 1. + 0.j]),
|
|
mode='same')
|
|
test_correlate([0.8, 4.6, 3.4], [19j, -8 + 5j, 2 + 5j, 13 - 1j, 9 - 10j],
|
|
np.array([
|
|
51.8 + 46.8j, 92. + 34.6j, 47. - 23.6j, -30. - 55.2j,
|
|
-27.2 - 104.4j
|
|
]),
|
|
mode='same')
|
|
test_correlate([1, 2, 3], [0., 1., 0.5],
|
|
np.array([0.5, 2., 3.5, 3., 0.]),
|
|
mode="full")
|
|
test_correlate([0 + 0j, 4.5 + 2.1 - 9j, 1 + 0j, 0 + 0.5j],
|
|
[1 + 1j, 2 + 0j, 3 - 1j],
|
|
np.array([
|
|
0. + 0.j, 28.8 - 20.4j, 16.2 - 17.j, -0.9 - 14.1j, 1. + 0.j,
|
|
0.5 + 0.5j
|
|
]),
|
|
mode='full')
|
|
test_correlate([0.8, 4.6, 3.4], [19j, -8 + 5j, 2 + 5j, 13 - 1j, 9 - 10j],
|
|
np.array([
|
|
7.2 + 8.j, 51.8 + 46.8j, 92. + 34.6j, 47. - 23.6j,
|
|
-30. - 55.2j, -27.2 - 104.4j, 0. - 64.6j
|
|
]),
|
|
mode='full')
|
|
test_correlate([1 + 1j, 2 + 0j, 3 - 1j], [0 + 0j, 1 + 0j, 0 + 0.5j],
|
|
np.array(
|
|
[0.5 - 0.5j, 1.0 + 0.j, 1.5 - 1.5j, 3.0 - 1.j, 0.0 + 0.j]),
|
|
mode='full')
|
|
test_correlate([0 + 0j, 1 + 0j, 0 + 0.5j], [1 + 1j, 2 + 0j, 3 - 1j],
|
|
np.array([0.j, 3. + 1.j, 1.5 + 1.5j, 1. + 0.j, 0.5 + 0.5j]),
|
|
mode='full')
|
|
test_correlate(np.array([1 + 0j, 2 + 0j, 3 + 0j, 4 + 1j]),
|
|
np.array([-1 + 0j, -2j, 3 + 1j]),
|
|
np.array([8. + 1.j, 11. + 5.j]))
|
|
|
|
@test
|
|
def test_bincount(x, expected, weights=None, minlength=0):
|
|
assert (np.bincount(x, weights=weights,
|
|
minlength=minlength) == expected).all()
|
|
|
|
test_bincount([1], np.array([0, 1]))
|
|
test_bincount(np.array([0, 1, 2, 3, 4]), np.array([1, 1, 1, 1, 1]))
|
|
test_bincount(
|
|
np.array([0, 1, 1, 3, 2, 1, 7, 23]),
|
|
np.array([
|
|
1, 3, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1
|
|
]))
|
|
test_bincount(np.array([0, 1, 1, 2, 2, 2]),
|
|
np.array([0.3, 0.7, 1.1]),
|
|
weights=np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]))
|
|
test_bincount(np.array([0, 1, 1, 3, 2, 1, 7]),
|
|
np.array([1, 3, 1, 1, 0, 0, 0, 1]),
|
|
minlength=2)
|
|
test_bincount(np.array([0, 1, 1, 3, 2, 1, 7]),
|
|
np.array([
|
|
1, 3, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0
|
|
]),
|
|
minlength=22)
|
|
test_bincount(np.array([1, 2, 4, 5, 2]), np.array([0, 0.2, 0.5, 0, 0.5, 0.1]),
|
|
np.array([0.2, 0.3, 0.5, 0.1, 0.2]))
|
|
test_bincount(np.array([0, 1, 1, 2, 2, 3, 3]),
|
|
np.array([1, 2, 2, 2]),
|
|
minlength=2)
|
|
test_bincount(np.array([0, 1, 1, 2, 2, 3, 3]),
|
|
np.array([1, 2, 2, 2]),
|
|
minlength=0)
|
|
test_bincount(np.array([1, 2, 4, 5, 2]),
|
|
np.array([0, 0.2, 0.5, 0, 0.5, 0.1, 0, 0]),
|
|
np.array([0.2, 0.3, 0.5, 0.1, 0.2]), 8)
|
|
test_bincount(np.empty(0, int), np.empty(0, int))
|
|
|
|
@test
|
|
def test_digitize(x, bins, expected, right=False):
|
|
assert (np.digitize(x, bins, right=right) == expected).all()
|
|
|
|
test_digitize(np.array([[0, 1, 1], [3, 2, 7]]), np.array([0, 1, 2, 4, 8]),
|
|
np.array([[1, 2, 2], [3, 3, 4]]))
|
|
test_digitize(np.array([0.2, 6.4, 3.0, 1.6]),
|
|
np.array([0.0, 1.0, 2.5, 4.0, 10.0]), np.array([1, 4, 3, 2]))
|
|
test_digitize(np.array([1.2, 10.0, 12.4, 15.5, 20.]),
|
|
np.array([0, 5, 10, 15, 20]),
|
|
np.array([1, 2, 3, 4, 4]),
|
|
right=True)
|
|
test_digitize(np.array([1.2, 10.0, 12.4, 15.5, 20.]),
|
|
np.array([0, 5, 10, 15, 20]), np.array([1, 3, 3, 4, 5]))
|
|
test_digitize(np.array([[0, 1, 1], [3, 2, 7]]),
|
|
np.array([0.0, 1.0, 2.5, 4.0, 10.0]),
|
|
np.array([[0, 1, 1], [3, 2, 4]]),
|
|
right=True)
|
|
test_digitize(np.arange(-6, 5), np.arange(-5, 5), np.arange(11))
|
|
test_digitize(np.arange(5, -6, -1), np.arange(5, -5, -1), np.arange(11))
|
|
test_digitize(np.arange(-6, 5), np.arange(-6, 4), np.arange(11), True)
|
|
x = [-1, 0, 1, 2]
|
|
bins = [0, 0, 1]
|
|
test_digitize(x, bins, np.array([0, 2, 3, 3]), False)
|
|
test_digitize(x, bins, np.array([0, 0, 2, 3]), True)
|
|
bins = [1, 1, 0]
|
|
test_digitize(x, bins, np.array([3, 2, 0, 0]), False)
|
|
test_digitize(x, bins, np.array([3, 3, 2, 0]), True)
|
|
bins = [1, 1, 1, 1]
|
|
test_digitize(x, bins, np.array([0, 0, 4, 4]), False)
|
|
test_digitize(x, bins, np.array([0, 0, 0, 4]), True)
|
|
|
|
@test
|
|
def test_histogram_bin_edges(a, expected, bins=10, range=None, weights=None):
|
|
assert (np.round(
|
|
np.histogram_bin_edges(a, bins=bins, range=range, weights=weights),
|
|
8) == np.round(expected, 8)).all()
|
|
|
|
test_histogram_bin_edges(
|
|
np.empty(0, float),
|
|
np.array([0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.]))
|
|
test_histogram_bin_edges(
|
|
[1], np.array([0.5, 0.6, 0.7, 0.8, 0.9, 1., 1.1, 1.2, 1.3, 1.4, 1.5]))
|
|
test_histogram_bin_edges(
|
|
[1, 100],
|
|
np.array([1., 10.9, 20.8, 30.7, 40.6, 50.5, 60.4, 70.3, 80.2, 90.1, 100.]))
|
|
test_histogram_bin_edges(
|
|
np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]),
|
|
np.array([0., 0.5, 1., 1.5, 2., 2.5, 3., 3.5, 4., 4.5, 5.]))
|
|
test_histogram_bin_edges(np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]),
|
|
np.array([
|
|
0., 0.38461538, 0.76923077, 1.15384615,
|
|
1.53846154, 1.92307692, 2.30769231, 2.69230769,
|
|
3.07692308, 3.46153846, 3.84615385, 4.23076923,
|
|
4.61538462, 5.
|
|
]),
|
|
bins=13)
|
|
test_histogram_bin_edges(np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]),
|
|
np.array([-1., -0.33333333, 0.33333333, 1.]),
|
|
bins=3,
|
|
range=(-1, 1))
|
|
test_histogram_bin_edges(np.array([0, 0, 1, 2, 3, 5]),
|
|
np.array([-5., 0., 5., 10.]),
|
|
bins=3,
|
|
range=(-5, 10),
|
|
weights=[8, 3, 1, 5, -9, 2])
|
|
|
|
test_histogram_bin_edges(np.empty(0, float), np.array([0., 1.]), bins='doane')
|
|
test_histogram_bin_edges([1], np.array([0.5, 1.5]), bins='doane')
|
|
test_histogram_bin_edges([1, 100], np.array([1., 100.]), bins='doane')
|
|
test_histogram_bin_edges(np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]),
|
|
np.array([0., 1., 2., 3., 4., 5.]),
|
|
bins='doane')
|
|
test_histogram_bin_edges(
|
|
np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]),
|
|
np.array([-1., -0.8, -0.6, -0.4, -0.2, 0., 0.2, 0.4, 0.6, 0.8, 1.]),
|
|
bins='doane',
|
|
range=(-1, 1))
|
|
|
|
test_histogram_bin_edges(np.empty(0, float), np.array([0., 1.]), bins='rice')
|
|
test_histogram_bin_edges([1], np.array([0.5, 1.5]), bins='rice')
|
|
test_histogram_bin_edges([1, 100], np.array([1., 34., 67., 100.]), bins='rice')
|
|
test_histogram_bin_edges(np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]),
|
|
np.array([0., 1., 2., 3., 4., 5.]),
|
|
bins='rice')
|
|
test_histogram_bin_edges(np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]),
|
|
np.array([
|
|
-1., -0.71428571, -0.42857143, -0.14285714,
|
|
0.14285714, 0.42857143, 0.71428571, 1.
|
|
]),
|
|
bins='rice',
|
|
range=(-1, 1))
|
|
|
|
test_histogram_bin_edges(np.empty(0, float), np.array([0., 1.]), bins='scott')
|
|
test_histogram_bin_edges([7], np.array([6.5, 7.5]), bins='scott')
|
|
test_histogram_bin_edges([1, 100], np.array([1., 100.]), bins='scott')
|
|
test_histogram_bin_edges(np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]),
|
|
np.array([0., 2.5, 5.]),
|
|
bins='scott')
|
|
test_histogram_bin_edges(np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]),
|
|
np.array([-1., -0.33333333, 0.33333333, 1.]),
|
|
bins='scott',
|
|
range=(-1, 1))
|
|
|
|
test_histogram_bin_edges(np.empty(0, float), np.array([0., 1.]), bins='sqrt')
|
|
test_histogram_bin_edges([3], np.array([2.5, 3.5]), bins='sqrt')
|
|
test_histogram_bin_edges([1, 100], np.array([1., 50.5, 100.]), bins='sqrt')
|
|
test_histogram_bin_edges(np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]),
|
|
np.array([0., 1.66666667, 3.33333333, 5.]),
|
|
bins='sqrt')
|
|
test_histogram_bin_edges(np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]),
|
|
np.array([-1., -0.5, 0., 0.5, 1.]),
|
|
bins='sqrt',
|
|
range=(-1, 1))
|
|
|
|
test_histogram_bin_edges(np.empty(0, float),
|
|
np.array([0., 1.]),
|
|
bins='sturges')
|
|
test_histogram_bin_edges([3], np.array([2.5, 3.5]), bins='sturges')
|
|
test_histogram_bin_edges([1, 100], np.array([1., 50.5, 100.]), bins='sturges')
|
|
test_histogram_bin_edges(np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]),
|
|
np.array([0., 1., 2., 3., 4., 5.]),
|
|
bins='sturges')
|
|
test_histogram_bin_edges(
|
|
np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]),
|
|
np.array([-1., -0.66666667, -0.33333333, 0., 0.33333333, 0.66666667, 1.]),
|
|
bins='sturges',
|
|
range=(-1, 1))
|
|
|
|
test_histogram_bin_edges(np.empty(0, float), np.array([0., 1.]), bins='fd')
|
|
test_histogram_bin_edges([3], np.array([2.5, 3.5]), bins='fd')
|
|
test_histogram_bin_edges([1, 100], np.array([1., 50.5, 100.]), bins='fd')
|
|
test_histogram_bin_edges(np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]),
|
|
np.array([0., 2.5, 5.]),
|
|
bins='fd')
|
|
test_histogram_bin_edges(
|
|
np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]),
|
|
np.array([
|
|
-12., -9.17857143, -6.35714286, -3.53571429, -0.71428571, 2.10714286,
|
|
4.92857143, 7.75, 10.57142857, 13.39285714, 16.21428571, 19.03571429,
|
|
21.85714286, 24.67857143, 27.5, 30.32142857, 33.14285714, 35.96428571,
|
|
38.78571429, 41.60714286, 44.42857143, 47.25, 50.07142857, 52.89285714,
|
|
55.71428571, 58.53571429, 61.35714286, 64.17857143, 67.
|
|
]),
|
|
bins='fd',
|
|
range=(-12, 67))
|
|
|
|
test_histogram_bin_edges(np.empty(0, float), np.array([0., 1.]), bins='auto')
|
|
test_histogram_bin_edges([3], np.array([2.5, 3.5]), bins='auto')
|
|
test_histogram_bin_edges([1, 100], np.array([1., 50.5, 100.]), bins='auto')
|
|
test_histogram_bin_edges(np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]),
|
|
np.array([0., 1., 2., 3., 4., 5.]),
|
|
bins='auto')
|
|
test_histogram_bin_edges(
|
|
np.array([0, 0, 2, 3, 3, 4]),
|
|
np.array([
|
|
-43., -41.88888889, -40.77777778, -39.66666667, -38.55555556,
|
|
-37.44444444, -36.33333333, -35.22222222, -34.11111111, -33.,
|
|
-31.88888889, -30.77777778, -29.66666667, -28.55555556, -27.44444444,
|
|
-26.33333333, -25.22222222, -24.11111111, -23., -21.88888889,
|
|
-20.77777778, -19.66666667, -18.55555556, -17.44444444, -16.33333333,
|
|
-15.22222222, -14.11111111, -13., -11.88888889, -10.77777778,
|
|
-9.66666667, -8.55555556, -7.44444444, -6.33333333, -5.22222222,
|
|
-4.11111111, -3., -1.88888889, -0.77777778, 0.33333333, 1.44444444,
|
|
2.55555556, 3.66666667, 4.77777778, 5.88888889, 7., 8.11111111,
|
|
9.22222222, 10.33333333, 11.44444444, 12.55555556, 13.66666667,
|
|
14.77777778, 15.88888889, 17.
|
|
]),
|
|
bins='auto',
|
|
range=(-43, 17))
|
|
|
|
test_histogram_bin_edges(np.empty(0, float), np.array([0., 1.]), bins='stone')
|
|
test_histogram_bin_edges([3], np.array([2.5, 3.5]), bins='stone')
|
|
test_histogram_bin_edges([1, 100], np.array([1., 100.]), bins='stone')
|
|
test_histogram_bin_edges(np.array([0, 0, 1, 2, 3, 3, 4, 5]),
|
|
np.array([0., 5.]),
|
|
bins='stone')
|
|
test_histogram_bin_edges(
|
|
np.array([0, 0, 2, 3, 3, 4]),
|
|
np.array([
|
|
-4., -3.43243243, -2.86486486, -2.2972973, -1.72972973, -1.16216216,
|
|
-0.59459459, -0.02702703, 0.54054054, 1.10810811, 1.67567568,
|
|
2.24324324, 2.81081081, 3.37837838, 3.94594595, 4.51351351, 5.08108108,
|
|
5.64864865, 6.21621622, 6.78378378, 7.35135135, 7.91891892, 8.48648649,
|
|
9.05405405, 9.62162162, 10.18918919, 10.75675676, 11.32432432,
|
|
11.89189189, 12.45945946, 13.02702703, 13.59459459, 14.16216216,
|
|
14.72972973, 15.2972973, 15.86486486, 16.43243243, 17.
|
|
]),
|
|
bins='stone',
|
|
range=(-4, 17))
|
|
|
|
@test
|
|
def test_histogram(a,
|
|
expected_hist,
|
|
expected_edges,
|
|
bins=10,
|
|
range=None,
|
|
density: Static[int] = False,
|
|
weights=None):
|
|
hist, bin_edges = np.histogram(a,
|
|
bins=bins,
|
|
range=range,
|
|
density=density,
|
|
weights=weights)
|
|
assert (np.round(hist, 8) == np.round(expected_hist, 8)).all()
|
|
assert (np.round(bin_edges, 8) == np.round(expected_edges, 8)).all()
|
|
|
|
test_histogram(np.empty(0, float), np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
|
|
np.array([0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.]))
|
|
test_histogram([1, 2, 3, 4],
|
|
np.array([3, 1]),
|
|
np.array([0, 4, 7]),
|
|
bins=[0, 4, 7],
|
|
range=(-3, 3))
|
|
test_histogram([1, 2, 3, 4],
|
|
np.array([-2.9, 12.]),
|
|
np.array([0, 4, 7]),
|
|
bins=[0, 4, 7],
|
|
weights=[0.6, 0.5, -4, 12])
|
|
test_histogram([0, 1, 2, 3],
|
|
np.array([1, 1, 1, 1]),
|
|
np.array([0, 1, 2, 3, 4]),
|
|
bins=[0, 1, 2, 3, 4])
|
|
test_histogram(
|
|
[0], np.array([0, 0, 0, 0, 0, 1, 0, 0, 0, 0]),
|
|
np.array([-0.5, -0.4, -0.3, -0.2, -0.1, 0., 0.1, 0.2, 0.3, 0.4, 0.5]))
|
|
test_histogram(np.linspace(0, 10, 100),
|
|
np.array([10, 10, 10, 10, 10, 10, 10, 10, 10, 10]),
|
|
np.array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]))
|
|
test_histogram([1, 2], np.array([2]), np.array([1., 2.]), bins=1)
|
|
test_histogram([1, 2, 3, 4, 5, 6, 7, 8],
|
|
np.array([
|
|
0.17857143, 0.17857143, 0.17857143, 0., 0.17857143,
|
|
0.17857143, 0., 0.17857143, 0.17857143, 0.17857143
|
|
]),
|
|
np.array([1., 1.7, 2.4, 3.1, 3.8, 4.5, 5.2, 5.9, 6.6, 7.3, 8.]),
|
|
density=True)
|
|
test_histogram([1, 2, 3, 4, 5, 6, 7, 8],
|
|
np.array([0., 0.125, 0.125, 0.09375]),
|
|
np.array([0, 1, 3, 6, 10]),
|
|
bins=[0, 1, 3, 6, 10],
|
|
density=True)
|
|
test_histogram([1, 2, 3, 4, 5, 6, 7, 8],
|
|
np.array([0, 2, 3, 3]),
|
|
np.array([0, 1, 3, 6, 10]),
|
|
bins=[0, 1, 3, 6, 10],
|
|
density=False)
|
|
test_histogram([1, 2, 3, 4, 5, 6, 7, 8],
|
|
np.array([0., 0.125, 0.125, 0.]),
|
|
np.array([0, 1, 3, 6, np.inf]),
|
|
bins=[0, 1, 3, 6, np.inf],
|
|
density=True)
|
|
test_histogram([1, 2, 3, 4],
|
|
np.array([0.25, 0.]),
|
|
np.array([0.5, 1.5, np.inf]),
|
|
bins=[0.5, 1.5, np.inf],
|
|
density=True)
|
|
#Test outliers
|
|
test_histogram(np.arange(10) + .5,
|
|
np.array([1, 1, 1, 1, 0, 1, 1, 1, 1, 1]),
|
|
np.array([0., 0.9, 1.8, 2.7, 3.6, 4.5, 5.4, 6.3, 7.2, 8.1, 9.]),
|
|
range=[0, 9])
|
|
test_histogram(np.arange(10) + .5,
|
|
np.array([1, 1, 1, 1, 0, 1, 1, 1, 1, 1]),
|
|
np.array([1., 1.9, 2.8, 3.7, 4.6, 5.5, 6.4, 7.3, 8.2, 9.1,
|
|
10.]),
|
|
range=[1, 10])
|
|
test_histogram(np.arange(10) + .5,
|
|
np.array([
|
|
0.12345679, 0.12345679, 0.12345679, 0.12345679, 0.,
|
|
0.12345679, 0.12345679, 0.12345679, 0.12345679, 0.12345679
|
|
]),
|
|
np.array([0., 0.9, 1.8, 2.7, 3.6, 4.5, 5.4, 6.3, 7.2, 8.1, 9.]),
|
|
range=[0, 9],
|
|
density=True)
|
|
test_histogram(np.arange(10) + .5,
|
|
np.array([
|
|
0.01371742, 0.04115226, 0.06858711, 0.09602195, 0.,
|
|
0.12345679, 0.15089163, 0.17832647, 0.20576132, 0.23319616
|
|
]),
|
|
np.array([0., 0.9, 1.8, 2.7, 3.6, 4.5, 5.4, 6.3, 7.2, 8.1, 9.]),
|
|
range=[0, 9],
|
|
weights=np.arange(10) + .5,
|
|
density=True)
|
|
test_histogram(np.arange(10) + .5,
|
|
np.array([0.5, 1.5, 2.5, 3.5, 10., 6.5, 7.5, 8.5]),
|
|
np.array([0., 1.125, 2.25, 3.375, 4.5, 5.625, 6.75, 7.875, 9.]),
|
|
bins=8,
|
|
range=[0, 9],
|
|
weights=np.arange(10) + .5)
|
|
test_histogram(np.array([0., 0., 0., 1., 2., 3., 3., 4., 5.]),
|
|
np.array([
|
|
0, 0, 3, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 2,
|
|
0, 0, 0, 0, 1, 0, 0, 0, 0, 1
|
|
]),
|
|
np.array([
|
|
-0.5, -0.31666667, -0.13333333, 0.05, 0.23333333,
|
|
0.41666667, 0.6, 0.78333333, 0.96666667, 1.15, 1.33333333,
|
|
1.51666667, 1.7, 1.88333333, 2.06666667, 2.25, 2.43333333,
|
|
2.61666667, 2.8, 2.98333333, 3.16666667, 3.35, 3.53333333,
|
|
3.71666667, 3.9, 4.08333333, 4.26666667, 4.45, 4.63333333,
|
|
4.81666667, 5.
|
|
]),
|
|
bins=30,
|
|
range=(-0.5, 5))
|
|
test_histogram(np.linspace(0, 10, 10),
|
|
np.array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1]),
|
|
np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
|
|
bins=np.arange(11),
|
|
weights=[0, 0, 0, 0, 0, 1, 1, 1, 1, 1])
|
|
test_histogram(np.arange(9),
|
|
np.array([0.2, 0.1, 0.1, 0.075]),
|
|
np.array([0, 1, 3, 6, 10]),
|
|
bins=[0, 1, 3, 6, 10],
|
|
weights=[2, 1, 1, 1, 1, 1, 1, 1, 1],
|
|
density=True)
|
|
test_histogram(np.array([1.3, 2.5, 2.3]),
|
|
np.array([1. + 2.j, 1. + 3.j]),
|
|
np.array([0, 2, 3]),
|
|
bins=[0, 2, 3],
|
|
weights=np.array([1. + 2.j, -1. + 1.j, 2. + 2.j]))
|
|
test_histogram(np.array([1.3, 2.5, 2.3]),
|
|
np.array([1. + 2.j, 1. + 3.j]),
|
|
np.array([1., 2., 3.]),
|
|
bins=2,
|
|
range=[1, 3],
|
|
weights=np.array([1. + 2.j, -1. + 1.j, 2. + 2.j]))
|
|
test_histogram(
|
|
np.array([1.3, 2.5, 2.3]),
|
|
np.array([
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0
|
|
]),
|
|
np.array([
|
|
-10., -9.8, -9.6, -9.4, -9.2, -9., -8.8, -8.6, -8.4, -8.2, -8., -7.8,
|
|
-7.6, -7.4, -7.2, -7., -6.8, -6.6, -6.4, -6.2, -6., -5.8, -5.6,
|
|
-5.4, -5.2, -5., -4.8, -4.6, -4.4, -4.2, -4., -3.8, -3.6,
|
|
-3.4, -3.2, -3., -2.8, -2.6, -2.4, -2.2, -2., -1.8, -1.6,
|
|
-1.4, -1.2, -1., -0.8, -0.6, -0.4, -0.2, 0., 0.2, 0.4, 0.6, 0.8, 1.,
|
|
1.2, 1.4, 1.6, 1.8, 2., 2.2, 2.4, 2.6, 2.8, 3., 3.2, 3.4, 3.6, 3.8, 4.,
|
|
4.2, 4.4, 4.6, 4.8, 5., 5.2, 5.4, 5.6, 5.8, 6., 6.2, 6.4, 6.6, 6.8, 7.,
|
|
7.2, 7.4, 7.6, 7.8, 8., 8.2, 8.4, 8.6, 8.8, 9., 9.2, 9.4, 9.6, 9.8, 10.
|
|
]),
|
|
range=[-10, 10],
|
|
bins=100)
|
|
test_histogram(np.array([0., 0., 0., 1., 2., 3., 3., 4., 5.]),
|
|
np.array([
|
|
0, 0, 3, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 2,
|
|
0, 0, 0, 0, 1, 0, 0, 0, 0, 1
|
|
]),
|
|
np.array([
|
|
-0.5, -0.31666667, -0.13333333, 0.05, 0.23333333,
|
|
0.41666667, 0.6, 0.78333333, 0.96666667, 1.15, 1.33333333,
|
|
1.51666667, 1.7, 1.88333333, 2.06666667, 2.25, 2.43333333,
|
|
2.61666667, 2.8, 2.98333333, 3.16666667, 3.35, 3.53333333,
|
|
3.71666667, 3.9, 4.08333333, 4.26666667, 4.45, 4.63333333,
|
|
4.81666667, 5.
|
|
]),
|
|
bins=30,
|
|
range=(-0.5, 5))
|
|
test_histogram(np.ones(100),
|
|
np.array([100]),
|
|
np.array([0.5, 1.5]),
|
|
bins='scott')
|
|
test_histogram(np.ones(100), np.array([100]), np.array([0.5, 1.5]), bins='fd')
|
|
xcenter = np.linspace(-10, 10, 50)
|
|
a = np.hstack((np.linspace(-110, -100, 5), xcenter))
|
|
test_histogram(a,
|
|
np.array([
|
|
3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 13,
|
|
15, 14
|
|
]),
|
|
np.array([
|
|
-110., -104.28571429, -98.57142857, -92.85714286,
|
|
-87.14285714, -81.42857143, -75.71428571, -70.,
|
|
-64.28571429, -58.57142857, -52.85714286, -47.14285714,
|
|
-41.42857143, -35.71428571, -30., -24.28571429,
|
|
-18.57142857, -12.85714286, -7.14285714, -1.42857143,
|
|
4.28571429, 10.
|
|
]),
|
|
bins='fd')
|
|
test_histogram(a,
|
|
np.array([5, 0, 0, 0, 50]),
|
|
np.array([-110., -86., -62., -38., -14., 10.]),
|
|
bins='scott')
|
|
test_histogram(a,
|
|
np.array([5, 0, 0, 0, 0, 0, 0, 0, 0, 23, 27]),
|
|
np.array([
|
|
-110., -99.09090909, -88.18181818, -77.27272727,
|
|
-66.36363636, -55.45454545, -44.54545455, -33.63636364,
|
|
-22.72727273, -11.81818182, -0.90909091, 10.
|
|
]),
|
|
bins='doane')
|
|
test_histogram(a,
|
|
np.array([5, 0, 0, 0, 0, 50]),
|
|
np.array([-110., -90., -70., -50., -30., -10., 10.]),
|
|
bins='stone')
|
|
|
|
@test
|
|
def test_histogram_fast(dtype: type):
|
|
data = np.array([1, 1, 2, 2, 3, 3, 4, 4, 4, 5], dtype=dtype)
|
|
|
|
if dtype is float or dtype is np.float32 or dtype is np.float16:
|
|
dt = dtype()
|
|
else:
|
|
dt = float()
|
|
|
|
bins_dtype = type(dt)
|
|
|
|
hist, bins = np.histogram(data)
|
|
assert np.array_equal(hist, [2, 0, 2, 0, 0, 2, 0, 3, 0, 1])
|
|
assert np.allclose(bins, [1. , 1.4, 1.8, 2.2, 2.6, 3. , 3.4, 3.8, 4.2, 4.6, 5. ])
|
|
assert hist.dtype is int
|
|
assert bins.dtype is bins_dtype
|
|
|
|
hist, bins = np.histogram(data, bins=1)
|
|
assert np.array_equal(hist, [10])
|
|
assert np.allclose(bins, [1., 5.])
|
|
assert hist.dtype is int
|
|
assert bins.dtype is bins_dtype
|
|
|
|
hist, bins = np.histogram(data, range=(1.5, 3.5))
|
|
assert np.array_equal(hist, [0, 0, 2, 0, 0, 0, 0, 2, 0, 0])
|
|
assert np.allclose(bins, [1.5, 1.7, 1.9, 2.1, 2.3, 2.5, 2.7, 2.9, 3.1, 3.3, 3.5])
|
|
assert hist.dtype is int
|
|
assert bins.dtype is bins_dtype
|
|
|
|
hist, bins = np.histogram(data, range=(5, 6))
|
|
assert np.array_equal(hist, [1, 0, 0, 0, 0, 0, 0, 0, 0, 0])
|
|
assert np.allclose(bins, [5. , 5.1, 5.2, 5.3, 5.4, 5.5, 5.6, 5.7, 5.8, 5.9, 6.])
|
|
assert hist.dtype is int
|
|
assert bins.dtype is bins_dtype
|
|
|
|
hist, bins = np.histogram(data, range=(1.5, 3.5), bins=5)
|
|
assert np.array_equal(hist, [0, 2, 0, 2, 0])
|
|
assert np.allclose(bins, [1.5, 1.9, 2.3, 2.7, 3.1, 3.5])
|
|
assert hist.dtype is int
|
|
assert bins.dtype is bins_dtype
|
|
|
|
hist, bins = np.histogram(data, bins=[-100., 2., 4., 4.2, 4.7, 5.0, 5.2])
|
|
assert np.array_equal(hist, [2, 4, 3, 0, 0, 1])
|
|
assert np.allclose(bins, [-100., 2., 4., 4.2, 4.7, 5., 5.2])
|
|
assert hist.dtype is int
|
|
assert bins.dtype is float
|
|
|
|
bins = np.array([-100., 2., 4., 4.2, 4.7, 5.0, 5.2], np.float32)
|
|
hist, bins = np.histogram(data, bins=bins)
|
|
assert np.array_equal(hist, [2, 4, 3, 0, 0, 1])
|
|
assert np.allclose(bins, [-100., 2., 4., 4.2, 4.7, 5., 5.2])
|
|
assert hist.dtype is int
|
|
assert bins.dtype is np.float32
|
|
|
|
hist, bins = np.histogram(data, bins=[-100., 2., 4., 4.2, 4.7, 5.0, 5.2], range=(2, 4))
|
|
assert np.array_equal(hist, [2, 4, 3, 0, 0, 1])
|
|
assert np.allclose(bins, [-100., 2., 4., 4.2, 4.7, 5., 5.2])
|
|
assert hist.dtype is int
|
|
assert bins.dtype is float
|
|
|
|
hist, bins = np.histogram(data, bins=[-100, 2, 4, 5, 100], range=(-1, 100))
|
|
assert np.array_equal(hist, [2, 4, 3, 1])
|
|
assert np.array_equal(bins, [-100, 2, 4, 5, 100])
|
|
assert hist.dtype is int
|
|
assert bins.dtype is int
|
|
|
|
data = np.array([2, 2, 2], dtype=dtype)
|
|
|
|
hist, bins = np.histogram(data)
|
|
assert np.array_equal(hist, [0, 0, 0, 0, 0, 3, 0, 0, 0, 0])
|
|
assert np.allclose(bins, [1.5, 1.6, 1.7, 1.8, 1.9, 2. , 2.1, 2.2, 2.3, 2.4, 2.5])
|
|
assert hist.dtype is int
|
|
assert bins.dtype is bins_dtype
|
|
|
|
hist, bins = np.histogram(data, bins=5)
|
|
assert np.array_equal(hist, [0, 0, 3, 0, 0])
|
|
assert np.allclose(bins, [1.5, 1.7, 1.9, 2.1, 2.3, 2.5])
|
|
assert hist.dtype is int
|
|
assert bins.dtype is bins_dtype
|
|
|
|
hist, bins = np.histogram(data, bins=5, range=(3, 4))
|
|
assert np.array_equal(hist, [0, 0, 0, 0, 0])
|
|
assert np.allclose(bins, [3. , 3.2, 3.4, 3.6, 3.8, 4.])
|
|
assert hist.dtype is int
|
|
assert bins.dtype is bins_dtype
|
|
|
|
data = np.empty(0, dtype=dtype)
|
|
|
|
hist, bins = np.histogram(data)
|
|
assert np.array_equal(hist, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
|
|
assert np.allclose(bins, [0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.])
|
|
assert hist.dtype is int
|
|
assert bins.dtype is bins_dtype
|
|
|
|
hist, bins = np.histogram(data, bins=1)
|
|
assert np.array_equal(hist, [0])
|
|
assert np.allclose(bins, [0., 1.])
|
|
assert hist.dtype is int
|
|
assert bins.dtype is bins_dtype
|
|
|
|
data = np.arange(81, dtype=dtype) ** 0.2
|
|
data = data.reshape((3, 3, 3, 3))
|
|
|
|
hist, bins = np.histogram(data)
|
|
assert np.array_equal(hist, [1, 0, 0, 0, 2, 4, 7, 13, 21, 33])
|
|
assert np.allclose(bins, [0. , 0.24022489, 0.48044977, 0.72067466, 0.96089955,
|
|
1.20112443, 1.44134932, 1.68157421, 1.92179909, 2.16202398,
|
|
2.40224887])
|
|
assert hist.dtype is int
|
|
assert bins.dtype is bins_dtype
|
|
|
|
hist, bins = np.histogram(data[::2,::2,::2,::2])
|
|
assert np.array_equal(hist, [1, 0, 0, 0, 1, 1, 1, 4, 0, 8])
|
|
assert np.allclose(bins, [0. , 0.24022489, 0.48044977, 0.72067466, 0.96089955,
|
|
1.20112443, 1.44134932, 1.68157421, 1.92179909, 2.16202398,
|
|
2.40224887])
|
|
assert hist.dtype is int
|
|
assert bins.dtype is bins_dtype
|
|
|
|
hist, bins = np.histogram(data[::2,::2,::2,::2], bins=[0, 0.2, 0.8, 3], range=(0, 2.1))
|
|
assert np.array_equal(hist, [1, 0, 15])
|
|
assert np.allclose(bins, [0., 0.2, 0.8, 3.])
|
|
assert hist.dtype is int
|
|
assert bins.dtype is float
|
|
|
|
test_histogram_fast(int)
|
|
test_histogram_fast(np.int8)
|
|
test_histogram_fast(np.float64)
|
|
test_histogram_fast(np.float32)
|