Pump length #169 #220

libs/AutomatonToImage/src/AutomatonToImage.cpp

@@ -39,11 +39,11 @@ string AutomatonToImage::to_image(string automat) {
 	FILE* fo;
 	fo = fopen("./refal/input.dot", "wt");
 	fprintf(fo, "%s", automat.c_str());
-	fclose(fo);
+	fclose(fo);           
 	system(
-		"cd refal && refgo Preprocess+MathMode input.dot > error_refal0.txt");
+		"cd refal && refgo Preprocess+MathMode+FrameFormatter input.dot > error_refal0.txt");
 	system("cd refal && dot2tex -ftikz -tmath \"Mod_input.dot\" > input.tex");
-	system("cd refal && refgo Postprocess+MathMode input.tex > error_refal.txt "
+	system("cd refal && refgo Postprocess+MathMode+FrameFormatter input.tex > error_refal.txt "
 		   "2>&1");
 
 	// для Linux:
@@ -67,7 +67,6 @@ string AutomatonToImage::to_image(string automat) {
 	// TODO: разные команды для Linux и Windows
 	system("cd refal && rm input.dot && rm input.tex && rm Mod_input.dot && rm "
 		   "R_input.tex");
-
 	// таблица
 	ifstream infile_for_L("./refal/L_input.tex");
 

libs/Interpreter/src/Interpreter.cpp

@@ -341,9 +341,11 @@ optional<GeneralObject> Interpreter::apply_function(
 		}
 	}
 	if (function.name == "SemDet") {
+		log_template.load_tex_template("SemDet");
 		return ObjectBoolean(get_automaton(arguments[0]).semdet(&log_template));
 	}
 	if (function.name == "PumpLength") {
+		log_template.load_tex_template("PumpLength");
 		return ObjectInt(
 			get<ObjectRegex>(arguments[0]).value.pump_length(&log_template));
 	}

libs/Logger/src/Logger.cpp

@@ -32,7 +32,7 @@ void Logger::render_to_file(const string& filename) {
 
 	cout << "\nFrameFormatter + MathMode...\n";
 
-	system("cd refal && refgo FrameFormatter+MathMode 2>err.txt");
+	system("cd refal && refgo RunFormatter+FrameFormatter+MathMode 2>err.txt");
 
 	cout << "\nConverting to PDF 1...\n";
 

libs/Objects/include/Objects/FiniteAutomaton.h

@@ -74,7 +74,11 @@ class FiniteAutomaton : public BaseObject {
 										  map<int, bool>& was) const;
 
 	// функция проверки на семантическую детерминированность
-	bool semdet_entry(bool annoted = false, iLogTemplate* log = nullptr) const;
+	bool semdet_entry(bool traps_removed = false, iLogTemplate* log = nullptr) const;
+
+	// Поиск языков состояний
+	void get_state_languages(vector<Regex>& state_languages,
+							 bool annoted = false) const;
 
   public:
 	FiniteAutomaton();

libs/Objects/include/Objects/Regex.h

@@ -99,6 +99,11 @@ class Regex : BaseObject {
 	void pre_order_travers() const;
 	void clear();
 
+	// Получение всех символов из строки
+	bool get_symbols_from_string(vector<Regex>& res);
+
+	void eps_removing();
+
   public:
 	Regex();
 	Regex(const string&);

libs/Objects/src/FiniteAutomaton.cpp

@@ -2242,17 +2242,19 @@ std::optional<std::string> FiniteAutomaton::get_prefix(
 				auto res = get_prefix(*it2, state_end, was);
 				if (res.has_value()) {
 					ans = (string)it->first + (string)res.value();
+					return ans;
 				}
-				return ans;
 			}
 		}
 	}
 	return ans;
 }
 
