def test_numpy_wrappers():
    a1 = YTArray([1, 2, 3], 'cm')
    a2 = YTArray([2, 3, 4, 5, 6], 'cm')
    a3 = YTArray([7, 8, 9, 10, 11], 'cm')
    catenate_answer = [1, 2, 3, 2, 3, 4, 5, 6]
    intersect_answer = [2, 3]
    union_answer = [1, 2, 3, 4, 5, 6]
    vstack_answer = [[2, 3, 4, 5, 6], [7, 8, 9, 10, 11]]

    assert_array_equal(YTArray(catenate_answer, 'cm'), uconcatenate((a1, a2)))
    assert_array_equal(catenate_answer, np.concatenate((a1, a2)))

    assert_array_equal(YTArray(intersect_answer, 'cm'), uintersect1d(a1, a2))
    assert_array_equal(intersect_answer, np.intersect1d(a1, a2))

    assert_array_equal(YTArray(union_answer, 'cm'), uunion1d(a1, a2))
    assert_array_equal(union_answer, np.union1d(a1, a2))

    assert_array_equal(YTArray(catenate_answer, 'cm'), uhstack([a1, a2]))
    assert_array_equal(catenate_answer, np.hstack([a1, a2]))

    assert_array_equal(YTArray(vstack_answer, 'cm'), uvstack([a2, a3]))
    assert_array_equal(vstack_answer, np.vstack([a2, a3]))

    assert_array_equal(YTArray(vstack_answer, 'cm'), ustack([a2, a3]))
    assert_array_equal(vstack_answer, np.stack([a2, a3]))
예제 #2
0
def test_numpy_wrappers():
    a1 = YTArray([1, 2, 3], 'cm')
    a2 = YTArray([2, 3, 4, 5, 6], 'cm')
    catenate_answer = [1, 2, 3, 2, 3, 4, 5, 6]
    intersect_answer = [2, 3]
    union_answer = [1, 2, 3, 4, 5, 6]

    assert_array_equal(YTArray(catenate_answer, 'cm'), uconcatenate((a1, a2)))
    assert_array_equal(catenate_answer, np.concatenate((a1, a2)))

    assert_array_equal(YTArray(intersect_answer, 'cm'), uintersect1d(a1, a2))
    assert_array_equal(intersect_answer, np.intersect1d(a1, a2))

    assert_array_equal(YTArray(union_answer, 'cm'), uunion1d(a1, a2))
    assert_array_equal(union_answer, np.union1d(a1, a2))
def test_numpy_wrappers():
    a1 = YTArray([1, 2, 3], 'cm')
    a2 = YTArray([2, 3, 4, 5, 6], 'cm')
    catenate_answer = [1, 2, 3, 2, 3, 4, 5, 6]
    intersect_answer = [2, 3]
    union_answer = [1, 2, 3, 4, 5, 6]

    yield (assert_array_equal, YTArray(catenate_answer, 'cm'),
           uconcatenate((a1, a2)))
    yield assert_array_equal, catenate_answer, np.concatenate((a1, a2))

    yield (assert_array_equal, YTArray(intersect_answer, 'cm'),
           uintersect1d(a1, a2))
    yield assert_array_equal, intersect_answer, np.intersect1d(a1, a2)

    yield assert_array_equal, YTArray(union_answer, 'cm'), uunion1d(a1, a2)
    yield assert_array_equal, union_answer, np.union1d(a1, a2)
