Develop

CMakeLists.txt

@@ -0,0 +1,21 @@
+cmake_minimum_required(VERSION 3.6)
+
+project(Main_automata)
+
+set(CMAKE_CXX_STANDARD 17)
+
+include_directories(
+        FSM/include
+        FSM/include/math)
+
+add_executable(run
+        main.cpp
+        FSM/src/NFSM.cpp
+        FSM/src/DFSM.cpp
+        FSM/src/MDFSM.cpp
+        FSM/src/math_func/utility.cpp
+        FSM/src/RegularFSM.cpp
+        FSM/src/State.cpp
+        )
+
+add_subdirectory(tests)

FSM/include/DFSM.h

@@ -0,0 +1,36 @@
+#pragma once
+#include "NFSM.h"
+#include "globals.h"
+#include <bitset>
+#include <vector>
+#include <cmath>
+#include <queue>
+#include <unordered_set>
+#include "State.h"
+#include "utility.h"
+
+
+struct IndexState {
+  std::vector<int> tranzitions;
+  int WayByLetter(int letter);
+  void SetSize(int new_size);
+  void SetWayByLetter(int letter, int new_tranz_index);
+};
+
+
+class DFSM{
+ public:
+  DFSM(std::string file_name);
+  DFSM(NFSM nfsm);
+  DFSM() = default;
+  bool RecognizeWord(std::string);
+  int getSize();
+  std::vector<IndexState> getStates();
+  std::bitset<MaxStateNumber> getF();
+  void Complement();
+ protected:
+  std::vector<IndexState> states_;
+  int size_;
+  int S_size_;
+  std::bitset<MaxStateNumber> F_;
+};

FSM/include/MDFSM.h

@@ -0,0 +1,16 @@
+#pragma once
+#include "State.h"
+#include "globals.h"
+#include "DFSM.h"
+#include <map>
+#include <set>
+
+class MDFSM: public DFSM{
+ public:
+  MDFSM(std::string file_name) : DFSM(file_name){};
+  MDFSM(DFSM);
+ private:
+  void BuildStatesByClasses(std::vector<int> state_to_class,
+                            std::vector<IndexState> last_states,
+                            std::bitset<MaxStateNumber>);
+};

FSM/include/NFSM.h

@@ -0,0 +1,41 @@
+#pragma once
+#include <vector>
+#include <iostream>
+#include <string>
+#include <bitset>
+#include <fstream>
+#include "globals.h"
+#include "State.h"
+
+
+struct EpsInfoState {
+  std::vector<std::string> attempts;
+  bool Find(std::string);
+};
+
+
+
+class NFSM {
+ private:
+  std::vector<State> states_;
+  int q0_;
+  int size_;
+  std::bitset<MaxStateNumber> F_;
+  int edge_size_;
+  int S_size_ = SigmaSize;
+  bool IsEpsExist = true;
+  std::vector<EpsInfoState> SeenBefore;
+  bool RecognizeWordIfNoEps(std::string, int);
+  bool RecognizeWordIfExistEps(std::string, int);
+ public:
+  NFSM(const std::string& file);
+  NFSM();
+  void FilchEps();
+  void print_states();
+  void print_ndsm();
+  void print_in_input_format();
+  bool RecognizeWord(std::string);
+  int getSize();
+  std::vector<State> getStates();
+  std::bitset<MaxStateNumber> getF();
+};

FSM/include/RegularFSM.h

@@ -0,0 +1,42 @@
+#include <string>
+#include <iostream>
+#include <DFSM.h>
+
+struct configuration {
+  int index; //куда пришел
+  std::string word; //по какому слову
+  configuration(int x):index(x), word("1"){};
+  configuration(int x, std::string s): index(x), word(s){};
+};
+
+struct way {
+  int index; //откуда иду
+  std::string word; //по какому слову
+  way(int x, std::string s): index(x), word(s){};
+  way(int x): index(x), word("1"){};
+};
+
+struct reg_state {
+  std::vector<configuration> inputs;
+  std::vector<way> outputs;
+  std::string mesh = "1";
+  reg_state() = default;
+};
+
+class Regular_automat {
+ private:
+  std::vector<bool> IsUsed_;
+  std::vector<reg_state> reg_states_;
+  int size_;
+  int S_size_;
+  void DeleteState(int index);
+  void Filch(int index);
+ public:
+  Regular_automat(DFSM aut);
+  void MakeRegular();
+  void print_for_latex();
+  std::string GetRegex();
+  void PrintRegex();
+  void PrintForLatex();
+
+};

