i20 simple graph implementation

Author: matiii

src/Dijkstra.NET.Tests/ShortestPath/DijkstraExtensionsTests.cs

@@ -1,5 +1,6 @@
 using System.Linq;
 using Dijkstra.NET.Graph;
+using Dijkstra.NET.Graph.Simple;
 using Dijkstra.NET.ShortestPath;
 using Xunit;
 
@@ -31,6 +32,40 @@ public void DijkstraGraphShould_Find_Path_In_Multi_Paths_Graph()
             Assert.True(result.IsFounded);
         }
 
+        [Fact]
+        public void DijkstraSimpleGraphShould_Find_Path_In_Multi_Paths_Graph()
+        {
+            var graph = new Graph.Simple.Graph() + 6;
+
+            var connected = graph >> 1 >> 2 ^ 2;
+            Assert.True(connected);
+            connected = graph >> 1 >> 3 ^ 3;
+            Assert.True(connected);
+
+            connected = graph >> 2 >> 4 ^ 4;
+            Assert.True(connected);
+
+            connected = graph >> 3 >> 4 ^ 2;
+            Assert.True(connected);
+
+            connected = graph >> 3 >> 5 ^ 1;
+            Assert.True(connected);
+
+            connected = graph >> 4 >> 6 ^ 6;
+            Assert.True(connected);
+
+            var result = graph.Dijkstra(1, 6);
+            uint[] path = result.GetPath().ToArray();
+
+            Assert.Equal<uint>(1, path[0]);
+            Assert.Equal<uint>(3, path[1]);
+            Assert.Equal<uint>(4, path[2]);
+            Assert.Equal<uint>(6, path[3]);
+
+            Assert.Equal(11, result.Distance);
+            Assert.True(result.IsFounded);
+        }
+
         [Fact]
         public void DijkstraGraphShould_Find_Path_In_Override_Node()
         {
@@ -109,6 +144,19 @@ public void DijkstraGraphShould_Find_Path_With_One_Vertex_In_Graph()
             Assert.True(result.IsFounded);
         }
 
+        [Fact]
+        public void DijkstraSimpleGraphShould_Find_Path_With_One_Vertex_In_Graph()
+        {
+            var graph = 1.ToGraph();
+
+            var result = graph.Dijkstra(1, 1);
+            uint[] path = result.GetPath().ToArray();
+
+            Assert.Equal<uint>(1, path[0]);
+            Assert.Equal(0, result.Distance);
+            Assert.True(result.IsFounded);
+        }
+
         [Fact]
         public void DijkstraGraphShould_Find_Path_With_One_Vertex_In_Graph_And_Depth_Zero()
         {
@@ -123,6 +171,19 @@ public void DijkstraGraphShould_Find_Path_With_One_Vertex_In_Graph_And_Depth_Zer
             Assert.True(result.IsFounded);
         }
 
+        [Fact]
+        public void DijkstraSimpleGraphShould_Find_Path_With_One_Vertex_In_Graph_And_Depth_Zero()
+        {
+            var graph = 1.ToGraph();
+
+            var result = graph.Dijkstra(1, 1, 0);
+            uint[] path = result.GetPath().ToArray();
+
+            Assert.Equal<uint>(1, path[0]);
+            Assert.Equal(0, result.Distance);
+            Assert.True(result.IsFounded);
+        }
+
         [Fact]
         public void DijkstraGraphShould_Find_Path_With_One_Vertex_And_One_Edge_In_Graph()
         {
@@ -139,6 +200,21 @@ public void DijkstraGraphShould_Find_Path_With_One_Vertex_And_One_Edge_In_Graph(
             Assert.True(result.IsFounded);
         }
 
+        [Fact]
+        public void DijkstraSimpleGraphShould_Find_Path_With_One_Vertex_And_One_Edge_In_Graph()
+        {
+            var graph = 1.ToGraph();
+
+            graph.Connect(1, 1, 5);
+
+            var result = graph.Dijkstra(1, 1);
+            uint[] path = result.GetPath().ToArray();
+
+            Assert.Equal<uint>(1, path[0]);
+            Assert.Equal(0, result.Distance);
+            Assert.True(result.IsFounded);
+        }
+
         [Fact]
         public void DijkstraGraphShould_Find_Path_In_Multi_Edges_Graph()
         {
@@ -173,7 +249,7 @@ public void DijkstraGraphShould_Find_Path_In_Multi_Edges_Graph()
         }
 
         [Fact]
-        public void DijkstraGraphShould_Find_Path_In_Multi_Edges_SimpleGraph()
+        public void DijkstraSimpleGraphShould_Find_Path_In_Multi_Edges()
         {
             var graph = new Graph.Simple.Graph();
 
@@ -229,7 +305,7 @@ public void DijkstraGraphNot_Should_Find_Path_In_Graph()
         }
 
         [Fact]
-        public void DijkstraGraphNot_Should_Find_Path_In_SimpleGraph()
+        public void DijkstraSimpleGraphNot_Should_Find_Path_In_Graph()
         {
             var graph = new Graph.Simple.Graph();
 

src/Dijkstra.NET/Graph/EdgeTemp.cs

@@ -47,12 +47,12 @@ public static EdgeTemp<T, TCustom> operator>>(EdgeTemp<T, TCustom> edge, int cos
             return edge.Graph.Connect(edge.NodeFrom, edge.NodeTo, edge.Cost, edgeCustom);
         }
 
-        public uint NodeFrom { get; }
+        internal uint NodeFrom { get; }
 
-        public uint NodeTo { get; }
+        internal uint NodeTo { get; }
 
-        public Graph<T, TCustom> Graph { get; }
+        internal Graph<T, TCustom> Graph { get; }
 
-        public int Cost { get; }
+        internal int Cost { get; }
     }
 }

