Interp benchmark

benchmark.py

from __future__ import print_function
import sys
import timeit
import numpy as np
from numba import njit

np.random.seed(0)
ndata=20000

# data to ne interpolated
xp = np.linspace(0, 10, 1+ndata)
fp = np.sin(xp / 2.0)

# test arrays
arr0 = np.linspace(2.0, 7.0, 1+ndata*5)
arr1 = np.linspace(2.0, 7.0, 1+ndata)
arr2 = np.linspace(2.1, 6.8, 1+ndata/2)
arr3 = np.linspace(2.1, 7.5, 1+ndata/2)
arr4 = np.linspace(1.1, 9.5, 1+ndata/5)

arr5 = np.linspace(3.1, 5.3, 1+ndata) * 1.09
arr6 = np.linspace(3.1, 8.3, 1+ndata/2) * 1.09

arr7 = np.linspace(3.1, 5.3, 1+ndata) * 0.91
arr8 = np.linspace(3.1, 8.3, 1+ndata/2) * 0.91

arr9 = np.linspace(3.1, 5.3, 1+ndata/2)  +  0.3 * np.sin(np.arange(1+ndata/2)*np.pi/(1+ndata/2))

arr10  = np.linspace(3.1, 5.3, 1+ndata) + np.random.normal(size=1+ndata, scale=0.5/ndata)
arr11 = np.linspace(3.1, 5.3, 1+ndata) + np.random.normal(size=1+ndata, scale=2.0/ndata)
arr12 = np.linspace(3.1, 5.3, 1+ndata) + np.random.normal(size=1+ndata, scale=5.0/ndata)
arr13 = np.linspace(3.1, 5.3, 1+ndata) + np.random.normal(size=1+ndata, scale=20.0/ndata)
arr14 = np.linspace(3.1, 5.3, 1+ndata) + np.random.normal(size=1+ndata, scale=50.0/ndata)
arr15 = np.linspace(3.1, 5.3, 1+ndata) + np.random.normal(size=1+ndata, scale=200.0/ndata)

arr16 = np.random.rand(1+ndata)*9.0   + 0.6
arr17 = np.random.rand(1+ndata*2)*4.0 + 1.3

def much_finer_grid():
    out = np.interp(arr0, xp, fp)

def finer_grid():
    out = np.interp(arr1, xp, fp)

def similar_grid():
    out = np.interp(arr2, xp, fp)

def coarser_grid():
    out = np.interp(arr3, xp, fp)

def much_coarser_grid():
    out = np.interp(arr4, xp, fp)

def finer_stretched_grid():
    out = np.interp(arr5, xp, fp)

def similar_stretched_grid():
    out = np.interp(arr5, xp, fp)

def finer_compressed_grid():
    out = np.interp(arr7, xp, fp)

def similar_compressed_grid():
    out = np.interp(arr8, xp, fp)

def warped_grid():
    out = np.interp(arr9, xp, fp)

def very_low_noise_grid():
    out = np.interp(arr10, xp, fp)

def low_noise_grid():
    out = np.interp(arr11, xp, fp)

def med_noise_grid():
    out = np.interp(arr12, xp, fp)

def high_noise_grid():
    out = np.interp(arr13, xp, fp)

def very_high_noise_grid():
    out = np.interp(arr14, xp, fp)

def extreme_noise_grid():
    out = np.interp(arr15, xp, fp)

def random_fine_grid():
    out = np.interp(arr16, xp, fp)

def random_grid():
    out = np.interp(arr17, xp, fp)

if __name__ == '__main__':
    print(" Python Version: ", sys.version)
    print(" Numpy Version: ", np.__version__)
    funcs = ('much_finer_grid', 'finer_grid', 'similar_grid',
             'coarser_grid', 'much_coarser_grid', 'finer_stretched_grid',
             'similar_stretched_grid', 'finer_compressed_grid',
             'similar_compressed_grid', 'warped_grid',
             'very_low_noise_grid', 'low_noise_grid', 'med_noise_grid',
             'high_noise_grid', 'very_high_noise_grid',
             'extreme_noise_grid', 'random_fine_grid', 'random_grid')

    for func in funcs:
        out = timeit.repeat(
            '%s()' % func,
            f"from __main__ import {func}; from numba import njit; {func} = njit()({func})",
            number=200,
            repeat=3)
        print(" %s %.5f" % ((func+24*' ')[:24], min(out)))