818074539

Build Type

github

Committed by GitHub

Commit Message

Merge 2c7cf32d4 into 93e37c4d7

Pull Request Pull Request #87: Add Aggregators (WIP)!

Run Details

1723 of 1770 branches covered (97.34%)

Branch coverage included in aggregate %.

594 of 631 new or added lines in 14 files covered. (94.14%)

3 existing lines in 3 files now uncovered.

8152 of 8212 relevant lines covered (99.27%)

10.37 hits per line

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

60.19

/grblas/tests/test_operator_types.py

import itertools
from collections import defaultdict
from grblas import dtypes, unary, binary, monoid, semiring, operator

BOOL = frozenset({"BOOL"})
UINT = frozenset({"UINT8", "UINT16", "UINT32", "UINT64"})
INT = frozenset({"INT8", "INT16", "INT32", "INT64", "UINT8", "UINT16", "UINT32", "UINT64"})
FP = frozenset({"FP32", "FP64"})
FPINT = frozenset(FP | INT)
NOFC = frozenset(BOOL | FPINT)
if dtypes._supports_complex:
    FC = frozenset({"FC32", "FC64"})
else:
    FC = frozenset()
FCFP = frozenset(FC | FP)
ALL = frozenset(NOFC | FC)
POS = frozenset({"INT32", "INT64"})
NOBOOL = frozenset(ALL - BOOL)

# fmt: off
UNARY = {
    (ALL, ALL): {"ainv", "identity", "minv", "one"},
    (ALL, FCFP): {
        "acos", "acosh", "asin", "asinh", "atan", "atanh", "ceil", "cos", "cosh", "exp",
        "exp2", "expm1", "floor", "log", "log10", "log1p", "log2", "round", "signum",
        "sin", "sinh", "sqrt", "tan", "tanh", "trunc",
    },
    (ALL, NOFC): {"abs"},
    (ALL, POS): {"positioni", "positioni1", "positionj", "positionj1"},
    (FCFP, BOOL): {"isfinite", "isinf", "isnan"},
    (FC, FC): {"conj"},
    (FC, FP): {"carg", "cimag", "creal"},
    (FP, FP): {"frexpe", "frexpx"},
    (INT, INT): {"bnot"},
    (NOFC, FP): {"erf", "erfc", "lgamma", "tgamma"},
    (NOFC, NOFC): {"lnot"},
}
BINARY = {
    (ALL, ALL): {
        "any", "cdiv", "first", "iseq", "isne", "minus", "pair", "plus", "pow", "rdiv",
        "rminus", "second", "times",
    },
    (ALL, BOOL): {"eq", "ne"},
    (ALL, FP): {"truediv"},
    (ALL, POS): {
        "firsti", "firsti1", "firstj", "firstj1", "secondi", "secondi1", "secondj", "secondj1",
    },
    (INT, INT): {"band", "bclr", "bget", "bor", "bset", "bshift", "bxnor", "bxor"},
    (NOFC, BOOL): {"ge", "gt", "land", "le", "lor", "lt", "lxnor", "lxor"},
    # (NOFC, BOOL): {"lxnor"},
    (NOFC, FC): {"cmplx"},
    (NOFC, FP): {"atan2", "copysign", "fmod", "hypot", "ldexp", "remainder"},
    (NOFC, FPINT): {"floordiv"},
    (NOFC, NOFC): {"isge", "isgt", "isle", "islt", "max", "min"},
}
MONOID = {
    (UINT, UINT): {"band", "bor", "bxnor", "bxor"},
    (BOOL, BOOL): {"eq", "land", "lor", "lxnor", "lxor"},
    (FPINT, FPINT): {"max", "min"},  # max[bool] -> lor, min[bool] -> land
    (NOBOOL, NOBOOL): {"plus", "times"},  # plus[bool] -> lor, times[bool] -> land
    (ALL, ALL): {"any"},
}

