/// <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
{
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>
/// Converts an incoming utf32 automaton to an equivalent
/// utf8 one. The incoming automaton need not be
/// deterministic. Note that the returned automaton will
/// not in general be deterministic, so you must
/// determinize it if that's needed.
/// </summary>
public Automaton Convert(Automaton utf32)
{
if (utf32.IsSingleton)
{
utf32 = utf32.CloneExpanded();
}
State[] map = new State[utf32.NumberedStates.Length];
List<State> pending = new List<State>();
State utf32State = utf32.InitialState;
pending.Add(utf32State);
Automaton utf8 = new Automaton();
utf8.Deterministic = false;
State utf8State = utf8.InitialState;
Utf8States = new State[5];
Utf8StateCount = 0;
utf8State.number = Utf8StateCount;
Utf8States[Utf8StateCount] = utf8State;
Utf8StateCount++;
utf8State.Accept = utf32State.Accept;
map[utf32State.number] = utf8State;
while (pending.Count != 0)
{
utf32State = pending[pending.Count - 1];
pending.RemoveAt(pending.Count - 1);
utf8State = map[utf32State.number];
for (int i = 0; i < utf32State.numTransitions; i++)
{
Transition t = utf32State.TransitionsArray[i];
State destUTF32 = t.To;
State destUTF8 = map[destUTF32.number];
if (destUTF8 == null)
{
destUTF8 = NewUTF8State();
destUTF8.accept = destUTF32.accept;
map[destUTF32.number] = destUTF8;
pending.Add(destUTF32);
}
ConvertOneEdge(utf8State, destUTF8, t.Min_Renamed, t.Max_Renamed);
}
}
utf8.SetNumberedStates(Utf8States, Utf8StateCount);
return utf8;
}