cleanup and fix test

Author: MarcG-TUE

include/maxplus/algebra/mpmatrix.h

@@ -58,7 +58,7 @@ using namespace Graphs;
  */
 class Vector {
 public:
-    explicit Vector(unsigned int size = 0, MPTime value = MP_MINUSINFINITY);
+    explicit Vector(unsigned int size = 0, MPTime value = MP_MINUS_INFINITY);
 
     explicit Vector(std::vector<MPTime> *v);
 
@@ -117,7 +117,7 @@ class Vector {
     /**
      * Get minimal finite element
      * returns the smallest among the finite elements in the vector or
-     * MP_MINUSINFINITY if no finite elements exist
+     * MP_MINUS_INFINITY if no finite elements exist
      * itsPosition returns the index of the (a) smallest finite element is set
      * to a pointer to unsigned int, otherwise set or defaults to NULL
      */
@@ -335,7 +335,7 @@ inline unsigned int VectorList::getSize() const { return static_cast<unsigned in
 inline void VectorList::grow() {
     auto last = static_cast<unsigned int>(this->size());
     this->resize(static_cast<size_t>(last + 1));
-    this->insert(this->begin() + last, std::make_unique<Vector>(oneVectorSize, MP_MINUSINFINITY));
+    this->insert(this->begin() + last, std::make_unique<Vector>(oneVectorSize, MP_MINUS_INFINITY));
 }
 
 } // namespace MaxPlus

include/maxplus/algebra/mpsparsematrix.h

@@ -64,7 +64,7 @@ using Ranges = std::vector<std::pair<unsigned int, unsigned int>>;
  */
 class SparseVector {
 public:
-    explicit SparseVector(unsigned int size = 0, MPTime value = MP_MINUSINFINITY);
+    explicit SparseVector(unsigned int size = 0, MPTime value = MP_MINUS_INFINITY);
 
     explicit SparseVector(const std::vector<MPTime> &v);
 
@@ -137,7 +137,7 @@ class SparseMatrix {
 public:
     explicit SparseMatrix(unsigned int rowSize = 0,
                           unsigned int colSize = 0,
-                          MPTime value = MP_MINUSINFINITY);
+                          MPTime value = MP_MINUS_INFINITY);
 
     SparseMatrix(const SparseMatrix &);
 
@@ -213,7 +213,7 @@ class SparseMatrix {
     SparseMatrix combine(const SparseMatrix &M, MPTime f(MPTime a, MPTime b));
     Matrix reduceRows();
     std::pair<Matrix, Sizes> reduceRowsAndColumns();
-    static SparseMatrix expand(const Matrix &M, const Sizes &rszs, const Sizes &cszs);
+    static SparseMatrix expand(const Matrix &M, const Sizes &rsz_s, const Sizes &csz_s);
     [[nodiscard]] Sizes sizes() const;
 };
 

include/maxplus/algebra/mptype.h

@@ -116,15 +116,15 @@ inline CDouble MP_MIN(CDouble a, CDouble b) { return CDouble(MP_MIN(MPTime(a), M
 //==============================
 
 // the quick and dirty way of representing -infinity
-const MPTime MP_MINUSINFINITY = MPTime(-1.0e+30);
-const MPTime MP_MINUSINFINITY_THR = MPTime(-0.5e+30);
+const MPTime MP_MINUS_INFINITY = MPTime(-1.0e+30);
+const MPTime MP_MINUS_INFINITY_THR = MPTime(-0.5e+30);
 const CDouble MPTIME_MIN_INF_VALPTHR = -0.5e+30;
-inline bool MP_ISMINUSINFINITY(CDouble a) { return a <= MPTIME_MIN_INF_VALPTHR; }
-inline bool MP_ISMINUSINFINITY(MPTime a) { return a <= MP_MINUSINFINITY_THR; }
+inline bool MP_IS_MINUS_INFINITY(CDouble a) { return a <= MPTIME_MIN_INF_VALPTHR; }
+inline bool MP_IS_MINUS_INFINITY(MPTime a) { return a <= MP_MINUS_INFINITY_THR; }
 
 inline MPTime MP_PLUS(CDouble a, CDouble b) {
-    return (MP_ISMINUSINFINITY(a) || MP_ISMINUSINFINITY(b))
-                   ? MP_MINUSINFINITY
+    return (MP_IS_MINUS_INFINITY(a) || MP_IS_MINUS_INFINITY(b))
+                   ? MP_MINUS_INFINITY
                    : MPTime(static_cast<CDouble>(a) + static_cast<CDouble>(b));
 }
 
@@ -162,11 +162,11 @@ inline MPTime &MPTime::operator-() {
 inline MPTime operator*(MPTime a, MPTime b) {
     if (a.isMinusInfinity()) {
         assert(((CDouble)b) > 0.0);
-        return MP_MINUSINFINITY;
+        return MP_MINUS_INFINITY;
     }
     if (b.isMinusInfinity()) {
         assert(((CDouble)a) > 0.0);
-        return MP_MINUSINFINITY;
+        return MP_MINUS_INFINITY;
     }
     return MPTime(static_cast<CDouble>(a) * static_cast<CDouble>(b));
 }
@@ -198,7 +198,7 @@ inline bool MPTime::operator<=(MPTime a) const { return this->myVal <= a.myVal;
 
 inline bool MPTime::operator>=(MPTime a) const { return this->myVal >= a.myVal; }
 
-inline bool MPTime::isMinusInfinity() const { return MP_ISMINUSINFINITY(this->myVal); }
+inline bool MPTime::isMinusInfinity() const { return MP_IS_MINUS_INFINITY(this->myVal); }
 
 inline MPTime MPTime::fabs() const { return MPTime(std::fabs(this->myVal)); }
 

include/maxplus/base/fsm/iofsm.h

@@ -11,6 +11,7 @@ using InputAction = CString;
 using OutputAction = CString;
 using IOAEdgeLabel = std::pair<InputAction, OutputAction>;
 using IOAState = ::FSM::Labeled::State<CId, IOAEdgeLabel>;
+using IOAStateRef = const IOAState*;
 using IOAEdge = ::FSM::Labeled::Edge<CId, IOAEdgeLabel>;
 using IOASetOfStates = ::FSM::Labeled::SetOfStates<CId, CString>;
 using IOASetOfStateRefs = ::FSM::Labeled::SetOfStateRefs<CId, CString>;

include/maxplus/game/policyiteration.h

@@ -118,7 +118,7 @@ template <typename SL, typename EL> class PolicyIteration {
     PolicyIterationResult policyIteration(RatioGame<SL, EL> &game,
                                           std::shared_ptr<StrategyVector<SL, EL>> initialStrategy,
                                           CDouble epsilon) {
-        SetOfStates<SL, EL> &states = game.getStates();
+        const SetOfStates<SL, EL> &states = game.getStates();
 
         bool improvement = true;
 
@@ -366,7 +366,7 @@ template <typename SL, typename EL> class PolicyIteration {
     CycleResult findCyclesInRestrictedGraph(RatioGame<SL, EL> &game,
                                             std::shared_ptr<StrategyVector<SL, EL>> currentStrategy,
                                             std::map<const State<SL, EL> *, CDouble> &stateIds) {
-        SetOfStates<SL, EL> &states = game.getStates();
+        const SetOfStates<SL, EL> &states = game.getStates();
         const State<SL, EL> *BOTTOM_VERTEX = nullptr;
 
         std::shared_ptr<FSM::Abstract::SetOfStateRefs> selectedVertices =
@@ -455,7 +455,7 @@ template <typename SL, typename EL> class PolicyIteration {
                      std::map<const State<SL, EL> *, CDouble> &r_prev,
                      std::map<const State<SL, EL> *, CDouble> &dw2_prev,
                      CDouble epsilon) {
-        SetOfStates<SL, EL> &states = game.getStates();
+        const SetOfStates<SL, EL> &states = game.getStates();
 
         std::stack<const State<SL, EL> *> stack;
         // Initialize visited vector.

include/maxplus/graph/smpls.h

@@ -60,7 +60,7 @@ class EdgeLabeledModeFSM : public ::FSM::Labeled::FiniteStateMachine<CId, CStrin
 public:
     // put the destructor deliberately into the cc sourc to ensure the class vtable is accessible
     // see: <https://stackoverflow.com/questions/3065154/undefined-reference-to-vtable>
-    virtual ~EdgeLabeledModeFSM();
+     ~EdgeLabeledModeFSM() override;
     virtual void removeDanglingStates();
 };
 
@@ -89,6 +89,7 @@ class DissectedModeMatrix {
 
 using Mode = InputAction;
 using Event = OutputAction;
+using EventList = std::list<Event>;
 using EventOutcome = CString;
 
 using ModeEventPair = std::pair<Mode,Event>;
@@ -153,18 +154,18 @@ class SMPLSwithEvents : public SMPLS {
      * recursive part of isConsistent
      */
     void isConsistentUtil(const IOAState &s,
-                          std::list<Event> &eventList,
+                          EventList &eventList,
                           const IOASetOfStates &finalStates,
                           CString &errMsg,
-                          std::map<const IOAState *, std::list<Event> *> &visited);
+                          std::map<IOAStateRef,EventList> &visited);
 
     void determinizeUtil(const IOAState &s,
                          IOASetOfStateRefs& visited,
                          const IOASetOfStates &finalStates,
-                         CString *errMsg,
+                         CString &errMsg,
                          std::ofstream &outfile);
 
-    static bool compareEventLists(std::list<Event>& l1, std::list<Event>& l2);
+    static bool compareEventLists(EventList& l1, EventList& l2);
 
     void dissectModeMatrices();
 };