static OrderedSet <Graph.State> MoveR(OrderedSet <Graph.State> initialStates, CharSet c)
{
var reachable = new Dictionary <Graph.State, bool>();
foreach (var state in initialStates)
{
foreach (var transition in state.FromTransitions)
{
if (transition.Label == null)
{
continue;
}
if (!transition.Label.Intersects(c))
{
continue;
}
reachable[transition.FromState] = true;
}
}
var result = new Graph.State[reachable.Count];
reachable.Keys.CopyTo(result, 0);
return(OrderedSet <Graph.State> .New(result));
}
public void CopyTo()
{
var set = OrderedSet <int> .New(new int[] { 3, 4, 1 });
var target = new int[5];
set.CopyTo(target, 1);
Assert.That(target, Is.EquivalentTo(new int[] { 0, 1, 3, 4, 0 }));
}
public void Subtract()
{
var a = OrderedSet <int> .New(new int[] { 1, 2 });
var b = OrderedSet <int> .New(new int[] { 2, 3 });
var x = a.Subtract(b);
Assert.That(x.ContainsValue(1), Is.EqualTo(true), "1");
Assert.That(x.ContainsValue(2), Is.EqualTo(false), "2");
Assert.That(x.ContainsValue(3), Is.EqualTo(false), "3");
Assert.That(x.ContainsValue(4), Is.EqualTo(false), "4");
}
public void IsOverlapping()
{
var set1 = OrderedSet <int> .New(new int[] { 1 });
var set2 = OrderedSet <int> .New(new int[] { 1, 2 });
var set3 = OrderedSet <int> .New(new int[] { 2, 3, 4 });
Assert.That(set1.Intersects(set2), Is.EqualTo(true));
Assert.That(set1.Intersects(set3), Is.EqualTo(false));
Assert.That(set2.Intersects(set1), Is.EqualTo(true));
Assert.That(set2.Intersects(set3), Is.EqualTo(true));
Assert.That(set3.Intersects(set1), Is.EqualTo(false));
Assert.That(set3.Intersects(set2), Is.EqualTo(true));
}
public void Length()
{
var set1 = OrderedSet <int> .New(System.Array.Empty <int>());
Assert.That(set1.Length, Is.EqualTo(0));
Assert.That(((ICollection)set1).Count, Is.EqualTo(0));
var set2 = OrderedSet <int> .New(new int[] { 1 });
Assert.That(set2.Length, Is.EqualTo(1));
Assert.That(((ICollection)set2).Count, Is.EqualTo(1));
var set3 = OrderedSet <int> .New(new int[] { 1, 2, 2, 4 });
Assert.That(set3.Length, Is.EqualTo(3));
Assert.That(((ICollection)set3).Count, Is.EqualTo(3));
}
public void IsSuperSetOf()
{
var set1 = OrderedSet <int> .New(new int[] { 1 });
var set2 = OrderedSet <int> .New(new int[] { 1, 2 });
var set3 = OrderedSet <int> .New(new int[] { 2, 3, 4 });
Assert.That(set1.IsSupersetOf(set2), Is.EqualTo(false));
Assert.That(set1.IsSupersetOf(set3), Is.EqualTo(false));
Assert.That(set2.IsSupersetOf(set1), Is.EqualTo(true));
Assert.That(set2.IsSupersetOf(set3), Is.EqualTo(false));
Assert.That(set3.IsSupersetOf(set1), Is.EqualTo(false));
Assert.That(set3.IsSupersetOf(set2), Is.EqualTo(false));
}
public void New()
{
var set1 = OrderedSet <int> .New(new int[] { 1, 2, 2 });
var set2 = OrderedSet <int> .New(new int[] { 2, 1 });
var set3 = OrderedSet <int> .New(new int[] { 2, 2 });
Assert.That(set1.Equals(set2), Is.EqualTo(true));
Assert.That(set2.Equals(set1), Is.EqualTo(true));
Assert.That(set1.Equals(set3), Is.EqualTo(false));
Assert.That(set3.Equals(set1), Is.EqualTo(false));
Assert.That(set2.Equals(set3), Is.EqualTo(false));
Assert.That(set3.Equals(set2), Is.EqualTo(false));
}
static OrderedSet <Graph.State> EpsilonClosure(OrderedSet <Graph.State> initialStates)
{
var reached = new Dictionary <Graph.State, bool>();
var statesToExamine = new Queue <Graph.State>();
foreach (var state in initialStates)
{
statesToExamine.Enqueue(state);
reached.Add(state, true);
}
while (statesToExamine.Count > 0)
{
var state = statesToExamine.Dequeue();
foreach (var transition in state.ToTransitions)
{
if (transition.Label != null)
{
continue;
}
if (reached.ContainsKey(transition.ToState))
{
continue;
}
reached.Add(transition.ToState, true);
statesToExamine.Enqueue(transition.ToState);
}
}
var result = new Graph.State[reached.Count];
reached.Keys.CopyTo(result, 0);
return(OrderedSet <Graph.State> .New(result));
}
static List <KeyValuePair <int, OrderedSet <Graph.State> > > GetStartStateSets(Graph graph)
{
var states = new List <Graph.State>(graph.States.Count);
foreach (var state in graph.States)
{
if (state.Label.StartState.HasValue)
{
states.Add(state);
}
}
var result = new List <KeyValuePair <int, OrderedSet <Graph.State> > >();
if (states.Count > 0)
{
states.Sort((s1, s2) => s1.Label.StartState.Value - s2.Label.StartState.Value);
var currentLabel = states[0].Label.StartState.Value;
var currentStates = new List <Graph.State>();
foreach (var state in states)
{
if (state.Label.StartState != currentLabel)
{
result.Add(new KeyValuePair <int, OrderedSet <Graph.State> >(currentLabel, OrderedSet <Graph.State> .New(currentStates)));
currentStates.Clear();
currentLabel = state.Label.StartState.Value;
}
currentStates.Add(state);
}
result.Add(new KeyValuePair <int, OrderedSet <Graph.State> >(currentLabel, OrderedSet <Graph.State> .New(currentStates)));
}
return(result);
}
