def dfa_tb_to_diagram(json_filename, output_filename): with open(json_filename) as json_file: dfa_tb = json.load(json_file) # construct nfa parameters alphabet = dfa_tb["alphabet"] states = dfa_tb["states"] dfa = dict() dfa["alphabet"] = set(alphabet) dfa["states"] = set(states) dfa["initial_state"] = dfa_tb["initial_state"] dfa["accepting_states"] = set(dfa_tb["accepting_states"]) # construct dfa transitions from transition table transition_table = dfa_tb["transition_table"] if len(transition_table) != len(states): raise Exception( "number of rows in transition table not equal to number of states") if len(transition_table[0]) != len(alphabet): raise Exception( "number of columns in transition table not equal to number of elements in alphabet" ) transitions = dict() for i in range(len(states)): for j in range(len(alphabet)): if len(transition_table[i][j]) > 0: transitions[(states[i], alphabet[j])] = transition_table[i][j] dfa["transitions"] = transitions print(dfa) automata_IO.dfa_to_dot(dfa, output_filename)
def read_determinize_minimized_write(path, model): nfa = automata_IO.nfa_dot_importer(path + model) dfa = NFA.nfa_determinization(nfa) automata_IO.dfa_to_dot(dfa, model + '_det', path) new_dfa = DFA.dfa_minimization(dfa) automata_IO.dfa_to_dot(new_dfa, model + "_det_min", path)
def saveSVG(self, dfaPath=None, dfaName=None, svgPath=None): if dfaPath is None or dfaName is None or svgPath is None: return dfa = self.getFormattedDFA(dfaPath) automata_IO.dfa_to_dot(dfa, dfaName, svgPath)
def check_relation(nfa1, nfa2): ''' :param nfa1: nfa :param nfa2: nfa :return: - 1 if model1 includes model 2 - -1 if model2 includes model 1 - 0 if the models are equal - otherwise ''' dfa1 = NFA.nfa_determinization(nfa1) dfa1_comp = DFA.dfa_complementation(dfa1) dfa2 = NFA.nfa_determinization(nfa2) dfa2_comp = DFA.dfa_complementation(dfa2) words_only_in_model2 = DFA.dfa_nonemptiness_check(DFA.dfa_intersection(dfa1_comp, dfa2)) words_only_in_model1 = DFA.dfa_nonemptiness_check(DFA.dfa_intersection(dfa2_comp, dfa1)) if words_only_in_model1\ and not words_only_in_model2: return 1 elif words_only_in_model2\ and not words_only_in_model1: dfa_intersect = DFA.dfa_intersection(dfa1_comp, dfa2) dfa_intersect_minimized = DFA.dfa_co_reachable(DFA.dfa_minimization(dfa_intersect)) automata_IO.dfa_to_dot(dfa_intersect_minimized, 'csv_intersect', path) return -1 elif not words_only_in_model2\ and not words_only_in_model1: return 0 else: return -1
def createImage(self): data = { 'alphabet': self.partialAlphabet, 'states': self.partialStates, 'initial_state': self.completeAutomata.initialState, 'accepting_states': self.partialAcceptingStates, 'transitions': self.partialTransitions } automata_IO.dfa_to_dot(data, "partialAutomata", "./resources")
def main(): automataDict = automata_IO.dfa_json_importer("./resources/automata.json") alphabet = automataDict["alphabet"] initialState = automataDict["initial_state"] transitions = automataDict["transitions"] acceptingStates = automataDict["accepting_states"] automata_IO.dfa_to_dot(automataDict, "automata", "./resources") automata = Automata(alphabet, initialState, transitions, acceptingStates) _ = Screen("./resources/automata.dot.svg", automata)
def main(): automataDict = automata_IO.dfa_json_importer("./resources/AFD.json") alphabet = automataDict["alphabet"] initialState = automataDict["initial_state"] transitions = automataDict["transitions"] acceptingStates = automataDict["accepting_states"] '''Monta a imagem a partir do Json passado''' automata_IO.dfa_to_dot(automataDict, "AFD", "./resources") automata = Automata(alphabet, initialState, transitions, acceptingStates) '''Screen recebe como parametro o caminho da imagem e também o objeto automato''' _ = Screen("./resources/AFD.dot.svg", automata)
def dot_dictionary(self, name: str) -> str: """ Generate svg for automaton :param name: :param name of svg file: """ dot = dict(initial_state=str(self._sets_start()), alphabet=self.__alphabet, states={str(x.state) for x in self.__states}, accepting_states={str(x.state) for x in self.__states if x.is_final()}, transitions={(str(x.state), i): x.morphs[i] for x in self.__states for i in self.alphabet}) automata_IO.dfa_to_dot(dot, name, ".") while True: if path.exists(f"{name}.dot.svg"): return f"./{name}.dot.svg"
def test_dfa_to_dot(self): """ Tests a simple dfa render thorough graphiz library""" automata_IO.dfa_to_dot(self.dfa_01, 'graphviz_dfa_render_test', 'tests/outputs')
def test_dfa_graphviz_intersection_render(self): """ Tests a rendering of a dfa resulting from an intersection, so consisting in more complex nodes""" automata_IO.dfa_to_dot(self.dfa_intersected, 'graphviz_dfa_intersection_render_test', 'tests/outputs')
from PySimpleAutomata import automata_IO import os, re os.environ[ "PATH"] += os.pathsep + 'C:\Program Files (x86)\Graphviz\release\bin' __location__ = os.path.realpath( os.path.join(os.getcwd(), os.path.dirname(__file__))) for filename in os.listdir(__location__): if re.match(".*hypo_\d+.json", filename): currdfa = automata_IO.dfa_json_importer( os.path.join(__location__, filename)) automata_IO.dfa_to_dot(currdfa, filename.split('.')[0], __location__)
if __name__ == "__main__": automata = Automata() ''' In order to run this program you must to create a file called, i.e., "RE.txt" which has to contain the Regular expresion and the alphabet, such as: 0*.1.0*.1.0*.1.0* 0 1 Where the first line is the RE and the next ones are the alphabet ''' automata.readFile("RE.txt") automata.convertREToPostfix() automata.convertREToNFA() automata.createTransitionMatrix() nfa_example = automata_IO.nfa_json_importer('quintuple_NFA.json') automata_IO.nfa_to_dot(nfa_example, 'graphic_NFA', './') automata.NFA_to_DFA() dfa_example = automata_IO.dfa_json_importer('quintuple_DFA.json') automata_IO.dfa_to_dot(dfa_example, 'graphic_DFA', './') automata.validateStrings() print( "The quintuple for the NFA is in 'quintuple_NFA.json', the graphic is in 'graphic_NFA.dot.svg'" ) print( "The quintuple for the DFA is in 'quintuple_DFA.json', the graphic is in 'graphic_DFA.dot.svg'" )
False) if type(f) == list: dfas.extend(f) else: dfas.append(f) if extension == 'pddl3': rewards = [1] * len(dfas) # return if dfa and rm: dfas = get_dfas(dfas, rewards, reward=True, minimize=False) for i in range(len(dfas)): if output == 'dot' or args.image: AutIO.dfa_to_dot(dfas[i], f'DFA_{i}') if not args.image: os.system(f'rm DFA_{i}.dot.svg') else: os.system(f'mv DFA_{i}.dot.svg DFA_{i}.svg') if output != 'dot': os.system(f'rm DFA_{i}.dot') write_output(output, dfas[i], f'DFA_{i}') reward_machine = dfa_intersection_to_rm(dfas, args.reduce, reward) if output == 'dot' or args.image: AutIO.dfa_to_dot(reward_machine, 'RewardMachine') if not args.image: os.system('rm RewardMachine.dot.svg') else: os.system(f'mv RewardMachine.dot.svg RewardMachine.svg')
from PySimpleAutomata import automata_IO, DFA import graphviz as gph dfa = automata_IO.dfa_dot_importer('./parler.dot') DFA.dfa_completion(dfa) dfa_min = DFA.dfa_minimization(dfa) dot_format = automata_IO.dfa_to_dot(dfa_min, 'parler_min') gph.render('dot', 'png', './parler_min.dot') #dg = gph.Digraph('parler', filename='parler.gv', engine='dot', format='png', body=dfa) #dg.render(view=True)
instance.read_and_store_states() if is_dfa: instance.read_and_store_initial_states(True) instance.read_and_store_accepting_states() instance.read_and_store_dfa_transitions() else: instance.read_and_store_initial_states() instance.read_and_store_accepting_states() instance.read_and_store_nfa_transitions() with open("Part1.json", "w") as file: json.dump(instance.getData(), file) if is_dfa: dfa = automata_IO.dfa_json_importer('Part1.json') automata_IO.dfa_to_dot(dfa, 'dfa') else: nfa = automata_IO.nfa_json_importer('Part1.json') automata_IO.nfa_to_dot(nfa, 'nfa') is_dfa_nfa_selection_exit = True is_exit = True if choice in ["2", 2]: instance = COMP5361() instance.read_and_store_alphabets() instance.read_and_store_states() instance.read_and_store_initial_states() instance.read_and_store_accepting_states() instance.read_and_store_nfa_transitions() instance.nfa_to_dfa_conversion()
for node in dfa: if node not in new_nodes: new_nodes[node] = i i += 1 new_edges = {} for edge in dfa[node]: if dfa[node][edge] not in new_nodes: new_nodes[dfa[node][edge]] = i i += 1 new_edges[edge] = new_nodes[dfa[node][edge]] full_dfa[new_nodes[node]] = new_edges if end_num in node: goals.add(new_nodes[node]) return full_dfa, goals end_num = init_first_last_pos() set_first_last_pos(formula) set_follow_pos(formula) set_dfa() dfa, goals = prettify_dfa(end_num) return dfa, goals """ trans.pass_trough_mona(formula) dfa = trans.read_dfa('dfa.txt') automata_IO.dfa_to_dot(dfa, 'eliminar.dfa', './')