_SEMIRING1 = {
    (ALL, ALL): [
        {"any"},
        {"first", "pair", "second"},
    ],
    (ALL, FP): [
        {"any", "max", "min", "plus", "times"},
        {"truediv"},
    ],
    (ALL, POS): [  # POS, extra->INT64
        {"any", "max", "min", "plus", "times"},
        {"firsti", "firsti1", "firstj", "firstj1", "secondi", "secondi1", "secondj", "secondj1"},
    ],
    (ALL, BOOL): [  # BOOL, extra->BOOL
        {"eq", "land", "lor", "lxnor", "lxor"},
        {"first", "pair", "second"},
    ],
    (NOFC, BOOL): [  # BOOL, extra->BOOL, can't coerce FC here
        # BOOL `*_ne` uses `*_lxor`
        {"any", "eq", "land", "lor", "lxnor", "lxor"},
        {"eq", "land", "lor", "lxor", "ne", "ge", "gt", "le", "lt"},
    ],
    (FPINT, FPINT): [
        # Some of these are superseded by (ALL, ALL)
        # We could cast BOOL to INT8
        {"any", "max", "min", "plus", "times"},
        {
            "cdiv", "first", "iseq", "isge", "isgt", "isle", "islt", "isne", "land", "lor",
            "lxor", "max", "min", "minus", "pair", "plus", "rdiv", "rminus", "second", "times",
        },
    ],
    (INT, UINT): [  # signed int -> next larger unsigned int
        {"band", "bor", "bxnor", "bxor"},
        {"band", "bor", "bxnor", "bxor"},
    ],
    (NOBOOL, NOBOOL): [
        # Some of these are superseded by (ALL, ALL)
        # We could cast BOOL to INT8
        {"any", "plus", "times"},
        {"cdiv", "first", "minus", "pair", "plus", "pow", "rdiv", "rminus", "second", "times"},
    ],
    (NOFC, FPINT): [
        {"any", "max", "min", "plus", "times"},
        {"floordiv"},
    ],
    (NOFC, NOFC): [
        {"any"},
        {"land", "lor", "lxor"},
    ],
}
# fmt: on
_SEMIRING2 = defaultdict(lambda: (set(), set()))  # {semiring: [input_types, output_types]}
for key, (leftvals, rightvals) in _SEMIRING1.items():
    for left, right in itertools.product(leftvals, rightvals):
        name = f"{left}_{right}"
        if not hasattr(semiring, name):
            continue
        _SEMIRING2[name][0].update(key[0])
        _SEMIRING2[name][1].update(key[1])

SEMIRING = defaultdict(set)
for name, (ins, outs) in _SEMIRING2.items():
    SEMIRING[(frozenset(ins), frozenset(outs))].add(name)
IGNORE = {
    # UDFs created during tests
    "is_positive",
    "plus_one",
    "bin_test_func",
    "plus_plus_one",
    "plus_plus_two",
    "extra_twos",
}


def _run_test(module, typ, expected):
    seen = defaultdict(set)
    for name, val in vars(module).items():
        if not isinstance(val, typ) or name in IGNORE:
            continue
        key = (frozenset(val.types.keys()), frozenset(val.types.values()))
        seen[key].add(name)
    seen = dict(seen)
    if seen != expected:
        seen_names = set()
        for names in seen.values():
            seen_names.update(names)
        expected_names = set()
        for names in expected.values():
            expected_names.update(names)
        extra = seen_names - expected_names
        if extra:
            raise AssertionError("grblas has more than expected:", sorted(extra))
        missing = expected_names - seen_names
        if missing:
            raise AssertionError("grblas has less than expected:", sorted(missing))

        for key in sorted(seen.keys() - expected.keys()):
            print(
                "Item not expected: (%s, %s): %s"
                % (sorted(key[0]), sorted(key[1]), sorted(seen[key]))
            )
        for key in sorted(expected.keys() - seen.keys()):
            print(
                "Item expected, but not seen: (%s, %s): %s"
                % (sorted(key[0]), sorted(key[1]), sorted(expected[key]))
            )
        for key in sorted(expected.keys() & seen.keys()):
            if expected[key] != seen[key]:
                print("Bad match:", sorted(key[0]), sorted(key[1]))
                extra = seen[key] - expected[key]
                if extra:
                    print("    Extra:", sorted(extra))
                missing = expected[key] - seen[key]
                if missing:
                    print("    Missing:", sorted(missing))
        assert seen == expected


def test_unarytypes():
    _run_test(unary, operator.UnaryOp, UNARY)


def test_binarytypes():
    _run_test(binary, operator.BinaryOp, BINARY)


def test_monoid_types():
    _run_test(monoid, operator.Monoid, MONOID)


def test_semiring_types():
    _run_test(semiring, operator.Semiring, SEMIRING)