예제 #4
0
def test_compose_overlap():
    r"""Test to make sure that composed data objects that do
    overlap behave the way we expect
    """
    for n in [1, 2, 4, 8]:
        ds = fake_random_ds(64, nprocs=n)
        ds.add_field(("index", "ID"), sampling_type="cell", function=_IDFIELD)

        # position parameters for initial region
        center = [0.4, 0.5, 0.5]
        left_edge = [0.1] * 3
        right_edge = [0.7] * 3
        normal = [1, 0, 0]
        radius = height = 0.15

        # initial 3D regions
        sources = [
            ds.sphere(center, radius),
            ds.region(center, left_edge, right_edge),
            ds.disk(center, normal, radius, height),
        ]

        # position parameters for overlapping regions
        center = [0.6, 0.5, 0.5]
        left_edge = [0.3] * 3
        right_edge = [0.9] * 3

        # subselect non-overlapping 0, 1, 2, 3D regions
        for data1 in sources:
            id1 = data1["index", "ID"]

            data2 = ds.sphere(center, radius)
            data3 = ds.sphere(center, radius, data_source=data1)
            id2 = data2["index", "ID"]
            id3 = data3["index", "ID"]
            id3.sort()
            assert_array_equal(uintersect1d(id1, id2), id3)

            data2 = ds.region(center, left_edge, right_edge)
            data3 = ds.region(center, left_edge, right_edge, data_source=data1)
            id2 = data2["index", "ID"]
            id3 = data3["index", "ID"]
            id3.sort()
            assert_array_equal(uintersect1d(id1, id2), id3)

            data2 = ds.disk(center, normal, radius, height)
            data3 = ds.disk(center, normal, radius, height, data_source=data1)
            id2 = data2["index", "ID"]
            id3 = data3["index", "ID"]
            id3.sort()
            assert_array_equal(uintersect1d(id1, id2), id3)

            for d in range(3):
                data2 = ds.slice(d, center[d])
                data3 = ds.slice(d, center[d], data_source=data1)
                id2 = data2["index", "ID"]
                id3 = data3["index", "ID"]
                id3.sort()
                assert_array_equal(uintersect1d(id1, id2), id3)

            for d in range(3):
                data2 = ds.ortho_ray(d, center[0:d] + center[d + 1 :])
                data3 = ds.ortho_ray(
                    d, center[0:d] + center[d + 1 :], data_source=data1
                )
                id2 = data2["index", "ID"]
                id3 = data3["index", "ID"]
                id3.sort()
                assert_array_equal(uintersect1d(id1, id2), id3)

            data2 = ds.point(center)
            data3 = ds.point(center, data_source=data1)
            id2 = data2["index", "ID"]
            id3 = data3["index", "ID"]
            id3.sort()
            assert_array_equal(uintersect1d(id1, id2), id3)
def test_compose_overlap():
    r"""Test to make sure that composed data objects that do
    overlap behave the way we expect 
    """
    empty = np.array([])
    for n in [1, 2, 4, 8]:
        ds = fake_random_ds(64, nprocs=n)
        ds.add_field(("index", "ID"), function=_IDFIELD)

        # position parameters for initial region
        center = [0.4, 0.5, 0.5]
        left_edge = [0.1]*3
        right_edge = [0.7]*3
        normal = [1, 0, 0]
        radius = height = 0.15

        # initial 3D regions
        sources = [ds.sphere(center, radius),
                   ds.region(center, left_edge, right_edge),
                   ds.disk(center, normal, radius, height)]

        # position parameters for overlapping regions
        center = [0.6, 0.5, 0.5]
        left_edge = [0.3]*3
        right_edge = [0.9]*3

        # subselect non-overlapping 0, 1, 2, 3D regions
        for data1 in sources:
            id1 = data1['index', 'ID']

            data2 = ds.sphere(center, radius)
            data3 = ds.sphere(center, radius, data_source=data1)
            id2 = data2['index', 'ID']
            id3 = data3['index', 'ID']
            id3.sort()
            yield assert_array_equal, uintersect1d(id1, id2), id3

            data2 = ds.region(center, left_edge, right_edge)
            data3 = ds.region(center, left_edge, right_edge, data_source=data1)
            id2 = data2['index', 'ID']
            id3 = data3['index', 'ID']
            id3.sort()
            yield assert_array_equal, uintersect1d(id1, id2), id3

            data2 = ds.disk(center, normal, radius, height)
            data3 = ds.disk(center, normal, radius, height, data_source=data1)
            id2 = data2['index', 'ID']
            id3 = data3['index', 'ID']
            id3.sort()
            yield assert_array_equal, uintersect1d(id1, id2), id3

            for d in range(3):
                data2 = ds.slice(d, center[d])
                data3 = ds.slice(d, center[d], data_source=data1)
                id2 = data2['index', 'ID']
                id3 = data3['index', 'ID']
                id3.sort()
                yield assert_array_equal, uintersect1d(id1, id2), id3

            for d in range(3):
                data2 = ds.ortho_ray(d, center[0:d] + center[d+1:])
                data3 = ds.ortho_ray(d, center[0:d] + center[d+1:], data_source=data1)
                id2 = data2['index', 'ID']
                id3 = data3['index', 'ID']
                id3.sort()
                yield assert_array_equal, uintersect1d(id1, id2), id3

            data2 = ds.point(center)
            data3 = ds.point(center, data_source=data1)
            id2 = data2['index', 'ID']
            id3 = data3['index', 'ID']
            id3.sort()
            yield assert_array_equal, uintersect1d(id1, id2), id3