Wenzel Jakob | 9e0a056 | 2016-05-05 20:33:54 +0200 | [diff] [blame] | 1 | /* |
Dean Moldovan | a0c1ccf | 2016-08-12 13:50:00 +0200 | [diff] [blame] | 2 | tests/eigen.cpp -- automatic conversion of Eigen types |
Wenzel Jakob | 9e0a056 | 2016-05-05 20:33:54 +0200 | [diff] [blame] | 3 | |
| 4 | Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch> |
| 5 | |
| 6 | All rights reserved. Use of this source code is governed by a |
| 7 | BSD-style license that can be found in the LICENSE file. |
| 8 | */ |
| 9 | |
Dean Moldovan | a0c1ccf | 2016-08-12 13:50:00 +0200 | [diff] [blame] | 10 | #include "pybind11_tests.h" |
Jason Rhinelander | 17d0283 | 2017-01-16 20:35:14 -0500 | [diff] [blame] | 11 | #include "constructor_stats.h" |
Wenzel Jakob | 9e0a056 | 2016-05-05 20:33:54 +0200 | [diff] [blame] | 12 | #include <pybind11/eigen.h> |
Jason Rhinelander | 5fd5074 | 2016-08-03 16:50:22 -0400 | [diff] [blame] | 13 | #include <Eigen/Cholesky> |
Wenzel Jakob | 9e0a056 | 2016-05-05 20:33:54 +0200 | [diff] [blame] | 14 | |
Jason Rhinelander | 17d0283 | 2017-01-16 20:35:14 -0500 | [diff] [blame] | 15 | using MatrixXdR = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>; |
Ben North | b063e64 | 2016-07-05 20:01:11 +0100 | [diff] [blame] | 16 | |
Ben North | b063e64 | 2016-07-05 20:01:11 +0100 | [diff] [blame] | 17 | |
Ben North | 3e0e779 | 2016-07-05 21:00:05 +0100 | [diff] [blame] | 18 | |
Jason Rhinelander | 17d0283 | 2017-01-16 20:35:14 -0500 | [diff] [blame] | 19 | // Sets/resets a testing reference matrix to have values of 10*r + c, where r and c are the |
| 20 | // (1-based) row/column number. |
| 21 | template <typename M> void reset_ref(M &x) { |
| 22 | for (int i = 0; i < x.rows(); i++) for (int j = 0; j < x.cols(); j++) |
| 23 | x(i, j) = 11 + 10*i + j; |
| 24 | } |
Jason Rhinelander | 5fd5074 | 2016-08-03 16:50:22 -0400 | [diff] [blame] | 25 | |
Jason Rhinelander | 17d0283 | 2017-01-16 20:35:14 -0500 | [diff] [blame] | 26 | // Returns a static, column-major matrix |
| 27 | Eigen::MatrixXd &get_cm() { |
| 28 | static Eigen::MatrixXd *x; |
| 29 | if (!x) { |
| 30 | x = new Eigen::MatrixXd(3, 3); |
| 31 | reset_ref(*x); |
| 32 | } |
| 33 | return *x; |
| 34 | } |
| 35 | // Likewise, but row-major |
| 36 | MatrixXdR &get_rm() { |
| 37 | static MatrixXdR *x; |
| 38 | if (!x) { |
| 39 | x = new MatrixXdR(3, 3); |
| 40 | reset_ref(*x); |
| 41 | } |
| 42 | return *x; |
| 43 | } |
| 44 | // Resets the values of the static matrices returned by get_cm()/get_rm() |
| 45 | void reset_refs() { |
| 46 | reset_ref(get_cm()); |
| 47 | reset_ref(get_rm()); |
| 48 | } |
| 49 | |
| 50 | // Returns element 2,1 from a matrix (used to test copy/nocopy) |
| 51 | double get_elem(Eigen::Ref<const Eigen::MatrixXd> m) { return m(2, 1); }; |
Ben North | 3e0e779 | 2016-07-05 21:00:05 +0100 | [diff] [blame] | 52 | |
Jason Rhinelander | efa8726 | 2017-03-17 14:51:52 -0300 | [diff] [blame] | 53 | |
| 54 | // Returns a matrix with 10*r + 100*c added to each matrix element (to help test that the matrix |
| 55 | // reference is referencing rows/columns correctly). |
| 56 | template <typename MatrixArgType> Eigen::MatrixXd adjust_matrix(MatrixArgType m) { |
| 57 | Eigen::MatrixXd ret(m); |
| 58 | for (int c = 0; c < m.cols(); c++) for (int r = 0; r < m.rows(); r++) |
| 59 | ret(r, c) += 10*r + 100*c; |
| 60 | return ret; |
| 61 | } |
| 62 | |
Dean Moldovan | 0d765f4 | 2017-03-21 01:15:20 +0100 | [diff] [blame] | 63 | struct CustomOperatorNew { |
| 64 | CustomOperatorNew() = default; |
| 65 | |
| 66 | Eigen::Matrix4d a = Eigen::Matrix4d::Zero(); |
| 67 | Eigen::Matrix4d b = Eigen::Matrix4d::Identity(); |
| 68 | |
| 69 | EIGEN_MAKE_ALIGNED_OPERATOR_NEW; |
| 70 | }; |
| 71 | |
Jason Rhinelander | 52f4be8 | 2016-09-03 14:54:22 -0400 | [diff] [blame] | 72 | test_initializer eigen([](py::module &m) { |
Wenzel Jakob | 9e0a056 | 2016-05-05 20:33:54 +0200 | [diff] [blame] | 73 | typedef Eigen::Matrix<float, 5, 6, Eigen::RowMajor> FixedMatrixR; |
| 74 | typedef Eigen::Matrix<float, 5, 6> FixedMatrixC; |
| 75 | typedef Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> DenseMatrixR; |
| 76 | typedef Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> DenseMatrixC; |
Jason Rhinelander | d9d224f | 2017-01-12 19:50:33 -0500 | [diff] [blame] | 77 | typedef Eigen::Matrix<float, 4, Eigen::Dynamic> FourRowMatrixC; |
| 78 | typedef Eigen::Matrix<float, Eigen::Dynamic, 4> FourColMatrixC; |
| 79 | typedef Eigen::Matrix<float, 4, Eigen::Dynamic> FourRowMatrixR; |
| 80 | typedef Eigen::Matrix<float, Eigen::Dynamic, 4> FourColMatrixR; |
Wenzel Jakob | 9e0a056 | 2016-05-05 20:33:54 +0200 | [diff] [blame] | 81 | typedef Eigen::SparseMatrix<float, Eigen::RowMajor> SparseMatrixR; |
| 82 | typedef Eigen::SparseMatrix<float> SparseMatrixC; |
| 83 | |
Jason Rhinelander | 3f1ff3f | 2016-12-12 17:42:52 -0500 | [diff] [blame] | 84 | m.attr("have_eigen") = true; |
Jason Rhinelander | 52f4be8 | 2016-09-03 14:54:22 -0400 | [diff] [blame] | 85 | |
Jason Rhinelander | 17d0283 | 2017-01-16 20:35:14 -0500 | [diff] [blame] | 86 | m.def("double_col", [](const Eigen::VectorXf &x) -> Eigen::VectorXf { return 2.0f * x; }); |
| 87 | m.def("double_row", [](const Eigen::RowVectorXf &x) -> Eigen::RowVectorXf { return 2.0f * x; }); |
Dean Moldovan | 5143989 | 2017-02-28 18:07:51 +0100 | [diff] [blame] | 88 | m.def("double_complex", [](const Eigen::VectorXcf &x) -> Eigen::VectorXcf { return 2.0f * x; }); |
Jason Rhinelander | 17d0283 | 2017-01-16 20:35:14 -0500 | [diff] [blame] | 89 | m.def("double_threec", [](py::EigenDRef<Eigen::Vector3f> x) { x *= 2; }); |
| 90 | m.def("double_threer", [](py::EigenDRef<Eigen::RowVector3f> x) { x *= 2; }); |
| 91 | m.def("double_mat_cm", [](Eigen::MatrixXf x) -> Eigen::MatrixXf { return 2.0f * x; }); |
| 92 | m.def("double_mat_rm", [](DenseMatrixR x) -> DenseMatrixR { return 2.0f * x; }); |
Wenzel Jakob | 9e0a056 | 2016-05-05 20:33:54 +0200 | [diff] [blame] | 93 | |
Jason Rhinelander | 17d0283 | 2017-01-16 20:35:14 -0500 | [diff] [blame] | 94 | // Different ways of passing via Eigen::Ref; the first and second are the Eigen-recommended |
| 95 | m.def("cholesky1", [](Eigen::Ref<MatrixXdR> x) -> Eigen::MatrixXd { return x.llt().matrixL(); }); |
| 96 | m.def("cholesky2", [](const Eigen::Ref<const MatrixXdR> &x) -> Eigen::MatrixXd { return x.llt().matrixL(); }); |
| 97 | m.def("cholesky3", [](const Eigen::Ref<MatrixXdR> &x) -> Eigen::MatrixXd { return x.llt().matrixL(); }); |
| 98 | m.def("cholesky4", [](Eigen::Ref<const MatrixXdR> x) -> Eigen::MatrixXd { return x.llt().matrixL(); }); |
| 99 | |
| 100 | // Mutators: these add some value to the given element using Eigen, but Eigen should be mapping into |
| 101 | // the numpy array data and so the result should show up there. There are three versions: one that |
| 102 | // works on a contiguous-row matrix (numpy's default), one for a contiguous-column matrix, and one |
| 103 | // for any matrix. |
| 104 | auto add_rm = [](Eigen::Ref<MatrixXdR> x, int r, int c, double v) { x(r,c) += v; }; |
| 105 | auto add_cm = [](Eigen::Ref<Eigen::MatrixXd> x, int r, int c, double v) { x(r,c) += v; }; |
| 106 | |
| 107 | // Mutators (Eigen maps into numpy variables): |
| 108 | m.def("add_rm", add_rm); // Only takes row-contiguous |
| 109 | m.def("add_cm", add_cm); // Only takes column-contiguous |
| 110 | // Overloaded versions that will accept either row or column contiguous: |
| 111 | m.def("add1", add_rm); |
| 112 | m.def("add1", add_cm); |
| 113 | m.def("add2", add_cm); |
| 114 | m.def("add2", add_rm); |
| 115 | // This one accepts a matrix of any stride: |
| 116 | m.def("add_any", [](py::EigenDRef<Eigen::MatrixXd> x, int r, int c, double v) { x(r,c) += v; }); |
| 117 | |
| 118 | // Return mutable references (numpy maps into eigen varibles) |
| 119 | m.def("get_cm_ref", []() { return Eigen::Ref<Eigen::MatrixXd>(get_cm()); }); |
| 120 | m.def("get_rm_ref", []() { return Eigen::Ref<MatrixXdR>(get_rm()); }); |
| 121 | // The same references, but non-mutable (numpy maps into eigen variables, but is !writeable) |
| 122 | m.def("get_cm_const_ref", []() { return Eigen::Ref<const Eigen::MatrixXd>(get_cm()); }); |
| 123 | m.def("get_rm_const_ref", []() { return Eigen::Ref<const MatrixXdR>(get_rm()); }); |
| 124 | // Just the corners (via a Map instead of a Ref): |
| 125 | m.def("get_cm_corners", []() { |
| 126 | auto &x = get_cm(); |
| 127 | return py::EigenDMap<Eigen::Matrix2d>( |
| 128 | x.data(), |
| 129 | py::EigenDStride(x.outerStride() * (x.rows() - 1), x.innerStride() * (x.cols() - 1))); |
| 130 | }); |
| 131 | m.def("get_cm_corners_const", []() { |
| 132 | const auto &x = get_cm(); |
| 133 | return py::EigenDMap<const Eigen::Matrix2d>( |
| 134 | x.data(), |
| 135 | py::EigenDStride(x.outerStride() * (x.rows() - 1), x.innerStride() * (x.cols() - 1))); |
| 136 | }); |
| 137 | |
| 138 | m.def("reset_refs", reset_refs); // Restores get_{cm,rm}_ref to original values |
| 139 | |
| 140 | // Increments and returns ref to (same) matrix |
| 141 | m.def("incr_matrix", [](Eigen::Ref<Eigen::MatrixXd> m, double v) { |
| 142 | m += Eigen::MatrixXd::Constant(m.rows(), m.cols(), v); |
| 143 | return m; |
| 144 | }, py::return_value_policy::reference); |
| 145 | |
| 146 | // Same, but accepts a matrix of any strides |
| 147 | m.def("incr_matrix_any", [](py::EigenDRef<Eigen::MatrixXd> m, double v) { |
| 148 | m += Eigen::MatrixXd::Constant(m.rows(), m.cols(), v); |
| 149 | return m; |
| 150 | }, py::return_value_policy::reference); |
| 151 | |
| 152 | // Returns an eigen slice of even rows |
| 153 | m.def("even_rows", [](py::EigenDRef<Eigen::MatrixXd> m) { |
| 154 | return py::EigenDMap<Eigen::MatrixXd>( |
| 155 | m.data(), (m.rows() + 1) / 2, m.cols(), |
| 156 | py::EigenDStride(m.outerStride(), 2 * m.innerStride())); |
| 157 | }, py::return_value_policy::reference); |
| 158 | |
| 159 | // Returns an eigen slice of even columns |
| 160 | m.def("even_cols", [](py::EigenDRef<Eigen::MatrixXd> m) { |
| 161 | return py::EigenDMap<Eigen::MatrixXd>( |
| 162 | m.data(), m.rows(), (m.cols() + 1) / 2, |
| 163 | py::EigenDStride(2 * m.outerStride(), m.innerStride())); |
| 164 | }, py::return_value_policy::reference); |
Ben North | b063e64 | 2016-07-05 20:01:11 +0100 | [diff] [blame] | 165 | |
Jason Rhinelander | 8657f30 | 2016-08-04 13:21:39 -0400 | [diff] [blame] | 166 | // Returns diagonals: a vector-like object with an inner stride != 1 |
| 167 | m.def("diagonal", [](const Eigen::Ref<const Eigen::MatrixXd> &x) { return x.diagonal(); }); |
| 168 | m.def("diagonal_1", [](const Eigen::Ref<const Eigen::MatrixXd> &x) { return x.diagonal<1>(); }); |
| 169 | m.def("diagonal_n", [](const Eigen::Ref<const Eigen::MatrixXd> &x, int index) { return x.diagonal(index); }); |
| 170 | |
| 171 | // Return a block of a matrix (gives non-standard strides) |
| 172 | m.def("block", [](const Eigen::Ref<const Eigen::MatrixXd> &x, int start_row, int start_col, int block_rows, int block_cols) { |
| 173 | return x.block(start_row, start_col, block_rows, block_cols); |
| 174 | }); |
| 175 | |
Jason Rhinelander | 17d0283 | 2017-01-16 20:35:14 -0500 | [diff] [blame] | 176 | // return value referencing/copying tests: |
| 177 | class ReturnTester { |
| 178 | Eigen::MatrixXd mat = create(); |
| 179 | public: |
| 180 | ReturnTester() { print_created(this); } |
| 181 | ~ReturnTester() { print_destroyed(this); } |
| 182 | static Eigen::MatrixXd create() { return Eigen::MatrixXd::Ones(10, 10); } |
| 183 | static const Eigen::MatrixXd createConst() { return Eigen::MatrixXd::Ones(10, 10); } |
| 184 | Eigen::MatrixXd &get() { return mat; } |
| 185 | Eigen::MatrixXd *getPtr() { return &mat; } |
| 186 | const Eigen::MatrixXd &view() { return mat; } |
| 187 | const Eigen::MatrixXd *viewPtr() { return &mat; } |
| 188 | Eigen::Ref<Eigen::MatrixXd> ref() { return mat; } |
| 189 | Eigen::Ref<const Eigen::MatrixXd> refConst() { return mat; } |
| 190 | Eigen::Block<Eigen::MatrixXd> block(int r, int c, int nrow, int ncol) { return mat.block(r, c, nrow, ncol); } |
| 191 | Eigen::Block<const Eigen::MatrixXd> blockConst(int r, int c, int nrow, int ncol) const { return mat.block(r, c, nrow, ncol); } |
| 192 | py::EigenDMap<Eigen::Matrix2d> corners() { return py::EigenDMap<Eigen::Matrix2d>(mat.data(), |
| 193 | py::EigenDStride(mat.outerStride() * (mat.outerSize()-1), mat.innerStride() * (mat.innerSize()-1))); } |
| 194 | py::EigenDMap<const Eigen::Matrix2d> cornersConst() const { return py::EigenDMap<const Eigen::Matrix2d>(mat.data(), |
| 195 | py::EigenDStride(mat.outerStride() * (mat.outerSize()-1), mat.innerStride() * (mat.innerSize()-1))); } |
| 196 | }; |
| 197 | using rvp = py::return_value_policy; |
| 198 | py::class_<ReturnTester>(m, "ReturnTester") |
| 199 | .def(py::init<>()) |
| 200 | .def_static("create", &ReturnTester::create) |
| 201 | .def_static("create_const", &ReturnTester::createConst) |
| 202 | .def("get", &ReturnTester::get, rvp::reference_internal) |
| 203 | .def("get_ptr", &ReturnTester::getPtr, rvp::reference_internal) |
| 204 | .def("view", &ReturnTester::view, rvp::reference_internal) |
| 205 | .def("view_ptr", &ReturnTester::view, rvp::reference_internal) |
| 206 | .def("copy_get", &ReturnTester::get) // Default rvp: copy |
| 207 | .def("copy_view", &ReturnTester::view) // " |
| 208 | .def("ref", &ReturnTester::ref) // Default for Ref is to reference |
| 209 | .def("ref_const", &ReturnTester::refConst) // Likewise, but const |
| 210 | .def("ref_safe", &ReturnTester::ref, rvp::reference_internal) |
| 211 | .def("ref_const_safe", &ReturnTester::refConst, rvp::reference_internal) |
| 212 | .def("copy_ref", &ReturnTester::ref, rvp::copy) |
| 213 | .def("copy_ref_const", &ReturnTester::refConst, rvp::copy) |
| 214 | .def("block", &ReturnTester::block) |
| 215 | .def("block_safe", &ReturnTester::block, rvp::reference_internal) |
| 216 | .def("block_const", &ReturnTester::blockConst, rvp::reference_internal) |
| 217 | .def("copy_block", &ReturnTester::block, rvp::copy) |
| 218 | .def("corners", &ReturnTester::corners, rvp::reference_internal) |
| 219 | .def("corners_const", &ReturnTester::cornersConst, rvp::reference_internal) |
| 220 | ; |
| 221 | |
Jason Rhinelander | 9ffb3dd | 2016-08-04 15:24:41 -0400 | [diff] [blame] | 222 | // Returns a DiagonalMatrix with diagonal (1,2,3,...) |
| 223 | m.def("incr_diag", [](int k) { |
| 224 | Eigen::DiagonalMatrix<int, Eigen::Dynamic> m(k); |
| 225 | for (int i = 0; i < k; i++) m.diagonal()[i] = i+1; |
| 226 | return m; |
| 227 | }); |
| 228 | |
| 229 | // Returns a SelfAdjointView referencing the lower triangle of m |
| 230 | m.def("symmetric_lower", [](const Eigen::MatrixXi &m) { |
| 231 | return m.selfadjointView<Eigen::Lower>(); |
| 232 | }); |
| 233 | // Returns a SelfAdjointView referencing the lower triangle of m |
| 234 | m.def("symmetric_upper", [](const Eigen::MatrixXi &m) { |
| 235 | return m.selfadjointView<Eigen::Upper>(); |
| 236 | }); |
| 237 | |
Jason Rhinelander | 17d0283 | 2017-01-16 20:35:14 -0500 | [diff] [blame] | 238 | // Test matrix for various functions below. |
| 239 | Eigen::MatrixXf mat(5, 6); |
| 240 | mat << 0, 3, 0, 0, 0, 11, |
| 241 | 22, 0, 0, 0, 17, 11, |
| 242 | 7, 5, 0, 1, 0, 11, |
| 243 | 0, 0, 0, 0, 0, 11, |
| 244 | 0, 0, 14, 0, 8, 11; |
Wenzel Jakob | 9e0a056 | 2016-05-05 20:33:54 +0200 | [diff] [blame] | 245 | |
Jason Rhinelander | 17d0283 | 2017-01-16 20:35:14 -0500 | [diff] [blame] | 246 | m.def("fixed_r", [mat]() -> FixedMatrixR { return FixedMatrixR(mat); }); |
| 247 | m.def("fixed_r_const", [mat]() -> const FixedMatrixR { return FixedMatrixR(mat); }); |
| 248 | m.def("fixed_c", [mat]() -> FixedMatrixC { return FixedMatrixC(mat); }); |
| 249 | m.def("fixed_copy_r", [](const FixedMatrixR &m) -> FixedMatrixR { return m; }); |
| 250 | m.def("fixed_copy_c", [](const FixedMatrixC &m) -> FixedMatrixC { return m; }); |
| 251 | m.def("fixed_mutator_r", [](Eigen::Ref<FixedMatrixR>) {}); |
| 252 | m.def("fixed_mutator_c", [](Eigen::Ref<FixedMatrixC>) {}); |
| 253 | m.def("fixed_mutator_a", [](py::EigenDRef<FixedMatrixC>) {}); |
| 254 | m.def("dense_r", [mat]() -> DenseMatrixR { return DenseMatrixR(mat); }); |
| 255 | m.def("dense_c", [mat]() -> DenseMatrixC { return DenseMatrixC(mat); }); |
| 256 | m.def("dense_copy_r", [](const DenseMatrixR &m) -> DenseMatrixR { return m; }); |
| 257 | m.def("dense_copy_c", [](const DenseMatrixC &m) -> DenseMatrixC { return m; }); |
| 258 | m.def("sparse_r", [mat]() -> SparseMatrixR { return Eigen::SparseView<Eigen::MatrixXf>(mat); }); |
| 259 | m.def("sparse_c", [mat]() -> SparseMatrixC { return Eigen::SparseView<Eigen::MatrixXf>(mat); }); |
| 260 | m.def("sparse_copy_r", [](const SparseMatrixR &m) -> SparseMatrixR { return m; }); |
| 261 | m.def("sparse_copy_c", [](const SparseMatrixC &m) -> SparseMatrixC { return m; }); |
| 262 | m.def("partial_copy_four_rm_r", [](const FourRowMatrixR &m) -> FourRowMatrixR { return m; }); |
| 263 | m.def("partial_copy_four_rm_c", [](const FourColMatrixR &m) -> FourColMatrixR { return m; }); |
| 264 | m.def("partial_copy_four_cm_r", [](const FourRowMatrixC &m) -> FourRowMatrixC { return m; }); |
| 265 | m.def("partial_copy_four_cm_c", [](const FourColMatrixC &m) -> FourColMatrixC { return m; }); |
Wenzel Jakob | 9e0a056 | 2016-05-05 20:33:54 +0200 | [diff] [blame] | 266 | |
Jason Rhinelander | 17d0283 | 2017-01-16 20:35:14 -0500 | [diff] [blame] | 267 | // Test that we can cast a numpy object to a Eigen::MatrixXd explicitly |
| 268 | m.def("cpp_copy", [](py::handle m) { return m.cast<Eigen::MatrixXd>()(1, 0); }); |
| 269 | m.def("cpp_ref_c", [](py::handle m) { return m.cast<Eigen::Ref<Eigen::MatrixXd>>()(1, 0); }); |
| 270 | m.def("cpp_ref_r", [](py::handle m) { return m.cast<Eigen::Ref<MatrixXdR>>()(1, 0); }); |
| 271 | m.def("cpp_ref_any", [](py::handle m) { return m.cast<py::EigenDRef<Eigen::MatrixXd>>()(1, 0); }); |
Wenzel Jakob | 9e0a056 | 2016-05-05 20:33:54 +0200 | [diff] [blame] | 272 | |
Wenzel Jakob | 9e0a056 | 2016-05-05 20:33:54 +0200 | [diff] [blame] | 273 | |
Jason Rhinelander | 17d0283 | 2017-01-16 20:35:14 -0500 | [diff] [blame] | 274 | // Test that we can prevent copying into an argument that would normally copy: First a version |
| 275 | // that would allow copying (if types or strides don't match) for comparison: |
| 276 | m.def("get_elem", &get_elem); |
| 277 | // Now this alternative that calls the tells pybind to fail rather than copy: |
| 278 | m.def("get_elem_nocopy", [](Eigen::Ref<const Eigen::MatrixXd> m) -> double { return get_elem(m); }, |
| 279 | py::arg().noconvert()); |
| 280 | // Also test a row-major-only no-copy const ref: |
| 281 | m.def("get_elem_rm_nocopy", [](Eigen::Ref<const Eigen::Matrix<long, -1, -1, Eigen::RowMajor>> &m) -> long { return m(2, 1); }, |
| 282 | py::arg().noconvert()); |
Jason Rhinelander | efa8726 | 2017-03-17 14:51:52 -0300 | [diff] [blame] | 283 | |
| 284 | // Issue #738: 1xN or Nx1 2D matrices were neither accepted nor properly copied with an |
| 285 | // incompatible stride value on the length-1 dimension--but that should be allowed (without |
| 286 | // requiring a copy!) because the stride value can be safely ignored on a size-1 dimension. |
| 287 | m.def("iss738_f1", &adjust_matrix<const Eigen::Ref<const Eigen::MatrixXd> &>, py::arg().noconvert()); |
| 288 | m.def("iss738_f2", &adjust_matrix<const Eigen::Ref<const Eigen::Matrix<double, -1, -1, Eigen::RowMajor>> &>, py::arg().noconvert()); |
Dean Moldovan | 0d765f4 | 2017-03-21 01:15:20 +0100 | [diff] [blame] | 289 | |
Jason Rhinelander | e9e1774 | 2017-04-08 19:26:42 -0400 | [diff] [blame] | 290 | // Make sure named arguments are working properly: |
| 291 | m.def("matrix_multiply", [](const py::EigenDRef<const Eigen::MatrixXd> A, const py::EigenDRef<const Eigen::MatrixXd> B) |
| 292 | -> Eigen::MatrixXd { |
| 293 | if (A.cols() != B.rows()) throw std::domain_error("Nonconformable matrices!"); |
| 294 | return A * B; |
| 295 | }, py::arg("A"), py::arg("B")); |
| 296 | |
Dean Moldovan | 0d765f4 | 2017-03-21 01:15:20 +0100 | [diff] [blame] | 297 | py::class_<CustomOperatorNew>(m, "CustomOperatorNew") |
| 298 | .def(py::init<>()) |
| 299 | .def_readonly("a", &CustomOperatorNew::a) |
| 300 | .def_readonly("b", &CustomOperatorNew::b); |
Jason Rhinelander | 52f4be8 | 2016-09-03 14:54:22 -0400 | [diff] [blame] | 301 | }); |