Question

我目前正在使用std :: map来存储稀疏矩阵：

std::map<std::pair<int, int>, double> matrix;

要插入我

matrix[std::make_pair(i,j)] = value;

在我创建矩阵之后我想做（矩阵转置*矩阵）我必须做（00 * 00）+（10 * 10）+（20 * 20）（访问垂直列）..由于迭代器来自（00）（01）（02）（访问水平列）...我不能使用std迭代器。

实现（00）*（00）+（10 * 10）+ ..我使用while循环使用x1，y1和x2，y2来访问矩阵元素。

所以现在我的问题是（如果我正在做的事情也有意义）如何在不使用迭代器的情况下访问第一对和第二对std ::对？

Answer 1

＆＃34; easy＆＃34;解决这个问题的方法是写transpose：

std::map<std::pair<int, int>, double> transpose(
  std::map<std::pair<int, int>, double> const& in
) {
  std::map<std::pair<int, int>, double> r;
  for (auto&& e:in)
    r[std::make_pair( e.first.second, e.first.first )] = e.second;
  return r;
}

但这需要分配一个全新的矩阵。

另一种方法是使用矩阵视图。矩阵视图是：

template<class R> using matrix_func = std::function< R( std::pair<int,int> ) >;
template<class R>
struct matrix_view_base:matrix_func<R> {
  std::pair<int, int> dimensions;
  matrix_view( matrix_func<R> f, std::pair<int, int> d ):
    matrix_func<R>(std::move(f)),
    dimensions(d)
  {}
};
using matrix_view = matrix_view_base<double&>;
using matrix_const_view = matrix_view_base<double>;

将坐标映射到双倍的函数与最大尺寸的知识。

然后我们写一个逆变器：

matrix_view invert( matrix_view in ) {
  return {
    [in]( std::pair<int, int> index )->double& {
      return in(index.second, index.first);
    },
    in.dimensions
  };
}
matrix_const_view invert( matrix_const_view in ) {
  return {
    [in]( std::pair<int, int> index )->double {
      return in(index.second, index.first);
    },
    in.dimensions
  };
}

使用一些函数来生成所述视图：

matrix_view view_of( matrix& m ) {
  return {
    [&](std::pair<int, int> idx)->double& {
      return m[idx];
    },
    // calculate dimensions
  };
}
matrix_const_view view_of( matrix const& m ) {
  return {
    [&](std::pair<int, int> idx)->double {
      auto it = m.find(idx);
      if (it == m.end()) return 0.0;
      return *it;
    },
    // calculate dimensions
  };
}
matrix_const_view const_view_of( matrix const& m ) {
  return view_of(m);
}

现在你只需要为矩阵视图编写乘法：

matrix_const_view multiply( matrix_const_view lhs, matrix_const_view rhs ) {
  return {
    [=](std::pair<int,int> idx)->double{
      // calculate value at idx using lhs(...) and rhs(...) return values
    },
    // calculate dimensions
  };
}

现在这并不完美，因为你能够确定0比两次查找更快的地方。但这个想法是你创建一个视图类，它表示一个矩阵的视图，对它们进行操作，并且只在你需要存储结果时固化成一个实际的矩阵。

这允许转置便宜。

是否可以在不使用映射中的迭代器的情况下访问键值对？

1 个答案: