/// <summary> /// Return an automaton that accepts all 1-character insertions, deletions, /// substitutions, and transpositions of s. /// </summary> private Automaton NaiveLev1T(string s) { Automaton a = NaiveLev1(s); a = BasicOperations.Union(a, TranspositionsOf(s)); MinimizationOperations.Minimize(a); return(a); }
public virtual void TestSingletonNFAConcatenate() { Automaton singleton = BasicAutomata.MakeString("prefix"); Automaton expandedSingleton = singleton.CloneExpanded(); // an NFA (two transitions for 't' from initial state) Automaton nfa = BasicOperations.Union(BasicAutomata.MakeString("this"), BasicAutomata.MakeString("three")); Automaton concat = BasicOperations.Concatenate(singleton, nfa); Assert.IsFalse(concat.IsDeterministic); Assert.IsTrue(BasicOperations.SameLanguage(BasicOperations.Concatenate(expandedSingleton, nfa), concat)); }
private static Automaton NaiveUnion(IList <BytesRef> strings) { Automaton[] eachIndividual = new Automaton[strings.Count]; int i = 0; foreach (BytesRef bref in strings) { eachIndividual[i++] = BasicAutomata.MakeString(bref.Utf8ToString()); } return(BasicOperations.Union(eachIndividual)); }
/// <summary> /// Return an automaton that accepts all 1-character insertions, deletions, and /// substitutions of s. /// </summary> private Automaton NaiveLev1(string s) { Automaton a = BasicAutomata.MakeString(s); a = BasicOperations.Union(a, InsertionsOf(s)); MinimizationOperations.Minimize(a); a = BasicOperations.Union(a, DeletionsOf(s)); MinimizationOperations.Minimize(a); a = BasicOperations.Union(a, SubstitutionsOf(s)); MinimizationOperations.Minimize(a); return(a); }
public virtual void TestFiniteStrings() { Automaton a = BasicOperations.Union(BasicAutomata.MakeString("dog"), BasicAutomata.MakeString("duck")); MinimizationOperations.Minimize(a); ISet <Int32sRef> strings = SpecialOperations.GetFiniteStrings(a, -1); Assert.AreEqual(2, strings.Count); Int32sRef dog = new Int32sRef(); Util.ToInt32sRef(new BytesRef("dog"), dog); Assert.IsTrue(strings.Contains(dog)); Int32sRef duck = new Int32sRef(); Util.ToInt32sRef(new BytesRef("duck"), duck); Assert.IsTrue(strings.Contains(duck)); }
/// <summary> /// Return an automaton that accepts all 1-character substitutions of s /// (replacing one character) /// </summary> private Automaton SubstitutionsOf(string s) { IList <Automaton> list = new List <Automaton>(); for (int i = 0; i < s.Length; i++) { Automaton au = BasicAutomata.MakeString(s.Substring(0, i)); au = BasicOperations.Concatenate(au, BasicAutomata.MakeAnyChar()); au = BasicOperations.Concatenate(au, BasicAutomata.MakeString(s.Substring(i + 1))); list.Add(au); } Automaton a = BasicOperations.Union(list); MinimizationOperations.Minimize(a); return(a); }
public void AssertLexicon(List<Automaton> a, List<string> terms) { var automata = CollectionsHelper.Shuffle(a); var lex = BasicOperations.Union(automata); lex.Determinize(); Assert.IsTrue(SpecialOperations.IsFinite(lex)); foreach (string s in terms) { Assert.IsTrue(BasicOperations.Run(lex, s)); } var lexByte = new ByteRunAutomaton(lex); foreach (string s in terms) { sbyte[] bytes = s.GetBytes(Encoding.UTF8); Assert.IsTrue(lexByte.Run(bytes, 0, bytes.Length)); } }
public void AssertLexicon() { Collections.Shuffle(automata, Random()); var lex = BasicOperations.Union(automata); lex.Determinize(); Assert.IsTrue(SpecialOperations.IsFinite(lex)); foreach (string s in terms) { assertTrue(BasicOperations.Run(lex, s)); } var lexByte = new ByteRunAutomaton(lex); foreach (string s in terms) { var bytes = s.GetBytes(Encoding.UTF8); assertTrue(lexByte.Run(bytes, 0, bytes.Length)); } }
private Automaton ToAutomaton(IDictionary <string, Automaton> automata, IAutomatonProvider automaton_provider) { IList <Automaton> list; Automaton a = null; switch (kind) { case Kind.REGEXP_UNION: list = new List <Automaton>(); FindLeaves(exp1, Kind.REGEXP_UNION, list, automata, automaton_provider); FindLeaves(exp2, Kind.REGEXP_UNION, list, automata, automaton_provider); a = BasicOperations.Union(list); MinimizationOperations.Minimize(a); break; case Kind.REGEXP_CONCATENATION: list = new List <Automaton>(); FindLeaves(exp1, Kind.REGEXP_CONCATENATION, list, automata, automaton_provider); FindLeaves(exp2, Kind.REGEXP_CONCATENATION, list, automata, automaton_provider); a = BasicOperations.Concatenate(list); MinimizationOperations.Minimize(a); break; case Kind.REGEXP_INTERSECTION: a = exp1.ToAutomaton(automata, automaton_provider).Intersection(exp2.ToAutomaton(automata, automaton_provider)); MinimizationOperations.Minimize(a); break; case Kind.REGEXP_OPTIONAL: a = exp1.ToAutomaton(automata, automaton_provider).Optional(); MinimizationOperations.Minimize(a); break; case Kind.REGEXP_REPEAT: a = exp1.ToAutomaton(automata, automaton_provider).Repeat(); MinimizationOperations.Minimize(a); break; case Kind.REGEXP_REPEAT_MIN: a = exp1.ToAutomaton(automata, automaton_provider).Repeat(min); MinimizationOperations.Minimize(a); break; case Kind.REGEXP_REPEAT_MINMAX: a = exp1.ToAutomaton(automata, automaton_provider).Repeat(min, max); MinimizationOperations.Minimize(a); break; case Kind.REGEXP_COMPLEMENT: a = exp1.ToAutomaton(automata, automaton_provider).Complement(); MinimizationOperations.Minimize(a); break; case Kind.REGEXP_CHAR: a = BasicAutomata.MakeChar(c); break; case Kind.REGEXP_CHAR_RANGE: a = BasicAutomata.MakeCharRange(from, to); break; case Kind.REGEXP_ANYCHAR: a = BasicAutomata.MakeAnyChar(); break; case Kind.REGEXP_EMPTY: a = BasicAutomata.MakeEmpty(); break; case Kind.REGEXP_STRING: a = BasicAutomata.MakeString(s); break; case Kind.REGEXP_ANYSTRING: a = BasicAutomata.MakeAnyString(); break; case Kind.REGEXP_AUTOMATON: Automaton aa = null; if (automata != null) { aa = automata[s]; } if (aa == null && automaton_provider != null) { try { aa = automaton_provider.GetAutomaton(s); } catch (Exception e) when(e.IsIOException()) { throw new ArgumentException(e.ToString(), e); } } if (aa == null) { throw new ArgumentException("'" + s + "' not found"); } a = (Automaton)aa.Clone(); // always clone here (ignore allow_mutate) break; case Kind.REGEXP_INTERVAL: a = BasicAutomata.MakeInterval(min, max, digits); break; } return(a); }
/// <summary> /// See <see cref="BasicOperations.Union(ICollection{Automaton})"/>. /// </summary> public static Automaton Union(ICollection <Automaton> l) { return(BasicOperations.Union(l)); }
/// <summary> /// See <see cref="BasicOperations.Union(Automaton, Automaton)"/>. /// </summary> public virtual Automaton Union(Automaton a) { return(BasicOperations.Union(this, a)); }