C++ 迭代两个稀疏矩阵

我正在使用boost稀疏矩阵来保存bool，并试图编写一个比较函数来将它们存储在地图中。这是一个非常简单的比较函数。基本上，其想法是将矩阵视为二进制数（在被展平为向量后），并根据该数字的值进行排序。这可以通过以下方式实现：

for(unsigned int j = 0; j < maxJ; j++)
{
  for(unsigned int i = 0; i < maxI; i++)
  {
    if(matrix1(i,j) < matrix2(i,j) return true;
    else if(matrix1(i,j) > matrix2(i,j) return false;
  }
}
return false;

for（无符号整数j=0；jmatrix2（i，j）返回false；
}
}
返回false；

然而，由于矩阵的稀疏性，这是低效的，我想使用迭代器得到同样的结果。 1） 抓取每个矩阵中的第一个非零单元格，2）比较两者的j*maxJ+i，3）如果相等，抓取每个矩阵中的下一个非零单元格并重复。不幸的是，在代码中，这是非常乏味的，我担心错误

我想知道的是（a）是否有更好的方法来实现这一点，（b）是否有简单的方法来获得两个矩阵的“下一个非零单元”？显然，我不能像迭代一个稀疏矩阵那样使用嵌套for循环

谢谢你的帮助

--

由于我上面提出的算法似乎是我特定应用程序中的最佳解决方案，我想我应该发布我为棘手部分开发的代码，在两个稀疏矩阵中获得下一个非零单元。这段代码并不理想，也不是很清楚，但我不知道如何改进它。如果有人发现了一个bug或者知道如何改进它，我将非常感谢你的评论。否则，我希望这对其他人有用

typedef boost::numeric::ublas::mapped_matrix<bool>::const_iterator1 iter1;
typedef boost::numeric::ublas::mapped_matrix<bool>::const_iterator2 iter2;

// Grabs the next nonzero cell in a sparse matrix after the cell pointed to by i1, i2.
std::pair<iter1, iter2> next_cell(iter1 i1, iter2 i2, iter1 end) const
{
    if(i2 == i1.end())
    {
        if (i1 == end)
            return std::pair<iter1, iter2>(i1, i2);
        ++i1;
        i2 = i1.begin();
    }
    else
    {
        ++i2;
    }

    for(; i1 != end;)
    {
        for(; i2 != i1.end(); ++i2)
        {
            return std::pair<iter1, iter2>(i1,i2);
        }
        ++i1;
        if(i1 != end) i2 = i1.begin();
    }
    return std::pair<iter1, iter2>(i1, i2);
}

typedef boost:：numeric:：ublas:：mapped_matrix:：const_iterator 1 iter1；
typedef boost:：numeric:：ublas:：mapped_matrix:：const_iterator 2 iter2；
//获取稀疏矩阵中i1、i2指向的单元之后的下一个非零单元。
标准：：配对下一个单元（iter1 i1、iter2 i2、iter1 end）常数
{
如果（i2==i1.end（））
{
如果（i1==结束）
返回std：：对（i1，i2）；
++i1；
i2=i1.begin（）；
}
其他的
{
++i2；
}
对于（；i1！=end；）
{
对于（；i2！=i1.end（）；++i2）
{
返回std：：对（i1，i2）；
}
++i1；
如果（i1！=end）i2=i1.begin（）；
}
返回std：：对（i1，i2）；
}

（a）我不完全理解您试图实现的目标，但如果您想比较两个矩阵在同一索引处是否具有相同的值，则使用元素矩阵乘法（也应在稀疏中实现）就足够了：

这样，您将得到每个索引：

0 (false) * 1 (true) = 0 (false)
0*0 = 0
1*1 = 1

---

因此，生成的矩阵3将把您的解决方案放在一行：）

在我看来，我们讨论的是在boost:：sparse_矩阵上实现按位、按元素的运算符，因为比较一个向量（或矩阵）是否比另一个向量（或矩阵）小而不使用任何标准向量范数需要特殊运算符（或特殊映射/范数）

据我所知，boost并没有为二进制矩阵（更不用说稀疏二进制矩阵）提供特殊的运算符。使用BLAS级矩阵/向量代数不太可能有任何直接的解决方案。二元矩阵在线性代数领域有自己的位置，所以有一些技巧和定理，但我怀疑它们比你的解更容易

您的问题可以重新表述为：如何有效地对二维位图表示的天文数字进行排序（n=100，因此100x100个元素将给出一个类似于2^10000的数字）

---

好问题顺便说一句，我喜欢这个问题

让我把你想问的假代码写出来

declare list of sparse matrices ListA
declare map MatMAp with a sparse Matrix type mapping to a double, along with a
`StrictWeakMatrixOrderer` function which takes two sparse matrices.

Insert ListA into MatMap. 

问题：如何有效地编写StrictWeakTrixOrder

这是一种方法。我在飞行中发明了这个

---

定义一个函数

flatte（）

并预计算展平矩阵，将展平向量存储在向量（或具有随机索引上限的另一个容器）中

flatte（）

可以简单地将每一行（或列）与前一行（或前一列）连接起来（如果您有一个获取行/列的常量时间函数，则可以在线性时间内完成）

这将产生一组大小为10^6的向量。这是一个折衷方案——保存这些信息，而不是动态计算。如果您要在进行过程中进行大量比较，这将非常有用

记住，零包含信息-删除它们可能会产生两个彼此相等的向量，而它们的生成矩阵可能不相等

然后，我们将算法问题从“序矩阵”转化为“序向量”。 我从来没有听说过矩阵的距离度量，但我听说过向量的距离度量

您可以使用“差异总和”排序，即汉明距离。（对于每个不同的元素，添加1）。这将是一个O（n）算法：

for i = 0 to max.
  if(a[i] != b[i])
     distance++

return distance

汉明距离满足这些条件

d(a,b) = d(b,a)
d(a,a) = 0
d(x, z) <= d(x, y) + d(y, z) 

d（a，b）=d（b，a）
d（a，a）=0
d（x，z）为什么要将布尔值与<和>？即使您可以相信falsed(a,b) = d(b,a)
d(a,a) = 0
d(x, z) <= d(x, y) + d(y, z)