sync

Author: MarcG-TUE

include/maxplus/algebra/mpmatrix.h

@@ -81,36 +81,36 @@ class Vector {
 
     Vector &operator=(const Vector &);
 
-    MPTime norm();
+    [[nodiscard]] MPTime norm() const;
 
     void negate();
     MPTime normalize();
 
-    [[nodiscard]] Vector *add(MPTime increase) const;
+    [[nodiscard]] Vector add(MPTime increase) const;
 
-    void add(MPTime increase, Vector *result) const;
+    void add(MPTime increase, Vector& result) const;
 
-    void maximum(const Vector *matB, Vector *result) const;
+    void maximum(const Vector& vecB, Vector& result) const;
 
-    Vector *add(const Vector *vecB) const;
+    [[nodiscard]] Vector add(const Vector& vecB) const;
 
-    void add(const Vector *vecB, Vector *res) const;
+    void add(const Vector& vecB, Vector& res) const;
 
     Vector &operator+=(MPTime increase) {
-        this->add(increase, this);
+        this->add(increase, *this);
         return *this;
     }
 
     Vector &operator-=(MPTime decrease) {
         assert(!decrease.isMinusInfinity());
-        this->add(-decrease, this);
+        this->add(-decrease, *this);
         return *this;
     }
 
-    bool compare(const Vector &v);
+    [[nodiscard]] bool compare(const Vector &v) const;
 
-    Vector &incrementalMaximum(const Vector *vec) {
-        this->maximum(vec, this);
+    Vector &incrementalMaximum(const Vector& vec) {
+        this->maximum(vec, *this);
         return *this;
     }
 
@@ -145,10 +145,13 @@ class Matrix {
      */
     Matrix(unsigned int nr_rows, unsigned int nr_cols, MatrixFill fill = MatrixFill::MinusInfinity);
 
-    Matrix(unsigned int nrows, unsigned int nr_cols, unsigned int nr_el);
+    Matrix(unsigned int nr_rows, unsigned int nr_cols, unsigned int nr_el);
 
     Matrix(Matrix &&) = default;
     Matrix &operator=(Matrix &&) = default;
+    Matrix(const Matrix &)=default;
+
+    Matrix &operator=(const Matrix &);
 
     virtual ~Matrix();
 
@@ -167,16 +170,16 @@ class Matrix {
 
     void pasteRowVector(unsigned int top_row, unsigned int left_column, const Vector *pastedVector);
 
-    [[nodiscard]] virtual Matrix *createCopy() const;
+    // [[nodiscard]] virtual Matrix *createCopy() const;
 
-    [[nodiscard]] Matrix *getTransposedCopy() const;
+    [[nodiscard]] Matrix transpose() const;
 
-    [[nodiscard]] virtual Matrix *getSubMatrix(const std::list<unsigned int> &rowIndices,
+    [[nodiscard]] virtual Matrix getSubMatrix(const std::list<unsigned int> &rowIndices,
                                                const std::list<unsigned int> &colIndices) const;
 
-    [[nodiscard]] Matrix *getSubMatrix(const std::list<unsigned int> &indices) const;
+    [[nodiscard]] Matrix getSubMatrix(const std::list<unsigned int> &indices) const;
 
-    [[nodiscard]] Matrix *getSubMatrixNonSquare(const std::list<unsigned int> &indices) const;
+    [[nodiscard]] Matrix getSubMatrixNonSquare(const std::list<unsigned int> &indices) const;
 
     /**
      * Increases the number of rows of the matrix by n and fills the new elements with -\infty.
@@ -188,21 +191,21 @@ class Matrix {
     void toLaTeXString(CString &outString, CDouble scale = 1.0) const;
 
     // Algebraic operations.
-    [[nodiscard]] Matrix *add(MPTime increase) const;
+    [[nodiscard]] Matrix add(MPTime increase) const;
 
-    void add(MPTime increase, Matrix *result) const;
+    void add(MPTime increase, Matrix& result) const;
 
-    [[nodiscard]] Matrix *mp_sub(const Matrix &m) const;
+    [[nodiscard]] Matrix mp_sub(const Matrix &m) const;
 
-    [[nodiscard]] Matrix *mp_maximum(const Matrix &m) const;
+    [[nodiscard]] Matrix mp_maximum(const Matrix &m) const;
 
-    void maximum(const Matrix *matB, Matrix *result) const;
+    void maximum(const Matrix& matB, Matrix& result) const;
 
-    [[nodiscard]] Vector *mp_multiply(const Vector &v) const;
+    [[nodiscard]] Vector mp_multiply(const Vector &v) const;
 
-    [[nodiscard]] Matrix *mp_multiply(const Matrix &m) const;
+    [[nodiscard]] Matrix mp_multiply(const Matrix &m) const;
 
-    [[nodiscard]] Matrix *mp_power(unsigned int p) const;
+    [[nodiscard]] Matrix mp_power(unsigned int p) const;
 
     [[nodiscard]] CDouble mp_eigenvalue() const;
 
@@ -213,19 +216,18 @@ class Matrix {
     [[nodiscard]] EigenvectorList mpEigenvectors() const;
 
     Matrix &operator+=(MPTime increase) {
-        this->add(increase, this);
+        this->add(increase, *this);
         return *this;
     }
 
     Matrix &operator-=(MPTime decrease) {
         assert(!decrease.isMinusInfinity());
-        this->add(-decrease, this);
+        this->add(-decrease, *this);
         return *this;
     }
 
-    Matrix &incrementalMaximum(const Matrix *matrix) {
-        this->maximum(matrix, this);
-        return *this;
+    void incrementalMaximum(const Matrix& matrix) {
+        this->maximum(matrix, *this);
     }
 
     bool operator==(const Matrix &other);
@@ -237,26 +239,21 @@ class Matrix {
     [[nodiscard]] MPTime largestFiniteElement() const;
     [[nodiscard]] MPTime minimalFiniteElement() const;
 
-    [[nodiscard]] Matrix *plusClosureMatrix(MPTime posCycleThreshold = MP_EPSILON) const;
+    [[nodiscard]] Matrix plusClosureMatrix(MPTime posCycleThreshold = MP_EPSILON) const;
 
-    [[nodiscard]] Matrix *starClosureMatrix(MPTime posCycleThreshold = MP_EPSILON) const;
+    [[nodiscard]] Matrix starClosureMatrix(MPTime posCycleThreshold = MP_EPSILON) const;
 
-    [[nodiscard]] Matrix *allPairLongestPathMatrix(MPTime posCycleThreshold,
+    [[nodiscard]] Matrix allPairLongestPathMatrix(MPTime posCycleThreshold,
                                                    bool implyZeroSelfEdges) const;
     bool
     allPairLongestPathMatrix(MPTime posCycleThreshold, bool implyZeroSelfEdges, Matrix &res) const;
 
     [[nodiscard]] MCMgraph mpMatrixToPrecedenceGraph() const;
 
-    // factory methods
-    [[nodiscard]] virtual Matrix *makeMatrix(unsigned int nr_rows, unsigned int nr_cols) const;
+    // // factory methods
+    // [[nodiscard]] virtual Matrix *makeMatrix(unsigned int nr_rows, unsigned int nr_cols) const;
 
 private:
-    // Implicit copying is not allowed
-    //  => Intentionally private and not implemented
-    Matrix(const Matrix &);
-
-    Matrix &operator=(const Matrix &);
 
     void init(MatrixFill fill);
     void init();
@@ -268,44 +265,6 @@ class Matrix {
     unsigned int szCols;
 };
 
-class ExtendedMatrix : public Matrix {
-public:
-    ExtendedMatrix(unsigned int nrows, unsigned int nr_cols) : Matrix(nrows, nr_cols) {
-        unsigned int nr_els = this->getRows() * this->getCols();
-        this->bufferSets.resize(nr_els);
-    }
-
-    // Creates a matrix with reserved memory for nr_el expected entities
-    ExtendedMatrix(unsigned int nrows, unsigned int nr_cols, unsigned int nr_el) :
-        Matrix(nrows, nr_cols, nr_el) {
-        this->bufferSets.reserve(nr_el);
-    }
-    explicit ExtendedMatrix(unsigned int N) : Matrix(N) {}
-
-    [[nodiscard]] Matrix *createCopy() const override {
-        Matrix *newMatrix = Matrix::createCopy();
-        auto *newExtendedMatrix = dynamic_cast<ExtendedMatrix *>(newMatrix);
-
-        unsigned int nr_els = this->getRows() * this->getCols();
-        for (unsigned int pos = 0; pos < nr_els; pos++) {
-            newExtendedMatrix->bufferSets[pos] = this->bufferSets[pos];
-        }
-
-        return newExtendedMatrix;
-    }
-
-    void put(unsigned int row, unsigned int column, MPTime value, std::unordered_set<int> &);
-    [[nodiscard]] Matrix *getSubMatrix(const std::list<unsigned int> &rowIndices,
-                                       const std::list<unsigned int> &colIndices) const override;
-
-    // factory methods
-    [[nodiscard]] Matrix *makeMatrix(unsigned int nr_rows, unsigned int nr_cols) const override;
-
-    [[nodiscard]] std::unordered_set<int> getBufferSet(unsigned int row, unsigned int column) const;
-
-private:
-    std::vector<std::unordered_set<int>> bufferSets;
-};
 
 /****************************************************
  * VectorList: usually represents a set of eigenvectors

include/maxplus/algebra/mpsparsematrix.h

@@ -101,7 +101,7 @@ class SparseVector {
 
     [[nodiscard]] SparseVector add(MPTime increase) const;
 
-    [[nodiscard]] SparseVector maximum(const SparseVector &matB) const;
+    [[nodiscard]] SparseVector maximum(const SparseVector &vecB) const;
 
     [[nodiscard]] SparseVector add(const SparseVector &vecB) const;
 
@@ -184,7 +184,7 @@ class SparseMatrix {
     SparseMatrix maximum(const SparseMatrix &M);
 
     SparseMatrix multiply(const SparseMatrix &M);
-    SparseVector multiply(const SparseVector &M);
+    SparseVector multiply(const SparseVector &v);
 
     void compress();
 
@@ -210,9 +210,9 @@ class SparseMatrix {
     std::vector<std::pair<unsigned int, SparseVector>> table;
     std::pair<unsigned int, unsigned int> find(unsigned int col);
     void doTranspose();
-    SparseMatrix combine(const SparseMatrix &vecB, MPTime f(MPTime a, MPTime b));
-    Matrix *reduceRows();
-    std::pair<Matrix *, Sizes> reduceRowsAndColumns();
+    SparseMatrix combine(const SparseMatrix &M, MPTime f(MPTime a, MPTime b));
+    Matrix reduceRows();
+    std::pair<Matrix, Sizes> reduceRowsAndColumns();
     static SparseMatrix expand(const Matrix &M, const Sizes &rszs, const Sizes &cszs);
     [[nodiscard]] Sizes sizes() const;
 };

include/maxplus/base/analysis/mcm/mcm.h

@@ -55,7 +55,7 @@ namespace Graphs {
  * algorithm.
  */
 CDouble maximumCycleMeanKarp(const MCMgraph& g);
-CDouble maximumCycleMeanKarpDouble(const MCMgraph& g, MCMnode **criticalNode = nullptr);
+CDouble maximumCycleMeanKarpDouble(const MCMgraph& g, const MCMnode **criticalNode = nullptr);
 
 /**
  * mcmGetAdjacentActors ()