I have a question about how the covert_to function works.

[QuasarJSPark]

Hello, I'm working on implementing the I/O of a data structure to use ginkgo. To convert from the internal structure of my simulator, I am implementing the gko::ConvertibleTo::convert_to function from COO to CSR data structure.

The problem is, depending on how the COO matrix is generated, we found that it does not convert to the CSR matrx data format.

Let's define the type as follows

using ValType = double;
using IdxType = int;

using CsrMtx = gko::matrix::Csr<ValType, IdxType>;
using CooMtx = gko::matrix::Coo<ValType, IdxType>;

using Valarray = gko::array<ValType>;
using Idxarray = gko::array<IdxType>;

Let's take data/A.mtx in ilu-preconditioned-solver example project as an example sparse matrix. If you read the file and then do the conversion, it is observed that it is converted normally.

const auto ompexec = gko::OmpExecutor::create();

auto COOA = gko::share(gko::read<CooMtx>(std::ifstream("../mtx_data/A.mtx"), ompexec));

auto ConvertMtx = gko::share(CsrMtx::create(ompexec));

COOA->convert_to(ConvertMtx);

If we proceed with the conversion as above, if we check ConvertMtx with the debugger, we can see that it is compressed normally with num_value=147, num_col=147, and num_row=20.

However, the internal data type is a COO matrix made up of std::vectors, so I assumed that was the case and converted the matrix to three std::vectors and printed them out.

    std::vector<IdxType> Arow, Acol;
    std::vector<ValType> Aval;
    Arow.clear(); Acol.clear(), Aval.clear();
    auto NNZ = COOA->get_num_stored_elements();
    auto Arowidx = COOA->get_const_row_idxs();
    auto Acolidx = COOA->get_const_col_idxs();
    auto Avalue = COOA->get_const_values();
    for (auto i = 0; i < NNZ; i++) {
        Arow.push_back(Arowidx[i]);
        Acol.push_back(Acolidx[i]);
        Aval.push_back(Avalue[i]);
    }

    auto coomtx =  gko::share(CooMtx::create(ompexec, gko::dim<2>(Arow.size(), Acol.size()),
                                     Valarray::view(ompexec, Aval.size(), Aval.data()),
                                     Idxarray::view(ompexec, Acol.size(), Acol.data()),
                                     Idxarray::view(ompexec, Arow.size(), Arow.data())
                                     )
    );

I put the rows, cols, and values of A.mtx into three std::vectors as shown above, and then used gko::array::view to recreate the COO Matrix, coomtx.

auto convermtx = gko::share(CsrMtx::create(ompexec));

coomtx->convert_to(convermtx);

However, when we convert this COO Matrix to CSR, it is converted to num_value=147, num_col=147, and num_row=148 without compressing. In the case of value, we can see that it is passed normally.

As in the experiment above, we observed that the success of the conversion depends on how the matrix is created. Could there be something wrong with the implementation? What am I missing that is preventing it from working properly?

I used Ginkgo 1.7.0 and compiled it with GCC 7.1.0.

[MarcelKoch]

The matrix dimensions you are setting here:

    auto coomtx =  gko::share(CooMtx::create(ompexec, gko::dim<2>(Arow.size(), Acol.size()),
                                     Valarray::view(ompexec, Aval.size(), Aval.data()),
                                     Idxarray::view(ompexec, Acol.size(), Acol.data()),
                                     Idxarray::view(ompexec, Arow.size(), Arow.data())
                                     )
    );

are not the correct ones. Instead of gko::dim<2>(Arow.size(), Acol.size()) it should be COOA->get_size(). Right now coomtx has as many rows as it has non-zero elements, which leads to the wrong Csr matrix.

[QuasarJSPark]

I edited the code as you suggested and the conversion is working fine. Thanks for your help!