997232685

Build Type

github

Committed by GitHub

Commit Message

Merge 709d0b782 into 32369a600

Pull Request Pull Request #92: Fix Windows

Run Details

1981 of 1999 branches covered (99.1%)

Branch coverage included in aggregate %.

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

2 existing lines in 1 file now uncovered.

8467 of 8488 relevant lines covered (99.75%)

20.22 hits per line

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

98.8

/grblas/dtypes.py

import numpy as np
import numba
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}")

    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"):  # pragma: no branch
    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 branch
    FC32 = DataType(
        "FC32", lib.GrB_FC32, "GrB_FC32", "float _Complex", numba.types.complex64, np.complex64
    )
if _supports_complex and hasattr(lib, "GxB_FC64"):  # pragma: no branch
    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 branch
    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:  # pragma: no branch
    _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:  # pragma: no branch
    _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:  # pragma: no branch
    _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):
    """
    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 == type2:
        return type1
    # Bools fit anywhere
    if type1 == BOOL:
        return type2
    if type2 == BOOL:
        return type1
    # Compute bit numbers for comparison
    num1 = 8 if type1.name[-1] == "8" else int(type1.name[-2:])
    num2 = 8 if type2.name[-1] == "8" else int(type2.name[-2:])

    # Same type with different numbers is easy: choose the larger one
    if type1.name[1] == type2.name[1]:
        return type2 if num2 > num1 else type1
    # One FC, one FP
    if type1.name[0] == "F" and type2.name[0] == "F":
        return lookup_dtype(f"FC{max(num1, num2)}")
    # Float or complex with int
    if type1.name[0] == "F":
        maxnum = min(64, max(num1, 2 * num2))
        if type1.name[1] == "C":
            return lookup_dtype(f"FC{maxnum}")
        return lookup_dtype(f"FP{maxnum}")
    # Int with float or complex
    if type2.name[0] == "F":
        maxnum = min(64, max(2 * num1, num2))
        if type2.name[1] == "C":
            return lookup_dtype(f"FC{maxnum}")
        return lookup_dtype(f"FP{maxnum}")
    # Mixed int/uint is a little harder
    # Need to double the uint bit number to safely store as int
    # Beyond 64, we have to move to float
    if type1.name[0] == "U":
        num1 *= 2
    else:  # type2 is unsigned
        num2 *= 2
    maxnum = max(num1, num2)
    if maxnum > 64:
        return FP64
    return lookup_dtype(f"INT{maxnum}")

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

metagraph-dev / grblas / 997232685

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