2009978378

Build # 2009978378

Build Type

github

Committed by GitHub

Commit Message

Merge f760508ba into 7dd54fd2f

Pull Request Pull Request #185: Investigate #184 by running on more OSes.

Run Details

4207 of 4318 branches covered (97.43%)

Branch coverage included in aggregate %.

44 of 51 new or added lines in 12 files covered. (86.27%)

71 existing lines in 11 files now uncovered.

13662 of 13740 relevant lines covered (99.43%)

6.46 hits per line

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

93.38

/grblas/dtypes.py

import numba
import numpy as np
from numpy import find_common_type, promote_types

from . import lib

# Default assumption unless FC32/FC64 are found in lib
_supports_complex = hasattr(lib, "GrB_FC64") or hasattr(lib, "GxB_FC64")


class DataType:
    __slots__ = "name", "gb_obj", "gb_name", "c_type", "numba_type", "np_type", "__weakref__"

    def __init__(self, name, gb_obj, gb_name, c_type, numba_type, np_type):
        self.name = name
        self.gb_obj = gb_obj
        self.gb_name = gb_name
        self.c_type = c_type
        self.numba_type = numba_type
        self.np_type = np_type

    def __repr__(self):
        return self.name

    def __eq__(self, other):
        if type(other) is DataType:
            return self.gb_obj == other.gb_obj
        else:
            # Attempt to use `other` as a lookup key
            try:
                other = lookup_dtype(other)
                return self == other
            except ValueError:
                raise TypeError(f"Invalid or unknown datatype: {other}") from None

    def __reduce__(self):
        if self.gb_name == "GrB_Index":
            return "_INDEX"
        return self.name

    @property
    def _carg(self):
        return self.gb_obj


BOOL = DataType("BOOL", lib.GrB_BOOL, "GrB_BOOL", "_Bool", numba.types.bool_, np.bool_)
INT8 = DataType("INT8", lib.GrB_INT8, "GrB_INT8", "int8_t", numba.types.int8, np.int8)
UINT8 = DataType("UINT8", lib.GrB_UINT8, "GrB_UINT8", "uint8_t", numba.types.uint8, np.uint8)
INT16 = DataType("INT16", lib.GrB_INT16, "GrB_INT16", "int16_t", numba.types.int16, np.int16)
UINT16 = DataType("UINT16", lib.GrB_UINT16, "GrB_UINT16", "uint16_t", numba.types.uint16, np.uint16)
INT32 = DataType("INT32", lib.GrB_INT32, "GrB_INT32", "int32_t", numba.types.int32, np.int32)
UINT32 = DataType("UINT32", lib.GrB_UINT32, "GrB_UINT32", "uint32_t", numba.types.uint32, np.uint32)
INT64 = DataType("INT64", lib.GrB_INT64, "GrB_INT64", "int64_t", numba.types.int64, np.int64)
# _Index (like UINT64) is for internal use only and shouldn't be exposed to the user
_INDEX = DataType("UINT64", lib.GrB_UINT64, "GrB_Index", "GrB_Index", numba.types.uint64, np.uint64)
UINT64 = DataType("UINT64", lib.GrB_UINT64, "GrB_UINT64", "uint64_t", numba.types.uint64, np.uint64)
FP32 = DataType("FP32", lib.GrB_FP32, "GrB_FP32", "float", numba.types.float32, np.float32)
FP64 = DataType("FP64", lib.GrB_FP64, "GrB_FP64", "double", numba.types.float64, np.float64)

if _supports_complex and hasattr(lib, "GxB_FC32"):
    FC32 = DataType(
        "FC32", lib.GxB_FC32, "GxB_FC32", "float _Complex", numba.types.complex64, np.complex64
    )
if _supports_complex and hasattr(lib, "GrB_FC32"):  # pragma: no coverage
    FC32 = DataType(
        "FC32", lib.GrB_FC32, "GrB_FC32", "float _Complex", numba.types.complex64, np.complex64
    )
if _supports_complex and hasattr(lib, "GxB_FC64"):
    FC64 = DataType(
        "FC64", lib.GxB_FC64, "GxB_FC64", "double _Complex", numba.types.complex128, np.complex128
    )
if _supports_complex and hasattr(lib, "GrB_FC64"):  # pragma: no coverage
    FC64 = DataType(
        "FC64", lib.GrB_FC64, "GrB_FC64", "double _Complex", numba.types.complex128, np.complex128
    )

