NumCpp: una implementación en C++ de encabezado con plantilla de la biblioteca NumPy de Python
Versión:
Licencia
Pruebas
Estándares C++:
Compiladores:
Estudio visual: 2022
GNU: 11.3 Sonido metálico: 14
Versiones mejoradas:
1.73+
Documentación
GitHub
Instalación
Edificio
Notas de la versión
De NumPy a NumCpp: una guía de inicio rápido
Esta guía de inicio rápido pretende ser una breve descripción general de algunas de las cosas que se pueden hacer con NumCpp . Para obtener un desglose completo de todo lo disponible en la biblioteca NumCpp , visite la documentación completa.
CONTENEDORES
La principal estructura de datos en NumCpp es NdArray . Es inherentemente una clase de matriz 2D, y las matrices 1D se implementan como matrices 1xN. También existe una clase DataCube que se proporciona como un contenedor conveniente para almacenar una matriz de NdArray 2D, pero tiene una utilidad limitada más allá de un simple contenedor.
| NumPy | NúmCpp |
|---|
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() |
INICIALIZADORES
Se proporcionan muchas funciones de inicializador que devuelven NdArray para necesidades comunes.
| NumPy | NúmCpp |
|---|
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 |
CORTE/DIFUSIÓN
NumCpp ofrece división y transmisión al estilo NumPy .
| NumPy | NúmCpp |
|---|
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) |
ALEATORIO
El módulo aleatorio proporciona formas sencillas de crear matrices aleatorias.
| NumPy | NúmCpp |
|---|
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) |
CONCATENACIÓN
Hay muchas formas de concatenar NdArray disponibles.
| NumPy | NúmCpp |
|---|
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) |
DIAGONAL, TRIANGULAR Y FLIP
Lo siguiente devuelve nuevos NdArray s.
| NumPy | NúmCpp |
|---|
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) |
ITERACIÓN
NumCpp sigue los modismos de C++ STL y proporciona pares de iteradores para iterar en matrices de diferentes formas.
| NumPy | NúmCpp |
|---|
for value in a | for(auto it = a.begin(); it < a.end(); ++it) |
| for(auto& value : a) |
LÓGICO
Las FUNCIONES lógicas en NumCpp se comportan igual que NumPy .
| NumPy | NúmCpp |
|---|
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) |
COMPARACIONES
| NumPy | NúmCpp |
|---|
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) |
MÍNIMO, MÁXIMO, CLASIFICACIÓN
| NumPy | NúmCpp |
|---|
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) |
REDUCTORES
Los reductores acumulan valores de NdArray s a lo largo de ejes específicos. Cuando no se especifica ningún eje, los valores se acumulan a lo largo de todos los ejes.
| NumPy | NúmCpp |
|---|
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étodos de salida de archivos e impresiones. Todas las clases de NumCpp admiten un método print() y operadores de flujo << .
| NumPy | NúmCpp |
|---|
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) |
FUNCIONES MATEMÁTICAS
Las funciones universales NumCpp se proporcionan para una gran cantidad de funciones matemáticas.
FUNCIONES BÁSICAS
| NumPy | NúmCpp |
|---|
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) |
FUNCIONES EXPONENCIALES
| NumPy | NúmCpp |
|---|
np.exp(a) | nc::exp(a) |
np.expm1(a) | nc::expm1(a) |
np.log(a) | nc::log(a) |
np.log1p(a) | nc::log1p(a) |
FUNCIONES DE POTENCIA
| NumPy | NúmCpp |
|---|
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) |
FUNCIONES TRIGONOMÉTRICAS
| NumPy | NúmCpp |
|---|
np.sin(a) | nc::sin(a) |
np.cos(a) | nc::cos(a) |
np.tan(a) | nc::tan(a) |
FUNCIONES HIPERBÓLICAS
| NumPy | NúmCpp |
|---|
np.sinh(a) | nc::sinh(a) |
np.cosh(a) | nc::cosh(a) |
np.tanh(a) | nc::tanh(a) |
FUNCIONES DE CLASIFICACIÓN
| NumPy | NúmCpp |
|---|
np.isnan(a) | nc::isnan(a) |
np.isinf(a) | nc::isinf(a) |
ÁLGEBRA LINEAL
| NumPy | NúmCpp |
|---|
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) |
