public StrongComponentChecker(IDirectedGraph <NodeType, EdgeType> graph)
{
this.graph = graph;
dfs = new DepthFirstSearch <NodeType, EdgeType>(graph);
CanCreateNodeData <NodeType> data = (CanCreateNodeData <NodeType>)graph;
DiscoverTime = data.CreateNodeData <int>(0);
RootDiscoverTime = data.CreateNodeData <int>(0);
dfs.DiscoverNode += delegate(NodeType node)
{
DiscoverTime[node] = time;
RootDiscoverTime[node] = time;
time++;
};
dfs.BackEdge += ProcessEdge2;
dfs.CrossEdge += ProcessEdge2;
dfs.FinishTreeEdge += ProcessEdge;
dfs.FinishNode += delegate(NodeType node)
{
int thisRootDiscoverTime = RootDiscoverTime[node];
if (thisRootDiscoverTime < DiscoverTime[node])
{
// not a root
}
else
{
// root of a component
if (thisRootDiscoverTime != 0)
{
IsStrong = false;
}
}
};
}
public CyclicDependencySort(
Converter <Node, IEnumerable <Node> > predecessors,
Converter <Node, IEnumerable <Node> > successors,
CanCreateNodeData <Node> data,
CostUpdater updateCost)
{
this.successors = successors;
bfs = new BreadthFirstSearch <Node>(predecessors, data);
this.updateCost = updateCost;
queue = new PriorityQueue <QueueEntry>(QueueEntry.Comparer);
queue.Moved += delegate(QueueEntry entry, int pos) { entry.QueuePosition = pos; };
EntryOfNode = data.CreateNodeData <QueueEntry>(null);
visitCount = 0;
bfs.FinishNode += delegate(Node node)
{
QueueEntry entry = new QueueEntry();
entry.ClosenessToTarget = ++visitCount;
entry.Node = node;
entry.Cost = Threshold;
EntryOfNode[node] = entry;
queue.Add(entry);
UpdateEntry(entry);
};
IsScheduled = data.CreateNodeData <bool>(false);
}
public PathFinder(IDirectedGraph <NodeType> graph)
{
this.graph = graph;
CanCreateNodeData <NodeType> data = (CanCreateNodeData <NodeType>)graph;
isBlocked = data.CreateNodeData <bool>(false);
}
public DistanceSearch(Converter <NodeType, IEnumerable <NodeType> > successors,
CanCreateNodeData <NodeType> data)
{
this.Successors = successors;
this.Data = data;
bfs = new BreadthFirstSearch <NodeType>(Successors, Data);
bfs.DiscoverNode += delegate(NodeType node)
{
OnSetDistance(node, distance);
if (distance == 0)
{
distance++;
}
else
{
childCount++;
}
};
bfs.FinishNode += delegate(NodeType node)
{
if (--parentCount == 0)
{
parentCount = childCount;
childCount = 0;
distance++;
}
};
}
public CycleFinder(IDirectedGraph <NodeType> graph)
{
this.graph = graph;
CanCreateNodeData <NodeType> data = (CanCreateNodeData <NodeType>)graph;
isBlocked = data.CreateNodeData <bool>(false);
blockedSources = data.CreateNodeData <Set <NodeType> >(null);
}
public PseudoPeripheralSearch(Converter <NodeType, IEnumerable <NodeType> > successors,
Converter <NodeType, IEnumerable <NodeType> > predecessors,
CanCreateNodeData <NodeType> data)
{
this.Successors = successors;
this.Predecessors = predecessors;
this.Data = data;
}
public NodeOnPathFinder(
Converter <NodeType, IEnumerable <NodeType> > successors,
CanCreateNodeData <NodeType> data,
IndexedProperty <NodeType, bool> onPath,
Predicate <NodeType> isSink)
{
this.successors = successors;
isBlocked = data.CreateNodeData <bool>(false);
blockedSources = data.CreateNodeData <Set <NodeType> >(null);
this.onPath = onPath;
this.isSink = isSink;
}
public EdgeOnPathFinder(
Converter <NodeType, IEnumerable <EdgeType> > edgesOutOf,
Converter <EdgeType, NodeType> targetOf,
CanCreateNodeData <NodeType> data,
IndexedProperty <EdgeType, bool> onPath,
Predicate <NodeType> isSink)
{
this.edgesOutOf = edgesOutOf;
this.targetOf = targetOf;
isBlocked = data.CreateNodeData <bool>(false);
blockedSources = data.CreateNodeData <Set <NodeType> >(null);
this.onPath = onPath;
this.isSink = isSink;
}
public StrongComponents(Converter <NodeType, IEnumerable <NodeType> > successors,
Converter <NodeType, IEnumerable <NodeType> > predecessors, CanCreateNodeData <NodeType> data)
{
dfsForward = new DepthFirstSearch <NodeType>(successors, data);
finished = new Stack <NodeType>();
dfsForward.FinishNode += node => finished.Push(node);
dfsBackward =
new DepthFirstSearch <NodeType>(node => predecessors(node).Where(source => (dfsForward.IsVisited[source] != VisitState.Unvisited)), data);
dfsBackward.DiscoverNode += OnAddNode;
}
public StrongComponents2(Converter <NodeType, IEnumerable <NodeType> > successors, CanCreateNodeData <NodeType> data)
{
dfs = new DepthFirstSearch <NodeType>(successors, data);
finished = new Stack <NodeType>();
DiscoverTime = data.CreateNodeData <int>(0);
RootDiscoverTime = data.CreateNodeData <int>(0);
dfs.DiscoverNode += delegate(NodeType node)
{
DiscoverTime[node] = time;
RootDiscoverTime[node] = time;
time++;
};
dfs.BackEdge += delegate(Edge <NodeType> edge)
{
if (RootDiscoverTime[edge.Target] < RootDiscoverTime[edge.Source])
{
RootDiscoverTime[edge.Source] = RootDiscoverTime[edge.Target];
}
};
dfs.CrossEdge += delegate(Edge <NodeType> edge)
{
if (RootDiscoverTime[edge.Target] < RootDiscoverTime[edge.Source])
{
RootDiscoverTime[edge.Source] = RootDiscoverTime[edge.Target];
}
};
dfs.FinishTreeEdge += delegate(Edge <NodeType> edge)
{
if (RootDiscoverTime[edge.Target] < RootDiscoverTime[edge.Source])
{
RootDiscoverTime[edge.Source] = RootDiscoverTime[edge.Target];
}
};
dfs.FinishNode += delegate(NodeType node)
{
int thisRootDiscoverTime = RootDiscoverTime[node];
if (thisRootDiscoverTime < DiscoverTime[node])
{
// not a root
finished.Push(node);
}
else
{
// root of a component
OnBeginComponent();
OnAddNode(node);
while (finished.Count > 0 && RootDiscoverTime[finished.Peek()] >= thisRootDiscoverTime)
{
NodeType child = finished.Pop();
OnAddNode(child);
RootDiscoverTime[child] = Int32.MaxValue; // prevent child from affecting any other components
}
RootDiscoverTime[node] = Int32.MaxValue; // prevent node from affecting any other components
OnEndComponent();
}
};
}
public DepthFirstSearch(Converter <NodeType, IEnumerable <NodeType> > successors,
CanCreateNodeData <NodeType> data)
: base(successors, data)
{
Initialize();
}
