Stellen Sie die von Eigen of C ++ erstellte Bibliothek mit Boost.Numpy in Python zur Verfügung.

Dieser Beitrag

Notieren Sie sich, was Sie in der Sapporo C ++ - Studiengruppe Online Mokumokukai # 36 getan haben.

Wie installiert man

Bitte schlagen Sie einen anderen Ort. Gib dein Bestes.

Dinge die zu tun sind

Als einfaches Beispiel die Summe der zweidimensionalen Arrays, die von numpy in Python erstellt wurden Es verwendet die C ++ Eigenbibliothek zur Berechnung und gibt sie dann an Python zurück.

C ++ - Quellcode

cpplib.cpp

#define EIGEN_DEFAULT_TO_ROW_MAJOR
#include<Eigen/Core>
#include<boost/numpy.hpp>
namespace py = boost::python;
namespace np = boost::numpy;

np::ndarray add_double(const np::ndarray lhs, const np::ndarray rhs) {
    using Stride = Eigen::Stride<Eigen::Dynamic, Eigen::Dynamic>;
    const auto
        lrows = lhs.shape(0),
        lcols = lhs.shape(1),
        rrows = rhs.shape(0),
        rcols = rhs.shape(1);

    const Stride
        lstride(lhs.strides(0)/sizeof(double), lhs.strides(1)/sizeof(double)),
        rstride(rhs.strides(0)/sizeof(double), rhs.strides(1)/sizeof(double));

    const Eigen::Map<const Eigen::MatrixXd, Eigen::Unaligned, Stride>
        lmat(reinterpret_cast<double*>(lhs.get_data()), lrows, lcols, lstride),
        rmat(reinterpret_cast<double*>(rhs.get_data()), rrows, rcols, rstride);

    np::ndarray ret = np::empty(
        py::make_tuple(lmat.rows(),lmat.cols()), 
        np::dtype::get_builtin<double>());

    Eigen::Map<Eigen::MatrixXd>
        ret_mat(reinterpret_cast<double*>(ret.get_data()), lmat.rows(), lmat.cols());

    ret_mat = lmat + rmat;
    return ret;
}

BOOST_PYTHON_MODULE(cpplib) {
    Py_Initialize();
    np::initialize();
    py::def("add_double",add_double); 
}

Es ist möglicherweise einfacher zu schreiben, wenn es nur zum Hinzufügen von Matrizen dient, aber es ist so geschrieben, dass es angewendet werden kann. Es ist unvermeidlich, dass der Typ auf "double" beschränkt ist. Die einzige Möglichkeit, dies zu tun, besteht darin, "dtype" und "branch" zu überprüfen, aber es bleibt keine andere Wahl, als zur Laufzeit zu urteilen.

Wie zu kompilieren

Ich werde es mit SCons machen. Zum Beispiel so. Ich mache es in einer Mingw-Umgebung.

SConstruct

# vim: filetype=python
# SConstruct

env = Environment(
    SHLIBPREFIX="",
    SHLIBSUFFIX=".pyd",
    CXX="/mingw64/bin/g++",
    CXXFLAGS=["-std=c++14"],
    LINKFLAGS=["-std=c++14"],
    CPPPATH=[
        "/mingw64/include/eigen3",
        "/mingw64/include/python3.5m", ],
    LIBPATH=["/mingw64/lib"])

env.SharedLibrary("cpplib", ["cpplib.cpp"],
    LIBS=["boost_numpy", "python3.5.dll", "boost_python3-mt"])

Python-Code

usecpp.py

import numpy as np
from cpplib import add_double

a = np.array(
    [[1, 2, 3, 4],
     [5, 6, 7, 8],
     [9, 1, 2, 3],
     [4, 5, 6, 7], ], dtype=np.float64)
b = np.array(
    [[5, 6],
     [4, 5], ], dtype=np.float64)

result = add_double(a[1::2, 1::2], b[::1, ::1])
print(result)

Ergebnis ist Da "[[6,8], [5,7]]" und "[[5,6], [4,5]]" hinzugefügt werden

$ python3 usecpp.py
[[ 11.  14.]
 [  9.  12.]]

Es wird sein. Auch hier ist die bewölkte Besprechungszeit abgelaufen.

Nachtrag

https://github.com/ignisan/boost_numpy_project/blob/master/to_eigen_map.hpp