Speed comparison, just info

[Peter230655]

I tried to compare symjit, lambdify and ufuncify by evaluation of some senseless function, just complicated enough that evaluation would take some time.
My initial finding are:

1. Results seem to be the same up to numerical errors.
2. All three can 'broadcast', but symjit is by far the slowest of the three, much slower than even lambdify
3. In this example, ufuncify seems almost twixe as fast as symjit

I attached the program below.

# %%
from sympy.utilities.autowrap import ufuncify
import sympy as sm
import numpy as np
from symjit import compile_func

x, y = sm.symbols('x y')
# just some senseless function, complicated enough so evaluation time takes
# some time.
f_ori = (
    (sm.Abs(
        (sm.sin(sm.sqrt(sm.Abs((sm.cos(sm.asin(sm.sin(sm.sqrt(y**15 + x**20)))) 
                                + sm.exp(sm.log(x**2 + y**2)) + 
                 (sm.log(x**2 + y**2)**10))))))) **(3/7)) + 3.0
    )

xs = [2.0, 3.0, 4.0, 8.0, 9.0, 10.0]
ys = [5.0, 6.0, 7.0, 11.0, 12.0, 13.0]
xs1 = np.array([2.0])
ys1 = np.array([5.0])


f_ufunc = ufuncify((x, y), f_ori, backend='Cython')
print('speed ufuncify')
%timeit (f_ufunc(np.array(xs), np.array(ys)))
%timeit (f_ufunc(np.array([xs[0]]), np.array([ys[0]])))
%timeit (f_ufunc(xs1, ys1))

f_lam = sm.lambdify((x, y), f_ori, cse=True)
print('\n')
print('speed lambdify')
%timeit (f_lam(np.array(xs), np.array(ys)))
%timeit (f_lam(xs[0], ys[0]))
%timeit (f_lam(xs1, ys1))


f_jit = compile_func((x, y), f_ori)
print('\n')
print('speed symjit')
%timeit (f_jit(np.array(xs), np.array(ys)))
%timeit (f_jit(xs1, ys1))
%timeit (f_jit(xs[2], ys[2]))

resultat_ufunc = f_ufunc(np.array(xs),np.array(ys))
resultat_lam = f_lam(np.array(xs), np.array(ys))
resultat_jit = f_jit(np.array(xs), np.array(ys))

print('\n')
print('numerical results')
print('resultat ufuncify:', resultat_ufunc)
print('resultat lambdify:', resultat_lam)
print('resultat symjit:', resultat_jit)

print('\n')
print('differences between results')
print('resultat ufuncify - resultat lambdify:', resultat_ufunc - resultat_lam)
print('resultat ufuncify - resultat symjit:', resultat_ufunc - resultat_jit)
print('resultat lambdify - resultat symjit:', resultat_lam - resultat_jit)

[shahriariravanian]

This is because you are testing with short arrays, where symjit call overhead dominates. Also, it is better to convert the Python array to a sympy ndarray outside the timing loop. If we use

xs = np.array([random.random() for _ in range(100000)])   # or equivalently, xs = np.random.rand(100000)
ys = np.array([random.random() for _ in range(100000)])
...
%timeit f_lam(xs, ys)
%timeit f_jit(xs, ys)

then symjit is around 10 times faster. I haven't setup ufuncify yet but expect some speed-up there too. Could you check it?

[Peter230655]

When I do this:
xs = np.array([np.random.random() for _ in range(100000)])
ys = np.array([np.random.random() for _ in range(100000)])

I get these results:
Definitely symjit beats the others by far!
(I have absolutely no experience with ufuncify, so there may well be better ways to implement it)

speed ufuncify
16.6 ms ± 6.78 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

speed lambdify
6.56 ms ± 33.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

speed symjit
719 µs ± 8.59 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)