Merge branch 'more-tests' into main

Author: Marc Geilen

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

@@ -49,13 +49,45 @@
 
 namespace Graphs {
 
-/**
- * maximumCycleMeanKarp ()
- * The function computes the maximum cycle mean of an MCMgraph using Karp's
- * algorithm.
- */
+/// <summary>
+///		The function computes the maximum cycle mean of an MCMgraph using Karp's
+///		algorithm.
+/// 	Assumes thal all nodes of the graph have an outgoing edge.
+/// 	Assumes that the edge weights are integer (!)
+/// </summary>
+/// <param name="g">graph to analyse</param>
+/// <returns>The maximum cycle mean of the graph.</returns>
 CDouble maximumCycleMeanKarp(MCMgraph& g);
-CDouble maximumCycleMeanKarpDouble(MCMgraph& g, const MCMnode **criticalNode = nullptr);
+
+/// <summary>
+///		The function computes the maximum cycle mean of an MCMgraph using Karp's
+///		algorithm.
+/// </summary>
+/// <param name="g">graph to analyse</param>
+/// <param name="criticalNodeg">optional, will point to an arbitrary node on the cycle with the maximum cycle mean.</param>
+/// <returns>The maximum cycle mean of the graph and optionally a critical node.</returns>
+CDouble maximumCycleMeanKarpDouble(MCMgraph &g, const MCMnode **criticalNode = nullptr);
+
+/// <summary>
+///		The function computes the maximum cycle mean of an MCMgraph using Karp's
+///		algorithm.
+/// 	Does not require that all nodes of the graph have an outgoing edge.
+/// 	Assumes that the edge weights are integer (!)
+/// </summary>
+/// <param name="g">graph to analyse</param>
+/// <returns>The maximum cycle mean of the graph.</returns>
+CDouble maximumCycleMeanKarpGeneral(MCMgraph &g);
+
+/// <summary>
+///		The function computes the maximum cycle mean of an MCMgraph using Karp's
+///		algorithm.
+/// 	Does not require that all nodes of the graph have an outgoing edge.
+/// </summary>
+/// <param name="g">graph to analyse</param>
+/// <param name="criticalNodeg">optional, will point to an arbitrary node on the cycle with the maximum cycle mean.</param>
+/// <returns>The maximum cycle mean of the graph and optionally a critical node.</returns>
+CDouble maximumCycleMeanKarpDoubleGeneral(MCMgraph &g, const MCMnode **criticalNode = nullptr);
+
 
 /**
  * mcmGetAdjacentActors ()

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

@@ -14,6 +14,15 @@
  *  Function        :   Compute the MCM for a graph using Dasdan-Gupta's
  *                      algorithm.
  *
+ *  @article{Dasdan1998FasterMA,
+ *    title={Faster maximum and minimum mean cycle algorithms for system-performance analysis},
+ *    author={Ali Dasdan and Rajesh K. Gupta},
+ *    journal={IEEE Trans. Comput. Aided Des. Integr. Circuits Syst.},
+ *    year={1998},
+ *    volume={17},
+ *    pages={889-899}
+ * }
+ *
  *  History         :
  *      08-11-05    :   Initial version.
  *
@@ -48,9 +57,10 @@ namespace Graphs {
 
 /**
  * mcmDG ()
- * The function computes the maximum cycle mean of a HSDF graph using
+ * The function computes the maximum cycle mean of an MCM graph using
  * Dasdan-Gupta's algorithm.
  * Note: this algorithm assumes that edge weights are integer valued !
+ * 
  * @todo
  * check if algorithm can be generalized to float edge weights
  */

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

@@ -105,6 +105,7 @@ class MCMgraph {
     MCMgraph &operator=(MCMgraph &&) = delete;
     MCMgraph &operator=(const MCMgraph &other) = delete;
 
+    [[nodiscard]] unsigned int numberOfNodes() { return static_cast<unsigned int>(this->nodes.size()); };
     [[nodiscard]] MCMnodes &getNodes() { return nodes; };
     [[nodiscard]] MCMnodeRefs getNodeRefs();
     [[nodiscard]] MCMedgeRefs getEdgeRefs();
@@ -127,6 +128,7 @@ class MCMgraph {
         return nullptr;
     };
 
+    [[nodiscard]] unsigned int numberOfEdges() { return static_cast<unsigned int>(this->edges.size()); };
     [[nodiscard]] MCMedges &getEdges() { return edges; };
 
     MCMedge *getEdge(CId id) {
@@ -196,7 +198,7 @@ class MCMgraph {
         e.dst->in.remove(&e);
     }
 
-    void relabelNodeIds(std::map<int, int> &nodeIdMap);
+    void relabelNodeIds(std::map<int, int> *nodeIdMap = nullptr);
 
     // reduce the MCM graph by removing obviously redundant edges
     // in particular if there are multiple edges between the same pair

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

@@ -76,6 +76,10 @@ void convertMCMgraphToMatrix(MCMgraph& g, std::shared_ptr<std::vector<int>> *ij,
  *      NIterations: Number of iterations of the algorithm
  *      NComponents: Number of connected components of the optimal policy
  *
+ * ASSUMPTIONS
+ *      The graph has a non-zero number of nodes
+ *      The graph has a non-zero number of edges
+ *      Every node in the graph has outgoing directed edges
  */
 
 void Howard(const std::vector<int> &ij,
@@ -88,5 +92,37 @@ void Howard(const std::vector<int> &ij,
             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
+ *
+ * OUTPUT:
+ *      maximum cycle mean
+ *      a node on the cycle with maximum cycle mean
+ *
+ * ASSUMPTIONS
+ *      The graph has a non-zero number of nodes
+ *      The graph has a non-zero number of edges
+ *      Every node in the graph has outgoing directed edges
+ *
+ */
+CDouble maximumCycleMeanHoward(MCMgraph &g, MCMnode **criticalNode);
+
+/**
+ * maximumCycleMeanHowardGeneral ()
+ * Howard Policy Iteration Algorithm for Max Plus Matrices.
+ *
+ * INPUT MCMgraph  which can be arbitrary
+ *
+ * OUTPUT:
+ *      maximum cycle mean
+ *      a node on the cycle with maximum cycle mean
+ *
+ */
+CDouble maximumCycleMeanHowardGeneral(MCMgraph &g, MCMnode **criticalNode);
+
+
 } // namespace Graphs
 #endif

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

@@ -106,19 +106,19 @@ using graph = struct Graph {
  */
 CDouble maxCycleMeanYoungTarjanOrlin(MCMgraph& mcmGraph);
 
-/**
- * maxCycleMeanAndCriticalCycleYoungTarjanOrlin ()
- * The function computes the maximum cycle mean of edge weight of
- * an MCMgraph using Young-Tarjan-Orlin's algorithm.
- * It returns both the MCM and a critical cycle
- * The critical cycle is only returned if cycle and len are not NULL. Then *cycle points
- * to an array of *MCMEdges of the critical cycle and *len indicates the length of the cycle.
- * *cycle is a freshly allocated array and it is the caller's obligation to deallocate it
- * in due time.
- */
+
+/// The function computes the maximum cycle mean of edge weight of
+/// an MCMgraph using Young-Tarjan-Orlin's algorithm.
+/// It returns both 
+/// The critical cycle is only returned if cycle is not NULL. Then *cycle points
+/// to an array of *MCMEdges of the critical cycle.
+/// @param mcmGraph The graph to analyze
+/// @param cycle Pointer to the critical cycle
+/// @return the MCM and a critical cycle
 CDouble
 maxCycleMeanAndCriticalCycleYoungTarjanOrlin(MCMgraph& mcmGraph, std::shared_ptr<std::vector<const MCMedge*>> *cycle);
 
+
 /**
  * maxCycleRatioYoungTarjanOrlin ()
  * The function computes the maximum cycle ratio of edge weight over delay of
@@ -131,10 +131,8 @@ CDouble maxCycleRatioYoungTarjanOrlin(MCMgraph& mcmGraph);
  * The function computes the maximum cycle ratio of edge weight over delay of
  * an MCMgraph using Young-Tarjan-Orlin's algorithm.
  * It returns both the MCR and a critical cycle
- * The critical cycle is only returned if cycle and len are not NULL. Then *cycle points
- * to an array of *MCMEdges of the critical cycle and *len indicates the length of the cycle.
- * *cycle is a freshly allocated array and it is the caller's obligation to deallocate it
- * in due time.
+ * The critical cycle is only returned if cycle is not NULL. Then *cycle points
+ * to an array of *MCMEdges of the critical cycle/
  */
 CDouble
 maxCycleRatioAndCriticalCycleYoungTarjanOrlin(MCMgraph& mcmGraph, std::shared_ptr<std::vector<const MCMedge*>> *cycle);
@@ -151,10 +149,8 @@ CDouble minCycleRatioYoungTarjanOrlin(MCMgraph& mcmGraph);
  * The function computes the minimum cycle ratio of edge weight over delay of
  * an MCMgraph using Young-Tarjan-Orlin's algorithm.
  * It returns both the MCR and a critical cycle
- * The critical cycle is only returned if cycle and len are not NULL. Then *cycle points
- * to an array of *MCMEdges of the critical cycle and *len indicates the length of the cycle.
- * *cycle is a freshly allocated array and it is the caller's obligation to deallocate it
- * in due time.
+ * The critical cycle is only returned if cycle is not NULL. Then *cycle points
+ * to an array of *MCMEdges of the critical cycle.
  */
 CDouble
 minCycleRatioAndCriticalCycleYoungTarjanOrlin(MCMgraph& mcmGraph, std::shared_ptr<std::vector<const MCMedge*>> *cycle);

src/algebra/mpmatrix.cc

@@ -1090,7 +1090,7 @@ Matrix::mp_generalized_eigenvectors() const {
 
         // MCM calculation requires node relabelling
         std::map<int, int> sccNodeIdMap;
-        scc->relabelNodeIds(sccNodeIdMap);
+        scc->relabelNodeIds(&sccNodeIdMap);
 
         if (scc->nrVisibleEdges() > 0) {
             // compute MCM mu and critical node n of scc

src/base/analysis/mcm/mcmdg.cc

@@ -14,6 +14,15 @@
  *  Function        :   Compute the MCM for an HSDF graph using Dasdan-Gupta's
  *                      algorithm.
  *
+ *  @article{Dasdan1998FasterMA,
+ *    title={Faster maximum and minimum mean cycle algorithms for system-performance analysis},
+ *    author={Ali Dasdan and Rajesh K. Gupta},
+ *    journal={IEEE Trans. Comput. Aided Des. Integr. Circuits Syst.},
+ *    year={1998},
+ *    volume={17},
+ *    pages={889-899}
+ * }
+ *
  *  History         :
  *      08-11-05    :   Initial version.
  *
@@ -46,15 +55,11 @@
 #include <memory>
 
 namespace Graphs {
-/**
- * mcmDG ()
- * The function computes the maximum cycle mean of a HSDF graph using
- * Dasdan-Gupta's algorithm.
- * Note: this algorithm assumes that edge weights are integer valued !
- * @todo
- * check if algorithm can be generalized to float edge weights
- */
-CDouble mcmDG(MCMgraph &mcmGraph) {
+
+// assumes teh graph is strongly connected and assumes the node ids are 0...N-1,
+// where N is the number of nodes
+CDouble mcmDG_SCC(MCMgraph &mcmGraph) {
+
     // Allocate memory
     const int n = mcmGraph.nrVisibleNodes();
     std::vector<int> level(n);
@@ -70,17 +75,17 @@ CDouble mcmDG(MCMgraph &mcmGraph) {
     level[0] = 0;
     std::list<int> Q_k;
     Q_k.push_back(0);
-    std::list<MCMnode*> Q_u;
+    std::list<MCMnode *> Q_u;
     Q_u.push_back(&(mcmGraph.getNodes().front()));
 
     // Compute the distances
     int k = Q_k.front();
     Q_k.pop_front();
-    MCMnode* u = Q_u.front();
+    MCMnode *u = Q_u.front();
     Q_u.pop_front();
     do {
-        for (auto& e: u->out) {
-            MCMnode* v = e->dst;
+        for (auto &e : u->out) {
+            MCMnode *v = e->dst;
 
             if (level[v->id] < static_cast<int>(k + 1)) {
                 Q_k.push_back(k + 1);
@@ -99,7 +104,7 @@ CDouble mcmDG(MCMgraph &mcmGraph) {
 
     // Compute lambda using Karp's theorem
     CDouble l = -INT_MAX;
-    for (const auto & u : mcmGraph.getNodes()) {
+    for (const auto &u : mcmGraph.getNodes()) {
 
         if (level[u.id] == n) {
             CDouble ld = INT_MAX;
@@ -114,5 +119,31 @@ CDouble mcmDG(MCMgraph &mcmGraph) {
 
     return l;
 }
+    
+    
+/**
+ * mcmDG ()
+ * The function computes the maximum cycle mean of an MCM graph using
+ * Dasdan-Gupta's algorithm.
+ * Note: this algorithm assumes that edge weights are integer valued !
+ * @todo
+ * check if algorithm can be generalized to float edge weights
+ */
+CDouble mcmDG(MCMgraph &mcmGraph) {
+
+    MCMgraphs sccs;
+    stronglyConnectedMCMgraph(mcmGraph, sccs, false);
+
+    CDouble mcm = -INFINITY;
+    for (auto &scc : sccs) {
+        scc->relabelNodeIds();
+        CDouble cmcm = mcmDG_SCC(*scc);
+        if (cmcm > mcm) {
+            mcm = cmcm;
+        }
+    }
+
+    return mcm;
+}
 
 } // namespace Graphs

src/base/analysis/mcm/mcmgraph.cc

@@ -755,11 +755,13 @@ CDouble MCMgraph::calculateMaximumCycleRatioAndCriticalCycleYoungTarjanOrlin(
     return maxCycleRatioAndCriticalCycleYoungTarjanOrlin(*this, cycle);
 }
 
-void MCMgraph::relabelNodeIds(std::map<int, int> &nodeIdMap) {
+void MCMgraph::relabelNodeIds(std::map<int, int> *nodeIdMap) {
     int k = 0;
     for (auto &i : this->nodes) {
         MCMnode &n = i;
-        nodeIdMap[k] = static_cast<int>(n.id);
+        if (nodeIdMap != nullptr) {
+            (*nodeIdMap)[k] = static_cast<int>(n.id);
+        }
         n.id = k;
         k++;
     }