# Used for testing user-defined functions
_sample_values = {
    INT8.name: np.int8(1),
    UINT8.name: np.uint8(1),
    INT16.name: np.int16(1),
    UINT16.name: np.uint16(1),
    INT32.name: np.int32(1),
    UINT32.name: np.uint32(1),
    INT64.name: np.int64(1),
    UINT64.name: np.uint64(1),
    FP32.name: np.float32(0.5),
    FP64.name: np.float64(0.5),
    BOOL.name: np.bool_(True),
}
if _supports_complex:
    _sample_values.update(
        {
            FC32.name: np.complex64(complex(0, 0.5)),
            FC64.name: np.complex128(complex(0, 0.5)),
        }
    )

# Create register to easily lookup types by name, gb_obj, or c_type
_registry = {}
_dtypes_to_register = [
    BOOL,
    INT8,
    UINT8,
    INT16,
    UINT16,
    INT32,
    UINT32,
    INT64,
    UINT64,
    FP32,
    FP64,
]
if _supports_complex:
    _dtypes_to_register.extend([FC32, FC64])

for dtype in _dtypes_to_register:
    _registry[dtype.name] = dtype
    _registry[dtype.name.lower()] = dtype
    _registry[dtype.gb_obj] = dtype
    _registry[dtype.gb_name] = dtype
    _registry[dtype.gb_name.lower()] = dtype
    _registry[dtype.c_type] = dtype
    _registry[dtype.c_type.upper()] = dtype
    _registry[dtype.numba_type] = dtype
    _registry[dtype.numba_type.name] = dtype
    val = _sample_values[dtype.name]
    _registry[val.dtype] = dtype
    _registry[val.dtype.name] = dtype
# Upcast numpy float16 to float32
_registry[np.dtype(np.float16)] = FP32
_registry["float16"] = FP32

# Add some common Python types as lookup keys
_registry[bool] = BOOL
_registry[int] = INT64
_registry[float] = FP64
_registry["bool"] = BOOL
_registry["int"] = INT64
_registry["float"] = FP64  # Choose 'float' to match numpy/Python; c_type 'float' would be FP32
if _supports_complex:
    _registry[complex] = FC64
    _registry["complex"] = FC64


def lookup_dtype(key):
    # Check for silly lookup where key is already a DataType
    if type(key) is DataType:
        return key
    try:
        return _registry[key]
    except KeyError:
        pass
    if hasattr(key, "name"):
        try:
            return _registry[key.name]
        except KeyError:
            pass
    try:
        return lookup_dtype(np.dtype(key))
    except Exception:
        pass
    raise ValueError(f"Unknown dtype: {key}")


def unify(type1, type2, *, is_left_scalar=False, is_right_scalar=False):
    """
    Returns a type that can hold both type1 and type2

    For example:
    unify(INT32, INT64) -> INT64
    unify(INT8, UINT16) -> INT32
    unify(BOOL, UINT16) -> UINT16
    unify(FP32, INT32) -> FP64
    """
    if type1 is type2:
        return type1
    if is_left_scalar:
        scalar_types = [type1.np_type]
        array_types = []
    elif not is_right_scalar:
        # Using `promote_types` is faster than `find_common_type`
        return lookup_dtype(promote_types(type1.np_type, type2.np_type))
    else:
        scalar_types = []
        array_types = [type1.np_type]
    if is_right_scalar:
        scalar_types.append(type2.np_type)
    else:
        array_types.append(type2.np_type)
    return lookup_dtype(find_common_type(array_types, scalar_types))

