/// <summary> /// Returns a new (deterministic) automaton that accepts a single character of the given value. /// </summary> /// <param name="c">The c.</param> /// <returns>A new (deterministic) automaton that accepts a single character of the given value.</returns> internal static Automaton MakeChar(char c) { var a = new Automaton(); a.Singleton = c.ToString(); a.IsDeterministic = true; return a; }
/// <summary> /// Returns a new (deterministic) automaton that accepts all strings. /// </summary> /// <returns> /// A new (deterministic) automaton that accepts all strings. /// </returns> internal static Automaton MakeAnyString() { var state = new State(); state.Accept = true; state.Transitions.Add(new Transition(char.MinValue, char.MaxValue, state)); var a = new Automaton(); a.Initial = state; a.IsDeterministic = true; return a; }
/// <summary> /// Initializes a new instance of the <see cref="Xeger"/> class. /// </summary> /// <param name="regex">The regex.</param> /// <param name="random">The random.</param> internal Xeger(string regex, Random random) { if (string.IsNullOrEmpty(regex)) { throw new ArgumentNullException("regex"); } if (random == null) { throw new ArgumentNullException("random"); } this.automaton = new RegExp(regex, AllExceptAnyString).ToAutomaton(); this.random = random; }
/// <summary> /// Reverses the language of the given (non-singleton) automaton while returning the set of /// new initial states. /// </summary> /// <param name="a">The automaton.</param> /// <returns></returns> internal static HashSet<State> Reverse(Automaton a) { // Reverse all edges. var m = new Dictionary<State, HashSet<Transition>>(); HashSet<State> states = a.GetStates(); HashSet<State> accept = a.GetAcceptStates(); foreach (State r in states) { m.Add(r, new HashSet<Transition>()); r.Accept = false; } foreach (State r in states) { foreach (Transition t in r.Transitions) { m[t.To].Add(new Transition(t.Min, t.Max, r)); } } foreach (State r in states) { r.Transitions = m[r].ToList(); } // Make new initial+final states. a.Initial.Accept = true; a.Initial = new State(); foreach (State r in accept) { a.Initial.AddEpsilon(r); // Ensures that all initial states are reachable. } a.IsDeterministic = false; return accept; }
internal static Automaton MakeStringMatcher(String s) { var a = new Automaton(); var states = new State[s.Length + 1]; states[0] = a.Initial; for (int i = 0; i < s.Length; i++) { states[i + 1] = new State(); } State f = states[s.Length]; f.Accept = true; f.Transitions.Add(new Transition(Char.MinValue, Char.MaxValue, f)); for (int i = 0; i < s.Length; i++) { var done = new HashSet <char?>(); char c = s[i]; states[i].Transitions.Add(new Transition(c, states[i + 1])); done.Add(c); for (int j = i; j >= 1; j--) { char d = s[j - 1]; if (!done.Contains(d) && s.Substring(0, j - 1).Equals(s.Substring(i - j + 1, i - (i - j + 1)))) { states[i].Transitions.Add(new Transition(d, states[j])); done.Add(d); } } var da = new char[done.Count]; int h = 0; foreach (char w in done) { da[h++] = w; } Array.Sort(da); int from = Char.MinValue; int k = 0; while (from <= Char.MaxValue) { while (k < da.Length && da[k] == from) { k++; from++; } if (from <= Char.MaxValue) { int to = Char.MaxValue; if (k < da.Length) { to = da[k] - 1; k++; } states[i].Transitions.Add(new Transition((char)from, (char)to, states[0])); from = to + 2; } } } a.IsDeterministic = true; return(a); }
/// <summary> /// Returns true if the given string is accepted by the automaton. /// </summary> /// <param name="a">The automaton.</param> /// <param name="s">The string.</param> /// <returns></returns> /// <remarks> /// Complexity: linear in the length of the string. /// </remarks> internal static bool Run(Automaton a, string s) { if (a.IsSingleton) { return(s.Equals(a.IsSingleton)); } if (a.IsDeterministic) { State p = a.Initial; foreach (char t in s) { State q = p.Step(t); if (q == null) { return(false); } p = q; } return(p.Accept); } HashSet <State> states = a.GetStates(); Automaton.SetStateNumbers(states); var pp = new LinkedList <State>(); var ppOther = new LinkedList <State>(); var bb = new BitArray(states.Count); var bbOther = new BitArray(states.Count); pp.AddLast(a.Initial); var dest = new List <State>(); bool accept = a.Initial.Accept; foreach (char c in s) { accept = false; ppOther.Clear(); bbOther.SetAll(false); foreach (State p in pp) { dest.Clear(); p.Step(c, dest); foreach (State q in dest) { if (q.Accept) { accept = true; } if (!bbOther.Get(q.Number)) { bbOther.Set(q.Number, true); ppOther.AddLast(q); } } } LinkedList <State> tp = pp; pp = ppOther; ppOther = tp; BitArray tb = bb; bb = bbOther; bbOther = tb; } return(accept); }
internal Automaton Concatenate(Automaton a) { return(BasicOperations.Concatenate(this, a)); }
internal static bool IsEmpty(Automaton a) { if (a.IsSingleton) { return false; } return !a.Initial.Accept && a.Initial.Transitions.Count == 0; }
/// <summary> /// Returns an automaton that accepts the intersection of the languages of the given automata. /// Never modifies the input automata languages. /// </summary> /// <param name="a1">The a1.</param> /// <param name="a2">The a2.</param> /// <returns></returns> internal static Automaton Intersection(Automaton a1, Automaton a2) { if (a1.IsSingleton) { if (a2.Run(a1.Singleton)) { return(a1.CloneIfRequired()); } return(BasicAutomata.MakeEmpty()); } if (a2.IsSingleton) { if (a1.Run(a2.Singleton)) { return(a2.CloneIfRequired()); } return(BasicAutomata.MakeEmpty()); } if (a1 == a2) { return(a1.CloneIfRequired()); } Transition[][] transitions1 = Automaton.GetSortedTransitions(a1.GetStates()); Transition[][] transitions2 = Automaton.GetSortedTransitions(a2.GetStates()); var c = new Automaton(); var worklist = new LinkedList <StatePair>(); var newstates = new Dictionary <StatePair, StatePair>(); var p = new StatePair(c.Initial, a1.Initial, a2.Initial); worklist.AddLast(p); newstates.Add(p, p); while (worklist.Count > 0) { p = worklist.RemoveAndReturnFirst(); p.S.Accept = p.FirstState.Accept && p.SecondState.Accept; Transition[] t1 = transitions1[p.FirstState.Number]; Transition[] t2 = transitions2[p.SecondState.Number]; for (int n1 = 0, b2 = 0; n1 < t1.Length; n1++) { while (b2 < t2.Length && t2[b2].Max < t1[n1].Min) { b2++; } for (int n2 = b2; n2 < t2.Length && t1[n1].Max >= t2[n2].Min; n2++) { if (t2[n2].Max >= t1[n1].Min) { var q = new StatePair(t1[n1].To, t2[n2].To); StatePair r; newstates.TryGetValue(q, out r); if (r == null) { q.S = new State(); worklist.AddLast(q); newstates.Add(q, q); r = q; } char min = t1[n1].Min > t2[n2].Min ? t1[n1].Min : t2[n2].Min; char max = t1[n1].Max < t2[n2].Max ? t1[n1].Max : t2[n2].Max; p.S.Transitions.Add(new Transition(min, max, r.S)); } } } } c.IsDeterministic = a1.IsDeterministic && a2.IsDeterministic; c.RemoveDeadTransitions(); c.CheckMinimizeAlways(); return(c); }
/// <summary> /// Determinizes the specified automaton. /// </summary> /// <remarks> /// Complexity: exponential in number of states. /// </remarks> /// <param name="a">The automaton.</param> internal static void Determinize(Automaton a) { if (a.IsDeterministic || a.IsSingleton) { return; } var initialset = new HashSet<State>(); initialset.Add(a.Initial); BasicOperations.Determinize(a, initialset.ToList()); }
/// <summary> /// Returns a new (deterministic) automaton that accepts a single char whose value is in the /// given interval (including both end points). /// </summary> /// <param name="min">The min.</param> /// <param name="max">The max.</param> /// <returns> /// A new (deterministic) automaton that accepts a single char whose value is in the /// given interval (including both end points). /// </returns> internal static Automaton MakeCharRange(char min, char max) { if (min == max) { return BasicAutomata.MakeChar(min); } var a = new Automaton(); var s1 = new State(); var s2 = new State(); a.Initial = s1; s2.Accept = true; if (min <= max) { s1.Transitions.Add(new Transition(min, max, s2)); } a.IsDeterministic = true; return a; }
/// <summary> /// Accepts <code>min</code> or more concatenated repetitions of the language of the given /// automaton. /// </summary> /// <param name="a">The automaton.</param> /// <param name="min">The minimum concatenated repetitions of the language of the given /// automaton.</param> /// <returns>Returns an automaton that accepts <code>min</code> or more concatenated /// repetitions of the language of the given automaton. /// </returns> /// <remarks> /// Complexity: linear in number of states and in <code>min</code>. /// </remarks> internal static Automaton Repeat(Automaton a, int min) { if (min == 0) { return BasicOperations.Repeat(a); } var @as = new List<Automaton>(); while (min-- > 0) { @as.Add(a); } @as.Add(BasicOperations.Repeat(a)); return BasicOperations.Concatenate(@as); }
/// <summary> /// Accepts between <code>min</code> and <code>max</code> (including both) concatenated /// repetitions of the language of the given automaton. /// </summary> /// <param name="a">The automaton.</param> /// <param name="min">The minimum concatenated repetitions of the language of the given /// automaton.</param> /// <param name="max">The maximum concatenated repetitions of the language of the given /// automaton.</param> /// <returns> /// Returns an automaton that accepts between <code>min</code> and <code>max</code> /// (including both) concatenated repetitions of the language of the given automaton. /// </returns> /// <remarks> /// Complexity: linear in number of states and in <code>min</code> and <code>max</code>. /// </remarks> internal static Automaton Repeat(Automaton a, int min, int max) { if (min > max) { return BasicAutomata.MakeEmpty(); } max -= min; a.ExpandSingleton(); Automaton b; if (min == 0) { b = BasicAutomata.MakeEmptyString(); } else if (min == 1) { b = a.Clone(); } else { var @as = new List<Automaton>(); while (min-- > 0) { @as.Add(a); } b = BasicOperations.Concatenate(@as); } if (max > 0) { Automaton d = a.Clone(); while (--max > 0) { Automaton c = a.Clone(); foreach (State p in c.GetAcceptStates()) { p.AddEpsilon(d.Initial); } d = c; } foreach (State p in b.GetAcceptStates()) { p.AddEpsilon(d.Initial); } b.IsDeterministic = false; b.ClearHashCode(); b.CheckMinimizeAlways(); } return b; }
/// <summary> /// Returns an automaton that accepts the union of the empty string and the language of the /// given automaton. /// </summary> /// <param name="a">The automaton.</param> /// <remarks> /// Complexity: linear in number of states. /// </remarks> /// <returns>An automaton that accepts the union of the empty string and the language of the /// given automaton.</returns> internal static Automaton Optional(Automaton a) { a = a.CloneExpandedIfRequired(); var s = new State(); s.AddEpsilon(a.Initial); s.Accept = true; a.Initial = s; a.IsDeterministic = false; a.ClearHashCode(); a.CheckMinimizeAlways(); return a; }
/// <summary> /// Accepts the Kleene star (zero or more concatenated repetitions) of the language of the /// given automaton. Never modifies the input automaton language. /// </summary> /// <param name="a">The automaton.</param> /// <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. /// </returns> /// <remarks> /// Complexity: linear in number of states. /// </remarks> internal static Automaton Repeat(Automaton a) { a = a.CloneExpanded(); var s = new State(); s.Accept = true; s.AddEpsilon(a.Initial); foreach (State p in a.GetAcceptStates()) { p.AddEpsilon(s); } a.Initial = s; a.IsDeterministic = false; a.ClearHashCode(); a.CheckMinimizeAlways(); return a; }
/// <summary> /// Adds epsilon transitions to the given automaton. This method adds extra character interval /// transitions that are equivalent to the given set of epsilon transitions. /// </summary> /// <param name="a">The automaton.</param> /// <param name="pairs">A collection of <see cref="StatePair"/> objects representing pairs of /// source/destination states where epsilon transitions should be added.</param> internal static void AddEpsilons(Automaton a, ICollection<StatePair> pairs) { a.ExpandSingleton(); var forward = new Dictionary<State, HashSet<State>>(); var back = new Dictionary<State, HashSet<State>>(); foreach (StatePair p in pairs) { HashSet<State> to = forward[p.FirstState]; if (to == null) { to = new HashSet<State>(); forward.Add(p.FirstState, to); } to.Add(p.SecondState); HashSet<State> from = back[p.SecondState]; if (from == null) { from = new HashSet<State>(); back.Add(p.SecondState, from); } from.Add(p.FirstState); } var worklist = new LinkedList<StatePair>(pairs); var workset = new HashSet<StatePair>(pairs); while (worklist.Count != 0) { StatePair p = worklist.RemoveAndReturnFirst(); workset.Remove(p); HashSet<State> to = forward[p.SecondState]; HashSet<State> from = back[p.FirstState]; if (to != null) { foreach (State s in to) { var pp = new StatePair(p.FirstState, s); if (!pairs.Contains(pp)) { pairs.Add(pp); forward[p.FirstState].Add(s); back[s].Add(p.FirstState); worklist.AddLast(pp); workset.Add(pp); if (from != null) { foreach (State q in from) { var qq = new StatePair(q, p.FirstState); if (!workset.Contains(qq)) { worklist.AddLast(qq); workset.Add(qq); } } } } } } } // Add transitions. foreach (StatePair p in pairs) { p.FirstState.AddEpsilon(p.SecondState); } a.IsDeterministic = false; a.ClearHashCode(); a.CheckMinimizeAlways(); }
/// <summary> /// Returns an automaton that accepts the intersection of the languages of the given automata. /// Never modifies the input automata languages. /// </summary> /// <param name="a1">The a1.</param> /// <param name="a2">The a2.</param> /// <returns></returns> internal static Automaton Intersection(Automaton a1, Automaton a2) { if (a1.IsSingleton) { if (a2.Run(a1.Singleton)) { return a1.CloneIfRequired(); } return BasicAutomata.MakeEmpty(); } if (a2.IsSingleton) { if (a1.Run(a2.Singleton)) { return a2.CloneIfRequired(); } return BasicAutomata.MakeEmpty(); } if (a1 == a2) { return a1.CloneIfRequired(); } Transition[][] transitions1 = Automaton.GetSortedTransitions(a1.GetStates()); Transition[][] transitions2 = Automaton.GetSortedTransitions(a2.GetStates()); var c = new Automaton(); var worklist = new LinkedList<StatePair>(); var newstates = new Dictionary<StatePair, StatePair>(); var p = new StatePair(c.Initial, a1.Initial, a2.Initial); worklist.AddLast(p); newstates.Add(p, p); while (worklist.Count > 0) { p = worklist.RemoveAndReturnFirst(); p.S.Accept = p.FirstState.Accept && p.SecondState.Accept; Transition[] t1 = transitions1[p.FirstState.Number]; Transition[] t2 = transitions2[p.SecondState.Number]; for (int n1 = 0, b2 = 0; n1 < t1.Length; n1++) { while (b2 < t2.Length && t2[b2].Max < t1[n1].Min) { b2++; } for (int n2 = b2; n2 < t2.Length && t1[n1].Max >= t2[n2].Min; n2++) { if (t2[n2].Max >= t1[n1].Min) { var q = new StatePair(t1[n1].To, t2[n2].To); StatePair r; newstates.TryGetValue(q, out r); if (r == null) { q.S = new State(); worklist.AddLast(q); newstates.Add(q, q); r = q; } char min = t1[n1].Min > t2[n2].Min ? t1[n1].Min : t2[n2].Min; char max = t1[n1].Max < t2[n2].Max ? t1[n1].Max : t2[n2].Max; p.S.Transitions.Add(new Transition(min, max, r.S)); } } } } c.IsDeterministic = a1.IsDeterministic && a2.IsDeterministic; c.RemoveDeadTransitions(); c.CheckMinimizeAlways(); return c; }
/// <summary> /// Determines whether the given automaton accepts the empty string and nothing else. /// </summary> /// <param name="a">The automaton.</param> /// <returns> /// <c>true</c> if the given automaton accepts the empty string and nothing else; otherwise, /// <c>false</c>. /// </returns> internal static bool IsEmptyString(Automaton a) { if (a.IsSingleton) { return a.Singleton.Length == 0; } return a.Initial.Accept && a.Initial.Transitions.Count == 0; }
/// <summary> /// Returns a (deterministic) automaton that accepts the complement of the language of the /// given automaton. /// </summary> /// <param name="a">The automaton.</param> /// <returns>A (deterministic) automaton that accepts the complement of the language of the /// given automaton.</returns> /// <remarks> /// Complexity: linear in number of states (if already deterministic). /// </remarks> internal static Automaton Complement(Automaton a) { a = a.CloneExpandedIfRequired(); a.Determinize(); a.Totalize(); foreach (State p in a.GetStates()) { p.Accept = !p.Accept; } a.RemoveDeadTransitions(); return a; }
internal static Automaton Minimize(Automaton a) { a.Minimize(); return a; }
internal static Automaton MakeStringMatcher(String s) { var a = new Automaton(); var states = new State[s.Length + 1]; states[0] = a.Initial; for (int i = 0; i < s.Length; i++) { states[i + 1] = new State(); } State f = states[s.Length]; f.Accept = true; f.Transitions.Add(new Transition(Char.MinValue, Char.MaxValue, f)); for (int i = 0; i < s.Length; i++) { var done = new HashSet<char?>(); char c = s[i]; states[i].Transitions.Add(new Transition(c, states[i + 1])); done.Add(c); for (int j = i; j >= 1; j--) { char d = s[j - 1]; if (!done.Contains(d) && s.Substring(0, j - 1).Equals(s.Substring(i - j + 1, i - (i - j + 1)))) { states[i].Transitions.Add(new Transition(d, states[j])); done.Add(d); } } var da = new char[done.Count]; int h = 0; foreach (char w in done) { da[h++] = w; } Array.Sort(da); int from = Char.MinValue; int k = 0; while (from <= Char.MaxValue) { while (k < da.Length && da[k] == from) { k++; from++; } if (from <= Char.MaxValue) { int to = Char.MaxValue; if (k < da.Length) { to = da[k] - 1; k++; } states[i].Transitions.Add(new Transition((char)from, (char)to, states[0])); from = to + 2; } } } a.IsDeterministic = true; return a; }
internal Automaton Intersection(Automaton a) { return BasicOperations.Intersection(this, a); }
internal static Automaton Concatenate(Automaton a1, Automaton a2) { if (a1.IsSingleton && a2.IsSingleton) { return BasicAutomata.MakeString(a1.Singleton + a2.Singleton); } if (BasicOperations.IsEmpty(a1) || BasicOperations.IsEmpty(a2)) { return BasicAutomata.MakeEmpty(); } 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.IsDeterministic = deterministic; a1.ClearHashCode(); a1.CheckMinimizeAlways(); return a1; }
internal static Automaton Concatenate(IList <Automaton> l) { if (l.Count == 0) { return(BasicAutomata.MakeEmptyString()); } bool allSingleton = l.All(a => a.IsSingleton); if (allSingleton) { var b = new StringBuilder(); foreach (Automaton a in l) { b.Append(a.Singleton); } return(BasicAutomata.MakeString(b.ToString())); } else { if (l.Any(a => a.IsEmpty)) { return(BasicAutomata.MakeEmpty()); } var ids = new HashSet <int>(); foreach (Automaton a in l) { ids.Add(RuntimeHelpers.GetHashCode(a)); } bool hasAliases = ids.Count != l.Count; Automaton b = l[0]; b = hasAliases ? b.CloneExpanded() : b.CloneExpandedIfRequired(); var ac = b.GetAcceptStates(); bool first = true; foreach (Automaton a in l) { if (first) { first = false; } else { if (a.IsEmptyString()) { continue; } Automaton aa = a; aa = hasAliases ? aa.CloneExpanded() : aa.CloneExpandedIfRequired(); HashSet <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.IsDeterministic = false; b.ClearHashCode(); b.CheckMinimizeAlways(); return(b); } }
/// <summary> /// Returns true if the given string is accepted by the automaton. /// </summary> /// <param name="a">The automaton.</param> /// <param name="s">The string.</param> /// <returns></returns> /// <remarks> /// Complexity: linear in the length of the string. /// </remarks> internal static bool Run(Automaton a, string s) { if (a.IsSingleton) { return s.Equals(a.IsSingleton); } if (a.IsDeterministic) { State p = a.Initial; foreach (char t in s) { State q = p.Step(t); if (q == null) { return false; } p = q; } return p.Accept; } HashSet<State> states = a.GetStates(); Automaton.SetStateNumbers(states); var pp = new LinkedList<State>(); var ppOther = new LinkedList<State>(); var bb = new BitArray(states.Count); var bbOther = new BitArray(states.Count); pp.AddLast(a.Initial); var dest = new List<State>(); bool accept = a.Initial.Accept; foreach (char c in s) { accept = false; ppOther.Clear(); bbOther.SetAll(false); foreach (State p in pp) { dest.Clear(); p.Step(c, dest); foreach (State q in dest) { if (q.Accept) { accept = true; } if (!bbOther.Get(q.Number)) { bbOther.Set(q.Number, true); ppOther.AddLast(q); } } } LinkedList<State> tp = pp; pp = ppOther; ppOther = tp; BitArray tb = bb; bb = bbOther; bbOther = tb; } return accept; }
/// <summary> /// Determinizes the given automaton using the given set of initial states. /// </summary> /// <param name="a">The automaton.</param> /// <param name="initialset">The initial states.</param> internal static void Determinize(Automaton a, List<State> initialset) { char[] points = a.GetStartPoints(); var comparer = new ListEqualityComparer<State>(); // Subset construction. var sets = new Dictionary<List<State>, List<State>>(comparer); var worklist = new LinkedList<List<State>>(); var newstate = new Dictionary<List<State>, State>(); sets.Add(initialset, initialset); worklist.AddLast(initialset); a.Initial = new State(); newstate.Add(initialset, a.Initial); while (worklist.Count > 0) { List<State> s = worklist.RemoveAndReturnFirst(); State r; newstate.TryGetValue(s, out r); foreach (State q in s) { if (q.Accept) { r.Accept = true; break; } } for (int n = 0; n < points.Length; n++) { var p = (from qq in s from t in qq.Transitions where t.Min <= points[n] && points[n] <= t.Max select t.To).ToList(); if (!sets.ContainsKey(p)) { sets.Add(p, p); worklist.AddLast(p); newstate.Add(p, new State()); } State q; newstate.TryGetValue(p, out q); char min = points[n]; char max; if (n + 1 < points.Length) { max = (char)(points[n + 1] - 1); } else { max = char.MaxValue; } r.Transitions.Add(new Transition(min, max, q)); } } a.IsDeterministic = true; a.RemoveDeadTransitions(); }
internal Automaton Concatenate(Automaton a) { return BasicOperations.Concatenate(this, a); }
/// <summary> /// Minimizes the given automaton using Huffman's algorithm. /// </summary> /// <param name="a">The automaton.</param> internal static void MinimizeHuffman(Automaton a) { a.Determinize(); a.Totalize(); HashSet <State> ss = a.GetStates(); var transitions = new Transition[ss.Count][]; State[] states = ss.ToArray(); var mark = new List <List <bool> >(); var triggers = new List <List <HashSet <IntPair> > >(); foreach (State t in states) { var v = new List <HashSet <IntPair> >(); Initialize(ref v, states.Length); triggers.Add(v); } // Initialize marks based on acceptance status and find transition arrays. for (int n1 = 0; n1 < states.Length; n1++) { states[n1].Number = n1; transitions[n1] = states[n1].GetSortedTransitions(false).ToArray(); for (int n2 = n1 + 1; n2 < states.Length; n2++) { if (states[n1].Accept != states[n2].Accept) { mark[n1][n2] = true; } } } // For all pairs, see if states agree. for (int n1 = 0; n1 < states.Length; n1++) { for (int n2 = n1 + 1; n2 < states.Length; n2++) { if (!mark[n1][n2]) { if (MinimizationOperations.StatesAgree(transitions, mark, n1, n2)) { MinimizationOperations.AddTriggers(transitions, triggers, n1, n2); } else { MinimizationOperations.MarkPair(mark, triggers, n1, n2); } } } } // Assign equivalence class numbers to states. int numclasses = 0; foreach (State t in states) { t.Number = -1; } for (int n1 = 0; n1 < states.Length; n1++) { if (states[n1].Number == -1) { states[n1].Number = numclasses; for (int n2 = n1 + 1; n2 < states.Length; n2++) { if (!mark[n1][n2]) { states[n2].Number = numclasses; } } numclasses++; } } // Make a new state for each equivalence class. var newstates = new State[numclasses]; for (int n = 0; n < numclasses; n++) { newstates[n] = new State(); } // Select a class representative for each class and find the new initial state. for (int n = 0; n < states.Length; n++) { newstates[states[n].Number].Number = n; if (states[n] == a.Initial) { a.Initial = newstates[states[n].Number]; } } // Build transitions and set acceptance. for (int n = 0; n < numclasses; n++) { State s = newstates[n]; s.Accept = states[s.Number].Accept; foreach (Transition t in states[s.Number].Transitions) { s.Transitions.Add(new Transition(t.Min, t.Max, newstates[t.To.Number])); } } a.RemoveDeadTransitions(); }
private Automaton ToAutomaton( IDictionary <string, Automaton> automata, IAutomatonProvider automatonProvider, bool minimize) { IList <Automaton> list; Automaton a = null; switch (kind) { case Kind.RegexpUnion: list = new List <Automaton>(); this.FindLeaves(exp1, Kind.RegexpUnion, list, automata, automatonProvider, minimize); this.FindLeaves(exp2, Kind.RegexpUnion, list, automata, automatonProvider, minimize); a = BasicOperations.Union(list); a.Minimize(); break; case Kind.RegexpConcatenation: list = new List <Automaton>(); this.FindLeaves(exp1, Kind.RegexpConcatenation, list, automata, automatonProvider, minimize); this.FindLeaves(exp2, Kind.RegexpConcatenation, list, automata, automatonProvider, minimize); a = BasicOperations.Concatenate(list); a.Minimize(); break; case Kind.RegexpIntersection: a = exp1.ToAutomaton(automata, automatonProvider, minimize) .Intersection(exp2.ToAutomaton(automata, automatonProvider, minimize)); a.Minimize(); break; case Kind.RegexpOptional: a = exp1.ToAutomaton(automata, automatonProvider, minimize).Optional(); a.Minimize(); break; case Kind.RegexpRepeat: a = exp1.ToAutomaton(automata, automatonProvider, minimize).Repeat(); a.Minimize(); break; case Kind.RegexpRepeatMin: a = exp1.ToAutomaton(automata, automatonProvider, minimize).Repeat(min); a.Minimize(); break; case Kind.RegexpRepeatMinMax: a = exp1.ToAutomaton(automata, automatonProvider, minimize).Repeat(min, max); a.Minimize(); break; case Kind.RegexpComplement: a = exp1.ToAutomaton(automata, automatonProvider, minimize).Complement(); a.Minimize(); break; case Kind.RegexpChar: a = BasicAutomata.MakeChar(c); break; case Kind.RegexpCharRange: a = BasicAutomata.MakeCharRange(from, to); break; case Kind.RegexpAnyChar: a = BasicAutomata.MakeAnyChar(); break; case Kind.RegexpEmpty: a = BasicAutomata.MakeEmpty(); break; case Kind.RegexpString: a = BasicAutomata.MakeString(s); break; case Kind.RegexpAnyString: a = BasicAutomata.MakeAnyString(); break; case Kind.RegexpAutomaton: Automaton aa = null; if (automata != null) { automata.TryGetValue(s, out aa); } if (aa == null && automatonProvider != null) { try { aa = automatonProvider.GetAutomaton(s); } catch (IOException e) { throw new ArgumentException(string.Empty, e); } } if (aa == null) { throw new ArgumentException("'" + s + "' not found"); } a = aa.Clone(); // Always clone here (ignore allowMutate). break; case Kind.RegexpInterval: a = BasicAutomata.MakeInterval(min, max, digits); break; } return(a); }
internal static void MinimizeHopcroft(Automaton a) { a.Determinize(); IList <Transition> tr = a.Initial.Transitions; if (tr.Count == 1) { Transition t = tr[0]; if (t.To == a.Initial && t.Min == char.MinValue && t.Max == char.MaxValue) { return; } } a.Totalize(); // Make arrays for numbered states and effective alphabet. HashSet <State> ss = a.GetStates(); var states = new State[ss.Count]; int number = 0; foreach (State q in ss) { states[number] = q; q.Number = number++; } char[] sigma = a.GetStartPoints(); // Initialize data structures. var reverse = new List <List <LinkedList <State> > >(); foreach (State s in states) { var v = new List <LinkedList <State> >(); Initialize(ref v, sigma.Length); reverse.Add(v); } var reverseNonempty = new bool[states.Length, sigma.Length]; var partition = new List <LinkedList <State> >(); Initialize(ref partition, states.Length); var block = new int[states.Length]; var active = new StateList[states.Length, sigma.Length]; var active2 = new StateListNode[states.Length, sigma.Length]; var pending = new LinkedList <IntPair>(); var pending2 = new bool[sigma.Length, states.Length]; var split = new List <State>(); var split2 = new bool[states.Length]; var refine = new List <int>(); var refine2 = new bool[states.Length]; var splitblock = new List <List <State> >(); Initialize(ref splitblock, states.Length); for (int q = 0; q < states.Length; q++) { splitblock[q] = new List <State>(); partition[q] = new LinkedList <State>(); for (int x = 0; x < sigma.Length; x++) { reverse[q][x] = new LinkedList <State>(); active[q, x] = new StateList(); } } // Find initial partition and reverse edges. foreach (State qq in states) { int j = qq.Accept ? 0 : 1; partition[j].AddLast(qq); block[qq.Number] = j; for (int x = 0; x < sigma.Length; x++) { char y = sigma[x]; State p = qq.Step(y); reverse[p.Number][x].AddLast(qq); reverseNonempty[p.Number, x] = true; } } // Initialize active sets. for (int j = 0; j <= 1; j++) { for (int x = 0; x < sigma.Length; x++) { foreach (State qq in partition[j]) { if (reverseNonempty[qq.Number, x]) { active2[qq.Number, x] = active[j, x].Add(qq); } } } } // Initialize pending. for (int x = 0; x < sigma.Length; x++) { int a0 = active[0, x].Size; int a1 = active[1, x].Size; int j = a0 <= a1 ? 0 : 1; pending.AddLast(new IntPair(j, x)); pending2[x, j] = true; } // Process pending until fixed point. int k = 2; while (pending.Count > 0) { IntPair ip = pending.RemoveAndReturnFirst(); int p = ip.N1; int x = ip.N2; pending2[x, p] = false; // Find states that need to be split off their blocks. for (StateListNode m = active[p, x].First; m != null; m = m.Next) { foreach (State s in reverse[m.State.Number][x]) { if (!split2[s.Number]) { split2[s.Number] = true; split.Add(s); int j = block[s.Number]; splitblock[j].Add(s); if (!refine2[j]) { refine2[j] = true; refine.Add(j); } } } } // Refine blocks. foreach (int j in refine) { if (splitblock[j].Count < partition[j].Count) { LinkedList <State> b1 = partition[j]; LinkedList <State> b2 = partition[k]; foreach (State s in splitblock[j]) { b1.Remove(s); b2.AddLast(s); block[s.Number] = k; for (int c = 0; c < sigma.Length; c++) { StateListNode sn = active2[s.Number, c]; if (sn != null && sn.StateList == active[j, c]) { sn.Remove(); active2[s.Number, c] = active[k, c].Add(s); } } } // Update pending. for (int c = 0; c < sigma.Length; c++) { int aj = active[j, c].Size; int ak = active[k, c].Size; if (!pending2[c, j] && 0 < aj && aj <= ak) { pending2[c, j] = true; pending.AddLast(new IntPair(j, c)); } else { pending2[c, k] = true; pending.AddLast(new IntPair(k, c)); } } k++; } foreach (State s in splitblock[j]) { split2[s.Number] = false; } refine2[j] = false; splitblock[j].Clear(); } split.Clear(); refine.Clear(); } // Make a new state for each equivalence class, set initial state. var newstates = new State[k]; for (int n = 0; n < newstates.Length; n++) { var s = new State(); newstates[n] = s; foreach (State q in partition[n]) { if (q == a.Initial) { a.Initial = s; } s.Accept = q.Accept; s.Number = q.Number; // Select representative. q.Number = n; } } // Build transitions and set acceptance. foreach (State s in newstates) { s.Accept = states[s.Number].Accept; foreach (Transition t in states[s.Number].Transitions) { s.Transitions.Add(new Transition(t.Min, t.Max, newstates[t.To.Number])); } } a.RemoveDeadTransitions(); }
/// <summary> /// Determinizes the given automaton using the given set of initial states. /// </summary> /// <param name="a">The automaton.</param> /// <param name="initialset">The initial states.</param> internal static void Determinize(Automaton a, List <State> initialset) { char[] points = a.GetStartPoints(); var comparer = new ListEqualityComparer <State>(); // Subset construction. var sets = new Dictionary <List <State>, List <State> >(comparer); var worklist = new LinkedList <List <State> >(); var newstate = new Dictionary <List <State>, State>(); sets.Add(initialset, initialset); worklist.AddLast(initialset); a.Initial = new State(); newstate.Add(initialset, a.Initial); while (worklist.Count > 0) { List <State> s = worklist.RemoveAndReturnFirst(); State r; newstate.TryGetValue(s, out r); foreach (State q in s) { if (q.Accept) { r.Accept = true; break; } } for (int n = 0; n < points.Length; n++) { var p = (from qq in s from t in qq.Transitions where t.Min <= points[n] && points[n] <= t.Max select t.To).ToList(); if (!sets.ContainsKey(p)) { sets.Add(p, p); worklist.AddLast(p); newstate.Add(p, new State()); } State q; newstate.TryGetValue(p, out q); char min = points[n]; char max; if (n + 1 < points.Length) { max = (char)(points[n + 1] - 1); } else { max = char.MaxValue; } r.Transitions.Add(new Transition(min, max, q)); } } a.IsDeterministic = true; a.RemoveDeadTransitions(); }
/// <summary> /// Returns a new (deterministic) automaton with the empty language. /// </summary> /// <returns> /// A new (deterministic) automaton with the empty language. /// </returns> internal static Automaton MakeEmpty() { var a = new Automaton(); var s = new State(); a.Initial = s; a.IsDeterministic = true; return a; }
/// <summary> /// Adds epsilon transitions to the given automaton. This method adds extra character interval /// transitions that are equivalent to the given set of epsilon transitions. /// </summary> /// <param name="a">The automaton.</param> /// <param name="pairs">A collection of <see cref="StatePair"/> objects representing pairs of /// source/destination states where epsilon transitions should be added.</param> internal static void AddEpsilons(Automaton a, ICollection <StatePair> pairs) { a.ExpandSingleton(); var forward = new Dictionary <State, HashSet <State> >(); var back = new Dictionary <State, HashSet <State> >(); foreach (StatePair p in pairs) { HashSet <State> to = forward[p.FirstState]; if (to == null) { to = new HashSet <State>(); forward.Add(p.FirstState, to); } to.Add(p.SecondState); HashSet <State> from = back[p.SecondState]; if (from == null) { from = new HashSet <State>(); back.Add(p.SecondState, from); } from.Add(p.FirstState); } var worklist = new LinkedList <StatePair>(pairs); var workset = new HashSet <StatePair>(pairs); while (worklist.Count != 0) { StatePair p = worklist.RemoveAndReturnFirst(); workset.Remove(p); HashSet <State> to = forward[p.SecondState]; HashSet <State> from = back[p.FirstState]; if (to != null) { foreach (State s in to) { var pp = new StatePair(p.FirstState, s); if (!pairs.Contains(pp)) { pairs.Add(pp); forward[p.FirstState].Add(s); back[s].Add(p.FirstState); worklist.AddLast(pp); workset.Add(pp); if (from != null) { foreach (State q in from) { var qq = new StatePair(q, p.FirstState); if (!workset.Contains(qq)) { worklist.AddLast(qq); workset.Add(qq); } } } } } } } // Add transitions. foreach (StatePair p in pairs) { p.FirstState.AddEpsilon(p.SecondState); } a.IsDeterministic = false; a.ClearHashCode(); a.CheckMinimizeAlways(); }
/// <summary> /// Returns a new (deterministic) automaton that accepts only the empty string. /// </summary> /// <returns> /// A new (deterministic) automaton that accepts only the empty string. /// </returns> internal static Automaton MakeEmptyString() { var a = new Automaton(); a.Singleton = string.Empty; a.IsDeterministic = true; return a; }
internal static Automaton Minimize(Automaton a) { a.Minimize(); return(a); }
internal static Automaton MakeInterval(int min, int max, int digits) { var a = new Automaton(); string x = Convert.ToString(min, CultureInfo.CurrentCulture); string y = Convert.ToString(max, CultureInfo.CurrentCulture); if (min > max || (digits > 0 && y.Length > digits)) { throw new ArgumentException(); } int d = digits > 0 ? digits : y.Length; var bx = new StringBuilder(); for (int i = x.Length; i < d; i++) { bx.Append('0'); } bx.Append(x); x = bx.ToString(); var by = new StringBuilder(); for (int i = y.Length; i < d; i++) { by.Append('0'); } by.Append(y); y = by.ToString(); ICollection<State> initials = new List<State>(); a.Initial = BasicAutomata.Between(x, y, 0, initials, digits <= 0); if (digits <= 0) { List<StatePair> pairs = (from p in initials where a.Initial != p select new StatePair(a.Initial, p)).ToList(); a.AddEpsilons(pairs); a.Initial.AddTransition(new Transition('0', a.Initial)); a.IsDeterministic = false; } else { a.IsDeterministic = true; } a.CheckMinimizeAlways(); return a; }
internal Automaton Intersection(Automaton a) { return(BasicOperations.Intersection(this, a)); }
/// <summary> /// Returns a new (deterministic) automaton that accepts the single given string. /// </summary> /// <param name="s">The string.</param> /// <returns>A new (deterministic) automaton that accepts the single given string.</returns> internal static Automaton MakeString(string s) { var a = new Automaton(); a.Singleton = s; a.IsDeterministic = true; return a; }
internal static Automaton MakeCharSet(string set) { if (set.Length == 1) { return MakeChar(set[0]); } var a = new Automaton(); var s1 = new State(); var s2 = new State(); a.Initial = s1; s2.Accept = true; foreach (char t in set) { s1.Transitions.Add(new Transition(t, s2)); } a.IsDeterministic = true; a.Reduce(); return a; }
/// <summary> /// Returns an automaton that accepts the union of the languages of the given automata. /// </summary> /// <param name="automatons">The l.</param> /// <returns> /// An automaton that accepts the union of the languages of the given automata. /// </returns> /// <remarks> /// Complexity: linear in number of states. /// </remarks> internal static Automaton Union(IList<Automaton> automatons) { var ids = new HashSet<int>(); foreach (Automaton a in automatons) { ids.Add(RuntimeHelpers.GetHashCode(a)); } bool hasAliases = ids.Count != automatons.Count; var s = new State(); foreach (Automaton b in automatons) { if (b.IsEmpty) { continue; } Automaton bb = b; bb = hasAliases ? bb.CloneExpanded() : bb.CloneExpandedIfRequired(); s.AddEpsilon(bb.Initial); } var automaton = new Automaton(); automaton.Initial = s; automaton.IsDeterministic = false; automaton.ClearHashCode(); automaton.CheckMinimizeAlways(); return automaton; }