refactoring smart pointers

Author: MarcG-TUE

.vscode/settings.json

@@ -44,7 +44,6 @@
 #include "maxplus/base/analysis/mcm/mcmgraph.h"
 #include "mptype.h"
 #include <memory>
-#include <unordered_set>
 #include <vector>
 
 namespace MaxPlus {
@@ -67,11 +66,11 @@ class Vector {
     Vector(Vector &&) = default;
     Vector &operator=(Vector &&) = delete;
 
-    [[nodiscard]] inline unsigned int getSize() const {
+    [[nodiscard]] unsigned int getSize() const {
         return static_cast<unsigned int>(this->table.size());
     }
 
-    [[nodiscard]] inline MPTime get(unsigned int row) const { return this->table[row]; }
+    [[nodiscard]] MPTime get(unsigned int row) const { return this->table[row]; }
 
     void put(unsigned int row, MPTime value);
 
@@ -127,7 +126,7 @@ class Vector {
     std::vector<MPTime> table;
 };
 
-enum class MatrixFill { MinusInfinity, Zero, Identity };
+enum class MatrixFill { MinusInfinity, Zero, Identity }; // NOLINT(*enum-size)
 
 class Matrix {
 public:
@@ -155,9 +154,9 @@ class Matrix {
 
     virtual ~Matrix();
 
-    [[nodiscard]] inline unsigned int getRows() const { return this->szRows; }
+    [[nodiscard]] unsigned int getRows() const { return this->szRows; }
 
-    [[nodiscard]] inline unsigned int getCols() const { return this->szCols; }
+    [[nodiscard]] unsigned int getCols() const { return this->szCols; }
 
     [[nodiscard]] unsigned int getSize() const;
 
@@ -170,30 +169,30 @@ class Matrix {
 
     void pasteRowVector(unsigned int top_row, unsigned int left_column, const Vector *pastedVector);
 
-    [[nodiscard]] virtual std::shared_ptr<Matrix> createCopyPtr() const;
+    [[nodiscard]] virtual std::unique_ptr<Matrix> createCopyPtr() const;
     [[nodiscard]] virtual Matrix createCopy() const;
 
-    [[nodiscard]] virtual std::shared_ptr<Matrix> getTransposedCopy() const;
+    [[nodiscard]] virtual std::unique_ptr<Matrix> getTransposedCopy() const;
 
     [[nodiscard]] Matrix transpose() const;
 
     [[nodiscard]] virtual Matrix getSubMatrix(const std::list<unsigned int> &rowIndices,
                                               const std::list<unsigned int> &colIndices) const;
 
-    [[nodiscard]] virtual std::shared_ptr<Matrix>
+    [[nodiscard]] virtual std::unique_ptr<Matrix>
     getSubMatrixPtr(const std::list<unsigned int> &rowIndices,
                     const std::list<unsigned int> &colIndices) const;
 
     [[nodiscard]] Matrix getSubMatrix(const std::list<unsigned int> &indices) const;
 
-    [[nodiscard]] virtual std::shared_ptr<Matrix>
+    [[nodiscard]] virtual std::unique_ptr<Matrix>
     getSubMatrixPtr(const std::list<unsigned int> &indices) const;
 
     [[nodiscard]] Matrix getSubMatrixNonSquare(const std::list<unsigned int> &indices) const;
 
     [[nodiscard]] Matrix getSubMatrixNonSquareRows(const std::list<unsigned int> &rowIndices) const;
 
-    [[nodiscard]] virtual std::shared_ptr<Matrix>
+    [[nodiscard]] virtual std::unique_ptr<Matrix>
     getSubMatrixNonSquareRowsPtr(const std::list<unsigned int> &rowIndices) const;
 
     /**
@@ -316,7 +315,7 @@ class VectorList : private std::vector<std::unique_ptr<Vector>> {
     //  similar - differs by a constant within a threshold
 
 private:
-    const unsigned int oneVectorSize;
+    unsigned int oneVectorSize;
 };
 
 inline VectorList::VectorList(unsigned int oneVectorSizeInit) : oneVectorSize(oneVectorSizeInit) {
@@ -335,7 +334,7 @@ inline unsigned int VectorList::getSize() const { return static_cast<unsigned in
 
 inline void VectorList::grow() {
     auto last = static_cast<unsigned int>(this->size());
-    this->resize(static_cast<size_t>(last + 1));
+    this->resize(last + 1);
     this->insert(this->begin() + last, std::make_unique<Vector>(oneVectorSize, MP_MINUS_INFINITY));
 }
 

include/maxplus/algebra/mpmatrix.h

@@ -44,9 +44,7 @@
 
 #include "maxplus/base/basic_types.h"
 #include <memory>
-#include <utility>
 
-using namespace MaxPlus;
 
 namespace MaxPlus::Graphs {
 class MCMnode;
@@ -207,7 +205,7 @@ class MCMgraph {
     // of nodes and for some edge (w1, d1) there exists a different edge
     // (w2, d2) such that d2<=d1 and w2>=w1, then (w2, d2) is removed
     // Note this algorithm does currently not distinguish visible and invisible edges!
-    std::shared_ptr<MCMgraph> pruneEdges();
+    std::unique_ptr<MCMgraph> pruneEdges();
 
     [[nodiscard]] CDouble calculateMaximumCycleMeanKarp();
     [[nodiscard]] CDouble
@@ -216,8 +214,8 @@ class MCMgraph {
     [[nodiscard]] CDouble calculateMaximumCycleRatioAndCriticalCycleYoungTarjanOrlin(
             std::vector<const MCMedge *> *cycle = nullptr);
 
-    [[nodiscard]] std::shared_ptr<MCMgraph> normalize(CDouble mu) const;
-    [[nodiscard]] std::shared_ptr<MCMgraph> normalize(const std::map<CId, CDouble> &mu) const;
+    [[nodiscard]] std::unique_ptr<MCMgraph> normalize(CDouble mu) const;
+    [[nodiscard]] std::unique_ptr<MCMgraph> normalize(const std::map<CId, CDouble> &mu) const;
     [[nodiscard]] std::map<CId, CDouble> longestPaths(CId rootNodeId) const;
     [[nodiscard]] std::map<CId, CDouble> normalizedLongestPaths(CId rootNodeId, CDouble mu) const;
     [[nodiscard]] std::map<CId, CDouble>
@@ -231,7 +229,7 @@ class MCMgraph {
     MCMedges edges;
 };
 
-using MCMgraphs = std::list<std::shared_ptr<MCMgraph>>;
+using MCMgraphs = std::list<std::unique_ptr<MCMgraph>>;
 using MCMgraphsIter = MCMgraphs::iterator;
 
 /**

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

@@ -61,8 +61,8 @@ namespace MaxPlus::Graphs {
  * to a sparse matrix input for Howard's algorithm.
  */
 void convertMCMgraphToMatrix(MCMgraph &g,
-                             std::shared_ptr<std::vector<int>> *ij,
-                             std::shared_ptr<std::vector<CDouble>> *A);
+                             std::unique_ptr<std::vector<int>> *ij,
+                             std::unique_ptr<std::vector<CDouble>> *A);
 
 /**
  * Howard ()
@@ -88,17 +88,17 @@ void Howard(const std::vector<int> &ij,
             const std::vector<CDouble> &A,
             int nr_nodes,
             int nr_arcs,
-            std::shared_ptr<std::vector<CDouble>> *chi,
-            std::shared_ptr<std::vector<CDouble>> *v,
-            std::shared_ptr<std::vector<int>>(*policy),
+            std::unique_ptr<std::vector<CDouble>> *chi,
+            std::unique_ptr<std::vector<CDouble>> *v,
+            std::unique_ptr<std::vector<int>> *policy,
             int *nr_iterations,
             int *nr_components);
 
 /**
  * maximumCycleMeanHoward ()
  * Howard Policy Iteration Algorithm for Max Plus Matrices.
  *
- * INPUT MCMgraph which must have outoing edges from every node
+ * INPUT MCMgraph which must have outgoing edges from every node
  *
  * OUTPUT:
  *      maximum cycle mean

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

@@ -0,0 +1,78 @@
+/*
+ *  Eindhoven University of Technology
+ *  Eindhoven, The Netherlands
+ *  Dept. of Electrical Engineering
+ *  Electronics Systems Group
+ *  Model Based Design Lab (https://computationalmodeling.info/)
+ *
+ *  Name            :   mcmkarp.cc
+ *
+ *  Author          :   Sander Stuijk (sander@ics.ele.tue.nl)
+ *
+ *  Date            :   November 8, 2005
+ *
+ *  Function        :   Compute the MCM for an HSDF graph using Karp's
+ *                      algorithm.
+ *
+ *  History         :
+ *      08-11-05    :   Initial version.
+ *
+ *
+ *  Copyright 2023 Eindhoven University of Technology
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the “Software”),
+ *  to deal in the Software without restriction, including without limitation
+ *  the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ *  and/or sell copies of the Software, and to permit persons to whom the
+ *  Software is furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included
+ *  in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+#ifndef MAXPLUS_BASE_ANALYSIS_MCM_MCMKARP_H_INCLUDED
+#define MAXPLUS_BASE_ANALYSIS_MCM_MCMKARP_H_INCLUDED
+
+#include "maxplus/base/analysis/mcm/mcmgraph.h"
+
+namespace MaxPlus::Graphs {
+
+/**
+ * maximumCycleMeanKarp()
+ *
+ * INPUT MCMgraph
+ *
+ * OUTPUT:
+ *      maximum cycle mean
+ */
+CDouble maximumCycleMeanKarp(MCMgraph &mcmGraph);
+
+CDouble maximumCycleMeanKarpGeneral(MCMgraph &g);
+
+/**
+ * maximumCycleMeanKarpDouble ()
+ * The function computes the maximum cycle mean of an MCMgGraph using Karp's
+ * algorithm.
+ * Note that the following assumptions are made about the MCMgraph
+ * 1. it is assumed that all nodes in the graph are 'visible'
+ * 2. it is assumed that the node have id's ranging from 0 up to the number of nodes.
+ *
+ * A critical node is only returned if criticalNode is not nullptr.
+ */
+
+CDouble maximumCycleMeanKarpDouble(MCMgraph &mcmGraph, const MCMnode **criticalNode = nullptr);
+
+CDouble maximumCycleMeanKarpDoubleGeneral(MCMgraph &g, const MCMnode **criticalNode = nullptr);
+
+} // namespace MaxPlus::Graphs
+
+#endif

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

@@ -50,7 +50,6 @@
 
 #include "maxplus/base/analysis/mcm/mcmgraph.h"
 #include <cstdint>
-#include <memory>
 #include <vector>
 
 namespace MaxPlus::Graphs {