def lower_const(self, const):
if isinstance(const, str):
ret = self.pyapi.string_from_string_and_size(const)
self.check_error(ret)
return ret
elif isinstance(const, complex):
real = self.context.get_constant(types.float64, const.real)
imag = self.context.get_constant(types.float64, const.imag)
ret = self.pyapi.complex_from_doubles(real, imag)
self.check_error(ret)
return ret
elif isinstance(const, float):
fval = self.context.get_constant(types.float64, const)
ret = self.pyapi.float_from_double(fval)
self.check_error(ret)
return ret
elif isinstance(const, int):
if utils.bit_length(const) >= 64:
raise ValueError("Integer is too big to be lowered")
ival = self.context.get_constant(types.intp, const)
return self.pyapi.long_from_ssize_t(ival)
elif isinstance(const, tuple):
items = [self.lower_const(i) for i in const]
return self.pyapi.tuple_pack(items)
elif const is Ellipsis:
return self.get_builtin_obj("Ellipsis")
elif const is None:
return self.pyapi.make_none()
else:
raise NotImplementedError(type(const))
def lower_const(self, const):
if isinstance(const, str):
ret = self.pyapi.string_from_constant_string(const)
self.check_error(ret)
return ret
elif isinstance(const, complex):
real = self.context.get_constant(types.float64, const.real)
imag = self.context.get_constant(types.float64, const.imag)
ret = self.pyapi.complex_from_doubles(real, imag)
self.check_error(ret)
return ret
elif isinstance(const, float):
fval = self.context.get_constant(types.float64, const)
ret = self.pyapi.float_from_double(fval)
self.check_error(ret)
return ret
elif isinstance(const, int):
if utils.bit_length(const) >= 64:
raise ValueError("Integer is too big to be lowered")
ival = self.context.get_constant(types.intp, const)
return self.pyapi.long_from_ssize_t(ival)
elif isinstance(const, tuple):
items = [self.lower_const(i) for i in const]
return self.pyapi.tuple_pack(items)
elif const is Ellipsis:
return self.get_builtin_obj("Ellipsis")
elif const is None:
return self.pyapi.make_none()
else:
raise NotImplementedError(type(const))
def _typeof_int(val, c):
# As in _typeof.c
nbits = utils.bit_length(val)
if nbits < 32:
typ = types.intp
elif nbits < 64:
typ = types.int64
elif nbits == 64 and val >= 0:
typ = types.uint64
else:
raise ValueError("Int value is too large: %s" % val)
return typ
def _typeof_int(val, c):
# As in _typeof.c
nbits = utils.bit_length(val)
if nbits < 32:
typ = types.intp
elif nbits < 64:
typ = types.int64
elif nbits == 64 and val >= 0:
typ = types.uint64
else:
raise ValueError("Int value is too large: %s" % val)
return typ
def get_number_type(self, num):
if isinstance(num, int):
nbits = utils.bit_length(num)
if nbits < 32:
typ = types.int32
elif nbits < 64:
typ = types.int64
else:
raise ValueError("Int value is too large: %s" % num)
return typ
elif isinstance(num, float):
return types.float64
else:
raise NotImplementedError(type(num), num)
def get_number_type(self, num):
if isinstance(num, int):
nbits = utils.bit_length(num)
if nbits < 32:
typ = types.int32
elif nbits < 64:
typ = types.int64
else:
raise ValueError("Int value is too large: %s" % num)
return typ
elif isinstance(num, float):
return types.float64
else:
raise NotImplementedError(type(num), num)
def _typeof_int(val, c):
if c.purpose is Purpose.argument:
# As in _typeof.c
return types.int64
else:
nbits = utils.bit_length(val)
if nbits < 32:
typ = types.int32
elif nbits < 64:
typ = types.int64
elif nbits == 64 and val >= 0:
typ = types.uint64
else:
raise ValueError("Int value is too large: %s" % val)
return typ
def _typeof_int(val, c):
if c.purpose is Purpose.argument:
# As in _typeof.c
return types.int64
else:
nbits = utils.bit_length(val)
if nbits < 32:
typ = types.int32
elif nbits < 64:
typ = types.int64
elif nbits == 64 and val >= 0:
typ = types.uint64
else:
raise ValueError("Int value is too large: %s" % val)
return typ
def test_merge_compute_minrun(self):
f = self.timsort.merge_compute_minrun
for i in range(0, 64):
self.assertEqual(f(i), i)
for i in range(6, 63):
self.assertEqual(f(2**i), 32)
for i in self.fibo():
if i < 64:
continue
if i >= 2 ** 63:
break
k = f(i)
self.assertGreaterEqual(k, 32)
self.assertLessEqual(k, 64)
if i > 500:
# i/k is close to, but strictly less than, an exact power of 2
quot = i // k
p = 2 ** utils.bit_length(quot)
self.assertLess(quot, p)
self.assertGreaterEqual(quot, 0.9 * p)
def lower_const(self, const):
from numba import dispatcher # Avoiding toplevel circular imports
if isinstance(const, str):
ret = self.pyapi.string_from_constant_string(const)
self.check_error(ret)
return ret
elif isinstance(const, complex):
real = self.context.get_constant(types.float64, const.real)
imag = self.context.get_constant(types.float64, const.imag)
ret = self.pyapi.complex_from_doubles(real, imag)
self.check_error(ret)
return ret
elif isinstance(const, float):
fval = self.context.get_constant(types.float64, const)
ret = self.pyapi.float_from_double(fval)
self.check_error(ret)
return ret
elif isinstance(const, utils.INT_TYPES):
if utils.bit_length(const) >= 64:
raise ValueError("Integer is too big to be lowered")
ival = self.context.get_constant(types.intp, const)
return self.pyapi.long_from_ssize_t(ival)
elif isinstance(const, tuple):
items = [self.lower_const(i) for i in const]
return self.pyapi.tuple_pack(items)
elif const is Ellipsis:
return self.get_builtin_obj("Ellipsis")
elif const is None:
return self.pyapi.make_none()
else:
# Constants which can't be reconstructed are frozen inside
# the environment (e.g. callables, lifted loops).
index = len(self.env.consts)
self.env.consts.append(const)
ret = self.get_env_const(index)
self.check_error(ret)
self.incref(ret)
return ret
def lower_const(self, const):
from numba import dispatcher # Avoiding toplevel circular imports
if isinstance(const, str):
ret = self.pyapi.string_from_constant_string(const)
self.check_error(ret)
return ret
elif isinstance(const, complex):
real = self.context.get_constant(types.float64, const.real)
imag = self.context.get_constant(types.float64, const.imag)
ret = self.pyapi.complex_from_doubles(real, imag)
self.check_error(ret)
return ret
elif isinstance(const, float):
fval = self.context.get_constant(types.float64, const)
ret = self.pyapi.float_from_double(fval)
self.check_error(ret)
return ret
elif isinstance(const, utils.INT_TYPES):
if utils.bit_length(const) >= 64:
raise ValueError("Integer is too big to be lowered")
ival = self.context.get_constant(types.intp, const)
return self.pyapi.long_from_ssize_t(ival)
elif isinstance(const, tuple):
items = [self.lower_const(i) for i in const]
return self.pyapi.tuple_pack(items)
elif const is Ellipsis:
return self.get_builtin_obj("Ellipsis")
elif const is None:
return self.pyapi.make_none()
else:
# Constants which can't be reconstructed are frozen inside
# the environment (e.g. callables, lifted loops).
index = len(self.env.consts)
self.env.consts.append(const)
ret = self.get_env_const(index)
self.check_error(ret)
self.incref(ret)
return ret
def mono_test(arr):
for i in arr:
result = mt.test(bin(i), bit_length(i))
if result[4] != True:
return False
return True
