- iOS/Objective-C 元类和类别
- objective-c - -1001 错误,当 NSURLSession 通过 httpproxy 和/etc/hosts
- java - 使用网络类获取 url 地址
- ios - 推送通知中不播放声音
我想使用 Boost.Proto 将嵌入式领域特定语言转换为一系列使用 Eigen 库实现的矩阵运算。由于效率很重要,我希望 proto 生成 Eigen 表达式模板并避免过早评估。
我实现了一个可以生成矩阵乘法表达式的简单语法。下面的代码在没有警告的情况下编译(在 g++ 4.8.0 和 Intel C++ 2013.3 上,使用 Boost 1.54.0 和 Eigen 3.1.3)并且只要我的表达式只有一个乘法运算就可以工作。一旦我向链中添加更多乘法,它就会崩溃。 Valgrind 告诉我,这是因为 Eigen::GeneralProduct 表达式模板之一在求值完成之前被销毁了。
我不明白为什么会发生这种情况,或者我可以做些什么来防止这种情况发生。感谢所有帮助!
#include <iostream>
#include <boost/fusion/container.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/void.hpp>
#include <boost/proto/proto.hpp>
#include <boost/ref.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/utility.hpp>
#include <Eigen/Dense>
namespace fusion = boost::fusion;
namespace mpl = boost::mpl;
namespace proto = boost::proto;
typedef Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> matrix;
// Placeholders
const proto::terminal<mpl::int_<0> >::type I1 = {{}};
const proto::terminal<mpl::int_<1> >::type I2 = {{}};
const proto::terminal<mpl::int_<2> >::type I3 = {{}};
// Grammar
template<class Rule, class Callable = proto::callable>
struct External :
proto::when<Rule, proto::external_transform> {};
struct matmul_transform : proto::callable {
template<class Sig> struct result;
template<class This, class MatrixExpr1, class MatrixExpr2>
struct result<This(MatrixExpr1, MatrixExpr2)> {
typedef typename Eigen::ProductReturnType<
typename boost::remove_const<typename boost::remove_reference<MatrixExpr1>::type>::type,
typename boost::remove_const<typename boost::remove_reference<MatrixExpr2>::type>::type>::Type
type;
};
template<class MatrixExpr1, class MatrixExpr2>
typename result<matmul_transform(MatrixExpr1, MatrixExpr2)>::type
operator()(const MatrixExpr1 &a, const MatrixExpr2 &b) const {
return a * b;
}
};
struct MatmulGrammar;
struct InputPlaceholder : proto::terminal<proto::_> {};
struct MatrixMultiplication :
proto::multiplies<MatmulGrammar, MatmulGrammar> {};
struct MatmulGrammar : proto::or_<
External<InputPlaceholder>,
External<MatrixMultiplication> > {};
struct matmul_transforms : proto::external_transforms<
proto::when<MatrixMultiplication, matmul_transform(MatmulGrammar(proto::_left), MatmulGrammar(proto::_right))>,
proto::when<InputPlaceholder, proto::functional::at(proto::_data, proto::_value)> > {};
int main() {
matrix mat1(2,2), mat2(2,2), mat3(2,2), result(2,2);
mat1 << 1, 2, 3, 4;
mat2 << 5, 6, 7, 8;
mat3 << 1, 3, 6, 9;
MatmulGrammar mmg;
// THIS WORKS:
result = mmg(I1 * I2,
mpl::void_(),
(proto::data = fusion::make_vector(boost::cref(mat1), boost::cref(mat2), boost::cref(mat3)),
proto::transforms = matmul_transforms()));
std::cout << result << std::endl;
// THIS CRASHES:
result = mmg(I1 * I2 * I3,
mpl::void_(),
(proto::data = fusion::make_vector(boost::cref(mat1), boost::cref(mat2), boost::cref(mat3)),
proto::transforms = matmul_transforms()));
std::cout << result << std::endl;
return 0;
}
最佳答案
这是我尝试将您的方法与评论中链接的解决方案合并的尝试。我从 here 复制了 stored_result_expression
、do_wrap_expression
和 wrap_expression
.我对您的代码或演讲中的代码所做的更改都标有 //CHANGED
。
#include <iostream>
#include <boost/fusion/container.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/void.hpp>
#include <boost/proto/proto.hpp>
#include <boost/ref.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/utility.hpp>
#include <Eigen/Dense>
namespace fusion = boost::fusion;
namespace mpl = boost::mpl;
namespace proto = boost::proto;
typedef Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> matrix;
// Placeholders
const proto::terminal<mpl::int_<0> >::type I1 = {{}};
const proto::terminal<mpl::int_<1> >::type I2 = {{}};
const proto::terminal<mpl::int_<2> >::type I3 = {{}};
// Grammar
template<class Rule, class Callable = proto::callable>
struct External :
proto::when<Rule, proto::external_transform> {};
struct matmul_transform : proto::callable {
template<class Sig> struct result;
template<class This, class Expr, class MatrixExpr1, class MatrixExpr2>
struct result<This(Expr, MatrixExpr1, MatrixExpr2)> {
typedef typename Eigen::MatrixBase<
typename Eigen::ProductReturnType<
typename boost::remove_const<typename boost::remove_reference<MatrixExpr1>::type>::type,
typename boost::remove_const<typename boost::remove_reference<MatrixExpr2>::type>::type
>::Type
>::PlainObject&
type; //CHANGED - THIS IS THE TYPE THAT IS USED IN THE CODE OF THE TALK
};
template<class Expr, class MatrixExpr1, class MatrixExpr2>
typename result<matmul_transform(Expr, MatrixExpr1, MatrixExpr2)>::type
operator()(Expr& expr, const MatrixExpr1 &a, const MatrixExpr2 &b) const { //CHANGED - ADDED THE expr PARAMETER
expr.value = a*b;
return expr.value;
}
};
struct MatmulGrammar;
struct InputPlaceholder : proto::terminal<proto::_> {};
struct MatrixMultiplication :
proto::multiplies<MatmulGrammar, MatmulGrammar> {};
struct MatmulGrammar : proto::or_<
External<InputPlaceholder>,
External<MatrixMultiplication> > {};
struct matmul_transforms : proto::external_transforms<
proto::when<MatrixMultiplication, matmul_transform(proto::_, MatmulGrammar(proto::_left), MatmulGrammar(proto::_right))>, //CHANGED - ADAPTED TO THE NEW SIGNATURE OF matmul_transform
proto::when<InputPlaceholder, proto::functional::at(proto::_data, proto::_value)> > {};
// THE FOLLOWING CODE BLOCK IS COPIED FROM https://github.com/barche/eigen-proto/blob/master/eigen_calculator_solution.cpp
//----------------------------------------------------------------------------------------------
/// Wraps a given expression, so the value that it represents can be stored inside the expression itself
template<typename ExprT, typename ValueT>
struct stored_result_expression :
proto::extends< ExprT, stored_result_expression<ExprT, ValueT> >
{
EIGEN_MAKE_ALIGNED_OPERATOR_NEW
typedef proto::extends< ExprT, stored_result_expression<ExprT, ValueT> > base_type;
explicit stored_result_expression(ExprT const &expr = ExprT())
: base_type(expr)
{
}
/// Temporary storage for the result of the expression
mutable ValueT value;
};
struct do_wrap_expression : proto::transform< do_wrap_expression >
{
template<typename ExprT, typename StateT, typename DataT>
struct impl : proto::transform_impl<ExprT, StateT, DataT>
{
typedef typename boost::result_of<MatmulGrammar(ExprT, StateT, DataT)>::type result_ref_type; //CHANGED - TO USE YOUR GRAMMAR
typedef typename boost::remove_reference<result_ref_type>::type value_type;
typedef typename boost::remove_const<typename boost::remove_reference<ExprT>::type>::type expr_val_type;
typedef stored_result_expression<expr_val_type, value_type> result_type;
result_type operator()(typename impl::expr_param expr, typename impl::state_param state, typename impl::data_param data)
{
return result_type(expr);
}
};
};
/// Wrap multiplies expressions so they can store a temporary result
struct wrap_expression :
proto::or_
<
proto::terminal<proto::_>,
proto::when
<
proto::multiplies<proto::_, proto::_>,
do_wrap_expression(
proto::functional::make_multiplies
(
wrap_expression(proto::_left), wrap_expression(proto::_right)
),
proto::_state, //CHANGED - THESE EXTRA PARAMETERS ARE NEEDED TO CALCULATE result_ref_type IN do_wrap_expression
proto::_env
)
>,
proto::nary_expr< proto::_, proto::vararg<wrap_expression> >
>
{
};
//--------------------------------------------------------------------------------------------------
int main() {
matrix mat1(2,2), mat2(2,2), mat3(2,2), result(2,2);
mat1 << 1, 1, 0, 1;
mat2 << 1, 1, 0, 1;
mat3 << 1, 1, 0, 1;
MatmulGrammar mmg;
wrap_expression wrap;
//THIS WORKS:
result = mmg( //THIS IS REALLY HORRIBLE, BUT IT WORKS. IT SHOULD PROBABLY BE HIDDEN BEHIND A FUNCTION
wrap(
I1 * I2,
mpl::void_(),
( proto::data = fusion::make_vector(boost::cref(mat1), boost::cref(mat2), boost::cref(mat3)),
proto::transforms = matmul_transforms() )
),
mpl::void_(),
( proto::data = fusion::make_vector(boost::cref(mat1), boost::cref(mat2), boost::cref(mat3)),
proto::transforms = matmul_transforms() )
);
std::cout << result << std::endl;
// THIS DOESN'T CRASH ANYMORE:
result = mmg(
wrap(
I1 * I2 * I3 * I1 * I2 * I3,
mpl::void_(),
( proto::data = fusion::make_vector(boost::cref(mat1), boost::cref(mat2), boost::cref(mat3)),
proto::transforms = matmul_transforms() )
),
mpl::void_(),
( proto::data = fusion::make_vector(boost::cref(mat1), boost::cref(mat2), boost::cref(mat3)),
proto::transforms = matmul_transforms() )
);
std::cout << result << std::endl;
return 0;
}
关于c++ - 使用 Boost.Proto 构建 Eigen 表达式模板,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/17754995/
我想了解表达式模板如何在 Eigen 中工作。 我知道两个动态双向量的总和是由如下所示的东西执行的: CwiseBinaryOp, VectorXd const, VectorXd const > o
在本征中,我们可以创建一个矩阵 Matrix3f m; m m(3, 8, 6); // Input after construction m.diagonal() << 3, 8, 6; Diag
我想知道是否有比使用 for 循环更简单的方法来解决我的问题。所以情况是这样的: 一般来说,我想从我的传感器收集数据点(消息类型为 Eigen::Vector3d,我无法更改它,因为它是一个巨大的框架
简而言之,问题是如何通过一个 Eigen::Map 反对一个期待一个函数 Eigen::MatrixXd 对象。 长话短说: 我有这个 C++ 函数声明 void npMatrix(const Eig
考虑以下代码。 const int N = 100; const float alpha = 0.9; Eigen::MatrixXf myVec = Eigen::MatrixXf::Random(
我试图获得两个张量的矩阵乘积,其中一个张量应该在相乘之前转置( At*B )。 到目前为止,我在 eigen documentation 中发现了什么是没有任何转置和两个矩阵都转置的矩阵乘积。 我正在
我的问题很简单,希望也有一个很好的答案:当我构造了 Eigen::MatrixXd 矩阵时,我可以使用多个线程同时填充矩阵中的行吗(如果我可以确保没有行被同时写入),或者我必须在每个线程中创建临时行对
#include #include namespace Eigen { // float op double -> double template struct ScalarBinaryOpTr
我在 Eigen 库的 API 上遇到了一些困难,即用于稀疏矩阵 Cholesky 分解的 SimplicialLLT 类。我需要分解三个矩阵,然后用它们来求解许多方程组(仅更改右侧) - 因此我只想
我正在尝试使用 Eigen 的 JacobiSVD 进行实验。特别是我试图从奇异值分解中重建输入矩阵。 http://eigen.tuxfamily.org/dox/classEigen_1_1Jac
我刚刚阅读了 Structures having static members Eigen 页。后者陈述如下: If you define a structure having members of
我正在使用 C++ 中的 Eigen 库来获取浮点方阵的平方根: MatrixXf gPrime(QUAD_EKF_NUM_STATES, QUAD_EKF_NUM_STATES); gPri
我正在尝试使用 vector 中的相应值来缩放矩阵中的所有列。如果此值为 0,我想用另一个按常数缩放的矩阵中的列替换该列。听起来很复杂,但在 Matlab 中它非常简单(但可能没有完全优化): a(:
使用 Eigen 将仿射变换转换为等距变换(即仅由旋转和平移组成)的最简单方法是什么? 图书馆? 两种变换都是 3D 的。仿射矩阵在左上象限有一个通用的 3x3 矩阵(即旋转、缩放和剪切),而等轴测在
我正在尝试生成 PCL 点云。我所有的点都在以下容器类型中: std::vector > 我想创建一个指向 PCL 点云的指针: pcl::PointCloud::Ptr pc 创建此点云的最有效方法
最近,我编译了 Eigen3 并用它在 Windows 上做一些线性代数任务。 但我想知道为什么 Eigen3 不需要链接额外的 lib 或 DLL(我只需要包含它的头文件) Eigen 是否在编译时
我正在使用特征张量库,在我看来,shuffle() 方法需要一个对象 Eigen::array 作为输入。 在我的实现中,我有一个 std::list 需要传递给 shuffle (当然我只在运行时知
我有两个问题。 Eigen::Affine3f 和 Eigen::Matrix4f 中表示的刚性变换是否相同? 我们如何从 Eigen::Affine3f 转换为 Eigen::Matrix4f,反之
我想用单个 3-D Eigen::Tensor 替换代码中的一系列矩阵。考虑到这一点,我尝试比较张量和矩阵的性能。 下面的函数“tensorContractTest”执行 (n,n,n) 3 阶张量与
如何将 ArrayXXd 数组转换为 MatrixXd?到目前为止,我已经完成了 MatrixXd temp_mat = my_array; 并且隐式转换似乎工作正常,但这是应该完成的方式吗?或者我应
我是一名优秀的程序员,十分优秀!