¿Matrices de estilo NumPy para C++?

Prueba xtensor. (Ver la Hoja de trucos de NumPy a Xtensor).

Xtensor es una biblioteca de C++ diseñada para el análisis numérico con expresiones de matriz multidimensional.

Xtensor proporciona

• un sistema de expresión extensible que permite la difusión al estilo numpy.
• una API que sigue los modismos de la biblioteca estándar de C++.
• herramientas para manipular expresiones de matriz y construir sobre xtensor.

Ejemplo

Inicialice una matriz 2-D y calcule la suma de una de sus filas y una matriz 1-D.

#include <iostream>
#include "xtensor/xarray.hpp"
#include "xtensor/xio.hpp"

xt::xarray<double> arr1
  {{1.0, 2.0, 3.0},
   {2.0, 5.0, 7.0},
   {2.0, 5.0, 7.0}};

xt::xarray<double> arr2
  {5.0, 6.0, 7.0};

xt::xarray<double> res = xt::view(arr1, 1) + arr2;

std::cout << res;

Salidas

{7, 11, 14}

Inicializar una matriz 1-D y remodelarla en su lugar.

#include <iostream>
#include "xtensor/xarray.hpp"
#include "xtensor/xio.hpp"

xt::xarray<int> arr
  {1, 2, 3, 4, 5, 6, 7, 8, 9};

arr.reshape({3, 3});

std::cout << arr;

Salidas

{{1, 2, 3},
 {4, 5, 6},
 {7, 8, 9}}

DyND está diseñado para ser, entre otras cosas, una biblioteca tipo NumPy para C++. Cosas como la radiodifusión, los operadores aritméticos y el corte funcionan bien. Por otro lado, todavía es muy experimental y muchas características aún no se han implementado.

Aquí hay una implementación simple del algoritmo de Casteljau en C++ usando matrices DyND:

#include <iostream>
#include <dynd/array.hpp>

using namespace dynd;

nd::array decasteljau(nd::array a, double t){
    size_t e = a.get_dim_size();
    for(size_t i=0; i < e-1; i++){
        a = (1.-t) * a(irange()<(e-i-1)) + t * a(0<irange());
    }
    return a;
}

int main(){
    nd::array a = {1., 2., 2., -1.};
    std::cout << decasteljau(a, .25) << std::endl;
}

Escribí una entrada de blog hace un rato con más ejemplos y comparaciones lado a lado de la sintaxis para Fortran 90, DyND en C++ y NumPy en Python.

Descargo de responsabilidad: Soy uno de los desarrolladores actuales de DyND.

Eigen es una buena biblioteca de álgebra lineal.

Http://eigen.tuxfamily.org/index.php?title=Main_Page

Es bastante fácil de instalar ya que es una biblioteca de solo encabezado. Se basa en la plantilla con el fin de generar código bien optimizado. Vectoriza automáticamente las operaciones de la matriz.

También soporta completamente operaciones de coeficiente sabio, como la "multiplicación por elemento" entre dos matrices por ejemplo. ¿Es lo que necesitas?

Blitz++ soporta arrays con un número arbitrario de ejes, mientras que Armadillo solo soporta hasta tres (vectores, matrices y cubos). Eigen solo soporta vectores y matrices (no cubos). La desventaja es que Blitz++ no tiene funciones de álgebra lineal más allá de las operaciones básicas de entrada y las contracciones de tensor. El desarrollo parece haberse ralentizado hace bastante tiempo, pero tal vez eso es solo porque la biblioteca hace lo que hace y no es necesario realizar muchos cambios hecho.

VIGRA contiene una buena implementación de matriz N-dimensional:

Http://ukoethe.github.io/vigra/doc/vigra/Tutorial.html

Lo uso ampliamente, y lo encuentro muy simple y efectivo. También es solo encabezado, por lo que es muy fácil de integrar en su entorno de desarrollo. Es lo más cercano que me he encontrado con el uso de NumPy en términos de su API.

El principal inconveniente es que no es tan utilizado como los demás, por lo que no encontrará mucha ayuda en línea. Eso, y es torpemente nombrado (trate de buscarlo!)

Eigen es una biblioteca de plantillas para álgebra lineal (matrices, vectores vectors). Es solo de cabecera y de uso gratuito (LGPL).

El GSL es genial, hace todo lo que estás pidiendo y mucho más. Sin embargo, está licenciado bajo la GPL.

Mientras que GLM está diseñado para acoplarse fácilmente con OpenGL y GLSL, es una biblioteca matemática de cabecera totalmente funcional para C++ con un conjunto de interfaces muy intuitivo.

Declara tipos de vectores y matrices, así como varias operaciones sobre ellos.

Multiplicar dos matrices es un simple as (M1 * M2). Restando dos vectores (V1-V2).

Acceder a los valores contenidos en vectores o matrices es igualmente sencillo. Después de declarar un vector vec3, por ejemplo, se puede acceder a su primer elemento con vector.x. Compruébalo.

Todas estas cosas son posibles utilizando la Biblioteca de Plantillas Estándar (STL) que está disponible como parte de la mayoría de las implementaciones de compiladores. ¿Has mirado STL?