2157701692

Build Type

github

Committed by GitHub

Commit Message

Merge 3f8205145 into b576aacf2

Pull Request Pull Request #208: Run pytests randomly using `pytest-randomly` to search for segfaults

Run Details

4598 of 4703 branches covered (97.77%)

Branch coverage included in aggregate %.

38 of 38 new or added lines in 6 files covered. (100.0%)

11 existing lines in 4 files now uncovered.

14962 of 14982 relevant lines covered (99.87%)

9.32 hits per line

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

96.15

/graphblas/monoid/numpy.py

""" Create UDFs of numpy functions supported by numba.

See list of numpy ufuncs supported by numpy here:

https://numba.pydata.org/numba-doc/dev/reference/numpysupported.html#math-operations

"""
import numpy as _np

from .. import binary as _binary
from .. import config as _config
from .. import monoid as _monoid
from .. import operator as _operator
from ..dtypes import _supports_complex

_delayed = {}
_complex_dtypes = {"FC32", "FC64"}
_float_dtypes = {"FP32", "FP64"}
_int_dtypes = {"INT8", "UINT8", "INT16", "UINT16", "INT32", "UINT32", "INT64", "UINT64"}
_bool_int_dtypes = _int_dtypes | {"BOOL"}

_monoid_identities = {
    # Math operations
    "add": 0,
    "multiply": 1,
    "logaddexp": dict.fromkeys(_float_dtypes, -_np.inf),
    "logaddexp2": dict.fromkeys(_float_dtypes, -_np.inf),
    "gcd": dict.fromkeys(_int_dtypes, 0),
    # Trigonometric functions
    "hypot": dict.fromkeys(_float_dtypes, 0.0),
    # Bit-twiddling functions
    "bitwise_and": {dtype: True if dtype == "BOOL" else -1 for dtype in _bool_int_dtypes},
    "bitwise_or": dict.fromkeys(_bool_int_dtypes, 0),
    "bitwise_xor": dict.fromkeys(_bool_int_dtypes, 0),
    # Comparison functions
    "equal": {"BOOL": True},
    "logical_and": {"BOOL": True},
    "logical_or": {"BOOL": True},
    "logical_xor": {"BOOL": False},
    "maximum": {
        "BOOL": False,
        "INT8": _np.iinfo(_np.int8).min,
        "UINT8": 0,
        "INT16": _np.iinfo(_np.int16).min,
        "UINT16": 0,
        "INT32": _np.iinfo(_np.int32).min,
        "UINT32": 0,
        "INT64": _np.iinfo(_np.int64).min,
        "UINT64": 0,
        "FP32": -_np.inf,
        "FP64": -_np.inf,
    },
    "minimum": {
        "BOOL": True,
        "INT8": _np.iinfo(_np.int8).max,
        "UINT8": _np.iinfo(_np.uint8).max,
        "INT16": _np.iinfo(_np.int16).max,
        "UINT16": _np.iinfo(_np.uint16).max,
        "INT32": _np.iinfo(_np.int32).max,
        "UINT32": _np.iinfo(_np.uint32).max,
        "INT64": _np.iinfo(_np.int64).max,
        "UINT64": _np.iinfo(_np.uint64).max,
        "FP32": _np.inf,
        "FP64": _np.inf,
    },
    "fmax": {
        "BOOL": False,
        "INT8": _np.iinfo(_np.int8).min,
        "UINT8": 0,
        "INT16": _np.iinfo(_np.int8).min,
        "UINT16": 0,
        "INT32": _np.iinfo(_np.int8).min,
        "UINT32": 0,
        "INT64": _np.iinfo(_np.int8).min,
        "UINT64": 0,
        "FP32": -_np.inf,  # or _np.nan?
        "FP64": -_np.inf,  # or _np.nan?
    },
    "fmin": {
        "BOOL": True,
        "INT8": _np.iinfo(_np.int8).max,
        "UINT8": _np.iinfo(_np.uint8).max,
        "INT16": _np.iinfo(_np.int16).max,
        "UINT16": _np.iinfo(_np.uint16).max,
        "INT32": _np.iinfo(_np.int32).max,
        "UINT32": _np.iinfo(_np.uint32).max,
        "INT64": _np.iinfo(_np.int64).max,
        "UINT64": _np.iinfo(_np.uint64).max,
        "FP32": _np.inf,  # or _np.nan?
        "FP64": _np.inf,  # or _np.nan?
    },
}
if _supports_complex:
    _monoid_identities["fmax"].update(dict.fromkeys(_complex_dtypes, complex(-_np.inf, -_np.inf)))
    _monoid_identities["fmin"].update(dict.fromkeys(_complex_dtypes, complex(_np.inf, _np.inf)))
    _monoid_identities["maximum"].update(
        dict.fromkeys(_complex_dtypes, complex(-_np.inf, -_np.inf))
    )
    _monoid_identities["minimum"].update(dict.fromkeys(_complex_dtypes, complex(_np.inf, _np.inf)))

