/// <summary> /// Initializes a new instance of the <see cref="DelegateBidirectionalIncidenceGraph{TVertex,TEdge}"/> class. /// </summary> /// <param name="tryGetOutEdges">Getter of out-edges.</param> /// <param name="tryGetInEdges">Getter of in-edges.</param> /// <param name="allowParallelEdges"> /// Indicates if parallel edges are allowed. /// Note that get of edges is delegated so you may have bugs related /// to parallel edges due to the delegated implementation. /// </param> /// <exception cref="T:System.ArgumentNullException"><paramref name="tryGetOutEdges"/> is <see langword="null"/>.</exception> /// <exception cref="T:System.ArgumentNullException"><paramref name="tryGetInEdges"/> is <see langword="null"/>.</exception> public DelegateBidirectionalIncidenceGraph( [NotNull] TryFunc <TVertex, IEnumerable <TEdge> > tryGetOutEdges, [NotNull] TryFunc <TVertex, IEnumerable <TEdge> > tryGetInEdges, bool allowParallelEdges = true) : base(tryGetOutEdges, allowParallelEdges) { _tryGetInEdgesFunc = tryGetInEdges ?? throw new ArgumentNullException(nameof(tryGetInEdges)); }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="getter"></param> /// <param name="threadSafe"></param> public DemandDictionary(TryFunc <TKey, TValue> getter, bool threadSafe) : this(getter, threadSafe ? (IDictionary <TKey, TValue>) new ConcurrentDictionary <TKey, TValue>() : new Dictionary <TKey, TValue>()) { if (getter == null) { throw new ArgumentNullException(nameof(getter)); } }
/// <summary> /// Initializes a new instance of the <see cref="DelegateUndirectedGraph{TVertex,TEdge}"/> class. /// </summary> /// <param name="vertices">Graph vertices.</param> /// <param name="tryGetAdjacentEdges">Getter of adjacent edges.</param> /// <param name="allowParallelEdges"> /// Indicates if parallel edges are allowed. /// Note that get of edges is delegated so you may have bugs related /// to parallel edges due to the delegated implementation. /// </param> public DelegateUndirectedGraph( IEnumerable <TVertex> vertices, TryFunc <TVertex, IEnumerable <TEdge> > tryGetAdjacentEdges, bool allowParallelEdges = true) : base(tryGetAdjacentEdges, allowParallelEdges) { _vertices = vertices ?? throw new ArgumentNullException(nameof(vertices)); }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="getter"></param> public DemandDictionary(TryFunc <TKey, TValue> getter) : this(getter, false) { if (getter == null) { throw new ArgumentNullException(nameof(getter)); } }
/// <summary> /// Initializes a new instance of the <see cref="DelegateVertexAndEdgeListGraph{TVertex,TEdge}"/> class. /// </summary> /// <param name="vertices">Graph vertices.</param> /// <param name="tryGetOutEdges">Getter of out-edges.</param> /// <param name="allowParallelEdges"> /// Indicates if parallel edges are allowed. /// Note that get of edges is delegated so you may have bugs related /// to parallel edges due to the delegated implementation. /// </param> public DelegateVertexAndEdgeListGraph( [NotNull, ItemNotNull] IEnumerable <TVertex> vertices, [NotNull] TryFunc <TVertex, IEnumerable <TEdge> > tryGetOutEdges, bool allowParallelEdges = true) : base(tryGetOutEdges, allowParallelEdges) { _vertices = vertices ?? throw new ArgumentNullException(nameof(vertices)); }
public DelegateBidirectionalIncidenceGraph( TryFunc <TVertex, IEnumerable <TEdge> > tryGetOutEdges, TryFunc <TVertex, IEnumerable <TEdge> > tryGetInEdges) : base(tryGetOutEdges) { //Contract.Requires(tryGetInEdges != null); this.tryGetInEdges = tryGetInEdges; }
public bool IsRoutePossible(IPlatformModule sourceModule, IPlatformModule targetModule) { Func <ModuleGraphEdge, double> edgeCost = x => 1; TryFunc <IPlatformModule, IEnumerable <ModuleGraphEdge> > tryGetPaths = Graph.ShortestPathsDijkstra(edgeCost, sourceModule); IEnumerable <ModuleGraphEdge> path; return(tryGetPaths(targetModule, out path)); }
public void TestPDFCreator() { TryFunc <int, IEnumerable <Edge <int> > > tryGetPath = this.graph.ShortestPathsDijkstra(this.edgeCost, 0); DotGenerator <int, Edge <int> > generator = new DotGenerator <int, Edge <int> >(graph, tryGetPath); (new PDFGenerator(generator.GetDotCode(), "test.pdf")).GeneratePDF(); FileAssert.Exists("test.pdf"); File.Delete("test.pdf"); }
public DelegateImplicitUndirectedGraph( TryFunc <TVertex, IEnumerable <TEdge> > tryGetAdjacenyEdges, bool allowParallelEdges) { Contract.Requires(tryGetAdjacenyEdges != null); this.tryGetAdjacentEdges = tryGetAdjacenyEdges; this.allowParallelEdges = allowParallelEdges; }
public IEnumerable <IBranch> GetShortestPath(INode source, INode target, Func <IBranch, double> weights) { TryFunc <INode, IEnumerable <IBranch> > result = this.ShortestPathsDijkstra(b => b.Length, source); IEnumerable <IBranch> path; result(target, out path); return(path); }
private static void CompareAlgorithms <TVertex, TEdge, TGraph>( [NotNull] AdjacencyGraph <TVertex, TEdge> graph, [NotNull, InstantHandle] Func <TEdge, double> getDistances, [NotNull, InstantHandle] Func <AdjacencyGraph <TVertex, TEdge>, Func <TEdge, double>, ShortestPathAlgorithmBase <TVertex, TEdge, TGraph> > shortestPathAlgorithmFactory) where TEdge : IEdge <TVertex> where TGraph : IVertexSet <TVertex> { // Compute all paths var algorithm = new FloydWarshallAllShortestPathAlgorithm <TVertex, TEdge>(graph, getDistances); algorithm.Compute(); TVertex[] vertices = graph.Vertices.ToArray(); foreach (TVertex source in vertices) { ShortestPathAlgorithmBase <TVertex, TEdge, TGraph> otherAlgorithm = shortestPathAlgorithmFactory(graph, getDistances); var predecessors = new VertexPredecessorRecorderObserver <TVertex, TEdge>(); using (predecessors.Attach(otherAlgorithm)) otherAlgorithm.Compute(source); TryFunc <TVertex, IEnumerable <TEdge> > otherPaths = predecessors.TryGetPath; foreach (TVertex target in vertices) { if (source.Equals(target)) { continue; } bool pathExists = algorithm.TryGetPath(source, target, out IEnumerable <TEdge> floydPath); Assert.AreEqual(pathExists, otherPaths(target, out IEnumerable <TEdge> otherPath)); if (pathExists) { TEdge[] floydEdges = floydPath.ToArray(); CheckPath(source, target, floydEdges); TEdge[] otherEdges = otherPath.ToArray(); CheckPath(source, target, otherEdges); // All distances are usually 1 in this test, so it should at least // be the same number if (otherEdges.Length != floydEdges.Length) { Assert.Fail("Path do not have the same length."); } // Check path length are the same double floydLength = floydEdges.Sum(getDistances); double otherLength = otherEdges.Sum(getDistances); if (Math.Abs(floydLength - otherLength) > double.Epsilon) { Assert.Fail("Path do not have the same length."); } } } } }
/// <summary> /// Creates an instance of DelegateIncidenceGraph. /// </summary> /// <typeparam name="TVertex">type of the vertices</typeparam> /// <typeparam name="TEdge">type of the edges</typeparam> /// <param name="tryGetOutEdges"></param> /// <returns></returns> public static DelegateIncidenceGraph <TVertex, TEdge> ToDelegateIncidenceGraph <TVertex, TEdge>( #if !NET20 this #endif TryFunc <TVertex, IEnumerable <TEdge> > tryGetOutEdges) where TEdge : IEdge <TVertex>, IEquatable <TEdge> { Contract.Requires(tryGetOutEdges != null); return(new DelegateIncidenceGraph <TVertex, TEdge>(tryGetOutEdges)); }
public void TestShortestPaths() { TryFunc <int, IEnumerable <Edge <int> > > tryGetPath = this.graph.ShortestPathsDijkstra(this.edgeCost, 0); IEnumerable <Edge <int> > path; Assert.IsFalse(tryGetPath(0, out path)); tryGetPath(2, out path); int[] pattern = new int[] { 4, 2 }; Assert.IsTrue(this.checkPath(path, pattern)); }
/// <summary> /// Creates an instance of DelegateIncidenceGraph. /// </summary> /// <typeparam name="TVertex">type of the vertices</typeparam> /// <typeparam name="TEdge">type of the edges</typeparam> /// <param name="tryGetOutEdges"></param> /// <param name="tryGetInEdges"></param> /// <returns></returns> public static DelegateBidirectionalIncidenceGraph <TVertex, TEdge> ToDelegateBidirectionalIncidenceGraph <TVertex, TEdge> (this TryFunc <TVertex, IEnumerable <TEdge> > tryGetOutEdges, TryFunc <TVertex, IEnumerable <TEdge> > tryGetInEdges) where TEdge : IEdge <TVertex>, IEquatable <TEdge> { Contract.Requires(tryGetOutEdges != null); Contract.Requires(tryGetInEdges != null); return(new DelegateBidirectionalIncidenceGraph <TVertex, TEdge>(tryGetOutEdges, tryGetInEdges)); }
private IEnumerable <Conversion> ComputeShortestPath(Unit start, Unit end) { // Find a path from the source to the target Func <Conversion, double> edgeCost = e => 1; TryFunc <Unit, IEnumerable <Conversion> > tryGetPaths = this.ShortestPathsDijkstra(edgeCost, start); IEnumerable <Conversion> path; return(tryGetPaths(end, out path) ? path : null); }
public static IEnumerable <TResult> Execute <TInput, TResult>(this TryFunc <TInput, IEnumerable <TResult> > tryFunc, TInput input) { if (tryFunc(input, out var result)) { return(result); } else { return(Enumerable.Empty <TResult>()); } }
public DictionaryAdapter( TryFunc <TKey, TValue> getCallback, Func <IEnumerable <TKey> > keyEnumerable, Action <TKey, TValue> addOrSetCallback, Predicate <TKey> removeCallback) { this.GetCallback = getCallback; this.AddOrSetCallback = addOrSetCallback; this.RemoveCallback = removeCallback; this.KeyEnumerable = keyEnumerable; }
public void TestGraphWithOneVertex() { Matrix matrix = new Matrix( new int[][] { new int[] { -1 } }); TryFunc <int, IEnumerable <Edge <int> > > tryGetPath = this.createTryGetPath(matrix); IEnumerable <Edge <int> > edges; Assert.IsFalse(tryGetPath(0, out edges)); }
public static IEnumerable <TResult> SelectTry <TSource, TResult>( this IEnumerable <TSource> source, TryFunc <TSource, TResult> selector) { foreach (TSource item in source) { TResult result; if (selector(item, out result)) { yield return(result); } } }
public static bool TryRetryFail(int retries, TryFunc thisFunction) { bool actionSucceeded = false; int tryCounter = 0; while ((actionSucceeded == false) && (tryCounter < retries)) { actionSucceeded = thisFunction(); tryCounter++; } return(actionSucceeded); }
/// <summary> /// /// </summary> /// <typeparam name="TSource"></typeparam> /// <typeparam name="TResult"></typeparam> /// <typeparam name="TValue"></typeparam> /// <param name="source"></param> /// <param name="selector"></param> /// <param name="executor"></param> /// <returns></returns> public static IEnumerable <TResult> SelectTry <TSource, TValue, TResult>( this IEnumerable <TSource> source, Func <TSource, TValue> selector, TryFunc <TValue, TResult> executor) { foreach (TSource s in source) { if (executor(selector(s), out TResult r)) { yield return(r); } } }
public DelegateVertexAndEdgeListGraph( IEnumerable <TVertex> vertices, TryFunc <TVertex, IEnumerable <TEdge> > tryGetOutEdges) : base(tryGetOutEdges) { Contract.Requires(vertices != null); Contract.Requires(Enumerable.All(vertices, v => { IEnumerable <TEdge> edges; return(tryGetOutEdges(v, out edges)); })); this.vertices = vertices; }
public DelegateUndirectedGraph( IEnumerable <TVertex> vertices, TryFunc <TVertex, IEnumerable <TEdge> > tryGetAdjacentEdges, bool allowParallelEdges) : base(tryGetAdjacentEdges, allowParallelEdges) { Contract.Requires(vertices != null); Contract.Requires(Enumerable.All(vertices, v => { IEnumerable <TEdge> edges; return(tryGetAdjacentEdges(v, out edges)); })); this.vertices = vertices; }
private readonly Func <TEdge, double> _edgeCost = e => 1; // constant cost public IEnumerable <TEdge> Find(TGraph dataGraph) { IEnumerable <DataVertex> vertices = dataGraph.Vertices; DataVertex root = GetVertexBySymbol(vertices, new Start().Symbol); DataVertex target = GetVertexBySymbol(vertices, new Quit().Symbol); // compute shortest paths TryFunc <DataVertex, IEnumerable <TEdge> > tryGetPaths = dataGraph.ShortestPathsDijkstra(_edgeCost, root); tryGetPaths(target, out IEnumerable <TEdge> path); return(path); }
protected override void InternalCompute() { var visibilityGraph = new VisibilityGraph(); foreach (TVertex vertex in VisitedGraph.Vertices) { Point pos = _vertexPositions[vertex]; Size sz = _vertexSizes[vertex]; var rect = new Rect(new Point(pos.X - (sz.Width / 2), pos.Y - (sz.Height / 2)), sz); rect.Inflate(_parameters.VertexMargin, _parameters.VertexMargin); visibilityGraph.Obstacles.Add(new Obstacle(rect.TopLeft, rect.TopRight, rect.BottomRight, rect.BottomLeft)); } foreach (TEdge edge in VisitedGraph.Edges) { visibilityGraph.SinglePoints.Add(_vertexPositions[edge.Source]); visibilityGraph.SinglePoints.Add(_vertexPositions[edge.Target]); } var vertexPoints = new HashSet <PointVertex>(_vertexPositions.Select(kvp => new PointVertex(kvp.Value))); visibilityGraph.Compute(); IUndirectedGraph <PointVertex, Edge <PointVertex> > graph = visibilityGraph.Graph; var usedEdges = new HashSet <Edge <PointVertex> >(); foreach (TEdge edge in VisitedGraph.Edges) { var pos1 = new PointVertex(_vertexPositions[edge.Source]); var pos2 = new PointVertex(_vertexPositions[edge.Target]); TryFunc <PointVertex, IEnumerable <Edge <PointVertex> > > paths = graph.ShortestPathsDijkstra(e => GetWeight(vertexPoints, usedEdges, pos1, pos2, e), pos1); IEnumerable <Edge <PointVertex> > path; if (paths(pos2, out path)) { var edgeRoute = new List <Point>(); bool first = true; PointVertex point = pos1; foreach (Edge <PointVertex> e in path) { if (!first) { edgeRoute.Add(point.Point); } usedEdges.Add(e); point = e.GetOtherVertex(point); first = false; } _edgeRoutes[edge] = edgeRoute.ToArray(); } } }
public virtual IEnumerable <IBranch> GetShortestPath(INode source, INode target, Func <IBranch, double> weights) { if (source == null || target == null) { return(new List <IBranch>()); } TryFunc <INode, IEnumerable <IBranch> > result = this.ShortestPathsDijkstra(b => b.Length, source); IEnumerable <IBranch> path; result(target, out path); return(path ?? new List <IBranch>()); }
/// <summary> /// 使用委托 封装try--catch---finally /// </summary> /// <param name="tryFunc"></param> /// <param name="errorFunc"></param> /// <param name="finallyFunc"></param> public static void TryCatchFuc(TryFunc tryFunc, ErrorFunc errorFunc, FinallyFunc finallyFunc) { try { tryFunc.Invoke(); } catch (Exception ex) { errorFunc?.Invoke(ex); } finally { finallyFunc(); } }
static void Main(String[] args) { try { String path = args[0]; (IVertexAndEdgeListGraph <int, Edge <int> > graph, Func <Edge <int>, double> edgeCost) = new GraphCreator(MatrixReader.ReadMatrix(path)).GetResult(); TryFunc <int, IEnumerable <Edge <int> > > tryGetPath = graph.ShortestPathsDijkstra(edgeCost, 0); DotGenerator <int, Edge <int> > generator = new DotGenerator <int, Edge <int> >(graph, tryGetPath); (new PDFGenerator(generator.GetDotCode(), args[1])).GeneratePDF(); } catch (IndexOutOfRangeException exn) { Console.Error.WriteLine("Path to adjacency matrix should be given."); } catch (Exception exn) { Console.Error.WriteLine(exn.Message); } }
static void Main(string[] args) { try { String path = args[0]; (IVertexAndEdgeListGraph <int, Edge <int> > graph, Func <Edge <int>, double> edgeCost) = GraphCreator.Create(MatrixReader.Read(path)); TryFunc <int, IEnumerable <Edge <int> > > tryGetPath = graph.ShortestPathsDijkstra(edgeCost, 0); PdfGenerator.Generate(DotGenerator <int, Edge <int> > .GetDotCode(graph, tryGetPath), args[1]); } catch (IndexOutOfRangeException) { Console.Error.WriteLine("Path to graph matrix must be given"); } }
/// <summary> /// Creates an instance of DelegateIncidenceGraph. /// </summary> /// <param name="vertices"></param> /// <typeparam name="TVertex">type of the vertices</typeparam> /// <typeparam name="TEdge">type of the edges</typeparam> /// <param name="tryGetAdjacentEdges"></param> /// <returns></returns> public static DelegateUndirectedGraph <TVertex, TEdge> ToDelegateUndirectedGraph <TVertex, TEdge> (this IEnumerable <TVertex> vertices, TryFunc <TVertex, IEnumerable <TEdge> > tryGetAdjacentEdges) where TEdge : IEdge <TVertex>, IEquatable <TEdge> { Contract.Requires(vertices != null); Contract.Requires(tryGetAdjacentEdges != null); Contract.Requires(Enumerable.All(vertices, v => { IEnumerable <TEdge> edges; return(tryGetAdjacentEdges(v, out edges)); })); return(new DelegateUndirectedGraph <TVertex, TEdge>(vertices, tryGetAdjacentEdges, true)); }
private List<int> PathToItem(List<int> finalPath,int from,int to) { this.tryPath = this.graph.ShortestPathsDijkstra(edgeWeights, from); IEnumerable<SEquatableEdge<int>> path; if (this.tryPath(to, out path)) { foreach (var node in path) { finalPath.Add(node.Target); locations[node.Target] = 0; } } return finalPath; }