如何在自研代码中使用Scipy LowLevelCallable并设计兼容双调用的求积函数？

核心逻辑 #

要同时支持Python可调用对象和scipy.LowLevelCallable，关键是在Cython层做类型判断与分支处理：对普通Python函数走Python调用逻辑，对LowLevelCallable直接调用其底层C函数指针，绕开Python解释器开销，从而拿到性能收益。

具体实现步骤 #

1. 先搞懂LowLevelCallable的底层结构 #

Scipy的LowLevelCallable本质是封装了一个C函数指针，还可以附带用户自定义数据。它的简化C定义大致是：

typedef double (*scipy_low_level_func)(double x, void* user_data);

在Cython里可以直接对应这个函数指针类型。

2. 在Cython中声明LowLevelCallable的接口 #

先在Cython头文件（.pxd）里声明Scipy的相关结构，方便后续调用：

cdef extern from "scipy/lowlevelcallable.h":
    ctypedef double (*scipy_llc_func)(double x, void* user_data)
    
    ctypedef struct _PyScipyLowLevelCallable:
        scipy_llc_func func
        void* user_data
        # 其他Scipy内部字段无需关注
        
    # 从Python对象提取底层结构的辅助函数
    _PyScipyLowLevelCallable* PyScipyLowLevel_GetLLC(object llc)

3. 编写兼容双类型的求积核心代码 #

在Cython实现文件（.pyx）中，先判断输入的可调用对象类型，再分情况处理：

• 如果是scipy.LowLevelCallable，直接提取C函数指针和用户数据，在C层面循环计算
• 如果是普通Python函数，通过Cython的object类型调用，走Python解释器逻辑

以梯形法求积为例：

import scipy.integrate as spi
from scipy.lowlevelcallable cimport LowLevelCallable

def trapezoidal_integral(func, double a, double b, int n=1000):
    cdef:
        double h = (b - a) / n
        double sum_val = 0.0
        double x
        int i
        _PyScipyLowLevelCallable* llc_ptr = NULL
        scipy_llc_func c_func = NULL
        void* user_data = NULL
        
    # 判断是否为LowLevelCallable
    if isinstance(func, LowLevelCallable):
        llc_ptr = PyScipyLowLevel_GetLLC(func)
        c_func = llc_ptr.func
        user_data = llc_ptr.user_data
        
        # C层面直接计算，无Python解释器开销
        sum_val = 0.5 * (c_func(a, user_data) + c_func(b, user_data))
        for i in range(1, n):
            x = a + i * h
            sum_val += c_func(x, user_data)
        sum_val *= h
    else:
        # 处理普通Python可调用对象
        sum_val = 0.5 * (func(a) + func(b))
        for i in range(1, n):
            x = a + i * h
            sum_val += func(x)
        sum_val *= h
    
    return sum_val

4. 写个测试用的LowLevelCallable示例 #

用Cython写一个底层函数，包装成LowLevelCallable供Python调用：

# 编译成C级别的计算函数
cdef double square_func(double x, void* user_data):
    return x * x

# 包装成LowLevelCallable
def get_square_llc():
    return spi.LowLevelCallable.from_cython(square_func, user_data=None)

5. 验证性能差异 #

对比普通Python函数和LowLevelCallable的耗时：

import time

# 普通Python实现的平方函数
def square(x):
    return x*x

# LowLevelCallable版本的平方函数
square_llc = get_square_llc()

# 测试积分计算
start = time.time()
trapezoidal_integral(square, 0, 1, 1000000)
print(f"Python函数耗时: {time.time() - start:.4f}秒")

start = time.time()
trapezoidal_integral(square_llc, 0, 1, 1000000)
print(f"LowLevelCallable耗时: {time.time() - start:.4f}秒")

一般来说，LowLevelCallable版本能拿到5-10倍甚至更高的性能提升，因为完全避开了Python解释器的循环调用开销。

注意事项 #

• Cython编译时要确保链接Scipy相关库，setup.py里要包含Scipy依赖
• LowLevelCallable的函数签名必须严格匹配Scipy要求（比如单变量积分是double(double, void*)，多变量是double(int, double*, void*)）
• 处理用户自定义数据时要注意内存安全，避免野指针问题

内容的提问来源于stack exchange，提问作者G. Fougeron