.. _program_listing_file_src_sparsebase_io_mtx_reader.cc:

Program Listing for File mtx_reader.cc
======================================

|exhale_lsh| :ref:`Return to documentation for file <file_src_sparsebase_io_mtx_reader.cc>` (``src/sparsebase/io/mtx_reader.cc``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #include "sparsebase/io/mtx_reader.h"
   
   #include <sstream>
   #include <string>
   
   #include "sparsebase/config.h"
   
   namespace sparsebase::io {
   
   template <typename IDType, typename NNZType, typename ValueType>
   MTXReader<IDType, NNZType, ValueType>::MTXReader(std::string filename,
                                                    bool convert_to_zero_index)
       : filename_(filename), convert_to_zero_index_(convert_to_zero_index) {
     std::ifstream fin(filename_);
   
     if (fin.is_open()) {
       std::string header_line;
       std::getline(fin, header_line);
       // parse first line
       options_ = ParseHeader(header_line);
     } else {
       throw utils::ReaderException("Wrong matrix market file name\n");
     }
   }
   
   template <typename IDType, typename NNZType, typename ValueType>
   typename MTXReader<IDType, NNZType, ValueType>::MTXOptions
   MTXReader<IDType, NNZType, ValueType>::ParseHeader(
       std::string header_line) const {
     std::stringstream line_ss(header_line);
     MTXOptions options;
     std::string prefix, object, format, field, symmetry;
     line_ss >> prefix >> object >> format >> field >> symmetry;
     if (prefix != MMX_PREFIX)
       throw utils::ReaderException("Wrong prefix in a matrix market file");
     // parsing Object option
     if (object == "matrix") {
       options.object =
           MTXReader<IDType, NNZType, ValueType>::MTXObjectOptions::matrix;
     } else if (object == "vector") {
       options.object =
           MTXReader<IDType, NNZType, ValueType>::MTXObjectOptions::matrix;
       throw utils::ReaderException(
           "Matrix market reader does not currently support reading vectors.");
     } else {
       throw utils::ReaderException(
           "Illegal value for the 'object' option in matrix market header");
     }
     // parsing format option
     if (format == "array") {
       options.format =
           MTXReader<IDType, NNZType, ValueType>::MTXFormatOptions::array;
     } else if (format == "coordinate") {
       options.format =
           MTXReader<IDType, NNZType, ValueType>::MTXFormatOptions::coordinate;
     } else {
       throw utils::ReaderException(
           "Illegal value for the 'format' option in matrix market header");
     }
     // parsing field option
     if (field == "real") {
       options.field =
           MTXReader<IDType, NNZType, ValueType>::MTXFieldOptions::real;
       if constexpr (std::is_same<void, ValueType>::value)
         throw utils::ReaderException(
             "You are reading the values of the matrix market file into a void "
             "array");
     } else if (field == "double") {
       options.field =
           MTXReader<IDType, NNZType, ValueType>::MTXFieldOptions::double_field;
       if constexpr (std::is_same<void, ValueType>::value)
         throw utils::ReaderException(
             "You are reading the values of the matrix market file into a void "
             "array");
     } else if (field == "complex") {
       options.field =
           MTXReader<IDType, NNZType, ValueType>::MTXFieldOptions::complex;
       if constexpr (std::is_same<void, ValueType>::value)
         throw utils::ReaderException(
             "You are reading the values of the matrix market file into a void "
             "array");
     } else if (field == "integer") {
       options.field =
           MTXReader<IDType, NNZType, ValueType>::MTXFieldOptions::integer;
       if constexpr (std::is_same<void, ValueType>::value)
         throw utils::ReaderException(
             "You are reading the values of the matrix market file into a void "
             "array");
     } else if (field == "pattern") {
       options.field =
           MTXReader<IDType, NNZType, ValueType>::MTXFieldOptions::pattern;
     } else {
       throw utils::ReaderException(
           "Illegal value for the 'field' option in matrix market header");
     }
     // parsing symmetry
     if (symmetry == "general") {
       options.symmetry =
           MTXReader<IDType, NNZType, ValueType>::MTXSymmetryOptions::general;
     } else if (symmetry == "symmetric") {
       options.symmetry =
           MTXReader<IDType, NNZType, ValueType>::MTXSymmetryOptions::symmetric;
     } else if (symmetry == "skew-symmetric") {
       options.symmetry = MTXReader<IDType, NNZType,
                                    ValueType>::MTXSymmetryOptions::skew_symmetric;
     } else if (symmetry == "hermitian") {
       options.symmetry =
           MTXReader<IDType, NNZType, ValueType>::MTXSymmetryOptions::hermitian;
       throw utils::ReaderException(
           "Matrix market reader does not currently support hermitian symmetry.");
     } else {
       throw utils::ReaderException(
           "Illegal value for the 'symmetry' option in matrix market header");
     }
     return options;
   }
   
   template <typename IDType, typename NNZType, typename ValueType>
   template <bool weighted>
   format::COO<IDType, NNZType, ValueType>
       *MTXReader<IDType, NNZType, ValueType>::ReadArrayIntoCOO() const {
     std::ifstream fin(filename_);
     // Ignore headers and comments:
     while (fin.peek() == '%')
       fin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
     // Declare variables: (check the types here)
   
     format::DimensionType M, N;
   
     fin >> M >> N;
   
     format::DimensionType total_values = M * N;
     IDType *long_rows = new IDType[total_values];
     IDType *long_cols = new IDType[total_values];
     ValueType *long_vals = nullptr;
     if constexpr (weighted) long_vals = new ValueType[total_values];
     NNZType num_nnz = 0;
     for (format::DimensionType l = 0; l < total_values; l++) {
       ValueType w;
       fin >> w;
   
       if (w != 0) {
         long_cols[num_nnz] = l / N;
         long_rows[num_nnz] = l % N;
         if constexpr (weighted) long_vals[num_nnz] = w;
         num_nnz++;
       }
       // nnz_counter += w != 0;
     }
   
     IDType *row = new IDType[num_nnz];
     IDType *col = new IDType[num_nnz];
     std::copy(long_rows, long_rows + num_nnz, row);
     std::copy(long_cols, long_cols + num_nnz, col);
     ValueType *vals = nullptr;
     if constexpr (weighted) {
       vals = new ValueType[num_nnz];
       std::copy(long_vals, long_vals + num_nnz, vals);
     }
   
     return new format::COO<IDType, NNZType, ValueType>(N, M, num_nnz, row, col,
                                                        vals, format::kOwned);
   }
   template <typename IDType, typename NNZType, typename ValueType>
   format::COO<IDType, NNZType, ValueType>
       *MTXReader<IDType, NNZType, ValueType>::ReadCOO() const {
     bool weighted = options_.field != MTXFieldOptions::pattern;
     if (options_.format == MTXFormatOptions::array) {
       if (weighted) {
         if constexpr (!std::is_same_v<ValueType, void>) {
           return this->ReadArrayIntoCOO<true>();
         } else {
           throw utils::ReaderException(
               "Weight type for weighted graphs can not be void");
         }
       } else
         throw utils::ReaderException(
             "Matrix market files with array format cannot have the field "
             "'pattern' ");
     } else if (options_.format == MTXFormatOptions::coordinate) {
       if (weighted) {
         if (options_.symmetry == MTXSymmetryOptions::general)
           if (this->convert_to_zero_index_)
             return this->ReadCoordinateIntoCOO<
                 true, (int)MTXSymmetryOptions::general, true>();
           else
             return this->ReadCoordinateIntoCOO<
                 true, (int)MTXSymmetryOptions::general, false>();
         else if (options_.symmetry == MTXSymmetryOptions::symmetric)
           if (this->convert_to_zero_index_)
             return this->ReadCoordinateIntoCOO<
                 true, (int)MTXSymmetryOptions::symmetric, true>();
           else
             return this->ReadCoordinateIntoCOO<
                 true, (int)MTXSymmetryOptions::symmetric, false>();
         else if (options_.symmetry == MTXSymmetryOptions::skew_symmetric)
           if (this->convert_to_zero_index_)
             return this->ReadCoordinateIntoCOO<
                 true, (int)MTXSymmetryOptions::skew_symmetric, true>();
           else
             return this->ReadCoordinateIntoCOO<
                 true, (int)MTXSymmetryOptions::skew_symmetric, false>();
         else
           throw utils::ReaderException(
               "Can't read matrix market symmetry options besides general, "
               "symmetric, and skew_symmetric");
       } else {
         if (options_.symmetry == MTXSymmetryOptions::general)
           if (this->convert_to_zero_index_)
             return this->ReadCoordinateIntoCOO<
                 false, (int)MTXSymmetryOptions::general, true>();
           else
             return this->ReadCoordinateIntoCOO<
                 false, (int)MTXSymmetryOptions::general, false>();
         else if (options_.symmetry == MTXSymmetryOptions::symmetric)
           if (this->convert_to_zero_index_)
             return this->ReadCoordinateIntoCOO<
                 false, (int)MTXSymmetryOptions::symmetric, true>();
           else
             return this->ReadCoordinateIntoCOO<
                 false, (int)MTXSymmetryOptions::symmetric, false>();
         else if (options_.symmetry == MTXSymmetryOptions::skew_symmetric)
           if (this->convert_to_zero_index_)
             return this->ReadCoordinateIntoCOO<
                 false, (int)MTXSymmetryOptions::skew_symmetric, true>();
           else
             return this->ReadCoordinateIntoCOO<
                 false, (int)MTXSymmetryOptions::skew_symmetric, false>();
         else
           throw utils::ReaderException(
               "Can't read matrix market symmetry options besides general, "
               "symmetric, and skew_symmetric");
       }
     } else {
       throw utils::ReaderException(
           "Can't read matrix market formats besides array and coordinate");
     }
   }
   
   template <typename IDType, typename NNZType, typename ValueType>
   format::Array<ValueType>
       *MTXReader<IDType, NNZType, ValueType>::ReadCoordinateIntoArray() const {
     if constexpr (std::is_same_v<ValueType, void>)
       throw utils::ReaderException(
           "Cannot read a matrix market file into an Array with void ValueType");
     else {
       std::ifstream fin(filename_);
   
       // Ignore headers and comments:
       while (fin.peek() == '%')
         fin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
       // Declare variables: (check the types here)
   
       // check that it has 1 row/column
       format::DimensionType M, N, L;
   
       fin >> M >> N >> L;
       if (M != 1 && N != 1) {
         throw utils::ReaderException(
             "Trying to read a 2D matrix with multiple rows "
             "and multiple columns into dense array");
       }
       fin.close();
       auto coo = ReadCOO();
       auto n = coo->get_dimensions()[0];
       auto m = coo->get_dimensions()[1];
       auto coo_col = coo->get_col();
       auto coo_row = coo->get_row();
       auto coo_vals = coo->get_vals();
       auto num_nnz = coo->get_num_nnz();
       ValueType *vals = new ValueType[std::max<IDType>(n, m)]();
       IDType curr_row = 0;
       IDType curr_col = 0;
       for (IDType nnz = 0; nnz < num_nnz; nnz++) {
         vals[coo_col[nnz] + coo_row[nnz]] = coo_vals[nnz];
       }
       return new format::Array<ValueType>(std::max(n, m), vals,
                                           sparsebase::format::kOwned);
     }
   }
   
   template <typename IDType, typename NNZType, typename ValueType>
   template <bool weighted, int symm, bool conv_to_zero>
   format::COO<IDType, NNZType, ValueType>
       *MTXReader<IDType, NNZType, ValueType>::ReadCoordinateIntoCOO() const {
     // Open the file:
     std::ifstream fin(filename_);
   
     if (fin.is_open()) {
       // Declare variables: (check the types here)
       format::DimensionType M, N, L;
   
       // Ignore headers and comments:
       while (fin.peek() == '%')
         fin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
   
       fin >> M >> N >> L;
       ValueType *vals = nullptr;
       if constexpr (symm == (int)MTXSymmetryOptions::general) {
         IDType *row = new IDType[L];
         IDType *col = new IDType[L];
         if constexpr (weighted) {
           if constexpr (!std::is_same_v<void, ValueType>) {
             vals = new ValueType[L];
             for (NNZType l = 0; l < L; l++) {
               IDType m, n;
               ValueType w;
               fin >> m >> n >> w;
   
               if constexpr (conv_to_zero) {
                 n--;
                 m--;
               }
   
               row[l] = m;
               col[l] = n;
               vals[l] = w;
             }
   
             auto coo = new format::COO<IDType, NNZType, ValueType>(
                 M, N, L, row, col, vals, format::kOwned);
             return coo;
           } else {
             // TODO: Add an exception class for this
             throw utils::ReaderException(
                 "Weight type for weighted graphs can not be void");
           }
         } else {
           for (NNZType l = 0; l < L; l++) {
             IDType m, n;
             fin >> m >> n;
   
             if constexpr (conv_to_zero) {
               n--;
               m--;
             }
   
             row[l] = m;
             col[l] = n;
           }
   
           auto coo = new format::COO<IDType, NNZType, ValueType>(
               M, N, L, row, col, nullptr, format::kOwned);
           return coo;
         }
       } else if constexpr (symm == (int)MTXSymmetryOptions::symmetric ||
                            symm == (int)MTXSymmetryOptions::skew_symmetric) {
         IDType *row = new IDType[L * 2];
         IDType *col = new IDType[L * 2];
         NNZType actual_nnzs = 0;
         IDType m, n;
         if constexpr (weighted) {
           if constexpr (!std::is_same_v<void, ValueType>) {
             vals = new ValueType[L * 2];
           } else {
             throw utils::ReaderException(
                 "Weight type for weighted graphs can not be void");
           }
         }
         for (NNZType l = 0; l < L; l++) {
           fin >> m >> n;
   
           if constexpr (conv_to_zero) {
             n--;
             m--;
           }
           row[actual_nnzs] = m;
           col[actual_nnzs] = n;
           if constexpr (weighted && !std::is_same_v<void, ValueType>) {
             fin >> vals[actual_nnzs];
           }
           actual_nnzs++;
           bool check_diagonal;
           if constexpr (symm == (int)MTXSymmetryOptions::skew_symmetric)
             check_diagonal = false;
           else
             check_diagonal = true;
           if (check_diagonal && m != n) {
             row[actual_nnzs] = n;
             col[actual_nnzs] = m;
             if constexpr (weighted && !std::is_same_v<void, ValueType> &&
                           weighted)
               vals[actual_nnzs] = vals[actual_nnzs - 1];
             actual_nnzs++;
           }
         }
         IDType *actual_rows = row;
         IDType *actual_cols = col;
         ValueType *actual_vals = vals;
         if (symm == (int)MTXSymmetryOptions::symmetric && actual_nnzs != L * 2) {
           actual_rows = new IDType[actual_nnzs];
           actual_cols = new IDType[actual_nnzs];
           std::copy(row, row + actual_nnzs, actual_rows);
           std::copy(col, col + actual_nnzs, actual_cols);
           delete[] row;
           delete[] col;
           if constexpr (weighted && !std::is_same_v<void, ValueType>) {
             actual_vals = new ValueType[actual_nnzs];
             std::copy(vals, vals + actual_nnzs, actual_vals);
             delete[] vals;
           }
         }
         auto coo = new format::COO<IDType, NNZType, ValueType>(
             M, N, actual_nnzs, actual_rows, actual_cols, actual_vals,
             format::kOwned);
         return coo;
       } else {
         throw utils::ReaderException(
             "Reader only supports general, symmetric, and skew-symmetric "
             "symmetry options");
       }
     } else {
       throw utils::ReaderException("file does not exists!!");
     }
   }
   template <typename IDType, typename NNZType, typename ValueType>
   format::Array<ValueType>
       *MTXReader<IDType, NNZType, ValueType>::ReadArrayIntoArray() const {
     if constexpr (!std::is_same_v<void, ValueType>) {
       std::ifstream fin(filename_);
       // Ignore headers and comments:
       while (fin.peek() == '%')
         fin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
       // Declare variables: (check the types here)
   
       // check that it has 1 row/column
       format::DimensionType M, N;
   
       fin >> M >> N;
   
       if (M != 1 && N != 1) {
         throw utils::ReaderException(
             "Trying to read a 2D matrix with multiple rows "
             "and multiple columns into dense array");
       }
       format::DimensionType total_values = M * N;
       // T ODO
       // Currently num_nnz is defined all wrong. Once it's fixed add back
       // nnz_counter
       // NNZType nnz_counter = 0;
       ValueType *vals = new ValueType[total_values];
       for (format::DimensionType l = 0; l < total_values; l++) {
         ValueType w;
         fin >> w;
   
         vals[l] = w;
         // nnz_counter += w != 0;
       }
   
       auto array = new format::Array<ValueType>(/*nnz_counter*/ total_values,
                                                 vals, format::kOwned);
       return array;
   
     } else {
       throw utils::ReaderException(
           "Cannot read a matrix market file into an Array whose ValueType is "
           "void");
     }
   }
   
   template <typename IDType, typename NNZType, typename ValueType>
   format::Array<ValueType> *MTXReader<IDType, NNZType, ValueType>::ReadArray()
       const {
     // check object
     if constexpr (std::is_same_v<ValueType, void>) {
       throw utils::ReaderException(
           "Cannot read a matrix market file into an Array whose ValueType is "
           "void");
     } else {
       bool weighted = options_.field != MTXFieldOptions::pattern;
       if (!weighted) {
         throw utils::ReaderException(
             "Cannot read a matrix market file into an Array if it is in pattern "
             "format");
       }
       if (options_.format == MTXFormatOptions::coordinate) {
         if constexpr (!std::is_same_v<ValueType, void>) {
           return ReadCoordinateIntoArray();
         }
       } else if (options_.format == MTXFormatOptions::array) {
         if constexpr (!std::is_same_v<ValueType, void>) {
           return ReadArrayIntoArray();
         }
       } else {
         throw utils::ReaderException(
             "Wrong format value while reading matrix market file\n");
       }
     }
   }
   
   template <typename IDType, typename NNZType, typename ValueType>
   format::CSR<IDType, NNZType, ValueType>
       *MTXReader<IDType, NNZType, ValueType>::ReadCSR() const {
     auto coo = ReadCOO();
     converter::ConverterOrderTwo<IDType, NNZType, ValueType> converterObj;
     context::CPUContext cpu_context;
     return converterObj.template Convert<format::CSR<IDType, NNZType, ValueType>>(
         coo, &cpu_context);
   }
   
   template <typename IDType, typename NNZType, typename ValueType>
   MTXReader<IDType, NNZType, ValueType>::~MTXReader(){};
   #ifndef _HEADER_ONLY
   #include "init/mtx_reader.inc"
   #endif
   }  // namespace sparsebase::io