1	import numba	7✔
2	import numpy as np	7✔
3	from numpy import find_common_type, promote_types	7✔
4
5	from . import lib	7✔
6
7	# Default assumption unless FC32/FC64 are found in lib
8	_supports_complex = hasattr(lib, "GrB_FC64") or hasattr(lib, "GxB_FC64")	7✔
9
10
11	class DataType:	7✔
12	__slots__ = "name", "gb_obj", "gb_name", "c_type", "numba_type", "np_type", "__weakref__"	7✔
13
14	def __init__(self, name, gb_obj, gb_name, c_type, numba_type, np_type):	7✔
15	self.name = name	7✔
16	self.gb_obj = gb_obj	7✔
17	self.gb_name = gb_name	7✔
18	self.c_type = c_type	7✔
19	self.numba_type = numba_type	7✔
20	self.np_type = np_type	7✔
21
22	def __repr__(self):	7✔
23	return self.name	7✔
24
25	def __eq__(self, other):	7✔
26	if type(other) is DataType:	7✔
27	return self.gb_obj == other.gb_obj	7✔
28	else:
29	# Attempt to use `other` as a lookup key
30	try:	7✔
31	other = lookup_dtype(other)	7✔
32	return self == other	7✔
33	except ValueError:	7✔
34	raise TypeError(f"Invalid or unknown datatype: {other}") from None	7✔
35
36	def __reduce__(self):	7✔
37	if self.gb_name == "GrB_Index":	7✔
38	return "_INDEX"	7✔
39	return self.name	7✔
40
41	@property	7✔
42	def _carg(self):	7✔
43	return self.gb_obj	7✔
44
45
46	BOOL = DataType("BOOL", lib.GrB_BOOL, "GrB_BOOL", "_Bool", numba.types.bool_, np.bool_)	7✔
47	INT8 = DataType("INT8", lib.GrB_INT8, "GrB_INT8", "int8_t", numba.types.int8, np.int8)	7✔
48	UINT8 = DataType("UINT8", lib.GrB_UINT8, "GrB_UINT8", "uint8_t", numba.types.uint8, np.uint8)	7✔
49	INT16 = DataType("INT16", lib.GrB_INT16, "GrB_INT16", "int16_t", numba.types.int16, np.int16)	7✔
50	UINT16 = DataType("UINT16", lib.GrB_UINT16, "GrB_UINT16", "uint16_t", numba.types.uint16, np.uint16)	7✔
51	INT32 = DataType("INT32", lib.GrB_INT32, "GrB_INT32", "int32_t", numba.types.int32, np.int32)	7✔
52	UINT32 = DataType("UINT32", lib.GrB_UINT32, "GrB_UINT32", "uint32_t", numba.types.uint32, np.uint32)	7✔
53	INT64 = DataType("INT64", lib.GrB_INT64, "GrB_INT64", "int64_t", numba.types.int64, np.int64)	7✔
54	# _Index (like UINT64) is for internal use only and shouldn't be exposed to the user
55	_INDEX = DataType("UINT64", lib.GrB_UINT64, "GrB_Index", "GrB_Index", numba.types.uint64, np.uint64)	7✔
56	UINT64 = DataType("UINT64", lib.GrB_UINT64, "GrB_UINT64", "uint64_t", numba.types.uint64, np.uint64)	7✔
57	FP32 = DataType("FP32", lib.GrB_FP32, "GrB_FP32", "float", numba.types.float32, np.float32)	7✔
58	FP64 = DataType("FP64", lib.GrB_FP64, "GrB_FP64", "double", numba.types.float64, np.float64)	7✔
59
60	if _supports_complex and hasattr(lib, "GxB_FC32"):	7✔
UNCOV 61	FC32 = DataType(	×
62	"FC32", lib.GxB_FC32, "GxB_FC32", "float _Complex", numba.types.complex64, np.complex64
63	)
64	if _supports_complex and hasattr(lib, "GrB_FC32"): # pragma: no coverage
65	FC32 = DataType(
66	"FC32", lib.GrB_FC32, "GrB_FC32", "float _Complex", numba.types.complex64, np.complex64
67	)
68	if _supports_complex and hasattr(lib, "GxB_FC64"):	7✔
UNCOV 69	FC64 = DataType(	×
70	"FC64", lib.GxB_FC64, "GxB_FC64", "double _Complex", numba.types.complex128, np.complex128
71	)
72	if _supports_complex and hasattr(lib, "GrB_FC64"): # pragma: no coverage
73	FC64 = DataType(
74	"FC64", lib.GrB_FC64, "GrB_FC64", "double _Complex", numba.types.complex128, np.complex128
75	)
76
77	# Used for testing user-defined functions
78	_sample_values = {	7✔
79	INT8.name: np.int8(1),
80	UINT8.name: np.uint8(1),
81	INT16.name: np.int16(1),
82	UINT16.name: np.uint16(1),
83	INT32.name: np.int32(1),
84	UINT32.name: np.uint32(1),
85	INT64.name: np.int64(1),
86	UINT64.name: np.uint64(1),
87	FP32.name: np.float32(0.5),
88	FP64.name: np.float64(0.5),
89	BOOL.name: np.bool_(True),
90	}
91	if _supports_complex:	7!
UNCOV 92	_sample_values.update(	×
93	{
94	FC32.name: np.complex64(complex(0, 0.5)),
95	FC64.name: np.complex128(complex(0, 0.5)),
96	}
97	)
98
99	# Create register to easily lookup types by name, gb_obj, or c_type
100	_registry = {}	7✔
101	_dtypes_to_register = [	7✔
102	BOOL,
103	INT8,
104	UINT8,
105	INT16,
106	UINT16,
107	INT32,
108	UINT32,
109	INT64,
110	UINT64,
111	FP32,
112	FP64,
113	]
114	if _supports_complex:	7!
UNCOV 115	_dtypes_to_register.extend([FC32, FC64])	×
116
117	for dtype in _dtypes_to_register:	7✔
118	_registry[dtype.name] = dtype	7✔
119	_registry[dtype.name.lower()] = dtype	7✔
120	_registry[dtype.gb_obj] = dtype	7✔
121	_registry[dtype.gb_name] = dtype	7✔
122	_registry[dtype.gb_name.lower()] = dtype	7✔
123	_registry[dtype.c_type] = dtype	7✔
124	_registry[dtype.c_type.upper()] = dtype	7✔
125	_registry[dtype.numba_type] = dtype	7✔
126	_registry[dtype.numba_type.name] = dtype	7✔
127	val = _sample_values[dtype.name]	7✔
128	_registry[val.dtype] = dtype	7✔
129	_registry[val.dtype.name] = dtype	7✔
130	# Upcast numpy float16 to float32
131	_registry[np.dtype(np.float16)] = FP32	7✔
132	_registry["float16"] = FP32	7✔
133
134	# Add some common Python types as lookup keys
135	_registry[bool] = BOOL	7✔
136	_registry[int] = INT64	7✔
137	_registry[float] = FP64	7✔
138	_registry["bool"] = BOOL	7✔
139	_registry["int"] = INT64	7✔
140	_registry["float"] = FP64 # Choose 'float' to match numpy/Python; c_type 'float' would be FP32	7✔
141	if _supports_complex:	7!
UNCOV 142	_registry[complex] = FC64	×
UNCOV 143	_registry["complex"] = FC64	×
144
145
146	def lookup_dtype(key):	7✔
147	# Check for silly lookup where key is already a DataType
148	if type(key) is DataType:	7✔
149	return key	7✔
150	try:	7✔
151	return _registry[key]	7✔
152	except KeyError:	7✔
153	pass	7✔
154	if hasattr(key, "name"):	7✔
155	try:	7✔
156	return _registry[key.name]	7✔
157	except KeyError:	7✔
158	pass	7✔
159	try:	7✔
160	return lookup_dtype(np.dtype(key))	7✔
161	except Exception:	7✔
162	pass	7✔
163	raise ValueError(f"Unknown dtype: {key}")	7✔
164
165
166	def unify(type1, type2, *, is_left_scalar=False, is_right_scalar=False):	7✔
167	"""
168	Returns a type that can hold both type1 and type2
169
170	For example:
171	unify(INT32, INT64) -> INT64
172	unify(INT8, UINT16) -> INT32
173	unify(BOOL, UINT16) -> UINT16
174	unify(FP32, INT32) -> FP64
175	"""
176	if type1 is type2:	7✔
177	return type1	7✔
178	if is_left_scalar:	7✔
179	scalar_types = [type1.np_type]	7✔
180	array_types = []	7✔
181	elif not is_right_scalar:	7✔
182	# Using `promote_types` is faster than `find_common_type`
183	return lookup_dtype(promote_types(type1.np_type, type2.np_type))	7✔
184	else:
185	scalar_types = []	7✔
186	array_types = [type1.np_type]	7✔
187	if is_right_scalar:	7✔
188	scalar_types.append(type2.np_type)	7✔
189	else:
190	array_types.append(type2.np_type)	7✔
191	return lookup_dtype(find_common_type(array_types, scalar_types))	7✔

metagraph-dev / grblas / 2009978378

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