Skip to content

Commit f70842e

Browse files
MarcG-TUEMarcG-TUE
committed
sync
1 parent 451ee18 commit f70842e

File tree

4 files changed

+57
-57
lines changed

4 files changed

+57
-57
lines changed

‎include/maxplus/base/fsm/fsm.h‎

Lines changed: 49 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -196,7 +196,7 @@ class FiniteStateMachine {
196196
FiniteStateMachine &operator=(FiniteStateMachine &&) = delete;
197197
virtual std::shared_ptr<FiniteStateMachine> newInstance() = 0;
198198

199-
[[nodiscard]] virtual State &getInitialState() = 0;
199+
[[nodiscard]] virtual State &getInitialState() const = 0;
200200
};
201201

202202
//
@@ -330,6 +330,7 @@ template <typename StateLabelType, typename EdgeLabelType> class Edge : public A
330330
Abstract::Edge(src, dst), label(lbl) {}
331331

332332
[[nodiscard]] const EdgeLabelType &getLabel() const { return this->label; }
333+
void setLabel(EdgeLabelType l) { this->label = l; }
333334

334335
private:
335336
EdgeLabelType label;
@@ -442,6 +443,7 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
442443
return &s;
443444
};
444445

446+
445447
Edge<StateLabelType, EdgeLabelType> *addEdge(const State<StateLabelType, EdgeLabelType> &src,
446448
EdgeLabelType lbl,
447449
const State<StateLabelType, EdgeLabelType> &dst) {
@@ -486,7 +488,7 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
486488
this->initialState = &s;
487489
};
488490

489-
[[nodiscard]] State<StateLabelType, EdgeLabelType> &getInitialState() override {
491+
[[nodiscard]] State<StateLabelType, EdgeLabelType> &getInitialState() const override {
490492
return *this->initialState;
491493
};
492494

@@ -523,6 +525,13 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
523525
};
524526

525527
SetOfStates<StateLabelType, EdgeLabelType> &getStates() { return this->states; };
528+
Abstract::SetOfStateRefs getStateRefs() {
529+
Abstract::SetOfStateRefs result;
530+
for (auto i: this->states) {
531+
result.insert(&(*(i.second)));
532+
}
533+
return result;
534+
};
526535

527536
Abstract::SetOfEdges &getEdges() { return this->edges; };
528537

@@ -679,47 +688,42 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
679688
return result;
680689
};
681690

682-
using EquivalenceMap = std::map<State<StateLabelType, EdgeLabelType> *,
683-
SetOfStates<StateLabelType, EdgeLabelType> *>;
691+
using EquivalenceMap = std::map<const Abstract::State*,
692+
std::shared_ptr<Abstract::SetOfStateRefs>>;
684693

