public IEnumerable <Arc> Arcs(Node u, Node v, ArcFilter filter = ArcFilter.All)
{
if (Directed)
{
switch (filter)
{
case ArcFilter.Edge:
yield break;
default:
yield return(GetArc(v, u));
/*Error: Unable to find new state assignment for yield return*/;
case ArcFilter.Forward:
break;
}
}
if (!Directed || filter != ArcFilter.Backward)
{
yield return(GetArc(u, v));
/*Error: Unable to find new state assignment for yield return*/;
}
}
public IEnumerable <Arc> Arcs(Node u, Node v, ArcFilter filter = ArcFilter.All)
{
foreach (Arc item in ArcsInternal(u, filter))
{
if (this.Other(item, u) == v)
{
yield return(item);
/*Error: Unable to find new state assignment for yield return*/;
}
}
if (graph != null && !nodes.Contains(u) && !nodes.Contains(v))
{
using (IEnumerator <Arc> enumerator2 = graph.Arcs(u, v, filter).GetEnumerator())
{
if (enumerator2.MoveNext())
{
Arc arc = enumerator2.Current;
yield return(arc);
/*Error: Unable to find new state assignment for yield return*/;
}
}
}
yield break;
IL_01d5:
/*Error near IL_01d6: Unexpected return in MoveNext()*/;
}
/// Runs the depth-first search. Can be called an arbitrary number of times.
/// \param graph The input graph.
/// \param roots The roots where the search should start, or \c null if all the graph nodes
/// should be considered.
public void Run(IGraph graph, IEnumerable <Node> roots = null)
{
Graph = graph;
Direction direction;
Start(out direction);
switch (direction)
{
case Direction.Undirected: arcFilter = ArcFilter.All; break;
case Direction.Forward: arcFilter = ArcFilter.Forward; break;
default: arcFilter = ArcFilter.Backward; break;
}
traversed = new HashSet <Node>();
foreach (var node in (roots ?? Graph.Nodes()))
{
if (traversed.Contains(node))
{
continue;
}
Level = 0;
if (!Traverse(node, Arc.Invalid))
{
break;
}
}
traversed = null;
StopSearch();
}
public IEnumerable <Arc> Arcs(Node u, ArcFilter filter = ArcFilter.All)
{
if (Directed)
{
if (filter == ArcFilter.Edge)
{
yield break;
}
if (filter != ArcFilter.Forward)
{
foreach (var w in Nodes())
{
if (w != u)
{
yield return(GetArc(w, u));
}
}
}
}
if (!Directed || filter != ArcFilter.Backward)
{
foreach (var w in Nodes())
{
if (w != u)
{
yield return(GetArc(u, w));
}
}
}
}
public IEnumerable <Arc> Arcs(ArcFilter filter = ArcFilter.All)
{
if (Directed)
{
for (int i = 0; i < nodeCount; i++)
{
for (int j = 0; j < nodeCount; j++)
{
if (i != j)
{
yield return(GetArcInternal(i, j));
}
}
}
}
else
{
for (int i = 0; i < nodeCount; i++)
{
for (int j = i + 1; j < nodeCount; j++)
{
yield return(GetArcInternal(i, j));
}
}
}
}
public int ArcCount(Node u, ArcFilter filter = ArcFilter.All)
{
bool flag = IsRed(u);
if (Directed)
{
switch (filter)
{
case ArcFilter.Forward:
if (flag)
{
goto default;
}
goto case ArcFilter.Edge;
default:
if (filter != ArcFilter.Backward || !flag)
{
break;
}
goto case ArcFilter.Edge;
case ArcFilter.Edge:
return(0);
}
}
return((!flag) ? RedNodeCount : BlueNodeCount);
}
public IEnumerable <Arc> Arcs(Node u, ArcFilter filter = ArcFilter.All)
{
bool isRed = IsRed(u);
if (Directed && (filter == ArcFilter.Edge ||
(filter == ArcFilter.Forward && !isRed) ||
(filter == ArcFilter.Backward && isRed)))
{
yield break;
}
if (isRed)
{
for (int i = 0; i < BlueNodeCount; i++)
{
yield return(GetArc(u, GetBlueNode(i)));
}
}
else
{
for (int i = 0; i < RedNodeCount; i++)
{
yield return(GetArc(GetRedNode(i), u));
}
}
}
private IEnumerable <Arc> FilterArcs(Node u, IEnumerable <Arc> arcs, ArcFilter filter)
{
switch (filter)
{
case ArcFilter.All: return(arcs);
case ArcFilter.Edge: return(arcs.Where(x => getDirection(x) == Direction.Edge));
case ArcFilter.Forward: return(arcs.Where(x =>
{
var dir = getDirection(x);
switch (dir)
{
case Direction.Forward: return U(x) == u;
case Direction.Backward: return V(x) == u;
default: return true;
}
}));
default: return(arcs.Where(x =>
{
var dir = getDirection(x);
switch (dir)
{
case Direction.Forward: return V(x) == u;
case Direction.Backward: return U(x) == u;
default: return true;
}
}));
}
}
public int ArcCount(ArcFilter filter = ArcFilter.All)
{
if (Directed && filter == ArcFilter.Edge)
{
return(0);
}
return(RedNodeCount * BlueNodeCount);
}
public int ArcCount(Node u, Node v, ArcFilter filter = ArcFilter.All)
{
if (IsRed(u) == IsRed(v))
{
return(0);
}
return(ArcCount(u, filter) > 0 ? 1 : 0);
}
public IEnumerable <Arc> Arcs(Node u, ArcFilter filter = ArcFilter.All)
{
if (graph == null || nodes.Contains(u))
{
return(ArcsInternal(u, filter));
}
return(ArcsInternal(u, filter).Concat(graph.Arcs(u, filter)));
}
public int ArcCount(ArcFilter filter = ArcFilter.All)
{
if (nodeExceptions.Count == 0 && filter == ArcFilter.All)
{
return(defaultNodeEnabled ? ((!defaultArcEnabled) ? arcExceptions.Count : (graph.ArcCount(ArcFilter.All) - arcExceptions.Count)) : 0);
}
return(Arcs(filter).Count());
}
public int ArcCount(Node u, Node v, ArcFilter filter = ArcFilter.All)
{
if (u != v)
{
Arc arc = MatchedArc(u);
return((arc != Arc.Invalid && arc == MatchedArc(v) && YieldArc(u, filter, arc)) ? 1 : 0);
}
return(0);
}
public IEnumerable <Arc> Arcs(Node u, Node v, ArcFilter filter = ArcFilter.All)
{
Arc arc = GetArc(u, v);
if (arc != Arc.Invalid && ArcCount(u, filter) > 0)
{
yield return(arc);
}
}
public IEnumerable <Arc> Arcs(Node u, ArcFilter filter = ArcFilter.All)
{
Arc arc = MatchedArc(u);
if (arc != Arc.Invalid && YieldArc(u, filter, arc))
{
yield return(arc);
}
}
public int ArcCount(ArcFilter filter = ArcFilter.All)
{
var result = nodeCount * (nodeCount - 1);
if (!Directed)
{
result /= 2;
}
return(result);
}
public IEnumerable <Arc> Arcs(ArcFilter filter = ArcFilter.All)
{
foreach (var arc in graph.Arcs(filter))
{
if (IsEnabled(arc) && IsEnabled(graph.U(arc)) && IsEnabled(graph.V(arc)))
{
yield return(arc);
}
}
}
public int ArcCount(ArcFilter filter = ArcFilter.All)
{
int num = nodeCount * (nodeCount - 1);
if (!Directed)
{
num /= 2;
}
return(num);
}
public IEnumerable <Arc> Arcs(Node u, Node v, ArcFilter filter = ArcFilter.All)
{
foreach (var arc in ArcsInternal(u, filter))
{
if (this.Other(arc, u) == v)
{
yield return(arc);
}
}
}
public IEnumerable <Arc> Arcs(ArcFilter filter = ArcFilter.All)
{
if (directed && filter == ArcFilter.Edge)
{
yield break;
}
for (int i = 1, n = ArcCountInternal(); i <= n; i++)
{
yield return(new Arc(i));
}
}
public IEnumerable <Arc> Arcs(Node u, Node v, ArcFilter filter = ArcFilter.All)
{
Arc arc = GetArc(u, v);
if (arc != Arc.Invalid && ArcCount(u, filter) > 0)
{
yield return(arc);
/*Error: Unable to find new state assignment for yield return*/;
}
}
public IEnumerable <Arc> Arcs(Node u, ArcFilter filter = ArcFilter.All)
{
Arc arc = MatchedArc(u);
if (arc != Arc.Invalid && YieldArc(u, filter, arc))
{
yield return(arc);
/*Error: Unable to find new state assignment for yield return*/;
}
}
/// Returns the opposite of an arc filter.
public static ArcFilter Reverse(ArcFilter filter)
{
if (filter == ArcFilter.Forward)
{
return(ArcFilter.Backward);
}
if (filter == ArcFilter.Backward)
{
return(ArcFilter.Forward);
}
return(filter);
}
public IEnumerable <Arc> Arcs(ArcFilter filter = ArcFilter.All)
{
if (filter == ArcFilter.All)
{
return(arcs);
}
if (edgeCount == 0)
{
return(Enumerable.Empty <Arc>());
}
return(arcs.Where(arc => IsEdge(arc)));
}
public int ArcCount(Node u, Node v, ArcFilter filter = ArcFilter.All)
{
int result = 0;
foreach (var arc in ArcsInternal(u, filter))
{
if (this.Other(arc, u) == v)
{
result++;
}
}
return(result + (graph == null || nodes.Contains(u) || nodes.Contains(v) ? 0 : graph.ArcCount(u, v, filter)));
}
public int ArcCount(Node u, ArcFilter filter = ArcFilter.All)
{
bool isRed = IsRed(u);
if (Directed && (filter == ArcFilter.Edge ||
(filter == ArcFilter.Forward && !isRed) ||
(filter == ArcFilter.Backward && isRed)))
{
return(0);
}
return(isRed ? BlueNodeCount : RedNodeCount);
}
public int ArcCount(Node u, Node v, ArcFilter filter = ArcFilter.All)
{
int result = 0;
foreach (var arc in ArcsInternal(u, filter))
{
if (this.Other(arc, u) == v)
{
result++;
}
}
return(result);
}
public int ArcCount(Node u, Node v, ArcFilter filter = ArcFilter.All)
{
int num = 0;
foreach (Arc item in ArcsInternal(u, filter))
{
if (this.Other(item, u) == v)
{
num++;
}
}
return(num + ((graph != null && !nodes.Contains(u) && !nodes.Contains(v)) ? graph.ArcCount(u, v, filter) : 0));
}
internal static IEnumerable <Arc> ArcsHelper(this IPath path, Node u, ArcFilter filter)
{
Arc arc3 = path.PrevArc(u);
Arc arc2 = path.NextArc(u);
if (arc3 == arc2)
{
arc2 = Arc.Invalid;
}
for (int i = 0; i < 2; i++)
{
Arc arc = (i != 0) ? arc2 : arc3;
if (!(arc == Arc.Invalid))
{
switch (filter)
{
case ArcFilter.All:
yield return(arc);
/*Error: Unable to find new state assignment for yield return*/;
case ArcFilter.Edge:
if (path.IsEdge(arc))
{
yield return(arc);
/*Error: Unable to find new state assignment for yield return*/;
}
break;
case ArcFilter.Forward:
if (path.IsEdge(arc) || path.U(arc) == u)
{
yield return(arc);
/*Error: Unable to find new state assignment for yield return*/;
}
break;
case ArcFilter.Backward:
if (path.IsEdge(arc) || path.V(arc) == u)
{
yield return(arc);
/*Error: Unable to find new state assignment for yield return*/;
}
break;
}
}
}
}
public IEnumerable <Arc> Arcs(ArcFilter filter = ArcFilter.All)
{
if (filter == ArcFilter.All)
{
return(arcs);
}
if (edgeCount == 0)
{
return(Enumerable.Empty <Arc>());
}
return(from arc in arcs
where IsEdge(arc)
select arc);
}
