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();
}
/// <summary>
/// Returns an automaton that accepts the intersection of the languages of the
/// given automata. Never modifies the input automata languages.
/// <para/>
/// Complexity: quadratic in number of states.
/// </summary>
public static Automaton Intersection(Automaton a1, Automaton a2)
{
if (a1.IsSingleton)
{
if (BasicOperations.Run(a2, a1.singleton))
{
return(a1.CloneIfRequired());
}
else
{
return(BasicAutomata.MakeEmpty());
}
}
if (a2.IsSingleton)
{
if (BasicOperations.Run(a1, a2.singleton))
{
return(a2.CloneIfRequired());
}
else
{
return(BasicAutomata.MakeEmpty());
}
}
if (a1 == a2)
{
return(a1.CloneIfRequired());
}
Transition[][] transitions1 = a1.GetSortedTransitions();
Transition[][] transitions2 = a2.GetSortedTransitions();
Automaton c = new Automaton();
LinkedList <StatePair> worklist = new LinkedList <StatePair>();
Dictionary <StatePair, StatePair> newstates = new Dictionary <StatePair, StatePair>();
StatePair p = new StatePair(c.initial, a1.initial, a2.initial);
worklist.AddLast(p);
newstates[p] = p;
while (worklist.Count > 0)
{
p = worklist.First.Value;
worklist.Remove(p);
p.s.accept = p.S1.accept && p.S2.accept;
Transition[] t1 = transitions1[p.S1.number];
Transition[] t2 = transitions2[p.S2.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)
{
StatePair 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[q] = q;
r = q;
}
int min = t1[n1].min > t2[n2].min ? t1[n1].min : t2[n2].min;
int max = t1[n1].max < t2[n2].max ? t1[n1].max : t2[n2].max;
p.s.AddTransition(new Transition(min, max, r.s));
}
}
}
}
c.deterministic = a1.deterministic && a2.deterministic;
c.RemoveDeadTransitions();
c.CheckMinimizeAlways();
return(c);
}
/// <summary>
/// Returns true if the language of <paramref name="a1"/> is a subset of the language
/// of <paramref name="a2"/>. As a side-effect, <paramref name="a2"/> is determinized if
/// not already marked as deterministic.
/// <para/>
/// Complexity: quadratic in number of states.
/// </summary>
public static bool SubsetOf(Automaton a1, Automaton a2)
{
if (a1 == a2)
{
return(true);
}
if (a1.IsSingleton)
{
if (a2.IsSingleton)
{
return(a1.singleton.Equals(a2.singleton, StringComparison.Ordinal));
}
return(BasicOperations.Run(a2, a1.singleton));
}
a2.Determinize();
Transition[][] transitions1 = a1.GetSortedTransitions();
Transition[][] transitions2 = a2.GetSortedTransitions();
LinkedList <StatePair> worklist = new LinkedList <StatePair>();
HashSet <StatePair> visited = new HashSet <StatePair>();
StatePair p = new StatePair(a1.initial, a2.initial);
worklist.AddLast(p);
visited.Add(p);
while (worklist.Count > 0)
{
p = worklist.First.Value;
worklist.Remove(p);
if (p.S1.accept && !p.S2.accept)
{
return(false);
}
Transition[] t1 = transitions1[p.S1.number];
Transition[] t2 = transitions2[p.S2.number];
for (int n1 = 0, b2 = 0; n1 < t1.Length; n1++)
{
while (b2 < t2.Length && t2[b2].max < t1[n1].min)
{
b2++;
}
int min1 = t1[n1].min, max1 = t1[n1].max;
for (int n2 = b2; n2 < t2.Length && t1[n1].max >= t2[n2].min; n2++)
{
if (t2[n2].min > min1)
{
return(false);
}
if (t2[n2].max < Character.MAX_CODE_POINT)
{
min1 = t2[n2].max + 1;
}
else
{
min1 = Character.MAX_CODE_POINT;
max1 = Character.MIN_CODE_POINT;
}
StatePair q = new StatePair(t1[n1].to, t2[n2].to);
if (!visited.Contains(q))
{
worklist.AddLast(q);
visited.Add(q);
}
}
if (min1 <= max1)
{
return(false);
}
}
}
return(true);
}
/// <summary>
/// Returns true if the language of <paramref name="a1"/> is a subset of the language
/// of <paramref name="a2"/>. As a side-effect, <paramref name="a2"/> is determinized if
/// not already marked as deterministic.
/// <para/>
/// Complexity: quadratic in number of states.
/// </summary>
public static bool SubsetOf(Automaton a1, Automaton a2)
{
if (a1 == a2)
{
return(true);
}
if (a1.IsSingleton)
{
if (a2.IsSingleton)
{
return(a1.singleton.Equals(a2.singleton, StringComparison.Ordinal));
}
return(BasicOperations.Run(a2, a1.singleton));
}
a2.Determinize();
Transition[][] transitions1 = a1.GetSortedTransitions();
Transition[][] transitions2 = a2.GetSortedTransitions();
Queue <StatePair> worklist = new Queue <StatePair>(); // LUCENENET specific - Queue is much more performant than LinkedList
JCG.HashSet <StatePair> visited = new JCG.HashSet <StatePair>();
StatePair p = new StatePair(a1.initial, a2.initial);
worklist.Enqueue(p);
visited.Add(p);
while (worklist.Count > 0)
{
p = worklist.Dequeue();
if (p.s1.accept && !p.s2.accept)
{
return(false);
}
Transition[] t1 = transitions1[p.s1.number];
Transition[] t2 = transitions2[p.s2.number];
for (int n1 = 0, b2 = 0; n1 < t1.Length; n1++)
{
while (b2 < t2.Length && t2[b2].max < t1[n1].min)
{
b2++;
}
int min1 = t1[n1].min, max1 = t1[n1].max;
for (int n2 = b2; n2 < t2.Length && t1[n1].max >= t2[n2].min; n2++)
{
if (t2[n2].min > min1)
{
return(false);
}
if (t2[n2].max < Character.MaxCodePoint)
{
min1 = t2[n2].max + 1;
}
else
{
min1 = Character.MaxCodePoint;
max1 = Character.MinCodePoint;
}
StatePair q = new StatePair(t1[n1].to, t2[n2].to);
if (!visited.Contains(q))
{
worklist.Enqueue(q);
visited.Add(q);
}
}
if (min1 <= max1)
{
return(false);
}
}
}
return(true);
}