sync

Author: MarcG-TUE

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

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

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

@@ -208,7 +208,7 @@ class MCMgraph {
     std::shared_ptr<MCMgraph> pruneEdges();
 
     [[nodiscard]] CDouble calculateMaximumCycleMeanKarp() const;
-    [[nodiscard]] CDouble calculateMaximumCycleMeanKarpDouble(const MCMnode *criticalNode = nullptr) const;
+    [[nodiscard]] CDouble calculateMaximumCycleMeanKarpDouble(MCMnode** criticalNode = nullptr) const;
 
     [[nodiscard]] CDouble calculateMaximumCycleRatioAndCriticalCycleYoungTarjanOrlin(std::shared_ptr<MCMedge> **cycle = nullptr,
                                                                        uint *len = nullptr);

src/algebra/mpmatrix.cc

@@ -1099,16 +1099,16 @@ Matrix::mp_generalized_eigenvectors() const {
     stronglyConnectedMCMgraph(precGraph, sccs, true);
 
     // map from number of SCC to SCC
-    std::map<uint, MCMgraph *> sccMapInv;
+    std::map<uint, std::shared_ptr<MCMgraph>> sccMapInv;
 
     // map from node of precGraph to its SCC
-    std::map<MCMnode *, uint> sccMap;
+    std::map<std::weak_ptr<MCMnode>, uint> sccMap;
 
     // map from nodes of precGraph to the cycle mean of its SCC
-    std::map<MCMnode *, MPTime> cycleMeansMap;
+    std::map<std::weak_ptr<MCMnode>, MPTime> cycleMeansMap;
 
     // vector such that element k is a node from precGraph in the critical path of SCC k
-    std::vector<MCMnode *> criticalNodes;
+    std::vector<std::shared_ptr<MCMnode>> criticalNodes;
 
     // vector such that element k is the maximum cycle mean of SCC k
     std::vector<MPTime> cycleMeans;
@@ -1117,7 +1117,7 @@ Matrix::mp_generalized_eigenvectors() const {
     uint k = 0;
     // for each SCC
     for (auto scci = sccs.cbegin(); scci != sccs.cend(); scci++, k++) {
-        MCMgraph *scc = *scci;
+        std::shared_ptr<MCMgraph> scc = *scci;
         sccMapInv[k] = scc;
 
         // MCM calculation requires node relabelling
@@ -1126,8 +1126,8 @@ Matrix::mp_generalized_eigenvectors() const {
 
         if (scc->nrVisibleEdges() > 0) {
             // compute MCM mu and critical node n of scc
-            MCMnode* n;
-            MPTime mu = MPTime(scc->calculateMaximumCycleMeanKarpDouble(&n));
+            MCMnode* n = nullptr;
+            auto mu = MPTime(scc->calculateMaximumCycleMeanKarpDouble(&n));
             criticalNodes.push_back(precGraph.getNode(sccNodeIdMap[n->id]));
             cycleMeans.push_back(mu);
         } else {
@@ -1136,8 +1136,8 @@ Matrix::mp_generalized_eigenvectors() const {
             cycleMeans.push_back(MP_MINUSINFINITY);
         }
         // for each node in the scc
-        for (auto *nn : scc->getNodes()) {
-            auto *nnn = precGraph.getNode(sccNodeIdMap[nn->id]);
+        for (auto nn=precGraph.getNodes().begin(); nn != precGraph.getNodes().end(); nn++) {
+            auto nnn = precGraph.getNode(sccNodeIdMap[(*nn)->id]);
             // map node to SCC index
             sccMap[nnn] = k;
             // map node to the cycle mean of its SCC
@@ -1165,7 +1165,7 @@ Matrix::mp_generalized_eigenvectors() const {
             while (change) {
                 change = false;
                 // for all edges in precGraph
-                for (auto *i : precGraph.getEdges()) {
+                for (auto i : precGraph.getEdges()) {
                     MCMedge &e = *i;
                     if (trCycleMeans[e.src->id] > trCycleMeans[e.dst->id]) {
                         change = true;
@@ -1221,11 +1221,6 @@ Matrix::mp_generalized_eigenvectors() const {
         }
     }
 
-    // the SCC graphs still need to be destroyed
-    for (auto *g : sccs) {
-        delete g;
-    }
-
     return std::make_pair(eigenVectors, genEigenVectors);
 }
 

src/base/analysis/mcm/mcmdg.cc

@@ -42,6 +42,7 @@
 #include "base/analysis/mcm/mcmgraph.h"
 #include "base/math/cmath.h"
 #include <climits>
+#include <memory>
 
 
 namespace Graphs {
@@ -57,10 +58,10 @@ CDouble mcmDG(MCMgraph *mcmGraph) {
     int k, n;
     int *level;
     int **pi, **d;
-    double l, ld;
-    MCMnode *u;
+    CDouble l, ld;
+    std::shared_ptr<MCMnode> u;
     list<int> Q_k;
-    list<MCMnode *> Q_u;
+    list<std::shared_ptr<MCMnode>> Q_u;
 
     // Allocate memory
     n = mcmGraph->nrVisibleNodes();
@@ -88,8 +89,8 @@ CDouble mcmDG(MCMgraph *mcmGraph) {
     Q_u.pop_front();
     do {
         for (MCMedgesIter iter = u->out.begin(); iter != u->out.end(); iter++) {
-            MCMedge *e = *iter;
-            MCMnode *v = e->dst;
+            std::shared_ptr<MCMedge> e = *iter;
+            std::shared_ptr<MCMnode> v = e->dst;
 
             if (level[v->id] < k + 1) {
                 Q_k.push_back(k + 1);
@@ -116,7 +117,7 @@ CDouble mcmDG(MCMgraph *mcmGraph) {
             ld = INT_MAX;
             k = pi[n][u->id];
             while (k > -1) {
-                ld = MIN(ld, (double)(d[n][u->id] - d[k][u->id]) / (double)(n - k));
+                ld = MIN(ld, (CDouble)(d[n][u->id] - d[k][u->id]) / (CDouble)(n - k));
                 k = pi[k][u->id];
             }
             l = MAX(l, ld);

src/base/analysis/mcm/mcmgraph.cc

@@ -819,7 +819,7 @@ std::shared_ptr<MCMgraph> MCMgraph::pruneEdges() {
 
 CDouble MCMgraph::calculateMaximumCycleMeanKarp() const { return maximumCycleMeanKarp(*this); }
 
-CDouble MCMgraph::calculateMaximumCycleMeanKarpDouble(const MCMnode *criticalNode) const {
+CDouble MCMgraph::calculateMaximumCycleMeanKarpDouble(MCMnode **criticalNode) const {
     return maximumCycleMeanKarpDouble(*this, criticalNode);
 }
 

src/base/analysis/mcm/mcmhoward.cc

@@ -53,6 +53,7 @@
 #include "base/exception/exception.h"
 
 #include <math.h>
+#include <memory>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -490,14 +491,15 @@ void Howard(int *ij,
  * The function converts a weighted directed graph used in the MCM algorithms
  * to a sparse matrix input for Howard's algorithm.
  */
-void convertMCMgraphToMatrix(MCMgraph *g, int *ij, double *A) {
+void convertMCMgraphToMatrix(const MCMgraph& g, int *ij, double *A) {
     int k = 0;
-    uint i = 0, j = 0;
-    v_uint mapId(g->getNodes().size());
+    uint i = 0;
+    uint j = 0;
+    v_uint mapId(g.getNodes().size());
 
     // Re-map the id of all visible nodes back to the range [0, g->nrNodes())
-    for (MCMnodesCIter iter = g->getNodes().begin(); iter != g->getNodes().end(); iter++) {
-        MCMnode *n = *iter;
+    for (auto iter = g.getNodes().begin(); iter != g.getNodes().end(); iter++) {
+        const std::shared_ptr<MCMnode>& n = *iter;
 
         if (n->visible) {
             mapId[i] = j;
@@ -507,8 +509,8 @@ void convertMCMgraphToMatrix(MCMgraph *g, int *ij, double *A) {
     }
 
     // Create an entry in the matrices for each edge
-    for (MCMedgesCIter iter = g->getEdges().begin(); iter != g->getEdges().end(); iter++) {
-        MCMedge *e = *iter;
+    for (auto iter = g.getEdges().begin(); iter != g.getEdges().end(); iter++) {
+        const std::shared_ptr<MCMedge>& e = *iter;
 
         // Is the edge a existing edge in the graph?
         if (e->visible) {