def test_dtype(self):
dtype = np.dtype("int64")
self.assertEqual(typeof(dtype), types.DType(types.int64))
dtype = np.dtype([("m", np.int32), ("n", "S5")])
rec_ty = numpy_support.from_struct_dtype(dtype)
self.assertEqual(typeof(dtype), types.DType(rec_ty))
def test_dtype(self):
dtype = np.dtype('int64')
self.assertEqual(typeof(dtype), types.DType(types.int64))
dtype = np.dtype([('m', np.int32), ('n', 'S5')])
rec_ty = numpy_support.from_struct_dtype(dtype)
self.assertEqual(typeof(dtype), types.DType(rec_ty))
def test_equality(self):
self.assertEqual(types.int32, types.int32)
self.assertEqual(types.uint32, types.uint32)
self.assertEqual(types.complex64, types.complex64)
self.assertEqual(types.float32, types.float32)
# Different signedness
self.assertNotEqual(types.int32, types.uint32)
# Different width
self.assertNotEqual(types.int64, types.int32)
self.assertNotEqual(types.float64, types.float32)
self.assertNotEqual(types.complex64, types.complex128)
# Different domain
self.assertNotEqual(types.int64, types.float64)
self.assertNotEqual(types.uint64, types.float64)
self.assertNotEqual(types.complex64, types.float64)
# Same arguments but different return types
get_pointer = None
sig_a = typing.signature(types.intp, types.intp)
sig_b = typing.signature(types.voidptr, types.intp)
a = types.ExternalFunctionPointer(sig=sig_a, get_pointer=get_pointer)
b = types.ExternalFunctionPointer(sig=sig_b, get_pointer=get_pointer)
self.assertNotEqual(a, b)
# Different call convention
a = types.ExternalFunctionPointer(sig=sig_a, get_pointer=get_pointer)
b = types.ExternalFunctionPointer(sig=sig_a,
get_pointer=get_pointer,
cconv='stdcall')
self.assertNotEqual(a, b)
# Different get_pointer
a = types.ExternalFunctionPointer(sig=sig_a, get_pointer=get_pointer)
b = types.ExternalFunctionPointer(sig=sig_a, get_pointer=object())
self.assertNotEqual(a, b)
# Different template classes bearing the same name
class DummyTemplate(object):
key = "foo"
a = types.BoundFunction(DummyTemplate, types.int32)
class DummyTemplate(object):
key = "bar"
b = types.BoundFunction(DummyTemplate, types.int32)
self.assertNotEqual(a, b)
# Different dtypes
self.assertNotEqual(types.DType(types.int32), types.DType(types.int64))
# CPointer with same addrspace
self.assertEqual(types.CPointer(types.float32),
types.CPointer(types.float32))
# CPointer with different addrspace
self.assertNotEqual(types.CPointer(types.float32, 0),
types.CPointer(types.float32, 1))
def typer(val):
if isinstance(val, (types.BaseTuple, types.Sequence)):
# Array constructor, e.g. np.int32([1, 2])
fnty = self.context.resolve_value_type(np.array)
sig = fnty.get_call_type(self.context, (val, types.DType(ty)),
{})
return sig.return_type
elif isinstance(val, (types.Number, types.Boolean, types.IntEnumMember)):
# Scalar constructor, e.g. np.int32(42)
return ty
elif isinstance(val, (types.NPDatetime, types.NPTimedelta)):
# Constructor cast from datetime-like, e.g.
# > np.int64(np.datetime64("2000-01-01"))
if ty.bitwidth == 64:
return ty
else:
msg = (f"Cannot cast {val} to {ty} as {ty} is not 64 bits "
"wide.")
raise errors.TypingError(msg)
else:
if (isinstance(val, types.Array) and val.ndim == 0 and
val.dtype == ty):
# This is 0d array -> scalar degrading
return ty
else:
# unsupported
msg = f"Casting {val} to {ty} directly is unsupported."
if isinstance(val, types.Array):
# array casts are supported a different way.
msg += f" Try doing '<array>.astype(np.{ty})' instead"
raise errors.TypingError(msg)
def typer(val):
if isinstance(val, (types.BaseTuple, types.Sequence)):
# Array constructor, e.g. np.int32([1, 2])
sig = self.context.resolve_function_type(
np.array, (val, ), {'dtype': types.DType(ty)})
return sig.return_type
else:
# Scalar constructor, e.g. np.int32(42)
return ty
def from_nb_type(nb_type):
return_type = types.DType(nb_type)
sig = return_type(desc)
def codegen(context, builder, signature, args):
# All dtype objects are dummy values in LLVM.
# They only exist in the type level.
return context.get_dummy_value()
return sig, codegen
def typer(val):
if isinstance(val, (types.BaseTuple, types.Sequence)):
# Array constructor, e.g. np.int32([1, 2])
fnty = self.context.resolve_value_type(np.array)
sig = fnty.get_call_type(self.context, (val, types.DType(ty)),
{})
return sig.return_type
else:
# Scalar constructor, e.g. np.int32(42)
return ty
def test_array_notation_for_dtype(self):
def check(arrty, scalar, ndim, layout):
self.assertIs(arrty.dtype, scalar)
self.assertEqual(arrty.ndim, ndim)
self.assertEqual(arrty.layout, layout)
scalar = types.int32
dtyped = types.DType(scalar)
check(dtyped[:], scalar, 1, 'A')
check(dtyped[::1], scalar, 1, 'C')
check(dtyped[:, :], scalar, 2, 'A')
check(dtyped[:, ::1], scalar, 2, 'C')
check(dtyped[::1, :], scalar, 2, 'F')
def typer(val):
if isinstance(val, (types.BaseTuple, types.Sequence)):
# Array constructor, e.g. np.int32([1, 2])
fnty = self.context.resolve_value_type(np.array)
sig = fnty.get_call_type(self.context, (val, types.DType(ty)),
{})
return sig.return_type
elif isinstance(val, (types.Number, types.Boolean)):
# Scalar constructor, e.g. np.int32(42)
return ty
else:
if (isinstance(val, types.Array) and val.ndim == 0
and val.dtype == ty):
# This is 0d array -> scalar degrading
return ty
else:
# unsupported
msg = f"Casting {val} to {ty} directly is unsupported."
if isinstance(val, types.Array):
# array casts are supported a different way.
msg += f" Try doing '<array>.astype(np.{ty})' instead"
raise errors.TypingError(msg)
def _typeof_dtype(val, c):
tp = numpy_support.from_dtype(val)
return types.DType(tp)
def resolve_dtype(self, ary):
return types.DType(ary.dtype)
