NumCpp : une implémentation C++ d'en-tête modélisée uniquement de la bibliothèque Python NumPy
Version:
Licence
Essai
Normes C++ :
Compilateurs :
Visual Studio : 2022
GNU : 11.3 Clang : 14
Versions boostées :
1,73+
Documentation
GitHub
Installation
Bâtiment
Notes de version
De NumPy à NumCpp – Un guide de démarrage rapide
Ce guide de démarrage rapide se veut un très bref aperçu de certaines des choses qui peuvent être faites avec NumCpp . Pour une description complète de tout ce qui est disponible dans la bibliothèque NumCpp , veuillez visiter la documentation complète.
CONTENEURS
La structure de données principale de NumCpp est le NdArray . Il s'agit intrinsèquement d'une classe de tableaux 2D, les tableaux 1D étant implémentés sous forme de tableaux 1xN. Il existe également une classe DataCube qui est fournie comme conteneur pratique pour stocker un tableau de NdArray 2D, mais son utilité est limitée au-delà d'un simple conteneur.
| NumPy | NbCpp |
|---|
a = np.array([[1, 2], [3, 4], [5, 6]]) | nc::NdArray a = { {1, 2}, {3, 4}, {5, 6} } |
a.reshape([2, 3]) | a.reshape(2, 3) |
a.astype(np.double) | a.astype() |
INITIALISATEURS
De nombreuses fonctions d'initialisation sont fournies qui renvoient des NdArray pour les besoins courants.
| NumPy | NbCpp |
|---|
np.linspace(1, 10, 5) | nc::linspace(1, 10, 5) |
np.arange(3, 7) | nc::arange(3, 7) |
np.eye(4) | nc::eye(4) |
np.zeros([3, 4]) | nc::zeros(3, 4) |
| nc::NdArray(3, 4) a = 0 |
np.ones([3, 4]) | nc::ones(3, 4) |
| nc::NdArray(3, 4) a = 1 |
np.nans([3, 4]) | nc::nans(3, 4) |
| nc::NdArray(3, 4) a = nc::constants::nan |
np.empty([3, 4]) | nc::empty(3, 4) |
| nc::NdArray(3, 4) a |
DÉCOUPE/DIFFUSION
NumCpp propose un découpage et une diffusion de style NumPy .
| NumPy | NbCpp |
|---|
a[2, 3] | a(2, 3) |
a[2:5, 5:8] | a(nc::Slice(2, 5), nc::Slice(5, 8)) |
| a({2, 5}, {5, 8}) |
a[:, 7] | a(a.rSlice(), 7) |
a[a > 5] | a[a > 5] |
a[a > 5] = 0 | a.putMask(a > 5, 0) |
ALÉATOIRE
Le module random fournit des moyens simples de créer des tableaux aléatoires.
| NumPy | NbCpp |
|---|
np.random.seed(666) | nc::random::seed(666) |
np.random.randn(3, 4) | nc::random::randN(nc::Shape(3, 4)) |
| nc::random::randN({3, 4}) |
np.random.randint(0, 10, [3, 4]) | nc::random::randInt(nc::Shape(3, 4), 0, 10) |
| nc::random::randInt({3, 4}, 0, 10) |
np.random.rand(3, 4) | nc::random::rand(nc::Shape(3,4)) |
| nc::random::rand({3, 4}) |
np.random.choice(a, 3) | nc::random::choice(a, 3) |
ENCHAÎNEMENT
De nombreuses façons de concaténer NdArray sont disponibles.
| NumPy | NbCpp |
|---|
np.stack([a, b, c], axis=0) | nc::stack({a, b, c}, nc::Axis::ROW) |
np.vstack([a, b, c]) | nc::vstack({a, b, c}) |
np.hstack([a, b, c]) | nc::hstack({a, b, c}) |
np.append(a, b, axis=1) | nc::append(a, b, nc::Axis::COL) |
DIAGONALE, TRIANGULAIRE ET FLIP
Les éléments suivants renvoient de nouveaux NdArray s.
| NumPy | NbCpp |
|---|
np.diagonal(a) | nc::diagonal(a) |
np.triu(a) | nc::triu(a) |
np.tril(a) | nc::tril(a) |
np.flip(a, axis=0) | nc::flip(a, nc::Axis::ROW) |
np.flipud(a) | nc::flipud(a) |
np.fliplr(a) | nc::fliplr(a) |
ITÉRATION
NumCpp suit les idiomes du STL C++ fournissant des paires d'itérateurs pour itérer sur les tableaux de différentes manières.
| NumPy | NbCpp |
|---|
for value in a | for(auto it = a.begin(); it < a.end(); ++it) |
| for(auto& value : a) |
LOGIQUE
Les FONCTIONS logiques dans NumCpp se comportent de la même manière que NumPy .
| NumPy | NbCpp |
|---|
np.where(a > 5, a, b) | nc::where(a > 5, a, b) |
np.any(a) | nc::any(a) |
np.all(a) | nc::all(a) |
np.logical_and(a, b) | nc::logical_and(a, b) |
np.logical_or(a, b) | nc::logical_or(a, b) |
np.isclose(a, b) | nc::isclose(a, b) |
np.allclose(a, b) | nc::allclose(a, b) |
COMPARAISON
| NumPy | NbCpp |
|---|
np.equal(a, b) | nc::equal(a, b) |
| a == b |
np.not_equal(a, b) | nc::not_equal(a, b) |
| a != b |
rows, cols = np.nonzero(a) | auto [rows, cols] = nc::nonzero(a) |
MINIMUM, MAXIMUM, TRI
| NumPy | NbCpp |
|---|
np.min(a) | nc::min(a) |
np.max(a) | nc::max(a) |
np.argmin(a) | nc::argmin(a) |
np.argmax(a) | nc::argmax(a) |
np.sort(a, axis=0) | nc::sort(a, nc::Axis::ROW) |
np.argsort(a, axis=1) | nc::argsort(a, nc::Axis::COL) |
np.unique(a) | nc::unique(a) |
np.setdiff1d(a, b) | nc::setdiff1d(a, b) |
np.diff(a) | nc::diff(a) |
RÉDUCTEURS
Les réducteurs accumulent les valeurs de NdArray le long des axes spécifiés. Lorsqu'aucun axe n'est spécifié, les valeurs sont accumulées le long de tous les axes.
| NumPy | NbCpp |
|---|
np.sum(a) | nc::sum(a) |
np.sum(a, axis=0) | nc::sum(a, nc::Axis::ROW) |
np.prod(a) | nc::prod(a) |
np.prod(a, axis=0) | nc::prod(a, nc::Axis::ROW) |
np.mean(a) | nc::mean(a) |
np.mean(a, axis=0) | nc::mean(a, nc::Axis::ROW) |
np.count_nonzero(a) | nc::count_nonzero(a) |
np.count_nonzero(a, axis=0) | nc::count_nonzero(a, nc::Axis::ROW) |
E/S
Méthodes d’impression et de sortie de fichiers. Toutes les classes NumCpp prennent en charge une méthode print() et des opérateurs << stream.
| NumPy | NbCpp |
|---|
print(a) | a.print() |
| std::cout << a |
a.tofile(filename, sep='n') | a.tofile(filename, 'n') |
np.fromfile(filename, sep='n') | nc::fromfile(filename, 'n') |
np.dump(a, filename) | nc::dump(a, filename) |
np.load(filename) | nc::load(filename) |
FONCTIONS MATHÉMATIQUES
Les fonctions universelles NumCpp sont fournies pour un grand nombre de fonctions mathématiques.
FONCTIONS DE BASE
| NumPy | NbCpp |
|---|
np.abs(a) | nc::abs(a) |
np.sign(a) | nc::sign(a) |
np.remainder(a, b) | nc::remainder(a, b) |
np.clip(a, 3, 8) | nc::clip(a, 3, 8) |
np.interp(x, xp, fp) | nc::interp(x, xp, fp) |
FONCTIONS EXPONENTIELLES
| NumPy | NbCpp |
|---|
np.exp(a) | nc::exp(a) |
np.expm1(a) | nc::expm1(a) |
np.log(a) | nc::log(a) |
np.log1p(a) | nc::log1p(a) |
FONCTIONS DE PUISSANCE
| NumPy | NbCpp |
|---|
np.power(a, 4) | nc::power(a, 4) |
np.sqrt(a) | nc::sqrt(a) |
np.square(a) | nc::square(a) |
np.cbrt(a) | nc::cbrt(a) |
FONCTIONS TRIGONOMÉTRIQUES
| NumPy | NbCpp |
|---|
np.sin(a) | nc::sin(a) |
np.cos(a) | nc::cos(a) |
np.tan(a) | nc::tan(a) |
FONCTIONS HYPERBOLIQUES
| NumPy | NbCpp |
|---|
np.sinh(a) | nc::sinh(a) |
np.cosh(a) | nc::cosh(a) |
np.tanh(a) | nc::tanh(a) |
FONCTIONS DE CLASSEMENT
| NumPy | NbCpp |
|---|
np.isnan(a) | nc::isnan(a) |
np.isinf(a) | nc::isinf(a) |
ALGÈBRE LINÉAIRE
| NumPy | NbCpp |
|---|
np.linalg.norm(a) | nc::norm(a) |
np.dot(a, b) | nc::dot(a, b) |
np.linalg.det(a) | nc::linalg::det(a) |
np.linalg.inv(a) | nc::linalg::inv(a) |
np.linalg.lstsq(a, b) | nc::linalg::lstsq(a, b) |
np.linalg.matrix_power(a, 3) | nc::linalg::matrix_power(a, 3) |
Np.linalg.multi_dot(a, b, c) | nc::linalg::multi_dot({a, b, c}) |
np.linalg.svd(a) | nc::linalg::svd(a) |
