def _jit_decorator(func): if isinstance(func, CLASS_TYPES): cls = func kwargs.update(env_name=env_name) return jit_extension_class(cls, kwargs, env) argtys = argtypes if argtys is None and restype: assert restype.is_function return_type = restype.return_type argtys = restype.args elif argtys is None: assert func.__code__.co_argcount == 0, func return_type = None argtys = [] else: return_type = restype assert argtys is not None env.specializations.register(func) assert kwargs.get('llvm_module') is None # TODO link to user module assert kwargs.get('llvm_ee') is None, "Engine should never be provided" sig, lfunc, wrapper = compile_function( env, func, argtys, restype=return_type, nopython=nopython, **kwargs) return numbawrapper.create_numba_wrapper(func, wrapper, sig, lfunc)
def _jit_decorator(func): if isinstance(func, CLASS_TYPES): cls = func kwargs.update(env_name=env_name) return jit_extension_class(cls, kwargs, env) argtys = argtypes if argtys is None and restype: assert restype.is_function return_type = restype.return_type argtys = restype.args elif argtys is None: assert func.__code__.co_argcount == 0, func return_type = None argtys = [] else: return_type = restype assert argtys is not None env.specializations.register(func) assert kwargs.get('llvm_module') is None # TODO link to user module assert kwargs.get('llvm_ee') is None, "Engine should never be provided" sig, lfunc, wrapper = compile_function(env, func, argtys, restype=return_type, nopython=nopython, func_ast=func_ast, **kwargs) return numbawrapper.create_numba_wrapper(func, wrapper, sig, lfunc)
def jit(restype=None, argtypes=None, backend='ast', target='cpu', nopython=False, **kws): """ Compile a function given the input and return types. There are multiple ways to specify the type signature: * Using the restype and argtypes arguments, passing Numba types. * By constructing a Numba function type and passing that as the first argument to the decorator. You can create a function type by calling an exisiting Numba type, which is the return type, and the arguments to that call define the argument types. For example, ``f8(f8)`` would create a Numba function type that takes a single double-precision floating point value argument, and returns a double-precision floating point value. * As above, but using a string instead of a constructed function type. Example: ``jit("f8(f8)")``. If backend='bytecode' the bytecode translator is used, if backend='ast' the AST translator is used. By default, the AST translator is used. *Note that the bytecode translator is deprecated as of the 0.3 release.* """ kws.update(nopython=nopython, backend=backend) if isinstance(restype, CLASS_TYPES): cls = restype env = kws.pop('env', None) or environment.NumbaEnvironment.get_environment( kws.get('env_name', None)) return jit_extension_class(cls, kws, env) # Called with f8(f8) syntax which returns a dictionary of argtypes and restype if isinstance(restype, typesystem.function): if argtypes is not None: raise TypeError( "Cannot use both calling syntax and argtypes keyword") argtypes = restype.args restype = restype.return_type # Called with a string like 'f8(f8)' elif isinstance(restype, str) and argtypes is None: signature = process_signature(restype, kws.get('name', None)) name, restype, argtypes = (signature.name, signature.return_type, signature.args) if name is not None: kws['func_name'] = name if restype is not None: kws['restype'] = restype if argtypes is not None: kws['argtypes'] = argtypes return jit_targets[target, backend](**kws)
def jit(restype=None, argtypes=None, backend='ast', target='cpu', nopython=False, **kws): """ Compile a function given the input and return types. There are multiple ways to specify the type signature: * Using the restype and argtypes arguments, passing Numba types. * By constructing a Numba function type and passing that as the first argument to the decorator. You can create a function type by calling an exisiting Numba type, which is the return type, and the arguments to that call define the argument types. For example, ``f8(f8)`` would create a Numba function type that takes a single double-precision floating point value argument, and returns a double-precision floating point value. * As above, but using a string instead of a constructed function type. Example: ``jit("f8(f8)")``. If backend='bytecode' the bytecode translator is used, if backend='ast' the AST translator is used. By default, the AST translator is used. *Note that the bytecode translator is deprecated as of the 0.3 release.* """ kws.update(nopython=nopython, backend=backend) if isinstance(restype, CLASS_TYPES): cls = restype env = kws.pop('env', None) or environment.NumbaEnvironment.get_environment( kws.get('env_name', None)) return jit_extension_class(cls, kws, env) # Called with f8(f8) syntax which returns a dictionary of argtypes and restype if isinstance(restype, typesystem.function): if argtypes is not None: raise TypeError("Cannot use both calling syntax and argtypes keyword") argtypes = restype.args restype = restype.return_type # Called with a string like 'f8(f8)' elif isinstance(restype, str) and argtypes is None: signature = process_signature(restype, kws.get('name', None)) name, restype, argtypes = (signature.name, signature.return_type, signature.args) if name is not None: kws['func_name'] = name if restype is not None: kws['restype'] = restype if argtypes is not None: kws['argtypes'] = argtypes return jit_targets[target, backend](**kws)