def register_binary_ufunc(ufunc, operator, asfloat=False, divbyzero=False): def binary_ufunc(context, builder, sig, args): imp = numpy_binary_ufunc(operator, asfloat=asfloat, divbyzero=divbyzero) return imp(context, builder, sig, args) def binary_ufunc_scalar_inputs(context, builder, sig, args): imp = numpy_binary_ufunc(operator, scalar_inputs=True, asfloat=asfloat, divbyzero=divbyzero) return imp(context, builder, sig, args) register( implement(ufunc, types.Kind(types.Array), types.Kind(types.Array), types.Kind(types.Array))(binary_ufunc)) for ty in types.number_domain: register( implement(ufunc, ty, types.Kind(types.Array), types.Kind(types.Array))(binary_ufunc_scalar_inputs)) register( implement(ufunc, types.Kind(types.Array), ty, types.Kind(types.Array))(binary_ufunc_scalar_inputs)) for ty1, ty2 in itertools.product(types.number_domain, types.number_domain): register( implement(ufunc, ty1, ty2, types.Kind(types.Array))(binary_ufunc_scalar_inputs))
def unary_math_extern(fn, f32extern, f64extern, int_restype=False): """ Register implementations of Python function *fn* using the external function named *f32extern* and *f64extern* (for float32 and float64 inputs, respectively). If *int_restype* is true, then the function's return value should be integral, otherwise floating-point. """ f_restype = types.int64 if int_restype else None f32impl = _float_input_unary_math_extern_impl(f32extern, types.float32, f_restype) f64impl = _float_input_unary_math_extern_impl(f64extern, types.float64, f_restype) register(implement(fn, types.float32)(f32impl)) register(implement(fn, types.float64)(f64impl)) if int_restype: # If asked for an integral return type, we choose the input type # as the return type. for input_type in [types.intp, types.uintp, types.int64, types.uint64]: impl = _unary_int_input_wrapper_impl( _float_input_unary_math_extern_impl(f64extern, types.float64, input_type)) register(implement(fn, input_type)(impl)) else: unary_math_int_impl(fn, f64impl)
def register_binary_ufunc(ufunc, operator, asfloat=False, divbyzero=False): def binary_ufunc(context, builder, sig, args): imp = numpy_binary_ufunc(operator, asfloat=asfloat, divbyzero=divbyzero) return imp(context, builder, sig, args) def binary_ufunc_scalar_inputs(context, builder, sig, args): imp = numpy_binary_ufunc(operator, scalar_inputs=True, asfloat=asfloat, divbyzero=divbyzero) return imp(context, builder, sig, args) register(implement(ufunc, types.Kind(types.Array), types.Kind(types.Array), types.Kind(types.Array))(binary_ufunc)) for ty in types.number_domain: register(implement(ufunc, ty, types.Kind(types.Array), types.Kind(types.Array))(binary_ufunc_scalar_inputs)) register(implement(ufunc, types.Kind(types.Array), ty, types.Kind(types.Array))(binary_ufunc_scalar_inputs)) for ty1, ty2 in itertools.product(types.number_domain, types.number_domain): register(implement(ufunc, ty1, ty2, types.Kind(types.Array))(binary_ufunc_scalar_inputs))
def register_unary_ufunc(ufunc, operator, asfloat=False): def unary_ufunc(context, builder, sig, args): imp = numpy_unary_ufunc(operator, asfloat=asfloat) return imp(context, builder, sig, args) def unary_ufunc_scalar_input(context, builder, sig, args): imp = numpy_unary_ufunc(operator, scalar_input=True, asfloat=asfloat) return imp(context, builder, sig, args) def scalar_unary_ufunc(context, builder, sig, args): imp = numpy_scalar_unary_ufunc(operator, asfloat) return imp(context, builder, sig, args) register(implement(ufunc, types.Kind(types.Array), types.Kind(types.Array))(unary_ufunc)) for ty in types.number_domain: register(implement(ufunc, ty, types.Kind(types.Array))(unary_ufunc_scalar_input)) for ty in types.number_domain: register(implement(ufunc, ty)(scalar_unary_ufunc))
'sqrt', 'exp', 'expm1', 'log', 'log10', 'log1p', 'copysign', 'pow', 'fmod', 'erf', 'erfc', 'gamma', 'lgamma', ] for name in _supported: sigs = function_descriptors.get(name) if sigs is None: warnings.warn("HSA - failed to register '{0}'".format(name)) continue try: # only symbols present in the math module key = getattr(math, name) except AttributeError: continue for sig in sigs: fn = _mk_fn_decl(name, sig) register(implement(key, *sig.args)(fn))
def _implement_real_operators(): ty = types.Kind(types.Float) register(implement(operator.add, ty, ty)(builtins.real_add_impl)) register(implement(operator.iadd, ty, ty)(builtins.real_add_impl)) register(implement(operator.sub, ty, ty)(builtins.real_sub_impl)) register(implement(operator.isub, ty, ty)(builtins.real_sub_impl)) register(implement(operator.mul, ty, ty)(builtins.real_mul_impl)) register(implement(operator.imul, ty, ty)(builtins.real_mul_impl)) if not utils.IS_PY3: register(implement(operator.div, ty, ty)(builtins.real_div_impl)) register(implement(operator.idiv, ty, ty)(builtins.real_div_impl)) register(implement(operator.floordiv, ty, ty)(builtins.real_floordiv_impl)) register(implement(operator.ifloordiv, ty, ty)(builtins.real_floordiv_impl)) register(implement(operator.truediv, ty, ty)(builtins.real_div_impl)) register(implement(operator.itruediv, ty, ty)(builtins.real_div_impl)) register(implement(operator.mod, ty, ty)(builtins.real_mod_impl)) register(implement(operator.imod, ty, ty)(builtins.real_mod_impl)) register(implement(operator.pow, ty, ty)(builtins.real_power_impl)) register(implement(operator.ipow, ty, ty)(builtins.real_power_impl)) register(implement(operator.eq, ty, ty)(builtins.real_eq_impl)) register(implement(operator.ne, ty, ty)(builtins.real_ne_impl)) register(implement(operator.lt, ty, ty)(builtins.real_lt_impl)) register(implement(operator.le, ty, ty)(builtins.real_le_impl)) register(implement(operator.gt, ty, ty)(builtins.real_gt_impl)) register(implement(operator.ge, ty, ty)(builtins.real_ge_impl)) register(implement(operator.neg, ty)(builtins.real_negate_impl)) register(implement(operator.pos, ty)(builtins.real_positive_impl)) register(implement(operator.not_, ty)(builtins.number_not_impl))
def _implement_integer_operators(): ty = types.Kind(types.Integer) register(implement(operator.add, ty, ty)(builtins.int_add_impl)) register(implement(operator.iadd, ty, ty)(builtins.int_add_impl)) register(implement(operator.sub, ty, ty)(builtins.int_sub_impl)) register(implement(operator.isub, ty, ty)(builtins.int_sub_impl)) register(implement(operator.mul, ty, ty)(builtins.int_mul_impl)) register(implement(operator.imul, ty, ty)(builtins.int_mul_impl)) register(implement(operator.eq, ty, ty)(builtins.int_eq_impl)) register(implement(operator.ne, ty, ty)(builtins.int_ne_impl)) register(implement(operator.lshift, ty, ty)(builtins.int_shl_impl)) register(implement(operator.ilshift, ty, ty)(builtins.int_shl_impl)) register(implement(operator.and_, ty, ty)(builtins.int_and_impl)) register(implement(operator.iand, ty, ty)(builtins.int_and_impl)) register(implement(operator.or_, ty, ty)(builtins.int_or_impl)) register(implement(operator.ior, ty, ty)(builtins.int_or_impl)) register(implement(operator.xor, ty, ty)(builtins.int_xor_impl)) register(implement(operator.ixor, ty, ty)(builtins.int_xor_impl)) register(implement(operator.neg, ty)(builtins.int_negate_impl)) register(implement(operator.pos, ty)(builtins.int_positive_impl)) register(implement(operator.invert, ty)(builtins.int_invert_impl)) register(implement(operator.not_, ty)(builtins.number_not_impl)) for ty in types.unsigned_domain: if not utils.IS_PY3: register(implement(operator.div, ty, ty)(builtins.int_udiv_impl)) register(implement(operator.idiv, ty, ty)(builtins.int_udiv_impl)) register(implement(operator.floordiv, ty, ty)(builtins.int_ufloordiv_impl)) register(implement(operator.ifloordiv, ty, ty)(builtins.int_ufloordiv_impl)) register(implement(operator.truediv, ty, ty)(builtins.int_utruediv_impl)) register(implement(operator.itruediv, ty, ty)(builtins.int_utruediv_impl)) register(implement(operator.mod, ty, ty)(builtins.int_urem_impl)) register(implement(operator.imod, ty, ty)(builtins.int_urem_impl)) register(implement(operator.lt, ty, ty)(builtins.int_ult_impl)) register(implement(operator.le, ty, ty)(builtins.int_ule_impl)) register(implement(operator.gt, ty, ty)(builtins.int_ugt_impl)) register(implement(operator.ge, ty, ty)(builtins.int_uge_impl)) register(implement(operator.pow, types.float64, ty)(builtins.int_upower_impl)) register(implement(operator.ipow, types.float64, ty)(builtins.int_upower_impl)) register(implement(operator.rshift, ty, ty)(builtins.int_lshr_impl)) register(implement(operator.irshift, ty, ty)(builtins.int_lshr_impl)) for ty in types.signed_domain: if not utils.IS_PY3: register(implement(operator.div, ty, ty)(builtins.int_sdiv_impl)) register(implement(operator.idiv, ty, ty)(builtins.int_sdiv_impl)) register(implement(operator.floordiv, ty, ty)(builtins.int_sfloordiv_impl)) register(implement(operator.ifloordiv, ty, ty)(builtins.int_sfloordiv_impl)) register(implement(operator.truediv, ty, ty)(builtins.int_struediv_impl)) register(implement(operator.itruediv, ty, ty)(builtins.int_struediv_impl)) register(implement(operator.mod, ty, ty)(builtins.int_srem_impl)) register(implement(operator.imod, ty, ty)(builtins.int_srem_impl)) register(implement(operator.lt, ty, ty)(builtins.int_slt_impl)) register(implement(operator.le, ty, ty)(builtins.int_sle_impl)) register(implement(operator.gt, ty, ty)(builtins.int_sgt_impl)) register(implement(operator.ge, ty, ty)(builtins.int_sge_impl)) register(implement(operator.pow, types.float64, ty)(builtins.int_spower_impl)) register(implement(operator.ipow, types.float64, ty)(builtins.int_spower_impl)) register(implement(operator.rshift, ty, ty)(builtins.int_ashr_impl)) register(implement(operator.irshift, ty, ty)(builtins.int_ashr_impl))
def powi_implement(nvname): def core(context, builder, sig, args): [base, pow] = args [basety, powty] = sig.args lmod = cgutils.get_module(builder) fty = context.get_value_type(basety) ity = context.get_value_type(types.int32) fnty = Type.function(fty, [fty, ity]) fn = lmod.get_or_insert_function(fnty, name=nvname) return builder.call(fn, [base, pow]) return core register( implement(math.pow, types.float32, types.int32)(powi_implement('__nv_powif'))) register( implement(math.pow, types.float64, types.int32)(powi_implement('__nv_powi'))) booleans = [] booleans += [('__nv_isnand', '__nv_isnanf', math.isnan)] booleans += [('__nv_isinfd', '__nv_isinff', math.isinf)] unarys = [] unarys += [('__nv_ceil', '__nv_ceilf', math.ceil)] unarys += [('__nv_floor', '__nv_floorf', math.floor)] unarys += [('__nv_fabs', '__nv_fabsf', math.fabs)] unarys += [('__nv_exp', '__nv_expf', math.exp)] if sys.version_info[:2] >= (2, 7): unarys += [('__nv_expm1', '__nv_expm1f', math.expm1)]
import operator from numba.targets.imputils import implement, Registry from numba.targets import builtins from numba import types, utils registry = Registry() register = registry.register for ty in types.integer_domain: register(implement(operator.add, ty, ty)(builtins.int_add_impl)) register(implement(operator.sub, ty, ty)(builtins.int_sub_impl)) register(implement(operator.mul, ty, ty)(builtins.int_mul_impl)) register(implement(operator.eq, ty, ty)(builtins.int_eq_impl)) register(implement(operator.ne, ty, ty)(builtins.int_ne_impl)) register(implement(operator.lshift, ty, ty)(builtins.int_shl_impl)) register(implement(operator.and_, ty, ty)(builtins.int_and_impl)) register(implement(operator.or_, ty, ty)(builtins.int_or_impl)) register(implement(operator.xor, ty, ty)(builtins.int_xor_impl)) register(implement(operator.neg, ty)(builtins.int_negate_impl)) register(implement(operator.invert, ty)(builtins.int_invert_impl)) for ty in types.unsigned_domain: if not utils.IS_PY3: register(implement(operator.div, ty, ty)(builtins.int_udiv_impl)) register(implement(operator.floordiv, ty, ty)(builtins.int_ufloordiv_impl)) register(implement(operator.truediv, ty, ty)(builtins.int_utruediv_impl)) register(implement(operator.mod, ty, ty)(builtins.int_urem_impl)) register(implement(operator.lt, ty, ty)(builtins.int_ult_impl)) register(implement(operator.le, ty, ty)(builtins.int_ule_impl)) register(implement(operator.gt, ty, ty)(builtins.int_ugt_impl)) register(implement(operator.ge, ty, ty)(builtins.int_uge_impl))
""" Definition of implementations for the `operator` module. """ import operator from numba.targets.imputils import implement, Registry from numba.targets import builtins from numba import types, utils registry = Registry() register = registry.register for ty in types.integer_domain: register(implement(operator.add, ty, ty)(builtins.int_add_impl)) register(implement(operator.sub, ty, ty)(builtins.int_sub_impl)) register(implement(operator.mul, ty, ty)(builtins.int_mul_impl)) register(implement(operator.eq, ty, ty)(builtins.int_eq_impl)) register(implement(operator.ne, ty, ty)(builtins.int_ne_impl)) register(implement(operator.lshift, ty, ty)(builtins.int_shl_impl)) register(implement(operator.and_, ty, ty)(builtins.int_and_impl)) register(implement(operator.or_, ty, ty)(builtins.int_or_impl)) register(implement(operator.xor, ty, ty)(builtins.int_xor_impl)) register(implement(operator.neg, ty)(builtins.int_negate_impl)) register(implement(operator.pos, ty)(builtins.int_positive_impl)) register(implement(operator.invert, ty)(builtins.int_invert_impl)) register(implement(operator.not_, ty)(builtins.number_not_impl)) for ty in types.unsigned_domain: if not utils.IS_PY3: register(implement(operator.div, ty, ty)(builtins.int_udiv_impl))
return cgutils.pack_array(builder, [r1, r2, r3]) # ----------------------------------------------------------------------------- def ptx_sreg_template(sreg): def ptx_sreg_impl(context, builder, sig, args): assert not args return nvvmutils.call_sreg(builder, sreg) return ptx_sreg_impl # Dynamic create all special register for sreg in nvvmutils.SREG_MAPPING.keys(): register(implement(sreg)(ptx_sreg_template(sreg))) # ----------------------------------------------------------------------------- @register @implement('ptx.cmem.arylike', types.Kind(types.Array)) def ptx_cmem_arylike(context, builder, sig, args): lmod = cgutils.get_module(builder) [arr] = args flat = arr.flatten(order='A') aryty = sig.return_type dtype = aryty.dtype if isinstance(dtype, types.Complex): elemtype = (types.float32
""" Definition of implementations for the `operator` module. """ import operator from numba.targets.imputils import implement, Registry from numba.targets import builtins from numba import types, utils registry = Registry() register = registry.register for ty in types.integer_domain: register(implement(operator.add, ty, ty)(builtins.int_add_impl)) register(implement(operator.iadd, ty, ty)(builtins.int_add_impl)) register(implement(operator.sub, ty, ty)(builtins.int_sub_impl)) register(implement(operator.isub, ty, ty)(builtins.int_sub_impl)) register(implement(operator.mul, ty, ty)(builtins.int_mul_impl)) register(implement(operator.imul, ty, ty)(builtins.int_mul_impl)) register(implement(operator.eq, ty, ty)(builtins.int_eq_impl)) register(implement(operator.ne, ty, ty)(builtins.int_ne_impl)) register(implement(operator.lshift, ty, ty)(builtins.int_shl_impl)) register(implement(operator.ilshift, ty, ty)(builtins.int_shl_impl)) register(implement(operator.and_, ty, ty)(builtins.int_and_impl)) register(implement(operator.iand, ty, ty)(builtins.int_and_impl)) register(implement(operator.or_, ty, ty)(builtins.int_or_impl)) register(implement(operator.ior, ty, ty)(builtins.int_or_impl)) register(implement(operator.xor, ty, ty)(builtins.int_xor_impl)) register(implement(operator.ixor, ty, ty)(builtins.int_xor_impl)) register(implement(operator.neg, ty)(builtins.int_negate_impl))
def powi_implement(nvname): def core(context, builder, sig, args): [base, pow] = args [basety, powty] = sig.args lmod = builder.module fty = context.get_value_type(basety) ity = context.get_value_type(types.int32) fnty = Type.function(fty, [fty, ity]) fn = lmod.get_or_insert_function(fnty, name=nvname) return builder.call(fn, [base, pow]) return core register(implement(math.pow, types.float32, types.int32)(powi_implement( '__nv_powif'))) register(implement(math.pow, types.float64, types.int32)( powi_implement('__nv_powi'))) booleans = [] booleans += [('__nv_isnand', '__nv_isnanf', math.isnan)] booleans += [('__nv_isinfd', '__nv_isinff', math.isinf)] unarys = [] unarys += [('__nv_ceil', '__nv_ceilf', math.ceil)] unarys += [('__nv_floor', '__nv_floorf', math.floor)] unarys += [('__nv_fabs', '__nv_fabsf', math.fabs)] unarys += [('__nv_exp', '__nv_expf', math.exp)] if sys.version_info[:2] >= (2, 7): unarys += [('__nv_expm1', '__nv_expm1f', math.expm1)]
def _implement_real_operators(): ty = types.Kind(types.Float) register(implement(operator.add, ty, ty)(builtins.real_add_impl)) register(implement(operator.iadd, ty, ty)(builtins.real_add_impl)) register(implement(operator.sub, ty, ty)(builtins.real_sub_impl)) register(implement(operator.isub, ty, ty)(builtins.real_sub_impl)) register(implement(operator.mul, ty, ty)(builtins.real_mul_impl)) register(implement(operator.imul, ty, ty)(builtins.real_mul_impl)) if not utils.IS_PY3: register(implement(operator.div, ty, ty)(builtins.real_div_impl)) register(implement(operator.idiv, ty, ty)(builtins.real_div_impl)) register(implement(operator.floordiv, ty, ty)(builtins.real_floordiv_impl)) register( implement(operator.ifloordiv, ty, ty)(builtins.real_floordiv_impl)) register(implement(operator.truediv, ty, ty)(builtins.real_div_impl)) register(implement(operator.itruediv, ty, ty)(builtins.real_div_impl)) register(implement(operator.mod, ty, ty)(builtins.real_mod_impl)) register(implement(operator.imod, ty, ty)(builtins.real_mod_impl)) register(implement(operator.pow, ty, ty)(builtins.real_power_impl)) register(implement(operator.ipow, ty, ty)(builtins.real_power_impl)) register(implement(operator.eq, ty, ty)(builtins.real_eq_impl)) register(implement(operator.ne, ty, ty)(builtins.real_ne_impl)) register(implement(operator.lt, ty, ty)(builtins.real_lt_impl)) register(implement(operator.le, ty, ty)(builtins.real_le_impl)) register(implement(operator.gt, ty, ty)(builtins.real_gt_impl)) register(implement(operator.ge, ty, ty)(builtins.real_ge_impl)) register(implement(operator.neg, ty)(builtins.real_negate_impl)) register(implement(operator.pos, ty)(builtins.real_positive_impl)) register(implement(operator.not_, ty)(builtins.number_not_impl))
def _implement_integer_operators(): ty = types.Kind(types.Integer) register(implement(operator.add, ty, ty)(builtins.int_add_impl)) register(implement(operator.iadd, ty, ty)(builtins.int_add_impl)) register(implement(operator.sub, ty, ty)(builtins.int_sub_impl)) register(implement(operator.isub, ty, ty)(builtins.int_sub_impl)) register(implement(operator.mul, ty, ty)(builtins.int_mul_impl)) register(implement(operator.imul, ty, ty)(builtins.int_mul_impl)) register(implement(operator.eq, ty, ty)(builtins.int_eq_impl)) register(implement(operator.ne, ty, ty)(builtins.int_ne_impl)) register(implement(operator.lshift, ty, ty)(builtins.int_shl_impl)) register(implement(operator.ilshift, ty, ty)(builtins.int_shl_impl)) register(implement(operator.and_, ty, ty)(builtins.int_and_impl)) register(implement(operator.iand, ty, ty)(builtins.int_and_impl)) register(implement(operator.or_, ty, ty)(builtins.int_or_impl)) register(implement(operator.ior, ty, ty)(builtins.int_or_impl)) register(implement(operator.xor, ty, ty)(builtins.int_xor_impl)) register(implement(operator.ixor, ty, ty)(builtins.int_xor_impl)) register(implement(operator.neg, ty)(builtins.int_negate_impl)) register(implement(operator.pos, ty)(builtins.int_positive_impl)) register(implement(operator.invert, ty)(builtins.int_invert_impl)) register(implement(operator.not_, ty)(builtins.number_not_impl)) for ty in types.unsigned_domain: if not utils.IS_PY3: register(implement(operator.div, ty, ty)(builtins.int_udiv_impl)) register(implement(operator.idiv, ty, ty)(builtins.int_udiv_impl)) register( implement(operator.floordiv, ty, ty)(builtins.int_ufloordiv_impl)) register( implement(operator.ifloordiv, ty, ty)(builtins.int_ufloordiv_impl)) register( implement(operator.truediv, ty, ty)(builtins.int_utruediv_impl)) register( implement(operator.itruediv, ty, ty)(builtins.int_utruediv_impl)) register(implement(operator.mod, ty, ty)(builtins.int_urem_impl)) register(implement(operator.imod, ty, ty)(builtins.int_urem_impl)) register(implement(operator.lt, ty, ty)(builtins.int_ult_impl)) register(implement(operator.le, ty, ty)(builtins.int_ule_impl)) register(implement(operator.gt, ty, ty)(builtins.int_ugt_impl)) register(implement(operator.ge, ty, ty)(builtins.int_uge_impl)) register( implement(operator.pow, types.float64, ty)(builtins.int_upower_impl)) register( implement(operator.ipow, types.float64, ty)(builtins.int_upower_impl)) register(implement(operator.rshift, ty, ty)(builtins.int_lshr_impl)) register(implement(operator.irshift, ty, ty)(builtins.int_lshr_impl)) for ty in types.signed_domain: if not utils.IS_PY3: register(implement(operator.div, ty, ty)(builtins.int_sdiv_impl)) register(implement(operator.idiv, ty, ty)(builtins.int_sdiv_impl)) register( implement(operator.floordiv, ty, ty)(builtins.int_sfloordiv_impl)) register( implement(operator.ifloordiv, ty, ty)(builtins.int_sfloordiv_impl)) register( implement(operator.truediv, ty, ty)(builtins.int_struediv_impl)) register( implement(operator.itruediv, ty, ty)(builtins.int_struediv_impl)) register(implement(operator.mod, ty, ty)(builtins.int_srem_impl)) register(implement(operator.imod, ty, ty)(builtins.int_srem_impl)) register(implement(operator.lt, ty, ty)(builtins.int_slt_impl)) register(implement(operator.le, ty, ty)(builtins.int_sle_impl)) register(implement(operator.gt, ty, ty)(builtins.int_sgt_impl)) register(implement(operator.ge, ty, ty)(builtins.int_sge_impl)) register( implement(operator.pow, types.float64, ty)(builtins.int_spower_impl)) register( implement(operator.ipow, types.float64, ty)(builtins.int_spower_impl)) register(implement(operator.rshift, ty, ty)(builtins.int_ashr_impl)) register(implement(operator.irshift, ty, ty)(builtins.int_ashr_impl))
def _implement_complex_operators(): ty = types.Kind(types.Complex) register(implement(operator.add, ty, ty)(builtins.complex_add_impl)) register(implement(operator.iadd, ty, ty)(builtins.complex_add_impl)) register(implement(operator.sub, ty, ty)(builtins.complex_sub_impl)) register(implement(operator.isub, ty, ty)(builtins.complex_sub_impl)) register(implement(operator.mul, ty, ty)(builtins.complex_mul_impl)) register(implement(operator.imul, ty, ty)(builtins.complex_mul_impl)) if not utils.IS_PY3: register(implement(operator.div, ty, ty)(builtins.complex_div_impl)) register(implement(operator.idiv, ty, ty)(builtins.complex_div_impl)) register(implement(operator.truediv, ty, ty)(builtins.complex_div_impl)) register(implement(operator.itruediv, ty, ty)(builtins.complex_div_impl)) register(implement(operator.eq, ty, ty)(builtins.complex_eq_impl)) register(implement(operator.ne, ty, ty)(builtins.complex_ne_impl)) register(implement(operator.neg, ty)(builtins.complex_negate_impl)) register(implement(operator.pos, ty)(builtins.complex_positive_impl)) register(implement(operator.not_, ty)(builtins.number_not_impl))
return impl @register @implement(numpy.absolute, types.Kind(types.Array), types.Kind(types.Array)) def numpy_absolute(context, builder, sig, args): imp = numpy_unary_ufunc(types.abs_type) return imp(context, builder, sig, args) def numpy_absolute_scalar_input(context, builder, sig, args): imp = numpy_unary_ufunc(types.abs_type, scalar_input=True) return imp(context, builder, sig, args) for ty in types.number_domain: register(implement(numpy.absolute, ty, types.Kind(types.Array))(numpy_absolute_scalar_input)) def numpy_absolute_scalar(context, builder, sig, args): imp = numpy_scalar_unary_ufunc(types.abs_type) return imp(context, builder, sig, args) for ty in types.number_domain: register(implement(numpy.absolute, ty)(numpy_absolute_scalar)) @register @implement(numpy.exp, types.Kind(types.Array), types.Kind(types.Array)) def numpy_exp(context, builder, sig, args): imp = numpy_unary_ufunc(math.exp, asfloat=True) return imp(context, builder, sig, args)
# FIXME: the current implementation relies on CPython API even in # nopython mode. def int_print_impl(context, builder, sig, args): [x] = args py = context.get_python_api(builder) szval = context.cast(builder, x, sig.args[0], types.intp) intobj = py.long_from_ssize_t(szval) py.print_object(intobj) py.decref(intobj) return context.get_dummy_value() for ty in types.integer_domain: register(implement(types.print_item_type, ty)(int_print_impl)) def real_print_impl(context, builder, sig, args): [x] = args py = context.get_python_api(builder) szval = context.cast(builder, x, sig.args[0], types.float64) intobj = py.float_from_double(szval) py.print_object(intobj) py.decref(intobj) return context.get_dummy_value() for ty in types.real_domain: register(implement(types.print_item_type, ty)(real_print_impl))
timedelta_eq_timedelta_impl = _create_timedelta_comparison_impl(lc.ICMP_EQ, cgutils.false_bit) timedelta_ne_timedelta_impl = _create_timedelta_comparison_impl(lc.ICMP_NE, cgutils.true_bit) timedelta_lt_timedelta_impl = _create_timedelta_ordering_impl(lc.ICMP_SLT) timedelta_le_timedelta_impl = _create_timedelta_ordering_impl(lc.ICMP_SLE) timedelta_gt_timedelta_impl = _create_timedelta_ordering_impl(lc.ICMP_SGT) timedelta_ge_timedelta_impl = _create_timedelta_ordering_impl(lc.ICMP_SGE) for op, func in [('==', timedelta_eq_timedelta_impl), ('!=', timedelta_ne_timedelta_impl), ('<', timedelta_lt_timedelta_impl), ('<=', timedelta_le_timedelta_impl), ('>', timedelta_gt_timedelta_impl), ('>=', timedelta_ge_timedelta_impl)]: builtin(implement(op, *TIMEDELTA_BINOP_SIG)(func)) # Arithmetic on datetime64 def is_leap_year(builder, year_val): """ Return a predicate indicating whether *year_val* (offset by 1970) is a leap year. """ actual_year = builder.add(year_val, Constant.int(DATETIME64, 1970)) multiple_of_4 = cgutils.is_null( builder, builder.and_(actual_year, Constant.int(DATETIME64, 3))) not_multiple_of_100 = cgutils.is_not_null( builder, builder.srem(actual_year, Constant.int(DATETIME64, 100))) multiple_of_400 = cgutils.is_null(
@implement(math.degrees, types.float64) def degrees_f64_impl(context, builder, sig, args): [x] = args full = context.get_constant(types.float64, 360) pi = context.get_constant(types.float64, math.pi) two = context.get_constant(types.float64, 2) twopi = builder.fmul(pi, two) return builder.fmul(builder.fdiv(x, twopi), full) @register @implement(math.degrees, types.float32) def degrees_f32_impl(context, builder, sig, args): [x] = args full = context.get_constant(types.float32, 360) pi = context.get_constant(types.float32, math.pi) two = context.get_constant(types.float32, 2) twopi = builder.fmul(pi, two) return builder.fdiv(builder.fmul(x, full), twopi) unary_math_int_impl(math.degrees, degrees_f64_impl) # ----------------------------------------------------------------------------- for ty in types.unsigned_domain: register(implement(math.pow, types.float64, ty)(builtins.int_upower_impl)) for ty in types.signed_domain: register(implement(math.pow, types.float64, ty)(builtins.int_spower_impl)) for ty in types.real_domain: register(implement(math.pow, ty, ty)(builtins.real_power_impl))
with cgutils.goto_block(builder, bb_postest): builder.cbranch(cmp_pos, bb_pos, bb_neg) with cgutils.goto_block(builder, bb_pos): builder.store(POS, presult) builder.branch(bb_exit) with cgutils.goto_block(builder, bb_neg): builder.store(NEG, presult) builder.branch(bb_exit) builder.position_at_end(bb_exit) return builder.load(presult) builtin(implement('==', types.boolean, types.boolean)(int_eq_impl)) builtin(implement('!=', types.boolean, types.boolean)(int_ne_impl)) builtin(implement('<', types.boolean, types.boolean)(int_ult_impl)) builtin(implement('<=', types.boolean, types.boolean)(int_ule_impl)) builtin(implement('>', types.boolean, types.boolean)(int_ugt_impl)) builtin(implement('>=', types.boolean, types.boolean)(int_uge_impl)) builtin(implement('~', types.boolean)(int_invert_impl)) for ty in types.integer_domain: builtin(implement('+', ty, ty)(int_add_impl)) builtin(implement('-', ty, ty)(int_sub_impl)) builtin(implement('*', ty, ty)(int_mul_impl)) builtin(implement('==', ty, ty)(int_eq_impl)) builtin(implement('!=', ty, ty)(int_ne_impl)) builtin(implement('<<', ty, types.uint32)(int_shl_impl))
mangler=mangle) res = builder.call(fn, args) return context.cast(builder, res, decl_sig.return_type, sig.return_type) core.__name__ = name return core _supported = ['sin', 'cos', 'tan', 'asin', 'acos', 'atan', 'atan2', 'sinh', 'cosh', 'tanh', 'asinh', 'acosh', 'atanh', 'isnan', 'isinf', 'ceil', 'floor', 'fabs', 'sqrt', 'exp', 'expm1', 'log', 'log10', 'log1p', 'copysign', 'pow', 'fmod', 'erf', 'erfc', 'gamma', 'lgamma', ] for name in _supported: sigs = function_descriptors.get(name) if sigs is None: warnings.warn("HSA - failed to register '{0}'".format(name)) continue try: # only symbols present in the math module key = getattr(math, name) except AttributeError: continue for sig in sigs: fn = _mk_fn_decl(name, sig) register(implement(key, *sig.args)(fn))
timedelta_eq_timedelta_impl = _create_timedelta_comparison_impl( lc.ICMP_EQ, cgutils.false_bit) timedelta_ne_timedelta_impl = _create_timedelta_comparison_impl( lc.ICMP_NE, cgutils.true_bit) timedelta_lt_timedelta_impl = _create_timedelta_ordering_impl(lc.ICMP_SLT) timedelta_le_timedelta_impl = _create_timedelta_ordering_impl(lc.ICMP_SLE) timedelta_gt_timedelta_impl = _create_timedelta_ordering_impl(lc.ICMP_SGT) timedelta_ge_timedelta_impl = _create_timedelta_ordering_impl(lc.ICMP_SGE) for op, func in [('==', timedelta_eq_timedelta_impl), ('!=', timedelta_ne_timedelta_impl), ('<', timedelta_lt_timedelta_impl), ('<=', timedelta_le_timedelta_impl), ('>', timedelta_gt_timedelta_impl), ('>=', timedelta_ge_timedelta_impl)]: builtin(implement(op, *TIMEDELTA_BINOP_SIG)(func)) # Arithmetic on datetime64 def is_leap_year(builder, year_val): """ Return a predicate indicating whether *year_val* (offset by 1970) is a leap year. """ actual_year = builder.add(year_val, Constant.int(DATETIME64, 1970)) multiple_of_4 = cgutils.is_null( builder, builder.and_(actual_year, Constant.int(DATETIME64, 3))) not_multiple_of_100 = cgutils.is_not_null( builder, builder.srem(actual_year, Constant.int(DATETIME64, 100))) multiple_of_400 = cgutils.is_null(
[x] = args full = context.get_constant(types.float64, 360) pi = context.get_constant(types.float64, math.pi) two = context.get_constant(types.float64, 2) twopi = builder.fmul(pi, two) return builder.fmul(builder.fdiv(x, twopi), full) @register @implement(math.degrees, types.float32) def degrees_f32_impl(context, builder, sig, args): [x] = args full = context.get_constant(types.float32, 360) pi = context.get_constant(types.float32, math.pi) two = context.get_constant(types.float32, 2) twopi = builder.fmul(pi, two) return builder.fdiv(builder.fmul(x, full), twopi) unary_math_int_impl(math.degrees, degrees_f64_impl) # ----------------------------------------------------------------------------- for ty in types.unsigned_domain: register(implement(math.pow, types.float64, ty)(builtins.int_upower_impl)) for ty in types.signed_domain: register(implement(math.pow, types.float64, ty)(builtins.int_spower_impl)) ty = types.Kind(types.Float) register(implement(math.pow, ty, ty)(builtins.real_power_impl))
# impl "builtins" @register_function @implement('is', AnyVal, ntypes.none) def anyval_is_none_impl(context, builder, sig, args): [x, y] = args val = AnyValStruct(context, builder, value=x) return builder.trunc(val.is_null, lc.Type.int(1)) def starval_is_none_impl(context, builder, sig, args): [x, y] = args x = builder.extract_value(x, 0) val = AnyValStruct(context, builder, value=x) return builder.trunc(val.is_null, lc.Type.int(1)) register_function(implement('is', BooleanVal, ntypes.none)(starval_is_none_impl)) register_function(implement('is', TinyIntVal, ntypes.none)(starval_is_none_impl)) register_function(implement('is', SmallIntVal, ntypes.none)(starval_is_none_impl)) register_function(implement('is', IntVal, ntypes.none)(starval_is_none_impl)) register_function(implement('is', BigIntVal, ntypes.none)(starval_is_none_impl)) register_function(implement('is', FloatVal, ntypes.none)(starval_is_none_impl)) register_function(implement('is', DoubleVal, ntypes.none)(starval_is_none_impl)) @register_function @implement(ntypes.len_type, StringVal) def len_stringval_impl(context, builder, sig, args): [s] = args val = StringValStruct(context, builder, value=s) return val.len @register_function
def unary_math_int_impl(fn, f64impl): impl = _unary_int_input_wrapper_impl(f64impl) for input_type in [types.intp, types.uintp, types.int64, types.uint64]: register(implement(fn, input_type)(impl))
# ----------------------------------------------------------------------------- def ptx_sreg_template(sreg): def ptx_sreg_impl(context, builder, sig, args): assert not args return nvvmutils.call_sreg(builder, sreg) return ptx_sreg_impl # Dynamic create all special register for sreg in nvvmutils.SREG_MAPPING.keys(): register(implement(sreg)(ptx_sreg_template(sreg))) # ----------------------------------------------------------------------------- @register @implement('ptx.cmem.arylike', types.Kind(types.Array)) def ptx_cmem_arylike(context, builder, sig, args): lmod = cgutils.get_module(builder) [arr] = args flat = arr.flatten(order='A') aryty = sig.return_type dtype = aryty.dtype if isinstance(dtype, types.Complex): elemtype = (types.float32
@implement('is', AnyVal, ntypes.none) def anyval_is_none_impl(context, builder, sig, args): [x, y] = args val = AnyValStruct(context, builder, value=x) return builder.trunc(val.is_null, lc.Type.int(1)) def starval_is_none_impl(context, builder, sig, args): [x, y] = args x = builder.extract_value(x, 0) val = AnyValStruct(context, builder, value=x) return builder.trunc(val.is_null, lc.Type.int(1)) register_function( implement('is', BooleanVal, ntypes.none)(starval_is_none_impl)) register_function( implement('is', TinyIntVal, ntypes.none)(starval_is_none_impl)) register_function( implement('is', SmallIntVal, ntypes.none)(starval_is_none_impl)) register_function(implement('is', IntVal, ntypes.none)(starval_is_none_impl)) register_function( implement('is', BigIntVal, ntypes.none)(starval_is_none_impl)) register_function(implement('is', FloatVal, ntypes.none)(starval_is_none_impl)) register_function( implement('is', DoubleVal, ntypes.none)(starval_is_none_impl)) @register_function @implement(ntypes.len_type, StringVal) def len_stringval_impl(context, builder, sig, args):