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)