cleaned up

Author: Marc Geilen

include/maxplus/algebra/mptype.h

@@ -224,21 +224,21 @@ inline CString timeToString(MPTime val) {
     // so that we can expose the unwanted "impure" infinities here.
     //
     if (static_cast<CDouble>(val)==MPTIME_MIN_INF_VAL) {
-        return {"-mp_inf"};
+        return CString("-mp_inf");
     }
-    return {static_cast<CDouble>(val)};
+    return CString(static_cast<CDouble>(val));
 }
 inline CString timeToMatlabString(MPTime val) {
     if (val.isMinusInfinity()) {
-        return {"-Inf"};
+        return CString("-Inf");
     }
-    return {static_cast<CDouble>(val)};
+    return CString(static_cast<CDouble>(val));
 }
 inline CString timeToLaTeXString(MPTime val) {
     if (val.isMinusInfinity()) {
-        return {"-\\infty{}"};
+        return CString("-\\infty{}");
     }
-    return {static_cast<CDouble>(val)};
+    return CString(static_cast<CDouble>(val));
 }
 
 } // namespace MaxPlus

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(const MCMgraph& g);
-CDouble maximumCycleMeanKarpDouble(const MCMgraph& g, const MCMnode **criticalNode = nullptr);
+CDouble maximumCycleMeanKarp(MCMgraph& g);
+CDouble maximumCycleMeanKarpDouble(MCMgraph& g, const MCMnode **criticalNode = nullptr);
 
 /**
  * mcmGetAdjacentActors ()

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

@@ -52,13 +52,16 @@ class MCMnode;
 class MCMedge {
 public:
     // Constructor
-    MCMedge(CId eId, MCMnode &src, MCMnode &dst, bool eVisible);
+    MCMedge(CId eId, MCMnode &src, MCMnode &dst, CDouble w, CDouble d, bool eVisible);
     CId id;
     bool visible;
     MCMnode *src;
     MCMnode *dst;
     CDouble w;
     CDouble d;
+    bool operator==(const MCMedge& e) const {
+        return this->id == e.id;
+    }
 };
 
 using MCMedges = std::list<MCMedge>;
@@ -72,14 +75,17 @@ class MCMnode {
     bool visible;
     MCMedgeRefs in;
     MCMedgeRefs out;
+    bool operator==(const MCMnode& n) const {
+        return this->id == n.id;
+    }
 };
 
-// struct MCMNodeLess {
-//     bool operator()(std::shared_ptr<MCMnode> const &lhs,
-//                     std::shared_ptr<MCMnode> const &rhs) const {
-//         return lhs->id < rhs->id;
-//     };
-// };
+struct MCMNodeLess {
+    bool operator()(const MCMnode* const &lhs,
+                    const MCMnode* const &rhs) const {
+        return lhs->id < rhs->id;
+    };
+};
 
 using MCMnodes = std::list<MCMnode>;
 using MCMnodeRefs = std::list<MCMnode *>;
@@ -99,7 +105,9 @@ class MCMgraph {
     MCMgraph &operator=(MCMgraph &&) = delete;
     MCMgraph &operator=(const MCMgraph &other) = delete;
 
-    [[nodiscard]] const MCMnodes &getNodes() const { return nodes; };
+    [[nodiscard]] MCMnodes &getNodes() { return nodes; };
+    [[nodiscard]] MCMnodeRefs getNodeRefs();
+    [[nodiscard]] MCMedgeRefs getEdgeRefs();
 
     [[nodiscard]] uint nrVisibleNodes() const {
         uint nrNodes = 0;
@@ -119,7 +127,7 @@ class MCMgraph {
         return nullptr;
     };
 
-    [[nodiscard]] const MCMedges &getEdges() const { return edges; };
+    [[nodiscard]] MCMedges &getEdges() { return edges; };
 
     MCMedge *getEdge(CId id) {
         for (auto &edge : edges) {
@@ -169,17 +177,12 @@ class MCMgraph {
         while (!n.out.empty()) {
             this->removeEdge(**(n.out.begin()));
         }
-
         this->nodes.remove(n);
     }
 
     // Add an edge to the MCMgraph.
-    MCMedge *addEdge(CId id, MCMnode &src, MCMnode &dst, CDouble w, CDouble d) {
-        MCMedge& e = this->edges.emplace_back(id, true);
-        e.src = &src;
-        e.dst = &dst;
-        e.w = w;
-        e.d = d;
+    MCMedge *addEdge(CId id, MCMnode &src, MCMnode &dst, CDouble w, CDouble d, bool visible = true) {
+        MCMedge& e = this->edges.emplace_back(id, src, dst, w, d, visible);
         src.out.push_back(&e);
         dst.in.push_back(&e);
         return &e;
@@ -202,12 +205,12 @@ class MCMgraph {
     // Note this algorithm does currently not distinguish visible and invisible edges!
     std::shared_ptr<MCMgraph> pruneEdges();
 
-    [[nodiscard]] CDouble calculateMaximumCycleMeanKarp() const;
+    [[nodiscard]] CDouble calculateMaximumCycleMeanKarp();
     [[nodiscard]] CDouble
-    calculateMaximumCycleMeanKarpDouble(const MCMnode **criticalNode = nullptr) const;
+    calculateMaximumCycleMeanKarpDouble(const MCMnode **criticalNode = nullptr);
 
     [[nodiscard]] CDouble calculateMaximumCycleRatioAndCriticalCycleYoungTarjanOrlin(
-            std::shared_ptr<std::vector<MCMedge*>> *cycle = nullptr) const;
+            std::shared_ptr<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;
@@ -238,7 +241,7 @@ using MCMgraphsIter = MCMgraphs::iterator;
  * MCM algorithms work also on this graph (which reduces the execution time
  * needed in some of the conversion algorithms).
  */
