C++ 从特征（SparseLU对象）序列化分解矩阵

我试图求解Ax=b，其中矩阵A的大小可以很大，接近1M x 1M，是稀疏对称的，但可能不是正定义的

问题是，使用in-eigen计算分解可能需要很长时间，最好存储sparseLU矩阵而不是原始矩阵，这样每当我们使用相同的矩阵a执行类似操作时，我们都可以通过不需要重新计算

快速搜索stackoverflow和google返回，搜索稀疏矩阵以序列化特征矩阵。但是，我不确定相同的代码是否可以应用于sparseLU对象

也许我应该重新表述我的问题：

如何将分解后的矩阵存储到文件中？

---

当前的方法都集中于存储原始矩阵，但我想存储分解后的矩阵。有办法吗？谢谢。

以下示例将帮助您实现自己的序列化

编辑更改示例以回答改写的问题

#include <Eigen/Dense>
#include <Eigen/Core>
#include <Eigen/Sparse>
#include <Eigen/SparseLU>
#include <iostream>
#include <fstream>

using namespace Eigen;
using namespace std;

typedef Triplet<int> Trip;

template <typename T, int whatever, typename IND>
void Serialize(SparseMatrix<T, whatever, IND>& m) {
    std::vector<Trip> res;
    int sz = m.nonZeros();
    m.makeCompressed();

    fstream writeFile;
    writeFile.open("matrix", ios::binary | ios::out);

    if(writeFile.is_open())
    {
        IND rows, cols, nnzs, outS, innS;
        rows = m.rows()     ;
        cols = m.cols()     ;
        nnzs = m.nonZeros() ;
        outS = m.outerSize();
        innS = m.innerSize();

        writeFile.write((const char *)&(rows), sizeof(IND));
        writeFile.write((const char *)&(cols), sizeof(IND));
        writeFile.write((const char *)&(nnzs), sizeof(IND));
        writeFile.write((const char *)&(outS), sizeof(IND));
        writeFile.write((const char *)&(innS), sizeof(IND));

        writeFile.write((const char *)(m.valuePtr()),       sizeof(T  ) * m.nonZeros());
        writeFile.write((const char *)(m.outerIndexPtr()),  sizeof(IND) * m.outerSize());
        writeFile.write((const char *)(m.innerIndexPtr()),  sizeof(IND) * m.nonZeros());

        writeFile.close();
    }
}

template <typename T, int whatever, typename IND>
void Deserialize(SparseMatrix<T, whatever, IND>& m) {
    fstream readFile;
    readFile.open("matrix", ios::binary | ios::in);
    if(readFile.is_open())
    {
        IND rows, cols, nnz, inSz, outSz;
        readFile.read((char*)&rows , sizeof(IND));
        readFile.read((char*)&cols , sizeof(IND));
        readFile.read((char*)&nnz  , sizeof(IND));
        readFile.read((char*)&outSz, sizeof(IND));
        readFile.read((char*)&inSz , sizeof(IND));

        m.resize(rows, cols);
        m.makeCompressed();
        m.resizeNonZeros(nnz);

        readFile.read((char*)(m.valuePtr())     , sizeof(T  ) * nnz  );
        readFile.read((char*)(m.outerIndexPtr()), sizeof(IND) * outSz);
        readFile.read((char*)(m.innerIndexPtr()), sizeof(IND) * nnz );

        m.finalize();
        readFile.close();

    } // file is open
}


