Génération vecteur de valeurs¶

In [19]:
#Python
import sys
sys.version
Out[19]:
'3.11.11 | packaged by conda-forge | (main, Dec  5 2024, 14:06:23) [MSC v.1942 64 bit (AMD64)]'
In [20]:
#numpy
import numpy
numpy.__version__
Out[20]:
'2.0.2'
In [21]:
#nombre de valeurs
n = 5000
In [22]:
#vecteur de valeurs
rng = numpy.random.default_rng(seed=2024)
v = rng.random(size=n)
v.shape
Out[22]:
(5000,)
In [23]:
#valeur du minimum
numpy.min(v)
Out[23]:
np.float64(0.00042384932857031377)

Programme recherche minimum¶

In [24]:
#sans directive particulière
def mon_min(x):
    n = x.shape[0]
    #départ
    global_min = x[0]
    for i in range(n):
        is_min = True
        for j in range(n):
            if (x[j] < x[i]):
                is_min = False
        if (is_min == True):
            global_min = x[i]
    #renvoyer l'extremum
    return global_min
In [25]:
#exécution sur notre vecteur
print(mon_min(v))

0.00042384932857031377
In [26]:
#temps de calcul
%timeit -r 3 -n 1 mon_min(v)

4.56 s ± 68.2 ms per loop (mean ± std. dev. of 3 runs, 1 loop each)

Compilation avec Taichi¶

In [27]:
#version de taichi
import taichi as ti
ti.__version__
Out[27]:
(1, 7, 3)
In [28]:
#initialisation de taichi, utilisation du cpu
ti.init(arch=ti.cpu)

[Taichi] Starting on arch=x64
In [29]:
#et l'étendue - fonction "publique"
@ti.kernel
def mon_min_taichi(x: ti.types.ndarray()) -> float:
    n = x.shape[0]
    #départ
    global_min = x[0]
    #pas de parallélisation des boucles
    ti.loop_config(serialize=True)
    for i in range(n):
        is_min = True
        for j in range(n):
            if (x[j] < x[i]):
                is_min = False
        if (is_min == True):
            global_min = x[i]
    #renvoyer l'extremum
    return global_min
In [30]:
#relancer
print(mon_min_taichi(v))

0.0004238493274897337
In [31]:
#temps de calcul
%timeit mon_min_taichi(v)

3.16 ms ± 80.5 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Compilation avec Numba¶

In [32]:
#version de numba
import numba
numba.__version__
Out[32]:
'0.60.0'
In [33]:
#pour compilation
from numba import njit

#minimum avec Numba
@njit
def mon_min_numba(x):
    n = x.shape[0]
    #départ
    global_min = x[0]
    for i in range(n):
        is_min = True
        for j in range(n):
            if (x[j] < x[i]):
                is_min = False
        if (is_min == True):
            global_min = x[i]
    #renvoyer l'extremum
    return global_min
In [34]:
#relancer
print(mon_min_numba(v))

0.00042384932857031377
In [35]:
#temps de calcul
%timeit mon_min_numba(v)

2.7 ms ± 90.8 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)