(#305) mfa equal

+ action and symbolic methods

README.md

@@ -246,8 +246,11 @@ TG.generate_task(3, 5, false, false);
 - `Complement: MFA -> MFA`
 - `Deterministic: MFA -> Boolean`
 - `Bisimilar: (MFA, MFA) -> OptionalBool`
+- `Action: MFA -> NFA`
+- `Symbolic: MFA -> NFA`
 - `ActionBisimilar: (MFA, MFA) -> Boolean`
 - `SymbolicBisimilar: (MFA, MFA) -> Boolean`
+- `Equal: (MFA, MFA) -> Boolean`
 - `MergeBisim: MFA -> MFA`
 
 **Метод Test**

libs/FuncLib/include/FuncLib/Functions.h

@@ -71,6 +71,7 @@ inline static const std::vector<Function> functions = {
 	{"Equiv", {ObjectType::NFA, ObjectType::NFA}, ObjectType::Boolean},
 	{"Equal", {ObjectType::Regex, ObjectType::Regex}, ObjectType::Boolean},
 	{"Equal", {ObjectType::NFA, ObjectType::NFA}, ObjectType::Boolean},
+	{"Equal", {ObjectType::MFA, ObjectType::MFA}, ObjectType::Boolean},
 	{"Equal", {ObjectType::Int, ObjectType::Int}, ObjectType::Boolean},
 	{"Equal", {ObjectType::AmbiguityValue, ObjectType::AmbiguityValue}, ObjectType::Boolean},
 	{"Equal", {ObjectType::Boolean, ObjectType::Boolean}, ObjectType::Boolean},
@@ -82,6 +83,8 @@ inline static const std::vector<Function> functions = {
 	{"ActionBisimilar", {ObjectType::MFA, ObjectType::MFA}, ObjectType::Boolean},
 	{"SymbolicBisimilar", {ObjectType::MFA, ObjectType::MFA}, ObjectType::Boolean},
 	{"MergeBisim", {ObjectType::MFA}, ObjectType::MFA},
+	{"Action", {ObjectType::MFA}, ObjectType::NFA},
+	{"Symbolic", {ObjectType::MFA}, ObjectType::NFA},
 };
 
 // вспомогательная функция для Ани и ее курсача

libs/Interpreter/src/Interpreter.cpp

@@ -334,6 +334,10 @@ optional<GeneralObject> Interpreter::apply_function(const Function& function,
 		return ObjectBoolean(MemoryFiniteAutomaton::symbolic_bisimilar(
 			get<ObjectMFA>(arguments[0]).value, get<ObjectMFA>(arguments[1]).value, &log_template));
 	}
+	if (function.name == "Equal" && function.input[0] == ObjectType::MFA) {
+		return ObjectBoolean(MemoryFiniteAutomaton::equal(
+			get<ObjectMFA>(arguments[0]).value, get<ObjectMFA>(arguments[1]).value, &log_template));
+	}
 	// # place for another diff types funcs
 
 	/*
@@ -448,6 +452,12 @@ optional<GeneralObject> Interpreter::apply_function(const Function& function,
 	if (function.name == "MergeBisim" && function.input[0] == ObjectType::MFA) {
 		res = ObjectMFA(get<ObjectMFA>(arguments[0]).value.merge_bisimilar(&log_template));
 	}
+	if (function.name == "Action") {
+		res = ObjectNFA(get<ObjectMFA>(arguments[0]).value.to_action_fa(&log_template));
+	}
+	if (function.name == "Symbolic") {
+		res = ObjectNFA(get<ObjectMFA>(arguments[0]).value.to_symbolic_fa(&log_template));
+	}
 	// # place for another same types funcs
 	if (function.name == "Intersect") {
 		res = ObjectNFA(FiniteAutomaton::intersection(

libs/Objects/include/Objects/MemoryFiniteAutomaton.h

@@ -252,9 +252,12 @@ class MemoryFiniteAutomaton : public AbstractMachine {
 	std::pair<std::unordered_set<std::string>, std::unordered_set<std::string>> generate_test_set(
 		int max_len) const;
 	// ссылки считаются символами алфавита, операции над памятью игнорируются
-	FiniteAutomaton to_action_fa() const;
+	FiniteAutomaton to_action_fa(iLogTemplate* log = nullptr) const;
 	// ссылки считаются символами алфавита, операции над памятью преобразуются в переходы Oi, Ci, Ri
-	FiniteAutomaton to_symbolic_fa() const;
+	FiniteAutomaton to_symbolic_fa(iLogTemplate* log = nullptr) const;
+	// проверка автоматов на равенство (буквальное + строгое равенство номеров ячеек)
+	static bool equal(const MemoryFiniteAutomaton&, const MemoryFiniteAutomaton&,
+					  iLogTemplate* log = nullptr);
 	// проверка автоматов на бисимилярность
 	static std::optional<bool> bisimilar(const MemoryFiniteAutomaton&, const MemoryFiniteAutomaton&,
 										 iLogTemplate* log = nullptr);

libs/Objects/src/MemoryFiniteAutomaton.cpp

@@ -1180,13 +1180,19 @@ pair<unordered_set<string>, unordered_set<string>> MemoryFiniteAutomaton::genera
 	return {words_in_language, mutated_words};
 }
 
-FiniteAutomaton MemoryFiniteAutomaton::to_action_fa() const {
+FiniteAutomaton MemoryFiniteAutomaton::to_action_fa(iLogTemplate* log) const {
 	vector<FAState> fa_states;
 	Alphabet alphabet;
 	fa_states.reserve(states.size());
 	for (const auto& state : states)
 		fa_states.emplace_back(state, alphabet);
-	return {initial_state, fa_states, alphabet};
+
+	FiniteAutomaton fa(initial_state, fa_states, alphabet);
+	if (log) {
+		log->set_parameter("mfa", *this);
+		log->set_parameter("result", fa);
+	}
+	return fa;
 }
 
 bool MemoryFiniteAutomaton::action_bisimilar(const MemoryFiniteAutomaton& mfa1,
@@ -1201,7 +1207,7 @@ bool MemoryFiniteAutomaton::action_bisimilar(const MemoryFiniteAutomaton& mfa1,
 	return result;
 }
 
-FiniteAutomaton MemoryFiniteAutomaton::to_symbolic_fa() const {
+FiniteAutomaton MemoryFiniteAutomaton::to_symbolic_fa(iLogTemplate* log) const {
 	int n = size();
 	vector<FAState> fa_states(n);
 	Alphabet alphabet;
@@ -1249,7 +1255,24 @@ FiniteAutomaton MemoryFiniteAutomaton::to_symbolic_fa() const {
 			}
 		}
 	}
-	return {initial_state, fa_states, alphabet};
+
+	FiniteAutomaton fa(initial_state, fa_states, alphabet);
+	if (log) {
+		log->set_parameter("mfa", *this);
+		log->set_parameter("result", fa);
+	}
+	return fa;
+}
+
+bool MemoryFiniteAutomaton::equal(const MemoryFiniteAutomaton& mfa1,
+								  const MemoryFiniteAutomaton& mfa2, iLogTemplate* log) {
+	bool result = FiniteAutomaton::equal(mfa1.to_symbolic_fa(), mfa2.to_symbolic_fa());
+	if (log) {
+		log->set_parameter("automaton1", mfa1);
+		log->set_parameter("automaton2", mfa2);
+		log->set_parameter("result", result ? "True" : "False");
+	}
+	return result;
 }
 
 bool MemoryFiniteAutomaton::symbolic_bisimilar(const MemoryFiniteAutomaton& mfa1,

resources/template/Action.tex

@@ -0,0 +1,9 @@
+\section{Action}
+\begin{frame}{$\Action\TypeIs\MFATYPE\to\NFATYPE$}
+	Автомат:
+	%template_mfa
+
+	Результат:
+	%template_result
+
+\end{frame}

resources/template/Equal3.tex

@@ -1,15 +1,14 @@
 \section{Equal}
-\begin{frame}{Предикат $\Equal\TypeIs\pair{\IntTYPE}{\IntTYPE}\to\BooleanTYPE$}
+\begin{frame}{$\Equal\TypeIs\pair{\MFATYPE}{\MFATYPE}\to\BooleanTYPE$}
+	Первый автомат:
 
-	Первое значение:
+	%template_automaton1
 
-	%template_value1
+	Второй автомат:
 
-	Второе значение:
-
-	%template_value2
+	%template_automaton2
 
 	Результат:
 	%template_result
 
-\end{frame}
+\end{frame}

resources/template/Equal4.tex

@@ -1,5 +1,5 @@
 \section{Equal}
-\begin{frame}{Предикат $\Equal\TypeIs\pair{\AmbiguityValueTYPE}{\AmbiguityValueTYPE}\to\BooleanTYPE$}
+\begin{frame}{Предикат $\Equal\TypeIs\pair{\IntTYPE}{\IntTYPE}\to\BooleanTYPE$}
 
 	Первое значение:
 

resources/template/Equal5.tex

@@ -1,5 +1,5 @@
 \section{Equal}
-\begin{frame}{Предикат $\Equal\TypeIs\pair{\BooleanTYPE}{\BooleanTYPE}\to\BooleanTYPE$}
+\begin{frame}{Предикат $\Equal\TypeIs\pair{\AmbiguityValueTYPE}{\AmbiguityValueTYPE}\to\BooleanTYPE$}
 
 	Первое значение:
 

resources/template/Equal6.tex

@@ -0,0 +1,15 @@
+\section{Equal}
+\begin{frame}{Предикат $\Equal\TypeIs\pair{\BooleanTYPE}{\BooleanTYPE}\to\BooleanTYPE$}
+
+	Первое значение:
+
+	%template_value1
+
+	Второе значение:
+
+	%template_value2
+
+	Результат:
+	%template_result
+
+\end{frame}

resources/template/Symbolic.tex

@@ -0,0 +1,9 @@
+\section{Symbolic}
+\begin{frame}{$\Symbolic\TypeIs\MFATYPE\to\NFATYPE$}
+	Автомат:
+	%template_mfa
+
+	Результат:
+	%template_result
+
+\end{frame}

resources/template/head.tex

@@ -170,6 +170,8 @@
 \def\IsAcreg{\mathtt{IsAcreg}}
 \def\ActionBisimilar{\mathtt{ActionBisimilar}}
 \def\SymbolicBisimilar{\mathtt{SymbolicBisimilar}}
+\def\Action{\mathtt{Action}}
+\def\Symbolic{\mathtt{Symbolic}}
 
 % типы интерпретатора
 \def\VoidTYPE{\mathtt{VOID}}