标签: eigen3

每次计算此行时,我都会收到此错误

double k = b.transpose()*Z.inverse()*b;

哪里Eigen::MatrixXd Z(3,3), b(3,1);.我试过铸造但没有运气.有什么建议？

Eigen可以做2D叉积吗？

我正在尝试替换此代码：

Eigen::Vector2f a, b;
float result = a.x()*b.y() - b.x()*a.y();

有了这个：

Eigen::Vector2f a, b;
float result = a.cross(b);

但是，这给了我以下错误：

error C2338: THIS_METHOD_IS_ONLY_FOR_VECTORS_OF_A_SPECIFIC_SIZE

更新资料

Of course Avi Ginsburg is right and its not really defined. So to clarify: What I'm looking for is the length of the cross product (basically the sine of the angle between the vectors, if I understand it correctly).

我正在尝试按照最新文档https://eigen.tuxfamily.org/dox-devel/TopicNewExpressionType.html编写新的Eigen表达式.基本上,我想要的是重塑功能的一部分,在Eigen中仍然没有.所以chop_expr(这里的特征向量表达式)应该将输入向量重塑为n次矩阵.

不幸的是,我实现的不适用于在堆上分配的表达式,例如下面的代码不起作用,但是在将MAXV更改为10之后,一切都变得完美.

另一个问题是

enum {Flags = EvalBeforeNestingBit}

我发现我需要它,否则,当我切割矩阵乘法时,Eigen不会创建临时值,但我猜这种方式我强制chop_expr也为任何其他表达式创建临时.所以问题是我该如何正确地做到这一点？

namespace Eigen {

template <int chunk, typename Derived> struct ChoppedExpression;

namespace internal {

template <int chunk, typename Derived>
struct traits<ChoppedExpression<chunk, Derived>> : traits<Derived> {
  enum {Flags = EvalBeforeNestingBit};
  enum {IsRowMajor = 0};

  enum {   RowsAtCompileTime = chunk};
  enum {MaxRowsAtCompileTime = chunk};

  enum {ColsAtCompileTime = (Derived::RowsAtCompileTime == Eigen::Dynamic 
      ? Eigen::Dynamic : Derived::RowsAtCompileTime / chunk)};

