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))
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 resolve_dtype(self, ary):
return types.DType(ary.dtype)
def _typeof_dtype(val, c):
tp = numpy_support.from_dtype(val)
return types.DType(tp)
def resolve_data_type(self, val):
"""
Return the numba type of a Python value representing data
(e.g. a number or an array, but not more sophisticated types
such as functions, etc.)
This function can return None to if it cannot decide.
"""
if val is True or val is False:
return types.boolean
# Under 2.x, we must guard against numpy scalars (np.intXY
# subclasses Python int but get_number_type() wouldn't infer the
# right bit width -- perhaps it should?).
elif (not isinstance(val, numpy.number)
and isinstance(val, utils.INT_TYPES + (float, ))):
return self.get_number_type(val)
elif val is None:
return types.none
elif isinstance(val, str):
return types.string
elif isinstance(val, complex):
return types.complex128
elif isinstance(val, tuple):
tys = [self.resolve_value_type(v) for v in val]
distinct_types = set(tys)
if len(distinct_types) == 1:
return types.UniTuple(tys[0], len(tys))
else:
return types.Tuple(tys)
elif ctypes_utils.is_ctypes_funcptr(val):
return ctypes_utils.make_function_type(val)
elif cffi_utils.SUPPORTED and cffi_utils.is_cffi_func(val):
return cffi_utils.make_function_type(val)
elif numpy_support.is_array(val):
ary = val
try:
dtype = numpy_support.from_dtype(ary.dtype)
except NotImplementedError:
return
layout = numpy_support.map_layout(ary)
readonly = not ary.flags.writeable
return types.Array(dtype, ary.ndim, layout, readonly=readonly)
elif sys.version_info >= (2, 7) and not isinstance(val, numpy.generic):
try:
m = memoryview(val)
except TypeError:
pass
else:
# Object has the buffer protocol
try:
dtype = bufproto.decode_pep3118_format(
m.format, m.itemsize)
except ValueError:
pass
else:
type_class = bufproto.get_type_class(type(val))
layout = bufproto.infer_layout(m)
return type_class(dtype,
m.ndim,
layout=layout,
readonly=m.readonly)
if isinstance(val, numpy.dtype):
tp = numpy_support.from_dtype(val)
return types.DType(tp)
else:
# Matching here is quite broad, so we have to do it after
# the more specific matches above.
try:
return numpy_support.map_arrayscalar_type(val)
except NotImplementedError:
pass
return
def inline_array(array_var, expr, stmts, list_vars, dels):
"""Check to see if the given "array_var" is created from a list
of constants, and try to inline the list definition as array
initialization.
Extra statements produced with be appended to "stmts".
"""
callname = guard(find_callname, func_ir, expr)
require(callname and callname[1] == 'numpy' and callname[0] == 'array')
require(expr.args[0].name in list_vars)
ret_type = calltypes[expr].return_type
require(
isinstance(ret_type, types.ArrayCompatible) and ret_type.ndim == 1)
loc = expr.loc
list_var = expr.args[0]
# Get the type of the array to be created.
array_typ = typemap[array_var.name]
debug_print("inline array_var = ", array_var, " list_var = ", list_var)
# Get the element type of the array to be created.
dtype = array_typ.dtype
# Get the sequence of operations to provide values to the new array.
seq, _ = find_build_sequence(func_ir, list_var)
size = len(seq)
# Create a tuple to pass to empty below to specify the new array size.
size_var = ir.Var(scope, mk_unique_var("size"), loc)
size_tuple_var = ir.Var(scope, mk_unique_var("size_tuple"), loc)
size_typ = types.intp
size_tuple_typ = types.UniTuple(size_typ, 1)
typemap[size_var.name] = size_typ
typemap[size_tuple_var.name] = size_tuple_typ
stmts.append(
_new_definition(func_ir, size_var, ir.Const(size, loc=loc), loc))
stmts.append(
_new_definition(func_ir, size_tuple_var,
ir.Expr.build_tuple(items=[size_var], loc=loc),
loc))
# The general approach is to create an empty array and then fill
# the elements in one-by-one from their specificiation.
# Get the numpy type to pass to empty.
nptype = types.DType(dtype)
# Create a variable to hold the numpy empty function.
empty_func = ir.Var(scope, mk_unique_var("empty_func"), loc)
fnty = get_np_ufunc_typ(np.empty)
sig = context.resolve_function_type(fnty, (size_typ, ),
{'dtype': nptype})
typemap[empty_func.name] = fnty
stmts.append(
_new_definition(func_ir, empty_func,
ir.Global('empty', np.empty, loc=loc), loc))
# We pass two arguments to empty, first the size tuple and second
# the dtype of the new array. Here, we created typ_var which is
# the dtype argument of the new array. typ_var in turn is created
# by getattr of the dtype string on the numpy module.
# Create var for numpy module.
g_np_var = ir.Var(scope, mk_unique_var("$np_g_var"), loc)
typemap[g_np_var.name] = types.misc.Module(np)
g_np = ir.Global('np', np, loc)
stmts.append(_new_definition(func_ir, g_np_var, g_np, loc))
# Create var for result of numpy.<dtype>.
typ_var = ir.Var(scope, mk_unique_var("$np_typ_var"), loc)
typemap[typ_var.name] = nptype
dtype_str = str(dtype)
if dtype_str == 'bool':
dtype_str = 'bool_'
# Get dtype attribute of numpy module.
np_typ_getattr = ir.Expr.getattr(g_np_var, dtype_str, loc)
stmts.append(_new_definition(func_ir, typ_var, np_typ_getattr, loc))
# Create the call to numpy.empty passing the size tuple and dtype var.
empty_call = ir.Expr.call(empty_func, [size_var, typ_var], {}, loc=loc)
calltypes[empty_call] = typing.signature(array_typ, size_typ, nptype)
stmts.append(_new_definition(func_ir, array_var, empty_call, loc))
# Fill in the new empty array one-by-one.
for i in range(size):
index_var = ir.Var(scope, mk_unique_var("index"), loc)
index_typ = types.intp
typemap[index_var.name] = index_typ
stmts.append(
_new_definition(func_ir, index_var, ir.Const(i, loc), loc))
setitem = ir.SetItem(array_var, index_var, seq[i], loc)
calltypes[setitem] = typing.signature(types.none, array_typ,
index_typ, dtype)
stmts.append(setitem)
stmts.extend(dels)
return True