-void stronglyConnectedMCMgraph(const MCMgraph &g,
+void stronglyConnectedMCMgraph(MCMgraph &g,
                                MCMgraphs &components,
                                bool includeComponentsWithoutEdges = false);
 
@@ -253,7 +256,7 @@ void relabelMCMgraph(std::shared_ptr<MCMgraph> g);
  * addLongestDelayEdgesToMCMgraph ()
  * The function adds additional edges to the graph which express the
  * longest path between two nodes crossing one edge with a delay. Edges
- * with no delay are removed and edges with more then one delay element
+ * with no delay are removed and edges with more than one delay element
  * are converted into a sequence of edges with one delay element.
  */
 void addLongestDelayEdgesToMCMgraph(std::shared_ptr<MCMgraph> g);

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

@@ -117,7 +117,7 @@ CDouble maxCycleMeanYoungTarjanOrlin(const MCMgraph& mcmGraph);
  * in due time.
  */
 CDouble
-maxCycleMeanAndCriticalCycleYoungTarjanOrlin(const MCMgraph& mcmGraph, std::shared_ptr<std::vector<const MCMedge*>> *cycle);
+maxCycleMeanAndCriticalCycleYoungTarjanOrlin(MCMgraph& mcmGraph, std::shared_ptr<std::vector<const MCMedge*>> *cycle);
 
 /**
  * maxCycleRatioYoungTarjanOrlin ()
@@ -137,14 +137,14 @@ CDouble maxCycleRatioYoungTarjanOrlin(const MCMgraph& mcmGraph);
  * in due time.
  */
 CDouble
-maxCycleRatioAndCriticalCycleYoungTarjanOrlin(const MCMgraph& mcmGraph, std::shared_ptr<std::vector<const MCMedge*>> *cycle);
+maxCycleRatioAndCriticalCycleYoungTarjanOrlin(MCMgraph& mcmGraph, std::shared_ptr<std::vector<const MCMedge*>> *cycle);
 
 /**
  * minCycleRatioYoungTarjanOrlin ()
  * The function computes the minimum cycle ratio of edge weight over delay of
  * an MCMgraph using Young-Tarjan-Orlin's algorithm.
  */
-CDouble minCycleRatioYoungTarjanOrlin(const MCMgraph& mcmGraph);
+CDouble minCycleRatioYoungTarjanOrlin(MCMgraph& mcmGraph);
 
 /**
  * minCycleRatioAndCriticalCycleYoungTarjanOrlin ()
@@ -157,7 +157,7 @@ CDouble minCycleRatioYoungTarjanOrlin(const MCMgraph& mcmGraph);
  * in due time.
  */
 CDouble
-minCycleRatioAndCriticalCycleYoungTarjanOrlin(const MCMgraph& mcmGraph, std::shared_ptr<std::vector<const MCMedge*>> *cycle);
+minCycleRatioAndCriticalCycleYoungTarjanOrlin(MCMgraph& mcmGraph, std::shared_ptr<std::vector<const MCMedge*>> *cycle);
 
 /**
  * getDelay ()

include/maxplus/base/base.h

@@ -51,7 +51,4 @@
 /* Math */
 #include "math/cmath.h"
 
-/* Lookups (i.e. hash tables)  */
-#include "lookup/clookup.h"
-
 #endif

include/maxplus/base/basic_types.h

@@ -42,8 +42,8 @@
 #ifndef BASE_BASIC_TYPES_H_INCLUDED
 #define BASE_BASIC_TYPES_H_INCLUDED
 
+#include <cassert>
 #include <cfloat>
-#include <assert.h>
 
 
 /* STL functionality */

include/maxplus/base/fraction/fraction.h

@@ -66,11 +66,11 @@ class CFraction {
 
     explicit CFraction(CString &f) {
         if (f.find('/') == CString::npos) {
-            num = f;
+            num = std::int64_t(f);
             den = 1;
         } else {
-            num = CString(f.substr(0, f.find('/')));
-            den = CString(f.substr(f.find('/') + 1));
+            num = std::int64_t(CString(f.substr(0, f.find('/'))));
+            den = std::int64_t(CString(f.substr(f.find('/') + 1)));
         }
         val = static_cast<CDouble>(num) / static_cast<CDouble>(den);
     };