test_eigen.cpp revision 14299
110458Sandreas.hansson@arm.com/*
210458Sandreas.hansson@arm.com    tests/eigen.cpp -- automatic conversion of Eigen types
310458Sandreas.hansson@arm.com
410458Sandreas.hansson@arm.com    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
510458Sandreas.hansson@arm.com
610458Sandreas.hansson@arm.com    All rights reserved. Use of this source code is governed by a
710458Sandreas.hansson@arm.com    BSD-style license that can be found in the LICENSE file.
810458Sandreas.hansson@arm.com*/
910458Sandreas.hansson@arm.com
1010458Sandreas.hansson@arm.com#include "pybind11_tests.h"
1110458Sandreas.hansson@arm.com#include "constructor_stats.h"
1210458Sandreas.hansson@arm.com#include <pybind11/eigen.h>
1310458Sandreas.hansson@arm.com#include <pybind11/stl.h>
1410458Sandreas.hansson@arm.com
1510458Sandreas.hansson@arm.com#if defined(_MSC_VER)
1610458Sandreas.hansson@arm.com#  pragma warning(disable: 4996) // C4996: std::unary_negation is deprecated
1710458Sandreas.hansson@arm.com#endif
1810458Sandreas.hansson@arm.com
1910458Sandreas.hansson@arm.com#include <Eigen/Cholesky>
2010458Sandreas.hansson@arm.com
2110458Sandreas.hansson@arm.comusing MatrixXdR = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
2210458Sandreas.hansson@arm.com
2310458Sandreas.hansson@arm.com
2410458Sandreas.hansson@arm.com
2510458Sandreas.hansson@arm.com// Sets/resets a testing reference matrix to have values of 10*r + c, where r and c are the
2610458Sandreas.hansson@arm.com// (1-based) row/column number.
2710458Sandreas.hansson@arm.comtemplate <typename M> void reset_ref(M &x) {
2810458Sandreas.hansson@arm.com    for (int i = 0; i < x.rows(); i++) for (int j = 0; j < x.cols(); j++)
2910458Sandreas.hansson@arm.com        x(i, j) = 11 + 10*i + j;
3010458Sandreas.hansson@arm.com}
3110458Sandreas.hansson@arm.com
3210458Sandreas.hansson@arm.com// Returns a static, column-major matrix
3310458Sandreas.hansson@arm.comEigen::MatrixXd &get_cm() {
3410458Sandreas.hansson@arm.com    static Eigen::MatrixXd *x;
3510458Sandreas.hansson@arm.com    if (!x) {
3610458Sandreas.hansson@arm.com        x = new Eigen::MatrixXd(3, 3);
3710458Sandreas.hansson@arm.com        reset_ref(*x);
3810458Sandreas.hansson@arm.com    }
3910458Sandreas.hansson@arm.com    return *x;
4010458Sandreas.hansson@arm.com}
4110458Sandreas.hansson@arm.com// Likewise, but row-major
4210458Sandreas.hansson@arm.comMatrixXdR &get_rm() {
4310458Sandreas.hansson@arm.com    static MatrixXdR *x;
4410458Sandreas.hansson@arm.com    if (!x) {
4510458Sandreas.hansson@arm.com        x = new MatrixXdR(3, 3);
4610458Sandreas.hansson@arm.com        reset_ref(*x);
4710458Sandreas.hansson@arm.com    }
4810458Sandreas.hansson@arm.com    return *x;
4910458Sandreas.hansson@arm.com}
5010458Sandreas.hansson@arm.com// Resets the values of the static matrices returned by get_cm()/get_rm()
5110458Sandreas.hansson@arm.comvoid reset_refs() {
5210458Sandreas.hansson@arm.com    reset_ref(get_cm());
5310458Sandreas.hansson@arm.com    reset_ref(get_rm());
5410458Sandreas.hansson@arm.com}
5510458Sandreas.hansson@arm.com
5610458Sandreas.hansson@arm.com// Returns element 2,1 from a matrix (used to test copy/nocopy)
5710458Sandreas.hansson@arm.comdouble get_elem(Eigen::Ref<const Eigen::MatrixXd> m) { return m(2, 1); };
5810458Sandreas.hansson@arm.com
5910458Sandreas.hansson@arm.com
6010458Sandreas.hansson@arm.com// Returns a matrix with 10*r + 100*c added to each matrix element (to help test that the matrix
6110458Sandreas.hansson@arm.com// reference is referencing rows/columns correctly).
6210458Sandreas.hansson@arm.comtemplate <typename MatrixArgType> Eigen::MatrixXd adjust_matrix(MatrixArgType m) {
6310458Sandreas.hansson@arm.com    Eigen::MatrixXd ret(m);
6410905Sandreas.sandberg@arm.com    for (int c = 0; c < m.cols(); c++) for (int r = 0; r < m.rows(); r++)
6510458Sandreas.hansson@arm.com        ret(r, c) += 10*r + 100*c;
6610458Sandreas.hansson@arm.com    return ret;
6710458Sandreas.hansson@arm.com}
6810458Sandreas.hansson@arm.com
6910458Sandreas.hansson@arm.comstruct CustomOperatorNew {
7010458Sandreas.hansson@arm.com    CustomOperatorNew() = default;
7110458Sandreas.hansson@arm.com
7210458Sandreas.hansson@arm.com    Eigen::Matrix4d a = Eigen::Matrix4d::Zero();
7310458Sandreas.hansson@arm.com    Eigen::Matrix4d b = Eigen::Matrix4d::Identity();
7410458Sandreas.hansson@arm.com
7510458Sandreas.hansson@arm.com    EIGEN_MAKE_ALIGNED_OPERATOR_NEW;
7610458Sandreas.hansson@arm.com};
7710458Sandreas.hansson@arm.com
7810458Sandreas.hansson@arm.comTEST_SUBMODULE(eigen, m) {
7910458Sandreas.hansson@arm.com    using FixedMatrixR = Eigen::Matrix<float, 5, 6, Eigen::RowMajor>;
8010458Sandreas.hansson@arm.com    using FixedMatrixC = Eigen::Matrix<float, 5, 6>;
8110458Sandreas.hansson@arm.com    using DenseMatrixR = Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
8210458Sandreas.hansson@arm.com    using DenseMatrixC = Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic>;
8310458Sandreas.hansson@arm.com    using FourRowMatrixC = Eigen::Matrix<float, 4, Eigen::Dynamic>;
8410458Sandreas.hansson@arm.com    using FourColMatrixC = Eigen::Matrix<float, Eigen::Dynamic, 4>;
8510458Sandreas.hansson@arm.com    using FourRowMatrixR = Eigen::Matrix<float, 4, Eigen::Dynamic>;
8610458Sandreas.hansson@arm.com    using FourColMatrixR = Eigen::Matrix<float, Eigen::Dynamic, 4>;
8710458Sandreas.hansson@arm.com    using SparseMatrixR = Eigen::SparseMatrix<float, Eigen::RowMajor>;
8810458Sandreas.hansson@arm.com    using SparseMatrixC = Eigen::SparseMatrix<float>;
8910458Sandreas.hansson@arm.com
9010458Sandreas.hansson@arm.com    m.attr("have_eigen") = true;
9110458Sandreas.hansson@arm.com
9210458Sandreas.hansson@arm.com    // various tests
9310458Sandreas.hansson@arm.com    m.def("double_col", [](const Eigen::VectorXf &x) -> Eigen::VectorXf { return 2.0f * x; });
9410458Sandreas.hansson@arm.com    m.def("double_row", [](const Eigen::RowVectorXf &x) -> Eigen::RowVectorXf { return 2.0f * x; });
9510458Sandreas.hansson@arm.com    m.def("double_complex", [](const Eigen::VectorXcf &x) -> Eigen::VectorXcf { return 2.0f * x; });
9610458Sandreas.hansson@arm.com    m.def("double_threec", [](py::EigenDRef<Eigen::Vector3f> x) { x *= 2; });
9710458Sandreas.hansson@arm.com    m.def("double_threer", [](py::EigenDRef<Eigen::RowVector3f> x) { x *= 2; });
9810458Sandreas.hansson@arm.com    m.def("double_mat_cm", [](Eigen::MatrixXf x) -> Eigen::MatrixXf { return 2.0f * x; });
9910458Sandreas.hansson@arm.com    m.def("double_mat_rm", [](DenseMatrixR x) -> DenseMatrixR { return 2.0f * x; });
10010458Sandreas.hansson@arm.com
10110458Sandreas.hansson@arm.com    // test_eigen_ref_to_python
10210458Sandreas.hansson@arm.com    // Different ways of passing via Eigen::Ref; the first and second are the Eigen-recommended
10310458Sandreas.hansson@arm.com    m.def("cholesky1", [](Eigen::Ref<MatrixXdR> x) -> Eigen::MatrixXd { return x.llt().matrixL(); });
10410458Sandreas.hansson@arm.com    m.def("cholesky2", [](const Eigen::Ref<const MatrixXdR> &x) -> Eigen::MatrixXd { return x.llt().matrixL(); });
10510458Sandreas.hansson@arm.com    m.def("cholesky3", [](const Eigen::Ref<MatrixXdR> &x) -> Eigen::MatrixXd { return x.llt().matrixL(); });
10610458Sandreas.hansson@arm.com    m.def("cholesky4", [](Eigen::Ref<const MatrixXdR> x) -> Eigen::MatrixXd { return x.llt().matrixL(); });
10710458Sandreas.hansson@arm.com
10810458Sandreas.hansson@arm.com    // test_eigen_ref_mutators
10910458Sandreas.hansson@arm.com    // Mutators: these add some value to the given element using Eigen, but Eigen should be mapping into
11010458Sandreas.hansson@arm.com    // the numpy array data and so the result should show up there.  There are three versions: one that
11110458Sandreas.hansson@arm.com    // works on a contiguous-row matrix (numpy's default), one for a contiguous-column matrix, and one
11210458Sandreas.hansson@arm.com    // for any matrix.
11310458Sandreas.hansson@arm.com    auto add_rm = [](Eigen::Ref<MatrixXdR> x, int r, int c, double v) { x(r,c) += v; };
11410458Sandreas.hansson@arm.com    auto add_cm = [](Eigen::Ref<Eigen::MatrixXd> x, int r, int c, double v) { x(r,c) += v; };
11510458Sandreas.hansson@arm.com
11610458Sandreas.hansson@arm.com    // Mutators (Eigen maps into numpy variables):
11710458Sandreas.hansson@arm.com    m.def("add_rm", add_rm); // Only takes row-contiguous
11810458Sandreas.hansson@arm.com    m.def("add_cm", add_cm); // Only takes column-contiguous
11910458Sandreas.hansson@arm.com    // Overloaded versions that will accept either row or column contiguous:
12010458Sandreas.hansson@arm.com    m.def("add1", add_rm);
12110458Sandreas.hansson@arm.com    m.def("add1", add_cm);
12210458Sandreas.hansson@arm.com    m.def("add2", add_cm);
12310458Sandreas.hansson@arm.com    m.def("add2", add_rm);
12410458Sandreas.hansson@arm.com    // This one accepts a matrix of any stride:
12510458Sandreas.hansson@arm.com    m.def("add_any", [](py::EigenDRef<Eigen::MatrixXd> x, int r, int c, double v) { x(r,c) += v; });
12610458Sandreas.hansson@arm.com
12710458Sandreas.hansson@arm.com    // Return mutable references (numpy maps into eigen variables)
12810458Sandreas.hansson@arm.com    m.def("get_cm_ref", []() { return Eigen::Ref<Eigen::MatrixXd>(get_cm()); });
12910458Sandreas.hansson@arm.com    m.def("get_rm_ref", []() { return Eigen::Ref<MatrixXdR>(get_rm()); });
13010458Sandreas.hansson@arm.com    // The same references, but non-mutable (numpy maps into eigen variables, but is !writeable)
13110458Sandreas.hansson@arm.com    m.def("get_cm_const_ref", []() { return Eigen::Ref<const Eigen::MatrixXd>(get_cm()); });
13210458Sandreas.hansson@arm.com    m.def("get_rm_const_ref", []() { return Eigen::Ref<const MatrixXdR>(get_rm()); });
13310458Sandreas.hansson@arm.com
13410458Sandreas.hansson@arm.com    m.def("reset_refs", reset_refs); // Restores get_{cm,rm}_ref to original values
13510458Sandreas.hansson@arm.com
13610458Sandreas.hansson@arm.com    // Increments and returns ref to (same) matrix
13710458Sandreas.hansson@arm.com    m.def("incr_matrix", [](Eigen::Ref<Eigen::MatrixXd> m, double v) {
13810458Sandreas.hansson@arm.com        m += Eigen::MatrixXd::Constant(m.rows(), m.cols(), v);
13910458Sandreas.hansson@arm.com        return m;
14010458Sandreas.hansson@arm.com    }, py::return_value_policy::reference);
14110458Sandreas.hansson@arm.com
14210458Sandreas.hansson@arm.com    // Same, but accepts a matrix of any strides
14310458Sandreas.hansson@arm.com    m.def("incr_matrix_any", [](py::EigenDRef<Eigen::MatrixXd> m, double v) {
14410458Sandreas.hansson@arm.com        m += Eigen::MatrixXd::Constant(m.rows(), m.cols(), v);
14510458Sandreas.hansson@arm.com        return m;
14610458Sandreas.hansson@arm.com    }, py::return_value_policy::reference);
14710458Sandreas.hansson@arm.com
14810458Sandreas.hansson@arm.com    // Returns an eigen slice of even rows
14910458Sandreas.hansson@arm.com    m.def("even_rows", [](py::EigenDRef<Eigen::MatrixXd> m) {
15010458Sandreas.hansson@arm.com        return py::EigenDMap<Eigen::MatrixXd>(
15110458Sandreas.hansson@arm.com                m.data(), (m.rows() + 1) / 2, m.cols(),
15210458Sandreas.hansson@arm.com                py::EigenDStride(m.outerStride(), 2 * m.innerStride()));
15310458Sandreas.hansson@arm.com    }, py::return_value_policy::reference);
15410458Sandreas.hansson@arm.com
15510458Sandreas.hansson@arm.com    // Returns an eigen slice of even columns
15610458Sandreas.hansson@arm.com    m.def("even_cols", [](py::EigenDRef<Eigen::MatrixXd> m) {
15710458Sandreas.hansson@arm.com        return py::EigenDMap<Eigen::MatrixXd>(
15810458Sandreas.hansson@arm.com                m.data(), m.rows(), (m.cols() + 1) / 2,
15910458Sandreas.hansson@arm.com                py::EigenDStride(2 * m.outerStride(), m.innerStride()));
16010458Sandreas.hansson@arm.com    }, py::return_value_policy::reference);
16110458Sandreas.hansson@arm.com
16210458Sandreas.hansson@arm.com    // Returns diagonals: a vector-like object with an inner stride != 1
16310458Sandreas.hansson@arm.com    m.def("diagonal", [](const Eigen::Ref<const Eigen::MatrixXd> &x) { return x.diagonal(); });
16410458Sandreas.hansson@arm.com    m.def("diagonal_1", [](const Eigen::Ref<const Eigen::MatrixXd> &x) { return x.diagonal<1>(); });
16510458Sandreas.hansson@arm.com    m.def("diagonal_n", [](const Eigen::Ref<const Eigen::MatrixXd> &x, int index) { return x.diagonal(index); });
16610458Sandreas.hansson@arm.com
16710458Sandreas.hansson@arm.com    // Return a block of a matrix (gives non-standard strides)
16810458Sandreas.hansson@arm.com    m.def("block", [](const Eigen::Ref<const Eigen::MatrixXd> &x, int start_row, int start_col, int block_rows, int block_cols) {
16910458Sandreas.hansson@arm.com        return x.block(start_row, start_col, block_rows, block_cols);
17010458Sandreas.hansson@arm.com    });
17110458Sandreas.hansson@arm.com
17210458Sandreas.hansson@arm.com    // test_eigen_return_references, test_eigen_keepalive
17310458Sandreas.hansson@arm.com    // return value referencing/copying tests:
17410458Sandreas.hansson@arm.com    class ReturnTester {
17510458Sandreas.hansson@arm.com        Eigen::MatrixXd mat = create();
17610458Sandreas.hansson@arm.com    public:
17710458Sandreas.hansson@arm.com        ReturnTester() { print_created(this); }
17810458Sandreas.hansson@arm.com        ~ReturnTester() { print_destroyed(this); }
17910458Sandreas.hansson@arm.com        static Eigen::MatrixXd create() { return Eigen::MatrixXd::Ones(10, 10); }
18010458Sandreas.hansson@arm.com        static const Eigen::MatrixXd createConst() { return Eigen::MatrixXd::Ones(10, 10); }
18110458Sandreas.hansson@arm.com        Eigen::MatrixXd &get() { return mat; }
18210458Sandreas.hansson@arm.com        Eigen::MatrixXd *getPtr() { return &mat; }
18310458Sandreas.hansson@arm.com        const Eigen::MatrixXd &view() { return mat; }
18410458Sandreas.hansson@arm.com        const Eigen::MatrixXd *viewPtr() { return &mat; }
18510458Sandreas.hansson@arm.com        Eigen::Ref<Eigen::MatrixXd> ref() { return mat; }
18610458Sandreas.hansson@arm.com        Eigen::Ref<const Eigen::MatrixXd> refConst() { return mat; }
18710458Sandreas.hansson@arm.com        Eigen::Block<Eigen::MatrixXd> block(int r, int c, int nrow, int ncol) { return mat.block(r, c, nrow, ncol); }
18810458Sandreas.hansson@arm.com        Eigen::Block<const Eigen::MatrixXd> blockConst(int r, int c, int nrow, int ncol) const { return mat.block(r, c, nrow, ncol); }
18910458Sandreas.hansson@arm.com        py::EigenDMap<Eigen::Matrix2d> corners() { return py::EigenDMap<Eigen::Matrix2d>(mat.data(),
19010458Sandreas.hansson@arm.com                    py::EigenDStride(mat.outerStride() * (mat.outerSize()-1), mat.innerStride() * (mat.innerSize()-1))); }
19110458Sandreas.hansson@arm.com        py::EigenDMap<const Eigen::Matrix2d> cornersConst() const { return py::EigenDMap<const Eigen::Matrix2d>(mat.data(),
19210458Sandreas.hansson@arm.com                    py::EigenDStride(mat.outerStride() * (mat.outerSize()-1), mat.innerStride() * (mat.innerSize()-1))); }
19310458Sandreas.hansson@arm.com    };
19410458Sandreas.hansson@arm.com    using rvp = py::return_value_policy;
19510458Sandreas.hansson@arm.com    py::class_<ReturnTester>(m, "ReturnTester")
19610458Sandreas.hansson@arm.com        .def(py::init<>())
19710458Sandreas.hansson@arm.com        .def_static("create", &ReturnTester::create)
19810458Sandreas.hansson@arm.com        .def_static("create_const", &ReturnTester::createConst)
19910458Sandreas.hansson@arm.com        .def("get", &ReturnTester::get, rvp::reference_internal)
20010458Sandreas.hansson@arm.com        .def("get_ptr", &ReturnTester::getPtr, rvp::reference_internal)
20110458Sandreas.hansson@arm.com        .def("view", &ReturnTester::view, rvp::reference_internal)
20210458Sandreas.hansson@arm.com        .def("view_ptr", &ReturnTester::view, rvp::reference_internal)
20310458Sandreas.hansson@arm.com        .def("copy_get", &ReturnTester::get)   // Default rvp: copy
20410458Sandreas.hansson@arm.com        .def("copy_view", &ReturnTester::view) //         "
20510458Sandreas.hansson@arm.com        .def("ref", &ReturnTester::ref) // Default for Ref is to reference
20610458Sandreas.hansson@arm.com        .def("ref_const", &ReturnTester::refConst) // Likewise, but const
20710458Sandreas.hansson@arm.com        .def("ref_safe", &ReturnTester::ref, rvp::reference_internal)
20810458Sandreas.hansson@arm.com        .def("ref_const_safe", &ReturnTester::refConst, rvp::reference_internal)
20910458Sandreas.hansson@arm.com        .def("copy_ref", &ReturnTester::ref, rvp::copy)
21010458Sandreas.hansson@arm.com        .def("copy_ref_const", &ReturnTester::refConst, rvp::copy)
21110458Sandreas.hansson@arm.com        .def("block", &ReturnTester::block)
21210458Sandreas.hansson@arm.com        .def("block_safe", &ReturnTester::block, rvp::reference_internal)
21310458Sandreas.hansson@arm.com        .def("block_const", &ReturnTester::blockConst, rvp::reference_internal)
21410458Sandreas.hansson@arm.com        .def("copy_block", &ReturnTester::block, rvp::copy)
21510458Sandreas.hansson@arm.com        .def("corners", &ReturnTester::corners, rvp::reference_internal)
21610458Sandreas.hansson@arm.com        .def("corners_const", &ReturnTester::cornersConst, rvp::reference_internal)
21710458Sandreas.hansson@arm.com        ;
21810458Sandreas.hansson@arm.com
21910458Sandreas.hansson@arm.com    // test_special_matrix_objects
22010458Sandreas.hansson@arm.com    // Returns a DiagonalMatrix with diagonal (1,2,3,...)
22110458Sandreas.hansson@arm.com    m.def("incr_diag", [](int k) {
22210458Sandreas.hansson@arm.com        Eigen::DiagonalMatrix<int, Eigen::Dynamic> m(k);
22310458Sandreas.hansson@arm.com        for (int i = 0; i < k; i++) m.diagonal()[i] = i+1;
22410458Sandreas.hansson@arm.com        return m;
22510458Sandreas.hansson@arm.com    });
22610458Sandreas.hansson@arm.com
22710458Sandreas.hansson@arm.com    // Returns a SelfAdjointView referencing the lower triangle of m
22810458Sandreas.hansson@arm.com    m.def("symmetric_lower", [](const Eigen::MatrixXi &m) {
22910458Sandreas.hansson@arm.com            return m.selfadjointView<Eigen::Lower>();
23010458Sandreas.hansson@arm.com    });
23110458Sandreas.hansson@arm.com    // Returns a SelfAdjointView referencing the lower triangle of m
23210458Sandreas.hansson@arm.com    m.def("symmetric_upper", [](const Eigen::MatrixXi &m) {
23310458Sandreas.hansson@arm.com            return m.selfadjointView<Eigen::Upper>();
23410458Sandreas.hansson@arm.com    });
23510458Sandreas.hansson@arm.com
23610458Sandreas.hansson@arm.com    // Test matrix for various functions below.
23710458Sandreas.hansson@arm.com    Eigen::MatrixXf mat(5, 6);
23810458Sandreas.hansson@arm.com    mat << 0,  3,  0,  0,  0, 11,
23910458Sandreas.hansson@arm.com           22, 0,  0,  0, 17, 11,
24010458Sandreas.hansson@arm.com           7,  5,  0,  1,  0, 11,
24110458Sandreas.hansson@arm.com           0,  0,  0,  0,  0, 11,
24210458Sandreas.hansson@arm.com           0,  0, 14,  0,  8, 11;
24310458Sandreas.hansson@arm.com
24410458Sandreas.hansson@arm.com    // test_fixed, and various other tests
24510458Sandreas.hansson@arm.com    m.def("fixed_r", [mat]() -> FixedMatrixR { return FixedMatrixR(mat); });
24610458Sandreas.hansson@arm.com    m.def("fixed_r_const", [mat]() -> const FixedMatrixR { return FixedMatrixR(mat); });
24710458Sandreas.hansson@arm.com    m.def("fixed_c", [mat]() -> FixedMatrixC { return FixedMatrixC(mat); });
24810458Sandreas.hansson@arm.com    m.def("fixed_copy_r", [](const FixedMatrixR &m) -> FixedMatrixR { return m; });
24910458Sandreas.hansson@arm.com    m.def("fixed_copy_c", [](const FixedMatrixC &m) -> FixedMatrixC { return m; });
25010458Sandreas.hansson@arm.com    // test_mutator_descriptors
25110458Sandreas.hansson@arm.com    m.def("fixed_mutator_r", [](Eigen::Ref<FixedMatrixR>) {});
25210458Sandreas.hansson@arm.com    m.def("fixed_mutator_c", [](Eigen::Ref<FixedMatrixC>) {});
25310458Sandreas.hansson@arm.com    m.def("fixed_mutator_a", [](py::EigenDRef<FixedMatrixC>) {});
25410458Sandreas.hansson@arm.com    // test_dense
25510458Sandreas.hansson@arm.com    m.def("dense_r", [mat]() -> DenseMatrixR { return DenseMatrixR(mat); });
25610458Sandreas.hansson@arm.com    m.def("dense_c", [mat]() -> DenseMatrixC { return DenseMatrixC(mat); });
25710458Sandreas.hansson@arm.com    m.def("dense_copy_r", [](const DenseMatrixR &m) -> DenseMatrixR { return m; });
25810458Sandreas.hansson@arm.com    m.def("dense_copy_c", [](const DenseMatrixC &m) -> DenseMatrixC { return m; });
25910458Sandreas.hansson@arm.com    // test_sparse, test_sparse_signature
26010458Sandreas.hansson@arm.com    m.def("sparse_r", [mat]() -> SparseMatrixR { return Eigen::SparseView<Eigen::MatrixXf>(mat); });
26110458Sandreas.hansson@arm.com    m.def("sparse_c", [mat]() -> SparseMatrixC { return Eigen::SparseView<Eigen::MatrixXf>(mat); });
26210458Sandreas.hansson@arm.com    m.def("sparse_copy_r", [](const SparseMatrixR &m) -> SparseMatrixR { return m; });
26310458Sandreas.hansson@arm.com    m.def("sparse_copy_c", [](const SparseMatrixC &m) -> SparseMatrixC { return m; });
26410458Sandreas.hansson@arm.com    // test_partially_fixed
26510458Sandreas.hansson@arm.com    m.def("partial_copy_four_rm_r", [](const FourRowMatrixR &m) -> FourRowMatrixR { return m; });
26610458Sandreas.hansson@arm.com    m.def("partial_copy_four_rm_c", [](const FourColMatrixR &m) -> FourColMatrixR { return m; });
26710458Sandreas.hansson@arm.com    m.def("partial_copy_four_cm_r", [](const FourRowMatrixC &m) -> FourRowMatrixC { return m; });
26810458Sandreas.hansson@arm.com    m.def("partial_copy_four_cm_c", [](const FourColMatrixC &m) -> FourColMatrixC { return m; });
26910458Sandreas.hansson@arm.com
27010458Sandreas.hansson@arm.com    // test_cpp_casting
27110458Sandreas.hansson@arm.com    // Test that we can cast a numpy object to a Eigen::MatrixXd explicitly
27210458Sandreas.hansson@arm.com    m.def("cpp_copy", [](py::handle m) { return m.cast<Eigen::MatrixXd>()(1, 0); });
27310458Sandreas.hansson@arm.com    m.def("cpp_ref_c", [](py::handle m) { return m.cast<Eigen::Ref<Eigen::MatrixXd>>()(1, 0); });
27410458Sandreas.hansson@arm.com    m.def("cpp_ref_r", [](py::handle m) { return m.cast<Eigen::Ref<MatrixXdR>>()(1, 0); });
27510458Sandreas.hansson@arm.com    m.def("cpp_ref_any", [](py::handle m) { return m.cast<py::EigenDRef<Eigen::MatrixXd>>()(1, 0); });
27610458Sandreas.hansson@arm.com
27710458Sandreas.hansson@arm.com
27810458Sandreas.hansson@arm.com    // test_nocopy_wrapper
27910458Sandreas.hansson@arm.com    // Test that we can prevent copying into an argument that would normally copy: First a version
28010458Sandreas.hansson@arm.com    // that would allow copying (if types or strides don't match) for comparison:
28110458Sandreas.hansson@arm.com    m.def("get_elem", &get_elem);
28210458Sandreas.hansson@arm.com    // Now this alternative that calls the tells pybind to fail rather than copy:
28310458Sandreas.hansson@arm.com    m.def("get_elem_nocopy", [](Eigen::Ref<const Eigen::MatrixXd> m) -> double { return get_elem(m); },
28410458Sandreas.hansson@arm.com            py::arg().noconvert());
28510458Sandreas.hansson@arm.com    // Also test a row-major-only no-copy const ref:
28610912Sandreas.sandberg@arm.com    m.def("get_elem_rm_nocopy", [](Eigen::Ref<const Eigen::Matrix<long, -1, -1, Eigen::RowMajor>> &m) -> long { return m(2, 1); },
28710458Sandreas.hansson@arm.com            py::arg().noconvert());
28810458Sandreas.hansson@arm.com
28910458Sandreas.hansson@arm.com    // test_issue738
29010458Sandreas.hansson@arm.com    // Issue #738: 1xN or Nx1 2D matrices were neither accepted nor properly copied with an
29110458Sandreas.hansson@arm.com    // incompatible stride value on the length-1 dimension--but that should be allowed (without
29210458Sandreas.hansson@arm.com    // requiring a copy!) because the stride value can be safely ignored on a size-1 dimension.
29310458Sandreas.hansson@arm.com    m.def("iss738_f1", &adjust_matrix<const Eigen::Ref<const Eigen::MatrixXd> &>, py::arg().noconvert());
29410458Sandreas.hansson@arm.com    m.def("iss738_f2", &adjust_matrix<const Eigen::Ref<const Eigen::Matrix<double, -1, -1, Eigen::RowMajor>> &>, py::arg().noconvert());
29510905Sandreas.sandberg@arm.com
29610458Sandreas.hansson@arm.com    // test_issue1105
29710458Sandreas.hansson@arm.com    // Issue #1105: when converting from a numpy two-dimensional (Nx1) or (1xN) value into a dense
29810458Sandreas.hansson@arm.com    // eigen Vector or RowVector, the argument would fail to load because the numpy copy would fail:
29910458Sandreas.hansson@arm.com    // numpy won't broadcast a Nx1 into a 1-dimensional vector.
30010458Sandreas.hansson@arm.com    m.def("iss1105_col", [](Eigen::VectorXd) { return true; });
30110458Sandreas.hansson@arm.com    m.def("iss1105_row", [](Eigen::RowVectorXd) { return true; });
30210458Sandreas.hansson@arm.com
30310458Sandreas.hansson@arm.com    // test_named_arguments
30410458Sandreas.hansson@arm.com    // Make sure named arguments are working properly:
30510458Sandreas.hansson@arm.com    m.def("matrix_multiply", [](const py::EigenDRef<const Eigen::MatrixXd> A, const py::EigenDRef<const Eigen::MatrixXd> B)
30610458Sandreas.hansson@arm.com            -> Eigen::MatrixXd {
30710458Sandreas.hansson@arm.com        if (A.cols() != B.rows()) throw std::domain_error("Nonconformable matrices!");
30810458Sandreas.hansson@arm.com        return A * B;
30910458Sandreas.hansson@arm.com    }, py::arg("A"), py::arg("B"));
31010458Sandreas.hansson@arm.com
31110458Sandreas.hansson@arm.com    // test_custom_operator_new
31210458Sandreas.hansson@arm.com    py::class_<CustomOperatorNew>(m, "CustomOperatorNew")
31310458Sandreas.hansson@arm.com        .def(py::init<>())
31410458Sandreas.hansson@arm.com        .def_readonly("a", &CustomOperatorNew::a)
315        .def_readonly("b", &CustomOperatorNew::b);
316
317    // test_eigen_ref_life_support
318    // In case of a failure (the caster's temp array does not live long enough), creating
319    // a new array (np.ones(10)) increases the chances that the temp array will be garbage
320    // collected and/or that its memory will be overridden with different values.
321    m.def("get_elem_direct", [](Eigen::Ref<const Eigen::VectorXd> v) {
322        py::module::import("numpy").attr("ones")(10);
323        return v(5);
324    });
325    m.def("get_elem_indirect", [](std::vector<Eigen::Ref<const Eigen::VectorXd>> v) {
326        py::module::import("numpy").attr("ones")(10);
327        return v[0](5);
328    });
329}
330