// LUCENENET specific - De-nested RandomAcceptedStrings /// <summary> /// Return a random NFA/DFA for testing. </summary> public static Automaton RandomAutomaton(Random random) { // get two random Automata from regexps Automaton a1 = (new RegExp(AutomatonTestUtil.RandomRegexp(random), RegExpSyntax.NONE)).ToAutomaton(); if (random.NextBoolean()) { a1 = BasicOperations.Complement(a1); } Automaton a2 = (new RegExp(AutomatonTestUtil.RandomRegexp(random), RegExpSyntax.NONE)).ToAutomaton(); if (random.NextBoolean()) { a2 = BasicOperations.Complement(a2); } // combine them in random ways switch (random.Next(4)) { case 0: return(BasicOperations.Concatenate(a1, a2)); case 1: return(BasicOperations.Union(a1, a2)); case 2: return(BasicOperations.Intersection(a1, a2)); default: return(BasicOperations.Minus(a1, a2)); } }
public virtual void TestEmptyLanguageConcatenate() { Automaton a = BasicAutomata.MakeString("a"); Automaton concat = BasicOperations.Concatenate(a, BasicAutomata.MakeEmpty()); Assert.IsTrue(BasicOperations.IsEmpty(concat)); }
public virtual void TestSingletonConcatenate() { Automaton singleton = BasicAutomata.MakeString("prefix"); Automaton expandedSingleton = singleton.CloneExpanded(); Automaton other = BasicAutomata.MakeCharRange('5', '7'); Automaton concat = BasicOperations.Concatenate(singleton, other); Assert.IsTrue(concat.IsDeterministic); Assert.IsTrue(BasicOperations.SameLanguage(BasicOperations.Concatenate(expandedSingleton, other), concat)); }
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)); }
/// <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 CompiledAutomaton(Automaton automaton, bool?finite, bool simplify) { if (simplify) { // Test whether the automaton is a "simple" form and // if so, don't create a runAutomaton. Note that on a // large automaton these tests could be costly: if (BasicOperations.IsEmpty(automaton)) { // matches nothing Type = AUTOMATON_TYPE.NONE; Term = null; CommonSuffixRef = null; RunAutomaton = null; sortedTransitions = null; this.Finite = null; return; } else if (BasicOperations.IsTotal(automaton)) { // matches all possible strings Type = AUTOMATON_TYPE.ALL; Term = null; CommonSuffixRef = null; RunAutomaton = null; sortedTransitions = null; this.Finite = null; return; } else { string commonPrefix; string singleton; if (automaton.Singleton == null) { commonPrefix = SpecialOperations.GetCommonPrefix(automaton); if (commonPrefix.Length > 0 && BasicOperations.SameLanguage(automaton, BasicAutomata.MakeString(commonPrefix))) { singleton = commonPrefix; } else { singleton = null; } } else { commonPrefix = null; singleton = automaton.Singleton; } if (singleton != null) { // matches a fixed string in singleton or expanded // representation Type = AUTOMATON_TYPE.SINGLE; Term = new BytesRef(singleton); CommonSuffixRef = null; RunAutomaton = null; sortedTransitions = null; this.Finite = null; return; } else if (BasicOperations.SameLanguage(automaton, BasicOperations.Concatenate(BasicAutomata.MakeString(commonPrefix), BasicAutomata.MakeAnyString()))) { // matches a constant prefix Type = AUTOMATON_TYPE.PREFIX; Term = new BytesRef(commonPrefix); CommonSuffixRef = null; RunAutomaton = null; sortedTransitions = null; this.Finite = null; return; } } } Type = AUTOMATON_TYPE.NORMAL; Term = null; if (finite == null) { this.Finite = SpecialOperations.IsFinite(automaton); } else { this.Finite = finite; } Automaton utf8 = (new UTF32ToUTF8()).Convert(automaton); if (this.Finite == true) { CommonSuffixRef = null; } else { CommonSuffixRef = SpecialOperations.GetCommonSuffixBytesRef(utf8); } RunAutomaton = new ByteRunAutomaton(utf8, true); sortedTransitions = utf8.GetSortedTransitions(); }
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.Concatenate(IList{Automaton})"/>. /// </summary> public static Automaton Concatenate(IList <Automaton> l) { return(BasicOperations.Concatenate(l)); }
/// <summary> /// See <see cref="BasicOperations.Concatenate(Automaton, Automaton)"/>. /// </summary> public virtual Automaton Concatenate(Automaton a) { return(BasicOperations.Concatenate(this, a)); }