update comments

justcoding121 · justcoding121 · commit f009d932415c · 2018-08-05T21:00:35.000-04:00
diff --git a/Advanced.Algorithms/Binary/BaseConversion.cs b/Advanced.Algorithms/Binary/BaseConversion.cs
@@ -3,6 +3,9 @@
 
 namespace Advanced.Algorithms.Binary
 { 
+    /// <summary>
+    /// Base conversion implementation.
+    /// </summary>
     public class BaseConversion
     {
         /// <summary>
diff --git a/Advanced.Algorithms/Binary/Logarithm.cs b/Advanced.Algorithms/Binary/Logarithm.cs
@@ -1,5 +1,8 @@
 ﻿namespace Advanced.Algorithms.Binary
 {
+    /// <summary>
+    /// Logarithm calculator.
+    /// </summary>
     public class Logarithm
     {
         public static int CalcBase2LogFloor(int x)
diff --git a/Advanced.Algorithms/Combinatorics/Combination.cs b/Advanced.Algorithms/Combinatorics/Combination.cs
@@ -2,6 +2,9 @@
 
 namespace Advanced.Algorithms.Combinatorics
 {
+    /// <summary>
+    /// Combinations computer.
+    /// </summary>
     public class Combination
     {
         public static List<List<T>> Find<T>(List<T> input, int r, bool withRepetition)
diff --git a/Advanced.Algorithms/Combinatorics/Permutation.cs b/Advanced.Algorithms/Combinatorics/Permutation.cs
@@ -2,6 +2,9 @@
 
 namespace Advanced.Algorithms.Combinatorics
 {
+    /// <summary>
+    /// Permutation computer.
+    /// </summary>
     public class Permutation
     {
         public static List<List<T>> Find<T>(List<T> input, int r, bool withRepetition = false)
diff --git a/Advanced.Algorithms/Combinatorics/Subset.cs b/Advanced.Algorithms/Combinatorics/Subset.cs
@@ -2,6 +2,9 @@
 
 namespace Advanced.Algorithms.Combinatorics
 {
+    /// <summary>
+    /// Subset computer.
+    /// </summary>
     public class Subset
     {
         public static List<List<T>> Find<T>(List<T> input)
diff --git a/Advanced.Algorithms/Distributed/LRUCache.cs b/Advanced.Algorithms/Distributed/LRUCache.cs
@@ -5,6 +5,9 @@
 
 namespace Advanced.Algorithms.Distributed
 {
+    /// <summary>
+    /// A least recently used cache implemetation.
+    /// </summary>
     public class LRUCache<K, V>
     {
         private readonly int capacity;
diff --git a/Advanced.Algorithms/Geometry/ClosestPointPair.cs b/Advanced.Algorithms/Geometry/ClosestPointPair.cs
@@ -4,6 +4,9 @@
 
 namespace Advanced.Algorithms.Geometry
 {
+    /// <summary>
+    /// Closest-point pair finder.
+    /// </summary>
     public class ClosestPointPair
     {
         public static double Find(List<int[]> points)
diff --git a/Advanced.Algorithms/Geometry/LineIntersection.cs b/Advanced.Algorithms/Geometry/LineIntersection.cs
@@ -1,8 +1,10 @@
 ﻿using System;
-using System.Linq;
 
 namespace Advanced.Algorithms.Geometry
 {
+    /// <summary>
+    /// Line intersection computer.
+    /// </summary>
     public class LineIntersection
     {
         /// <summary>
@@ -197,6 +199,9 @@ private static bool IsInsideLine(Line line, Point p, double tolerance)
 
     }
 
+    /// <summary>
+    /// Line extensions.
+    /// </summary>
     public static class LineExtensions
     {
         public static bool Intersects(this Line lineA, Line lineB, int precision = 5)
diff --git a/Advanced.Algorithms/Geometry/PointInsidePolygon.cs b/Advanced.Algorithms/Geometry/PointInsidePolygon.cs
@@ -1,11 +1,10 @@
 ﻿namespace Advanced.Algorithms.Geometry
 {
-
+    /// <summary>
+    ///  Implementesa  method tp Check whether a given point is inside given polygon.
+    /// </summary>
     public class PointInsidePolygon
     {
-        /// <summary>
-        ///     Checks whether the given point is inside given polygon.
-        /// </summary>
         public static bool IsInside(Polygon polygon, Point point)
         {
             //a imaginary ray line from point to right infinity
diff --git a/Advanced.Algorithms/Geometry/PointRotation.cs b/Advanced.Algorithms/Geometry/PointRotation.cs
@@ -2,6 +2,9 @@
 
 namespace Advanced.Algorithms.Geometry
 {
+    /// <summary>
+    /// Rotates given point by given angle about given center.
+    /// </summary>
     public class PointRotation
     {
         public static Point Rotate(Point center, Point point, int angle)
diff --git a/Advanced.Algorithms/Geometry/RectangleIntersection.cs b/Advanced.Algorithms/Geometry/RectangleIntersection.cs
@@ -2,6 +2,9 @@
 
 namespace Advanced.Algorithms.Geometry
 {
+    /// <summary>
+    /// Rectangle intersection finder.
+    /// </summary>
     public class RectangleIntersection
     {
         /// <summary>
diff --git a/Advanced.Algorithms/Geometry/Shapes/Line.cs b/Advanced.Algorithms/Geometry/Shapes/Line.cs
@@ -2,6 +2,9 @@
 
 namespace Advanced.Algorithms.Geometry
 {
+    /// <summary>
+    /// Line object.
+    /// </summary>
     public class Line
     {
         public Point Left { get; private set; }
diff --git a/Advanced.Algorithms/Geometry/Shapes/Point.cs b/Advanced.Algorithms/Geometry/Shapes/Point.cs
@@ -1,5 +1,8 @@
 ﻿namespace Advanced.Algorithms.Geometry
 {
+    /// <summary>
+    /// Point object.
+    /// </summary>
     public class Point
     {
         public Point(double x, double y)
diff --git a/Advanced.Algorithms/Geometry/Shapes/Polygon.cs b/Advanced.Algorithms/Geometry/Shapes/Polygon.cs
@@ -3,8 +3,7 @@
 namespace Advanced.Algorithms.Geometry
 {
     /// <summary>
-    ///     A polygon when more than one edge points are provided.
-    ///     Or a point when only one edge point is provided.
+    /// Polygon object.
     /// </summary>
     public class Polygon
     {
diff --git a/Advanced.Algorithms/Geometry/Shapes/Rectangle.cs b/Advanced.Algorithms/Geometry/Shapes/Rectangle.cs
@@ -3,6 +3,9 @@
 
 namespace Advanced.Algorithms.Geometry
 {
+    /// <summary>
+    /// Rectangle object.
+    /// </summary>
     public class Rectangle
     {
         public Point LeftTop { get; set; }
diff --git a/Advanced.Algorithms/Geometry/Shared/PointComparer.cs b/Advanced.Algorithms/Geometry/Shared/PointComparer.cs
@@ -2,6 +2,9 @@
 
 namespace Advanced.Algorithms.Geometry
 {
+    /// <summary>
+    /// Compares two points for geometric equality implementing IEqualityComparer.
+    /// </summary>
     public class PointComparer : IEqualityComparer<Point>
     {
         public bool Equals(Point x, Point y)
@@ -25,7 +28,6 @@ public bool Equals(Point x, Point y)
             return x.X == y.X && x.Y == y.Y;
         }
 
-
         public int GetHashCode(Point point)
         {
             var hashCode = 33;
diff --git a/Advanced.Algorithms/Geometry/Shared/RectangleComparer.cs b/Advanced.Algorithms/Geometry/Shared/RectangleComparer.cs
@@ -2,6 +2,9 @@
 
 namespace Advanced.Algorithms.Geometry
 {
+    /// <summary>
+    /// Compares two rectangles for geometrical equality implementing IEqualityComparer.
+    /// </summary>
     public class RectangleComparer : IEqualityComparer<Rectangle>
     {
         public bool Equals(Rectangle x, Rectangle y)
diff --git a/Advanced.Algorithms/Graph/Coloring/MColorer.cs b/Advanced.Algorithms/Graph/Coloring/MColorer.cs
@@ -94,6 +94,9 @@ private bool isSafe(Dictionary<GraphVertex<T>, C> progress,
         }
     }
 
+    /// <summary>
+    /// M-coloring result object.
+    /// </summary>
     public class MColorResult<T, C>
     {
         public bool CanColor { get; }
diff --git a/Advanced.Algorithms/Graph/Cut/MinimumCut.cs b/Advanced.Algorithms/Graph/Cut/MinimumCut.cs
@@ -6,7 +6,7 @@ namespace Advanced.Algorithms.Graph
 {
 
     /// <summary>
-    /// Commpute minimum cut edges of given graph 
+    /// Compute minimum cut edges of given graph 
     /// using Edmond Karps improved Ford-Fulkerson Max Flow Algorithm.
     /// </summary>
     public class MinCut<T, W> where W : IComparable
diff --git a/Advanced.Algorithms/Graph/Flow/FordFulkerson.cs b/Advanced.Algorithms/Graph/Flow/FordFulkerson.cs
@@ -210,7 +210,7 @@ private WeightedDiGraph<T, W> createResidualGraph(WeightedDiGraph<T, W> graph)
     }
 
     /// <summary>
-    /// Operators to deal with generic Add, Substract etc on edge weights.
+    /// Operators to deal with generic Add, Substract etc on edge weights for flow algorithms such as ford-fulkerson algorithm.
     /// </summary>
     public interface IFlowOperators<W> where W : IComparable
     {
diff --git a/Advanced.Algorithms/Graph/Matching/BiPartiteMatching.cs b/Advanced.Algorithms/Graph/Matching/BiPartiteMatching.cs
@@ -121,6 +121,9 @@ public MatchEdge(T source, T target)
         }
     }
 
+    /// <summary>
+    /// Generic operator interface required by BiPartite matching algorithm.
+    /// </summary>
     public interface IBiPartiteMatchOperators<T> : IFlowOperators<int>
     {
         /// <summary>
diff --git a/Advanced.Algorithms/Graph/MinimumSpanningTree/Kruskals.cs b/Advanced.Algorithms/Graph/MinimumSpanningTree/Kruskals.cs
@@ -115,7 +115,7 @@ private void dfs(WeightedGraphVertex<T, TW> currentVertex, System.Collections.Ge
     }
 
     /// <summary>
-    /// MST edge object.
+    /// Minimum spanning tree edge object.
     /// </summary>
     public class MSTEdge<T, W> : IComparable where W : IComparable
     {
diff --git a/Advanced.Algorithms/Graph/ShortestPath/Dijikstra.cs b/Advanced.Algorithms/Graph/ShortestPath/Dijikstra.cs
@@ -148,7 +148,7 @@ private ShortestPathResult<T, W> tracePath(WeightedDiGraph<T, W> graph, Dictiona
     }
 
     /// <summary>
-    /// Generic operators.
+    /// Generic operators interface required by shorted path algorithms.
     /// </summary>
     public interface IShortestPathOperators<W> where W : IComparable
     {
@@ -157,6 +157,9 @@ public interface IShortestPathOperators<W> where W : IComparable
         W Sum(W a, W b);
     }
 
+    /// <summary>
+    /// Shortest path result object.
+    /// </summary>
     public class ShortestPathResult<T, W> where W : IComparable
     {
         public ShortestPathResult(List<T> path, W length)
diff --git a/Advanced.Algorithms/Graph/ShortestPath/Floyd-Warshall.cs b/Advanced.Algorithms/Graph/ShortestPath/Floyd-Warshall.cs
@@ -131,6 +131,9 @@ private List<T> tracePath(W[,] result, T[,] parent, int i, int j,
 
     }
 
+    /// <summary>
+    /// All pairs shortest path algorithm result object.
+    /// </summary>
     public class AllPairShortestPathResult<T, W> where W : IComparable
     {
         public T Source { get; }
diff --git a/Advanced.Algorithms/Graph/ShortestPath/Johnsons.cs b/Advanced.Algorithms/Graph/ShortestPath/Johnsons.cs
@@ -88,6 +88,9 @@ public List<AllPairShortestPathResult<T, W>>
 
     }
 
+    /// <summary>
+    /// A concrete implementation of this interface is required by Johnson's algorithm.
+    /// </summary>
     public interface IJohnsonsShortestPathOperators<T, W>
     : IShortestPathOperators<W> where W : IComparable
     {
diff --git a/README.md b/README.md
@@ -101,9 +101,9 @@ Note: It is observed that among the implementations here in practice, with the e
 
 - [X] Segment tree ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/DataStructures/Tree/SegmentTree.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/DataStructures/Tree/SegmentTree_Tests.cs))
 - [X] Binary indexed tree (Fenwick tree) ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/DataStructures/Tree/FenwickTree.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/DataStructures/Tree/FenwickTree_Tests.cs))
-- [X] Multi-dimensional interval tree ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/DataStructures/Tree/IntervalTree.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/DataStructures/Tree/IntervalTree_Tests.cs)) using nested Red-black tree
+- [X] Multi-dimensional interval tree ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/DataStructures/Tree/IntervalTree.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/DataStructures/Tree/IntervalTree_Tests.cs)) using nested red-black tree
 - [X] Multi-dimensional k-d tree ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/DataStructures/Tree/K_DTree.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/DataStructures/Tree/KdTree_Tests.cs)) for range and nearest neigbour queries
-- [X] Multi-dimensional range tree ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/DataStructures/Tree/RangeTree.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/DataStructures/Tree/RangeTreetests.cs)) using nested Red-black tree
+- [X] Multi-dimensional range tree ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/DataStructures/Tree/RangeTree.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/DataStructures/Tree/RangeTreetests.cs)) using nested red-black tree
 - [X] R-tree ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/DataStructures/Tree/RTree.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/DataStructures/Tree/RTree_Tests.cs))
 - [X] Quadtree ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/DataStructures/Tree/QuadTree.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/DataStructures/Tree/QuadTree_Tests.cs))
 
@@ -175,19 +175,19 @@ TODO: implement trie compression.
 ### Shortest path
 
 - [X] Bellman-Ford algorithm ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/Graph/ShortestPath/Bellman-Ford.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/Graph/ShortestPath/BellmanFord_Tests.cs))
-- [X] Dijikstra's algorithm ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/Graph/ShortestPath/Dijikstra.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/Graph/ShortestPath/Dijikstras_Tests.cs)) using Fibornacci Heap.
+- [X] Dijikstra's algorithm ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/Graph/ShortestPath/Dijikstra.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/Graph/ShortestPath/Dijikstras_Tests.cs)) using Fibornacci heap.
 - [X] Floyd-Warshall algorithm ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/Graph/ShortestPath/Floyd-Warshall.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/Graph/ShortestPath/FloydWarshall_Tests.cs))
 - [X] Johnson's algorithm ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/Graph/ShortestPath/Johnsons.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/Graph/ShortestPath/Johnson_Tests.cs))
 - [X] Travelling salesman problem ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/Graph/ShortestPath/TravellingSalesman.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/Graph/ShortestPath/TravellingSalesman_Tests.cs))
 
 ### Matching
 
-- [X] Max bipartite matching ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/Graph/Matching/BiPartiteMatching.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/Graph/Matching/BiPartiteMatching_Tests.cs)) using Edmonds Karp's improved Ford Fulkerson Max Flow algorithm 
+- [X] Max bipartite matching ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/Graph/Matching/BiPartiteMatching.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/Graph/Matching/BiPartiteMatching_Tests.cs)) using Edmonds Karp's improved Ford Fulkerson max flow algorithm 
 - [X] Max bipartite matching ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/Graph/Matching/HopcroftKarp.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/Graph/Matching/HopcroftKarp_Tests.cs)) using Hopcroft Karp algorithm
 
 ### Cut
 
-- [X] Minimum cut ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/Graph/Cut/MinimumCut.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/Graph/Cut/MinCut_Tests.cs)) using Edmonds Karp's improved Ford Fulkerson Max Flow algorithm
+- [X] Minimum cut ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/Graph/Cut/MinimumCut.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/Graph/Cut/MinCut_Tests.cs)) using Edmonds Karp's improved Ford Fulkerson max flow algorithm
 
 ### Search
 
@@ -202,12 +202,12 @@ TODO: implement trie compression.
 
 ### Minimum spanning tree
 
-- [X] Kruskal's algorithm ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/Graph/MinimumSpanningTree/Kruskals.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/Graph/MinimumSpanningTree/Kruskals_Test.cs)) using Merge Sort and Disjoint Set
+- [X] Kruskal's algorithm ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/Graph/MinimumSpanningTree/Kruskals.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/Graph/MinimumSpanningTree/Kruskals_Test.cs)) using merge sort and disjoint set
 - [X] Prim's algorithm ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/Graph/MinimumSpanningTree/Prims.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/Graph/MinimumSpanningTree/Prims_Test.cs))
 
 ## String
 
-- [X] Manacher's algorithm for linear time longest Palindrome ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/String/ManachersPalindrome.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/String/Manachers_Tests.cs))
+- [X] Manacher's algorithm for linear time longest palindrome ([implementation](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms/String/ManachersPalindrome.cs) | [tests](https://github.com/justcoding121/Advanced-Algorithms/blob/master/Advanced.Algorithms.Tests/String/Manachers_Tests.cs))
 
 ### Pattern matching
 

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,9 @@`
`3`	`3`
`4`	`4`	`namespace Advanced.Algorithms.Binary`
`5`	`5`	`{`
	`6`	`+ /// <summary>`
	`7`	`+ /// Base conversion implementation.`
	`8`	`+ /// </summary>`
`6`	`9`	`public class BaseConversion`
`7`	`10`	`{`
`8`	`11`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,8 @@`
`1`	`1`	`namespace Advanced.Algorithms.Binary`
`2`	`2`	`{`
	`3`	`+ /// <summary>`
	`4`	`+ /// Logarithm calculator.`
	`5`	`+ /// </summary>`
`3`	`6`	`public class Logarithm`
`4`	`7`	`{`
`5`	`8`	`public static int CalcBase2LogFloor(int x)`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,9 @@`
`2`	`2`
`3`	`3`	`namespace Advanced.Algorithms.Combinatorics`
`4`	`4`	`{`
	`5`	`+ /// <summary>`
	`6`	`+ /// Combinations computer.`
	`7`	`+ /// </summary>`
`5`	`8`	`public class Combination`
`6`	`9`	`{`
`7`	`10`	`public static List<List<T>> Find<T>(List<T> input, int r, bool withRepetition)`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,9 @@`
`5`	`5`
`6`	`6`	`namespace Advanced.Algorithms.Distributed`
`7`	`7`	`{`
	`8`	`+ /// <summary>`
	`9`	`+ /// A least recently used cache implemetation.`
	`10`	`+ /// </summary>`
`8`	`11`	`public class LRUCache<K, V>`
`9`	`12`	`{`
`10`	`13`	`private readonly int capacity;`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,9 @@`
`4`	`4`
`5`	`5`	`namespace Advanced.Algorithms.Geometry`
`6`	`6`	`{`
	`7`	`+ /// <summary>`
	`8`	`+ /// Closest-point pair finder.`
	`9`	`+ /// </summary>`
`7`	`10`	`public class ClosestPointPair`
`8`	`11`	`{`
`9`	`12`	`public static double Find(List<int[]> points)`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,10 @@`
`1`	`1`	`using System;`
`2`		`-using System.Linq;`
`3`	`2`
`4`	`3`	`namespace Advanced.Algorithms.Geometry`
`5`	`4`	`{`
	`5`	`+ /// <summary>`
	`6`	`+ /// Line intersection computer.`
	`7`	`+ /// </summary>`
`6`	`8`	`public class LineIntersection`
`7`	`9`	`{`
`8`	`10`	`/// <summary>`
`@@ -197,6 +199,9 @@ private static bool IsInsideLine(Line line, Point p, double tolerance)`
`197`	`199`
`198`	`200`	`}`
`199`	`201`
	`202`	`+ /// <summary>`
	`203`	`+ /// Line extensions.`
	`204`	`+ /// </summary>`
`200`	`205`	`public static class LineExtensions`
`201`	`206`	`{`
`202`	`207`	`public static bool Intersects(this Line lineA, Line lineB, int precision = 5)`
Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,10 @@`
`1`	`1`	`namespace Advanced.Algorithms.Geometry`
`2`	`2`	`{`
`3`		`-`
	`3`	`+ /// <summary>`
	`4`	`+ /// Implementesa method tp Check whether a given point is inside given polygon.`
	`5`	`+ /// </summary>`
`4`	`6`	`public class PointInsidePolygon`
`5`	`7`	`{`
`6`		`- /// <summary>`
`7`		`- /// Checks whether the given point is inside given polygon.`
`8`		`- /// </summary>`
`9`	`8`	`public static bool IsInside(Polygon polygon, Point point)`
`10`	`9`	`{`
`11`	`10`	`//a imaginary ray line from point to right infinity`