public void Measure(IEdgeEnumerable edges)
{
Clear();
// count the number of passages
int count = 0;
foreach (IEdge e in edges)
{
if (this.passCounts[e] == 0)
{
++count;
}
this.passCounts[e]++;
}
// compute covergage
if (this.graph.EdgesEmpty)
{
this.coverage = 0;
}
else
{
this.coverage = count / (double)this.graph.EdgesCount;
}
}
/// <summary>
/// Adds the elements of another EdgeCollection to the end of this EdgeCollection.
/// </summary>
/// <param name="items">
/// The EdgeCollection whose elements are to be added to the end of this EdgeCollection.
/// </param>
public void AddRange(IEdgeEnumerable items)
{
foreach (IEdge item in items)
{
this.List.Add(item);
}
}
public void Measure(IEdgeEnumerable edges)
{
this.Clear();
int num = 0;
IEdgeEnumerator enumerator = edges.GetEnumerator();
while (enumerator.MoveNext())
{
EdgeIntDictionary dictionary;
IEdge edge2;
IEdge edge = enumerator.get_Current();
if (this.passCounts.get_Item(edge) == 0)
{
num++;
}
(dictionary = this.passCounts).set_Item(edge2 = edge, dictionary.get_Item(edge2) + 1);
}
if (this.graph.get_EdgesEmpty())
{
this.coverage = 0.0;
}
else
{
this.coverage = ((double) num) / ((double) this.graph.get_EdgesCount());
}
}
public void MeasurePath(IEdgeEnumerable edges)
{
Clear();
// count the number of passages
int count = 0;
bool isFirst = true;
foreach (IEdge e in edges)
{
if (isFirst)
{
this.passCounts[e.Source]++;
isFirst = false;
}
if (this.passCounts[e.Target] == 0)
{
++count;
}
this.passCounts[e.Target]++;
}
// compute covergage
if (this.graph.VerticesEmpty)
{
this.coverage = 0;
}
else
{
this.coverage = count / (double)this.graph.VerticesCount;
}
}
private void VisitEdges(IEdgeEnumerable outEdges, bool forward)
{
IVertex target = null;
foreach (IEdge e in outEdges)
{
OnExamineEdge(e);
if (forward)
{
target = e.Target;
}
else
{
target = e.Source;
}
GraphColor vc = Colors[target];
GraphColor ec = EdgeColors[e];
EdgeColors[e] = GraphColor.Black;
if (vc == GraphColor.White) // tree edge
{
OnTreeEdge(e);
Visit(target);
}
else if (vc == GraphColor.Gray && ec == GraphColor.White)
{
OnBackEdge(e);
}
}
}
internal IEdge NextState(int edgeCount, IEdgeEnumerable edges)
{
if (edgeCount == 0)
{
return null;
}
double num = this.rnd.NextDouble();
int num2 = (int) Math.Floor(edgeCount * num);
if (num2 == edgeCount)
{
num2--;
}
int num3 = 0;
IEdgeEnumerator enumerator = edges.GetEnumerator();
while (enumerator.MoveNext())
{
IEdge edge = enumerator.get_Current();
if (num3 == num2)
{
return edge;
}
num3++;
}
throw new InvalidOperationException("This is a bug");
}
/// <summary>
///
/// </summary>
/// <param name="edges"></param>
/// <param name="count"></param>
/// <param name="rnd"></param>
/// <returns></returns>
public static IEdge Edge(IEdgeEnumerable edges, int count, Random rnd)
{
if (edges == null)
{
throw new ArgumentNullException("edges");
}
if (rnd == null)
{
throw new ArgumentNullException("random generator");
}
if (count == 0)
{
throw new ArgumentException("edges is empty");
}
int i = rnd.Next(count);
foreach (IEdge e in edges)
{
if (i == 0)
{
return(e);
}
else
{
--i;
}
}
// failed
throw new ArgumentOutOfRangeException("count");
}
internal IEdge NextState(
int edgeCount,
IEdgeEnumerable edges
)
{
if (edgeCount == 0)
{
return(null);
}
double r = this.rnd.NextDouble();
int nr = (int)Math.Floor(edgeCount * r);
if (nr == edgeCount)
{
--nr;
}
int i = 0;
foreach (IEdge e in edges)
{
if (i == nr)
{
return(e);
}
++i;
}
throw new InvalidOperationException("This is a bug");
}
/// <summary>
/// Returns the first vertex of the enumerable
/// </summary>
/// <param name="edges">enumerable collection of <see cref="IEdge"/></param>
/// <returns>first target vertex if any, otherwise a null reference</returns>
public static IVertex FirstTargetVertex(IEdgeEnumerable edges)
{
IEdge e = FirstEdge(edges);
if (e!=null)
return e.Target;
else
return null;
}
/// <summary>
/// Returns the first source vertex of the enumerable
/// </summary>
/// <param name="edges">enumerable collection of <see cref="IEdge"/></param>
/// <returns>first source vertex if any, otherwise a null reference</returns>
public static IVertex FirstSourceVertex(IEdgeEnumerable edges)
{
IEdge e = FirstEdge(edges);
if (e!=null)
return e.Source;
else
return null;
}
public TargetVertexEnumerator(IEdgeEnumerable edges)
{
if (edges == null)
{
throw new ArgumentNullException("edges");
}
this.enumerator = edges.GetEnumerator();
}
/// <summary>
/// Filtered edge collection
/// </summary>
/// <param name="ec">base collection</param>
/// <param name="ep">filtering predicate</param>
public FilteredEdgeEnumerable(IEdgeEnumerable ec, IEdgePredicate ep)
{
if (ec == null)
throw new ArgumentNullException("edge collection");
if (ep == null)
throw new ArgumentNullException("edge predicate");
m_EdgeCollection = ec;
m_EdgePredicate = ep;
}
/// <summary>
/// Returns the first edge of the graph
/// </summary>
/// <param name="edges">graph</param>
/// <returns>first edge if any, otherwise a null reference</returns>
public static IEdge FirstEdge(IEdgeEnumerable edges)
{
if (edges==null)
throw new ArgumentNullException("edges");
IEdgeEnumerator en = edges.GetEnumerator();
if (!en.MoveNext())
return null;
else
return en.Current;
}
/// <summary>
/// Returns the last source vertex of the enumerable
/// </summary>
/// <param name="edges">enumerable collection of <see cref="IEdge"/></param>
/// <returns>last source vertex if any, otherwise a null reference</returns>
public static IVertex LastSourceVertex(IEdgeEnumerable edges)
{
IEdge e = LastEdge(edges);
if (e != null)
{
return(e.Source);
}
else
{
return(null);
}
}
/// <summary>
/// Returns the last vertex of the enumerable
/// </summary>
/// <param name="edges">enumerable collection of <see cref="IEdge"/></param>
/// <returns>last target vertex if any, otherwise a null reference</returns>
public static IVertex LastTargetVertex(IEdgeEnumerable edges)
{
IEdge e = LastEdge(edges);
if (e != null)
{
return(e.Target);
}
else
{
return(null);
}
}
private IEdge SelectSingleOutEdgeNotInCircuit(IVertex v)
{
IEdgeEnumerable en = this.SelectOutEdgesNotInCircuit(v);
IEdgeEnumerator eor = en.GetEnumerator();
if (!eor.MoveNext())
{
return(null);
}
else
{
return(eor.Current);
}
}
/// <summary>
/// Filtered edge collection
/// </summary>
/// <param name="ec">base collection</param>
/// <param name="ep">filtering predicate</param>
public FilteredEdgeEnumerable(IEdgeEnumerable ec, IEdgePredicate ep)
{
if (ec == null)
{
throw new ArgumentNullException("edge collection");
}
if (ep == null)
{
throw new ArgumentNullException("edge predicate");
}
m_EdgeCollection = ec;
m_EdgePredicate = ep;
}
/// <summary>
/// Returns the last edge of the edge collection
/// </summary>
/// <param name="edges">edge collection</param>
/// <returns>last edge if any, otherwise a null reference</returns>
public static IEdge LastEdge(IEdgeEnumerable edges)
{
if (edges == null)
{
throw new ArgumentNullException("edges");
}
IEdgeEnumerator en = edges.GetEnumerator();
IEdge current = null;
while (en.MoveNext())
{
current = en.Current;
}
return(current);
}
/// <summary>
/// Visits vertex s
/// </summary>
/// <param name="u">vertex to visit</param>
public void Visit(IVertex u)
{
VertexEventArgs uArgs = new VertexEventArgs(u);
Colors[u] = GraphColor.Gray;
OnDiscoverVertex(u);
IEdgeEnumerable outEdges = VisitedGraph.OutEdges(u);
VisitEdges(outEdges, true);
IEdgeEnumerable intEdges = VisitedGraph.InEdges(u);
VisitEdges(intEdges, false);
Colors[u] = GraphColor.Black;
OnFinishVertex(u);
}
/// <summary>
/// Returns the first edge of the graph
/// </summary>
/// <param name="edges">graph</param>
/// <returns>first edge if any, otherwise a null reference</returns>
public static IEdge FirstEdge(IEdgeEnumerable edges)
{
if (edges == null)
{
throw new ArgumentNullException("edges");
}
IEdgeEnumerator en = edges.GetEnumerator();
if (!en.MoveNext())
{
return(null);
}
else
{
return(en.Current);
}
}
public void Measure(IEdgeEnumerable edges)
{
Clear();
// count the number of passages
int count=0;
foreach(IEdge e in edges)
{
if (this.passCounts[e]==0)
++count;
this.passCounts[e]++;
}
// compute covergage
if (this.graph.EdgesEmpty)
this.coverage =0;
else
this.coverage = count / (double)this.graph.EdgesCount;
}
internal void WriteEdges(EdgeColorDictionary edgeColors,
IEdgeEnumerable edges)
{
foreach (IEdge e in edges)
{
if (edgeColors[e] != GraphColor.White)
{
continue;
}
Output.Write("{0} -> {1} [",
e.Source.ID,
e.Target.ID
);
OnWriteEdge(e);
OnFormatEdge(EdgeFormat, e);
Output.WriteLine("];");
edgeColors[e] = GraphColor.Black;
}
}
public void MeasurePath(IEdgeEnumerable edges)
{
Clear();
// count the number of passages
int count=0;
bool isFirst = true;
foreach(IEdge e in edges)
{
if (isFirst)
{
this.passCounts[e.Source]++;
isFirst = false;
}
if (this.passCounts[e.Target]==0)
++count;
this.passCounts[e.Target]++;
}
// compute covergage
if (this.graph.VerticesEmpty)
this.coverage =0;
else
this.coverage = count / (double)this.graph.VerticesCount;
}
public TargetVertexEnumerator(IEdgeEnumerable edges)
{
if (edges==null)
throw new ArgumentNullException("edges");
this.enumerator = edges.GetEnumerator();
}
public void MeasurePath(IEdgeEnumerable edges)
{
this.Clear();
int num = 0;
bool flag = true;
IEdgeEnumerator enumerator = edges.GetEnumerator();
while (enumerator.MoveNext())
{
VertexIntDictionary dictionary2;
IVertex vertex2;
IEdge edge = enumerator.get_Current();
if (flag)
{
VertexIntDictionary dictionary;
IVertex vertex;
(dictionary = this.passCounts).set_Item(vertex = edge.get_Source(), dictionary.get_Item(vertex) + 1);
flag = false;
}
if (this.passCounts.get_Item(edge.get_Target()) == 0)
{
num++;
}
(dictionary2 = this.passCounts).set_Item(vertex2 = edge.get_Target(), dictionary2.get_Item(vertex2) + 1);
}
if (this.graph.get_VerticesEmpty())
{
this.coverage = 0.0;
}
else
{
this.coverage = ((double) num) / ((double) this.graph.get_VerticesCount());
}
}
private void VisitEdges(IEdgeEnumerable outEdges, bool forward)
{
IVertex target=null;
foreach (IEdge e in outEdges)
{
OnExamineEdge(e);
if (forward)
target = e.Target;
else
target = e.Source;
GraphColor vc = Colors[target];
GraphColor ec = EdgeColors[e];
EdgeColors[e] = GraphColor.Black;
if (vc == GraphColor.White) // tree edge
{
OnTreeEdge(e);
Visit(target);
}
else if (vc == GraphColor.Gray && ec == GraphColor.White)
{
OnBackEdge(e);
}
}
}
/// <summary>
/// Adds the elements of another EdgeCollection to the end of this EdgeCollection.
/// </summary>
/// <param name="items">
/// The EdgeCollection whose elements are to be added to the end of this EdgeCollection.
/// </param>
public void AddRange(IEdgeEnumerable items)
{
foreach (IEdge item in items)
{
this.List.Add(item);
}
}
/// <summary>
/// Initializes a new instance of the EdgeCollection class, containing elements
/// copied from another instance of EdgeCollection
/// </summary>
/// <param name="items">
/// The EdgeCollection whose elements are to be added to the new EdgeCollection.
/// </param>
public EdgeCollection(IEdgeEnumerable items)
{
this.AddRange(items);
}
/// <summary>
///
/// </summary>
/// <param name="edges"></param>
/// <param name="count"></param>
/// <param name="rnd"></param>
/// <returns></returns>
public static IEdge Edge(IEdgeEnumerable edges, int count, Random rnd)
{
if (edges == null)
throw new ArgumentNullException("edges");
if (rnd == null)
throw new ArgumentNullException("random generator");
if (count == 0)
throw new ArgumentException("edges is empty");
int i = rnd.Next(count);
foreach(IEdge e in edges)
{
if (i==0)
return e;
else
--i;
}
// failed
throw new ArgumentOutOfRangeException("count");
}
private void VisitEdges(IEdgeEnumerable outEdges, bool forward)
{
IVertex u = null;
IEdgeEnumerator enumerator = outEdges.GetEnumerator();
while (enumerator.MoveNext())
{
IEdge e = enumerator.get_Current();
this.OnExamineEdge(e);
if (forward)
{
u = e.get_Target();
}
else
{
u = e.get_Source();
}
GraphColor color = this.Colors.get_Item(u);
GraphColor color2 = this.EdgeColors.get_Item(e);
this.EdgeColors.set_Item(e, 1);
if (color == null)
{
this.OnTreeEdge(e);
this.Visit(u);
}
else if ((color == 2) && (color2 == null))
{
this.OnBackEdge(e);
}
}
}
public ReversedEdgeEnumerable(IEdgeEnumerable edges)
{
this.edges = edges;
}
public ReversedEdgeEnumerable(IEdgeEnumerable edges)
{
this.edges = edges;
}
/// <summary>
/// Returns the last edge of the edge collection
/// </summary>
/// <param name="edges">edge collection</param>
/// <returns>last edge if any, otherwise a null reference</returns>
public static IEdge LastEdge(IEdgeEnumerable edges)
{
if (edges==null)
throw new ArgumentNullException("edges");
IEdgeEnumerator en = edges.GetEnumerator();
IEdge current = null;
while(en.MoveNext())
{
current = en.Current;
}
return current;
}
public TargetVertexEnumerable(IEdgeEnumerable edges)
{
if (edges==null)
throw new ArgumentNullException("edges");
this.edges = edges;
}
internal void WriteEdges(EdgeColorDictionary edgeColors,
IEdgeEnumerable edges)
{
foreach(IEdge e in edges)
{
if (edgeColors[e]!=GraphColor.White)
continue;
Output.Write("{0} -> {1} [",
e.Source.ID,
e.Target.ID
);
OnWriteEdge(e);
OnFormatEdge(EdgeFormat,e);
Output.WriteLine("];");
edgeColors[e]=GraphColor.Black;
}
}
/// <summary>
/// Initializes a new instance of the EdgeCollection class, containing elements
/// copied from another instance of EdgeCollection
/// </summary>
/// <param name="items">
/// The EdgeCollection whose elements are to be added to the new EdgeCollection.
/// </param>
public EdgeCollection(IEdgeEnumerable items)
{
this.AddRange(items);
}
internal IEdge NextState(
int edgeCount,
IEdgeEnumerable edges
)
{
if (edgeCount == 0)
return null;
double r = this.rnd.NextDouble();
int nr = (int)Math.Floor(edgeCount * r);
if (nr==edgeCount)
--nr;
int i=0;
foreach(IEdge e in edges)
{
if (i==nr)
return e;
++i;
}
throw new InvalidOperationException("This is a bug");
}
