def check(caller, func, user_data): caller = CALLERS[caller] user_data = USER_DATAS[user_data]() func = BAD_FUNCS[func]() if func is callback_python: func2 = lambda x: func(x, 2.0) else: func2 = LowLevelCallable(func, user_data) func = LowLevelCallable(func) # Test that basic call fails assert_raises(ValueError, caller, LowLevelCallable(func), 1.0) # Test that passing in user_data also fails assert_raises(ValueError, caller, func2, 1.0) # Test error message llfunc = LowLevelCallable(func) try: caller(llfunc, 1.0) except ValueError as err: msg = str(err) assert_(llfunc.signature in msg, msg) assert_('double (double, double, int *, void *)' in msg, msg)
def test_signature_override(): caller = _test_ccallback.test_call_simple func = _test_ccallback.test_get_plus1_capsule() llcallable = LowLevelCallable(func, signature="bad signature") assert_equal(llcallable.signature, "bad signature") assert_raises(ValueError, caller, llcallable, 3) llcallable = LowLevelCallable(func, signature="double (double, int *, void *)") assert_equal(llcallable.signature, "double (double, int *, void *)") assert_equal(caller(llcallable, 3), 4)
def test_ctypes_variants(self): sin_0 = get_clib_test_routine('_sin_0', ctypes.c_double, ctypes.c_double, ctypes.c_void_p) sin_1 = get_clib_test_routine('_sin_1', ctypes.c_double, ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_void_p) sin_2 = get_clib_test_routine('_sin_2', ctypes.c_double, ctypes.c_double) sin_3 = get_clib_test_routine('_sin_3', ctypes.c_double, ctypes.c_int, ctypes.POINTER(ctypes.c_double)) sin_4 = get_clib_test_routine('_sin_3', ctypes.c_double, ctypes.c_int, ctypes.c_double) all_sigs = [sin_0, sin_1, sin_2, sin_3, sin_4] legacy_sigs = [sin_2, sin_4] legacy_only_sigs = [sin_4] # LowLevelCallables work for new signatures for j, func in enumerate(all_sigs): callback = LowLevelCallable(func) if func in legacy_only_sigs: assert_raises(ValueError, quad, callback, 0, pi) else: assert_allclose(quad(callback, 0, pi)[0], 2.0) # Plain ctypes items work only for legacy signatures for j, func in enumerate(legacy_sigs): if func in legacy_sigs: assert_allclose(quad(func, 0, pi)[0], 2.0) else: assert_raises(ValueError, quad, func, 0, pi)
def check(caller, func, user_data): caller = CALLERS[caller] user_data = USER_DATAS[user_data]() func = BAD_FUNCS[func]() if func is callback_python: func2 = lambda x: func(x, 2.0) else: func2 = LowLevelCallable(func, user_data) func = LowLevelCallable(func) # Test that basic call fails assert_raises(ValueError, caller, LowLevelCallable(func), 1.0) # Test that passing in user_data also fails assert_raises(ValueError, caller, func2, 1.0)
def check(caller, func, user_data): caller = CALLERS[caller] func = FUNCS[func]() user_data = USER_DATAS[user_data]() if func is callback_python: func2 = lambda x: func(x, 2.0) else: func2 = LowLevelCallable(func, user_data) func = LowLevelCallable(func) # Test basic call assert_equal(caller(func, 1.0), 2.0) # Test 'bad' value resulting to an error assert_raises(ValueError, caller, func, ERROR_VALUE) # Test passing in user_data assert_equal(caller(func2, 1.0), 3.0)
def test_ctypes_variants(self): lib = ctypes.CDLL(clib_test.__file__) sin_0 = lib._sin_0 sin_0.restype = ctypes.c_double sin_0.argtypes = [ctypes.c_double, ctypes.c_void_p] sin_1 = lib._sin_1 sin_1.restype = ctypes.c_double sin_1.argtypes = [ ctypes.c_int, ctypes.POINTER(ctypes.c_double), ctypes.c_void_p ] sin_2 = lib._sin_2 sin_2.restype = ctypes.c_double sin_2.argtypes = [ctypes.c_double] sin_3 = lib._sin_3 sin_3.restype = ctypes.c_double sin_3.argtypes = [ctypes.c_int, ctypes.POINTER(ctypes.c_double)] sin_4 = lib._sin_3 sin_4.restype = ctypes.c_double sin_4.argtypes = [ctypes.c_int, ctypes.c_double] all_sigs = [sin_0, sin_1, sin_2, sin_3, sin_4] legacy_sigs = [sin_2, sin_4] legacy_only_sigs = [sin_4] # LowLevelCallables work for new signatures for j, func in enumerate(all_sigs): callback = LowLevelCallable(func) if func in legacy_only_sigs: assert_raises(ValueError, quad, callback, 0, pi) else: assert_allclose(quad(callback, 0, pi)[0], 2.0) # Plain ctypes items work only for legacy signatures for j, func in enumerate(legacy_sigs): if func in legacy_sigs: assert_allclose(quad(func, 0, pi)[0], 2.0) else: assert_raises(ValueError, quad, func, 0, pi)
import numpy as np from numpy.testing import assert_allclose from scipy import ndimage from scipy.ndimage import _ctest from scipy.ndimage import _ctest_oldapi from scipy.ndimage import _cytest from scipy._lib._ccallback import LowLevelCallable FILTER1D_FUNCTIONS = [ lambda filter_size: _ctest.filter1d(filter_size), lambda filter_size: _ctest_oldapi.filter1d(filter_size), lambda filter_size: _cytest.filter1d(filter_size, with_signature=False), lambda filter_size: LowLevelCallable( _cytest.filter1d(filter_size, with_signature=True)), lambda filter_size: LowLevelCallable.from_cython( _cytest, "_filter1d", _cytest.filter1d_capsule(filter_size)), ] FILTER2D_FUNCTIONS = [ lambda weights: _ctest.filter2d(weights), lambda weights: _ctest_oldapi.filter2d(weights), lambda weights: _cytest.filter2d(weights, with_signature=False), lambda weights: LowLevelCallable( _cytest.filter2d(weights, with_signature=True)), lambda weights: LowLevelCallable.from_cython( _cytest, "_filter2d", _cytest.filter2d_capsule(weights)), ] TRANSFORM_FUNCTIONS = [ lambda shift: _ctest.transform(shift),
def test_ctypes_sine(self): quad(LowLevelCallable(sine_ctypes), 0, 1)
a, b = 0.01, 100 @contextlib.contextmanager def timing(): s = time.time() yield print('Time: {}s'.format(time.time() - s)) def func(x): return sin(1 / x) optimized_func = cfunc("float64(float64)")(func) print('Optimized version') with timing(): out1 = quad(LowLevelCallable(optimized_func.ctypes), a, b) print(out1) print('Optimized version') with timing(): out1 = quad(LowLevelCallable(optimized_func.ctypes), a, b) print(out1) print('Standard version') with timing(): out2 = quad(func, a, b) print(out2)