src/Dijkstra.NET/Graph/Exceptions/EdgeNotFoundException.cs

@@ -5,7 +5,7 @@ namespace Dijkstra.NET.Graph.Exceptions
     public class EdgeNotFoundException: Exception
     {
         internal EdgeNotFoundException(uint node)
-            :base($"Edge with {node} nod key doesn't exist.")
+            :base($"Edge with {node} node key doesn't exist.")
         {
         }
     }

src/Dijkstra.NET/Graph/Simple/EdgeTemp.cs

@@ -1,7 +1,52 @@
+using System;
+
 namespace Dijkstra.NET.Graph.Simple
 {
     public readonly struct EdgeTemp
     {
+        internal EdgeTemp(Graph graph, uint nodeFrom)
+            : this(graph, nodeFrom, default)
+        {
+        }
+
+        internal EdgeTemp(Graph graph, uint nodeFrom, uint nodeTo)
+        {
+            Graph = graph;
+            NodeFrom = nodeFrom;
+            NodeTo = nodeTo;
+        }
+
+        internal Graph Graph { get; }
+
+        internal uint NodeFrom { get; }
+
+        internal uint NodeTo { get; }
+
+        /// <summary>
+        /// Connect two nodes in graph
+        /// </summary>
+        /// <param name="edge">Node from</param>
+        /// <param name="node">Node to</param>
+        /// <returns>Temporary edge</returns>
+        public static EdgeTemp operator >>(EdgeTemp edge, int node)
+        {
+            return new EdgeTemp(edge.Graph, edge.NodeFrom, (uint)node);
+        }
+
+        /// <summary>
+        /// Create edge between two nodes
+        /// </summary>
+        /// <param name="edge">Temporary edge</param>
+        /// <param name="cost">Connection cost</param>
+        /// <returns>True if connected</returns>
+        public static bool operator^(EdgeTemp edge, int cost)
+        {
+            if (edge.NodeTo == default)
+            {
+                throw new InvalidOperationException("Destination node is not defined. Use >> operator to define it.");
+            }
 
+            return edge.Graph.Connect(edge.NodeFrom, edge.NodeTo, cost);
+        }
     }
 }

src/Dijkstra.NET/Graph/Simple/Graph.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 using Dijkstra.NET.Extensions;
 using Dijkstra.NET.PageRank;
 using Dijkstra.NET.ShortestPath;
@@ -23,7 +24,22 @@ public class Graph: IDijkstraGraph, IPageRankGraph
         /// <returns>Temporary edge</returns>
         public static EdgeTemp operator >>(Graph graph, int node)
         {
-            return new EdgeTemp();
+            return new EdgeTemp(graph, (uint)node);
+        }
+
+        /// <summary>
+        /// Add nodes to graph
+        /// </summary>
+        /// <param name="graph">Graph</param>
+        /// <param name="numberOfNodes">Number of nodes</param>
+        /// <returns></returns>
+        public static Graph operator +(Graph graph, int numberOfNodes)
+        {
+            Enumerable
+                .Range(0, numberOfNodes)
+                .Each(_ => graph.AddNode());
+
+            return graph;
         }
 
         /// <summary>