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)
