warnings

Author: MarcG-TUE

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

@@ -198,7 +198,7 @@ class MCMgraph {
         e.dst->in.remove(&e);
     }
 
-    void relabelNodeIds(std::map<int, int> *nodeIdMap = nullptr);
+    void relabelNodeIds(std::map<CId, CId> *nodeIdMap = nullptr);
 
     // reduce the MCM graph by removing obviously redundant edges
     // in particular if there are multiple edges between the same pair

src/algebra/mpmatrix.cc

@@ -1089,7 +1089,7 @@ Matrix::mp_generalized_eigenvectors() const {
         sccMapInv[k] = scc.get();
 
         // MCM calculation requires node relabelling
-        std::map<int, int> sccNodeIdMap;
+        std::map<CId, CId> sccNodeIdMap;
         scc->relabelNodeIds(&sccNodeIdMap);
 
         if (scc->nrVisibleEdges() > 0) {

src/base/analysis/mcm/mcmdg.cc

@@ -61,7 +61,7 @@ namespace Graphs {
 CDouble mcmDG_SCC(MCMgraph &mcmGraph) {
 
     // Allocate memory
-    const int n = mcmGraph.nrVisibleNodes();
+    const int n = static_cast<int>(mcmGraph.nrVisibleNodes());
     std::vector<int> level(n);
     std::vector<std::vector<int>> pi(n + 1, std::vector<int>(n));
     std::vector<std::vector<int>> d(n + 1, std::vector<int>(n));
@@ -134,7 +134,7 @@ CDouble mcmDG(MCMgraph &mcmGraph) {
     MCMgraphs sccs;
     stronglyConnectedMCMgraph(mcmGraph, sccs, false);
 
-    CDouble mcm = -INFINITY;
+    auto mcm = static_cast<CDouble>(-INFINITY);
     for (auto &scc : sccs) {
         scc->relabelNodeIds();
         CDouble cmcm = mcmDG_SCC(*scc);

src/base/analysis/mcm/mcmgraph.cc

@@ -225,8 +225,12 @@ static void addLongestDelayEdgeForNode(MCMgraph &g, MCMnode &n, MCMedge &e) {
         // Node m reachable from n and not connected directly to n via e?
         if (d[m->id] > 0 && e.dst->id != m->id) {
             // Create an edge between n and m
-            MCMedge *eN = g.addEdge(
-                    static_cast<CId>(g.getEdges().size()), n, *m, d[m->id], e.d, false); // e.d should always be 1
+            MCMedge *eN = g.addEdge(static_cast<CId>(g.getEdges().size()),
+                                    n,
+                                    *m,
+                                    d[m->id],
+                                    e.d,
+                                    false); // e.d should always be 1
             n.out.push_back(eN);
             m->in.push_back(eN);
         }
@@ -435,7 +439,7 @@ static void addNodeToComponent(const MCMnode &n, MCMgraph &comp) {
     // in the previous loop already
     for (const auto &e : n.in) {
         // Is source node in the component?
-        for (auto& iterN : comp.getNodes()) {
+        for (auto &iterN : comp.getNodes()) {
             // if the source node is in the component and it is not a self-edge
             if ((e->src->id == iterN.id) && (e->src->id != e->dst->id)) {
                 // Add a copy of the edge to the component
@@ -757,7 +761,7 @@ CDouble MCMgraph::calculateMaximumCycleRatioAndCriticalCycleYoungTarjanOrlin(
     return maxCycleRatioAndCriticalCycleYoungTarjanOrlin(*this, cycle);
 }
 
-void MCMgraph::relabelNodeIds(std::map<int, int> *nodeIdMap) {
+void MCMgraph::relabelNodeIds(std::map<CId, CId> *nodeIdMap) {
     int k = 0;
     for (auto &i : this->nodes) {
         MCMnode &n = i;

src/base/analysis/mcm/mcmhoward.cc

@@ -575,7 +575,7 @@ CDouble maximumCycleMeanHowardGeneral(MCMgraph &g, MCMnode **criticalNode) {
         *criticalNode = nullptr;
     }
     for (auto &scc : sccs) {
-        std::map<int, int> nodeMap;
+        std::map<CId, CId> nodeMap;
         scc->relabelNodeIds(&nodeMap);
         MCMnode *sccCriticalNode = nullptr;
         ;

src/base/analysis/mcm/mcmkarp.cc

@@ -109,9 +109,9 @@ CDouble maximumCycleMeanKarpGeneral(MCMgraph& g) {
     MCMgraphs sccs;
     stronglyConnectedMCMgraph(g, sccs, false);
 
-    CDouble mcm = -INFINITY;
+    auto mcm = static_cast<CDouble>(-INFINITY);
     for (auto &scc : sccs) {
-        std::map<int, int> nodeMap;
+        std::map<CId, CId> nodeMap;
         scc->relabelNodeIds(&nodeMap);
         MCMnode *sccCriticalNode = nullptr;
         ;
@@ -189,12 +189,12 @@ CDouble maximumCycleMeanKarpDoubleGeneral(MCMgraph &g, const MCMnode **criticalN
     MCMgraphs sccs;
     stronglyConnectedMCMgraph(g, sccs, false);
 
-    CDouble mcm = -INFINITY;
+    auto mcm = static_cast<CDouble>(-INFINITY);
     if (criticalNode != nullptr) {
         *criticalNode = nullptr;
     }
     for (auto &scc : sccs) {
-        std::map<int, int> nodeMap;
+        std::map<CId, CId> nodeMap;
         scc->relabelNodeIds(&nodeMap);
         const MCMnode *sccCriticalNode = nullptr;
         ;

src/base/analysis/mcm/mcmyto.cc

@@ -940,20 +940,20 @@ void convertMCMgraphToYTOgraph(MCMgraph &g,
                                CDouble (*costFunction)(const MCMedge& e),
                                CDouble (*transit_timeFunction)(const MCMedge& e)) {
 
-    gr.n_nodes = g.nrVisibleNodes();
-    gr.n_arcs = g.nrVisibleEdges();
+    gr.n_nodes = static_cast<int>(g.nrVisibleNodes());
+    gr.n_arcs = static_cast<int>(g.nrVisibleEdges());
     // allocate space for the nodes, plus one for the exta source node that will be added
     gr.nodes.resize(gr.n_nodes + 1);
     gr.arcs.resize(gr.n_arcs + gr.n_nodes);
 
     // create nodes
     // keep an index of node id's
-    std::map<int,int> nodeIndex;
+    std::map<CId,CId> nodeIndex;
     uint ind = 0;
     for (const auto &n : g.getNodes()) {
         nodeIndex[n.id] = ind;
         node& x = (gr.nodes)[ind];
-        x.id = n.id + 1;
+        x.id = static_cast<int>(n.id + 1);
         x.first_arc_out = nullptr;
         x.first_arc_in = nullptr;
 

src/graph/mpautomaton.cc

@@ -16,15 +16,15 @@ CDouble MaxPlusAutomatonWithRewards::calculateMCR(){
 
     std::map<const ::FSM::Abstract::State*, MCMnode*> nodeMap;
 
-    for (auto s: this->getStates()) {
-        auto n = g.addNode(nId++);
+    for (const auto& s: this->getStates()) {
+        auto *n = g.addNode(nId++);
         nodeMap[&(*(s.second))] = n;
     }
 
     CId eId = 0;
-    for (auto s: this->getStates()) {
-        for(auto e: (s.second)->getOutgoingEdges()) {
-            auto mpae = dynamic_cast<MPAREdge*>(e);
+    for (const auto& s: this->getStates()) {
+        for(auto *e: (s.second)->getOutgoingEdges()) {
+            auto *mpae = dynamic_cast<MPAREdge*>(e);
             g.addEdge(eId++, *nodeMap[&(mpae->getSource())], *nodeMap[&(mpae->getDestination())], static_cast<CDouble>(mpae->getLabel().delay), mpae->getLabel().reward);
         }
     }
@@ -42,17 +42,17 @@ CDouble MaxPlusAutomatonWithRewards::calculateMCRAndCycle(std::shared_ptr<std::v
     CId nId = 0;
     std::map<const ::FSM::Abstract::State*, MCMnode*> nodeMap;
 
-    for (auto s: this->getStates()) {
-        auto n = g.addNode(nId++);
+    for (const auto& s: this->getStates()) {
+        auto *n = g.addNode(nId++);
         nodeMap[&(*(s.second))] = n;
     }
 
     CId eId = 0;
     std::map<const MCMedge*, const MPAREdge*> edgeMap;
 
-    for (auto s: this->getStates()) {
-        for(auto e: (s.second)->getOutgoingEdges()) {
-            auto mpae = dynamic_cast<MPAREdge*>(e);
+    for (const auto& s: this->getStates()) {
+        for(auto *e: (s.second)->getOutgoingEdges()) {
+            auto *mpae = dynamic_cast<MPAREdge*>(e);
             g.addEdge(eId++, *nodeMap[&(mpae->getSource())], *nodeMap[&(mpae->getDestination())], static_cast<CDouble>(mpae->getLabel().delay), mpae->getLabel().reward);
         }
     }
@@ -61,7 +61,7 @@ CDouble MaxPlusAutomatonWithRewards::calculateMCRAndCycle(std::shared_ptr<std::v
     CDouble mcr = maxCycleRatioAndCriticalCycleYoungTarjanOrlin(g, &mcmCycle);
     if (cycle != nullptr) {
         *cycle = std::make_shared<std::vector<const MPAREdge*>>();
-        for (auto e: *mcmCycle) {
+        for (const auto *e: *mcmCycle) {
             (*cycle)->push_back(edgeMap[e]);
         }
     }

src/testbench/algebra/testing.h

@@ -40,7 +40,7 @@ namespace testing {
 
 #define ASSERT_APPROX_EQUAL( x, y, eps )                                   \
 {                                                                   \
-  if( abs(( x ) - ( y )) > eps )                                              \
+  if( std::abs(( x ) - ( y )) > eps )                                              \
   {                                                                 \
     throw std::runtime_error(   std::string( "Asserted approximate equality violated." )                  \
                               + std::string( "\nIn:" )              \

src/testbench/base/mcmtest.cc

@@ -9,6 +9,7 @@
 #include "mcmtest.h"
 #include "testing.h"
 #include <random>
+#include <type_traits>
 
 
 using namespace MaxPlus;
@@ -216,7 +217,7 @@ void MCMTest::test_yto() {
     ASSERT_THROW(eid == 6);
 
     // TODO: check of the cycle ratio are identical to old SDF3
-    CDouble expectedMinCycleRatios[] = {
+    std::array<CDouble,250> expectedMinCycleRatios = {
             0.526141,  0.124523,  0.0389826, 0.289127,   0.11451,    0.723313,   1.07027,
             0.956067,  0.570066,  0.746341,  0.33622,    0.475978,   0.902663,   1.02951,
             0.088711,  0.269878,  0.213763,  0.468927,   2.13632,    0.564086,   0.656227,
@@ -262,12 +263,12 @@ void MCMTest::test_yto() {
         //std::cout << "MCM: " << result << "cycle length: " << cycle->size() << std::endl;
     }
 
-    CDouble expectedMaxCycleRatios[] = {
+    std::array<CDouble, 25> expectedMaxCycleRatios = {
             304.647, 122.759, 104.209, 126.85,  1341.83, 135.611, 186.801, 151.854, 341.077,
             216.21,  148.74,  117.382, 127.863, 246.385, 92.0357, 72.9353, 124.893, 202.074,
             281.92,  481.408, 253.295, 849.381, 123.668, 64.0955, 219.92};
     // go through a bunch of (deterministic) big pseudo-random graphs
-    for (int k = 0; k < 25; k++) {
+    for (int k = 0; k < expectedMaxCycleRatios.size(); k++) {
         MCMgraph gr = makeRandomGraph(1000, 100000, k);
         result = maxCycleRatioAndCriticalCycleYoungTarjanOrlin(gr, &cycle);
         ASSERT_APPROX_EQUAL(expectedMaxCycleRatios[k], result, 1e-2);