Example #1
0
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))
Example #2
0
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)
Example #3
0
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))
Example #4
0
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))
Example #5
0
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)
Example #6
0
    '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))
Example #7
0
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))
Example #8
0
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))
Example #9
0
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)]
Example #10
0
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))
Example #11
0
"""
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))
Example #12
0
    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
Example #13
0
"""
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))
Example #14
0
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)]
Example #15
0
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))
Example #16
0
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))
Example #17
0
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))
Example #18
0
    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)
Example #19
0
# 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))
Example #20
0

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(
Example #21
0
@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))

Example #22
0
    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))
Example #23
0
                               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))
Example #24
0
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(
Example #25
0
    [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))
Example #26
0
# 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
Example #27
0
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))
Example #28
0
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))
Example #29
0
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))
Example #30
0

# -----------------------------------------------------------------------------


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
Example #31
0
@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):