2156400673

Build Type

push

github

Committed by GitHub

Commit Message

Change how we create objects!  For example, `Vector(float, size=2)`. (#205)

Run Details

4690 of 4714 branches covered (99.49%)

Branch coverage included in aggregate %.

299 of 299 new or added lines in 23 files covered. (100.0%)

1 existing line in 1 file now uncovered.

14975 of 14985 relevant lines covered (99.93%)

14.15 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.63

/grblas/tests/test_numpyops.py

# These tests are very slow, since they force creation of all
# numpy unary, binary, monoid, and semiring objects.
import itertools

import numpy as np
import pytest

import grblas
import grblas.binary.numpy as npbinary
import grblas.monoid.numpy as npmonoid
import grblas.semiring.numpy as npsemiring
import grblas.unary.numpy as npunary
from grblas import Vector
from grblas.dtypes import _supports_complex

from .conftest import compute


def test_numpyops_dir():
    assert "exp2" in dir(npunary)
    assert "logical_and" in dir(npbinary)
    assert "logaddexp" in dir(npmonoid)
    assert "add_add" in dir(npsemiring)


@pytest.mark.slow
def test_bool_doesnt_get_too_large():
    a = Vector.from_values([0, 1, 2, 3], [True, False, True, False])
    b = Vector.from_values([0, 1, 2, 3], [True, True, False, False])
    if grblas.config["mapnumpy"]:
        with pytest.raises(KeyError, match="plus does not work with BOOL"):
            z = a.ewise_mult(b, grblas.monoid.numpy.add).new()
    else:
        z = a.ewise_mult(b, grblas.monoid.numpy.add).new()
        x, y = z.to_values()
        np.testing.assert_array_equal(y, (True, True, True, False))

    op = grblas.operator.UnaryOp.register_anonymous(lambda x: np.add(x, x))
    z = a.apply(op).new()
    x, y = z.to_values()
    np.testing.assert_array_equal(y, (True, False, True, False))


@pytest.mark.slow
def test_npunary():
    L = list(range(5))
    data = [
        [Vector.from_values([0, 1], [True, False]), np.array([True, False])],
        [Vector.from_values(L, L), np.array(L, dtype=np.int64)],
        [Vector.from_values(L, L, dtype="float64"), np.array(L, dtype=np.float64)],
    ]
    if _supports_complex:
        data.append(
            [Vector.from_values(L, L, dtype="FC64"), np.array(L, dtype=np.complex128)],
        )
    blocklist = {"BOOL": {"negative", "sign"}, "FC64": {"ceil", "floor", "trunc"}}
    isclose = grblas.binary.isclose(1e-7, 0)
    for gb_input, np_input in data:
        for unary_name in sorted(npunary._unary_names):
            op = getattr(npunary, unary_name)
            if gb_input.dtype not in op.types or unary_name in blocklist.get(
                gb_input.dtype.name, ()
            ):
                continue
            if gb_input.dtype.name.startswith("FC"):
                # There are some nasty branch cuts as 1
                gb_input = gb_input.dup()
                gb_input[1] = 1.1 + 1.2j
                np_input = np_input.copy()
                np_input[1] = 1.1 + 1.2j
            with np.errstate(divide="ignore", over="ignore", under="ignore", invalid="ignore"):
                gb_result = gb_input.apply(op).new()
                if gb_input.dtype == "BOOL" and gb_result.dtype == "FP32":
                    np_result = getattr(np, unary_name)(np_input, dtype="float32")
                    compare_op = isclose
                else:
                    np_result = getattr(np, unary_name)(np_input)
                    if gb_result.dtype.name.startswith("FC"):
                        compare_op = isclose
                    else:
                        compare_op = npbinary.equal
            np_result = Vector.from_values(
                list(range(np_input.size)), list(np_result), dtype=gb_result.dtype
            )
            assert gb_result.nvals == np_result.size
            match = gb_result.ewise_mult(np_result, compare_op).new()
            if gb_result.dtype.name.startswith("F"):
                match(accum=grblas.binary.lor) << gb_result.apply(npunary.isnan)
            compare = match.reduce(grblas.monoid.land).new()
            if not compare:  # pragma: no cover
                print(unary_name, gb_input.dtype)
                print(compute(gb_result))
                print(np_result)
            assert compare


@pytest.mark.slow
def test_npbinary():
    values1 = [0, 0, 1, 1, 2, 5]
    values2 = [0, 1, 0, 1, 3, 8]
    index = list(range(len(values1)))
    data = [
        [
            [Vector.from_values(index, values1), Vector.from_values(index, values2)],
            [np.array(values1, dtype=np.int64), np.array(values2, dtype=np.int64)],
        ],
        [
            [
                Vector.from_values(index, values1, dtype="float64"),
                Vector.from_values(index, values2, dtype="float64"),
            ],
            [np.array(values1, dtype=np.float64), np.array(values2, dtype=np.float64)],
        ],
        [
            [
                Vector.from_values([0, 1, 2, 3], [True, False, True, False]),
                Vector.from_values([0, 1, 2, 3], [True, True, False, False]),
            ],
            [np.array([True, False, True, False]), np.array([True, True, False, False])],
        ],
    ]
    if _supports_complex:
        data.append(
            [
                [
                    Vector.from_values(index, values1, dtype="FC64"),
                    Vector.from_values(index, values2, dtype="FC64"),
                ],
                [np.array(values1, dtype=np.complex128), np.array(values2, dtype=np.complex128)],
            ],
        )
    blocklist = {
        "FP64": {"floor_divide"},  # numba/numpy difference for 1.0 / 0.0
        "BOOL": {"gcd", "lcm", "subtract"},  # not supported by numpy
    }
    isclose = grblas.binary.isclose(1e-7, 0)
    for (gb_left, gb_right), (np_left, np_right) in data:
        for binary_name in sorted(npbinary._binary_names):
            op = getattr(npbinary, binary_name)
            if gb_left.dtype not in op.types or binary_name in blocklist.get(
                gb_left.dtype.name, ()
            ):
                continue
            if not _supports_complex and binary_name == "ldexp":
                # On Windows, the second argument must be int32 or less (I'm not sure why)
                np_right = np_right.astype(np.int32)
            with np.errstate(divide="ignore", over="ignore", under="ignore", invalid="ignore"):
                gb_result = gb_left.ewise_mult(gb_right, op).new()
                if gb_left.dtype == "BOOL" and gb_result.dtype == "FP32":
                    np_result = getattr(np, binary_name)(np_left, np_right, dtype="float32")
                    compare_op = isclose
                else:
                    np_result = getattr(np, binary_name)(np_left, np_right)
                    compare_op = npbinary.equal

            np_result = Vector.from_values(
                np.arange(np_left.size), np_result, dtype=gb_result.dtype
            )

            assert gb_result.nvals == np_result.size
            match = gb_result.ewise_mult(np_result, compare_op).new()
            if gb_result.dtype.name.startswith("F"):
                match(accum=grblas.binary.lor) << gb_result.apply(npunary.isnan)
            if gb_result.dtype.name.startswith("FC"):
                # Divide by 0j sometimes result in different behavior, such as `nan` or `(inf+0j)`
                match(accum=grblas.binary.lor) << gb_result.apply(npunary.isinf)
            compare = match.reduce(grblas.monoid.land).new()
            if not compare:  # pragma: no cover
                print(binary_name)
                print(compute(gb_left))
                print(compute(gb_right))
                print(compute(gb_result))
                print(np_result)
            assert compare


@pytest.mark.slow
def test_npmonoid():
    values1 = [0, 0, 1, 1, 2, 5]
    values2 = [0, 1, 0, 1, 3, 8]
    index = list(range(len(values1)))
    data = [
        [
            [Vector.from_values(index, values1), Vector.from_values(index, values2)],
            [np.array(values1, dtype=int), np.array(values2, dtype=int)],
        ],
        [
            [
                Vector.from_values(index, values1, dtype="float64"),
                Vector.from_values(index, values2, dtype="float64"),
            ],
            [np.array(values1, dtype=np.float64), np.array(values2, dtype=np.float64)],
        ],
        [
            [
                Vector.from_values([0, 1, 2, 3], [True, False, True, False]),
                Vector.from_values([0, 1, 2, 3], [True, True, False, False]),
            ],
            [np.array([True, False, True, False]), np.array([True, True, False, False])],
        ],
    ]
    # Complex monoids not working yet (they segfault upon creation in grblas.operators)
    # if _supports_complex:  # pragma: no branch
    #     data.append(
    #         [
    #             [
    #                 Vector.from_values(index, values1, dtype="FC64"),
    #                 Vector.from_values(index, values2, dtype="FC64"),
    #             ],
    #             [
    #                 np.array(values1, dtype=np.complex128),
    #                 np.array(values2, dtype=np.complex128),
    #             ],
    #         ]
    #     )
    blocklist = {}
    reduction_blocklist = {
        "BOOL": {"add"},
    }
    for (gb_left, gb_right), (np_left, np_right) in data:
        for binary_name in sorted(npmonoid._monoid_identities):
            op = getattr(npmonoid, binary_name)
            assert len(op.types) > 0, op.name
            if gb_left.dtype not in op.types or binary_name in blocklist.get(
                gb_left.dtype.name, ()
            ):
                continue
            with np.errstate(divide="ignore", over="ignore", under="ignore", invalid="ignore"):
                gb_result = gb_left.ewise_mult(gb_right, op).new()
                np_result = getattr(np, binary_name)(np_left, np_right)
            np_result = Vector.from_values(
                np.arange(np_left.size), np_result, dtype=gb_result.dtype
            )
            assert gb_result.nvals == np_result.size
            match = gb_result.ewise_mult(np_result, npbinary.equal).new()
            if gb_result.dtype.name.startswith("F"):
                match(accum=grblas.binary.lor) << gb_result.apply(npunary.isnan)
            compare = match.reduce(grblas.monoid.land).new()
            if not compare:  # pragma: no cover
                print(binary_name, gb_left.dtype)
                print(compute(gb_result))
                print(np_result)
            assert compare

            # numpy reductions don't have dtype-dependent identities, so results sometimes differ
            if binary_name in reduction_blocklist.get(gb_left.dtype.name, ()):
                continue

            gb_result = gb_left.reduce(op).new()
            np_result = getattr(np, binary_name).reduce(np_left)
            assert gb_result.value == np_result

            gb_result = gb_right.reduce(op).new()
            np_result = getattr(np, binary_name).reduce(np_right)
            assert gb_result.value == np_result


@pytest.mark.slow
def test_npsemiring():
    for monoid_name, binary_name in itertools.product(
        sorted(npmonoid._monoid_identities), sorted(npbinary._binary_names)
    ):
        monoid = getattr(npmonoid, monoid_name)
        binary = getattr(npbinary, binary_name)
        name = monoid.name.split(".")[-1] + "_" + binary.name.split(".")[-1]
        if name in {"eq_pow", "eq_minus"}:
            continue
        semiring = grblas.operator.Semiring.register_anonymous(monoid, binary, name)
        if len(semiring.types) == 0:
            if not grblas.config["mapnumpy"] and "logical" not in name:
                assert not hasattr(npsemiring, semiring.name), name
        else:
            assert hasattr(npsemiring, f"{monoid_name}_{binary_name}"), (name, semiring.name)

1	# These tests are very slow, since they force creation of all
2	# numpy unary, binary, monoid, and semiring objects.
3	import itertools	15✔
4
5	import numpy as np	15✔
6	import pytest	15✔
7
8	import grblas	15✔
9	import grblas.binary.numpy as npbinary	15✔
10	import grblas.monoid.numpy as npmonoid	15✔
11	import grblas.semiring.numpy as npsemiring	15✔
12	import grblas.unary.numpy as npunary	15✔
13	from grblas import Vector	15✔
14	from grblas.dtypes import _supports_complex	15✔
15
16	from .conftest import compute	15✔
17
18
19	def test_numpyops_dir():	15✔
20	assert "exp2" in dir(npunary)	15✔
21	assert "logical_and" in dir(npbinary)	15✔
22	assert "logaddexp" in dir(npmonoid)	15✔
23	assert "add_add" in dir(npsemiring)	15✔
24
25
26	@pytest.mark.slow	15✔
27	def test_bool_doesnt_get_too_large():	15✔
28	a = Vector.from_values([0, 1, 2, 3], [True, False, True, False])	5✔
29	b = Vector.from_values([0, 1, 2, 3], [True, True, False, False])	5✔
30	if grblas.config["mapnumpy"]:	5✔
31	with pytest.raises(KeyError, match="plus does not work with BOOL"):	4✔
32	z = a.ewise_mult(b, grblas.monoid.numpy.add).new()	4✔
33	else:
34	z = a.ewise_mult(b, grblas.monoid.numpy.add).new()	3✔
35	x, y = z.to_values()	3✔
36	np.testing.assert_array_equal(y, (True, True, True, False))	3✔
37
38	op = grblas.operator.UnaryOp.register_anonymous(lambda x: np.add(x, x))	5!
39	z = a.apply(op).new()	5✔
40	x, y = z.to_values()	5✔
41	np.testing.assert_array_equal(y, (True, False, True, False))	5✔
42
43
44	@pytest.mark.slow	15✔
45	def test_npunary():	15✔
46	L = list(range(5))	5✔
47	data = [	5✔
48	[Vector.from_values([0, 1], [True, False]), np.array([True, False])],
49	[Vector.from_values(L, L), np.array(L, dtype=np.int64)],
50	[Vector.from_values(L, L, dtype="float64"), np.array(L, dtype=np.float64)],
51	]
52	if _supports_complex:	5!
53	data.append(	5✔
54	[Vector.from_values(L, L, dtype="FC64"), np.array(L, dtype=np.complex128)],
55	)
56	blocklist = {"BOOL": {"negative", "sign"}, "FC64": {"ceil", "floor", "trunc"}}	5✔
57	isclose = grblas.binary.isclose(1e-7, 0)	5✔
58	for gb_input, np_input in data:	5✔
59	for unary_name in sorted(npunary._unary_names):	5✔
60	op = getattr(npunary, unary_name)	5✔
61	if gb_input.dtype not in op.types or unary_name in blocklist.get(	5✔
62	gb_input.dtype.name, ()
63	):
64	continue	5✔
65	if gb_input.dtype.name.startswith("FC"):	5✔
66	# There are some nasty branch cuts as 1
67	gb_input = gb_input.dup()	5✔
68	gb_input[1] = 1.1 + 1.2j	5✔
69	np_input = np_input.copy()	5✔
70	np_input[1] = 1.1 + 1.2j	5✔
71	with np.errstate(divide="ignore", over="ignore", under="ignore", invalid="ignore"):	5✔
72	gb_result = gb_input.apply(op).new()	5✔
73	if gb_input.dtype == "BOOL" and gb_result.dtype == "FP32":	5✔
74	np_result = getattr(np, unary_name)(np_input, dtype="float32")	5✔
75	compare_op = isclose	5✔
76	else:
77	np_result = getattr(np, unary_name)(np_input)	5✔
78	if gb_result.dtype.name.startswith("FC"):	5✔
79	compare_op = isclose	5✔
80	else:
81	compare_op = npbinary.equal	5✔
82	np_result = Vector.from_values(	5✔
83	list(range(np_input.size)), list(np_result), dtype=gb_result.dtype
84	)
85	assert gb_result.nvals == np_result.size	5✔
86	match = gb_result.ewise_mult(np_result, compare_op).new()	5✔
87	if gb_result.dtype.name.startswith("F"):	5✔
88	match(accum=grblas.binary.lor) << gb_result.apply(npunary.isnan)	5✔
89	compare = match.reduce(grblas.monoid.land).new()	5✔
90	if not compare: # pragma: no cover
91	print(unary_name, gb_input.dtype)
92	print(compute(gb_result))
93	print(np_result)
94	assert compare	5✔
95
96
97	@pytest.mark.slow	15✔
98	def test_npbinary():	15✔
99	values1 = [0, 0, 1, 1, 2, 5]	5✔
100	values2 = [0, 1, 0, 1, 3, 8]	5✔
101	index = list(range(len(values1)))	5✔
102	data = [	5✔
103	[
104	[Vector.from_values(index, values1), Vector.from_values(index, values2)],
105	[np.array(values1, dtype=np.int64), np.array(values2, dtype=np.int64)],
106	],
107	[
108	[
109	Vector.from_values(index, values1, dtype="float64"),
110	Vector.from_values(index, values2, dtype="float64"),
111	],
112	[np.array(values1, dtype=np.float64), np.array(values2, dtype=np.float64)],
113	],
114	[
115	[
116	Vector.from_values([0, 1, 2, 3], [True, False, True, False]),
117	Vector.from_values([0, 1, 2, 3], [True, True, False, False]),
118	],
119	[np.array([True, False, True, False]), np.array([True, True, False, False])],
120	],
121	]
122	if _supports_complex:	5!
123	data.append(	5✔
124	[
125	[
126	Vector.from_values(index, values1, dtype="FC64"),
127	Vector.from_values(index, values2, dtype="FC64"),
128	],
129	[np.array(values1, dtype=np.complex128), np.array(values2, dtype=np.complex128)],
130	],
131	)
132	blocklist = {	5✔
133	"FP64": {"floor_divide"}, # numba/numpy difference for 1.0 / 0.0
134	"BOOL": {"gcd", "lcm", "subtract"}, # not supported by numpy
135	}
136	isclose = grblas.binary.isclose(1e-7, 0)	5✔
137	for (gb_left, gb_right), (np_left, np_right) in data:	5✔
138	for binary_name in sorted(npbinary._binary_names):	5✔
139	op = getattr(npbinary, binary_name)	5✔
140	if gb_left.dtype not in op.types or binary_name in blocklist.get(	5✔
141	gb_left.dtype.name, ()
142	):
143	continue	5✔
144	if not _supports_complex and binary_name == "ldexp":	5!
145	# On Windows, the second argument must be int32 or less (I'm not sure why)
UNCOV 146	np_right = np_right.astype(np.int32)	×
147	with np.errstate(divide="ignore", over="ignore", under="ignore", invalid="ignore"):	5✔
148	gb_result = gb_left.ewise_mult(gb_right, op).new()	5✔
149	if gb_left.dtype == "BOOL" and gb_result.dtype == "FP32":	5✔
150	np_result = getattr(np, binary_name)(np_left, np_right, dtype="float32")	5✔
151	compare_op = isclose	5✔
152	else:
153	np_result = getattr(np, binary_name)(np_left, np_right)	5✔
154	compare_op = npbinary.equal	5✔
155
156	np_result = Vector.from_values(	5✔
157	np.arange(np_left.size), np_result, dtype=gb_result.dtype
158	)
159
160	assert gb_result.nvals == np_result.size	5✔
161	match = gb_result.ewise_mult(np_result, compare_op).new()	5✔
162	if gb_result.dtype.name.startswith("F"):	5✔
163	match(accum=grblas.binary.lor) << gb_result.apply(npunary.isnan)	5✔
164	if gb_result.dtype.name.startswith("FC"):	5✔
165	# Divide by 0j sometimes result in different behavior, such as `nan` or `(inf+0j)`
166	match(accum=grblas.binary.lor) << gb_result.apply(npunary.isinf)	5✔
167	compare = match.reduce(grblas.monoid.land).new()	5✔
168	if not compare: # pragma: no cover
169	print(binary_name)
170	print(compute(gb_left))
171	print(compute(gb_right))
172	print(compute(gb_result))
173	print(np_result)
174	assert compare	5✔
175
176
177	@pytest.mark.slow	15✔
178	def test_npmonoid():	15✔
179	values1 = [0, 0, 1, 1, 2, 5]	5✔
180	values2 = [0, 1, 0, 1, 3, 8]	5✔
181	index = list(range(len(values1)))	5✔
182	data = [	5✔
183	[
184	[Vector.from_values(index, values1), Vector.from_values(index, values2)],
185	[np.array(values1, dtype=int), np.array(values2, dtype=int)],
186	],
187	[
188	[
189	Vector.from_values(index, values1, dtype="float64"),
190	Vector.from_values(index, values2, dtype="float64"),
191	],
192	[np.array(values1, dtype=np.float64), np.array(values2, dtype=np.float64)],
193	],
194	[
195	[
196	Vector.from_values([0, 1, 2, 3], [True, False, True, False]),
197	Vector.from_values([0, 1, 2, 3], [True, True, False, False]),
198	],
199	[np.array([True, False, True, False]), np.array([True, True, False, False])],
200	],
201	]
202	# Complex monoids not working yet (they segfault upon creation in grblas.operators)
203	# if _supports_complex: # pragma: no branch
204	# data.append(
205	# [
206	# [
207	# Vector.from_values(index, values1, dtype="FC64"),
208	# Vector.from_values(index, values2, dtype="FC64"),
209	# ],
210	# [
211	# np.array(values1, dtype=np.complex128),
212	# np.array(values2, dtype=np.complex128),
213	# ],
214	# ]
215	# )
216	blocklist = {}	5✔
217	reduction_blocklist = {	5✔
218	"BOOL": {"add"},
219	}
220	for (gb_left, gb_right), (np_left, np_right) in data:	5✔
221	for binary_name in sorted(npmonoid._monoid_identities):	5✔
222	op = getattr(npmonoid, binary_name)	5✔
223	assert len(op.types) > 0, op.name	5✔
224	if gb_left.dtype not in op.types or binary_name in blocklist.get(	5✔
225	gb_left.dtype.name, ()
226	):
227	continue	4✔
228	with np.errstate(divide="ignore", over="ignore", under="ignore", invalid="ignore"):	5✔
229	gb_result = gb_left.ewise_mult(gb_right, op).new()	5✔
230	np_result = getattr(np, binary_name)(np_left, np_right)	5✔
231	np_result = Vector.from_values(	5✔
232	np.arange(np_left.size), np_result, dtype=gb_result.dtype
233	)
234	assert gb_result.nvals == np_result.size	5✔
235	match = gb_result.ewise_mult(np_result, npbinary.equal).new()	5✔
236	if gb_result.dtype.name.startswith("F"):	5✔
237	match(accum=grblas.binary.lor) << gb_result.apply(npunary.isnan)	5✔
238	compare = match.reduce(grblas.monoid.land).new()	5✔
239	if not compare: # pragma: no cover
240	print(binary_name, gb_left.dtype)
241	print(compute(gb_result))
242	print(np_result)
243	assert compare	5✔
244
245	# numpy reductions don't have dtype-dependent identities, so results sometimes differ
246	if binary_name in reduction_blocklist.get(gb_left.dtype.name, ()):	5✔
247	continue	3✔
248
249	gb_result = gb_left.reduce(op).new()	5✔
250	np_result = getattr(np, binary_name).reduce(np_left)	5✔
251	assert gb_result.value == np_result	5✔
252
253	gb_result = gb_right.reduce(op).new()	5✔
254	np_result = getattr(np, binary_name).reduce(np_right)	5✔
255	assert gb_result.value == np_result	5✔
256
257
258	@pytest.mark.slow	15✔
259	def test_npsemiring():	15✔
260	for monoid_name, binary_name in itertools.product(	5✔
261	sorted(npmonoid._monoid_identities), sorted(npbinary._binary_names)
262	):
263	monoid = getattr(npmonoid, monoid_name)	5✔
264	binary = getattr(npbinary, binary_name)	5✔
265	name = monoid.name.split(".")[-1] + "_" + binary.name.split(".")[-1]	5✔
266	if name in {"eq_pow", "eq_minus"}:	5✔
267	continue	4✔
268	semiring = grblas.operator.Semiring.register_anonymous(monoid, binary, name)	5✔
269	if len(semiring.types) == 0:	5✔
270	if not grblas.config["mapnumpy"] and "logical" not in name:	5✔
271	assert not hasattr(npsemiring, semiring.name), name	3✔
272	else:
273	assert hasattr(npsemiring, f"{monoid_name}_{binary_name}"), (name, semiring.name)	5✔

metagraph-dev / grblas / 2156400673

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous