def test_missing_module(self):
with self.assertRaises(ImportError) as raises:
get_cython_function_address("fakemodule", "fakefunction")
# The quotes are not there in Python 2
msg = "No module named '?fakemodule'?"
match = re.match(msg, str(raises.exception))
self.assertIsNotNone(match)
def test_missing_module(self):
with self.assertRaises(ImportError) as raises:
addr = get_cython_function_address("fakemodule", "fakefunction")
# The quotes are not there in Python 2
msg = "No module named '?fakemodule'?"
match = re.match(msg, str(raises.exception))
self.assertIsNotNone(match)
def test_getting_function(self):
addr = get_cython_function_address("scipy.special.cython_special",
"j0")
functype = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double)
_j0 = functype(addr)
j0 = jit(nopython=True)(lambda x: _j0(x))
self.assertEqual(j0(0), 1)
def test_missing_function(self):
with self.assertRaises(ValueError) as raises:
addr = get_cython_function_address("scipy.special.cython_special", "foo")
msg = (
"No function 'foo' found in __pyx_capi__ of 'scipy.special.cython_special'"
)
self.assertEqual(msg, str(raises.exception))
def cy_unboxer(self):
'''
Return the address of the cython generated C(++) function which
provides the actual DAAL C++ pointer for our result/model Python object.
'''
addr = get_cython_function_address("_daal4py", 'unbox_'+self.spec.c_name)
return addr
def _make_betainc():
addr = get_cython_function_address('scipy.special.cython_special',
'betainc')
betainc_type = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double,
ctypes.c_double, ctypes.c_double)
func = betainc_type(addr)
return func
def get_special_function_pointer(ctypes_signature, function_name):
try:
address = get_cython_function_address(
'scipy.special.cython_special',
function_name,
)
except ValueError:
return None
return ctypes.CFUNCTYPE(*ctypes_signature)(address)
def get_chunked_array_xarray_value(element_type, element_type_name):
addr = get_cython_function_address(
self.override_module_name,
"ChunkedArray_" + element_type_name + "Array_Value",
)
ChunkedArray_xArray_Value = ctypes.CFUNCTYPE(
element_type, ctypes.c_voidp, ctypes.c_uint64,
ctypes.c_uint64)(addr)
return ChunkedArray_xArray_Value
def get_cython_function_address_with_defaults(full_function_name, default_module_name, default_function_name):
module_name = None
function_name = None
if full_function_name:
i = full_function_name.rfind(".")
if i >= 0:
module_name = full_function_name[:i]
function_name = full_function_name[i + 1 :]
else:
function_name = full_function_name
return get_cython_function_address(module_name or default_module_name, function_name or default_function_name)
def generate_signatures_dicts(signature_to_pointer):
name_to_numba_signatures = collections.defaultdict(list)
name_and_types_to_pointer = {}
for mangled_name, *signature in signature_to_pointer.keys():
name = de_mangle_function_name(mangled_name)
name_to_numba_signatures[name].append(tuple(signature[1:]))
key = (name, ) + tuple(signature[1:])
address = (get_cython_function_address('scipy.special.cython_special',
mangled_name))
ctypes_signature = [NUMBA_TO_CTYPES[t] for t in signature]
ctypes_cast = (ctypes.CFUNCTYPE(*ctypes_signature))
name_and_types_to_pointer[key] = ctypes_cast(address)
name_to_numba_signatures = {
name: tuple(signatures)
for name, signatures in name_to_numba_signatures.items()
}
return name_to_numba_signatures, name_and_types_to_pointer
thresh = beta - alpha
if thresh < -1:
matrix[n_t, n_r] += scale * 0.5 * erfcx(-thresh) * np.exp(
-beta * beta)
else:
matrix[n_t, n_r] += (scale * 0.5 * (1 + erf(thresh)) *
np.exp(alpha * (alpha - 2 * beta)))
if backsweep:
x1 = np.exp(-r_n * (t_n - center + backsweep_period))
x2 = np.exp(-r_n * ((backsweep_period / 2) - (t_n - center)))
x3 = np.exp(-r_n * backsweep_period)
matrix[n_t, n_r] += scale * (x1 + x2) / (1 - x3)
import ctypes # noqa: E402
# This is a work around to use scipy.special function with numba
from numba.extending import get_cython_function_address # noqa: E402
_dble = ctypes.c_double
functype = ctypes.CFUNCTYPE(_dble, _dble)
erf_addr = get_cython_function_address("scipy.special.cython_special",
"__pyx_fuse_1erf")
erfcx_addr = get_cython_function_address("scipy.special.cython_special",
"__pyx_fuse_1erfcx")
erf = functype(erf_addr)
erfcx = functype(erfcx_addr)
from numba.extending import get_cython_function_address
__ffi = cffi.FFI()
__uplo_U = np.array([ord('U')], dtype=np.int8)
__uplo_L = np.array([ord('L')], dtype=np.int8)
__trans_N = np.array([ord('N')], dtype=np.int8)
__trans_T = np.array([ord('T')], dtype=np.int8)
__trans_C = np.array([ord('C')], dtype=np.int8)
__diag_U = np.array([ord('U')], dtype=np.int8)
__diag_N = np.array([ord('N')], dtype=np.int8)
__inc_1 = np.ones(1, dtype=np.int32)
__dtrsv = __ffi.cast(
"void (*) (char*, char*, char*, int*, double*, int*, double*, int*)",
get_cython_function_address("scipy.linalg.cython_blas", "dtrsv"))
__dposv = __ffi.cast(
"void (*) (char*, int*, int*, double*, int*, double*, int*, int*)",
get_cython_function_address("scipy.linalg.cython_lapack", "dposv"))
@n.njit(n.void(n.boolean, n.boolean, n.double[:, ::1], n.double[::1]),
nogil=True)
def _dtrsv(lower, trans, a, x):
inc1 = __ffi.from_buffer(__inc_1)
# dtrsv uses Fortran-layout arrays. Because we use C-layout arrays, we will
# invert the meaning of 'lower' and 'trans', and the function will work fine.
# We also need to swap index orders
uplo = __uplo_U if lower else __uplo_L
tspec = __trans_N if trans else __trans_T
import ctypes
from math import erf
import numba as nb
from numba import njit
from numba.extending import get_cython_function_address
import numpy as np
import scipy.stats as stats
from .statsutils import chi_test, kruskal, kendalltau
# Import erfinv from scipy special into numba
addr = get_cython_function_address("scipy.special.cython_special", "erfinv")
functype = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double)
erfinv_fn = functype(addr)
@njit
def resample_strat(x, y, n_classes):
"""
Resampling (bootstrapping) of x stratified according to y.
Parameters
----------
x: numpy array
Typically a matrix nxm with n samples and m variables.
y: numpy array (1D)
The class variable we are stratifying against.
n_classes: int
The number of classes in y.
Returns
-------
<capsule object "double (double, double, int __pyx_skip_dispatch)" at 0x7f7148cbf480>)]
```
We get a list of tuples consisting of the function name (__pyx_fuse_...) and the type signature (<capsule object ....).
Clearly ```__pyx_fuse_0kve``` and ```__pyx_fuse_1kve``` correspond to the function ```scipy.special.kve``` which is not what we want.
```__pyx_fuse_0kv``` takes complex values as input and output parameter, also not what we want.
So, ```__pyx_fuse_1kv``` seems to be the right one, acting on doubles!
[1] https://numba.pydata.org/numba-doc/dev/extending/high-level.html#importing-cython-functions
[2] https://www.bountysource.com/issues/78681198-questions-about-__pyx_capi__-use-stability
"""
import ctypes
from numba.extending import get_cython_function_address
addr = get_cython_function_address("scipy.special.cython_special", "__pyx_fuse_1kv")
functype = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double, ctypes.c_double)
kv = functype(addr)
addr = get_cython_function_address("scipy.special.cython_special", "__pyx_fuse_1gamma")
functype = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double)
gamma = functype(addr)
# small test to make sure we have the correct thing
if __name__ == '__main__':
import numpy as np
import scipy.special as ss
for x in [0.2, 0.5, 1, 1.5, 2]:
np.testing.assert_allclose(ss.gamma(x), gamma(x))
# import numpy as np
# from scipy.linalg.cython_lapack cimport dpotrf, dpotrs
# --- wrappers to BLAS/LAPACK functions ----------------------------------------
# necessary ctypes
_PTR = ctypes.POINTER
_float = ctypes.c_float
_double = ctypes.c_double
_int = ctypes.c_int
_float_p = _PTR(_float)
_double_p = _PTR(_double)
_int_p = _PTR(_int)
# dpotrf (cho_factor for doubles)
addr = get_cython_function_address('scipy.linalg.cython_lapack', 'dpotrf')
functype = ctypes.CFUNCTYPE(
None,
_int_p, # UPLO
_int_p, # N
_double_p, # U
_int_p, # LDA
_int_p, # INFO
)
_dpotrf = functype(addr)
# cho_factor: float
addr = get_cython_function_address('scipy.linalg.cython_lapack', 'spotrf')
functype = ctypes.CFUNCTYPE(
None,
_int_p, # UPLO
_int_p, # N
[2 * (bd + ac), 2 * (cd - ab), aa + dd - bb - cc]])
@jit(nopython=True)
def rotate_by_theta(n, theta):
"""rotates vector n by theta in random direction"""
axis = np.random.randn(3)
axis -= numba_dot(axis, n) * n / numba_norm(n) ** 2
axis /= numba_norm(axis)
return numba_dot(rotation_matrix(axis, theta), n)
# numba optimized Voigt function using numba wrapper around scipy.wofz (Faddeeva function)
# see https://github.com/numba/numba/issues/3086
# python setup.py build_ext --inplace
_PTR = ctypes.POINTER
_dble = ctypes.c_double
_ptr_dble = _PTR(_dble)
addr = get_cython_function_address("special", "wofz")
functype = ctypes.CFUNCTYPE(None, _dble, _dble, _ptr_dble, _ptr_dble)
wofz_fn = functype(addr)
@jit(nopython=True)
def numba_Voigt(a, x):
out_real = np.empty(1, dtype=np.float64)
out_imag = np.empty(1, dtype=np.float64)
wofz_fn(x, a, out_real.ctypes, out_imag.ctypes)
return out_real[0]
import ctypes
from math import gamma, erfc
import numba as nb
from numba import njit, vectorize, uint64
from numba.extending import get_cython_function_address
import numpy as np
addr = get_cython_function_address("scipy.special.cython_special", "chdtrc")
functype = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double, ctypes.c_double)
chdtrc_fn = functype(addr)
@vectorize('float64(float64, float64)')
def vec_chdtrc(x, y):
return chdtrc_fn(x, y)
@njit
def chdtrc(x, y):
return vec_chdtrc(x, y)
###############################
##### Independence Tests ######
###############################
@njit
def kruskal(x, y):
alldata = np.concatenate((x, y))
ranked = rankdata(alldata, use_missing=False)
ties = tiecorrect(ranked[ranked>1])
import matplotlib.pyplot as plt
import nlopt
import numpy as np
from numba import njit
from numba import vectorize
from numba.extending import get_cython_function_address
from scipy import special
from tables import ComplexCol
from tables import Float64Col
from tables import IsDescription
from tables import open_file
from tqdm import tqdm
from SiPANN import scee
addr = get_cython_function_address("scipy.special.cython_special", "binom")
functype = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double, ctypes.c_double)
binom_fn = functype(addr)
##################################################
### HELPER FUNCTIONS ###
### used to help quickly define gap functions ###
##################################################
@njit
def bernstein_quick(n, j, t):
"""Quickly computes the jth bernstein polynomial for the basis of n+1
polynomials.
Parameters
def __init__(self,
orig_typ,
addr_func,
addr_func_name=None,
override_module_name=None):
# HACK: No super call
class Type(numba.types.Type):
def __init__(self, chunk_type):
super().__init__(name=orig_typ.__name__ + "[" +
chunk_type.__name__ + "]")
self.chunk_type = chunk_type
@property
def key(self):
return (self.name, self.chunk_type)
typs = {k: Type(c) for k, c in _array_type_map.items()}
@typeof_impl.register(orig_typ)
def typeof_(val, c):
_ = c
return typs[val.type]
_ = typeof_
self._build_model(Type)
self.Type = Type
self.types = typs
self.type_name = orig_typ.__name__
self.module_name = orig_typ.__module__
self.override_module_name = override_module_name or self.module_name
self.orig_type = orig_typ
self.addr_func = self._build_unbox_by_call(addr_func, addr_func_name)
addr = get_cython_function_address(self.override_module_name,
"ChunkedArray_length")
ChunkedArray_length = ctypes.CFUNCTYPE(ctypes.c_uint64,
ctypes.c_voidp)(addr)
@overload(len)
def overload_len(v):
if isinstance(v, self.Type):
def impl_(v):
return ChunkedArray_length(v.ptr)
return impl_
return None
_ = overload_len
addr = get_cython_function_address(self.override_module_name,
"ChunkedArray_num_chunks")
ChunkedArray_num_chunks = ctypes.CFUNCTYPE(ctypes.c_uint64,
ctypes.c_voidp)(addr)
addr = get_cython_function_address(self.override_module_name,
"ChunkedArray_Array_chunk_length")
ChunkedArray_Array_chunk_length = ctypes.CFUNCTYPE(
ctypes.c_uint64, ctypes.c_voidp, ctypes.c_uint64)(addr)
@overload_method(self.Type, "convert_index")
def overload_convert_index(v, i):
if isinstance(v, self.Type):
if isinstance(i, numba.types.UniTuple) and i.types == (
numba.types.uint64,
numba.types.uint64,
):
def impl_pair_index(v, i):
_ = v
return i
return impl_pair_index
def impl_single_index(v, i):
chunk = 0
while True: # contains break
chunk_len = ChunkedArray_Array_chunk_length(
v.ptr, chunk)
if i < chunk_len:
break
i -= chunk_len
chunk += 1
return (chunk, i)
return impl_single_index
return None
_ = overload_convert_index
addr = get_cython_function_address(self.override_module_name,
"ChunkedArray_Array_is_valid")
ChunkedArray_is_valid = ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_voidp,
ctypes.c_uint64,
ctypes.c_uint64)(addr)
@overload_method(self.Type, "is_valid")
def overload_is_valid(v, ind):
_ = v
_ = ind
def impl_(v, ind):
c, i = v.convert_index(ind)
return ChunkedArray_is_valid(v.ptr, c, i)
return impl_
_ = overload_is_valid
@overload_method(self.Type, "is_null")
def overload_is_null(v, ind):
_ = v
_ = ind
def impl_(v, ind):
c, i = v.convert_index(ind)
return not ChunkedArray_is_valid(v.ptr, c, i)
return impl_
_ = overload_is_null
@overload_method(self.Type, "indicies")
def overload_indicies(v):
_ = v
def impl_(v):
for c in range(ChunkedArray_num_chunks(v.ptr)):
for i in range(ChunkedArray_Array_chunk_length(v.ptr, c)):
if v.is_valid((c, i)):
yield (c, i)
return impl_
_ = overload_indicies
def get_chunked_array_xarray_value(element_type, element_type_name):
addr = get_cython_function_address(
self.override_module_name,
"ChunkedArray_" + element_type_name + "Array_Value",
)
ChunkedArray_xArray_Value = ctypes.CFUNCTYPE(
element_type, ctypes.c_voidp, ctypes.c_uint64,
ctypes.c_uint64)(addr)
return ChunkedArray_xArray_Value
ChunkedArray_xArray_Value_map = {
t: get_chunked_array_xarray_value(
_arrow_ctypes_map[_type_array_map[t.chunk_type]],
t.chunk_type.__name__[:-5],
)
for t in typs.values()
}
@overload(operator.getitem)
def overload_getitem(v, i):
if isinstance(v, self.Type):
ChunkedArray_xArray_Value = ChunkedArray_xArray_Value_map[v]
if isinstance(i, numba.types.UniTuple) and i.types == (
numba.types.uint64,
numba.types.uint64,
):
def impl_pair_index(v, i):
return ChunkedArray_xArray_Value(v.ptr, i[0], i[1])
return impl_pair_index
def impl_single_index(v, i):
chunk = 0
while True: # contains break
chunk_len = ChunkedArray_Array_chunk_length(
v.ptr, chunk)
if i < chunk_len:
break
i -= chunk_len
chunk += 1
return ChunkedArray_xArray_Value(v.ptr, chunk, i)
return impl_single_index
return None
_ = overload_getitem
@overload_method(self.Type, "values")
def overload_values(v):
ChunkedArray_xArray_Value = ChunkedArray_xArray_Value_map[v]
def impl_(v):
for c in range(ChunkedArray_num_chunks(v.ptr)):
for i in range(ChunkedArray_Array_chunk_length(v.ptr, c)):
if v.is_valid((c, i)):
yield ChunkedArray_xArray_Value(v.ptr, c, i)
return impl_
_ = overload_values
import numba
from numba.extending import get_cython_function_address
import ctypes
from numpy import ascontiguousarray, linspace, interp, zeros, diff, double, sqrt, arange
_PTR = ctypes.POINTER
_dble = ctypes.c_double
_ptr_dble = _PTR(_dble)
addr = get_cython_function_address("optimum_reparam_N", "reparm_dp")
reparm_dp_functype = ctypes.CFUNCTYPE(_ptr_dble, _ptr_dble)
reparm_dp_numba = reparm_dp_functype(addr)
@numba.jit()
def grad(f, binsize):
n = f.shape[0]
g = zeros(n)
h = binsize * arange(1, n + 1)
g[0] = (f[0] - f[0]) / (h[1] - h[0])
g[-1] = (f[-1] - f[(-2)]) / (h[-1] - h[-2])
h = h[2:-1] - h[0:-3]
g[1:-2] = (f[2:-1] - f[0:-3]) / h[0]
return g
@numba.njit()
def efda_distance(q1, q2):
if (q1 == q2).all():
n_points=500,
n_cond=2):
"""
Simulates a diffusion process given a parameter vector.
"""
x = np.zeros((n_points, n_cond), dtype=np.float32)
simulate_diffusion_parallel(x, drifts, sv, zr, szr, a, ndt, sndt, alpha)
return x
# Get a pointer to the C function diffusion.c
if __name__ != '__main__':
# Add to path
sys.path.append(
sys.path.insert(
0,
os.path.join(
os.path.dirname(os.path.dirname(os.path.realpath(__file__))),
'simulators')))
addr_diffusion = get_cython_function_address("diffusion",
"diffusion_trial")
functype = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double,
ctypes.c_double, ctypes.c_double,
ctypes.c_double, ctypes.c_double,
ctypes.c_double, ctypes.c_double,
ctypes.c_double, ctypes.c_double, ctypes.c_int)
diffusion_trial = functype(addr_diffusion)
phi_neg_choice = norm.cdf(- sqrt_x_k.reshape(1, degrees, 1)
- u_dif.reshape(n_obs, 1, n_choices - 1))
phi_pos_choice = norm.cdf(sqrt_x_k.reshape(1, degrees, 1)
- u_dif.reshape(n_obs, 1, n_choices -1))
choice_probs_interm = phi_neg_choice.prod(axis=2) + phi_pos_choice.prod(axis=2)
choice_prob_obs = (1/(2*np.sqrt(np.pi)))*np.dot(choice_probs_interm, fraction)
return choice_prob_obs
# FROM HERE ON THIS CODE IS MADE BY JANOS!!
cdf_addr = get_cython_function_address("scipy.special.cython_special", '__pyx_fuse_1ndtr')
functype = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double)
normcdf = functype(cdf_addr)
ppf_addr = get_cython_function_address("scipy.special.cython_special", 'ndtri')
normppf = functype(ppf_addr)
log_cdf_addr = get_cython_function_address("scipy.special.cython_special", "__pyx_fuse_1log_ndtr")
log_normcdf = functype(log_cdf_addr)
def get_seed_points(alphas, seeds):
"""Seed points for the generation of r-sequences.
The r-sequences are seeded with a real number between 0 and 1.
This seed is used to calculate a first point. All other points
can be calculated recursively from the first point. We call
# necessary when discrete variables are define on integers
x = np.asarray(x, dtype=float)
from pyapprox.cython.orthonormal_polynomials_1d import \
evaluate_orthonormal_polynomial_deriv_1d_pyx
return evaluate_orthonormal_polynomial_deriv_1d_pyx(
x, nmax, ab, deriv_order)
except:
print('evaluate_orthonormal_polynomial_deriv_1d_pyx extension failed')
return __evaluate_orthonormal_polynomial_deriv_1d
_PTR = ctypes.POINTER
_dble = ctypes.c_double
_ptr_dble = _PTR(_dble)
addr = get_cython_function_address("scipy.special.cython_special", "gammaln")
functype = ctypes.CFUNCTYPE(_dble, _dble)
gammaln_float64 = functype(addr)
@njit
def numba_gammaln(x):
return gammaln_float64(x)
@jit(nopython=True)
def __evaluate_orthonormal_polynomial_1d(x, nmax, ab):
r"""
Evaluate univariate orthonormal polynomials using their
three-term recurrence coefficients.
import numba.extending as nbe
import ctypes
import numpy as np
from numba import njit
dpotrf_addr = nbe.get_cython_function_address(
'scipy.linalg.cython_lapack', 'dpotrf') # cholesky decomposition
dtrsv_addr = nbe.get_cython_function_address('scipy.linalg.cython_blas',
'dtrsv') # solve Ax=b
dpotrf_cfunc = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p, ctypes.c_void_p,
ctypes.c_void_p, ctypes.c_void_p,
ctypes.c_void_p)
dtrsv_cfunc = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p, ctypes.c_void_p,
ctypes.c_void_p, ctypes.c_void_p,
ctypes.c_void_p, ctypes.c_void_p,
ctypes.c_void_p, ctypes.c_void_p)
dpotrf_fun = dpotrf_cfunc(dpotrf_addr)
dtrsv_fun = dtrsv_cfunc(dtrsv_addr)
@njit
def lapack_solve_triangular(Lalloc, balloc, N):
#solves the linalg equation A*x=L*L**T*x=b, where L is the lower cholesky decomposed matrix of A
side_a = np.empty(1, dtype=np.int32)
side_a[0] = 76 # L
t_a = np.empty(1, dtype=np.int32)
t_a[0] = 78 # N - solve L*x=b and not L**T*x=b
import matplotlib.pyplot as plt
from matplotlib.colors import LogNorm
import numpy as np
import ctypes
from numba import jit, cfunc, vectorize
from numba.extending import get_cython_function_address
from scipy.integrate import quad
from scipy.interpolate import interp1d
"""
Constants and utility functions.
"""
# Set up the gamma function. It needs to be defined this way since
# get_cython_function_address doesn't work with gamma, likely because gamma
# involves complex numbers.
addr_gs = get_cython_function_address("scipy.special.cython_special",
"gammasgn")
functype_gs = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double)
gammasgn_cs = functype_gs(addr_gs)
addr_gln = get_cython_function_address("scipy.special.cython_special",
"gammaln")
functype_gln = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double)
gammaln_cs = functype_gln(addr_gln)
## Required to handle case where first argument to incomplete gamma function is 0.
# Can fix by finding the mangled function name in:
# >>> from scipy.special.cython_special import __pyx_capi__
# >>> __pyx_capi__
# addr_expi = get_cython_function_address("scipy.special.cython_special", "expi")
# functype_expi = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double)
# expi_cs = functype_expi(addr_expi)
def test_getting_function(self):
addr = get_cython_function_address("scipy.special.cython_special", "j0")
functype = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double)
_j0 = functype(addr)
j0 = jit(nopython=True)(lambda x: _j0(x))
self.assertEqual(j0(0), 1)
'ellipkinc': [(
float64,
float64,
)],
'ellipeinc': [(
float64,
float64,
)],
'erf': [(float64, )],
}
name_and_types_to_pointer = {
('expi', float64):
ctypes.CFUNCTYPE(ctypes.c_double,
ctypes.c_double)(get_cython_function_address(
'scipy.special.cython_special',
'__pyx_fuse_1expi')),
('ellipe', float64):
ctypes.CFUNCTYPE(ctypes.c_double,
ctypes.c_double)(get_cython_function_address(
'scipy.special.cython_special', 'ellipe')),
('iv', float64, float64):
ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double,
ctypes.c_double)(get_cython_function_address(
'scipy.special.cython_special',
'__pyx_fuse_1iv')),
('gamma', float64):
ctypes.CFUNCTYPE(ctypes.c_double,
ctypes.c_double)(get_cython_function_address(
'scipy.special.cython_special',
'__pyx_fuse_1gamma')),
def test_missing_function(self):
with self.assertRaises(ValueError) as raises:
addr = get_cython_function_address("scipy.special.cython_special", "foo")
msg = "No function 'foo' found in __pyx_capi__ of 'scipy.special.cython_special'"
self.assertEqual(msg, str(raises.exception))
from numba.extending import get_cython_function_address
from numba import cfunc, jit
from numba.types import float64, CPointer, intc
from scipy import LowLevelCallable
from scipy.integrate import quad
from scipy.optimize import brentq
from dm_params import fx, sv
from utilities import e0, b0, D0, delta, kpc_to_cm, speed_of_light, D
from utilities import rho_critical, GeV_to_m_sun
from utilities import e_high_excess
# Obtained by finding the mangled function name in:
# >>> from scipy.special.cython_special import __pyx_capi__
# >>> __pyx_capi__
addr_hyp = get_cython_function_address("scipy.special.cython_special",
"__pyx_fuse_1hyp2f1")
functype_hyp = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double,
ctypes.c_double, ctypes.c_double,
ctypes.c_double)
hyp2f1_cs = functype_hyp(addr_hyp)
@np.vectorize
def rho(dist, rs, rhos, gamma):
return rhos * (rs / np.abs(dist))**gamma * (1. + np.abs(dist) / rs)**(
gamma - 3.)
@np.vectorize
def mass(rs, rhos, gamma):
# Find virial mass numerically. The "magic number" of 10000 should
def __init__(
self,
orig_typ,
addr_func,
element_type,
addr_func_name=None,
override_module_name=None,
):
super().__init__(orig_typ, addr_func, addr_func_name,
override_module_name)
assert self.type_name.endswith("Array")
element_type_name = self.type_name[:-5]
addr = get_cython_function_address(self.override_module_name,
"Array_length")
Array_length = ctypes.CFUNCTYPE(ctypes.c_uint64, ctypes.c_voidp)(addr)
@overload(len)
def overload_len(v):
if isinstance(v, self.Type):
def impl_(v):
return Array_length(v.ptr)
return impl_
return None
_ = overload_len
addr = get_cython_function_address(self.override_module_name,
"Array_is_valid")
Array_is_valid = ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_voidp,
ctypes.c_uint64)(addr)
@overload_method(self.Type, "is_valid")
def overload_is_valid(v, i):
_ = v
_ = i
def impl_(v, i):
return Array_is_valid(v.ptr, i)
return impl_
_ = overload_is_valid
@overload_method(self.Type, "is_null")
def overload_is_null(v, i):
_ = v
_ = i
def impl_(v, i):
return not Array_is_valid(v.ptr, i)
return impl_
_ = overload_is_null
@overload_method(self.Type, "indicies")
def overload_indicies(v):
_ = v
def impl_(v):
for i in range(Array_length(v.ptr)):
if v.is_valid(i):
yield i
return impl_
_ = overload_indicies
addr = get_cython_function_address(
self.override_module_name,
"Array_" + element_type_name + "Array_Value")
Array_xArray_Value = ctypes.CFUNCTYPE(element_type, ctypes.c_voidp,
ctypes.c_uint64)(addr)
@overload(operator.getitem)
def overload_getitem(v, i):
_ = i
if isinstance(v, self.Type):
def impl_(v, i):
return Array_xArray_Value(v.ptr, i)
return impl_
return None
_ = overload_getitem
@overload_method(self.Type, "values")
def overload_values(v):
_ = v
def impl_(v):
for i in range(Array_length(v.ptr)):
if v.is_valid(i):
yield Array_xArray_Value(v.ptr, i)
return impl_
_ = overload_values
out = (cos(2*alp)- 1/(1+x)) / (kap - beta * (1+x) * sin(2*alp))
# Add SC term
# out += -1 / ( (gamma**2-1)*(1+x)*(kap - beta*(1+x)*sin(2*alp)) )
return out
# Include special functions for Numba
#
# Tip from: https://github.com/numba/numba/issues/3086
# and http://numba.pydata.org/numba-doc/latest/extending/high-level.html
#
addr1 = get_cython_function_address('scipy.special.cython_special', 'ellipkinc')
addr2 = get_cython_function_address('scipy.special.cython_special', 'ellipeinc')
functype = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double, ctypes.c_double)
my_ellipkinc = functype(addr1)
my_ellipeinc = functype(addr2)
@vectorize([float64(float64, float64, float64)])
def psi_x(z, x, gamma):
"""
2D longitudinal potential ( "psi_phi" term excluded )
Numba vectorized
import ctypes
import numba
from numba.extending import get_cython_function_address
import numpy as np
import pyximport
pyximport.install()
import wofz_cython
_PTR = ctypes.POINTER
_dble = ctypes.c_double
_ptr_dble = _PTR(_dble)
addr = get_cython_function_address("wofz_cython", "wofz")
functype = ctypes.CFUNCTYPE(None, _dble, _dble, _ptr_dble, _ptr_dble)
wofz_fn = functype(addr)
@numba.njit
def wofz(z):
w_real = np.empty(1, dtype=np.float64)
w_imag = np.empty(1, dtype=np.float64)
wofz_fn(np.real(z), np.imag(z), w_real.ctypes, w_imag.ctypes)
return np.complex(w_real[0] + 1j * w_imag[0])
A += np.sum(_A_ij(sample1[i], sample2))
return A / (N1 * N2)
@jit("float32(float32[:], float32[:])", nopython=True, parallel=True)
def KS_statistic(sample1, sample2):
sample_both = np.concatenate((sample1, sample2))
cdf1 = np.searchsorted(sample1, sample_both, 'right') / len(sample1)
cdf2 = np.searchsorted(sample2, sample_both, 'right') / len(sample2)
ks = np.max(np.abs(cdf1 - cdf2))
return ks
## Standard normal distribution
_addr_ndtri = get_cython_function_address("scipy.special.cython_special",
"ndtri")
_functype_ndtri = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double)
normal_ppf = _functype_ndtri(_addr_ndtri)
_addr_ndtr = get_cython_function_address("scipy.special.cython_special",
"__pyx_fuse_0ndtr")
_functype_ndtr = ctypes.CFUNCTYPE(ctypes.c_double, ctypes.c_double)
normal_cdf = _functype_ndtr(_addr_ndtr)
## Quantile-Quantile plot
def calculate_QQplot(data1, data2, a=0):
def _sample_quantiles(data):
probplot = gofplots.ProbPlot(np.array(data, dtype=float), a=a)
return probplot.sample_quantiles
