public static void MinimizeHopcroft(Automaton a)
{
a.Determinize();
var tr = a.Initial.Transitions;
if (tr.Count == 1)
{
var t = tr[0];
if (t.To == a.Initial && t.Min == char.MinValue && t.Max == char.MaxValue)
{
return;
}
}
a.Totalize();
var ss = a.GetStates();
var states = new State[ss.Count];
var number = 0;
foreach (var q in ss)
{
states[number] = q;
q.Number = number++;
}
var sigma = a.GetStartPoints();
var v = Enumerable.Repeat <LinkedList <State> >(default, sigma.Length);
public static Automaton Complement(Automaton a)
{
a = a.CloneExpandedIfRequired();
a.Determinize();
a.Totalize();
foreach (var p in a.GetStates())
{
p.Accept = !p.Accept;
}
a.RemoveDeadTransitions();
return(a);
}
public static bool Run(Automaton a, string s)
{
if (a.IsSingleton)
{
return(s.Equals(a.Singleton));
}
if (a.IsDeterministic)
{
var p = a.Initial;
foreach (var t in s)
{
var q = p.Step(t);
if (q == null)
{
return(false);
}
p = q;
}
return(p.Accept);
}
var 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>();
var accept = a.Initial.Accept;
foreach (var c in s)
{
accept = false;
ppOther.Clear();
bbOther.SetAll(false);
foreach (var p in pp)
{
dest.Clear();
p.Step(c, dest);
foreach (var q in dest)
{
if (q.Accept)
{
accept = true;
}
if (!bbOther.Get(q.Number))
{
bbOther.Set(q.Number, true);
_ = ppOther.AddLast(q);
}
}
}
var tp = pp;
pp = ppOther;
ppOther = tp;
var tb = bb;
bb = bbOther;
bbOther = tb;
}
return(accept);
}
public static Automaton Intersection(Automaton a1, Automaton a2)
{
if (a1.IsSingleton)
{
return(a2.Run(a1.Singleton) ? a1.CloneIfRequired() : BasicAutomata.MakeEmpty());
}
if (a2.IsSingleton)
{
return(a1.Run(a2.Singleton) ? a2.CloneIfRequired() : BasicAutomata.MakeEmpty());
}
if (a1 == a2)
{
return(a1.CloneIfRequired());
}
var transitions1 = Automaton.GetSortedTransitions(a1.GetStates());
var 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;
var t1 = transitions1[p.FirstState.Number];
var 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 (var 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);
_ = newstates.TryGetValue(q, out var r);
if (r == null)
{
q.S = new State();
_ = worklist.AddLast(q);
newstates.Add(q, q);
r = q;
}
var min = t1[n1].Min > t2[n2].Min ? t1[n1].Min : t2[n2].Min;
var 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);
}
