Matrici che hanno un passaggio costante tra gli elementi
In caso di uno rangeo qualsiasi altro array che aumenta in modo lineare, è possibile semplicemente calcolare l'indice a livello di codice, senza che sia necessario eseguire l'iterazione dell'array:
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
Probabilmente si potrebbe migliorare un po '. Mi sono assicurato che funzioni correttamente per alcuni array e valori di esempio, ma ciò non significa che non possano esserci errori, soprattutto considerando che utilizza float ...
>>> 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
Dato che può calcolare la posizione senza alcuna iterazione, sarà un tempo costante ( O(1)) e probabilmente potrà battere tutti gli altri approcci citati. Tuttavia richiede un passaggio costante nell'array, altrimenti produrrà risultati errati.
Soluzione generale usando numba
Un approccio più generale sarebbe l'utilizzo di una funzione numba:
@nb.njit
def first_index_numba(val, arr):
for idx in range(len(arr)):
if arr[idx] > val:
return idx
return -1
Funzionerà per qualsiasi array ma deve iterare sull'array, quindi nel caso medio sarà O(n):
>>> first_index_numba(4.8, np.arange(-10, 10))
15
>>> first_index_numba(5, np.arange(-10, 10))
16
Prova delle prestazioni
Anche se Nico Schlömer ha già fornito alcuni parametri di riferimento, ho pensato che potesse essere utile includere le mie nuove soluzioni e testare diversi "valori".
L'impostazione del test:
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
e i grafici sono stati generati usando:
%matplotlib notebook
b.plot()
l'oggetto è all'inizio
b = benchmark(
funcs,
{2**i: MultiArgument([0, np.arange(2**i)]) for i in range(2, 20)},
argument_name="array size")
La funzione numba esegue al meglio seguita dalla funzione calcola e dalla funzione di ricerca. Le altre soluzioni funzionano molto peggio.
l'oggetto è alla fine
b = benchmark(
funcs,
{2**i: MultiArgument([2**i-2, np.arange(2**i)]) for i in range(2, 20)},
argument_name="array size")
Per array di piccole dimensioni la funzione numba si comporta in modo sorprendentemente veloce, tuttavia per array di dimensioni maggiori è sovraperformata dalla funzione di calcolo e dalla funzione di ricerca.
l'articolo è a 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")
Questo è più interessante Anche in questo caso numba e la funzione di calcolo funzionano alla grande, tuttavia questo in realtà sta innescando il caso peggiore di ricerche che in questo caso in realtà non funziona bene.
Confronto delle funzioni quando nessun valore soddisfa la condizione
Un altro punto interessante è come si comportano queste funzioni se non esiste alcun valore il cui indice deve essere restituito:
arr = np.ones(100)
value = 2
for func in funcs:
print(func.__name__)
try:
print('-->', func(value, arr))
except Exception as e:
print('-->', e)
Con questo risultato:
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
Searchsorted, argmax e numba restituiscono semplicemente un valore errato. Tuttavia searchsortede numbarestituire un indice che non è un indice valido per l'array.
Le funzioni where, min, nonzeroe calculategenerano un'eccezione. Tuttavia, solo l'eccezione per calculateeffettivamente dice qualcosa di utile.
Ciò significa che uno deve effettivamente avvolgere queste chiamate in una funzione wrapper appropriata che rileva eccezioni o valori di ritorno non validi e gestisce in modo appropriato, almeno se non si è sicuri che il valore possa essere nell'array.
Nota: il calcolo e le searchsortedopzioni funzionano solo in condizioni speciali. La funzione "calcola" richiede un passaggio costante e la ricerca ordinata richiede che l'array sia ordinato. Quindi questi potrebbero essere utili nelle giuste circostanze ma non sono soluzioni generali per questo problema. Nel caso in cui hai a che fare con ordinati liste Python si potrebbe desiderare di dare un'occhiata al bisect modulo invece di utilizzare Numpys searchsorted.
