/// <summary> /// Returns an automaton that accepts the Kleene star (zero or more /// concatenated repetitions) of the language of the given automaton. Never /// modifies the input automaton language. /// <para/> /// Complexity: linear in number of states. /// </summary> public static Automaton Repeat(Automaton a) { a = a.CloneExpanded(); State s = new State { accept = true }; s.AddEpsilon(a.initial); foreach (State p in a.GetAcceptStates()) { p.AddEpsilon(s); } a.initial = s; a.deterministic = false; //a.clearHashCode(); a.ClearNumberedStates(); a.CheckMinimizeAlways(); return(a); }
/// <summary> /// Returns an automaton that accepts the union of the languages of the given /// automata. /// <para/> /// Complexity: linear in number of states. /// </summary> public static Automaton Union(ICollection <Automaton> l) { JCG.HashSet <int> ids = new JCG.HashSet <int>(); foreach (Automaton a in l) { ids.Add(a.GetHashCode()); } bool has_aliases = ids.Count != l.Count; State s = new State(); foreach (Automaton b in l) { if (BasicOperations.IsEmpty(b)) { continue; } Automaton bb = b; if (has_aliases) { bb = bb.CloneExpanded(); } else { bb = bb.CloneExpandedIfRequired(); } s.AddEpsilon(bb.initial); } Automaton a_ = new Automaton { initial = s, deterministic = false }; //a.clearHashCode(); a_.ClearNumberedStates(); a_.CheckMinimizeAlways(); return(a_); }
/// <summary> /// Returns an automaton that accepts the concatenation of the languages of the /// given automata. /// <para/> /// Complexity: linear in number of states. /// </summary> public static Automaton Concatenate(Automaton a1, Automaton a2) { if (a1.IsSingleton && a2.IsSingleton) { return(BasicAutomata.MakeString(a1.singleton + a2.singleton)); } if (IsEmpty(a1) || IsEmpty(a2)) { return(BasicAutomata.MakeEmpty()); } // adding epsilon transitions with the NFA concatenation algorithm // in this case always produces a resulting DFA, preventing expensive // redundant determinize() calls for this common case. bool deterministic = a1.IsSingleton && a2.IsDeterministic; if (a1 == a2) { a1 = a1.CloneExpanded(); a2 = a2.CloneExpanded(); } else { a1 = a1.CloneExpandedIfRequired(); a2 = a2.CloneExpandedIfRequired(); } foreach (State s in a1.GetAcceptStates()) { s.accept = false; s.AddEpsilon(a2.initial); } a1.deterministic = deterministic; //a1.clearHashCode(); a1.ClearNumberedStates(); a1.CheckMinimizeAlways(); return(a1); }
/// <summary> /// Returns an automaton that accepts the concatenation of the languages of the /// given automata. /// <para/> /// Complexity: linear in total number of states. /// </summary> public static Automaton Concatenate(IList <Automaton> l) { if (l.Count == 0) { return(BasicAutomata.MakeEmptyString()); } bool all_singleton = true; foreach (Automaton a in l) { if (!a.IsSingleton) { all_singleton = false; break; } } if (all_singleton) { StringBuilder b = new StringBuilder(); foreach (Automaton a in l) { b.Append(a.singleton); } return(BasicAutomata.MakeString(b.ToString())); } else { foreach (Automaton a in l) { if (BasicOperations.IsEmpty(a)) { return(BasicAutomata.MakeEmpty()); } } HashSet <int> ids = new HashSet <int>(); foreach (Automaton a in l) { ids.Add(a.GetHashCode()); } bool has_aliases = ids.Count != l.Count; Automaton b = l[0]; if (has_aliases) { b = b.CloneExpanded(); } else { b = b.CloneExpandedIfRequired(); } ISet <State> ac = b.GetAcceptStates(); bool first = true; foreach (Automaton a in l) { if (first) { first = false; } else { if (a.IsEmptyString) { continue; } Automaton aa = a; if (has_aliases) { aa = aa.CloneExpanded(); } else { aa = aa.CloneExpandedIfRequired(); } ISet <State> ns = aa.GetAcceptStates(); foreach (State s in ac) { s.accept = false; s.AddEpsilon(aa.initial); if (s.accept) { ns.Add(s); } } ac = ns; } } b.deterministic = false; //b.clearHashCode(); b.ClearNumberedStates(); b.CheckMinimizeAlways(); return(b); } }
/// <summary> /// Converts an incoming utf32 automaton to an equivalent /// utf8 one. The incoming automaton need not be /// deterministic. Note that the returned automaton will /// not in general be deterministic, so you must /// determinize it if that's needed. /// </summary> public Automaton Convert(Automaton utf32) { if (utf32.IsSingleton) { utf32 = utf32.CloneExpanded(); } State[] map = new State[utf32.NumberedStates.Length]; List<State> pending = new List<State>(); State utf32State = utf32.InitialState; pending.Add(utf32State); Automaton utf8 = new Automaton(); utf8.Deterministic = false; State utf8State = utf8.InitialState; Utf8States = new State[5]; Utf8StateCount = 0; utf8State.number = Utf8StateCount; Utf8States[Utf8StateCount] = utf8State; Utf8StateCount++; utf8State.Accept = utf32State.Accept; map[utf32State.number] = utf8State; while (pending.Count != 0) { utf32State = pending[pending.Count - 1]; pending.RemoveAt(pending.Count - 1); utf8State = map[utf32State.number]; for (int i = 0; i < utf32State.numTransitions; i++) { Transition t = utf32State.TransitionsArray[i]; State destUTF32 = t.To; State destUTF8 = map[destUTF32.number]; if (destUTF8 == null) { destUTF8 = NewUTF8State(); destUTF8.accept = destUTF32.accept; map[destUTF32.number] = destUTF8; pending.Add(destUTF32); } ConvertOneEdge(utf8State, destUTF8, t.Min_Renamed, t.Max_Renamed); } } utf8.SetNumberedStates(Utf8States, Utf8StateCount); return utf8; }