  enum {MaxColsAtCompileTime = (Derived::MaxRowsAtCompileTime == Eigen::Dynamic
      ? Eigen::Dynamic : (Derived::MaxRowsAtCompileTime + chunk - 1) / chunk)};
}; …

我正在尝试在科学程序中使用 Eigen3 库，但我正在努力制作一些简单的函数和成员函数。例如，我不确定应该为以下内容选择哪种返回类型：

template <typename DerivedA,typename DerivedB>
inline **something** mult(const MatrixBase<DerivedA>& p1,
                          const MatrixBase<DerivedB>& p2)
  {
  return p1*p2;
  }

我假设有一些课程，比如说productOp，我可以毫无问题地返回。我仍然无法想象在涉及大量操作的函数中会发生什么，或者更糟糕的是，依赖于输入的迭代会发生什么：

template <typename Derived>
**something** foo(const MatrixBase<Derived>& p1))
  {
  **something** p2;
  p2.setZero();
  while(p2(0,0) < 1)
    p2 += p1; 
  return p2;
  }

我的问题是：

1. 第二个例子可能吗？
2. 我怎样才能确定像这样的操作的类型p1*p2？
3. 在复杂函数的情况下如何计算返回类型？

最近我正在一个项目中使用 Eigen 库。我\xe2\x80\x99m很好奇为什么\xe2\x80\x99s没有要链接的二进制文件，而只有一个标头。我不\xe2\x80\x99t真正理解Eigen如何在幕后工作以使这成为可能。

我在 Python3（使用 numpy）中有一些代码，我想将它们转换为 C++（使用 eigen3）以获得更高效的程序。所以我决定测试一个简单的例子来评估我将获得的性能提升。代码由两个随机数组组成，这些数组要按系数相乘。我的结论是 numpy 的 python 代码比 C++ 的代码快 30%。我想知道为什么解释的 python 代码比编​​译的 C++ 代码快。我在 C++ 代码中遗漏了什么吗？

我正在使用 gcc 9.1.0、Eigen 3.3.7、Python 3.7.3 和 Numpy 1.16.4。

可能的解释：

C++ 程序没有使用矢量化
Numpy 比我想象的要优化得多
Time 测量每个程序中的不同内容

Stack Overflow ( Eigen Matrix vs Numpy Array multiplication performance ) 中有一个类似的问题。我在我的电脑上测试了这个并得到了预期的结果，即 eigen 比 numpy 更有效，但这里的操作是矩阵乘法而不是系数乘法。

Python代码（main.py）
执行命令：python3 main.py

import numpy as np
import time

Lx = 4096
Ly = 4000

# Filling arrays
a = np.random.rand(Lx, Ly).astype(np.float64)
a1 = np.random.rand(Lx, Ly).astype(np.float64)

# Coefficient-wise product
start = …

我有以下问题。我有一些使用 Eigen3 的代码。Eigen3 使用 int 或 long int 作为索引。在代码中的某些地方，我必须将特征数组中的值存储在std::vector.

这是一些例子：

std::vector myStdVector;
Eigen::VectorXd myEigen;
....

for(size_t i=0; i<myStdVector.size(); i++)
{
    myStdVector[i] = myEigen(i);
}

这里我得到编译器警告：

警告：隐式转换会丢失整数精度：“const size_t”（又名“const unsigned long”）到“int”

所以我当然可以static_cast<int>(i)在发生这种情况的所有函数中添加 a ，但我想知道是否有更好的方法来处理这种情况。我想许多其他“库混合”也会发生这种情况。

将形状的输入张量(3, 20, 30)（通道优先表示法）与8形状的滤波器进行卷积(3, 5, 7)应会得到形状的张量(8, 24, 16)。我正在尝试使用实现此功能Eigen::Tensor::convolve，但最终的形状是(1, 24, 16)。因此，似乎仅应用了一个过滤器，而不是所有过滤器8。

这是一个最小的示例：

#include <cassert>
#include <iostream>
#include <eigen3/unsupported/Eigen/CXX11/Tensor>

int main() {
    int input_height = 20;
    int input_width = 30;
    int input_channels = 3;

    int kernels_height = 5;
    int kernels_width = 7;
    int kernels_channels = 3;
    int kernel_count = 8;

    assert(kernels_channels == input_channels);

    int expected_output_height = input_height + 1 - kernels_height;
    int expected_output_width = input_width + 1 - kernels_width; …

这里写的是std::ranges::size应该返回一个无符号整数。但是，当我在Eigen向量（使用 Eigen 3.4）上使用它时，将进行以下编译：

Eigen::VectorXd x;
static_assert(std::same_as<Eigen::VectorXd::Index,
                           decltype(std::ranges::size(x))>);

其中Eigen::VectorXd::Index是众所周知的有符号整数。通过查看 的实现std::ranges::size，我注意到返回类型是从 的返回类型推断出来的x.size()，这正是Eigen::VectorXd::Index. 这是一个错误吗std::ranges::size？或者这是预期的？

更新 27/12/2021

上面链接的 C++ 参考页最终更改了该函数的描述std::ranges::size：它只返回一个整数，不一定是无符号的！

假设我有一个具有以下模式的大型稀疏矩阵：

• 每列的非零数及其位置是固定的
• 只有矩阵块 A 和 B 会发生变化，矩阵的其余部分保持不变；（块 A 和 B 本身也是稀疏的，具有固定的非零位置）

按照文档中的说明，我已通过以下方式初始化了上述矩阵

• 为列主稀疏矩阵保留每列非零的确切数量
• 逐列插入
• 从每列的最小行索引插入

在程序的后面部分，很自然地会重用矩阵并仅就地更新 A、B 块。可能的方式有：

1. 通过 , 访问现有条目coeffRef会引入二分搜索，因此此处不推荐使用。
2. 迭代外部和内部维度，如此处记录的

然而，似乎没有必要迭代所有非零条目，因为稀疏矩阵的大部分保持不变。

是否可以就地更新 A、B 而无需迭代矩阵中的所有非零值？