685694
// minimize the automaton based on edge labels only.
686695
std::shared_ptr<FiniteStateMachine<StateLabelType, EdgeLabelType>> minimizeEdgeLabels() {
687696
// partition refinement algorithm
688697

689698
// generate a vector of equivalence classes
690-
std::shared_ptr<std::list<std::shared_ptr<Abstract::SetOfStateRefs>>> eqClasses =
691-
std::make_shared<std::list<std::shared_ptr<Abstract::SetOfStateRefs>>>();
699+
std::list<std::shared_ptr<Abstract::SetOfStateRefs>> eqClasses;
692700

693701
// populate it with s set of all states
694-
std::shared_ptr<Abstract::SetOfStateRefs> initialClass =
695-
std::make_shared<Abstract::SetOfStateRefs>(*(this->getStates()));
696-
eqClasses->push_back(initialClass);
702+
std::shared_ptr<Abstract::SetOfStateRefs> initialClass = std::make_shared<Abstract::SetOfStateRefs>(this->getStateRefs());
703+
eqClasses.push_back(initialClass);
697704

698705
// initially map all state to the initial class
699706
EquivalenceMap eqMap;
700707
for (const auto *si : *initialClass) {
701-
eqMap[*si] = initialClass;
708+
auto sp = dynamic_cast<const State<StateLabelType, EdgeLabelType>*>(si);
709+
eqMap[sp] = initialClass;
702710
}
703711

704712
// partition refinement
705713
bool changed = false;
706714
do {
707715
changed = false;
708716

709-
std::shared_ptr<std::list<std::shared_ptr<Abstract::SetOfStateRefs>>> newEqClasses =
710-
std::make_shared<std::list<std::shared_ptr<Abstract::SetOfStateRefs>>>();
717+
std::list<std::shared_ptr<Abstract::SetOfStateRefs>> newEqClasses;
711718

712719
// for every potential equivalence class
713-
for (const auto &ic : *eqClasses) {
720+
for (const auto &ic : eqClasses) {
714721
std::shared_ptr<Abstract::SetOfStateRefs> _class = ic;
715722

716-
typename SetOfStates<StateLabelType, EdgeLabelType>::iterator i;
717-
i = _class->begin();
723+
auto i = _class->begin();
718724

719725
// pick arbitrary state from class
720-
State<StateLabelType, EdgeLabelType> *s1 = nullptr;
721-
State<StateLabelType, EdgeLabelType> *s2 = nullptr;
722-
s1 = *i;
726+
auto s1 = dynamic_cast<const State<StateLabelType, EdgeLabelType> *>(*i);
723727

724728
std::shared_ptr<Abstract::SetOfStateRefs> equivSet =
725729
std::make_shared<Abstract::SetOfStateRefs>();
@@ -730,7 +734,7 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
730734
// check whether all other states can go with the same label to
731735
// the same set of other equivalence classes.
732736
while (++i != _class->end()) {
733-
s2 = *i;
737+
auto s2 = dynamic_cast<const State<StateLabelType, EdgeLabelType> *>(*i);
734738
if (this->edgesEquivalent(eqMap, s1, s2)) {
735739
equivSet->insert(s2);
736740
} else {
@@ -739,12 +743,12 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
739743
}
740744
// if not, split the class
741745
if (equivSet->size() == _class->size()) {
742-
newEqClasses->push_back(equivSet);
746+
newEqClasses.push_back(equivSet);
743747
this->mapStates(eqMap, equivSet);
744748
} else {
745-
newEqClasses->push_back(equivSet);
749+
newEqClasses.push_back(equivSet);
746750
this->mapStates(eqMap, equivSet);
747-
newEqClasses->push_back(remainingSet);
751+
newEqClasses.push_back(remainingSet);
748752
this->mapStates(eqMap, remainingSet);
749753
changed = true;
750754
}
@@ -753,35 +757,34 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
753757
eqClasses = newEqClasses;
754758
} while (changed);
755759

756-
std::shared_ptr<FiniteStateMachine<StateLabelType, EdgeLabelType>> result =
757-
std::make_shared<FiniteStateMachine<StateLabelType, EdgeLabelType>>();
760+
auto result = std::dynamic_pointer_cast<FiniteStateMachine<StateLabelType,EdgeLabelType>>(this->newInstance());
758761

759762
// make a state for every equivalence class
760-
std::map<Abstract::SetOfStateRefs *, State<StateLabelType, EdgeLabelType> *> newStateMap;
763+
std::map<std::shared_ptr<Abstract::SetOfStateRefs>, State<StateLabelType, EdgeLabelType> *> newStateMap;
761764
CId sid = 0;
762-
for (const auto &cli : *eqClasses) {
763-
std::shared_ptr<State<StateLabelType, EdgeLabelType>> ns =
764-
std::make_shared<State<StateLabelType, EdgeLabelType>>(sid);
765-
result->addState(ns);
766-
newStateMap[*cli] = ns;
765+
for (const auto &cli : eqClasses) {
766+
// take state label from arbitrary state from the class
767+
const State<StateLabelType, EdgeLabelType>* s = dynamic_cast<const State<StateLabelType, EdgeLabelType>*>(*(cli->begin()));
768+
auto ns = result->addState(s->stateLabel);
769+
newStateMap[cli] = ns;
767770
sid++;
768771
}
769772

770773
// make the appropriate edges
771-
for (const auto &cli : *eqClasses) {
774+
for (const auto &cli : eqClasses) {
772775
// take a representative state
773776
const auto *s = *(cli->begin());
774777
auto es = s->getOutgoingEdges();
775778
// for every outgoing edge
776779
for (auto *edi : es) {
777780
auto ed = dynamic_cast<Edge<StateLabelType, EdgeLabelType> *>(edi);
778781
result->addEdge(
779-
newStateMap[*cli], ed->label, newStateMap[eqMap[ed->getDestination()]]);
782+
*(newStateMap[cli]), ed->getLabel(), *(newStateMap[eqMap[&(ed->getDestination())]]));
780783
}
781784
}
782785

783786
// set initial state
784-
result->setInitialState(newStateMap[eqMap[this->getInitialState()]]);
787+
result->setInitialState(*(newStateMap[eqMap[&(this->getInitialState())]]));
785788

786789
return result;
787790
}
@@ -800,8 +803,8 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
800803

801804
// function only used by minimizeEdgeLabels
802805
bool edgesEquivalent(EquivalenceMap &m,
803-
State<StateLabelType, EdgeLabelType> *s1,
804-
State<StateLabelType, EdgeLabelType> *s2) {
806+
const State<StateLabelType, EdgeLabelType> *s1,
807+
const State<StateLabelType, EdgeLabelType> *s2) {
805808
// s1 and s2 are equivalent if for every s1-a->C, s2-a->C
806809
// and vice versa
807810
std::set<EdgeLabelType> labels;
@@ -812,17 +815,17 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
812815
typename std::set<EdgeLabelType>::const_iterator k;
813816
for (k = labels.begin(); k != labels.end(); k++) {
814817
EdgeLabelType l = *k;
815-
SetOfStates<StateLabelType, EdgeLabelType> *ns1 = s1->nextStatesOfEdgeLabel(l);
816-
SetOfStates<StateLabelType, EdgeLabelType> *ns2 = s2->nextStatesOfEdgeLabel(l);
818+
std::shared_ptr<Abstract::SetOfStateRefs> ns1 = s1->nextStatesOfEdgeLabel(l);
819+
std::shared_ptr<Abstract::SetOfStateRefs> ns2 = s2->nextStatesOfEdgeLabel(l);
817820
// collect classes of states in ns1 and ns2
818821
std::set<SetOfStates<StateLabelType, EdgeLabelType> *> cs1;
819822
std::set<SetOfStates<StateLabelType, EdgeLabelType> *> cs2;
820-
for (auto j : ns1) {
821-
auto s = *j;
823+
for (auto j : *ns1) {
824+
auto s = j;
822825
cs1.insert(m[s]);
823826
}
824-
for (auto j : ns2) {
825-
auto s = *j;
827+
for (auto j : *ns2) {
828+
auto s = j;
826829
cs2.insert(m[s]);
827830
}
828831

@@ -835,10 +838,9 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
835838
}
836839

837840
// function only used by minimizeEdgeLabels
838-
void mapStates(EquivalenceMap &m, SetOfStates<StateLabelType, EdgeLabelType> *sos) {
839-
for (auto i : sos) {
840-
auto s = *i;
841-
m[s] = sos;
841+
void mapStates(EquivalenceMap &m, std::shared_ptr<Abstract::SetOfStateRefs>& sos) {
842+
for (auto i : *sos) {
843+
m[i] = sos;
842844
}
843845
}
844846
};
@@ -888,7 +890,7 @@ class State : public Labeled::State<CString, char> {
888890

889891
class FiniteStateMachine : public Labeled::FiniteStateMachine<CString, char> {
890892
public:
891-
State &getInitialState() {
893+
State &getInitialState() const {
892894
return dynamic_cast<State &>(Labeled::FiniteStateMachine<CString, char>::getInitialState());
893895
};
894896

@@ -930,7 +932,7 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
930932
const Abstract::FiniteStateMachine &fsm2) :
931933
fsm_a(fsm1), fsm_b(fsm2) {}
932934

933-
State &getInitialState();
935+
State &getInitialState() const;
934936

935937
[[nodiscard]] virtual bool matchEdges(const Abstract::Edge &e1,
936938
const Abstract::Edge &e2) const = 0;

‎include/maxplus/graph/mpautomaton.h‎

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -54,9 +54,11 @@ using namespace ::FSM::Labeled;
5454
*/
5555
using MPAStateLabel = struct MPAStateLabel {
5656
CId id;
57-
unsigned int tokenNr;
57+
int tokenNr; // use -1 to indicate unassigned
5858
};
5959

60+
61+
6062
/**
6163
* Create a new state label.
6264
* @param stateId FSM state id
@@ -69,6 +71,7 @@ inline MPAStateLabel makeMPAStateLabel(CId stateId, unsigned int tokenId) {
6971
return sl;
7072
}
7173

74+
7275
inline bool operator==(const MPAStateLabel& s, const MPAStateLabel& t) {
7376
return s.id == t.id && s.tokenNr == t.tokenNr;
7477
}
@@ -143,7 +146,8 @@ using MPASetOfEdges = ::FSM::Abstract::SetOfEdges;
143146
class MaxPlusAutomaton : public ::FSM::Labeled::FiniteStateMachine<MPAStateLabel, MPAEdgeLabel> {
144147
public:
145148
// Destructor.
146-
~MaxPlusAutomaton() override= default;;
149+
~MaxPlusAutomaton() override= default;
150+
147151
};
148152

149153
/**

‎log.txt‎

Lines changed: 0 additions & 8 deletions
This file was deleted.

‎src/testbench/graph/mpautomatontest.cc‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -88,6 +88,8 @@ void MPAutomatonTest::testDeterminizeFSM() {
8888
ASSERT_THROW(mpaDeterminized->getStates().size() == 2);
8989
ASSERT_THROW(mpaDeterminized->getEdges().size()==3);
9090

91+
auto mpaMin = mpa.minimizeEdgeLabels();
92+
9193
// TODO: implement MCR on MaxPlusAutomatonWithRewards and MCM on MaxPlusAutomaton
9294
// CDouble mcr = mpaDeterminized->calculateMCR();
9395
// std::cout << "MCR: " << mcr << std::endl;

0 commit comments

Comments
 (0)