public void Constructor()
{
var graph = new UndirectedGraph <int, Edge <int> >();
var algorithm = new PrimMinimumSpanningTreeAlgorithm <int, Edge <int> >(graph, edge => 1.0);
AssertAlgorithmState(algorithm, graph);
algorithm = new PrimMinimumSpanningTreeAlgorithm <int, Edge <int> >(null, graph, edge => 1.0);
AssertAlgorithmState(algorithm, graph);
}
public static IEnumerable <TaggedEdge <string, string> > GetEdges(UndirectedGraph <string, TaggedEdge <string, string> > g)
{
var algorithm = new PrimMinimumSpanningTreeAlgorithm <string, TaggedEdge <string, string> >(g, edgeWeights => double.Parse(edgeWeights.Tag));
var recorder = new EdgeRecorderObserver <string, TaggedEdge <string, string> >();
using (recorder.Attach(algorithm))
{
algorithm.Compute();
return(recorder.Edges);
}
}
public static IEnumerable <Edge <int> > GetEdges(UndirectedGraph <int, Edge <int> > g)
{
var algorithm = new PrimMinimumSpanningTreeAlgorithm <int, Edge <int> >(g, edgeWeights => 1.0);
var recorder = new EdgeRecorderObserver <int, Edge <int> >();
using (recorder.Attach(algorithm))
{
algorithm.Compute();
return(recorder.Edges);
}
}
protected static void PrimSpanningTree <TVertex, TEdge>([NotNull] IUndirectedGraph <TVertex, TEdge> graph, [NotNull] Func <TEdge, double> edgeWeights)
where TEdge : IEdge <TVertex>
{
var distances = new Dictionary <TEdge, double>();
foreach (TEdge edge in graph.Edges)
{
distances[edge] = edgeWeights(edge);
}
var prim = new PrimMinimumSpanningTreeAlgorithm <TVertex, TEdge>(graph, e => distances[e]);
AssertMinimumSpanningTree(graph, prim);
}
public void MyPrim <TVertex, TEdge>([PexAssumeNotNull] IUndirectedGraph <TVertex, TEdge> g)
where TEdge : IEdge <TVertex>
{
var distances = new Dictionary <TEdge, double>();
foreach (var e in g.Edges)
{
distances[e] = g.AdjacentDegree(e.Source) + 1;
}
var prim = new PrimMinimumSpanningTreeAlgorithm <TVertex, TEdge>(g, e => distances[e]);
AssertMinimumSpanningTree <TVertex, TEdge>(g, prim);
}
/// <summary>
/// Prim Minimum Spanning Tree
/// </summary>
/// <typeparam name="TVertex"></typeparam>
/// <typeparam name="TEdge"></typeparam>
/// <param name="g"></param>
/// <param name="edgeWeights"></param>
/// <param name="resultEdges"></param>
private static void Prim <TVertex, TEdge>(IUndirectedGraph <TVertex, TEdge> g, Func <TEdge, double> edgeWeights, ref int[][] resultEdges) where TEdge : IEdge <TVertex>
{
List <TEdge> ed = g.Edges.ToList();
Dictionary <TEdge, double> distances = new Dictionary <TEdge, double>();
foreach (TEdge e in g.Edges)
{
distances[e] = edgeWeights(e);
}
PrimMinimumSpanningTreeAlgorithm <TVertex, TEdge> prim = new PrimMinimumSpanningTreeAlgorithm <TVertex, TEdge>(g, e => distances[e]);
//call this method
AssertMinimumSpanningTree <TVertex, TEdge>(g, prim, ref resultEdges);
}
public void MyPrim <TVertex, TEdge>([PexAssumeNotNull] IUndirectedGraph <TVertex, TEdge> g, Func <TEdge, double> edgeWeights)
where TEdge : IEdge <TVertex>
{
var ed = g.Edges.ToList();
var distances = new Dictionary <TEdge, double>();
foreach (var e in g.Edges)
{
distances[e] = edgeWeights(e);
}
var prim = new PrimMinimumSpanningTreeAlgorithm <TVertex, TEdge>(g, e => distances[e]);
AssertMinimumSpanningTree <TVertex, TEdge>(g, prim);
}
public static double GetCost(UndirectedGraph <string, TaggedEdge <string, string> > g)
{
var algorithm = new PrimMinimumSpanningTreeAlgorithm <string, TaggedEdge <string, string> >(g, edgeWeights => double.Parse(edgeWeights.Tag));
var recorder = new EdgeRecorderObserver <string, TaggedEdge <string, string> >();
var distances = new Dictionary <TaggedEdge <string, string>, double>();
foreach (var e in g.Edges)
{
distances[e] = double.Parse(e.Tag);
}
using (recorder.Attach(algorithm))
{
algorithm.Compute();
return(recorder.Edges.Sum(e => distances[e]));
}
}
public static double GetCost(UndirectedGraph <int, Edge <int> > g)
{
var algorithm = new PrimMinimumSpanningTreeAlgorithm <int, Edge <int> >(g, edgeWeights => 1.0);
var recorder = new EdgeRecorderObserver <int, Edge <int> >();
var distances = new Dictionary <Edge <int>, double>();
foreach (var edge in g.Edges)
{
distances[edge] = 1.0;
}
using (recorder.Attach(algorithm))
{
algorithm.Compute();
return(recorder.Edges.Sum(e => distances[e]));
}
}
public void Compute(IUndirectedGraph<string, Edge<string>> g)
{
Dictionary<Edge<string>, double> distances = new Dictionary<Edge<string>,double>();
foreach(Edge<string> edge in g.Edges)
distances.Add(edge, 1);
PrimMinimumSpanningTreeAlgorithm<string, Edge<string>> prim = new PrimMinimumSpanningTreeAlgorithm<string, Edge<string>>(g, distances);
VertexPredecessorRecorderObserver<string, Edge<string>> predecessors = new VertexPredecessorRecorderObserver<string, Edge<string>>();
predecessors.Attach(prim);
prim.Compute();
foreach (string v in g.Vertices)
{
Edge<string> edge;
if (predecessors.VertexPredecessors.TryGetValue(v, out edge))
Console.WriteLine("{0}: {1}", v, edge);
else
Console.WriteLine("{0}", v);
}
}
