/// <summary>
/// Returns an automaton that accepts the union of the languages of the given automata.
/// </summary>
/// <param name="automatons">The l.</param>
/// <returns>
/// An automaton that accepts the union of the languages of the given automata.
/// </returns>
/// <remarks>
/// Complexity: linear in number of states.
/// </remarks>
internal static Automaton Union(IList <Automaton> automatons)
{
var ids = new HashSet <int>();
foreach (Automaton a in automatons)
{
ids.Add(RuntimeHelpers.GetHashCode(a));
}
bool hasAliases = ids.Count != automatons.Count;
var s = new State();
foreach (Automaton b in automatons)
{
if (b.IsEmpty)
{
continue;
}
Automaton bb = b;
bb = hasAliases ? bb.CloneExpanded() : bb.CloneExpandedIfRequired();
s.AddEpsilon(bb.Initial);
}
var automaton = new Automaton();
automaton.Initial = s;
automaton.IsDeterministic = false;
automaton.ClearHashCode();
automaton.CheckMinimizeAlways();
return(automaton);
}
/// <summary>
/// Returns an automaton that accepts the union of the empty string and the language of the
/// given automaton.
/// </summary>
/// <param name="a">The automaton.</param>
/// <remarks>
/// Complexity: linear in number of states.
/// </remarks>
/// <returns>An automaton that accepts the union of the empty string and the language of the
/// given automaton.</returns>
internal static Automaton Optional(Automaton a)
{
a = a.CloneExpandedIfRequired();
var s = new State();
s.AddEpsilon(a.Initial);
s.Accept = true;
a.Initial = s;
a.IsDeterministic = false;
a.ClearHashCode();
a.CheckMinimizeAlways();
return(a);
}
/// <summary>
/// Accepts the Kleene star (zero or more concatenated repetitions) of the language of the
/// given automaton. Never modifies the input automaton language.
/// </summary>
/// <param name="a">The automaton.</param>
/// <returns>
/// An automaton that accepts the Kleene star (zero or more concatenated repetitions)
/// of the language of the given automaton. Never modifies the input automaton language.
/// </returns>
/// <remarks>
/// Complexity: linear in number of states.
/// </remarks>
internal static Automaton Repeat(Automaton a)
{
a = a.CloneExpanded();
var s = new State();
s.Accept = true;
s.AddEpsilon(a.Initial);
foreach (State p in a.GetAcceptStates())
{
p.AddEpsilon(s);
}
a.Initial = s;
a.IsDeterministic = false;
a.ClearHashCode();
a.CheckMinimizeAlways();
return(a);
}
internal static Automaton Concatenate(Automaton a1, Automaton a2)
{
if (a1.IsSingleton && a2.IsSingleton)
{
return(BasicAutomata.MakeString(a1.Singleton + a2.Singleton));
}
if (BasicOperations.IsEmpty(a1) || BasicOperations.IsEmpty(a2))
{
return(BasicAutomata.MakeEmpty());
}
bool deterministic = a1.IsSingleton && a2.IsDeterministic;
if (a1 == a2)
{
a1 = a1.CloneExpanded();
a2 = a2.CloneExpanded();
}
else
{
a1 = a1.CloneExpandedIfRequired();
a2 = a2.CloneExpandedIfRequired();
}
foreach (State s in a1.GetAcceptStates())
{
s.Accept = false;
s.AddEpsilon(a2.Initial);
}
a1.IsDeterministic = deterministic;
a1.ClearHashCode();
a1.CheckMinimizeAlways();
return(a1);
}
/// <summary>
/// Adds epsilon transitions to the given automaton. This method adds extra character interval
/// transitions that are equivalent to the given set of epsilon transitions.
/// </summary>
/// <param name="a">The automaton.</param>
/// <param name="pairs">A collection of <see cref="StatePair"/> objects representing pairs of
/// source/destination states where epsilon transitions should be added.</param>
internal static void AddEpsilons(Automaton a, ICollection <StatePair> pairs)
{
a.ExpandSingleton();
var forward = new Dictionary <State, HashSet <State> >();
var back = new Dictionary <State, HashSet <State> >();
foreach (StatePair p in pairs)
{
HashSet <State> to = forward[p.FirstState];
if (to == null)
{
to = new HashSet <State>();
forward.Add(p.FirstState, to);
}
to.Add(p.SecondState);
HashSet <State> from = back[p.SecondState];
if (from == null)
{
from = new HashSet <State>();
back.Add(p.SecondState, from);
}
from.Add(p.FirstState);
}
var worklist = new LinkedList <StatePair>(pairs);
var workset = new HashSet <StatePair>(pairs);
while (worklist.Count != 0)
{
StatePair p = worklist.RemoveAndReturnFirst();
workset.Remove(p);
HashSet <State> to = forward[p.SecondState];
HashSet <State> from = back[p.FirstState];
if (to != null)
{
foreach (State s in to)
{
var pp = new StatePair(p.FirstState, s);
if (!pairs.Contains(pp))
{
pairs.Add(pp);
forward[p.FirstState].Add(s);
back[s].Add(p.FirstState);
worklist.AddLast(pp);
workset.Add(pp);
if (from != null)
{
foreach (State q in from)
{
var qq = new StatePair(q, p.FirstState);
if (!workset.Contains(qq))
{
worklist.AddLast(qq);
workset.Add(qq);
}
}
}
}
}
}
}
// Add transitions.
foreach (StatePair p in pairs)
{
p.FirstState.AddEpsilon(p.SecondState);
}
a.IsDeterministic = false;
a.ClearHashCode();
a.CheckMinimizeAlways();
}
internal static Automaton Concatenate(IList <Automaton> l)
{
if (l.Count == 0)
{
return(BasicAutomata.MakeEmptyString());
}
bool allSingleton = l.All(a => a.IsSingleton);
if (allSingleton)
{
var b = new StringBuilder();
foreach (Automaton a in l)
{
b.Append(a.Singleton);
}
return(BasicAutomata.MakeString(b.ToString()));
}
else
{
if (l.Any(a => a.IsEmpty))
{
return(BasicAutomata.MakeEmpty());
}
var ids = new HashSet <int>();
foreach (Automaton a in l)
{
ids.Add(RuntimeHelpers.GetHashCode(a));
}
bool hasAliases = ids.Count != l.Count;
Automaton b = l[0];
b = hasAliases ? b.CloneExpanded() : b.CloneExpandedIfRequired();
var ac = b.GetAcceptStates();
bool first = true;
foreach (Automaton a in l)
{
if (first)
{
first = false;
}
else
{
if (a.IsEmptyString())
{
continue;
}
Automaton aa = a;
aa = hasAliases ? aa.CloneExpanded() : aa.CloneExpandedIfRequired();
HashSet <State> ns = aa.GetAcceptStates();
foreach (State s in ac)
{
s.Accept = false;
s.AddEpsilon(aa.Initial);
if (s.Accept)
{
ns.Add(s);
}
}
ac = ns;
}
}
b.IsDeterministic = false;
b.ClearHashCode();
b.CheckMinimizeAlways();
return(b);
}
}
/// <summary>
/// Accepts the Kleene star (zero or more concatenated repetitions) of the language of the
/// given automaton. Never modifies the input automaton language.
/// </summary>
/// <param name="a">The automaton.</param>
/// <returns>
/// An automaton that accepts the Kleene star (zero or more concatenated repetitions)
/// of the language of the given automaton. Never modifies the input automaton language.
/// </returns>
/// <remarks>
/// Complexity: linear in number of states.
/// </remarks>
internal static Automaton Repeat(Automaton a)
{
a = a.CloneExpanded();
var s = new State();
s.Accept = true;
s.AddEpsilon(a.Initial);
foreach (State p in a.GetAcceptStates())
{
p.AddEpsilon(s);
}
a.Initial = s;
a.IsDeterministic = false;
a.ClearHashCode();
a.CheckMinimizeAlways();
return a;
}
/// <summary>
/// Returns an automaton that accepts the union of the empty string and the language of the
/// given automaton.
/// </summary>
/// <param name="a">The automaton.</param>
/// <remarks>
/// Complexity: linear in number of states.
/// </remarks>
/// <returns>An automaton that accepts the union of the empty string and the language of the
/// given automaton.</returns>
internal static Automaton Optional(Automaton a)
{
a = a.CloneExpandedIfRequired();
var s = new State();
s.AddEpsilon(a.Initial);
s.Accept = true;
a.Initial = s;
a.IsDeterministic = false;
a.ClearHashCode();
a.CheckMinimizeAlways();
return a;
}
/// <summary>
/// Adds epsilon transitions to the given automaton. This method adds extra character interval
/// transitions that are equivalent to the given set of epsilon transitions.
/// </summary>
/// <param name="a">The automaton.</param>
/// <param name="pairs">A collection of <see cref="StatePair"/> objects representing pairs of
/// source/destination states where epsilon transitions should be added.</param>
internal static void AddEpsilons(Automaton a, ICollection<StatePair> pairs)
{
a.ExpandSingleton();
var forward = new Dictionary<State, HashSet<State>>();
var back = new Dictionary<State, HashSet<State>>();
foreach (StatePair p in pairs)
{
HashSet<State> to = forward[p.FirstState];
if (to == null)
{
to = new HashSet<State>();
forward.Add(p.FirstState, to);
}
to.Add(p.SecondState);
HashSet<State> from = back[p.SecondState];
if (from == null)
{
from = new HashSet<State>();
back.Add(p.SecondState, from);
}
from.Add(p.FirstState);
}
var worklist = new LinkedList<StatePair>(pairs);
var workset = new HashSet<StatePair>(pairs);
while (worklist.Count != 0)
{
StatePair p = worklist.RemoveAndReturnFirst();
workset.Remove(p);
HashSet<State> to = forward[p.SecondState];
HashSet<State> from = back[p.FirstState];
if (to != null)
{
foreach (State s in to)
{
var pp = new StatePair(p.FirstState, s);
if (!pairs.Contains(pp))
{
pairs.Add(pp);
forward[p.FirstState].Add(s);
back[s].Add(p.FirstState);
worklist.AddLast(pp);
workset.Add(pp);
if (from != null)
{
foreach (State q in from)
{
var qq = new StatePair(q, p.FirstState);
if (!workset.Contains(qq))
{
worklist.AddLast(qq);
workset.Add(qq);
}
}
}
}
}
}
}
// Add transitions.
foreach (StatePair p in pairs)
{
p.FirstState.AddEpsilon(p.SecondState);
}
a.IsDeterministic = false;
a.ClearHashCode();
a.CheckMinimizeAlways();
}
internal static Automaton Concatenate(Automaton a1, Automaton a2)
{
if (a1.IsSingleton && a2.IsSingleton)
{
return BasicAutomata.MakeString(a1.Singleton + a2.Singleton);
}
if (BasicOperations.IsEmpty(a1) || BasicOperations.IsEmpty(a2))
{
return BasicAutomata.MakeEmpty();
}
bool deterministic = a1.IsSingleton && a2.IsDeterministic;
if (a1 == a2)
{
a1 = a1.CloneExpanded();
a2 = a2.CloneExpanded();
}
else
{
a1 = a1.CloneExpandedIfRequired();
a2 = a2.CloneExpandedIfRequired();
}
foreach (State s in a1.GetAcceptStates())
{
s.Accept = false;
s.AddEpsilon(a2.Initial);
}
a1.IsDeterministic = deterministic;
a1.ClearHashCode();
a1.CheckMinimizeAlways();
return a1;
}
/// <summary>
/// Returns an automaton that accepts the union of the languages of the given automata.
/// </summary>
/// <param name="automatons">The l.</param>
/// <returns>
/// An automaton that accepts the union of the languages of the given automata.
/// </returns>
/// <remarks>
/// Complexity: linear in number of states.
/// </remarks>
internal static Automaton Union(IList<Automaton> automatons)
{
var ids = new HashSet<int>();
foreach (Automaton a in automatons)
{
ids.Add(RuntimeHelpers.GetHashCode(a));
}
bool hasAliases = ids.Count != automatons.Count;
var s = new State();
foreach (Automaton b in automatons)
{
if (b.IsEmpty)
{
continue;
}
Automaton bb = b;
bb = hasAliases ? bb.CloneExpanded() : bb.CloneExpandedIfRequired();
s.AddEpsilon(bb.Initial);
}
var automaton = new Automaton();
automaton.Initial = s;
automaton.IsDeterministic = false;
automaton.ClearHashCode();
automaton.CheckMinimizeAlways();
return automaton;
}