some fixes

Author: MarcG-TUE

include/maxplus/base/fsm/fsm.h

@@ -771,7 +771,7 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
 
     Abstract::SetOfStateRefs getStateRefs() {
         Abstract::SetOfStateRefs result;
-        for (auto i : this->states) {
+        for (const auto& i : this->states) {
             result.insert(&(*(i.second)));
         }
         return result;
@@ -801,8 +801,8 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
     };
 
     void setEdgeLabel(const EdgeRef<StateLabelType, EdgeLabelType> &e, const EdgeLabelType &l) {
-        auto ee = std::dynamic_pointer_cast<Edge<StateLabelType, EdgeLabelType>>(
-                (*this->edges.find(e->getId())).second);
+        auto ee = dynamic_cast<Edge<StateLabelType, EdgeLabelType>*>(
+                (*this->edges.find(e->getId())).second.get());
         ee->setLabel(l);
     }
 
@@ -829,7 +829,7 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
         // get all labels
         const SetOfStates<StateLabelType, EdgeLabelType> &allStates = this->getStates();
 
-        for (auto iter : allStates) {
+        for (const auto& iter : allStates) {
             auto s = dynamic_cast<State<StateLabelType, EdgeLabelType> &>(*(iter.second));
             if (s.stateLabel == src) {
                 const StateRef<StateLabelType, EdgeLabelType> srcState = this->getStateLabeled(src);
@@ -856,7 +856,7 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
     std::unique_ptr<FiniteStateMachine<StateLabelType, EdgeLabelType>> determinizeEdgeLabels() {
         std::unique_ptr<FiniteStateMachine<StateLabelType, EdgeLabelType>> result =
                 std::unique_ptr<FiniteStateMachine<StateLabelType, EdgeLabelType>>(
-                        this->newInstance());
+                        dynamic_cast<FiniteStateMachine<StateLabelType, EdgeLabelType>*>(this->newInstance().release()));
 
         // maintain map of sets of states to the corresponding new states.
         std::map<const Abstract::SetOfStateRefs, const State<StateLabelType, EdgeLabelType> *>
@@ -876,7 +876,7 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
         result->setInitialState(si);
 
         // add initial state to list of unprocessed state sets
-        unprocessed.push_back(initialStateSet);
+        unprocessed.push_back(std::move(initialStateSet));
 
         while (!unprocessed.empty()) {
             Abstract::SetOfStateRefs *Q = (unprocessed.begin())->get();
@@ -1003,8 +1003,7 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
                         changed = true;
                     }
                 }
-                auto tempEqClasses = eqClasses;
-                eqClasses = newEqClasses;
+                eqClasses = std::move(newEqClasses);
             } while (changed);
         }
 
@@ -1054,12 +1053,12 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
                     changed = true;
                 }
             }
-            auto tempEqClasses = eqClasses;
-            eqClasses = newEqClasses;
+            eqClasses = std::move(newEqClasses);
         } while (changed);
 
         std::unique_ptr<FiniteStateMachine<StateLabelType, EdgeLabelType>> result =
-                this->newInstance();
+                std::unique_ptr<FiniteStateMachine<StateLabelType, EdgeLabelType>>(
+                        dynamic_cast<FiniteStateMachine<StateLabelType, EdgeLabelType>*>(this->newInstance().release()));
 
         // make a state for every equivalence class
         std::map<Abstract::SetOfStateRefs *, StateRef<StateLabelType, EdgeLabelType>> newStateMap;
@@ -1069,7 +1068,7 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
             const State<StateLabelType, EdgeLabelType> *s =
                     dynamic_cast<const State<StateLabelType, EdgeLabelType> *>(*(cli->begin()));
             auto ns = result->addState(s->stateLabel);
-            newStateMap[cli] = ns;
+            newStateMap[cli.get()] = ns;
             sid++;
         }
 
