def test_unsupport_bitsize(self):
ffi = self.get_ffi()
with self.assertRaises(ValueError) as raises:
cffi_support.map_type(
ffi.typeof('error'),
use_record_dtype=True,
)
# When bitsize is provided, bitshift defaults to 0.
self.assertEqual("field 'bits' has bitshift, this is not supported",
str(raises.exception))
def __new__(meta, type_name, bases, attrs):
if attrs.get('base', False):
cls = super().__new__(meta, type_name, bases, attrs)
return cls
if 'members' in attrs:
m = attrs['members']
cls_ffi = FFI()
cls_ffi.cdef(build_udt_def(type_name, m))
t = core_ffi.new('GrB_Type*')
_check(lib.GrB_Type_new(t, cls_ffi.sizeof(type_name)))
cffi_support.map_type(cls_ffi.typeof(type_name),
use_record_dtype=True)
attrs['ffi'] = cls_ffi
attrs['gb_type'] = t[0]
attrs['C'] = type_name
attrs['member_def'] = list(map(methodcaller('split'), m))
attrs['base_name'] = 'UDT'
else:
attrs['ffi'] = core_ffi
gb_type_name = type_name
cls = super().__new__(meta, type_name, bases, attrs)
meta._gb_type_map[cls.gb_type] = cls
cls.ptr = cls.C + '*'
cls.zero = getattr(cls, 'zero', core_ffi.NULL)
cls.one = getattr(cls, 'one', core_ffi.NULL)
get = partial(getattr, lib)
cls.base_name = base_name = getattr(cls, 'base_name', cls.__name__)
cls.Monoid_new = get('GrB_Monoid_new_{}'.format(base_name))
cls.Matrix_setElement = get(
'GrB_Matrix_setElement_{}'.format(base_name))
cls.Matrix_extractElement = get(
'GrB_Matrix_extractElement_{}'.format(base_name))
cls.Matrix_extractTuples = get(
'GrB_Matrix_extractTuples_{}'.format(base_name))
cls.Matrix_assignScalar = get('GrB_Matrix_assign_{}'.format(base_name))
cls.Vector_setElement = get(
'GrB_Vector_setElement_{}'.format(base_name))
cls.Vector_extractElement = get(
'GrB_Vector_extractElement_{}'.format(base_name))
cls.Vector_extractTuples = get(
'GrB_Vector_extractTuples_{}'.format(base_name))
cls.Vector_assignScalar = get('GrB_Vector_assign_{}'.format(base_name))
cls.Scalar_setElement = get(
'GxB_Scalar_setElement_{}'.format(base_name))
cls.Scalar_extractElement = get(
'GxB_Scalar_extractElement_{}'.format(base_name))
return cls
def test_cfunc_callback(self):
ffi = self.get_ffi()
big_struct = ffi.typeof('big_struct')
nb_big_struct = cffi_support.map_type(big_struct,
use_record_dtype=True)
sig = cffi_support.map_type(ffi.typeof('myfunc'),
use_record_dtype=True)
@njit
def calc(base):
tmp = 0
for i in range(base.size):
elem = base[i]
tmp += elem.i1 * elem.f2 / elem.d3
tmp += base[i].af4.sum()
return tmp
@cfunc(sig)
def foo(ptr, n):
base = carray(ptr, n)
return calc(base)
# Make data
mydata = ffi.new('big_struct[3]')
ptr = ffi.cast('big_struct*', mydata)
for i in range(3):
ptr[i].i1 = i * 123
ptr[i].f2 = i * 213
ptr[i].d3 = (1 + i) * 213
for j in range(9):
ptr[i].af4[j] = i * 10 + j
# Address of my data
addr = int(ffi.cast('size_t', ptr))
got = foo.ctypes(addr, 3)
# Make numpy array from the cffi buffer
array = np.ndarray(
buffer=ffi.buffer(mydata),
dtype=numpy_support.as_dtype(nb_big_struct),
shape=3,
)
expect = calc(array)
self.assertEqual(got, expect)
def test_type_parsing(self):
ffi = self.get_ffi()
# Check struct typedef
big_struct = ffi.typeof('big_struct')
nbtype = cffi_support.map_type(big_struct, use_record_dtype=True)
self.assertIsInstance(nbtype, types.Record)
self.assertEqual(len(nbtype), 4)
self.assertEqual(nbtype.typeof('i1'), types.int32)
self.assertEqual(nbtype.typeof('f2'), types.float32)
self.assertEqual(nbtype.typeof('d3'), types.float64)
self.assertEqual(
nbtype.typeof('af4'),
types.NestedArray(dtype=types.float32, shape=(9, )),
)
# Check function typedef
myfunc = ffi.typeof('myfunc')
sig = cffi_support.map_type(myfunc, use_record_dtype=True)
self.assertIsInstance(sig, typing.Signature)
self.assertEqual(sig.args[0], types.CPointer(nbtype))
self.assertEqual(sig.args[1], types.uintp)
self.assertEqual(sig.return_type, types.float64)
def __set_name__(self, cls, name):
func_name = self.func.__name__
cls_name = cls.__name__
if cls.base_name == 'UDT':
cls.ffi.cdef(build_binop_def(cls_name, func_name, boolean))
sig = cffi_support.map_type(cls.ffi.typeof(
binop_name(cls_name, func_name)),
use_record_dtype=True)
else:
sig = numba.void(cls.numba_t, cls.numba_t, cls.numba_t)
jitfunc = jit(self.func, nopython=True)
@cfunc(sig)
def wrapper(z_, x_, y_):
z = carray(z_, 1)[0]
x = carray(x_, 1)[0]
y = carray(y_, 1)[0]
jitfunc(z, x, y)
self.op = BinaryOp(func_name, cls_name, wrapper, cls, boolean)
setattr(cls, func_name, self.op)
def test_type_map(self):
signature = cffi_support.map_type(mod.ffi.typeof(mod.cffi_sin))
self.assertEqual(len(signature.args), 1)
self.assertEqual(signature.args[0], types.double)
def __new__(meta, type_name, bases, attrs):
if attrs.get("base", False):
cls = super().__new__(meta, type_name, bases, attrs)
return cls
if "members" in attrs:
m = attrs["members"]
cls_ffi = FFI()
cls_ffi.cdef(build_udt_def(type_name, m))
t = core_ffi.new("GrB_Type*")
_check(lib.GrB_Type_new(t, cls_ffi.sizeof(type_name)))
cffi_support.map_type(cls_ffi.typeof(type_name),
use_record_dtype=True)
attrs["ffi"] = cls_ffi
attrs["gb_type"] = t[0]
attrs["C"] = type_name
attrs["member_def"] = list(map(methodcaller("split"), m))
attrs["base_name"] = "UDT"
else:
attrs["ffi"] = core_ffi
gb_type_name = type_name
cls = super().__new__(meta, type_name, bases, attrs)
meta._gb_type_map[cls.gb_type] = cls
meta._type_gb_map[cls] = cls.gb_type
meta._gb_name_type_map[type_name] = cls
meta._gb_name_type_map[cls.C] = cls
cls.ptr = cls.C + "*"
cls.zero = getattr(cls, "zero", core_ffi.NULL)
cls.one = getattr(cls, "one", core_ffi.NULL)
get = partial(getattr, lib)
cls.base_name = base_name = getattr(cls, "base_name", cls.__name__)
cls.prefix = prefix = getattr(cls, "prefix", "GrB")
cls.Monoid_new = get("{}_Monoid_new_{}".format(prefix, base_name))
cls.Matrix_setElement = get("{}_Matrix_setElement_{}".format(
prefix, base_name))
cls.Matrix_extractElement = get("{}_Matrix_extractElement_{}".format(
prefix, base_name))
cls.Matrix_extractTuples = get("{}_Matrix_extractTuples_{}".format(
prefix, base_name))
cls.Matrix_assignScalar = get("{}_Matrix_assign_{}".format(
prefix, base_name))
cls.Matrix_apply_BinaryOp1st = get(
"{}_Matrix_apply_BinaryOp1st_{}".format(prefix, base_name))
cls.Matrix_apply_BinaryOp2nd = get(
"{}_Matrix_apply_BinaryOp2nd_{}".format(prefix, base_name))
cls.Vector_setElement = get("{}_Vector_setElement_{}".format(
prefix, base_name))
cls.Vector_extractElement = get("{}_Vector_extractElement_{}".format(
prefix, base_name))
cls.Vector_extractTuples = get("{}_Vector_extractTuples_{}".format(
prefix, base_name))
cls.Vector_assignScalar = get("{}_Vector_assign_{}".format(
prefix, base_name))
cls.Vector_apply_BinaryOp1st = get(
"{}_Vector_apply_BinaryOp1st_{}".format(prefix, base_name))
cls.Vector_apply_BinaryOp2nd = get(
"{}_Vector_apply_BinaryOp2nd_{}".format(prefix, base_name))
cls.Scalar_setElement = get(
"GxB_Scalar_setElement_{}".format(base_name))
cls.Scalar_extractElement = get(
"GxB_Scalar_extractElement_{}".format(base_name))
return cls
logger = logging.getLogger("sunode.basic")
lib: Any = _cvodes.lib
ffi: Any = _cvodes.ffi
cffi_utils.register_module(_cvodes)
cffi_utils.register_type(
ffi.typeof("N_Vector").item, numba.types.Opaque("N_Vector")
)
cffi_utils.register_type(
ffi.typeof("SUNMatrix").item, numba.types.Opaque("SUNMatrix")
)
_data_dtype = cffi_utils.map_type(ffi.typeof("realtype"))
_index_dtype = cffi_utils.map_type(ffi.typeof("sunindextype"))
data_dtype: Any = np.dtype(_data_dtype.name)
index_dtype: Any = np.dtype(_index_dtype.name)
CPointer = NewType("CPointer", int)
ERRORS = {}
for name in dir(lib):
item = getattr(lib, name)
if not isinstance(item, int):
continue
if name.startswith('CV_') or name.startswith('CVLS_') or name.startswith('SUN_NLS_'):
ERRORS[item] = name
def __new__(meta, type_name, bases, attrs):
if attrs.get("base", False):
cls = super().__new__(meta, type_name, bases, attrs)
return cls
if "members" in attrs: # pragma: nocover
m = attrs["members"]
cls_ffi = FFI()
cls_ffi.cdef(build_udt_def(type_name, m))
t = core_ffi.new("GrB_Type*")
_check(lib.GrB_Type_new(t, cls_ffi.sizeof(type_name)))
cffi_support.map_type(cls_ffi.typeof(type_name),
use_record_dtype=True)
attrs["_ffi"] = cls_ffi
attrs["_gb_type"] = t[0]
attrs["_c_type"] = type_name
attrs["member_def"] = list(map(methodcaller("split"), m))
attrs["base_name"] = "UDT"
else:
attrs["_ffi"] = core_ffi
_gb_type_name = type_name
cls = super().__new__(meta, type_name, bases, attrs)
meta._gb_type_map[cls._gb_type] = cls
meta._type_gb_map[cls] = cls._gb_type
meta._dtype_gb_map[cls._numpy_t] = cls
meta._gb_name_type_map[type_name] = cls
meta._gb_name_type_map[cls._c_type] = cls
cls._ptr = cls._c_type + "*"
cls.default_zero = getattr(cls, "default_zero", core_ffi.NULL)
cls.default_one = getattr(cls, "default_one", core_ffi.NULL)
def get(n):
try:
return getattr(lib, "GrB_" + n)
except AttributeError:
return getattr(lib, "GxB_" + n)
cls._base_name = base_name = getattr(cls, "_base_name", cls.__name__)
cls._Monoid_new = get(f"Monoid_new_{base_name}")
cls._Matrix_setElement = get(f"Matrix_setElement_{base_name}")
cls._Matrix_extractElement = get(f"Matrix_extractElement_{base_name}")
cls._Matrix_extractTuples = get(f"Matrix_extractTuples_{base_name}")
cls._Matrix_assignScalar = get(f"Matrix_assign_{base_name}")
cls._Matrix_apply_BinaryOp1st = get(
f"Matrix_apply_BinaryOp1st_{base_name}")
cls._Matrix_apply_BinaryOp2nd = get(
f"Matrix_apply_BinaryOp2nd_{base_name}")
cls._Vector_setElement = get(f"Vector_setElement_{base_name}")
cls._Vector_extractElement = get(f"Vector_extractElement_{base_name}")
cls._Vector_extractTuples = get(f"Vector_extractTuples_{base_name}")
cls._Vector_assignScalar = get(f"Vector_assign_{base_name}")
cls._Vector_apply_BinaryOp1st = get(
f"Vector_apply_BinaryOp1st_{base_name}")
cls._Vector_apply_BinaryOp2nd = get(
f"Vector_apply_BinaryOp2nd_{base_name}")
cls._Scalar_setElement = get(f"Scalar_setElement_{base_name}")
cls._Scalar_extractElement = get(f"Scalar_extractElement_{base_name}")
cls._Vector_reduce = get(f"Vector_reduce_{base_name}")
cls._Matrix_reduce = get(f"Matrix_reduce_{base_name}")
return cls
