more tests

Author: MarcG-TUE

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/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,8 +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/base/analysis/mcm/mcmhoward.cc

@@ -99,7 +99,7 @@ class AlgHoward {
         *chi = std::make_shared<std::vector<CDouble>>(nr_nodes);
         *v = std::make_shared<std::vector<CDouble>>(nr_nodes);
 
-        Security_Check();
+        Safety_Check();
         Allocate_Memory();
         Epsilon(&epsilon);
         Initial_Policy();
@@ -379,9 +379,11 @@ class AlgHoward {
     }
 
     void Check_Rows() {
+        // check if every node has outgoing edges.
         std::vector<int> u(nr_nodes);
 
         for (int i = 0; i < narcs; i++) {
+            // ij[2*k] is the source node number of edge number k
             u[ij[2 * i]] = 1;
         }
 
@@ -392,7 +394,7 @@ class AlgHoward {
         }
     }
 
-    void Security_Check() {
+    void Safety_Check() {
         if (nr_nodes < 1) {
             throw CException("Howard: number of nodes must be a positive integer.");
         }
@@ -482,7 +484,6 @@ void Howard(const std::vector<int> &ij,
 void convertMCMgraphToMatrix(MCMgraph &g,
                              std::shared_ptr<std::vector<int>> *ij,
                              std::shared_ptr<std::vector<CDouble>> *A) {
-    int k = 0;
     uint i = 0;
     uint j = 0;
     v_uint mapId(g.getNodes().size());
@@ -502,8 +503,9 @@ void convertMCMgraphToMatrix(MCMgraph &g,
     auto& Ar = *(*A);
 
     // Create an entry in the matrices for each edge
+    int k = 0;
     for (const auto &e : g.getEdges()) {
-        // Is the edge a existing edge in the graph?
+        // Is the edge an existing edge in the graph?
         if (e.visible) {
             ijr[2 * k] = mapId[e.src->id];
             ijr[2 * k + 1] = mapId[e.dst->id];
@@ -563,5 +565,31 @@ CDouble maximumCycleMeanHoward(MCMgraph& g, MCMnode* *criticalNode) {
     return mcm;
 }
 
+CDouble maximumCycleMeanHowardGeneral(MCMgraph &g, MCMnode **criticalNode) {
+
+    MCMgraphs sccs;
+    stronglyConnectedMCMgraph(g, sccs, false);
+
+    CDouble mcm = -INFINITY;
+    if (criticalNode != nullptr) {
+        *criticalNode = nullptr;
+    }
+    for (auto &scc : sccs) {
+        std::map<int, int> nodeMap;
+        scc->relabelNodeIds(&nodeMap);
+        MCMnode *sccCriticalNode = nullptr;
+        ;
+        CDouble cmcm = maximumCycleMeanHoward(*scc, &sccCriticalNode);
+        if (cmcm > mcm) {
+            mcm = cmcm;
+            if (criticalNode != nullptr) {
+                *criticalNode = g.getNode(nodeMap[sccCriticalNode->id]);
+            }
+        }
+    }
+
+    return mcm;
+}
+
 
 } // namespace Graphs

src/base/analysis/mcm/mcmkarp.cc

@@ -47,17 +47,16 @@
 namespace Graphs {
 /**
  * mcmKarp ()
- * The function computes the maximum cycle mean of an MCMgGraph using Karp's
+ * The function computes the maximum cycle mean of an MCMgraph using Karp's
  * algorithm.
  * Note that the following assumptions are made about the MCMgraph
  * 1. it is assumed that the edge weights have integer values.
  * 2. it is assumed that all nodes in the graph are 'visible'
  * 3. it is assumed that the node have id's ranging from 0 up to the number of nodes.
+ * 4. it is assumed that all nodes have an outgoing directed edge
  *
- * The critical cycle is only returned if cycle and len are not nullptr. 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 nullptr. Then *cycle points
+ * to an array of MCMEdges of the critical cycle.
  * cycle  - pointers to arcs on maximum ratio cycle,
  *          ordered in array from top to bottom with
  *          respect to subsequent arcs on cycle
@@ -106,6 +105,26 @@ CDouble maximumCycleMeanKarp(MCMgraph &mcmGraph) {
     return l;
 }
 
+CDouble maximumCycleMeanKarpGeneral(MCMgraph& g) {
+    MCMgraphs sccs;
+    stronglyConnectedMCMgraph(g, sccs, false);
+
+    CDouble mcm = -INFINITY;
+    for (auto &scc : sccs) {
+        std::map<int, int> nodeMap;
+        scc->relabelNodeIds(&nodeMap);
+        MCMnode *sccCriticalNode = nullptr;
+        ;
+        CDouble cmcm = maximumCycleMeanKarp(*scc);
+        if (cmcm > mcm) {
+            mcm = cmcm;
+        }
+    }
+
+    return mcm;
+}
+
+
 /**
  * maximumCycleMeanKarpDouble ()
  * The function computes the maximum cycle mean of an MCMgGraph using Karp's
@@ -166,4 +185,29 @@ CDouble maximumCycleMeanKarpDouble(MCMgraph &mcmGraph, const MCMnode **criticalN
     return l;
 }
 
+CDouble maximumCycleMeanKarpDoubleGeneral(MCMgraph &g, const MCMnode **criticalNode) {
+    MCMgraphs sccs;
+    stronglyConnectedMCMgraph(g, sccs, false);
+
+    CDouble mcm = -INFINITY;
+    if (criticalNode != nullptr) {
+        *criticalNode = nullptr;
+    }
+    for (auto &scc : sccs) {
+        std::map<int, int> nodeMap;
+        scc->relabelNodeIds(&nodeMap);
+        const MCMnode *sccCriticalNode = nullptr;
+        ;
+        CDouble cmcm = maximumCycleMeanKarpDouble(*scc, &sccCriticalNode);
+        if (cmcm > mcm) {
+            mcm = cmcm;
+            if (criticalNode != nullptr) {
+                *criticalNode = g.getNode(nodeMap[sccCriticalNode->id]);
+            }
+        }
+    }
+
+    return mcm;
+}
+
 } // namespace Graphs

src/base/analysis/mcm/mcmyto.cc

@@ -1066,10 +1066,8 @@ CDouble getDelay(const MCMedge& e) { return e.d; }
  * 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 nullptr. 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 nullptr. Then *cycle points
+ * to an array of *MCMEdges of the critical cycle.
  *
  * Note that the following assumed are made about the MCMgraph
  * 1. it is assumed that all nodes in the graph are 'visible'
@@ -1126,11 +1124,8 @@ CDouble maxCycleMeanYoungTarjanOrlin(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
- * Since MCM is in C-style code, let's do it the C-way.
- * The critical cycle is only returned if cycle and len are not nullptr. 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 nullptr. Then *cycle points
+ * to a vector of MCMEdges of the critical cycle.
  */
 
 CDouble maxCycleRatioAndCriticalCycleYoungTarjanOrlin(MCMgraph &mcmGraph,
@@ -1191,10 +1186,8 @@ CDouble maxCycleRatioYoungTarjanOrlin(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 nullptr. 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 nullptr. Then *cycle points
+ * to an array of MCMEdges of the critical cycle.
  */
 
 CDouble minCycleRatioAndCriticalCycleYoungTarjanOrlin(MCMgraph &mcmGraph,