int main(int argc, char *argv[]){
    int rows, cols;
    rows = cols = 6;
    SparseMatrix<double> A(rows,cols), B;

    std::vector<Trip> trp, tmp;

    trp.push_back(Trip(0, 0, rand()));
    trp.push_back(Trip(1, 1, rand()));
    trp.push_back(Trip(2, 2, rand()));
    trp.push_back(Trip(3, 3, rand()));
    trp.push_back(Trip(4, 4, rand()));
    trp.push_back(Trip(5, 5, rand()));
    trp.push_back(Trip(2, 4, rand()));
    trp.push_back(Trip(3, 1, rand()));

    A.setFromTriplets(trp.begin(), trp.end());
    cout << A.nonZeros() << endl;   // Prints 8
    cout << A.size() << endl;       // Prints 36
    cout << A << endl;              // Prints the matrix along with the sparse matrix stuff

    Serialize(A);

    Deserialize(B);

    cout << B.nonZeros() << endl;   // Prints 8
    cout << B.size() << endl;       // Prints 36
    cout << B << endl;              // Prints the reconstructed matrix along with the sparse matrix stuff


    SparseLU<SparseMatrix<double>, COLAMDOrdering<int> > solver;
    solver.isSymmetric(true);
    solver.compute(A);  // Works...
    /*
    ...
    */

    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间特征；
使用名称空间std；
typedef三重态跳闸；
模板
无效序列化（SparseMatrix&m）{
std：：向量res；
int sz=m.非零（）；
m、 makeCompressed（）；
流写入文件；
open（“矩阵”，ios:：binary | ios:：out）；
if（writeFile.is_open（））
{
IND ROW、cols、NNZ、outS、innS；
行=m.行（）；
cols=m.cols（）；
nnzs=m.非零（）；
outS=m.outerSize（）；
innS=m.innerSize（）；
writeFile.write（（const char*）&（rows），sizeof（IND））；
writeFile.write（（const char*）&（cols），sizeof（IND））；
writeFile.write（（const char*）&（nnzs），sizeof（IND））；
writeFile.write（（const char*）和（out），sizeof（IND））；
writeFile.write（（const char*）和（innS），sizeof（IND））；
writeFile.write（（const char*）（m.valuePtr（）），sizeof（T）*m.nonZeros（））；
writeFile.write（（const char*）（m.outerIndexPtr（）），sizeof（IND）*m.outerSize（））；
writeFile.write（（const char*）（m.innerIndexPtr（）），sizeof（IND）*m.nonZeros（））；
writeFile.close（）；
}
}
模板
void反序列化（SparseMatrix&m）{
fstream读取文件；
open（“矩阵”，ios:：binary | ios:：in）；
if（readFile.is_open（））
{
IND行、cols、nnz、inSz、outSz；
readFile.read（（char*）&rows，sizeof（IND））；
readFile.read（（char*）&cols，sizeof（IND））；
readFile.read（（char*）&nnz，sizeof（IND））；
readFile.read（（char*）&outSz，sizeof（IND））；
readFile.read（（char*）&inSz，sizeof（IND））；
m、 调整大小（行、列）；
m、 makeCompressed（）；
m、 resizeNonZeros（nnz）；
readFile.read（（char*）（m.valuePtr（）），sizeof（T）*nnz）；
readFile.read（（char*）（m.outerIndexPtr（）），sizeof（IND）*outSz）；
readFile.read（（char*）（m.innerIndexPtr（）），sizeof（IND）*nnz）；
m、 定稿（）；
readFile.close（）；
}//文件已打开
}
int main（int argc，char*argv[]）{
int行，cols；
行=cols=6；
SparseMatrix A（行，列），B；
std：：载体trp，tmp；
trp.push_back（Trip（0，0，rand（））；
trp.push_back（Trip（1，1，rand（））；
trp.push_back（Trip（2，2，rand（））；
trp.push_back（Trip（3,3，rand（））；
trp.push_back（Trip（4,4，rand（））；
trp.推回（行程（5，5，rand（））；
trp.推回（行程（2，4，rand（））；
trp.push_back（Trip（3,1，rand（））；
A.setFromTriplets（trp.begin（），trp.end（））；
矩阵有多稀疏？有提到的选项。我不确定矩阵有多稀疏，因为这可能会随着输入的变化而变化。但是，这里的主要问题是，是否可以序列化分解的sparseLU对象。当尝试使用我在sparseLU对象上提供的链接提供的方法时，它们都不起作用。在nk我提供的，ggael展示了如果你想进行你自己的序列化，如何访问索引和矩阵的值。谢谢Avi，我想我现在明白你的意思了。再加上和，我认为有可能序列化sparseLU。现在的问题是以下错误：“类本征：：sparseLU”没有member命名为'nonZeros'，这很奇怪，因为我已经检查过nonZeros（）肯定是一个成员函数，我不确定这出了什么问题。嗨，Avi，非常感谢你的帮助。我最近收到ggael的通知，我无法保存SparseLU对象，我将不得不“破解”sparseLU对象类，以便我执行序列化。非常感谢您的帮助！！@Sam我刚才才意识到您想保存
sparseLU
对象，而不是
SparseMatrix
。如果ggael说您必须自己保存/加载方法，那就去吧。谢谢，删除了注释！