Esempio n. 1
0
def test_old_to_new_known():
    old = ((10, 10, 10, 10, 10), )
    new = ((25, 5, 20), )
    result = _old_to_new(old, new)
    expected = [[[(0, slice(0, 10, None)), (1, slice(0, 10, None)),
                  (2, slice(0, 5, None))], [(2, slice(5, 10, None))],
                 [(3, slice(0, 10, None)), (4, slice(0, 10, None))]]]
    assert result == expected
Esempio n. 2
0
def test_old_to_new():
    old = ((float('nan'), ), (10, ))
    new = ((float('nan'), ), (5, 5))
    result = _old_to_new(old, new)
    expected = [[[(0, slice(0, None, None))]],
                [[(0, slice(0, 5, None))], [(0, slice(5, 10, None))]]]

    assert result == expected
Esempio n. 3
0
def test_old_to_new_known():
    old = ((10, 10, 10, 10, 10), )
    new = ((25, 5, 20), )
    result = _old_to_new(old, new)
    expected = [[[(0, slice(0, 10, None)), (1, slice(0, 10, None)), (2, slice(0, 5, None))],
                [(2, slice(5, 10, None))],
                [(3, slice(0, 10, None)), (4, slice(0, 10, None))]]]
    assert result == expected
Esempio n. 4
0
def test_old_to_new():
    old = ((float('nan'),), (10,))
    new = ((float('nan'),), (5, 5))
    result = _old_to_new(old, new)
    expected = [[[(0, slice(0, None, None))]],
                [[(0, slice(0, 5, None))], [(0, slice(5, 10, None))]]]

    assert result == expected
Esempio n. 5
0
def test_old_to_new_large():
    old = (tuple([float('nan')] * 4), (10, ))
    new = (tuple([float('nan')] * 4), (5, 5))

    result = _old_to_new(old, new)
    expected = [[[(0, slice(0, None, None))], [(1, slice(0, None, None))],
                 [(2, slice(0, None, None))], [(3, slice(0, None, None))]],
                [[(0, slice(0, 5, None))], [(0, slice(5, 10, None))]]]
    assert result == expected
Esempio n. 6
0
def test_old_to_new_single():
    old = ((float('nan'), float('nan')), (8, ))
    new = ((float('nan'), float('nan')), (4, 4))
    result = _old_to_new(old, new)

    expected = [[[(0, slice(0, None, None))], [(1, slice(0, None, None))]],
                [[(0, slice(0, 4, None))], [(0, slice(4, 8, None))]]]

    assert result == expected
Esempio n. 7
0
def test_old_to_new_single():
    old = ((float('nan'), float('nan')), (8,))
    new = ((float('nan'), float('nan')), (4, 4))
    result = _old_to_new(old, new)

    expected = [[[(0, slice(0, None, None))], [(1, slice(0, None, None))]],
                [[(0, slice(0, 4, None))], [(0, slice(4, 8, None))]]]

    assert result == expected
Esempio n. 8
0
def test_old_to_new_large():
    old = (tuple([float('nan')] * 4), (10,))
    new = (tuple([float('nan')] * 4), (5, 5))

    result = _old_to_new(old, new)
    expected = [[[(0, slice(0, None, None))],
                [(1, slice(0, None, None))],
                [(2, slice(0, None, None))],
                [(3, slice(0, None, None))]],
                [[(0, slice(0, 5, None))], [(0, slice(5, 10, None))]]]
    assert result == expected
Esempio n. 9
0
def test_old_to_new_with_zero():
    from dask.array.rechunk import _old_to_new

    old = ((4, 4), )
    new = ((4, 0, 4), )
    result = _old_to_new(old, new)
    expected = [[[(0, slice(0, 4))], [(1, slice(0, 0))], [(1, slice(0, 4))]]]
    assert result == expected

    old = ((4, ), )
    new = ((4, 0), )
    result = _old_to_new(old, new)
    expected = [[[(0, slice(0, 4))], [(0, slice(4, 4))]]]
    assert result == expected

    old = ((4, 0, 4), )
    new = ((4, 0, 2, 2), )
    result = _old_to_new(old, new)
    expected = [[[(0, slice(0, 4))], [(2, slice(0, 0))], [(2, slice(0, 2))],
                 [(2, slice(2, 4))]]]
    assert result == expected
Esempio n. 10
0
def test_changing_raises():
    nan = float("nan")
    with pytest.raises(ValueError) as record:
        _old_to_new(((nan, nan), (4, 4)), ((nan, nan, nan), (4, 4)))

    assert "unchanging" in str(record.value)
Esempio n. 11
0
def test_changing_raises():
    nan = float('nan')
    with pytest.raises(ValueError) as record:
        _old_to_new(((nan, nan), (4, 4)), ((nan, nan, nan), (4, 4)))

    assert 'unchanging' in str(record.value)