_operator._STANDARD_OPERATOR_NAMES.update(f"monoid.numpy.{name}" for name in _monoid_identities)
__all__ = list(_monoid_identities)
_numpy_to_graphblas = {
    "add": "plus",
    "bitwise_and": "band",
    "bitwise_or": "bor",
    "bitwise_xor": "bxor",
    "equal": "eq",
    "fmax": "max",  # ignores nan
    "fmin": "min",  # ignores nan
    "logical_and": "land",
    "logical_or": "lor",
    "logical_xor": "lxor",
    "multiply": "times",
}
# _graphblas_to_numpy = {val: key for key, val in _numpy_to_graphblas.items()}  # Soon...
# Not included: maximum, minimum, gcd, hypot, logaddexp, logaddexp2


def __dir__():
    return globals().keys() | _delayed.keys() | _monoid_identities.keys()


def __getattr__(name):
    if name in _delayed:
        func, kwargs = _delayed.pop(name)
        if type(kwargs["binaryop"]) is str:
            from ..binary import from_string

            kwargs["binaryop"] = from_string(kwargs["binaryop"])
        rv = func(**kwargs)
        globals()[name] = rv
        return rv
    if name not in _monoid_identities:
        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
    if _config.get("mapnumpy") and name in _numpy_to_graphblas:
        globals()[name] = getattr(_monoid, _numpy_to_graphblas[name])
    else:
        func = getattr(_binary.numpy, name)
        _operator.Monoid.register_new(f"numpy.{name}", func, _monoid_identities[name])
    return globals()[name]

