HANDLER_DEF_END HANDLER_DEF_BEGIN(pop_rm32_handler) { assert( context->code[0] == 0x8F ); uint32_t displacement = INT32_MAX; unsigned char *dest; dest = (unsigned char*)get_rm( &context->code[1], context->general_purpose_registers, &displacement, table); switch( GETEXTOPCODE(context->code[1]) ) { case 6: { uint32_t *stack = (uint32_t *)get_real_address( context->esp, table, WRITE, false ); *dest = *stack; context->esp+=sizeof(uint32_t); } break; default: log_message( ERROR, "Undefined extended opcode for 0x8F (POP rm32)"); assert(0); break; } }
HANDLER_DEF_END HANDLER_DEF_BEGIN(pop_rm1632_handler) { uint32_t prefixes = get_prefixes( &context->code, &context->eip ); assert( context->code[0] == 0x8F ); uint32_t displacement = INT32_MAX; uint32_t *dest; dest = (uint32_t *)get_rm( &context->code[1], context->general_purpose_registers, &displacement, table); switch( GETEXTOPCODE(context->code[1]) ) { case 6: { if ( prefixes & PREFIX_OPERAND_SIZE_OVERRIDE ) { uint16_t *stack = (uint16_t *)get_real_address( context->esp, table, WRITE, false ); *((uint16_t *)dest) = *stack; context->esp+=sizeof(uint16_t); } else { uint32_t *stack = (uint32_t *)get_real_address( context->esp, table, WRITE, false ); *dest = *stack; context->esp+=sizeof(uint32_t); } context->eip += displacement+1; context->code += displacement+1; } break; default: log_message( ERROR, "Undefined extended opcode for 0x8F (POP rm1632)"); assert(0); break; } }
HANDLER_DEF_END HANDLER_DEF_BEGIN(jmp_rm32_handler){ uint32_t displacement; uint32_t dest_address = *((int32_t *)get_rm( &context->code[1], context->general_purpose_registers, &displacement, table)); dest_address += context->eip + displacement + 1; unsigned char *dest = get_real_address( dest_address, table, EXECUTE, false ); context->eip = dest_address; context->code = dest; }
HANDLER_DEF_END HANDLER_DEF_BEGIN(callpush_rm1632_handler) { uint32_t prefixes = get_prefixes( &context->code, &context->eip ); assert( context->code[0] == 0xFF ); uint32_t value; uint32_t displacement = INT32_MAX; unsigned char *dest; dest = (unsigned char*)get_rm( &context->code[1], context->general_purpose_registers, &displacement, table); value = *((uint32_t *)dest); if ( prefixes & PREFIX_OPERAND_SIZE_OVERRIDE ) value &= 0xFFFF; switch( GETEXTOPCODE(context->code[1]) ) { case 2: { dest = (unsigned char*)get_real_address(value, table, EXECUTE, false); if ( prefixes & PREFIX_OPERAND_SIZE_OVERRIDE ) { context->esp-=sizeof(uint16_t); context->eip += displacement+1; uint16_t *stack = (uint16_t *)get_real_address( context->esp, table, WRITE, false ); *stack = (uint16_t)context->eip; } else { context->esp-=sizeof(uint32_t); context->eip += displacement+1; uint32_t *stack = (uint32_t *)get_real_address( context->esp, table, WRITE, false ); *stack = context->eip; } context->eip = value; context->code = dest; } break; case 6: { if ( prefixes & PREFIX_OPERAND_SIZE_OVERRIDE ) { context->esp-=sizeof(uint16_t); uint16_t *stack = (uint16_t *)get_real_address( context->esp, table, WRITE, false ); *stack = (uint16_t)value; } else { context->esp-=sizeof(uint32_t); uint32_t *stack = (uint32_t *)get_real_address( context->esp, table, WRITE, false ); *stack = value; } context->eip += displacement+1; context->code += displacement+1; } break; default: log_message( ERROR, "Undefined extended opcode for 0xFF (CALL rm1632,PUSH rm1632)"); assert(0); break; } }
HANDLER_DEF_END HANDLER_DEF_BEGIN(jmp_rm1632_handler){ uint32_t prefixes = get_prefixes( &context->code, &context->eip ); uint32_t displacement; uint32_t dest_address; if( prefixes & PREFIX_OPERAND_SIZE_OVERRIDE ) dest_address = (int16_t)*((int16_t *)get_rm( &context->code[1], context->general_purpose_registers, &displacement, table)); else dest_address = *((int32_t *)get_rm( &context->code[1], context->general_purpose_registers, &displacement, table)); dest_address += context->eip + displacement + 1; unsigned char *dest = get_real_address( dest_address, table, EXECUTE, false ); if( dest == NULL ) { log_message( ERROR, "Invalid destination address for JMP rm1632" ); assert(0); } context->eip = dest_address; context->code = dest; }
void test_math_matrix_mult_TCRRMV(void) { T d1[M*N]; for(unsigned i=0; i<(M*N); ++i) { d1[i] = T(std::rand()%10000)/2; } T d2[N*K]; for(unsigned i=0; i<(N*K); ++i) { d2[i] = T(std::rand()%10000)/2; } auto m1 = eagine::math::matrix<T, N, M, RM1, V>::from(d1, M*N); auto m2 = eagine::math::matrix<T, K, N, RM2, V>::from(d2, N*K); eagine::math::matrix<T, K, M, RM1, V> m = multiply(m1, m2); (void)m; for(unsigned i=0; i<M; ++i) for(unsigned j=0; j<K; ++j) { T e = T(0); for(unsigned k=0; k<N; ++k) { e += row(m1, i)[k]*column(m2, j)[k]; } BOOST_CHECK_EQUAL(get_cm(m, j, i), e); BOOST_CHECK_EQUAL(get_rm(m, i, j), e); } }
TEST_SUBMODULE(eigen, m) { using FixedMatrixR = Eigen::Matrix<float, 5, 6, Eigen::RowMajor>; using FixedMatrixC = Eigen::Matrix<float, 5, 6>; using DenseMatrixR = Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>; using DenseMatrixC = Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic>; using FourRowMatrixC = Eigen::Matrix<float, 4, Eigen::Dynamic>; using FourColMatrixC = Eigen::Matrix<float, Eigen::Dynamic, 4>; using FourRowMatrixR = Eigen::Matrix<float, 4, Eigen::Dynamic>; using FourColMatrixR = Eigen::Matrix<float, Eigen::Dynamic, 4>; using SparseMatrixR = Eigen::SparseMatrix<float, Eigen::RowMajor>; using SparseMatrixC = Eigen::SparseMatrix<float>; m.attr("have_eigen") = true; // various tests m.def("double_col", [](const Eigen::VectorXf &x) -> Eigen::VectorXf { return 2.0f * x; }); m.def("double_row", [](const Eigen::RowVectorXf &x) -> Eigen::RowVectorXf { return 2.0f * x; }); m.def("double_complex", [](const Eigen::VectorXcf &x) -> Eigen::VectorXcf { return 2.0f * x; }); m.def("double_threec", [](py::EigenDRef<Eigen::Vector3f> x) { x *= 2; }); m.def("double_threer", [](py::EigenDRef<Eigen::RowVector3f> x) { x *= 2; }); m.def("double_mat_cm", [](Eigen::MatrixXf x) -> Eigen::MatrixXf { return 2.0f * x; }); m.def("double_mat_rm", [](DenseMatrixR x) -> DenseMatrixR { return 2.0f * x; }); // test_eigen_ref_to_python // Different ways of passing via Eigen::Ref; the first and second are the Eigen-recommended m.def("cholesky1", [](Eigen::Ref<MatrixXdR> x) -> Eigen::MatrixXd { return x.llt().matrixL(); }); m.def("cholesky2", [](const Eigen::Ref<const MatrixXdR> &x) -> Eigen::MatrixXd { return x.llt().matrixL(); }); m.def("cholesky3", [](const Eigen::Ref<MatrixXdR> &x) -> Eigen::MatrixXd { return x.llt().matrixL(); }); m.def("cholesky4", [](Eigen::Ref<const MatrixXdR> x) -> Eigen::MatrixXd { return x.llt().matrixL(); }); // test_eigen_ref_mutators // Mutators: these add some value to the given element using Eigen, but Eigen should be mapping into // the numpy array data and so the result should show up there. There are three versions: one that // works on a contiguous-row matrix (numpy's default), one for a contiguous-column matrix, and one // for any matrix. auto add_rm = [](Eigen::Ref<MatrixXdR> x, int r, int c, double v) { x(r,c) += v; }; auto add_cm = [](Eigen::Ref<Eigen::MatrixXd> x, int r, int c, double v) { x(r,c) += v; }; // Mutators (Eigen maps into numpy variables): m.def("add_rm", add_rm); // Only takes row-contiguous m.def("add_cm", add_cm); // Only takes column-contiguous // Overloaded versions that will accept either row or column contiguous: m.def("add1", add_rm); m.def("add1", add_cm); m.def("add2", add_cm); m.def("add2", add_rm); // This one accepts a matrix of any stride: m.def("add_any", [](py::EigenDRef<Eigen::MatrixXd> x, int r, int c, double v) { x(r,c) += v; }); // Return mutable references (numpy maps into eigen varibles) m.def("get_cm_ref", []() { return Eigen::Ref<Eigen::MatrixXd>(get_cm()); }); m.def("get_rm_ref", []() { return Eigen::Ref<MatrixXdR>(get_rm()); }); // The same references, but non-mutable (numpy maps into eigen variables, but is !writeable) m.def("get_cm_const_ref", []() { return Eigen::Ref<const Eigen::MatrixXd>(get_cm()); }); m.def("get_rm_const_ref", []() { return Eigen::Ref<const MatrixXdR>(get_rm()); }); m.def("reset_refs", reset_refs); // Restores get_{cm,rm}_ref to original values // Increments and returns ref to (same) matrix m.def("incr_matrix", [](Eigen::Ref<Eigen::MatrixXd> m, double v) { m += Eigen::MatrixXd::Constant(m.rows(), m.cols(), v); return m; }, py::return_value_policy::reference); // Same, but accepts a matrix of any strides m.def("incr_matrix_any", [](py::EigenDRef<Eigen::MatrixXd> m, double v) { m += Eigen::MatrixXd::Constant(m.rows(), m.cols(), v); return m; }, py::return_value_policy::reference); // Returns an eigen slice of even rows m.def("even_rows", [](py::EigenDRef<Eigen::MatrixXd> m) { return py::EigenDMap<Eigen::MatrixXd>( m.data(), (m.rows() + 1) / 2, m.cols(), py::EigenDStride(m.outerStride(), 2 * m.innerStride())); }, py::return_value_policy::reference); // Returns an eigen slice of even columns m.def("even_cols", [](py::EigenDRef<Eigen::MatrixXd> m) { return py::EigenDMap<Eigen::MatrixXd>( m.data(), m.rows(), (m.cols() + 1) / 2, py::EigenDStride(2 * m.outerStride(), m.innerStride())); }, py::return_value_policy::reference); // Returns diagonals: a vector-like object with an inner stride != 1 m.def("diagonal", [](const Eigen::Ref<const Eigen::MatrixXd> &x) { return x.diagonal(); }); m.def("diagonal_1", [](const Eigen::Ref<const Eigen::MatrixXd> &x) { return x.diagonal<1>(); }); m.def("diagonal_n", [](const Eigen::Ref<const Eigen::MatrixXd> &x, int index) { return x.diagonal(index); }); // Return a block of a matrix (gives non-standard strides) m.def("block", [](const Eigen::Ref<const Eigen::MatrixXd> &x, int start_row, int start_col, int block_rows, int block_cols) { return x.block(start_row, start_col, block_rows, block_cols); }); // test_eigen_return_references, test_eigen_keepalive // return value referencing/copying tests: class ReturnTester { Eigen::MatrixXd mat = create(); public: ReturnTester() { print_created(this); } ~ReturnTester() { print_destroyed(this); } static Eigen::MatrixXd create() { return Eigen::MatrixXd::Ones(10, 10); } static const Eigen::MatrixXd createConst() { return Eigen::MatrixXd::Ones(10, 10); } Eigen::MatrixXd &get() { return mat; } Eigen::MatrixXd *getPtr() { return &mat; } const Eigen::MatrixXd &view() { return mat; } const Eigen::MatrixXd *viewPtr() { return &mat; } Eigen::Ref<Eigen::MatrixXd> ref() { return mat; } Eigen::Ref<const Eigen::MatrixXd> refConst() { return mat; } Eigen::Block<Eigen::MatrixXd> block(int r, int c, int nrow, int ncol) { return mat.block(r, c, nrow, ncol); } Eigen::Block<const Eigen::MatrixXd> blockConst(int r, int c, int nrow, int ncol) const { return mat.block(r, c, nrow, ncol); } py::EigenDMap<Eigen::Matrix2d> corners() { return py::EigenDMap<Eigen::Matrix2d>(mat.data(), py::EigenDStride(mat.outerStride() * (mat.outerSize()-1), mat.innerStride() * (mat.innerSize()-1))); } py::EigenDMap<const Eigen::Matrix2d> cornersConst() const { return py::EigenDMap<const Eigen::Matrix2d>(mat.data(), py::EigenDStride(mat.outerStride() * (mat.outerSize()-1), mat.innerStride() * (mat.innerSize()-1))); } }; using rvp = py::return_value_policy; py::class_<ReturnTester>(m, "ReturnTester") .def(py::init<>()) .def_static("create", &ReturnTester::create) .def_static("create_const", &ReturnTester::createConst) .def("get", &ReturnTester::get, rvp::reference_internal) .def("get_ptr", &ReturnTester::getPtr, rvp::reference_internal) .def("view", &ReturnTester::view, rvp::reference_internal) .def("view_ptr", &ReturnTester::view, rvp::reference_internal) .def("copy_get", &ReturnTester::get) // Default rvp: copy .def("copy_view", &ReturnTester::view) // " .def("ref", &ReturnTester::ref) // Default for Ref is to reference .def("ref_const", &ReturnTester::refConst) // Likewise, but const .def("ref_safe", &ReturnTester::ref, rvp::reference_internal) .def("ref_const_safe", &ReturnTester::refConst, rvp::reference_internal) .def("copy_ref", &ReturnTester::ref, rvp::copy) .def("copy_ref_const", &ReturnTester::refConst, rvp::copy) .def("block", &ReturnTester::block) .def("block_safe", &ReturnTester::block, rvp::reference_internal) .def("block_const", &ReturnTester::blockConst, rvp::reference_internal) .def("copy_block", &ReturnTester::block, rvp::copy) .def("corners", &ReturnTester::corners, rvp::reference_internal) .def("corners_const", &ReturnTester::cornersConst, rvp::reference_internal) ; // test_special_matrix_objects // Returns a DiagonalMatrix with diagonal (1,2,3,...) m.def("incr_diag", [](int k) { Eigen::DiagonalMatrix<int, Eigen::Dynamic> m(k); for (int i = 0; i < k; i++) m.diagonal()[i] = i+1; return m; }); // Returns a SelfAdjointView referencing the lower triangle of m m.def("symmetric_lower", [](const Eigen::MatrixXi &m) { return m.selfadjointView<Eigen::Lower>(); }); // Returns a SelfAdjointView referencing the lower triangle of m m.def("symmetric_upper", [](const Eigen::MatrixXi &m) { return m.selfadjointView<Eigen::Upper>(); }); // Test matrix for various functions below. Eigen::MatrixXf mat(5, 6); mat << 0, 3, 0, 0, 0, 11, 22, 0, 0, 0, 17, 11, 7, 5, 0, 1, 0, 11, 0, 0, 0, 0, 0, 11, 0, 0, 14, 0, 8, 11; // test_fixed, and various other tests m.def("fixed_r", [mat]() -> FixedMatrixR { return FixedMatrixR(mat); }); m.def("fixed_r_const", [mat]() -> const FixedMatrixR { return FixedMatrixR(mat); }); m.def("fixed_c", [mat]() -> FixedMatrixC { return FixedMatrixC(mat); }); m.def("fixed_copy_r", [](const FixedMatrixR &m) -> FixedMatrixR { return m; }); m.def("fixed_copy_c", [](const FixedMatrixC &m) -> FixedMatrixC { return m; }); // test_mutator_descriptors m.def("fixed_mutator_r", [](Eigen::Ref<FixedMatrixR>) {}); m.def("fixed_mutator_c", [](Eigen::Ref<FixedMatrixC>) {}); m.def("fixed_mutator_a", [](py::EigenDRef<FixedMatrixC>) {}); // test_dense m.def("dense_r", [mat]() -> DenseMatrixR { return DenseMatrixR(mat); }); m.def("dense_c", [mat]() -> DenseMatrixC { return DenseMatrixC(mat); }); m.def("dense_copy_r", [](const DenseMatrixR &m) -> DenseMatrixR { return m; }); m.def("dense_copy_c", [](const DenseMatrixC &m) -> DenseMatrixC { return m; }); // test_sparse, test_sparse_signature m.def("sparse_r", [mat]() -> SparseMatrixR { return Eigen::SparseView<Eigen::MatrixXf>(mat); }); m.def("sparse_c", [mat]() -> SparseMatrixC { return Eigen::SparseView<Eigen::MatrixXf>(mat); }); m.def("sparse_copy_r", [](const SparseMatrixR &m) -> SparseMatrixR { return m; }); m.def("sparse_copy_c", [](const SparseMatrixC &m) -> SparseMatrixC { return m; }); // test_partially_fixed m.def("partial_copy_four_rm_r", [](const FourRowMatrixR &m) -> FourRowMatrixR { return m; }); m.def("partial_copy_four_rm_c", [](const FourColMatrixR &m) -> FourColMatrixR { return m; }); m.def("partial_copy_four_cm_r", [](const FourRowMatrixC &m) -> FourRowMatrixC { return m; }); m.def("partial_copy_four_cm_c", [](const FourColMatrixC &m) -> FourColMatrixC { return m; }); // test_cpp_casting // Test that we can cast a numpy object to a Eigen::MatrixXd explicitly m.def("cpp_copy", [](py::handle m) { return m.cast<Eigen::MatrixXd>()(1, 0); }); m.def("cpp_ref_c", [](py::handle m) { return m.cast<Eigen::Ref<Eigen::MatrixXd>>()(1, 0); }); m.def("cpp_ref_r", [](py::handle m) { return m.cast<Eigen::Ref<MatrixXdR>>()(1, 0); }); m.def("cpp_ref_any", [](py::handle m) { return m.cast<py::EigenDRef<Eigen::MatrixXd>>()(1, 0); }); // test_nocopy_wrapper // Test that we can prevent copying into an argument that would normally copy: First a version // that would allow copying (if types or strides don't match) for comparison: m.def("get_elem", &get_elem); // Now this alternative that calls the tells pybind to fail rather than copy: m.def("get_elem_nocopy", [](Eigen::Ref<const Eigen::MatrixXd> m) -> double { return get_elem(m); }, py::arg().noconvert()); // Also test a row-major-only no-copy const ref: m.def("get_elem_rm_nocopy", [](Eigen::Ref<const Eigen::Matrix<long, -1, -1, Eigen::RowMajor>> &m) -> long { return m(2, 1); }, py::arg().noconvert()); // test_issue738 // Issue #738: 1xN or Nx1 2D matrices were neither accepted nor properly copied with an // incompatible stride value on the length-1 dimension--but that should be allowed (without // requiring a copy!) because the stride value can be safely ignored on a size-1 dimension. m.def("iss738_f1", &adjust_matrix<const Eigen::Ref<const Eigen::MatrixXd> &>, py::arg().noconvert()); m.def("iss738_f2", &adjust_matrix<const Eigen::Ref<const Eigen::Matrix<double, -1, -1, Eigen::RowMajor>> &>, py::arg().noconvert()); // test_issue1105 // Issue #1105: when converting from a numpy two-dimensional (Nx1) or (1xN) value into a dense // eigen Vector or RowVector, the argument would fail to load because the numpy copy would fail: // numpy won't broadcast a Nx1 into a 1-dimensional vector. m.def("iss1105_col", [](Eigen::VectorXd) { return true; }); m.def("iss1105_row", [](Eigen::RowVectorXd) { return true; }); // test_named_arguments // Make sure named arguments are working properly: m.def("matrix_multiply", [](const py::EigenDRef<const Eigen::MatrixXd> A, const py::EigenDRef<const Eigen::MatrixXd> B) -> Eigen::MatrixXd { if (A.cols() != B.rows()) throw std::domain_error("Nonconformable matrices!"); return A * B; }, py::arg("A"), py::arg("B")); // test_custom_operator_new py::class_<CustomOperatorNew>(m, "CustomOperatorNew") .def(py::init<>()) .def_readonly("a", &CustomOperatorNew::a) .def_readonly("b", &CustomOperatorNew::b); // test_eigen_ref_life_support // In case of a failure (the caster's temp array does not live long enough), creating // a new array (np.ones(10)) increases the chances that the temp array will be garbage // collected and/or that its memory will be overridden with different values. m.def("get_elem_direct", [](Eigen::Ref<const Eigen::VectorXd> v) { py::module::import("numpy").attr("ones")(10); return v(5); }); m.def("get_elem_indirect", [](std::vector<Eigen::Ref<const Eigen::VectorXd>> v) { py::module::import("numpy").attr("ones")(10); return v[0](5); }); }
// Resets the values of the static matrices returned by get_cm()/get_rm() void reset_refs() { reset_ref(get_cm()); reset_ref(get_rm()); }