Esempio n. 1
0
 // 생성자
 public EpsilonNFA(HashSet <string> _States, HashSet <string> _Inputs, Microsoft.Collections.Extensions.MultiValueDictionary <Tuple <string, string>, string> _TransitionFunctions, HashSet <string> _StartState, List <string> _FinalStates)
 {
     States = _States;
     Inputs = _Inputs;
     TransitionFunctions = _TransitionFunctions;
     StartState          = _StartState;
     FinalStates         = _FinalStates;
 }
Esempio n. 2
0
 // 기본 생성자
 public EpsilonNFA()
 {
     States = new HashSet <string>();
     Inputs = DefaultInputs;
     TransitionFunctions = new Microsoft.Collections.Extensions.MultiValueDictionary <Tuple <string, string>, string>();
     StartState          = new HashSet <string>();
     FinalStates         = new List <string>();
 }
Esempio n. 3
0
        //e-NFA to DFA
        public static DFA SubsetConstruction(EpsilonNFA epsilonNFA)
        {
            HashSet <string>         startState = new HashSet <string>();
            List <HashSet <string> > states     = new List <HashSet <string> >();

            Microsoft.Collections.Extensions.MultiValueDictionary <Tuple <string, string>, string> transitionFunctions = new Microsoft.Collections.Extensions.MultiValueDictionary <Tuple <string, string>, string>();
            HashSet <string> reconstructedStates = new HashSet <string>();
            List <string>    finalStates         = new List <string>();

            foreach (var item in epsilonNFA.StartState)
            {
                startState.UnionWith(epsilonNFA.closure(item));
                break;
            }

            foreach (var input in epsilonNFA.Inputs)
            {
                foreach (var state in startState)
                {
                    foreach (var output in epsilonNFA.TransitionFunctions[new Tuple <string, string>(state, input)])
                    {
                        var newState = epsilonNFA.closure(output);
                        if (states.Contains(newState)) // 여기서 같은것이 반복되면 무시!
                        {
                            continue;
                        }

                        states.Add(newState);

                        string reconstructedStartState = "";
                        string reconstructedFinalState = "";
                        foreach (var item in startState)
                        {
                            reconstructedStartState += item;
                        }
                        foreach (var item in newState)
                        {
                            reconstructedFinalState += item;
                        }
                        if (reconstructedFinalState.Equals(string.Empty))
                        {
                            continue;
                        }

                        transitionFunctions.Add(new Tuple <string, string>(reconstructedStartState, input), reconstructedFinalState);
                    }
                }
            }

            // 해쉬셋을 재구성해서 스테이트로 쓰기위해 하나의 문자열로 만든다
            foreach (var set in states)
            {
                var newState = "";
                foreach (var str in set)
                {
                    newState += str;
                }
                reconstructedStates.Add(newState);
            }

            // 원래 NFA의 finalstate를 가진 것이 곧 DFA의 finalStte
            foreach (var state in reconstructedStates)
            {
                foreach (var nfaFinal in epsilonNFA.FinalStates)
                {
                    if (state.Contains(nfaFinal.ToString()))
                    {
                        finalStates.Add(state);
                    }
                }
            }

            return(new DFA(reconstructedStates, epsilonNFA.Inputs, transitionFunctions, startState, finalStates));
        }