/// <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));
}
