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