def load_ool_module(): """ Compile an out-of-line module, return the corresponding ffi and module objects. """ from cffi import FFI defs = """ double sin(double x); double cos(double x); void vsSin(int n, float* x, float* y); void vdSin(int n, double* x, double* y); int foo(int a, int b, int c); """ source = """ static int foo(int a, int b, int c) { return a + b * c; } void vsSin(int n, float* x, float* y) { int i; for (i=0; i<n; i++) y[i] = sin(x[i]); } void vdSin(int n, double* x, double* y) { int i; for (i=0; i<n; i++) y[i] = sin(x[i]); } """ ffi = FFI() ffi.set_source('cffi_usecases_ool', source) ffi.cdef(defs, override=True) tmpdir = static_temp_directory('test_cffi') ffi.compile(tmpdir=tmpdir) sys.path.append(tmpdir) try: import cffi_usecases_ool as mod cffi_support.register_module(mod) return mod.ffi, mod finally: sys.path.remove(tmpdir)
import numpy as np from numba import njit, cffi_support import _ndtri from _ndtri import lib, ffi cffi_support.register_module(_ndtri) _ndtri = lib.ndtri @njit def ndtri(q): return _ndtri(q)
from pywigxjpf_ffi import ffi, lib import pywigxjpf_ffi import time import numba from numba import cffi_support cffi_support.register_module(pywigxjpf_ffi) nb_wig3jj = pywigxjpf_ffi.lib.wig3jj lib.wig_table_init(100, 9) lib.wig_temp_init(100) print(lib.wig3jj(5, 6, 7, 3, 4, -7)) print(lib.wig6jj(6, 6, 6, 6, 6, 6)) print(lib.wig9jj(6, 6, 6, 7, 7, 6, 7, 7, 8)) print(lib.wig9jj(6, 6, 6, 7, 7, 6, 7, 7, 8)) print(lib.wig6jj(6, 6, 6, 6, 6, int(4 + 0.5 * 4))) # Benchmark 1, make calls for a lot of trivially-0 symbols. @numba.jit(nopython=True) def benchmark(jjmax): sum = 0.0 calls = 0 for jj1 in range(0, jjmax + 1): for jj2 in range(0, jjmax + 1): for jj3 in range(0, jjmax + 1): for mm1 in range(-jjmax, jjmax + 1): for mm2 in range(-jjmax, jjmax + 1): for mm3 in range(-jjmax, jjmax + 1): w = nb_wig3jj(jj1, jj2, jj3, \
# Import our Rmath module import _rmath_ffi dnorm = _rmath_ffi.lib.dnorm pnorm = _rmath_ffi.lib.pnorm dunif = _rmath_ffi.lib.dunif punif = _rmath_ffi.lib.punif dgamma = _rmath_ffi.lib.dgamma pgamma = _rmath_ffi.lib.pgamma from numba import cffi_support cffi_support.register_module(_rmath_ffi) @nb.jit(nopython=True) def pnorm_nb(x): y = np.empty_like(x) for k in range(x.shape[0]): y[k] = pnorm(x[k], 0.0, 1.0, 1, 0) return y @nb.vectorize(nopython=True) def pnorm_nb_vec(x): return pnorm(x, 0.0, 1.0, 1, 0) x = np.random.normal(size=(100,))
from numba import jit, prange, types, cffi_support import numpy as np import time import sys from _writer import ffi, lib import _writer # from ._writer import ffi, lib # from . import _writer cffi_support.register_module(_writer) write = _writer.lib.write_data @jit((types.Array(types.float32, 2, "A"), types.int32), nopython=True, nogil=True, parallel=True, fastmath=True, cache=False) def activity_score(a, buffer_size): """Calculate activity score for column pairs. If Args: a (np.array[np.float32]): 2d array with data buffer_size (int32): size of buffer per thread. If buffer_size>a.shape[1]**2, "small data" mode is used Returns: if "small data" mode: np.array[np.float32]: 1D array with maximum interquantile range for each column pair np.array[np.float32]: 1D array with (1-spearman correlation) score for each column pair else:
from __future__ import unicode_literals from . import _cprob_ffi from ._cprob_ffi.lib import * try: from numba import cffi_support as _cffi_support _cffi_support.register_module(_cprob_ffi) except ImportError: pass
from numba import njit import chess import itertools import functools from chess.polyglot import POLYGLOT_RANDOM_ARRAY, zobrist_hash from numba import cffi_support from cffi import FFI ffi = FFI() import khash_numba._khash_ffi as khash_ffi cffi_support.register_module(khash_ffi) khash_init = khash_ffi.lib.khash_int2int_init khash_get = khash_ffi.lib.khash_int2int_get khash_set = khash_ffi.lib.khash_int2int_set khash_destroy = khash_ffi.lib.khash_int2int_destroy @njit def create_index_table(ids): table = khash_init() for j in range(len(ids)): khash_set(table, ids[j], j) return table
import numpy as np from numba import njit, cffi_support import _hyper from _hyper import lib, ffi cffi_support.register_module(_hyper) _hyp2f1 = lib.hyp2f1 _vd_hyp2f1 = lib.vd_hyp2f1 @njit def hyp2f1(a, b, c, x): """Gauss hypergeometric function 2F1. Parameters ---------- a, b, c, x : float """ if x == 1.0: return np.inf return _hyp2f1(a, b, c, x) @njit def vd_hyp2f1(a, b, c, x): """ Gauss hypergeometric function 2F1 vectorized for float x.
void vdSin(int n, double* x, double* y) { int i; for (i=0; i<n; i++) y[i] = sin(x[i]); } """ ffi_ool = FFI() ffi.set_source('cffi_usecases_ool', source) ffi.cdef(defs, override=True) tmpdir = static_temp_directory('test_cffi') ffi.compile(tmpdir=tmpdir) sys.path.append(tmpdir) try: import cffi_usecases_ool cffi_support.register_module(cffi_usecases_ool) cffi_sin_ool = cffi_usecases_ool.lib.sin cffi_cos_ool = cffi_usecases_ool.lib.cos cffi_foo = cffi_usecases_ool.lib.foo vsSin = cffi_usecases_ool.lib.vsSin vdSin = cffi_usecases_ool.lib.vdSin finally: sys.path.remove(tmpdir) def use_cffi_sin(x): return cffi_sin(x) * 2 def use_two_funcs(x): return cffi_sin(x) - cffi_cos(x)
import importlib import numba import numpy as np from numba import types from numba.typed import Dict from numba.cffi_support import register_module loaded = importlib.import_module('_utils') register_module(loaded) get_seconds_since_epoch = loaded.lib.get_seconds_since_epoch print_char_int = loaded.lib.print_char print_float = loaded.lib.print_float print_bar = loaded.lib.print_bar print_info_bar = loaded.lib.print_info_bar print_remaining = loaded.lib.print_remaining @numba.jit(nopython=True) def numba_ord(chr): if chr == '=': return 61 elif chr == '.': return 46 elif chr == '>': return 62 elif chr == '[': return 91 elif chr == ']':
import numpy as np from numba import cffi_support, float32, float64, vectorize import _chi2 from _chi2 import lib, ffi cffi_support.register_module(_chi2) _chdtr = lib.chdtr _chdtrc = lib.chdtrc _chdtri = lib.chdtri @vectorize([float64(float64, float64), float32(float32, float32)]) def cdf(x, df): return _chdtr(df, x) @vectorize([float64(float64, float64), float32(float32, float32)]) def ppf(p, df): return _chdtri(df, 1.0-p) @vectorize([float64(float64, float64), float32(float32, float32)]) def sf(p, df): return _chdtrc(df, p) @vectorize([float64(float64, float64), float32(float32, float32)]) def isf(p, df): return _chdtri(df, p)
import numpy as np from numba import jit, cffi_support from . import _cnufft cffi_support.register_module(_cnufft) nufft3d1 = _cnufft.lib.nufft3d1 @jit(nopython=True) def njit_nufft3d1(x, y, z, c, ms, mt, mu, df=1, eps=1e-15, iflag=1, direct=False): nj = x.shape[0] x = np.ascontiguousarray(x) y = np.ascontiguousarray(y) z = np.ascontiguousarray(z) c = np.ascontiguousarray(c) fk = np.ascontiguousarray(np.zeros((ms * mt * mu * 2))) return_code = nufft3d1(np.int32(nj), cffi_support.ffi.from_buffer(x.view(np.float64)), cffi_support.ffi.from_buffer(y.view(np.float64)),
from __future__ import unicode_literals from . import _ellf_ffi from ._ellf_ffi.lib import * try: from numba import cffi_support as _cffi_support _cffi_support.register_module(_ellf_ffi) except ImportError: pass
from __future__ import print_function import numpy as np import numba as nb from numba import cffi_support import _rmath_ffi cffi_support.register_module(_rmath_ffi) pnorm = _rmath_ffi.lib.pnorm qnorm = _rmath_ffi.lib.qnorm runif = _rmath_ffi.lib.runif set_seed = _rmath_ffi.lib.set_seed set_seed(123, 456) @nb.njit def f(): zlo = np.random.random() zhi = np.random.random() if zlo > 0.0: plo = pnorm(-zhi, 0.0, 1.0, 1, 0) phi = pnorm(-zlo, 0.0, 1.0, 1, 0) else: plo = pnorm(zlo, 0.0, 1.0, 1, 0) phi = pnorm(zhi, 0.0, 1.0, 1, 0) p = runif(plo, phi)
import cffi ffi = cffi.FFI() import numpy as np from numba import cffi_support import numbaflow._tensorflow_ffi as _tensorflow_ffi cffi_support.register_module(_tensorflow_ffi) get_info_struct = _tensorflow_ffi.lib.create_run_info close_info_struct = _tensorflow_ffi.lib.close_run_info sess_run = _tensorflow_ffi.lib.sess_run def create_eval_fn(): info_struct = get_info_struct() def evaluator(pieces, masks): returned_pointer = sess_run( info_struct, ffi.cast("uint8_t *", ffi.from_buffer(pieces)), ffi.cast("uint64_t *", ffi.from_buffer(masks)), len(masks), len(pieces)) result_buff = ffi.buffer(returned_pointer)
"""Wrappers to the functions in the extension module built by `build_ssht_cffi.py` The function signatures are defined in the SSHT docs. """ import cffi import numba as nb import numpy as np from numba import cffi_support from . import _ssht_cffi ffi = cffi.FFI() # allows numba to use functions from this module in nopython mode cffi_support.register_module(_ssht_cffi) # tells numba how to map numba types to the types defined in the cffi function signatures cffi_support.register_type(ffi.typeof("double _Complex"), nb.types.complex128) cffi_support.register_type(ffi.typeof("double _Complex *"), nb.types.CPointer(nb.types.complex128)) __all__ = [ "mw_forward_sov_conv_sym", "mw_inverse_sov_sym", "mw_forward_sov_conv_sym_real", "mw_inverse_sov_sym_real", "mw_forward_sov_conv_sym_ss", "mw_inverse_sov_sym_ss", "mw_forward_sov_conv_sym_ss_real", "mw_inverse_sov_sym_ss_real", "ind2elm",
def load_ool_module(): """ Compile an out-of-line module, return the corresponding ffi and module objects. """ from cffi import FFI numba_complex = """ typedef struct _numba_complex { double real; double imag; } numba_complex; """ defs = numba_complex + """ double sin(double x); double cos(double x); int foo(int a, int b, int c); void vsSin(int n, float* x, float* y); void vdSin(int n, double* x, double* y); void vector_real(numba_complex *c, double *real, int n); void vector_imag(numba_complex *c, double *imag, int n); """ source = numba_complex + """ static int foo(int a, int b, int c) { return a + b * c; } void vsSin(int n, float* x, float* y) { int i; for (i=0; i<n; i++) y[i] = sin(x[i]); } void vdSin(int n, double* x, double* y) { int i; for (i=0; i<n; i++) y[i] = sin(x[i]); } static void vector_real(numba_complex *c, double *real, int n) { int i; for (i = 0; i < n; i++) real[i] = c[i].real; } static void vector_imag(numba_complex *c, double *imag, int n) { int i; for (i = 0; i < n; i++) imag[i] = c[i].imag; } """ ffi = FFI() ffi.set_source('cffi_usecases_ool', source) ffi.cdef(defs, override=True) tmpdir = temp_directory('test_cffi') ffi.compile(tmpdir=tmpdir) sys.path.append(tmpdir) try: mod = import_dynamic('cffi_usecases_ool') cffi_support.register_module(mod) cffi_support.register_type(mod.ffi.typeof('struct _numba_complex'), complex128) return mod.ffi, mod finally: sys.path.remove(tmpdir)
import numpy as np from numba import cffi_support, float32, float64, vectorize import _igam from _igam import lib, ffi cffi_support.register_module(_igam) _igam = lib.igam _igamc = lib.igamc @vectorize([float64(float64, float64), float32(float32, float32)]) def lower(s, x): return _igam(s, x) @vectorize([float64(float64, float64), float32(float32, float32)]) def upper(s, x): return _igamc(s, x)
from __future__ import unicode_literals from . import _misc_ffi from ._misc_ffi.lib import * try: from numba import cffi_support as _cffi_support _cffi_support.register_module(_misc_ffi) except ImportError: pass
from __future__ import absolute_import, print_function, division import numpy as np import numba as nb from numba.targets.registry import CPUDispatcher from numba.cffi_support import register_module from . import _wrapper from ._wrapper import lib, ffi register_module(_wrapper) start_instrumentation = lib.start_instrumentation stop_instrumentation = lib.stop_instrumentation zero_stats = lib.zero_stats dump_stats = lib.dump_stats dump_stats_at = lib.dump_stats_at def _wrap_numba(func, tag=None): if not isinstance(func, CPUDispatcher): raise TypeError("Not a numba dispatch function") if tag is None: @nb.jit(**func.targetoptions) def inner(*args): zero_stats() start_instrumentation() res = func(*args) stop_instrumentation()