1	""" Create UDFs of numpy functions supported by numba.
2
3	See list of numpy ufuncs supported by numpy here:
4
5	https://numba.pydata.org/numba-doc/dev/reference/numpysupported.html#math-operations
6
7	"""
8	import numpy as _np	10✔
9
10	from .. import binary as _binary	10✔
11	from .. import config as _config	10✔
12	from .. import monoid as _monoid	10✔
13	from .. import operator as _operator	10✔
14	from ..dtypes import _supports_complex	10✔
15
16	_delayed = {}	10✔
17	_complex_dtypes = {"FC32", "FC64"}	10✔
18	_float_dtypes = {"FP32", "FP64"}	10✔
19	_int_dtypes = {"INT8", "UINT8", "INT16", "UINT16", "INT32", "UINT32", "INT64", "UINT64"}	10✔
20	_bool_int_dtypes = _int_dtypes \| {"BOOL"}	10✔
21
22	_monoid_identities = {	10✔
23	# Math operations
24	"add": 0,
25	"multiply": 1,
26	"logaddexp": dict.fromkeys(_float_dtypes, -_np.inf),
27	"logaddexp2": dict.fromkeys(_float_dtypes, -_np.inf),
28	"gcd": dict.fromkeys(_int_dtypes, 0),
29	# Trigonometric functions
30	"hypot": dict.fromkeys(_float_dtypes, 0.0),
31	# Bit-twiddling functions
32	"bitwise_and": {dtype: True if dtype == "BOOL" else -1 for dtype in _bool_int_dtypes},
33	"bitwise_or": dict.fromkeys(_bool_int_dtypes, 0),
34	"bitwise_xor": dict.fromkeys(_bool_int_dtypes, 0),
35	# Comparison functions
36	"equal": {"BOOL": True},
37	"logical_and": {"BOOL": True},
38	"logical_or": {"BOOL": True},
39	"logical_xor": {"BOOL": False},
40	"maximum": {
41	"BOOL": False,
42	"INT8": _np.iinfo(_np.int8).min,
43	"UINT8": 0,
44	"INT16": _np.iinfo(_np.int16).min,
45	"UINT16": 0,
46	"INT32": _np.iinfo(_np.int32).min,
47	"UINT32": 0,
48	"INT64": _np.iinfo(_np.int64).min,
49	"UINT64": 0,
50	"FP32": -_np.inf,
51	"FP64": -_np.inf,
52	},
53	"minimum": {
54	"BOOL": True,
55	"INT8": _np.iinfo(_np.int8).max,
56	"UINT8": _np.iinfo(_np.uint8).max,
57	"INT16": _np.iinfo(_np.int16).max,
58	"UINT16": _np.iinfo(_np.uint16).max,
59	"INT32": _np.iinfo(_np.int32).max,
60	"UINT32": _np.iinfo(_np.uint32).max,
61	"INT64": _np.iinfo(_np.int64).max,
62	"UINT64": _np.iinfo(_np.uint64).max,
63	"FP32": _np.inf,
64	"FP64": _np.inf,
65	},
66	"fmax": {
67	"BOOL": False,
68	"INT8": _np.iinfo(_np.int8).min,
69	"UINT8": 0,
70	"INT16": _np.iinfo(_np.int8).min,
71	"UINT16": 0,
72	"INT32": _np.iinfo(_np.int8).min,
73	"UINT32": 0,
74	"INT64": _np.iinfo(_np.int8).min,
75	"UINT64": 0,
76	"FP32": -_np.inf, # or _np.nan?
77	"FP64": -_np.inf, # or _np.nan?
78	},
79	"fmin": {
80	"BOOL": True,
81	"INT8": _np.iinfo(_np.int8).max,
82	"UINT8": _np.iinfo(_np.uint8).max,
83	"INT16": _np.iinfo(_np.int16).max,
84	"UINT16": _np.iinfo(_np.uint16).max,
85	"INT32": _np.iinfo(_np.int32).max,
86	"UINT32": _np.iinfo(_np.uint32).max,
87	"INT64": _np.iinfo(_np.int64).max,
88	"UINT64": _np.iinfo(_np.uint64).max,
89	"FP32": _np.inf, # or _np.nan?
90	"FP64": _np.inf, # or _np.nan?
91	},
92	}
93	if _supports_complex:	10✔
94	_monoid_identities["fmax"].update(dict.fromkeys(_complex_dtypes, complex(-_np.inf, -_np.inf)))	6✔
95	_monoid_identities["fmin"].update(dict.fromkeys(_complex_dtypes, complex(_np.inf, _np.inf)))	6✔
96	_monoid_identities["maximum"].update(	6✔
97	dict.fromkeys(_complex_dtypes, complex(-_np.inf, -_np.inf))
98	)
99	_monoid_identities["minimum"].update(dict.fromkeys(_complex_dtypes, complex(_np.inf, _np.inf)))	6✔
100
101	_operator._STANDARD_OPERATOR_NAMES.update(f"monoid.numpy.{name}" for name in _monoid_identities)	10✔
102	__all__ = list(_monoid_identities)	10✔
103	_numpy_to_graphblas = {	10✔
104	"add": "plus",
105	"bitwise_and": "band",
106	"bitwise_or": "bor",
107	"bitwise_xor": "bxor",
108	"equal": "eq",
109	"fmax": "max", # ignores nan
110	"fmin": "min", # ignores nan
111	"logical_and": "land",
112	"logical_or": "lor",
113	"logical_xor": "lxor",
114	"multiply": "times",
115	}
116	# _graphblas_to_numpy = {val: key for key, val in _numpy_to_graphblas.items()} # Soon...
117	# Not included: maximum, minimum, gcd, hypot, logaddexp, logaddexp2
118
119
120	def __dir__():	10✔
121	return globals().keys() \| _delayed.keys() \| _monoid_identities.keys()	10✔
122
123
124	def __getattr__(name):	10✔
125	if name in _delayed:	10✔
126	func, kwargs = _delayed.pop(name)	2✔
127	if type(kwargs["binaryop"]) is str:	2✔
128	from ..binary import from_string	2✔
129
130	kwargs["binaryop"] = from_string(kwargs["binaryop"])	2✔
131	rv = func(**kwargs)	2✔
132	globals()[name] = rv	2✔
133	return rv	2✔
134	if name not in _monoid_identities:	10✔
135	raise AttributeError(f"module {__name__!r} has no attribute {name!r}")	10✔
136	if _config.get("mapnumpy") and name in _numpy_to_graphblas:	2!
UNCOV 137	globals()[name] = getattr(_monoid, _numpy_to_graphblas[name])	×
138	else:
139	func = getattr(_binary.numpy, name)	2✔
140	_operator.Monoid.register_new(f"numpy.{name}", func, _monoid_identities[name])	2✔
141	return globals()[name]	2✔

metagraph-dev / grblas / 2157701692

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