/// <summary>
/// Returns a new automaton that accepts strings representing decimal
/// non-negative integers in the given interval.
/// </summary>
/// <param name="min"> minimal value of interval </param>
/// <param name="max"> maximal value of interval (both end points are included in the
/// interval) </param>
/// <param name="digits"> if >0, use fixed number of digits (strings must be prefixed
/// by 0's to obtain the right length) - otherwise, the number of
/// digits is not fixed </param>
/// <exception cref="IllegalArgumentException"> if min>max or if numbers in the
/// interval cannot be expressed with the given fixed number of
/// digits </exception>
public static Automaton MakeInterval(int min, int max, int digits)
{
Automaton a = new Automaton();
string x = Convert.ToString(min);
string y = Convert.ToString(max);
if (min > max || (digits > 0 && y.Length > digits))
{
throw new System.ArgumentException();
}
int d;
if (digits > 0)
{
d = digits;
}
else
{
d = y.Length;
}
StringBuilder bx = new StringBuilder();
for (int i = x.Length; i < d; i++)
{
bx.Append('0');
}
bx.Append(x);
x = bx.ToString();
StringBuilder by = new StringBuilder();
for (int i = y.Length; i < d; i++)
{
by.Append('0');
}
by.Append(y);
y = by.ToString();
ICollection <State> initials = new List <State>();
a.initial = Between(x, y, 0, initials, digits <= 0);
if (digits <= 0)
{
List <StatePair> pairs = new List <StatePair>();
foreach (State p in initials)
{
if (a.initial != p)
{
pairs.Add(new StatePair(a.initial, p));
}
}
BasicOperations.AddEpsilons(a, pairs);
a.initial.AddTransition(new Transition('0', a.initial));
a.deterministic = false;
}
else
{
a.deterministic = true;
}
a.CheckMinimizeAlways();
return(a);
}
/// <summary>
/// Returns an automaton that accepts the union of the languages of the given
/// automata.
/// <para/>
/// Complexity: linear in number of states.
/// </summary>
public static Automaton Union(Automaton a1, Automaton a2)
{
if ((a1.IsSingleton && a2.IsSingleton && a1.singleton.Equals(a2.singleton, StringComparison.Ordinal)) || a1 == a2)
{
return(a1.CloneIfRequired());
}
if (a1 == a2)
{
a1 = a1.CloneExpanded();
a2 = a2.CloneExpanded();
}
else
{
a1 = a1.CloneExpandedIfRequired();
a2 = a2.CloneExpandedIfRequired();
}
State s = new State();
s.AddEpsilon(a1.initial);
s.AddEpsilon(a2.initial);
a1.initial = s;
a1.deterministic = false;
//a1.clearHashCode();
a1.ClearNumberedStates();
a1.CheckMinimizeAlways();
return(a1);
}
/// <summary>
/// Returns an automaton that accepts the union of the empty string and the
/// language of the given automaton.
/// <para/>
/// Complexity: linear in number of states.
/// </summary>
public static Automaton Optional(Automaton a)
{
a = a.CloneExpandedIfRequired();
State s = new State();
s.AddEpsilon(a.initial);
s.accept = true;
a.initial = s;
a.deterministic = false;
//a.clearHashCode();
a.ClearNumberedStates();
a.CheckMinimizeAlways();
return(a);
}
/// <summary>
/// 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.
/// <para/>
/// Complexity: linear in number of states.
/// </summary>
public static Automaton Repeat(Automaton a)
{
a = a.CloneExpanded();
State s = new State();
s.accept = true;
s.AddEpsilon(a.initial);
foreach (State p in a.GetAcceptStates())
{
p.AddEpsilon(s);
}
a.initial = s;
a.deterministic = false;
//a.clearHashCode();
a.ClearNumberedStates();
a.CheckMinimizeAlways();
return(a);
}
/// <summary>
/// Returns an automaton that accepts the union of the languages of the given
/// automata.
/// <para/>
/// Complexity: linear in number of states.
/// </summary>
public static Automaton Union(ICollection <Automaton> l)
{
JCG.HashSet <int> ids = new JCG.HashSet <int>();
foreach (Automaton a in l)
{
ids.Add(a.GetHashCode());
}
bool has_aliases = ids.Count != l.Count;
State s = new State();
foreach (Automaton b in l)
{
if (BasicOperations.IsEmpty(b))
{
continue;
}
Automaton bb = b;
if (has_aliases)
{
bb = bb.CloneExpanded();
}
else
{
bb = bb.CloneExpandedIfRequired();
}
s.AddEpsilon(bb.initial);
}
Automaton a_ = new Automaton
{
initial = s,
deterministic = false
};
//a.clearHashCode();
a_.ClearNumberedStates();
a_.CheckMinimizeAlways();
return(a_);
}
/// <summary>
/// Returns an automaton that accepts the concatenation of the languages of the
/// given automata.
/// <para/>
/// Complexity: linear in number of states.
/// </summary>
public static Automaton Concatenate(Automaton a1, Automaton a2)
{
if (a1.IsSingleton && a2.IsSingleton)
{
return(BasicAutomata.MakeString(a1.singleton + a2.singleton));
}
if (IsEmpty(a1) || IsEmpty(a2))
{
return(BasicAutomata.MakeEmpty());
}
// adding epsilon transitions with the NFA concatenation algorithm
// in this case always produces a resulting DFA, preventing expensive
// redundant determinize() calls for this common case.
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.deterministic = deterministic;
//a1.clearHashCode();
a1.ClearNumberedStates();
a1.CheckMinimizeAlways();
return(a1);
}
/// <summary>
/// Returns an automaton that accepts the concatenation of the languages of the
/// given automata.
/// <para/>
/// Complexity: linear in total number of states.
/// </summary>
public static Automaton Concatenate(IList <Automaton> l)
{
if (l.Count == 0)
{
return(BasicAutomata.MakeEmptyString());
}
bool all_singleton = true;
foreach (Automaton a in l)
{
if (!a.IsSingleton)
{
all_singleton = false;
break;
}
}
if (all_singleton)
{
StringBuilder b = new StringBuilder();
foreach (Automaton a in l)
{
b.Append(a.singleton);
}
return(BasicAutomata.MakeString(b.ToString()));
}
else
{
foreach (Automaton a in l)
{
if (BasicOperations.IsEmpty(a))
{
return(BasicAutomata.MakeEmpty());
}
}
HashSet <int> ids = new HashSet <int>();
foreach (Automaton a in l)
{
ids.Add(a.GetHashCode());
}
bool has_aliases = ids.Count != l.Count;
Automaton b = l[0];
if (has_aliases)
{
b = b.CloneExpanded();
}
else
{
b = b.CloneExpandedIfRequired();
}
ISet <State> ac = b.GetAcceptStates();
bool first = true;
foreach (Automaton a in l)
{
if (first)
{
first = false;
}
else
{
if (a.IsEmptyString)
{
continue;
}
Automaton aa = a;
if (has_aliases)
{
aa = aa.CloneExpanded();
}
else
{
aa = aa.CloneExpandedIfRequired();
}
ISet <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.deterministic = false;
//b.clearHashCode();
b.ClearNumberedStates();
b.CheckMinimizeAlways();
return(b);
}
}
/// <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"> Automaton. </param>
/// <param name="pairs"> Collection of <see cref="StatePair"/> objects representing pairs of
/// source/destination states where epsilon transitions should be
/// added. </param>
public static void AddEpsilons(Automaton a, ICollection <StatePair> pairs)
{
a.ExpandSingleton();
Dictionary <State, HashSet <State> > forward = new Dictionary <State, HashSet <State> >();
Dictionary <State, HashSet <State> > back = new Dictionary <State, HashSet <State> >();
foreach (StatePair p in pairs)
{
HashSet <State> to;
if (!forward.TryGetValue(p.S1, out to))
{
to = new HashSet <State>();
forward[p.S1] = to;
}
to.Add(p.S2);
HashSet <State> from;
if (!back.TryGetValue(p.S2, out from))
{
from = new HashSet <State>();
back[p.S2] = from;
}
from.Add(p.S1);
}
// calculate epsilon closure
LinkedList <StatePair> worklist = new LinkedList <StatePair>(pairs);
HashSet <StatePair> workset = new HashSet <StatePair>(pairs);
while (worklist.Count > 0)
{
StatePair p = worklist.First.Value;
worklist.Remove(p);
workset.Remove(p);
HashSet <State> to;
HashSet <State> from;
if (forward.TryGetValue(p.S2, out to))
{
foreach (State s in to)
{
StatePair pp = new StatePair(p.S1, s);
if (!pairs.Contains(pp))
{
pairs.Add(pp);
forward[p.S1].Add(s);
back[s].Add(p.S1);
worklist.AddLast(pp);
workset.Add(pp);
if (back.TryGetValue(p.S1, out from))
{
foreach (State q in from)
{
StatePair qq = new StatePair(q, p.S1);
if (!workset.Contains(qq))
{
worklist.AddLast(qq);
workset.Add(qq);
}
}
}
}
}
}
}
// add transitions
foreach (StatePair p in pairs)
{
p.S1.AddEpsilon(p.S2);
}
a.deterministic = false;
//a.clearHashCode();
a.ClearNumberedStates();
a.CheckMinimizeAlways();
}
/// <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 a new automaton that accepts strings representing decimal
/// non-negative integers in the given interval.
/// </summary>
/// <param name="min"> minimal value of interval </param>
/// <param name="max"> maximal value of interval (both end points are included in the
/// interval) </param>
/// <param name="digits"> if >0, use fixed number of digits (strings must be prefixed
/// by 0's to obtain the right length) - otherwise, the number of
/// digits is not fixed </param>
/// <exception cref="IllegalArgumentException"> if min>max or if numbers in the
/// interval cannot be expressed with the given fixed number of
/// digits </exception>
public static Automaton MakeInterval(int min, int max, int digits)
{
Automaton a = new Automaton();
string x = Convert.ToString(min);
string y = Convert.ToString(max);
if (min > max || (digits > 0 && y.Length > digits))
{
throw new System.ArgumentException();
}
int d;
if (digits > 0)
{
d = digits;
}
else
{
d = y.Length;
}
StringBuilder bx = new StringBuilder();
for (int i = x.Length; i < d; i++)
{
bx.Append('0');
}
bx.Append(x);
x = bx.ToString();
StringBuilder by = new StringBuilder();
for (int i = y.Length; i < d; i++)
{
by.Append('0');
}
by.Append(y);
y = by.ToString();
ICollection<State> initials = new List<State>();
a.Initial = Between(x, y, 0, initials, digits <= 0);
if (digits <= 0)
{
List<StatePair> pairs = new List<StatePair>();
foreach (State p in initials)
{
if (a.Initial != p)
{
pairs.Add(new StatePair(a.Initial, p));
}
}
BasicOperations.AddEpsilons(a, pairs);
a.Initial.AddTransition(new Transition('0', a.Initial));
a.deterministic = false;
}
else
{
a.deterministic = true;
}
a.CheckMinimizeAlways();
return a;
}