SparseMatrix.h

Go to the documentation of this file.

/*
        This file is part of the EnergyOptimizatorOfRoboticCells program.

        EnergyOptimizatorOfRoboticCells is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation, either version 3 of the License, or
        (at your option) any later version.

        EnergyOptimizatorOfRoboticCells is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
        GNU General Public License for more details.

        You should have received a copy of the GNU General Public License
        along with EnergyOptimizatorOfRoboticCells. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef HLIDAC_PES_SPARSE_MATRIX_H
#define HLIDAC_PES_SPARSE_MATRIX_H

#include <algorithm>
#include <cassert>
#include <iostream>
#include <set>
#include <vector>
#include <utility>
#include <stdint.h>

template <class T>
class SparseMatrix {
        public:
                SparseMatrix(T defaultValue = T()) : mDefaultValue(defaultValue) { }

                T get(const uint32_t& i, const uint32_t& j) const {
                        assert(i < mSparseMatrix.size());
                        for (const auto& rowElement : mSparseMatrix[i]) {
                                if (rowElement.first == j)
                                        return rowElement.second;
                        }

                        return mDefaultValue;
                }

                using Row = std::vector<std::pair<uint32_t, T> >;

                void addRow(Row& row)   {
                        assert(!row.empty() && checkColumn(row) && "Invalid matrix row!");
                        mSparseMatrix.push_back(std::move(row));
                }

                Row& operator[](const uint32_t& i) {
                        assert(i < mSparseMatrix.size() && "Row index is out of range!");
                        return mSparseMatrix[i];
                }

                const Row& operator[](const uint32_t& i) const {
                        assert(i < mSparseMatrix.size() && "Row index is out of range!");
                        return mSparseMatrix[i];
                }

                uint64_t numberOfRows() const { return mSparseMatrix.size(); }

                uint64_t numberOfColumns() const {
                        int64_t numberOfColumns = -1;
                        for (const auto& row : mSparseMatrix)   {
                                for (const auto& element : row)
                                        numberOfColumns = std::max(numberOfColumns, (int64_t) element.first);
                        }

                        return (numberOfColumns != -1) ? (uint64_t) numberOfColumns+1 : 0ul;
                }

                uint64_t numberOfElements() const {
                        uint64_t numberOfElements = 0;
                        for (const auto& row : mSparseMatrix)
                                numberOfElements += row.size();
                        return numberOfElements;
                }

                double densityOfMatrix() const {
                        return ((double) numberOfElements())/((double) numberOfRows()*numberOfColumns());
                }

                void clear() { mSparseMatrix.clear(); }

        private:

                bool checkColumn(const Row& row) const {
                        std::set<uint32_t> uniqueColumns;
                        for (const auto& el : row)      {
                                if (uniqueColumns.count(el.first) > 0)
                                        return false;
                                else
                                        uniqueColumns.insert(el.first);
                        }

                        return true;
                }

                T mDefaultValue;
                std::vector<Row> mSparseMatrix;
};

template <class T>
std::ostream& operator<<(std::ostream& out, const SparseMatrix<T>& m)   {
        out<<"A = ["<<std::endl;
        for (uint32_t r = 0; r < m.numberOfRows(); ++r) {
                out<<"\t";
                for (uint32_t c = 0; c < m.numberOfColumns(); ++c)
                        out<<" "<<m.get(r,c);

                if (r+1 < m.numberOfRows())
                        out<<";"<<std::endl;
                else
                        out<<std::endl;
        }
        out<<"];";

        return out;
}

#endif