old/formalang
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

refactor

Browse source
This commit is contained in:
MaxanRus 2021-10-05 16:11:24 +03:00
parent 32f8a3dcc6
commit 1fd4158840
22 changed files with 175 additions and 574 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
CMakeLists.txt
View file

@ -18,14 +18,12 @@ set(CMAKE_CXX_STANDARD 17)
set(SOURCE_FILES
src/regular/RegularTree.cpp
src/regular/RegularTreeNode.cpp
src/NFA/NFATree.cpp
src/NFA/NFAGraph.cpp
src/NFA/NFATreeVertex.cpp
src/converters/RegularToNFA.cpp
src/converters/NFAToDFA.cpp
src/DFA/DFAGraph.cpp
src/DFA/DFAGraphVertex.cpp
# src/FDFA/FDFAGraph.cpp
# src/FDFA/FDFAGraphVertex.cpp
src/converters/DFAToFDFA.cpp
src/converters/DFAToMinDFA.cpp
src/converters/DFAToRegular.cpp

67
include/FDFA/FDFAGraph.hpp
View file

@ -1,67 +0,0 @@
#pragma once
#include <map>
#include <vector>
#include <set>
#include <memory>
namespace FDFA {
class FDFAGraph {
public:
class Vertex {
public:
Vertex(FDFAGraph* owner);
bool IsFinal() const;
bool IsStart() const;
size_t GetNumber() const;
const std::map<char, size_t>& GetTransitions() const;
const std::map<char, size_t>& GetBackTransitions() const;
void AddEdge(char, size_t);
void RemoveEdge(char);
void SetOwner(FDFAGraph* owner);
void SetFinal(bool status);
void SetStart(bool status);
private:
FDFAGraph* owner_;
std::map<char, size_t> transitions_;
std::map<char, size_t> back_transitions_;
size_t number_;
bool is_final_ = false;
bool is_start_ = false;
friend class FDFAGraph;
};
FDFAGraph() = default;
FDFAGraph(const FDFAGraph&) = delete;
FDFAGraph(FDFAGraph&&) = default;
FDFAGraph& operator=(const FDFAGraph&) = delete;
FDFAGraph& operator=(FDFAGraph&&) = default;
size_t AddNewVertex();
void AddFinalVertex(size_t number);
void AddStartVertex(size_t number);
void RemoveVertex(size_t number);
void RemoveFinalVertex(size_t number);
void RemoveStartVertex(size_t number);
std::shared_ptr<Vertex> GetVertex(size_t number);
size_t GetCountVertexes() const;
const std::vector<size_t>& GetFinalVertexes() const;
const std::vector<size_t>& GetStartVertexes() const;
void Print() const;
bool Accepted(const std::string&) const;
private:
size_t count_vertexes_ = 0;
std::map<size_t, std::shared_ptr<Vertex>> vertexes_;
std::vector<size_t> final_vertexes_;
std::vector<size_t> start_vertexes_;
};
}

22
include/NFA/NFATree.hpp → include/NFA/NFAGraph.hpp
View file

@ -6,11 +6,11 @@
#include <memory>
namespace NFA {
class NFATree {
class NFAGraph {
public:
class Vertex {
public:
Vertex(NFATree* owner);
Vertex(NFAGraph* owner);
bool IsFinal() const;
bool IsStart() const;
@ -21,11 +21,11 @@ class NFATree {
void AddEdge(char, size_t);
void RemoveEdge(char, size_t);
void SetOwner(NFATree* owner);
void SetOwner(NFAGraph* owner);
void SetFinal(bool status);
void SetStart(bool status);
private:
NFATree* owner_;
NFAGraph* owner_;
std::map<char, std::set<size_t>> transitions_;
std::map<char, std::set<size_t>> back_transitions_;
@ -33,15 +33,15 @@ class NFATree {
bool is_final_ = false;
bool is_start_ = false;
friend class NFATree;
friend class NFAGraph;
};
NFATree() = default;
NFATree(const NFATree&) = delete;
NFATree(NFATree&&);
NFAGraph() = default;
NFAGraph(const NFAGraph&) = delete;
NFAGraph(NFAGraph&&);
NFATree& operator=(const NFATree&) = delete;
NFATree& operator=(NFATree&&);
NFAGraph& operator=(const NFAGraph&) = delete;
NFAGraph& operator=(NFAGraph&&);
size_t AddNewVertex();
void AddFinalVertex(size_t number);
@ -51,7 +51,7 @@ class NFATree {
void RemoveFinalVertex(size_t number);
void RemoveStartVertex(size_t number);
void Composition(NFATree&&,
void Composition(NFAGraph&&,
std::vector<size_t> start_vertexes,
std::vector<size_t> final_vertexes);

3
include/converters/DFAToFDFA.hpp
View file

@ -1,10 +1,7 @@
#pragma once
#include "DFA/DFAGraph.hpp"
#include "FDFA/FDFAGraph.hpp"
namespace converters {
using namespace DFA;
using namespace FDFA;
DFAGraph DFAGraphToFDFAGraph(DFAGraph&&, const std::vector<char>& alphabet);
// FDFAGraph DFAGraphToFDFAGraph(DFAGraph&&, const std::vector<char>& alphabet);
}

2
include/converters/DFAToMinDFA.hpp
View file

@ -3,5 +3,5 @@
namespace converters {
using namespace DFA;
DFAGraph DFAToMinDFA(DFAGraph&&);
DFAGraph DFAGraphToMinDFAGraph(DFAGraph&&);
}

12
include/converters/NFAToDFA.hpp
View file

@ -1,13 +1,13 @@
#pragma once
#include "NFA/NFATree.hpp"
#include "NFA/NFAGraph.hpp"
#include "DFA/DFAGraph.hpp"
namespace converters {
using namespace NFA;
using namespace DFA;
NFATree AddAllEpsilonTransitions(NFATree&&);
NFATree AddAllPossibleStartFilnal(NFATree&&);
NFATree DeleteEpsilonTransitions(NFATree&&);
NFATree DeleteTransitionsByOneLetter(NFATree&&);
DFAGraph NFATreeToDFAGraph(NFATree&&);
NFAGraph AddAllEpsilonTransitions(NFAGraph&&);
NFAGraph AddAllPossibleStartFinal(NFAGraph&&);
NFAGraph DeleteEpsilonTransitions(NFAGraph&&);
NFAGraph DeleteTransitionsByOneLetter(NFAGraph&&);
DFAGraph NFAGraphToDFAGraph(NFAGraph&&);
}

4
include/converters/RegularToNFA.hpp
View file

@ -1,10 +1,10 @@
#pragma once
#include "regular/RegularTree.hpp"
#include "NFA/NFATree.hpp"
#include "NFA/NFAGraph.hpp"
namespace converters {
using namespace NFA;
using namespace regular;
NFATree RegularToNFA(RegularTree&&);
NFAGraph RegularToNFAGraph(RegularTree&&);
}

1
include/regular/RegularTree.hpp
View file

@ -1,5 +1,4 @@
#pragma once
#include <variant>
#include <vector>
#include <memory>
#include <string>

1
src/DFA/DFAGraphVertex.cpp
View file

@ -1,5 +1,4 @@
#include "DFA/DFAGraph.hpp"
#include <iostream>
using Vertex = DFA::DFAGraph::Vertex;

98
src/FDFA/FDFAGraph.cpp
View file

@ -1,98 +0,0 @@
#include "FDFA/FDFAGraph.hpp"
#include <algorithm>
#include <iostream>
namespace FDFA {
size_t FDFAGraph::AddNewVertex() {
vertexes_[count_vertexes_] = std::make_shared<Vertex>(this);
vertexes_[count_vertexes_]->number_ = count_vertexes_;
return count_vertexes_++;
}
void FDFAGraph::AddFinalVertex(size_t number) {
if (!vertexes_[number]->is_final_) {
vertexes_[number]->is_final_ = true;
final_vertexes_.push_back(number);
}
}
void FDFAGraph::AddStartVertex(size_t number) {
if (!vertexes_[number]->is_start_) {
vertexes_[number]->is_start_ = true;
start_vertexes_.push_back(number);
}
}
void FDFAGraph::RemoveVertex(size_t number) {
RemoveFinalVertex(number);
RemoveStartVertex(number);
vertexes_.erase(number);
}
void FDFAGraph::RemoveFinalVertex(size_t number) {
for (size_t i = 0; i < final_vertexes_.size(); ++i) {
if (final_vertexes_[i] == number) {
vertexes_[number]->is_final_ = false;
std::swap(final_vertexes_[i], final_vertexes_.back());
final_vertexes_.pop_back();
break;
}
}
}
void FDFAGraph::RemoveStartVertex(size_t number) {
for (size_t i = 0; i < start_vertexes_.size(); ++i) {
if (start_vertexes_[i] == number) {
vertexes_[number]->is_start_ = false;
std::swap(start_vertexes_[i], start_vertexes_.back());
start_vertexes_.pop_back();
break;
}
}
}
std::shared_ptr<FDFAGraph::Vertex> FDFAGraph::GetVertex(size_t number) {
if (vertexes_.count(number))
return vertexes_[number];
return nullptr;
}
size_t FDFAGraph::GetCountVertexes() const {
return count_vertexes_;
}
const std::vector<size_t>& FDFAGraph::GetFinalVertexes() const {
return final_vertexes_;
}
const std::vector<size_t>& FDFAGraph::GetStartVertexes() const {
return start_vertexes_;
}
void FDFAGraph::Print() const {
for (auto i: vertexes_) {
std::cout << i.second->number_ << " " << "f-" << i.second->is_final_ << " s-" <<
i.second->is_start_ << std::endl;
}
for (auto& i: vertexes_) {
for (auto& j: i.second->transitions_) {
std::cout << i.second->number_ << "->" << j.second << " <" << j.first << ">" <<
std::endl;
}
}
std::cout << std::endl;
}
bool FDFAGraph::Accepted(const std::string& str) const {
std::shared_ptr<const Vertex> current = vertexes_.at(start_vertexes_[0]);
for (auto i: str) {
if (current->GetTransitions().count(i)) {
current = vertexes_.at(current->GetTransitions().at(i));
} else {
return false;
}
}
return current->IsFinal();
}
}

58
src/FDFA/FDFAGraphVertex.cpp
View file

@ -1,58 +0,0 @@
#include "FDFA/FDFAGraph.hpp"
#include <iostream>
using Vertex = FDFA::FDFAGraph::Vertex;
Vertex::Vertex(FDFAGraph* owner) : owner_(owner) {}
bool Vertex::IsFinal() const {
return is_final_;
}
bool Vertex::IsStart() const {
return is_start_;
}
size_t Vertex::GetNumber() const {
return number_;
}
const std::map<char, size_t>& Vertex::GetTransitions() const {
return transitions_;
}
const std::map<char, size_t>& Vertex::GetBackTransitions() const {
return back_transitions_;
}
void Vertex::AddEdge(char symbol, size_t number) {
transitions_[symbol] = number;
owner_->GetVertex(number)->back_transitions_[symbol] = number_;
}
void Vertex::RemoveEdge(char symbol) {
owner_->GetVertex(transitions_[symbol])->back_transitions_.erase(symbol);
transitions_.erase(symbol);
}
void Vertex::SetOwner(FDFAGraph* owner) {
owner_ = owner;
}
void Vertex::SetFinal(bool status) {
if (status != is_final_) {
if (status)
owner_->AddFinalVertex(number_);
else
owner_->RemoveFinalVertex(number_);
}
}
void Vertex::SetStart(bool status) {
if (status != is_start_) {
if (status)
owner_->AddStartVertex(number_);
else
owner_->RemoveStartVertex(number_);
}
}

36
src/NFA/NFATree.cpp → src/NFA/NFAGraph.cpp
View file

@ -1,9 +1,9 @@
#include "NFA/NFATree.hpp"
#include "NFA/NFAGraph.hpp"
#include <algorithm>
#include <iostream>
namespace NFA {
NFATree::NFATree(NFATree&& another) {
NFAGraph::NFAGraph(NFAGraph&& another) {
std::swap(count_vertexes_, another.count_vertexes_);
std::swap(vertexes_, another.vertexes_);
std::swap(final_vertexes_, another.final_vertexes_);
@ -15,7 +15,7 @@ NFATree::NFATree(NFATree&& another) {
i.second->owner_ = &another;
}
NFATree& NFATree::operator=(NFATree&& another) {
NFAGraph& NFAGraph::operator=(NFAGraph&& another) {
std::swap(count_vertexes_, another.count_vertexes_);
std::swap(vertexes_, another.vertexes_);
std::swap(final_vertexes_, another.final_vertexes_);
@ -28,33 +28,33 @@ NFATree& NFATree::operator=(NFATree&& another) {
return *this;
}
size_t NFATree::AddNewVertex() {
size_t NFAGraph::AddNewVertex() {
vertexes_[count_vertexes_] = std::make_shared<Vertex>(this);
vertexes_[count_vertexes_]->number_ = count_vertexes_;
return count_vertexes_++;
}
void NFATree::AddFinalVertex(size_t number) {
void NFAGraph::AddFinalVertex(size_t number) {
if (!vertexes_[number]->is_final_) {
vertexes_[number]->is_final_ = true;
final_vertexes_.push_back(number);
}
}
void NFATree::AddStartVertex(size_t number) {
void NFAGraph::AddStartVertex(size_t number) {
if (!vertexes_[number]->is_start_) {
vertexes_[number]->is_start_ = true;
start_vertexes_.push_back(number);
}
}
void NFATree::RemoveVertex(size_t number) {
void NFAGraph::RemoveVertex(size_t number) {
RemoveFinalVertex(number);
RemoveStartVertex(number);
vertexes_.erase(number);
}
void NFATree::RemoveFinalVertex(size_t number) {
void NFAGraph::RemoveFinalVertex(size_t number) {
for (size_t i = 0; i < final_vertexes_.size(); ++i) {
if (final_vertexes_[i] == number) {
vertexes_[number]->is_final_ = false;
@ -65,7 +65,7 @@ void NFATree::RemoveFinalVertex(size_t number) {
}
}
void NFATree::RemoveStartVertex(size_t number) {
void NFAGraph::RemoveStartVertex(size_t number) {
for (size_t i = 0; i < start_vertexes_.size(); ++i) {
if (start_vertexes_[i] == number) {
vertexes_[number]->is_start_ = false;
@ -76,15 +76,15 @@ void NFATree::RemoveStartVertex(size_t number) {
}
}
void NFATree::Composition(NFATree&& tree,
void NFAGraph::Composition(NFAGraph&& nfa_graph,
std::vector<size_t> start_vertexes,
std::vector<size_t> final_vertexes) {
auto add_final_vertexes = tree.final_vertexes_;
auto add_start_vertexes = tree.start_vertexes_;
auto add_final_vertexes = nfa_graph.final_vertexes_;
auto add_start_vertexes = nfa_graph.start_vertexes_;
size_t new_count_vertexes = count_vertexes_;
for (auto& i: tree.vertexes_) {
for (auto& i: nfa_graph.vertexes_) {
new_count_vertexes = std::max(new_count_vertexes, i.first + count_vertexes_ + 1);
i.second->number_ += count_vertexes_;
std::map<char, std::set<size_t>> new_transitions;
@ -135,25 +135,25 @@ void NFATree::Composition(NFATree&& tree,
}
}
std::shared_ptr<NFATree::Vertex> NFATree::GetVertex(size_t number) {
std::shared_ptr<NFAGraph::Vertex> NFAGraph::GetVertex(size_t number) {
if (vertexes_.count(number))
return vertexes_[number];
return nullptr;
}
size_t NFATree::GetCountVertexes() const {
size_t NFAGraph::GetCountVertexes() const {
return count_vertexes_;
}
const std::vector<size_t>& NFATree::GetFinalVertexes() const {
const std::vector<size_t>& NFAGraph::GetFinalVertexes() const {
return final_vertexes_;
}
const std::vector<size_t>& NFATree::GetStartVertexes() const {
const std::vector<size_t>& NFAGraph::GetStartVertexes() const {
return start_vertexes_;
}
void NFATree::Print() const {
void NFAGraph::Print() const {
for (auto i: vertexes_) {
std::cout << i.second->number_ << " " << "f-" << i.second->is_final_ << " s-" <<
i.second->is_start_ << std::endl;

9
src/NFA/NFATreeVertex.cpp
View file

@ -1,9 +1,8 @@
#include "NFA/NFATree.hpp"
#include <iostream>
#include "NFA/NFAGraph.hpp"
using Vertex = NFA::NFATree::Vertex;
using Vertex = NFA::NFAGraph::Vertex;
Vertex::Vertex(NFATree* owner) : owner_(owner) {}
Vertex::Vertex(NFAGraph* owner) : owner_(owner) {}
bool Vertex::IsFinal() const {
return is_final_;
@ -40,7 +39,7 @@ void Vertex::RemoveEdge(char symbol, size_t number) {
owner_->GetVertex(number)->back_transitions_.erase(symbol);
}
void Vertex::SetOwner(NFATree* owner) {
void Vertex::SetOwner(NFAGraph* owner) {
owner_ = owner;
}

44
src/converters/DFAToFDFA.cpp
View file

@ -43,48 +43,4 @@ DFAGraph DFAGraphToFDFAGraph(DFAGraph&& graph, const std::vector<char>& alphabet
return result;
}
/*
FDFAGraph DFAGraphToFDFAGraph(DFAGraph&& graph, const std::vector<char>& alphabet) {
FDFAGraph result;
const int n = graph.GetCountVertexes();
std::map<size_t, size_t> number_vertex_in_DFA;
for (int i = 0; i < n; ++i) {
if (!graph.GetVertex(i)) continue;
number_vertex_in_DFA[i] = result.AddNewVertex();
}
for (int i = 0; i < n; ++i) {
if (!graph.GetVertex(i)) continue;
if (graph.GetVertex(i)->IsFinal())
result.GetVertex(number_vertex_in_DFA[i])->SetFinal(true);
if (graph.GetVertex(i)->IsStart())
result.GetVertex(number_vertex_in_DFA[i])->SetStart(true);
const auto& transitions = graph.GetVertex(i)->GetTransitions();
for (const auto& t: transitions) {
result.GetVertex(number_vertex_in_DFA[i])->AddEdge(t.first, t.second);
}
}
size_t drain = result.AddNewVertex();
for (int i = 0; i < n; ++i) {
const auto& transitions = graph.GetVertex(i)->GetTransitions();
for (char j: alphabet) {
if (!transitions.count(j)) {
result.GetVertex(i)->AddEdge(j, drain);
}
}
}
if (result.GetVertex(drain)->GetBackTransitions().size() == 0) {
result.RemoveVertex(drain);
} else {
for (char j: alphabet) {
result.GetVertex(drain)->AddEdge(j, drain);
}
}
return result;
}
*/
}

10
src/converters/DFAToMinDFA.cpp
View file

@ -1,22 +1,20 @@
#include "converters/DFAToMinDFA.hpp"
#include <cstdlib>
#include <iostream>
namespace converters {
DFAGraph DFAToMinDFA(DFAGraph&& graph) {
DFAGraph DFAGraphToMinDFAGraph(DFAGraph&& graph) {
const int n = graph.GetCountVertexes();
DFAGraph result;
std::vector<char> alphabet;
{
std::set<char> salphabet;
std::set<char> set_alphabet;
for (int i = 0; i < n; ++i) {
for (auto i: graph.GetVertex(i)->GetTransitions()) {
salphabet.insert(i.first);
set_alphabet.insert(i.first);
}
}
alphabet = std::vector<char>(salphabet.begin(), salphabet.end());
alphabet = std::vector<char>(set_alphabet.begin(), set_alphabet.end());
}
std::vector<std::vector<std::vector<size_t>>> table(n,

2
src/converters/DFAToRegular.cpp
View file

@ -1,6 +1,4 @@
#include "converters/DFAToRegular.hpp"
#include <cstdlib>
#include <iostream>
namespace converters {
std::string DFAGraphToRegular(DFAGraph&& graph) {

205
src/converters/NFAToDFA.cpp
View file

@ -1,135 +1,22 @@
#include "converters/NFAToDFA.hpp"
#include <functional>
#include <iostream>
#include <queue>
#include <stdexcept>
namespace converters {
/*
OLD version
NFATree AddAllEpsilonTransitions(NFATree&& tree) {
// Algorithm from 2-sat
const int n = tree.GetCountVertexes();
std::vector<bool> used(n, false);
std::vector<int> component(n, -1);
std::vector<int> order;
std::function<void(int)> dfs_order = [&tree, &used, &order, &dfs_order](int v) -> void {
used[v] = true;
const auto& transitions = tree.GetVertex(v)->GetTransitions();
if (transitions.count(' ')) {
const auto& s = transitions.at(' ');
for (auto i: s) {
if (!used[i]) {
dfs_order(i);
}
}
}
order.push_back(v);
};
std::function<void(int, int)> dfs_component = [&tree, &component,
&dfs_component](int v, int c) -> void {
component[v] = c;
const auto& transitions = tree.GetVertex(v)->GetBackTransitions();
if (transitions.count(' ')) {
const auto& s = transitions.at(' ');
for (auto i: s) {
if (component[i] == -1) {
dfs_component(i, c);
}
}
}
};
for (int i = 0; i < n; ++i) {
if (!used[i] && tree.GetVertex(i)) {
dfs_order(i);
}
}
int current_component = 0;
for (int i = 0; i < n; ++i) {
int v = order[n - i - 1];
if (component[v] == -1 && tree.GetVertex(i)) {
dfs_component(v, current_component++);
}
}
std::set<std::pair<int, int>> connectivity_components;
used.assign(n, false);
std::vector<std::set<int>> connectivity_from(current_component);
std::function<void(int)> dfs_connectivity = [&tree, &component,
&used, &dfs_connectivity, &connectivity_from](int v) -> void {
used[v] = true;
const auto& transitions = tree.GetVertex(v)->GetTransitions();
if (transitions.count(' ')) {
const auto& s = transitions.at(' ');
for (auto i: s) {
if (!used[i]) {
dfs_connectivity(i);
}
if (component[v] != component[i]) {
connectivity_from[component[v]].insert(connectivity_from[component[i]].begin(),
connectivity_from[component[i]].end());
connectivity_from[component[v]].insert(component[i]);
}
}
}
};
for (int i = 0; i < n; ++i) {
if (!tree.GetVertex(i)) continue;
connectivity_components.emplace(component[i], component[i]);
if (!used[i]) {
dfs_connectivity(i);
}
for (int j: connectivity_from[component[i]]) {
std::cout << i << " " << j << std::endl;
connectivity_components.emplace(component[i], j);
}
}
for (int i = 0; i < n; ++i) {
std::cout << component[i] << " ";
}
std::cout << std::endl;
for (int i: connectivity_from[1]) {
std::cout << i << " ";
}
std::cout << std::endl;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (i == j) continue;
if (connectivity_components.count(std::make_pair(component[i], component[j]))) {
tree.GetVertex(i)->AddEdge(' ', j);
}
}
}
return std::move(tree);
}
*/
NFATree AddAllEpsilonTransitions(NFATree&& tree) {
const int n = tree.GetCountVertexes();
NFAGraph AddAllEpsilonTransitions(NFAGraph&& nfa_graph) {
const int n = nfa_graph.GetCountVertexes();
std::vector<bool> used(n, false);
std::function<void(int, int)> dfs = [&tree, &used, &dfs](int u, int v) -> void {
std::function<void(int, int)> dfs = [&nfa_graph, &used, &dfs](int u, int v) -> void {
used[v] = true;
const auto& transitions = tree.GetVertex(v)->GetTransitions();
const auto& transitions = nfa_graph.GetVertex(v)->GetTransitions();
if (transitions.count(' ')) {
const auto& s = transitions.at(' ');
for (auto i: s) {
if (!used[i]) {
if (u != i)
tree.GetVertex(u)->AddEdge(' ', i);
nfa_graph.GetVertex(u)->AddEdge(' ', i);
dfs(u, i);
}
}
@ -137,62 +24,62 @@ NFATree AddAllEpsilonTransitions(NFATree&& tree) {
};
for (int i = 0; i < n; ++i) {
if (!tree.GetVertex(i)) continue;
if (!nfa_graph.GetVertex(i)) continue;
used.assign(n, false);
dfs(i, i);
}
return std::move(tree);
return std::move(nfa_graph);
}
NFATree AddAllPossibleStartFilnal(NFATree&& tree) {
if (tree.GetStartVertexes().size() != 1) {
size_t start_vertex = tree.AddNewVertex();
for (auto v: tree.GetStartVertexes()) {
tree.GetVertex(start_vertex)->AddEdge(' ', v);
NFAGraph AddAllPossibleStartFinal(NFAGraph&& nfa_graph) {
if (nfa_graph.GetStartVertexes().size() != 1) {
size_t start_vertex = nfa_graph.AddNewVertex();
for (auto v: nfa_graph.GetStartVertexes()) {
nfa_graph.GetVertex(start_vertex)->AddEdge(' ', v);
}
}
for (const auto& v: tree.GetFinalVertexes()) {
const auto& transitions = tree.GetVertex(v)->GetBackTransitions();
for (const auto& v: nfa_graph.GetFinalVertexes()) {
const auto& transitions = nfa_graph.GetVertex(v)->GetBackTransitions();
if (transitions.count(' ')) {
const auto& s = transitions.at(' ');
for (auto i: s) {
tree.GetVertex(i)->SetFinal(true);
nfa_graph.GetVertex(i)->SetFinal(true);
}
}
}
return std::move(tree);
return std::move(nfa_graph);
}
NFATree DeleteEpsilonTransitions(NFATree&& tree) {
const int n = tree.GetCountVertexes();
NFAGraph DeleteEpsilonTransitions(NFAGraph&& nfa_graph) {
const int n = nfa_graph.GetCountVertexes();
for (int v = 0; v < n; ++v) {
if (!tree.GetVertex(v)) continue;
if (!nfa_graph.GetVertex(v)) continue;
const auto& transitions = tree.GetVertex(v)->GetTransitions();
const auto& transitions = nfa_graph.GetVertex(v)->GetTransitions();
if (transitions.count(' ')) {
auto s = transitions.at(' ');
for (auto u: s) {
for (auto& i: tree.GetVertex(u)->GetTransitions()) {
for (auto& i: nfa_graph.GetVertex(u)->GetTransitions()) {
if (i.first == ' ') continue;
for (auto t: i.second) {
tree.GetVertex(v)->AddEdge(i.first, t);
nfa_graph.GetVertex(v)->AddEdge(i.first, t);
}
}
}
for (auto u: s) {
tree.GetVertex(v)->RemoveEdge(' ', u);
nfa_graph.GetVertex(v)->RemoveEdge(' ', u);
}
}
}
return std::move(tree);
return std::move(nfa_graph);
}
NFATree DeleteTransitionsByOneLetter(NFATree&& tree) {
const int n = tree.GetCountVertexes();
NFAGraph DeleteTransitionsByOneLetter(NFAGraph&& nfa_graph) {
const int n = nfa_graph.GetCountVertexes();
NFATree result_tree;
NFAGraph result_tree;
std::map<std::pair<std::set<size_t>, char>, std::set<size_t>> transitions;
std::map<std::set<size_t>, size_t> number_vertex_in_result_tree;
@ -200,14 +87,14 @@ NFATree DeleteTransitionsByOneLetter(NFATree&& tree) {
std::set<char> alphabet;
for (int i = 0; i < n; ++i) {
if (!tree.GetVertex(i)) continue;
for (const auto& j: tree.GetVertex(i)->GetTransitions()) {
if (!nfa_graph.GetVertex(i)) continue;
for (const auto& j: nfa_graph.GetVertex(i)->GetTransitions()) {
if (j.second.size() > 0)
alphabet.insert(j.first);
}
}
for (auto i: tree.GetStartVertexes()) {
for (auto i: nfa_graph.GetStartVertexes()) {
queue.push({i});
number_vertex_in_result_tree[{i}] = result_tree.AddNewVertex();
}
@ -219,7 +106,7 @@ NFATree DeleteTransitionsByOneLetter(NFATree&& tree) {
for (auto symbol: alphabet) {
std::set<size_t> result;
for (auto v: current) {
const auto& transitions = tree.GetVertex(v)->GetTransitions();
const auto& transitions = nfa_graph.GetVertex(v)->GetTransitions();
if (transitions.count(symbol)) {
const auto& s = transitions.at(symbol);
result.insert(s.begin(), s.end());
@ -248,9 +135,9 @@ NFATree DeleteTransitionsByOneLetter(NFATree&& tree) {
auto v = i.second;
for (auto i: s) {
if (tree.GetVertex(i)->IsFinal())
if (nfa_graph.GetVertex(i)->IsFinal())
result_tree.GetVertex(v)->SetFinal(true);
if (tree.GetVertex(i)->IsStart())
if (nfa_graph.GetVertex(i)->IsStart())
result_tree.GetVertex(v)->SetStart(true);
}
}
@ -258,31 +145,25 @@ NFATree DeleteTransitionsByOneLetter(NFATree&& tree) {
return result_tree;
}
DFAGraph NFATreeToDFAGraph(NFATree&& tree) {
/*
tree = AddAllEpsilonTransitions(std::move(tree));
tree = AddAllPossibleStartFilnal(std::move(tree));
tree = DeleteEpsilonTransitions(std::move(tree));
tree = DeleteTransitionsByOneLetter(std::move(tree));
*/
tree = DeleteTransitionsByOneLetter(DeleteEpsilonTransitions(AddAllPossibleStartFilnal(
AddAllEpsilonTransitions(std::move(tree)))));
DFAGraph NFAGraphToDFAGraph(NFAGraph&& nfa_graph) {
nfa_graph = DeleteTransitionsByOneLetter(DeleteEpsilonTransitions(AddAllPossibleStartFinal(
AddAllEpsilonTransitions(std::move(nfa_graph)))));
const int n = tree.GetCountVertexes();
const int n = nfa_graph.GetCountVertexes();
DFAGraph result;
std::map<int, int> number_vertex_in_DFA;
for (int i = 0; i < n; ++i) {
if (!tree.GetVertex(i)) continue;
if (!nfa_graph.GetVertex(i)) continue;
number_vertex_in_DFA[i] = result.AddNewVertex();
}
for (int i = 0; i < n; ++i) {
if (!tree.GetVertex(i)) continue;
if (tree.GetVertex(i)->IsFinal())
if (!nfa_graph.GetVertex(i)) continue;
if (nfa_graph.GetVertex(i)->IsFinal())
result.GetVertex(number_vertex_in_DFA[i])->SetFinal(true);
if (tree.GetVertex(i)->IsStart())
if (nfa_graph.GetVertex(i)->IsStart())
result.GetVertex(number_vertex_in_DFA[i])->SetStart(true);
const auto& transitions = tree.GetVertex(i)->GetTransitions();
const auto& transitions = nfa_graph.GetVertex(i)->GetTransitions();
for (const auto& t: transitions) {
if (t.second.size() != 1) throw std::logic_error("");
result.GetVertex(number_vertex_in_DFA[i])->AddEdge(t.first, *t.second.begin());

9
src/converters/RegularToNFA.cpp
View file

@ -1,7 +1,6 @@
#include "converters/RegularToNFA.hpp"
#include "regular/RegularTree.hpp"
#include "NFA/NFATree.hpp"
#include <iostream>
#include "NFA/NFAGraph.hpp"
using namespace NFA;
using namespace regular;
@ -13,8 +12,8 @@ struct do_nothing_deleter{
};
template<typename deleter>
NFATree RegularToNFA(std::unique_ptr<Node, deleter> node) {
NFATree result;
NFAGraph RegularToNFA(std::unique_ptr<Node, deleter> node) {
NFAGraph result;
if (node->type == Node::Type::Word) {
auto end = result.AddNewVertex();
auto start = end;
@ -80,7 +79,7 @@ NFATree RegularToNFA(std::unique_ptr<Node, deleter> node) {
}
namespace converters {
NFATree RegularToNFA(RegularTree&& tree) {
NFAGraph RegularToNFAGraph(RegularTree&& tree) {
const Node& root = tree.GetNode();
return RegularToNFA(std::unique_ptr<Node,
do_nothing_deleter>(&const_cast<Node&>(tree.GetNode())));

26
src/main.cpp
View file

@ -16,17 +16,17 @@ using namespace converters;
int main() {
{
RegularTree r("a*");
NFATree NFA_tree = RegularToNFA(std::move(r));
DFAGraph DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFAGraph NFA_tree = RegularToNFAGraph(std::move(r));
DFAGraph DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
DFA_graph.Print();
std::string reg = DFAGraphToRegular(std::move(DFA_graph));
r = RegularTree(reg);
NFA_tree = RegularToNFA(std::move(r));
DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFA_tree = RegularToNFAGraph(std::move(r));
DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
DFA_graph.Print();
}
@ -36,16 +36,16 @@ int main() {
{
RegularTree r("a+");
r.Print();
NFA::NFATree NFA_tree = converters::RegularToNFA(std::move(r));
NFA::NFAGraph NFA_tree = converters::RegularToNFAGraph(std::move(r));
NFA_tree.Print();
DFA::DFAGraph DFA_graph = converters::NFATreeToDFAGraph(std::move(NFA_tree));
DFA::DFAGraph DFA_graph = converters::NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph.Print();
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
DFA_graph.Print();
}
return 0;
NFA::NFATree tree;
NFA::NFAGraph tree;
const int N = 10;
int a[N];
@ -110,7 +110,7 @@ int main() {
tree.GetVertex(a[3])->SetFinal(true);
tree.GetVertex(a[4])->SetFinal(true);
DFA::DFAGraph res = converters::NFATreeToDFAGraph(std::move(tree));
DFA::DFAGraph res = converters::NFAGraphToDFAGraph(std::move(tree));
// FDFA::FDFAGraph res2 = converters::DFAGraphToFDFAGraph(std::move(res), {'a', 'b'});
// res2.Print();
@ -119,7 +119,7 @@ int main() {
// res = converters::DFAGraphToFDFAGraph(std::move(res), {'a', 'b'});
res = converters::DFAToMinDFA(std::move(res));
res = converters::DFAGraphToMinDFAGraph(std::move(res));
res.Print();
@ -163,7 +163,7 @@ int main() {
RegularTree reg_tree(str);
reg_tree.Print();
auto NFA_tree = converters::RegularToNFA(std::move(reg_tree));
auto NFA_tree = converters::RegularToNFAGraph(std::move(reg_tree));
std::cout << std::endl;

84
tests/DFAToRegular/DFAToRegular.cpp
View file

@ -17,16 +17,16 @@ extern std::string GenerateRandomString(std::vector<char> alphabet, size_t len);
TEST(DFA_to_regular, a_star) {
RegularTree r("a*");
NFATree NFA_tree = RegularToNFA(std::move(r));
DFAGraph DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFAGraph NFA_tree = RegularToNFAGraph(std::move(r));
DFAGraph DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
std::string reg = DFAGraphToRegular(std::move(DFA_graph));
r = RegularTree(reg);
NFA_tree = RegularToNFA(std::move(r));
DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFA_tree = RegularToNFAGraph(std::move(r));
DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
std::string s = "";
@ -40,16 +40,16 @@ TEST(DFA_to_regular, a_plus) {
std::string regulars[] = {"a+", "(a)+", "(a+)"};
for (const auto& regular: regulars) {
RegularTree r(regular);
NFATree NFA_tree = RegularToNFA(std::move(r));
DFAGraph DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFAGraph NFA_tree = RegularToNFAGraph(std::move(r));
DFAGraph DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
std::string reg = DFAGraphToRegular(std::move(DFA_graph));
r = RegularTree(reg);
NFA_tree = RegularToNFA(std::move(r));
DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFA_tree = RegularToNFAGraph(std::move(r));
DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
std::string s = "";
ASSERT_EQ(DFA_graph.Accepted(s), false);
@ -65,16 +65,16 @@ TEST(DFA_to_regular, abc) {
std::string regulars[] = {"abc"};
for (const auto& regular: regulars) {
RegularTree r(regular);
NFATree NFA_tree = RegularToNFA(std::move(r));
DFAGraph DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFAGraph NFA_tree = RegularToNFAGraph(std::move(r));
DFAGraph DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
std::string reg = DFAGraphToRegular(std::move(DFA_graph));
r = RegularTree(reg);
NFA_tree = RegularToNFA(std::move(r));
DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFA_tree = RegularToNFAGraph(std::move(r));
DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
ASSERT_EQ(DFA_graph.Accepted("abc"), true);
for (int i = 0; i < 1000; ++i) {
@ -89,16 +89,16 @@ TEST(DFA_to_regular, a_or_b_or_c) {
std::string regulars[] = {};
for (const auto& regular: regulars) {
RegularTree r("a|b|c");
NFATree NFA_tree = RegularToNFA(std::move(r));
DFAGraph DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFAGraph NFA_tree = RegularToNFAGraph(std::move(r));
DFAGraph DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
std::string reg = DFAGraphToRegular(std::move(DFA_graph));
r = RegularTree(reg);
NFA_tree = RegularToNFA(std::move(r));
DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFA_tree = RegularToNFAGraph(std::move(r));
DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
ASSERT_EQ(DFA_graph.Accepted("a"), true);
ASSERT_EQ(DFA_graph.Accepted("b"), true);
@ -117,16 +117,16 @@ TEST(DFA_to_regular, a_star_or_b_star_or_c_star) {
std::string regulars[] = {"a*|b*|c*", "(a*)|(b*|c*)", "(a*|b*|c*)", "((a*)|(b*)|(c*))"};
for (const auto& regular: regulars) {
RegularTree r(regular);
NFATree NFA_tree = RegularToNFA(std::move(r));
DFAGraph DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFAGraph NFA_tree = RegularToNFAGraph(std::move(r));
DFAGraph DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
std::string reg = DFAGraphToRegular(std::move(DFA_graph));
r = RegularTree(reg);
NFA_tree = RegularToNFA(std::move(r));
DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFA_tree = RegularToNFAGraph(std::move(r));
DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
auto check = [](const std::string str) {
std::set<char> s(str.begin(), str.end());
@ -151,16 +151,16 @@ TEST(DFA_to_regular, a_star_or_b_star_or_c_star) {
TEST(DFA_to_regular, _a_star_or_b_star_or_c_star_plus) {
RegularTree r("(a*|b*|c*)+");
NFATree NFA_tree = RegularToNFA(std::move(r));
DFAGraph DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFAGraph NFA_tree = RegularToNFAGraph(std::move(r));
DFAGraph DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
std::string reg = DFAGraphToRegular(std::move(DFA_graph));
r = RegularTree(reg);
NFA_tree = RegularToNFA(std::move(r));
DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFA_tree = RegularToNFAGraph(std::move(r));
DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
auto check = [](const std::string str) {
std::set<char> s(str.begin(), str.end());
@ -177,16 +177,16 @@ TEST(DFA_to_regular, _a_star_or_b_star_or_c_star_plus) {
TEST(DFA_to_regular, _a_or_b_or_c_star_plus) {
RegularTree r("(a|b|c*)+");
NFATree NFA_tree = RegularToNFA(std::move(r));
DFAGraph DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFAGraph NFA_tree = RegularToNFAGraph(std::move(r));
DFAGraph DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
std::string reg = DFAGraphToRegular(std::move(DFA_graph));
r = RegularTree(reg);
NFA_tree = RegularToNFA(std::move(r));
DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFA_tree = RegularToNFAGraph(std::move(r));
DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
auto check = [](const std::string str) {
std::set<char> s(str.begin(), str.end());

10
tests/NFAToDFA/check_equivalence.cpp
View file

@ -1,7 +1,7 @@
#include <gtest/gtest.h>
#include <random>
#include "DFA/DFAGraph.hpp"
#include "NFA/NFATree.hpp"
#include "NFA/NFAGraph.hpp"
#include "converters/NFAToDFA.hpp"
using namespace NFA;
@ -19,7 +19,7 @@ std::string GenerateRandomString(std::vector<char> alphabet, size_t len) {
}
TEST(check_equivalence_NFA_to_DFA, 1) {
NFA::NFATree tree;
NFA::NFAGraph tree;
const int N = 10;
int a[N];
@ -34,7 +34,7 @@ TEST(check_equivalence_NFA_to_DFA, 1) {
tree.GetVertex(a[2])->SetFinal(true);
tree.GetVertex(a[3])->SetFinal(true);
DFA::DFAGraph res = converters::NFATreeToDFAGraph(std::move(tree));
DFA::DFAGraph res = converters::NFAGraphToDFAGraph(std::move(tree));
EXPECT_FALSE(res.Accepted(""));
EXPECT_TRUE(res.Accepted("a"));
@ -46,7 +46,7 @@ TEST(check_equivalence_NFA_to_DFA, 1) {
}
TEST(check_equivalence_NFA_to_DFA, 2) {
NFA::NFATree tree;
NFA::NFAGraph tree;
const int N = 10;
int a[N];
@ -62,7 +62,7 @@ TEST(check_equivalence_NFA_to_DFA, 2) {
tree.GetVertex(a[1])->SetFinal(true);
tree.GetVertex(a[2])->SetFinal(true);
DFA::DFAGraph res = converters::NFATreeToDFAGraph(std::move(tree));
DFA::DFAGraph res = converters::NFAGraphToDFAGraph(std::move(tree));
auto check = [](const std::string& str) {
if (str.size() > 0) {

42
tests/regularToDFA/regularToDFA.cpp
View file

@ -16,9 +16,9 @@ extern std::string GenerateRandomString(std::vector<char> alphabet, size_t len);
TEST(regular_to_DFA, a_star) {
RegularTree r("a*");
NFATree NFA_tree = RegularToNFA(std::move(r));
DFAGraph DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFAGraph NFA_tree = RegularToNFAGraph(std::move(r));
DFAGraph DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
std::string s = "";
for (int i = 0; i < 100; ++i) {
@ -31,9 +31,9 @@ TEST(regular_to_DFA, a_plus) {
std::string regulars[] = {"a+", "(a)+", "(a+)"};
for (const auto& regular: regulars) {
RegularTree r(regular);
NFATree NFA_tree = RegularToNFA(std::move(r));
DFAGraph DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFAGraph NFA_tree = RegularToNFAGraph(std::move(r));
DFAGraph DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
std::string s = "";
ASSERT_EQ(DFA_graph.Accepted(s), false);
@ -49,9 +49,9 @@ TEST(regular_to_DFA, abc) {
std::string regulars[] = {"abc"};
for (const auto& regular: regulars) {
RegularTree r(regular);
NFATree NFA_tree = RegularToNFA(std::move(r));
DFAGraph DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFAGraph NFA_tree = RegularToNFAGraph(std::move(r));
DFAGraph DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
ASSERT_EQ(DFA_graph.Accepted("abc"), true);
for (int i = 0; i < 1000; ++i) {
@ -66,9 +66,9 @@ TEST(regular_to_DFA, a_or_b_or_c) {
std::string regulars[] = {};
for (const auto& regular: regulars) {
RegularTree r("a|b|c");
NFATree NFA_tree = RegularToNFA(std::move(r));
DFAGraph DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFAGraph NFA_tree = RegularToNFAGraph(std::move(r));
DFAGraph DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
ASSERT_EQ(DFA_graph.Accepted("a"), true);
ASSERT_EQ(DFA_graph.Accepted("b"), true);
@ -87,9 +87,9 @@ TEST(regular_to_DFA, a_star_or_b_star_or_c_star) {
std::string regulars[] = {"a*|b*|c*", "(a*)|(b*|c*)", "(a*|b*|c*)", "((a*)|(b*)|(c*))"};
for (const auto& regular: regulars) {
RegularTree r(regular);
NFATree NFA_tree = RegularToNFA(std::move(r));
DFAGraph DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFAGraph NFA_tree = RegularToNFAGraph(std::move(r));
DFAGraph DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
auto check = [](const std::string str) {
std::set<char> s(str.begin(), str.end());
@ -114,9 +114,9 @@ TEST(regular_to_DFA, a_star_or_b_star_or_c_star) {
TEST(regular_to_DFA, _a_star_or_b_star_or_c_star_plus) {
RegularTree r("(a*|b*|c*)+");
NFATree NFA_tree = RegularToNFA(std::move(r));
DFAGraph DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFAGraph NFA_tree = RegularToNFAGraph(std::move(r));
DFAGraph DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
auto check = [](const std::string str) {
std::set<char> s(str.begin(), str.end());
@ -133,9 +133,9 @@ TEST(regular_to_DFA, _a_star_or_b_star_or_c_star_plus) {
TEST(regular_to_DFA, _a_or_b_or_c_star_plus) {
RegularTree r("(a|b|c*)+");
NFATree NFA_tree = RegularToNFA(std::move(r));
DFAGraph DFA_graph = NFATreeToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAToMinDFA(std::move(DFA_graph));
NFAGraph NFA_tree = RegularToNFAGraph(std::move(r));
DFAGraph DFA_graph = NFAGraphToDFAGraph(std::move(NFA_tree));
DFA_graph = DFAGraphToMinDFAGraph(std::move(DFA_graph));
auto check = [](const std::string str) {
std::set<char> s(str.begin(), str.end());