@@ -1081,7 +1080,7 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
             // for every outgoing edge
             for (const auto *edi : es) {
                 auto ed = dynamic_cast<EdgeRef<StateLabelType, EdgeLabelType>>(edi);
-                result->addEdge(*(newStateMap[cli]),
+                result->addEdge(*(newStateMap[cli.get()]),
                                 ed->getLabel(),
                                 *(newStateMap[eqMap[ed->getDestination()]]));
             }

include/maxplus/game/policyiteration.h

@@ -115,7 +115,7 @@ template <typename SL, typename EL> class PolicyIteration {
                 std::make_unique<StrategyVector<SL, EL>>();
         initialStrategy->initializeRandomStrategy(game);
 
-        return policyIteration(game, initialStrategy, epsilon);
+        return policyIteration(game, std::move(initialStrategy), epsilon);
     }
 
 private:
@@ -250,7 +250,7 @@ template <typename SL, typename EL> class PolicyIteration {
             improvement = false;
             // Evaluate the current strategies of both players.
             StrategyEvaluation evalResult =
-                    evaluateStrategy(game, s_i_t, d_prev, r_prev, dw2_prev, stateIds, epsilon);
+                    evaluateStrategy(game, *s_i_t, d_prev, r_prev, dw2_prev, stateIds, epsilon);
 
             // Update the current vectors.
             d_i_t = evalResult.d_i_t;
@@ -339,7 +339,7 @@ template <typename SL, typename EL> class PolicyIteration {
         // and the ratio of each cycle.
         DistanceResult dr = computeDistances(game,
                                              currentStrategy,
-                                             cycleResult.states,
+                                             *(cycleResult.states),
                                              r_i_t,
                                              distanceVector,
                                              ratioVector,
@@ -392,14 +392,14 @@ template <typename SL, typename EL> class PolicyIteration {
                 const State<SL, EL> *u = v;
                 while (visited[u] == BOTTOM_VERTEX) { // NOLINT(*pointer-arithmetic)
                     visited[u] = v; // NOLINT(*pointer-arithmetic)
-                    u = currentStrategy->getSuccessor(u);
+                    u = currentStrategy.getSuccessor(u);
                 }
                 if (visited[u] == v) { // NOLINT(*pointer-arithmetic)
                     const State<SL, EL> *v_s = u;
-                    const State<SL, EL> *x = currentStrategy->getSuccessor(u);
+                    const State<SL, EL> *x = currentStrategy.getSuccessor(u);
 
                     // Initialize both numerator and denominator.
-                    EdgeRef<SL, EL> e = game.getEdge(*u, *(currentStrategy->getSuccessor(u)));
+                    EdgeRef<SL, EL> e = game.getEdge(*u, *(currentStrategy.getSuccessor(u)));
                     auto w1sum = static_cast<CDouble>(game.getWeight1(e));
                     auto w2sum = static_cast<CDouble>(game.getWeight2(e));
 
@@ -411,13 +411,13 @@ template <typename SL, typename EL> class PolicyIteration {
                             v_s = x;
                         }
                         EdgeRef<SL, EL> x_succ =
-                                game.getEdge(*x, *(currentStrategy->getSuccessor(x)));
+                                game.getEdge(*x, *(currentStrategy.getSuccessor(x)));
                         auto w1 = static_cast<CDouble>(game.getWeight1(x_succ));
                         auto w2 = static_cast<CDouble>(game.getWeight2(x_succ));
 
                         w1sum += w1;
                         w2sum += w2;
-                        x = currentStrategy->getSuccessor(x);
+                        x = currentStrategy.getSuccessor(x);
                     }
                     // Store the cycle ratio for the cycle containing v_s.
                     r_i_t[v_s] = w1sum / w2sum; // NOLINT(*pointer-arithmetic)
@@ -427,7 +427,7 @@ template <typename SL, typename EL> class PolicyIteration {
         }
 
         CycleResult result;
-        result.states = selectedVertices;
+        result.states = std::move(selectedVertices);
         result.valueMap = r_i_t;
 
         return result;
@@ -492,7 +492,7 @@ template <typename SL, typename EL> class PolicyIteration {
                 while (!visited[u]) { // NOLINT(*pointer-arithmetic)
                     visited[u] = true; // NOLINT(*pointer-arithmetic)
                     stack.push(u);
-                    u = currentStrategy->getSuccessor(u);
+                    u = currentStrategy.getSuccessor(u);
                 }
                 while (!stack.empty()) {
                     const State<SL, EL> *x = stack.top();

src/base/analysis/mcm/mcmyto.cc

@@ -51,6 +51,7 @@
 #include <algorithm>
 #include <cassert>
 #include <cfloat>
+#include <cmath>
 #include <cstdint>
 
 namespace MaxPlus::Graphs {

src/testbench/graph/mpautomatontest.cc

@@ -122,7 +122,7 @@ void MPAutomatonTest::testMinimizeFSM() { // NOLINT(*to-static)
     fsa.setInitialState(*s0);
 
     const auto fsaMin = std::unique_ptr<FSM::Labeled::FiniteStateMachine<int, int>>(
-            fsa.minimizeEdgeLabels());
+            dynamic_cast<FSM::Labeled::FiniteStateMachine<int, int>*>(fsa.minimizeEdgeLabels().release()));
 
     std::cout << "Nr states: " << fsaMin->getStates().size() << "\n";
     std::cout << "Nr edges: " << fsaMin->getEdges().size() << "\n";