Array yang memiliki langkah konstan antara elemen
Jika rangearray atau peningkatan linear lainnya, Anda dapat menghitung indeks secara terprogram, tidak perlu benar-benar beralih ke array sama sekali:
def first_index_calculate_range_like(val, arr):
if len(arr) == 0:
raise ValueError('no value greater than {}'.format(val))
elif len(arr) == 1:
if arr[0] > val:
return 0
else:
raise ValueError('no value greater than {}'.format(val))
first_value = arr[0]
step = arr[1] - first_value
# For linearly decreasing arrays or constant arrays we only need to check
# the first element, because if that does not satisfy the condition
# no other element will.
if step <= 0:
if first_value > val:
return 0
else:
raise ValueError('no value greater than {}'.format(val))
calculated_position = (val - first_value) / step
if calculated_position < 0:
return 0
elif calculated_position > len(arr) - 1:
raise ValueError('no value greater than {}'.format(val))
return int(calculated_position) + 1
Seseorang mungkin bisa sedikit memperbaiki itu. Saya telah memastikan itu berfungsi dengan benar untuk beberapa sampel array dan nilai-nilai tetapi itu tidak berarti tidak mungkin ada kesalahan di sana, terutama mengingat bahwa ia menggunakan pelampung ...
>>> import numpy as np
>>> first_index_calculate_range_like(5, np.arange(-10, 10))
16
>>> np.arange(-10, 10)[16] # double check
6
>>> first_index_calculate_range_like(4.8, np.arange(-10, 10))
15
Mengingat bahwa ia dapat menghitung posisi tanpa iterasi apa pun, itu akan menjadi waktu yang konstan ( O(1)) dan mungkin dapat mengalahkan semua pendekatan yang disebutkan lainnya. Namun itu membutuhkan langkah konstan dalam array, jika tidak maka akan menghasilkan hasil yang salah.
Solusi umum menggunakan numba
Pendekatan yang lebih umum akan menggunakan fungsi numba:
@nb.njit
def first_index_numba(val, arr):
for idx in range(len(arr)):
if arr[idx] > val:
return idx
return -1
Itu akan bekerja untuk array apa pun tetapi harus beralih di atas array, jadi dalam kasus rata-rata akan menjadi O(n):
>>> first_index_numba(4.8, np.arange(-10, 10))
15
>>> first_index_numba(5, np.arange(-10, 10))
16
Tolok ukur
Meskipun Nico Schlömer sudah memberikan beberapa tolok ukur, saya pikir mungkin berguna untuk memasukkan solusi baru saya dan untuk menguji "nilai" yang berbeda.
Pengaturan tes:
import numpy as np
import math
import numba as nb
def first_index_using_argmax(val, arr):
return np.argmax(arr > val)
def first_index_using_where(val, arr):
return np.where(arr > val)[0][0]
def first_index_using_nonzero(val, arr):
return np.nonzero(arr > val)[0][0]
def first_index_using_searchsorted(val, arr):
return np.searchsorted(arr, val) + 1
def first_index_using_min(val, arr):
return np.min(np.where(arr > val))
def first_index_calculate_range_like(val, arr):
if len(arr) == 0:
raise ValueError('empty array')
elif len(arr) == 1:
if arr[0] > val:
return 0
else:
raise ValueError('no value greater than {}'.format(val))
first_value = arr[0]
step = arr[1] - first_value
if step <= 0:
if first_value > val:
return 0
else:
raise ValueError('no value greater than {}'.format(val))
calculated_position = (val - first_value) / step
if calculated_position < 0:
return 0
elif calculated_position > len(arr) - 1:
raise ValueError('no value greater than {}'.format(val))
return int(calculated_position) + 1
@nb.njit
def first_index_numba(val, arr):
for idx in range(len(arr)):
if arr[idx] > val:
return idx
return -1
funcs = [
first_index_using_argmax,
first_index_using_min,
first_index_using_nonzero,
first_index_calculate_range_like,
first_index_numba,
first_index_using_searchsorted,
first_index_using_where
]
from simple_benchmark import benchmark, MultiArgument
dan plot dihasilkan menggunakan:
%matplotlib notebook
b.plot()
item di awal
b = benchmark(
funcs,
{2**i: MultiArgument([0, np.arange(2**i)]) for i in range(2, 20)},
argument_name="array size")
Fungsi numba berkinerja terbaik diikuti oleh fungsi penghitungan dan fungsi yang disortir. Solusi lain berperforma jauh lebih buruk.
barang ada di akhir
b = benchmark(
funcs,
{2**i: MultiArgument([2**i-2, np.arange(2**i)]) for i in range(2, 20)},
argument_name="array size")
Untuk array kecil, fungsi numba berkinerja sangat cepat, namun untuk array yang lebih besar, kinerjanya lebih baik dari fungsi penghitungan dan fungsi yang dicari.
item ada di sqrt (len)
b = benchmark(
funcs,
{2**i: MultiArgument([np.sqrt(2**i), np.arange(2**i)]) for i in range(2, 20)},
argument_name="array size")
Ini lebih menarik. Lagi-lagi numba dan fungsi kalkulasi bekerja sangat baik, namun ini sebenarnya memicu kasus pencarian terburuk yang benar-benar tidak berfungsi dengan baik dalam kasus ini.
Perbandingan fungsi ketika tidak ada nilai yang memenuhi kondisi
Poin menarik lainnya adalah bagaimana fungsi ini berperilaku jika tidak ada nilai yang indeksnya harus dikembalikan:
arr = np.ones(100)
value = 2
for func in funcs:
print(func.__name__)
try:
print('-->', func(value, arr))
except Exception as e:
print('-->', e)
Dengan hasil ini:
first_index_using_argmax
--> 0
first_index_using_min
--> zero-size array to reduction operation minimum which has no identity
first_index_using_nonzero
--> index 0 is out of bounds for axis 0 with size 0
first_index_calculate_range_like
--> no value greater than 2
first_index_numba
--> -1
first_index_using_searchsorted
--> 101
first_index_using_where
--> index 0 is out of bounds for axis 0 with size 0
Pencarian yang disortir, argmax, dan numba hanya mengembalikan nilai yang salah. Namun searchsorteddan numbamengembalikan indeks yang bukan indeks yang valid untuk array.
Fungsi where, min, nonzerodan calculatemelemparkan sebuah pengecualian. Namun hanya pengecualian untuk calculatebenar - benar mengatakan sesuatu yang bermanfaat.
Itu berarti kita harus membungkus panggilan ini dalam fungsi wrapper yang sesuai yang menangkap pengecualian atau nilai pengembalian yang tidak valid dan menangani dengan tepat, setidaknya jika Anda tidak yakin apakah nilainya bisa dalam array.
Catatan: Perhitungan dan searchsortedopsi hanya berfungsi dalam kondisi khusus. Fungsi "menghitung" memerlukan langkah konstan dan pencarian disortir membutuhkan array yang akan diurutkan. Jadi ini bisa berguna dalam situasi yang tepat tetapi bukan solusi umum untuk masalah ini. Jika Anda berurusan dengan daftar Python yang diurutkan, Anda mungkin ingin melihat modul bisect daripada menggunakan Numpys yang dicari.