1	import itertools	11✔
2	from collections import defaultdict	11✔
3	from grblas import dtypes, unary, binary, monoid, semiring, operator	11✔
4
5	BOOL = frozenset({"BOOL"})	11✔
6	UINT = frozenset({"UINT8", "UINT16", "UINT32", "UINT64"})	11✔
7	INT = frozenset({"INT8", "INT16", "INT32", "INT64", "UINT8", "UINT16", "UINT32", "UINT64"})	11✔
8	FP = frozenset({"FP32", "FP64"})	11✔
9	FPINT = frozenset(FP \| INT)	11✔
10	NOFC = frozenset(BOOL \| FPINT)	11✔
11	if dtypes._supports_complex:	11!
12	FC = frozenset({"FC32", "FC64"})	11✔
13	else:
NEW 14	FC = frozenset()	×
15	FCFP = frozenset(FC \| FP)	11✔
16	ALL = frozenset(NOFC \| FC)	11✔
17	POS = frozenset({"INT32", "INT64"})	11✔
18	NOBOOL = frozenset(ALL - BOOL)	11✔
19
20	# fmt: off
21	UNARY = {	11✔
22	(ALL, ALL): {"ainv", "identity", "minv", "one"},
23	(ALL, FCFP): {
24	"acos", "acosh", "asin", "asinh", "atan", "atanh", "ceil", "cos", "cosh", "exp",
25	"exp2", "expm1", "floor", "log", "log10", "log1p", "log2", "round", "signum",
26	"sin", "sinh", "sqrt", "tan", "tanh", "trunc",
27	},
28	(ALL, NOFC): {"abs"},
29	(ALL, POS): {"positioni", "positioni1", "positionj", "positionj1"},
30	(FCFP, BOOL): {"isfinite", "isinf", "isnan"},
31	(FC, FC): {"conj"},
32	(FC, FP): {"carg", "cimag", "creal"},
33	(FP, FP): {"frexpe", "frexpx"},
34	(INT, INT): {"bnot"},
35	(NOFC, FP): {"erf", "erfc", "lgamma", "tgamma"},
36	(NOFC, NOFC): {"lnot"},
37	}
38	BINARY = {	11✔
39	(ALL, ALL): {
40	"any", "cdiv", "first", "iseq", "isne", "minus", "pair", "plus", "pow", "rdiv",
41	"rminus", "second", "times",
42	},
43	(ALL, BOOL): {"eq", "ne"},
44	(ALL, FP): {"truediv"},
45	(ALL, POS): {
46	"firsti", "firsti1", "firstj", "firstj1", "secondi", "secondi1", "secondj", "secondj1",
47	},
48	(INT, INT): {"band", "bclr", "bget", "bor", "bset", "bshift", "bxnor", "bxor"},
49	(NOFC, BOOL): {"ge", "gt", "land", "le", "lor", "lt", "lxnor", "lxor"},
50	# (NOFC, BOOL): {"lxnor"},
51	(NOFC, FC): {"cmplx"},
52	(NOFC, FP): {"atan2", "copysign", "fmod", "hypot", "ldexp", "remainder"},
53	(NOFC, FPINT): {"floordiv"},
54	(NOFC, NOFC): {"isge", "isgt", "isle", "islt", "max", "min"},
55	}
56	MONOID = {	11✔
57	(UINT, UINT): {"band", "bor", "bxnor", "bxor"},
58	(BOOL, BOOL): {"eq", "land", "lor", "lxnor", "lxor"},
59	(FPINT, FPINT): {"max", "min"}, # max[bool] -> lor, min[bool] -> land
60	(NOBOOL, NOBOOL): {"plus", "times"}, # plus[bool] -> lor, times[bool] -> land
61	(ALL, ALL): {"any"},
62	}
63
64	_SEMIRING1 = {	11✔
65	(ALL, ALL): [
66	{"any"},
67	{"first", "pair", "second"},
68	],
69	(ALL, FP): [
70	{"any", "max", "min", "plus", "times"},
71	{"truediv"},
72	],
73	(ALL, POS): [ # POS, extra->INT64
74	{"any", "max", "min", "plus", "times"},
75	{"firsti", "firsti1", "firstj", "firstj1", "secondi", "secondi1", "secondj", "secondj1"},
76	],
77	(ALL, BOOL): [ # BOOL, extra->BOOL
78	{"eq", "land", "lor", "lxnor", "lxor"},
79	{"first", "pair", "second"},
80	],
81	(NOFC, BOOL): [ # BOOL, extra->BOOL, can't coerce FC here
82	# BOOL `_ne` uses `_lxor`
83	{"any", "eq", "land", "lor", "lxnor", "lxor"},
84	{"eq", "land", "lor", "lxor", "ne", "ge", "gt", "le", "lt"},
85	],
86	(FPINT, FPINT): [
87	# Some of these are superseded by (ALL, ALL)
88	# We could cast BOOL to INT8
89	{"any", "max", "min", "plus", "times"},
90	{
91	"cdiv", "first", "iseq", "isge", "isgt", "isle", "islt", "isne", "land", "lor",
92	"lxor", "max", "min", "minus", "pair", "plus", "rdiv", "rminus", "second", "times",
93	},
94	],
95	(INT, UINT): [ # signed int -> next larger unsigned int
96	{"band", "bor", "bxnor", "bxor"},
97	{"band", "bor", "bxnor", "bxor"},
98	],
99	(NOBOOL, NOBOOL): [
100	# Some of these are superseded by (ALL, ALL)
101	# We could cast BOOL to INT8
102	{"any", "plus", "times"},
103	{"cdiv", "first", "minus", "pair", "plus", "pow", "rdiv", "rminus", "second", "times"},
104	],
105	(NOFC, FPINT): [
106	{"any", "max", "min", "plus", "times"},
107	{"floordiv"},
108	],
109	(NOFC, NOFC): [
110	{"any"},
111	{"land", "lor", "lxor"},
112	],
113	}
114	# fmt: on
115	_SEMIRING2 = defaultdict(lambda: (set(), set())) # {semiring: [input_types, output_types]}	11✔
116	for key, (leftvals, rightvals) in _SEMIRING1.items():	11✔
117	for left, right in itertools.product(leftvals, rightvals):	11✔
118	name = f"{left}_{right}"	11✔
119	if not hasattr(semiring, name):	11✔
120	continue	11✔
121	_SEMIRING2[name][0].update(key[0])	11✔
122	_SEMIRING2[name][1].update(key[1])	11✔
123
124	SEMIRING = defaultdict(set)	11✔
125	for name, (ins, outs) in _SEMIRING2.items():	11✔
126	SEMIRING[(frozenset(ins), frozenset(outs))].add(name)	11✔
127	IGNORE = {	11✔
128	# UDFs created during tests
129	"is_positive",
130	"plus_one",
131	"bin_test_func",
132	"plus_plus_one",
133	"plus_plus_two",
134	"extra_twos",
135	}
136
137
138	def _run_test(module, typ, expected):	11✔
139	seen = defaultdict(set)	11✔
140	for name, val in vars(module).items():	11✔
141	if not isinstance(val, typ) or name in IGNORE:	11✔
142	continue	11✔
143	key = (frozenset(val.types.keys()), frozenset(val.types.values()))	11✔
144	seen[key].add(name)	11✔
145	seen = dict(seen)	11✔
146	if seen != expected:	11!
NEW 147	seen_names = set()	×
NEW 148	for names in seen.values():	×
NEW 149	seen_names.update(names)	×
NEW 150	expected_names = set()	×
NEW 151	for names in expected.values():	×
NEW 152	expected_names.update(names)	×
NEW 153	extra = seen_names - expected_names	×
NEW 154	if extra:	×
155	raise AssertionError("grblas has more than expected:", sorted(extra))
NEW 156	missing = expected_names - seen_names	×
NEW 157	if missing:	×
158	raise AssertionError("grblas has less than expected:", sorted(missing))
159
NEW 160	for key in sorted(seen.keys() - expected.keys()):	×
NEW 161	print(	×
162	"Item not expected: (%s, %s): %s"
163	% (sorted(key[0]), sorted(key[1]), sorted(seen[key]))
164	)
NEW 165	for key in sorted(expected.keys() - seen.keys()):	×
NEW 166	print(	×
167	"Item expected, but not seen: (%s, %s): %s"
168	% (sorted(key[0]), sorted(key[1]), sorted(expected[key]))
169	)
NEW 170	for key in sorted(expected.keys() & seen.keys()):	×
NEW 171	if expected[key] != seen[key]:	×
NEW 172	print("Bad match:", sorted(key[0]), sorted(key[1]))	×
NEW 173	extra = seen[key] - expected[key]	×
NEW 174	if extra:	×
NEW 175	print(" Extra:", sorted(extra))	×
NEW 176	missing = expected[key] - seen[key]	×
NEW 177	if missing:	×
NEW 178	print(" Missing:", sorted(missing))	×
NEW 179	assert seen == expected	×
180
181
182	def test_unarytypes():	11✔
183	_run_test(unary, operator.UnaryOp, UNARY)	11✔
184
185
186	def test_binarytypes():	11✔
187	_run_test(binary, operator.BinaryOp, BINARY)	11✔
188
189
190	def test_monoid_types():	11✔
191	_run_test(monoid, operator.Monoid, MONOID)	11✔
192
193
194	def test_semiring_types():	11✔
195	_run_test(semiring, operator.Semiring, SEMIRING)	11✔

metagraph-dev / grblas / 818074539

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