FSM/include/State.h

@@ -0,0 +1,21 @@
+#pragma once
+#include<vector>
+#include<bitset>
+#include "globals.h"
+
+struct State {
+  std::vector<std::bitset<MaxStateNumber>> tranzitions;
+
+  std::bitset<MaxStateNumber> way_by_letter(int x);
+  std::bitset<MaxStateNumber> way_by_eps();
+  void Unite(int letter, std::bitset<MaxStateNumber>);
+  bool IsTranzIncludeState(int letter, int state_id);
+  std::bitset<MaxStateNumber> WayByLetter(int letter);
+  void SetWayByLetter(int letter, std::bitset<MaxStateNumber>);
+  void SetSize(int new_size);
+};
+
+struct DetState {
+  std::vector<std::bitset<MaxStateNumber>> tranzitions;
+  std::bitset<MaxStateNumber> mask;
+};

FSM/include/globals.h

@@ -0,0 +1,3 @@
+#pragma once
+const int MaxStateNumber = 64;
+const int SigmaSize = 2;

FSM/include/math/utility.h

@@ -0,0 +1,3 @@
+#pragma once
+int charBiject(char c);
+char intBiject(int x);

FSM/include/tmp.txt

@@ -0,0 +1,88 @@
+#include "DFSM.h"
+
+int IndexState::way_by_letter(int letter) {
+  return tranzitions[letter];
+}
+
+DFSM::DFSM(NFSM fsm){
+  std::vector<State> old_states = fsm.getStates();
+  std::vector<DetState> new_states;
+  std::bitset<MaxStateNumber> old_F = fsm.getF();
+  std::cout << std::endl;
+  int old_size = fsm.getSize();
+
+  S_size_ = SigmaSize;
+  F_ = 0;
+
+  std::queue<std::bitset<MaxStateNumber>> WorkingStates;
+  std::unordered_set<std::bitset<MaxStateNumber>, std::hash<std::bitset<MaxStateNumber>>> UsedStates;
+  std::bitset<MaxStateNumber> zero;
+
+  zero.set(0);
+  UsedStates.insert(zero);
+  WorkingStates.push(zero);
+
+  DetState new_state;
+  new_state.tranzitions.resize(S_size_+1);
+
+  while (!WorkingStates.empty()) {
+    new_state.mask = WorkingStates.front();
+    WorkingStates.pop();
+    new_state.tranzitions.resize(S_size_ + 1);
+    for(int c = 1; c < S_size_+1; ++c) {
+      new_state.tranzitions[c] = 0;
+      for (int k = 0; k < old_size; ++k) {
+        if (new_state.mask.test(k)) {
+          new_state.tranzitions[c] |= old_states[k].way_by_letter(c);
+        }
+      }
+      if (UsedStates.find(new_state.tranzitions[c]) == UsedStates.end()) {
+        UsedStates.insert(new_state.tranzitions[c]);
+        WorkingStates.push(new_state.tranzitions[c]);
+      }
+    }
+    new_states.push_back(new_state);
+  }
+  states_.resize(new_states.size());
+  size_ = new_states.size();
+  for(int i = 0; i < size_; ++i) {
+    states_[i].resize(S_size_ + 1);
+    for(int c = 1; c < S_size_+1; ++c) {
+      for(int j = 0; j < size_; ++j) {
+        if (new_states[i].tranzitions[c] == new_states[j].mask) {
+          states_[i][c] = j;
+          break;
+        }
+        states_[i][c] = size_-1;
+      }
+    }
+    if ((new_states[i].mask & old_F) != 0) {
+      F_.set(i);
+    }
+  }
+}
+
+
+bool DFSM::RecognizeWord(std::string word) {
+  int pivot = 0;
+  for(int pos = 0; pos < word.size(); ++pos) {
+    pivot = states_[pivot][charBiject(word[pos])];
+  }
+  return F_.test(pivot);
+}
+
+int DFSM::getSize() {
+  return size_;
+}
+
+std::vector<std::vector<int>> DFSM::getStates() {
+  return states_;
+}
+
+std::bitset<MaxStateNumber> DFSM::getF() {
+  return F_;
+}
+
+void DFSM::Complement() {
+  F_ = ~F_;
+}