numbakit-anjit 0.2

numbakit-anjit: 利用numba加速常微分方程的积分

numbakit-anjit (nbkanjit) 通过提供 anjit，一个注解感知的numba jit装饰器和管理对象来处理Jit配置，以辅助Numba密集型项目。

它运行在Python 3.7+，依赖于Numba。它遵循BSD许可协议。

使用它非常简单自然

>>> from numba import types as nt
>>> import nbkanjit
>>> @nbkanjit.anjit
... def func(x: nt.float64, y: nt.float64) -> nt.float64:
...     return x + y

您还可以使用映射到numba类型的Python类型

>>> @nbkanjit.anjit
... def func(x: float, y: float) -> float:
...     return x + y

。

您可以使用

>>> from nbkanjit import Function as F_
>>> @nbkanjit.anjit
... def func1(x: int, y: float) -> float:
...     return x + y
>>> def func2(x: int, y: F_(funct1)._return) -> float:
...     return x + y

您还可以使用任何参数的注解。例如，在此情况下，F_(func).x 等同于 int。甚至是一个完整的函数 F_(func)，它将返回 FunctionType(float64(int, float64))

它还提供了一个管理器来封装（并重复使用不同的参数）

>>> import nbkanjit
>>> jm = nbkanjit.JitManager(cache=True)
>>> @jm.anjit
... def func(x: float, y:float) -> nt.float64:
...     return x + y

甚至应用于标准的numba njit。

>>> jm = nbkanjit.JitManager(cache=True)
>>> @jm.njit
... def func(x, y):
...     return x + y

您可以通过将任何Python对象映射到numba类型来教会管理器新技巧

>>> jm.mapping["array1d"] = nt.float64[:]

。

并且有一种方法将签名注册为模板（tmpl）

>>> import nbkanjit
>>> jm = nbkanjit.JitManager()
>>> jm.register("nice", nt.float64((nt.float64, nt.float64)))

然后通过显式命名或使用函数名来使用它

>>> @jm.njit_tmpl("nice")
... def other_func(x, y):
...     return x + y

或使用函数名

>>> @jm.njit_tmpl
... def nice(x, y):
...     return x + y

您可以直接从函数注册

>>> @jm.register("nice")
... def _(x: float, y:float) -> nt.float64:
...     pass

或再次使用函数名

>>> @jm.register
... def nice(x: float, y:float) -> nt.float64:
...     pass

$ pip install numbakit-anjit

$ conda install -c conda-forge numbakit-anjit

in [Lazy mode], compilation will be deferred until the first function
execution. Numba will infer the argument types at call time, and
generate optimized code based on this information. Numba will also
be able to compile separate specializations depending on the input
types.

In which you can also tell Numba the function signature you are expecting.
[..] In this case, the corresponding specialization will be compiled by the
decorator, and no other specialization will be allowed. This is useful
if you want fine-grained control over types chosen by the compiler (for
example, to use single-precision floats).