指向切成薄片的特征矩阵

Question

我有一个函数，该函数将指针指向特征矩阵。我需要将此矩阵切成几片，然后将矩阵的一部分传递给该函数。我想避免复制数据，因此我想用指针将其传递。

我切一个矩阵，例如：

MatrixXd A;
// some operations with the matrix
// now I want something like this:
MatrixXd *B = &A(seq(2, 4), all);

最后一行是无效的。我如何获取指向矩阵的指针，以便仍然可以将其视为特征矩阵？有解决方法吗？同样，我想避免创建新矩阵，就像我的真实程序中一样大。

Answer 1

这就是eigen :: ref是用来的。 “如何写通用但非塑造功能？

请参阅 这样：

void consume_matrix(const Eigen::Ref<const Eigen::MatrixXd>& in);
void produce_matrix(Eigen::Ref<Eigen::MatrixXd> out);


void foo()
{
    Eigen::MatrixXd matrix = ...;
    produce_matrix(matrix.middleRows(start, len));
    consume_matrix(matrix.leftCols(len));
}

存储块引用

eigen不带有非常适合保留矩阵的“借用”块表达式的类型。对于这种情况，我不推荐ref，因为它太容易了，无法指出临时分配，这很容易导致悬挂的指针。

最终，存储借来的观点是从根本上不安全的操作。但是，如果您绝对必须这样做，我将使用eigen :: Map。至少这清楚地表明，您不拥有所引用的内存。类似的事情：

struct MatrixReference
{
  using map_type = Eigen::Map<
    Eigen::MatrixXd, Eigen::Unaligned, Eigen::OuterStride<> >;

  map_type matrix;

  template<class Derived>
  static map_type to_map(const Eigen::DenseBase<Derived>& matrix) noexcept
  {
    assert(matrix.innerStride() == 1);
    return map_type(const_cast<double*>(matrix.derived().data()),
                    matrix.rows(), matrix.cols(),
                    Eigen::OuterStride<>(matrix.outerStride()));
  }

  MatrixReference() noexcept
  : matrix(nullptr, 0, 0, Eigen::OuterStride<>(1))
  {}
  template<class Derived>
  explicit MatrixReference(const Eigen::DenseBase<Derived>& matrix) noexcept
    : matrix(to_map(matrix))
  {}
  MatrixReference(const MatrixReference&) = default;
  MatrixReference& operator=(const MatrixReference& o) noexcept
  {
    // placement-new because assignment would overwrite the content
    new (&matrix) map_type(o.matrix);
    return *this;
  }
};
int main()
{
  Eigen::MatrixXd mat = Eigen::MatrixXd::Random(4, 5);
  MatrixReference ref(mat.topRows(2));
  std::cout << mat << "\n\n" << ref.matrix << "\n\n";
}

一个稍微更安全的选项是将shared_ptr保留到矩阵中，并存储信息单独使用的切片。也许这样：

struct CountedBlockRef
{
  std::shared_ptr<Eigen::MatrixXd> matrix;
  Eigen::Index first_row, first_col, rows, cols;

  using block_type = Eigen::Block<
    Eigen::MatrixXd, Eigen::Dynamic, Eigen::Dynamic>;
  using const_block_type = Eigen::Block<
    const Eigen::MatrixXd, Eigen::Dynamic, Eigen::Dynamic>;

  CountedBlockRef() noexcept
  : matrix(), first_row(), first_col(), rows(), cols()
  {}
  CountedBlockRef(std::shared_ptr<Eigen::MatrixXd> matrix,
                  Eigen::Index first_row, Eigen::Index first_col,
                  Eigen::Index rows, Eigen::Index cols) noexcept
    : matrix(std::move(matrix)),
      first_row(first_row),
      first_col(first_col),
      rows(rows),
      cols(cols)
  {}
  block_type block() noexcept
  { return matrix->block(first_row, first_col, rows, cols); }

  const_block_type block() const noexcept
  {
    const Eigen::MatrixXd& matrix = *this->matrix;
    return matrix.block(first_row, first_col, rows, cols);
  }
};
int main()
{
  std::shared_ptr<Eigen::MatrixXd> matptr =
    std::make_shared<Eigen::MatrixXd>(Eigen::MatrixXd::Random(4, 5));
  CountedBlockRef aref(matptr, 0, 0, 2, 5);
  std::cout << *matptr << "\n\n" << aref.block() << '\n';
}

这样，即使在调整了矩阵和悬空指针大小后，参考文献也将保持有效。只有缩水仍然是一个威胁，但假设您与他们进行了编译，那会被断言所抓住。