sync

Author: MarcG-TUE

include/maxplus/algebra/mpmatrix.h

@@ -43,9 +43,11 @@
 
 #include "base/analysis/mcm/mcmgraph.h"
 #include "mptype.h"
+#include <memory>
 #include <unordered_set>
 #include <vector>
 
+
 class CString;
 
 namespace MaxPlus {
@@ -311,13 +313,18 @@ class ExtendedMatrix : public Matrix {
  * More efficient than vector<MaxPlus::Vector>
  ****************************************************/
 
-class VectorList : private std::vector<Vector *> {
+class VectorList : private std::vector<std::unique_ptr<Vector>> {
 public:
     explicit VectorList(unsigned int oneVectorSizeInit);
-    ~VectorList();
+    ~VectorList() = default;
 
     VectorList(VectorList &&) = default;
     VectorList &operator=(VectorList &&) = delete;
+    
+    // Implicit copying is not allowed
+    //  => Intentionally private and not implemented
+    VectorList(const VectorList &)=delete;
+    VectorList &operator=(const VectorList &)=delete;
 
     [[nodiscard]] const Vector &vectorRefAt(unsigned int n) const; // vector at index 'n'
     Vector &vectorRefAt(unsigned int n);
@@ -336,24 +343,13 @@ class VectorList : private std::vector<Vector *> {
     //  similar - differs by a constant within a threshold
 
 private:
-    // Implicit copying is not allowed
-    //  => Intentionally private and not implemented
-    VectorList(const VectorList &);
-    VectorList &operator=(const VectorList &);
-
     const unsigned int oneVectorSize;
 };
 
 inline VectorList::VectorList(unsigned int oneVectorSizeInit) : oneVectorSize(oneVectorSizeInit) {
     assert(oneVectorSize > 0);
 }
 
-inline VectorList::~VectorList() {
-    for (unsigned int pos = 0; pos < size(); pos++) {
-        delete this->at(pos);
-    }
-}
-
 inline const Vector &VectorList::vectorRefAt(unsigned int n) const { return *this->at(n); }
 
 inline Vector &VectorList::vectorRefAt(unsigned int n) { return *this->at(n); }
@@ -363,13 +359,13 @@ inline const Vector &VectorList::lastVectorRef() const { return *this->at(this->
 inline Vector &VectorList::lastVectorRef() { return *this->at(this->size() - 1); }
 
 inline unsigned int VectorList::getSize() const {
-    return static_cast<unsigned int>(vector<Vector *>::size());
+    return static_cast<unsigned int>(this->size());
 }
 
 inline void VectorList::grow() {
     auto last = static_cast<unsigned int>(this->size());
     this->resize(last + 1);
-    this->at(last) = new Vector(oneVectorSize, MP_MINUSINFINITY);
+    this->insert(this->begin()+last, std::make_unique<Vector>(oneVectorSize, MP_MINUSINFINITY));
 }
 
 } // namespace MaxPlus

include/maxplus/algebra/mptype.h

@@ -87,7 +87,7 @@ using MPDelay = MPTime;
 // MP_MAX()
 //==============================
 
-inline MPTime MP_MAX(MPTime a, MPTime b) { return (((CDouble)a) > ((CDouble)b)) ? (a) : (b); }
+inline MPTime MP_MAX(MPTime a, MPTime b) { return (static_cast<CDouble>(a)) > (static_cast<CDouble>(b)) ? (a) : (b); }
 
 inline MPTime MP_MAX(CDouble a, MPTime b) { return MP_MAX(MPTime(a), b); }
 
@@ -99,7 +99,7 @@ inline CDouble MP_MAX(CDouble a, CDouble b) { return CDouble(MP_MAX(MPTime(a), M
 // MP_MIN()
 //==============================
 
-inline MPTime MP_MIN(MPTime a, MPTime b) { return (((CDouble)a) < ((CDouble)b)) ? (a) : (b); }
+inline MPTime MP_MIN(MPTime a, MPTime b) { return (static_cast<CDouble>(a)) < (static_cast<CDouble>(b)) ? (a) : (b); }
 
 inline MPTime MP_MIN(CDouble a, MPTime b) { return MP_MIN(MPTime(a), b); }
 
@@ -168,9 +168,9 @@ inline MPTime operator*(MPTime a, MPTime b) {
     return MPTime(static_cast<CDouble>(a) * static_cast<CDouble>(b));
 }
 
-inline const MPTime operator*(CDouble a, MPTime b) { return MPTime(a) * MPTime(b); }
+inline MPTime operator*(CDouble a, MPTime b) { return MPTime(a) * MPTime(b); }
 
-inline const MPTime operator*(MPTime a, CDouble b) { return MPTime(a) * MPTime(b); }
+inline MPTime operator*(MPTime a, CDouble b) { return MPTime(a) * MPTime(b); }
 
 inline MPTime &MPTime::operator+=(MPTime a) {
     *this = *this + a;
@@ -179,7 +179,7 @@ inline MPTime &MPTime::operator+=(MPTime a) {
 
 inline MPTime &MPTime::operator-=(MPTime a) {
     assert(!a.isMinusInfinity());
-    *this = *this + MPTime(CDouble(-a));
+    *this = *this + (-a);
     return *this;
 }
 

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

@@ -54,8 +54,8 @@ namespace Graphs {
  * The function computes the maximum cycle mean of an MCMgraph using Karp's
  * algorithm.
  */
-CDouble maximumCycleMeanKarp(MCMgraph *g);
-CDouble maximumCycleMeanKarpDouble(MCMgraph *g, MCMnode **criticalNode = NULL);
+CDouble maximumCycleMeanKarp(const MCMgraph& g);
+CDouble maximumCycleMeanKarpDouble(const MCMgraph& g, const MCMnode *criticalNode = nullptr);
 
 /**
  * mcmGetAdjacentActors ()

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

@@ -43,6 +43,8 @@
 #define BASE_ANALYSIS_MCM_MCMGRAPH_H_INCLUDED
 
 #include "base/basic_types.h"
+#include <memory>
+#include <utility>
 
 namespace Graphs {
 class MCMnode;
@@ -53,15 +55,15 @@ class MCMedge {
     MCMedge(CId eId, bool eVisible);
     CId id;
     bool visible;
-    MCMnode *src;
-    MCMnode *dst;
+    std::shared_ptr<MCMnode> src;
+    std::shared_ptr<MCMnode> dst;
     CDouble w;
     CDouble d;
 };
 
-typedef list<MCMedge *> MCMedges;
-typedef MCMedges::iterator MCMedgesIter;
-typedef MCMedges::const_iterator MCMedgesCIter;
+using MCMedges = list<std::shared_ptr<MCMedge>>;
+using MCMedgesIter = MCMedges::iterator;
+using MCMedgesCIter = MCMedges::const_iterator;
 
 class MCMnode {
 public:
@@ -74,12 +76,12 @@ class MCMnode {
 };
 
 struct MCMNodeLess {
-    bool operator()(MCMnode *const &lhs, MCMnode *const &rhs) const { return lhs->id < rhs->id; };
+    bool operator()(std::shared_ptr<MCMnode> const &lhs, std::shared_ptr<MCMnode> const &rhs) const { return lhs->id < rhs->id; };
 };
 
-typedef list<MCMnode *> MCMnodes;
-typedef MCMnodes::iterator MCMnodesIter;
-typedef MCMnodes::const_iterator MCMnodesCIter;
+using MCMnodes = list<std::shared_ptr<MCMnode>>;
+using MCMnodesIter = MCMnodes::iterator;
+using MCMnodesCIter = MCMnodes::const_iterator;
 
 class MCMgraph {
 public:
@@ -92,60 +94,69 @@ class MCMgraph {
     // Copy Constructor
     MCMgraph(const MCMgraph &g);
 
-    const MCMnodes &getNodes() { return nodes; };
+    const MCMnodes &getNodes() const { return nodes; };
 
-    uint nrVisibleNodes() {
+    uint nrVisibleNodes() const {
         uint nrNodes = 0;
-        for (MCMnodesIter iter = nodes.begin(); iter != nodes.end(); iter++)
-            if ((*iter)->visible)
+        for (auto &node : nodes) {
+            if (node->visible) {
                 nrNodes++;
+            }
+        }
         return nrNodes;
     };
-    MCMnode *getNode(CId id) {
-        for (MCMnodes::iterator i = nodes.begin(); i != nodes.end(); i++)
-            if ((*i)->id == id)
-                return (*i);
-        return NULL;
+    std::shared_ptr<MCMnode> getNode(CId id) {
+        for (auto &node : nodes) {
+            if (node->id == id) {
+                return node;
+            }
+        }
+        return nullptr;
     };
 
-    const MCMedges &getEdges() { return edges; };
+    const MCMedges &getEdges() const { return edges; };
 
-    MCMedge *getEdge(CId id) {
-        for (MCMedges::iterator i = edges.begin(); i != edges.end(); i++)
-            if ((*i)->id == id)
-                return (*i);
-        return NULL;
+    std::shared_ptr<MCMedge> getEdge(CId id) {
+        for (auto &edge : edges) {
+            if (edge->id == id) {
+                return edge;
+            }
+        }
+        return nullptr;
     };
 
-    MCMedge *getEdge(CId srcId, CId dstId) {
-        for (MCMedges::iterator i = edges.begin(); i != edges.end(); i++)
-            if ((*i)->src->id == srcId) {
-                if ((*i)->dst->id == dstId) {
-                    return (*i);
+    std::shared_ptr<MCMedge> getEdge(CId srcId, CId dstId) {
+        for (auto &edge : edges) {
+            if (edge->src->id == srcId) {
+                if (edge->dst->id == dstId) {
+                    return edge;
                 }
             }
-        return NULL;
+        }
+        return nullptr;
     };
 
-    uint nrVisibleEdges() {
+    [[nodiscard]] uint nrVisibleEdges() const {
         uint nrEdges = 0;
-        for (MCMedgesIter iter = edges.begin(); iter != edges.end(); iter++)
-            if ((*iter)->visible)
+        for (const auto &edge : edges) {
+            if (edge->visible) {
                 nrEdges++;
+            }
+        }
         return nrEdges;
     };
 
     // Construction
 
     // Add a node to the MCM graph
-    void addNode(MCMnode *n) {
+    void addNode(const std::shared_ptr<MCMnode> &n) {
         // Add the node to the MCM graph
         this->nodes.push_back(n);
     }
 
     // Remove a node from the MCMgraph.
     // Note: containers of nodes are lists, so remove is expensive!
-    void removeNode(MCMnode *n) {
+    void removeNode(const std::shared_ptr<MCMnode> &n) {
         // remove any remaining edges
         while (!n->in.empty()) {
             this->removeEdge(*(n->in.begin()));
@@ -158,26 +169,30 @@ class MCMgraph {
     }
 
     // Add an edge to the MCMgraph.
-    MCMedge *addEdge(CId id, MCMnode *src, MCMnode *dst, CDouble w, CDouble d) {
-        MCMedge *e = new MCMedge(id, true);
-        e->src = src;
-        e->dst = dst;
+    std::shared_ptr<MCMedge> addEdge(CId id,
+                                     std::shared_ptr<MCMnode> src,
+                                     std::shared_ptr<MCMnode> dst,
+                                     CDouble w,
+                                     CDouble d) {
+        std::shared_ptr<MCMedge> e = std::make_shared<MCMedge>(id, true);
+        e->src = std::move(src);
+        e->dst = std::move(dst);
         e->w = w;
         e->d = d;
         this->addEdge(e);
         return e;
     }
 
     // Add an edge to the MCMgraph.
-    void addEdge(MCMedge *e) {
+    void addEdge(std::shared_ptr<MCMedge> e) {
         this->edges.push_back(e);
         e->src->out.push_back(e);
         e->dst->in.push_back(e);
     }
 
     // Remove an edge from the MCMgraph.
     // Note: containers of edges are lists, so remove is expensive!
-    void removeEdge(MCMedge *e) {
+    void removeEdge(std::shared_ptr<MCMedge> e) {
         this->edges.remove(e);
         e->src->out.remove(e);
         e->dst->in.remove(e);
@@ -190,19 +205,19 @@ 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!
-    MCMgraph *pruneEdges(void);
+    std::shared_ptr<MCMgraph> pruneEdges();
 
-    CDouble calculateMaximumCycleMeanKarp();
-    CDouble calculateMaximumCycleMeanKarpDouble(MCMnode **criticalNode = NULL);
+    [[nodiscard]] CDouble calculateMaximumCycleMeanKarp() const;
+    [[nodiscard]] CDouble calculateMaximumCycleMeanKarpDouble(const MCMnode *criticalNode = nullptr) const;
 
-    CDouble calculateMaximumCycleRatioAndCriticalCycleYoungTarjanOrlin(MCMedge ***cycle = NULL,
-                                                                       uint *len = NULL);
+    [[nodiscard]] CDouble calculateMaximumCycleRatioAndCriticalCycleYoungTarjanOrlin(std::shared_ptr<MCMedge> **cycle = nullptr,
+                                                                       uint *len = nullptr);
 
-    MCMgraph normalize(CDouble mu) const;
-    MCMgraph normalize(const std::map<CId, CDouble> &mu) const;
-    std::map<CId, CDouble> longestPaths(const CId rootNodeId) const;
-    std::map<CId, CDouble> normalizedLongestPaths(const CId rootNodeId, const CDouble mu) const;
-    std::map<CId, CDouble> normalizedLongestPaths(const CId rootNodeId,
+    [[nodiscard]] MCMgraph normalize(CDouble mu) const;
+    [[nodiscard]] 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> normalizedLongestPaths( CId rootNodeId,
                                                   const std::map<CId, CDouble> &) const;
 
 private:
@@ -213,8 +228,8 @@ class MCMgraph {
     MCMedges edges;
 };
 
-typedef list<MCMgraph *> MCMgraphs;
-typedef MCMgraphs::iterator MCMgraphsIter;
+using MCMgraphs = list<std::shared_ptr<MCMgraph>>;
+using MCMgraphsIter = MCMgraphs::iterator;
 
 /**
  * Extract the strongly connected components from the graph. These components
@@ -227,7 +242,7 @@ typedef MCMgraphs::iterator MCMgraphsIter;
  * MCM algorithms work also on this graph (which reduces the execution time
  * needed in some of the conversion algorithms).
  */
-void stronglyConnectedMCMgraph(MCMgraph *g,
+void stronglyConnectedMCMgraph(const MCMgraph& g,
                                MCMgraphs &components,
                                bool includeComponentsWithoutEdges = false);
 
@@ -236,7 +251,7 @@ void stronglyConnectedMCMgraph(MCMgraph *g,
  * The function removes all hidden nodes and edges from the graph. All visible
  * edges are assigned a new id starting in the range [0,nrNodes()).
  */
-void relabelMCMgraph(MCMgraph *g);
+void relabelMCMgraph(std::shared_ptr<MCMgraph> g);
 
 /**
  * addLongestDelayEdgesToMCMgraph ()
@@ -245,7 +260,7 @@ void relabelMCMgraph(MCMgraph *g);
  * with no delay are removed and edges with more then one delay element
  * are converted into a sequence of edges with one delay element.
  */
-void addLongestDelayEdgesToMCMgraph(MCMgraph *g);
+void addLongestDelayEdgesToMCMgraph(std::shared_ptr<MCMgraph> g);
 
 } // namespace Graphs
 #endif