pybind11/tests/test_eigen.cpp

93     m.def("double_col", [](const Eigen::VectorXf &x) -> Eigen::VectorXf { return 2.0f * x; });
94     m.def("double_row", [](const Eigen::RowVectorXf &x) -> Eigen::RowVectorXf { return 2.0f * x; });
95     m.def("double_complex", [](const Eigen::VectorXcf &x) -> Eigen::VectorXcf { return 2.0f * x; });
96     m.def("double_threec", [](py::EigenDRef<Eigen::Vector3f> x) { x *= 2; });
97     m.def("double_threer", [](py::EigenDRef<Eigen::RowVector3f> x) { x *= 2; });
98     m.def("double_mat_cm", [](Eigen::MatrixXf x) -> Eigen::MatrixXf { return 2.0f * x; });
99     m.def("double_mat_rm", [](DenseMatrixR x) -> DenseMatrixR { return 2.0f * x; });
103     m.def("cholesky1", [](Eigen::Ref<MatrixXdR> x) -> Eigen::MatrixXd { return x.llt().matrixL(); });
104     m.def("cholesky2", [](const Eigen::Ref<const MatrixXdR> &x) -> Eigen::MatrixXd { return x.llt().matrixL(); });
105     m.def("cholesky3", [](const Eigen::Ref<MatrixXdR> &x) -> Eigen::MatrixXd { return x.llt().matrixL(); });
106     m.def("cholesky4", [](Eigen::Ref<const MatrixXdR> x) -> Eigen::MatrixXd { return x.llt().matrixL(); });
117     m.def("add_rm", add_rm); // Only takes row-contiguous
118     m.def("add_cm", add_cm); // Only takes column-contiguous
120     m.def("add1", add_rm);
121     m.def("add1", add_cm);
122     m.def("add2", add_cm);
123     m.def("add2", add_rm);
125     m.def("add_any", [](py::EigenDRef<Eigen::MatrixXd> x, int r, int c, double v) { x(r,c) += v; });
128     m.def("get_cm_ref", []() { return Eigen::Ref<Eigen::MatrixXd>(get_cm()); });
129     m.def("get_rm_ref", []() { return Eigen::Ref<MatrixXdR>(get_rm()); });
131     m.def("get_cm_const_ref", []() { return Eigen::Ref<const Eigen::MatrixXd>(get_cm()); });
132     m.def("get_rm_const_ref", []() { return Eigen::Ref<const MatrixXdR>(get_rm()); });
134     m.def("reset_refs", reset_refs); // Restores get_{cm,rm}_ref to original values
137     m.def("incr_matrix", [](Eigen::Ref<Eigen::MatrixXd> m, double v) {
143     m.def("incr_matrix_any", [](py::EigenDRef<Eigen::MatrixXd> m, double v) {
149     m.def("even_rows", [](py::EigenDRef<Eigen::MatrixXd> m) {
156     m.def("even_cols", [](py::EigenDRef<Eigen::MatrixXd> m) {
163     m.def("diagonal", [](const Eigen::Ref<const Eigen::MatrixXd> &x) { return x.diagonal(); });
164     m.def("diagonal_1", [](const Eigen::Ref<const Eigen::MatrixXd> &x) { return x.diagonal<1>(); });
165     m.def("diagonal_n", [](const Eigen::Ref<const Eigen::MatrixXd> &x, int index) { return x.diagonal(index); });
168     m.def("block", [](const Eigen::Ref<const Eigen::MatrixXd> &x, int start_row, int start_col, int block_rows, int block_cols) {
196         .def(py::init<>())
199         .def("get", &ReturnTester::get, rvp::reference_internal)
200         .def("get_ptr", &ReturnTester::getPtr, rvp::reference_internal)
201         .def("view", &ReturnTester::view, rvp::reference_internal)
202         .def("view_ptr", &ReturnTester::view, rvp::reference_internal)
203         .def("copy_get", &ReturnTester::get)   // Default rvp: copy
204         .def("copy_view", &ReturnTester::view) //         "
205         .def("ref", &ReturnTester::ref) // Default for Ref is to reference
206         .def("ref_const", &ReturnTester::refConst) // Likewise, but const
207         .def("ref_safe", &ReturnTester::ref, rvp::reference_internal)
208         .def("ref_const_safe", &ReturnTester::refConst, rvp::reference_internal)
209         .def("copy_ref", &ReturnTester::ref, rvp::copy)
210         .def("copy_ref_const", &ReturnTester::refConst, rvp::copy)
211         .def("block", &ReturnTester::block)
212         .def("block_safe", &ReturnTester::block, rvp::reference_internal)
213         .def("block_const", &ReturnTester::blockConst, rvp::reference_internal)
214         .def("copy_block", &ReturnTester::block, rvp::copy)
215         .def("corners", &ReturnTester::corners, rvp::reference_internal)
216         .def("corners_const", &ReturnTester::cornersConst, rvp::reference_internal)
221     m.def("incr_diag", [](int k) {
228     m.def("symmetric_lower", [](const Eigen::MatrixXi &m) {
232     m.def("symmetric_upper", [](const Eigen::MatrixXi &m) {
245     m.def("fixed_r", [mat]() -> FixedMatrixR { return FixedMatrixR(mat); });
246     m.def("fixed_r_const", [mat]() -> const FixedMatrixR { return FixedMatrixR(mat); });
247     m.def("fixed_c", [mat]() -> FixedMatrixC { return FixedMatrixC(mat); });
248     m.def("fixed_copy_r", [](const FixedMatrixR &m) -> FixedMatrixR { return m; });
249     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>) {});
255     m.def("dense_r", [mat]() -> DenseMatrixR { return DenseMatrixR(mat); });
256     m.def("dense_c", [mat]() -> DenseMatrixC { return DenseMatrixC(mat); });
257     m.def("dense_copy_r", [](const DenseMatrixR &m) -> DenseMatrixR { return m; });
258     m.def("dense_copy_c", [](const DenseMatrixC &m) -> DenseMatrixC { return m; });
260     m.def("sparse_r", [mat]() -> SparseMatrixR { return Eigen::SparseView<Eigen::MatrixXf>(mat); });
261     m.def("sparse_c", [mat]() -> SparseMatrixC { return Eigen::SparseView<Eigen::MatrixXf>(mat); });
262     m.def("sparse_copy_r", [](const SparseMatrixR &m) -> SparseMatrixR { return m; });
263     m.def("sparse_copy_c", [](const SparseMatrixC &m) -> SparseMatrixC { return m; });
265     m.def("partial_copy_four_rm_r", [](const FourRowMatrixR &m) -> FourRowMatrixR { return m; });
266     m.def("partial_copy_four_rm_c", [](const FourColMatrixR &m) -> FourColMatrixR { return m; });
267     m.def("partial_copy_four_cm_r", [](const FourRowMatrixC &m) -> FourRowMatrixC { return m; });
268     m.def("partial_copy_four_cm_c", [](const FourColMatrixC &m) -> FourColMatrixC { return m; });
272     m.def("cpp_copy", [](py::handle m) { return m.cast<Eigen::MatrixXd>()(1, 0); });
273     m.def("cpp_ref_c", [](py::handle m) { return m.cast<Eigen::Ref<Eigen::MatrixXd>>()(1, 0); });
274     m.def("cpp_ref_r", [](py::handle m) { return m.cast<Eigen::Ref<MatrixXdR>>()(1, 0); });
275     m.def("cpp_ref_any", [](py::handle m) { return m.cast<py::EigenDRef<Eigen::MatrixXd>>()(1, 0); });
281     m.def("get_elem", &get_elem);
283     m.def("get_elem_nocopy", [](Eigen::Ref<const Eigen::MatrixXd> m) -> double { return get_elem(m); },
286     m.def("get_elem_rm_nocopy", [](Eigen::Ref<const Eigen::Matrix<long, -1, -1, Eigen::RowMajor>> &m) -> long { return m(2, 1); },
293     m.def("iss738_f1", &adjust_matrix<const Eigen::Ref<const Eigen::MatrixXd> &>, py::arg().noconvert());
294     m.def("iss738_f2", &adjust_matrix<const Eigen::Ref<const Eigen::Matrix<double, -1, -1, Eigen::RowMajor>> &>, py::arg().noconvert());
300     m.def("iss1105_col", [](Eigen::VectorXd) { return true; });
301     m.def("iss1105_row", [](Eigen::RowVectorXd) { return true; });
305     m.def("matrix_multiply", [](const py::EigenDRef<const Eigen::MatrixXd> A, const py::EigenDRef<const Eigen::MatrixXd> B)
313         .def(py::init<>())
321     m.def("get_elem_direct", [](Eigen::Ref<const Eigen::VectorXd> v) {
325     m.def("get_elem_indirect", [](std::vector<Eigen::Ref<const Eigen::VectorXd>> v) {