-bool FiniteAutomaton::semdet_entry(bool annoted, iLogTemplate* log) const {
+void FiniteAutomaton::get_state_languages(vector<Regex>& state_languages,
+										  bool annoted) const {
 	if (!annoted) {
-		return annote().semdet_entry(true);
+		annote().remove_trap_states().get_state_languages(state_languages, true);
+		return;
 	}
 	// Logger::log(
 	//"Получение языка из производной регулярки автомата по префиксу");
@@ -2261,65 +2263,88 @@ bool FiniteAutomaton::semdet_entry(bool annoted, iLogTemplate* log) const {
 	for (int i = 0; i < states.size(); i++) {
 		if (states[i].is_terminal) final_states.push_back(i);
 	}
-	std::vector<Regex> state_languages;
 	state_languages.resize(states.size());
 	for (int i = 0; i < states.size(); i++) {
 		auto prefix = get_prefix(initial_state, i, was);
 		was.clear();
-		// cout << "Try " << i << "\n";
 		if (!prefix.has_value()) continue;
 		Regex reg;
 		// Получение языка из производной регулярки автомата по префиксу:
-		//		this -> reg (arden?)
 		reg = to_regex();
-		//  cout << "State: " << i << "\n";
-		//  cout << "Prefix: " << prefix.value() << "\n";
-		//  cout << "Regex: " << reg.to_txt() << "\n";
-		// Logger::log("State", to_string(i));
-		// Logger::log("Prefix", prefix.value());
-		// Logger::log("Regex", reg.to_txt());
 		auto derivative = reg.prefix_derivative(prefix.value());
+		//cout << prefix.value() << " " << reg.to_txt() << "\n";
 		if (!derivative.has_value()) continue;
-		state_languages[i] = derivative.value();
-		// cout << "Derevative: " << state_languages[i].to_txt() << "\n";
-		// Logger::log("Derevative", state_languages[i].to_txt());
-
-		// TODO: logs
-		if (log) {
-			log->set_parameter("state", i);
-			log->set_parameter("prefix", prefix.value());
-			log->set_parameter("regex", reg);
-			log->set_parameter("derivative", state_languages[i]);
-		}
-		state_languages[i].make_language();
+		state_languages[i].from_string(derivative.value().to_txt());
+		state_languages[i] = state_languages[i].deannote();
+		//cout << state_languages[i].to_txt() << "\n";
 	}
-	for (int i = 0; i < states.size(); i++) {
-		for (int j = 0; j < states.size(); j++) {
-			for (auto transition = states[j].transitions.begin();
-				 transition != states[j].transitions.end(); transition++) {
-				bool verified_ambiguity = false;
+}
+
+bool FiniteAutomaton::semdet_entry(bool traps_removed, iLogTemplate* log) const {
+	if (!traps_removed) {
+		return remove_trap_states().semdet_entry(true, log);
+	}
+	vector<Regex> state_languages;
+	get_state_languages(state_languages, false);
+	auto make_string_transition = [=](string from, alphabet_symbol through,
+									  string to) {
+		string f = from;
+		string arrow = ">->>{" + string(through) + "}";
+		string t = to;
+		return f + arrow + t;
+	};
+	std::string ambiguous_transitions = "";
+	for (int j = 0; j < states.size(); j++) {
+		for (auto transition = states[j].transitions.begin();
+				transition != states[j].transitions.end(); transition++) {
+			bool verified_ambiguity = false;
+			if (transition->second.size() > 1) {
+				ambiguous_transitions += "Ambigous: ";
 				for (auto it = transition->second.begin();
-					 it != transition->second.end(); it++) {
-					bool reliability = true;
-					for (auto it2 = transition->second.begin();
-						 it2 != transition->second.end(); it2++) {
-						if (!state_languages[*it].subset(
-								state_languages[*it2])) {
-							reliability = false;
-							break;
-						}
+						it != transition->second.end(); it++) {
+					ambiguous_transitions +=
+						make_string_transition(states[j].identifier, transition->first, states[*it].identifier) +
+						",";
+				}
+			}
+			for (auto it = transition->second.begin();
+					it != transition->second.end(); it++) {
+				bool reliability = true;
+				for (auto it2 = transition->second.begin();
+						it2 != transition->second.end(); it2++) {
+					if (!state_languages[*it].subset(
+							state_languages[*it2])) {
+						reliability = false;
+						break;
 					}
-					verified_ambiguity |= reliability;
 				}
-				if (!verified_ambiguity) {
-					// Logger::log("Результат SemDet", "false");
-					// Logger::finish_step();
-					return false;
+				verified_ambiguity |= reliability;
+				if (reliability && transition->second.size() > 1) {
+					ambiguous_transitions +=
+						"Reliable:" + 
+						make_string_transition(states[j].identifier, transition->first, states[*it].identifier) +
+						+"\\\\";
 				}
 			}
+			if (!verified_ambiguity) {
+				// Logger::log("Результат SemDet", "false");
+				// Logger::finish_step();
+				ambiguous_transitions += "Reliable: none\\\\";
+				if (log) {
+					log->set_parameter("ambiguous transitions", ambiguous_transitions);
+					log->set_parameter("semdet result", "false\\\\");
+				}
+				return false;
+			}
+		}
+	}
+	if (log) {
+		if (ambiguous_transitions == "") {
+			ambiguous_transitions = "None";
 		}
+		log->set_parameter("ambiguous transitions", ambiguous_transitions);
+		log->set_parameter("semdet result", "true\\\\");
 	}
-	// Logger::log("Результат SemDet", "true");
 	return true;
 }
 
@@ -2328,10 +2353,7 @@ bool FiniteAutomaton::semdet(iLogTemplate* log) const {
 	if (log) {
 		log->set_parameter("oldautomaton", *this);
 	}
-	bool result = semdet_entry(log);
-	if (log) {
-		log->set_parameter("result", result);
-	}
+	bool result = semdet_entry(false, log);
 	return result;
 	// Logger::finish_step();
 }

libs/Objects/src/Grammar.cpp

@@ -430,7 +430,7 @@ string Grammar::pg_to_txt() const {
 	for (const auto& elem : out) {
 		ss << elem << "\\\\";
 	}
-	ss << "------------ base words ------------"
+	ss << "------------------------- Базисные слова -----------------------"
 	   << "\\\\";
 
 	for (int i = 0; i < prefix_grammar.size(); i++) {