Vecteur de valeurs

#numpy
import numpy as np
np.__version__

'1.26.4'

#nombre de valeurs
n = 1000000

#générer les valeurs
rng = np.random.default_rng(2024)
vec = rng.random(size=n)
#nb. de valeurs obtenues
vec.shape

(1000000,)

#min et max
print(np.min(vec))
print(np.max(vec))

1.675090474106966e-06
0.9999998884825583

Solution 1 - Boucle

#fonction pour transformer une valeur
def trans(x):
    if (x < 0.1):
        res = 1
    elif (x < 0.3):
        res = x**2
    elif (x < 0.8):
        res = (x+1)*31.5
    else:
        res = 1245
    return res

#test de la fonction
trans(0.25)

0.0625

#et on boucle sur le vecteur
def boucle_v1(v):
    result = []
    for x in v:
        result.append(trans(x))
    return np.array(result)

#lancement
z1 = boucle_v1(vec)
print(np.sum(z1))

272817349.82839215

#temps de traitement
%timeit -r 10 -n 1 boucle_v1(vec)

372 ms ± 10.2 ms per loop (mean ± std. dev. of 10 runs, 1 loop each)

#boucle liste bis
def boucle_v1_bis(v):
    result = [trans(x) for x in v]
    return np.array(result)

#lancement
z1_bis = boucle_v1_bis(vec)
print(np.sum(z1_bis))

272817349.82839215

#temps de traitement
%timeit -r 10 -n 1 boucle_v1_bis(vec)

354 ms ± 13.8 ms per loop (mean ± std. dev. of 10 runs, 1 loop each)

#boucle sur un vecteur numpy
def boucle_v2(v):
    result = np.empty(v.shape[0])
    for i in range(v.shape[0]):
        result[i] = trans(v[i])
    return result

#lancement
z2 = boucle_v2(vec)
print(np.sum(z2))

272817349.82839215

#temps de traitement
%timeit -r 10 -n 1 boucle_v2(vec)

385 ms ± 8.37 ms per loop (mean ± std. dev. of 10 runs, 1 loop each)

#boucle sur un vecteur
def boucle_v3(v):
    result = np.empty(v.shape[0])
    for i,x in enumerate(v):
        result[i] = trans(x)
    return result

#lancement
z3 = boucle_v3(vec)
print(np.sum(z3))

272817349.82839215

#temps de traitement
%timeit -r 10 -n 1 boucle_v3(vec)

390 ms ± 10.3 ms per loop (mean ± std. dev. of 10 runs, 1 loop each)

Vectorisation

#fonction de vectorisation
vecfun = np.vectorize(trans)

#application de la fonction
z4 = vecfun(vec)
np.sum(z4)

272817349.82839215

#temps de traitement
%timeit -r 10 -n 1 vecfun(vec)

234 ms ± 8.25 ms per loop (mean ± std. dev. of 10 runs, 1 loop each)

Vectorisation avec Numba

#version de numba
import numba
numba.__version__

'0.60.0'

from numba import njit
#fonction pour transformer une valeur
@njit
def trans_numba(x):
    if (x < 0.1):
        res = 1
    elif (x < 0.3):
        res = x**2
    elif (x < 0.8):
        res = (x+1)*31.5
    else:
        res = 1245
    return res

#fonction de vectorisation
vecfun_numba = np.vectorize(trans_numba)

#application de la fonction
z5 = vecfun_numba(vec)
np.sum(z5)

272817349.82839215

#temps de traitement
%timeit -r 10 -n 1 vecfun_numba(vec)

197 ms ± 7.5 ms per loop (mean ± std. dev. of 10 runs, 1 loop each)

Vectorisation avec Numba + xarray

from numba import vectorize, float64
#nouvelle directive de compilation pour la vectorisation
@vectorize([float64(float64)])
def trans_numba_bis(x):
    if (x < 0.1):
        res = 1
    elif (x < 0.3):
        res = x**2
    elif (x < 0.8):
        res = (x+1)*31.5
    else:
        res = 1245
    return res

#version de xarray
import xarray as xr
xr.__version__

'2023.6.0'

#appliquer la fonction trans() aux valeurs du vecteur
import xarray as xr
z6 = xr.apply_ufunc(trans_numba_bis,vec)
np.sum(z6)

272817349.82839215

#temps de traitement
%timeit -r 10 -n 1 xr.apply_ufunc(trans_numba_bis,vec)

5.49 ms ± 1.35 ms per loop (mean ± std. dev. of 10 runs, 1 loop each)

Indexation booléene

#ré-écrire la fonction trans
def index_bool(v):
    result = np.zeros(v.shape[0])
    result[v < 0.1] = 1
    result[(v >= 0.1) & (v < 0.3)] = v[(v >= 0.1) & (v < 0.3)]**2
    result[(v >= 0.3) & (v < 0.8)] = (v[(v >= 0.3) & (v < 0.8)] + 1) * 31.5
    result[v >= 0.8] = 1245
    return result

#tester
z7 = index_bool(vec)
np.sum(z7)

272817349.82839215

#temps de traitement
%timeit -r 10 -n 1 index_bool(vec)

48.3 ms ± 3.15 ms per loop (mean ± std. dev. of 10 runs, 1 loop each)